remove MJ API compatibility layer
This commit is contained in:
parent
efdbeb31aa
commit
2c04e14389
10 changed files with 8 additions and 725 deletions
|
@ -1,23 +0,0 @@
|
|||
/**
|
||||
* Copyright (c) 2011-2014, SpaceToad and the BuildCraft Team
|
||||
* http://www.mod-buildcraft.com
|
||||
*
|
||||
* BuildCraft is distributed under the terms of the Minecraft Mod Public
|
||||
* License 1.0, or MMPL. Please check the contents of the license located in
|
||||
* http://www.mod-buildcraft.com/MMPL-1.0.txt
|
||||
*/
|
||||
package buildcraft.api.power;
|
||||
|
||||
import net.minecraftforge.common.util.ForgeDirection;
|
||||
|
||||
/**
|
||||
* Essentially only used for Wooden Power Pipe connection rules.
|
||||
*
|
||||
* This Tile Entity interface allows you to indicate that a block can emit power
|
||||
* from a specific side.
|
||||
*/
|
||||
@Deprecated
|
||||
public interface IPowerEmitter {
|
||||
|
||||
boolean canEmitPowerFrom(ForgeDirection side);
|
||||
}
|
|
@ -1,47 +0,0 @@
|
|||
/**
|
||||
* Copyright (c) 2011-2014, SpaceToad and the BuildCraft Team
|
||||
* http://www.mod-buildcraft.com
|
||||
*
|
||||
* BuildCraft is distributed under the terms of the Minecraft Mod Public
|
||||
* License 1.0, or MMPL. Please check the contents of the license located in
|
||||
* http://www.mod-buildcraft.com/MMPL-1.0.txt
|
||||
*/
|
||||
package buildcraft.api.power;
|
||||
|
||||
import net.minecraft.world.World;
|
||||
|
||||
import net.minecraftforge.common.util.ForgeDirection;
|
||||
|
||||
/**
|
||||
* This interface should be implemented by any Tile Entity that wishes to be
|
||||
* able to receive power.
|
||||
*/
|
||||
@Deprecated
|
||||
public interface IPowerReceptor {
|
||||
|
||||
/**
|
||||
* Get the PowerReceiver for this side of the block. You can return the same
|
||||
* PowerReceiver for all sides or one for each side.
|
||||
*
|
||||
* You should NOT return null to this method unless you mean to NEVER
|
||||
* receive power from that side. Returning null, after previous returning a
|
||||
* PowerReceiver, will most likely cause pipe connections to derp out and
|
||||
* engines to eventually explode.
|
||||
*
|
||||
* @param side
|
||||
* @return
|
||||
*/
|
||||
PowerHandler.PowerReceiver getPowerReceiver(ForgeDirection side);
|
||||
|
||||
/**
|
||||
* Call back from the PowerHandler that is called when the stored power
|
||||
* exceeds the activation power.
|
||||
*
|
||||
* It can be triggered by update() calls or power modification calls.
|
||||
*
|
||||
* @param workProvider
|
||||
*/
|
||||
void doWork(PowerHandler workProvider);
|
||||
|
||||
World getWorld();
|
||||
}
|
|
@ -1,493 +0,0 @@
|
|||
/**
|
||||
* Copyright (c) 2011-2014, SpaceToad and the BuildCraft Team
|
||||
* http://www.mod-buildcraft.com
|
||||
*
|
||||
* BuildCraft is distributed under the terms of the Minecraft Mod Public
|
||||
* License 1.0, or MMPL. Please check the contents of the license located in
|
||||
* http://www.mod-buildcraft.com/MMPL-1.0.txt
|
||||
*/
|
||||
package buildcraft.api.power;
|
||||
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
|
||||
import net.minecraftforge.common.util.ForgeDirection;
|
||||
|
||||
import buildcraft.api.core.SafeTimeTracker;
|
||||
|
||||
/**
|
||||
* The PowerHandler is similar to FluidTank in that it holds your power and
|
||||
* allows standardized interaction between machines.
|
||||
*
|
||||
* To receive power to your machine you needs create an instance of PowerHandler
|
||||
* and implement IPowerReceptor on the TileEntity.
|
||||
*
|
||||
* If you plan emit power, you need only implement IPowerEmitter. You do not
|
||||
* need a PowerHandler. Engines have a PowerHandler because they can also
|
||||
* receive power from other Engines.
|
||||
*
|
||||
* See TileRefinery for a simple example of a power using machine.
|
||||
*
|
||||
* @see IPowerReceptor
|
||||
* @see IPowerEmitter
|
||||
*/
|
||||
@Deprecated
|
||||
public final class PowerHandler {
|
||||
|
||||
public static enum Type {
|
||||
|
||||
ENGINE, GATE, MACHINE, PIPE, STORAGE;
|
||||
|
||||
public boolean canReceiveFromPipes() {
|
||||
switch (this) {
|
||||
case MACHINE:
|
||||
case STORAGE:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
public boolean eatsEngineExcess() {
|
||||
switch (this) {
|
||||
case MACHINE:
|
||||
case STORAGE:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Extend this class to create custom Perdition algorithms (its not final).
|
||||
*
|
||||
* NOTE: It is not possible to create a Zero perdition algorithm.
|
||||
*/
|
||||
public static class PerditionCalculator {
|
||||
|
||||
public static final float DEFAULT_POWERLOSS = 1F;
|
||||
public static final float MIN_POWERLOSS = 0.01F;
|
||||
private final double powerLoss;
|
||||
|
||||
public PerditionCalculator() {
|
||||
powerLoss = DEFAULT_POWERLOSS;
|
||||
}
|
||||
|
||||
/**
|
||||
* Simple constructor for simple Perdition per tick.
|
||||
*
|
||||
* @param powerLoss power loss per tick
|
||||
*/
|
||||
public PerditionCalculator(double iPowerLoss) {
|
||||
if (iPowerLoss < MIN_POWERLOSS) {
|
||||
powerLoss = iPowerLoss;
|
||||
} else {
|
||||
powerLoss = MIN_POWERLOSS;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Apply the perdition algorithm to the current stored energy. This
|
||||
* function can only be called once per tick, but it might not be called
|
||||
* every tick. It is triggered by any manipulation of the stored energy.
|
||||
*
|
||||
* @param powerHandler the PowerHandler requesting the perdition update
|
||||
* @param current the current stored energy
|
||||
* @param ticksPassed ticks since the last time this function was called
|
||||
* @return
|
||||
*/
|
||||
public double applyPerdition(PowerHandler powerHandler, double current, long ticksPassed) {
|
||||
double result = current;
|
||||
|
||||
result -= powerLoss * ticksPassed;
|
||||
if (result < 0) {
|
||||
result = 0;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Taxes a flat rate on all incoming power.
|
||||
*
|
||||
* Defaults to 0% tax rate.
|
||||
*
|
||||
* @return percent of input to tax
|
||||
*/
|
||||
public double getTaxPercent() {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
public static final PerditionCalculator DEFAULT_PERDITION = new PerditionCalculator();
|
||||
public static final double ROLLING_AVERAGE_WEIGHT = 100.0;
|
||||
public static final double ROLLING_AVERAGE_NUMERATOR = ROLLING_AVERAGE_WEIGHT - 1;
|
||||
public static final double ROLLING_AVERAGE_DENOMINATOR = 1.0 / ROLLING_AVERAGE_WEIGHT;
|
||||
public final int[] powerSources = new int[6];
|
||||
public final IPowerReceptor receptor;
|
||||
private double minEnergyReceived;
|
||||
private double maxEnergyReceived;
|
||||
private double maxEnergyStored;
|
||||
private double activationEnergy;
|
||||
private double energyStored = 0;
|
||||
private final SafeTimeTracker doWorkTracker = new SafeTimeTracker();
|
||||
private final SafeTimeTracker sourcesTracker = new SafeTimeTracker();
|
||||
private final SafeTimeTracker perditionTracker = new SafeTimeTracker();
|
||||
private PerditionCalculator perdition;
|
||||
private final PowerReceiver receiver;
|
||||
private final Type type;
|
||||
// Tracking
|
||||
private double averageLostPower = 0;
|
||||
private double averageReceivedPower = 0;
|
||||
private double averageUsedPower = 0;
|
||||
|
||||
public PowerHandler(IPowerReceptor receptor, Type type) {
|
||||
this.receptor = receptor;
|
||||
this.type = type;
|
||||
this.receiver = new PowerReceiver();
|
||||
this.perdition = DEFAULT_PERDITION;
|
||||
}
|
||||
|
||||
public PowerReceiver getPowerReceiver() {
|
||||
return receiver;
|
||||
}
|
||||
|
||||
public double getMinEnergyReceived() {
|
||||
return minEnergyReceived;
|
||||
}
|
||||
|
||||
public double getMaxEnergyReceived() {
|
||||
return maxEnergyReceived;
|
||||
}
|
||||
|
||||
public double getMaxEnergyStored() {
|
||||
return maxEnergyStored;
|
||||
}
|
||||
|
||||
public double getActivationEnergy() {
|
||||
return activationEnergy;
|
||||
}
|
||||
|
||||
public double getEnergyStored() {
|
||||
return energyStored;
|
||||
}
|
||||
|
||||
/**
|
||||
* Setup your PowerHandler's settings.
|
||||
*
|
||||
* @param minEnergyReceived
|
||||
* This is the minimum about of power that will be accepted by
|
||||
* the PowerHandler. This should generally be greater than the
|
||||
* activationEnergy if you plan to use the doWork() callback.
|
||||
* Anything greater than 1 will prevent Redstone Engines from
|
||||
* powering this Provider.
|
||||
* @param iMaxEnergyReceived
|
||||
* The maximum amount of power accepted by the PowerHandler. This
|
||||
* should generally be less than 500. Too low and larger engines
|
||||
* will overheat while trying to power the machine. Too high, and
|
||||
* the engines will never warm up. Greater values also place
|
||||
* greater strain on the power net.
|
||||
* @param activationEnergy
|
||||
* If the stored energy is greater than this value, the doWork()
|
||||
* callback is called (once per tick).
|
||||
* @param maxStoredEnergy
|
||||
* The maximum amount of power this PowerHandler can store.
|
||||
* Values tend to range between 100 and 5000. With 1000 and 1500
|
||||
* being common.
|
||||
*/
|
||||
public void configure(double iMinEnergyReceived, double iMaxEnergyReceived, double iActivationEnergy,
|
||||
double iMaxStoredEnergy) {
|
||||
|
||||
if (iMinEnergyReceived > maxEnergyReceived) {
|
||||
maxEnergyReceived = iMinEnergyReceived;
|
||||
} else {
|
||||
maxEnergyReceived = iMaxEnergyReceived;
|
||||
}
|
||||
|
||||
minEnergyReceived = iMinEnergyReceived;
|
||||
maxEnergyStored = iMaxStoredEnergy;
|
||||
activationEnergy = iActivationEnergy;
|
||||
}
|
||||
|
||||
/**
|
||||
* Allows you define perdition in terms of loss/ticks.
|
||||
*
|
||||
* This function is mostly for legacy implementations. See
|
||||
* PerditionCalculator for more complex perdition formulas.
|
||||
*
|
||||
* @param powerLoss
|
||||
* @param powerLossRegularity
|
||||
* @see PerditionCalculator
|
||||
*/
|
||||
public void configurePowerPerdition(int powerLoss, int powerLossRegularity) {
|
||||
if (powerLoss == 0 || powerLossRegularity == 0) {
|
||||
perdition = new PerditionCalculator(0);
|
||||
return;
|
||||
}
|
||||
perdition = new PerditionCalculator((float) powerLoss / (float) powerLossRegularity);
|
||||
}
|
||||
|
||||
/**
|
||||
* Allows you to define a new PerditionCalculator class to handler perdition
|
||||
* calculations.
|
||||
*
|
||||
* For example if you want exponentially increasing loss based on amount
|
||||
* stored.
|
||||
*
|
||||
* @param iPerdition
|
||||
*/
|
||||
public void setPerdition(PerditionCalculator iPerdition) {
|
||||
if (iPerdition == null) {
|
||||
perdition = DEFAULT_PERDITION;
|
||||
} else {
|
||||
perdition = iPerdition;
|
||||
}
|
||||
}
|
||||
|
||||
public PerditionCalculator getPerdition() {
|
||||
if (perdition == null) {
|
||||
return DEFAULT_PERDITION;
|
||||
}
|
||||
return perdition;
|
||||
}
|
||||
|
||||
/**
|
||||
* Ticks the power handler. You should call this if you can, but its not
|
||||
* required.
|
||||
*
|
||||
* If you don't call it, the possibility exists for some weirdness with the
|
||||
* perdition algorithm and work callback as its possible they will not be
|
||||
* called on every tick they otherwise would be. You should be able to
|
||||
* design around this though if you are aware of the limitations.
|
||||
*/
|
||||
public void update() {
|
||||
applyPerdition();
|
||||
applyWork();
|
||||
validateEnergy();
|
||||
}
|
||||
|
||||
private void applyPerdition() {
|
||||
if (perditionTracker.markTimeIfDelay(receptor.getWorld(), 1) && energyStored > 0) {
|
||||
double prev = energyStored;
|
||||
double newEnergy = getPerdition().applyPerdition(this, energyStored, perditionTracker.durationOfLastDelay());
|
||||
if (newEnergy == 0 || newEnergy < energyStored) {
|
||||
energyStored = newEnergy;
|
||||
} else {
|
||||
energyStored = DEFAULT_PERDITION.applyPerdition(this, energyStored, perditionTracker.durationOfLastDelay());
|
||||
}
|
||||
validateEnergy();
|
||||
|
||||
averageLostPower = (averageLostPower * ROLLING_AVERAGE_NUMERATOR + (prev - energyStored)) * ROLLING_AVERAGE_DENOMINATOR;
|
||||
}
|
||||
}
|
||||
|
||||
private void applyWork() {
|
||||
if (energyStored >= activationEnergy) {
|
||||
if (doWorkTracker.markTimeIfDelay(receptor.getWorld(), 1)) {
|
||||
receptor.doWork(this);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void updateSources(ForgeDirection source) {
|
||||
if (sourcesTracker.markTimeIfDelay(receptor.getWorld(), 1)) {
|
||||
for (int i = 0; i < 6; ++i) {
|
||||
powerSources[i] -= sourcesTracker.durationOfLastDelay();
|
||||
if (powerSources[i] < 0) {
|
||||
powerSources[i] = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (source != null) {
|
||||
powerSources[source.ordinal()] = 10;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Extract energy from the PowerHandler. You must call this even if doWork()
|
||||
* triggers.
|
||||
*
|
||||
* @param min
|
||||
* @param max
|
||||
* @param doUse
|
||||
* @return amount used
|
||||
*/
|
||||
public double useEnergy(double min, double max, boolean doUse) {
|
||||
applyPerdition();
|
||||
|
||||
double result = 0;
|
||||
|
||||
if (energyStored >= min) {
|
||||
if (energyStored <= max) {
|
||||
result = energyStored;
|
||||
if (doUse) {
|
||||
energyStored = 0;
|
||||
}
|
||||
} else {
|
||||
result = max;
|
||||
if (doUse) {
|
||||
energyStored -= max;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
validateEnergy();
|
||||
|
||||
if (doUse) {
|
||||
averageUsedPower = (averageUsedPower * ROLLING_AVERAGE_NUMERATOR + result) * ROLLING_AVERAGE_DENOMINATOR;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
public void readFromNBT(NBTTagCompound data) {
|
||||
readFromNBT(data, "powerProvider");
|
||||
}
|
||||
|
||||
public void readFromNBT(NBTTagCompound data, String tag) {
|
||||
NBTTagCompound nbt = data.getCompoundTag(tag);
|
||||
energyStored = nbt.getDouble("energyStored");
|
||||
}
|
||||
|
||||
public void writeToNBT(NBTTagCompound data) {
|
||||
writeToNBT(data, "powerProvider");
|
||||
}
|
||||
|
||||
public void writeToNBT(NBTTagCompound data, String tag) {
|
||||
NBTTagCompound nbt = new NBTTagCompound();
|
||||
nbt.setDouble("energyStored", energyStored);
|
||||
data.setTag(tag, nbt);
|
||||
}
|
||||
|
||||
public final class PowerReceiver {
|
||||
|
||||
private PowerReceiver() {
|
||||
}
|
||||
|
||||
public double getMinEnergyReceived() {
|
||||
return minEnergyReceived;
|
||||
}
|
||||
|
||||
public double getMaxEnergyReceived() {
|
||||
return maxEnergyReceived;
|
||||
}
|
||||
|
||||
public double getMaxEnergyStored() {
|
||||
return maxEnergyStored;
|
||||
}
|
||||
|
||||
public double getActivationEnergy() {
|
||||
return activationEnergy;
|
||||
}
|
||||
|
||||
public double getEnergyStored() {
|
||||
return energyStored;
|
||||
}
|
||||
|
||||
public double getAveragePowerReceived() {
|
||||
return averageReceivedPower;
|
||||
}
|
||||
|
||||
public double getAveragePowerUsed() {
|
||||
return averageUsedPower;
|
||||
}
|
||||
|
||||
public double getAveragePowerLost() {
|
||||
return averageLostPower;
|
||||
}
|
||||
|
||||
public Type getType() {
|
||||
return type;
|
||||
}
|
||||
|
||||
public void update() {
|
||||
PowerHandler.this.update();
|
||||
}
|
||||
|
||||
/**
|
||||
* The amount of power that this PowerHandler currently needs.
|
||||
*
|
||||
* @return
|
||||
*/
|
||||
public double powerRequest() {
|
||||
update();
|
||||
return Math.min(maxEnergyReceived, maxEnergyStored - energyStored);
|
||||
}
|
||||
|
||||
/**
|
||||
* Add power to the PowerReceiver from an external source.
|
||||
*
|
||||
* IPowerEmitters are responsible for calling this themselves.
|
||||
*
|
||||
* @param quantity
|
||||
* @param from
|
||||
* @return the amount of power used
|
||||
*/
|
||||
public double receiveEnergy(Type source, final double quantity, ForgeDirection from) {
|
||||
double used = quantity;
|
||||
if (source == Type.ENGINE) {
|
||||
if (used < minEnergyReceived) {
|
||||
return 0;
|
||||
} else if (used > maxEnergyReceived) {
|
||||
used = maxEnergyReceived;
|
||||
}
|
||||
}
|
||||
|
||||
updateSources(from);
|
||||
|
||||
used -= used * getPerdition().getTaxPercent();
|
||||
|
||||
used = addEnergy(used);
|
||||
|
||||
applyWork();
|
||||
|
||||
if (source == Type.ENGINE && type.eatsEngineExcess()) {
|
||||
used = Math.min(quantity, maxEnergyReceived);
|
||||
}
|
||||
|
||||
averageReceivedPower = (averageReceivedPower * ROLLING_AVERAGE_NUMERATOR + used) * ROLLING_AVERAGE_DENOMINATOR;
|
||||
|
||||
return used;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* @return the amount the power changed by
|
||||
*/
|
||||
public double addEnergy(double iQuantity) {
|
||||
energyStored += iQuantity;
|
||||
|
||||
double added = iQuantity;
|
||||
|
||||
if (energyStored > maxEnergyStored) {
|
||||
added -= energyStored - maxEnergyStored;
|
||||
energyStored = maxEnergyStored;
|
||||
} else if (energyStored < 0) {
|
||||
added -= energyStored;
|
||||
energyStored = 0;
|
||||
}
|
||||
|
||||
applyPerdition();
|
||||
|
||||
return added;
|
||||
}
|
||||
|
||||
public void setEnergy(double quantity) {
|
||||
this.energyStored = quantity;
|
||||
validateEnergy();
|
||||
}
|
||||
|
||||
public boolean isPowerSource(ForgeDirection from) {
|
||||
return powerSources[from.ordinal()] != 0;
|
||||
}
|
||||
|
||||
private void validateEnergy() {
|
||||
if (energyStored < 0) {
|
||||
energyStored = 0;
|
||||
}
|
||||
if (energyStored > maxEnergyStored) {
|
||||
energyStored = maxEnergyStored;
|
||||
}
|
||||
}
|
||||
}
|
|
@ -1,3 +1,3 @@
|
|||
@API(apiVersion = "1.1", owner = "BuildCraftAPI|core", provides = "BuildCraftAPI|power")
|
||||
@API(apiVersion = "1.2", owner = "BuildCraftAPI|core", provides = "BuildCraftAPI|power")
|
||||
package buildcraft.api.power;
|
||||
import cpw.mods.fml.common.API;
|
||||
|
|
|
@ -22,7 +22,6 @@ import net.minecraft.tileentity.TileEntity;
|
|||
import net.minecraftforge.common.util.ForgeDirection;
|
||||
import cofh.api.energy.IEnergyHandler;
|
||||
import buildcraft.BuildCraftCore;
|
||||
import buildcraft.api.power.IPowerReceptor;
|
||||
import buildcraft.core.network.BuildCraftPacket;
|
||||
import buildcraft.core.network.ISynchronizedTile;
|
||||
import buildcraft.core.network.PacketPayload;
|
||||
|
@ -80,11 +79,6 @@ public abstract class TileBuildCraft extends TileEntity implements ISynchronized
|
|||
initialize();
|
||||
init = true;
|
||||
}
|
||||
|
||||
if (this instanceof IPowerReceptor) {
|
||||
IPowerReceptor receptor = (IPowerReceptor) this;
|
||||
receptor.getPowerReceiver(null).update();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
30
common/buildcraft/energy/TileEnergyReceiver.java
Executable file → Normal file
30
common/buildcraft/energy/TileEnergyReceiver.java
Executable file → Normal file
|
@ -16,16 +16,12 @@ import net.minecraftforge.common.util.ForgeDirection;
|
|||
|
||||
import cofh.api.energy.IEnergyHandler;
|
||||
|
||||
import buildcraft.api.power.IPowerEmitter;
|
||||
import buildcraft.api.power.IPowerReceptor;
|
||||
import buildcraft.api.power.PowerHandler;
|
||||
import buildcraft.api.power.PowerHandler.PowerReceiver;
|
||||
import buildcraft.api.transport.IPipeConnection;
|
||||
import buildcraft.api.transport.IPipeTile.PipeType;
|
||||
import buildcraft.core.TileBuffer;
|
||||
import buildcraft.core.TileBuildCraft;
|
||||
|
||||
public class TileEnergyReceiver extends TileBuildCraft implements IPipeConnection, IPowerEmitter {
|
||||
public class TileEnergyReceiver extends TileBuildCraft implements IPipeConnection {
|
||||
public static LinkedList<TileEnergyReceiver> knownReceivers = new LinkedList<TileEnergyReceiver>();
|
||||
|
||||
public int energyStored = 0;
|
||||
|
@ -50,9 +46,7 @@ public class TileEnergyReceiver extends TileBuildCraft implements IPipeConnectio
|
|||
}
|
||||
|
||||
public boolean isPoweredTile(TileEntity tile, ForgeDirection side) {
|
||||
if (tile instanceof IPowerReceptor) {
|
||||
return ((IPowerReceptor) tile).getPowerReceiver(side.getOpposite()) != null;
|
||||
} else if (tile instanceof IEnergyHandler) {
|
||||
if (tile instanceof IEnergyHandler) {
|
||||
return ((IEnergyHandler) tile).canConnectEnergy(side.getOpposite());
|
||||
}
|
||||
|
||||
|
@ -63,17 +57,7 @@ public class TileEnergyReceiver extends TileBuildCraft implements IPipeConnectio
|
|||
for (ForgeDirection s : ForgeDirection.VALID_DIRECTIONS) {
|
||||
TileEntity tile = getTileBuffer(s).getTile();
|
||||
|
||||
if (tile instanceof IPowerReceptor) {
|
||||
PowerReceiver receptor = ((IPowerReceptor) tile)
|
||||
.getPowerReceiver(s.getOpposite());
|
||||
|
||||
if (receptor != null) {
|
||||
receptor.receiveEnergy(PowerHandler.Type.ENGINE, energyStored / 10.0,
|
||||
s.getOpposite());
|
||||
|
||||
energyStored = 0;
|
||||
}
|
||||
} else if (tile instanceof IEnergyHandler) {
|
||||
if (tile instanceof IEnergyHandler) {
|
||||
int energyUsed = ((IEnergyHandler) tile).receiveEnergy(s.getOpposite(), energyStored, false);
|
||||
energyStored -= energyUsed;
|
||||
}
|
||||
|
@ -88,12 +72,6 @@ public class TileEnergyReceiver extends TileBuildCraft implements IPipeConnectio
|
|||
|
||||
@Override
|
||||
public void updateEntity () {
|
||||
sendPower ();
|
||||
sendPower();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canEmitPowerFrom(ForgeDirection side) {
|
||||
return true;
|
||||
}
|
||||
|
||||
}
|
|
@ -16,10 +16,6 @@ import net.minecraft.util.ResourceLocation;
|
|||
import net.minecraftforge.common.util.ForgeDirection;
|
||||
import cofh.api.energy.IEnergyHandler;
|
||||
import buildcraft.api.core.NetworkData;
|
||||
import buildcraft.api.power.IPowerEmitter;
|
||||
import buildcraft.api.power.IPowerReceptor;
|
||||
import buildcraft.api.power.PowerHandler;
|
||||
import buildcraft.api.power.PowerHandler.PowerReceiver;
|
||||
import buildcraft.api.transport.IPipeConnection;
|
||||
import buildcraft.api.transport.IPipeTile;
|
||||
import buildcraft.api.transport.IPipeTile.PipeType;
|
||||
|
@ -28,8 +24,7 @@ import buildcraft.core.TileBuffer;
|
|||
import buildcraft.core.TileBuildCraft;
|
||||
import buildcraft.energy.gui.ContainerEngine;
|
||||
|
||||
public abstract class TileEngine extends TileBuildCraft implements IPowerEmitter,
|
||||
IPipeConnection, IEnergyHandler {
|
||||
public abstract class TileEngine extends TileBuildCraft implements IPipeConnection, IEnergyHandler {
|
||||
// Index corresponds to metadata
|
||||
public static final ResourceLocation[] BASE_TEXTURES = new ResourceLocation[]{
|
||||
new ResourceLocation(DefaultProps.TEXTURE_PATH_BLOCKS + "/base_wood.png"),
|
||||
|
@ -271,12 +266,6 @@ public abstract class TileEngine extends TileBuildCraft implements IPowerEmitter
|
|||
orientation.getOpposite(),
|
||||
Math.round(this.energy), true);
|
||||
return extractEnergy(minEnergy, maxEnergy, false);
|
||||
} else if (tile instanceof IPowerReceptor) {
|
||||
PowerReceiver receptor = ((IPowerReceptor) tile)
|
||||
.getPowerReceiver(orientation.getOpposite());
|
||||
|
||||
return extractEnergy((int) Math.floor(receptor.getMinEnergyReceived() * 10),
|
||||
(int) Math.ceil(receptor.getMaxEnergyReceived() * 10), false);
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
|
@ -301,17 +290,6 @@ public abstract class TileEngine extends TileBuildCraft implements IPowerEmitter
|
|||
|
||||
extractEnergy(0, neededRF, true);
|
||||
}
|
||||
} else if (tile instanceof IPowerReceptor) {
|
||||
PowerReceiver receptor = ((IPowerReceptor) tile)
|
||||
.getPowerReceiver(orientation.getOpposite());
|
||||
|
||||
if (extracted > 0) {
|
||||
double neededMJ = receptor.receiveEnergy(
|
||||
PowerHandler.Type.ENGINE, extracted / 10.0,
|
||||
orientation.getOpposite());
|
||||
|
||||
extractEnergy((int) Math.floor(receptor.getMinEnergyReceived() * 10), (int) Math.ceil(neededMJ * 10), true);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -496,8 +474,6 @@ public abstract class TileEngine extends TileBuildCraft implements IPowerEmitter
|
|||
return false;
|
||||
} else if (tile instanceof IEnergyHandler) {
|
||||
return ((IEnergyHandler) tile).canConnectEnergy(side.getOpposite());
|
||||
} else if (tile instanceof IPowerReceptor) {
|
||||
return ((IPowerReceptor) tile).getPowerReceiver(side.getOpposite()) != null;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
|
@ -532,11 +508,6 @@ public abstract class TileEngine extends TileBuildCraft implements IPowerEmitter
|
|||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canEmitPowerFrom(ForgeDirection side) {
|
||||
return side == orientation;
|
||||
}
|
||||
|
||||
public void checkRedstonePower() {
|
||||
isRedstonePowered = worldObj.isBlockIndirectlyGettingPowered(xCoord, yCoord, zCoord);
|
||||
}
|
||||
|
|
|
@ -20,10 +20,6 @@ import cofh.api.energy.IEnergyHandler;
|
|||
import buildcraft.BuildCraftCore;
|
||||
import buildcraft.BuildCraftTransport;
|
||||
import buildcraft.api.core.SafeTimeTracker;
|
||||
import buildcraft.api.power.IPowerEmitter;
|
||||
import buildcraft.api.power.IPowerReceptor;
|
||||
import buildcraft.api.power.PowerHandler.PowerReceiver;
|
||||
import buildcraft.api.power.PowerHandler.Type;
|
||||
import buildcraft.api.transport.IPipeTile.PipeType;
|
||||
import buildcraft.core.DefaultProps;
|
||||
import buildcraft.transport.network.PacketPowerUpdate;
|
||||
|
@ -93,14 +89,6 @@ public class PipeTransportPower extends PipeTransport {
|
|||
return true;
|
||||
}
|
||||
|
||||
if (tile instanceof IPowerReceptor) {
|
||||
IPowerReceptor receptor = (IPowerReceptor) tile;
|
||||
PowerReceiver receiver = receptor.getPowerReceiver(side.getOpposite());
|
||||
if (receiver != null && receiver.getType().canReceiveFromPipes()) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
if (tile instanceof IEnergyConnection) {
|
||||
IEnergyConnection handler = (IEnergyConnection) tile;
|
||||
if (handler != null && handler.canConnectEnergy(side.getOpposite())) {
|
||||
|
@ -108,13 +96,6 @@ public class PipeTransportPower extends PipeTransport {
|
|||
}
|
||||
}
|
||||
|
||||
if (container.pipe instanceof PipePowerWood && tile instanceof IPowerEmitter) {
|
||||
IPowerEmitter emitter = (IPowerEmitter) tile;
|
||||
if (emitter.canEmitPowerFrom(side.getOpposite())) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
@ -212,16 +193,6 @@ public class PipeTransportPower extends PipeTransport {
|
|||
powerConsumed, false);
|
||||
tilePowered = true;
|
||||
}
|
||||
} else {
|
||||
PowerReceiver prov = getReceiverOnSide(ForgeDirection.VALID_DIRECTIONS[out]);
|
||||
|
||||
if (prov != null) {
|
||||
// Transmit power to the legacy power framework
|
||||
|
||||
powerConsumed = (int) Math.ceil(prov.receiveEnergy(Type.PIPE, powerConsumed / 10.0,
|
||||
ForgeDirection.VALID_DIRECTIONS[out].getOpposite()) * 10);
|
||||
tilePowered = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (!tilePowered) {
|
||||
|
@ -285,15 +256,6 @@ public class PipeTransportPower extends PipeTransport {
|
|||
if (handler.canConnectEnergy(dir.getOpposite())) {
|
||||
int request = handler.receiveEnergy(dir.getOpposite(), this.maxPower, true);
|
||||
|
||||
if (request > 0) {
|
||||
requestEnergy(dir, request);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
PowerReceiver prov = getReceiverOnSide(dir);
|
||||
if (prov != null) {
|
||||
int request = (int) Math.floor(prov.powerRequest() * 10);
|
||||
|
||||
if (request > 0) {
|
||||
requestEnergy(dir, request);
|
||||
}
|
||||
|
@ -351,22 +313,6 @@ public class PipeTransportPower extends PipeTransport {
|
|||
}
|
||||
}
|
||||
|
||||
private PowerReceiver getReceiverOnSide(ForgeDirection side) {
|
||||
TileEntity tile = tiles[side.ordinal()];
|
||||
if (!(tile instanceof IPowerReceptor)) {
|
||||
return null;
|
||||
}
|
||||
IPowerReceptor receptor = (IPowerReceptor) tile;
|
||||
PowerReceiver receiver = receptor.getPowerReceiver(side.getOpposite());
|
||||
if (receiver == null) {
|
||||
return null;
|
||||
}
|
||||
if (!receiver.getType().canReceiveFromPipes()) {
|
||||
return null;
|
||||
}
|
||||
return receiver;
|
||||
}
|
||||
|
||||
public boolean isOverloaded() {
|
||||
return overload >= OVERLOAD_TICKS;
|
||||
}
|
||||
|
|
21
common/buildcraft/transport/TileGenericPipe.java
Executable file → Normal file
21
common/buildcraft/transport/TileGenericPipe.java
Executable file → Normal file
|
@ -37,9 +37,6 @@ import buildcraft.api.core.EnumColor;
|
|||
import buildcraft.api.core.IIconProvider;
|
||||
import buildcraft.api.core.Position;
|
||||
import buildcraft.api.gates.IGateExpansion;
|
||||
import buildcraft.api.power.IPowerReceptor;
|
||||
import buildcraft.api.power.PowerHandler;
|
||||
import buildcraft.api.power.PowerHandler.PowerReceiver;
|
||||
import buildcraft.api.transport.IPipe;
|
||||
import buildcraft.api.transport.IPipeConnection;
|
||||
import buildcraft.api.transport.IPipePluggable;
|
||||
|
@ -63,7 +60,7 @@ import buildcraft.transport.gates.GateFactory;
|
|||
import buildcraft.transport.gates.ItemGate;
|
||||
import buildcraft.transport.utils.RobotStationState;
|
||||
|
||||
public class TileGenericPipe extends TileEntity implements IPowerReceptor, IFluidHandler,
|
||||
public class TileGenericPipe extends TileEntity implements IFluidHandler,
|
||||
IPipeTile, ITileBufferHolder, IEnergyHandler, IDropControlInventory,
|
||||
ISyncedTile, ISolidSideTile, IGuiReturnHandler {
|
||||
|
||||
|
@ -1117,22 +1114,6 @@ public class TileGenericPipe extends TileEntity implements IPowerReceptor, IFlui
|
|||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public PowerReceiver getPowerReceiver(ForgeDirection side) {
|
||||
if (BlockGenericPipe.isValid(pipe) && pipe instanceof IPowerReceptor) {
|
||||
return ((IPowerReceptor) pipe).getPowerReceiver(null);
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void doWork(PowerHandler workProvider) {
|
||||
if (BlockGenericPipe.isValid(pipe) && pipe instanceof IPowerReceptor) {
|
||||
((IPowerReceptor) pipe).doWork(workProvider);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canConnectEnergy(ForgeDirection from) {
|
||||
if (pipe instanceof IEnergyHandler) {
|
||||
|
|
|
@ -18,12 +18,6 @@ import cofh.api.energy.IEnergyConnection;
|
|||
import cofh.api.energy.IEnergyHandler;
|
||||
import buildcraft.BuildCraftTransport;
|
||||
import buildcraft.api.core.IIconProvider;
|
||||
import buildcraft.api.power.IPowerEmitter;
|
||||
import buildcraft.api.power.IPowerReceptor;
|
||||
import buildcraft.api.power.PowerHandler;
|
||||
import buildcraft.api.power.PowerHandler.PerditionCalculator;
|
||||
import buildcraft.api.power.PowerHandler.PowerReceiver;
|
||||
import buildcraft.api.power.PowerHandler.Type;
|
||||
import buildcraft.api.transport.IPipeTile;
|
||||
import buildcraft.core.RFBattery;
|
||||
import buildcraft.transport.IPipeTransportPowerHook;
|
||||
|
@ -31,7 +25,7 @@ import buildcraft.transport.Pipe;
|
|||
import buildcraft.transport.PipeIconProvider;
|
||||
import buildcraft.transport.PipeTransportPower;
|
||||
|
||||
public class PipePowerWood extends Pipe<PipeTransportPower> implements IPowerReceptor, IPipeTransportPowerHook, IEnergyHandler {
|
||||
public class PipePowerWood extends Pipe<PipeTransportPower> implements IPipeTransportPowerHook, IEnergyHandler {
|
||||
|
||||
public final boolean[] powerSources = new boolean[6];
|
||||
|
||||
|
@ -41,16 +35,11 @@ public class PipePowerWood extends Pipe<PipeTransportPower> implements IPowerRec
|
|||
|
||||
private boolean full;
|
||||
private int requestedEnergy, sources;
|
||||
private PowerHandler powerHandler;
|
||||
|
||||
public PipePowerWood(Item item) {
|
||||
super(new PipeTransportPower(), item);
|
||||
|
||||
battery = new RFBattery(320 * 50, 320, 0);
|
||||
|
||||
powerHandler = new PowerHandler(this, Type.PIPE);
|
||||
powerHandler.configure(0, 500, 1, 1500);
|
||||
powerHandler.setPerdition(new PerditionCalculator(PerditionCalculator.MIN_POWERLOSS));
|
||||
transport.initFromPipe(getClass());
|
||||
}
|
||||
|
||||
|
@ -196,24 +185,11 @@ public class PipePowerWood extends Pipe<PipeTransportPower> implements IPowerRec
|
|||
public boolean isPowerSource(TileEntity tile, ForgeDirection from) {
|
||||
if (!transport.inputOpen(from)) {
|
||||
return false;
|
||||
} else if (tile instanceof IPowerEmitter && ((IPowerEmitter) tile).canEmitPowerFrom(from.getOpposite())) {
|
||||
return true;
|
||||
} else {
|
||||
return tile instanceof IEnergyConnection && ((IEnergyConnection) tile).canConnectEnergy(from.getOpposite());
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public PowerReceiver getPowerReceiver(ForgeDirection side) {
|
||||
return powerHandler.getPowerReceiver();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void doWork(PowerHandler workProvider) {
|
||||
battery.addEnergy(0, (int) Math.round(this.powerHandler.getEnergyStored() * 10), true);
|
||||
this.powerHandler.setEnergy(0.0);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canConnectEnergy(ForgeDirection from) {
|
||||
return true;
|
||||
|
|
Loading…
Reference in a new issue