G2A Many GEOs
SHARE
TWEET

VoidExtractorTileEntity

a guest Sep 13th, 2014 12 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. package net.prefixaut.voidmod.tileentitys;
  2.  
  3. import static net.prefixaut.voidmod.api.VoidBlocks.*;
  4. import net.minecraft.entity.player.EntityPlayer;
  5. import net.minecraft.inventory.ISidedInventory;
  6. import net.minecraft.item.Item;
  7. import net.minecraft.item.ItemStack;
  8. import net.minecraft.nbt.NBTTagCompound;
  9. import net.minecraft.tileentity.TileEntity;
  10. import net.minecraftforge.common.MinecraftForge;
  11. import net.minecraftforge.common.util.ForgeDirection;
  12. import net.prefixaut.voidmod.VoidRecipeManager;
  13.  
  14. import net.prefixaut.voidmod.api.VoidBlocks;
  15. import net.prefixaut.voidmod.api.VoidRecipes;
  16.  
  17. import net.prefixaut.voidmod.blocks.VoidExtractorBlock;
  18. import net.prefixaut.voidmod.utility.IC2EnergyTier;
  19. import ic2.api.energy.event.EnergyTileLoadEvent;
  20. import ic2.api.energy.event.EnergyTileUnloadEvent;
  21. import ic2.api.energy.tile.IEnergySink;
  22. import ic2.api.tile.IWrenchable;
  23.  
  24. import java.util.ArrayList;
  25. import java.util.List;
  26.  
  27. public class VoidExtractorTileEntity extends TileEntity implements ISidedInventory, IEnergySink, IWrenchable {
  28.  
  29.         private boolean initialized, active;
  30.        
  31.         private IC2EnergyTier euTier = IC2EnergyTier.LV;
  32.         private int maxenergy = 10000;
  33.         private int maxvoidmatter = 10000;
  34.         private int energyDraw = euTier.getEUperTick();
  35.         private ItemStack workingOn;
  36.        
  37.         private static final int[]
  38.                         slotsTop = new int[]{0},
  39.                         slotsBottom = new int[]{1},
  40.                         slotsLeft = new int[]{0},
  41.                         slotsRight = new int[]{1},
  42.                         slotsFront = new int[]{0,1},
  43.                         slotsBack = new int[]{0,1};
  44.         private ItemStack[] slots = new ItemStack[2];
  45.        
  46.         public int maxWorktime = 200;
  47.         public int currentWorktime;
  48.         public int energy, voidmatter = 0;
  49.         public String name = "VoidConsumer";
  50.        
  51.         public static void initialize() {
  52.                 VoidRecipes.voidextractor = VoidRecipeManager.getVoidExtractorManager();
  53.                
  54.                 VoidRecipeManager.getVoidExtractorManager().addVoidItem(new ItemStack(voidedStone), 50);
  55.                 VoidRecipeManager.getVoidExtractorManager().addVoidItem(new ItemStack(impureVoidBlock), 100);
  56.                 VoidRecipeManager.getVoidExtractorManager().addVoidItem(new ItemStack(pureVoidBlock), 1000);
  57.         }
  58.        
  59.         @Override
  60.         public int getSizeInventory() {
  61.                 return slots.length;
  62.         }
  63.  
  64.         @Override
  65.         public ItemStack getStackInSlot(int slot) {
  66.                 try {
  67.                         return slots[slot];
  68.                 } catch (Exception e) {
  69.                         return null;
  70.                 }
  71.         }
  72.  
  73.         @Override
  74.         public ItemStack decrStackSize(int slot, int amount) {
  75.                 try {
  76.                         ItemStack stack = slots[slot].copy();
  77.                         if (stack != null) {
  78.                                 if (stack.stackSize <= amount) {
  79.                                         slots[slot] = null;
  80.                                         return stack;
  81.                                 }
  82.                                 stack.stackSize =- amount;
  83.                                 slots[slot].stackSize -= amount;
  84.                                 return stack;
  85.                         } else return null;
  86.                 } catch (Exception e) {
  87.                         return null;
  88.                 }
  89.         }
  90.  
  91.         @Override
  92.         public ItemStack getStackInSlotOnClosing(int slot) {
  93.                 return null;
  94.         }
  95.  
  96.         @Override
  97.         public void setInventorySlotContents(int slot, ItemStack item) {
  98.                 slots[slot] = item;
  99.         }
  100.  
  101.         @Override
  102.         public String getInventoryName() {
  103.                 return name;
  104.         }
  105.  
  106.         @Override
  107.         public boolean hasCustomInventoryName() {
  108.                 return name != null && !name.equals("");
  109.         }
  110.  
  111.         @Override
  112.         public int getInventoryStackLimit() {
  113.                 return 64;
  114.         }
  115.  
  116.         @Override
  117.         public boolean isUseableByPlayer(EntityPlayer player) {
  118.                 return true;
  119.         }
  120.  
  121.         @Override
  122.         public void openInventory() {
  123.         }
  124.  
  125.         @Override
  126.         public void closeInventory() {
  127.         }
  128.  
  129.         @Override
  130.         public boolean isItemValidForSlot(int slot, ItemStack item) {
  131.                 try {
  132.                         boolean ret;
  133.                         switch (slot) {
  134.                                 case 0: ret = VoidRecipeManager.getVoidExtractorManager().getRecipes().containsKey(item);
  135.                                                 break;
  136.                                 case 1: ret = VoidRecipeManager.energyItems.contains(item);
  137.                                                 break;
  138.                                 default: ret = false;
  139.                                                 break;
  140.                         }
  141.                         return ret;
  142.                 } catch (Exception e) {
  143.                         e.printStackTrace();
  144.                         return false;
  145.                 }
  146.         }
  147.  
  148.         @Override
  149.         public int[] getAccessibleSlotsFromSide(int side) {
  150.                 switch (side) {
  151.                         case 0: return slotsBottom;
  152.                         case 1: return slotsTop;
  153.                         case 2: return slotsFront;
  154.                         case 3: return slotsBack;
  155.                         case 4: return slotsLeft;
  156.                         case 5: return slotsRight;
  157.                         default: return null;
  158.                 }
  159.         }
  160.  
  161.         @Override
  162.         public boolean canInsertItem(int slot, ItemStack item, int side) {
  163.                 if (!VoidRecipeManager.getVoidExtractorManager().isValidItem(item)) return false;
  164.                 int[] array;
  165.                 switch (side) {
  166.                         case 0: array = slotsBottom;
  167.                                         break;
  168.                         case 1: array = slotsTop;
  169.                                         break;
  170.                         case 2: array = slotsFront;
  171.                                         break;
  172.                         case 3: array = slotsBack;
  173.                                         break;
  174.                         case 4: array = slotsLeft;
  175.                                         break;
  176.                         case 5: array = slotsRight;
  177.                                         break;
  178.                         default: array = null;
  179.                 }
  180.                 if (array == null) return false;
  181.                 for (int i=0; i < array.length; i++) {
  182.                         if (array[i] == slot) return true;
  183.                 }
  184.                 return false;
  185.         }
  186.  
  187.         @Override
  188.         public boolean canExtractItem(int slot, ItemStack item, int side) {
  189.                 return false;
  190.         }
  191.        
  192.         @Override
  193.         public void readFromNBT(NBTTagCompound nbt) {
  194.                 super.readFromNBT(nbt);
  195.                 if (nbt.hasKey("energy")) {
  196.                         this.energy = (int) nbt.getDouble("energy");
  197.                 }
  198.                 if (nbt.hasKey("voidmatter")) {
  199.                         this.voidmatter = (int) nbt.getInteger("voidmatter");
  200.                 }
  201.         }
  202.        
  203.         @Override
  204.         public void writeToNBT(NBTTagCompound nbt) {
  205.                 super.writeToNBT(nbt);
  206.                 nbt.setDouble("energy", this.energy);
  207.                 nbt.setDouble("voidmatter", voidmatter);
  208.                 worldObj.notifyBlockChange(xCoord, yCoord, zCoord, worldObj.getBlock(xCoord, yCoord, zCoord));
  209.         }
  210.        
  211.         private void updateStatus() {
  212.                 System.out.println("Update-Status");
  213.                 VoidExtractorBlock b = (VoidExtractorBlock) worldObj.getBlock(xCoord, yCoord, zCoord);
  214.                 b.updateActivity(active, worldObj, xCoord, yCoord, zCoord, this);
  215.                
  216.         }
  217.        
  218.         private int c = 1;
  219.         @Override
  220.         public void updateEntity() {
  221.                 super.updateEntity();
  222.                 if (!this.initialized && worldObj != null) {
  223.                         if (!worldObj.isRemote) {
  224.                                 EnergyTileLoadEvent load = new EnergyTileLoadEvent(this);
  225.                                 MinecraftForge.EVENT_BUS.post(load);
  226.                         }
  227.                         this.initialized = true;
  228.                 }
  229.                 if (!active) {
  230. //                      Starting
  231.                         if (energy >= energyDraw) {
  232.                                 if (this.getStackInSlot(0) != null){
  233.                                         if (VoidRecipeManager.getVoidExtractorManager().isValidItem(this.getStackInSlot(0))) {
  234.                                                 energy -= energyDraw;
  235.                                                 active = true;
  236.                                                 currentWorktime = 0;
  237.                                                 workingOn = this.getStackInSlot(0).copy();
  238.                                                 this.decrStackSize(0, 1);
  239.                                                 this.updateStatus();
  240.                                                 return;
  241.                                         }
  242.                                 }
  243.                         }
  244.                 } else {
  245.                         if (currentWorktime < maxWorktime) {
  246.                                 if (energy >= energyDraw) {
  247.                                         energy -= energyDraw;
  248.                                         currentWorktime++;
  249.                                         return;
  250.                                 }
  251.                         } else {
  252. //                              Finishing
  253.                                 if (VoidRecipeManager.getVoidExtractorManager().getVoidMatter(workingOn) > (maxvoidmatter - voidmatter)) {
  254. //                                      It would produce too much, so it stops until it can fill up the buffer again.
  255.                                         return;
  256.                                 }
  257.                                 energy -= energyDraw;
  258.                                 active = false;
  259.                                 currentWorktime = 0;
  260.                                 voidmatter += VoidRecipeManager.getVoidExtractorManager().getVoidMatter(workingOn);
  261.                                 workingOn = null;
  262.                                 this.updateStatus();
  263.                                 return;
  264.                         }
  265.                 }
  266.         }
  267.        
  268.         @Override
  269.         public void invalidate() {
  270.                 System.out.println("DEBUG: Invalidating TileEntity [" + this + "]");
  271.                 EnergyTileUnloadEvent unload = new EnergyTileUnloadEvent(this);
  272.                 MinecraftForge.EVENT_BUS.post(unload);
  273.                 super.invalidate();
  274.         }
  275.        
  276.         /*
  277.          * -==========| GUI Display |==========-
  278.          */
  279.        
  280.         public int getWorktimeScaled(int size) {
  281.                 return ((this.currentWorktime * size) / this.maxWorktime);
  282.         }
  283.        
  284.         public int getEnergyBufferScaled(int size) {
  285.                 return ((this.energy * size) / this.maxenergy);
  286.         }
  287.        
  288.         public int getEnergyLoadingScaled(int size) {
  289.                 int tmp = ((this.energy * size) / (this.energyDraw * this.maxWorktime));
  290.                 if (tmp > size) tmp = size;
  291.                 return tmp;
  292.         }
  293.        
  294.         public int getVoidMatterScaled(int size) {
  295.                 return ((this.voidmatter * size) / this.maxvoidmatter);
  296.         }
  297.        
  298.         public int getMaxEnergy() {
  299.                 return this.maxenergy;
  300.         }
  301.        
  302.         public int getEnergy() {
  303.                 return this.energy;
  304.         }
  305.        
  306.         public int getMaxVoid() {
  307.                 return this.maxenergy;
  308.         }
  309.        
  310.         public int getVoid() {
  311.                 return this.voidmatter;
  312.         }
  313.  
  314.         public boolean isActive() {
  315.                 return active;
  316.         }
  317.        
  318.         public boolean hasEnergy() {
  319.                 return this.energy >= this.energyDraw;
  320.         }
  321.        
  322.         /*
  323.          * -==========| IC 2 Enegery Stuff |==========-
  324.          */
  325.        
  326.         @Override
  327.         public boolean acceptsEnergyFrom(TileEntity emitter, ForgeDirection direction) {
  328.                 return true;
  329.         }
  330.  
  331.         @Override
  332.         public double getDemandedEnergy() {
  333.                 return this.maxenergy - this.energy;
  334.         }
  335.  
  336.         @Override
  337.         public int getSinkTier() {
  338.                 return euTier.getTier();
  339.         }
  340.  
  341.         @Override
  342.         public double injectEnergy(ForgeDirection directionFrom, double amount, double voltage) {
  343.                 if (energy == maxenergy) return amount;
  344.                 else if ((energy + amount) > maxenergy) {
  345.                         double tmp = energy + amount;
  346.                         energy = maxenergy;
  347.                         return tmp - maxenergy;
  348.                 } else {
  349.                         energy += amount;
  350.                         return 0;
  351.                 }
  352.         }
  353.  
  354.         @Override
  355.         public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side) {
  356.                 return false;
  357.         }
  358.  
  359.         @Override
  360.         public short getFacing() {
  361.                 return 0;
  362.         }
  363.  
  364.         @Override
  365.         public void setFacing(short facing) {
  366.                
  367.         }
  368.  
  369.         @Override
  370.         public boolean wrenchCanRemove(EntityPlayer entityPlayer) {
  371.                 return true;
  372.         }
  373.  
  374.         @Override
  375.         public float getWrenchDropRate() {
  376.                 return 1;
  377.         }
  378.  
  379.         @Override
  380.         public ItemStack getWrenchDrop(EntityPlayer entityPlayer) {
  381.                 return new ItemStack(VoidBlocks.voidExtractor);
  382.         }
  383.  
  384. }
RAW Paste Data
Ledger Nano X - The secure hardware wallet
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Top