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