common/pcc/chemicraft/ChemiCraftAPI.java

   1 package pcc.chemicraft;
   2
   3 import java.util.ArrayList;
   4 import java.util.HashMap;
   5
   6 import net.minecraft.item.Item;
   7 import net.minecraft.item.ItemStack;
   8 import pcc.chemicraft.gen.EnumOreSpawnFrequency;
   9 import pcc.chemicraft.gen.WorldGenAtomsOre;
  10 import pcc.chemicraft.system.ChemiCraftCraftingManager;
  11 import pcc.chemicraft.tileentity.TileEntityElectrolysisTable;
  12 import pcc.chemicraft.tileentity.TileEntityPyrolysisTable;
  13 import pcc.chemicraft.util.ChemicalNBTRecipe;
  14 import pcc.chemicraft.util.ICompoundHandler;
  15 import pcc.chemicraft.util.ListHash;
  16 import pcc.chemicraft.util.MaterialRecipe;
  17
  18
  19 /**
  20  * ChemiCraftのAPI
  21  * 基本的にAddonはこのクラスのインスタンスを使う
  22  * @author mozipi
  23  *
  24  */
  25 public class ChemiCraftAPI {
  26
  27         /**
  28          * Instance of the ChemiCraftAPI.
  29          */
  30         private static ChemiCraftAPI instance = new ChemiCraftAPI();
  31
  32
  33         public static ChemiCraftAPI instance(){
  34                 return instance;
  35         }
  36
  37
  38         /**
  39          * 鉱石別元素数リスト
  40          */
  41         private ArrayList<Integer[]> atomOresAmountsList = new ArrayList<Integer[]>();
  42
  43
  44         /**
  45          * 鉱石別元素リスト
  46          */
  47         private ArrayList<Integer[]> atomOresAtomsList = new ArrayList<Integer[]>();
  48
  49
  50         /**
  51          * 鉱石の言語リスト
  52          */
  53         private ListHash<String, String> atomOresLangListHash = new ListHash<String, String>();
  54
  55
  56         /**
  57          * 鉱石リスト
  58          */
  59         private ArrayList<WorldGenAtomsOre> atomOresList = new ArrayList<WorldGenAtomsOre>();
  60
  61
  62         /**
  63          * 鉱石名リスト
  64          */
  65         private ListHash<String, String> atomOresNameListHash = new ListHash<String, String>();
  66
  67
  68
  69         /**
  70          * 電池言語リスト
  71          */
  72         private ListHash<String, String> chemicalCellsLangListHash = new ListHash<String, String>();
  73
  74
  75         /**
  76          * 電池
  77          */
  78         private HashMap<ItemStack, Integer> chemicalCellsList = new HashMap<ItemStack, Integer>();
  79
  80
  81         /**
  82          * 電池名リスト
  83          */
  84         private ListHash<String, String> chemicalCellsNameListHash = new ListHash<String, String>();
  85
  86
  87
  88         /**
  89          * 化合台の原子の数のリスト
  90          */
  91         private ArrayList<Integer[]> chemicalCombinationAmounts = new ArrayList<Integer[]>();
  92
  93
  94         /**
  95          * 化合台の原子の種類のリスト
  96          */
  97         private ArrayList<String[]> chemicalCombinationAtoms = new ArrayList<String[]>();
  98
  99
 100         /**
 101          * 化合台の結果のリスト
 102          */
 103         private ArrayList<ItemStack> chemicalCombinationResult = new ArrayList<ItemStack>();
 104
 105
 106         /**
 107          * ChemiCraftの化学作業台類のレシピのマネージャー
 108          */
 109         private ChemiCraftCraftingManager chemiCraftCraftingManager = new ChemiCraftCraftingManager();
 110
 111
 112         /**
 113          * List of item name of handler to compounds.
 114          */
 115         private ArrayList<String> compoundHandlerItemNames = new ArrayList<String>();
 116
 117
 118         /**
 119          * List of compounds handlers.
 120          */
 121         private ArrayList<ICompoundHandler> compoundHandlers = new ArrayList<ICompoundHandler>();
 122
 123
 124         /**
 125          * 化合物の文字列をダメージ値に変換します。
 126          */
 127         private HashMap<String, Integer> compoundHash = new HashMap<String, Integer>();
 128
 129
 130         /**
 131          * List of compounds the language names.
 132          */
 133         private ListHash<String, String> compoundsLangListHash = new ListHash<String, String>();
 134
 135
 136         /**
 137          * List of compounds names.
 138          */
 139         private ListHash<String, String> compoundsNameListHash = new ListHash<String, String>();
 140
 141
 142
 143         /**
 144          * 素材製作台のレシピクラス
 145          */
 146         private ArrayList<MaterialRecipe> materialRecipe = new ArrayList<MaterialRecipe>();
 147
 148
 149         /**
 150          * ツール&武器作成台の素材一覧のリスト
 151          */
 152         private ArrayList<ItemStack[]> toolAndWeaponMaterials = new ArrayList<ItemStack[]>();
 153
 154
 155         /**
 156          * ツール&武器作成台の結果のリスト
 157          */
 158         private ArrayList<ItemStack> toolAndWeaponResult = new ArrayList<ItemStack>();
 159
 160
 161
 162         /**
 163          * ツール&武器作成台の不定形であるか
 164          */
 165         private ArrayList<Boolean> toolAndWeaponSharpless = new ArrayList<Boolean>();
 166
 167
 168
 169         /**
 170          * 鉱石を追加します
 171          * @param par1Name 鉱石名
 172          * @param par2Atoms 元素
 173          * @param par3Amounts 元素数
 174          * @param par4Id ID
 175          * @param par5Size 量
 176          * @param par6Frequency 頻度
 177          * @param par7PosY Y座標
 178          */
 179         public void addAtomOres(String par1Name, Integer[] par2Atoms, Integer[] par3Amounts, int par4Id, int par5Size, int par6Frequency, int par7PosY){
 180                 atomOresList.add(new WorldGenAtomsOre(par4Id, getAtomOresMetaOfLastIndex(), par5Size, par6Frequency, par7PosY));
 181                 atomOresAtomsList.add(par2Atoms);
 182                 atomOresAmountsList.add(par3Amounts);
 183                 addAtomOresLanguage(par1Name, par1Name, "en_US");
 184         }
 185
 186
 187
 188         public void addAtomOres(String par1Name, Integer[] par2Atoms, Integer[] par3Amounts, int par4Id, int par5Size, EnumOreSpawnFrequency par6Frequency, int par7PosY){
 189                 addAtomOres(par1Name, par2Atoms, par3Amounts, par4Id, par5Size, par6Frequency.getFrequency(), par7PosY);
 190         }
 191
 192
 193
 194         public void addAtomOres(String par1Name, String[] par2Atoms, Integer[] par3Amounts, int par4Id, int par5Size, EnumOreSpawnFrequency par6Frequency, int par7PosY){
 195                 addAtomOres(par1Name, ChemiCraftData.toAtoms(par2Atoms), par3Amounts, par4Id, par5Size, par6Frequency.getFrequency(), par7PosY);
 196         }
 197
 198
 199
 200         public void addAtomOres(String par1Name, String[] par2Atoms, Integer[] par3Amounts, int par4Id, int par5Size, int par6Frequency, int par7PosY){
 201                 addAtomOres(par1Name, ChemiCraftData.toAtoms(par2Atoms), par3Amounts, par4Id, par5Size, par6Frequency, par7PosY);
 202         }
 203
 204
 205
 206         /**
 207          * 既に登録した鉱石の新しい名前・言語を追加します
 208          * @param par1Name 英語名
 209          * @param par2NewName 新しい名前
 210          * @param par3Language 言語
 211          */
 212         public void addAtomOresLanguage(String par1Name, String par2NewName, String par3Language){
 213                 atomOresNameListHash.add(par1Name, par2NewName);
 214                 atomOresLangListHash.add(par1Name, par3Language);
 215         }
 216
 217
 218
 219         /**
 220          * 電池を追加します
 221          * @param par1Name
 222          */
 223         public void addChemicalCell(Item par1ChemicalCell, String par2Name, int par3OperationTime){
 224                 chemicalCellsList.put(new ItemStack(par1ChemicalCell, 0, chemicalCellsNameListHash.sizeKeysList()), par3OperationTime);
 225                 addChemicalCellLanguage(par2Name, "en_US", par2Name);
 226         }
 227
 228
 229
 230         /**
 231          * 既に登録した電池の新しい名前・言語を追加します
 232          * @param par1Name 英語名
 233          * @param par2NewName 新しい名前
 234          * @param par3Language 言語
 235          */
 236         public void addChemicalCellLanguage(String par1Name, String par3NewLanguage, String par2NewName){
 237                 chemicalCellsNameListHash.add(par1Name, par2NewName);
 238                 chemicalCellsLangListHash.add(par1Name, par3NewLanguage);
 239         }
 240
 241
 242
 243         /**
 244          * 化合レシピを追加します。materialの要素数は0<= n <= 16にしてください。
 245          * @param material 素材
 246          * @param result 結果
 247          */
 248         public void addChemicalCombinationRecipe(String[] atoms, Integer[] amounts, ItemStack result){
 249                 chemicalCombinationAtoms.add(atoms);
 250                 chemicalCombinationAmounts.add(amounts);
 251                 chemicalCombinationResult.add(result);
 252         }
 253
 254
 255
 256         /**
 257          * add compound.
 258          * @param name compound name.
 259          */
 260         public void addCompound(String name){
 261                 compoundsNameListHash.add(name, name);
 262                 compoundsLangListHash.add(name, "en_US");
 263                 compoundHash.put(name, compoundHash.size());
 264         }
 265
 266
 267
 268         /**
 269          * add compound corresponding to the language.
 270          * @param lang Language to the corresponding
 271          * @param englishName compound name
 272          * @param langName compound name(specified language)
 273          */
 274         public void addCompound(String lang, String englishName, String langName){
 275                 addCompound(englishName);
 276                 addCompoundLanguage(lang, englishName, langName);
 277         }
 278
 279
 280
 281         public void addCompoundLanguage(String lang, String englishName, String langName){
 282                 compoundsNameListHash.add(englishName, langName);
 283                 compoundsLangListHash.add(englishName, lang);
 284         }
 285
 286
 287
 288         public void addElectrolysisDecompositionRecipe(ItemStack material, Integer[] integers, Integer[] integers2) {
 289                 ItemStack[] itemstacks = new ItemStack[integers.length];
 290                 for (int i = 0; i < itemstacks.length; i++) {
 291                         itemstacks[i] = new ItemStack(ChemiCraft.instance.itemAtoms,integers2[i], integers[i]);
 292                 }
 293                 TileEntityElectrolysisTable.addRecipe(material, itemstacks);
 294         }
 295
 296
 297         /**
 298          * 素材作成台のレシピを追加します
 299          * @param materials 素材
 300          * @param result 結果
 301          * @param nbtRecipe NBT(Nullの場合はなし)
 302          */
 303         public void addMaterialRecipe(ItemStack[] materials, ItemStack result, ChemicalNBTRecipe nbtRecipe){
 304                 materialRecipe.add(new MaterialRecipe(result, materials, nbtRecipe, false));
 305         }
 306
 307
 308
 309         /**
 310          * 分解台の燃料を追加します
 311          * @param itemstack 燃料のItemStack
 312          * @param burnTime 燃焼時間(tick * rate)
 313          */
 314         public void addPyrolysisDecompositionFuel(ItemStack itemstack, int burnTime) {
 315                 TileEntityPyrolysisTable.addFuel(itemstack, burnTime);
 316         }
 317
 318
 319
 320         /**
 321          * 分解台のレシピを追加します
 322          * @param material 素材
 323          * @param integers 原子の元素番号の配列
 324          * @param integers2 原子のできる数の配列
 325          */
 326         public void addPyrolysisDecompositionRecipe(ItemStack material, Integer[] integers, Integer[] integers2) {
 327                 ItemStack[] itemstacks = new ItemStack[integers.length];
 328                 for (int i = 0; i < itemstacks.length; i++) {
 329                         itemstacks[i] = new ItemStack(ChemiCraft.instance.itemAtoms,integers2[i], integers[i]);
 330                 }
 331                 TileEntityPyrolysisTable.addRecipe(material, itemstacks);
 332         }
 333
 334
 335
 336         /**
 337          * 素材作成台の不定形レシピを追加します
 338          * @param materials 素材
 339          * @param result 結果
 340          * @param nbtRecipe NBT(Nullの場合はなし)
 341          */
 342         public void addSharplessMaterialRecipe(ItemStack[] materials, ItemStack result, ChemicalNBTRecipe nbtRecipe){
 343                 materialRecipe.add(new MaterialRecipe(result, materials, nbtRecipe, true));
 344         }
 345
 346
 347
 348         /**
 349          * ツール&武器作成台の不定形レシピを追加します
 350          * @param materials 素材
 351          * @param result 結果
 352          */
 353         public void addSharplessToolAndWeaponRecipe(ItemStack[] materials, ItemStack result) {
 354                 toolAndWeaponMaterials.add(materials);
 355                 toolAndWeaponResult.add(result);
 356                 toolAndWeaponSharpless.add(true);
 357         }
 358
 359
 360         /**
 361          * ツール&武器作成台のレシピを追加します
 362          * @param materials 素材
 363          * @param result 結果
 364          */
 365         public void addToolAndWeaponRecipe(ItemStack[] materials, ItemStack result) {
 366                 toolAndWeaponMaterials.add(materials);
 367                 toolAndWeaponResult.add(result);
 368                 toolAndWeaponSharpless.add(false);
 369         }
 370
 371
 372         public ArrayList<WorldGenAtomsOre> getAtomOres(){
 373                 return atomOresList;
 374         }
 375
 376
 377         //以下システム関連//////////////////////////////////////////////////////
 378
 379         public ArrayList<Integer[]> getAtomOresAmounts(){
 380                 return atomOresAmountsList;
 381         }
 382
 383
 384
 385         public ArrayList<Integer[]> getAtomOresAtoms(){
 386                 return atomOresAtomsList;
 387         }
 388
 389
 390
 391         public ListHash<String, String> getAtomOresLanguage(){
 392                 return atomOresLangListHash;
 393         }
 394
 395
 396
 397         public int getAtomOresLastIndex(){
 398                 return atomOresNameListHash.sizeKeysList() / 16;
 399         }
 400
 401
 402
 403         public int getAtomOresMetaOfLastIndex(){
 404                 return atomOresNameListHash.sizeKeysList() - getAtomOresLastIndex() * 16;
 405         }
 406
 407
 408
 409         public ListHash<String, String> getAtomOresName(){
 410                 return atomOresNameListHash;
 411         }
 412
 413
 414
 415         public ListHash<String, String> getChemicalCellsLanguage(){
 416                 return chemicalCellsLangListHash;
 417         }
 418
 419
 420
 421         public HashMap<ItemStack, Integer> getChemicalCellsList(){
 422                 return chemicalCellsList;
 423         }
 424
 425
 426
 427         public ListHash<String, String> getChemicalCellsName(){
 428                 return chemicalCellsNameListHash;
 429         }
 430
 431
 432
 433         public ArrayList<Integer[]> getChemicalCombinationAmounts(){
 434                 return chemicalCombinationAmounts;
 435         }
 436
 437
 438
 439         public ArrayList<String[]> getChemicalCombinationAtoms(){
 440                 return chemicalCombinationAtoms;
 441         }
 442
 443
 444
 445         public ArrayList<ItemStack> getChemicalCombinationResult(){
 446                 return chemicalCombinationResult;
 447         }
 448
 449
 450
 451         public int getCompound(String key){
 452                 if(compoundHash.get(key) != null){
 453                         return compoundHash.get(key);
 454                 } else {
 455                         return -1;
 456                 }
 457         }
 458
 459
 460
 461         public ArrayList<ICompoundHandler> getCompoundHandler(){
 462                 compoundHandlers.trimToSize();
 463                 return compoundHandlers;
 464
 465         }
 466
 467
 468
 469         public ArrayList<String> getCompoundHandlerItemName(){
 470                 compoundHandlerItemNames.trimToSize();
 471                 return compoundHandlerItemNames;
 472         }
 473
 474
 475
 476         public ListHash<String, String> getCompoundsLang(){
 477                 return compoundsLangListHash;
 478         }
 479
 480
 481
 482         public ListHash<String, String> getCompoundsName(){
 483                 return compoundsNameListHash;
 484         }
 485
 486
 487
 488         public ChemiCraftCraftingManager getCraftingManager(){
 489                 return chemiCraftCraftingManager;
 490         }
 491
 492
 493
 494         public ArrayList<MaterialRecipe> getMaterialRecipe(){
 495                 return materialRecipe;
 496         }
 497
 498
 499
 500         public ArrayList<ItemStack[]> getToolAndWeaponMaterials() {
 501                 return toolAndWeaponMaterials;
 502         }
 503
 504
 505
 506         public ArrayList<ItemStack> getToolAndWeaponResult() {
 507                 return toolAndWeaponResult;
 508         }
 509
 510
 511
 512         public ArrayList<Boolean> getToolAndWeaponSharpless() {
 513                 return toolAndWeaponSharpless;
 514         }
 515
 516
 517
 518         /**
 519          * setting compound handler.
 520          * @param handlerItemName
 521          * @param compoundHandler
 522          */
 523         public void settingCompoundHandler(String handlerItemName, ICompoundHandler compoundHandler){
 524                 compoundHandlers.add(compoundHandler);
 525                 compoundHandlerItemNames.add(handlerItemName);
 526         }
 527
 528 }