Relocate Source to proper directory.

2014-09-23 19:26:27 -05:00
parent fe927ce65d
commit 386d18a059
785 changed files with 35585 additions and 35580 deletions
@@ -0,0 +1,6 @@
+package appeng.tile.powersink;
+
+public abstract class AEBasePoweredTile extends MekJoules
+{
+
+}
@@ -0,0 +1,167 @@
+package appeng.tile.powersink;
+
+import java.util.EnumSet;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.common.util.ForgeDirection;
+import appeng.api.config.AccessRestriction;
+import appeng.api.config.Actionable;
+import appeng.api.config.PowerMultiplier;
+import appeng.api.config.PowerUnits;
+import appeng.api.networking.energy.IAEPowerStorage;
+import appeng.api.networking.events.MENetworkPowerStorage.PowerEventType;
+import appeng.tile.AEBaseInvTile;
+import appeng.tile.TileEvent;
+import appeng.tile.events.TileEventType;
+
+public abstract class AERootPoweredTile extends AEBaseInvTile implements IAEPowerStorage
+{
+
+	// values that determine general function, are set by inheriting classes if
+	// needed. These should generally remain static.
+	protected double internalMaxPower = 10000;
+	protected boolean internalCanAcceptPower = true;
+	protected boolean internalPublicPowerStorage = false;
+	private EnumSet<ForgeDirection> internalPowerSides = EnumSet.allOf( ForgeDirection.class );
+
+	protected AccessRestriction internalPowerFlow = AccessRestriction.READ_WRITE;
+
+	// the current power buffer.
+	protected double internalCurrentPower = 0;
+
+	protected void setPowerSides(EnumSet<ForgeDirection> sides)
+	{
+		internalPowerSides = sides;
+		// trigger re-calc!
+	}
+
+	protected EnumSet<ForgeDirection> getPowerSides()
+	{
+		return internalPowerSides.clone();
+	}
+
+	@TileEvent(TileEventType.WORLD_NBT_WRITE)
+	public void writeToNBT_AERootPoweredTile(NBTTagCompound data)
+	{
+		data.setDouble( "internalCurrentPower", internalCurrentPower );
+	}
+
+	@TileEvent(TileEventType.WORLD_NBT_READ)
+	public void readFromNBT_AERootPoweredTile(NBTTagCompound data)
+	{
+		internalCurrentPower = data.getDouble( "internalCurrentPower" );
+	}
+
+	final protected double getExternalPowerDemand(PowerUnits externalUnit, double maxPowerRequired)
+	{
+		return PowerUnits.AE.convertTo( externalUnit, Math.max( 0.0, getFunnelPowerDemand( externalUnit.convertTo( PowerUnits.AE, maxPowerRequired ) ) ) );
+	}
+
+	protected double getFunnelPowerDemand(double maxRequired)
+	{
+		return internalMaxPower - internalCurrentPower;
+	}
+
+	final public double injectExternalPower(PowerUnits input, double amt)
+	{
+		return PowerUnits.AE.convertTo( input, funnelPowerIntoStorage( input.convertTo( PowerUnits.AE, amt ), Actionable.MODULATE ) );
+	}
+
+	protected double funnelPowerIntoStorage(double AEUnits, Actionable mode)
+	{
+		return injectAEPower( AEUnits, mode );
+	}
+
+	@Override
+	final public double injectAEPower(double amt, Actionable mode)
+	{
+		if ( amt < 0.000001 )
+			return 0;
+
+		if ( mode == Actionable.SIMULATE )
+		{
+			double fakeBattery = internalCurrentPower + amt;
+
+			if ( fakeBattery > internalMaxPower )
+				return fakeBattery - internalMaxPower;
+
+			return 0;
+		}
+		else
+		{
+			if ( internalCurrentPower < 0.01 && amt > 0.01 )
+				PowerEvent( PowerEventType.PROVIDE_POWER );
+
+			internalCurrentPower += amt;
+			if ( internalCurrentPower > internalMaxPower )
+			{
+				amt = internalCurrentPower - internalMaxPower;
+				internalCurrentPower = internalMaxPower;
+				return amt;
+			}
+
+			return 0;
+		}
+	}
+
+	protected void PowerEvent(PowerEventType x)
+	{
+		// nothing.
+	}
+
+	protected double extractAEPower(double amt, Actionable mode)
+	{
+		if ( mode == Actionable.SIMULATE )
+		{
+			if ( internalCurrentPower > amt )
+				return amt;
+			return internalCurrentPower;
+		}
+
+		boolean wasFull = internalCurrentPower >= internalMaxPower - 0.001;
+		if ( wasFull && amt > 0.001 )
+		{
+			PowerEvent( PowerEventType.REQUEST_POWER );
+		}
+
+		if ( internalCurrentPower > amt )
+		{
+			internalCurrentPower -= amt;
+			return amt;
+		}
+
+		amt = internalCurrentPower;
+		internalCurrentPower = 0;
+		return amt;
+	}
+
+	@Override
+	final public double extractAEPower(double amt, Actionable mode, PowerMultiplier multiplier)
+	{
+		return multiplier.divide( extractAEPower( multiplier.multiply( amt ), mode ) );
+	}
+
+	@Override
+	final public double getAEMaxPower()
+	{
+		return internalMaxPower;
+	}
+
+	@Override
+	final public double getAECurrentPower()
+	{
+		return internalCurrentPower;
+	}
+
+	@Override
+	final public boolean isAEPublicPowerStorage()
+	{
+		return internalPublicPowerStorage;
+	}
+
+	@Override
+	final public AccessRestriction getPowerFlow()
+	{
+		return internalPowerFlow;
+	}
+}
@@ -0,0 +1,105 @@
+package appeng.tile.powersink;
+
+import ic2.api.energy.tile.IEnergySink;
+
+import java.util.EnumSet;
+
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.util.ForgeDirection;
+import appeng.api.config.PowerUnits;
+import appeng.core.AppEng;
+import appeng.integration.IntegrationType;
+import appeng.integration.abstraction.IIC2;
+import appeng.transformer.annotations.integration.Interface;
+import appeng.util.Platform;
+
+@Interface(iname = "IC2", iface = "ic2.api.energy.tile.IEnergySink")
+public abstract class IC2 extends MinecraftJoules6 implements IEnergySink
+{
+
+	boolean isInIC2 = false;
+
+	@Override
+	final public boolean acceptsEnergyFrom(TileEntity emitter, ForgeDirection direction)
+	{
+		return internalCanAcceptPower && getPowerSides().contains( direction );
+	}
+
+	@Override
+	final public double getDemandedEnergy()
+	{
+		return getExternalPowerDemand( PowerUnits.EU, Double.MAX_VALUE );
+	}
+
+	@Override
+	final public double injectEnergy(ForgeDirection directionFrom, double amount, double voltage)
+	{
+		// just store the excess in the current block, if I return the waste,
+		// IC2 will just disintegrate it - Oct 20th 2013
+		double overflow = PowerUnits.EU.convertTo( PowerUnits.AE, injectExternalPower( PowerUnits.EU, amount ) );
+		internalCurrentPower += overflow;
+		return 0; // see above comment.
+	}
+
+	@Override
+	final public int getSinkTier()
+	{
+		return Integer.MAX_VALUE;
+	}
+
+	@Override
+	public void invalidate()
+	{
+		super.invalidate();
+		removeFromENet();
+	}
+
+	@Override
+	public void onChunkUnload()
+	{
+		super.onChunkUnload();
+		removeFromENet();
+	}
+
+	@Override
+	public void onReady()
+	{
+		super.onReady();
+		addToENet();
+	}
+
+	@Override
+	protected void setPowerSides(EnumSet<ForgeDirection> sides)
+	{
+		super.setPowerSides( sides );
+		removeFromENet();
+		addToENet();
+	}
+
+	final private void addToENet()
+	{
+		if ( AppEng.instance.isIntegrationEnabled( IntegrationType.IC2 ) )
+		{
+			IIC2 ic2Integration = (IIC2) AppEng.instance.getIntegration( IntegrationType.IC2 );
+			if ( !isInIC2 && Platform.isServer() && ic2Integration != null )
+			{
+				ic2Integration.addToEnergyNet( this );
+				isInIC2 = true;
+			}
+		}
+	}
+
+	final private void removeFromENet()
+	{
+		if ( AppEng.instance.isIntegrationEnabled( IntegrationType.IC2 ) )
+		{
+			IIC2 ic2Integration = (IIC2) AppEng.instance.getIntegration( IntegrationType.IC2 );
+			if ( isInIC2 && Platform.isServer() && ic2Integration != null )
+			{
+				ic2Integration.removeFromEnergyNet( this );
+				isInIC2 = false;
+			}
+		}
+	}
+
+}
@@ -0,0 +1,43 @@
+package appeng.tile.powersink;
+
+import mekanism.api.energy.IStrictEnergyAcceptor;
+import net.minecraftforge.common.util.ForgeDirection;
+import appeng.api.config.PowerUnits;
+import appeng.transformer.annotations.integration.Interface;
+
+@Interface(iname = "Mekanism", iface = "mekanism.api.energy.IStrictEnergyAcceptor")
+public abstract class MekJoules extends RedstoneFlux implements IStrictEnergyAcceptor   {
+
+	@Override
+	public double getEnergy() {
+		return 0;
+	}
+
+	@Override
+	public void setEnergy(double energy) {
+		double extra = injectExternalPower( PowerUnits.MK, energy );
+		internalCurrentPower += PowerUnits.MK.convertTo(PowerUnits.AE, extra );
+	}
+
+	@Override
+	public double getMaxEnergy() {
+		return this.getExternalPowerDemand( PowerUnits.MK, 100000 );
+	}
+
+	@Override
+	public double transferEnergyToAcceptor(ForgeDirection side, double amount)
+	{
+		double demand = getExternalPowerDemand( PowerUnits.MK, Double.MAX_VALUE );
+		if ( amount > demand )
+			amount = demand;
+
+		double overflow = injectExternalPower( PowerUnits.MK, amount );
+		return amount - overflow;
+	}
+
+	@Override
+	public boolean canReceiveEnergy(ForgeDirection side) {
+		return getPowerSides().contains(side);
+	}
+
+}
@@ -0,0 +1,82 @@
+package appeng.tile.powersink;
+
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+import appeng.api.config.PowerUnits;
+import appeng.core.AppEng;
+import appeng.integration.IntegrationType;
+import appeng.integration.abstraction.IMJ5;
+import appeng.integration.abstraction.helpers.BaseMJperdition;
+import appeng.tile.TileEvent;
+import appeng.tile.events.TileEventType;
+import appeng.transformer.annotations.integration.Interface;
+import appeng.transformer.annotations.integration.Method;
+import appeng.util.Platform;
+import buildcraft.api.power.IPowerReceptor;
+import buildcraft.api.power.PowerHandler;
+import buildcraft.api.power.PowerHandler.PowerReceiver;
+
+@Interface(iname = "MJ5", iface = "buildcraft.api.power.IPowerReceptor")
+public abstract class MinecraftJoules5 extends AERootPoweredTile implements IPowerReceptor
+{
+
+	BaseMJperdition bcPowerWrapper;
+
+	@Method(iname = "MJ5")
+	@TileEvent(TileEventType.TICK)
+	public void Tick_MinecraftJoules5()
+	{
+		if ( bcPowerWrapper != null )
+			bcPowerWrapper.Tick();
+	}
+
+	public MinecraftJoules5() {
+		if ( Platform.isServer() )
+		{
+			try
+			{
+				if ( AppEng.instance.isIntegrationEnabled( IntegrationType.MJ5 ) )
+				{
+					IMJ5 mjIntegration = (IMJ5) AppEng.instance.getIntegration( IntegrationType.MJ5 );
+					if ( mjIntegration != null )
+					{
+						bcPowerWrapper = (BaseMJperdition) mjIntegration.createPerdition( this );
+						if ( bcPowerWrapper != null )
+							bcPowerWrapper.configure( 1, 380, 1.0f / 5.0f, 1000 );
+					}
+				}
+			}
+			catch (Throwable t)
+			{
+				// ignore.. no bc?
+			}
+		}
+	}
+
+	@Override
+	@Method(iname = "MJ5")
+	final public PowerReceiver getPowerReceiver(ForgeDirection side)
+	{
+		if ( internalCanAcceptPower && getPowerSides().contains( side ) && bcPowerWrapper != null )
+			return bcPowerWrapper.getPowerReceiver();
+		return null;
+	}
+
+	@Override
+	@Method(iname = "MJ5")
+	final public void doWork(PowerHandler workProvider)
+	{
+		float required = (float) getExternalPowerDemand( PowerUnits.MJ, bcPowerWrapper.getPowerReceiver().getEnergyStored() );
+		double failed = injectExternalPower( PowerUnits.MJ, bcPowerWrapper.useEnergy( 0.0f, required, true ) );
+		if ( failed > 0.01 )
+			bcPowerWrapper.addEnergy( (float) failed );
+	}
+
+	@Override
+	@Method(iname = "MJ5")
+	final public World getWorld()
+	{
+		return worldObj;
+	}
+
+}
@@ -0,0 +1,98 @@
+package appeng.tile.powersink;
+
+import appeng.api.config.PowerUnits;
+import appeng.transformer.annotations.integration.Interface;
+import appeng.transformer.annotations.integration.InterfaceList;
+import appeng.transformer.annotations.integration.Method;
+import buildcraft.api.mj.IBatteryObject;
+import buildcraft.api.mj.IBatteryProvider;
+
+@InterfaceList(value = { @Interface(iname = "MJ6", iface = "buildcraft.api.mj.IBatteryProvider"),
+		@Interface(iname = "MJ6", iface = "buildcraft.api.mj.IBatteryObject") })
+public abstract class MinecraftJoules6 extends MinecraftJoules5 implements IBatteryProvider, IBatteryObject
+{
+
+	@Override
+	@Method(iname = "MJ6")
+	public String kind()
+	{
+		return null;
+	}
+
+	@Override
+	@Method(iname = "MJ6")
+	public double getEnergyRequested()
+	{
+		return getExternalPowerDemand( PowerUnits.MJ, Double.MAX_VALUE );
+	}
+
+	@Override
+	@Method(iname = "MJ6")
+	public double addEnergy(double amount)
+	{
+		double demand = getExternalPowerDemand( PowerUnits.MJ, Double.MAX_VALUE );
+		if ( amount > demand )
+			amount = demand;
+
+		double overflow = injectExternalPower( PowerUnits.MJ, amount );
+		return amount - overflow;
+	}
+
+	@Override
+	@Method(iname = "MJ6")
+	public double addEnergy(double amount, boolean ignoreCycleLimit)
+	{
+		double overflow = injectExternalPower( PowerUnits.MJ, amount );
+		return amount - overflow;
+	}
+
+	@Override
+	@Method(iname = "MJ6")
+	public double getEnergyStored()
+	{
+		return PowerUnits.AE.convertTo( PowerUnits.MJ, internalCurrentPower );
+	}
+
+	@Override
+	@Method(iname = "MJ6")
+	public void setEnergyStored(double mj)
+	{
+		internalCurrentPower = PowerUnits.MJ.convertTo( PowerUnits.AE, mj );
+	}
+
+	@Override
+	@Method(iname = "MJ6")
+	public double maxCapacity()
+	{
+		return PowerUnits.AE.convertTo( PowerUnits.MJ, internalMaxPower );
+	}
+
+	@Override
+	@Method(iname = "MJ6")
+	public double minimumConsumption()
+	{
+		return 0.1;
+	}
+
+	@Override
+	@Method(iname = "MJ6")
+	public double maxReceivedPerCycle()
+	{
+		return 999999.0;
+	}
+
+	@Override
+	@Method(iname = "MJ6")
+	public IBatteryObject reconfigure(double maxCapacity, double maxReceivedPerCycle, double minimumConsumption)
+	{
+		return getMjBattery( "" );
+	}
+
+	@Override
+	@Method(iname = "MJ6")
+	public IBatteryObject getMjBattery(String kind)
+	{
+		return this;
+	}
+
+}
@@ -0,0 +1,65 @@
+package appeng.tile.powersink;
+
+import net.minecraftforge.common.util.ForgeDirection;
+import appeng.api.config.PowerUnits;
+import appeng.transformer.annotations.integration.Interface;
+import cofh.api.energy.IEnergyHandler;
+
+@Interface(iname = "RF", iface = "cofh.api.energy.IEnergyHandler")
+public abstract class RedstoneFlux extends RotaryCraft implements IEnergyHandler
+{
+
+	@Override
+	final public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate)
+	{
+		if ( simulate )
+		{
+			double demand = getExternalPowerDemand( PowerUnits.RF, maxReceive );
+			if ( demand > maxReceive )
+				return maxReceive;
+			return (int) Math.floor( maxReceive - demand );
+		}
+		else
+		{
+			int demand = (int) Math.floor( getExternalPowerDemand( PowerUnits.RF, maxReceive ) );
+
+			int ignored = 0;
+			int insertAmt = maxReceive;
+
+			if ( insertAmt > demand )
+			{
+				ignored = insertAmt - demand;
+				insertAmt = demand;
+			}
+
+			double overFlow = injectExternalPower( PowerUnits.RF, insertAmt );
+			double ox = Math.floor( overFlow );
+			internalCurrentPower += PowerUnits.RF.convertTo( PowerUnits.AE, overFlow - ox );
+			return maxReceive - ((int) ox + ignored);
+		}
+	}
+
+	@Override
+	final public int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate)
+	{
+		return 0;
+	}
+
+	final public boolean canConnectEnergy(ForgeDirection from)
+	{
+		return internalCanAcceptPower && getPowerSides().contains( from );
+	}
+
+	@Override
+	final public int getEnergyStored(ForgeDirection from)
+	{
+		return (int) Math.floor( PowerUnits.AE.convertTo( PowerUnits.RF, getAECurrentPower() ) );
+	}
+
+	@Override
+	final public int getMaxEnergyStored(ForgeDirection from)
+	{
+		return (int) Math.floor( PowerUnits.AE.convertTo( PowerUnits.RF, getAEMaxPower() ) );
+	}
+
+}
@@ -0,0 +1,148 @@
+package appeng.tile.powersink;
+
+import net.minecraftforge.common.util.ForgeDirection;
+import Reika.RotaryCraft.API.ShaftPowerReceiver;
+import appeng.api.config.PowerUnits;
+import appeng.tile.TileEvent;
+import appeng.tile.events.TileEventType;
+import appeng.transformer.annotations.integration.Interface;
+import appeng.transformer.annotations.integration.Method;
+import appeng.util.Platform;
+
+@Interface(iname = "RotaryCraft", iface = "Reika.RotaryCraft.API.ShaftPowerReceiver")
+public abstract class RotaryCraft extends IC2 implements ShaftPowerReceiver
+{
+
+	private int omega = 0;
+	private int torque = 0;
+	private long power = 0;
+	private int alpha = 0;
+
+	@TileEvent(TileEventType.TICK)
+	@Method(iname = "RotaryCraft")
+	public void Tick_RotaryCraft()
+	{
+		if ( worldObj != null && !worldObj.isRemote && power > 0 )
+			injectExternalPower( PowerUnits.WA, power );
+	}
+
+	@Override
+	final public int getOmega()
+	{
+		return omega;
+	}
+
+	@Override
+	final public int getTorque()
+	{
+		return torque;
+	}
+
+	@Override
+	final public long getPower()
+	{
+		return power;
+	}
+
+	@Override
+	final public String getName()
+	{
+		return "AE";
+	}
+
+	@Override
+	final public int getIORenderAlpha()
+	{
+		return alpha;
+	}
+
+	@Override
+	final public void setIORenderAlpha(int io)
+	{
+		alpha = io;
+	}
+
+	
+	final public int getMachineX()
+	{
+		return xCoord;
+	}
+
+	final public int getMachineY()
+	{
+		return yCoord;
+	}
+
+	final public int getMachineZ()
+	{
+		return zCoord;
+	}
+
+	@Override
+	final public void setOmega(int o)
+	{
+		omega = o;
+	}
+
+	@Override
+	final public void setTorque(int t)
+	{
+		torque = t;
+	}
+
+	@Override
+	final public void setPower(long p)
+	{
+		if ( Platform.isClient() )
+			return;
+
+		power = p;
+	}
+
+	final public boolean canReadFromBlock(int x, int y, int z)
+	{
+		ForgeDirection side = ForgeDirection.UNKNOWN;
+
+		if ( x == xCoord - 1 )
+			side = ForgeDirection.WEST;
+		else if ( x == xCoord + 1 )
+			side = ForgeDirection.EAST;
+		else if ( z == zCoord - 1 )
+			side = ForgeDirection.NORTH;
+		else if ( z == zCoord + 1 )
+			side = ForgeDirection.SOUTH;
+		else if ( y == yCoord - 1 )
+			side = ForgeDirection.DOWN;
+		else if ( y == yCoord + 1 )
+			side = ForgeDirection.UP;
+
+		return internalCanAcceptPower && getPowerSides().contains( side );
+	}
+
+	@Override
+	final public boolean isReceiving()
+	{
+		return true;
+	}
+
+	@Override
+	final public void noInputMachine()
+	{
+		power = 0;
+		torque = 0;
+		omega = 0;
+	}
+
+	@Override
+	final public boolean canReadFrom(ForgeDirection side)
+	{
+		return internalCanAcceptPower && getPowerSides().contains( side );
+	}
+
+	@Override
+	final public int getMinTorque(int available)
+	{
+		return 0;
+	}
+
+}
@@ -0,0 +1,65 @@
+package appeng.tile.powersink;
+
+/*
+import net.minecraftforge.common.util.ForgeDirection;
+import universalelectricity.core.block.IElectrical;
+import universalelectricity.core.electricity.ElectricityPack;
+import appeng.api.config.PowerUnits;
+
+public abstract class UniversalElectricity extends ThermalExpansion implements IElectrical
+{
+
+	@Override
+	final public boolean canConnect(ForgeDirection direction)
+	{
+		return internalCanAcceptPower && getPowerSides().contains( direction );
+	}
+
+	@Override
+	final public float receiveElectricity(ForgeDirection from, ElectricityPack receive, boolean doReceive)
+	{
+		float accepted = 0;
+		double receivedPower = receive.getWatts();
+
+		if ( doReceive )
+		{
+			accepted = (float) (receivedPower - injectExternalPower( PowerUnits.KJ, receivedPower ));
+		}
+		else
+		{
+			double whatIWant = getExternalPowerDemand( PowerUnits.KJ );
+			if ( whatIWant > receivedPower )
+				accepted = (float) receivedPower;
+			else
+				accepted = (float) whatIWant;
+		}
+
+		return accepted;
+	}
+
+	@Override
+	final public float getRequest(ForgeDirection direction)
+	{
+		return (float) getExternalPowerDemand( PowerUnits.KJ );
+	}
+
+	@Override
+	final public float getVoltage()
+	{
+		return 120;
+	}
+
+	@Override
+	final public ElectricityPack provideElectricity(ForgeDirection from, ElectricityPack request, boolean doProvide)
+	{
+		return null; // cannot be dis-charged
+	}
+
+	@Override
+	final public float getProvide(ForgeDirection direction)
+	{
+		return 0;
+	}
+
+}
+*/