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

306 lines
12 KiB
Java
Raw Normal View History

2016-05-16 22:52:27 +02:00
/*
* This file ("TileEntityLaserRelayEnergy.java") is part of the Actually Additions mod for Minecraft.
* It is created and owned by Ellpeck and distributed
* under the Actually Additions License to be found at
* http://ellpeck.de/actaddlicense
* View the source code at https://github.com/Ellpeck/ActuallyAdditions
*
2017-01-01 16:23:26 +01:00
* © 2015-2017 Ellpeck
2016-05-16 22:52:27 +02:00
*/
package de.ellpeck.actuallyadditions.mod.tile;
2016-09-12 16:13:39 +02:00
import de.ellpeck.actuallyadditions.api.laser.IConnectionPair;
import de.ellpeck.actuallyadditions.api.laser.LaserType;
import de.ellpeck.actuallyadditions.api.laser.Network;
2018-05-10 11:38:58 +02:00
import de.ellpeck.actuallyadditions.mod.ActuallyAdditions;
2016-07-14 16:44:01 +02:00
import de.ellpeck.actuallyadditions.mod.config.values.ConfigBoolValues;
import de.ellpeck.actuallyadditions.mod.util.StringUtil;
import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet;
2021-02-26 22:15:48 +01:00
import net.minecraft.entity.player.PlayerEntity;
import net.minecraft.nbt.CompoundNBT;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.Direction;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.MathHelper;
2016-12-05 15:09:37 +01:00
import net.minecraft.util.text.TextFormatting;
import net.minecraftforge.energy.CapabilityEnergy;
import net.minecraftforge.energy.IEnergyStorage;
2021-02-26 22:15:48 +01:00
import net.minecraftforge.fml.relauncher.OnlyIn;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
2016-11-26 21:32:27 +01:00
2019-05-02 09:10:29 +02:00
public class TileEntityLaserRelayEnergy extends TileEntityLaserRelay {
2016-07-14 16:44:01 +02:00
public static final int CAP = 1000;
public final ConcurrentHashMap<Direction, TileEntity> receiversAround = new ConcurrentHashMap<>();
2016-11-26 20:43:50 +01:00
private final IEnergyStorage[] energyStorages = new IEnergyStorage[6];
2016-12-18 17:50:31 +01:00
private Mode mode = Mode.BOTH;
2016-11-26 20:43:50 +01:00
2019-05-02 09:10:29 +02:00
public TileEntityLaserRelayEnergy(String name) {
super(name, LaserType.ENERGY);
2016-07-14 16:44:01 +02:00
2019-05-02 09:10:29 +02:00
for (int i = 0; i < this.energyStorages.length; i++) {
Direction facing = Direction.values()[i];
2019-05-02 09:10:29 +02:00
this.energyStorages[i] = new IEnergyStorage() {
2016-11-26 20:43:50 +01:00
@Override
2019-05-02 09:10:29 +02:00
public int receiveEnergy(int amount, boolean simulate) {
2016-11-26 20:43:50 +01:00
return TileEntityLaserRelayEnergy.this.transmitEnergy(facing, amount, simulate);
}
2016-11-26 20:43:50 +01:00
@Override
2019-05-02 09:10:29 +02:00
public int extractEnergy(int maxExtract, boolean simulate) {
2016-11-26 20:43:50 +01:00
return 0;
}
@Override
2019-05-02 09:10:29 +02:00
public int getEnergyStored() {
2016-11-26 20:43:50 +01:00
return 0;
}
@Override
2019-05-02 09:10:29 +02:00
public int getMaxEnergyStored() {
2016-11-26 20:43:50 +01:00
return TileEntityLaserRelayEnergy.this.getEnergyCap();
}
@Override
2019-05-02 09:10:29 +02:00
public boolean canExtract() {
2016-11-26 20:43:50 +01:00
return false;
}
@Override
2019-05-02 09:10:29 +02:00
public boolean canReceive() {
2016-11-26 20:43:50 +01:00
return true;
}
};
}
}
2019-05-02 09:10:29 +02:00
public TileEntityLaserRelayEnergy() {
2016-11-26 20:43:50 +01:00
this("laserRelay");
}
private int transmitEnergy(Direction from, int maxTransmit, boolean simulate) {
int transmitted = 0;
2019-05-02 09:10:29 +02:00
if (maxTransmit > 0 && this.mode != Mode.OUTPUT_ONLY) {
Network network = this.getNetwork();
2019-05-02 09:10:29 +02:00
if (network != null) {
2016-07-14 16:44:01 +02:00
transmitted = this.transferEnergyToReceiverInNeed(from, network, maxTransmit, simulate);
}
}
return transmitted;
}
@Override
public IEnergyStorage getEnergyStorage(Direction facing) {
2021-02-26 22:15:48 +01:00
return this.energyStorages[facing == null
? 0
: facing.ordinal()];
}
@Override
2019-05-02 09:10:29 +02:00
public boolean shouldSaveDataOnChangeOrWorldStart() {
return true;
}
@Override
2019-05-02 09:10:29 +02:00
public void saveDataOnChangeOrWorldStart() {
Map<Direction, TileEntity> old = new HashMap<>(this.receiversAround);
boolean change = false;
this.receiversAround.clear();
for (Direction side : Direction.values()) {
2016-07-04 20:15:41 +02:00
BlockPos pos = this.getPos().offset(side);
2019-05-02 09:10:29 +02:00
if (this.world.isBlockLoaded(pos)) {
TileEntity tile = this.world.getTileEntity(pos);
2019-05-02 09:10:29 +02:00
if (tile != null && !(tile instanceof TileEntityLaserRelay)) {
if (tile.hasCapability(CapabilityEnergy.ENERGY, side.getOpposite())) {
this.receiversAround.put(side, tile);
TileEntity oldTile = old.get(side);
2019-05-02 09:10:29 +02:00
if (oldTile == null || !tile.equals(oldTile)) {
change = true;
}
}
}
}
}
2019-05-02 09:10:29 +02:00
if (change || old.size() != this.receiversAround.size()) {
Network network = this.getNetwork();
2019-05-02 09:10:29 +02:00
if (network != null) {
network.changeAmount++;
}
}
}
private int transferEnergyToReceiverInNeed(Direction from, Network network, int maxTransfer, boolean simulate) {
int transmitted = 0;
//Keeps track of all the Laser Relays and Energy Acceptors that have been checked already to make nothing run multiple times
Set<BlockPos> alreadyChecked = new ObjectOpenHashSet<>();
Set<TileEntityLaserRelayEnergy> relaysThatWork = new ObjectOpenHashSet<>();
int totalReceiverAmount = 0;
2019-05-02 09:10:29 +02:00
for (IConnectionPair pair : network.connections) {
for (BlockPos relay : pair.getPositions()) {
if (relay != null && this.world.isBlockLoaded(relay) && !alreadyChecked.contains(relay)) {
alreadyChecked.add(relay);
2016-11-26 21:32:27 +01:00
TileEntity relayTile = this.world.getTileEntity(relay);
2019-05-02 09:10:29 +02:00
if (relayTile instanceof TileEntityLaserRelayEnergy) {
TileEntityLaserRelayEnergy theRelay = (TileEntityLaserRelayEnergy) relayTile;
if (theRelay.mode != Mode.INPUT_ONLY) {
boolean workedOnce = false;
for (Direction facing : theRelay.receiversAround.keySet()) {
2019-05-02 09:10:29 +02:00
if (theRelay != this || facing != from) {
TileEntity tile = theRelay.receiversAround.get(facing);
Direction opp = facing.getOpposite();
2019-05-02 09:10:29 +02:00
if (tile != null) {
if (tile.hasCapability(CapabilityEnergy.ENERGY, opp)) {
2019-02-27 19:53:05 +01:00
IEnergyStorage cap = tile.getCapability(CapabilityEnergy.ENERGY, opp);
2019-05-02 09:10:29 +02:00
if (cap != null && cap.receiveEnergy(maxTransfer, true) > 0) {
2019-02-27 19:53:05 +01:00
totalReceiverAmount++;
workedOnce = true;
}
}
}
}
2016-12-05 15:09:37 +01:00
}
2019-05-02 09:10:29 +02:00
if (workedOnce) {
2016-12-05 15:09:37 +01:00
relaysThatWork.add(theRelay);
}
}
}
}
}
}
2019-05-02 09:10:29 +02:00
if (totalReceiverAmount > 0 && !relaysThatWork.isEmpty()) {
int amountPer = maxTransfer / totalReceiverAmount;
if (amountPer <= 0) {
amountPer = maxTransfer;
}
2019-05-02 09:10:29 +02:00
for (TileEntityLaserRelayEnergy theRelay : relaysThatWork) {
double highestLoss = Math.max(theRelay.getLossPercentage(), this.getLossPercentage());
int lowestCap = Math.min(theRelay.getEnergyCap(), this.getEnergyCap());
for (Map.Entry<Direction, TileEntity> receiver : theRelay.receiversAround.entrySet()) {
2019-05-02 09:10:29 +02:00
if (receiver != null) {
Direction side = receiver.getKey();
Direction opp = side.getOpposite();
TileEntity tile = receiver.getValue();
2019-05-02 09:10:29 +02:00
if (!alreadyChecked.contains(tile.getPos())) {
alreadyChecked.add(tile.getPos());
2019-05-02 09:10:29 +02:00
if (theRelay != this || side != from) {
if (tile.hasCapability(CapabilityEnergy.ENERGY, opp)) {
IEnergyStorage cap = tile.getCapability(CapabilityEnergy.ENERGY, opp);
2019-05-02 09:10:29 +02:00
if (cap != null) {
int theoreticalReceived = cap.receiveEnergy(Math.min(amountPer, lowestCap), true);
2019-05-02 09:10:29 +02:00
if (theoreticalReceived > 0) {
int deduct = this.calcDeduction(theoreticalReceived, highestLoss);
2019-05-02 09:10:29 +02:00
if (deduct >= theoreticalReceived) { //Happens with small numbers
deduct = 0;
}
2019-05-02 09:10:29 +02:00
transmitted += cap.receiveEnergy(theoreticalReceived - deduct, simulate);
transmitted += deduct;
}
}
}
//If everything that could be transmitted was transmitted
2021-02-26 22:15:48 +01:00
if (transmitted >= maxTransfer) {
return transmitted;
}
}
}
}
}
}
}
return transmitted;
}
2016-07-14 16:44:01 +02:00
2019-05-02 09:10:29 +02:00
private int calcDeduction(int theoreticalReceived, double highestLoss) {
2021-02-26 22:15:48 +01:00
return ConfigBoolValues.LASER_RELAY_LOSS.isEnabled()
? MathHelper.ceil(theoreticalReceived * (highestLoss / 100))
: 0;
}
2019-05-02 09:10:29 +02:00
public int getEnergyCap() {
2016-07-14 16:44:01 +02:00
return CAP;
}
2019-05-02 09:10:29 +02:00
public double getLossPercentage() {
2016-07-14 16:44:01 +02:00
return 5;
}
2016-12-05 15:09:37 +01:00
@Override
2021-02-26 22:15:48 +01:00
@OnlyIn(Dist.CLIENT)
2019-05-02 09:10:29 +02:00
public String getExtraDisplayString() {
return StringUtil.localize("info." + ActuallyAdditions.MODID + ".laserRelay.energy.extra") + ": " + TextFormatting.DARK_RED + StringUtil.localize(this.mode.name) + TextFormatting.RESET;
2016-12-05 15:09:37 +01:00
}
@Override
2021-02-26 22:15:48 +01:00
@OnlyIn(Dist.CLIENT)
2019-05-02 09:10:29 +02:00
public String getCompassDisplayString() {
return TextFormatting.GREEN + StringUtil.localize("info." + ActuallyAdditions.MODID + ".laserRelay.energy.display");
2016-12-05 15:09:37 +01:00
}
@Override
2021-02-26 22:15:48 +01:00
public void onCompassAction(PlayerEntity player) {
2016-12-05 15:09:37 +01:00
this.mode = this.mode.getNext();
}
@Override
2021-02-26 22:15:48 +01:00
public void writeSyncableNBT(CompoundNBT compound, NBTType type) {
2016-12-05 15:09:37 +01:00
super.writeSyncableNBT(compound, type);
2019-05-02 09:10:29 +02:00
if (type != NBTType.SAVE_BLOCK) {
2016-12-05 15:09:37 +01:00
compound.setString("Mode", this.mode.toString());
}
}
@Override
2021-02-26 22:15:48 +01:00
public void readSyncableNBT(CompoundNBT compound, NBTType type) {
2016-12-05 15:09:37 +01:00
super.readSyncableNBT(compound, type);
2019-05-02 09:10:29 +02:00
if (type != NBTType.SAVE_BLOCK) {
2016-12-05 15:09:37 +01:00
String modeStrg = compound.getString("Mode");
2019-05-02 09:10:29 +02:00
if (modeStrg != null && !modeStrg.isEmpty()) {
2016-12-05 15:09:37 +01:00
this.mode = Mode.valueOf(modeStrg);
}
}
}
2019-05-02 09:10:29 +02:00
public enum Mode {
BOTH("info." + ActuallyAdditions.MODID + ".laserRelay.mode.both"),
OUTPUT_ONLY("info." + ActuallyAdditions.MODID + ".laserRelay.mode.outputOnly"),
INPUT_ONLY("info." + ActuallyAdditions.MODID + ".laserRelay.mode.inputOnly");
2016-12-05 15:09:37 +01:00
public final String name;
2019-05-02 09:10:29 +02:00
Mode(String name) {
2016-12-05 15:09:37 +01:00
this.name = name;
}
2019-05-02 09:10:29 +02:00
public Mode getNext() {
int ordinal = this.ordinal() + 1;
2016-12-05 15:09:37 +01:00
2019-05-02 09:10:29 +02:00
if (ordinal >= values().length) {
2016-12-05 15:09:37 +01:00
ordinal = 0;
}
return values()[ordinal];
}
}
}