Fixed IC2 energy exploits
Fixed IC2 tiles not updating after changing side input/output mode Refactored energy API Removed IUpgradable API
This commit is contained in:
LemADEC
parent
84ebc4a08a
commit
f1a1906d4b
18 changed files with 226 additions and 291 deletions
|
|
@ -1,11 +0,0 @@
|
|||
package cr0s.warpdrive.api;
|
||||
|
||||
import java.util.Map;
|
||||
|
||||
import cr0s.warpdrive.data.UpgradeType;
|
||||
|
||||
public interface IUpgradable
|
||||
{
|
||||
public boolean takeUpgrade(UpgradeType upgradeType,boolean simulate);
|
||||
public Map<UpgradeType,Integer> getInstalledUpgrades();
|
||||
}
|
||||
|
|
@ -178,8 +178,8 @@ public abstract class BlockAbstractContainer extends BlockContainer implements I
|
|||
TileEntity tileEntity = world.getTileEntity(x, y, z);
|
||||
if (tileEntity instanceof TileEntityAbstractEnergy) {
|
||||
TileEntityAbstractEnergy tileEntityAbstractEnergy = (TileEntityAbstractEnergy) tileEntity;
|
||||
if (tileEntityAbstractEnergy.getMaxEnergyStored() > 0) {
|
||||
tileEntityAbstractEnergy.consumeEnergy(Math.round(tileEntityAbstractEnergy.getEnergyStored() * efficiency), false);
|
||||
if (tileEntityAbstractEnergy.energy_getMaxStorage() > 0) {
|
||||
tileEntityAbstractEnergy.energy_consume(Math.round(tileEntityAbstractEnergy.energy_getEnergyStored() * efficiency), false);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -97,7 +97,7 @@ public class BlockAirGenerator extends BlockAbstractContainer {
|
|||
Item heldItem = heldItemStack.getItem();
|
||||
if (heldItem != null && (heldItem instanceof IAirCanister)) {
|
||||
IAirCanister airCanister = (IAirCanister) heldItem;
|
||||
if (airCanister.canContainAir(heldItemStack) && airGenerator.consumeEnergy(WarpDriveConfig.AIRGEN_ENERGY_PER_CANISTER, true)) {
|
||||
if (airCanister.canContainAir(heldItemStack) && airGenerator.energy_consume(WarpDriveConfig.AIRGEN_ENERGY_PER_CANISTER, true)) {
|
||||
entityPlayer.inventory.decrStackSize(entityPlayer.inventory.currentItem, 1);
|
||||
ItemStack toAdd = airCanister.fullDrop(heldItemStack);
|
||||
if (toAdd != null) {
|
||||
|
|
@ -106,7 +106,7 @@ public class BlockAirGenerator extends BlockAbstractContainer {
|
|||
entityPlayer.worldObj.spawnEntityInWorld(ie);
|
||||
}
|
||||
((EntityPlayerMP)entityPlayer).sendContainerToPlayer(entityPlayer.inventoryContainer);
|
||||
airGenerator.consumeEnergy(WarpDriveConfig.AIRGEN_ENERGY_PER_CANISTER, false);
|
||||
airGenerator.energy_consume(WarpDriveConfig.AIRGEN_ENERGY_PER_CANISTER, false);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,9 +1,10 @@
|
|||
package cr0s.warpdrive.block;
|
||||
|
||||
import java.math.BigDecimal;
|
||||
import java.util.HashMap;
|
||||
|
||||
import cr0s.warpdrive.WarpDrive;
|
||||
import cr0s.warpdrive.data.EnumComponentType;
|
||||
import cr0s.warpdrive.item.ItemComponent;
|
||||
import ic2.api.energy.event.EnergyTileLoadEvent;
|
||||
import ic2.api.energy.event.EnergyTileUnloadEvent;
|
||||
import ic2.api.energy.tile.IEnergySink;
|
||||
|
|
@ -15,12 +16,12 @@ import li.cil.oc.api.machine.Callback;
|
|||
import li.cil.oc.api.machine.Context;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import net.minecraft.tileentity.TileEntity;
|
||||
import net.minecraft.util.EnumFacing;
|
||||
import net.minecraft.util.StatCollector;
|
||||
import net.minecraftforge.common.MinecraftForge;
|
||||
import net.minecraftforge.common.util.ForgeDirection;
|
||||
import cpw.mods.fml.common.Optional;
|
||||
import cr0s.warpdrive.config.WarpDriveConfig;
|
||||
import cr0s.warpdrive.data.UpgradeType;
|
||||
import dan200.computercraft.api.lua.ILuaContext;
|
||||
import dan200.computercraft.api.peripheral.IComputerAccess;
|
||||
|
||||
|
|
@ -37,40 +38,34 @@ public abstract class TileEntityAbstractEnergy extends TileEntityAbstractInterfa
|
|||
protected int IC2_sinkTier = 3;
|
||||
protected int IC2_sourceTier = 3;
|
||||
|
||||
private int scanTickCount = -1;
|
||||
private final static int SCAN_INTERVAL_TICKS = 20;
|
||||
private int scanTickCount = SCAN_INTERVAL_TICKS;
|
||||
|
||||
private Object[] cofhEnergyReceivers;
|
||||
|
||||
@Deprecated
|
||||
protected final HashMap<UpgradeType, Integer> deprecated_upgrades = new HashMap<>();
|
||||
|
||||
public TileEntityAbstractEnergy() {
|
||||
super();
|
||||
if (WarpDriveConfig.isCoFHCoreLoaded) {
|
||||
RF_initialiseAPI();
|
||||
CoFH_initialiseAPI();
|
||||
}
|
||||
addMethods(new String[] { "energy" });
|
||||
}
|
||||
|
||||
@Deprecated
|
||||
public Object[] getUpgrades_deprecated() {
|
||||
Object[] retVal = new Object[UpgradeType.values().length];
|
||||
for (UpgradeType type : UpgradeType.values()) {
|
||||
int am = 0;
|
||||
if (deprecated_upgrades.containsKey(type))
|
||||
am = deprecated_upgrades.get(type);
|
||||
retVal[type.ordinal()] = type + ":" + am;
|
||||
}
|
||||
return retVal;
|
||||
}
|
||||
|
||||
// WarpDrive methods
|
||||
protected static int convertInternalToRF(int energy) {
|
||||
return (int) Math.round(energy * RF_PER_INTERNAL);
|
||||
protected static int convertInternalToRF_ceil(int energy) {
|
||||
return (int) Math.ceil(energy * RF_PER_INTERNAL);
|
||||
}
|
||||
|
||||
protected static int convertRFtoInternal(int energy) {
|
||||
return (int) Math.round(energy / RF_PER_INTERNAL);
|
||||
protected static int convertInternalToRF_floor(int energy) {
|
||||
return (int) Math.floor(energy * RF_PER_INTERNAL);
|
||||
}
|
||||
|
||||
protected static int convertRFtoInternal_ceil(int energy) {
|
||||
return (int) Math.ceil(energy / RF_PER_INTERNAL);
|
||||
}
|
||||
|
||||
protected static int convertRFtoInternal_floor(int energy) {
|
||||
return (int) Math.floor(energy / RF_PER_INTERNAL);
|
||||
}
|
||||
|
||||
protected static double convertInternalToEU_ceil(int energy) {
|
||||
|
|
@ -89,23 +84,23 @@ public abstract class TileEntityAbstractEnergy extends TileEntityAbstractInterfa
|
|||
return (int) Math.floor(amount / EU_PER_INTERNAL);
|
||||
}
|
||||
|
||||
public int getEnergyStored() {
|
||||
return clamp(0, getMaxEnergyStored(), energyStored_internal);
|
||||
public int energy_getEnergyStored() {
|
||||
return clamp(0, energy_getMaxStorage(), energyStored_internal);
|
||||
}
|
||||
|
||||
// Methods to override
|
||||
|
||||
/**
|
||||
* Should return the maximum amount of energy that can be stored (measured in internal energy units).
|
||||
* Return the maximum amount of energy that can be stored (measured in internal energy units).
|
||||
*/
|
||||
public int getMaxEnergyStored() {
|
||||
public int energy_getMaxStorage() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Should return the maximum amount of energy that can be output (measured in internal energy units).
|
||||
* Return the maximum amount of energy that can be output (measured in internal energy units).
|
||||
*/
|
||||
public int getPotentialEnergyOutput() {
|
||||
public int energy_getPotentialOutput() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -113,15 +108,15 @@ public abstract class TileEntityAbstractEnergy extends TileEntityAbstractInterfa
|
|||
* Remove energy from storage, called after actual output happened (measured in internal energy units).
|
||||
* Override this to use custom storage or measure output statistics.
|
||||
*/
|
||||
protected void energyOutputDone(int energyOutput_internal) {
|
||||
consumeEnergy(energyOutput_internal, false);
|
||||
protected void energy_outputDone(final int energyOutput_internal) {
|
||||
energy_consume(energyOutput_internal);
|
||||
}
|
||||
|
||||
/**
|
||||
* Should return true if that direction can receive energy.
|
||||
*/
|
||||
@SuppressWarnings("UnusedParameters")
|
||||
public boolean canInputEnergy(ForgeDirection from) {
|
||||
public boolean energy_canInput(ForgeDirection from) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -129,7 +124,7 @@ public abstract class TileEntityAbstractEnergy extends TileEntityAbstractInterfa
|
|||
* Should return true if that direction can output energy.
|
||||
*/
|
||||
@SuppressWarnings("UnusedParameters")
|
||||
public boolean canOutputEnergy(ForgeDirection to) {
|
||||
public boolean energy_canOutput(ForgeDirection to) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -137,54 +132,38 @@ public abstract class TileEntityAbstractEnergy extends TileEntityAbstractInterfa
|
|||
* Consume energy from storage for internal usage or after outputting (measured in internal energy units).
|
||||
* Override this to use custom storage or measure energy consumption statistics (internal usage or output).
|
||||
*/
|
||||
public boolean consumeEnergy(int amount_internal, boolean simulate) {
|
||||
int amountUpgraded = amount_internal;
|
||||
if (deprecated_upgrades.containsKey(UpgradeType.Power)) {
|
||||
double valueMul = Math.pow(0.8, deprecated_upgrades.get(UpgradeType.Power));
|
||||
amountUpgraded = (int) Math.ceil(valueMul * amountUpgraded);
|
||||
}
|
||||
|
||||
if (deprecated_upgrades.containsKey(UpgradeType.Range)) {
|
||||
double valueMul = Math.pow(1.2, deprecated_upgrades.get(UpgradeType.Range));
|
||||
amountUpgraded = (int) Math.ceil(valueMul * amountUpgraded);
|
||||
}
|
||||
|
||||
if (deprecated_upgrades.containsKey(UpgradeType.Speed)) {
|
||||
double valueMul = Math.pow(1.2, deprecated_upgrades.get(UpgradeType.Speed));
|
||||
amountUpgraded = (int) Math.ceil(valueMul * amountUpgraded);
|
||||
}
|
||||
// FIXME: upgrades balancing & implementation to be done...
|
||||
|
||||
if (getEnergyStored() >= amount_internal) {
|
||||
public boolean energy_consume(final int amount_internal, final boolean simulate) {
|
||||
if (energy_getEnergyStored() >= amount_internal) {
|
||||
if (!simulate) {
|
||||
energyStored_internal -= amount_internal;
|
||||
energy_consume(amount_internal);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Consume all internal energy and return it's value (measured in internal energy units).
|
||||
* Override this to use custom storage or measure energy consumption statistics of this kind.
|
||||
*/
|
||||
public int consumeAllEnergy() {
|
||||
int temp = getEnergyStored();
|
||||
energyStored_internal = 0;
|
||||
return temp;
|
||||
public void energy_consume(final int amount_internal) {
|
||||
int amountUpgraded = amount_internal;
|
||||
double absorption = Math.min(1.0D, 0.8D + 0.025D * getUpgradeCount(ItemComponent.getItemStack(EnumComponentType.POWER_INTERFACE)));
|
||||
if (amount_internal > 0) {
|
||||
amountUpgraded = (int) Math.ceil(amount_internal * absorption);
|
||||
} else {
|
||||
amountUpgraded = (int) Math.floor(amount_internal / absorption);
|
||||
}
|
||||
|
||||
energyStored_internal -= amount_internal;
|
||||
}
|
||||
|
||||
public Object[] energy() {
|
||||
return new Object[] { getEnergyStored(), getMaxEnergyStored() };
|
||||
return new Object[] { energy_getEnergyStored(), energy_getMaxStorage() };
|
||||
}
|
||||
|
||||
public String getEnergyStatus() {
|
||||
if (getMaxEnergyStored() == 0) {
|
||||
if (energy_getMaxStorage() == 0) {
|
||||
return "";
|
||||
}
|
||||
return StatCollector.translateToLocalFormatted("warpdrive.energy.statusLine",
|
||||
BigDecimal.valueOf(convertInternalToEU_floor(getEnergyStored())).toPlainString(),
|
||||
BigDecimal.valueOf(convertInternalToEU_floor(getMaxEnergyStored())).toPlainString());
|
||||
BigDecimal.valueOf(convertInternalToEU_floor(energy_getEnergyStored())).toPlainString(),
|
||||
BigDecimal.valueOf(convertInternalToEU_floor(energy_getMaxStorage())).toPlainString());
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
@ -223,6 +202,10 @@ public abstract class TileEntityAbstractEnergy extends TileEntityAbstractInterfa
|
|||
return;
|
||||
}
|
||||
|
||||
if (WarpDriveConfig.LOGGING_ENERGY) {
|
||||
WarpDrive.logger.info(this + " updateEntity");
|
||||
}
|
||||
|
||||
// IndustrialCraft2
|
||||
if (WarpDriveConfig.isIndustrialCraft2Loaded) {
|
||||
IC2_addToEnergyNet();
|
||||
|
|
@ -230,12 +213,12 @@ public abstract class TileEntityAbstractEnergy extends TileEntityAbstractInterfa
|
|||
|
||||
// Thermal Expansion
|
||||
if (WarpDriveConfig.isCoFHCoreLoaded) {
|
||||
scanTickCount++;
|
||||
if (scanTickCount >= 20) {
|
||||
scanTickCount = 0;
|
||||
scanForEnergyHandlers();
|
||||
scanTickCount--;
|
||||
if (scanTickCount <= 0) {
|
||||
scanTickCount = SCAN_INTERVAL_TICKS;
|
||||
CoFH_scanForEnergyHandlers();
|
||||
}
|
||||
outputEnergy();
|
||||
CoFH_outputEnergy();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -261,25 +244,25 @@ public abstract class TileEntityAbstractEnergy extends TileEntityAbstractInterfa
|
|||
@Override
|
||||
@Optional.Method(modid = "IC2")
|
||||
public double getDemandedEnergy() {
|
||||
return Math.max(0.0D, convertInternalToEU_floor(getMaxEnergyStored() - getEnergyStored()));
|
||||
return Math.max(0.0D, convertInternalToEU_floor(energy_getMaxStorage() - energy_getEnergyStored()));
|
||||
}
|
||||
|
||||
@Override
|
||||
@Optional.Method(modid = "IC2")
|
||||
public double injectEnergy(ForgeDirection from, double amount_EU, double voltage) {
|
||||
if (WarpDriveConfig.LOGGING_ENERGY) {
|
||||
WarpDrive.logger.info(this + " [IC2]injectEnergy from " + from + " amount_EU " + amount_EU + " " + voltage);
|
||||
WarpDrive.logger.info(this + " [IC2]injectEnergy from " + from + "(" + energy_canInput(from) + ") amount " + amount_EU + " voltage " + voltage);
|
||||
}
|
||||
if (canInputEnergy(from)) {
|
||||
if (energy_canInput(from)) {
|
||||
int leftover_internal = 0;
|
||||
energyStored_internal += convertEUtoInternal_floor(amount_EU);
|
||||
|
||||
if (energyStored_internal > getMaxEnergyStored()) {
|
||||
leftover_internal = (energyStored_internal - getMaxEnergyStored());
|
||||
energyStored_internal = getMaxEnergyStored();
|
||||
if (energyStored_internal > energy_getMaxStorage()) {
|
||||
leftover_internal = (energyStored_internal - energy_getMaxStorage());
|
||||
energyStored_internal = energy_getMaxStorage();
|
||||
}
|
||||
|
||||
return convertInternalToEU_ceil(leftover_internal);
|
||||
return convertInternalToEU_floor(leftover_internal);
|
||||
} else {
|
||||
return amount_EU;
|
||||
}
|
||||
|
|
@ -288,14 +271,17 @@ public abstract class TileEntityAbstractEnergy extends TileEntityAbstractInterfa
|
|||
@Override
|
||||
@Optional.Method(modid = "IC2")
|
||||
public boolean acceptsEnergyFrom(TileEntity emitter, ForgeDirection from) {
|
||||
return canInputEnergy(from);
|
||||
if (WarpDriveConfig.LOGGING_ENERGY) {
|
||||
WarpDrive.logger.info(this + " [IC2]acceptsEnergyFrom emitter " + emitter + " from " + from + " => " + energy_canInput(from));
|
||||
}
|
||||
return energy_canInput(from);
|
||||
}
|
||||
|
||||
// IndustrialCraft IEnergySource interface
|
||||
@Override
|
||||
@Optional.Method(modid = "IC2")
|
||||
public double getOfferedEnergy() {
|
||||
return convertInternalToEU_floor(getPotentialEnergyOutput());
|
||||
return convertInternalToEU_floor(energy_getPotentialOutput());
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
@ -304,16 +290,16 @@ public abstract class TileEntityAbstractEnergy extends TileEntityAbstractInterfa
|
|||
if (WarpDriveConfig.LOGGING_ENERGY) {
|
||||
WarpDrive.logger.info(this + " [IC2]drawEnergy amount_EU " + amount_EU);
|
||||
}
|
||||
energyOutputDone(convertEUtoInternal_ceil(amount_EU));
|
||||
energy_outputDone(convertEUtoInternal_ceil(amount_EU));
|
||||
}
|
||||
|
||||
@Override
|
||||
@Optional.Method(modid = "IC2")
|
||||
public boolean emitsEnergyTo(TileEntity receiver, ForgeDirection to) {
|
||||
if (WarpDriveConfig.LOGGING_ENERGY) {
|
||||
WarpDrive.logger.info(this + " [IC2]emitsEnergyTo receiver " + receiver + " to " + to);
|
||||
WarpDrive.logger.info(this + " [IC2]emitsEnergyTo receiver " + receiver + " to " + to + " => " + energy_canOutput(to));
|
||||
}
|
||||
return canOutputEnergy(to);
|
||||
return energy_canOutput(to);
|
||||
}
|
||||
|
||||
@Optional.Method(modid = "IC2")
|
||||
|
|
@ -349,10 +335,7 @@ public abstract class TileEntityAbstractEnergy extends TileEntityAbstractInterfa
|
|||
@Override
|
||||
@Optional.Method(modid = "CoFHCore") /* IEnergyReceiver */
|
||||
public int receiveEnergy(ForgeDirection from, int maxReceive_RF, boolean simulate) {
|
||||
if (WarpDriveConfig.LOGGING_ENERGY) {
|
||||
WarpDrive.logger.info(this + " [CoFH]receiveEnergy from " + from + " maxReceive_RF " + maxReceive_RF + " simulate " + simulate);
|
||||
}
|
||||
if (!canInputEnergy(from)) {
|
||||
if (!energy_canInput(from)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -363,8 +346,11 @@ public abstract class TileEntityAbstractEnergy extends TileEntityAbstractInterfa
|
|||
int energyStored_RF = getEnergyStored(from);
|
||||
|
||||
int toAdd_RF = Math.min(maxReceive_RF, maxStored_RF - energyStored_RF);
|
||||
if (WarpDriveConfig.LOGGING_ENERGY) {
|
||||
WarpDrive.logger.info(this + " [CoFH]receiveEnergy from " + from + " maxReceive_RF " + maxReceive_RF + " simulate " + simulate + " energy_RF " + energyStored_RF + "/" + maxStored_RF + " toAdd_RF " + toAdd_RF);
|
||||
}
|
||||
if (!simulate) {
|
||||
energyStored_internal = Math.min(getMaxEnergyStored(), getEnergyStored() + convertRFtoInternal(toAdd_RF));
|
||||
energyStored_internal = Math.min(energy_getMaxStorage(), energy_getEnergyStored() + convertRFtoInternal_floor(toAdd_RF));
|
||||
}
|
||||
|
||||
return toAdd_RF;
|
||||
|
|
@ -376,67 +362,68 @@ public abstract class TileEntityAbstractEnergy extends TileEntityAbstractInterfa
|
|||
if (WarpDriveConfig.LOGGING_ENERGY) {
|
||||
WarpDrive.logger.info(this + " [CoFH]extractEnergy from " + from + " maxExtract_RF " + maxExtract_RF + " simulate " + simulate);
|
||||
}
|
||||
if (!canOutputEnergy(from)) {
|
||||
if (!energy_canOutput(from)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int potentialEnergyOutput_internal = getPotentialEnergyOutput();
|
||||
int energyExtracted_internal = Math.min(convertRFtoInternal(maxExtract_RF), potentialEnergyOutput_internal);
|
||||
int potentialEnergyOutput_internal = energy_getPotentialOutput();
|
||||
int energyExtracted_internal = Math.min(convertRFtoInternal_ceil(maxExtract_RF), potentialEnergyOutput_internal);
|
||||
if (!simulate) {
|
||||
energyOutputDone(energyExtracted_internal);
|
||||
energy_outputDone(energyExtracted_internal);
|
||||
}
|
||||
return convertInternalToRF(energyExtracted_internal);
|
||||
return convertInternalToRF_floor(energyExtracted_internal);
|
||||
}
|
||||
|
||||
@Override
|
||||
@Optional.Method(modid = "CoFHCore") /* IEnergyConnection */
|
||||
public boolean canConnectEnergy(ForgeDirection from) {
|
||||
return (getMaxEnergyStored() != 0) && (canInputEnergy(from) || canOutputEnergy(from)); // Warning: deadlock risk depending on child implementation
|
||||
return (energy_getMaxStorage() != 0) && (energy_canInput(from) || energy_canOutput(from)); // Warning: deadlock risk depending on child implementation
|
||||
}
|
||||
|
||||
@Override
|
||||
@Optional.Method(modid = "CoFHCore") /* IEnergyReceiver and IEnergyProvider */
|
||||
public int getEnergyStored(ForgeDirection from) {
|
||||
return canConnectEnergy(from) ? convertInternalToRF(getEnergyStored()) : 0;
|
||||
return canConnectEnergy(from) ? convertInternalToRF_floor(energy_getEnergyStored()) : 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
@Optional.Method(modid = "CoFHCore") /* IEnergyReceiver and IEnergyProvider */
|
||||
public int getMaxEnergyStored(ForgeDirection from) {
|
||||
return canConnectEnergy(from) ? convertInternalToRF(getMaxEnergyStored()) : 0;
|
||||
return canConnectEnergy(from) ? convertInternalToRF_floor(energy_getMaxStorage()) : 0;
|
||||
}
|
||||
|
||||
|
||||
// WarpDrive overrides for Thermal Expansion
|
||||
@Optional.Method(modid = "CoFHCore")
|
||||
private void outputEnergy(ForgeDirection from, IEnergyReceiver energyReceiver) {
|
||||
private void CoFH_outputEnergy(ForgeDirection from, IEnergyReceiver energyReceiver) {
|
||||
if (energyReceiver == null || worldObj.getTileEntity(xCoord + from.offsetX, yCoord + from.offsetY, zCoord + from.offsetZ) == null) {
|
||||
return;
|
||||
}
|
||||
if (!canOutputEnergy(from)) {
|
||||
if (!energy_canOutput(from)) {
|
||||
return;
|
||||
}
|
||||
int potentialEnergyOutput_internal = getPotentialEnergyOutput();
|
||||
int potentialEnergyOutput_internal = energy_getPotentialOutput();
|
||||
if (potentialEnergyOutput_internal > 0) {
|
||||
int energyToOutput_RF = energyReceiver.receiveEnergy(from.getOpposite(), convertInternalToRF(potentialEnergyOutput_internal), true);
|
||||
int potentialEnergyOutput_RF = convertInternalToRF_floor(potentialEnergyOutput_internal);
|
||||
int energyToOutput_RF = energyReceiver.receiveEnergy(from.getOpposite(), potentialEnergyOutput_RF, true);
|
||||
if (energyToOutput_RF > 0) {
|
||||
int energyOutputted_RF = energyReceiver.receiveEnergy(from.getOpposite(), energyToOutput_RF, false);
|
||||
energyOutputDone(convertRFtoInternal(energyOutputted_RF));
|
||||
energy_outputDone(convertRFtoInternal_ceil(energyOutputted_RF));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Optional.Method(modid = "CoFHCore")
|
||||
private void outputEnergy() {
|
||||
private void CoFH_outputEnergy() {
|
||||
for (ForgeDirection from : ForgeDirection.VALID_DIRECTIONS) {
|
||||
if (cofhEnergyReceivers[from.ordinal()] != null) {
|
||||
outputEnergy(from, (IEnergyReceiver) cofhEnergyReceivers[from.ordinal()]);
|
||||
CoFH_outputEnergy(from, (IEnergyReceiver) cofhEnergyReceivers[from.ordinal()]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Optional.Method(modid = "CoFHCore")
|
||||
private void RF_initialiseAPI() {
|
||||
private void CoFH_initialiseAPI() {
|
||||
cofhEnergyReceivers = new IEnergyReceiver[ForgeDirection.VALID_DIRECTIONS.length];
|
||||
}
|
||||
|
||||
|
|
@ -451,7 +438,7 @@ public abstract class TileEntityAbstractEnergy extends TileEntityAbstractInterfa
|
|||
@Override
|
||||
public void writeToNBT(NBTTagCompound tag) {
|
||||
super.writeToNBT(tag);
|
||||
tag.setInteger("energy", getEnergyStored());
|
||||
tag.setInteger("energy", energy_getEnergyStored());
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
@ -467,14 +454,21 @@ public abstract class TileEntityAbstractEnergy extends TileEntityAbstractInterfa
|
|||
super.updatedNeighbours();
|
||||
|
||||
if (WarpDriveConfig.isCoFHCoreLoaded) {
|
||||
scanForEnergyHandlers();
|
||||
CoFH_scanForEnergyHandlers();
|
||||
}
|
||||
}
|
||||
|
||||
protected void energy_resetConnections(final EnumFacing facing) {
|
||||
if (WarpDriveConfig.isIndustrialCraft2Loaded) {
|
||||
IC2_removeFromEnergyNet();
|
||||
}
|
||||
scanTickCount = -1;
|
||||
}
|
||||
|
||||
@Optional.Method(modid = "CoFHCore")
|
||||
private void scanForEnergyHandlers() {
|
||||
private void CoFH_scanForEnergyHandlers() {
|
||||
if (WarpDriveConfig.LOGGING_ENERGY) {
|
||||
WarpDrive.logger.info(this + " [CoFH]scanForEnergyHandlers");
|
||||
WarpDrive.logger.info(this + " [CoFH]CoFH_scanForEnergyHandlers");
|
||||
}
|
||||
for (ForgeDirection from : ForgeDirection.VALID_DIRECTIONS) {
|
||||
boolean energyReceiverFound = false;
|
||||
|
|
|
|||
|
|
@ -112,7 +112,7 @@ public abstract class TileEntityAbstractLaser extends TileEntityAbstractInterfac
|
|||
break;
|
||||
}
|
||||
laserMediums.add((TileEntityLaserMedium) tileEntity);
|
||||
totalEnergy += ((TileEntityLaserMedium) tileEntity).getEnergyStored();
|
||||
totalEnergy += ((TileEntityLaserMedium) tileEntity).energy_getEnergyStored();
|
||||
}
|
||||
count--;
|
||||
if (count == 0) {
|
||||
|
|
@ -132,7 +132,7 @@ public abstract class TileEntityAbstractLaser extends TileEntityAbstractInterfac
|
|||
|
||||
// Secondary scan for laser medium below the required average
|
||||
for (TileEntityLaserMedium laserMedium : laserMediums) {
|
||||
int energyStored = laserMedium.getEnergyStored();
|
||||
int energyStored = laserMedium.energy_getEnergyStored();
|
||||
if (energyStored < energyAverage) {
|
||||
energyLeftOver += energyAverage - energyStored;
|
||||
}
|
||||
|
|
@ -141,10 +141,10 @@ public abstract class TileEntityAbstractLaser extends TileEntityAbstractInterfac
|
|||
// Third and final pass for energy consumption
|
||||
int energyTotalConsumed = 0;
|
||||
for (TileEntityLaserMedium laserMedium : laserMediums) {
|
||||
int energyStored = laserMedium.getEnergyStored();
|
||||
int energyStored = laserMedium.energy_getEnergyStored();
|
||||
int energyToConsume = Math.min(energyStored, energyAverage + energyLeftOver);
|
||||
energyLeftOver -= Math.max(0, energyToConsume - energyAverage);
|
||||
laserMedium.consumeEnergy(energyToConsume, false); // simulate is always false here
|
||||
laserMedium.energy_consume(energyToConsume, false); // simulate is always false here
|
||||
energyTotalConsumed += energyToConsume;
|
||||
}
|
||||
return energyTotalConsumed;
|
||||
|
|
@ -167,8 +167,8 @@ public abstract class TileEntityAbstractLaser extends TileEntityAbstractInterfac
|
|||
break;
|
||||
}
|
||||
// laserMediums.add((TileEntityLaserMedium) tileEntity);
|
||||
energyStored += ((TileEntityLaserMedium) tileEntity).getEnergyStored();
|
||||
energyStoredMax += ((TileEntityLaserMedium) tileEntity).getMaxEnergyStored();
|
||||
energyStored += ((TileEntityLaserMedium) tileEntity).energy_getEnergyStored();
|
||||
energyStoredMax += ((TileEntityLaserMedium) tileEntity).energy_getMaxStorage();
|
||||
}
|
||||
return new Object[] { energyStored, energyStoredMax };
|
||||
}
|
||||
|
|
|
|||
|
|
@ -38,7 +38,7 @@ public class TileEntityAirGenerator extends TileEntityAbstractEnergy {
|
|||
|
||||
cooldownTicks++;
|
||||
if (cooldownTicks > WarpDriveConfig.AIRGEN_AIR_GENERATION_TICKS) {
|
||||
if (consumeEnergy(WarpDriveConfig.AIRGEN_ENERGY_PER_NEWAIRBLOCK, true)) {
|
||||
if (energy_consume(WarpDriveConfig.AIRGEN_ENERGY_PER_NEWAIRBLOCK, true)) {
|
||||
if (getBlockMetadata() != 1) {
|
||||
worldObj.setBlockMetadataWithNotify(xCoord, yCoord, zCoord, 1, 2); // set enabled texture
|
||||
}
|
||||
|
|
@ -62,12 +62,12 @@ public class TileEntityAirGenerator extends TileEntityAbstractEnergy {
|
|||
Block block = worldObj.getBlock(xCoord + xOffset, yCoord + yOffset, zCoord + zOffset);
|
||||
if (block.isAir(worldObj, xCoord + xOffset, yCoord + yOffset, zCoord + zOffset)) {// can be air
|
||||
int energy_cost = (!block.isAssociatedBlock(WarpDrive.blockAir)) ? WarpDriveConfig.AIRGEN_ENERGY_PER_NEWAIRBLOCK : WarpDriveConfig.AIRGEN_ENERGY_PER_EXISTINGAIRBLOCK;
|
||||
if (consumeEnergy(energy_cost, true)) {// enough energy
|
||||
if (energy_consume(energy_cost, true)) {// enough energy
|
||||
if (worldObj.setBlock(xCoord + xOffset, yCoord + yOffset, zCoord + zOffset, WarpDrive.blockAir, START_CONCENTRATION_VALUE, 2)) {
|
||||
// (needs to renew air or was not maxed out)
|
||||
consumeEnergy(WarpDriveConfig.AIRGEN_ENERGY_PER_NEWAIRBLOCK, false);
|
||||
energy_consume(WarpDriveConfig.AIRGEN_ENERGY_PER_NEWAIRBLOCK, false);
|
||||
} else {
|
||||
consumeEnergy(WarpDriveConfig.AIRGEN_ENERGY_PER_EXISTINGAIRBLOCK, false);
|
||||
energy_consume(WarpDriveConfig.AIRGEN_ENERGY_PER_EXISTINGAIRBLOCK, false);
|
||||
}
|
||||
} else {// low energy => remove air block
|
||||
if (block.isAssociatedBlock(WarpDrive.blockAir)) {
|
||||
|
|
@ -95,12 +95,20 @@ public class TileEntityAirGenerator extends TileEntityAbstractEnergy {
|
|||
}
|
||||
|
||||
@Override
|
||||
public int getMaxEnergyStored() {
|
||||
public int energy_getMaxStorage() {
|
||||
return WarpDriveConfig.AIRGEN_MAX_ENERGY_STORED;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canInputEnergy(ForgeDirection from) {
|
||||
public boolean energy_canInput(ForgeDirection from) {
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return String.format("%s @ \'%s\' (%d %d %d)",
|
||||
getClass().getSimpleName(),
|
||||
worldObj == null ? "~NULL~" : worldObj.getWorldInfo().getWorldName(),
|
||||
xCoord, yCoord, zCoord);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,19 +1,17 @@
|
|||
package cr0s.warpdrive.block;
|
||||
|
||||
import java.util.Map;
|
||||
|
||||
import cpw.mods.fml.common.Optional;
|
||||
import cr0s.warpdrive.item.ItemUpgrade;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import net.minecraft.world.ChunkCoordIntPair;
|
||||
import net.minecraft.world.chunk.Chunk;
|
||||
import cr0s.warpdrive.api.IUpgradable;
|
||||
import cr0s.warpdrive.config.WarpDriveConfig;
|
||||
import cr0s.warpdrive.data.UpgradeType;
|
||||
import dan200.computercraft.api.lua.ILuaContext;
|
||||
import dan200.computercraft.api.peripheral.IComputerAccess;
|
||||
|
||||
public class TileEntityChunkLoader extends TileEntityAbstractChunkLoading implements IUpgradable
|
||||
{
|
||||
public class TileEntityChunkLoader extends TileEntityAbstractChunkLoading {
|
||||
private boolean canLoad = false;
|
||||
private boolean shouldLoad = false;
|
||||
|
||||
|
|
@ -38,10 +36,13 @@ public class TileEntityChunkLoader extends TileEntityAbstractChunkLoading implem
|
|||
"active",
|
||||
"upgrades"
|
||||
});
|
||||
|
||||
setUpgradeMaxCount(ItemUpgrade.getItemStack(UpgradeType.Energy), 2);
|
||||
setUpgradeMaxCount(ItemUpgrade.getItemStack(UpgradeType.Power), 2);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getMaxEnergyStored() {
|
||||
public int energy_getMaxStorage() {
|
||||
return WarpDriveConfig.CL_MAX_ENERGY;
|
||||
}
|
||||
|
||||
|
|
@ -65,11 +66,11 @@ public class TileEntityChunkLoader extends TileEntityAbstractChunkLoading implem
|
|||
|
||||
if(shouldLoad)
|
||||
{
|
||||
canLoad = consumeEnergy(area * WarpDriveConfig.CL_RF_PER_CHUNKTICK, false);
|
||||
canLoad = energy_consume(area * WarpDriveConfig.CL_RF_PER_CHUNKTICK, false);
|
||||
}
|
||||
else
|
||||
{
|
||||
canLoad = consumeEnergy(area * WarpDriveConfig.CL_RF_PER_CHUNKTICK, true);
|
||||
canLoad = energy_consume(area * WarpDriveConfig.CL_RF_PER_CHUNKTICK, true);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -152,41 +153,9 @@ public class TileEntityChunkLoader extends TileEntityAbstractChunkLoading implem
|
|||
shouldLoad = toBool(arguments[0]);
|
||||
return new Object[]{shouldChunkLoad()};
|
||||
case "upgrades":
|
||||
return getUpgrades_deprecated();
|
||||
return new Object[] { getUpgradesAsString() };
|
||||
}
|
||||
|
||||
return super.callMethod(computer, context, method, arguments);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean takeUpgrade(UpgradeType upgradeType, boolean simulate)
|
||||
{
|
||||
int max = 0;
|
||||
if(upgradeType == UpgradeType.Energy)
|
||||
max = 2;
|
||||
else if(upgradeType == UpgradeType.Power)
|
||||
max = 2;
|
||||
|
||||
if(max == 0)
|
||||
return false;
|
||||
|
||||
if(deprecated_upgrades.containsKey(upgradeType))
|
||||
if(deprecated_upgrades.get(upgradeType) >= max)
|
||||
return false;
|
||||
|
||||
if(!simulate)
|
||||
{
|
||||
int c = 0;
|
||||
if(deprecated_upgrades.containsKey(upgradeType))
|
||||
c = deprecated_upgrades.get(upgradeType);
|
||||
deprecated_upgrades.put(upgradeType, c+1);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Map<UpgradeType, Integer> getInstalledUpgrades()
|
||||
{
|
||||
return deprecated_upgrades;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ public class TileEntityLaserMedium extends TileEntityAbstractEnergy {
|
|||
if (ticks > 20) {
|
||||
ticks = 0;
|
||||
|
||||
int metadata = Math.max(0, Math.min(7, Math.round((getEnergyStored() * 8) / getMaxEnergyStored())));
|
||||
int metadata = Math.max(0, Math.min(7, Math.round((energy_getEnergyStored() * 8) / energy_getMaxStorage())));
|
||||
if (getBlockMetadata() != metadata) {
|
||||
worldObj.setBlockMetadataWithNotify(xCoord, yCoord, zCoord, metadata, 3);
|
||||
}
|
||||
|
|
@ -43,12 +43,12 @@ public class TileEntityLaserMedium extends TileEntityAbstractEnergy {
|
|||
|
||||
// IEnergySink methods implementation
|
||||
@Override
|
||||
public int getMaxEnergyStored() {
|
||||
public int energy_getMaxStorage() {
|
||||
return WarpDriveConfig.LASER_MEDIUM_MAX_ENERGY_STORED;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canInputEnergy(ForgeDirection from) {
|
||||
public boolean energy_canInput(ForgeDirection from) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -294,7 +294,7 @@ public class TileEntityShipScanner extends TileEntityAbstractEnergy {
|
|||
|
||||
// Consume energy
|
||||
int energyCost = getScanningEnergyCost(shipCore.shipMass);
|
||||
if (!consumeEnergy(energyCost, false)) {
|
||||
if (!energy_consume(energyCost, false)) {
|
||||
reason.append(String.format("Insufficient energy (%d required)", energyCost));
|
||||
return false;
|
||||
}
|
||||
|
|
@ -383,7 +383,7 @@ public class TileEntityShipScanner extends TileEntityAbstractEnergy {
|
|||
// Empty energy storage
|
||||
// IC2
|
||||
if (tagTileEntity.hasKey("energy")) {
|
||||
consumeEnergy((int)Math.round(tagTileEntity.getDouble("energy")), true);
|
||||
energy_consume((int)Math.round(tagTileEntity.getDouble("energy")), true);
|
||||
tagTileEntity.setDouble("energy", 0);
|
||||
}
|
||||
// Gregtech
|
||||
|
|
@ -392,7 +392,7 @@ public class TileEntityShipScanner extends TileEntityAbstractEnergy {
|
|||
}
|
||||
// Immersive Engineering & Thermal Expansion
|
||||
if (tagTileEntity.hasKey("Energy")) {
|
||||
consumeEnergy(tagTileEntity.getInteger("Energy"), true);
|
||||
energy_consume(tagTileEntity.getInteger("Energy"), true);
|
||||
tagTileEntity.setInteger("Energy", 0);
|
||||
}
|
||||
if (tagTileEntity.hasKey("Owner")) {
|
||||
|
|
@ -615,7 +615,7 @@ public class TileEntityShipScanner extends TileEntityAbstractEnergy {
|
|||
|
||||
// Consume energy
|
||||
int energyCost = getDeploymentEnergyCost(blocksToDeployCount);
|
||||
if (!consumeEnergy(energyCost, false)) {
|
||||
if (!energy_consume(energyCost, false)) {
|
||||
reason.append(String.format("Insufficient energy (%d required)", energyCost));
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -743,7 +743,7 @@ public class TileEntityShipScanner extends TileEntityAbstractEnergy {
|
|||
return new Object[] { false, 1, "Ship-Core not found" };
|
||||
}
|
||||
int energyCost = getScanningEnergyCost(shipCore.shipMass);
|
||||
if (!consumeEnergy(energyCost, true)) {
|
||||
if (!energy_consume(energyCost, true)) {
|
||||
return new Object[] { false, 2, "Not enough energy! " + energyCost + " required." };
|
||||
} else {
|
||||
StringBuilder reason = new StringBuilder();
|
||||
|
|
@ -895,12 +895,12 @@ public class TileEntityShipScanner extends TileEntityAbstractEnergy {
|
|||
|
||||
// IEnergySink methods implementation
|
||||
@Override
|
||||
public int getMaxEnergyStored() {
|
||||
public int energy_getMaxStorage() {
|
||||
return WarpDriveConfig.SS_MAX_ENERGY_STORED;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canInputEnergy(ForgeDirection from) {
|
||||
public boolean energy_canInput(ForgeDirection from) {
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -124,7 +124,7 @@ public class TileEntityCloakingCore extends TileEntityAbstractEnergy {
|
|||
if (WarpDriveConfig.LOGGING_CLOAKING) {
|
||||
WarpDrive.logger.info(this + " Coil(s) lost, cloak field is collapsing...");
|
||||
}
|
||||
consumeAllEnergy();
|
||||
energy_consume(energy_getEnergyStored());
|
||||
disableCloakingField();
|
||||
} else {// enabled, cloaking and valid
|
||||
if (hasEnoughPower) {// enabled, cloaking and able to
|
||||
|
|
@ -279,7 +279,7 @@ public class TileEntityCloakingCore extends TileEntityAbstractEnergy {
|
|||
}
|
||||
|
||||
// WarpDrive.logger.info(this + " Consuming " + energyToConsume + " EU for " + blocksCount + " blocks");
|
||||
return consumeEnergy(energyToConsume, false);
|
||||
return energy_consume(energyToConsume, false);
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
@ -444,12 +444,12 @@ public class TileEntityCloakingCore extends TileEntityAbstractEnergy {
|
|||
}
|
||||
|
||||
@Override
|
||||
public int getMaxEnergyStored() {
|
||||
public int energy_getMaxStorage() {
|
||||
return WarpDriveConfig.CLOAKING_MAX_ENERGY_STORED;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canInputEnergy(ForgeDirection from) {
|
||||
public boolean energy_canInput(ForgeDirection from) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -178,7 +178,7 @@ public class TileEntityRadar extends TileEntityAbstractEnergy {
|
|||
return new Object[] { false, "Invalid radius" };
|
||||
}
|
||||
int energyRequired = calculateEnergyRequired(radius);
|
||||
if (!consumeEnergy(energyRequired, false)) {
|
||||
if (!energy_consume(energyRequired, false)) {
|
||||
return new Object[] { false, "Insufficient energy" };
|
||||
}
|
||||
|
||||
|
|
@ -264,12 +264,12 @@ public class TileEntityRadar extends TileEntityAbstractEnergy {
|
|||
}
|
||||
|
||||
@Override
|
||||
public int getMaxEnergyStored() {
|
||||
public int energy_getMaxStorage() {
|
||||
return WarpDriveConfig.RADAR_MAX_ENERGY_STORED;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canInputEnergy(ForgeDirection from) {
|
||||
public boolean energy_canInput(ForgeDirection from) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -74,7 +74,7 @@ public class TileEntityEnanReactorCore extends TileEntityAbstractEnergy {
|
|||
}
|
||||
|
||||
private void increaseInstability(ForgeDirection from, boolean isNatural) {
|
||||
if (canOutputEnergy(from)) {
|
||||
if (energy_canOutput(from)) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -100,14 +100,14 @@ public class TileEntityEnanReactorCore extends TileEntityAbstractEnergy {
|
|||
}
|
||||
|
||||
public void decreaseInstability(ForgeDirection from, int energy) {
|
||||
if (canOutputEnergy(from)) {
|
||||
if (energy_canOutput(from)) {
|
||||
return;
|
||||
}
|
||||
|
||||
// laser is active => start updating reactor
|
||||
hold = false;
|
||||
|
||||
int amount = convertInternalToRF(energy);
|
||||
int amount = convertInternalToRF_floor(energy);
|
||||
if (amount <= 1) {
|
||||
return;
|
||||
}
|
||||
|
|
@ -454,7 +454,7 @@ public class TileEntityEnanReactorCore extends TileEntityAbstractEnergy {
|
|||
|
||||
// POWER INTERFACES
|
||||
@Override
|
||||
public int getPotentialEnergyOutput() {
|
||||
public int energy_getPotentialOutput() {
|
||||
if (hold) {// still loading/booting => hold output
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -463,31 +463,31 @@ public class TileEntityEnanReactorCore extends TileEntityAbstractEnergy {
|
|||
if (releaseMode == MODE_MANUAL_RELEASE) {
|
||||
result = Math.min(Math.max(0, containedEnergy), capacity);
|
||||
if (WarpDriveConfig.LOGGING_ENERGY) {
|
||||
WarpDrive.logger.info("PotentialOutput Manual " + result + " RF (" + convertRFtoInternal(result) + " internal) capacity " + capacity);
|
||||
WarpDrive.logger.info("PotentialOutput Manual " + result + " RF (" + convertRFtoInternal_floor(result) + " internal) capacity " + capacity);
|
||||
}
|
||||
} else if (releaseMode == MODE_RELEASE_ABOVE) {
|
||||
result = Math.min(Math.max(0, containedEnergy - releaseAbove), capacity);
|
||||
if (WarpDriveConfig.LOGGING_ENERGY) {
|
||||
WarpDrive.logger.info("PotentialOutput Above " + result + " RF (" + convertRFtoInternal(result) + " internal) capacity " + capacity);
|
||||
WarpDrive.logger.info("PotentialOutput Above " + result + " RF (" + convertRFtoInternal_floor(result) + " internal) capacity " + capacity);
|
||||
}
|
||||
} else if (releaseMode == MODE_RELEASE_AT_RATE) {
|
||||
int remainingRate = Math.max(0, releaseRate - releasedThisTick);
|
||||
result = Math.min(Math.max(0, containedEnergy), Math.min(remainingRate, capacity));
|
||||
if (WarpDriveConfig.LOGGING_ENERGY) {
|
||||
WarpDrive.logger.info("PotentialOutput Rated " + result + " RF (" + convertRFtoInternal(result) + " internal) remainingRate " + remainingRate + " RF/t capacity " + capacity);
|
||||
WarpDrive.logger.info("PotentialOutput Rated " + result + " RF (" + convertRFtoInternal_floor(result) + " internal) remainingRate " + remainingRate + " RF/t capacity " + capacity);
|
||||
}
|
||||
}
|
||||
return convertRFtoInternal(result);
|
||||
return convertRFtoInternal_floor(result);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canOutputEnergy(ForgeDirection from) {
|
||||
public boolean energy_canOutput(ForgeDirection from) {
|
||||
return from.equals(ForgeDirection.UP) || from.equals(ForgeDirection.DOWN);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void energyOutputDone(int energyOutput_internal) {
|
||||
int energyOutput_RF = convertInternalToRF(energyOutput_internal);
|
||||
protected void energy_outputDone(int energyOutput_internal) {
|
||||
int energyOutput_RF = convertRFtoInternal_ceil(energyOutput_internal);
|
||||
containedEnergy -= energyOutput_RF;
|
||||
if (containedEnergy < 0) {
|
||||
containedEnergy = 0;
|
||||
|
|
@ -500,13 +500,13 @@ public class TileEntityEnanReactorCore extends TileEntityAbstractEnergy {
|
|||
}
|
||||
|
||||
@Override
|
||||
public int getEnergyStored() {
|
||||
return convertRFtoInternal(containedEnergy);
|
||||
public int energy_getEnergyStored() {
|
||||
return convertRFtoInternal_floor(containedEnergy);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getMaxEnergyStored() {
|
||||
return convertRFtoInternal(WarpDriveConfig.ENAN_REACTOR_MAX_ENERGY_STORED);
|
||||
public int energy_getMaxStorage() {
|
||||
return convertRFtoInternal_floor(WarpDriveConfig.ENAN_REACTOR_MAX_ENERGY_STORED);
|
||||
}
|
||||
|
||||
// Forge overrides
|
||||
|
|
|
|||
|
|
@ -25,27 +25,22 @@ public class TileEntityEnergyBank extends TileEntityAbstractEnergy {
|
|||
}
|
||||
|
||||
@Override
|
||||
public int getPotentialEnergyOutput() {
|
||||
return getEnergyStored();
|
||||
public int energy_getPotentialOutput() {
|
||||
return energy_getEnergyStored();
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void energyOutputDone(int energyOutput) {
|
||||
consumeEnergy(energyOutput, false);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getMaxEnergyStored() {
|
||||
public int energy_getMaxStorage() {
|
||||
return WarpDriveConfig.ENERGY_BANK_MAX_ENERGY_STORED;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canInputEnergy(ForgeDirection from) {
|
||||
public boolean energy_canInput(ForgeDirection from) {
|
||||
return modeSide[from.ordinal()] == MODE_INPUT;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canOutputEnergy(ForgeDirection to) {
|
||||
public boolean energy_canOutput(ForgeDirection to) {
|
||||
return modeSide[to.ordinal()] == MODE_OUTPUT;
|
||||
}
|
||||
|
||||
|
|
@ -56,6 +51,7 @@ public class TileEntityEnergyBank extends TileEntityAbstractEnergy {
|
|||
void setMode(final EnumFacing facing, final byte mode) {
|
||||
modeSide[facing.ordinal()] = (byte)(mode % 3);
|
||||
markDirty();
|
||||
energy_resetConnections(facing);
|
||||
}
|
||||
|
||||
// Forge overrides
|
||||
|
|
@ -93,4 +89,13 @@ public class TileEntityEnergyBank extends TileEntityAbstractEnergy {
|
|||
readFromNBT(tagCompound);
|
||||
worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return String.format("%s @ \'%s\' (%d %d %d) %8d",
|
||||
getClass().getSimpleName(),
|
||||
worldObj == null ? "~NULL~" : worldObj.getWorldInfo().getWorldName(),
|
||||
xCoord, yCoord, zCoord,
|
||||
energy_getEnergyStored());
|
||||
}
|
||||
}
|
||||
|
|
@ -102,10 +102,10 @@ public class TileEntityIC2reactorLaserMonitor extends TileEntityAbstractEnergy {
|
|||
if (item != null) {
|
||||
if (item.getItem() instanceof ItemIC2reactorLaserFocus) {
|
||||
int heatInLaserFocus = item.getItemDamage();
|
||||
int heatRemovable = (int) Math.floor(Math.min(getEnergyStored() / WarpDriveConfig.IC2_REACTOR_ENERGY_PER_HEAT, heatInLaserFocus));
|
||||
int heatRemovable = (int) Math.floor(Math.min(energy_getEnergyStored() / WarpDriveConfig.IC2_REACTOR_ENERGY_PER_HEAT, heatInLaserFocus));
|
||||
if (heatRemovable > 0) {
|
||||
didCoolReactor = true;
|
||||
if (consumeEnergy((int) Math.ceil(heatRemovable * WarpDriveConfig.IC2_REACTOR_ENERGY_PER_HEAT), false)) {
|
||||
if (energy_consume((int) Math.ceil(heatRemovable * WarpDriveConfig.IC2_REACTOR_ENERGY_PER_HEAT), false)) {
|
||||
item.setItemDamage(heatInLaserFocus - heatRemovable);
|
||||
}
|
||||
}
|
||||
|
|
@ -151,7 +151,7 @@ public class TileEntityIC2reactorLaserMonitor extends TileEntityAbstractEnergy {
|
|||
|
||||
private void setMetadata() {
|
||||
int metadata = (updateFlag ? 0 : 1) | (activeSides != 0 ? 2 : 0);
|
||||
if (getEnergyStored() >= WarpDriveConfig.IC2_REACTOR_ENERGY_PER_HEAT) {
|
||||
if (energy_getEnergyStored() >= WarpDriveConfig.IC2_REACTOR_ENERGY_PER_HEAT) {
|
||||
metadata |= 8;
|
||||
}
|
||||
if (getBlockMetadata() != metadata) {
|
||||
|
|
@ -203,12 +203,12 @@ public class TileEntityIC2reactorLaserMonitor extends TileEntityAbstractEnergy {
|
|||
}
|
||||
|
||||
@Override
|
||||
public int getMaxEnergyStored() {
|
||||
public int energy_getMaxStorage() {
|
||||
return WarpDriveConfig.IC2_REACTOR_MAX_ENERGY_STORED;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canInputEnergy(ForgeDirection from) {
|
||||
public boolean energy_canInput(ForgeDirection from) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -153,10 +153,10 @@ public class TileEntityForceFieldProjector extends TileEntityAbstractForceField
|
|||
} else {
|
||||
energyRequired = (int)Math.round( forceFieldSetup.scanEnergyCost * forceFieldSetup.scanSpeed * PROJECTOR_PROJECTION_UPDATE_TICKS / 20.0F);
|
||||
}
|
||||
if (energyRequired > getMaxEnergyStored()) {
|
||||
WarpDrive.logger.error("Force field projector requires " + energyRequired + " to get started but can only store " + getMaxEnergyStored());
|
||||
if (energyRequired > energy_getMaxStorage()) {
|
||||
WarpDrive.logger.error("Force field projector requires " + energyRequired + " to get started but can only store " + energy_getMaxStorage());
|
||||
}
|
||||
isPowered = getEnergyStored() >= energyRequired;
|
||||
isPowered = energy_getEnergyStored() >= energyRequired;
|
||||
|
||||
boolean isEnabledAndValid = isEnabled && isValid();
|
||||
boolean isOn = isEnabledAndValid && cooldownTicks <= 0 && isPowered;
|
||||
|
|
@ -955,7 +955,7 @@ public class TileEntityForceFieldProjector extends TileEntityAbstractForceField
|
|||
if ( legacy_forceFieldSetup.getCamouflageBlock() != cache_forceFieldSetup.getCamouflageBlock()
|
||||
|| legacy_forceFieldSetup.getCamouflageMetadata() != cache_forceFieldSetup.getCamouflageMetadata()
|
||||
|| legacy_forceFieldSetup.beamFrequency != cache_forceFieldSetup.beamFrequency
|
||||
|| !consumeEnergy(energyRequired, false)) {
|
||||
|| !energy_consume(energyRequired, false)) {
|
||||
if (WarpDriveConfig.LOGGING_FORCEFIELD) {
|
||||
WarpDrive.logger.info(this + " rebooting with new rendering...");
|
||||
}
|
||||
|
|
@ -966,7 +966,8 @@ public class TileEntityForceFieldProjector extends TileEntityAbstractForceField
|
|||
|| legacy_forceFieldSetup.thickness != cache_forceFieldSetup.thickness
|
||||
|| !legacy_forceFieldSetup.vMin.equals(cache_forceFieldSetup.vMin)
|
||||
|| !legacy_forceFieldSetup.vMax.equals(cache_forceFieldSetup.vMax)
|
||||
|| !legacy_forceFieldSetup.vTranslation.equals(cache_forceFieldSetup.vTranslation)) {
|
||||
|| !legacy_forceFieldSetup.vTranslation.equals(cache_forceFieldSetup.vTranslation)
|
||||
|| (legacy_forceFieldSetup.breaking_maxHardness <= 0 && cache_forceFieldSetup.breaking_maxHardness > 0) ) {
|
||||
if (WarpDriveConfig.LOGGING_FORCEFIELD) {
|
||||
WarpDrive.logger.info(this + " rebooting with new shape...");
|
||||
}
|
||||
|
|
@ -979,18 +980,18 @@ public class TileEntityForceFieldProjector extends TileEntityAbstractForceField
|
|||
}
|
||||
|
||||
@Override
|
||||
public int getMaxEnergyStored() {
|
||||
public int energy_getMaxStorage() {
|
||||
return maxEnergyStored;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canInputEnergy(ForgeDirection from) {
|
||||
public boolean energy_canInput(ForgeDirection from) {
|
||||
return true;
|
||||
}
|
||||
|
||||
public boolean consumeEnergy(final double amount_internal, boolean simulate) {
|
||||
int intAmount = (int)Math.floor(amount_internal + consumptionLeftOver);
|
||||
boolean bResult = super.consumeEnergy(intAmount, simulate);
|
||||
boolean bResult = super.energy_consume(intAmount, simulate);
|
||||
if (!simulate) {
|
||||
consumptionLeftOver = amount_internal + consumptionLeftOver - intAmount;
|
||||
}
|
||||
|
|
@ -1045,7 +1046,7 @@ public class TileEntityForceFieldProjector extends TileEntityAbstractForceField
|
|||
|
||||
// Common OC/CC methods
|
||||
private Object[] state() { // isConnected, isPowered, shape
|
||||
int energy = getEnergyStored();
|
||||
int energy = energy_getEnergyStored();
|
||||
String status = getStatus();
|
||||
return new Object[] { status, isEnabled, isConnected, isPowered, getShape().name(), energy };
|
||||
}
|
||||
|
|
|
|||
|
|
@ -70,7 +70,7 @@ public class TileEntityLift extends TileEntityAbstractEnergy {
|
|||
&& isPassableBlock(yCoord - 1)
|
||||
&& isPassableBlock(yCoord - 2);
|
||||
|
||||
if (getEnergyStored() < WarpDriveConfig.LIFT_ENERGY_PER_ENTITY || !isEnabled) {
|
||||
if (energy_getEnergyStored() < WarpDriveConfig.LIFT_ENERGY_PER_ENTITY || !isEnabled) {
|
||||
mode = MODE_INACTIVE;
|
||||
if (getBlockMetadata() != 0) {
|
||||
worldObj.setBlockMetadataWithNotify(xCoord, yCoord, zCoord, 0, 2); // disabled
|
||||
|
|
@ -133,14 +133,14 @@ public class TileEntityLift extends TileEntityAbstractEnergy {
|
|||
for (Object o : list) {
|
||||
if ( o != null
|
||||
&& o instanceof EntityLivingBase
|
||||
&& consumeEnergy(WarpDriveConfig.LIFT_ENERGY_PER_ENTITY, true)) {
|
||||
&& energy_consume(WarpDriveConfig.LIFT_ENERGY_PER_ENTITY, true)) {
|
||||
((EntityLivingBase) o).setPositionAndUpdate(xCoord + 0.5D, yCoord + 1.0D, zCoord + 0.5D);
|
||||
PacketHandler.sendBeamPacket(worldObj,
|
||||
new Vector3(xCoord + 0.5D, firstUncoveredY, zCoord + 0.5D),
|
||||
new Vector3(xCoord + 0.5D, yCoord, zCoord + 0.5D),
|
||||
1F, 1F, 0F, 40, 0, 100);
|
||||
worldObj.playSoundEffect(xCoord + 0.5D, yCoord, zCoord + 0.5D, "warpdrive:hilaser", 4F, 1F);
|
||||
consumeEnergy(WarpDriveConfig.LIFT_ENERGY_PER_ENTITY, false);
|
||||
energy_consume(WarpDriveConfig.LIFT_ENERGY_PER_ENTITY, false);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -152,13 +152,13 @@ public class TileEntityLift extends TileEntityAbstractEnergy {
|
|||
for (Object o : list) {
|
||||
if ( o != null
|
||||
&& o instanceof EntityLivingBase
|
||||
&& consumeEnergy(WarpDriveConfig.LIFT_ENERGY_PER_ENTITY, true)) {
|
||||
&& energy_consume(WarpDriveConfig.LIFT_ENERGY_PER_ENTITY, true)) {
|
||||
((EntityLivingBase) o).setPositionAndUpdate(xCoord + 0.5D, firstUncoveredY, zCoord + 0.5D);
|
||||
PacketHandler.sendBeamPacket(worldObj,
|
||||
new Vector3(xCoord + 0.5D, yCoord, zCoord + 0.5D),
|
||||
new Vector3(xCoord + 0.5D, firstUncoveredY, zCoord + 0.5D), 1F, 1F, 0F, 40, 0, 100);
|
||||
worldObj.playSoundEffect(xCoord + 0.5D, yCoord, zCoord + 0.5D, "warpdrive:hilaser", 4F, 1F);
|
||||
consumeEnergy(WarpDriveConfig.LIFT_ENERGY_PER_ENTITY, false);
|
||||
energy_consume(WarpDriveConfig.LIFT_ENERGY_PER_ENTITY, false);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -188,12 +188,12 @@ public class TileEntityLift extends TileEntityAbstractEnergy {
|
|||
}
|
||||
|
||||
@Override
|
||||
public int getMaxEnergyStored() {
|
||||
public int energy_getMaxStorage() {
|
||||
return WarpDriveConfig.LIFT_MAX_ENERGY_STORED;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canInputEnergy(ForgeDirection from) {
|
||||
public boolean energy_canInput(ForgeDirection from) {
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -493,7 +493,7 @@ public class TileEntityShipCore extends TileEntityAbstractEnergy {
|
|||
}
|
||||
|
||||
private void summonPlayer(EntityPlayerMP player, final int x, final int y, final int z) {
|
||||
if (consumeEnergy(WarpDriveConfig.SHIP_TELEPORT_ENERGY_PER_ENTITY, false)) {
|
||||
if (energy_consume(WarpDriveConfig.SHIP_TELEPORT_ENERGY_PER_ENTITY, false)) {
|
||||
if (player.dimension != worldObj.provider.dimensionId) {
|
||||
player.mcServer.getConfigurationManager().transferPlayerToDimension(
|
||||
player,
|
||||
|
|
@ -637,7 +637,7 @@ public class TileEntityShipCore extends TileEntityAbstractEnergy {
|
|||
// Now make jump to a beacon
|
||||
if (isBeaconFound) {
|
||||
// Consume energy
|
||||
if (consumeEnergy(calculateRequiredEnergy(currentMode, shipMass, controller.getDistance()), false)) {
|
||||
if (energy_consume(calculateRequiredEnergy(currentMode, shipMass, controller.getDistance()), false)) {
|
||||
WarpDrive.logger.info(this + " Moving ship to beacon (" + beaconX + "; " + yCoord + "; " + beaconZ + ")");
|
||||
JumpSequencer jump = new JumpSequencer(this, false, 0, 0, 0, (byte)0, true, beaconX, yCoord, beaconZ);
|
||||
jump.enable();
|
||||
|
|
@ -800,7 +800,7 @@ public class TileEntityShipCore extends TileEntityAbstractEnergy {
|
|||
}
|
||||
|
||||
// Consume energy
|
||||
if (consumeEnergy(calculateRequiredEnergy(currentMode, shipMass, controller.getDistance()), false)) {
|
||||
if (energy_consume(calculateRequiredEnergy(currentMode, shipMass, controller.getDistance()), false)) {
|
||||
WarpDrive.logger.info(this + " Moving ship to a place around gate '" + targetGate.name + "' (" + destX + "; " + destY + "; " + destZ + ")");
|
||||
JumpSequencer jump = new JumpSequencer(this, false, 0, 0, 0, (byte)0, true, destX, destY, destZ);
|
||||
jump.enable();
|
||||
|
|
@ -813,8 +813,8 @@ public class TileEntityShipCore extends TileEntityAbstractEnergy {
|
|||
int distance = controller.getDistance();
|
||||
int requiredEnergy = calculateRequiredEnergy(currentMode, shipMass, distance);
|
||||
|
||||
if (!consumeEnergy(requiredEnergy, true)) {
|
||||
messageToAllPlayersOnShip("Insufficient energy to jump! Core is currently charged with " + getEnergyStored() + " EU while jump requires "
|
||||
if (!energy_consume(requiredEnergy, true)) {
|
||||
messageToAllPlayersOnShip("Insufficient energy to jump! Core is currently charged with " + energy_getEnergyStored() + " EU while jump requires "
|
||||
+ requiredEnergy + " EU");
|
||||
controller.setJumpFlag(false);
|
||||
return;
|
||||
|
|
@ -858,7 +858,7 @@ public class TileEntityShipCore extends TileEntityAbstractEnergy {
|
|||
}
|
||||
|
||||
if (currentMode == EnumShipCoreMode.BASIC_JUMP || currentMode == EnumShipCoreMode.LONG_JUMP || currentMode == EnumShipCoreMode.HYPERSPACE) {
|
||||
if (!consumeEnergy(requiredEnergy, false)) {
|
||||
if (!energy_consume(requiredEnergy, false)) {
|
||||
messageToAllPlayersOnShip("Insufficient energy level");
|
||||
return;
|
||||
}
|
||||
|
|
@ -904,7 +904,7 @@ public class TileEntityShipCore extends TileEntityAbstractEnergy {
|
|||
return;
|
||||
}
|
||||
for (Object o : list) {
|
||||
if (!consumeEnergy(WarpDriveConfig.SHIP_TELEPORT_ENERGY_PER_ENTITY, false)) {
|
||||
if (!energy_consume(WarpDriveConfig.SHIP_TELEPORT_ENERGY_PER_ENTITY, false)) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -1119,12 +1119,12 @@ public class TileEntityShipCore extends TileEntityAbstractEnergy {
|
|||
}
|
||||
|
||||
@Override
|
||||
public int getMaxEnergyStored() {
|
||||
public int energy_getMaxStorage() {
|
||||
return WarpDriveConfig.SHIP_MAX_ENERGY_STORED;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canInputEnergy(ForgeDirection from) {
|
||||
public boolean energy_canInput(ForgeDirection from) {
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -2,8 +2,8 @@ package cr0s.warpdrive.block.movement;
|
|||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
import cr0s.warpdrive.item.ItemUpgrade;
|
||||
import li.cil.oc.api.machine.Arguments;
|
||||
import li.cil.oc.api.machine.Callback;
|
||||
import li.cil.oc.api.machine.Context;
|
||||
|
|
@ -16,7 +16,6 @@ import net.minecraft.util.StatCollector;
|
|||
import net.minecraftforge.common.util.ForgeDirection;
|
||||
import cr0s.warpdrive.DamageTeleportation;
|
||||
import cr0s.warpdrive.WarpDrive;
|
||||
import cr0s.warpdrive.api.IUpgradable;
|
||||
import cr0s.warpdrive.block.TileEntityAbstractEnergy;
|
||||
import cr0s.warpdrive.config.WarpDriveConfig;
|
||||
import cr0s.warpdrive.data.UpgradeType;
|
||||
|
|
@ -24,7 +23,7 @@ import cr0s.warpdrive.data.Vector3;
|
|||
import dan200.computercraft.api.lua.ILuaContext;
|
||||
import dan200.computercraft.api.peripheral.IComputerAccess;
|
||||
|
||||
public class TileEntityTransporter extends TileEntityAbstractEnergy implements IUpgradable {
|
||||
public class TileEntityTransporter extends TileEntityAbstractEnergy {
|
||||
private double scanRange = 2;
|
||||
|
||||
private int scanDist = 4;
|
||||
|
|
@ -59,6 +58,10 @@ public class TileEntityTransporter extends TileEntityAbstractEnergy implements I
|
|||
"getEnergyRequired",
|
||||
"upgrades"
|
||||
});
|
||||
|
||||
setUpgradeMaxCount(ItemUpgrade.getItemStack(UpgradeType.Energy), 2);
|
||||
setUpgradeMaxCount(ItemUpgrade.getItemStack(UpgradeType.Power), 4);
|
||||
setUpgradeMaxCount(ItemUpgrade.getItemStack(UpgradeType.Range), 4);
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
@ -300,7 +303,7 @@ public class TileEntityTransporter extends TileEntityAbstractEnergy implements I
|
|||
}
|
||||
Vector3 modDest = destVec.clone().translate(centreOnMe);
|
||||
for (Entity ent : entitiesToTransport) {
|
||||
if (consumeEnergy(energyRequired, false)) {
|
||||
if (energy_consume(energyRequired, false)) {
|
||||
if (WarpDriveConfig.LOGGING_TRANSPORTER) {
|
||||
WarpDrive.logger.info(this + " Transporting entity " + ent.getEntityId());
|
||||
}
|
||||
|
|
@ -430,9 +433,8 @@ public class TileEntityTransporter extends TileEntityAbstractEnergy implements I
|
|||
|
||||
private double getLockStrength() {
|
||||
if (isLocked) {
|
||||
double upgradeBoost = 1;
|
||||
if (deprecated_upgrades.containsKey(UpgradeType.Range))
|
||||
upgradeBoost = Math.pow(1.2, deprecated_upgrades.get(UpgradeType.Range));
|
||||
int rangeUgrades = getUpgradeCount(ItemUpgrade.getItemStack(UpgradeType.Range));
|
||||
double upgradeBoost = Math.pow(1.2, rangeUgrades);
|
||||
return clamp(0, 1, baseLockStrength * lockStrengthMul * Math.pow(2, powerBoost - 1) * upgradeBoost * (1 + beaconEffect));
|
||||
}
|
||||
return -1;
|
||||
|
|
@ -500,16 +502,14 @@ public class TileEntityTransporter extends TileEntityAbstractEnergy implements I
|
|||
}
|
||||
|
||||
@Override
|
||||
public int getMaxEnergyStored() {
|
||||
int max = WarpDriveConfig.TRANSPORTER_MAX_ENERGY_STORED;
|
||||
if (deprecated_upgrades.containsKey(UpgradeType.Energy)) {
|
||||
max = (int) Math.floor(max * Math.pow(1.2, deprecated_upgrades.get(UpgradeType.Energy)));
|
||||
}
|
||||
public int energy_getMaxStorage() {
|
||||
int energyUgrades = getUpgradeCount(ItemUpgrade.getItemStack(UpgradeType.Energy));
|
||||
int max = (int) Math.floor(WarpDriveConfig.TRANSPORTER_MAX_ENERGY_STORED * Math.pow(1.2, energyUgrades));
|
||||
return max;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canInputEnergy(ForgeDirection from) {
|
||||
public boolean energy_canInput(ForgeDirection from) {
|
||||
if (from == ForgeDirection.UP) {
|
||||
return false;
|
||||
}
|
||||
|
|
@ -527,35 +527,4 @@ public class TileEntityTransporter extends TileEntityAbstractEnergy implements I
|
|||
super.readFromNBT(tag);
|
||||
powerBoost = tag.getDouble("powerBoost");
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean takeUpgrade(UpgradeType upgradeType, boolean simulate) {
|
||||
int max = 0;
|
||||
if (upgradeType == UpgradeType.Energy)
|
||||
max = 2;
|
||||
else if (upgradeType == UpgradeType.Power)
|
||||
max = 4;
|
||||
else if (upgradeType == UpgradeType.Range)
|
||||
max = 4;
|
||||
|
||||
if (max == 0)
|
||||
return false;
|
||||
|
||||
if (deprecated_upgrades.containsKey(upgradeType))
|
||||
if (deprecated_upgrades.get(upgradeType) >= max)
|
||||
return false;
|
||||
|
||||
if (!simulate) {
|
||||
int c = 0;
|
||||
if (deprecated_upgrades.containsKey(upgradeType))
|
||||
c = deprecated_upgrades.get(upgradeType);
|
||||
deprecated_upgrades.put(upgradeType, c + 1);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Map<UpgradeType, Integer> getInstalledUpgrades() {
|
||||
return deprecated_upgrades;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue