API tools faq
paste
Advertisement
Guest User

BasicFurnaceTile

a guest
May 13th, 2022
66
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 11.99 KB | None | 0 0
raw download clone embed print report
  1. package com.github.will11690.mechanicraft.blocks.machines.basic.basicfurnace;
  2.  
  3. import java.util.Optional;
  4.  
  5. import javax.annotation.Nonnull;
  6. import javax.annotation.Nullable;
  7.  
  8. import com.github.will11690.mechanicraft.energy.MechaniCraftEnergyStorage;
  9. import com.github.will11690.mechanicraft.util.handlers.TileEntityHandler;
  10.  
  11. import net.minecraft.block.BlockState;
  12. import net.minecraft.entity.player.PlayerEntity;
  13. import net.minecraft.entity.player.PlayerInventory;
  14. import net.minecraft.inventory.Inventory;
  15. import net.minecraft.inventory.container.Container;
  16. import net.minecraft.inventory.container.INamedContainerProvider;
  17. import net.minecraft.item.ItemStack;
  18. import net.minecraft.item.crafting.FurnaceRecipe;
  19. import net.minecraft.item.crafting.IRecipeType;
  20. import net.minecraft.item.crafting.RecipeManager;
  21. import net.minecraft.nbt.CompoundNBT;
  22. import net.minecraft.network.NetworkManager;
  23. import net.minecraft.network.play.server.SUpdateTileEntityPacket;
  24. import net.minecraft.tileentity.ITickableTileEntity;
  25. import net.minecraft.tileentity.TileEntity;
  26. import net.minecraft.util.Direction;
  27. import net.minecraft.util.IIntArray;
  28. import net.minecraft.util.text.ITextComponent;
  29. import net.minecraft.util.text.TranslationTextComponent;
  30. import net.minecraft.world.World;
  31. import net.minecraftforge.common.capabilities.Capability;
  32. import net.minecraftforge.common.util.LazyOptional;
  33. import net.minecraftforge.energy.CapabilityEnergy;
  34. import net.minecraftforge.energy.IEnergyStorage;
  35. import net.minecraftforge.items.CapabilityItemHandler;
  36. import net.minecraftforge.items.ItemStackHandler;
  37.  
  38. public class TileEntityBasicFurnace extends TileEntity implements ITickableTileEntity, INamedContainerProvider {
  39.    
  40.     public enum FurnaceSlots {
  41.  
  42.         CHARGE(0),
  43.         INPUT(1),
  44.         OUTPUT(2);
  45.  
  46.         int id;
  47.  
  48.         FurnaceSlots(int number) {
  49.            
  50.             id = number;
  51.            
  52.         }
  53.  
  54.         public int getId() {
  55.            
  56.             return id;
  57.            
  58.         }
  59.     }
  60.  
  61.     private MechaniCraftEnergyStorage energyStorage = createEnergy();
  62.     private BasicFurnaceItemHandler itemHandler = createItem();
  63.  
  64.     private LazyOptional<IEnergyStorage> energy = LazyOptional.of(() -> energyStorage);
  65.     public LazyOptional<ItemStackHandler> inventory  = LazyOptional.of(() -> itemHandler);
  66.  
  67.     private int progress = 0;
  68.  
  69.     static final int WORK_TIME = 10 * 20;
  70.  
  71.     //TODO Create config for energy consumed and working times
  72.  
  73.     private int smeltingEnergy = 20/*PER TICK*/;
  74.  
  75.     static int MAX_ENERGY = 0;
  76.  
  77.     private final IIntArray fields = new IIntArray() {
  78.  
  79.         @Override
  80.         public int get(int index) {
  81.  
  82.             switch (index) {
  83.  
  84.             case 0:
  85.                 return energyStorage.getEnergyStored();
  86.             case 1:
  87.                 return progress;
  88.             default:
  89.                 return 0;
  90.  
  91.             }
  92.         }
  93.  
  94.         @Override
  95.         public void set(int index, int value) {
  96.  
  97.             switch (index) {
  98.  
  99.             case 0:
  100.                 energyStorage.setEnergyStored(value, false);
  101.                 break;
  102.             case 1:
  103.                 progress = value;
  104.                 break;
  105.             default:
  106.                 break;
  107.  
  108.             }
  109.         }
  110.  
  111.         @Override
  112.         public int getCount() {
  113.            
  114.             return 2;
  115.            
  116.         }
  117.     };
  118.  
  119.     public TileEntityBasicFurnace() {
  120.  
  121.         super(TileEntityHandler.TILE_ENTITY_BASIC_FURNACE.get());
  122.  
  123.     }
  124.  
  125.     @Override
  126.     public void tick() {
  127.  
  128.         if (this.level == null || this.level.isClientSide) {
  129.  
  130.             return;
  131.  
  132.         }
  133.  
  134.         if(energyStorage.getMaxEnergyStored() > energyStorage.getEnergyStored()) {
  135.  
  136.             if(!(itemHandler.getStackInSlot(FurnaceSlots.CHARGE.id).equals(ItemStack.EMPTY))) {
  137.  
  138.                 receivePowerItem(itemHandler.getStackInSlot(FurnaceSlots.CHARGE.id));
  139.  
  140.             }
  141.  
  142.             else
  143.  
  144.                 receivePower();
  145.  
  146.         }
  147.  
  148.         if(progress <= 0 && this.level.getBlockState(this.worldPosition).getValue(BasicFurnace.LIT) == true) {
  149.  
  150.             this.level.setBlockAndUpdate(this.worldPosition, this.level.getBlockState(this.worldPosition).setValue(BasicFurnace.LIT, Boolean.valueOf(false)));
  151.  
  152.         }
  153.  
  154.         if(canSmelt()) {
  155.  
  156.             startSmelting();
  157.  
  158.         }
  159.        
  160.         if(itemHandler.getStackInSlot(FurnaceSlots.INPUT.id).equals(ItemStack.EMPTY) && progress > 0) {
  161.  
  162.             progress = 0;
  163.  
  164.         }
  165.  
  166.         if(energyStorage.getEnergyStored() <= 0 && progress > 0) {
  167.  
  168.             progress -= 2;
  169.  
  170.         }
  171.  
  172.         if(progress > 0 && this.level.getBlockState(this.worldPosition).getValue(BasicFurnace.LIT) == false) {
  173.  
  174.             this.level.setBlockAndUpdate(this.worldPosition, this.level.getBlockState(this.worldPosition).setValue(BasicFurnace.LIT, Boolean.valueOf(true)));
  175.  
  176.         }
  177.     }
  178.  
  179.     private MechaniCraftEnergyStorage createEnergy() {
  180.  
  181.         return new MechaniCraftEnergyStorage(100000, 500, 0) {
  182.  
  183.             @Override
  184.             protected void onEnergyChanged() {
  185.  
  186.                 setChanged();
  187.  
  188.             }
  189.         };
  190.     }
  191.  
  192.     private BasicFurnaceItemHandler createItem() {
  193.  
  194.         return new BasicFurnaceItemHandler(this) {
  195.  
  196.             @Override
  197.             public boolean isItemValid(int slot, @Nonnull ItemStack stack) {
  198.  
  199.                 Optional<FurnaceRecipe> recipe = getRecipeForInput(level, stack);
  200.  
  201.                 if(slot == TileEntityBasicFurnace.FurnaceSlots.INPUT.getId() && recipe.isPresent() && !(ItemStack.matches(getResultForItem(level, stack), stack))) {
  202.  
  203.                     return true;
  204.  
  205.                 }
  206.  
  207.                 if(slot == TileEntityBasicFurnace.FurnaceSlots.OUTPUT.getId()) {
  208.  
  209.                     return false;
  210.  
  211.                 }
  212.  
  213.                 if(slot == TileEntityBasicFurnace.FurnaceSlots.CHARGE.getId() && stack.getCapability(CapabilityEnergy.ENERGY).isPresent()) {
  214.  
  215.                     return true;
  216.  
  217.                 }
  218.  
  219.                 return false;
  220.             }
  221.         };
  222.     }
  223.  
  224.     //FOR GUI SYNC
  225.     private int setMaxEnergy() {
  226.  
  227.         return MAX_ENERGY = energyStorage.getMaxEnergyStored();
  228.  
  229.     }
  230.  
  231.     private boolean canSmelt() {
  232.  
  233.         ItemStack input = itemHandler.getStackInSlot(FurnaceSlots.INPUT.id);
  234.         ItemStack output = itemHandler.getStackInSlot(FurnaceSlots.OUTPUT.id);
  235.  
  236.         ItemStack result = getResultForItem(level, input);
  237.  
  238.         if(energyStorage.getEnergyStored() >= smeltingEnergy) {
  239.  
  240.             if (result.isEmpty() || input.isEmpty()) {
  241.  
  242.                 setMaxEnergy();
  243.                 return false;
  244.  
  245.             }
  246.  
  247.             if ((output.getCount() + result.getCount()) > output.getMaxStackSize()) {
  248.  
  249.                 setMaxEnergy();
  250.                 return false;
  251.  
  252.             }
  253.  
  254.             if (output.isEmpty() || output.getItem().equals(result.getItem())) {
  255.  
  256.                 setMaxEnergy();
  257.                 return true;
  258.  
  259.             }
  260.  
  261.             return false;
  262.  
  263.         }
  264.  
  265.         else return false;
  266.  
  267.     }
  268.  
  269.     private void startSmelting() {
  270.  
  271.         ItemStack input = itemHandler.getStackInSlot(FurnaceSlots.INPUT.id);
  272.         ItemStack output = itemHandler.getStackInSlot(FurnaceSlots.OUTPUT.id);
  273.  
  274.         ItemStack result = getResultForItem(level, input);
  275.  
  276.         if(canSmelt()) {
  277.  
  278.             if(progress < WORK_TIME) {
  279.  
  280.                 ++progress;
  281.                 energyStorage.consumeEnergy(smeltingEnergy);
  282.  
  283.             }
  284.  
  285.             if (progress >= WORK_TIME) {
  286.  
  287.                 if(output.isEmpty()) {
  288.  
  289.                     itemHandler.setStackInSlot(FurnaceSlots.OUTPUT.id, result.copy());
  290.                     progress = 0;
  291.                     itemHandler.extractItem(FurnaceSlots.INPUT.id, 1, false);
  292.  
  293.                 } else {
  294.  
  295.                     if(output.getItem().equals(result.getItem()) && output.getCount() < result.getMaxStackSize()) {
  296.  
  297.                         output.grow(result.getCount());
  298.                         progress = 0;
  299.                         itemHandler.extractItem(FurnaceSlots.INPUT.id, 1, false);
  300.  
  301.                     }
  302.                 }
  303.             }
  304.         }
  305.     }
  306.  
  307.     public static Optional<FurnaceRecipe> getRecipeForInput(World world, ItemStack itemStack) {
  308.  
  309.         RecipeManager recipeManager = world.getRecipeManager();
  310.         Inventory singleItemInventory = new Inventory(itemStack);
  311.  
  312.         Optional<FurnaceRecipe> recipe = recipeManager.getRecipeFor(IRecipeType.SMELTING, singleItemInventory, world);
  313.  
  314.         return recipe;
  315.  
  316.     }
  317.  
  318.     public static ItemStack getResultForItem(World world, ItemStack itemStack) {
  319.  
  320.         Optional<FurnaceRecipe> recipe = getRecipeForInput(world, itemStack);
  321.         if (!recipe.isPresent()) return ItemStack.EMPTY;
  322.  
  323.         return recipe.get().getResultItem().copy();
  324.  
  325.     }
  326.  
  327.     private void receivePower() {
  328.  
  329.         if (energyStorage.getEnergyStored() <= 0 || energyStorage.getMaxEnergyStored() > energyStorage.getEnergyStored()) {
  330.  
  331.             for (Direction direction : Direction.values()) {
  332.  
  333.                 TileEntity te = level.getBlockEntity(worldPosition.relative(direction));
  334.  
  335.                 if (te != null) {
  336.  
  337.                     this.getCapability(CapabilityEnergy.ENERGY).ifPresent(energyStorage -> te.getCapability(CapabilityEnergy.ENERGY).ifPresent(tileEnergy -> {
  338.  
  339.                         if(!isEnergyBlock(tileEnergy) || tileEnergy.getEnergyStored() <= 0 || energyStorage.getEnergyStored() == energyStorage.getMaxEnergyStored()) {
  340.  
  341.                             return;
  342.  
  343.                         } else {
  344.  
  345.                             if(tileEnergy.getEnergyStored() < this.energyStorage.getMaxReceive()) {
  346.  
  347.                                 int energyToReceive = tileEnergy.extractEnergy(Math.min(energyStorage.getMaxEnergyStored() - energyStorage.getEnergyStored(), tileEnergy.getEnergyStored()), true);
  348.                                 tileEnergy.extractEnergy(energyToReceive, false);
  349.                                 this.energyStorage.receiveEnergy(energyToReceive, false);
  350.  
  351.                             } else {
  352.  
  353.                                 int energyToReceive = tileEnergy.extractEnergy(Math.min(energyStorage.getMaxEnergyStored() - energyStorage.getEnergyStored(), this.energyStorage.getMaxReceive()), true);
  354.                                 tileEnergy.extractEnergy(energyToReceive, false);
  355.                                 this.energyStorage.receiveEnergy(energyToReceive, false);
  356.  
  357.                             }
  358.                         }
  359.                     }));
  360.                 }
  361.             }
  362.         }
  363.     }
  364.  
  365.     private void receivePowerItem(ItemStack stack) {
  366.  
  367.         //TODO Figure out why items not powering machine
  368.  
  369.         this.getCapability(CapabilityEnergy.ENERGY).ifPresent(energyStorage -> stack.getCapability(CapabilityEnergy.ENERGY).ifPresent(itemEnergy -> {
  370.  
  371.             if(!isEnergyItem(itemEnergy) || itemEnergy.getEnergyStored() <= 0 || energyStorage.getEnergyStored() == energyStorage.getMaxEnergyStored()) {
  372.  
  373.                 return;
  374.  
  375.             } else {
  376.  
  377.                 int energyToReceive = itemEnergy.extractEnergy(Math.min(energyStorage.getMaxEnergyStored() - energyStorage.getEnergyStored(), this.energyStorage.getMaxExtract()), true);
  378.                 itemEnergy.extractEnergy(energyToReceive, false);
  379.                 this.energyStorage.receiveEnergy(energyToReceive, false);
  380.  
  381.             }
  382.         }));
  383.     }
  384.  
  385.     private boolean isEnergyItem(IEnergyStorage itemEnergy) {
  386.  
  387.         return itemEnergy.getEnergyStored() >= 0 && itemEnergy.extractEnergy(itemEnergy.getEnergyStored(), true) >= 0;
  388.  
  389.     }
  390.  
  391.     private boolean isEnergyBlock(IEnergyStorage blockEnergy) {
  392.  
  393.         return blockEnergy.getEnergyStored() >= 0 && blockEnergy.extractEnergy(blockEnergy.getEnergyStored(), true) >= 0;
  394.  
  395.     }
  396.  
  397.     @Nullable
  398.     @Override
  399.     public Container createMenu(int id, PlayerInventory playerInventory, PlayerEntity playerEntity) {
  400.  
  401.         assert level != null;
  402.         return new ContainerBasicFurnace(this, this.fields, id, playerInventory, this.inventory.orElse(new ItemStackHandler(3)));
  403.  
  404.     }
  405.  
  406.     @Override
  407.     public void load(BlockState state, CompoundNBT tags) {
  408.  
  409.         super.load(state, tags);
  410.         this.progress = tags.getInt("Progress");
  411.         this.energyStorage.deserializeNBT(tags.getCompound("energy"));
  412.         inventory.ifPresent(h -> h.deserializeNBT(tags.getCompound("items")));
  413.  
  414.     }
  415.  
  416.     @Override
  417.     public CompoundNBT save(CompoundNBT tags) {
  418.  
  419.         super.save(tags);
  420.         tags.putInt("Progress", this.progress);
  421.         tags.put("energy", energyStorage.serializeNBT());
  422.         inventory.ifPresent(h ->  tags.put("items", h.serializeNBT()));
  423.         return tags;
  424.  
  425. }
  426.  
  427.     @Nullable
  428.     @Override
  429.     public SUpdateTileEntityPacket getUpdatePacket() {
  430.  
  431.         CompoundNBT tags = this.getUpdateTag();
  432.         return new SUpdateTileEntityPacket(this.worldPosition, 1, tags);
  433.  
  434.     }
  435.  
  436.     @Override
  437.     public CompoundNBT getUpdateTag() {
  438.  
  439.         return save(new CompoundNBT());
  440.  
  441.     }
  442.  
  443.     @Override
  444.     public void handleUpdateTag(BlockState stateIn, CompoundNBT tag) {
  445.  
  446.         load(stateIn, tag);
  447.  
  448.     }
  449.  
  450.     @Override
  451.     public void onDataPacket(NetworkManager net, SUpdateTileEntityPacket pkt) {
  452.  
  453.         load(this.getBlockState(), pkt.getTag());
  454.  
  455.     }
  456.  
  457.     @Nullable
  458.     @Override
  459.     public <T> LazyOptional<T> getCapability(Capability<T> cap, @Nullable Direction side) {
  460.  
  461.         if (!this.remove && side != null) {
  462.  
  463.             if (cap == CapabilityEnergy.ENERGY) {
  464.  
  465.                 return energy.cast();
  466.  
  467.             }
  468.  
  469.             if (cap == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY) {
  470.  
  471.                 return inventory.cast();
  472.  
  473.             }
  474.         }
  475.  
  476.         return super.getCapability(cap, side);
  477.        
  478.     }
  479.  
  480.     @Override
  481.     public void setRemoved() {
  482.  
  483.         energy.invalidate();
  484.         inventory.invalidate();
  485.         super.setRemoved();
  486.  
  487.     }
  488.  
  489.     @Override
  490.     public ITextComponent getDisplayName() {
  491.  
  492.         return new TranslationTextComponent("container.mechanicraft.basic_furnace");
  493.  
  494.     }
  495. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!