common/chemicraft/tileentity/TileEntityChemicalCombinationTable.java

   1 package chemicraft.tileentity;
   2
   3 import java.io.DataOutputStream;
   4 import java.util.ArrayList;
   5 import java.util.Arrays;
   6
   7 import net.minecraft.src.EntityItem;
   8 import net.minecraft.src.IInventory;
   9 import net.minecraft.src.ItemStack;
  10 import net.minecraft.src.NBTTagCompound;
  11 import net.minecraft.src.NBTTagList;
  12 import net.minecraft.src.Packet;
  13 import net.minecraft.src.TileEntity;
  14 import chemicraft.ChemiCraft;
  15 import chemicraft.ChemiCraftData;
  16 import chemicraft.inventory.InventoryChemicalCombinationTableMaterial;
  17 import chemicraft.inventory.InventoryChemicalCombinationTableResult;
  18 import chemicraft.system.PacketHandler;
  19 import 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         }
 258
 259         public void setDropItems(ItemStack par1ItemStack){
 260                 this.dropItems = par1ItemStack;
 261         }
 262
 263         public String getAtoms(){
 264                 StringBuffer var1 = new StringBuffer();
 265                 for(int i = 0;i < this.atomsList.size();i++){
 266                         if (this.atomsAmountList.get(i) != 1){
 267                                 var1.append(this.atomsList.get(i) + this.atomsAmountList.get(i));
 268                         }else{
 269                                 var1.append(this.atomsList.get(i));
 270                         }
 271                 }
 272                 return var1.toString();
 273         }
 274
 275         public ArrayList<String> getAtomsList(){
 276                 return this.atomsList;
 277         }
 278
 279         public ArrayList<Integer> getAtomsAmountList(){
 280                 return this.atomsAmountList;
 281         }
 282
 283         public void emptytoAtomsList(){
 284                 this.atomsList.clear();
 285                 this.atomsAmountList.clear();
 286         }
 287
 288         public void setProvidePower(boolean par1) {
 289                 this.isProvidePower = par1;
 290         }
 291
 292         public boolean getProvidePower() {
 293                 return this.isProvidePower;
 294         }
 295
 296         public void field_00001() {
 297                 IInventory inv = this.getInvMaterial();
 298                 ItemStack[] stacks = new ItemStack[inv.getSizeInventory()];
 299                 for(int i = 0;i < stacks.length;i++){
 300                         if(inv.getStackInSlot(i) != null){
 301                                 stacks[i] = inv.getStackInSlot(i);
 302                         }
 303                 }
 304                 Arrays.sort(stacks, new ComparatorItemStack());
 305                 stacks = ChemiCraft.instance.arrayAuxiliary.deleteNull(stacks);
 306
 307                 for(int i = 0;i < stacks.length;i++){
 308                         if(stacks[i].stackSize > 1){
 309                                 this.setAtoms(ChemiCraftData.ATOMSLIST[stacks[i].getItemDamage()], stacks[i].stackSize);
 310                         }else{
 311                                 this.setAtoms(ChemiCraftData.ATOMSLIST[stacks[i].getItemDamage()], 1);
 312                         }
 313                 }
 314
 315                 for(int i = 0;i < inv.getSizeInventory();i++){
 316                         inv.setInventorySlotContents(i, null);
 317                 }
 318         }
 319
 320         public void field_00002() {
 321                 ArrayList<String> var1 = this.getAtomsList();
 322                 ArrayList<Integer> var2 = this.getAtomsAmountList();
 323
 324                 for (int i = 0;i < var1.size();i++) {
 325                         for (int j = 0;j < ChemiCraftData.ATOMSLIST.length;j++) {
 326                                 if (var1.get(i).equals(ChemiCraftData.ATOMSLIST[j])) {
 327                                         int var3 = var2.get(i);
 328                                         while(var3 > 0){
 329                                                 if(var3 > 64){
 330                                                         ItemStack itemstack = new ItemStack(ChemiCraft.instance.itemAtoms, 64, j);
 331                                                         this.setDropItems(itemstack);
 332                                                         PacketDispatcher.sendPacketToServer(this.getDescriptionPacket());
 333                                                         var3 -= 64;
 334                                                 }else{
 335                                                         ItemStack itemstack = new ItemStack(ChemiCraft.instance.itemAtoms, var3, j);
 336                                                         this.setDropItems(itemstack);
 337                                                         PacketDispatcher.sendPacketToServer(this.getDescriptionPacket());
 338                                                         var3 = 0;
 339                                                 }
 340                                         }
 341                                         break;
 342                                 }
 343                         }
 344                 }
 345                 IInventory invr = this.getInvResult();
 346                 if (invr.getStackInSlot(0) != null) {
 347                         invr.setInventorySlotContents(0, null);
 348                 }
 349                 this.emptytoAtomsList();
 350         }
 351
 352         protected boolean isNumber(String par1){
 353                 try {
 354                         int var1 = Integer.valueOf(new String(par1));
 355                 } catch (Exception e) {
 356                         return false;
 357                 }
 358                 return true;
 359         }
 360
 361         public InventoryChemicalCombinationTableMaterial getInvMaterial(){
 362                 return this.invm;
 363         }
 364
 365         public InventoryChemicalCombinationTableResult getInvResult(){
 366                 return this.invr;
 367         }
 368
 369 }