common/pcc/chemicraft/tileentity/TileEntityElectrolysisTable.java

   1 package pcc.chemicraft.tileentity;
   2
   3 import ic2.api.Direction;
   4 import ic2.api.energy.tile.IEnergySink;
   5
   6 import java.io.DataOutputStream;
   7 import java.util.HashMap;
   8 import java.util.Iterator;
   9 import java.util.Random;
  10
  11 import net.minecraft.block.Block;
  12 import net.minecraft.item.ItemStack;
  13 import net.minecraft.nbt.NBTTagCompound;
  14 import net.minecraft.nbt.NBTTagList;
  15 import net.minecraft.network.packet.Packet;
  16 import net.minecraft.tileentity.TileEntity;
  17 import pcc.chemicraft.ChemiCraftAPI;
  18 import pcc.chemicraft.inventory.InventoryElectrolysisFuel;
  19 import pcc.chemicraft.inventory.InventoryElectrolysisMaterial;
  20 import pcc.chemicraft.inventory.InventoryElectrolysisResult;
  21 import pcc.chemicraft.system.PacketHandler;
  22
  23 import com.google.common.io.ByteArrayDataInput;
  24
  25 public class TileEntityElectrolysisTable extends TileEntity implements IEnergySink
  26 {
  27
  28         private InventoryElectrolysisMaterial invm = new InventoryElectrolysisMaterial();
  29         private InventoryElectrolysisResult invr = new InventoryElectrolysisResult();
  30         private InventoryElectrolysisFuel invf = new InventoryElectrolysisFuel();
  31
  32         /**
  33          * 電力
  34          */
  35         private float heat = 0;
  36
  37         /**
  38          * 素材の電力時間
  39          */
  40         private float burnTime = 0;
  41
  42         /**
  43          * 電池の残り電力時間
  44          */
  45         private float fuelRestTime = 0;
  46
  47         /**
  48          * 最大熱量
  49          */
  50         private static final int MAX_HEAT = 1700;
  51
  52         /**
  53          * 燃料が燃え始める最低熱量
  54          */
  55         private static final int MIN_HEAT = 400;
  56
  57         /**
  58          * 燃料の燃焼速度比率・素材の燃焼速度比率の中心となる熱量
  59          */
  60         private static final int CENTER_HEAT = 1050;
  61
  62         /**
  63          * 分解までの時間
  64          */
  65         private static final int MAX_BURN_TIME = 2000;
  66
  67         /**
  68          * Random of instance.
  69          */
  70         public static final Random rand = new Random();
  71
  72         /**
  73          * レシピのリスト
  74          */
  75         private static HashMap<ItemStack, ItemStack[]> recipeList = new HashMap<ItemStack, ItemStack[]>();
  76
  77         @Override
  78         public void updateEntity()
  79         {
  80                 if (this.fuelRestTime >= 0) {
  81                         this.burnTime += 10 * CENTER_HEAT / this.heat;
  82                         this.fuelRestTime -= 10 * CENTER_HEAT / this.heat;
  83                 }
  84
  85                 if (this.burnTime >= MAX_BURN_TIME) {
  86                         Iterator<ItemStack> itMaterial = recipeList.keySet().iterator();
  87                         while (itMaterial.hasNext()) {
  88                                 ItemStack itemstackMaterial = itMaterial.next();
  89                                 ItemStack materialItem = this.invm.getStackInSlot(0);
  90                                 if (materialItem != null) {
  91                                         if (this.isInItemCheck(itemstackMaterial)) {
  92                                                 if (itemstackMaterial.itemID == materialItem.itemID && itemstackMaterial.getItemDamage() == materialItem.getItemDamage()) {
  93                                                         this.inItem(itemstackMaterial);
  94                                                         if (materialItem.stackSize > 1) {
  95                                                                 this.invm.setInventorySlotContents(0, new ItemStack(materialItem.itemID, --materialItem.stackSize, materialItem.getItemDamage()));
  96                                                         } else {
  97                                                                 this.invm.setInventorySlotContents(0, null);
  98                                                         }
  99                                                         break;
 100                                                 }
 101                                         }
 102                                 }
 103                         }
 104                         this.burnTime = 0;
 105                 }
 106
 107                 boolean var1 = false;
 108                 if (this.heat > MIN_HEAT) {
 109                         Iterator<ItemStack> itMaterial = recipeList.keySet().iterator();
 110                         while (itMaterial.hasNext()) {
 111                                 ItemStack itemstackMaterial = itMaterial.next();
 112                                 ItemStack materialItem = this.invm.getStackInSlot(0);
 113                                 if (materialItem != null) {
 114                                         if (this.isInItemCheck(itemstackMaterial)) {
 115                                                 if (itemstackMaterial.itemID == materialItem.itemID && itemstackMaterial.getItemDamage() == materialItem.getItemDamage()) {
 116                                                         var1 = true;
 117                                                         if (this.fuelRestTime <= 0) {
 118                                                                 Iterator<ItemStack> itFuel = ChemiCraftAPI.instance().getChemicalCellsList().keySet().iterator();
 119                                                                 while (itFuel.hasNext()) {
 120                                                                         ItemStack itemstackFuel = itFuel.next();
 121                                                                         ItemStack fuelItem = this.invf.getStackInSlot(0);
 122                                                                         if (fuelItem != null) {
 123                                                                                 if (itemstackFuel.itemID == fuelItem.itemID && itemstackFuel.getItemDamage() == fuelItem.getItemDamage()) {
 124                                                                                         this.fuelRestTime = ChemiCraftAPI.instance().getChemicalCellsList().get(itemstackFuel);
 125                                                                                         if (fuelItem.stackSize > 1) {
 126                                                                                                 this.invf.setInventorySlotContents(0, new ItemStack(fuelItem.itemID, --fuelItem.stackSize, fuelItem.getItemDamage()));
 127                                                                                                 break;
 128                                                                                         } else {
 129                                                                                                 this.invf.setInventorySlotContents(0, null);
 130                                                                                                 break;
 131                                                                                         }
 132                                                                                 }
 133                                                                         }
 134                                                                 }
 135                                                         }
 136                                                 }
 137                                         }
 138                                 } else {
 139                                         this.burnTime = 0;
 140                                 }
 141                         }
 142                         if (!var1) {
 143                                 this.burnTime = 0;
 144                         }
 145                 }
 146         }
 147
 148         @Override
 149         public void readFromNBT(NBTTagCompound par1) {
 150                 super.readFromNBT(par1);
 151                 this.heat = par1.getFloat("Heat");
 152                 this.burnTime = par1.getFloat("BurnTime");
 153                 this.fuelRestTime = par1.getFloat("FuelRestTime");
 154
 155                 NBTTagList var2 = par1.getTagList("Items");
 156                 for (int var3 = 0; var3 < var2.tagCount(); ++var3)
 157                 {
 158                         NBTTagCompound var4 = (NBTTagCompound)var2.tagAt(var3);
 159                         int var5 = var4.getByte("Slot") & 255;
 160
 161                         if  (var5 >= 0 && var5 < this.invm.getSizeInventory())
 162                         {
 163                                 this.invm.setInventorySlotContents(var5, ItemStack.loadItemStackFromNBT(var4));
 164                         }
 165                 }
 166
 167                 NBTTagList var6 = par1.getTagList("Items2");
 168                 for (int var3 = 0; var3 < var6.tagCount(); ++var3)
 169                 {
 170                         NBTTagCompound var7 = (NBTTagCompound)var6.tagAt(var3);
 171                         int var8 = var7.getByte("Slot2") & 255;
 172
 173                         if  (var8 >= 0 && var8 < this.invr.getSizeInventory())
 174                         {
 175                                 this.invr.setInventorySlotContents(var8, ItemStack.loadItemStackFromNBT(var7));
 176                         }
 177                 }
 178
 179                 NBTTagList var9 = par1.getTagList("Items3");
 180                 for (int var3 = 0; var3 < var9.tagCount(); ++var3)
 181                 {
 182                         NBTTagCompound var10 = (NBTTagCompound)var9.tagAt(var3);
 183                         int var11 = var10.getByte("Slot3") & 255;
 184
 185                         if  (var11 >= 0 && var11 < this.invf.getSizeInventory())
 186                         {
 187                                 this.invf.setInventorySlotContents(var11, ItemStack.loadItemStackFromNBT(var10));
 188                         }
 189                 }
 190         }
 191
 192         @Override
 193         public void writeToNBT(NBTTagCompound par1) {
 194                 super.writeToNBT(par1);
 195                 par1.setFloat("Heat", this.heat);
 196                 par1.setFloat("BurnTime", this.burnTime);
 197                 par1.setFloat("FuelRestTime", this.fuelRestTime);
 198
 199                 NBTTagList var2 = new NBTTagList();
 200                 for (int var3 = 0; var3 < this.invm.getSizeInventory(); ++var3)
 201                 {
 202                         if  (this.invm.getStackInSlot(var3) != null)
 203                         {
 204                                 NBTTagCompound var4 = new NBTTagCompound();
 205                                 var4.setByte("Slot", (byte)var3);
 206                                 this.invm.getStackInSlot(var3).writeToNBT(var4);
 207                                 var2.appendTag(var4);
 208                         }
 209                 }
 210                 par1.setTag("Items", var2);
 211
 212                 NBTTagList var5 = new NBTTagList();
 213                 for (int var6 = 0; var6 < this.invr.getSizeInventory(); ++var6)
 214                 {
 215                         if  (this.invr.getStackInSlot(var6) != null)
 216                         {
 217                                 NBTTagCompound var7 = new NBTTagCompound();
 218                                 var7.setByte("Slot2", (byte)var6);
 219                                 this.invr.getStackInSlot(var6).writeToNBT(var7);
 220                                 var5.appendTag(var7);
 221                         }
 222                 }
 223                 par1.setTag("Items2", var5);
 224
 225                 NBTTagList var8 = new NBTTagList();
 226                 for (int var9 = 0; var9 < this.invf.getSizeInventory(); ++var9)
 227                 {
 228                         if  (this.invf.getStackInSlot(var9) != null)
 229                         {
 230                                 NBTTagCompound var10 = new NBTTagCompound();
 231                                 var10.setByte("Slot3", (byte)var9);
 232                                 this.invf.getStackInSlot(var9).writeToNBT(var10);
 233                                 var8.appendTag(var10);
 234                         }
 235                 }
 236                 par1.setTag("Items3", var8);
 237         }
 238
 239         @Override
 240         public Packet getDescriptionPacket() {
 241                 return PacketHandler.getPacket(this);
 242         }
 243
 244         public void readPacket(ByteArrayDataInput data) {
 245                 try {
 246                         this.heat = data.readFloat();
 247                         this.burnTime = data.readInt();
 248                         this.fuelRestTime = data.readFloat();
 249                         for(int i = 0;i < this.invm.getSizeInventory();i++){
 250                                 int id = data.readInt();
 251                                 int size = data.readByte();
 252                                 int damage = data.readInt();
 253                                 if (id != 0 && size != 0){
 254                                         this.invm.setInventorySlotContents(i, new ItemStack(id, size, damage));
 255                                 }else{
 256                                         this.invm.setInventorySlotContents(i, null);
 257                                 }
 258                         }
 259
 260                         for(int i = 0;i < this.invr.getSizeInventory();i++){
 261                                 int id = data.readInt();
 262                                 int size = data.readByte();
 263                                 int damage = data.readInt();
 264                                 if (id != 0 && size != 0){
 265                                         this.invr.setInventorySlotContents(i, new ItemStack(id, size, damage));
 266                                 }else{
 267                                         this.invr.setInventorySlotContents(i, null);
 268                                 }
 269                         }
 270
 271                         for(int i = 0;i < this.invf.getSizeInventory();i++){
 272                                 int id = data.readInt();
 273                                 int size = data.readByte();
 274                                 int damage = data.readInt();
 275                                 if (id != 0 && size != 0){
 276                                         this.invf.setInventorySlotContents(i, new ItemStack(id, size, damage));
 277                                 }else{
 278                                         this.invf.setInventorySlotContents(i, null);
 279                                 }
 280                         }
 281                 } catch (Exception e) {
 282                         e.printStackTrace();
 283                 }
 284         }
 285
 286
 287         public void writePacket(DataOutputStream dos){
 288                 try {
 289                         dos.writeFloat(this.heat);
 290                         dos.writeFloat(this.burnTime);
 291                         dos.writeFloat(this.fuelRestTime);
 292                         for(int i = 0;i < this.invm.getSizeInventory();i++){
 293                                 int id = 0;
 294                                 int size = 0;
 295                                 int damage  = 0;
 296                                 ItemStack itemstack = this.invm.getStackInSlot(i);
 297                                 if (itemstack != null){
 298                                         id = itemstack.itemID;
 299                                         size = itemstack.stackSize;
 300                                         damage = itemstack.getItemDamage();
 301                                         dos.writeInt(id);
 302                                         dos.writeByte(size);
 303                                         dos.writeInt(damage);
 304                                 }else{
 305                                         dos.writeInt(0);
 306                                         dos.writeByte(0);
 307                                         dos.writeInt(0);
 308                                 }
 309                         }
 310
 311                         for(int i = 0;i < this.invr.getSizeInventory();i++){
 312                                 int id = 0;
 313                                 int size = 0;
 314                                 int damage  = 0;
 315                                 ItemStack itemstack = this.invr.getStackInSlot(i);
 316                                 if (itemstack != null){
 317                                         id = itemstack.itemID;
 318                                         size = itemstack.stackSize;
 319                                         damage = itemstack.getItemDamage();
 320                                         dos.writeInt(id);
 321                                         dos.writeByte(size);
 322                                         dos.writeInt(damage);
 323                                 }else{
 324                                         dos.writeInt(0);
 325                                         dos.writeByte(0);
 326                                         dos.writeInt(0);
 327                                 }
 328                         }
 329
 330                         for(int i = 0;i < this.invf.getSizeInventory();i++){
 331                                 int id = 0;
 332                                 int size = 0;
 333                                 int damage  = 0;
 334                                 ItemStack itemstack = this.invf.getStackInSlot(i);
 335                                 if (itemstack != null){
 336                                         id = itemstack.itemID;
 337                                         size = itemstack.stackSize;
 338                                         damage = itemstack.getItemDamage();
 339                                         dos.writeInt(id);
 340                                         dos.writeByte(size);
 341                                         dos.writeInt(damage);
 342                                 }else{
 343                                         dos.writeInt(0);
 344                                         dos.writeByte(0);
 345                                         dos.writeInt(0);
 346                                 }
 347                         }
 348                 } catch (Exception e) {
 349                         e.printStackTrace();
 350                 }
 351         }
 352
 353         public float getBurnTime() {
 354                 return this.burnTime;
 355         }
 356
 357         public float getHeat() {
 358                 return this.heat;
 359         }
 360
 361         public InventoryElectrolysisMaterial getInvMaterial(){
 362                 return this.invm;
 363         }
 364
 365         public InventoryElectrolysisResult getInvResult(){
 366                 return this.invr;
 367         }
 368
 369         public InventoryElectrolysisFuel getInvFuel(){
 370                 return this.invf;
 371         }
 372
 373         public boolean isInItemCheck(ItemStack key) {
 374                 ItemStack[] results = recipeList.get(key).clone();
 375                 ItemStack[] containerResults = new ItemStack[this.invr.getSizeInventory()];
 376                 for (int j = 0; j < this.invr.getSizeInventory(); j++) {
 377                         containerResults[j] = this.invr.getStackInSlot(j);
 378                 }
 379
 380                 for (int i = 0; i < results.length; i++) {
 381                         int var1 = results[i].itemID;
 382                         int var3 = results[i].getItemDamage();
 383                         int var5 = results[i].stackSize;
 384                         for (int j = 0; j < containerResults.length; j++) {
 385                                 if (containerResults[j] == null) {
 386                                         containerResults[j] = results[i];
 387                                         results[i] = null;
 388                                         break;
 389                                 } else {
 390                                         int var2 = containerResults[j].itemID;
 391                                         int var4 = containerResults[j].getItemDamage();
 392                                         int var6 = containerResults[j].stackSize;
 393                                         int var7 = containerResults[j].getMaxStackSize();
 394                                         if (var1 == var2 && var3 == var4) {
 395                                                 if (var5 + var6 <= var7) {
 396                                                         containerResults[j] = results[i];
 397                                                         results[i] = null;
 398                                                         break;
 399                                                 } else {
 400                                                         var5 -= var7 - var6;
 401                                                 }
 402                                         }
 403                                 }
 404                         }
 405                 }
 406                 for (int i = 0; i < results.length; i++) {
 407                         if (results[i] != null) {
 408                                 return false;
 409                         }
 410                 }
 411                 return true;
 412         }
 413
 414         public void inItem(ItemStack key) {
 415                 ItemStack[] results = recipeList.get(key);
 416
 417                 for (int i = 0; i < results.length; i++) {
 418                         ItemStack[] containerResults = new ItemStack[this.invr.getSizeInventory()];
 419                         for (int j = 0; j < this.invr.getSizeInventory(); j++) {
 420                                 containerResults[j] = this.invr.getStackInSlot(j);
 421                         }
 422                         int var1 = results[i].itemID;
 423                         int var3 = results[i].getItemDamage();
 424                         int var5 = results[i].stackSize;
 425                         for (int j = 0; j < containerResults.length; j++) {
 426                                 if (containerResults[j] == null) {
 427                                         this.invr.setInventorySlotContents(j, results[i]);
 428                                         break;
 429                                 } else {
 430                                         int var2 = containerResults[j].itemID;
 431                                         int var4 = containerResults[j].getItemDamage();
 432                                         int var6 = containerResults[j].stackSize;
 433                                         int var7 = containerResults[j].getMaxStackSize();
 434                                         if (var1 == var2 && var3 == var4) {
 435                                                 if (var5 + var6 <= var7) {
 436                                                         this.invr.setInventorySlotContents(j, new ItemStack(results[i].itemID, var5 + var6, results[i].getItemDamage()));
 437                                                         break;
 438                                                 } else {
 439                                                         this.invr.setInventorySlotContents(j, new ItemStack(results[i].itemID, var7, results[i].getItemDamage()));
 440                                                         var5 -= var7 - var6;
 441                                                 }
 442                                         }
 443                                 }
 444                         }
 445                 }
 446         }
 447
 448         public static void addRecipe(ItemStack material, ItemStack[] result) {
 449                 recipeList.put(material, result);
 450         }
 451
 452         @Override
 453         public boolean acceptsEnergyFrom(TileEntity emitter, Direction direction)
 454         {
 455                 return true;
 456         }
 457
 458         @Override
 459         public boolean isAddedToEnergyNet()
 460         {
 461                 return true;
 462         }
 463
 464         @Override
 465         public int demandsEnergy()
 466         {
 467                 return 0;
 468         }
 469
 470         @Override
 471         public int injectEnergy(Direction directionFrom, int amount)
 472         {
 473                 return 0;
 474         }
 475
 476         @Override
 477         public int getMaxSafeInput()
 478         {
 479                 return 32;
 480         }
 481
 482 }