common/pcc/chemicraft/tileentity/TileEntityChemicalCombinationTable.java

   1 package pcc.chemicraft.tileentity;
   2
   3 import java.io.DataOutputStream;
   4 import java.util.ArrayList;
   5 import java.util.Arrays;
   6
   7 import net.minecraft.entity.item.EntityItem;
   8 import net.minecraft.inventory.IInventory;
   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.ChemiCraft;
  15 import pcc.chemicraft.ChemiCraftData;
  16 import pcc.chemicraft.inventory.InventoryChemicalCombinationTableMaterial;
  17 import pcc.chemicraft.inventory.InventoryChemicalCombinationTableResult;
  18 import pcc.chemicraft.system.PacketHandler;
  19 import pcc.chemicraft.util.ComparatorItemStack;
  20
  21 import com.google.common.io.ByteArrayDataInput;
  22
  23 import cpw.mods.fml.common.network.PacketDispatcher;
  24
  25 public class TileEntityChemicalCombinationTable extends TileEntity {
  26
  27         private InventoryChemicalCombinationTableMaterial invm = new InventoryChemicalCombinationTableMaterial();
  28         private InventoryChemicalCombinationTableResult invr = new InventoryChemicalCombinationTableResult();
  29
  30         private ArrayList<String> atomsList = new ArrayList<String>();
  31         private ArrayList<Integer> atomsAmountList = new ArrayList<Integer>();
  32         private int atomsListSize = 0;
  33
  34         private ItemStack dropItems;
  35
  36         private boolean isProvidePower;
  37
  38         @Override
  39         public void updateEntity(){
  40                 super.updateEntity();
  41                 if (this.isProvidePower && !this.worldObj.isRemote) {
  42                         this.field_00001();
  43                         this.isProvidePower = false;
  44                         PacketDispatcher.sendPacketToAllPlayers(this.getDescriptionPacket());
  45                 }
  46         }
  47
  48         @Override
  49         public void readFromNBT(NBTTagCompound par1){
  50                 super.readFromNBT(par1);
  51                 NBTTagList var2 = par1.getTagList("Items");
  52                 for (int var3 = 0; var3 < var2.tagCount(); ++var3)
  53                 {
  54                         NBTTagCompound var4 = (NBTTagCompound)var2.tagAt(var3);
  55                         int var5 = var4.getByte("Slot") & 255;
  56
  57                         if  (var5 >= 0 && var5 < this.invm.getSizeInventory())
  58                         {
  59                                 this.invm.setInventorySlotContents(var5, ItemStack.loadItemStackFromNBT(var4));
  60                         }
  61                 }
  62
  63                 NBTTagList var6 = par1.getTagList("Items2");
  64                 for (int var3 = 0; var3 < var6.tagCount(); ++var3)
  65                 {
  66                         NBTTagCompound var7 = (NBTTagCompound)var6.tagAt(var3);
  67                         int var8 = var7.getByte("Slot2") & 255;
  68
  69                         if  (var8 >= 0 && var8 < this.invr.getSizeInventory())
  70                         {
  71                                 this.invr.setInventorySlotContents(var8, ItemStack.loadItemStackFromNBT(var7));
  72                         }
  73                 }
  74
  75                 this.atomsListSize = par1.getInteger("atomsListSize");
  76                 for(int i = 0;i < this.atomsListSize;i++){
  77                         this.atomsList.add(par1.getString("atomsList" + i));
  78                 }
  79                 for(int i = 0;i < this.atomsListSize;i++){
  80                         this.atomsAmountList.add(par1.getInteger("atomsAmountList" + i));
  81                 }
  82
  83                 this.isProvidePower = par1.getBoolean("isProvidePower");
  84         }
  85
  86         @Override
  87         public void writeToNBT(NBTTagCompound par1){
  88                 super.writeToNBT(par1);
  89                 NBTTagList var2 = new NBTTagList();
  90                 for (int var3 = 0; var3 < this.invm.getSizeInventory(); ++var3)
  91                 {
  92                         if  (this.invm.getStackInSlot(var3) != null)
  93                         {
  94                                 NBTTagCompound var4 = new NBTTagCompound();
  95                                 var4.setByte("Slot", (byte)var3);
  96                                 this.invm.getStackInSlot(var3).writeToNBT(var4);
  97                                 var2.appendTag(var4);
  98                         }
  99                 }
 100                 par1.setTag("Items", var2);
 101
 102                 NBTTagList var5 = new NBTTagList();
 103                 for (int var6 = 0; var6 < this.invr.getSizeInventory(); ++var6)
 104                 {
 105                         if  (this.invr.getStackInSlot(var6) != null)
 106                         {
 107                                 NBTTagCompound var7 = new NBTTagCompound();
 108                                 var7.setByte("Slot2", (byte)var6);
 109                                 this.invr.getStackInSlot(var6).writeToNBT(var7);
 110                                 var5.appendTag(var7);
 111                         }
 112                 }
 113                 par1.setTag("Items2", var5);
 114
 115                 this.atomsList.trimToSize();
 116                 this.atomsAmountList.trimToSize();
 117                 for(int i = 0;i < this.atomsList.size();i++){
 118                         par1.setString("atomsList" + i, this.atomsList.get(i));
 119                 }
 120                 for(int i = 0;i < this.atomsAmountList.size();i++){
 121                         par1.setInteger("atomsAmountList" + i, this.atomsAmountList.get(i));
 122                 }
 123
 124                 this.atomsListSize = this.atomsList.size();
 125                 par1.setInteger("atomsListSize", this.atomsListSize);
 126
 127                 par1.setBoolean("isProvidePower", this.isProvidePower);
 128         }
 129
 130         @Override
 131         public Packet getDescriptionPacket() {
 132                 return PacketHandler.getPacket(this);
 133         }
 134
 135         public void readPacket(ByteArrayDataInput data) {
 136                 try {
 137                         for(int i = 0;i < this.invm.getSizeInventory();i++){
 138                                 int id = data.readInt();
 139                                 int size = data.readByte();
 140                                 int damage = data.readInt();
 141                                 if (id != 0 && size != 0){
 142                                         this.invm.setInventorySlotContents(i, new ItemStack(id, size, damage));
 143                                 }else{
 144                                         this.invm.setInventorySlotContents(i, null);
 145                                 }
 146                         }
 147
 148                         for(int i = 0;i < this.invr.getSizeInventory();i++){
 149                                 int id = data.readInt();
 150                                 int size = data.readByte();
 151                                 int damage = data.readInt();
 152                                 if (id != 0 && size != 0){
 153                                         this.invr.setInventorySlotContents(i, new ItemStack(id, size, damage));
 154                                 }else{
 155                                         this.invr.setInventorySlotContents(i, null);
 156                                 }
 157                         }
 158
 159                         this.atomsListSize = data.readInt();
 160                         this.atomsList.clear();
 161                         this.atomsAmountList.clear();
 162                         for(int i = 0;i < this.atomsListSize;i++){
 163                                 this.atomsList.add(data.readUTF());
 164                         }
 165                         for(int i = 0;i < this.atomsListSize;i++){
 166                                 this.atomsAmountList.add(data.readInt());
 167                         }
 168
 169                         ItemStack itemstack = new ItemStack(data.readInt(), data.readByte(), data.readInt());
 170                         if(itemstack.itemID != 0 && !this.worldObj.isRemote){
 171                                 this.worldObj.spawnEntityInWorld(new EntityItem(this.worldObj, this.xCoord, this.yCoord + 1, this.zCoord, itemstack));
 172                         }
 173                         this.dropItems = null;
 174
 175                         this.isProvidePower = data.readBoolean();
 176                 } catch (Exception e) {
 177                         e.printStackTrace();
 178                 }
 179         }
 180
 181         public void writePacket(DataOutputStream dos){
 182                 try {
 183                         for(int i = 0;i < this.invm.getSizeInventory();i++){
 184                                 int id = 0;
 185                                 int size = 0;
 186                                 int damage  = 0;
 187                                 ItemStack itemstack = this.invm.getStackInSlot(i);
 188                                 if (itemstack != null){
 189                                         id = itemstack.itemID;
 190                                         size = itemstack.stackSize;
 191                                         damage = itemstack.getItemDamage();
 192                                         dos.writeInt(id);
 193                                         dos.writeByte(size);
 194                                         dos.writeInt(damage);
 195                                 }else{
 196                                         dos.writeInt(0);
 197                                         dos.writeByte(0);
 198                                         dos.writeInt(0);
 199                                 }
 200                         }
 201
 202                         for(int i = 0;i < this.invr.getSizeInventory();i++){
 203                                 int id = 0;
 204                                 int size = 0;
 205                                 int damage  = 0;
 206                                 ItemStack itemstack = this.invr.getStackInSlot(i);
 207                                 if (itemstack != null){
 208                                         id = itemstack.itemID;
 209                                         size = itemstack.stackSize;
 210                                         damage = itemstack.getItemDamage();
 211                                         dos.writeInt(id);
 212                                         dos.writeByte(size);
 213                                         dos.writeInt(damage);
 214                                 }else{
 215                                         dos.writeInt(0);
 216                                         dos.writeByte(0);
 217                                         dos.writeInt(0);
 218                                 }
 219                         }
 220
 221                         dos.writeInt(this.atomsList.size());
 222                         for(int i = 0;i < this.atomsList.size();i++){
 223                                 dos.writeUTF(this.atomsList.get(i));
 224                         }
 225                         for(int i = 0;i < this.atomsAmountList.size();i++){
 226                                 dos.writeInt(this.atomsAmountList.get(i));
 227                         }
 228
 229                         if (this.dropItems != null){
 230                                 int id = this.dropItems.itemID;
 231                                 int size = this.dropItems.stackSize;
 232                                 int damage = this.dropItems.getItemDamage();
 233                                 dos.writeInt(id);
 234                                 dos.writeByte(size);
 235                                 dos.writeInt(damage);
 236                         }else{
 237                                 dos.writeInt(0);
 238                                 dos.writeByte(0);
 239                                 dos.writeInt(0);
 240                         }
 241                         this.dropItems = null;
 242
 243                         dos.writeBoolean(this.isProvidePower);
 244                 } catch (Exception e) {
 245                         e.printStackTrace();
 246                 }
 247         }
 248
 249         public void setAtoms(String par1, int par2){
 250                 if (this.atomsList.indexOf(par1) != -1){
 251                         int var1 = this.atomsList.indexOf(par1);
 252                         this.atomsAmountList.set(var1, this.atomsAmountList.get(var1) + par2);
 253                 }else{
 254                         this.atomsList.add(par1);
 255                         this.atomsAmountList.add(par2);
 256                 }
 257                 PacketDispatcher.sendPacketToAllPlayers(this.getDescriptionPacket());
 258         }
 259
 260         public void setDropItems(ItemStack par1ItemStack){
 261                 this.dropItems = par1ItemStack;
 262         }
 263
 264         public String getAtoms(){
 265                 StringBuffer var1 = new StringBuffer();
 266                 for(int i = 0;i < this.atomsList.size();i++){
 267                         if (this.atomsAmountList.get(i) != 1){
 268                                 var1.append(this.atomsList.get(i) + this.atomsAmountList.get(i));
 269                         }else{
 270                                 var1.append(this.atomsList.get(i));
 271                         }
 272                 }
 273                 return var1.toString();
 274         }
 275
 276         public ArrayList<String> getAtomsList(){
 277                 return this.atomsList;
 278         }
 279
 280         public ArrayList<Integer> getAtomsAmountList(){
 281                 return this.atomsAmountList;
 282         }
 283
 284         public void emptytoAtomsList(){
 285                 this.atomsList.clear();
 286                 this.atomsAmountList.clear();
 287         }
 288
 289         public void setProvidePower(boolean par1) {
 290                 this.isProvidePower = par1;
 291         }
 292
 293         public boolean getProvidePower() {
 294                 return this.isProvidePower;
 295         }
 296
 297         public void field_00001() {
 298                 IInventory inv = this.getInvMaterial();
 299                 ItemStack[] stacks = new ItemStack[inv.getSizeInventory()];
 300                 for(int i = 0;i < stacks.length;i++){
 301                         if(inv.getStackInSlot(i) != null){
 302                                 stacks[i] = inv.getStackInSlot(i);
 303                         }
 304                 }
 305                 Arrays.sort(stacks, new ComparatorItemStack());
 306                 stacks = ChemiCraft.instance.arrayAuxiliary.deleteNull(stacks);
 307
 308                 for(int i = 0;i < stacks.length;i++){
 309                         if(stacks[i].stackSize > 1){
 310                                 this.setAtoms(ChemiCraftData.ATOMSLIST[stacks[i].getItemDamage()], stacks[i].stackSize);
 311                         }else{
 312                                 this.setAtoms(ChemiCraftData.ATOMSLIST[stacks[i].getItemDamage()], 1);
 313                         }
 314                 }
 315
 316                 for(int i = 0;i < inv.getSizeInventory();i++){
 317                         inv.setInventorySlotContents(i, null);
 318                 }
 319         }
 320
 321         public void field_00002() {
 322                 ArrayList<String> var1 = this.getAtomsList();
 323                 ArrayList<Integer> var2 = this.getAtomsAmountList();
 324
 325                 for (int i = 0;i < var1.size();i++) {
 326                         for (int j = 0;j < ChemiCraftData.ATOMSLIST.length;j++) {
 327                                 if (var1.get(i).equals(ChemiCraftData.ATOMSLIST[j])) {
 328                                         int var3 = var2.get(i);
 329                                         while(var3 > 0){
 330                                                 if(var3 > 64){
 331                                                         ItemStack itemstack = new ItemStack(ChemiCraft.instance.itemAtoms, 64, j);
 332                                                         this.setDropItems(itemstack);
 333                                                         PacketDispatcher.sendPacketToServer(this.getDescriptionPacket());
 334                                                         var3 -= 64;
 335                                                 }else{
 336                                                         ItemStack itemstack = new ItemStack(ChemiCraft.instance.itemAtoms, var3, j);
 337                                                         this.setDropItems(itemstack);
 338                                                         PacketDispatcher.sendPacketToServer(this.getDescriptionPacket());
 339                                                         var3 = 0;
 340                                                 }
 341                                         }
 342                                         break;
 343                                 }
 344                         }
 345                 }
 346                 IInventory invr = this.getInvResult();
 347                 if (invr.getStackInSlot(0) != null) {
 348                         invr.setInventorySlotContents(0, null);
 349                 }
 350                 this.emptytoAtomsList();
 351         }
 352
 353         protected boolean isNumber(String par1){
 354                 try {
 355                         int var1 = Integer.valueOf(new String(par1));
 356                 } catch (Exception e) {
 357                         return false;
 358                 }
 359                 return true;
 360         }
 361
 362         public InventoryChemicalCombinationTableMaterial getInvMaterial(){
 363                 return this.invm;
 364         }
 365
 366         public InventoryChemicalCombinationTableResult getInvResult(){
 367                 return this.invr;
 368         }
 369
 370 }