Merge remote-tracking branch 'origin/1.16' into 1.16
# Conflicts: # src/main/java/techreborn/init/TRContent.java
This commit is contained in:
commit
18a08b798e
235 changed files with 3995 additions and 3065 deletions
|
@ -38,10 +38,9 @@ import reborncore.common.util.RebornInventory;
|
|||
|
||||
/**
|
||||
* @author drcrazy
|
||||
*
|
||||
*/
|
||||
public abstract class GenericMachineBlockEntity extends PowerAcceptorBlockEntity
|
||||
implements IToolDrop, InventoryProvider, IRecipeCrafterProvider{
|
||||
implements IToolDrop, InventoryProvider, IRecipeCrafterProvider {
|
||||
|
||||
public String name;
|
||||
public int maxInput;
|
||||
|
@ -50,12 +49,12 @@ public abstract class GenericMachineBlockEntity extends PowerAcceptorBlockEntity
|
|||
public int energySlot;
|
||||
public RebornInventory<?> inventory;
|
||||
public RecipeCrafter crafter;
|
||||
|
||||
|
||||
/**
|
||||
* @param name String Name for a blockEntity. Do we need it at all?
|
||||
* @param maxInput int Maximum energy input, value in EU
|
||||
* @param maxEnergy int Maximum energy buffer, value in EU
|
||||
* @param toolDrop Block Block to drop with wrench
|
||||
* @param name String Name for a blockEntity. Do we need it at all?
|
||||
* @param maxInput int Maximum energy input, value in EU
|
||||
* @param maxEnergy int Maximum energy buffer, value in EU
|
||||
* @param toolDrop Block Block to drop with wrench
|
||||
* @param energySlot int Energy slot to use to charge machine from battery
|
||||
*/
|
||||
public GenericMachineBlockEntity(BlockEntityType<?> blockEntityType, String name, int maxInput, int maxEnergy, Block toolDrop, int energySlot) {
|
||||
|
@ -67,7 +66,7 @@ public abstract class GenericMachineBlockEntity extends PowerAcceptorBlockEntity
|
|||
this.energySlot = energySlot;
|
||||
checkTier();
|
||||
}
|
||||
|
||||
|
||||
public int getProgressScaled(int scale) {
|
||||
if (crafter != null && crafter.currentTickTime != 0) {
|
||||
return crafter.currentTickTime * scale / crafter.currentNeededTicks;
|
||||
|
@ -79,11 +78,11 @@ public abstract class GenericMachineBlockEntity extends PowerAcceptorBlockEntity
|
|||
@Override
|
||||
public void tick() {
|
||||
super.tick();
|
||||
if (!world.isClient) {
|
||||
if (!world.isClient && energySlot != -1) {
|
||||
charge(energySlot);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public double getBaseMaxPower() {
|
||||
return maxEnergy;
|
||||
|
@ -108,19 +107,19 @@ public abstract class GenericMachineBlockEntity extends PowerAcceptorBlockEntity
|
|||
public double getBaseMaxInput() {
|
||||
return maxInput;
|
||||
}
|
||||
|
||||
|
||||
// IToolDrop
|
||||
@Override
|
||||
public ItemStack getToolDrop(PlayerEntity p0) {
|
||||
return new ItemStack(toolDrop, 1);
|
||||
}
|
||||
|
||||
|
||||
// InventoryProvider
|
||||
@Override
|
||||
public RebornInventory<?> getInventory() {
|
||||
return inventory;
|
||||
}
|
||||
|
||||
|
||||
// IRecipeCrafterProvider
|
||||
@Override
|
||||
public RecipeCrafter getRecipeCrafter() {
|
||||
|
|
|
@ -57,9 +57,10 @@ public abstract class AbstractIronMachineBlockEntity extends MachineBaseBlockEnt
|
|||
this.totalCookingTime = (int) (200 / TechRebornConfig.cookingScale);
|
||||
this.toolDrop = toolDrop;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Checks that we have all inputs and can put output into slot
|
||||
*
|
||||
* @return
|
||||
*/
|
||||
protected abstract boolean canSmelt();
|
||||
|
@ -73,6 +74,7 @@ public abstract class AbstractIronMachineBlockEntity extends MachineBaseBlockEnt
|
|||
/**
|
||||
* Returns the number of ticks that the supplied fuel item will keep the
|
||||
* furnace burning, or 0 if the item isn't fuel
|
||||
*
|
||||
* @param stack Itemstack of fuel
|
||||
* @return Integer Number of ticks
|
||||
*/
|
||||
|
@ -82,11 +84,12 @@ public abstract class AbstractIronMachineBlockEntity extends MachineBaseBlockEnt
|
|||
}
|
||||
return (int) (AbstractFurnaceBlockEntity.createFuelTimeMap().getOrDefault(stack.getItem(), 0) * TechRebornConfig.fuelScale);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns remaining fraction of fuel burn time
|
||||
* Returns remaining fraction of fuel burn time
|
||||
*
|
||||
* @param scale Scale to use for burn time
|
||||
* @return int scaled remaining fuel burn time
|
||||
* @return int scaled remaining fuel burn time
|
||||
*/
|
||||
public int getBurnTimeRemainingScaled(int scale) {
|
||||
if (totalBurnTime == 0) {
|
||||
|
@ -95,11 +98,12 @@ public abstract class AbstractIronMachineBlockEntity extends MachineBaseBlockEnt
|
|||
|
||||
return burnTime * scale / totalBurnTime;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns crafting progress
|
||||
* Returns crafting progress
|
||||
*
|
||||
* @param scale Scale to use for crafting progress
|
||||
* @return int Scaled crafting progress
|
||||
* @return int Scaled crafting progress
|
||||
*/
|
||||
public int getProgressScaled(int scale) {
|
||||
if (totalCookingTime > 0) {
|
||||
|
@ -110,6 +114,7 @@ public abstract class AbstractIronMachineBlockEntity extends MachineBaseBlockEnt
|
|||
|
||||
/**
|
||||
* Returns true if Iron Machine is burning fuel thus can do work
|
||||
*
|
||||
* @return Boolean True if machine is burning
|
||||
*/
|
||||
public boolean isBurning() {
|
||||
|
@ -136,24 +141,24 @@ public abstract class AbstractIronMachineBlockEntity extends MachineBaseBlockEnt
|
|||
|
||||
@Override
|
||||
public CompoundTag toTag(CompoundTag compoundTag) {
|
||||
super.toTag(compoundTag);
|
||||
compoundTag.putInt("BurnTime", burnTime);
|
||||
compoundTag.putInt("TotalBurnTime", totalBurnTime);
|
||||
compoundTag.putInt("Progress", progress);
|
||||
return compoundTag;
|
||||
super.toTag(compoundTag);
|
||||
compoundTag.putInt("BurnTime", burnTime);
|
||||
compoundTag.putInt("TotalBurnTime", totalBurnTime);
|
||||
compoundTag.putInt("Progress", progress);
|
||||
return compoundTag;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void tick() {
|
||||
super.tick();
|
||||
if(world.isClient){
|
||||
if (world.isClient) {
|
||||
return;
|
||||
}
|
||||
boolean isBurning = isBurning();
|
||||
if (isBurning) {
|
||||
--burnTime;
|
||||
}
|
||||
|
||||
|
||||
if (!isBurning && canSmelt()) {
|
||||
burnTime = totalBurnTime = getItemBurnTime(inventory.getStack(fuelSlot));
|
||||
if (burnTime > 0) {
|
||||
|
@ -168,17 +173,17 @@ public abstract class AbstractIronMachineBlockEntity extends MachineBaseBlockEnt
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (isBurning() && canSmelt()) {
|
||||
++progress;
|
||||
if (progress == totalCookingTime) {
|
||||
progress = 0;
|
||||
smelt();
|
||||
}
|
||||
} else if(!canSmelt()) {
|
||||
} else if (!canSmelt()) {
|
||||
progress = 0;
|
||||
}
|
||||
|
||||
|
||||
if (isBurning != isBurning()) {
|
||||
inventory.setChanged();
|
||||
updateState();
|
||||
|
@ -198,7 +203,7 @@ public abstract class AbstractIronMachineBlockEntity extends MachineBaseBlockEnt
|
|||
public RebornInventory<?> getInventory() {
|
||||
return inventory;
|
||||
}
|
||||
|
||||
|
||||
// IToolDrop
|
||||
@Override
|
||||
public ItemStack getToolDrop(PlayerEntity entityPlayer) {
|
||||
|
@ -220,7 +225,7 @@ public abstract class AbstractIronMachineBlockEntity extends MachineBaseBlockEnt
|
|||
public void setTotalBurnTime(int totalBurnTime) {
|
||||
this.totalBurnTime = totalBurnTime;
|
||||
}
|
||||
|
||||
|
||||
public int getProgress() {
|
||||
return progress;
|
||||
}
|
||||
|
|
|
@ -36,7 +36,7 @@ import techreborn.init.ModRecipes;
|
|||
import techreborn.init.TRBlockEntities;
|
||||
import techreborn.init.TRContent;
|
||||
|
||||
public class IronAlloyFurnaceBlockEntity extends AbstractIronMachineBlockEntity implements BuiltScreenHandlerProvider {
|
||||
public class IronAlloyFurnaceBlockEntity extends AbstractIronMachineBlockEntity implements BuiltScreenHandlerProvider {
|
||||
|
||||
int input1 = 0;
|
||||
int input2 = 1;
|
||||
|
@ -84,7 +84,7 @@ public class IronAlloyFurnaceBlockEntity extends AbstractIronMachineBlockEntity
|
|||
if (!inventory.getStack(output).isItemEqualIgnoreDamage(itemstack))
|
||||
return false;
|
||||
int result = inventory.getStack(output).getCount() + itemstack.getCount();
|
||||
return result <= inventory.getStackLimit() && result <= inventory.getStack(output).getMaxCount();
|
||||
return result <= inventory.getStackLimit() && result <= inventory.getStack(output).getMaxCount();
|
||||
}
|
||||
|
||||
@Override
|
||||
|
@ -121,28 +121,28 @@ public class IronAlloyFurnaceBlockEntity extends AbstractIronMachineBlockEntity
|
|||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public BuiltScreenHandler createScreenHandler(int syncID, final PlayerEntity player) {
|
||||
return new ScreenHandlerBuilder("alloyfurnace").player(player.inventory).inventory().hotbar()
|
||||
.addInventory().blockEntity(this)
|
||||
.slot(0, 47, 17)
|
||||
.slot(1, 65, 17)
|
||||
.outputSlot(2, 116, 35).fuelSlot(3, 56, 53)
|
||||
.sync(this::getBurnTime, this::setBurnTime)
|
||||
.sync(this::getProgress, this::setProgress)
|
||||
.sync(this::getTotalBurnTime, this::setTotalBurnTime)
|
||||
.addInventory().create(this, syncID);
|
||||
.addInventory().blockEntity(this)
|
||||
.slot(0, 47, 17)
|
||||
.slot(1, 65, 17)
|
||||
.outputSlot(2, 116, 35).fuelSlot(3, 56, 53)
|
||||
.sync(this::getBurnTime, this::setBurnTime)
|
||||
.sync(this::getProgress, this::setProgress)
|
||||
.sync(this::getTotalBurnTime, this::setTotalBurnTime)
|
||||
.addInventory().create(this, syncID);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isStackValid(int slotID, ItemStack stack) {
|
||||
return ModRecipes.ALLOY_SMELTER.getRecipes(world).stream()
|
||||
.anyMatch(rebornRecipe -> rebornRecipe.getRebornIngredients().stream()
|
||||
.anyMatch(rebornIngredient -> rebornIngredient.test(stack))
|
||||
);
|
||||
.anyMatch(rebornRecipe -> rebornRecipe.getRebornIngredients().stream()
|
||||
.anyMatch(rebornIngredient -> rebornIngredient.test(stack))
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
|
@ -47,12 +47,12 @@ public class IronFurnaceBlockEntity extends AbstractIronMachineBlockEntity imple
|
|||
int inputSlot = 0;
|
||||
int outputSlot = 1;
|
||||
public float experience;
|
||||
|
||||
|
||||
public IronFurnaceBlockEntity() {
|
||||
super(TRBlockEntities.IRON_FURNACE, 2, TRContent.Machine.IRON_FURNACE.block);
|
||||
this.inventory = new RebornInventory<>(3, "IronFurnaceBlockEntity", 64, this);
|
||||
}
|
||||
|
||||
|
||||
public void handleGuiInputFromClient(PlayerEntity playerIn) {
|
||||
if (playerIn instanceof ServerPlayerEntity) {
|
||||
ServerPlayerEntity player = (ServerPlayerEntity) playerIn;
|
||||
|
@ -65,7 +65,7 @@ public class IronFurnaceBlockEntity extends AbstractIronMachineBlockEntity imple
|
|||
}
|
||||
experience = 0;
|
||||
}
|
||||
|
||||
|
||||
private ItemStack getResultFor(ItemStack stack) {
|
||||
ItemStack result = RecipeUtils.getMatchingRecipes(world, RecipeType.SMELTING, stack);
|
||||
if (!result.isEmpty()) {
|
||||
|
@ -81,7 +81,7 @@ public class IronFurnaceBlockEntity extends AbstractIronMachineBlockEntity imple
|
|||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
// AbstractIronMachineBlockEntity
|
||||
@Override
|
||||
protected void smelt() {
|
||||
|
@ -90,7 +90,7 @@ public class IronFurnaceBlockEntity extends AbstractIronMachineBlockEntity imple
|
|||
}
|
||||
ItemStack inputStack = inventory.getStack(inputSlot);
|
||||
ItemStack resultStack = getResultFor(inputStack);
|
||||
|
||||
|
||||
if (inventory.getStack(outputSlot).isEmpty()) {
|
||||
inventory.setStack(outputSlot, resultStack.copy());
|
||||
} else if (inventory.getStack(outputSlot).isItemEqualIgnoreDamage(resultStack)) {
|
||||
|
@ -103,12 +103,12 @@ public class IronFurnaceBlockEntity extends AbstractIronMachineBlockEntity imple
|
|||
inventory.setStack(inputSlot, ItemStack.EMPTY);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
protected boolean canSmelt() {
|
||||
if (inventory.getStack(inputSlot).isEmpty()) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
ItemStack outputStack = getResultFor(inventory.getStack(inputSlot));
|
||||
if (outputStack.isEmpty())
|
||||
return false;
|
||||
|
@ -130,19 +130,19 @@ public class IronFurnaceBlockEntity extends AbstractIronMachineBlockEntity imple
|
|||
super.fromTag(blockState, compoundTag);
|
||||
experience = compoundTag.getFloat("Experience");
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public CompoundTag toTag(CompoundTag compoundTag) {
|
||||
super.toTag(compoundTag);
|
||||
compoundTag.putFloat("Experience", experience);
|
||||
return compoundTag;
|
||||
super.toTag(compoundTag);
|
||||
compoundTag.putFloat("Experience", experience);
|
||||
return compoundTag;
|
||||
}
|
||||
|
||||
// IContainerProvider
|
||||
public float getExperience() {
|
||||
return experience;
|
||||
}
|
||||
|
||||
|
||||
public void setExperience(float experience) {
|
||||
this.experience = experience;
|
||||
}
|
||||
|
|
|
@ -42,30 +42,30 @@ import techreborn.init.TRContent;
|
|||
import techreborn.utils.MessageIDs;
|
||||
|
||||
public class AlarmBlockEntity extends BlockEntity
|
||||
implements Tickable, IToolDrop {
|
||||
implements Tickable, IToolDrop {
|
||||
private int selectedSound = 1;
|
||||
|
||||
public AlarmBlockEntity() {
|
||||
super(TRBlockEntities.ALARM);
|
||||
}
|
||||
|
||||
public void rightClick() {
|
||||
if (world.isClient) {
|
||||
return;
|
||||
}
|
||||
public void rightClick() {
|
||||
if (world.isClient) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (selectedSound < 3) {
|
||||
selectedSound++;
|
||||
} else {
|
||||
selectedSound = 1;
|
||||
}
|
||||
if (selectedSound < 3) {
|
||||
selectedSound++;
|
||||
} else {
|
||||
selectedSound = 1;
|
||||
}
|
||||
|
||||
ChatUtils.sendNoSpamMessages(MessageIDs.alarmID, new TranslatableText("techreborn.message.alarm")
|
||||
ChatUtils.sendNoSpamMessages(MessageIDs.alarmID, new TranslatableText("techreborn.message.alarm")
|
||||
.formatted(Formatting.GRAY)
|
||||
.append(" Alarm ")
|
||||
.append(String.valueOf(selectedSound)));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// BlockEntity
|
||||
@Override
|
||||
public CompoundTag toTag(CompoundTag compound) {
|
||||
|
@ -87,12 +87,12 @@ public class AlarmBlockEntity extends BlockEntity
|
|||
// ITickable
|
||||
@Override
|
||||
public void tick() {
|
||||
if (world.isClient()){
|
||||
return;
|
||||
}
|
||||
if (world.getTime() % 25 != 0) {
|
||||
return;
|
||||
}
|
||||
if (world.isClient()) {
|
||||
return;
|
||||
}
|
||||
if (world.getTime() % 25 != 0) {
|
||||
return;
|
||||
}
|
||||
if (world.isReceivingRedstonePower(getPos())) {
|
||||
BlockAlarm.setActive(true, world, pos);
|
||||
switch (selectedSound) {
|
||||
|
@ -106,7 +106,7 @@ public class AlarmBlockEntity extends BlockEntity
|
|||
world.playSound(null, pos.getX(), pos.getY(), pos.getZ(), ModSounds.ALARM_3, SoundCategory.BLOCKS, 4F, 1F);
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
} else {
|
||||
BlockAlarm.setActive(false, world, pos);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -40,7 +40,7 @@ import techreborn.init.TRBlockEntities;
|
|||
import techreborn.init.TRContent;
|
||||
|
||||
public class ChargeOMatBlockEntity extends PowerAcceptorBlockEntity
|
||||
implements IToolDrop, InventoryProvider, BuiltScreenHandlerProvider {
|
||||
implements IToolDrop, InventoryProvider, BuiltScreenHandlerProvider {
|
||||
|
||||
public RebornInventory<ChargeOMatBlockEntity> inventory = new RebornInventory<>(6, "ChargeOMatBlockEntity", 64, this);
|
||||
|
||||
|
@ -53,7 +53,7 @@ public class ChargeOMatBlockEntity extends PowerAcceptorBlockEntity
|
|||
public void tick() {
|
||||
super.tick();
|
||||
|
||||
if(world.isClient){
|
||||
if (world.isClient) {
|
||||
return;
|
||||
}
|
||||
for (int i = 0; i < 6; i++) {
|
||||
|
@ -61,11 +61,11 @@ public class ChargeOMatBlockEntity extends PowerAcceptorBlockEntity
|
|||
|
||||
if (Energy.valid(stack)) {
|
||||
Energy.of(this)
|
||||
.into(
|
||||
Energy
|
||||
.of(stack)
|
||||
)
|
||||
.move();
|
||||
.into(
|
||||
Energy
|
||||
.of(stack)
|
||||
)
|
||||
.move();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -94,7 +94,7 @@ public class ChargeOMatBlockEntity extends PowerAcceptorBlockEntity
|
|||
public double getBaseMaxInput() {
|
||||
return TechRebornConfig.chargeOMatBMaxInput;
|
||||
}
|
||||
|
||||
|
||||
// TileMachineBase
|
||||
@Override
|
||||
public boolean canBeUpgraded() {
|
||||
|
@ -117,7 +117,7 @@ public class ChargeOMatBlockEntity extends PowerAcceptorBlockEntity
|
|||
@Override
|
||||
public BuiltScreenHandler createScreenHandler(int syncID, final PlayerEntity player) {
|
||||
return new ScreenHandlerBuilder("chargebench").player(player.inventory).inventory().hotbar().addInventory()
|
||||
.blockEntity(this).energySlot(0, 62, 25).energySlot(1, 98, 25).energySlot(2, 62, 45).energySlot(3, 98, 45)
|
||||
.energySlot(4, 62, 65).energySlot(5, 98, 65).syncEnergyValue().addInventory().create(this, syncID);
|
||||
.blockEntity(this).energySlot(0, 62, 25).energySlot(1, 98, 25).energySlot(2, 62, 45).energySlot(3, 98, 45)
|
||||
.energySlot(4, 62, 65).energySlot(5, 98, 65).syncEnergyValue().addInventory().create(this, syncID);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -43,7 +43,7 @@ public class DrainBlockEntity extends MachineBaseBlockEntity {
|
|||
|
||||
protected Tank internalTank = new Tank("tank", FluidValue.BUCKET, this);
|
||||
|
||||
public DrainBlockEntity(){
|
||||
public DrainBlockEntity() {
|
||||
this(TRBlockEntities.DRAIN);
|
||||
}
|
||||
|
||||
|
@ -54,13 +54,13 @@ public class DrainBlockEntity extends MachineBaseBlockEntity {
|
|||
@Override
|
||||
public void tick() {
|
||||
super.tick();
|
||||
if(world.isClient){
|
||||
if (world.isClient) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (world.getTime() % 10 == 0) {
|
||||
|
||||
if(internalTank.isEmpty()) {
|
||||
if (internalTank.isEmpty()) {
|
||||
tryDrain();
|
||||
}
|
||||
}
|
||||
|
@ -72,7 +72,7 @@ public class DrainBlockEntity extends MachineBaseBlockEntity {
|
|||
return internalTank;
|
||||
}
|
||||
|
||||
private void tryDrain(){
|
||||
private void tryDrain() {
|
||||
// Position above drain
|
||||
BlockPos above = this.getPos().up();
|
||||
|
||||
|
|
|
@ -24,12 +24,12 @@
|
|||
|
||||
package techreborn.blockentity.machine.multiblock;
|
||||
|
||||
import net.minecraft.block.Material;
|
||||
import net.minecraft.entity.player.PlayerEntity;
|
||||
import net.minecraft.util.math.BlockPos;
|
||||
import net.minecraft.util.math.Direction;
|
||||
import reborncore.client.screen.BuiltScreenHandlerProvider;
|
||||
import reborncore.client.screen.builder.BuiltScreenHandler;
|
||||
import reborncore.client.screen.builder.ScreenHandlerBuilder;
|
||||
import reborncore.common.blockentity.MultiblockWriter;
|
||||
import reborncore.common.crafting.RebornRecipe;
|
||||
import reborncore.common.recipes.RecipeCrafter;
|
||||
import reborncore.common.util.RebornInventory;
|
||||
|
@ -41,40 +41,21 @@ import techreborn.init.TRContent;
|
|||
|
||||
public class DistillationTowerBlockEntity extends GenericMachineBlockEntity implements BuiltScreenHandlerProvider {
|
||||
|
||||
public MultiblockChecker multiblockChecker;
|
||||
|
||||
public DistillationTowerBlockEntity() {
|
||||
super(TRBlockEntities.DISTILLATION_TOWER, "DistillationTower", TechRebornConfig.distillationTowerMaxInput, TechRebornConfig.distillationTowerMaxEnergy, TRContent.Machine.DISTILLATION_TOWER.block, 6);
|
||||
final int[] inputs = new int[] { 0, 1 };
|
||||
final int[] outputs = new int[] { 2, 3, 4, 5 };
|
||||
final int[] inputs = new int[]{0, 1};
|
||||
final int[] outputs = new int[]{2, 3, 4, 5};
|
||||
this.inventory = new RebornInventory<>(7, "DistillationTowerBlockEntity", 64, this);
|
||||
this.crafter = new RecipeCrafter(ModRecipes.DISTILLATION_TOWER, this, 2, 4, this.inventory, inputs, outputs);
|
||||
}
|
||||
|
||||
public boolean getMutliBlock() {
|
||||
if (multiblockChecker == null) {
|
||||
return false;
|
||||
}
|
||||
final boolean layer0 = multiblockChecker.checkRectY(1, 1, MultiblockChecker.STANDARD_CASING, MultiblockChecker.ZERO_OFFSET);
|
||||
final boolean layer1 = multiblockChecker.checkRingY(1, 1, MultiblockChecker.INDUSTRIAL_CASING, new BlockPos(0, 1, 0));
|
||||
final boolean layer2 = multiblockChecker.checkRingY(1, 1, MultiblockChecker.STANDARD_CASING, new BlockPos(0, 2, 0));
|
||||
final boolean layer3 = multiblockChecker.checkRectY(1, 1, MultiblockChecker.INDUSTRIAL_CASING, new BlockPos(0, 3, 0));
|
||||
final Material centerBlock1 = multiblockChecker.getBlock(0, 1, 0).getMaterial();
|
||||
final Material centerBlock2 = multiblockChecker.getBlock(0, 2, 0).getMaterial();
|
||||
final boolean center1 = (centerBlock1 == Material.AIR);
|
||||
final boolean center2 = (centerBlock2 == Material.AIR);
|
||||
return layer0 && layer1 && layer2 && layer3 && center1 && center2;
|
||||
}
|
||||
|
||||
// TileGenericMachine
|
||||
@Override
|
||||
public void tick() {
|
||||
if (multiblockChecker == null) {
|
||||
final BlockPos downCenter = pos.offset(getFacing().getOpposite(), 2);
|
||||
multiblockChecker = new MultiblockChecker(world, downCenter);
|
||||
}
|
||||
|
||||
super.tick();
|
||||
public void writeMultiblock(MultiblockWriter writer) {
|
||||
writer.translate(1, 0, -1)
|
||||
.fill(0, 0, 0, 3, 1, 3, TRContent.MachineBlocks.BASIC.getCasing().getDefaultState())
|
||||
.ringWithAir(Direction.Axis.Y, 3, 1, 3, TRContent.MachineBlocks.INDUSTRIAL.getCasing().getDefaultState())
|
||||
.ringWithAir(Direction.Axis.Y, 3, 2, 3, TRContent.MachineBlocks.BASIC.getCasing().getDefaultState())
|
||||
.fill(0, 3, 0, 3, 4, 3, TRContent.MachineBlocks.INDUSTRIAL.getCasing().getDefaultState());
|
||||
}
|
||||
|
||||
// IContainerProvider
|
||||
|
@ -88,6 +69,6 @@ public class DistillationTowerBlockEntity extends GenericMachineBlockEntity impl
|
|||
|
||||
@Override
|
||||
public boolean canCraft(RebornRecipe rebornRecipe) {
|
||||
return getMutliBlock();
|
||||
return isMultiblockValid();
|
||||
}
|
||||
}
|
|
@ -27,10 +27,11 @@ package techreborn.blockentity.machine.multiblock;
|
|||
import net.minecraft.block.BlockState;
|
||||
import net.minecraft.entity.player.PlayerEntity;
|
||||
import net.minecraft.nbt.CompoundTag;
|
||||
import net.minecraft.util.math.BlockPos;
|
||||
import net.minecraft.util.math.Direction;
|
||||
import reborncore.client.screen.BuiltScreenHandlerProvider;
|
||||
import reborncore.client.screen.builder.BuiltScreenHandler;
|
||||
import reborncore.client.screen.builder.ScreenHandlerBuilder;
|
||||
import reborncore.common.blockentity.MultiblockWriter;
|
||||
import reborncore.common.fluid.FluidValue;
|
||||
import reborncore.common.recipes.RecipeCrafter;
|
||||
import reborncore.common.util.IInventoryAccess;
|
||||
|
@ -47,11 +48,9 @@ import javax.annotation.Nullable;
|
|||
|
||||
/**
|
||||
* @author drcrazy
|
||||
*
|
||||
*/
|
||||
public class FluidReplicatorBlockEntity extends GenericMachineBlockEntity implements BuiltScreenHandlerProvider {
|
||||
|
||||
public MultiblockChecker multiblockChecker;
|
||||
public static final FluidValue TANK_CAPACITY = FluidValue.BUCKET.multiply(16);
|
||||
public Tank tank;
|
||||
int ticksSinceLastChange;
|
||||
|
@ -59,27 +58,20 @@ public class FluidReplicatorBlockEntity extends GenericMachineBlockEntity implem
|
|||
public FluidReplicatorBlockEntity() {
|
||||
super(TRBlockEntities.FLUID_REPLICATOR, "FluidReplicator", TechRebornConfig.fluidReplicatorMaxInput, TechRebornConfig.fluidReplicatorMaxEnergy, TRContent.Machine.FLUID_REPLICATOR.block, 3);
|
||||
this.inventory = new RebornInventory<>(4, "FluidReplicatorBlockEntity", 64, this, getInventoryAccess());
|
||||
this.crafter = new RecipeCrafter(ModRecipes.FLUID_REPLICATOR, this, 1, 0, this.inventory, new int[] {0}, null);
|
||||
this.crafter = new RecipeCrafter(ModRecipes.FLUID_REPLICATOR, this, 1, 0, this.inventory, new int[]{0}, null);
|
||||
this.tank = new Tank("FluidReplicatorBlockEntity", FluidReplicatorBlockEntity.TANK_CAPACITY, this);
|
||||
}
|
||||
|
||||
public boolean getMultiBlock() {
|
||||
if (multiblockChecker == null) {
|
||||
return false;
|
||||
}
|
||||
final boolean ring = multiblockChecker.checkRingY(1, 1, MultiblockChecker.ADVANCED_CASING,
|
||||
MultiblockChecker.ZERO_OFFSET);
|
||||
return ring;
|
||||
@Override
|
||||
public void writeMultiblock(MultiblockWriter writer) {
|
||||
BlockState state = TRContent.MachineBlocks.ADVANCED.getCasing().getDefaultState();
|
||||
writer.translate(1, 0, -1)
|
||||
.ring(Direction.Axis.Y, 3, 0, 3, (v, p) -> v.getBlockState(p) == state, state, null, null);
|
||||
}
|
||||
|
||||
// TileGenericMachine
|
||||
@Override
|
||||
public void tick() {
|
||||
if (multiblockChecker == null) {
|
||||
final BlockPos downCenter = pos.offset(getFacing().getOpposite(), 2);
|
||||
multiblockChecker = new MultiblockChecker(world, downCenter);
|
||||
}
|
||||
|
||||
ticksSinceLastChange++;
|
||||
// Check cells input slot 2 time per second
|
||||
if (!world.isClient && ticksSinceLastChange >= 10) {
|
||||
|
@ -92,10 +84,10 @@ public class FluidReplicatorBlockEntity extends GenericMachineBlockEntity implem
|
|||
super.tick();
|
||||
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public RecipeCrafter getRecipeCrafter() {
|
||||
return (RecipeCrafter) crafter;
|
||||
return crafter;
|
||||
}
|
||||
|
||||
// TilePowerAcceptor
|
||||
|
@ -112,9 +104,9 @@ public class FluidReplicatorBlockEntity extends GenericMachineBlockEntity implem
|
|||
return tagCompound;
|
||||
}
|
||||
|
||||
private static IInventoryAccess<FluidReplicatorBlockEntity> getInventoryAccess(){
|
||||
private static IInventoryAccess<FluidReplicatorBlockEntity> getInventoryAccess() {
|
||||
return (slotID, stack, face, direction, blockEntity) -> {
|
||||
if(slotID == 0){
|
||||
if (slotID == 0) {
|
||||
return stack.isItemEqualIgnoreDamage(TRContent.Parts.UU_MATTER.getStack());
|
||||
}
|
||||
return true;
|
||||
|
|
|
@ -33,32 +33,27 @@ import net.minecraft.text.Text;
|
|||
import net.minecraft.util.Identifier;
|
||||
import net.minecraft.util.math.BlockPos;
|
||||
import net.minecraft.util.math.Direction;
|
||||
import reborncore.api.IToolDrop;
|
||||
import reborncore.api.blockentity.InventoryProvider;
|
||||
import reborncore.client.screen.BuiltScreenHandlerProvider;
|
||||
import reborncore.client.screen.builder.BuiltScreenHandler;
|
||||
import reborncore.client.screen.builder.ScreenHandlerBuilder;
|
||||
import reborncore.common.blockentity.MultiblockWriter;
|
||||
import reborncore.common.crafting.RebornRecipe;
|
||||
import reborncore.common.crafting.ingredient.RebornIngredient;
|
||||
import reborncore.common.powerSystem.PowerAcceptorBlockEntity;
|
||||
import reborncore.common.util.ItemUtils;
|
||||
import reborncore.common.util.RebornInventory;
|
||||
import reborncore.common.util.StringUtils;
|
||||
import reborncore.common.util.Torus;
|
||||
import techreborn.api.recipe.recipes.FusionReactorRecipe;
|
||||
import techreborn.blockentity.machine.GenericMachineBlockEntity;
|
||||
import techreborn.config.TechRebornConfig;
|
||||
import techreborn.init.ModRecipes;
|
||||
import techreborn.init.TRBlockEntities;
|
||||
import techreborn.init.TRContent;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class FusionControlComputerBlockEntity extends PowerAcceptorBlockEntity
|
||||
implements IToolDrop, InventoryProvider, BuiltScreenHandlerProvider {
|
||||
public class FusionControlComputerBlockEntity extends GenericMachineBlockEntity implements BuiltScreenHandlerProvider {
|
||||
|
||||
public RebornInventory<FusionControlComputerBlockEntity> inventory;
|
||||
|
||||
public int coilCount = 0;
|
||||
public int crafingTickTime = 0;
|
||||
public int neededPower = 0;
|
||||
public int size = 6;
|
||||
|
@ -73,36 +68,15 @@ public class FusionControlComputerBlockEntity extends PowerAcceptorBlockEntity
|
|||
long lastTick = -1;
|
||||
|
||||
public FusionControlComputerBlockEntity() {
|
||||
super(TRBlockEntities.FUSION_CONTROL_COMPUTER);
|
||||
super(TRBlockEntities.FUSION_CONTROL_COMPUTER, "FusionControlComputer", -1, -1, TRContent.Machine.FUSION_CONTROL_COMPUTER.block, -1);
|
||||
checkOverfill = false;
|
||||
this.inventory = new RebornInventory<>(3, "FusionControlComputerBlockEntity", 64, this);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check that reactor has all necessary coils in place
|
||||
*
|
||||
* @return boolean Return true if coils are present
|
||||
*/
|
||||
public boolean checkCoils() {
|
||||
List<BlockPos> coils = Torus.generate(pos, size);
|
||||
for(BlockPos coilPos : coils){
|
||||
if (!isCoil(coilPos)) {
|
||||
coilCount = 0;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
coilCount = coils.size();
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if block is fusion coil
|
||||
*
|
||||
* @param pos coordinate for block
|
||||
* @return boolean Returns true if block is fusion coil
|
||||
*/
|
||||
public boolean isCoil(BlockPos pos) {
|
||||
return world.getBlockState(pos).getBlock() == TRContent.Machine.FUSION_COIL.block;
|
||||
@Override
|
||||
public void writeMultiblock(MultiblockWriter writer) {
|
||||
BlockState coil = TRContent.Machine.FUSION_COIL.block.getDefaultState();
|
||||
Torus.generate(BlockPos.ORIGIN, size).forEach(pos -> writer.add(pos.getX(), pos.getY(), pos.getZ(), coil));
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -118,14 +92,14 @@ public class FusionControlComputerBlockEntity extends PowerAcceptorBlockEntity
|
|||
/**
|
||||
* Checks that ItemStack could be inserted into slot provided, including check
|
||||
* for existing item in slot and maximum stack size
|
||||
*
|
||||
*
|
||||
* @param stack ItemStack ItemStack to insert
|
||||
* @param slot int Slot ID to check
|
||||
* @param tags boolean Should we use tags
|
||||
* @param slot int Slot ID to check
|
||||
* @param tags boolean Should we use tags
|
||||
* @return boolean Returns true if ItemStack will fit into slot
|
||||
*/
|
||||
public boolean canFitStack(ItemStack stack, int slot, boolean tags) {// Checks to see if it can
|
||||
// fit the stack
|
||||
// fit the stack
|
||||
if (stack.isEmpty()) {
|
||||
return true;
|
||||
}
|
||||
|
@ -140,7 +114,7 @@ public class FusionControlComputerBlockEntity extends PowerAcceptorBlockEntity
|
|||
|
||||
/**
|
||||
* Returns progress scaled to input value
|
||||
*
|
||||
*
|
||||
* @param scale int Maximum value for progress
|
||||
* @return int Scale of progress
|
||||
*/
|
||||
|
@ -166,20 +140,20 @@ public class FusionControlComputerBlockEntity extends PowerAcceptorBlockEntity
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Validates if reactor has all inputs and can output result
|
||||
*
|
||||
*
|
||||
* @param recipe FusionReactorRecipe Recipe to validate
|
||||
* @return Boolean True if we have all inputs and can fit output
|
||||
*/
|
||||
private boolean validateRecipe(FusionReactorRecipe recipe) {
|
||||
return hasAllInputs(recipe) && canFitStack(recipe.getOutputs().get(0), outputStackSlot, true);
|
||||
return hasAllInputs(recipe) && canFitStack(recipe.getOutputs().get(0), outputStackSlot, true);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Check if BlockEntity has all necessary inputs for recipe provided
|
||||
*
|
||||
*
|
||||
* @param recipeType RebornRecipe Recipe to check inputs
|
||||
* @return Boolean True if reactor has all inputs for recipe
|
||||
*/
|
||||
|
@ -199,10 +173,10 @@ public class FusionControlComputerBlockEntity extends PowerAcceptorBlockEntity
|
|||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Decrease stack size on the given slot according to recipe input
|
||||
*
|
||||
*
|
||||
* @param slot int Slot number
|
||||
*/
|
||||
private void useInput(int slot) {
|
||||
|
@ -228,7 +202,7 @@ public class FusionControlComputerBlockEntity extends PowerAcceptorBlockEntity
|
|||
}
|
||||
|
||||
//Move this to here from the nbt read method, as it now requires the world as of 1.14
|
||||
if(checkNBTRecipe) {
|
||||
if (checkNBTRecipe) {
|
||||
checkNBTRecipe = false;
|
||||
for (final RebornRecipe reactorRecipe : ModRecipes.FUSION_REACTOR.getRecipes(getWorld())) {
|
||||
if (validateRecipe((FusionReactorRecipe) reactorRecipe)) {
|
||||
|
@ -237,7 +211,7 @@ public class FusionControlComputerBlockEntity extends PowerAcceptorBlockEntity
|
|||
}
|
||||
}
|
||||
|
||||
if(lastTick == world.getTime()){
|
||||
if (lastTick == world.getTime()) {
|
||||
//Prevent tick accerators, blame obstinate for this.
|
||||
return;
|
||||
}
|
||||
|
@ -245,11 +219,10 @@ public class FusionControlComputerBlockEntity extends PowerAcceptorBlockEntity
|
|||
|
||||
// Force check every second
|
||||
if (world.getTime() % 20 == 0) {
|
||||
checkCoils();
|
||||
inventory.setChanged();
|
||||
}
|
||||
|
||||
if (coilCount == 0) {
|
||||
if (!isMultiblockValid()) {
|
||||
resetCrafter();
|
||||
return;
|
||||
}
|
||||
|
@ -314,7 +287,7 @@ public class FusionControlComputerBlockEntity extends PowerAcceptorBlockEntity
|
|||
|
||||
@Override
|
||||
public double getPowerMultiplier() {
|
||||
double calc = (1F/2F) * Math.pow(size -5, 1.8);
|
||||
double calc = (1F / 2F) * Math.pow(size - 5, 1.8);
|
||||
return Math.max(Math.round(calc * 100D) / 100D, 1D);
|
||||
}
|
||||
|
||||
|
@ -355,10 +328,10 @@ public class FusionControlComputerBlockEntity extends PowerAcceptorBlockEntity
|
|||
this.crafingTickTime = tagCompound.getInt("crafingTickTime");
|
||||
this.neededPower = tagCompound.getInt("neededPower");
|
||||
this.hasStartedCrafting = tagCompound.getBoolean("hasStartedCrafting");
|
||||
if(tagCompound.contains("hasActiveRecipe") && tagCompound.getBoolean("hasActiveRecipe") && this.currentRecipe == null){
|
||||
if (tagCompound.contains("hasActiveRecipe") && tagCompound.getBoolean("hasActiveRecipe") && this.currentRecipe == null) {
|
||||
checkNBTRecipe = true;
|
||||
}
|
||||
if(tagCompound.contains("size")){
|
||||
if (tagCompound.contains("size")) {
|
||||
this.size = tagCompound.getInt("size");
|
||||
}
|
||||
this.size = Math.min(size, TechRebornConfig.fusionControlComputerMaxCoilSize);//Done here to force the samller size, will be useful if people lag out on a large one.
|
||||
|
@ -375,24 +348,11 @@ public class FusionControlComputerBlockEntity extends PowerAcceptorBlockEntity
|
|||
return tagCompound;
|
||||
}
|
||||
|
||||
// TileLegacyMachineBase
|
||||
@Override
|
||||
public void onLoad() {
|
||||
super.onLoad();
|
||||
this.checkCoils();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canBeUpgraded() {
|
||||
return false;
|
||||
}
|
||||
|
||||
// IToolDrop
|
||||
@Override
|
||||
public ItemStack getToolDrop(PlayerEntity playerIn) {
|
||||
return TRContent.Machine.FUSION_CONTROL_COMPUTER.getStack();
|
||||
}
|
||||
|
||||
// ItemHandlerProvider
|
||||
@Override
|
||||
public RebornInventory<FusionControlComputerBlockEntity> getInventory() {
|
||||
|
@ -404,7 +364,6 @@ public class FusionControlComputerBlockEntity extends PowerAcceptorBlockEntity
|
|||
public BuiltScreenHandler createScreenHandler(int syncID, final PlayerEntity player) {
|
||||
return new ScreenHandlerBuilder("fusionreactor").player(player.inventory).inventory().hotbar()
|
||||
.addInventory().blockEntity(this).slot(0, 34, 47).slot(1, 126, 47).outputSlot(2, 80, 47).syncEnergyValue()
|
||||
.sync(this::getCoilStatus, this::setCoilStatus)
|
||||
.sync(this::getCrafingTickTime, this::setCrafingTickTime)
|
||||
.sync(this::getSize, this::setSize)
|
||||
.sync(this::getState, this::setState)
|
||||
|
@ -414,14 +373,6 @@ public class FusionControlComputerBlockEntity extends PowerAcceptorBlockEntity
|
|||
.create(this, syncID);
|
||||
}
|
||||
|
||||
public int getCoilStatus() {
|
||||
return coilCount;
|
||||
}
|
||||
|
||||
public void setCoilStatus(int coilStatus) {
|
||||
this.coilCount = coilStatus;
|
||||
}
|
||||
|
||||
public int getCrafingTickTime() {
|
||||
return crafingTickTime;
|
||||
}
|
||||
|
@ -446,61 +397,61 @@ public class FusionControlComputerBlockEntity extends PowerAcceptorBlockEntity
|
|||
this.size = size;
|
||||
}
|
||||
|
||||
public void changeSize(int sizeDelta){
|
||||
public void changeSize(int sizeDelta) {
|
||||
int newSize = size + sizeDelta;
|
||||
this.size = Math.max(6, Math.min(TechRebornConfig.fusionControlComputerMaxCoilSize, newSize));
|
||||
}
|
||||
|
||||
public int getState(){
|
||||
if(currentRecipe == null ){
|
||||
public int getState() {
|
||||
if (currentRecipe == null) {
|
||||
return 0; //No Recipe
|
||||
}
|
||||
if(!hasStartedCrafting){
|
||||
if (!hasStartedCrafting) {
|
||||
return 1; //Waiting on power
|
||||
}
|
||||
return 2; //Crafting
|
||||
}
|
||||
|
||||
public void setState(int state){
|
||||
public void setState(int state) {
|
||||
this.state = state;
|
||||
}
|
||||
|
||||
public Identifier getCurrentRecipeID() {
|
||||
if(currentRecipe == null) {
|
||||
if (currentRecipe == null) {
|
||||
return new Identifier("null", "null");
|
||||
}
|
||||
return currentRecipe.getId();
|
||||
}
|
||||
|
||||
public void setCurrentRecipeID(Identifier currentRecipeID) {
|
||||
if(currentRecipeID.getPath().equals("null")) {
|
||||
if (currentRecipeID.getPath().equals("null")) {
|
||||
currentRecipeID = null;
|
||||
}
|
||||
this.currentRecipeID = currentRecipeID;
|
||||
}
|
||||
|
||||
public FusionReactorRecipe getCurrentRecipeFromID() {
|
||||
if(currentRecipeID == null) return null;
|
||||
if (currentRecipeID == null) return null;
|
||||
return ModRecipes.FUSION_REACTOR.getRecipes(world).stream()
|
||||
.filter(recipe -> recipe.getId().equals(currentRecipeID))
|
||||
.findFirst()
|
||||
.orElse(null);
|
||||
}
|
||||
|
||||
public Text getStateText(){
|
||||
if(state == -1){
|
||||
public Text getStateText() {
|
||||
if (state == -1) {
|
||||
return LiteralText.EMPTY;
|
||||
} else if (state == 0){
|
||||
} else if (state == 0) {
|
||||
return new LiteralText("No recipe");
|
||||
} else if (state == 1){
|
||||
} else if (state == 1) {
|
||||
FusionReactorRecipe r = getCurrentRecipeFromID();
|
||||
if(r == null) {
|
||||
if (r == null) {
|
||||
return new LiteralText("Charging");
|
||||
}
|
||||
int percentage = percentage(r.getStartEnergy(), getEnergy());
|
||||
return new LiteralText("Charging (")
|
||||
.append(StringUtils.getPercentageText(percentage));
|
||||
} else if (state == 2){
|
||||
} else if (state == 2) {
|
||||
return new LiteralText("Crafting");
|
||||
}
|
||||
return LiteralText.EMPTY;
|
||||
|
|
|
@ -25,10 +25,11 @@
|
|||
package techreborn.blockentity.machine.multiblock;
|
||||
|
||||
import net.minecraft.entity.player.PlayerEntity;
|
||||
import net.minecraft.util.math.BlockPos;
|
||||
import net.minecraft.util.math.Direction;
|
||||
import reborncore.client.screen.BuiltScreenHandlerProvider;
|
||||
import reborncore.client.screen.builder.BuiltScreenHandler;
|
||||
import reborncore.client.screen.builder.ScreenHandlerBuilder;
|
||||
import reborncore.common.blockentity.MultiblockWriter;
|
||||
import reborncore.common.crafting.RebornRecipe;
|
||||
import reborncore.common.recipes.RecipeCrafter;
|
||||
import reborncore.common.util.RebornInventory;
|
||||
|
@ -40,34 +41,20 @@ import techreborn.init.TRContent;
|
|||
|
||||
public class ImplosionCompressorBlockEntity extends GenericMachineBlockEntity implements BuiltScreenHandlerProvider {
|
||||
|
||||
public MultiblockChecker multiblockChecker;
|
||||
|
||||
public ImplosionCompressorBlockEntity() {
|
||||
super(TRBlockEntities.IMPLOSION_COMPRESSOR, "ImplosionCompressor", TechRebornConfig.implosionCompressorMaxInput, TechRebornConfig.implosionCompressorMaxEnergy, TRContent.Machine.IMPLOSION_COMPRESSOR.block, 4);
|
||||
final int[] inputs = new int[] { 0, 1 };
|
||||
final int[] outputs = new int[] { 2, 3 };
|
||||
final int[] inputs = new int[]{0, 1};
|
||||
final int[] outputs = new int[]{2, 3};
|
||||
this.inventory = new RebornInventory<>(5, "ImplosionCompressorBlockEntity", 64, this);
|
||||
this.crafter = new RecipeCrafter(ModRecipes.IMPLOSION_COMPRESSOR, this, 2, 2, this.inventory, inputs, outputs);
|
||||
}
|
||||
|
||||
public boolean getMutliBlock() {
|
||||
if(multiblockChecker == null){
|
||||
return false;
|
||||
}
|
||||
final boolean down = multiblockChecker.checkRectY(1, 1, MultiblockChecker.ADVANCED_CASING, MultiblockChecker.ZERO_OFFSET);
|
||||
final boolean up = multiblockChecker.checkRectY(1, 1, MultiblockChecker.ADVANCED_CASING, new BlockPos(0, 2, 0));
|
||||
final boolean chamber = multiblockChecker.checkRingYHollow(1, 1, MultiblockChecker.ADVANCED_CASING, new BlockPos(0, 1, 0));
|
||||
return down && chamber && up;
|
||||
}
|
||||
|
||||
// TileGenericMachine
|
||||
@Override
|
||||
public void tick() {
|
||||
if (multiblockChecker == null) {
|
||||
multiblockChecker = new MultiblockChecker(world, pos.down(3));
|
||||
}
|
||||
|
||||
super.tick();
|
||||
public void writeMultiblock(MultiblockWriter writer) {
|
||||
writer.translate(-1, -3, -1)
|
||||
.fill(0, 0, 0, 3, 1, 3, TRContent.MachineBlocks.ADVANCED.getCasing().getDefaultState())
|
||||
.ringWithAir(Direction.Axis.Y, 3, 1, 3, TRContent.MachineBlocks.ADVANCED.getCasing().getDefaultState())
|
||||
.fill(0, 2, 0, 3, 3, 3, TRContent.MachineBlocks.ADVANCED.getCasing().getDefaultState());
|
||||
}
|
||||
|
||||
// IContainerProvider
|
||||
|
@ -80,6 +67,6 @@ public class ImplosionCompressorBlockEntity extends GenericMachineBlockEntity im
|
|||
|
||||
@Override
|
||||
public boolean canCraft(RebornRecipe rebornRecipe) {
|
||||
return getMutliBlock();
|
||||
return isMultiblockValid();
|
||||
}
|
||||
}
|
||||
|
|
|
@ -24,14 +24,18 @@
|
|||
|
||||
package techreborn.blockentity.machine.multiblock;
|
||||
|
||||
import net.minecraft.block.BlockState;
|
||||
import net.minecraft.block.Blocks;
|
||||
import net.minecraft.block.Material;
|
||||
import net.minecraft.block.entity.BlockEntity;
|
||||
import net.minecraft.entity.player.PlayerEntity;
|
||||
import net.minecraft.util.math.BlockPos;
|
||||
import net.minecraft.util.math.Direction;
|
||||
import net.minecraft.world.BlockView;
|
||||
import reborncore.client.screen.BuiltScreenHandlerProvider;
|
||||
import reborncore.client.screen.builder.BuiltScreenHandler;
|
||||
import reborncore.client.screen.builder.ScreenHandlerBuilder;
|
||||
import reborncore.common.blockentity.MultiblockWriter;
|
||||
import reborncore.common.multiblock.IMultiblockPart;
|
||||
import reborncore.common.recipes.RecipeCrafter;
|
||||
import reborncore.common.util.RebornInventory;
|
||||
|
@ -44,24 +48,49 @@ import techreborn.init.TRBlockEntities;
|
|||
import techreborn.init.TRContent;
|
||||
import techreborn.multiblocks.MultiBlockCasing;
|
||||
|
||||
import java.util.function.BiPredicate;
|
||||
|
||||
public class IndustrialBlastFurnaceBlockEntity extends GenericMachineBlockEntity implements BuiltScreenHandlerProvider {
|
||||
|
||||
public MultiblockChecker multiblockChecker;
|
||||
private int cachedHeat;
|
||||
|
||||
public IndustrialBlastFurnaceBlockEntity() {
|
||||
super(TRBlockEntities.INDUSTRIAL_BLAST_FURNACE, "IndustrialBlastFurnace", TechRebornConfig.industrialBlastFurnaceMaxInput, TechRebornConfig.industrialBlastFurnaceMaxEnergy, TRContent.Machine.INDUSTRIAL_BLAST_FURNACE.block, 4);
|
||||
final int[] inputs = new int[] { 0, 1 };
|
||||
final int[] outputs = new int[] { 2, 3 };
|
||||
final int[] inputs = new int[]{0, 1};
|
||||
final int[] outputs = new int[]{2, 3};
|
||||
this.inventory = new RebornInventory<>(5, "IndustrialBlastFurnaceBlockEntity", 64, this);
|
||||
this.crafter = new RecipeCrafter(ModRecipes.BLAST_FURNACE, this, 2, 2, this.inventory, inputs, outputs);
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public void writeMultiblock(MultiblockWriter writer) {
|
||||
BlockState basic = TRContent.MachineBlocks.BASIC.getCasing().getDefaultState();
|
||||
BlockState advanced = TRContent.MachineBlocks.ADVANCED.getCasing().getDefaultState();
|
||||
BlockState industrial = TRContent.MachineBlocks.INDUSTRIAL.getCasing().getDefaultState();
|
||||
BlockState lava = Blocks.LAVA.getDefaultState();
|
||||
|
||||
BiPredicate<BlockView, BlockPos> casing = (view, pos) -> {
|
||||
BlockState state = view.getBlockState(pos);
|
||||
return basic == state || advanced == state || industrial == state;
|
||||
};
|
||||
|
||||
BiPredicate<BlockView, BlockPos> maybeLava = (view, pos) -> {
|
||||
BlockState state = view.getBlockState(pos);
|
||||
return state == lava || state.getBlock() == Blocks.AIR;
|
||||
};
|
||||
|
||||
writer.translate(1, 0, -1)
|
||||
.fill(0, 0, 0, 3, 1, 3, casing, basic)
|
||||
.ring(Direction.Axis.Y, 3, 1, 3, casing, basic, maybeLava, lava)
|
||||
.ring(Direction.Axis.Y, 3, 2, 3, casing, basic, maybeLava, lava)
|
||||
.fill(0, 3, 0, 3, 4, 3, casing, basic);
|
||||
}
|
||||
|
||||
public int getHeat() {
|
||||
if (!getMutliBlock()){
|
||||
if (!isMultiblockValid()) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
// Bottom center of multiblock
|
||||
final BlockPos location = pos.offset(getFacing().getOpposite(), 2);
|
||||
final BlockEntity blockEntity = world.getBlockEntity(location);
|
||||
|
@ -93,22 +122,7 @@ public class IndustrialBlastFurnaceBlockEntity extends GenericMachineBlockEntity
|
|||
|
||||
return 0;
|
||||
}
|
||||
|
||||
public boolean getMutliBlock() {
|
||||
if(multiblockChecker == null){
|
||||
return false;
|
||||
}
|
||||
final boolean layer0 = multiblockChecker.checkRectY(1, 1, MultiblockChecker.CASING_ANY, MultiblockChecker.ZERO_OFFSET);
|
||||
final boolean layer1 = multiblockChecker.checkRingY(1, 1, MultiblockChecker.CASING_ANY, new BlockPos(0, 1, 0));
|
||||
final boolean layer2 = multiblockChecker.checkRingY(1, 1, MultiblockChecker.CASING_ANY, new BlockPos(0, 2, 0));
|
||||
final boolean layer3 = multiblockChecker.checkRectY(1, 1, MultiblockChecker.CASING_ANY, new BlockPos(0, 3, 0));
|
||||
final Material centerBlock1 = multiblockChecker.getBlock(0, 1, 0).getMaterial();
|
||||
final Material centerBlock2 = multiblockChecker.getBlock(0, 2, 0).getMaterial();
|
||||
final boolean center1 = (centerBlock1 == Material.AIR || centerBlock1 == Material.LAVA);
|
||||
final boolean center2 = (centerBlock2 == Material.AIR || centerBlock2 == Material.LAVA);
|
||||
return layer0 && layer1 && layer2 && layer3 && center1 && center2;
|
||||
}
|
||||
|
||||
|
||||
public void setHeat(final int heat) {
|
||||
cachedHeat = heat;
|
||||
}
|
||||
|
@ -116,17 +130,7 @@ public class IndustrialBlastFurnaceBlockEntity extends GenericMachineBlockEntity
|
|||
public int getCachedHeat() {
|
||||
return cachedHeat;
|
||||
}
|
||||
|
||||
// TileGenericMachine
|
||||
@Override
|
||||
public void tick() {
|
||||
if (multiblockChecker == null) {
|
||||
final BlockPos downCenter = pos.offset(getFacing().getOpposite(), 2);
|
||||
multiblockChecker = new MultiblockChecker(world, downCenter);
|
||||
}
|
||||
super.tick();
|
||||
}
|
||||
|
||||
|
||||
// IContainerProvider
|
||||
@Override
|
||||
public BuiltScreenHandler createScreenHandler(int syncID, final PlayerEntity player) {
|
||||
|
|
|
@ -25,15 +25,15 @@
|
|||
package techreborn.blockentity.machine.multiblock;
|
||||
|
||||
import net.minecraft.block.BlockState;
|
||||
import net.minecraft.block.FluidBlock;
|
||||
import net.minecraft.block.Blocks;
|
||||
import net.minecraft.block.Material;
|
||||
import net.minecraft.entity.player.PlayerEntity;
|
||||
import net.minecraft.nbt.CompoundTag;
|
||||
import net.minecraft.util.math.BlockPos;
|
||||
import net.minecraft.util.math.Direction;
|
||||
import reborncore.client.screen.BuiltScreenHandlerProvider;
|
||||
import reborncore.client.screen.builder.BuiltScreenHandler;
|
||||
import reborncore.client.screen.builder.ScreenHandlerBuilder;
|
||||
import reborncore.common.blockentity.MultiblockWriter;
|
||||
import reborncore.common.fluid.FluidValue;
|
||||
import reborncore.common.recipes.RecipeCrafter;
|
||||
import reborncore.common.util.RebornInventory;
|
||||
|
@ -51,41 +51,31 @@ public class IndustrialGrinderBlockEntity extends GenericMachineBlockEntity impl
|
|||
|
||||
public static final FluidValue TANK_CAPACITY = FluidValue.BUCKET.multiply(16);
|
||||
public Tank tank;
|
||||
public MultiblockChecker multiblockChecker;
|
||||
int ticksSinceLastChange;
|
||||
|
||||
public IndustrialGrinderBlockEntity() {
|
||||
super(TRBlockEntities.INDUSTRIAL_GRINDER, "IndustrialGrinder", TechRebornConfig.industrialGrinderMaxInput, TechRebornConfig.industrialGrinderMaxEnergy, TRContent.Machine.INDUSTRIAL_GRINDER.block, 7);
|
||||
final int[] inputs = new int[] { 0, 1 };
|
||||
final int[] outputs = new int[] {2, 3, 4, 5};
|
||||
final int[] inputs = new int[]{0, 1};
|
||||
final int[] outputs = new int[]{2, 3, 4, 5};
|
||||
this.inventory = new RebornInventory<>(8, "IndustrialGrinderBlockEntity", 64, this);
|
||||
this.crafter = new RecipeCrafter(ModRecipes.INDUSTRIAL_GRINDER, this, 1, 4, this.inventory, inputs, outputs);
|
||||
this.tank = new Tank("IndustrialGrinderBlockEntity", IndustrialGrinderBlockEntity.TANK_CAPACITY, this);
|
||||
this.ticksSinceLastChange = 0;
|
||||
}
|
||||
|
||||
public boolean getMultiBlock() {
|
||||
if (multiblockChecker == null) {
|
||||
return false;
|
||||
}
|
||||
final boolean down = multiblockChecker.checkRectY(1, 1, MultiblockChecker.STANDARD_CASING, MultiblockChecker.ZERO_OFFSET);
|
||||
final boolean up = multiblockChecker.checkRectY(1, 1, MultiblockChecker.STANDARD_CASING, new BlockPos(0, 2, 0));
|
||||
final boolean blade = multiblockChecker.checkRingY(1, 1, MultiblockChecker.ADVANCED_CASING, new BlockPos(0, 1, 0));
|
||||
final BlockState centerBlock = multiblockChecker.getBlock(0, 1, 0);
|
||||
final boolean center = ((centerBlock.getBlock() instanceof FluidBlock
|
||||
|| centerBlock.getBlock() instanceof FluidBlock)
|
||||
&& centerBlock.getMaterial() == Material.WATER);
|
||||
return down && center && blade && up;
|
||||
@Override
|
||||
public void writeMultiblock(MultiblockWriter writer) {
|
||||
BlockState basic = TRContent.MachineBlocks.BASIC.getCasing().getDefaultState();
|
||||
BlockState advanced = TRContent.MachineBlocks.ADVANCED.getCasing().getDefaultState();
|
||||
writer.translate(1, -1, -1)
|
||||
.fill(0, 0, 0, 3, 1, 3, basic)
|
||||
.ring(Direction.Axis.Y, 3, 1, 3, (view, pos) -> view.getBlockState(pos) == advanced, advanced, (view, pos) -> view.getBlockState(pos).getMaterial() == Material.WATER, Blocks.WATER.getDefaultState())
|
||||
.fill(0, 2, 0, 3, 3, 3, basic);
|
||||
}
|
||||
|
||||
// TilePowerAcceptor
|
||||
@Override
|
||||
public void tick() {
|
||||
if (multiblockChecker == null) {
|
||||
final BlockPos downCenter = pos.offset(getFacing().getOpposite(), 2).offset(Direction.DOWN, 1);
|
||||
multiblockChecker = new MultiblockChecker(world, downCenter);
|
||||
}
|
||||
|
||||
ticksSinceLastChange++;
|
||||
// Check cells input slot 2 time per second
|
||||
if (!world.isClient && ticksSinceLastChange >= 10) {
|
||||
|
|
|
@ -25,15 +25,15 @@
|
|||
package techreborn.blockentity.machine.multiblock;
|
||||
|
||||
import net.minecraft.block.BlockState;
|
||||
import net.minecraft.block.FluidBlock;
|
||||
import net.minecraft.block.Blocks;
|
||||
import net.minecraft.block.Material;
|
||||
import net.minecraft.entity.player.PlayerEntity;
|
||||
import net.minecraft.nbt.CompoundTag;
|
||||
import net.minecraft.util.math.BlockPos;
|
||||
import net.minecraft.util.math.Direction;
|
||||
import reborncore.client.screen.BuiltScreenHandlerProvider;
|
||||
import reborncore.client.screen.builder.BuiltScreenHandler;
|
||||
import reborncore.client.screen.builder.ScreenHandlerBuilder;
|
||||
import reborncore.common.blockentity.MultiblockWriter;
|
||||
import reborncore.common.fluid.FluidValue;
|
||||
import reborncore.common.recipes.RecipeCrafter;
|
||||
import reborncore.common.util.RebornInventory;
|
||||
|
@ -51,41 +51,31 @@ public class IndustrialSawmillBlockEntity extends GenericMachineBlockEntity impl
|
|||
|
||||
public static final FluidValue TANK_CAPACITY = FluidValue.BUCKET.multiply(16);
|
||||
public Tank tank;
|
||||
public MultiblockChecker multiblockChecker;
|
||||
int ticksSinceLastChange;
|
||||
|
||||
public IndustrialSawmillBlockEntity() {
|
||||
super(TRBlockEntities.INDUSTRIAL_SAWMILL, "IndustrialSawmill", TechRebornConfig.industrialSawmillMaxInput, TechRebornConfig.industrialSawmillMaxEnergy, TRContent.Machine.INDUSTRIAL_SAWMILL.block, 6);
|
||||
final int[] inputs = new int[] { 0, 1 };
|
||||
final int[] outputs = new int[] { 2, 3, 4 };
|
||||
final int[] inputs = new int[]{0, 1};
|
||||
final int[] outputs = new int[]{2, 3, 4};
|
||||
this.inventory = new RebornInventory<>(7, "SawmillBlockEntity", 64, this);
|
||||
this.crafter = new RecipeCrafter(ModRecipes.INDUSTRIAL_SAWMILL, this, 1, 3, this.inventory, inputs, outputs);
|
||||
this.tank = new Tank("SawmillBlockEntity", IndustrialSawmillBlockEntity.TANK_CAPACITY, this);
|
||||
this.ticksSinceLastChange = 0;
|
||||
}
|
||||
|
||||
public boolean getMutliBlock() {
|
||||
if (multiblockChecker == null) {
|
||||
return false;
|
||||
}
|
||||
final boolean down = multiblockChecker.checkRectY(1, 1, MultiblockChecker.STANDARD_CASING, MultiblockChecker.ZERO_OFFSET);
|
||||
final boolean up = multiblockChecker.checkRectY(1, 1, MultiblockChecker.STANDARD_CASING, new BlockPos(0, 2, 0));
|
||||
final boolean blade = multiblockChecker.checkRingY(1, 1, MultiblockChecker.ADVANCED_CASING, new BlockPos(0, 1, 0));
|
||||
final BlockState centerBlock = multiblockChecker.getBlock(0, 1, 0);
|
||||
final boolean center = ((centerBlock.getBlock() instanceof FluidBlock
|
||||
|| centerBlock.getBlock() instanceof FluidBlock)
|
||||
&& centerBlock.getMaterial() == Material.WATER);
|
||||
return down && center && blade && up;
|
||||
@Override
|
||||
public void writeMultiblock(MultiblockWriter writer) {
|
||||
BlockState basic = TRContent.MachineBlocks.BASIC.getCasing().getDefaultState();
|
||||
BlockState advanced = TRContent.MachineBlocks.ADVANCED.getCasing().getDefaultState();
|
||||
writer.translate(1, -1, -1)
|
||||
.fill(0, 0, 0, 3, 1, 3, basic)
|
||||
.ring(Direction.Axis.Y, 3, 1, 3, (view, pos) -> view.getBlockState(pos) == advanced, advanced, (view, pos) -> view.getBlockState(pos).getMaterial() == Material.WATER, Blocks.WATER.getDefaultState())
|
||||
.fill(0, 2, 0, 3, 3, 3, basic);
|
||||
}
|
||||
|
||||
// TileGenericMachine
|
||||
@Override
|
||||
public void tick() {
|
||||
if (multiblockChecker == null) {
|
||||
final BlockPos downCenter = pos.offset(getFacing().getOpposite(), 2).offset(Direction.DOWN, 1);
|
||||
multiblockChecker = new MultiblockChecker(world, downCenter);
|
||||
}
|
||||
|
||||
ticksSinceLastChange++;
|
||||
// Check cells input slot 2 time per second
|
||||
if (!world.isClient && ticksSinceLastChange >= 10) {
|
||||
|
@ -99,7 +89,7 @@ public class IndustrialSawmillBlockEntity extends GenericMachineBlockEntity impl
|
|||
super.tick();
|
||||
|
||||
}
|
||||
|
||||
|
||||
// TilePowerAcceptor
|
||||
@Override
|
||||
public void fromTag(BlockState blockState, final CompoundTag tagCompound) {
|
||||
|
|
|
@ -1,134 +0,0 @@
|
|||
/*
|
||||
* This file is part of TechReborn, licensed under the MIT License (MIT).
|
||||
*
|
||||
* Copyright (c) 2020 TechReborn
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
* SOFTWARE.
|
||||
*/
|
||||
|
||||
package techreborn.blockentity.machine.multiblock;
|
||||
|
||||
import net.minecraft.block.Block;
|
||||
import net.minecraft.block.BlockState;
|
||||
import net.minecraft.util.math.BlockPos;
|
||||
import net.minecraft.world.World;
|
||||
import techreborn.init.TRContent;
|
||||
|
||||
public class MultiblockChecker {
|
||||
|
||||
public static final BlockPos ZERO_OFFSET = BlockPos.ORIGIN;
|
||||
|
||||
public static final String STANDARD_CASING = "standard";
|
||||
public static final String ADVANCED_CASING = "advanced";
|
||||
public static final String INDUSTRIAL_CASING = "industrial";
|
||||
public static final String CASING_ANY = "any";
|
||||
|
||||
private final World world;
|
||||
private final BlockPos downCenter;
|
||||
|
||||
public MultiblockChecker(World world, BlockPos downCenter) {
|
||||
this.world = world;
|
||||
this.downCenter = downCenter;
|
||||
}
|
||||
|
||||
// TODO: make thid not so ugly
|
||||
public boolean checkCasing(int offX, int offY, int offZ, String type) {
|
||||
Block block = getBlock(offX, offY, offZ).getBlock();
|
||||
if (block == TRContent.MachineBlocks.BASIC.getCasing()|| block == TRContent.MachineBlocks.ADVANCED.getCasing() || block == TRContent.MachineBlocks.INDUSTRIAL.getCasing() ) {
|
||||
if (type == MultiblockChecker.CASING_ANY) {
|
||||
return true;
|
||||
} else if ( type == "standard" && block == TRContent.MachineBlocks.BASIC.getCasing()) {
|
||||
return true;
|
||||
}
|
||||
else if (type == "advanced" && block == TRContent.MachineBlocks.ADVANCED.getCasing()) {
|
||||
return true;
|
||||
}
|
||||
else if (type == "industrial" && block == TRContent.MachineBlocks.INDUSTRIAL.getCasing()) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public boolean checkAir(int offX, int offY, int offZ) {
|
||||
BlockPos pos = downCenter.add(offX, offY, offZ);
|
||||
return world.isAir(pos);
|
||||
}
|
||||
|
||||
public BlockState getBlock(int offX, int offY, int offZ) {
|
||||
BlockPos pos = downCenter.add(offX, offY, offZ);
|
||||
return world.getBlockState(pos);
|
||||
}
|
||||
|
||||
public boolean checkRectY(int sizeX, int sizeZ, String casingType, BlockPos offset) {
|
||||
for (int x = -sizeX; x <= sizeX; x++) {
|
||||
for (int z = -sizeZ; z <= sizeZ; z++) {
|
||||
if (!checkCasing(x + offset.getX(), offset.getY(), z + offset.getZ(), casingType))
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public boolean checkRectZ(int sizeX, int sizeY, String casingType, BlockPos offset) {
|
||||
for (int x = -sizeX; x <= sizeX; x++) {
|
||||
for (int y = -sizeY; y <= sizeY; y++) {
|
||||
if (!checkCasing(x + offset.getX(), y + offset.getY(), offset.getZ(), casingType))
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public boolean checkRectX(int sizeZ, int sizeY, String casingType, BlockPos offset) {
|
||||
for (int z = -sizeZ; z <= sizeZ; z++) {
|
||||
for (int y = -sizeY; y <= sizeY; y++) {
|
||||
if (!checkCasing(offset.getX(), y + offset.getY(), z + offset.getZ(), casingType))
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public boolean checkRingY(int sizeX, int sizeZ, String casingType, BlockPos offset) {
|
||||
for (int x = -sizeX; x <= sizeX; x++) {
|
||||
for (int z = -sizeZ; z <= sizeZ; z++) {
|
||||
if ((x == sizeX || x == -sizeX) || (z == sizeZ || z == -sizeZ)) {
|
||||
if (!checkCasing(x + offset.getX(), offset.getY(), z + offset.getZ(), casingType))
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public boolean checkRingYHollow(int sizeX, int sizeZ, String casingType, BlockPos offset) {
|
||||
for (int x = -sizeX; x <= sizeX; x++) {
|
||||
for (int z = -sizeZ; z <= sizeZ; z++) {
|
||||
if ((x == sizeX || x == -sizeX) || (z == sizeZ || z == -sizeZ)) {
|
||||
if (!checkCasing(x + offset.getX(), offset.getY(), z + offset.getZ(), casingType))
|
||||
return false;
|
||||
} else if (!checkAir(x + offset.getX(), offset.getY(), z + offset.getZ()))
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
}
|
|
@ -24,12 +24,14 @@
|
|||
|
||||
package techreborn.blockentity.machine.multiblock;
|
||||
|
||||
import net.minecraft.block.BlockState;
|
||||
import net.minecraft.entity.player.PlayerEntity;
|
||||
import net.minecraft.util.math.BlockPos;
|
||||
import net.minecraft.util.math.Direction;
|
||||
import reborncore.client.screen.BuiltScreenHandlerProvider;
|
||||
import reborncore.client.screen.builder.BuiltScreenHandler;
|
||||
import reborncore.client.screen.builder.ScreenHandlerBuilder;
|
||||
import reborncore.common.blockentity.MultiblockWriter;
|
||||
import reborncore.common.crafting.RebornRecipe;
|
||||
import reborncore.common.recipes.RecipeCrafter;
|
||||
import reborncore.common.util.RebornInventory;
|
||||
import techreborn.blockentity.machine.GenericMachineBlockEntity;
|
||||
|
@ -40,31 +42,23 @@ import techreborn.init.TRContent;
|
|||
|
||||
public class VacuumFreezerBlockEntity extends GenericMachineBlockEntity implements BuiltScreenHandlerProvider {
|
||||
|
||||
public MultiblockChecker multiblockChecker;
|
||||
|
||||
public VacuumFreezerBlockEntity() {
|
||||
super(TRBlockEntities.VACUUM_FREEZER, "VacuumFreezer", TechRebornConfig.vacuumFreezerMaxInput, TechRebornConfig.vacuumFreezerMaxEnergy, TRContent.Machine.VACUUM_FREEZER.block, 2);
|
||||
final int[] inputs = new int[] { 0 };
|
||||
final int[] outputs = new int[] { 1 };
|
||||
final int[] inputs = new int[]{0};
|
||||
final int[] outputs = new int[]{1};
|
||||
this.inventory = new RebornInventory<>(3, "VacuumFreezerBlockEntity", 64, this);
|
||||
this.crafter = new RecipeCrafter(ModRecipes.VACUUM_FREEZER, this, 2, 1, this.inventory, inputs, outputs);
|
||||
}
|
||||
|
||||
public boolean getMultiBlock() {
|
||||
if (multiblockChecker == null) {
|
||||
return false;
|
||||
}
|
||||
final boolean up = multiblockChecker.checkRectY(1, 1, MultiblockChecker.ADVANCED_CASING, MultiblockChecker.ZERO_OFFSET);
|
||||
final boolean down = multiblockChecker.checkRectY(1, 1, MultiblockChecker.ADVANCED_CASING, new BlockPos(0, -2, 0));
|
||||
final boolean chamber = multiblockChecker.checkRingYHollow(1, 1, MultiblockChecker.INDUSTRIAL_CASING, new BlockPos(0, -1, 0));
|
||||
return down && chamber && up;
|
||||
}
|
||||
|
||||
// BlockEntity
|
||||
|
||||
@Override
|
||||
public void cancelRemoval() {
|
||||
super.cancelRemoval();
|
||||
multiblockChecker = new MultiblockChecker(world, pos.offset(Direction.DOWN, 1));
|
||||
public void writeMultiblock(MultiblockWriter writer) {
|
||||
BlockState advanced = TRContent.MachineBlocks.ADVANCED.getCasing().getDefaultState();
|
||||
BlockState industrial = TRContent.MachineBlocks.INDUSTRIAL.getCasing().getDefaultState();
|
||||
|
||||
writer.translate(-1, -3, -1)
|
||||
.fill(0, 0, 0, 3, 1, 3, advanced)
|
||||
.ringWithAir(Direction.Axis.Y, 3, 1, 3, industrial)
|
||||
.fill(0, 2, 0, 3, 3, 3, advanced);
|
||||
}
|
||||
|
||||
// IContainerProvider
|
||||
|
@ -74,4 +68,13 @@ public class VacuumFreezerBlockEntity extends GenericMachineBlockEntity implemen
|
|||
.blockEntity(this).slot(0, 55, 45).outputSlot(1, 101, 45).energySlot(2, 8, 72).syncEnergyValue()
|
||||
.syncCrafterValue().addInventory().create(this, syncID);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canCraft(RebornRecipe rebornRecipe) {
|
||||
if (!this.isMultiblockValid()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return super.canCraft(rebornRecipe);
|
||||
}
|
||||
}
|
|
@ -40,8 +40,8 @@ public class AlloySmelterBlockEntity extends GenericMachineBlockEntity implement
|
|||
|
||||
public AlloySmelterBlockEntity() {
|
||||
super(TRBlockEntities.ALLOY_SMELTER, "AlloySmelter", TechRebornConfig.alloySmelterMaxInput, TechRebornConfig.alloySmelterMaxEnergy, TRContent.Machine.ALLOY_SMELTER.block, 3);
|
||||
final int[] inputs = new int[] { 0, 1 };
|
||||
final int[] outputs = new int[] { 2 };
|
||||
final int[] inputs = new int[]{0, 1};
|
||||
final int[] outputs = new int[]{2};
|
||||
this.inventory = new RebornInventory<>(4, "AlloySmelterBlockEntity", 64, this);
|
||||
this.crafter = new RecipeCrafter(ModRecipes.ALLOY_SMELTER, this, 2, 1, this.inventory, inputs, outputs);
|
||||
}
|
||||
|
@ -50,10 +50,10 @@ public class AlloySmelterBlockEntity extends GenericMachineBlockEntity implement
|
|||
@Override
|
||||
public BuiltScreenHandler createScreenHandler(int syncID, final PlayerEntity player) {
|
||||
return new ScreenHandlerBuilder("alloysmelter").player(player.inventory).inventory().hotbar()
|
||||
.addInventory().blockEntity(this)
|
||||
.slot(0, 34, 47)
|
||||
.slot(1, 126, 47)
|
||||
.outputSlot(2, 80, 47).energySlot(3, 8, 72).syncEnergyValue().syncCrafterValue().addInventory()
|
||||
.create(this, syncID);
|
||||
.addInventory().blockEntity(this)
|
||||
.slot(0, 34, 47)
|
||||
.slot(1, 126, 47)
|
||||
.outputSlot(2, 80, 47).energySlot(3, 8, 72).syncEnergyValue().syncCrafterValue().addInventory()
|
||||
.create(this, syncID);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -40,17 +40,17 @@ public class AssemblingMachineBlockEntity extends GenericMachineBlockEntity impl
|
|||
|
||||
public AssemblingMachineBlockEntity() {
|
||||
super(TRBlockEntities.ASSEMBLY_MACHINE, "AssemblingMachine", TechRebornConfig.assemblingMachineMaxInput, TechRebornConfig.assemblingMachineMaxEnergy, TRContent.Machine.ASSEMBLY_MACHINE.block, 3);
|
||||
final int[] inputs = new int[] { 0, 1 };
|
||||
final int[] outputs = new int[] { 2 };
|
||||
final int[] inputs = new int[]{0, 1};
|
||||
final int[] outputs = new int[]{2};
|
||||
this.inventory = new RebornInventory<>(4, "AssemblingMachineBlockEntity", 64, this);
|
||||
this.crafter = new RecipeCrafter(ModRecipes.ASSEMBLING_MACHINE, this, 2, 2, this.inventory, inputs, outputs);
|
||||
}
|
||||
|
||||
|
||||
// IContainerProvider
|
||||
@Override
|
||||
public BuiltScreenHandler createScreenHandler(int syncID, final PlayerEntity player) {
|
||||
return new ScreenHandlerBuilder("assemblingmachine").player(player.inventory).inventory().hotbar()
|
||||
.addInventory().blockEntity(this).slot(0, 55, 35).slot(1, 55, 55).outputSlot(2, 101, 45).energySlot(3, 8, 72)
|
||||
.syncEnergyValue().syncCrafterValue().addInventory().create(this, syncID);
|
||||
.addInventory().blockEntity(this).slot(0, 55, 35).slot(1, 55, 55).outputSlot(2, 101, 45).energySlot(3, 8, 72)
|
||||
.syncEnergyValue().syncCrafterValue().addInventory().create(this, syncID);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -127,7 +127,7 @@ public class AutoCraftingTableBlockEntity extends PowerAcceptorBlockEntity
|
|||
if (ingredient != Ingredient.EMPTY && !(ingredient.test(ItemStack.EMPTY))) {
|
||||
boolean foundIngredient = false;
|
||||
for (int i = 0; i < 9; i++) {
|
||||
if(checkedSlots.contains(i)) {
|
||||
if (checkedSlots.contains(i)) {
|
||||
continue;
|
||||
}
|
||||
ItemStack stack = inventory.getStack(i);
|
||||
|
@ -150,9 +150,7 @@ public class AutoCraftingTableBlockEntity extends PowerAcceptorBlockEntity
|
|||
}
|
||||
}
|
||||
if (!missingOutput) {
|
||||
if (hasOutputSpace(recipe.getOutput(), 9)) {
|
||||
return true;
|
||||
}
|
||||
return hasOutputSpace(recipe.getOutput(), 9);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
@ -173,9 +171,7 @@ public class AutoCraftingTableBlockEntity extends PowerAcceptorBlockEntity
|
|||
return true;
|
||||
}
|
||||
if (ItemUtils.isItemEqual(stack, output, true, true)) {
|
||||
if (stack.getMaxCount() > stack.getCount() + output.getCount()) {
|
||||
return true;
|
||||
}
|
||||
return stack.getMaxCount() > stack.getCount() + output.getCount();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
@ -191,7 +187,7 @@ public class AutoCraftingTableBlockEntity extends PowerAcceptorBlockEntity
|
|||
ItemStack bestSlot = inventory.getStack(i);
|
||||
if (ingredient.test(bestSlot)) {
|
||||
ItemStack remainderStack = getRemainderItem(bestSlot);
|
||||
if(remainderStack.isEmpty()) {
|
||||
if (remainderStack.isEmpty()) {
|
||||
bestSlot.decrement(1);
|
||||
} else {
|
||||
inventory.setStack(i, remainderStack);
|
||||
|
@ -202,7 +198,7 @@ public class AutoCraftingTableBlockEntity extends PowerAcceptorBlockEntity
|
|||
ItemStack stack = inventory.getStack(j);
|
||||
if (ingredient.test(stack)) {
|
||||
ItemStack remainderStack = getRemainderItem(stack);
|
||||
if(remainderStack.isEmpty()) {
|
||||
if (remainderStack.isEmpty()) {
|
||||
stack.decrement(1);
|
||||
} else {
|
||||
inventory.setStack(j, remainderStack);
|
||||
|
@ -223,7 +219,7 @@ public class AutoCraftingTableBlockEntity extends PowerAcceptorBlockEntity
|
|||
}
|
||||
|
||||
private ItemStack getRemainderItem(ItemStack stack) {
|
||||
if(stack.getItem() instanceof ExtendedRecipeRemainder) {
|
||||
if (stack.getItem() instanceof ExtendedRecipeRemainder) {
|
||||
return ((ExtendedRecipeRemainder) stack.getItem()).getRemainderStack(stack);
|
||||
|
||||
} else if (stack.getItem().hasRecipeRemainder()) {
|
||||
|
@ -310,7 +306,7 @@ public class AutoCraftingTableBlockEntity extends PowerAcceptorBlockEntity
|
|||
List<Integer> possibleSlots = new ArrayList<>();
|
||||
for (int s = 0; s < currentRecipe.getPreviewInputs().size(); s++) {
|
||||
for (int i = 0; i < 9; i++) {
|
||||
if(possibleSlots.contains(i)) {
|
||||
if (possibleSlots.contains(i)) {
|
||||
continue;
|
||||
}
|
||||
ItemStack stackInSlot = inventory.getStack(i);
|
||||
|
@ -325,8 +321,8 @@ public class AutoCraftingTableBlockEntity extends PowerAcceptorBlockEntity
|
|||
|
||||
}
|
||||
|
||||
if(!possibleSlots.isEmpty()){
|
||||
int totalItems = possibleSlots.stream()
|
||||
if (!possibleSlots.isEmpty()) {
|
||||
int totalItems = possibleSlots.stream()
|
||||
.mapToInt(value -> inventory.getStack(value).getCount()).sum();
|
||||
int slots = possibleSlots.size();
|
||||
|
||||
|
@ -334,11 +330,11 @@ public class AutoCraftingTableBlockEntity extends PowerAcceptorBlockEntity
|
|||
int[] split = new int[slots];
|
||||
int remainder = totalItems % slots;
|
||||
Arrays.fill(split, totalItems / slots);
|
||||
while (remainder > 0){
|
||||
while (remainder > 0) {
|
||||
for (int i = 0; i < split.length; i++) {
|
||||
if(remainder > 0){
|
||||
split[i] +=1;
|
||||
remainder --;
|
||||
if (remainder > 0) {
|
||||
split[i] += 1;
|
||||
remainder--;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -350,7 +346,7 @@ public class AutoCraftingTableBlockEntity extends PowerAcceptorBlockEntity
|
|||
boolean needsBalance = false;
|
||||
for (int i = 0; i < split.length; i++) {
|
||||
int required = split[i];
|
||||
if(slotEnvTyperubution.contains(required)){
|
||||
if (slotEnvTyperubution.contains(required)) {
|
||||
//We need to remove the int, not at the int, this seems to work around that
|
||||
slotEnvTyperubution.remove(new Integer(required));
|
||||
} else {
|
||||
|
|
|
@ -40,8 +40,8 @@ public class ChemicalReactorBlockEntity extends GenericMachineBlockEntity implem
|
|||
|
||||
public ChemicalReactorBlockEntity() {
|
||||
super(TRBlockEntities.CHEMICAL_REACTOR, "ChemicalReactor", TechRebornConfig.chemicalReactorMaxInput, TechRebornConfig.chemicalReactorMaxEnergy, TRContent.Machine.CHEMICAL_REACTOR.block, 3);
|
||||
final int[] inputs = new int[] { 0, 1 };
|
||||
final int[] outputs = new int[] { 2 };
|
||||
final int[] inputs = new int[]{0, 1};
|
||||
final int[] outputs = new int[]{2};
|
||||
this.inventory = new RebornInventory<>(4, "ChemicalReactorBlockEntity", 64, this);
|
||||
this.crafter = new RecipeCrafter(ModRecipes.CHEMICAL_REACTOR, this, 2, 2, this.inventory, inputs, outputs);
|
||||
}
|
||||
|
@ -50,7 +50,7 @@ public class ChemicalReactorBlockEntity extends GenericMachineBlockEntity implem
|
|||
@Override
|
||||
public BuiltScreenHandler createScreenHandler(int syncID, final PlayerEntity player) {
|
||||
return new ScreenHandlerBuilder("chemicalreactor").player(player.inventory).inventory().hotbar()
|
||||
.addInventory().blockEntity(this).slot(0, 34, 47).slot(1, 126, 47).outputSlot(2, 80, 47).energySlot(3, 8, 72)
|
||||
.syncEnergyValue().syncCrafterValue().addInventory().create(this, syncID);
|
||||
.addInventory().blockEntity(this).slot(0, 34, 47).slot(1, 126, 47).outputSlot(2, 80, 47).energySlot(3, 8, 72)
|
||||
.syncEnergyValue().syncCrafterValue().addInventory().create(this, syncID);
|
||||
}
|
||||
}
|
|
@ -40,12 +40,12 @@ public class CompressorBlockEntity extends GenericMachineBlockEntity implements
|
|||
|
||||
public CompressorBlockEntity() {
|
||||
super(TRBlockEntities.COMPRESSOR, "Compressor", TechRebornConfig.compressorMaxInput, TechRebornConfig.compressorMaxEnergy, TRContent.Machine.COMPRESSOR.block, 2);
|
||||
final int[] inputs = new int[] { 0 };
|
||||
final int[] outputs = new int[] { 1 };
|
||||
final int[] inputs = new int[]{0};
|
||||
final int[] outputs = new int[]{1};
|
||||
this.inventory = new RebornInventory<>(3, "CompressorBlockEntity", 64, this);
|
||||
this.crafter = new RecipeCrafter(ModRecipes.COMPRESSOR, this, 2, 1, this.inventory, inputs, outputs);
|
||||
}
|
||||
|
||||
|
||||
// IContainerProvider
|
||||
@Override
|
||||
public BuiltScreenHandler createScreenHandler(int syncID, final PlayerEntity player) {
|
||||
|
|
|
@ -58,19 +58,19 @@ public class ElectricFurnaceBlockEntity extends PowerAcceptorBlockEntity
|
|||
private int cookTimeTotal;
|
||||
// Energy cost per tick of cooking
|
||||
final int EnergyPerTick = 1;
|
||||
|
||||
|
||||
public ElectricFurnaceBlockEntity() {
|
||||
super(TRBlockEntities.ELECTRIC_FURNACE );
|
||||
super(TRBlockEntities.ELECTRIC_FURNACE);
|
||||
}
|
||||
|
||||
|
||||
private void setInvDirty(boolean isDirty) {
|
||||
inventory.setChanged(isDirty);
|
||||
}
|
||||
|
||||
|
||||
private boolean isInvDirty() {
|
||||
return inventory.hasChanged();
|
||||
}
|
||||
|
||||
|
||||
private void updateCurrentRecipe() {
|
||||
if (inventory.getStack(inputSlot).isEmpty()) {
|
||||
resetCrafter();
|
||||
|
@ -99,11 +99,11 @@ public class ElectricFurnaceBlockEntity extends PowerAcceptorBlockEntity
|
|||
return true;
|
||||
}
|
||||
if (ItemUtils.isItemEqual(inventory.getStack(slot), recipeOutput, true, true)) {
|
||||
return recipeOutput.getCount() + inventory.getStack(slot).getCount() <= recipeOutput.getMaxCount();
|
||||
return recipeOutput.getCount() + inventory.getStack(slot).getCount() <= recipeOutput.getMaxCount();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
public boolean canCraftAgain() {
|
||||
if (inventory.getStack(inputSlot).isEmpty()) {
|
||||
return false;
|
||||
|
@ -114,16 +114,16 @@ public class ElectricFurnaceBlockEntity extends PowerAcceptorBlockEntity
|
|||
if (!canAcceptOutput(currentRecipe, outputSlot)) {
|
||||
return false;
|
||||
}
|
||||
return !(getEnergy() < currentRecipe.getCookTime() * getEuPerTick(EnergyPerTick));
|
||||
}
|
||||
|
||||
return !(getEnergy() < currentRecipe.getCookTime() * getEuPerTick(EnergyPerTick));
|
||||
}
|
||||
|
||||
private void resetCrafter() {
|
||||
currentRecipe = null;
|
||||
cookTime = 0;
|
||||
cookTimeTotal = 0;
|
||||
updateState();
|
||||
}
|
||||
|
||||
|
||||
private void updateState() {
|
||||
Block furnaceBlock = getWorld().getBlockState(pos).getBlock();
|
||||
|
||||
|
@ -134,7 +134,7 @@ public class ElectricFurnaceBlockEntity extends PowerAcceptorBlockEntity
|
|||
}
|
||||
world.updateListeners(pos, world.getBlockState(pos), world.getBlockState(pos), 3);
|
||||
}
|
||||
|
||||
|
||||
private boolean hasAllInputs(SmeltingRecipe recipe) {
|
||||
if (recipe == null) {
|
||||
return false;
|
||||
|
@ -143,9 +143,9 @@ public class ElectricFurnaceBlockEntity extends PowerAcceptorBlockEntity
|
|||
return false;
|
||||
}
|
||||
|
||||
return recipe.matches(inventory, world);
|
||||
}
|
||||
|
||||
return recipe.matches(inventory, world);
|
||||
}
|
||||
|
||||
private void craftRecipe(SmeltingRecipe recipe) {
|
||||
if (recipe == null) {
|
||||
return;
|
||||
|
@ -156,22 +156,21 @@ public class ElectricFurnaceBlockEntity extends PowerAcceptorBlockEntity
|
|||
ItemStack outputStack = inventory.getStack(outputSlot);
|
||||
if (outputStack.isEmpty()) {
|
||||
inventory.setStack(outputSlot, recipe.getOutput().copy());
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
// Just increment. We already checked stack match and stack size
|
||||
outputStack.increment(1);
|
||||
}
|
||||
|
||||
|
||||
inventory.getStack(inputSlot).decrement(1);
|
||||
}
|
||||
|
||||
|
||||
public int getProgressScaled(int scale) {
|
||||
if (cookTimeTotal != 0) {
|
||||
return cookTime * scale / cookTimeTotal;
|
||||
}
|
||||
return 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
public int getCookTime() {
|
||||
return cookTime;
|
||||
}
|
||||
|
@ -179,7 +178,7 @@ public class ElectricFurnaceBlockEntity extends PowerAcceptorBlockEntity
|
|||
public void setCookTime(int cookTime) {
|
||||
this.cookTime = cookTime;
|
||||
}
|
||||
|
||||
|
||||
public int getCookTimeTotal() {
|
||||
return cookTimeTotal;
|
||||
}
|
||||
|
@ -187,12 +186,13 @@ public class ElectricFurnaceBlockEntity extends PowerAcceptorBlockEntity
|
|||
public void setCookTimeTotal(int cookTimeTotal) {
|
||||
this.cookTimeTotal = cookTimeTotal;
|
||||
}
|
||||
|
||||
// TilePowerAcceptor
|
||||
@Override
|
||||
public void tick() {
|
||||
super.tick();
|
||||
charge(2);
|
||||
|
||||
|
||||
if (world.isClient) {
|
||||
return;
|
||||
}
|
||||
|
@ -206,7 +206,7 @@ public class ElectricFurnaceBlockEntity extends PowerAcceptorBlockEntity
|
|||
|
||||
if (isInvDirty()) {
|
||||
if (currentRecipe == null) {
|
||||
updateCurrentRecipe();
|
||||
updateCurrentRecipe();
|
||||
}
|
||||
if (currentRecipe != null && (!hasAllInputs(currentRecipe) || !canAcceptOutput(currentRecipe, outputSlot))) {
|
||||
resetCrafter();
|
||||
|
|
|
@ -40,12 +40,12 @@ public class ExtractorBlockEntity extends GenericMachineBlockEntity implements B
|
|||
|
||||
public ExtractorBlockEntity() {
|
||||
super(TRBlockEntities.EXTRACTOR, "Extractor", TechRebornConfig.extractorMaxInput, TechRebornConfig.extractorMaxEnergy, TRContent.Machine.EXTRACTOR.block, 2);
|
||||
final int[] inputs = new int[] { 0 };
|
||||
final int[] outputs = new int[] { 1 };
|
||||
final int[] inputs = new int[]{0};
|
||||
final int[] outputs = new int[]{1};
|
||||
this.inventory = new RebornInventory<>(3, "ExtractorBlockEntity", 64, this);
|
||||
this.crafter = new RecipeCrafter(ModRecipes.EXTRACTOR, this, 2, 1, this.inventory, inputs, outputs);
|
||||
}
|
||||
|
||||
|
||||
// IContainerProvider
|
||||
@Override
|
||||
public BuiltScreenHandler createScreenHandler(int syncID, final PlayerEntity player) {
|
||||
|
|
|
@ -29,6 +29,7 @@ import net.minecraft.entity.player.PlayerEntity;
|
|||
import net.minecraft.item.ItemStack;
|
||||
import net.minecraft.server.world.ServerWorld;
|
||||
import net.minecraft.state.property.IntProperty;
|
||||
import net.minecraft.state.property.Properties;
|
||||
import net.minecraft.util.math.BlockPos;
|
||||
import net.minecraft.util.math.Direction;
|
||||
import reborncore.api.IToolDrop;
|
||||
|
@ -36,6 +37,7 @@ import reborncore.api.blockentity.InventoryProvider;
|
|||
import reborncore.client.screen.BuiltScreenHandlerProvider;
|
||||
import reborncore.client.screen.builder.BuiltScreenHandler;
|
||||
import reborncore.client.screen.builder.ScreenHandlerBuilder;
|
||||
import reborncore.common.blockentity.MultiblockWriter;
|
||||
import reborncore.common.powerSystem.PowerAcceptorBlockEntity;
|
||||
import reborncore.common.util.ItemUtils;
|
||||
import reborncore.common.util.RebornInventory;
|
||||
|
@ -50,31 +52,34 @@ import java.util.List;
|
|||
|
||||
public class GreenhouseControllerBlockEntity extends PowerAcceptorBlockEntity
|
||||
implements IToolDrop, InventoryProvider, BuiltScreenHandlerProvider {
|
||||
|
||||
|
||||
private final RebornInventory<GreenhouseControllerBlockEntity> inventory = new RebornInventory<>(7, "GreenhouseControllerBlockEntity", 64, this);
|
||||
private BlockPos multiblockCenter;
|
||||
private int ticksToNextMultiblockCheck = 0;
|
||||
private boolean growthBoost = false;
|
||||
|
||||
|
||||
public GreenhouseControllerBlockEntity() {
|
||||
super(TRBlockEntities.GREENHOUSE_CONTROLLER);
|
||||
}
|
||||
|
||||
public boolean getMultiBlock() {
|
||||
if (multiblockCenter == null || world == null) {
|
||||
return false;
|
||||
}
|
||||
for (int i = -1; i <= 1; i++) {
|
||||
for (int j = -1; j <= 1; j++) {
|
||||
BlockState block = world.getBlockState(multiblockCenter.add(i * 3, 3, i * 3));
|
||||
if (!(block.getBlock() instanceof BlockLamp) || !BlockLamp.isActive(block)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void writeMultiblock(MultiblockWriter writer) {
|
||||
BlockState lamp = TRContent.Machine.LAMP_INCANDESCENT.block.getDefaultState().with(Properties.FACING, Direction.DOWN);
|
||||
BlockState crop = Blocks.CACTUS.getDefaultState();
|
||||
|
||||
for (int i = -1; i < 2; i++) {
|
||||
for (int j = -1; j < 2; j++) {
|
||||
writer.add(i * 3, 3, j * 3, (world, pos) -> BlockLamp.isActive(world.getBlockState(pos)), lamp);
|
||||
}
|
||||
}
|
||||
|
||||
for (int i = -4; i <= 4; i++) {
|
||||
for (int j = -4; j <= 4; j++) {
|
||||
writer.add(i, 0, j, (world, pos) -> true, crop);
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public void tick() {
|
||||
if (multiblockCenter == null) {
|
||||
|
@ -82,34 +87,34 @@ public class GreenhouseControllerBlockEntity extends PowerAcceptorBlockEntity
|
|||
}
|
||||
charge(6);
|
||||
super.tick();
|
||||
|
||||
|
||||
if (world.isClient) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
if (useEnergy(getEuPerTick(TechRebornConfig.greenhouseControllerEnergyPerTick)) != getEuPerTick(TechRebornConfig.greenhouseControllerEnergyPerTick)) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
if (--ticksToNextMultiblockCheck < 0) {
|
||||
growthBoost = getMultiBlock();
|
||||
growthBoost = isMultiblockValid();
|
||||
ticksToNextMultiblockCheck = 200;
|
||||
}
|
||||
|
||||
|
||||
if (world.getTime() % 20 == 0) {
|
||||
double cyclesLimit = getSpeedMultiplier() * 4 + 1;
|
||||
while (cyclesLimit-- > 0) {
|
||||
workCycle();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
private void workCycle() {
|
||||
BlockPos blockPos = multiblockCenter.add(world.random.nextInt(9) - 4, 0, world.random.nextInt(9) - 4);
|
||||
BlockState blockState = world.getBlockState(blockPos);
|
||||
Block block = blockState.getBlock();
|
||||
|
||||
|
||||
if (growthBoost) {
|
||||
if (block instanceof Fertilizable
|
||||
|| block instanceof PlantBlock
|
||||
|
@ -122,7 +127,7 @@ public class GreenhouseControllerBlockEntity extends PowerAcceptorBlockEntity
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (block instanceof CropBlock) {
|
||||
processAgedCrop(blockState, blockPos, ((CropBlock) block).getAgeProperty(), ((CropBlock) block).getMaxAge(), 0);
|
||||
} else if (block instanceof NetherWartBlock) {
|
||||
|
@ -160,9 +165,9 @@ public class GreenhouseControllerBlockEntity extends PowerAcceptorBlockEntity
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
private void processAgedCrop(BlockState blockState, BlockPos blockPos, IntProperty ageProperty, int maxAge, int newAge) {
|
||||
if (blockState.get(ageProperty) >= maxAge) {
|
||||
if (tryHarvestBlock(blockState, blockPos)) {
|
||||
|
@ -170,7 +175,7 @@ public class GreenhouseControllerBlockEntity extends PowerAcceptorBlockEntity
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
private boolean tryHarvestBlock(BlockState blockState, BlockPos blockPos) {
|
||||
if (canUseEnergy(TechRebornConfig.greenhouseControllerEnergyPerHarvest)
|
||||
&& insertIntoInv(Block.getDroppedStacks(blockState, (ServerWorld) world, blockPos, null))) {
|
||||
|
@ -179,7 +184,7 @@ public class GreenhouseControllerBlockEntity extends PowerAcceptorBlockEntity
|
|||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
private boolean insertIntoInv(List<ItemStack> stacks) {
|
||||
boolean result = false;
|
||||
for (ItemStack stack : stacks) {
|
||||
|
@ -190,7 +195,7 @@ public class GreenhouseControllerBlockEntity extends PowerAcceptorBlockEntity
|
|||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
private boolean insertIntoInv(int slot, ItemStack stack) {
|
||||
ItemStack targetStack = inventory.getStack(slot);
|
||||
if (targetStack.isEmpty()) {
|
||||
|
@ -210,47 +215,42 @@ public class GreenhouseControllerBlockEntity extends PowerAcceptorBlockEntity
|
|||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canAcceptEnergy(Direction direction) {
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public boolean canProvideEnergy(Direction direction) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public double getBaseMaxPower() {
|
||||
return TechRebornConfig.greenhouseControllerMaxEnergy;
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public double getBaseMaxOutput() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public double getBaseMaxInput() {
|
||||
return TechRebornConfig.greenhouseControllerMaxInput;
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public ItemStack getToolDrop(PlayerEntity entityPlayer) {
|
||||
return TRContent.Machine.GREENHOUSE_CONTROLLER.getStack();
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public RebornInventory<GreenhouseControllerBlockEntity> getInventory() {
|
||||
return this.inventory;
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public boolean canBeUpgraded() {
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public BuiltScreenHandler createScreenHandler(int syncID, PlayerEntity player) {
|
||||
return new ScreenHandlerBuilder("greenhousecontroller").player(player.inventory).inventory().hotbar().addInventory()
|
||||
|
@ -261,5 +261,5 @@ public class GreenhouseControllerBlockEntity extends PowerAcceptorBlockEntity
|
|||
.energySlot(6, 8, 72).syncEnergyValue()
|
||||
.addInventory().create(this, syncID);
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
|
|
@ -42,20 +42,20 @@ public class IndustrialElectrolyzerBlockEntity extends GenericMachineBlockEntity
|
|||
|
||||
public IndustrialElectrolyzerBlockEntity() {
|
||||
super(TRBlockEntities.INDUSTRIAL_ELECTROLYZER, "IndustrialElectrolyzer", TechRebornConfig.industrialElectrolyzerMaxInput, TechRebornConfig.industrialElectrolyzerMaxEnergy, TRContent.Machine.INDUSTRIAL_ELECTROLYZER.block, 6);
|
||||
final int[] inputs = new int[] { 0, 1 };
|
||||
final int[] outputs = new int[] { 2, 3, 4, 5 };
|
||||
final int[] inputs = new int[]{0, 1};
|
||||
final int[] outputs = new int[]{2, 3, 4, 5};
|
||||
this.inventory = new RebornInventory<>(7, "IndustrialElectrolyzerBlockEntity", 64, this);
|
||||
this.crafter = new RecipeCrafter(ModRecipes.INDUSTRIAL_ELECTROLYZER, this, 2, 4, this.inventory, inputs, outputs);
|
||||
}
|
||||
|
||||
|
||||
// IContainerProvider
|
||||
@Override
|
||||
public BuiltScreenHandler createScreenHandler(int syncID, final PlayerEntity player) {
|
||||
return new ScreenHandlerBuilder("industrialelectrolyzer").player(player.inventory).inventory().hotbar()
|
||||
.addInventory().blockEntity(this)
|
||||
.filterSlot(1, 47, 72, stack -> ItemUtils.isItemEqual(stack, DynamicCellItem.getEmptyCell(1), true, true))
|
||||
.filterSlot(0, 81, 72, stack -> !ItemUtils.isItemEqual(stack, DynamicCellItem.getEmptyCell(1), true, true))
|
||||
.outputSlot(2, 51, 24).outputSlot(3, 71, 24).outputSlot(4, 91, 24).outputSlot(5, 111, 24)
|
||||
.energySlot(6, 8, 72).syncEnergyValue().syncCrafterValue().addInventory().create(this, syncID);
|
||||
.addInventory().blockEntity(this)
|
||||
.filterSlot(1, 47, 72, stack -> ItemUtils.isItemEqual(stack, DynamicCellItem.getEmptyCell(1), true, true))
|
||||
.filterSlot(0, 81, 72, stack -> !ItemUtils.isItemEqual(stack, DynamicCellItem.getEmptyCell(1), true, true))
|
||||
.outputSlot(2, 51, 24).outputSlot(3, 71, 24).outputSlot(4, 91, 24).outputSlot(5, 111, 24)
|
||||
.energySlot(6, 8, 72).syncEnergyValue().syncCrafterValue().addInventory().create(this, syncID);
|
||||
}
|
||||
}
|
|
@ -47,7 +47,7 @@ public class PlayerDectectorBlockEntity extends PowerAcceptorBlockEntity impleme
|
|||
public PlayerDectectorBlockEntity() {
|
||||
super(TRBlockEntities.PLAYER_DETECTOR);
|
||||
}
|
||||
|
||||
|
||||
public boolean isProvidingPower() {
|
||||
return redstone;
|
||||
}
|
||||
|
@ -60,7 +60,7 @@ public class PlayerDectectorBlockEntity extends PowerAcceptorBlockEntity impleme
|
|||
boolean lastRedstone = redstone;
|
||||
redstone = false;
|
||||
if (canUseEnergy(TechRebornConfig.playerDetectorEuPerTick)) {
|
||||
for(PlayerEntity player : world.getPlayers()){
|
||||
for (PlayerEntity player : world.getPlayers()) {
|
||||
if (player.distanceTo(player) <= 256.0D) {
|
||||
PlayerDetectorType type = world.getBlockState(pos).get(BlockPlayerDetector.TYPE);
|
||||
if (type == PlayerDetectorType.ALL) {// ALL
|
||||
|
@ -84,7 +84,7 @@ public class PlayerDectectorBlockEntity extends PowerAcceptorBlockEntity impleme
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public double getBaseMaxPower() {
|
||||
return TechRebornConfig.playerDetectorMaxEnergy;
|
||||
|
|
|
@ -61,7 +61,7 @@ public class RecyclerBlockEntity extends PowerAcceptorBlockEntity
|
|||
public int gaugeProgressScaled(int scale) {
|
||||
return progress * scale / time;
|
||||
}
|
||||
|
||||
|
||||
public int getProgress() {
|
||||
return progress;
|
||||
}
|
||||
|
@ -69,7 +69,7 @@ public class RecyclerBlockEntity extends PowerAcceptorBlockEntity
|
|||
public void setProgress(int progress) {
|
||||
this.progress = progress;
|
||||
}
|
||||
|
||||
|
||||
public void recycleItems() {
|
||||
ItemStack itemstack = TRContent.Parts.SCRAP.getStack();
|
||||
final int randomchance = this.world.random.nextInt(chance);
|
||||
|
@ -77,8 +77,7 @@ public class RecyclerBlockEntity extends PowerAcceptorBlockEntity
|
|||
if (randomchance == 1) {
|
||||
if (inventory.getStack(1).isEmpty()) {
|
||||
inventory.setStack(1, itemstack.copy());
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
inventory.getStack(1).increment(itemstack.getCount());
|
||||
}
|
||||
}
|
||||
|
@ -86,16 +85,13 @@ public class RecyclerBlockEntity extends PowerAcceptorBlockEntity
|
|||
}
|
||||
|
||||
public boolean canRecycle() {
|
||||
return !inventory.getStack(0) .isEmpty() && hasSlotGotSpace(1);
|
||||
return !inventory.getStack(0).isEmpty() && hasSlotGotSpace(1);
|
||||
}
|
||||
|
||||
public boolean hasSlotGotSpace(int slot) {
|
||||
if (inventory.getStack(slot).isEmpty()) {
|
||||
return true;
|
||||
} else if (inventory.getStack(slot).getCount() < inventory.getStack(slot).getMaxCount()) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
} else return inventory.getStack(slot).getCount() < inventory.getStack(slot).getMaxCount();
|
||||
}
|
||||
|
||||
public boolean isBurning() {
|
||||
|
@ -129,13 +125,12 @@ public class RecyclerBlockEntity extends PowerAcceptorBlockEntity
|
|||
boolean updateInventory = false;
|
||||
if (canRecycle() && !isBurning() && getEnergy() != 0) {
|
||||
setBurning(true);
|
||||
}
|
||||
else if (isBurning()) {
|
||||
} else if (isBurning()) {
|
||||
if (useEnergy(getEuPerTick(cost)) != getEuPerTick(cost)) {
|
||||
this.setBurning(false);
|
||||
}
|
||||
progress++;
|
||||
if (progress >= Math.max((int) (time* (1.0 - getSpeedMultiplier())), 1)) {
|
||||
if (progress >= Math.max((int) (time * (1.0 - getSpeedMultiplier())), 1)) {
|
||||
progress = 0;
|
||||
recycleItems();
|
||||
updateInventory = true;
|
||||
|
@ -144,7 +139,7 @@ public class RecyclerBlockEntity extends PowerAcceptorBlockEntity
|
|||
}
|
||||
|
||||
updateState();
|
||||
|
||||
|
||||
if (updateInventory) {
|
||||
markDirty();
|
||||
}
|
||||
|
@ -174,13 +169,13 @@ public class RecyclerBlockEntity extends PowerAcceptorBlockEntity
|
|||
public double getBaseMaxInput() {
|
||||
return TechRebornConfig.recyclerMaxInput;
|
||||
}
|
||||
|
||||
|
||||
// TileMachineBase
|
||||
@Override
|
||||
public boolean canBeUpgraded() {
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
// IToolDrop
|
||||
@Override
|
||||
public ItemStack getToolDrop(PlayerEntity entityPlayer) {
|
||||
|
|
|
@ -0,0 +1,248 @@
|
|||
/*
|
||||
* This file is part of TechReborn, licensed under the MIT License (MIT).
|
||||
*
|
||||
* Copyright (c) 2020 TechReborn
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
* SOFTWARE.
|
||||
*/
|
||||
|
||||
package techreborn.blockentity.machine.tier1;
|
||||
|
||||
import net.minecraft.block.BlockState;
|
||||
import net.minecraft.block.Blocks;
|
||||
import net.minecraft.block.entity.HopperBlockEntity;
|
||||
import net.minecraft.entity.player.PlayerEntity;
|
||||
import net.minecraft.inventory.Inventory;
|
||||
import net.minecraft.item.ItemStack;
|
||||
import net.minecraft.nbt.CompoundTag;
|
||||
import net.minecraft.sound.SoundCategory;
|
||||
import net.minecraft.util.math.BlockPos;
|
||||
import net.minecraft.util.math.Direction;
|
||||
import net.minecraft.world.World;
|
||||
import reborncore.common.blockentity.MachineBaseBlockEntity;
|
||||
import reborncore.common.util.WorldUtils;
|
||||
import techreborn.blocks.machine.tier1.ResinBasinBlock;
|
||||
import techreborn.blocks.misc.BlockRubberLog;
|
||||
import techreborn.config.TechRebornConfig;
|
||||
import techreborn.init.ModSounds;
|
||||
import techreborn.init.TRBlockEntities;
|
||||
import techreborn.init.TRContent;
|
||||
|
||||
import static reborncore.api.items.InventoryUtils.getInventoryAt;
|
||||
|
||||
public class ResinBasinBlockEntity extends MachineBaseBlockEntity {
|
||||
private Direction direction = Direction.NORTH;
|
||||
|
||||
// State
|
||||
private boolean isPouring = false;
|
||||
private boolean isFull = false;
|
||||
|
||||
private int pouringTimer = 0;
|
||||
|
||||
public ResinBasinBlockEntity() {
|
||||
super(TRBlockEntities.RESIN_BASIN);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void tick() {
|
||||
super.tick();
|
||||
if (world == null || world.isClient) return;
|
||||
|
||||
boolean shouldUpdateState = false;
|
||||
|
||||
if (isPouring) {
|
||||
pouringTimer--;
|
||||
|
||||
// Play pouring audio
|
||||
if (world.getTime() % 20 == 0) {
|
||||
world.playSound(null, pos, ModSounds.SAP_EXTRACT, SoundCategory.BLOCKS, 1F, 1F);
|
||||
}
|
||||
|
||||
if (pouringTimer <= 0) {
|
||||
isPouring = false;
|
||||
isFull = true;
|
||||
shouldUpdateState = true;
|
||||
}
|
||||
}
|
||||
|
||||
// Try and deposit
|
||||
if (isFull) {
|
||||
// Get inventory
|
||||
Inventory invBelow = getInventoryBelow();
|
||||
if (invBelow != null) {
|
||||
|
||||
ItemStack out = new ItemStack(TRContent.Parts.SAP, (Math.random() <= 0.5) ? 1 : 2);
|
||||
out = HopperBlockEntity.transfer(null, invBelow, out, Direction.UP);
|
||||
|
||||
if (out.isEmpty()) {
|
||||
// Successfully deposited
|
||||
isFull = false;
|
||||
shouldUpdateState = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
boolean readyToHarvest = !isFull && !isPouring;
|
||||
|
||||
// Ensuring it's placed on a log
|
||||
if ((readyToHarvest || world.getTime() % 20 == 0) && !validPlacement()) {
|
||||
// Not placed on log, drop on ground
|
||||
world.setBlockState(pos, Blocks.AIR.getDefaultState());
|
||||
WorldUtils.dropItem(TRContent.Machine.RESIN_BASIN.asItem(), world, pos);
|
||||
return;
|
||||
}
|
||||
|
||||
if (readyToHarvest) {
|
||||
// Check for rubber
|
||||
if (world.getTime() % TechRebornConfig.checkForSapTime == 0) {
|
||||
BlockPos targetRubber = getLogWithSap();
|
||||
|
||||
if (targetRubber != null) {
|
||||
// We have a valid sap log, harvest it
|
||||
world.setBlockState(targetRubber, world.getBlockState(targetRubber).with(BlockRubberLog.HAS_SAP, false).with(BlockRubberLog.SAP_SIDE, Direction.fromHorizontal(0)));
|
||||
isPouring = true;
|
||||
pouringTimer = TechRebornConfig.sapTimeTicks;
|
||||
shouldUpdateState = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (shouldUpdateState) {
|
||||
setPouringState(isPouring);
|
||||
setFullState(isFull);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onBreak(World world, PlayerEntity playerEntity, BlockPos blockPos, BlockState blockState) {
|
||||
super.onBreak(world, playerEntity, blockPos, blockState);
|
||||
|
||||
// Drop a sap if full
|
||||
if (this.isFull) {
|
||||
ItemStack out = new ItemStack(TRContent.Parts.SAP, (Math.random() <= 0.6) ? 1 : 2);
|
||||
WorldUtils.dropItem(out, world, pos);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public CompoundTag toTag(CompoundTag tagCompound) {
|
||||
super.toTag(tagCompound);
|
||||
|
||||
return tagCompound;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void fromTag(BlockState blockState, CompoundTag tagCompound) {
|
||||
super.fromTag(blockState, tagCompound);
|
||||
|
||||
this.isFull = blockState.get(ResinBasinBlock.FULL);
|
||||
|
||||
if (blockState.get(ResinBasinBlock.POURING)) {
|
||||
this.isPouring = true;
|
||||
pouringTimer = TechRebornConfig.sapTimeTicks;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onLoad() {
|
||||
super.onLoad();
|
||||
|
||||
if (world == null || world.isClient) return;
|
||||
|
||||
// Set facing
|
||||
direction = world.getBlockState(pos).get(ResinBasinBlock.FACING).getOpposite();
|
||||
}
|
||||
|
||||
private Inventory getInventoryBelow() {
|
||||
return getInventoryAt(this.getWorld(), this.pos.offset(Direction.DOWN));
|
||||
}
|
||||
|
||||
private boolean validPlacement() {
|
||||
return world.getBlockState(this.pos.offset(direction)).getBlock() == TRContent.RUBBER_LOG;
|
||||
}
|
||||
|
||||
|
||||
private BlockPos getLogWithSap() {
|
||||
// Checking origin block
|
||||
BlockPos originPos = this.pos.offset(direction);
|
||||
BlockState originState = world.getBlockState(originPos);
|
||||
|
||||
if (originState.get(BlockRubberLog.HAS_SAP)) {
|
||||
return originPos;
|
||||
}
|
||||
|
||||
boolean shouldExit = false;
|
||||
BlockPos current = originPos;
|
||||
|
||||
// Progress Up
|
||||
while (!shouldExit) {
|
||||
current = current.offset(Direction.UP);
|
||||
|
||||
BlockState state = world.getBlockState(current);
|
||||
if (state.getBlock() == TRContent.RUBBER_LOG) {
|
||||
if (state.get(BlockRubberLog.HAS_SAP)) {
|
||||
return current;
|
||||
}
|
||||
} else {
|
||||
shouldExit = true;
|
||||
}
|
||||
}
|
||||
|
||||
current = originPos;
|
||||
shouldExit = false;
|
||||
// Progress Down
|
||||
while (!shouldExit) {
|
||||
current = current.offset(Direction.DOWN);
|
||||
|
||||
BlockState state = world.getBlockState(current);
|
||||
if (state.getBlock() == TRContent.RUBBER_LOG) {
|
||||
if (state.get(BlockRubberLog.HAS_SAP)) {
|
||||
return current;
|
||||
}
|
||||
} else {
|
||||
shouldExit = true;
|
||||
}
|
||||
}
|
||||
|
||||
// Could not find a rubber log with sap
|
||||
return null;
|
||||
}
|
||||
|
||||
private void setPouringState(boolean value) {
|
||||
if (world != null) {
|
||||
world.setBlockState(pos, world.getBlockState(pos).with(ResinBasinBlock.POURING, value));
|
||||
}
|
||||
}
|
||||
|
||||
private void setFullState(boolean value) {
|
||||
if (world != null) {
|
||||
world.setBlockState(pos, world.getBlockState(pos).with(ResinBasinBlock.FULL, value));
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean hasSlotConfig() {
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canBeUpgraded() {
|
||||
return false;
|
||||
}
|
||||
}
|
|
@ -59,9 +59,9 @@ import java.util.stream.Collectors;
|
|||
//TODO add tick and power bars.
|
||||
|
||||
public class RollingMachineBlockEntity extends PowerAcceptorBlockEntity
|
||||
implements IToolDrop, InventoryProvider, BuiltScreenHandlerProvider {
|
||||
implements IToolDrop, InventoryProvider, BuiltScreenHandlerProvider {
|
||||
|
||||
public int[] craftingSlots = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
|
||||
public int[] craftingSlots = new int[]{0, 1, 2, 3, 4, 5, 6, 7, 8};
|
||||
private CraftingInventory craftCache;
|
||||
public RebornInventory<RollingMachineBlockEntity> inventory = new RebornInventory<>(12, "RollingMachineBlockEntity", 64, this);
|
||||
public boolean isRunning;
|
||||
|
@ -69,7 +69,7 @@ public class RollingMachineBlockEntity extends PowerAcceptorBlockEntity
|
|||
@Nonnull
|
||||
public ItemStack currentRecipeOutput;
|
||||
public RollingMachineRecipe currentRecipe;
|
||||
private int outputSlot;
|
||||
private final int outputSlot;
|
||||
public boolean locked = false;
|
||||
public int balanceSlot = 0;
|
||||
|
||||
|
@ -177,12 +177,12 @@ public class RollingMachineBlockEntity extends PowerAcceptorBlockEntity
|
|||
}
|
||||
|
||||
public void setIsActive(boolean active) {
|
||||
if (active == isRunning){
|
||||
if (active == isRunning) {
|
||||
return;
|
||||
}
|
||||
isRunning = active;
|
||||
if (this.getWorld().getBlockState(this.getPos()).getBlock() instanceof BlockMachineBase) {
|
||||
BlockMachineBase blockMachineBase = (BlockMachineBase)this.getWorld().getBlockState(this.getPos()).getBlock();
|
||||
BlockMachineBase blockMachineBase = (BlockMachineBase) this.getWorld().getBlockState(this.getPos()).getBlock();
|
||||
blockMachineBase.setActive(active, this.getWorld(), this.getPos());
|
||||
}
|
||||
this.getWorld().updateListeners(this.getPos(), this.getWorld().getBlockState(this.getPos()), this.getWorld().getBlockState(this.getPos()), 3);
|
||||
|
@ -213,7 +213,7 @@ public class RollingMachineBlockEntity extends PowerAcceptorBlockEntity
|
|||
List<Integer> possibleSlots = new ArrayList<>();
|
||||
for (int s = 0; s < currentRecipe.getPreviewInputs().size(); s++) {
|
||||
ItemStack stackInSlot = inventory.getStack(s);
|
||||
Ingredient ingredient = (Ingredient) currentRecipe.getPreviewInputs().get(s);
|
||||
Ingredient ingredient = currentRecipe.getPreviewInputs().get(s);
|
||||
if (ingredient != Ingredient.EMPTY && ingredient.test(sourceStack)) {
|
||||
if (stackInSlot.isEmpty()) {
|
||||
possibleSlots.add(s);
|
||||
|
@ -223,32 +223,32 @@ public class RollingMachineBlockEntity extends PowerAcceptorBlockEntity
|
|||
}
|
||||
}
|
||||
|
||||
if(!possibleSlots.isEmpty()){
|
||||
int totalItems = possibleSlots.stream()
|
||||
.mapToInt(value -> inventory.getStack(value).getCount()).sum();
|
||||
if (!possibleSlots.isEmpty()) {
|
||||
int totalItems = possibleSlots.stream()
|
||||
.mapToInt(value -> inventory.getStack(value).getCount()).sum();
|
||||
int slots = possibleSlots.size();
|
||||
|
||||
//This makes an array of ints with the best possible slot EnvTyperibution
|
||||
int[] split = new int[slots];
|
||||
int remainder = totalItems % slots;
|
||||
Arrays.fill(split, totalItems / slots);
|
||||
while (remainder > 0){
|
||||
while (remainder > 0) {
|
||||
for (int i = 0; i < split.length; i++) {
|
||||
if(remainder > 0){
|
||||
split[i] +=1;
|
||||
remainder --;
|
||||
if (remainder > 0) {
|
||||
split[i] += 1;
|
||||
remainder--;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
List<Integer> slotEnvTyperubution = possibleSlots.stream()
|
||||
.mapToInt(value -> inventory.getStack(value).getCount())
|
||||
.boxed().collect(Collectors.toList());
|
||||
.mapToInt(value -> inventory.getStack(value).getCount())
|
||||
.boxed().collect(Collectors.toList());
|
||||
|
||||
boolean needsBalance = false;
|
||||
for (int i = 0; i < split.length; i++) {
|
||||
int required = split[i];
|
||||
if(slotEnvTyperubution.contains(required)){
|
||||
if (slotEnvTyperubution.contains(required)) {
|
||||
//We need to remove the int, not at the int, this seems to work around that
|
||||
slotEnvTyperubution.remove(new Integer(required));
|
||||
} else {
|
||||
|
@ -276,10 +276,10 @@ public class RollingMachineBlockEntity extends PowerAcceptorBlockEntity
|
|||
}
|
||||
}
|
||||
if (bestSlot == null
|
||||
|| bestSlot.getLeft() == balanceSlot
|
||||
|| bestSlot.getRight() == sourceStack.getCount()
|
||||
|| inventory.getStack(bestSlot.getLeft()).isEmpty()
|
||||
|| !ItemUtils.isItemEqual(sourceStack, inventory.getStack(bestSlot.getLeft()), true, true)) {
|
||||
|| bestSlot.getLeft() == balanceSlot
|
||||
|| bestSlot.getRight() == sourceStack.getCount()
|
||||
|| inventory.getStack(bestSlot.getLeft()).isEmpty()
|
||||
|| !ItemUtils.isItemEqual(sourceStack, inventory.getStack(bestSlot.getLeft()), true, true)) {
|
||||
return Optional.empty();
|
||||
}
|
||||
sourceStack.decrement(1);
|
||||
|
@ -322,13 +322,13 @@ public class RollingMachineBlockEntity extends PowerAcceptorBlockEntity
|
|||
return ItemUtils.isItemEqual(stack, output, true, true);
|
||||
}
|
||||
|
||||
public List<RollingMachineRecipe> getAllRecipe(World world){
|
||||
public List<RollingMachineRecipe> getAllRecipe(World world) {
|
||||
return ModRecipes.ROLLING_MACHINE.getRecipes(world);
|
||||
}
|
||||
|
||||
public ItemStack findMatchingRecipeOutput(CraftingInventory inv, World world) {
|
||||
RollingMachineRecipe recipe = findMatchingRecipe(inv, world);
|
||||
if(recipe == null){
|
||||
if (recipe == null) {
|
||||
return ItemStack.EMPTY;
|
||||
}
|
||||
return recipe.getOutput();
|
||||
|
@ -342,7 +342,7 @@ public class RollingMachineBlockEntity extends PowerAcceptorBlockEntity
|
|||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public ItemStack getToolDrop(final PlayerEntity entityPlayer) {
|
||||
return TRContent.Machine.ROLLING_MACHINE.getStack();
|
||||
|
@ -379,24 +379,24 @@ public class RollingMachineBlockEntity extends PowerAcceptorBlockEntity
|
|||
}
|
||||
|
||||
public int getBurnTimeRemainingScaled(final int scale) {
|
||||
if (tickTime == 0 || Math.max((int) (TechRebornConfig.rollingMachineRunTime* (1.0 - getSpeedMultiplier())), 1) == 0) {
|
||||
if (tickTime == 0 || Math.max((int) (TechRebornConfig.rollingMachineRunTime * (1.0 - getSpeedMultiplier())), 1) == 0) {
|
||||
return 0;
|
||||
}
|
||||
return tickTime * scale / Math.max((int) (TechRebornConfig.rollingMachineRunTime* (1.0 - getSpeedMultiplier())), 1);
|
||||
return tickTime * scale / Math.max((int) (TechRebornConfig.rollingMachineRunTime * (1.0 - getSpeedMultiplier())), 1);
|
||||
}
|
||||
|
||||
@Override
|
||||
public BuiltScreenHandler createScreenHandler(int syncID, final PlayerEntity player) {
|
||||
return new ScreenHandlerBuilder("rollingmachine").player(player.inventory)
|
||||
.inventory().hotbar()
|
||||
.addInventory().blockEntity(this)
|
||||
.slot(0, 30, 22).slot(1, 48, 22).slot(2, 66, 22)
|
||||
.slot(3, 30, 40).slot(4, 48, 40).slot(5, 66, 40)
|
||||
.slot(6, 30, 58).slot(7, 48, 58).slot(8, 66, 58)
|
||||
.onCraft(inv -> this.inventory.setStack(1, findMatchingRecipeOutput(getCraftingMatrix(), this.world)))
|
||||
.outputSlot(9, 124, 40)
|
||||
.energySlot(10, 8, 70)
|
||||
.syncEnergyValue().sync(this::getBurnTime, this::setBurnTime).sync(this::getLockedInt, this::setLockedInt).addInventory().create(this, syncID);
|
||||
.inventory().hotbar()
|
||||
.addInventory().blockEntity(this)
|
||||
.slot(0, 30, 22).slot(1, 48, 22).slot(2, 66, 22)
|
||||
.slot(3, 30, 40).slot(4, 48, 40).slot(5, 66, 40)
|
||||
.slot(6, 30, 58).slot(7, 48, 58).slot(8, 66, 58)
|
||||
.onCraft(inv -> this.inventory.setStack(1, findMatchingRecipeOutput(getCraftingMatrix(), this.world)))
|
||||
.outputSlot(9, 124, 40)
|
||||
.energySlot(10, 8, 70)
|
||||
.syncEnergyValue().sync(this::getBurnTime, this::setBurnTime).sync(this::getLockedInt, this::setLockedInt).addInventory().create(this, syncID);
|
||||
}
|
||||
|
||||
//Easyest way to sync back to the client
|
||||
|
@ -409,8 +409,8 @@ public class RollingMachineBlockEntity extends PowerAcceptorBlockEntity
|
|||
}
|
||||
|
||||
public int getProgressScaled(final int scale) {
|
||||
if (tickTime != 0 && Math.max((int) (TechRebornConfig.rollingMachineRunTime* (1.0 - getSpeedMultiplier())), 1) != 0) {
|
||||
return tickTime * scale / Math.max((int) (TechRebornConfig.rollingMachineRunTime* (1.0 - getSpeedMultiplier())), 1);
|
||||
if (tickTime != 0 && Math.max((int) (TechRebornConfig.rollingMachineRunTime * (1.0 - getSpeedMultiplier())), 1) != 0) {
|
||||
return tickTime * scale / Math.max((int) (TechRebornConfig.rollingMachineRunTime * (1.0 - getSpeedMultiplier())), 1);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -39,12 +39,12 @@ public class ScrapboxinatorBlockEntity extends GenericMachineBlockEntity impleme
|
|||
|
||||
public ScrapboxinatorBlockEntity() {
|
||||
super(TRBlockEntities.SCRAPBOXINATOR, "Scrapboxinator", TechRebornConfig.scrapboxinatorMaxInput, TechRebornConfig.scrapboxinatorMaxEnergy, TRContent.Machine.SCRAPBOXINATOR.block, 2);
|
||||
final int[] inputs = new int[] { 0 };
|
||||
final int[] outputs = new int[] { 1 };
|
||||
final int[] inputs = new int[]{0};
|
||||
final int[] outputs = new int[]{1};
|
||||
this.inventory = new RebornInventory<>(3, "ScrapboxinatorBlockEntity", 64, this);
|
||||
this.crafter = new ScrapboxRecipeCrafter(this, this.inventory, inputs, outputs);
|
||||
}
|
||||
|
||||
|
||||
// TileMachineBase
|
||||
@Override
|
||||
public boolean canBeUpgraded() {
|
||||
|
|
|
@ -40,8 +40,8 @@ public class SoildCanningMachineBlockEntity extends GenericMachineBlockEntity im
|
|||
|
||||
public SoildCanningMachineBlockEntity() {
|
||||
super(TRBlockEntities.SOLID_CANNING_MACHINE, "SolidCanningMachine", TechRebornConfig.solidCanningMachineMaxInput, TechRebornConfig.solidCanningMachineMaxEnergy, TRContent.Machine.SOLID_CANNING_MACHINE.block, 3);
|
||||
final int[] inputs = new int[] { 0, 1 };
|
||||
final int[] outputs = new int[] { 2 };
|
||||
final int[] inputs = new int[]{0, 1};
|
||||
final int[] outputs = new int[]{2};
|
||||
this.inventory = new RebornInventory<>(4, "SolidCanningMachineBlockEntity", 64, this);
|
||||
this.crafter = new RecipeCrafter(ModRecipes.SOLID_CANNING_MACHINE, this, 2, 1, this.inventory, inputs, outputs);
|
||||
}
|
||||
|
@ -50,10 +50,10 @@ public class SoildCanningMachineBlockEntity extends GenericMachineBlockEntity im
|
|||
@Override
|
||||
public BuiltScreenHandler createScreenHandler(int syncID, final PlayerEntity player) {
|
||||
return new ScreenHandlerBuilder("solidcanningmachine").player(player.inventory).inventory().hotbar()
|
||||
.addInventory().blockEntity(this)
|
||||
.slot(0, 34, 47)
|
||||
.slot(1, 126, 47)
|
||||
.outputSlot(2, 80, 47).energySlot(3, 8, 72).syncEnergyValue().syncCrafterValue().addInventory()
|
||||
.create(this, syncID);
|
||||
.addInventory().blockEntity(this)
|
||||
.slot(0, 34, 47)
|
||||
.slot(1, 126, 47)
|
||||
.outputSlot(2, 80, 47).energySlot(3, 8, 72).syncEnergyValue().syncCrafterValue().addInventory()
|
||||
.create(this, syncID);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -39,8 +39,8 @@ public class WireMillBlockEntity extends GenericMachineBlockEntity implements Bu
|
|||
|
||||
public WireMillBlockEntity() {
|
||||
super(TRBlockEntities.WIRE_MILL, "WireMill", 32, 1000, TRContent.Machine.WIRE_MILL.block, 2);
|
||||
final int[] inputs = new int[] { 0 };
|
||||
final int[] outputs = new int[] { 1 };
|
||||
final int[] inputs = new int[]{0};
|
||||
final int[] outputs = new int[]{1};
|
||||
this.inventory = new RebornInventory<>(3, "WireMillBlockEntity", 64, this);
|
||||
this.crafter = new RecipeCrafter(ModRecipes.WIRE_MILL, this, 1, 1, this.inventory, inputs, outputs);
|
||||
}
|
||||
|
@ -49,13 +49,13 @@ public class WireMillBlockEntity extends GenericMachineBlockEntity implements Bu
|
|||
@Override
|
||||
public BuiltScreenHandler createScreenHandler(int syncID, final PlayerEntity player) {
|
||||
return new ScreenHandlerBuilder("wiremill").player(player.inventory).inventory().hotbar()
|
||||
.addInventory().blockEntity(this)
|
||||
.slot(0, 55, 45)
|
||||
.outputSlot(1, 101, 45)
|
||||
.energySlot(2, 8, 72)
|
||||
.syncEnergyValue()
|
||||
.syncCrafterValue()
|
||||
.addInventory()
|
||||
.create(this, syncID);
|
||||
.addInventory().blockEntity(this)
|
||||
.slot(0, 55, 45)
|
||||
.outputSlot(1, 101, 45)
|
||||
.energySlot(2, 8, 72)
|
||||
.syncEnergyValue()
|
||||
.syncCrafterValue()
|
||||
.addInventory()
|
||||
.create(this, syncID);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -55,10 +55,10 @@ public class ChunkLoaderBlockEntity extends MachineBaseBlockEntity implements IT
|
|||
private String ownerUdid;
|
||||
|
||||
public ChunkLoaderBlockEntity() {
|
||||
super(TRBlockEntities.CHUNK_LOADER );
|
||||
super(TRBlockEntities.CHUNK_LOADER);
|
||||
this.radius = 1;
|
||||
}
|
||||
|
||||
|
||||
public void handleGuiInputFromClient(int buttonID, @Nullable PlayerEntity playerEntity) {
|
||||
radius += buttonID;
|
||||
|
||||
|
@ -71,7 +71,7 @@ public class ChunkLoaderBlockEntity extends MachineBaseBlockEntity implements IT
|
|||
|
||||
reload();
|
||||
|
||||
if(playerEntity != null){
|
||||
if (playerEntity != null) {
|
||||
ChunkLoaderManager manager = ChunkLoaderManager.get(getWorld());
|
||||
manager.syncChunkLoaderToClient((ServerPlayerEntity) playerEntity, getPos());
|
||||
}
|
||||
|
@ -82,20 +82,20 @@ public class ChunkLoaderBlockEntity extends MachineBaseBlockEntity implements IT
|
|||
return TRContent.Machine.CHUNK_LOADER.getStack();
|
||||
}
|
||||
|
||||
private void reload(){
|
||||
private void reload() {
|
||||
unloadAll();
|
||||
load();
|
||||
}
|
||||
|
||||
private void load(){
|
||||
private void load() {
|
||||
ChunkLoaderManager manager = ChunkLoaderManager.get(getWorld());
|
||||
ChunkPos rootPos = getChunkPos();
|
||||
int loadRadius = radius -1;
|
||||
int loadRadius = radius - 1;
|
||||
for (int i = -loadRadius; i <= loadRadius; i++) {
|
||||
for (int j = -loadRadius; j <= loadRadius; j++) {
|
||||
ChunkPos loadPos = new ChunkPos(rootPos.x + i, rootPos.z + j);
|
||||
|
||||
if(!manager.isChunkLoaded(getWorld(), loadPos, getPos())){
|
||||
if (!manager.isChunkLoaded(getWorld(), loadPos, getPos())) {
|
||||
manager.loadChunk(getWorld(), loadPos, getPos(), ownerUdid);
|
||||
}
|
||||
}
|
||||
|
@ -105,7 +105,7 @@ public class ChunkLoaderBlockEntity extends MachineBaseBlockEntity implements IT
|
|||
|
||||
@Override
|
||||
public void onBreak(World world, PlayerEntity playerEntity, BlockPos blockPos, BlockState blockState) {
|
||||
if(world.isClient){
|
||||
if (world.isClient) {
|
||||
return;
|
||||
}
|
||||
unloadAll();
|
||||
|
@ -114,19 +114,19 @@ public class ChunkLoaderBlockEntity extends MachineBaseBlockEntity implements IT
|
|||
|
||||
@Override
|
||||
public void onPlace(World worldIn, BlockPos pos, BlockState state, LivingEntity placer, ItemStack stack) {
|
||||
if(world.isClient){
|
||||
if (world.isClient) {
|
||||
return;
|
||||
}
|
||||
ownerUdid = placer.getUuidAsString();
|
||||
reload();
|
||||
}
|
||||
|
||||
private void unloadAll(){
|
||||
private void unloadAll() {
|
||||
ChunkLoaderManager manager = ChunkLoaderManager.get(world);
|
||||
manager.unloadChunkLoader(world, getPos());
|
||||
}
|
||||
|
||||
public ChunkPos getChunkPos(){
|
||||
public ChunkPos getChunkPos() {
|
||||
return new ChunkPos(getPos());
|
||||
}
|
||||
|
||||
|
@ -144,7 +144,7 @@ public class ChunkLoaderBlockEntity extends MachineBaseBlockEntity implements IT
|
|||
super.fromTag(blockState, nbttagcompound);
|
||||
this.radius = nbttagcompound.getInt("radius");
|
||||
this.ownerUdid = nbttagcompound.getString("ownerUdid");
|
||||
if(!StringUtils.isBlank(ownerUdid)){
|
||||
if (!StringUtils.isBlank(ownerUdid)) {
|
||||
nbttagcompound.putString("ownerUdid", this.ownerUdid);
|
||||
}
|
||||
inventory.read(nbttagcompound);
|
||||
|
@ -158,7 +158,7 @@ public class ChunkLoaderBlockEntity extends MachineBaseBlockEntity implements IT
|
|||
public int getRadius() {
|
||||
return radius;
|
||||
}
|
||||
|
||||
|
||||
public void setRadius(int radius) {
|
||||
this.radius = radius;
|
||||
}
|
||||
|
|
|
@ -48,29 +48,29 @@ public class IndustrialCentrifugeBlockEntity extends GenericMachineBlockEntity i
|
|||
|
||||
public IndustrialCentrifugeBlockEntity() {
|
||||
super(TRBlockEntities.INDUSTRIAL_CENTRIFUGE, "IndustrialCentrifuge", TechRebornConfig.industrialCentrifugeMaxInput, TechRebornConfig.industrialCentrifugeMaxEnergy, TRContent.Machine.INDUSTRIAL_CENTRIFUGE.block, 6);
|
||||
final int[] inputs = new int[] { 0, 1 };
|
||||
final int[] outputs = new int[] { 2, 3, 4, 5 };
|
||||
final int[] inputs = new int[]{0, 1};
|
||||
final int[] outputs = new int[]{2, 3, 4, 5};
|
||||
this.inventory = new RebornInventory<>(7, "IndustrialCentrifugeBlockEntity", 64, this);
|
||||
this.crafter = new RecipeCrafter(ModRecipes.CENTRIFUGE, this, 2, 4, this.inventory, inputs, outputs);
|
||||
}
|
||||
|
||||
|
||||
// IContainerProvider
|
||||
@Override
|
||||
public BuiltScreenHandler createScreenHandler(int syncID, final PlayerEntity player) {
|
||||
return new ScreenHandlerBuilder("centrifuge").player(player.inventory).inventory().hotbar()
|
||||
.addInventory().blockEntity(this)
|
||||
.filterSlot(1, 40, 54, stack -> ItemUtils.isItemEqual(stack, DynamicCellItem.getEmptyCell(1), true, true))
|
||||
.filterSlot(0, 40, 34, stack -> !ItemUtils.isItemEqual(stack, DynamicCellItem.getEmptyCell(1), true, true))
|
||||
.outputSlot(2, 82, 44).outputSlot(3, 101, 25)
|
||||
.outputSlot(4, 120, 44).outputSlot(5, 101, 63).energySlot(6, 8, 72).syncEnergyValue()
|
||||
.syncCrafterValue().addInventory().create(this, syncID);
|
||||
.addInventory().blockEntity(this)
|
||||
.filterSlot(1, 40, 54, stack -> ItemUtils.isItemEqual(stack, DynamicCellItem.getEmptyCell(1), true, true))
|
||||
.filterSlot(0, 40, 34, stack -> !ItemUtils.isItemEqual(stack, DynamicCellItem.getEmptyCell(1), true, true))
|
||||
.outputSlot(2, 82, 44).outputSlot(3, 101, 25)
|
||||
.outputSlot(4, 120, 44).outputSlot(5, 101, 63).energySlot(6, 8, 72).syncEnergyValue()
|
||||
.syncCrafterValue().addInventory().create(this, syncID);
|
||||
}
|
||||
|
||||
|
||||
// IListInfoProvider
|
||||
@Override
|
||||
public void addInfo(final List<Text> info, final boolean isReal, boolean hasData) {
|
||||
super.addInfo(info, isReal, hasData);
|
||||
if(Screen.hasControlDown()) {
|
||||
if (Screen.hasControlDown()) {
|
||||
info.add(new LiteralText("Round and round it goes"));
|
||||
}
|
||||
}
|
||||
|
|
|
@ -46,7 +46,7 @@ public class MatterFabricatorBlockEntity extends PowerAcceptorBlockEntity
|
|||
private int amplifier = 0;
|
||||
|
||||
public MatterFabricatorBlockEntity() {
|
||||
super(TRBlockEntities.MATTER_FABRICATOR );
|
||||
super(TRBlockEntities.MATTER_FABRICATOR);
|
||||
}
|
||||
|
||||
private boolean spaceForOutput() {
|
||||
|
@ -61,7 +61,7 @@ public class MatterFabricatorBlockEntity extends PowerAcceptorBlockEntity
|
|||
private boolean spaceForOutput(int slot) {
|
||||
return inventory.getStack(slot).isEmpty()
|
||||
|| ItemUtils.isItemEqual(inventory.getStack(slot), TRContent.Parts.UU_MATTER.getStack(), true, true)
|
||||
&& inventory.getStack(slot).getCount() < 64;
|
||||
&& inventory.getStack(slot).getCount() < 64;
|
||||
}
|
||||
|
||||
private void addOutputProducts() {
|
||||
|
@ -76,8 +76,7 @@ public class MatterFabricatorBlockEntity extends PowerAcceptorBlockEntity
|
|||
private void addOutputProducts(int slot) {
|
||||
if (inventory.getStack(slot).isEmpty()) {
|
||||
inventory.setStack(slot, TRContent.Parts.UU_MATTER.getStack());
|
||||
}
|
||||
else if (ItemUtils.isItemEqual(this.inventory.getStack(slot), TRContent.Parts.UU_MATTER.getStack(), true, true)) {
|
||||
} else if (ItemUtils.isItemEqual(this.inventory.getStack(slot), TRContent.Parts.UU_MATTER.getStack(), true, true)) {
|
||||
inventory.getStack(slot).setCount((Math.min(64, 1 + inventory.getStack(slot).getCount())));
|
||||
}
|
||||
}
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue