common/pcc/chemicraft/core/tileentity/TileEntityPyrolysisTable.java

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