ActuallyAdditions/src/main/java/de/ellpeck/actuallyadditions/mod/tile/TileEntityGrinder.java

288 lines
12 KiB
Java
Raw Normal View History

2015-08-29 14:33:25 +02:00
/*
2016-05-16 22:52:27 +02:00
* This file ("TileEntityGrinder.java") is part of the Actually Additions mod for Minecraft.
2015-08-29 14:33:25 +02:00
* It is created and owned by Ellpeck and distributed
* under the Actually Additions License to be found at
2016-05-16 22:52:27 +02:00
* http://ellpeck.de/actaddlicense
2015-08-29 14:33:25 +02:00
* View the source code at https://github.com/Ellpeck/ActuallyAdditions
*
2017-01-01 16:23:26 +01:00
* © 2015-2017 Ellpeck
2015-08-29 14:33:25 +02:00
*/
2016-01-05 04:47:35 +01:00
package de.ellpeck.actuallyadditions.mod.tile;
import de.ellpeck.actuallyadditions.api.recipe.CrusherRecipe;
import de.ellpeck.actuallyadditions.mod.blocks.BlockFurnaceDouble;
import de.ellpeck.actuallyadditions.mod.inventory.ContainerGrinder;
2016-12-06 18:10:43 +01:00
import de.ellpeck.actuallyadditions.mod.misc.SoundHandler;
import de.ellpeck.actuallyadditions.mod.network.gui.IButtonReactor;
2016-01-05 04:47:35 +01:00
import de.ellpeck.actuallyadditions.mod.recipe.CrusherRecipeRegistry;
2018-08-10 05:04:07 +02:00
import de.ellpeck.actuallyadditions.mod.util.ItemStackHandlerAA.IAcceptor;
import de.ellpeck.actuallyadditions.mod.util.ItemStackHandlerAA.IRemover;
import de.ellpeck.actuallyadditions.mod.util.StackUtil;
2016-01-05 04:47:35 +01:00
import de.ellpeck.actuallyadditions.mod.util.Util;
import net.minecraft.block.BlockState;
2021-02-26 22:15:48 +01:00
import net.minecraft.entity.player.PlayerEntity;
import net.minecraft.entity.player.PlayerInventory;
import net.minecraft.inventory.container.Container;
import net.minecraft.inventory.container.INamedContainerProvider;
import net.minecraft.item.ItemStack;
2021-02-26 22:15:48 +01:00
import net.minecraft.nbt.CompoundNBT;
import net.minecraft.tileentity.TileEntityType;
import net.minecraft.util.Direction;
2016-05-01 22:26:26 +02:00
import net.minecraft.util.SoundCategory;
import net.minecraft.util.text.ITextComponent;
import net.minecraft.util.text.StringTextComponent;
import net.minecraftforge.common.util.LazyOptional;
2016-11-26 08:58:42 +01:00
import net.minecraftforge.energy.IEnergyStorage;
import javax.annotation.Nullable;
public class TileEntityGrinder extends TileEntityInventoryBase implements IButtonReactor, INamedContainerProvider {
2015-05-20 22:39:43 +02:00
2015-10-03 10:16:18 +02:00
public static final int SLOT_INPUT_1 = 0;
public static final int SLOT_OUTPUT_1_1 = 1;
public static final int SLOT_OUTPUT_1_2 = 2;
public static final int SLOT_INPUT_2 = 3;
public static final int SLOT_OUTPUT_2_1 = 4;
public static final int SLOT_OUTPUT_2_2 = 5;
public static final int ENERGY_USE = 40;
2016-11-26 20:43:50 +01:00
public final CustomEnergyStorage storage = new CustomEnergyStorage(60000, 100, 0);
public final LazyOptional<IEnergyStorage> lazyEnergy = LazyOptional.of(() -> this.storage);
2015-10-03 10:16:18 +02:00
public int firstCrushTime;
public int secondCrushTime;
public boolean isDouble;
2016-09-12 20:45:29 +02:00
public boolean isAutoSplit;
private int lastEnergy;
2015-10-03 10:16:18 +02:00
private int lastFirstCrush;
private int lastSecondCrush;
private boolean lastAutoSplit;
private boolean lastCrushed;
public TileEntityGrinder(TileEntityType<?> type, int slots) {
super(type, slots);
2015-10-03 10:16:18 +02:00
}
2015-10-03 10:19:40 +02:00
2018-08-10 05:04:07 +02:00
public TileEntityGrinder() {
super(ActuallyTiles.GRINDER_TILE.get(), 3);
2015-10-03 10:16:18 +02:00
this.isDouble = false;
}
2015-05-20 22:39:43 +02:00
@Override
2021-02-26 22:15:48 +01:00
public void writeSyncableNBT(CompoundNBT compound, NBTType type) {
2018-08-10 05:04:07 +02:00
if (type != NBTType.SAVE_BLOCK) {
compound.putInt("FirstCrushTime", this.firstCrushTime);
compound.putInt("SecondCrushTime", this.secondCrushTime);
compound.putBoolean("IsAutoSplit", this.isAutoSplit);
}
this.storage.writeToNBT(compound);
super.writeSyncableNBT(compound, type);
}
@Override
2021-02-26 22:15:48 +01:00
public void readSyncableNBT(CompoundNBT compound, NBTType type) {
2018-08-10 05:04:07 +02:00
if (type != NBTType.SAVE_BLOCK) {
this.firstCrushTime = compound.getInt("FirstCrushTime");
this.secondCrushTime = compound.getInt("SecondCrushTime");
this.isAutoSplit = compound.getBoolean("IsAutoSplit");
}
this.storage.readFromNBT(compound);
super.readSyncableNBT(compound, type);
}
@Override
2018-08-10 05:04:07 +02:00
public void updateEntity() {
super.updateEntity();
2018-08-10 05:04:07 +02:00
if (!this.world.isRemote) {
if (this.isDouble && this.isAutoSplit) {
TileEntityFurnaceDouble.autoSplit(this.inv, SLOT_INPUT_1, SLOT_INPUT_2);
}
boolean crushed = false;
2015-06-21 02:28:49 +02:00
boolean canCrushOnFirst = this.canCrushOn(SLOT_INPUT_1, SLOT_OUTPUT_1_1, SLOT_OUTPUT_1_2);
boolean canCrushOnSecond = false;
2018-08-10 05:04:07 +02:00
if (this.isDouble) {
2015-10-03 10:16:18 +02:00
canCrushOnSecond = this.canCrushOn(SLOT_INPUT_2, SLOT_OUTPUT_2_1, SLOT_OUTPUT_2_2);
}
boolean shouldPlaySound = false;
2018-08-10 05:04:07 +02:00
if (canCrushOnFirst) {
if (this.storage.getEnergyStored() >= ENERGY_USE) {
if (this.firstCrushTime % 20 == 0) {
shouldPlaySound = true;
}
this.firstCrushTime++;
2018-08-10 05:04:07 +02:00
if (this.firstCrushTime >= this.getMaxCrushTime()) {
this.finishCrushing(SLOT_INPUT_1, SLOT_OUTPUT_1_1, SLOT_OUTPUT_1_2);
this.firstCrushTime = 0;
}
this.storage.extractEnergyInternal(ENERGY_USE, false);
}
2019-02-27 19:53:05 +01:00
crushed = this.storage.getEnergyStored() >= ENERGY_USE;
2018-08-10 05:04:07 +02:00
} else {
2015-10-02 16:48:01 +02:00
this.firstCrushTime = 0;
}
2018-08-10 05:04:07 +02:00
if (this.isDouble) {
if (canCrushOnSecond) {
if (this.storage.getEnergyStored() >= ENERGY_USE) {
if (this.secondCrushTime % 20 == 0) {
shouldPlaySound = true;
}
this.secondCrushTime++;
2018-08-10 05:04:07 +02:00
if (this.secondCrushTime >= this.getMaxCrushTime()) {
this.finishCrushing(SLOT_INPUT_2, SLOT_OUTPUT_2_1, SLOT_OUTPUT_2_2);
this.secondCrushTime = 0;
}
this.storage.extractEnergyInternal(ENERGY_USE, false);
}
2019-02-27 19:53:05 +01:00
crushed = this.storage.getEnergyStored() >= ENERGY_USE;
2018-08-10 05:04:07 +02:00
} else {
2015-10-02 16:48:01 +02:00
this.secondCrushTime = 0;
}
}
2021-02-26 22:15:48 +01:00
BlockState currState = this.world.getBlockState(this.pos);
boolean current = currState.get(BlockFurnaceDouble.IS_ON);
2019-03-03 23:09:59 +01:00
boolean changeTo = current;
2021-02-26 22:15:48 +01:00
if (this.lastCrushed != crushed) {
changeTo = crushed;
}
if (this.isRedstonePowered) {
changeTo = true;
}
if (!crushed && !this.isRedstonePowered) {
changeTo = false;
}
2019-03-03 23:09:59 +01:00
if (changeTo != current) {
this.world.setBlockState(this.pos, currState.with(BlockFurnaceDouble.IS_ON, changeTo));
}
2019-03-03 23:09:59 +01:00
this.lastCrushed = crushed;
2018-08-10 05:04:07 +02:00
if ((this.lastEnergy != this.storage.getEnergyStored() || this.lastFirstCrush != this.firstCrushTime || this.lastSecondCrush != this.secondCrushTime || this.isAutoSplit != this.lastAutoSplit) && this.sendUpdateWithInterval()) {
this.lastEnergy = this.storage.getEnergyStored();
this.lastFirstCrush = this.firstCrushTime;
this.lastSecondCrush = this.secondCrushTime;
this.lastAutoSplit = this.isAutoSplit;
}
2018-08-10 05:04:07 +02:00
if (shouldPlaySound) {
this.world.playSound(null, this.getPos().getX(), this.getPos().getY(), this.getPos().getZ(), SoundHandler.crusher, SoundCategory.BLOCKS, 0.025F, 1.0F);
}
}
}
2016-02-01 17:49:55 +01:00
@Override
2018-08-10 05:04:07 +02:00
public IAcceptor getAcceptor() {
2019-02-27 19:53:05 +01:00
return (slot, stack, automation) -> !automation || (slot == SLOT_INPUT_1 || slot == SLOT_INPUT_2) && CrusherRecipeRegistry.getRecipeFromInput(stack) != null;
2018-08-10 05:04:07 +02:00
}
@Override
public IRemover getRemover() {
2019-02-27 19:53:05 +01:00
return (slot, automation) -> !automation || slot == SLOT_OUTPUT_1_1 || slot == SLOT_OUTPUT_1_2 || slot == SLOT_OUTPUT_2_1 || slot == SLOT_OUTPUT_2_2;
2016-02-01 17:49:55 +01:00
}
2018-08-10 05:04:07 +02:00
public boolean canCrushOn(int theInput, int theFirstOutput, int theSecondOutput) {
if (StackUtil.isValid(this.inv.getStackInSlot(theInput))) {
2019-02-27 19:53:05 +01:00
CrusherRecipe recipe = CrusherRecipeRegistry.getRecipeFromInput(this.inv.getStackInSlot(theInput));
2021-02-26 22:15:48 +01:00
if (recipe == null) {
return false;
}
ItemStack outputOne = recipe.getOutputOne();
ItemStack outputTwo = recipe.getOutputTwo();
2018-08-10 05:04:07 +02:00
if (StackUtil.isValid(outputOne)) {
if (outputOne.getDamage() == Util.WILDCARD) {
outputOne.setDamage(0);
}
if (StackUtil.isValid(outputTwo) && outputTwo.getDamage() == Util.WILDCARD) {
outputTwo.setDamage(0);
}
2021-02-26 22:15:48 +01:00
if ((!StackUtil.isValid(this.inv.getStackInSlot(theFirstOutput)) || this.inv.getStackInSlot(theFirstOutput).isItemEqual(outputOne) && this.inv.getStackInSlot(theFirstOutput).getCount() <= this.inv.getStackInSlot(theFirstOutput).getMaxStackSize() - outputOne.getCount()) && (!StackUtil.isValid(outputTwo) || !StackUtil.isValid(this.inv.getStackInSlot(theSecondOutput)) || this.inv.getStackInSlot(theSecondOutput).isItemEqual(outputTwo) && this.inv.getStackInSlot(theSecondOutput).getCount() <= this.inv.getStackInSlot(theSecondOutput).getMaxStackSize() - outputTwo.getCount())) {
return true;
}
}
}
return false;
}
2018-08-10 05:04:07 +02:00
private int getMaxCrushTime() {
2021-02-26 22:15:48 +01:00
return this.isDouble
? 150
: 100;
2015-10-03 10:19:40 +02:00
}
2018-08-10 05:04:07 +02:00
public void finishCrushing(int theInput, int theFirstOutput, int theSecondOutput) {
2019-02-27 19:53:05 +01:00
CrusherRecipe recipe = CrusherRecipeRegistry.getRecipeFromInput(this.inv.getStackInSlot(theInput));
2021-02-26 22:15:48 +01:00
if (recipe == null) {
return;
}
ItemStack outputOne = recipe.getOutputOne();
2018-08-10 05:04:07 +02:00
if (StackUtil.isValid(outputOne)) {
if (outputOne.getDamage() == Util.WILDCARD) {
outputOne.setDamage(0);
}
2018-08-10 05:04:07 +02:00
if (!StackUtil.isValid(this.inv.getStackInSlot(theFirstOutput))) {
this.inv.setStackInSlot(theFirstOutput, outputOne.copy());
2018-08-10 05:04:07 +02:00
} else if (this.inv.getStackInSlot(theFirstOutput).getItem() == outputOne.getItem()) {
this.inv.setStackInSlot(theFirstOutput, StackUtil.grow(this.inv.getStackInSlot(theFirstOutput), outputOne.getCount()));
2015-10-02 16:48:01 +02:00
}
2015-06-21 02:28:49 +02:00
}
ItemStack outputTwo = recipe.getOutputTwo();
2018-08-10 05:04:07 +02:00
if (StackUtil.isValid(outputTwo)) {
if (outputTwo.getDamage() == Util.WILDCARD) {
outputTwo.setDamage(0);
}
2018-08-10 05:04:07 +02:00
int rand = this.world.rand.nextInt(100) + 1;
if (rand <= recipe.getSecondChance()) {
if (!StackUtil.isValid(this.inv.getStackInSlot(theSecondOutput))) {
this.inv.setStackInSlot(theSecondOutput, outputTwo.copy());
2018-08-10 05:04:07 +02:00
} else if (this.inv.getStackInSlot(theSecondOutput).getItem() == outputTwo.getItem()) {
this.inv.setStackInSlot(theSecondOutput, StackUtil.grow(this.inv.getStackInSlot(theSecondOutput), outputTwo.getCount()));
2015-10-02 16:48:01 +02:00
}
}
}
2018-08-10 05:04:07 +02:00
this.inv.getStackInSlot(theInput).shrink(1);
}
2018-08-10 05:04:07 +02:00
public int getEnergyScaled(int i) {
return this.storage.getEnergyStored() * i / this.storage.getMaxEnergyStored();
}
2018-08-10 05:04:07 +02:00
public int getFirstTimeToScale(int i) {
return this.firstCrushTime * i / this.getMaxCrushTime();
}
2018-08-10 05:04:07 +02:00
public int getSecondTimeToScale(int i) {
return this.secondCrushTime * i / this.getMaxCrushTime();
2015-04-02 12:06:42 +02:00
}
2015-10-03 10:16:18 +02:00
@Override
2021-02-26 22:15:48 +01:00
public void onButtonPressed(int buttonID, PlayerEntity player) {
2018-08-10 05:04:07 +02:00
if (buttonID == 0) {
this.isAutoSplit = !this.isAutoSplit;
this.markDirty();
}
}
2016-11-26 08:58:42 +01:00
@Override
public LazyOptional<IEnergyStorage> getEnergyStorage(Direction facing) {
return this.lazyEnergy;
2016-11-26 08:58:42 +01:00
}
@Override
public ITextComponent getDisplayName() {
return StringTextComponent.EMPTY;
}
@Nullable
@Override
public Container createMenu(int windowId, PlayerInventory playerInventory, PlayerEntity player) {
return new ContainerGrinder(windowId, playerInventory, this);
}
}