common/pcc/chemicraft/tileentity/TileEntityElectrolysisTable.java

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