268 lines
9.4 KiB
Java
268 lines
9.4 KiB
Java
package com.thebrokenrail.energonrelics.block.entity.shifter;
|
|
|
|
import com.thebrokenrail.energonrelics.EnergonRelics;
|
|
import com.thebrokenrail.energonrelics.api.block.entity.core.EnergyReceiverBlockEntity;
|
|
import com.thebrokenrail.energonrelics.api.energy.Action;
|
|
import com.thebrokenrail.energonrelics.api.energy.tick.EnergyTickable;
|
|
import com.thebrokenrail.energonrelics.api.energy.tick.EnergyTicker;
|
|
import com.thebrokenrail.energonrelics.api.item.MultimeterExtra;
|
|
import com.thebrokenrail.energonrelics.block.PhaseShifterBlock;
|
|
import com.thebrokenrail.energonrelics.block.entity.reactor.ReactorInputBlockEntity;
|
|
import com.thebrokenrail.energonrelics.config.HardcodedConfig;
|
|
import com.thebrokenrail.energonrelics.util.WeightedList;
|
|
import net.minecraft.block.BlockState;
|
|
import net.minecraft.block.entity.BlockEntityType;
|
|
import net.minecraft.entity.player.PlayerEntity;
|
|
import net.minecraft.inventory.Inventories;
|
|
import net.minecraft.inventory.Inventory;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.CompoundTag;
|
|
import net.minecraft.nbt.ListTag;
|
|
import net.minecraft.nbt.Tag;
|
|
import net.minecraft.text.LiteralText;
|
|
import net.minecraft.text.MutableText;
|
|
import net.minecraft.text.TranslatableText;
|
|
import net.minecraft.util.Formatting;
|
|
import net.minecraft.util.collection.DefaultedList;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Objects;
|
|
|
|
public class PhaseShifterBlockEntity extends EnergyReceiverBlockEntity implements Inventory, MultimeterExtra {
|
|
private final static int INVENTORY_SIZE = ReactorInputBlockEntity.INVENTORY_SIZE;
|
|
|
|
private final DefaultedList<ItemStack> inv = DefaultedList.ofSize(INVENTORY_SIZE, ItemStack.EMPTY);
|
|
|
|
private int cooldown = 0;
|
|
|
|
public PhaseShifterBlockEntity(BlockEntityType<?> type) {
|
|
super(type);
|
|
}
|
|
|
|
@Override
|
|
public int size() {
|
|
return inv.size();
|
|
}
|
|
|
|
@Override
|
|
public boolean isEmpty() {
|
|
boolean empty = false;
|
|
for (ItemStack stack : inv) {
|
|
if (stack.isEmpty()) {
|
|
empty = true;
|
|
break;
|
|
}
|
|
}
|
|
return empty;
|
|
}
|
|
|
|
@Override
|
|
public ItemStack getStack(int slot) {
|
|
return inv.get(slot);
|
|
}
|
|
|
|
@Override
|
|
public ItemStack removeStack(int slot, int amount) {
|
|
ItemStack stack = Inventories.splitStack(inv, slot, amount);
|
|
if (!stack.isEmpty()) {
|
|
markDirty();
|
|
}
|
|
return stack;
|
|
}
|
|
|
|
@Override
|
|
public ItemStack removeStack(int slot) {
|
|
return Inventories.removeStack(inv, slot);
|
|
}
|
|
|
|
@Override
|
|
public void setStack(int slot, ItemStack stack) {
|
|
inv.set(slot, stack);
|
|
if (stack.getCount() > getMaxCountPerStack()) {
|
|
stack.setCount(getMaxCountPerStack());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean canPlayerUse(PlayerEntity player) {
|
|
if (Objects.requireNonNull(getWorld()).getBlockEntity(getPos()) != this) {
|
|
return false;
|
|
} else {
|
|
return player.squaredDistanceTo((double) getPos().getX() + 0.5D, (double) getPos().getY() + 0.5D, (double) getPos().getZ() + 0.5D) <= 64.0D;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void clear() {
|
|
inv.clear();
|
|
}
|
|
|
|
private final List<PhasedItem> phasedItems = new ArrayList<>();
|
|
|
|
@Override
|
|
public void fromTag(BlockState state, CompoundTag tag) {
|
|
super.fromTag(state, tag);
|
|
inv.clear();
|
|
Inventories.fromTag(tag, inv);
|
|
cooldown = tag.getInt("Cooldown");
|
|
|
|
phasedItems.clear();
|
|
Tag list = tag.get("PhasedItems");
|
|
if (list instanceof ListTag) {
|
|
ListTag itemsTag = (ListTag) list;
|
|
for (int i = 0; i < itemsTag.size(); i++) {
|
|
phasedItems.add(PhasedItem.fromTag(itemsTag.getCompound(i)));
|
|
}
|
|
}
|
|
}
|
|
|
|
private int canInsert(ItemStack stack) {
|
|
if (stack.getCount() <= getMaxCountPerStack()) {
|
|
for (int slot = 0; slot < size(); slot++) {
|
|
ItemStack oldStack = getStack(slot);
|
|
if (oldStack.isItemEqual(stack)) {
|
|
int newCount = oldStack.getCount() + stack.getCount();
|
|
if (newCount <= Math.min(oldStack.getMaxCount(), getMaxCountPerStack())) {
|
|
return slot;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int slot = 0; slot < size(); slot++) {
|
|
ItemStack oldStack = getStack(slot);
|
|
if (oldStack.isEmpty()) {
|
|
return slot;
|
|
}
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
private long getCost() {
|
|
return getCachedState().get(PhaseShifterBlock.IS_OUTPUT) ? HardcodedConfig.PHASE_SHIFTER_OUTPUT_ENERGY_REQUIRED : HardcodedConfig.PHASE_SHIFTER_INPUT_ENERGY_REQUIRED_BASE + (HardcodedConfig.PHASE_SHIFTER_INPUT_ENERGY_REQUIRED_PER_ITEM * phasedItems.size());
|
|
}
|
|
|
|
@Override
|
|
protected void energyTick() {
|
|
assert getWorld() != null;
|
|
|
|
addAction(Action.createBlockStatePropertyAction(getCost(), PhaseShifterBlock.POWERED, true, false));
|
|
|
|
boolean dirty = false;
|
|
|
|
if (cooldown > 0) {
|
|
cooldown--;
|
|
dirty = true;
|
|
}
|
|
|
|
if (getCachedState().get(PhaseShifterBlock.POWERED) && !getCachedState().get(PhaseShifterBlock.IS_OUTPUT)) {
|
|
List<PhaseShifterBlockEntity> outputs = new ArrayList<>();
|
|
for (EnergyTickable tickable : EnergyTicker.getAllLoaded()) {
|
|
if (tickable instanceof PhaseShifterBlockEntity && ((PhaseShifterBlockEntity) tickable).getCachedState().get(PhaseShifterBlock.IS_OUTPUT) && Objects.requireNonNull(((PhaseShifterBlockEntity) tickable).getWorld()).getRegistryKey() == getWorld().getRegistryKey() && ((PhaseShifterBlockEntity) tickable).cooldown == 0 && ((PhaseShifterBlockEntity) tickable).getCachedState().get(PhaseShifterBlock.COLOR) == getCachedState().get(PhaseShifterBlock.COLOR)) {
|
|
outputs.add((PhaseShifterBlockEntity) tickable);
|
|
}
|
|
}
|
|
|
|
if (phasedItems.size() > 0) {
|
|
dirty = true;
|
|
}
|
|
|
|
Iterator<PhasedItem> iterator = phasedItems.iterator();
|
|
while (iterator.hasNext()) {
|
|
PhasedItem item = iterator.next();
|
|
|
|
if (item.cooldown > 0) {
|
|
item.cooldown--;
|
|
} else {
|
|
Map<PhaseShifterBlockEntity, Integer> validOutputs = new HashMap<>();
|
|
for (PhaseShifterBlockEntity output : outputs) {
|
|
int slot = output.canInsert(item.item);
|
|
if (slot != -1 && output.getPos().isWithinDistance(getPos(), item.getRange())) {
|
|
validOutputs.put(output, slot);
|
|
}
|
|
}
|
|
|
|
boolean success = validOutputs.size() > 0 && HardcodedConfig.PHASE_SHIFTER_SUCCESS_CHANCE >= getWorld().random.nextFloat();
|
|
|
|
if (success) {
|
|
WeightedList<PhaseShifterBlockEntity> weightedList = new WeightedList<>();
|
|
for (PhaseShifterBlockEntity output : validOutputs.keySet()) {
|
|
weightedList.add(1, output);
|
|
}
|
|
|
|
PhaseShifterBlockEntity output = weightedList.pick(getWorld().random);
|
|
|
|
int slot = validOutputs.get(output);
|
|
|
|
ItemStack stack = item.item.copy();
|
|
stack.increment(output.getStack(slot).getCount());
|
|
|
|
output.setStack(slot, stack);
|
|
|
|
output.resetCooldown();
|
|
|
|
output.markDirty();
|
|
|
|
iterator.remove();
|
|
} else {
|
|
item.roll++;
|
|
item.cooldown = HardcodedConfig.PHASE_SHIFTER_INPUT_ROLL_COOLDOWN;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (cooldown == 0) {
|
|
ItemStack next = ItemStack.EMPTY;
|
|
|
|
for (int slot = 0; slot < size(); slot++) {
|
|
ItemStack stack = getStack(slot);
|
|
if (!stack.isEmpty()) {
|
|
next = stack.split(1);
|
|
}
|
|
}
|
|
|
|
if (!next.isEmpty()) {
|
|
phasedItems.add(new PhasedItem(next));
|
|
resetCooldown();
|
|
dirty = true;
|
|
}
|
|
}
|
|
} else if (phasedItems.size() > 0) {
|
|
phasedItems.clear();
|
|
dirty = true;
|
|
}
|
|
|
|
if (dirty) {
|
|
markDirty();
|
|
}
|
|
}
|
|
|
|
private void resetCooldown() {
|
|
cooldown = getCachedState().get(PhaseShifterBlock.IS_OUTPUT) ? HardcodedConfig.PHASE_SHIFTER_OUTPUT_COOLDOWN : HardcodedConfig.PHASE_SHIFTER_INPUT_COOLDOWN;
|
|
}
|
|
|
|
@Override
|
|
public CompoundTag toTag(CompoundTag tag) {
|
|
super.toTag(tag);
|
|
Inventories.toTag(tag, inv);
|
|
tag.putInt("Cooldown", cooldown);
|
|
|
|
ListTag itemsTag = new ListTag();
|
|
for (PhasedItem item : phasedItems) {
|
|
itemsTag.add(item.toTag());
|
|
}
|
|
tag.put("PhasedItems", itemsTag);
|
|
|
|
return tag;
|
|
}
|
|
|
|
@Override
|
|
public MutableText getExtra() {
|
|
return getCachedState().get(PhaseShifterBlock.IS_OUTPUT) ? null : new TranslatableText("text." + EnergonRelics.NAMESPACE + ".phase_shifter_extra", new LiteralText(String.valueOf(phasedItems.size())).formatted(Formatting.WHITE));
|
|
}
|
|
}
|