AE2 First Commit, the dawn of 1.7 hast arrived.

2013-12-27 16:59:59 -06:00
commit e9acdcbee2
468 changed files with 47440 additions and 0 deletions
@@ -0,0 +1,6 @@
+package appeng.tile.powersink;
+
+public abstract class AEBasePoweredTile extends ThermalExpansion
+{
+
+}
@@ -0,0 +1,177 @@
+package appeng.tile.powersink;
+
+import java.util.EnumSet;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.common.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.events.AETileEventHandler;
+import appeng.tile.events.TileEventType;
+
+public abstract class AERootPoweredTile extends AEBaseInvTile implements IAEPowerStorage
+{
+
+	// values that determin 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();
+	}
+
+	private class AEPoweredRootHandler extends AETileEventHandler
+	{
+
+		public AEPoweredRootHandler() {
+			super( EnumSet.of( TileEventType.WORLD_NBT ) );
+		}
+
+		@Override
+		public void writeToNBT(NBTTagCompound data)
+		{
+			data.setDouble( "internalCurrentPower", internalCurrentPower );
+		}
+
+		@Override
+		public void readFromNBT(NBTTagCompound data)
+		{
+			internalCurrentPower = data.getDouble( "internalCurrentPower" );
+		}
+
+	};
+
+	public AERootPoweredTile() {
+		addNewHandler( new AEPoweredRootHandler() );
+	}
+
+	final protected double getExternalPowerDemand(PowerUnits externalUnit)
+	{
+		return PowerUnits.AE.convertTo( externalUnit, Math.max( 0.0, getFunnelPowerDemand() ) );
+	}
+
+	protected double getFunnelPowerDemand()
+	{
+		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 ( 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,98 @@
+package appeng.tile.powersink;
+
+import java.util.EnumSet;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.world.World;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.config.PowerUnits;
+import appeng.core.AppEng;
+import appeng.tile.events.AETileEventHandler;
+import appeng.tile.events.TileEventType;
+import buildcraft.api.power.IPowerReceptor;
+import buildcraft.api.power.PowerHandler;
+import buildcraft.api.power.PowerHandler.PowerReceiver;
+import buildcraft.api.power.PowerHandler.Type;
+import cpw.mods.fml.common.Loader;
+import cpw.mods.fml.common.Optional.Interface;
+import cpw.mods.fml.common.Optional.Method;
+
+@Interface(modid = "BuildCraftAPI|power", iface = "buildcraft.api.power.IPowerReceptor")
+public abstract class BuildCraft extends AERootPoweredTile implements IPowerReceptor
+{
+
+	private class BCPerdition extends AETileEventHandler
+	{
+
+		final protected PowerHandler bcPowerHandler;
+
+		public BCPerdition(IPowerReceptor te) {
+			super( EnumSet.of( TileEventType.TICK, TileEventType.WORLD_NBT ) );
+			bcPowerHandler = new PowerHandler( te, Type.MACHINE );
+		}
+
+		@Override
+		public void Tick()
+		{
+			bcPowerHandler.update();
+		}
+
+		@Override
+		public void writeToNBT(NBTTagCompound data)
+		{
+			bcPowerHandler.writeToNBT( data, "bcPowerHandler" );
+		}
+
+		@Override
+		public void readFromNBT(NBTTagCompound data)
+		{
+			bcPowerHandler.readFromNBT( data, "bcPowerHandler" );
+		}
+
+	};
+
+	BCPerdition bcPowerWrapper;
+
+	public BuildCraft() {
+		try
+		{
+			if ( Loader.isModLoaded( "BuildCraftAPI|power" ) )
+			{
+				if ( AppEng.instance.isIntegrationEnabled( "" ) )
+					addNewHandler( bcPowerWrapper = new BCPerdition( this ) );
+				bcPowerWrapper.bcPowerHandler.configure( 1, 380, 1.0f / 5.0f, 1000 );
+			}
+		}
+		catch (Throwable t)
+		{
+			// ignore.. no bc?
+		}
+	}
+
+	@Override
+	@Method(modid = "BuildCraftAPI|power")
+	final public PowerReceiver getPowerReceiver(ForgeDirection side)
+	{
+		if ( internalCanAcceptPower && getPowerSides().contains( side ) )
+			return bcPowerWrapper.bcPowerHandler.getPowerReceiver();
+		return null;
+	}
+
+	@Override
+	@Method(modid = "BuildCraftAPI|power")
+	final public void doWork(PowerHandler workProvider)
+	{
+		float requred = (float) getExternalPowerDemand( PowerUnits.MJ );
+		double failed = injectExternalPower( PowerUnits.MJ, bcPowerWrapper.bcPowerHandler.useEnergy( 0.0f, requred, true ) );
+		if ( failed > 0.01 )
+			bcPowerWrapper.bcPowerHandler.addEnergy( (float) failed );
+	}
+
+	@Override
+	@Method(modid = "BuildCraftAPI|power")
+	final public World getWorld()
+	{
+		return worldObj;
+	}
+
+}
@@ -0,0 +1,96 @@
+package appeng.tile.powersink;
+
+import ic2.api.energy.tile.IEnergySink;
+
+import java.util.EnumSet;
+
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.ForgeDirection;
+import net.minecraftforge.common.MinecraftForge;
+import appeng.api.config.PowerUnits;
+import appeng.util.Platform;
+import cpw.mods.fml.common.Optional.Interface;
+
+@Interface(modid = "IC2", iface = "ic2.api.energy.tile.IEnergySink")
+public abstract class IC2 extends BuildCraft implements IEnergySink
+{
+
+	boolean isInIC2 = false;
+
+	@Override
+	final public boolean acceptsEnergyFrom(TileEntity emitter, ForgeDirection direction)
+	{
+		return internalCanAcceptPower && getPowerSides().contains( direction );
+	}
+
+	@Override
+	final public double demandedEnergyUnits()
+	{
+		return getExternalPowerDemand( PowerUnits.EU );
+	}
+
+	@Override
+	final public double injectEnergyUnits(ForgeDirection directionFrom, double amount)
+	{
+		// 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 getMaxSafeInput()
+	{
+		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 ( !isInIC2 && Platform.isServer() )
+		{
+			MinecraftForge.EVENT_BUS.post( new ic2.api.energy.event.EnergyTileLoadEvent( this ) );
+			isInIC2 = true;
+		}
+	}
+
+	final private void removeFromENet()
+	{
+		if ( isInIC2 && Platform.isServer() )
+		{
+			MinecraftForge.EVENT_BUS.post( new ic2.api.energy.event.EnergyTileUnloadEvent( this ) );
+			isInIC2 = false;
+		}
+	}
+
+}
@@ -0,0 +1,125 @@
+package appeng.tile.powersink;
+
+import net.minecraftforge.common.ForgeDirection;
+import Reika.RotaryCraft.API.ShaftPowerReceiver;
+import appeng.api.config.PowerUnits;
+import cpw.mods.fml.common.Optional.Interface;
+
+@Interface(modid = "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;
+
+	@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;
+	}
+
+	@Override
+	final public int getMachineX()
+	{
+		return xCoord;
+	}
+
+	@Override
+	final public int getMachineY()
+	{
+		return yCoord;
+	}
+
+	@Override
+	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)
+	{
+		injectExternalPower( PowerUnits.WA, p );
+		power = p;
+	}
+
+	@Override
+	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;
+	}
+
+}
@@ -0,0 +1,55 @@
+package appeng.tile.powersink;
+
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.config.PowerUnits;
+import cofh.api.energy.IEnergyHandler;
+import cpw.mods.fml.common.Optional.Interface;
+
+@Interface(modid = "ThermalExpansion", iface = "cofh.api.energy.IEnergyHandler")
+public abstract class ThermalExpansion extends RotaryCraft implements IEnergyHandler
+{
+
+	@Override
+	final public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate)
+	{
+		if ( simulate )
+		{
+			double demand = getExternalPowerDemand( PowerUnits.RF );
+			if ( demand > maxReceive )
+				return maxReceive;
+			return (int) Math.floor( maxReceive - demand );
+		}
+		else
+		{
+			double overFlow = injectExternalPower( PowerUnits.RF, maxReceive );
+			double ox = Math.floor( overFlow );
+			internalCurrentPower += PowerUnits.RF.convertTo( PowerUnits.AE, overFlow - ox );
+			return maxReceive - (int) ox;
+		}
+	}
+
+	@Override
+	final public int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate)
+	{
+		return 0;
+	}
+
+	@Override
+	final public boolean canInterface(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,65 @@
+package appeng.tile.powersink;
+
+/*
+import net.minecraftforge.common.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 recievedPower = receive.getWatts();
+
+		if ( doReceive )
+		{
+			accepted = (float) (recievedPower - injectExternalPower( PowerUnits.KJ, recievedPower ));
+		}
+		else
+		{
+			double whatIWant = getExternalPowerDemand( PowerUnits.KJ );
+			if ( whatIWant > recievedPower )
+				accepted = (float) recievedPower;
+			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;
+	}
+
+}
+*/