OSDN Git Service

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