tilera/electrodynamics
1
0
Fork 0
Code Issues 1 Pull requests Projects Releases Wiki Activity

starting on removing some parts

Browse source
This commit is contained in:
DarkGuardsman 2013-12-18 07:16:03 -05:00
parent a27ccb3b44
commit d08d449e53
118 changed files with 3 additions and 10517 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

21
APIs/buildcraft/api/core/BuildCraftAPI.java
View file

@ -1,21 +0,0 @@
/**
* Copyright (c) SpaceToad, 2011
* 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.core;
import net.minecraft.block.Block;
public class BuildCraftAPI
{
public static final int LAST_ORIGINAL_BLOCK = 122;
public static final int LAST_ORIGINAL_ITEM = 126;
public static final boolean[] softBlocks = new boolean[Block.blocksList.length];
}

36
APIs/buildcraft/api/core/IAreaProvider.java
View file

@ -1,36 +0,0 @@
/**
* Copyright (c) SpaceToad, 2011
* 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.core;
/**
* To be implemented by TileEntities able to provide a square area on the world, typically
* BuildCraft markers.
*/
public interface IAreaProvider
{
public int xMin();
public int yMin();
public int zMin();
public int xMax();
public int yMax();
public int zMax();
/**
* Remove from the world all objects used to define the area.
*/
public void removeFromWorld();
}

31
APIs/buildcraft/api/core/IBox.java
View file

@ -1,31 +0,0 @@
/**
* Copyright (c) SpaceToad, 2011
* 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.core;
import net.minecraft.world.World;
public interface IBox
{
public void expand(int amount);
public void contract(int amount);
public boolean contains(int x, int y, int z);
public Position pMin();
public Position pMax();
public void createLasers(World world, LaserKind kind);
public void deleteLasers();
}

27
APIs/buildcraft/api/core/IIconProvider.java
View file

@ -1,27 +0,0 @@
package buildcraft.api.core;
import net.minecraft.client.renderer.texture.IconRegister;
import net.minecraft.util.Icon;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
public interface IIconProvider
{
/**
* @param iconIndex
* @return
*/
@SideOnly(Side.CLIENT)
public Icon getIcon(int iconIndex);
/**
* A call for the provider to register its Icons. This may be called multiple times but should
* only be executed once per provider
*
* @param iconRegister
*/
@SideOnly(Side.CLIENT)
public void registerIcons(IconRegister iconRegister);
}

15
APIs/buildcraft/api/core/LaserKind.java
View file

@ -1,15 +0,0 @@
/**
* Copyright (c) SpaceToad, 2011
* 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.core;
public enum LaserKind
{
Red, Blue, Stripes
}

161
APIs/buildcraft/api/core/Position.java
View file

@ -1,161 +0,0 @@
/**
* Copyright (c) SpaceToad, 2011
* 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.core;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.common.ForgeDirection;
public class Position
{
public double x, y, z;
public ForgeDirection orientation;
public Position(double ci, double cj, double ck)
{
x = ci;
y = cj;
z = ck;
orientation = ForgeDirection.UNKNOWN;
}
public Position(double ci, double cj, double ck, ForgeDirection corientation)
{
x = ci;
y = cj;
z = ck;
orientation = corientation;
}
public Position(Position p)
{
x = p.x;
y = p.y;
z = p.z;
orientation = p.orientation;
}
public Position(NBTTagCompound nbttagcompound)
{
x = nbttagcompound.getDouble("i");
y = nbttagcompound.getDouble("j");
z = nbttagcompound.getDouble("k");
orientation = ForgeDirection.UNKNOWN;
}
public Position(TileEntity tile)
{
x = tile.xCoord;
y = tile.yCoord;
z = tile.zCoord;
}
public void moveRight(double step)
{
switch (orientation)
{
case SOUTH:
x = x - step;
break;
case NORTH:
x = x + step;
break;
case EAST:
z = z + step;
break;
case WEST:
z = z - step;
break;
default:
}
}
public void moveLeft(double step)
{
moveRight(-step);
}
public void moveForwards(double step)
{
switch (orientation)
{
case UP:
y = y + step;
break;
case DOWN:
y = y - step;
break;
case SOUTH:
z = z + step;
break;
case NORTH:
z = z - step;
break;
case EAST:
x = x + step;
break;
case WEST:
x = x - step;
break;
default:
}
}
public void moveBackwards(double step)
{
moveForwards(-step);
}
public void moveUp(double step)
{
switch (orientation)
{
case SOUTH:
case NORTH:
case EAST:
case WEST:
y = y + step;
break;
default:
}
}
public void moveDown(double step)
{
moveUp(-step);
}
public void writeToNBT(NBTTagCompound nbttagcompound)
{
nbttagcompound.setDouble("i", x);
nbttagcompound.setDouble("j", y);
nbttagcompound.setDouble("k", z);
}
@Override
public String toString()
{
return "{" + x + ", " + y + ", " + z + "}";
}
public Position min(Position p)
{
return new Position(p.x > x ? x : p.x, p.y > y ? y : p.y, p.z > z ? z : p.z);
}
public Position max(Position p)
{
return new Position(p.x < x ? x : p.x, p.y < y ? y : p.y, p.z < z ? z : p.z);
}
}

53
APIs/buildcraft/api/core/SafeTimeTracker.java
View file

@ -1,53 +0,0 @@
/**
* Copyright (c) SpaceToad, 2011 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.core;
import net.minecraft.world.World;
public class SafeTimeTracker
{
private long lastMark = Long.MIN_VALUE;
private long duration = -1;
/**
* Return true if a given delay has passed since last time marked was called successfully.
*/
public boolean markTimeIfDelay(World world, long delay)
{
if (world == null)
return false;
long currentTime = world.getTotalWorldTime();
if (currentTime < lastMark)
{
lastMark = currentTime;
return false;
}
else if (lastMark + delay <= currentTime)
{
duration = currentTime - lastMark;
lastMark = currentTime;
return true;
}
else
return false;
}
public long durationOfLastDelay()
{
return duration > 0 ? duration : 0;
}
public void markTime(World world)
{
lastMark = world.getTotalWorldTime();
}
}

54
APIs/buildcraft/api/core/StackWrapper.java
View file

@ -1,54 +0,0 @@
/*
* Copyright (c) SpaceToad, 2011-2012
* 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.core;
import net.minecraft.item.ItemStack;
/**
*
* @author CovertJaguar <http://www.railcraft.info/>
*/
public class StackWrapper
{
public final ItemStack stack;
public StackWrapper(ItemStack stack)
{
this.stack = stack;
}
@Override
public int hashCode()
{
int hash = 5;
hash = 67 * hash + stack.itemID;
hash = 67 * hash + stack.getItemDamage();
if (stack.stackTagCompound != null)
hash = 67 * hash + stack.stackTagCompound.hashCode();
return hash;
}
@Override
public boolean equals(Object obj)
{
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
final StackWrapper other = (StackWrapper) obj;
if (stack.itemID != other.stack.itemID)
return false;
if (stack.getHasSubtypes() && stack.getItemDamage() != other.stack.getItemDamage())
return false;
if (stack.stackTagCompound != null && !stack.stackTagCompound.equals(other.stack.stackTagCompound))
return false;
return true;
}
}

25
APIs/buildcraft/api/power/IPowerEmitter.java
View file

@ -1,25 +0,0 @@
/*
* Copyright (c) SpaceToad, 2011-2012
* 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.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.
*
* @author CovertJaguar <http://www.railcraft.info/>
*/
public interface IPowerEmitter
{
public boolean canEmitPowerFrom(ForgeDirection side);
}

46
APIs/buildcraft/api/power/IPowerReceptor.java
View file

@ -1,46 +0,0 @@
/**
* Copyright (c) SpaceToad, 2011 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.ForgeDirection;
import buildcraft.api.power.PowerHandler.PowerReceiver;
/**
* This interface should be implemented by any Tile Entity that wishes to be able to receive power.
*
* @author CovertJaguar <http://www.railcraft.info/>
*/
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
*/
public 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
*/
public void doWork(PowerHandler workProvider);
public World getWorld();
}

455
APIs/buildcraft/api/power/PowerHandler.java
View file

@ -1,455 +0,0 @@
/**
* Copyright (c) SpaceToad, 2011 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.ForgeDirection;
import buildcraft.api.core.SafeTimeTracker;
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;
}
}
}
public static class PerditionCalculator
{
public static final float DEFAULT_POWERLOSS = 1F;
public static final float MIN_POWERLOSS = 0.01F;
private final float powerLoss;
public PerditionCalculator()
{
powerLoss = DEFAULT_POWERLOSS;
}
public PerditionCalculator(float powerLoss)
{
if (powerLoss < MIN_POWERLOSS)
{
powerLoss = MIN_POWERLOSS;
}
this.powerLoss = 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 float applyPerdition(PowerHandler powerHandler, float current, long ticksPassed)
{
current -= powerLoss * ticksPassed;
if (current < 0)
{
current = 0;
}
return current;
}
}
public static final PerditionCalculator DEFAULT_PERDITION = new PerditionCalculator();
private float minEnergyReceived;
private float maxEnergyReceived;
private float maxEnergyStored;
private float activationEnergy;
private float energyStored = 0;
private final SafeTimeTracker doWorkTracker = new SafeTimeTracker();
private final SafeTimeTracker sourcesTracker = new SafeTimeTracker();
private final SafeTimeTracker perditionTracker = new SafeTimeTracker();
public final int[] powerSources = new int[6];
public final IPowerReceptor receptor;
private PerditionCalculator perdition;
private final PowerReceiver receiver;
private final Type type;
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 float getMinEnergyReceived()
{
return minEnergyReceived;
}
public float getMaxEnergyReceived()
{
return maxEnergyReceived;
}
public float getMaxEnergyStored()
{
return maxEnergyStored;
}
public float getActivationEnergy()
{
return activationEnergy;
}
public float 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 maxEnergyReceived 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(float minEnergyReceived, float maxEnergyReceived, float activationEnergy, float maxStoredEnergy)
{
if (minEnergyReceived > maxEnergyReceived)
{
maxEnergyReceived = minEnergyReceived;
}
this.minEnergyReceived = minEnergyReceived;
this.maxEnergyReceived = maxEnergyReceived;
this.maxEnergyStored = maxStoredEnergy;
this.activationEnergy = activationEnergy;
}
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 perdition
*/
public void setPerdition(PerditionCalculator perdition)
{
if (perdition == null)
perdition = DEFAULT_PERDITION;
this.perdition = perdition;
}
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)
{
float newEnergy = getPerdition().applyPerdition(this, energyStored, perditionTracker.durationOfLastDelay());
if (newEnergy == 0 || newEnergy < energyStored)
energyStored = newEnergy;
else
energyStored = DEFAULT_PERDITION.applyPerdition(this, energyStored, perditionTracker.durationOfLastDelay());
validateEnergy();
}
}
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 float useEnergy(float min, float max, boolean doUse)
{
applyPerdition();
float result = 0;
if (energyStored >= min)
{
if (energyStored <= max)
{
result = energyStored;
if (doUse)
{
energyStored = 0;
}
}
else
{
result = max;
if (doUse)
{
energyStored -= max;
}
}
}
validateEnergy();
return result;
}
public void readFromNBT(NBTTagCompound data)
{
readFromNBT(data, "powerProvider");
}
public void readFromNBT(NBTTagCompound data, String tag)
{
NBTTagCompound nbt = data.getCompoundTag(tag);
energyStored = nbt.getFloat("storedEnergy");
}
public void writeToNBT(NBTTagCompound data)
{
writeToNBT(data, "powerProvider");
}
public void writeToNBT(NBTTagCompound data, String tag)
{
NBTTagCompound nbt = new NBTTagCompound();
nbt.setFloat("storedEnergy", energyStored);
data.setCompoundTag(tag, nbt);
}
public final class PowerReceiver
{
private PowerReceiver()
{
}
public float getMinEnergyReceived()
{
return minEnergyReceived;
}
public float getMaxEnergyReceived()
{
return maxEnergyReceived;
}
public float getMaxEnergyStored()
{
return maxEnergyStored;
}
public float getActivationEnergy()
{
return activationEnergy;
}
public float getEnergyStored()
{
return energyStored;
}
public Type getType()
{
return type;
}
public void update()
{
PowerHandler.this.update();
}
/**
* The amount of power that this PowerHandler currently needs.
*
* @return
*/
public float powerRequest()
{
update();
return Math.min(maxEnergyReceived, maxEnergyStored - energyStored);
}
/**
* Add power to the PowerReceiver from an external source.
*
* @param quantity
* @param from
* @return the amount of power used
*/
public float receiveEnergy(Type source, final float quantity, ForgeDirection from)
{
float used = quantity;
if (source == Type.ENGINE)
{
if (used < minEnergyReceived)
{
return 0;
}
else if (used > maxEnergyReceived)
{
used = maxEnergyReceived;
}
}
updateSources(from);
used = addEnergy(used);
applyWork();
if (source == Type.ENGINE && type.eatsEngineExcess())
{
return Math.min(quantity, maxEnergyReceived);
}
return used;
}
}
/**
*
* @return the amount the power changed by
*/
public float addEnergy(float quantity)
{
energyStored += quantity;
if (energyStored > maxEnergyStored)
{
quantity -= energyStored - maxEnergyStored;
energyStored = maxEnergyStored;
}
else if (energyStored < 0)
{
quantity -= energyStored;
energyStored = 0;
}
applyPerdition();
return quantity;
}
public void setEnergy(float 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;
}
}
}

25
APIs/buildcraft/api/transport/FacadeManager.java
View file

@ -1,25 +0,0 @@
package buildcraft.api.transport;
import java.lang.reflect.Method;
import net.minecraft.item.ItemStack;
/**
* You can use this if you wish, but FML InterModComms are recommended.
*
* SYNTAX: add-facade:id@meta
*/
public class FacadeManager {
private static Method addFacade;
@SuppressWarnings({ "unchecked", "rawtypes" })
public static void addFacade(ItemStack is) {
try {
if (addFacade == null) {
Class facade = Class.forName("buildcraft.transport.ItemFacade");
addFacade = facade.getMethod("addFacade", ItemStack.class);
}
addFacade.invoke(null, is);
} catch (Exception ex) {
}
}
}

21
APIs/buildcraft/api/transport/IExtractionHandler.java
View file

@ -1,21 +0,0 @@
package buildcraft.api.transport;
import net.minecraft.world.World;
/**
* Implement and register with the PipeManager if you want to suppress connections from wooden pipes.
*/
public interface IExtractionHandler {
/**
* Can this pipe extract items from the block located at these coordinates?
* param extractor can be null
*/
boolean canExtractItems(Object extractor, World world, int i, int j, int k);
/**
* Can this pipe extract liquids from the block located at these coordinates?
* param extractor can be null
*/
boolean canExtractFluids(Object extractor, World world, int i, int j, int k);
}

45
APIs/buildcraft/api/transport/IPipe.java
View file

@ -1,45 +0,0 @@
/**
* Copyright (c) SpaceToad, 2011
* 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.transport;
import net.minecraft.tileentity.TileEntity;
public interface IPipe {
enum DrawingState {
DrawingPipe, DrawingRedWire, DrawingBlueWire, DrawingGreenWire, DrawingYellowWire, DrawingGate
}
enum WireColor {
Red, Blue, Green, Yellow;
public WireColor reverse() {
switch (this) {
case Red:
return Yellow;
case Blue:
return Green;
case Green:
return Blue;
default:
return Red;
}
}
}
public boolean isWired(WireColor color);
public boolean hasGate();
public TileEntity getContainer();
public boolean isWireConnectedTo(TileEntity tile, WireColor color);
}

29
APIs/buildcraft/api/transport/IPipeConnection.java
View file

@ -1,29 +0,0 @@
/**
* Copyright (c) SpaceToad, 2011 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.transport;
import buildcraft.api.transport.IPipeTile.PipeType;
import net.minecraftforge.common.ForgeDirection;
public interface IPipeConnection {
enum ConnectOverride {
CONNECT, DISCONNECT, DEFAULT
};
/**
* Allows you to override pipe connection logic.
*
* @param type
* @param with
* @return CONNECT to force a connection, DISCONNECT to force no connection,
* and DEFAULT to let the pipe decide.
*/
public ConnectOverride overridePipeConnection(PipeType type, ForgeDirection with);
}

39
APIs/buildcraft/api/transport/IPipeTile.java
View file

@ -1,39 +0,0 @@
/**
* Copyright (c) SpaceToad, 2011 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.transport;
import net.minecraft.item.ItemStack;
import net.minecraftforge.common.ForgeDirection;
import net.minecraftforge.fluids.IFluidHandler;
public interface IPipeTile extends ISolidSideTile, IFluidHandler {
public enum PipeType {
ITEM, FLUID, POWER, STRUCTURE;
}
@Deprecated
IPipe getPipe();
PipeType getPipeType();
/**
* Offers an ItemStack for addition to the pipe. Will be rejected if the
* pipe doesn't accept items from that side.
*
* @param stack ItemStack offered for addition. Do not manipulate this!
* @param doAdd If false no actual addition should take place. Implementors
* should simulate.
* @param from Orientation the ItemStack is offered from.
* @return Amount of items used from the passed stack.
*/
int injectItem(ItemStack stack, boolean doAdd, ForgeDirection from);
boolean isPipeConnected(ForgeDirection with);
}

7
APIs/buildcraft/api/transport/ISolidSideTile.java
View file

@ -1,7 +0,0 @@
package buildcraft.api.transport;
import net.minecraftforge.common.ForgeDirection;
public interface ISolidSideTile {
public boolean isSolidOnSide(ForgeDirection side);
}

36
APIs/buildcraft/api/transport/PipeManager.java
View file

@ -1,36 +0,0 @@
package buildcraft.api.transport;
import java.util.ArrayList;
import java.util.List;
import net.minecraft.world.World;
public abstract class PipeManager {
public static List<IExtractionHandler> extractionHandlers = new ArrayList<IExtractionHandler>();
public static void registerExtractionHandler(IExtractionHandler handler) {
extractionHandlers.add(handler);
}
/**
* param extractor can be null
*/
public static boolean canExtractItems(Object extractor, World world, int i, int j, int k) {
for (IExtractionHandler handler : extractionHandlers)
if (!handler.canExtractItems(extractor, world, i, j, k))
return false;
return true;
}
/**
* param extractor can be null
*/
public static boolean canExtractFluids(Object extractor, World world, int i, int j, int k) {
for (IExtractionHandler handler : extractionHandlers)
if (!handler.canExtractFluids(extractor, world, i, j, k))
return false;
return true;
}
}

163
APIs/dan200/computer/api/ComputerCraftAPI.java
View file

@ -1,163 +0,0 @@
/**
* This file is part of the public ComputerCraft API - http://www.computercraft.info
* Copyright Daniel Ratcliffe, 2011-2013. This API may be redistributed unmodified and in full only.
* For help using the API, and posting your mods, visit the forums at computercraft.info.
*/
package dan200.computer.api;
import java.lang.reflect.Method;
import net.minecraft.world.World;
/**
* The static entry point to the ComputerCraft API.
* Members in this class must be called after mod_ComputerCraft has been initialised,
* but may be called before it is fully loaded.
*/
public class ComputerCraftAPI
{
/**
* Creates a numbered directory in a subfolder of the save directory for a given world, and returns that number.<br>
* Use in conjuction with createSaveDirMount() to create a unique place for your peripherals or media items to store files.<br>
* @param world The world for which the save dir should be created. This should be the serverside world object.
* @param parentSubPath The folder path within the save directory where the new directory should be created. eg: "computer/disk"
* @return The numerical value of the name of the new folder, or -1 if the folder could not be created for some reason.<br>
* eg: if createUniqueNumberedSaveDir( world, "computer/disk" ) was called returns 42, then "computer/disk/42" is now available for writing.
* @see #createSaveDirMount(World, String)
*/
public static int createUniqueNumberedSaveDir( World world, String parentSubPath )
{
findCC();
if( computerCraft_createUniqueNumberedSaveDir != null )
{
try {
return ((Integer)computerCraft_createUniqueNumberedSaveDir.invoke( null, world, parentSubPath )).intValue();
} catch (Exception e){
// It failed
}
}
return -1;
}
/**
* Creates a file system mount that maps to a subfolder of the save directory for a given world, and returns it.<br>
* Use in conjuction with IComputerAccess.mount() or IComputerAccess.mountWritable() to mount a folder from the
* users save directory onto a computers file system.<br>
* @param world The world for which the save dir can be found. This should be the serverside world object.
* @param subPath The folder path within the save directory that the mount should map to. eg: "computer/disk/42".<br>
* Use createUniqueNumberedSaveDir() to create a new numbered folder to use.
* @param capacity The ammount of data that can be stored in the directory before it fills up, in bytes.
* @return The mount, or null if it could be created for some reason. Use IComputerAccess.mount() or IComputerAccess.mountWritable()
* to mount this on a Computers' file system.
* @see #createUniqueNumberedSaveDir(World, String)
* @see IComputerAccess#mount(String, IMount)
* @see IComputerAccess#mountWritable(String, IWritableMount)
* @see IMount
* @see IMountWritable
*/
public static IWritableMount createSaveDirMount( World world, String subPath, long capacity )
{
findCC();
if( computerCraft_createSaveDirMount != null )
{
try {
return (IWritableMount)computerCraft_createSaveDirMount.invoke( null, world, subPath, capacity );
} catch (Exception e){
// It failed
}
}
return null;
}
/**
* Creates a file system mount to a resource folder, and returns it.<br>
* Use in conjuction with IComputerAccess.mount() or IComputerAccess.mountWritable() to mount a resource folder onto a computers file system.<br>
* The files in this mount will be a combination of files in the specified mod jar, and resource packs that contain resources with the same domain and path.<br>
* @param class A class in whose jar to look first for the resources to mount. Using your main mod class is recommended. eg: MyMod.class
* @param domain The domain under which to look for resources. eg: "mymod"
* @param subPath The domain under which to look for resources. eg: "mymod/lua/myfiles"
* @return The mount, or null if it could be created for some reason. Use IComputerAccess.mount() or IComputerAccess.mountWritable()
* to mount this on a Computers' file system.
* @see IComputerAccess#mount(String, IMount)
* @see IComputerAccess#mountWritable(String, IMountWritable)
* @see IMount
*/
public static IMount createResourceMount( Class modClass, String domain, String subPath )
{
findCC();
if( computerCraft_createResourceMount != null )
{
try {
return (IMount)computerCraft_createResourceMount.invoke( null, modClass, domain, subPath );
} catch (Exception e){
// It failed
}
}
return null;
}
/**
* Registers a peripheral handler for a TileEntity that you do not have access to. Only
* use this if you want to expose IPeripheral on a TileEntity from another mod. For your own
* mod, just implement IPeripheral on the TileEntity directly.
* @see IPeripheral
* @see IPeripheralHandler
*/
public static void registerExternalPeripheral( Class <? extends net.minecraft.tileentity.TileEntity> clazz, IPeripheralHandler handler )
{
findCC();
if (computerCraft_registerExternalPeripheral != null)
{
try {
computerCraft_registerExternalPeripheral.invoke(null, clazz, handler);
} catch (Exception e){
// It failed
}
}
}
// The functions below here are private, and are used to interface with the non-API ComputerCraft classes.
// Reflection is used here so you can develop your mod in MCP without decompiling ComputerCraft and including
// it in your solution.
private static void findCC()
{
if( !ccSearched ) {
try {
computerCraft = Class.forName( "dan200.ComputerCraft" );
computerCraft_createUniqueNumberedSaveDir = findCCMethod( "createUniqueNumberedSaveDir", new Class[] {
World.class, String.class
} );
computerCraft_createSaveDirMount = findCCMethod( "createSaveDirMount", new Class[] {
World.class, String.class, Long.TYPE
} );
computerCraft_createResourceMount = findCCMethod( "createResourceMount", new Class[] {
Class.class, String.class, String.class
} );
computerCraft_registerExternalPeripheral = findCCMethod( "registerExternalPeripheral", new Class[] {
Class.class, IPeripheralHandler.class
} );
} catch( Exception e ) {
net.minecraft.server.MinecraftServer.getServer().logInfo( "ComputerCraftAPI: ComputerCraft not found." );
} finally {
ccSearched = true;
}
}
}
private static Method findCCMethod( String name, Class[] args )
{
try {
return computerCraft.getMethod( name, args );
} catch( NoSuchMethodException e ) {
net.minecraft.server.MinecraftServer.getServer().logInfo( "ComputerCraftAPI: ComputerCraft method " + name + " not found." );
return null;
}
}
private static boolean ccSearched = false;
private static Class computerCraft = null;
private static Method computerCraft_createUniqueNumberedSaveDir = null;
private static Method computerCraft_createSaveDirMount = null;
private static Method computerCraft_createResourceMount = null;
private static Method computerCraft_registerExternalPeripheral = null;
}

109
APIs/dan200/computer/api/IComputerAccess.java
View file

@ -1,109 +0,0 @@
/**
* This file is part of the public ComputerCraft API - http://www.computercraft.info
* Copyright Daniel Ratcliffe, 2011-2013. This API may be redistributed unmodified and in full only.
* For help using the API, and posting your mods, visit the forums at computercraft.info.
*/
package dan200.computer.api;
import net.minecraft.world.World;
/**
* The interface passed to peripherals by computers or turtles, providing methods that they can
* call. This should not be implemented by your classes. Do not interact with computers except via
* this interface.
*/
public interface IComputerAccess
{
/**
* Mount a mount onto the computers' file system in a read only mode.<br>
*
* @param desiredLoction The location on the computer's file system where you would like the
* mount to be mounted.
* @param mount The mount object to mount on the computer. These can be obtained by calling
* ComputerCraftAPI.createSaveDirMount(), ComputerCraftAPI.createResourceMount() or by creating
* your own objects that implement the IMount interface.
* @return The location on the computer's file system where you the mount was actually mounted,
* this may be different from desiredLocation if there was already a file in the desired
* location. Store this value if you wish to unmount the mount later.
* @see ComputerCraftAPI#createSaveDirMount(World, String)
* @see ComputerCraftAPI#createResourceMount(Class, String, String)
* @see #mountWritable(String, IWritableMount)
* @see #unmount(String)
* @see IMount
*/
public String mount(String desiredLocation, IMount mount);
/**
* Mount a mount onto the computers' file system in a writable mode.<br>
*
* @param desiredLoction The location on the computer's file system where you would like the
* mount to be mounted.
* @param mount The mount object to mount on the computer. These can be obtained by calling
* ComputerCraftAPI.createSaveDirMount() or by creating your own objects that implement the
* IWritableMount interface.
* @return The location on the computer's file system where you the mount was actually mounted,
* this may be different from desiredLocation if there was already a file in the desired
* location. Store this value if you wish to unmount the mount later.
* @see ComputerCraftAPI#createSaveDirMount(World, String)
* @see ComputerCraftAPI#createResourceMount(Class, String, String)
* @see #mount(String, IMount)
* @see #unmount(String)
* @see IMount
*/
public String mountWritable(String desiredLocation, IWritableMount mount);
/**
* Unmounts a directory previously mounted onto the computers file system by mount() or
* mountWritable().<br>
* When a directory is unmounted, it will disappear from the computers file system, and the user
* will no longer be able to access it. All directories mounted by a mount or mountWritable are
* automatically unmounted when the peripheral is attached if they have not been explicitly
* unmounted.
*
* @param location The desired location in the computers file system of the directory to
* unmount. This must be the location of a directory previously mounted by mount() or
* mountWritable(), as indicated by their return value.
* @see #mount(String, IMount)
* @see #mountWritable(String, IWritableMount)
*/
public void unmount(String location);
/**
* Returns the numerical ID of this computer.<br>
* This is the same number obtained by calling os.getComputerID() or running the "id" program
* from lua, and is guarunteed unique. This number will be positive.
*
* @return The identifier.
*/
public int getID();
/**
* Causes an event to be raised on this computer, which the computer can respond to by calling
* os.pullEvent(). This can be used to notify the computer when things happen in the world or to
* this peripheral.
*
* @param event A string identifying the type of event that has occurred, this will be returned
* as the first value from os.pullEvent(). It is recommended that you you choose a name that is
* unique, and recognisable as originating from your peripheral. eg: If your peripheral type is
* "button", a suitable event would be "button_pressed".
* @param arguments In addition to a name, you may pass an array of extra arguments to the
* event, that will be supplied as extra return values to os.pullEvent(). Objects in the array
* will be converted to lua data types in the same fashion as the return values of
* IPeripheral.callMethod().<br>
* You may supply null to indicate that no arguments are to be supplied.
* @see IPeripheral#callMethod
*/
public void queueEvent(String event, Object[] arguments);
/**
* Get a string, unique to the computer, by which the computer refers to this peripheral. For
* directly attached peripherals this will be "left","right","front","back",etc, but for
* peripherals attached remotely it will be different. It is good practice to supply this string
* when raising events to the computer, so that the computer knows from which peripheral the
* event came.
*
* @return A string unique to the computer, but not globally.
*/
public String getAttachmentName();
}

44
APIs/dan200/computer/api/IHostedPeripheral.java
View file

@ -1,44 +0,0 @@
/**
* This file is part of the public ComputerCraft API - http://www.computercraft.info
* Copyright Daniel Ratcliffe, 2011-2013. This API may be redistributed unmodified and in full only.
* For help using the API, and posting your mods, visit the forums at computercraft.info.
*/
package dan200.computer.api;
import dan200.computer.api.IPeripheral;
/**
* A subclass of IPeripheral specifically for peripherals
* created by ITurtleUpgrade's of type Peripheral. When an
* IHostedPeripheral is created, its IPeripheral methods will be called
* just as if the peripheral was a seperate adjacent block in the world,
* and update() will be called once per tick.
* @see ITurtleUpgrade
*/
public interface IHostedPeripheral extends IPeripheral
{
/**
* A method called on each hosted peripheral once per tick, on the main thread
* over the lifetime of the turtle or block. May be used to update the state
* of the peripheral, and may interact with IComputerAccess or ITurtleAccess
* however it likes at this time.
*/
public void update();
/**
* A method called whenever data is read from the Turtle's NBTTag,
* over the lifetime of the turtle. You should only use this for
* reading data you want to stay with the peripheral.
* @param nbttagcompound The peripheral's NBTTag
*/
public void readFromNBT( net.minecraft.nbt.NBTTagCompound nbttagcompound );
/**
* A method called whenever data is written to the Turtle's NBTTag,
* over the lifetime of the turtle. You should only use this for
* writing data you want to stay with the peripheral.
* @param nbttagcompound The peripheral's NBTTag.
* @param ID The turtle's ID.
*/
public void writeToNBT( net.minecraft.nbt.NBTTagCompound nbttagcompound );
}

62
APIs/dan200/computer/api/ILuaContext.java
View file

@ -1,62 +0,0 @@
/**
* This file is part of the public ComputerCraft API - http://www.computercraft.info
* Copyright Daniel Ratcliffe, 2011-2013. This API may be redistributed unmodified and in full only.
* For help using the API, and posting your mods, visit the forums at computercraft.info.
*/
package dan200.computer.api;
/**
* An interface passed to peripherals and ILuaObjects' by computers or turtles, providing methods
* that allow the peripheral call to wait for events before returning, just like in lua. This is
* very useful if you need to signal work to be performed on the main thread, and don't want to
* return until the work has been completed.
*/
public interface ILuaContext
{
/**
* Wait for an event to occur on the computer, suspending the thread until it arises. This
* method is exactly equivalent to os.pullEvent() in lua.
*
* @param filter A specific event to wait for, or null to wait for any event
* @return An object array containing the name of the event that occurred, and any event
* parameters
* @throws Exception If the user presses CTRL+T to terminate the current program while
* pullEvent() is waiting for an event, a "Terminated" exception will be thrown here. Do not
* attempt to block this exception, unless you wish to prevent termination, which is not
* recommended.
* @throws InterruptedException If the user shuts down or reboots the computer while pullEvent()
* is waiting for an event, InterruptedException will be thrown. This exception must not be
* caught or intercepted, or the computer will leak memory and end up in a broken state.
*/
public Object[] pullEvent(String filter) throws Exception, InterruptedException;
/**
* The same as pullEvent(), except "terminated" events are ignored. Only use this if you want to
* prevent program termination, which is not recommended. This method is exactly equivalent to
* os.pullEventRaw() in lua.
*
* @param filter A specific event to wait for, or null to wait for any event
* @return An object array containing the name of the event that occurred, and any event
* parameters
* @throws InterruptedException If the user shuts down or reboots the computer while
* pullEventRaw() is waiting for an event, InterruptedException will be thrown. This exception
* must not be caught or intercepted, or the computer will leak memory and end up in a broken
* state.
* @see #pullEvent(String)
*/
public Object[] pullEventRaw(String filter) throws InterruptedException;
/**
* Yield the current coroutine with some arguments until it is resumed. This method is exactly
* equivalent to coroutine.yield() in lua. Use pullEvent() if you wish to wait for events.
*
* @param arguments An object array containing the arguments to pass to coroutine.yield()
* @return An object array containing the return values from coroutine.yield()
* @throws InterruptedException If the user shuts down or reboots the computer the coroutine is
* suspended, InterruptedException will be thrown. This exception must not be caught or
* intercepted, or the computer will leak memory and end up in a broken state.
* @see #pullEvent(String)
*/
public Object[] yield(Object[] arguments) throws InterruptedException;
}

26
APIs/dan200/computer/api/ILuaObject.java
View file

@ -1,26 +0,0 @@
/**
* This file is part of the public ComputerCraft API - http://www.computercraft.info
* Copyright Daniel Ratcliffe, 2011-2013. This API may be redistributed unmodified and in full only.
* For help using the API, and posting your mods, visit the forums at computercraft.info.
*/
package dan200.computer.api;
/**
* An interface for representing custom objects returned by IPeripheral.callMethod() calls.
* Return objects implementing this interface to expose objects with methods to lua.
*/
public interface ILuaObject
{
/**
* Get the names of the methods that this object implements. This works the same as IPeripheral.getMethodNames(). See that method for detailed documentation.
* @see IPeripheral#getMethodNames()
*/
public String[] getMethodNames();
/**
* Called when a user calls one of the methods that this object implements. This works the same as IPeripheral.callMethod(). See that method for detailed documentation.
* @see IPeripheral#callMethod(IComputerAccess, ILuaContext, int, Object[])
*/
public Object[] callMethod( ILuaContext context, int method, Object[] arguments ) throws Exception;
}

57
APIs/dan200/computer/api/IMedia.java
View file

@ -1,57 +0,0 @@
/**
* This file is part of the public ComputerCraft API - http://www.computercraft.info
* Copyright Daniel Ratcliffe, 2011-2013. This API may be redistributed unmodified and in full only.
* For help using the API, and posting your mods, visit the forums at computercraft.info.
*/
package dan200.computer.api;
import net.minecraft.world.World;
import net.minecraft.item.ItemStack;
/**
* Represents an item that can be placed in a disk drive and used by a Computer.
* Implement this interface on your Item class to allow it to be used in the drive.
*/
public interface IMedia
{
/**
* Get a string representing the label of this item. Will be called vi disk.getLabel() in lua.
* @param stack The itemstack to inspect
* @return The label. ie: "Dan's Programs"
*/
public String getLabel( ItemStack stack );
/**
* Set a string representing the label of this item. Will be called vi disk.setLabel() in lua.
* @param stack The itemstack to modify.
* @param label The string to set the label to.
* @return true if the label was updated, false if the label may not be modified.
*/
public boolean setLabel( ItemStack stack, String label );
/**
* If this disk represents an item with audio (like a record), get the readable name of the audio track. ie: "Jonathon Coulton - Still Alive"
* @param stack The itemstack to inspect.
* @return The name, or null if this item does not represent an item with audio.
*/
public String getAudioTitle( ItemStack stack );
/**
* If this disk represents an item with audio (like a record), get the resource name of the audio track to play.
* @param stack The itemstack to inspect.
* @return The name, or null if this item does not represent an item with audio.
*/
public String getAudioRecordName( ItemStack stack );
/**
* If this disk represents an item with data (like a floppy disk), get a mount representing it's contents. This will be mounted onto the filesystem of the computer while the media is in the disk drive.
* @param stack The itemstack to inspect.
* @param world The world in which the item and disk drive reside.
* @return The mount, or null if this item does not represent an item with data. If the IMount returned also implements IWritableMount, it will mounted using mountWritable()
* @see IMount
* @see IWritableMount
* @see ComputerCraftAPI#createSaveDirMount(World, String)
* @see ComputerCraftAPI#createResourceMount(Class, String, String)
*/
public IMount createDataMount( ItemStack stack, World world );
}

72
APIs/dan200/computer/api/IMount.java
View file

@ -1,72 +0,0 @@
/**
* This file is part of the public ComputerCraft API - http://www.computercraft.info
* Copyright Daniel Ratcliffe, 2011-2013. This API may be redistributed unmodified and in full only.
* For help using the API, and posting your mods, visit the forums at computercraft.info.
*/
package dan200.computer.api;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import net.minecraft.world.World;
/**
* Represents a read only part of a virtual filesystem that can be mounted onto a computer using
* IComputerAccess.mount(). Ready made implementations of this interface can be created using
* ComputerCraftAPI.createSaveDirMount() or ComputerCraftAPI.createResourceMount(), or you're free
* to implement it yourselves!
*
* @see ComputerCraftAPI#createSaveDirMount(World, String)
* @see ComputerCraftAPI#createResourceMount(Class, String, String)
* @see IComputerAccess#mount(String, IMount)
* @see IWritableMount
*/
public interface IMount
{
/**
* Returns whether a file with a given path exists or not.
*
* @param path A file path in normalised format, relative to the mount location. ie:
* "programs/myprogram"
* @return true if the file exists, false otherwise
*/
public boolean exists(String path) throws IOException;
/**
* Returns whether a file with a given path is a directory or not.
*
* @param path A file path in normalised format, relative to the mount location. ie:
* "programs/myprograms"
* @return true if the file exists and is a directory, false otherwise
*/
public boolean isDirectory(String path) throws IOException;
/**
* Returns the file names of all the files in a directory.
*
* @param path A file path in normalised format, relative to the mount location. ie:
* "programs/myprograms"
* @param contents A list of strings. Add all the file names to this list
*/
public void list(String path, List<String> contents) throws IOException;
/**
* Returns the size of a file with a given path, in bytes
*
* @param path A file path in normalised format, relative to the mount location. ie:
* "programs/myprogram"
* @return the size of the file, in bytes
*/
public long getSize(String path) throws IOException;
/**
* Opens a file with a given path, and returns an inputstream representing it's contents.
*
* @param path A file path in normalised format, relative to the mount location. ie:
* "programs/myprogram"
* @return a stream representing the contents of the file
*/
public InputStream openForRead(String path) throws IOException;
}

114
APIs/dan200/computer/api/IPeripheral.java
View file

@ -1,114 +0,0 @@
/**
* This file is part of the public ComputerCraft API - http://www.computercraft.info
* Copyright Daniel Ratcliffe, 2011-2013. This API may be redistributed unmodified and in full only.
* For help using the API, and posting your mods, visit the forums at computercraft.info.
*/
package dan200.computer.api;
/**
* The interface that defines a peripheral. This should be implemented by the TileEntity of any
* block that you wish to be interacted with by computer or turtle.
*/
public interface IPeripheral
{
/**
* Should return a string that uniquely identifies this type of peripheral. This can be queried
* from lua by calling peripheral.getType()
*
* @return A string identifying the type of peripheral.
*/
public String getType();
/**
* Should return an array of strings that identify the methods that this peripheral exposes to
* Lua. This will be called once before each attachment, and should not change when called
* multiple times.
*
* @return An array of strings representing method names.
* @see #callMethod
*/
public String[] getMethodNames();
/**
* This is called when a lua program on an attached computer calls peripheral.call() with one of
* the methods exposed by getMethodNames().<br>
* <br>
* Be aware that this will be called from the ComputerCraft Lua thread, and must be thread-safe
* when interacting with minecraft objects.
*
* @param computer The interface to the computer that is making the call. Remember that multiple
* computers can be attached to a peripheral at once.
* @param context The context of the currently running lua thread. This can be used to wait for
* events or otherwise yield.
* @param method An integer identifying which of the methods from getMethodNames() the computer
* wishes to call. The integer indicates the index into the getMethodNames() table that
* corresponds to the string passed into peripheral.call()
* @param arguments An array of objects, representing the arguments passed into
* peripheral.call().<br>
* Lua values of type "string" will be represented by Object type String.<br>
* Lua values of type "number" will be represented by Object type Double.<br>
* Lua values of type "boolean" will be represented by Object type Boolean.<br>
* Lua values of any other type will be represented by a null object.<br>
* This array will be empty if no arguments are passed.
* @return An array of objects, representing values you wish to return to the lua program.<br>
* Integers, Doubles, Floats, Strings, Booleans and null be converted to their corresponding lua
* type.<br>
* All other types will be converted to nil.<br>
* You may return null to indicate no values should be returned.
* @throws Exception If you throw any exception from this function, a lua error will be raised
* with the same message as your exception. Use this to throw appropriate errors if the wrong
* arguments are supplied to your method.
* @see #getMethodNames
*/
public Object[] callMethod(IComputerAccess computer, ILuaContext context, int method, Object[] arguments) throws Exception;
/**
* Is called before the computer attempts to attach to the peripheral, and should return whether
* to allow the attachment. Use this to restrict the number of computers that can attach, or to
* limit attachments to certain world directions.<br>
* If true is returned, attach() will be called shortly afterwards, and the computer will be
* able to make method calls. If false is returned, attach() will not be called, and the
* peripheral will be invisible to the computer.
*
* @param side The world direction (0=bottom, 1=top, etc) that the computer lies relative to the
* peripheral.
* @return Whether to allow the attachment, as a boolean.
* @see #attach
*/
public boolean canAttachToSide(int side);
/**
* Is called when canAttachToSide has returned true, and a computer is attaching to the
* peripheral. This will occur when a peripheral is placed next to an active computer, when a
* computer is turned on next to a peripheral, or when a turtle travels into a square next to a
* peripheral. Between calls to attach() and detach(), the attached computer can make method
* calls on the peripheral using peripheral.call(). This method can be used to keep track of
* which computers are attached to the peripheral, or to take action when attachment occurs.<br>
* <br>
* Be aware that this will be called from the ComputerCraft Lua thread, and must be thread-safe
* when interacting with minecraft objects.
*
* @param computer The interface to the computer that is being attached. Remember that multiple
* computers can be attached to a peripheral at once.
* @see #canAttachToSide
* @see #detach
*/
public void attach(IComputerAccess computer);
/**
* Is called when a computer is detaching from the peripheral. This will occur when a computer
* shuts down, when the peripheral is removed while attached to computers, or when a turtle
* moves away from a square attached to a peripheral. This method can be used to keep track of
* which computers are attached to the peripheral, or to take action when detachment occurs.<br>
* <br>
* Be aware that this will be called from the ComputerCraft Lua thread, and must be thread-safe
* when interacting with minecraft objects.
*
* @param computer The interface to the computer that is being detached. Remember that multiple
* computers can be attached to a peripheral at once.
* @see #canAttachToSide
* @see #detach
*/
public void detach(IComputerAccess computer);
}

15
APIs/dan200/computer/api/IPeripheralHandler.java
View file

@ -1,15 +0,0 @@
/**
* This file is part of the public ComputerCraft API - http://www.computercraft.info
* Copyright Daniel Ratcliffe, 2011-2013. This API may be redistributed unmodified and in full only.
* For help using the API, and posting your mods, visit the forums at computercraft.info.
*/
package dan200.computer.api;
/**
* TODO: Document me
*/
public interface IPeripheralHandler
{
public IHostedPeripheral getPeripheral( net.minecraft.tileentity.TileEntity tile );
}

67
APIs/dan200/computer/api/IWritableMount.java
View file

@ -1,67 +0,0 @@
/**
* This file is part of the public ComputerCraft API - http://www.computercraft.info
* Copyright Daniel Ratcliffe, 2011-2013. This API may be redistributed unmodified and in full only.
* For help using the API, and posting your mods, visit the forums at computercraft.info.
*/
package dan200.computer.api;
import java.io.IOException;
import java.io.OutputStream;
import net.minecraft.world.World;
/**
* Represents a part of a virtual filesystem that can be mounted onto a computer using
* IComputerAccess.mount() or IComputerAccess.mountWritable(), that can also be written to. Ready
* made implementations of this interface can be created using
* ComputerCraftAPI.createSaveDirMount(), or you're free to implement it yourselves!
*
* @see ComputerCraftAPI#createSaveDirMount(World, String)
* @see IComputerAccess#mountWritable(String, IMount)
* @see IMount
*/
public interface IWritableMount extends IMount
{
/**
* Creates a directory at a given path inside the virtual file system.
*
* @param path A file path in normalised format, relative to the mount location. ie:
* "programs/mynewprograms"
*/
public void makeDirectory(String path) throws IOException;
/**
* Deletes a directory at a given path inside the virtual file system.
*
* @param path A file path in normalised format, relative to the mount location. ie:
* "programs/myoldprograms"
*/
public void delete(String path) throws IOException;
/**
* Opens a file with a given path, and returns an outputstream for writing to it.
*
* @param path A file path in normalised format, relative to the mount location. ie:
* "programs/myprogram"
* @return a stream for writing to
*/
public OutputStream openForWrite(String path) throws IOException;
/**
* Opens a file with a given path, and returns an outputstream for appending to it.
*
* @param path A file path in normalised format, relative to the mount location. ie:
* "programs/myprogram"
* @return a stream for writing to
*/
public OutputStream openForAppend(String path) throws IOException;
/**
* Get the ammount of free space on the mount, in bytes. You should decrease this value as the
* user writes to the mount, and write operations should fail once it reaches zero.
*
* @return The ammount of free space, in bytes.
*/
public long getRemainingSpace() throws IOException;
}

158
APIs/dan200/turtle/api/ITurtleAccess.java
View file

@ -1,158 +0,0 @@
/**
* This file is part of the public ComputerCraft API - http://www.computercraft.info
* Copyright Daniel Ratcliffe, 2011-2013. This API may be redistributed unmodified and in full only.
* For help using the API, and posting your mods, visit the forums at computercraft.info.
*/
package dan200.turtle.api;
import dan200.computer.api.*;
/**
* The interface passed to upgrades by turtles, providing methods that they can call.
* This should not be implemented by your classes. Do not interact with turtles except via this interface and ITurtleUpgrade.
*/
public interface ITurtleAccess
{
/**
* Returns the world in which the turtle resides.
* @return the world in which the turtle resides.
*/
public net.minecraft.world.World getWorld();
/**
* Returns a vector containing the integer block co-ordinates at which the turtle resides.
* @return a vector containing the integer block co-ordinates at which the turtle resides.
*/
public net.minecraft.util.Vec3 getPosition();
/**
* Returns a vector containing the co-ordinates at which the turtle is rendered.
* This will shift when the turtle is moving.
* @param f The subframe fraction
* @return a vector containing the integer block co-ordinates at which the turtle resides.
*/
public net.minecraft.util.Vec3 getVisualPosition( float f );
/**
* Returns the world direction the turtle is currently facing.
* @return the world direction the turtle is currently facing.
*/
public int getFacingDir();
/**
* Returns the size of the turtles inventory, in number of slots. This will currently always be 16.
* @return the size of the turtles inventory, in number of slots. This will currently always be 16.
*/
public int getInventorySize();
/**
* Returns which slot the turtle currently has selected in its inventory using turtle.select().
* Unlike the 1-based lua representation, this will be between 0 and getInventorySize() - 1.
* @return which slot the turtle currently has selected in its inventory
*/
public int getSelectedSlot();
/**
* Returns the item stack that the turtle has in one of its inventory slots.
* @param index which inventory slot to retreive, should be between 0 and getInventorySize() - 1
* @return the item stack that the turtle has in one of its inventory slots. May be null.
*/
public net.minecraft.item.ItemStack getSlotContents( int index );
/**
* Changes the item stack that the turtle has in one of its inventory slots.
* @param index which inventory slot to change, should be between 0 and getInventorySize() - 1
* @param stack an item stack to put in the slot. May be null.
*/
public void setSlotContents( int index, net.minecraft.item.ItemStack stack );
/**
* Tries to store an item stack into the turtles current inventory, starting from the turtles
* currently selected inventory slot.
* @param stack The item stack to try and store.
* @return true if the stack was completely stored in the inventory, false if
* it was only partially stored, or could not fit at all. If false is returned
* and the stack was partially stored, the ItemStack passed into "stack" will now
* represent the stack of items that is left over.
*/
public boolean storeItemStack( net.minecraft.item.ItemStack stack );
/**
* Drops an item stack from the turtle onto the floor, or into an inventory is there is one
* adjacent to the turtle in the direction specified.
* @param stack The item stack to drop.
* @param dir The world direction to drop the item
* @return true if the stack was dropped, or completely stored in the adjacent inventory, false if
* it was only partially stored in the adjacent inventory, or could not fit at all. If false is returned
* and the stack was partially stored, the ItemStack passed into "stack" will now
* represent the stack of items that is left over.
*/
public boolean dropItemStack( net.minecraft.item.ItemStack stack, int dir );
/**
* "Deploys" an item stack in the direction specified. This simulates a player right clicking, and calls onItemUse() on the Item class.
* Will return true if some kind of deployment happened, and may modify the item stack. For block item types, this can be
* used to place blocks. Some kinds of items (such as shears when facing a sheep) may modify the turtles inventory during this call.
* @param stack The item stack to deploy
* @param dir The world direction to deploy the item
* @return true if the stack was deployed, false if it was not.
*/
public boolean deployWithItemStack( net.minecraft.item.ItemStack stack, int dir );
/**
* Tries to "attack" entities with an item stack in the direction specified. This simulates a player left clicking, but will
* not affect blocks. If an entity is attacked and killed during this call, its dropped items will end up in the turtles
* inventory.
* @param stack The item stack to attack with
* @param dir The world direction to attack with the item
* @return true if something was attacked, false if it was not
*/
public boolean attackWithItemStack( net.minecraft.item.ItemStack stack, int dir, float damageMultiplier );
/**
* Returns the current fuel level of the turtle, this is the same integer returned by turtle.getFuelLevel(),
* that decreases by 1 every time the turtle moves. Can be used to have your tool or peripheral require or supply
* fuel to the turtle.
* @return the fuel level
*/
public int getFuelLevel();
/**
* Tries to increase the fuel level of a turtle by burning an item stack. If the item passed in is a fuel source, fuel
* will increase and true will be returned. Otherwise, nothing will happen and false will be returned.
* @param stack The stack to try to refuel with
* @return Whether the turtle was refueled
*/
public boolean refuelWithItemStack( net.minecraft.item.ItemStack stack );
/**
* Removes some fuel from the turtles fuel supply. Negative numbers can be passed in to INCREASE the fuel level of the turtle.
* @return Whether the turtle was able to consume the ammount of fuel specified. Will return false if you supply a number
* greater than the current fuel level of the turtle.
*/
public boolean consumeFuel( int fuel );
/**
* Adds a custom command to the turtles command queue. Unlike peripheral methods, these custom commands will be executed
* on the main thread, so are guaranteed to be able to access Minecraft objects safely, and will be queued up
* with the turtles standard movement and tool commands. An issued command will return an unique integer, which will
* be supplied as a parameter to a "turtle_response" event issued to the turtle after the command has completed. Look at the
* lua source code for "rom/apis/turtle" for how to build a lua wrapper around this functionality.
* @param handler an object which will execute the custom command when its point in the queue is reached
* @return the unique command identifier described above
* @see ITurtleCommandHandler
*/
public int issueCommand( ITurtleCommandHandler handler );
/**
* Returns the upgrade on the specified side of the turtle, if there is one.
* @return the upgrade on the specified side of the turtle, if there is one.
*/
public ITurtleUpgrade getUpgrade( TurtleSide side );
/**
* Returns the peripheral created by the upgrade on the specified side of the turtle, if there is one.
* @return the peripheral created by the upgrade on the specified side of the turtle, if there is one.
*/
public IHostedPeripheral getPeripheral( TurtleSide side );
}

25
APIs/dan200/turtle/api/ITurtleCommandHandler.java
View file

@ -1,25 +0,0 @@
/**
* This file is part of the public ComputerCraft API - http://www.computercraft.info
* Copyright Daniel Ratcliffe, 2011-2013. This API may be redistributed unmodified and in full only.
* For help using the API, and posting your mods, visit the forums at computercraft.info.
*/
package dan200.turtle.api;
/**
* An interface for objects executing custom turtle commands, used with ITurtleAccess.issueCommand
* @see ITurtleAccess#issueCommand( ITurtleCommandHandler )
*/
public interface ITurtleCommandHandler
{
/**
* Will be called by the turtle on the main thread when it is time to execute the custom command.
* The handler should either perform the work of the command, and return true for success, or return
* false to indicate failure if the command cannot be executed at this time.
* @param turtle access to the turtle for whom the command was issued
* @return true for success, false for failure. If true is returned, the turtle will wait 0.4 seconds
* before executing the next command in its queue, as it does for the standard turtle commands.
* @see ITurtleAccess#issueCommand( ITurtleCommandHandler )
*/
public boolean handleCommand( ITurtleAccess turtle );
}

92
APIs/dan200/turtle/api/ITurtleUpgrade.java
View file

@ -1,92 +0,0 @@
/**
* This file is part of the public ComputerCraft API - http://www.computercraft.info
* Copyright Daniel Ratcliffe, 2011-2013. This API may be redistributed unmodified and in full only.
* For help using the API, and posting your mods, visit the forums at computercraft.info.
*/
package dan200.turtle.api;
import net.minecraft.util.Icon;
import dan200.computer.api.*;
/**
* The primary interface for defining an upgrade for Turtles. A turtle upgrade
* can either be a new tool, or a new peripheral.
* @see TurtleAPI#registerUpgrade( ITurtleUpgrade )
*/
public interface ITurtleUpgrade
{
/**
* Gets a unique numerical identifier representing this type of turtle upgrade.
* Like Minecraft block and item IDs, you should strive to make this number unique
* among all turtle upgrades that have been released for ComputerCraft.
* The ID must be in the range 64 to 255, as the ID is stored as an 8-bit value,
* and 0-64 is reserved for future use by ComputerCraft. The upgrade will
* fail registration if an already used ID is specified.
* @see TurtleAPI#registerUpgrade( ITurtleUpgrade )
*/
public int getUpgradeID();
/**
* Return a String to describe this type of upgrade in turtle item names.
* Examples of built-in adjectives are "Wireless", "Mining" and "Crafty".
*/
public String getAdjective();
/**
* Return whether this upgrade adds a tool or a peripheral to the turtle.
* Currently, turtle crafting is restricted to one tool & one peripheral per turtle.
* @see TurtleUpgradeType for the differences between the two.
*/
public TurtleUpgradeType getType();
/**
* Return an item stack representing the type of item that a turtle must be crafted
* with to create a turtle which holds this upgrade.
* Currently, turtle crafting is restricted to one tool & one peripheral per turtle.
*/
public net.minecraft.item.ItemStack getCraftingItem();
/**
* Return whether this turtle upgrade is an easter egg, and should be attempted to be hidden
* from the creative mode inventory and recipe book plugins.
*/
public boolean isSecret();
/**
* Will only be called for Peripheral upgrades. Creates a peripheral for a turtle
* being placed using this upgrade. The peripheral created will be stored
* for the lifetime of the turtle, will have update() called once-per-tick, and will be
* attach'd detach'd and have methods called in the same manner as a Computer peripheral.
* @param turtle Access to the turtle that the peripheral is being created for.
* @param side Which side of the turtle (left or right) that the upgrade resides on.
* @returns The newly created peripheral. You may return null if this upgrade is a Tool
* and this method is not expected to be called.
*/
public IHostedPeripheral createPeripheral( ITurtleAccess turtle, TurtleSide side );
/**
* Will only be called for Tool upgrades. Called when turtle.dig() or turtle.attack() is called
* by the turtle, and the tool is required to do some work.
* @param turtle Access to the turtle that the tool resides on.
* @param side Which side of the turtle (left or right) the tool resides on.
* @param verb Which action (dig or attack) the turtle is being called on to perform.
* @param direction Which world direction the action should be performed in, relative to the turtles
* position. This will either be up, down, or the direction the turtle is facing, depending on
* whether dig, digUp or digDown was called.
* @return Whether the turtle was able to perform the action, and hence whether the turtle.dig()
* or turtle.attack() lua method should return true. If true is returned, the tool will perform
* a swinging animation. You may return false if this upgrade is a Peripheral
* and this method is not expected to be called.
*/
public boolean useTool( ITurtleAccess turtle, TurtleSide side, TurtleVerb verb, int direction );
/**
* Called to obtain the Icon to be used when rendering a turtle peripheral. Needs to be a "block"
* type Icon for now, as there is no way to determine which texture sheet an Icon is from by the
* Icon itself.
* @param turtle Access to the turtle that the peripheral resides on.
* @param side Which side of the turtle (left or right) the peripheral resides on.
* @return The Icon that you wish to be used to render your turtle peripheral.
*/
public Icon getIcon( ITurtleAccess turtle, TurtleSide side );
}

78
APIs/dan200/turtle/api/TurtleAPI.java
View file

@ -1,78 +0,0 @@
/**
* This file is part of the public ComputerCraft API - http://www.computercraft.info
* Copyright Daniel Ratcliffe, 2011-2013. This API may be redistributed unmodified and in full only.
* For help using the API, and posting your mods, visit the forums at computercraft.info.
*/
package dan200.turtle.api;
import java.lang.reflect.Method;
/**
* The static entry point to the ComputerCraft Turtle Upgrade API.
* Members in this class must be called after mod_CCTurtle has been initialised,
* but may be called before it is fully loaded.
*/
public class TurtleAPI
{
/**
* Registers a new turtle upgrade for use in ComputerCraft. After calling this,
* users should be able to craft Turtles with your new upgrade. It is recommended to call
* this during the load() method of your mod.
* @throws Exception if you try to register an upgrade with an already used or reserved upgradeID
* @see ITurtleUpgrade
*/
public static void registerUpgrade( ITurtleUpgrade upgrade )
{
if( upgrade != null )
{
findCCTurtle();
if( ccTurtle_registerTurtleUpgrade != null )
{
try {
ccTurtle_registerTurtleUpgrade.invoke( null, new Object[]{ upgrade } );
} catch( Exception e ) {
// It failed
}
}
}
}
// The functions below here are private, and are used to interface with the non-API ComputerCraft classes.
// Reflection is used here so you can develop your mod in MCP without decompiling ComputerCraft and including
// it in your solution.
private static void findCCTurtle()
{
if( !ccTurtleSearched ) {
// Search for CCTurtle
try {
ccTurtle = Class.forName( "dan200.CCTurtle" );
ccTurtle_registerTurtleUpgrade = findCCTurtleMethod( "registerTurtleUpgrade", new Class[] {
ITurtleUpgrade.class
} );
} catch( ClassNotFoundException e ) {
System.out.println("ComputerCraftAPI: CCTurtle not found.");
} finally {
ccTurtleSearched = true;
}
}
}
private static Method findCCTurtleMethod( String name, Class[] args )
{
try {
return ccTurtle.getMethod( name, args );
} catch( NoSuchMethodException e ) {
System.out.println("ComputerCraftAPI: CCTurtle method " + name + " not found.");
return null;
}
}
private static boolean ccTurtleSearched = false;
private static Class ccTurtle = null;
private static Method ccTurtle_registerTurtleUpgrade = null;
}

23
APIs/dan200/turtle/api/TurtleSide.java
View file

@ -1,23 +0,0 @@
/**
* This file is part of the public ComputerCraft API - http://www.computercraft.info
* Copyright Daniel Ratcliffe, 2011-2013. This API may be redistributed unmodified and in full only.
* For help using the API, and posting your mods, visit the forums at computercraft.info.
*/
package dan200.turtle.api;
/**
* An enum representing the two sides of the turtle that a turtle upgrade might reside.
*/
public enum TurtleSide
{
/**
* The turtles left side (where the pickaxe usually is on a Wireless Mining Turtle)
*/
Left,
/**
* The turtles right side (where the modem usually is on a Wireless Mining Turtle)
*/
Right,
}

27
APIs/dan200/turtle/api/TurtleUpgradeType.java
View file

@ -1,27 +0,0 @@
/**
* This file is part of the public ComputerCraft API - http://www.computercraft.info
* Copyright Daniel Ratcliffe, 2011-2013. This API may be redistributed unmodified and in full only.
* For help using the API, and posting your mods, visit the forums at computercraft.info.
*/
package dan200.turtle.api;
/**
* An enum representing the two different types of upgrades that an ITurtleUpgrade
* implementation can add to a turtle.
* @see ITurtleUpgrade
*/
public enum TurtleUpgradeType
{
/**
* A tool is rendered as an item on the side of the turtle, and responds to the turtle.dig()
* and turtle.attack() methods (Such as pickaxe or sword on Mining and Melee turtles).
*/
Tool,
/**
* A peripheral adds a special peripheral which is attached to the side of the turtle,
* and can be interacted with the peripheral API (Such as the modem on Wireless Turtles).
*/
Peripheral,
}

26
APIs/dan200/turtle/api/TurtleVerb.java
View file

@ -1,26 +0,0 @@
/**
* This file is part of the public ComputerCraft API - http://www.computercraft.info
* Copyright Daniel Ratcliffe, 2011-2013. This API may be redistributed unmodified and in full only.
* For help using the API, and posting your mods, visit the forums at computercraft.info.
*/
package dan200.turtle.api;
/**
* An enum representing the two different actions that an ITurtleUpgrade of type
* Tool may be called on to perform by a turtle.
* @see ITurtleUpgrade
* @see ITurtleUpgrade#useTool
*/
public enum TurtleVerb
{
/**
* The turtle called turtle.dig(), turtle.digUp() or turtle.digDown()
*/
Dig,
/**
* The turtle called turtle.attack(), turtle.attackUp() or turtle.attackDown()
*/
Attack,
}

23
APIs/ic2/api/energy/event/EnergyTileEvent.java
View file

@ -1,23 +0,0 @@
package ic2.api.energy.event;
import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.event.world.WorldEvent;
import ic2.api.energy.tile.IEnergyTile;
/**
* Base class for energy net events, don't use it directly.
*
* See ic2/api/energy/usage.txt for an overall description of the energy net api.
*/
public class EnergyTileEvent extends WorldEvent {
public final IEnergyTile energyTile;
public EnergyTileEvent(IEnergyTile energyTile) {
super(((TileEntity) energyTile).worldObj);
this.energyTile = energyTile;
}
}

26
APIs/ic2/api/energy/event/EnergyTileLoadEvent.java
View file

@ -1,26 +0,0 @@
package ic2.api.energy.event;
import ic2.api.energy.tile.IEnergyTile;
/**
* Event announcing new energy tiles.
*
* This event notifies subscribers of loaded energy tiles, e.g. after getting
* loaded through the chunk they are in or after being placed down by the
* player or another deployer mechanism.
*
* Every energy tile which wants to get connected to the IC2 Energy Network has
* to either post this event or alternatively call EnergyNet.addTileEntity().
*
* You may use this event to build a static representation of energy tiles for
* your own energy grid implementation if you need to. It's not required if you
* always lookup energy paths on demand.
*
* See ic2/api/energy/usage.txt for an overall description of the energy net api.
*/
public class EnergyTileLoadEvent extends EnergyTileEvent {
public EnergyTileLoadEvent(IEnergyTile energyTile) {
super(energyTile);
}
}

27
APIs/ic2/api/energy/event/EnergyTileUnloadEvent.java
View file

@ -1,27 +0,0 @@
package ic2.api.energy.event;
import ic2.api.energy.tile.IEnergyTile;
/**
* Event announcing terminated energy tiles.
*
* This event notifies subscribers of unloaded energy tiles, e.g. after getting
* unloaded through the chunk they are in or after being destroyed by the
* player or another block pick/destruction mechanism.
*
* Every energy tile which wants to get disconnected from the IC2 Energy
* Network has to either post this event or alternatively call
* EnergyNet.removeTileEntity().
*
* You may use this event to build a static representation of energy tiles for
* your own energy grid implementation if you need to. It's not required if you
* always lookup energy paths on demand.
*
* See ic2/api/energy/usage.txt for an overall description of the energy net api.
*/
public class EnergyTileUnloadEvent extends EnergyTileEvent {
public EnergyTileUnloadEvent(IEnergyTile energyTile) {
super(energyTile);
}
}

27
APIs/ic2/api/energy/tile/IEnergyAcceptor.java
View file

@ -1,27 +0,0 @@
package ic2.api.energy.tile;
import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.common.ForgeDirection;
/**
* For internal/multi-block usage only.
*
* @see IEnergySink
* @see IEnergyConductor
*
* See ic2/api/energy/usage.txt for an overall description of the energy net api.
*/
public interface IEnergyAcceptor extends IEnergyTile {
/**
* Determine if this acceptor can accept current from an adjacent emitter in a direction.
*
* The TileEntity in the emitter parameter is what was originally added to the energy net,
* which may be normal in-world TileEntity, a delegate or an IMetaDelegate.
*
* @param emitter energy emitter
* @param direction direction the energy is being received from
*/
boolean acceptsEnergyFrom(TileEntity emitter, ForgeDirection direction);
}

53
APIs/ic2/api/energy/tile/IEnergyConductor.java
View file

@ -1,53 +0,0 @@
package ic2.api.energy.tile;
/**
* Tile entities which conduct energy pulses without buffering (mostly cables) have to implement this
* interface.
*
* See ic2/api/energy/usage.txt for an overall description of the energy net api.
*/
public interface IEnergyConductor extends IEnergyAcceptor, IEnergyEmitter {
/**
* Energy loss for the conductor in EU per block.
*
* @return Energy loss
*/
double getConductionLoss();
/**
* Amount of energy the insulation will handle before shocking nearby players and mobs.
*
* @return Insulation energy absorption in EU
*/
int getInsulationEnergyAbsorption();
/**
* Amount of energy the insulation will handle before it is destroyed.
* Ensure that this value is greater than the insulation energy absorption + 64.
*
* @return Insulation-destroying energy in EU
*/
int getInsulationBreakdownEnergy();
/**
* Amount of energy the conductor will handle before it melts.
*
* @return Conductor-destroying energy in EU
*/
int getConductorBreakdownEnergy();
/**
* Remove the conductor's insulation if the insulation breakdown energy was exceeded.
*
* @see #getInsulationBreakdownEnergy()
*/
void removeInsulation();
/**
* Remove the conductor if the conductor breakdown energy was exceeded.
*
* @see #getConductorBreakdownEnergy()
*/
void removeConductor();
}

28
APIs/ic2/api/energy/tile/IEnergyEmitter.java
View file

@ -1,28 +0,0 @@
package ic2.api.energy.tile;
import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.common.ForgeDirection;
/**
* For internal/multi-block usage only.
*
* @see IEnergySource
* @see IEnergyConductor
*
* See ic2/api/energy/usage.txt for an overall description of the energy net api.
*/
public interface IEnergyEmitter extends IEnergyTile {
/**
* Determine if this emitter can emit energy to an adjacent receiver.
*
* The TileEntity in the receiver parameter is what was originally added to the energy net,
* which may be normal in-world TileEntity, a delegate or an IMetaDelegate.
*
* @param receiver receiver, may be an IMetaDelegate
* @param direction direction the receiver is from the emitter
* @return Whether energy should be emitted
*/
boolean emitsEnergyTo(TileEntity receiver, ForgeDirection direction);
}

46
APIs/ic2/api/energy/tile/IEnergySink.java
View file

@ -1,46 +0,0 @@
package ic2.api.energy.tile;
import net.minecraftforge.common.ForgeDirection;
/**
* Allows a tile entity (mostly a machine) to receive energy.
*
* See ic2/api/energy/usage.txt for an overall description of the energy net api.
*/
public interface IEnergySink extends IEnergyAcceptor {
/**
* Determine how much energy the sink accepts.
*
* This value is unrelated to getMaxSafeInput().
*
* Make sure that injectEnergy() does accepts energy if demandsEnergy() returns anything > 0.
*
* @return max accepted input in eu
*/
double demandedEnergyUnits();
/**
* Transfer energy to the sink.
*
* It's highly recommended to accept all energy by letting the internal buffer overflow to
* increase the performance and accuracy of the distribution simulation.
*
* @param directionFrom direction from which the energy comes from
* @param amount energy to be transferred
* @return Energy not consumed (leftover)
*/
double injectEnergyUnits(ForgeDirection directionFrom, double amount);
/**
* Determine the amount of eu which can be safely injected into the specific energy sink without exploding.
*
* Typical values are 32 for LV, 128 for MV, 512 for HV and 2048 for EV. A value of Integer.MAX_VALUE indicates no
* limit.
*
* This value is unrelated to demandsEnergy().
*
* @return max safe input in eu
*/
int getMaxSafeInput();
}

26
APIs/ic2/api/energy/tile/IEnergySource.java
View file

@ -1,26 +0,0 @@
package ic2.api.energy.tile;
/**
* Allows a tile entity (mostly a generator) to emit energy.
*
* See ic2/api/energy/usage.txt for an overall description of the energy net api.
*/
public interface IEnergySource extends IEnergyEmitter {
/**
* Energy output provided by the source this tick.
* This is typically Math.min(stored energy, max output/tick).
*
* @return Energy offered this tick
*/
double getOfferedEnergy();
/**
* Draw energy from this source's buffer.
*
* If the source doesn't have a buffer, this is a no-op.
*
* @param amount amount of EU to draw, may be negative
*/
void drawEnergy(double amount);
}

14
APIs/ic2/api/energy/tile/IEnergyTile.java
View file

@ -1,14 +0,0 @@
package ic2.api.energy.tile;
/**
* For internal usage only, base class for all energy tiles.
*
* @see IEnergySink
* @see IEnergySource
* @see IEnergyConductor
*
* See ic2/api/energy/usage.txt for an overall description of the energy net api.
*/
public interface IEnergyTile {
}

32
APIs/ic2/api/energy/tile/IMetaDelegate.java
View file

@ -1,32 +0,0 @@
package ic2.api.energy.tile;
import java.util.List;
import net.minecraft.tileentity.TileEntity;
/**
* Interface for grouping multi-block structures to a single energy net delegate.
*
* The energy net uses TileEntity to refer to a specific xyz+world position. If multiple of those
* positions should belong to the same functional structure, i.e. they consume or produce energy
* only once for the whole multi-block instead of once per every single block, this interface
* allows to do so.
*
* The tile entity implementing IMetaDelegate has to be added/removed to/from the energy net
* instead of every single sub-TileEntity. The energy net interaction will be handled by the
* IMetaDelegate TileEntity as well.
*
* The sub tile array TileEntity[] just provides optional connectivity (IEnergyAcceptor,
* IEnergyEmitter) and mandatory position (x, y, z, World) data.
* If the connectivity data on the sub tile is missing, the meta delegate is queried instead.
*
* See ic2/api/energy/usage.txt for an overall description of the energy net api.
*/
public interface IMetaDelegate extends IEnergyTile {
/**
* Get the sub-TileEntities belonging to this Meta TileEntity.
*
* @return sub-TileEntity array
*/
List<TileEntity> getSubTiles();
}

108
APIs/ic2/api/item/ElectricItem.java
View file

@ -1,108 +0,0 @@
package ic2.api.item;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemStack;
/**
* Allows for charging, discharging and using electric items (IElectricItem).
*
* The charge or remaining capacity of an item can be determined by calling charge/discharge with
* ignoreTransferLimit and simulate set to true.
*/
public final class ElectricItem {
/**
* IElectricItemManager to use for interacting with IElectricItem ItemStacks.
*
* This manager will act as a gateway and delegate the tasks to the final implementation
* (rawManager or a custom one) as necessary.
*/
public static IElectricItemManager manager;
/**
* Standard IElectricItemManager implementation, only call it directly from another
* IElectricItemManager. Use manager instead.
*/
public static IElectricItemManager rawManager;
/**
* Charge an item with a specified amount of energy
*
* @param itemStack electric item's stack
* @param amount amount of energy to charge in EU
* @param tier tier of the charging device, has to be at least as high as the item to charge
* @param ignoreTransferLimit ignore the transfer limit specified by getTransferLimit()
* @param simulate don't actually change the item, just determine the return value
* @return Energy transferred into the electric item
*
* @deprecated use manager.charge() instead
*/
@Deprecated
public static int charge(ItemStack itemStack, int amount, int tier, boolean ignoreTransferLimit, boolean simulate) {
return manager.charge(itemStack, amount, tier, ignoreTransferLimit, simulate);
}
/**
* Discharge an item by a specified amount of energy
*
* @param itemStack electric item's stack
* @param amount amount of energy to charge in EU
* @param tier tier of the discharging device, has to be at least as high as the item to discharge
* @param ignoreTransferLimit ignore the transfer limit specified by getTransferLimit()
* @param simulate don't actually discharge the item, just determine the return value
* @return Energy retrieved from the electric item
*
* @deprecated use manager.discharge() instead
*/
@Deprecated
public static int discharge(ItemStack itemStack, int amount, int tier, boolean ignoreTransferLimit, boolean simulate) {
return manager.discharge(itemStack, amount, tier, ignoreTransferLimit, simulate);
}
/**
* Determine if the specified electric item has at least a specific amount of EU.
* This is supposed to be used in the item code during operation, for example if you want to implement your own electric item.
* BatPacks are not taken into account.
*
* @param itemStack electric item's stack
* @param amount minimum amount of energy required
* @return true if there's enough energy
*
* @deprecated use manager.canUse() instead
*/
@Deprecated
public static boolean canUse(ItemStack itemStack, int amount) {
return manager.canUse(itemStack, amount);
}
/**
* Try to retrieve a specific amount of energy from an Item, and if applicable, a BatPack.
* This is supposed to be used in the item code during operation, for example if you want to implement your own electric item.
*
* @param itemStack electric item's stack
* @param amount amount of energy to discharge in EU
* @param player player holding the item
* @return true if the operation succeeded
*
* @deprecated use manager.use() instead
*/
@Deprecated
public static boolean use(ItemStack itemStack, int amount, EntityPlayer player) {
return manager.use(itemStack, amount, player);
}
/**
* Charge an item from the BatPack a player is wearing.
* This is supposed to be used in the item code during operation, for example if you want to implement your own electric item.
* use() already contains this functionality.
*
* @param itemStack electric item's stack
* @param player player holding the item
*
* @deprecated use manager.chargeFromArmor() instead
*/
@Deprecated
public static void chargeFromArmor(ItemStack itemStack, EntityPlayer player) {
manager.chargeFromArmor(itemStack, player);
}
}

14
APIs/ic2/api/item/IBoxable.java
View file

@ -1,14 +0,0 @@
package ic2.api.item;
import net.minecraft.item.ItemStack;
public interface IBoxable {
/**
* Determine whether an item can be stored in a toolbox or not.
*
* @param itemstack item to be stored
* @return Whether to store the item in the toolbox or not
*/
public abstract boolean canBeStoredInToolbox(ItemStack itemstack);
}

67
APIs/ic2/api/item/ICustomElectricItem.java
View file

@ -1,67 +0,0 @@
package ic2.api.item;
import net.minecraft.item.ItemStack;
/**
* Provides the ability to store energy on the implementing item.
*
* This interface is a special version of IElectricItem which delegates the implementation of
* charge(), discharge() and canUse() to the implementing Item.
*
* The default implementation (when not using ICustomElectricItem) does the following:
* - store and retrieve the charge
* - handle charging, taking amount, tier, transfer limit, canProvideEnergy and simulate into account
* - replace item IDs if appropriate (getChargedItemId() and getEmptyItemId())
* - update and manage the damage value for the visual charge indicator
*
* @note ICustomElectricItem must not call the ElectricItem methods charge, discharge or canUse
*
* @deprecated Use ISpecialElectricItem instead.
*/
@Deprecated
public interface ICustomElectricItem extends IElectricItem {
/**
* Charge an item with a specified amount of energy
*
* @param itemStack electric item's stack
* @param amount amount of energy to charge in EU
* @param tier tier of the charging device, has to be at least as high as the item to charge
* @param ignoreTransferLimit ignore the transfer limit specified by getTransferLimit()
* @param simulate don't actually change the item, just determine the return value
* @return Energy transferred into the electric item
*/
public int charge(ItemStack itemStack, int amount, int tier, boolean ignoreTransferLimit, boolean simulate);
/**
* Discharge an item by a specified amount of energy
*
* @param itemStack electric item's stack
* @param amount amount of energy to charge in EU
* @param tier tier of the discharging device, has to be at least as high as the item to discharge
* @param ignoreTransferLimit ignore the transfer limit specified by getTransferLimit()
* @param simulate don't actually discharge the item, just determine the return value
* @return Energy retrieved from the electric item
*/
public int discharge(ItemStack itemStack, int amount, int tier, boolean ignoreTransferLimit, boolean simulate);
/**
* Determine if the specified electric item has at least a specific amount of EU.
* This is supposed to be used in the item code during operation, for example if you want to implement your own electric item.
* BatPacks are not taken into account.
*
* @param itemStack electric item's stack
* @param amount minimum amount of energy required
* @return true if there's enough energy
*/
public boolean canUse(ItemStack itemStack, int amount);
/**
* Determine whether to show the charge tool tip with NEI or other means.
*
* Return false if IC2's handler is incompatible, you want to implement your own or you don't
* want to display the charge at all.
*
* @return true to show the tool tip (x/y EU)
*/
public boolean canShowChargeToolTip(ItemStack itemStack);
}

23
APIs/ic2/api/item/IDebuggable.java
View file

@ -1,23 +0,0 @@
package ic2.api.item;
/**
* Allows a tile entity to output a debug message when the debugItem is used on it.
* Suggestions by Myrathi
*/
public abstract interface IDebuggable {
/**
* Checks if the tile entity is in a state that can be debugged.
*
* @return True if the tile entity can be debugged
*/
public abstract boolean isDebuggable();
/**
* Gets the debug text for the tile entity.
*
* @return The text that the debugItem should show
*/
public abstract String getDebugText();
}

54
APIs/ic2/api/item/IElectricItem.java
View file

@ -1,54 +0,0 @@
package ic2.api.item;
import net.minecraft.item.ItemStack;
/**
* Provides the ability to store energy on the implementing item.
*
* The item should have a maximum damage of 13.
*/
public interface IElectricItem {
/**
* Determine if the item can be used in a machine or as an armor part to supply energy.
*
* @return Whether the item can supply energy
*/
boolean canProvideEnergy(ItemStack itemStack);
/**
* Get the item ID to use for a charge energy greater than 0.
*
* @return Item ID to use
*/
int getChargedItemId(ItemStack itemStack);
/**
* Get the item ID to use for a charge energy of 0.
*
* @return Item ID to use
*/
int getEmptyItemId(ItemStack itemStack);
/**
* Get the item's maximum charge energy in EU.
*
* @return Maximum charge energy
*/
int getMaxCharge(ItemStack itemStack);
/**
* Get the item's tier, lower tiers can't send energy to higher ones.
* Batteries are Tier 1, Energy Crystals are Tier 2, Lapotron Crystals are Tier 3.
*
* @return Item's tier
*/
int getTier(ItemStack itemStack);
/**
* Get the item's transfer limit in EU per transfer operation.
*
* @return Transfer limit
*/
int getTransferLimit(ItemStack itemStack);
}

92
APIs/ic2/api/item/IElectricItemManager.java
View file

@ -1,92 +0,0 @@
package ic2.api.item;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.item.ItemStack;
/**
* This interface specifies a manager to handle the various tasks for electric items.
*
* The default implementation does the following:
* - store and retrieve the charge
* - handle charging, taking amount, tier, transfer limit, canProvideEnergy and simulate into account
* - replace item IDs if appropriate (getChargedItemId() and getEmptyItemId())
* - update and manage the damage value for the visual charge indicator
*
* @note If you're implementing your own variant (ISpecialElectricItem), you can delegate to the
* default implementations through ElectricItem.rawManager. The default implementation is designed
* to minimize its dependency on its own constraints/structure and delegates most work back to the
* more atomic features in the gateway manager.
*/
public interface IElectricItemManager {
/**
* Charge an item with a specified amount of energy
*
* @param itemStack electric item's stack
* @param amount amount of energy to charge in EU
* @param tier tier of the charging device, has to be at least as high as the item to charge
* @param ignoreTransferLimit ignore the transfer limit specified by getTransferLimit()
* @param simulate don't actually change the item, just determine the return value
* @return Energy transferred into the electric item
*/
int charge(ItemStack itemStack, int amount, int tier, boolean ignoreTransferLimit, boolean simulate);
/**
* Discharge an item by a specified amount of energy
*
* @param itemStack electric item's stack
* @param amount amount of energy to charge in EU
* @param tier tier of the discharging device, has to be at least as high as the item to discharge
* @param ignoreTransferLimit ignore the transfer limit specified by getTransferLimit()
* @param simulate don't actually discharge the item, just determine the return value
* @return Energy retrieved from the electric item
*/
int discharge(ItemStack itemStack, int amount, int tier, boolean ignoreTransferLimit, boolean simulate);
/**
* Determine the charge level for the specified item
*
* @param itemStack ItemStack containing the electric item
* @return charge level in EU
*/
int getCharge(ItemStack itemStack);
/**
* Determine if the specified electric item has at least a specific amount of EU.
* This is supposed to be used in the item code during operation, for example if you want to implement your own electric item.
* BatPacks are not taken into account.
*
* @param itemStack electric item's stack
* @param amount minimum amount of energy required
* @return true if there's enough energy
*/
boolean canUse(ItemStack itemStack, int amount);
/**
* Try to retrieve a specific amount of energy from an Item, and if applicable, a BatPack.
* This is supposed to be used in the item code during operation, for example if you want to implement your own electric item.
*
* @param itemStack electric item's stack
* @param amount amount of energy to discharge in EU
* @param entity entity holding the item
* @return true if the operation succeeded
*/
boolean use(ItemStack itemStack, int amount, EntityLivingBase entity);
/**
* Charge an item from the BatPack a player is wearing.
* This is supposed to be used in the item code during operation, for example if you want to implement your own electric item.
* use() already contains this functionality.
*
* @param itemStack electric item's stack
* @param entity entity holding the item
*/
void chargeFromArmor(ItemStack itemStack, EntityLivingBase entity);
/**
* Get the tool tip to display for electric items.
*
* @param itemStack ItemStack to determine the tooltip for
* @return tool tip string or null for none
*/
String getToolTip(ItemStack itemStack);
}

27
APIs/ic2/api/item/IItemHudInfo.java
View file

@ -1,27 +0,0 @@
package ic2.api.item;
import java.util.LinkedList;
import java.util.List;
import net.minecraft.item.ItemStack;
public interface IItemHudInfo {
/*
Add Info to Nano- and Quantum-Suit Helm Hud
for itemStack
@Override
public List<String> getHudInfo(ItemStack itemStack) {
List<String> info = new LinkedList<String>();
info.add("i am a Cool Item");
info.add("and have Cool info");
return info;
}
*/
public List<String> getHudInfo(ItemStack itemStack);
}

20
APIs/ic2/api/item/IMetalArmor.java
View file

@ -1,20 +0,0 @@
package ic2.api.item;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemStack;
/**
* Armor items implementing this can be considered metal armor.
*
* Currently used for determining which boots can be used to slide up a magnetic pole.
*/
public interface IMetalArmor {
/**
* Determine if the given armor piece is metal armor.
*
* @param itemstack Armor piece as worn by the player
* @param player The player
* @return Whether the armor piece is metal armor
*/
public boolean isMetalArmor(ItemStack itemstack, EntityPlayer player);
}

13
APIs/ic2/api/item/ISpecialElectricItem.java
View file

@ -1,13 +0,0 @@
package ic2.api.item;
import net.minecraft.item.ItemStack;
public interface ISpecialElectricItem extends IElectricItem {
/**
* Supply a custom IElectricItemManager.
*
* @param itemStack ItemStack to get the manager for
* @return IElectricItemManager instance
*/
IElectricItemManager getManager(ItemStack itemStack);
}

35
APIs/ic2/api/item/ITerraformingBP.java
View file

@ -1,35 +0,0 @@
package ic2.api.item;
import net.minecraft.world.World;
/**
* Allows an item to act as a terraformer blueprint.
*/
public interface ITerraformingBP
{
/**
* Get the energy consumption per operation of the blueprint.
*
* @return Energy consumption in EU
*/
public abstract int getConsume();
/**
* Get the maximum range of the blueprint.
* Should be a divisor of 5.
*
* @return Maximum range in blocks
*/
public abstract int getRange();
/**
* Perform the terraforming operation.
*
* @param world world to terraform
* @param x X position to terraform
* @param z Z position to terraform
* @param yCoord Y position of the terraformer
* @return Whether the operation was successful and the terraformer should consume energy.
*/
public abstract boolean terraform(World world, int x, int z, int yCoord);
}

50
APIs/ic2/api/item/ItemWrapper.java
View file

@ -1,50 +0,0 @@
package ic2.api.item;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Multimap;
/**
* Wrapper for inserting interfaces into items you don't own.
*
* @author Richard
*/
public class ItemWrapper {
private static final Multimap<Item, IBoxable> boxableItems = ArrayListMultimap.create();
private static final Multimap<Item, IMetalArmor> metalArmorItems = ArrayListMultimap.create();
public static void registerBoxable(Item item, IBoxable boxable) {
boxableItems.put(item, boxable);
}
public static boolean canBeStoredInToolbox(ItemStack stack) {
Item item = stack.getItem();
// use customs first to allow for overriding behavior
for (IBoxable boxable : boxableItems.get(item)) {
if (boxable.canBeStoredInToolbox(stack)) return true;
}
if (item instanceof IBoxable && ((IBoxable) item).canBeStoredInToolbox(stack)) return true;
return false;
}
public static void registerMetalArmor(Item item, IMetalArmor armor) {
metalArmorItems.put(item, armor);
}
public static boolean isMetalArmor(ItemStack stack, EntityPlayer player) {
Item item = stack.getItem();
// use customs first to allow for overriding behavior
for (IMetalArmor metalArmor : metalArmorItems.get(item)) {
if (metalArmor.isMetalArmor(stack, player)) return true;
}
if (item instanceof IMetalArmor && ((IMetalArmor) item).isMetalArmor(stack, player)) return true;
return false;
}
}

407
APIs/ic2/api/item/Items.java
View file

@ -1,407 +0,0 @@
package ic2.api.item;
import net.minecraft.item.ItemStack;
/**
* Provides access to IC2 blocks and items.
*
* Some items can be acquired through the ore dictionary which is the recommended way.
* The items are initialized while IC2 is being loaded - try to use ModsLoaded() or load your mod after IC2.
* Some blocks/items can be disabled by a config setting, so it's recommended to check if they're null first.
*
* Getting the associated Block/Item for an ItemStack x:
* Blocks: Block.blocksList[x.itemID]
* Items: x.getItem()
*/
public final class Items {
/**
* Get an ItemStack for a specific item name, example: Items.getItem("resin")
* See the list below for item names.
* Make sure to copy() the ItemStack if you want to modify it.
*
* @param name item name
* @return The item or null if the item does not exist or an error occurred
*/
public static ItemStack getItem(String name) {
try {
if (Ic2Items == null) Ic2Items = Class.forName(getPackage() + ".core.Ic2Items");
Object ret = Ic2Items.getField(name).get(null);
if (ret instanceof ItemStack) {
return (ItemStack) ret;
} else {
return null;
}
} catch (Exception e) {
System.out.println("IC2 API: Call getItem failed for "+name);
return null;
}
}
/* Possible values:
----- blocks -----
ores
copperOre Copper Ore block, currently not meta sensitive, meta in ItemStack set to 0, ore dictionary: oreCopper, null with enableWorldGenOreCopper=false
tinOre Tin Ore block, currently not meta sensitive, meta in ItemStack set to 0, ore dictionary: oreTin, null with enableWorldGenOreTin=false
uraniumOre Tin Ore block, currently not meta sensitive, meta in ItemStack set to 0, ore dictionary: oreUranium, null with enableWorldGenOreUranium=false
rubber related
Rubber wood block, meta reflects the state, meta in ItemStack set to 0, ore dictionary: woodRubber (with meta 0), null with enableWorldGenTreeRubber=false
dropped (as an item) -> metadata 0
block, no resin spot -> metadata 0 or 1
block, wet resin spot -> metadata 2-5 (according to the side)
block, dry resin spot -> metadata 8-11 (wet state + 6)
rubberWood
rubberLeaves Rubber Leaves block, currently not meta sensitive, meta in ItemStack set to 0, null with enableWorldGenTreeRubber=false
rubberSapling Rubber Sapling block, currently not meta sensitive, meta in ItemStack set to 0, null with enableWorldGenTreeRubber=false
resinSheet Resin Sheet block, currently not meta sensitive
rubberTrampoline Rubber Trampoline block, meta reflects internal state, meta in ItemStack set to 0
building/storage
ironFence Iron Fence block, currently not meta sensitive
reinforcedStone Reinforced Stone block, currently not meta sensitive
reinforcedGlass Reinforced Glass block, currently not meta sensitive
reinforcedDoorBlock Reinforced Door block, meta reflects the state (see vanilla doors), meta in ItemStack set to 0
constructionFoam Construction Foam block, currently not meta sensitive
constructionFoamWall Construction Foam Wall block, meta = color, implements IPaintableBlock
scaffold Scaffold block, meta reflects internal physical model data
bronzeBlock Bronze block, meta sensitive
copperBlock Copper block, meta sensitive
tinBlock Tin block, meta sensitive
uraniumBlock Uranium block, meta sensitive
cables (when placed as a block, inventory items are different TE implements IEnergyConductor)
copperCableBlock Copper Cable block, meta sensitive
insulatedCopperCableBlock Insulated Copper Cable block, meta sensitive
goldCableBlock Gold Cable block, meta sensitive
insulatedGoldCableBlock Insulated Gold Cable block, meta sensitive
doubleInsulatedGoldCableBlock Double Insulated Gold Cable block, meta sensitive
ironCableBlock Iron Cable block, meta sensitive
insulatedIronCableBlock Insulated Iron Cable block, meta sensitive
doubleInsulatedIronCableBlock Double Insulated Iron Cable block, meta sensitive
trippleInsulatedIronCableBlock Tripple Insulated Iron Cable block, meta sensitive
glassFiberCableBlock Glass Fiber Cable block, meta sensitive
tinCableBlock Tin Cable block, meta sensitive
detectorCableBlock Detector Cable block, meta sensitive
splitterCableBlock Splitter Cable block, meta sensitive
generators + related (TE implements IEnergySource ex. reactorChamber)
generator Generator block, meta sensitive
geothermalGenerator Geothermal Generator block, meta sensitive
waterMill Water Mill block, meta sensitive
solarPanel Solar Panel block, meta sensitive
windMill Wind Mill block, meta sensitive
nuclearReactor Nuclear Reactor block, meta sensitive
reactorChamber Reactor Chamber block, currently not meta sensitive
energy storages (TE implements IEnergySource and IEnergyConductor)
batBox BatBox block, meta sensitive
mfeUnit MFE Unit block, meta sensitive
mfsUnit MFS Unit block, meta sensitive
transformers (TE implements IEnergySource and IEnergyConductor)
lvTransformer LV Transformer block, meta sensitive
mvTransformer MV Transformer block, meta sensitive
hvTransformer HV Transformer block, meta sensitive
machines + related (TE implements IEnergySink ex. machine, miningPipe, miningPipeTip)
machine Machine block, meta sensitive
advancedMachine Advanced Machine block, meta sensitive
ironFurnace Iron Furnace block, meta sensitive
electroFurnace Electro Furnace block, meta sensitive
macerator Macerator block, meta sensitive
extractor Extractor block, meta sensitive
compressor Compressor block, meta sensitive
canner Canner block, meta sensitive
miner Miner block, meta sensitive
pump Pump block, meta sensitive
magnetizer Magnetizer block, meta sensitive
electrolyzer Electrolyzer block, meta sensitive
recycler Recycler block, meta sensitive
inductionFurnace Induction Furnace block, meta sensitive
massFabricator Mass Fabricator block, meta sensitive
terraformer Terraformer block, meta sensitive
teleporter Teleporter block, meta sensitive
teslaCoil Tesla Coil block, meta sensitive
luminator Passive (dark) Luminator block, meta = facing
activeLuminator Active (bright) Luminator block, meta = facing
miningPipe Mining Pipe block, currently not meta sensitive, meta in ItemStack set to 0
miningPipeTip Mining Pipe Tip block, currently not meta sensitive, meta in ItemStack set to 0
personal blocks
personalSafe Personal Safe block, meta sensitive
tradeOMat Trade-O-Mat block, meta sensitive
energyOMat Energy-O-Mat block, meta sensitive
explosives
industrialTnt Industrial TNT block, currently not meta sensitive
nuke Nuke block, currently not meta sensitive
dynamiteStick Dynamite Stick block, meta = placement, meta in ItemStack set to 0
dynamiteStickWithRemote Dynamite Stick with Remote block, meta = placement, meta in ItemStack set to 0
Agriculture Stuff
crop Crop Block, empty, not meta sensitive
----- items -----
rubber + related
resin Resin item, currently not meta sensitive
rubber Rubber item, currently not meta sensitive, ore dictionary: itemRubber
ore drops
uraniumDrop Uranium Drop item, currently not meta sensitive, ore dictionary: itemDropUranium
dusts
bronzeDust Bronze Dust item, currently not meta sensitive
clayDust Clay Dust item, currently not meta sensitive
coalDust Coal Dust item, currently not meta sensitive
copperDust Copper Dust item, currently not meta sensitive
goldDust Gold Dust item, currently not meta sensitive
ironDust Iron Dust item, currently not meta sensitive
silverDust Silver Dust item, currently not meta sensitive
smallIronDust Small Iron Dust item, currently not meta sensitive
tinDust Tin Dust item, currently not meta sensitive
hydratedCoalDust Hydrated Coal Dust item, currently not meta sensitive
ingots
refinedIronIngot Refined Iron Ingot item, currently not meta sensitive, ore dictionary: ingotRefinedIron
copperIngot Copper Ingot item, currently not meta sensitive, ore dictionary: ingotCopper
tinIngot Tin Ingot item, currently not meta sensitive, ore dictionary: ingotTin
bronzeIngot Bronze Ingot item, currently not meta sensitive, ore dictionary: ingotBronze
mixedMetalIngot Mixed Metal Ingot item, currently not meta sensitive
uraniumIngot Uranium Ingot item, currently not meta sensitive, ore dictionary: ingotUranium
tools/weapons (without electric tools)
treetap Treetap item, meta = damage value
wrench Wrench item, meta = damage value
cutter Insulation Cutter item, meta = damage value
constructionFoamSprayer Construction Foam Sprayer item, meta = charges (as of v1.45)
bronzePickaxe Bronze Pickaxe item, meta = damage value
bronzeAxe Bronze Axe item, meta = damage value
bronzeSword Bronze Sword item, meta = damage value
bronzeShovel Bronze Shovel item, meta = damage value
bronzeHoe Bronze Hoe item, meta = damage value
el. tools/devices/weapons
miningDrill Mining Drill item, meta = visual charge indicator, implements IElectricItem
diamondDrill Diamond Tipped Mining Drill item, meta = visual charge indicator, implements IElectricItem
chainsaw Chainsaw item, meta = visual charge indicator, implements IElectricItem
electricWrench Electric Wrench item, meta = visual charge indicator, implements IElectricItem
electricTreetap Electric Treetap item, meta = visual charge indicator, implements IElectricItem
miningLaser Mining Laser item, meta = visual charge indicator, implements IElectricItem
ecMeter EC-Mater item, currently not meta sensitive
odScanner Ore Density Scanner item, meta = damage value for charge level, implements IElectricItem
ovScanner Ore Value Scanner item, meta = visual charge indicator, implements IElectricItem
frequencyTransmitter Frequency Transmitter item, currently not meta sensitive
nanoSaber Idle Nano Saber item, meta = visual charge indicator, implements IElectricItem
enabledNanoSaber Enabled Nano Saber item, meta = visual charge indicator, implements IElectricItem
armor/wearable
rubberBoots Rubber Boots item, meta = damage value
bronzeHelmet Bronze Helmet Armor item, meta = damage value
bronzeChestplate Bronze Chestplate Armor item, meta = damage value
bronzeLeggings Bronze Leggings Armor item, meta = damage value
bronzeBoots Bronze Boots Armor item, meta = damage value
compositeArmor Composite Armor item, meta = damage value for charge level
nanoHelmet Nano Helmet Armor item, meta = visual charge indicator, implements IElectricItem
nanoBodyarmor Nano Bodyarmor item, meta = visual charge indicator, implements IElectricItem
nanoLeggings Nano Leggings Armor item, meta = visual charge indicator, implements IElectricItem
nanoBoots Nano Boots Armor item, meta = visual charge indicator, implements IElectricItem
quantumHelmet Quantum Helmet Armor item, meta = visual charge indicator, implements IElectricItem
quantumBodyarmor Quantum Bodyarmor item, meta = visual charge indicator, implements IElectricItem
quantumLeggings Quantum Leggings Armor item, meta = visual charge indicator, implements IElectricItem
quantumBoots Quantum Boots Armor item, meta = visual charge indicator, implements IElectricItem
jetpack Jetpack item, meta = damage value for fuel level
electricJetpack Electric Jetpack item, meta = visual charge indicator, implements IElectricItem
batPack BatPack item, meta = visual charge indicator, implements IElectricItem, can provide energy
lapPack LapPack item, meta = visual charge indicator, implements IElectricItem, can provide energy
cfPack CF Pack item, meta = charges (as of v1.45)
solarHelmet Solar Helmet item, currently not meta sensitive
staticBoots Static Boots item, currently not meta sensitive
batteries
reBattery Empty RE Battery item, currently not meta sensitive, implements IElectricItem
chargedReBattery RE Battery item, meta = visual charge indicator, implements IElectricItem, can provide energy
energyCrystal Energy Crystal item, meta = visual charge indicator, implements IElectricItem, can provide energy
lapotronCrystal Lapotron Crystal item, meta = visual charge indicator, implements IElectricItem, can provide energy
suBattery SU Battery item, currently not meta sensitive
cables
copperCableItem Copper Cable item, meta sensitive
insulatedCopperCableItem Insulated Copper Cable item, meta sensitive
goldCableItem Gold Cable item, meta sensitive
insulatedGoldCableItem Insulated Gold Cable item, meta sensitive
doubleInsulatedGoldCableItem Double Insulated Gold Cable item, meta sensitive
ironCableItem Iron Cable item, meta sensitive
insulatedIronCableItem Insulated Iron Cable item, meta sensitive
doubleInsulatedIronCableItem Double Insulated Iron Cable item, meta sensitive
trippleInsulatedIronCableItem Tripple Insulated Iron Cable item, meta sensitive
glassFiberCableItem Glass Fiber Cable item, meta sensitive
tinCableItem Tin Cable item, meta sensitive
detectorCableItem Detector Cable item, meta sensitive
splitterCableItem Splitter Cable item, meta sensitive
cells/containers (without reactor components)
cell Empty Cell item, currently not meta sensitive
lavaCell Lava Cell item, currently not meta sensitive
hydratedCoalCell Hydrated Coal Cell item, currently not meta sensitive
bioCell Bio Cell item, currently not meta sensitive
coalfuelCell Coalfuel Cell item, currently not meta sensitive
biofuelCell Biofuel Cell item, currently not meta sensitive
waterCell Water Cell item, currently not meta sensitive
electrolyzedWaterCell Electrolyzed Water Cell item, currently not meta sensitive
fuelCan Empty Fuel Can item, currently not meta sensitive
filledFuelCan Fuel Can item, meta = fuel value (as of v1.45)
tinCan Empty Tin Can item, currently not meta sensitive
filledTinCan Filled Tin Can item, currently not meta sensitive
reactor components
uraniumCell Uranium Cell item, meta = damage value
coolingCell Cooling Cell item, meta = damage value
depletedIsotopeCell Depleted Isotope Cell item, meta = damage value
reEnrichedUraniumCell Re-Enriched Uranium Cell item, currently not meta sensitive
nearDepletedUraniumCell Near-Depleted Uranium Cell item, currently not meta sensitive
integratedReactorPlating Integrated Reactor Plating item, meta = damage value
integratedHeatDisperser Integrated Heat Disperser item, meta = damage value
terraformer blueprints
terraformerBlueprint Empty Terraformer Blueprint item, currently not meta sensitive
cultivationTerraformerBlueprint Cultivation Terraformer Blueprint item, currently not meta sensitive
irrigationTerraformerBlueprint Irrigation Terraformer Blueprint item, currently not meta sensitive
chillingTerraformerBlueprint Chilling Terraformer Blueprint item, currently not meta sensitive
desertificationTerraformerBlueprint Desertification Terraformer Blueprint item, currently not meta sensitive
flatificatorTerraformerBlueprint Flatificator Terraformer Blueprint item, currently not meta sensitive
mushroomTerraformerBlueprint Mushroom Terraformer Blueprint item, currently not meta sensitive
diamond chain
coalBall Coal Ball item, currently not meta sensitive
compressedCoalBall Compressed Coal Ball item, currently not meta sensitive
coalChunk Coal Chunk item, currently not meta sensitive
industrialDiamond Industrial Diamond item, currently not meta sensitive, DEPRECATED
recycler chain
scrap Scrap item, currently not meta sensitive
scrapBox Scrap Box item, currently not meta sensitive
fuel production chain
hydratedCoalClump Hydrated Coal Clump item, currently not meta sensitive
plantBall Plant Ball item, currently not meta sensitive
compressedPlantBall Compressed Plant Ball item, currently not meta sensitive
painting
painter Painter item, currently not meta sensitive
blackPainter Black Painter item, meta = damage value
redPainter Red Painter item, meta = damage value
greenPainter Green Painter item, meta = damage value
brownPainter Brown Painter item, meta = damage value
bluePainter Blue Painter item, meta = damage value
purplePainter Purple Painter item, meta = damage value
cyanPainter Cyan Painter item, meta = damage value
lightGreyPainter Light Grey Painter item, meta = damage value
darkGreyPainter Dark Grey Painter item, meta = damage value
pinkPainter Pink Painter item, meta = damage value
limePainter Lime Painter item, meta = damage value
yellowPainter Yellow Painter item, meta = damage value
cloudPainter Cloud Painter item, meta = damage value
magentaPainter Magenta Painter item, meta = damage value
orangePainter Orange Painter item, meta = damage value
whitePainter White Painter item, meta = damage value
explosives + related
dynamite Throwable Dynamite item, currently not meta sensitive
stickyDynamite Throwable Sticky Dynamite item, currently not meta sensitive
remote Dynamite Remote item, currently not meta sensitive
misc intermediate recipe ingredients
electronicCircuit Electronic Circuit item, currently not meta sensitive
advancedCircuit Advanced Circuit item, currently not meta sensitive
advancedAlloy Advanced Alloy item, currently not meta sensitive
carbonFiber Raw Carbon Fiber item, currently not meta sensitive
carbonMesh Raw Carbon Mesh item, currently not meta sensitive
carbonPlate Carbon Plate item, currently not meta sensitive
matter UU-Matter item, currently not meta sensitive
iridiumOre Iridium Ore item, currently not meta sensitive
iridiumPlate Iridium Plate item, currently not meta sensitive
upgrade modules
overclockerUpgrade overclocker upgrade item, meta sensitive
transformerUpgrade transformer upgrade item, meta sensitive
energyStorageUpgrade energy storage upgrade item, meta sensitive
misc
coin Coin item, currently not meta sensitive
reinforcedDoor Reinforced Door item, currently not meta sensitive
constructionFoamPellet Construction Foam Pellet item, currently not meta sensitive
cropSeed Crop seeds, stuff stored in NBT, don't use for crafting recipes!
cropnalyzer Cropnalyzer handheld device
fertilizer Basic IC2Item, used to provide nutrients toCropBlocks
hydratingCell Cell used to hydrate Crops, meta = Content, 0 = Full, 9999 = Near empty
electricHoe Electric Hoe, meta = charge level
solarHelmet Solar Helmet item, currently not meta sensitive
terraWart Terra Wart item, cures potion effects
weedEx Weed-EX can, meta = uses left
*/
/**
* Get the base IC2 package name, used internally.
*
* @return IC2 package name, if unable to be determined defaults to ic2
*/
private static String getPackage() {
Package pkg = Items.class.getPackage();
if (pkg != null) {
String packageName = pkg.getName();
return packageName.substring(0, packageName.length() - ".api.item".length());
}
return "ic2";
}
private static Class<?> Ic2Items;
}

46
APIs/thermalexpansion/api/item/IChargeableItem.java
View file

@ -1,46 +0,0 @@
package thermalexpansion.api.item;
import net.minecraft.item.ItemStack;
/**
* Implement this interface on Item classes that support external manipulation of their internal
* energy storages. This interface does not provide methods for the underlying internal energy
* usage.
*/
public interface IChargeableItem
{
/**
* Adds energy to an item. Returns the quantity of energy that was accepted. This should always
* return 0 if the item cannot be externally charged.
*
* @param theItem ItemStack to be charged.
* @param energy Maximum amount of energy to be sent into the item.
* @param doReceive If false, the charge will only be simulated.
* @return Amount of energy that was accepted by the item.
*/
public float receiveEnergy(ItemStack theItem, float energy, boolean doReceive);
/**
* Removes energy from an item. Returns the quantity of energy that was removed. This should
* always return 0 if the item cannot be externally discharged.
*
* @param theItem ItemStack to be discharged.
* @param energy Maximum amount of energy to be removed from the item.
* @param doTransfer If false, the discharge will only be simulated.
* @return Amount of energy that was removed from the item.
*/
public float transferEnergy(ItemStack theItem, float energy, boolean doTransfer);
/**
* Get the amount of energy currently stored in the item.
*/
public float getEnergyStored(ItemStack theItem);
/**
* Get the max amount of energy that can be stored in the item.
*/
public float getMaxEnergyStored(ItemStack theItem);
}

80
APIs/universalelectricity/compatibility/Compatibility.java
View file

@ -1,80 +0,0 @@
package universalelectricity.compatibility;
import universalelectricity.core.UniversalElectricity;
import universalelectricity.core.electricity.NetworkLoader;
import cpw.mods.fml.common.Loader;
/**
* The Universal Electricity compatibility module allows your mod to be compatible with most major
* power systems in Minecraft.
*
* @author Calclavia, Micdoodle
*/
public class Compatibility
{
/** Version of build craft api compiled with */
public static String BCx_VERSION = "@BCxVersion@";
/** Version of industrial craft api compiled with */
public static String ICx_VERSION = "@ICxVersion@";
/** Version of thermal expansion api compiled with */
public static String TEx_VERSION = "@TExVersion@";
/** Has the initiate method been called */
public static boolean INIT = false;
/** Ratio of Build craft(MJ) power to UE power(KW). Multiply BC3 power by this to convert to UE */
public static float BC3_RATIO = 1;
/**
* Ratio of Industrial craft(EU) power to UE power(KW). Multiply IC2 power by this to convert to
* UE
*/
public static float IC2_RATIO = 0.04f;
/**
* Ratio of UE power(KW) to Industrial craft(EU) power. Multiply UE power by this to convert it
* to IC2 power
*/
public static float TO_IC2_RATIO = 1 / IC2_RATIO;
/**
* Ratio of UE power(KW) to Build craft(MJ) power. Multiply UE power by this to convert it to
* BC3 power
*/
public static float TO_BC_RATIO = 1 / BC3_RATIO;
/** You must call this function to enable the Universal Network module. */
public static void initiate()
{
if (!INIT)
{
/** Outputs basic version information */
System.out.println("[UniversalElectricity] Loading compatibility API version " + UniversalElectricity.VERSION);
System.out.println("[UniversalElectricity] Compiled with IndustrialCraft API version " + Compatibility.ICx_VERSION);
System.out.println("[UniversalElectricity] Compiled with BuildCraft API version " + Compatibility.BCx_VERSION);
System.out.println("[UniversalElectricity] Compiled with ThermalExpansion API version " + Compatibility.TEx_VERSION);
/** Loads the configuration and sets all the values. */
UniversalElectricity.CONFIGURATION.load();
IC2_RATIO = (float) UniversalElectricity.CONFIGURATION.get("Compatiblity", "IndustrialCraft Conversion Ratio", IC2_RATIO).getDouble(IC2_RATIO);
BC3_RATIO = (float) UniversalElectricity.CONFIGURATION.get("Compatiblity", "BuildCraft Conversion Ratio", BC3_RATIO).getDouble(BC3_RATIO);
TO_IC2_RATIO = 1 / IC2_RATIO;
TO_BC_RATIO = 1 / BC3_RATIO;
UniversalElectricity.CONFIGURATION.save();
NetworkLoader.setNetworkClass(UniversalNetwork.class);
}
}
/** Checks using the FML loader too see if IC2 is loaded */
public static boolean isIndustrialCraft2Loaded()
{
return Loader.isModLoaded("IC2");
}
/** Checks using the FML loader too see if BC3 is loaded */
public static boolean isBuildcraftLoaded()
{
return Loader.isModLoaded("BuildCraft|Energy");
}
// TODO add Thermal expansion isLoaded check
}

150
APIs/universalelectricity/compatibility/ItemUniversalElectric.java
View file

@ -1,150 +0,0 @@
package universalelectricity.compatibility;
import ic2.api.item.IElectricItemManager;
import ic2.api.item.ISpecialElectricItem;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.item.ItemStack;
import thermalexpansion.api.item.IChargeableItem;
import universalelectricity.core.item.IItemElectric;
import universalelectricity.core.item.ItemElectric;
public abstract class ItemUniversalElectric extends ItemElectric implements ISpecialElectricItem, IChargeableItem
{
public static final float CHARGE_RATE = 0.005f;
public ItemUniversalElectric(int id)
{
super(id);
}
/**
* IC2
*/
@Override
public int getChargedItemId(ItemStack itemStack)
{
return this.itemID;
}
@Override
public int getEmptyItemId(ItemStack itemStack)
{
return this.itemID;
}
@Override
public int getMaxCharge(ItemStack itemStack)
{
return (int) (this.getMaxElectricityStored(itemStack) * Compatibility.TO_IC2_RATIO);
}
@Override
public int getTier(ItemStack itemStack)
{
return 1;
}
@Override
public int getTransferLimit(ItemStack itemStack)
{
return (int) ((this.getMaxElectricityStored(itemStack) * CHARGE_RATE) * Compatibility.TO_IC2_RATIO);
}
@Override
public IElectricItemManager getManager(ItemStack itemStack)
{
return IC2ElectricItemManager.MANAGER;
}
@Override
public boolean canProvideEnergy(ItemStack itemStack)
{
return this.recharge(itemStack, 1, false) > 0;
}
/**
* Thermal Expansion
*/
@Override
public float receiveEnergy(ItemStack theItem, float energy, boolean doReceive)
{
return this.recharge(theItem, energy * Compatibility.BC3_RATIO, doReceive) * Compatibility.TO_BC_RATIO;
}
@Override
public float transferEnergy(ItemStack theItem, float energy, boolean doTransfer)
{
return this.discharge(theItem, energy * Compatibility.BC3_RATIO, doTransfer) * Compatibility.TO_BC_RATIO;
}
@Override
public float getEnergyStored(ItemStack theItem)
{
return this.getElectricityStored(theItem) * Compatibility.TO_BC_RATIO;
}
@Override
public float getMaxEnergyStored(ItemStack theItem)
{
return this.getMaxElectricityStored(theItem) * Compatibility.TO_BC_RATIO;
}
public static class IC2ElectricItemManager implements IElectricItemManager
{
public static final IElectricItemManager MANAGER = new IC2ElectricItemManager();
private IItemElectric getElectricItem(ItemStack itemStack)
{
if (itemStack.getItem() instanceof IItemElectric)
{
return ((IItemElectric) itemStack.getItem());
}
return null;
}
@Override
public int charge(ItemStack itemStack, int amount, int tier, boolean ignoreTransferLimit, boolean simulate)
{
float inputElectricity = amount * Compatibility.IC2_RATIO;
return (int) (getElectricItem(itemStack).recharge(itemStack, inputElectricity, !simulate) * Compatibility.TO_IC2_RATIO);
}
@Override
public int discharge(ItemStack itemStack, int amount, int tier, boolean ignoreTransferLimit, boolean simulate)
{
float outputElectricity = amount * Compatibility.IC2_RATIO;
return (int) (getElectricItem(itemStack).discharge(itemStack, outputElectricity, !simulate) * Compatibility.TO_IC2_RATIO);
}
@Override
public boolean canUse(ItemStack itemStack, int amount)
{
return false;
}
@Override
public int getCharge(ItemStack itemStack)
{
return 0;
}
@Override
public boolean use(ItemStack itemStack, int amount, EntityLivingBase entity)
{
return false;
}
@Override
public void chargeFromArmor(ItemStack itemStack, EntityLivingBase entity)
{
}
@Override
public String getToolTip(ItemStack itemStack)
{
return null;
}
}
}

217
APIs/universalelectricity/compatibility/TileEntityUniversalConductor.java
View file

@ -1,217 +0,0 @@
package universalelectricity.compatibility;
import ic2.api.energy.event.EnergyTileLoadEvent;
import ic2.api.energy.event.EnergyTileUnloadEvent;
import ic2.api.energy.tile.IEnergyAcceptor;
import ic2.api.energy.tile.IEnergyEmitter;
import ic2.api.energy.tile.IEnergySink;
import ic2.api.energy.tile.IEnergyTile;
import java.util.HashSet;
import java.util.Set;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
import net.minecraftforge.common.ForgeDirection;
import net.minecraftforge.common.MinecraftForge;
import universalelectricity.core.block.IConnector;
import universalelectricity.core.electricity.ElectricityPack;
import universalelectricity.core.vector.Vector3;
import universalelectricity.core.vector.VectorHelper;
import universalelectricity.prefab.tile.TileEntityConductor;
import buildcraft.api.power.IPowerReceptor;
import buildcraft.api.power.PowerHandler;
import buildcraft.api.power.PowerHandler.PowerReceiver;
import buildcraft.api.power.PowerHandler.Type;
/**
* A universal conductor class.
*
* Extend this class or use as a reference for your own implementation of compatible conductor
* tiles.
*
* @author Calclavia, micdoodle8
*
*/
public abstract class TileEntityUniversalConductor extends TileEntityConductor implements IEnergySink, IPowerReceptor
{
protected boolean isAddedToEnergyNet;
public PowerHandler powerHandler;
public float buildcraftBuffer = Compatibility.BC3_RATIO * 50;
public TileEntityUniversalConductor()
{
this.powerHandler = new PowerHandler(this, Type.PIPE);
this.powerHandler.configure(0, this.buildcraftBuffer, this.buildcraftBuffer, this.buildcraftBuffer * 2);
this.powerHandler.configurePowerPerdition(0, 0);
}
@Override
public TileEntity[] getAdjacentConnections()
{
if (this.adjacentConnections == null)
{
this.adjacentConnections = new TileEntity[6];
for (byte i = 0; i < 6; i++)
{
ForgeDirection side = ForgeDirection.getOrientation(i);
TileEntity tileEntity = VectorHelper.getTileEntityFromSide(this.worldObj, new Vector3(this), side);
if (tileEntity instanceof IConnector)
{
if (((IConnector) tileEntity).canConnect(side.getOpposite()))
{
this.adjacentConnections[i] = tileEntity;
}
}
else if (Compatibility.isIndustrialCraft2Loaded() && tileEntity instanceof IEnergyTile)
{
if (tileEntity instanceof IEnergyAcceptor)
{
if (((IEnergyAcceptor) tileEntity).acceptsEnergyFrom(this, side.getOpposite()))
{
this.adjacentConnections[i] = tileEntity;
continue;
}
}
if (tileEntity instanceof IEnergyEmitter)
{
if (((IEnergyEmitter) tileEntity).emitsEnergyTo(tileEntity, side.getOpposite()))
{
this.adjacentConnections[i] = tileEntity;
continue;
}
}
this.adjacentConnections[i] = tileEntity;
}
else if (Compatibility.isBuildcraftLoaded() && tileEntity instanceof IPowerReceptor)
{
if (((IPowerReceptor) tileEntity).getPowerReceiver(side.getOpposite()) != null)
{
this.adjacentConnections[i] = tileEntity;
}
}
}
}
return this.adjacentConnections;
}
/*
* @Override public boolean canUpdate() { return !this.isAddedToEnergyNet; }
*/
@Override
public void updateEntity()
{
if (!this.worldObj.isRemote)
{
if (!this.isAddedToEnergyNet)
{
this.initIC();
}
}
}
@Override
public void invalidate()
{
this.unloadTileIC2();
super.invalidate();
}
@Override
public void onChunkUnload()
{
this.unloadTileIC2();
super.onChunkUnload();
}
protected void initIC()
{
if (Compatibility.isIndustrialCraft2Loaded())
{
MinecraftForge.EVENT_BUS.post(new EnergyTileLoadEvent(this));
}
this.isAddedToEnergyNet = true;
}
private void unloadTileIC2()
{
if (this.isAddedToEnergyNet && this.worldObj != null)
{
if (Compatibility.isIndustrialCraft2Loaded())
{
MinecraftForge.EVENT_BUS.post(new EnergyTileUnloadEvent(this));
}
this.isAddedToEnergyNet = false;
}
}
@Override
public double demandedEnergyUnits()
{
if (this.getNetwork() == null)
{
return 0.0;
}
return this.getNetwork().getRequest(this).getWatts() * Compatibility.TO_IC2_RATIO;
}
@Override
public double injectEnergyUnits(ForgeDirection directionFrom, double amount)
{
TileEntity tile = VectorHelper.getTileEntityFromSide(this.worldObj, new Vector3(this), directionFrom);
ElectricityPack pack = ElectricityPack.getFromWatts((float) (amount * Compatibility.IC2_RATIO), 120);
return this.getNetwork().produce(pack, this, tile) * Compatibility.TO_IC2_RATIO;
}
@Override
public int getMaxSafeInput()
{
return Integer.MAX_VALUE;
}
@Override
public boolean acceptsEnergyFrom(TileEntity emitter, ForgeDirection direction)
{
return true;
}
/**
* BuildCraft functions
*/
@Override
public PowerReceiver getPowerReceiver(ForgeDirection side)
{
return this.powerHandler.getPowerReceiver();
}
@Override
public void doWork(PowerHandler workProvider)
{
Set<TileEntity> ignoreTiles = new HashSet<TileEntity>();
ignoreTiles.add(this);
for (ForgeDirection direction : ForgeDirection.VALID_DIRECTIONS)
{
TileEntity tile = new Vector3(this).modifyPositionFromSide(direction).getTileEntity(this.worldObj);
ignoreTiles.add(tile);
}
ElectricityPack pack = ElectricityPack.getFromWatts(workProvider.useEnergy(0, this.getNetwork().getRequest(this).getWatts() * Compatibility.TO_BC_RATIO, true) * Compatibility.BC3_RATIO, 120);
this.getNetwork().produce(pack, ignoreTiles.toArray(new TileEntity[0]));
}
@Override
public World getWorld()
{
return this.getWorldObj();
}
}

317
APIs/universalelectricity/compatibility/TileEntityUniversalElectrical.java
View file

@ -1,317 +0,0 @@
package universalelectricity.compatibility;
import ic2.api.energy.event.EnergyTileLoadEvent;
import ic2.api.energy.event.EnergyTileUnloadEvent;
import ic2.api.energy.tile.IEnergySink;
import ic2.api.energy.tile.IEnergySource;
import ic2.api.energy.tile.IEnergyTile;
import ic2.api.item.IElectricItemManager;
import ic2.api.item.ISpecialElectricItem;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
import net.minecraftforge.common.ForgeDirection;
import net.minecraftforge.common.MinecraftForge;
import thermalexpansion.api.item.IChargeableItem;
import universalelectricity.core.electricity.ElectricityPack;
import universalelectricity.core.item.IItemElectric;
import universalelectricity.core.vector.Vector3;
import universalelectricity.prefab.tile.TileEntityElectrical;
import buildcraft.api.power.IPowerReceptor;
import buildcraft.api.power.PowerHandler;
import buildcraft.api.power.PowerHandler.PowerReceiver;
import buildcraft.api.power.PowerHandler.Type;
/**
* A universal electricity tile used for tiles that consume or produce electricity.
*
* Extend this class or use as a reference for your own implementation of compatible electrical
* tiles.
*
* @author micdoodle8, Calclavia
*
*/
public abstract class TileEntityUniversalElectrical extends TileEntityElectrical implements IEnergySink, IEnergySource, IPowerReceptor
{
protected boolean isAddedToEnergyNet;
public PowerHandler bcPowerHandler;
public Type bcBlockType = Type.MACHINE;
public float maxInputEnergy = 100;
/**
* Recharges electric item.
*/
@Override
public void recharge(ItemStack itemStack)
{
if (itemStack != null)
{
if (itemStack.getItem() instanceof IItemElectric)
{
super.recharge(itemStack);
}
else if (itemStack.getItem() instanceof ISpecialElectricItem)
{
ISpecialElectricItem electricItem = (ISpecialElectricItem) itemStack.getItem();
IElectricItemManager manager = electricItem.getManager(itemStack);
float energy = Math.max(this.getProvide(ForgeDirection.UNKNOWN) * Compatibility.IC2_RATIO, 0);
energy = manager.charge(itemStack, (int) (energy * Compatibility.TO_IC2_RATIO), 0, false, false) * Compatibility.IC2_RATIO;
this.provideElectricity(energy, true);
}
else if (itemStack.getItem() instanceof IChargeableItem)
{
float accepted = ((IChargeableItem) itemStack.getItem()).receiveEnergy(itemStack, this.getProvide(ForgeDirection.UNKNOWN) * Compatibility.BC3_RATIO, true);
this.provideElectricity(accepted, true);
}
}
}
/**
* Discharges electric item.
*/
@Override
public void discharge(ItemStack itemStack)
{
if (itemStack != null)
{
if (itemStack.getItem() instanceof IItemElectric)
{
super.discharge(itemStack);
}
else if (itemStack.getItem() instanceof ISpecialElectricItem)
{
ISpecialElectricItem electricItem = (ISpecialElectricItem) itemStack.getItem();
if (electricItem.canProvideEnergy(itemStack))
{
IElectricItemManager manager = electricItem.getManager(itemStack);
float energy = Math.max(this.getRequest(ForgeDirection.UNKNOWN) * Compatibility.IC2_RATIO, 0);
energy = manager.discharge(itemStack, (int) (energy * Compatibility.TO_IC2_RATIO), 0, false, false);
this.receiveElectricity(energy, true);
}
}
else if (itemStack.getItem() instanceof IChargeableItem)
{
float given = ((IChargeableItem) itemStack.getItem()).transferEnergy(itemStack, this.getRequest(ForgeDirection.UNKNOWN) * Compatibility.BC3_RATIO, true);
this.receiveElectricity(given, true);
}
}
}
@Override
public void initiate()
{
super.initiate();
this.initBuildCraft();
}
@Override
public void updateEntity()
{
super.updateEntity();
// Register to the IC2 Network
if (!this.worldObj.isRemote)
{
if (!this.isAddedToEnergyNet)
{
this.initIC();
}
if (this.bcPowerHandler == null)
{
this.initBuildCraft();
}
if (Compatibility.isBuildcraftLoaded())
{
if (this.bcPowerHandler.getEnergyStored() > 0)
{
/**
* Cheat BuildCraft powerHandler and always empty energy inside of it.
*/
this.receiveElectricity(this.bcPowerHandler.getEnergyStored() * Compatibility.BC3_RATIO, true);
this.bcPowerHandler.setEnergy(0);
}
}
}
}
@Override
public void produce()
{
if (!this.worldObj.isRemote)
{
for (ForgeDirection outputDirection : this.getOutputDirections())
{
if (outputDirection != ForgeDirection.UNKNOWN)
{
if (!this.produceUE(outputDirection))
{
this.produceBuildCraft(outputDirection);
}
}
}
}
}
public boolean produceBuildCraft(ForgeDirection outputDirection)
{
if (!this.worldObj.isRemote && outputDirection != null && outputDirection != ForgeDirection.UNKNOWN)
{
float provide = this.getProvide(outputDirection);
if (this.getEnergyStored() >= provide && provide > 0)
{
if (Compatibility.isBuildcraftLoaded())
{
TileEntity tileEntity = new Vector3(this).modifyPositionFromSide(outputDirection).getTileEntity(this.worldObj);
if (tileEntity instanceof IPowerReceptor)
{
PowerReceiver receiver = ((IPowerReceptor) tileEntity).getPowerReceiver(outputDirection.getOpposite());
if (receiver != null)
{
if (receiver.powerRequest() > 0)
{
float bc3Provide = provide * Compatibility.TO_BC_RATIO;
float energyUsed = Math.min(receiver.receiveEnergy(this.bcBlockType, bc3Provide, outputDirection.getOpposite()), bc3Provide);
this.provideElectricity(energyUsed * Compatibility.TO_BC_RATIO, true);
}
}
return true;
}
}
}
}
return false;
}
/**
* IC2 Methods
*/
@Override
public boolean acceptsEnergyFrom(TileEntity emitter, ForgeDirection direction)
{
return this.getInputDirections().contains(direction);
}
@Override
public double getOfferedEnergy()
{
return this.getProvide(ForgeDirection.UNKNOWN) * Compatibility.TO_IC2_RATIO;
}
@Override
public void drawEnergy(double amount)
{
this.provideElectricity((float) amount * Compatibility.IC2_RATIO, true);
}
@Override
public void invalidate()
{
this.unloadTileIC2();
super.invalidate();
}
@Override
public void onChunkUnload()
{
this.unloadTileIC2();
super.onChunkUnload();
}
protected void initIC()
{
if (Compatibility.isIndustrialCraft2Loaded())
{
MinecraftForge.EVENT_BUS.post(new EnergyTileLoadEvent(this));
}
this.isAddedToEnergyNet = true;
}
private void unloadTileIC2()
{
if (this.isAddedToEnergyNet && this.worldObj != null)
{
if (Compatibility.isIndustrialCraft2Loaded())
{
MinecraftForge.EVENT_BUS.post(new EnergyTileUnloadEvent(this));
}
this.isAddedToEnergyNet = false;
}
}
@Override
public double demandedEnergyUnits()
{
return Math.ceil(this.getRequest(ForgeDirection.UNKNOWN) * Compatibility.TO_IC2_RATIO);
}
@Override
public double injectEnergyUnits(ForgeDirection direction, double amount)
{
if (this.getInputDirections().contains(direction))
{
float convertedEnergy = (float) (amount * Compatibility.IC2_RATIO);
ElectricityPack toSend = ElectricityPack.getFromWatts(convertedEnergy, this.getVoltage());
float receive = this.receiveElectricity(direction, toSend, true);
// Return the difference, since injectEnergy returns left over energy, and
// receiveElectricity returns energy used.
return Math.round(amount - (receive * Compatibility.TO_IC2_RATIO));
}
return amount;
}
@Override
public boolean emitsEnergyTo(TileEntity receiver, ForgeDirection direction)
{
return receiver instanceof IEnergyTile && this.getOutputDirections().contains(direction);
}
@Override
public int getMaxSafeInput()
{
return Integer.MAX_VALUE;
}
/**
* BuildCraft power support
*/
public void initBuildCraft()
{
if (this.bcPowerHandler == null)
{
this.bcPowerHandler = new PowerHandler(this, this.bcBlockType);
}
this.bcPowerHandler.configure(0, this.maxInputEnergy, 0, (int) Math.ceil(this.getMaxEnergyStored() * Compatibility.BC3_RATIO));
}
@Override
public PowerReceiver getPowerReceiver(ForgeDirection side)
{
this.initBuildCraft();
return this.bcPowerHandler.getPowerReceiver();
}
@Override
public void doWork(PowerHandler workProvider)
{
}
@Override
public World getWorld()
{
return this.getWorldObj();
}
}

434
APIs/universalelectricity/compatibility/UniversalNetwork.java
View file

@ -1,434 +0,0 @@
package universalelectricity.compatibility;
import ic2.api.energy.tile.IEnergyAcceptor;
import ic2.api.energy.tile.IEnergySink;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.common.ForgeDirection;
import net.minecraftforge.common.MinecraftForge;
import universalelectricity.core.block.IConductor;
import universalelectricity.core.block.IElectrical;
import universalelectricity.core.block.INetworkConnection;
import universalelectricity.core.block.INetworkProvider;
import universalelectricity.core.electricity.ElectricalEvent.ElectricityProductionEvent;
import universalelectricity.core.electricity.ElectricalEvent.ElectricityRequestEvent;
import universalelectricity.core.electricity.ElectricityPack;
import universalelectricity.core.grid.ElectricityNetwork;
import universalelectricity.core.grid.IElectricityNetwork;
import universalelectricity.core.path.Pathfinder;
import universalelectricity.core.path.PathfinderChecker;
import universalelectricity.core.vector.Vector3;
import universalelectricity.core.vector.VectorHelper;
import buildcraft.api.power.IPowerReceptor;
import buildcraft.api.power.PowerHandler.PowerReceiver;
import buildcraft.api.power.PowerHandler.Type;
import cpw.mods.fml.common.FMLLog;
/**
* A universal network that words with multiple energy systems.
*
* @author micdoodle8, Calclavia, Aidancbrady
*
*/
public class UniversalNetwork extends ElectricityNetwork
{
@Override
public float produce(ElectricityPack electricity, TileEntity... ignoreTiles)
{
ElectricityProductionEvent evt = new ElectricityProductionEvent(this, electricity, ignoreTiles);
MinecraftForge.EVENT_BUS.post(evt);
float totalEnergy = electricity.getWatts();
float networkResistance = getTotalResistance();
float proportionWasted = getTotalResistance() / (getTotalResistance() + acceptorResistance);
float energyWasted = totalEnergy * proportionWasted;
float totalUsableEnergy = totalEnergy - energyWasted;
float remainingUsableEnergy = totalUsableEnergy;
float voltage = electricity.voltage;
if (!evt.isCanceled())
{
Set<TileEntity> avaliableEnergyTiles = this.getAcceptors();
if (!avaliableEnergyTiles.isEmpty())
{
final float totalEnergyRequest = this.getRequest(ignoreTiles).getWatts();
if (totalEnergyRequest > 0)
{
boolean markRefresh = false;
for (TileEntity tileEntity : avaliableEnergyTiles)
{
if (tileEntity != null && !tileEntity.isInvalid())
{
if (remainingUsableEnergy > 0 && !Arrays.asList(ignoreTiles).contains(tileEntity))
{
if (tileEntity instanceof IElectrical)
{
IElectrical electricalTile = (IElectrical) tileEntity;
for (ForgeDirection direction : ForgeDirection.VALID_DIRECTIONS)
{
if (electricalTile.canConnect(direction) && this.getConductors().contains(VectorHelper.getConnectorFromSide(tileEntity.worldObj, new Vector3(tileEntity), direction)))
{
float energyToSend = totalUsableEnergy * (Math.min(electricalTile.getRequest(direction), totalEnergyRequest) / totalEnergyRequest);
if (energyToSend > 0)
{
ElectricityPack electricityToSend = ElectricityPack.getFromWatts(energyToSend, voltage);
remainingUsableEnergy -= electricalTile.receiveElectricity(direction, electricityToSend, true);
}
}
}
}
else if (Compatibility.isIndustrialCraft2Loaded() && tileEntity instanceof IEnergySink)
{
IEnergySink electricalTile = (IEnergySink) tileEntity;
for (ForgeDirection direction : ForgeDirection.VALID_DIRECTIONS)
{
TileEntity conductor = VectorHelper.getConnectorFromSide(tileEntity.worldObj, new Vector3(tileEntity), direction);
if (this.getConductors().contains(conductor) && electricalTile.acceptsEnergyFrom(conductor, direction))
{
float energyToSend = (float) Math.min(totalUsableEnergy * ((electricalTile.demandedEnergyUnits() * Compatibility.IC2_RATIO) / totalEnergyRequest), electricalTile.getMaxSafeInput() * Compatibility.IC2_RATIO);
if (energyToSend > 0)
{
remainingUsableEnergy -= electricalTile.injectEnergyUnits(direction, energyToSend * Compatibility.TO_IC2_RATIO);
}
}
}
}
else if (Compatibility.isBuildcraftLoaded() && tileEntity instanceof IPowerReceptor)
{
IPowerReceptor electricalTile = (IPowerReceptor) tileEntity;
for (ForgeDirection direction : ForgeDirection.VALID_DIRECTIONS)
{
TileEntity conductor = VectorHelper.getConnectorFromSide(tileEntity.worldObj, new Vector3(tileEntity), direction);
PowerReceiver receiver = electricalTile.getPowerReceiver(direction);
if (receiver != null)
{
if (this.getConductors().contains(conductor))
{
float energyToSend = totalUsableEnergy * ((receiver.powerRequest() * Compatibility.TO_BC_RATIO) / totalEnergyRequest);
if (energyToSend > 0)
{
remainingUsableEnergy -= receiver.receiveEnergy(Type.PIPE, energyToSend * Compatibility.TO_BC_RATIO, direction);
}
}
}
}
}
}
}
else
{
markRefresh = true;
}
}
if(markRefresh)
{
this.refresh();
}
}
}
}
return remainingUsableEnergy;
}
@Override
public ElectricityPack getRequest(TileEntity... ignoreTiles)
{
List<ElectricityPack> requests = new ArrayList<ElectricityPack>();
Iterator<TileEntity> it = this.getAcceptors().iterator();
while (it.hasNext())
{
TileEntity tileEntity = it.next();
if (Arrays.asList(ignoreTiles).contains(tileEntity))
{
continue;
}
if (tileEntity != null && !tileEntity.isInvalid())
{
if (tileEntity.worldObj.getBlockTileEntity(tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord) == tileEntity)
{
if (tileEntity instanceof IElectrical)
{
for (ForgeDirection direction : ForgeDirection.VALID_DIRECTIONS)
{
if (((IElectrical) tileEntity).canConnect(direction) && this.getConductors().contains(VectorHelper.getConnectorFromSide(tileEntity.worldObj, new Vector3(tileEntity), direction)))
{
requests.add(ElectricityPack.getFromWatts(((IElectrical) tileEntity).getRequest(direction), ((IElectrical) tileEntity).getVoltage()));
}
}
continue;
}
if (Compatibility.isIndustrialCraft2Loaded() && tileEntity instanceof IEnergySink)
{
for (ForgeDirection direction : ForgeDirection.VALID_DIRECTIONS)
{
if (((IEnergySink) tileEntity).acceptsEnergyFrom(VectorHelper.getTileEntityFromSide(tileEntity.worldObj, new Vector3(tileEntity), direction), direction) && this.getConductors().contains(VectorHelper.getConnectorFromSide(tileEntity.worldObj, new Vector3(tileEntity), direction)))
{
ElectricityPack pack = ElectricityPack.getFromWatts((float) (Math.min(((IEnergySink) tileEntity).demandedEnergyUnits(), ((IEnergySink) tileEntity).getMaxSafeInput()) * Compatibility.IC2_RATIO), 1);
if (pack.getWatts() > 0)
{
requests.add(pack);
}
}
}
continue;
}
if (Compatibility.isBuildcraftLoaded() && tileEntity instanceof IPowerReceptor)
{
for (ForgeDirection direction : ForgeDirection.VALID_DIRECTIONS)
{
if (((IPowerReceptor) tileEntity).getPowerReceiver(direction) != null)
{
ElectricityPack pack = ElectricityPack.getFromWatts(((IPowerReceptor) tileEntity).getPowerReceiver(direction).powerRequest() * Compatibility.BC3_RATIO, 1);
if (pack.getWatts() > 0)
{
requests.add(pack);
break;
}
}
}
continue;
}
}
}
}
ElectricityPack mergedPack = ElectricityPack.merge(requests);
ElectricityRequestEvent evt = new ElectricityRequestEvent(this, mergedPack, ignoreTiles);
MinecraftForge.EVENT_BUS.post(evt);
return mergedPack;
}
@Override
public void refresh()
{
this.electricalTiles.clear();
try
{
Iterator<IConductor> it = this.getConductors().iterator();
while (it.hasNext())
{
IConductor conductor = it.next();
if (conductor == null)
{
it.remove();
}
else if (((TileEntity) conductor).isInvalid())
{
it.remove();
}
else
{
conductor.setNetwork(this);
}
for (int i = 0; i < conductor.getAdjacentConnections().length; i++)
{
TileEntity acceptor = conductor.getAdjacentConnections()[i];
if (!(acceptor instanceof IConductor))
{
if (acceptor instanceof IElectrical)
{
ArrayList<ForgeDirection> possibleDirections = null;
if (this.electricalTiles.containsKey(acceptor))
{
possibleDirections = this.electricalTiles.get(acceptor);
}
else
{
possibleDirections = new ArrayList<ForgeDirection>();
}
if (((IElectrical) acceptor).canConnect(ForgeDirection.getOrientation(i)) && this.getConductors().contains(VectorHelper.getConnectorFromSide(acceptor.worldObj, new Vector3(acceptor), ForgeDirection.getOrientation(i))))
{
possibleDirections.add(ForgeDirection.getOrientation(i));
}
this.electricalTiles.put(acceptor, possibleDirections);
continue;
}
if (Compatibility.isIndustrialCraft2Loaded() && acceptor instanceof IEnergyAcceptor)
{
ArrayList<ForgeDirection> possibleDirections = null;
if (this.electricalTiles.containsKey(acceptor))
{
possibleDirections = this.electricalTiles.get(acceptor);
}
else
{
possibleDirections = new ArrayList<ForgeDirection>();
}
if (((IEnergyAcceptor) acceptor).acceptsEnergyFrom(VectorHelper.getTileEntityFromSide(acceptor.worldObj, new Vector3(acceptor), ForgeDirection.getOrientation(i)), ForgeDirection.getOrientation(i)) && this.getConductors().contains(VectorHelper.getConnectorFromSide(acceptor.worldObj, new Vector3(acceptor), ForgeDirection.getOrientation(i))))
{
possibleDirections.add(ForgeDirection.getOrientation(i));
}
this.electricalTiles.put(acceptor, possibleDirections);
continue;
}
if (Compatibility.isBuildcraftLoaded() && acceptor instanceof IPowerReceptor)
{
ArrayList<ForgeDirection> possibleDirections = null;
if (this.electricalTiles.containsKey(acceptor))
{
possibleDirections = this.electricalTiles.get(acceptor);
}
else
{
possibleDirections = new ArrayList<ForgeDirection>();
}
if (this.getConductors().contains(VectorHelper.getConnectorFromSide(acceptor.worldObj, new Vector3(acceptor), ForgeDirection.getOrientation(i))))
{
possibleDirections.add(ForgeDirection.getOrientation(i));
}
this.electricalTiles.put(acceptor, possibleDirections);
continue;
}
}
}
}
}
catch (Exception e)
{
FMLLog.severe("Universal Electricity: Failed to refresh conductor.");
e.printStackTrace();
}
}
@Override
public void merge(IElectricityNetwork network)
{
if (network != null && network != this)
{
UniversalNetwork newNetwork = new UniversalNetwork();
newNetwork.getConductors().addAll(this.getConductors());
newNetwork.getConductors().addAll(network.getConductors());
newNetwork.refresh();
}
}
@Override
public void split(IConductor splitPoint)
{
if (splitPoint instanceof TileEntity)
{
this.getConductors().remove(splitPoint);
/**
* Loop through the connected blocks and attempt to see if there are connections between
* the two points elsewhere.
*/
TileEntity[] connectedBlocks = splitPoint.getAdjacentConnections();
for (int i = 0; i < connectedBlocks.length; i++)
{
TileEntity connectedBlockA = connectedBlocks[i];
if (connectedBlockA instanceof INetworkConnection)
{
for (int ii = 0; ii < connectedBlocks.length; ii++)
{
final TileEntity connectedBlockB = connectedBlocks[ii];
if (connectedBlockA != connectedBlockB && connectedBlockB instanceof INetworkConnection)
{
Pathfinder finder = new PathfinderChecker(((TileEntity) splitPoint).worldObj, (INetworkConnection) connectedBlockB, splitPoint);
finder.init(new Vector3(connectedBlockA));
if (finder.results.size() > 0)
{
/**
* The connections A and B are still intact elsewhere. Set all
* references of wire connection into one network.
*/
for (Vector3 node : finder.closedSet)
{
TileEntity nodeTile = node.getTileEntity(((TileEntity) splitPoint).worldObj);
if (nodeTile instanceof INetworkProvider)
{
if (nodeTile != splitPoint)
{
((INetworkProvider) nodeTile).setNetwork(this);
}
}
}
}
else
{
/**
* The connections A and B are not connected anymore. Give both of
* them a new network.
*/
IElectricityNetwork newNetwork = new UniversalNetwork();
for (Vector3 node : finder.closedSet)
{
TileEntity nodeTile = node.getTileEntity(((TileEntity) splitPoint).worldObj);
if (nodeTile instanceof INetworkProvider)
{
if (nodeTile != splitPoint)
{
newNetwork.getConductors().add((IConductor) nodeTile);
}
}
}
newNetwork.refresh();
}
}
}
}
}
}
}
@Override
public String toString()
{
return "UniversalNetwork[" + this.hashCode() + "|Wires:" + this.getConductors().size() + "|Acceptors:" + this.electricalTiles.size() + "]";
}
}

86
APIs/universalelectricity/core/UniversalElectricity.java
View file

@ -1,86 +0,0 @@
package universalelectricity.core;
import java.io.File;
import net.minecraft.block.material.MapColor;
import net.minecraft.block.material.Material;
import net.minecraftforge.common.Configuration;
import net.minecraftforge.common.MinecraftForge;
import cpw.mods.fml.common.Loader;
/**
* General Universal Electricity class.
*
* @author Calclavia
*
*/
public class UniversalElectricity
{
/**
* The version of the Universal Electricity API.
*/
public static final String MAJOR_VERSION = "@MAJOR@";
public static final String MINOR_VERSION = "@MINOR@";
public static final String REVISION_VERSION = "@REVIS@";
public static final String BUILD_VERSION = "@BUILD@";
public static final String VERSION = MAJOR_VERSION + "." + MINOR_VERSION + "." + REVISION_VERSION;
/**
* The Universal Electricity configuration file.
*/
public static final Configuration CONFIGURATION = new Configuration(new File(Loader.instance().getConfigDir(), "UniversalElectricity.cfg"));
/**
* Is Universal Electricity currently being voltage sensitive? If so, all machines should
* explode under high voltage and react to different amounts of voltage differently.
*/
public static boolean isVoltageSensitive = false;
//TODO: Enable this next major MC version
//public static float DEFAULT_VOLTAGE = 1;
/**
* Set this value to true if your mod contains and has the ability to transfer electricity via
* the ElectricityNetwork. Examples would be a mod that adds any sort of wire. This value will
* be true as long as there is a way to conduct electricity.
*/
@Deprecated
public static boolean isNetworkActive = false;
/**
* A general material that can be used by machines. Breakable by hand, suitable for machines.
*/
public static final Material machine = new Material(MapColor.ironColor);
private static boolean INIT = false;
static
{
initiate();
}
public static void initiate()
{
if (!INIT)
{
/**
* Loads the configuration and sets all the values.
*/
CONFIGURATION.load();
isVoltageSensitive = CONFIGURATION.get("Compatiblity", "Is Voltage Sensitive", isVoltageSensitive).getBoolean(isVoltageSensitive);
isNetworkActive = CONFIGURATION.get("Compatiblity", "Is Network Active", isNetworkActive).getBoolean(isNetworkActive);
CONFIGURATION.save();
try
{
MinecraftForge.EVENT_BUS.register(Class.forName("universalelectricity.core.electricity.ElectricityHelper").newInstance());
}
catch (Exception e)
{
e.printStackTrace();
}
}
INIT = true;
}
}

17
APIs/universalelectricity/core/block/IConductor.java
View file

@ -1,17 +0,0 @@
package universalelectricity.core.block;
public interface IConductor extends INetworkProvider, INetworkConnection
{
/**
* Gets the resistance of the conductor. Used to calculate energy loss. A higher resistance
* means a higher energy loss.
*
* @return The amount of resistance in Ohms.
*/
public float getResistance();
/**
* @return The maximum amount of amps this conductor can handle before melting down.
*/
public float getCurrentCapacity();
}

18
APIs/universalelectricity/core/block/IConnector.java
View file

@ -1,18 +0,0 @@
package universalelectricity.core.block;
import net.minecraftforge.common.ForgeDirection;
/**
* Applied to TileEntities that can connect to an electrical network.
*
* @author Calclavia
*
*/
public interface IConnector
{
/**
* @return If the connection is possible.
*/
public boolean canConnect(ForgeDirection direction);
}

53
APIs/universalelectricity/core/block/IElectrical.java
View file

@ -1,53 +0,0 @@
package universalelectricity.core.block;
import net.minecraftforge.common.ForgeDirection;
import universalelectricity.core.electricity.ElectricityPack;
/**
* Applied to all TileEntities that can interact with electricity.
*
* @author Calclavia, King_Lemming
*
*/
public interface IElectrical extends IConnector
{
/**
* Adds electricity to an block. Returns the quantity of electricity that was accepted. This
* should always return 0 if the block cannot be externally charged.
*
* @param from Orientation the electricity is sent in from.
* @param receive Maximum amount of electricity to be sent into the block.
* @param doReceive If false, the charge will only be simulated.
* @return Amount of energy that was accepted by the block.
*/
public float receiveElectricity(ForgeDirection from, ElectricityPack receive, boolean doReceive);
/**
* Adds electricity to an block. Returns the ElectricityPack, the electricity provided. This
* should always return null if the block cannot be externally discharged.
*
* @param from Orientation the electricity is requested from.
* @param energy Maximum amount of energy to be sent into the block.
* @param doReceive If false, the charge will only be simulated.
* @return Amount of energy that was given out by the block.
*/
public ElectricityPack provideElectricity(ForgeDirection from, ElectricityPack request, boolean doProvide);
/**
* @return How much energy does this TileEntity want?
*/
public float getRequest(ForgeDirection direction);
/**
* @return How much energy does this TileEntity want to provide?
*/
public float getProvide(ForgeDirection direction);
/**
* Gets the voltage of this TileEntity.
*
* @return The amount of volts. E.g 120v or 240v
*/
public float getVoltage();
}

24
APIs/universalelectricity/core/block/IElectricalStorage.java
View file

@ -1,24 +0,0 @@
package universalelectricity.core.block;
/**
* This interface is to be applied to all TileEntities which stores electricity within them.
*
* @author Calclavia
*/
public interface IElectricalStorage
{
/**
* Sets the amount of joules this unit has stored.
*/
public void setEnergyStored(float energy);
/**
* * @return Get the amount of energy currently stored in the block.
*/
public float getEnergyStored();
/**
* @return Get the max amount of energy that can be stored in the block.
*/
public float getMaxEnergyStored();
}

26
APIs/universalelectricity/core/block/INetworkConnection.java
View file

@ -1,26 +0,0 @@
package universalelectricity.core.block;
import net.minecraft.tileentity.TileEntity;
/**
* Applied to TileEntities.
*
* @author Calclavia
*
*/
public interface INetworkConnection extends IConnector
{
/**
* Gets a list of all the connected TileEntities that this conductor is connected to. The
* array's length should be always the 6 adjacent wires.
*
* @return
*/
public TileEntity[] getAdjacentConnections();
/**
* Refreshes the conductor
*/
public void refresh();
}

16
APIs/universalelectricity/core/block/INetworkProvider.java
View file

@ -1,16 +0,0 @@
package universalelectricity.core.block;
import universalelectricity.core.grid.IElectricityNetwork;
/**
* Applied to TileEntities that has an instance of an electricity network.
*
* @author Calclavia
*
*/
public interface INetworkProvider
{
public IElectricityNetwork getNetwork();
public void setNetwork(IElectricityNetwork network);
}

68
APIs/universalelectricity/core/electricity/ElectricalEvent.java
View file

@ -1,68 +0,0 @@
package universalelectricity.core.electricity;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
import net.minecraftforge.event.Cancelable;
import net.minecraftforge.event.Event;
import universalelectricity.core.block.IElectrical;
import universalelectricity.core.grid.IElectricityNetwork;
public class ElectricalEvent extends Event
{
/**
* Call this to have your TileEntity produce power into the network.
*
* @author Calclavia
*
*/
@Cancelable
public static class ElectricityProduceEvent extends ElectricalEvent
{
public World world;
public IElectrical tileEntity;
public ElectricityProduceEvent(IElectrical tileEntity)
{
this.tileEntity = tileEntity;
this.world = ((TileEntity) this.tileEntity).worldObj;
}
}
public static class NetworkEvent extends ElectricalEvent
{
public final IElectricityNetwork network;
public ElectricityPack electricityPack;
public TileEntity[] ignoreTiles;
public NetworkEvent(IElectricityNetwork network, ElectricityPack electricityPack, TileEntity... ignoreTiles)
{
this.network = network;
this.electricityPack = electricityPack;
this.ignoreTiles = ignoreTiles;
}
}
/**
* Internal Events. These events are fired when something happens in the network.
*
* @author Calclavia
*
*/
@Cancelable
public static class ElectricityProductionEvent extends NetworkEvent
{
public ElectricityProductionEvent(IElectricityNetwork network, ElectricityPack electricityPack, TileEntity... ignoreTiles)
{
super(network, electricityPack, ignoreTiles);
}
}
public static class ElectricityRequestEvent extends NetworkEvent
{
public ElectricityRequestEvent(IElectricityNetwork network, ElectricityPack electricityPack, TileEntity... ignoreTiles)
{
super(network, electricityPack, ignoreTiles);
}
}
}

199
APIs/universalelectricity/core/electricity/ElectricityDisplay.java
View file

@ -1,199 +0,0 @@
package universalelectricity.core.electricity;
/**
* An easy way to display information on electricity for the client.
*
* @author Calclavia
*/
public class ElectricityDisplay
{
/**
* Universal Electricity's units are in KILOJOULES, KILOWATTS and KILOVOLTS. Try to make your
* energy ratio as close to real life as possible.
*/
public static enum ElectricUnit
{
AMPERE("Amp", "I"), AMP_HOUR("Amp Hour", "Ah"), VOLTAGE("Volt", "V"), WATT("Watt", "W"),
WATT_HOUR("Watt Hour", "Wh"), RESISTANCE("Ohm", "R"), CONDUCTANCE("Siemen", "S"),
JOULES("Joule", "J");
public String name;
public String symbol;
private ElectricUnit(String name, String symbol)
{
this.name = name;
this.symbol = symbol;
}
public String getPlural()
{
return this.name + "s";
}
}
/** Metric system of measurement. */
public static enum MeasurementUnit
{
MICRO("Micro", "u", 0.000001f), MILLI("Milli", "m", 0.001f), BASE("", "", 1),
KILO("Kilo", "k", 1000f), MEGA("Mega", "M", 1000000f), GIGA("Giga", "G", 1000000000f),
TERA("Tera", "T", 1000000000000f), PETA("Peta", "P", 1000000000000000f),
EXA("Exa", "E", 1000000000000000000f), ZETTA("Zetta", "Z", 1000000000000000000000f),
YOTTA("Yotta", "Y", 1000000000000000000000000f);
/** long name for the unit */
public String name;
/** short unit version of the unit */
public String symbol;
/** Point by which a number is consider to be of this unit */
public float value;
private MeasurementUnit(String name, String symbol, float value)
{
this.name = name;
this.symbol = symbol;
this.value = value;
}
public String getName(boolean getShort)
{
if (getShort)
{
return symbol;
}
else
{
return name;
}
}
/** Divides the value by the unit value start */
public double process(double value)
{
return value / this.value;
}
/** Checks if a value is above the unit value start */
public boolean isAbove(float value)
{
return value > this.value;
}
/** Checks if a value is lower than the unit value start */
public boolean isBellow(float value)
{
return value < this.value;
}
}
/** By default, mods should store energy in Kilo-Joules, hence a multiplier of 1/1000. */
public static String getDisplay(float value, ElectricUnit unit, int decimalPlaces, boolean isShort)
{
return getDisplay(value, unit, decimalPlaces, isShort, 1000);
}
/**
* Displays the unit as text. Does handle negative numbers, and will place a negative sign in
* front of the output string showing this. Use string.replace to remove the negative sign if
* unwanted
*/
public static String getDisplay(float value, ElectricUnit unit, int decimalPlaces, boolean isShort, float multiplier)
{
String unitName = unit.name;
String prefix = "";
if (value < 0)
{
value = Math.abs(value);
prefix = "-";
}
value *= multiplier;
if (isShort)
{
unitName = unit.symbol;
}
else if (value > 1)
{
unitName = unit.getPlural();
}
if (value == 0)
{
return value + " " + unitName;
}
else
{
for (int i = 0; i < MeasurementUnit.values().length; i++)
{
MeasurementUnit lowerMeasure = MeasurementUnit.values()[i];
if (lowerMeasure.isBellow(value) && lowerMeasure.ordinal() == 0)
{
return prefix + roundDecimals(lowerMeasure.process(value), decimalPlaces) + " " + lowerMeasure.getName(isShort) + unitName;
}
if (lowerMeasure.ordinal() + 1 >= MeasurementUnit.values().length)
{
return prefix + roundDecimals(lowerMeasure.process(value), decimalPlaces) + " " + lowerMeasure.getName(isShort) + unitName;
}
MeasurementUnit upperMeasure = MeasurementUnit.values()[i + 1];
if ((lowerMeasure.isAbove(value) && upperMeasure.isBellow(value)) || lowerMeasure.value == value)
{
return prefix + roundDecimals(lowerMeasure.process(value), decimalPlaces) + " " + lowerMeasure.getName(isShort) + unitName;
}
}
}
return prefix + roundDecimals(value, decimalPlaces) + " " + unitName;
}
public static String getDisplay(float value, ElectricUnit unit)
{
return getDisplay(value, unit, 2, false);
}
public static String getDisplayShort(float value, ElectricUnit unit)
{
return getDisplay(value, unit, 2, true);
}
public static String getDisplayShort(float value, ElectricUnit unit, int decimalPlaces)
{
return getDisplay(value, unit, decimalPlaces, true);
}
public static String getDisplaySimple(float value, ElectricUnit unit, int decimalPlaces)
{
if (value > 1)
{
if (decimalPlaces < 1)
{
return (int) value + " " + unit.getPlural();
}
return roundDecimals(value, decimalPlaces) + " " + unit.getPlural();
}
if (decimalPlaces < 1)
{
return (int) value + " " + unit.name;
}
return roundDecimals(value, decimalPlaces) + " " + unit.name;
}
/**
* Rounds a number to a specific number place places
*
* @param The number
* @return The rounded number
*/
public static double roundDecimals(double d, int decimalPlaces)
{
int j = (int) (d * Math.pow(10, decimalPlaces));
return j / Math.pow(10, decimalPlaces);
}
public static double roundDecimals(double d)
{
return roundDecimals(d, 2);
}
}

152
APIs/universalelectricity/core/electricity/ElectricityHelper.java
View file

@ -1,152 +0,0 @@
package universalelectricity.core.electricity;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.Set;
import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.common.ForgeDirection;
import universalelectricity.core.block.IConnector;
import universalelectricity.core.block.INetworkProvider;
import universalelectricity.core.grid.IElectricityNetwork;
import universalelectricity.core.vector.Vector3;
/**
* A helper class that provides additional useful functions to interact with the ElectricityNetwork
*
* @author Calclavia
*
*/
public class ElectricityHelper
{
public static EnumSet<ForgeDirection> getDirections(TileEntity tileEntity)
{
EnumSet<ForgeDirection> possibleSides = EnumSet.noneOf(ForgeDirection.class);
if (tileEntity instanceof IConnector)
{
for (int i = 0; i < 6; i++)
{
ForgeDirection direction = ForgeDirection.getOrientation(i);
if (((IConnector) tileEntity).canConnect(direction))
{
possibleSides.add(direction);
}
}
}
return possibleSides;
}
@Deprecated
public static ElectricityPack produceFromMultipleSides(TileEntity tileEntity, ElectricityPack electricityPack)
{
return ElectricityHelper.produceFromMultipleSides(tileEntity, getDirections(tileEntity), electricityPack);
}
/**
* Produces electricity from all specified sides. Use this as a simple helper function.
*
* @param tileEntity - The TileEntity consuming the electricity.
* @param approachDirection - The sides in which you can connect to.
* @param producePack - The amount of electricity to be produced.
* @return What remained in the electricity pack.
*/
@Deprecated
public static ElectricityPack produceFromMultipleSides(TileEntity tileEntity, EnumSet<ForgeDirection> approachingDirection, ElectricityPack producingPack)
{
ElectricityPack remainingElectricity = producingPack.clone();
if (tileEntity != null && approachingDirection != null)
{
final Set<IElectricityNetwork> connectedNetworks = ElectricityHelper.getNetworksFromMultipleSides(tileEntity, approachingDirection);
if (connectedNetworks.size() > 0)
{
/**
* Requests an even amount of electricity from all sides.
*/
float wattsPerSide = (producingPack.getWatts() / connectedNetworks.size());
float voltage = producingPack.voltage;
for (IElectricityNetwork network : connectedNetworks)
{
if (wattsPerSide > 0 && producingPack.getWatts() > 0)
{
float amperes = Math.min(wattsPerSide / voltage, network.getRequest(tileEntity).getWatts() / voltage);
if (amperes > 0)
{
network.produce(new ElectricityPack(amperes, voltage));
remainingElectricity.amperes -= amperes;
}
}
}
}
}
return remainingElectricity;
}
/**
* @param tileEntity - The TileEntity's sides.
* @param approachingDirection - The directions that can be connected.
* @return A list of networks from all specified sides. There will be no repeated
* ElectricityNetworks and it will never return null.
*/
public static Set<IElectricityNetwork> getNetworksFromMultipleSides(TileEntity tileEntity, EnumSet<ForgeDirection> approachingDirection)
{
final Set<IElectricityNetwork> connectedNetworks = new HashSet<IElectricityNetwork>();
for (ForgeDirection side : ForgeDirection.VALID_DIRECTIONS)
{
if (approachingDirection.contains(side))
{
Vector3 position = new Vector3(tileEntity);
position.modifyPositionFromSide(side);
TileEntity outputConductor = position.getTileEntity(tileEntity.worldObj);
IElectricityNetwork electricityNetwork = ElectricityHelper.getNetworkFromTileEntity(outputConductor, side);
if (electricityNetwork != null)
{
connectedNetworks.add(electricityNetwork);
}
}
}
return connectedNetworks;
}
/**
* Tries to find the electricity network based in a tile entity and checks to see if it is a
* conductor. All machines should use this function to search for a connecting conductor around
* it.
*
* @param conductor - The TileEntity conductor
* @param approachDirection - The direction you are approaching this wire from.
* @return The ElectricityNetwork or null if not found.
*/
public static IElectricityNetwork getNetworkFromTileEntity(TileEntity tileEntity, ForgeDirection approachDirection)
{
if (tileEntity != null)
{
if (tileEntity instanceof INetworkProvider)
{
if (tileEntity instanceof IConnector)
{
if (((IConnector) tileEntity).canConnect(approachDirection.getOpposite()))
{
return ((INetworkProvider) tileEntity).getNetwork();
}
}
else
{
return ((INetworkProvider) tileEntity).getNetwork();
}
}
}
return null;
}
}

198
APIs/universalelectricity/core/electricity/ElectricityPack.java
View file

@ -1,198 +0,0 @@
package universalelectricity.core.electricity;
import java.util.List;
/**
* A simple way to store electrical data.
*
* @author Calclavia
*
*/
public class ElectricityPack implements Cloneable
{
public float amperes;
public float voltage;
public ElectricityPack(float amperes, float voltage)
{
this.amperes = amperes;
this.voltage = voltage;
}
public ElectricityPack()
{
this(0, 0);
}
public static ElectricityPack getFromWatts(float watts, float voltage)
{
return new ElectricityPack(watts / voltage, voltage);
}
/**
* Merges multiple ElectricityPacks together to form one with an average voltage.
*/
public static ElectricityPack merge(ElectricityPack... packs)
{
float totalEnergy = 0;
float totalVoltage = 0;
for (ElectricityPack pack : packs)
{
totalEnergy += pack.getWatts();
totalVoltage += pack.voltage;
}
if (totalEnergy <= 0 || totalVoltage <= 0)
{
return new ElectricityPack();
}
return ElectricityPack.getFromWatts(totalEnergy, totalVoltage / packs.length);
}
public static ElectricityPack merge(List<ElectricityPack> providedPacks)
{
return merge(providedPacks.toArray(new ElectricityPack[0]));
}
/**
* @return Returns the ElectricityPack with the largest amount of energy.
*/
public static ElectricityPack max(ElectricityPack... packs)
{
ElectricityPack optimalPack = null;
for (ElectricityPack pack : packs)
{
if (optimalPack == null || (optimalPack != null && pack.getWatts() > optimalPack.getWatts()))
{
optimalPack = pack;
}
}
return optimalPack;
}
/**
* @return Returns the ElectricityPack with the smallest amount of energy.
*/
public static ElectricityPack min(ElectricityPack... packs)
{
ElectricityPack optimalPack = null;
for (ElectricityPack pack : packs)
{
if (optimalPack == null || (optimalPack != null && pack.getWatts() < optimalPack.getWatts()))
{
optimalPack = pack;
}
}
return optimalPack;
}
public float getWatts()
{
return getWatts(amperes, voltage);
}
public float getConductance()
{
return getConductance(amperes, voltage);
}
public float getResistance()
{
return getResistance(amperes, voltage);
}
public static float getJoules(float watts, float seconds)
{
return watts * seconds;
}
public static float getJoules(float amps, float voltage, float seconds)
{
return amps * voltage * seconds;
}
public static float getWattsFromJoules(float joules, float seconds)
{
return joules / seconds;
}
public static float getAmps(float watts, float voltage)
{
return watts / voltage;
}
public static float getAmps(float ampHours)
{
return ampHours * 3600;
}
public static float getAmpsFromWattHours(float wattHours, float voltage)
{
return getWatts(wattHours) / voltage;
}
public static float getWattHoursFromAmpHours(float ampHours, float voltage)
{
return ampHours * voltage;
}
public static float getAmpHours(float amps)
{
return amps / 3600;
}
public static float getWatts(float amps, float voltage)
{
return amps * voltage;
}
public static float getWatts(float wattHours)
{
return wattHours * 3600;
}
public static float getWattHours(float watts)
{
return watts / 3600;
}
public static float getWattHours(float amps, float voltage)
{
return getWattHours(getWatts(amps, voltage));
}
public static float getResistance(float amps, float voltage)
{
return voltage / amps;
}
public static float getConductance(float amps, float voltage)
{
return amps / voltage;
}
@Override
public String toString()
{
return "ElectricityPack [Amps:" + this.amperes + " Volts:" + this.voltage + "]";
}
@Override
public ElectricityPack clone()
{
return new ElectricityPack(this.amperes, this.voltage);
}
public boolean isEqual(ElectricityPack electricityPack)
{
return this.amperes == electricityPack.amperes && this.voltage == electricityPack.voltage;
}
}

64
APIs/universalelectricity/core/electricity/NetworkLoader.java
View file

@ -1,64 +0,0 @@
package universalelectricity.core.electricity;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import universalelectricity.core.block.IConductor;
import universalelectricity.core.grid.IElectricityNetwork;
import cpw.mods.fml.common.FMLLog;
@SuppressWarnings("unchecked")
public class NetworkLoader
{
/**
* The default IElectricityNetwork used for primary electrical networks.
*/
public static Class<? extends IElectricityNetwork> NETWORK_CLASS;
public static final Set<Class<? extends IElectricityNetwork>> NETWORK_CLASS_REGISTRY = new HashSet<Class<? extends IElectricityNetwork>>();
static
{
setNetworkClass("universalelectricity.core.grid.ElectricityNetwork");
}
public static void setNetworkClass(Class<? extends IElectricityNetwork> networkClass)
{
NETWORK_CLASS_REGISTRY.add(networkClass);
NETWORK_CLASS = networkClass;
}
public static void setNetworkClass(String className)
{
try
{
setNetworkClass((Class<? extends IElectricityNetwork>) Class.forName(className));
}
catch (Exception e)
{
FMLLog.severe("Universal Electricity: Failed to set network class with name " + className);
e.printStackTrace();
}
}
public static IElectricityNetwork getNewNetwork(IConductor... conductors)
{
try
{
IElectricityNetwork network = NETWORK_CLASS.newInstance();
network.getConductors().addAll(Arrays.asList(conductors));
return network;
}
catch (InstantiationException e)
{
e.printStackTrace();
}
catch (IllegalAccessException e)
{
e.printStackTrace();
}
return null;
}
}

356
APIs/universalelectricity/core/grid/ElectricityNetwork.java
View file

@ -1,356 +0,0 @@
package universalelectricity.core.grid;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.common.ForgeDirection;
import net.minecraftforge.common.MinecraftForge;
import universalelectricity.core.block.IConductor;
import universalelectricity.core.block.IConnector;
import universalelectricity.core.block.IElectrical;
import universalelectricity.core.block.INetworkConnection;
import universalelectricity.core.block.INetworkProvider;
import universalelectricity.core.electricity.ElectricalEvent.ElectricityProductionEvent;
import universalelectricity.core.electricity.ElectricalEvent.ElectricityRequestEvent;
import universalelectricity.core.electricity.ElectricityPack;
import universalelectricity.core.path.Pathfinder;
import universalelectricity.core.path.PathfinderChecker;
import universalelectricity.core.vector.Vector3;
import universalelectricity.core.vector.VectorHelper;
import cpw.mods.fml.common.FMLLog;
/**
* An Electrical Network specifies a wire connection. Each wire connection line will have its own
* electrical network.
*
* !! Do not include this class if you do not intend to have custom wires in your mod. This will
* increase future compatibility. !!
*
* @author Calclavia
*
*/
public class ElectricityNetwork implements IElectricityNetwork
{
public Map<TileEntity, ArrayList<ForgeDirection>> electricalTiles = new HashMap<TileEntity, ArrayList<ForgeDirection>>();
private final Set<IConductor> conductors = new HashSet<IConductor>();
public float acceptorResistance = 500;
@Override
public float produce(ElectricityPack electricity, TileEntity... ignoreTiles)
{
ElectricityProductionEvent evt = new ElectricityProductionEvent(this, electricity, ignoreTiles);
MinecraftForge.EVENT_BUS.post(evt);
float totalEnergy = electricity.getWatts();
float networkResistance = getTotalResistance();
float proportionWasted = getTotalResistance() / (getTotalResistance() + acceptorResistance);
float energyWasted = totalEnergy * proportionWasted;
float totalUsableEnergy = totalEnergy - energyWasted;
float remainingUsableEnergy = totalUsableEnergy;
float voltage = electricity.voltage;
if (!evt.isCanceled())
{
Set<TileEntity> avaliableEnergyTiles = this.getAcceptors();
if (!avaliableEnergyTiles.isEmpty())
{
final float totalEnergyRequest = this.getRequest(ignoreTiles).getWatts();
if (totalEnergyRequest > 0)
{
for (TileEntity tileEntity : avaliableEnergyTiles)
{
if (!Arrays.asList(ignoreTiles).contains(tileEntity))
{
if (tileEntity instanceof IElectrical)
{
IElectrical electricalTile = (IElectrical) tileEntity;
for (ForgeDirection direction : ForgeDirection.VALID_DIRECTIONS)
{
if (electricalTile.canConnect(direction) && this.getConductors().contains(VectorHelper.getConnectorFromSide(tileEntity.worldObj, new Vector3(tileEntity), direction)))
{
float energyToSend = totalUsableEnergy * (electricalTile.getRequest(direction) / totalEnergyRequest);
if (energyToSend > 0)
{
ElectricityPack electricityToSend = ElectricityPack.getFromWatts(energyToSend, voltage);
remainingUsableEnergy -= ((IElectrical) tileEntity).receiveElectricity(direction, electricityToSend, true);
}
}
}
}
}
}
}
}
}
return remainingUsableEnergy;
}
/**
* @return How much electricity this network needs.
*/
@Override
public ElectricityPack getRequest(TileEntity... ignoreTiles)
{
List<ElectricityPack> requests = new ArrayList<ElectricityPack>();
Iterator<TileEntity> it = this.getAcceptors().iterator();
while (it.hasNext())
{
TileEntity tileEntity = it.next();
if (Arrays.asList(ignoreTiles).contains(tileEntity))
{
continue;
}
if (tileEntity instanceof IElectrical)
{
if (!tileEntity.isInvalid())
{
if (tileEntity.worldObj.getBlockTileEntity(tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord) == tileEntity)
{
for (ForgeDirection direction : ForgeDirection.VALID_DIRECTIONS)
{
if (((IElectrical) tileEntity).canConnect(direction) && this.getConductors().contains(VectorHelper.getConnectorFromSide(tileEntity.worldObj, new Vector3(tileEntity), direction)))
{
requests.add(ElectricityPack.getFromWatts(((IElectrical) tileEntity).getRequest(direction), ((IElectrical) tileEntity).getVoltage()));
continue;
}
}
}
}
}
}
ElectricityPack mergedPack = ElectricityPack.merge(requests);
ElectricityRequestEvent evt = new ElectricityRequestEvent(this, mergedPack, ignoreTiles);
MinecraftForge.EVENT_BUS.post(evt);
return mergedPack;
}
/**
* @return Returns all producers in this electricity network.
*/
@Override
public Set<TileEntity> getAcceptors()
{
return this.electricalTiles.keySet();
}
/**
* @param tile The tile to get connections for
* @return The list of directions that can be connected to for the provided tile
*/
@Override
public ArrayList<ForgeDirection> getPossibleDirections(TileEntity tile)
{
return this.electricalTiles.containsKey(tile) ? this.electricalTiles.get(tile) : null;
}
/**
* This function is called to refresh all conductors in this network
*/
@Override
public void refresh()
{
this.electricalTiles.clear();
try
{
Iterator<IConductor> it = this.conductors.iterator();
while (it.hasNext())
{
IConductor conductor = it.next();
if (conductor == null)
{
it.remove();
}
else if (((TileEntity) conductor).isInvalid())
{
it.remove();
}
else
{
conductor.setNetwork(this);
}
for (int i = 0; i < conductor.getAdjacentConnections().length; i++)
{
TileEntity acceptor = conductor.getAdjacentConnections()[i];
if (!(acceptor instanceof IConductor) && acceptor instanceof IConnector)
{
ArrayList<ForgeDirection> possibleDirections = null;
if (this.electricalTiles.containsKey(acceptor))
{
possibleDirections = this.electricalTiles.get(acceptor);
}
else
{
possibleDirections = new ArrayList<ForgeDirection>();
}
possibleDirections.add(ForgeDirection.getOrientation(i));
this.electricalTiles.put(acceptor, possibleDirections);
}
}
}
}
catch (Exception e)
{
FMLLog.severe("Universal Electricity: Failed to refresh conductor.");
e.printStackTrace();
}
}
@Override
public float getTotalResistance()
{
float resistance = 0;
for (IConductor conductor : this.conductors)
{
resistance += conductor.getResistance();
}
return resistance;
}
@Override
public float getLowestCurrentCapacity()
{
float lowestAmperage = 0;
for (IConductor conductor : this.conductors)
{
if (lowestAmperage == 0 || conductor.getCurrentCapacity() < lowestAmperage)
{
lowestAmperage = conductor.getCurrentCapacity();
}
}
return lowestAmperage;
}
@Override
public Set<IConductor> getConductors()
{
return this.conductors;
}
@Override
public void merge(IElectricityNetwork network)
{
if (network != null && network != this)
{
ElectricityNetwork newNetwork = new ElectricityNetwork();
newNetwork.getConductors().addAll(this.getConductors());
newNetwork.getConductors().addAll(network.getConductors());
newNetwork.refresh();
}
}
@Override
public void split(IConductor splitPoint)
{
if (splitPoint instanceof TileEntity)
{
this.getConductors().remove(splitPoint);
/**
* Loop through the connected blocks and attempt to see if there are connections between
* the two points elsewhere.
*/
TileEntity[] connectedBlocks = splitPoint.getAdjacentConnections();
for (int i = 0; i < connectedBlocks.length; i++)
{
TileEntity connectedBlockA = connectedBlocks[i];
if (connectedBlockA instanceof INetworkConnection)
{
for (int ii = 0; ii < connectedBlocks.length; ii++)
{
final TileEntity connectedBlockB = connectedBlocks[ii];
if (connectedBlockA != connectedBlockB && connectedBlockB instanceof INetworkConnection)
{
Pathfinder finder = new PathfinderChecker(((TileEntity) splitPoint).worldObj, (INetworkConnection) connectedBlockB, splitPoint);
finder.init(new Vector3(connectedBlockA));
if (finder.results.size() > 0)
{
/**
* The connections A and B are still intact elsewhere. Set all
* references of wire connection into one network.
*/
for (Vector3 node : finder.closedSet)
{
TileEntity nodeTile = node.getTileEntity(((TileEntity) splitPoint).worldObj);
if (nodeTile instanceof INetworkProvider)
{
if (nodeTile != splitPoint)
{
((INetworkProvider) nodeTile).setNetwork(this);
}
}
}
}
else
{
/**
* The connections A and B are not connected anymore. Give both of
* them a new network.
*/
IElectricityNetwork newNetwork = new ElectricityNetwork();
for (Vector3 node : finder.closedSet)
{
TileEntity nodeTile = node.getTileEntity(((TileEntity) splitPoint).worldObj);
if (nodeTile instanceof INetworkProvider)
{
if (nodeTile != splitPoint)
{
newNetwork.getConductors().add((IConductor) nodeTile);
}
}
}
newNetwork.refresh();
}
}
}
}
}
}
}
@Override
public String toString()
{
return "ElectricityNetwork[" + this.hashCode() + "|Wires:" + this.conductors.size() + "|Acceptors:" + this.electricalTiles.size() + "]";
}
}

38
APIs/universalelectricity/core/grid/IElectricityNetwork.java
View file

@ -1,38 +0,0 @@
package universalelectricity.core.grid;
import net.minecraft.tileentity.TileEntity;
import universalelectricity.core.block.IConductor;
import universalelectricity.core.electricity.ElectricityPack;
/**
* The Electrical Network in interface form.
*
* @author Calclavia
*
*/
public interface IElectricityNetwork extends IGridNetwork<IElectricityNetwork, IConductor, TileEntity>
{
/**
* Produces electricity in this electrical network.
*
* @return Rejected energy in Joules.
*/
public float produce(ElectricityPack electricityPack, TileEntity... ignoreTiles);
/**
* Gets the total amount of electricity requested/needed in the electricity network.
*
* @param ignoreTiles The TileEntities to ignore during this calculation (optional).
*/
public ElectricityPack getRequest(TileEntity... ignoreTiles);
/**
* @return The total amount of resistance of this electrical network. In Ohms.
*/
public float getTotalResistance();
/**
* @return The lowest amount of current (amperage) that this electrical network can tolerate.
*/
public float getLowestCurrentCapacity();
}

66
APIs/universalelectricity/core/grid/IGridNetwork.java
View file

@ -1,66 +0,0 @@
package universalelectricity.core.grid;
import java.util.ArrayList;
import java.util.Set;
import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.common.ForgeDirection;
/**
* Implement this in your network class/interface if you plan to have your own network defined by
* specific conductors and acceptors.
*
* @author aidancbrady
*
* @param <N> - the class/interface Type value in which you implement this
* @param <C> - the class/interface Type which makes up the network's conductor Set
* @param <A> - the class/interface Type which makes up the network's acceptor Set
*/
public interface IGridNetwork<N, C, A>
{
/**
* Refreshes and cleans up conductor references of this network, as well as updating the
* acceptor set.
*/
public void refresh();
/**
* Gets the Set of conductors that make up this network.
*
* @return conductor set
*/
public Set<C> getConductors();
/**
* Gets the Set of AVAILABLE acceptors in this network. Make sure this doesn't include any stray
* acceptors which cannot accept resources.
*
* @return available acceptor set
*/
public Set<A> getAcceptors();
/**
* Gets the list of possible connection directions for the provided TileEntity. Tile must be in
* this network.
*
* @param tile The tile to get connections for
* @return The list of directions that can be connected to for the provided tile
*/
public ArrayList<ForgeDirection> getPossibleDirections(TileEntity tile);
/**
* Creates a new network that makes up the current network and the network defined in the
* parameters. Be sure to refresh the new network inside this method.
*
* @param network - network to merge
*/
public void merge(N network);
/**
* Splits a network by the conductor referenced in the parameters. It will then create and
* refresh the new independent networks possibly created by this operation.
*
* @param connection
*/
public void split(C connection);
}

92
APIs/universalelectricity/core/item/ElectricItemHelper.java
View file

@ -1,92 +0,0 @@
package universalelectricity.core.item;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
/**
* Some helper functions for electric items.
*
* @author Calclavia
*
*/
public class ElectricItemHelper
{
/**
* Recharges an electric item.
*
* @param joules - The joules being provided to the electric item
* @return The total amount of joules provided by the provider.
*/
public static float chargeItem(ItemStack itemStack, float joules)
{
if (itemStack != null)
{
if (itemStack.getItem() instanceof IItemElectric)
{
return ((IItemElectric) itemStack.getItem()).recharge(itemStack, Math.min(((IItemElectric) itemStack.getItem()).getTransfer(itemStack), joules), true);
}
}
return 0;
}
/**
* Decharges an electric item.
*
* @param joules - The joules being withdrawn from the electric item
* @return The total amount of joules the provider received.
*/
public static float dischargeItem(ItemStack itemStack, float joules)
{
if (itemStack != null)
{
if (itemStack.getItem() instanceof IItemElectric)
{
return ((IItemElectric) itemStack.getItem()).discharge(itemStack, Math.min(((IItemElectric) itemStack.getItem()).getMaxElectricityStored(itemStack), joules), true);
}
}
return 0;
}
/**
* Returns an uncharged version of the electric item. Use this if you want the crafting recipe
* to use a charged version of the electric item instead of an empty version of the electric
* item
*
* @return An electrical ItemStack with a specific charge.
*/
public static ItemStack getWithCharge(ItemStack itemStack, float joules)
{
if (itemStack != null)
{
if (itemStack.getItem() instanceof IItemElectric)
{
((IItemElectric) itemStack.getItem()).setElectricity(itemStack, joules);
return itemStack;
}
}
return itemStack;
}
public static ItemStack getWithCharge(Item item, float joules)
{
return getWithCharge(new ItemStack(item), joules);
}
public static ItemStack getCloneWithCharge(ItemStack itemStack, float joules)
{
return getWithCharge(itemStack.copy(), joules);
}
public static ItemStack getUncharged(ItemStack itemStack)
{
return getWithCharge(itemStack, 0);
}
public static ItemStack getUncharged(Item item)
{
return getUncharged(new ItemStack(item));
}
}

56
APIs/universalelectricity/core/item/IItemElectric.java
View file

@ -1,56 +0,0 @@
package universalelectricity.core.item;
import net.minecraft.item.ItemStack;
public interface IItemElectric
{
/**
* Adds energy to an item. Returns the quantity of energy that was accepted. This should always
* return 0 if the item cannot be externally charged.
*
* @param itemStack ItemStack to be charged.
* @param energy Maximum amount of energy to be sent into the item.
* @param doRecharge If false, the charge will only be simulated.
* @return Amount of energy that was accepted by the item.
*/
public float recharge(ItemStack itemStack, float energy, boolean doRecharge);
/**
* Removes energy from an item. Returns the quantity of energy that was removed. This should
* always return 0 if the item cannot be externally discharged.
*
* @param itemStack ItemStack to be discharged.
* @param energy Maximum amount of energy to be removed from the item.
* @param doDischarge If false, the discharge will only be simulated.
* @return Amount of energy that was removed from the item.
*/
public float discharge(ItemStack itemStack, float energy, boolean doDischarge);
/**
* Get the amount of energy currently stored in the item.
*/
public float getElectricityStored(ItemStack theItem);
/**
* Get the max amount of energy that can be stored in the item.
*/
public float getMaxElectricityStored(ItemStack theItem);
/**
* Sets the amount of energy in the ItemStack.
*
* @param itemStack - the ItemStack.
* @param joules - Amount of electrical energy.
*/
public void setElectricity(ItemStack itemStack, float joules);
/**
* @return the energy request this ItemStack demands.
*/
public float getTransfer(ItemStack itemStack);
/**
* @return The voltage in which this item runs on.
*/
public float getVoltage(ItemStack itemStack);
}

149
APIs/universalelectricity/core/item/ItemElectric.java
View file

@ -1,149 +0,0 @@
package universalelectricity.core.item;
import java.util.List;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTBase;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagDouble;
import net.minecraft.nbt.NBTTagFloat;
import net.minecraft.world.World;
import universalelectricity.core.electricity.ElectricityDisplay;
import universalelectricity.core.electricity.ElectricityDisplay.ElectricUnit;
/** Extend from this class if your item requires electricity or to be charged. Optionally, you can
* implement IItemElectric instead.
*
* @author Calclavia */
public abstract class ItemElectric extends Item implements IItemElectric
{
public ItemElectric(int id)
{
super(id);
this.setMaxStackSize(1);
this.setMaxDamage(100);
this.setNoRepair();
}
@Override
public void addInformation(ItemStack itemStack, EntityPlayer entityPlayer, List list, boolean par4)
{
String color = "";
float joules = this.getElectricityStored(itemStack);
if (joules <= this.getMaxElectricityStored(itemStack) / 3)
{
color = "\u00a74";
}
else if (joules > this.getMaxElectricityStored(itemStack) * 2 / 3)
{
color = "\u00a72";
}
else
{
color = "\u00a76";
}
list.add(color + ElectricityDisplay.getDisplayShort(joules, ElectricUnit.JOULES) + "/" + ElectricityDisplay.getDisplayShort(this.getMaxElectricityStored(itemStack), ElectricUnit.JOULES));
}
/** Makes sure the item is uncharged when it is crafted and not charged. Change this if you do
* not want this to happen! */
@Override
public void onCreated(ItemStack itemStack, World par2World, EntityPlayer par3EntityPlayer)
{
this.setElectricity(itemStack, 0);
}
@Override
public float recharge(ItemStack itemStack, float energy, boolean doReceive)
{
float rejectedElectricity = Math.max((this.getElectricityStored(itemStack) + energy) - this.getMaxElectricityStored(itemStack), 0);
float energyToReceive = energy - rejectedElectricity;
if (doReceive)
{
this.setElectricity(itemStack, this.getElectricityStored(itemStack) + energyToReceive);
}
return energyToReceive;
}
@Override
public float discharge(ItemStack itemStack, float energy, boolean doTransfer)
{
float energyToTransfer = Math.min(this.getElectricityStored(itemStack), energy);
if (doTransfer)
{
this.setElectricity(itemStack, this.getElectricityStored(itemStack) - energyToTransfer);
}
return energyToTransfer;
}
@Override
public float getVoltage(ItemStack itemStack)
{
return 0.120f;
}
@Override
public void setElectricity(ItemStack itemStack, float joules)
{
// Saves the frequency in the ItemStack
if (itemStack.getTagCompound() == null)
{
itemStack.setTagCompound(new NBTTagCompound());
}
float electricityStored = Math.max(Math.min(joules, this.getMaxElectricityStored(itemStack)), 0);
itemStack.getTagCompound().setFloat("electricity", electricityStored);
/** Sets the damage as a percentage to render the bar properly. */
itemStack.setItemDamage((int) (100 - (electricityStored / getMaxElectricityStored(itemStack)) * 100));
}
@Override
public float getTransfer(ItemStack itemStack)
{
return this.getMaxElectricityStored(itemStack) - this.getElectricityStored(itemStack);
}
/** Gets the energy stored in the item. Energy is stored using item NBT */
@Override
public float getElectricityStored(ItemStack itemStack)
{
if (itemStack.getTagCompound() == null)
{
itemStack.setTagCompound(new NBTTagCompound());
}
float energyStored = 0f;
if (itemStack.getTagCompound().hasKey("electricity"))
{
NBTBase obj = itemStack.getTagCompound().getTag("electricity");
if (obj instanceof NBTTagDouble)
{
energyStored = (float) ((NBTTagDouble) obj).data;
}
else if (obj instanceof NBTTagFloat)
{
energyStored = ((NBTTagFloat) obj).data;
}
}
/** Sets the damage as a percentage to render the bar properly. */
itemStack.setItemDamage((int) (100 - (energyStored / getMaxElectricityStored(itemStack)) * 100));
return energyStored;
}
@Override
public void getSubItems(int par1, CreativeTabs par2CreativeTabs, List par3List)
{
par3List.add(ElectricItemHelper.getUncharged(new ItemStack(this)));
par3List.add(ElectricItemHelper.getWithCharge(new ItemStack(this), this.getMaxElectricityStored(new ItemStack(this))));
}
}

25
APIs/universalelectricity/core/path/IPathCallBack.java
View file

@ -1,25 +0,0 @@
package universalelectricity.core.path;
import java.util.Set;
import universalelectricity.core.vector.Vector3;
public interface IPathCallBack
{
/**
* @param finder - The Pathfinder object.
* @param currentNode - The node being iterated through.
* @return A set of nodes connected to the currentNode. Essentially one should return a set of
* neighboring nodes.
*/
public Set<Vector3> getConnectedNodes(Pathfinder finder, Vector3 currentNode);
/**
* Called when looping through nodes.
*
* @param finder - The Pathfinder.
* @param node - The node being searched.
* @return True to stop the path finding operation.
*/
public boolean onSearch(Pathfinder finder, Vector3 node);
}

79
APIs/universalelectricity/core/path/Pathfinder.java
View file

@ -1,79 +0,0 @@
package universalelectricity.core.path;
import java.util.HashSet;
import java.util.Set;
import universalelectricity.core.vector.Vector3;
/**
* A class that allows flexible pathfinding for different positions. Compared to AStar pathfinding,
* this version is faster but does not calculated the most optimal path.
*
* @author Calclavia
*
*/
public class Pathfinder
{
/**
* A pathfinding call back interface used to call back on paths.
*/
public IPathCallBack callBackCheck;
/**
* A list of nodes that the pathfinder already went through.
*/
public Set<Vector3> closedSet;
/**
* The resulted path found by the pathfinder. Could be null if no path was found.
*/
public Set<Vector3> results;
public Pathfinder(IPathCallBack callBack)
{
this.callBackCheck = callBack;
this.reset();
}
/**
* @return True on success finding, false on failure.
*/
public boolean findNodes(Vector3 currentNode)
{
this.closedSet.add(currentNode);
if (this.callBackCheck.onSearch(this, currentNode))
{
return false;
}
for (Vector3 node : this.callBackCheck.getConnectedNodes(this, currentNode))
{
if (!this.closedSet.contains(node))
{
if (this.findNodes(node))
{
return true;
}
}
}
return false;
}
/**
* Called to execute the pathfinding operation.
*/
public Pathfinder init(Vector3 startNode)
{
this.findNodes(startNode);
return this;
}
public Pathfinder reset()
{
this.closedSet = new HashSet<Vector3>();
this.results = new HashSet<Vector3>();
return this;
}
}

175
APIs/universalelectricity/core/path/PathfinderAStar.java
View file

@ -1,175 +0,0 @@
package universalelectricity.core.path;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
import net.minecraftforge.common.ForgeDirection;
import universalelectricity.core.vector.Vector3;
/**
* An advanced version of pathfinding to find the shortest path between two points. Uses the A*
* Pathfinding algorithm.
*
* @author Calclavia
*
*/
public class PathfinderAStar extends Pathfinder
{
/**
* A pathfinding call back interface used to call back on paths.
*/
public IPathCallBack callBackCheck;
/**
* The set of tentative nodes to be evaluated, initially containing the start node
*/
public Set<Vector3> openSet;
/**
* The map of navigated nodes storing the data of which position came from which in the format
* of: X came from Y.
*/
public HashMap<Vector3, Vector3> navigationMap;
/**
* Score values, used to determine the score for a path to evaluate how optimal the path is.
* G-Score is the cost along the best known path while F-Score is the total cost.
*/
public HashMap<Vector3, Double> gScore, fScore;
/**
* The node in which the pathfinder is trying to reach.
*/
public Vector3 goal;
public PathfinderAStar(IPathCallBack callBack, Vector3 goal)
{
super(callBack);
this.goal = goal;
}
@Override
public boolean findNodes(Vector3 start)
{
this.openSet.add(start);
this.gScore.put(start, 0d);
this.fScore.put(start, this.gScore.get(start) + getHeuristicEstimatedCost(start, this.goal));
while (!this.openSet.isEmpty())
{
// Current is the node in openset having the lowest f_score[] value
Vector3 currentNode = null;
double lowestFScore = 0;
for (Vector3 node : this.openSet)
{
if (currentNode == null || this.fScore.get(node) < lowestFScore)
{
currentNode = node;
lowestFScore = this.fScore.get(node);
}
}
if (currentNode == null)
{
break;
}
if (this.callBackCheck.onSearch(this, currentNode))
{
return false;
}
if (currentNode.equals(this.goal))
{
this.results = reconstructPath(this.navigationMap, goal);
return true;
}
this.openSet.remove(currentNode);
this.closedSet.add(currentNode);
for (Vector3 neighbor : getNeighborNodes(currentNode))
{
double tentativeGScore = this.gScore.get(currentNode) + currentNode.distanceTo(neighbor);
if (this.closedSet.contains(neighbor))
{
if (tentativeGScore >= this.gScore.get(neighbor))
{
continue;
}
}
if (!this.openSet.contains(neighbor) || tentativeGScore < this.gScore.get(neighbor))
{
this.navigationMap.put(neighbor, currentNode);
this.gScore.put(neighbor, tentativeGScore);
this.fScore.put(neighbor, gScore.get(neighbor) + getHeuristicEstimatedCost(neighbor, goal));
this.openSet.add(neighbor);
}
}
}
return false;
}
@Override
public Pathfinder reset()
{
this.openSet = new HashSet<Vector3>();
this.navigationMap = new HashMap<Vector3, Vector3>();
return super.reset();
}
/**
* A recursive function to back track and find the path in which we have analyzed.
*/
public Set<Vector3> reconstructPath(HashMap<Vector3, Vector3> nagivationMap, Vector3 current_node)
{
Set<Vector3> path = new HashSet<Vector3>();
path.add(current_node);
if (nagivationMap.containsKey(current_node))
{
path.addAll(reconstructPath(nagivationMap, nagivationMap.get(current_node)));
return path;
}
else
{
return path;
}
}
/**
* @return An estimated cost between two points.
*/
public double getHeuristicEstimatedCost(Vector3 start, Vector3 goal)
{
return start.distanceTo(goal);
}
/**
* @return A Set of neighboring Vector3 positions.
*/
public Set<Vector3> getNeighborNodes(Vector3 vector)
{
if (this.callBackCheck != null)
{
return this.callBackCheck.getConnectedNodes(this, vector);
}
else
{
Set<Vector3> neighbors = new HashSet<Vector3>();
for (int i = 0; i < 6; i++)
{
neighbors.add(vector.clone().modifyPositionFromSide(ForgeDirection.getOrientation(i)));
}
return neighbors;
}
}
}

62
APIs/universalelectricity/core/path/PathfinderChecker.java
View file

@ -1,62 +0,0 @@
package universalelectricity.core.path;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
import net.minecraftforge.common.ForgeDirection;
import universalelectricity.core.block.IConductor;
import universalelectricity.core.block.INetworkConnection;
import universalelectricity.core.vector.Vector3;
/**
* Check if a conductor connects with another.
*
* @author Calclavia
*
*/
public class PathfinderChecker extends Pathfinder
{
public PathfinderChecker(final World world, final INetworkConnection targetConnector, final INetworkConnection... ignoreConnector)
{
super(new IPathCallBack()
{
@Override
public Set<Vector3> getConnectedNodes(Pathfinder finder, Vector3 currentNode)
{
Set<Vector3> neighbors = new HashSet<Vector3>();
for (int i = 0; i < 6; i++)
{
ForgeDirection direction = ForgeDirection.getOrientation(i);
Vector3 position = currentNode.clone().modifyPositionFromSide(direction);
TileEntity connectedBlock = position.getTileEntity(world);
if (connectedBlock instanceof IConductor && !Arrays.asList(ignoreConnector).contains(connectedBlock))
{
if (((IConductor) connectedBlock).canConnect(direction.getOpposite()))
{
neighbors.add(position);
}
}
}
return neighbors;
}
@Override
public boolean onSearch(Pathfinder finder, Vector3 node)
{
if (node.getTileEntity(world) == targetConnector)
{
finder.results.add(node);
return true;
}
return false;
}
});
}
}

213
APIs/universalelectricity/core/vector/Quaternion.java
View file

@ -1,213 +0,0 @@
package universalelectricity.core.vector;
/**
* Quaternion class designed to be used for the rotation of objects.
*
* Do not use in MC 1.6.4, subject to change!
*
* @author DarkGuardsman, Calclavia
*/
public class Quaternion implements Cloneable
{
public static final float TOLERANCE = 0.00001f;
public double x, y, z, w;
public Quaternion()
{
this(0, 0, 0, 1);
}
public Quaternion(Quaternion copy)
{
this(copy.x, copy.y, copy.z, copy.w);
}
public Quaternion(double x, double y, double z, double w)
{
this.x = x;
this.y = y;
this.z = z;
this.w = w;
}
/**
* Convert from Euler Angles. Basically we create 3 Quaternions, one for pitch, one for yaw, one
* for roll and multiply those together. the calculation below does the same, just shorter
*/
public Quaternion(float pitch, float yaw, float roll)
{
float p = (float) (pitch * (Math.PI / 180) / 2.0);
float y = (float) (yaw * (Math.PI / 180) / 2.0);
float r = (float) (roll * (Math.PI / 180) / 2.0);
float sinp = (float) Math.sin(p);
float siny = (float) Math.sin(y);
float sinr = (float) Math.sin(r);
float cosp = (float) Math.cos(p);
float cosy = (float) Math.cos(y);
float cosr = (float) Math.cos(r);
this.x = sinr * cosp * cosy - cosr * sinp * siny;
this.y = cosr * sinp * cosy + sinr * cosp * siny;
this.z = cosr * cosp * siny - sinr * sinp * cosy;
this.w = cosr * cosp * cosy + sinr * sinp * siny;
this.normalize();
}
public Quaternion(Vector3 vector, double w)
{
this(vector.x, vector.y, vector.z, w);
}
public static Quaternion IDENTITY()
{
return new Quaternion();
}
public Quaternion set(Quaternion quaternion)
{
this.w = quaternion.w;
this.x = quaternion.x;
this.y = quaternion.y;
this.z = quaternion.z;
return this;
}
public Quaternion set(double x, double y, double z, double w)
{
return this.set(new Quaternion(x, y, z, w));
}
public Quaternion normalize()
{
double magnitude = this.magnitude();
this.x /= magnitude;
this.y /= magnitude;
this.z /= magnitude;
this.w /= magnitude;
return this;
}
public double magnitude()
{
return Math.sqrt(this.magnitudeSquared());
}
public double magnitudeSquared()
{
return this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w;
}
public Quaternion inverse()
{
double d = this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w;
return new Quaternion(this.x / d, -this.y / d, -this.z / d, -this.w / d);
}
/**
* Gets the conjugate of this Quaternion
*/
public Quaternion getConjugate()
{
return this.clone().conjugate();
}
public Quaternion conjugate()
{
this.y = -this.y;
this.z = -this.z;
this.w = -this.w;
return this;
}
/**
* Let the current quaternion be "a". Multiplying the a with b applies the rotation a to b.
*/
public Quaternion getMultiply(Quaternion b)
{
return this.clone().multiply(b);
}
public Quaternion multiply(Quaternion b)
{
Quaternion a = this;
double newX = a.x * b.x - a.y * b.y - a.z * b.z - a.w * b.w;
double newY = a.x * b.y + a.y * b.x + a.z * b.w - a.w * b.z;
double newZ = a.x * b.z - a.y * b.w + a.z * b.x + a.w * b.y;
double newW = a.x * b.w + a.y * b.z - a.z * b.y + a.w * b.x;
this.set(newX, newY, newZ, newW);
return this;
}
public Quaternion divide(Quaternion b)
{
Quaternion a = this;
return a.inverse().multiply(b);
}
/** Multi a vector against this in other words applying rotation */
public Vector3 multi(Vector3 vec)
{
Vector3 vn = vec.clone();
Quaternion vecQuat = new Quaternion(0, 0, 0, 1), resQuat;
vecQuat.x = (float) vn.x;
vecQuat.y = (float) vn.y;
vecQuat.z = (float) vn.z;
vecQuat.w = 0.0f;
resQuat = vecQuat.multiply(this.getConjugate());
resQuat = this.multiply(resQuat);
return new Vector3(resQuat.x, resQuat.y, resQuat.z);
}
public static Quaternion fromAxis(Vector3 vector, double angle)
{
angle *= 0.5f;
Vector3 vn = vector.clone().normalize();
float sinAngle = (float) Math.sin(angle);
return new Quaternion(vn.x * sinAngle, vn.y * sinAngle, vn.z * sinAngle, Math.cos(angle));
}
/*
* Convert to Matrix public Matrix4 getMatrix() { float x2 = (float) (x * x); float y2 = (float)
* (y * y); float z2 = (float) (z * z); float xy = (float) (x * y); float xz = (float) (x * z);
* float yz = (float) (y * z); float wx = (float) (w * x); float wy = (float) (w * y); float wz
* = (float) (w * z);
*
* // This calculation would be a lot more complicated for non-unit length quaternions // Note:
* The constructor of Matrix4 expects the Matrix in column-major format like expected // by //
* OpenGL return new Matrix4(1.0f - 2.0f * (y2 + z2), 2.0f * (xy - wz), 2.0f * (xz + wy), 0.0f,
* 2.0f * (xy + wz), 1.0f - 2.0f * (x2 + z2), 2.0f * (yz - wx), 0.0f, 2.0f * (xz - wy), 2.0f *
* (yz + wx), 1.0f - 2.0f * (x2 + y2), 0.0f, 0.0f, 0.0f, 0.0f, 1.0f); }
*/
/**
* Convert to Axis/Angles
*
* @param axis - The axis of rotation
* @param angle - The angle of rotation
*/
public void getAxisAngle(Vector3 axis, float angle)
{
float scale = (float) axis.getMagnitude();
this.x = this.x / scale;
this.y = this.y / scale;
this.z = this.z / scale;
angle = (float) (Math.acos(this.w) * 2.0f);
}
@Override
public Quaternion clone()
{
return new Quaternion(this);
}
@Override
public String toString()
{
return "Quaternion [" + x + ", " + y + ", " + z + ", " + w + "]";
}
}

135
APIs/universalelectricity/core/vector/Vector2.java
View file

@ -1,135 +0,0 @@
package universalelectricity.core.vector;
/**
* Vector2 Class is used for defining objects in a 2D space.
*
* @author Calclavia
*/
public class Vector2 implements Cloneable
{
public double x;
public double y;
public Vector2()
{
this(0, 0);
}
public Vector2(double x, double y)
{
this.x = x;
this.y = y;
}
/**
* Returns the integer floor value.
*
* @return
*/
public int intX()
{
return (int) Math.floor(this.x);
}
public int intY()
{
return (int) Math.floor(this.y);
}
/**
* Makes a new copy of this Vector. Prevents variable referencing problems.
*/
@Override
public Vector2 clone()
{
return new Vector2(this.x, this.y);
}
public static double distance(Vector2 point1, Vector2 point2)
{
double xDifference = point1.x - point2.x;
double yDiference = point1.y - point2.y;
return Math.sqrt(xDifference * xDifference + yDiference * yDiference);
}
public static double slope(Vector2 point1, Vector2 point2)
{
double xDifference = point1.x - point2.x;
double yDiference = point1.y - point2.y;
return yDiference / xDifference;
}
public double distanceTo(Vector2 target)
{
double xDifference = this.x - target.x;
double yDifference = this.y - target.y;
return Math.sqrt(xDifference * xDifference + yDifference * yDifference);
}
public Vector2 add(Vector2 par1)
{
this.x += par1.x;
this.y += par1.y;
return this;
}
public Vector2 add(double par1)
{
this.x += par1;
this.y += par1;
return this;
}
public Vector2 invert()
{
this.multiply(-1);
return this;
}
public Vector2 multiply(double amount)
{
this.x *= amount;
this.y *= amount;
return this;
}
public Vector2 round()
{
return new Vector2(Math.round(this.x), Math.round(this.y));
}
public Vector2 ceil()
{
return new Vector2(Math.ceil(this.x), Math.ceil(this.y));
}
public Vector2 floor()
{
return new Vector2(Math.floor(this.x), Math.floor(this.y));
}
@Override
public int hashCode()
{
return ("X:" + this.x + "Y:" + this.y).hashCode();
}
@Override
public boolean equals(Object o)
{
if (o instanceof Vector2)
{
Vector2 vector = (Vector2) o;
return this.x == vector.x && this.y == vector.y;
}
return false;
}
@Override
public String toString()
{
return "Vector2 [" + this.x + "," + this.y + "]";
}
}

849
APIs/universalelectricity/core/vector/Vector3.java
View file

@ -1,849 +0,0 @@
package universalelectricity.core.vector;
import java.util.List;
import net.minecraft.entity.Entity;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.util.ChunkCoordinates;
import net.minecraft.util.MovingObjectPosition;
import net.minecraft.util.Vec3;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import net.minecraftforge.common.ForgeDirection;
/**
* Vector3 Class is used for defining objects in a 3D space.
*
* @author Calclavia
*/
public class Vector3 implements Cloneable
{
public double x;
public double y;
public double z;
public Vector3(double x, double y, double z)
{
this.x = x;
this.y = y;
this.z = z;
}
public Vector3()
{
this(0, 0, 0);
}
public Vector3(Vector3 vector)
{
this(vector.x, vector.y, vector.z);
}
public Vector3(double amount)
{
this(amount, amount, amount);
}
public Vector3(Entity par1)
{
this(par1.posX, par1.posY, par1.posZ);
}
public Vector3(TileEntity par1)
{
this(par1.xCoord, par1.yCoord, par1.zCoord);
}
public Vector3(Vec3 par1)
{
this(par1.xCoord, par1.yCoord, par1.zCoord);
}
public Vector3(MovingObjectPosition par1)
{
this(par1.blockX, par1.blockY, par1.blockZ);
}
public Vector3(ChunkCoordinates par1)
{
this(par1.posX, par1.posY, par1.posZ);
}
public Vector3(ForgeDirection direction)
{
this(direction.offsetX, direction.offsetY, direction.offsetZ);
}
/**
* Loads a Vector3 from an NBT compound.
*/
public Vector3(NBTTagCompound nbt)
{
this(nbt.getDouble("x"), nbt.getDouble("y"), nbt.getDouble("z"));
}
/**
* Get a Vector3 based on the rotationYaw and rotationPitch.
*
* @param rotationYaw - Degree
* @param rotationPitch- Degree
*/
public Vector3(float rotationYaw, float rotationPitch)
{
this(Math.cos(Math.toRadians(rotationYaw + 90)), Math.sin(Math.toRadians(-rotationPitch)), Math.sin(Math.toRadians(rotationYaw + 90)));
}
/**
* Returns the coordinates as integers, ideal for block placement.
*/
public int intX()
{
return (int) Math.floor(this.x);
}
public int intY()
{
return (int) Math.floor(this.y);
}
public int intZ()
{
return (int) Math.floor(this.z);
}
public float floatX()
{
return (float) this.x;
}
public float floatY()
{
return (float) this.y;
}
public float floatZ()
{
return (float) this.z;
}
/**
* Makes a new copy of this Vector. Prevents variable referencing problems.
*/
@Override
public Vector3 clone()
{
return new Vector3(this);
}
/**
* Easy block access functions.
*
* @param world
* @return
*/
public int getBlockID(IBlockAccess world)
{
return world.getBlockId(this.intX(), this.intY(), this.intZ());
}
public int getBlockMetadata(IBlockAccess world)
{
return world.getBlockMetadata(this.intX(), this.intY(), this.intZ());
}
public TileEntity getTileEntity(IBlockAccess world)
{
return world.getBlockTileEntity(this.intX(), this.intY(), this.intZ());
}
public boolean setBlock(World world, int id, int metadata, int notify)
{
return world.setBlock(this.intX(), this.intY(), this.intZ(), id, metadata, notify);
}
public boolean setBlock(World world, int id, int metadata)
{
return this.setBlock(world, id, metadata, 3);
}
public boolean setBlock(World world, int id)
{
return this.setBlock(world, id, 0);
}
/**
* ---------------------- CONVERSION FUNCTIONS ----------------------------
*/
/**
* Converts this Vector3 into a Vector2 by dropping the Y axis.
*/
public Vector2 toVector2()
{
return new Vector2(this.x, this.z);
}
/**
* Converts this vector three into a Minecraft Vec3 object
*/
public Vec3 toVec3()
{
return Vec3.createVectorHelper(this.x, this.y, this.z);
}
/**
* Converts Vector3 into a ForgeDirection.
*/
public ForgeDirection toForgeDirection()
{
for (ForgeDirection direction : ForgeDirection.VALID_DIRECTIONS)
{
if (this.x == direction.offsetX && this.y == direction.offsetY && this.z == direction.offsetZ)
{
return direction;
}
}
return ForgeDirection.UNKNOWN;
}
public double getMagnitude()
{
return Math.sqrt(this.getMagnitudeSquared());
}
public double getMagnitudeSquared()
{
return this.x * this.x + this.y * this.y + this.z * this.z;
}
public Vector3 normalize()
{
double d = this.getMagnitude();
if (d != 0)
{
this.scale(1 / d);
}
return this;
}
/**
* Gets the distance between two vectors
*
* @return The distance
*/
public static double distance(Vector3 vec1, Vector3 vec2)
{
return vec1.distance(vec2);
}
@Deprecated
public double distanceTo(Vector3 vector3)
{
return this.distance(vector3);
}
public double distance(Vector3 compare)
{
Vector3 difference = this.clone().difference(compare);
return difference.getMagnitude();
}
/**
* Multiplies the vector by negative one.
*/
public Vector3 invert()
{
this.scale(-1);
return this;
}
public Vector3 translate(Vector3 par1)
{
this.x += par1.x;
this.y += par1.y;
this.z += par1.z;
return this;
}
public Vector3 translate(double par1)
{
this.x += par1;
this.y += par1;
this.z += par1;
return this;
}
public static Vector3 translate(Vector3 translate, Vector3 par1)
{
translate.x += par1.x;
translate.y += par1.y;
translate.z += par1.z;
return translate;
}
public static Vector3 translate(Vector3 translate, double par1)
{
translate.x += par1;
translate.y += par1;
translate.z += par1;
return translate;
}
@Deprecated
public Vector3 add(Vector3 amount)
{
return translate(amount);
}
@Deprecated
public Vector3 add(double amount)
{
return translate(amount);
}
@Deprecated
public Vector3 subtract(Vector3 amount)
{
return this.translate(amount.clone().invert());
}
@Deprecated
public Vector3 subtract(double amount)
{
return this.translate(-amount);
}
public Vector3 difference(Vector3 amount)
{
return this.translate(amount.clone().invert());
}
public Vector3 difference(double amount)
{
return this.translate(-amount);
}
public Vector3 scale(double amount)
{
this.x *= amount;
this.y *= amount;
this.z *= amount;
return this;
}
public Vector3 scale(Vector3 amount)
{
this.x *= amount.x;
this.y *= amount.y;
this.z *= amount.z;
return this;
}
public static Vector3 scale(Vector3 vec, double amount)
{
return vec.scale(amount);
}
public static Vector3 scale(Vector3 vec, Vector3 amount)
{
return vec.scale(amount);
}
@Deprecated
public Vector3 multiply(double amount)
{
return this.scale(amount);
}
@Deprecated
public Vector3 multiply(Vector3 amount)
{
return this.scale(amount);
}
/**
* Static versions of a lot of functions
*/
@Deprecated
public static Vector3 subtract(Vector3 par1, Vector3 par2)
{
return new Vector3(par1.x - par2.x, par1.y - par2.y, par1.z - par2.z);
}
@Deprecated
public static Vector3 add(Vector3 par1, Vector3 par2)
{
return new Vector3(par1.x + par2.x, par1.y + par2.y, par1.z + par2.z);
}
@Deprecated
public static Vector3 add(Vector3 par1, double par2)
{
return new Vector3(par1.x + par2, par1.y + par2, par1.z + par2);
}
@Deprecated
public static Vector3 multiply(Vector3 vec1, Vector3 vec2)
{
return new Vector3(vec1.x * vec2.x, vec1.y * vec2.y, vec1.z * vec2.z);
}
@Deprecated
public static Vector3 multiply(Vector3 vec1, double vec2)
{
return new Vector3(vec1.x * vec2, vec1.y * vec2, vec1.z * vec2);
}
public Vector3 round()
{
return new Vector3(Math.round(this.x), Math.round(this.y), Math.round(this.z));
}
public Vector3 ceil()
{
return new Vector3(Math.ceil(this.x), Math.ceil(this.y), Math.ceil(this.z));
}
public Vector3 floor()
{
return new Vector3(Math.floor(this.x), Math.floor(this.y), Math.floor(this.z));
}
public Vector3 toRound()
{
this.x = Math.round(this.x);
this.y = Math.round(this.y);
this.z = Math.round(this.z);
return this;
}
public Vector3 toCeil()
{
this.x = Math.ceil(this.x);
this.y = Math.ceil(this.y);
this.z = Math.ceil(this.z);
return this;
}
public Vector3 toFloor()
{
this.x = Math.floor(this.x);
this.y = Math.floor(this.y);
this.z = Math.floor(this.z);
return this;
}
/**
* Gets all entities inside of this position in block space.
*/
public List<Entity> getEntitiesWithin(World worldObj, Class<? extends Entity> par1Class)
{
return worldObj.getEntitiesWithinAABB(par1Class, AxisAlignedBB.getBoundingBox(this.intX(), this.intY(), this.intZ(), this.intX() + 1, this.intY() + 1, this.intZ() + 1));
}
/**
* Gets a position relative to a position's side
*
* @param position - The position
* @param side - The side. 0-5
* @return The position relative to the original position's side
*/
public Vector3 modifyPositionFromSide(ForgeDirection side, double amount)
{
return this.translate(new Vector3(side).scale(amount));
}
public Vector3 modifyPositionFromSide(ForgeDirection side)
{
this.modifyPositionFromSide(side, 1);
return this;
}
/**
* Cross product functions
*
* @return The cross product between this vector and another.
*/
public Vector3 toCrossProduct(Vector3 compare)
{
double newX = this.y * compare.z - this.z * compare.y;
double newY = this.z * compare.x - this.x * compare.z;
double newZ = this.x * compare.y - this.y * compare.x;
this.x = newX;
this.y = newY;
this.z = newZ;
return this;
}
public Vector3 crossProduct(Vector3 compare)
{
return this.clone().toCrossProduct(compare);
}
public Vector3 xCrossProduct()
{
return new Vector3(0.0D, this.z, -this.y);
}
public Vector3 zCrossProduct()
{
return new Vector3(-this.y, this.x, 0.0D);
}
public double dotProduct(Vector3 vec2)
{
return this.x * vec2.x + this.y * vec2.y + this.z * vec2.z;
}
/**
* @return The perpendicular vector.
*/
public Vector3 getPerpendicular()
{
if (this.z == 0.0F)
{
return this.zCrossProduct();
}
return this.xCrossProduct();
}
/**
* @return True if this Vector3 is zero.
*/
public boolean isZero()
{
return (this.x == 0) && (this.y == 0) && (this.z == 0);
}
/**
* Rotate by a this vector around an axis.
*
* @return The new Vector3 rotation.
*/
public Vector3 rotate(float angle, Vector3 axis)
{
return translateMatrix(getRotationMatrix(angle, axis), this.clone());
}
public double[] getRotationMatrix(float angle)
{
double[] matrix = new double[16];
Vector3 axis = this.clone().normalize();
double x = axis.x;
double y = axis.y;
double z = axis.z;
angle *= 0.0174532925D;
float cos = (float) Math.cos(angle);
float ocos = 1.0F - cos;
float sin = (float) Math.sin(angle);
matrix[0] = (x * x * ocos + cos);
matrix[1] = (y * x * ocos + z * sin);
matrix[2] = (x * z * ocos - y * sin);
matrix[4] = (x * y * ocos - z * sin);
matrix[5] = (y * y * ocos + cos);
matrix[6] = (y * z * ocos + x * sin);
matrix[8] = (x * z * ocos + y * sin);
matrix[9] = (y * z * ocos - x * sin);
matrix[10] = (z * z * ocos + cos);
matrix[15] = 1.0F;
return matrix;
}
public static Vector3 translateMatrix(double[] matrix, Vector3 translation)
{
double x = translation.x * matrix[0] + translation.y * matrix[1] + translation.z * matrix[2] + matrix[3];
double y = translation.x * matrix[4] + translation.y * matrix[5] + translation.z * matrix[6] + matrix[7];
double z = translation.x * matrix[8] + translation.y * matrix[9] + translation.z * matrix[10] + matrix[11];
translation.x = x;
translation.y = y;
translation.z = z;
return translation;
}
public static double[] getRotationMatrix(float angle, Vector3 axis)
{
return axis.getRotationMatrix(angle);
}
/**
* Rotates this Vector by a yaw, pitch and roll value.
*/
public void rotate(double yaw, double pitch, double roll)
{
double yawRadians = Math.toRadians(yaw);
double pitchRadians = Math.toRadians(pitch);
double rollRadians = Math.toRadians(roll);
double x = this.x;
double y = this.y;
double z = this.z;
this.x = x * Math.cos(yawRadians) * Math.cos(pitchRadians) + z * (Math.cos(yawRadians) * Math.sin(pitchRadians) * Math.sin(rollRadians) - Math.sin(yawRadians) * Math.cos(rollRadians)) + y * (Math.cos(yawRadians) * Math.sin(pitchRadians) * Math.cos(rollRadians) + Math.sin(yawRadians) * Math.sin(rollRadians));
this.z = x * Math.sin(yawRadians) * Math.cos(pitchRadians) + z * (Math.sin(yawRadians) * Math.sin(pitchRadians) * Math.sin(rollRadians) + Math.cos(yawRadians) * Math.cos(rollRadians)) + y * (Math.sin(yawRadians) * Math.sin(pitchRadians) * Math.cos(rollRadians) - Math.cos(yawRadians) * Math.sin(rollRadians));
this.y = -x * Math.sin(pitchRadians) + z * Math.cos(pitchRadians) * Math.sin(rollRadians) + y * Math.cos(pitchRadians) * Math.cos(rollRadians);
}
/**
* Rotates a point by a yaw and pitch around the anchor 0,0 by a specific angle.
*/
public void rotate(double yaw, double pitch)
{
this.rotate(yaw, pitch, 0);
}
public void rotate(double yaw)
{
double yawRadians = Math.toRadians(yaw);
double x = this.x;
double z = this.z;
if (yaw != 0)
{
this.x = x * Math.cos(yawRadians) - z * Math.sin(yawRadians);
this.z = x * Math.sin(yawRadians) + z * Math.cos(yawRadians);
}
}
/**
* Gets the delta look position based on the rotation yaw and pitch. Minecraft coordinates are
* messed up. Y and Z are flipped. Yaw is displaced by 90 degrees. Pitch is inversed.
*
* @param rotationYaw
* @param rotationPitch
*/
public static Vector3 getDeltaPositionFromRotation(float rotationYaw, float rotationPitch)
{
return new Vector3(rotationYaw, rotationPitch);
}
/**
* Gets the angle between this vector and another vector.
*
* @return Angle in degrees
*/
public double getAngle(Vector3 vec2)
{
return anglePreNorm(this.clone().normalize(), vec2.clone().normalize());
}
public static double getAngle(Vector3 vec1, Vector3 vec2)
{
return vec1.getAngle(vec2);
}
public double anglePreNorm(Vector3 vec2)
{
return Math.acos(this.dotProduct(vec2));
}
public static double anglePreNorm(Vector3 vec1, Vector3 vec2)
{
return Math.acos(vec1.clone().dotProduct(vec2));
}
/**
* Loads a Vector3 from an NBT compound.
*/
@Deprecated
public static Vector3 readFromNBT(NBTTagCompound nbt)
{
return new Vector3(nbt);
}
/**
* Saves this Vector3 to disk
*
* @param prefix - The prefix of this save. Use some unique string.
* @param nbt - The NBT compound object to save the data in
*/
public NBTTagCompound writeToNBT(NBTTagCompound nbt)
{
nbt.setDouble("x", this.x);
nbt.setDouble("y", this.y);
nbt.setDouble("z", this.z);
return nbt;
}
public static Vector3 UP()
{
return new Vector3(0, 1, 0);
}
public static Vector3 DOWN()
{
return new Vector3(0, -1, 0);
}
public static Vector3 NORTH()
{
return new Vector3(0, 0, -1);
}
public static Vector3 SOUTH()
{
return new Vector3(0, 0, 1);
}
public static Vector3 WEST()
{
return new Vector3(-1, 0, 0);
}
public static Vector3 EAST()
{
return new Vector3(1, 0, 0);
}
/**
* RayTrace Code, retrieved from MachineMuse.
*
* @author MachineMuse
*/
public MovingObjectPosition rayTrace(World world, float rotationYaw, float rotationPitch, boolean collisionFlag, double reachDistance)
{
// Somehow this destroys the playerPosition vector -.-
MovingObjectPosition pickedBlock = this.rayTraceBlocks(world, rotationYaw, rotationPitch, collisionFlag, reachDistance);
MovingObjectPosition pickedEntity = this.rayTraceEntities(world, rotationYaw, rotationPitch, reachDistance);
if (pickedBlock == null)
{
return pickedEntity;
}
else if (pickedEntity == null)
{
return pickedBlock;
}
else
{
double dBlock = this.distance(new Vector3(pickedBlock.hitVec));
double dEntity = this.distance(new Vector3(pickedEntity.hitVec));
if (dEntity < dBlock)
{
return pickedEntity;
}
else
{
return pickedBlock;
}
}
}
public MovingObjectPosition rayTraceBlocks(World world, float rotationYaw, float rotationPitch, boolean collisionFlag, double reachDistance)
{
Vector3 lookVector = this.getDeltaPositionFromRotation(rotationYaw, rotationPitch);
Vector3 reachPoint = this.clone().translate(lookVector.clone().scale(reachDistance));
return world.rayTraceBlocks_do_do(this.toVec3(), reachPoint.toVec3(), collisionFlag, !collisionFlag);
}
@Deprecated
public MovingObjectPosition rayTraceEntities(World world, float rotationYaw, float rotationPitch, boolean collisionFlag, double reachDistance)
{
return this.rayTraceEntities(world, rotationYaw, rotationPitch, reachDistance);
}
public MovingObjectPosition rayTraceEntities(World world, float rotationYaw, float rotationPitch, double reachDistance)
{
return this.rayTraceEntities(world, getDeltaPositionFromRotation(rotationYaw, rotationPitch).scale(reachDistance));
}
/**
* Does an entity raytrace.
*
* @param world - The world object.
* @param target - The rotation in terms of Vector3. Convert using
* getDeltaPositionFromRotation()
* @return The target hit.
*/
public MovingObjectPosition rayTraceEntities(World world, Vector3 target)
{
MovingObjectPosition pickedEntity = null;
Vec3 startingPosition = this.toVec3();
Vec3 look = target.toVec3();
double reachDistance = this.distance(target);
Vec3 reachPoint = Vec3.createVectorHelper(startingPosition.xCoord + look.xCoord * reachDistance, startingPosition.yCoord + look.yCoord * reachDistance, startingPosition.zCoord + look.zCoord * reachDistance);
double checkBorder = 1.1 * reachDistance;
AxisAlignedBB boxToScan = AxisAlignedBB.getAABBPool().getAABB(-checkBorder, -checkBorder, -checkBorder, checkBorder, checkBorder, checkBorder).offset(this.x, this.y, this.z);
@SuppressWarnings("unchecked")
List<Entity> entitiesHit = world.getEntitiesWithinAABBExcludingEntity(null, boxToScan);
double closestEntity = reachDistance;
if (entitiesHit == null || entitiesHit.isEmpty())
{
return null;
}
for (Entity entityHit : entitiesHit)
{
if (entityHit != null && entityHit.canBeCollidedWith() && entityHit.boundingBox != null)
{
float border = entityHit.getCollisionBorderSize();
AxisAlignedBB aabb = entityHit.boundingBox.expand(border, border, border);
MovingObjectPosition hitMOP = aabb.calculateIntercept(startingPosition, reachPoint);
if (hitMOP != null)
{
if (aabb.isVecInside(startingPosition))
{
if (0.0D < closestEntity || closestEntity == 0.0D)
{
pickedEntity = new MovingObjectPosition(entityHit);
if (pickedEntity != null)
{
pickedEntity.hitVec = hitMOP.hitVec;
closestEntity = 0.0D;
}
}
}
else
{
double distance = startingPosition.distanceTo(hitMOP.hitVec);
if (distance < closestEntity || closestEntity == 0.0D)
{
pickedEntity = new MovingObjectPosition(entityHit);
pickedEntity.hitVec = hitMOP.hitVec;
closestEntity = distance;
}
}
}
}
}
return pickedEntity;
}
@Override
public int hashCode()
{
return ("X:" + this.x + "Y:" + this.y + "Z:" + this.z).hashCode();
}
@Override
public boolean equals(Object o)
{
if (o instanceof Vector3)
{
Vector3 vector3 = (Vector3) o;
return this.x == vector3.x && this.y == vector3.y && this.z == vector3.z;
}
return false;
}
@Override
public String toString()
{
return "Vector3 [" + this.x + "," + this.y + "," + this.z + "]";
}
}

52
APIs/universalelectricity/core/vector/VectorHelper.java
View file

@ -1,52 +0,0 @@
package universalelectricity.core.vector;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
import net.minecraftforge.common.ForgeDirection;
import universalelectricity.core.block.IConnector;
public class VectorHelper
{
public static final int[][] RELATIVE_MATRIX = { { 3, 2, 1, 0, 5, 4 }, { 4, 5, 0, 1, 2, 3 }, { 0, 1, 3, 2, 4, 5 }, { 0, 1, 2, 3, 5, 4 }, { 0, 1, 5, 4, 3, 2 }, { 0, 1, 4, 5, 2, 3 } };
/**
* Finds the direction relative to a base direction.
*
* @param front - The direction in which this block is facing/front. Use a number between 0 and
* 5. Default is 3.
* @param side - The side you are trying to find. A number between 0 and 5.
* @return The side relative to the facing direction.
*/
public static ForgeDirection getOrientationFromSide(ForgeDirection front, ForgeDirection side)
{
if (front != ForgeDirection.UNKNOWN && side != ForgeDirection.UNKNOWN)
{
return ForgeDirection.getOrientation(RELATIVE_MATRIX[front.ordinal()][side.ordinal()]);
}
return ForgeDirection.UNKNOWN;
}
/**
* Gets a connector unit based on the given side.
*/
public static TileEntity getConnectorFromSide(World world, Vector3 position, ForgeDirection side)
{
TileEntity tileEntity = VectorHelper.getTileEntityFromSide(world, position, side);
if (tileEntity instanceof IConnector)
{
if (((IConnector) tileEntity).canConnect(getOrientationFromSide(side, ForgeDirection.NORTH)))
{
return tileEntity;
}
}
return null;
}
public static TileEntity getTileEntityFromSide(World world, Vector3 position, ForgeDirection side)
{
return position.clone().modifyPositionFromSide(side).getTileEntity(world);
}
}

64
APIs/universalelectricity/prefab/ConductorChunkInitiate.java
View file

@ -1,64 +0,0 @@
package universalelectricity.prefab;
import java.util.ArrayList;
import java.util.Collection;
import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.event.ForgeSubscribe;
import net.minecraftforge.event.world.ChunkEvent;
import universalelectricity.core.block.INetworkConnection;
/**
* A helper class to register chunk loading for your wires if you need them to be refreshed upon
* chunk load. This prevents the need for your wire to be refreshed.
*
* @author Calclavia, Aidancbrady
*
*/
public class ConductorChunkInitiate
{
private static boolean onChunkLoadRegistered = false;
/**
* Registers and initiates Universal Electricity's network loader.
*/
public static void register()
{
if (!onChunkLoadRegistered)
{
try
{
MinecraftForge.EVENT_BUS.register(new ConductorChunkInitiate());
onChunkLoadRegistered = true;
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
@ForgeSubscribe
public void onChunkLoad(ChunkEvent.Load event)
{
if (event.getChunk() != null)
{
Collection<?> collection = new ArrayList();
collection.addAll(event.getChunk().chunkTileEntityMap.values());
for (Object obj : collection)
{
if (obj instanceof TileEntity)
{
TileEntity tileEntity = (TileEntity) obj;
if (tileEntity instanceof INetworkConnection)
{
((INetworkConnection) tileEntity).refresh();
}
}
}
}
}
}

42
APIs/universalelectricity/prefab/CustomDamageSource.java
View file

@ -1,42 +0,0 @@
package universalelectricity.prefab;
import net.minecraft.util.DamageSource;
import cpw.mods.fml.common.registry.LanguageRegistry;
public class CustomDamageSource extends DamageSource
{
/**
* Use this damage source for all types of electrical attacks.
*/
public static final CustomDamageSource electrocution = ((CustomDamageSource) new CustomDamageSource("electrocution").setDamageBypassesArmor()).setDeathMessage("%1$s got electrocuted!");
public CustomDamageSource(String damageType)
{
super(damageType);
}
@Deprecated
public CustomDamageSource setDeathMessage(String deathMessage)
{
LanguageRegistry.instance().addStringLocalization("death.attack." + this.damageType, deathMessage);
return this;
}
@Override
public DamageSource setDamageBypassesArmor()
{
return super.setDamageBypassesArmor();
}
@Override
public DamageSource setDamageAllowedInCreativeMode()
{
return super.setDamageAllowedInCreativeMode();
}
@Override
public DamageSource setFireDamage()
{
return super.setFireDamage();
}
}

192
APIs/universalelectricity/prefab/RecipeHelper.java
View file

@ -1,192 +0,0 @@
package universalelectricity.prefab;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import net.minecraft.item.ItemStack;
import net.minecraft.item.crafting.CraftingManager;
import net.minecraft.item.crafting.IRecipe;
import net.minecraftforge.common.Configuration;
import cpw.mods.fml.common.registry.GameRegistry;
/**
* This class is used to replace recipes that are already added in the existing recipe pool for
* crafting and smelting. All recipe functions take account of the Forge Ore Dictionary. It also
* includes some recipe helper functions to shorten some of your function calls.
*
* @author Calclavia
*
*/
public class RecipeHelper
{
public static List<IRecipe> getRecipesByOutput(ItemStack output)
{
List<IRecipe> list = new ArrayList<IRecipe>();
for (Object obj : CraftingManager.getInstance().getRecipeList())
{
if (obj instanceof IRecipe)
{
if (((IRecipe) obj).getRecipeOutput() == output)
{
list.add((IRecipe) obj);
}
}
}
return list;
}
/**
* Replaces a recipe with a new IRecipe.
*
* @return True if successful
*/
public static boolean replaceRecipe(IRecipe recipe, IRecipe newRecipe)
{
for (Object obj : CraftingManager.getInstance().getRecipeList())
{
if (obj instanceof IRecipe)
{
if (((IRecipe) obj).equals(recipe) || obj == recipe)
{
CraftingManager.getInstance().getRecipeList().remove(obj);
CraftingManager.getInstance().getRecipeList().add(newRecipe);
return true;
}
}
}
return false;
}
/**
* Replaces a recipe with the resulting ItemStack with a new IRecipe.
*
* @return True if successful
*/
public static boolean replaceRecipe(ItemStack recipe, IRecipe newRecipe)
{
if (removeRecipe(recipe))
{
CraftingManager.getInstance().getRecipeList().add(newRecipe);
return true;
}
return false;
}
/**
* Removes a recipe by its IRecipe class.
*
* @return True if successful
*/
public static boolean removeRecipe(IRecipe recipe)
{
for (Object obj : CraftingManager.getInstance().getRecipeList())
{
if (obj != null)
{
if (obj instanceof IRecipe)
{
if (((IRecipe) obj).equals(recipe) || obj == recipe)
{
CraftingManager.getInstance().getRecipeList().remove(obj);
return true;
}
}
}
}
return false;
}
/**
* Removes the first recipe found by its output.
*
* @return True if successful
*/
public static boolean removeRecipe(ItemStack stack)
{
for (Object obj : CraftingManager.getInstance().getRecipeList())
{
if (obj != null)
{
if (obj instanceof IRecipe)
{
if (((IRecipe) obj).getRecipeOutput() != null)
{
if (((IRecipe) obj).getRecipeOutput().isItemEqual(stack))
{
CraftingManager.getInstance().getRecipeList().remove(obj);
return true;
}
}
}
}
}
return false;
}
/**
* Removes all recipes found that has this output. You may use this with Forge Ore Dictionary to
* remove all recipes with the FoD ID.
*
* @return True if successful
*/
public static boolean removeRecipes(ItemStack... itemStacks)
{
boolean didRemove = false;
for (Iterator itr = CraftingManager.getInstance().getRecipeList().iterator(); itr.hasNext();)
{
Object obj = itr.next();
if (obj != null)
{
if (obj instanceof IRecipe)
{
if (((IRecipe) obj).getRecipeOutput() != null)
{
for (ItemStack itemStack : itemStacks)
{
if (((IRecipe) obj).getRecipeOutput().isItemEqual(itemStack))
{
itr.remove();
didRemove = true;
break;
}
}
}
}
}
}
return didRemove;
}
/**
* Use this function if you want to check if the recipe is allowed in the configuration file.
*/
public static void addRecipe(IRecipe recipe, String name, Configuration configuration, boolean defaultBoolean)
{
if (configuration != null)
{
configuration.load();
if (configuration.get("Crafting", "Allow " + name + " Crafting", defaultBoolean).getBoolean(defaultBoolean))
{
GameRegistry.addRecipe(recipe);
}
configuration.save();
}
}
public static void addRecipe(IRecipe recipe, Configuration config, boolean defaultBoolean)
{
addRecipe(recipe, recipe.getRecipeOutput().getUnlocalizedName(), config, defaultBoolean);
}
}

95
APIs/universalelectricity/prefab/SlotSpecific.java
View file

@ -1,95 +0,0 @@
package universalelectricity.prefab;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
/**
* Creates a slot with a specific amount of items that matches the slot's requirements. Allows easy
* shift right clicking management and slot blocking in classes. In your container you can use
* this.getSlot(i).isItemValid to justify the player's shift clicking actions to match the slot.
*
* @author Calclavia
*
*/
public class SlotSpecific extends Slot
{
public ItemStack[] validItemStacks = new ItemStack[0];
public Class[] validClasses = new Class[0];
public boolean isInverted = false;
public boolean isMetadataSensitive = false;
public SlotSpecific(IInventory par2IInventory, int par3, int par4, int par5, ItemStack... itemStacks)
{
super(par2IInventory, par3, par4, par5);
this.setItemStacks(itemStacks);
}
public SlotSpecific(IInventory par2IInventory, int par3, int par4, int par5, Class... validClasses)
{
super(par2IInventory, par3, par4, par5);
this.setClasses(validClasses);
}
public SlotSpecific setMetadataSensitive()
{
this.isMetadataSensitive = true;
return this;
}
public SlotSpecific setItemStacks(ItemStack... validItemStacks)
{
this.validItemStacks = validItemStacks;
return this;
}
public SlotSpecific setClasses(Class... validClasses)
{
this.validClasses = validClasses;
return this;
}
public SlotSpecific toggleInverted()
{
this.isInverted = !this.isInverted;
return this;
}
/**
* Check if the stack is a valid item for this slot. Always true beside for the armor slots.
*/
@Override
public boolean isItemValid(ItemStack compareStack)
{
boolean returnValue = false;
for (ItemStack itemStack : this.validItemStacks)
{
if (compareStack.isItemEqual(itemStack) || (!this.isMetadataSensitive && compareStack.itemID == itemStack.itemID))
{
returnValue = true;
break;
}
}
if (!returnValue)
{
for (Class clazz : this.validClasses)
{
if (clazz.equals(compareStack.getItem().getClass()) || clazz.isInstance(compareStack.getItem()))
{
returnValue = true;
break;
}
}
}
if (this.isInverted)
{
return !returnValue;
}
return returnValue;
}
}

88
APIs/universalelectricity/prefab/TranslationHelper.java
View file

@ -1,88 +0,0 @@
package universalelectricity.prefab;
import cpw.mods.fml.common.FMLCommonHandler;
import cpw.mods.fml.common.FMLLog;
import cpw.mods.fml.common.registry.LanguageRegistry;
import cpw.mods.fml.relauncher.Side;
/**
* A class to help you out with translations.
*
* @author Calclavia
*
*/
public class TranslationHelper
{
/**
* Loads all the language files for a mod. This supports the loading of "child" language files
* for sub-languages to be loaded all from one file instead of creating multiple of them. An
* example of this usage would be different Spanish sub-translations (es_MX, es_YU).
*
* @param languagePath - The path to the mod's language file folder.
* @param languageSupported - The languages supported. E.g: new String[]{"en_US", "en_AU",
* "en_UK"}
* @return The amount of language files loaded successfully.
*/
public static int loadLanguages(String languagePath, String[] languageSupported)
{
int languages = 0;
/**
* Load all languages.
*/
for (String language : languageSupported)
{
LanguageRegistry.instance().loadLocalization(languagePath + language + ".properties", language, false);
if (LanguageRegistry.instance().getStringLocalization("children", language) != "")
{
try
{
String[] children = LanguageRegistry.instance().getStringLocalization("children", language).split(",");
for (String child : children)
{
if (child != "" || child != null)
{
LanguageRegistry.instance().loadLocalization(languagePath + language + ".properties", child, false);
languages++;
}
}
}
catch (Exception e)
{
FMLLog.severe("Failed to load a child language file.");
e.printStackTrace();
}
}
languages++;
}
return languages;
}
/**
* Gets the local text of your translation based on the given key. This will look through your
* mod's translation file that was previously registered. Make sure you enter the full name
*
* @param key - e.g tile.block.name
* @return The translated string or the default English translation if none was found.
*/
public static String getLocal(String key)
{
String text = null;
if (FMLCommonHandler.instance().getEffectiveSide() == Side.CLIENT)
{
text = LanguageRegistry.instance().getStringLocalization(key);
}
if (text == null || text == "")
{
text = LanguageRegistry.instance().getStringLocalization(key, "en_US");
}
return text;
}
}

200
APIs/universalelectricity/prefab/block/BlockAdvanced.java
View file

@ -1,200 +0,0 @@
package universalelectricity.prefab.block;
import java.lang.reflect.Method;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemStack;
import net.minecraft.world.World;
/**
* An advanced block class that is to be extended for wrenching capabilities.
*/
public abstract class BlockAdvanced extends Block
{
public BlockAdvanced(int id, Material material)
{
super(id, material);
this.setHardness(0.6f);
}
/**
* DO NOT OVERRIDE THIS FUNCTION! Called when the block is right clicked by the player. This
* modified version detects electric items and wrench actions on your machine block. Do not
* override this function. Use onMachineActivated instead! (It does the same thing)
*
* @param world The World Object.
* @param x , y, z The coordinate of the block.
* @param side The side the player clicked on.
* @param hitX , hitY, hitZ The position the player clicked on relative to the block.
*/
@Override
public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer entityPlayer, int side, float hitX, float hitY, float hitZ)
{
int metadata = world.getBlockMetadata(x, y, z);
/**
* Check if the player is holding a wrench or an electric item. If so, call the wrench
* event.
*/
if (this.isUsableWrench(entityPlayer, entityPlayer.inventory.getCurrentItem(), x, y, z))
{
this.damageWrench(entityPlayer, entityPlayer.inventory.getCurrentItem(), x, y, z);
if (entityPlayer.isSneaking())
{
if (this.onSneakUseWrench(world, x, y, z, entityPlayer, side, hitX, hitY, hitZ))
{
return true;
}
}
if (this.onUseWrench(world, x, y, z, entityPlayer, side, hitX, hitY, hitZ))
{
return true;
}
}
if (entityPlayer.isSneaking())
{
if (this.onSneakMachineActivated(world, x, y, z, entityPlayer, side, hitX, hitY, hitZ))
{
return true;
}
}
return this.onMachineActivated(world, x, y, z, entityPlayer, side, hitX, hitY, hitZ);
}
/**
* A function that denotes if an itemStack is a wrench that can be used. Override this for more
* wrench compatibility. Compatible with Buildcraft and IC2 wrench API via reflection.
*
* @return True if it is a wrench.
*/
public boolean isUsableWrench(EntityPlayer entityPlayer, ItemStack itemStack, int x, int y, int z)
{
if (entityPlayer != null && itemStack != null)
{
Class wrenchClass = itemStack.getItem().getClass();
/**
* UE and Buildcraft
*/
try
{
Method methodCanWrench = wrenchClass.getMethod("canWrench", EntityPlayer.class, Integer.TYPE, Integer.TYPE, Integer.TYPE);
return (Boolean) methodCanWrench.invoke(itemStack.getItem(), entityPlayer, x, y, z);
}
catch (NoClassDefFoundError e)
{
}
catch (Exception e)
{
}
/**
* Industrialcraft
*/
try
{
if (wrenchClass == Class.forName("ic2.core.item.tool.ItemToolWrench") || wrenchClass == Class.forName("ic2.core.item.tool.ItemToolWrenchElectric"))
{
return itemStack.getItemDamage() < itemStack.getMaxDamage();
}
}
catch (Exception e)
{
}
}
return false;
}
/**
* This function damages a wrench. Works with Buildcraft and Industrialcraft wrenches.
*
* @return True if damage was successfull.
*/
public boolean damageWrench(EntityPlayer entityPlayer, ItemStack itemStack, int x, int y, int z)
{
if (this.isUsableWrench(entityPlayer, itemStack, x, y, z))
{
Class wrenchClass = itemStack.getItem().getClass();
/**
* UE and Buildcraft
*/
try
{
Method methodWrenchUsed = wrenchClass.getMethod("wrenchUsed", EntityPlayer.class, Integer.TYPE, Integer.TYPE, Integer.TYPE);
methodWrenchUsed.invoke(itemStack.getItem(), entityPlayer, x, y, z);
return true;
}
catch (Exception e)
{
}
/**
* Industrialcraft
*/
try
{
if (wrenchClass == Class.forName("ic2.core.item.tool.ItemToolWrench") || wrenchClass == Class.forName("ic2.core.item.tool.ItemToolWrenchElectric"))
{
Method methodWrenchDamage = wrenchClass.getMethod("damage", ItemStack.class, Integer.TYPE, EntityPlayer.class);
methodWrenchDamage.invoke(itemStack.getItem(), itemStack, 1, entityPlayer);
return true;
}
}
catch (Exception e)
{
}
}
return false;
}
/**
* Called when the machine is right clicked by the player
*
* @return True if something happens
*/
public boolean onMachineActivated(World world, int x, int y, int z, EntityPlayer entityPlayer, int side, float hitX, float hitY, float hitZ)
{
return false;
}
/**
* Called when the machine is being wrenched by a player while sneaking.
*
* @return True if something happens
*/
public boolean onSneakMachineActivated(World world, int x, int y, int z, EntityPlayer entityPlayer, int side, float hitX, float hitY, float hitZ)
{
return false;
}
/**
* Called when a player uses a wrench on the machine
*
* @return True if some happens
*/
public boolean onUseWrench(World world, int x, int y, int z, EntityPlayer entityPlayer, int side, float hitX, float hitY, float hitZ)
{
return false;
}
/**
* Called when a player uses a wrench on the machine while sneaking. Only works with the UE
* wrench.
*
* @return True if some happens
*/
public boolean onSneakUseWrench(World world, int x, int y, int z, EntityPlayer entityPlayer, int side, float hitX, float hitY, float hitZ)
{
return this.onUseWrench(world, x, y, z, entityPlayer, side, hitX, hitY, hitZ);
}
}

193
APIs/universalelectricity/prefab/block/BlockConductor.java
View file

@ -1,193 +0,0 @@
package universalelectricity.prefab.block;
import java.util.List;
import net.minecraft.block.BlockContainer;
import net.minecraft.block.material.Material;
import net.minecraft.entity.Entity;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import universalelectricity.core.block.IConductor;
import universalelectricity.core.vector.Vector3;
import universalelectricity.prefab.tile.TileEntityConductor;
public abstract class BlockConductor extends BlockContainer
{
public boolean isWireCollision = true;
public Vector3 minVector = new Vector3(0.3, 0.3, 0.3);
public Vector3 maxVector = new Vector3(0.7, 0.7, 0.7);
public BlockConductor(int id, Material material)
{
super(id, material);
}
/**
* Called whenever the block is added into the world. Args: world, x, y, z
*/
@Override
public void onBlockAdded(World world, int x, int y, int z)
{
super.onBlockAdded(world, x, y, z);
TileEntity tileEntity = world.getBlockTileEntity(x, y, z);
if (tileEntity instanceof IConductor)
{
((IConductor) tileEntity).refresh();
}
}
/**
* Lets the block know when one of its neighbor changes. Doesn't know which neighbor changed
* (coordinates passed are their own) Args: x, y, z, neighbor blockID
*/
@Override
public void onNeighborBlockChange(World world, int x, int y, int z, int blockID)
{
TileEntity tileEntity = world.getBlockTileEntity(x, y, z);
if (tileEntity instanceof IConductor)
{
((IConductor) tileEntity).refresh();
}
}
/**
* Returns a bounding box from the pool of bounding boxes (this means this box can change after
* the pool has been cleared to be reused)
*/
@Override
public AxisAlignedBB getCollisionBoundingBoxFromPool(World world, int x, int y, int z)
{
this.setBlockBoundsBasedOnState(world, x, y, z);
return super.getCollisionBoundingBoxFromPool(world, x, y, z);
}
@Override
public AxisAlignedBB getSelectedBoundingBoxFromPool(World world, int x, int y, int z)
{
this.setBlockBoundsBasedOnState(world, x, y, z);
return super.getSelectedBoundingBoxFromPool(world, x, y, z);
}
/**
* Returns the bounding box of the wired rectangular prism to render.
*/
@Override
public void setBlockBoundsBasedOnState(IBlockAccess world, int x, int y, int z)
{
if (this.isWireCollision)
{
TileEntity tileEntity = world.getBlockTileEntity(x, y, z);
if (tileEntity instanceof TileEntityConductor)
{
TileEntity[] connectable = ((TileEntityConductor) tileEntity).getAdjacentConnections();
if (connectable != null)
{
float minX = (float) this.minVector.x;
float minY = (float) this.minVector.y;
float minZ = (float) this.minVector.z;
float maxX = (float) this.maxVector.x;
float maxY = (float) this.maxVector.y;
float maxZ = (float) this.maxVector.z;
if (connectable[0] != null)
{
minY = 0.0F;
}
if (connectable[1] != null)
{
maxY = 1.0F;
}
if (connectable[2] != null)
{
minZ = 0.0F;
}
if (connectable[3] != null)
{
maxZ = 1.0F;
}
if (connectable[4] != null)
{
minX = 0.0F;
}
if (connectable[5] != null)
{
maxX = 1.0F;
}
this.setBlockBounds(minX, minY, minZ, maxX, maxY, maxZ);
}
}
}
}
@Override
public void addCollisionBoxesToList(World world, int x, int y, int z, AxisAlignedBB axisalignedbb, List list, Entity entity)
{
if (this.isWireCollision)
{
TileEntity tileEntity = world.getBlockTileEntity(x, y, z);
if (tileEntity instanceof TileEntityConductor)
{
TileEntity[] connectable = ((TileEntityConductor) tileEntity).getAdjacentConnections();
this.setBlockBounds((float) this.minVector.x, (float) this.minVector.y, (float) this.minVector.z, (float) this.maxVector.x, (float) this.maxVector.y, (float) this.maxVector.z);
super.addCollisionBoxesToList(world, x, y, z, axisalignedbb, list, entity);
if (connectable[4] != null)
{
this.setBlockBounds(0, (float) this.minVector.y, (float) this.minVector.z, (float) this.maxVector.x, (float) this.maxVector.y, (float) this.maxVector.z);
super.addCollisionBoxesToList(world, x, y, z, axisalignedbb, list, entity);
}
if (connectable[5] != null)
{
this.setBlockBounds((float) this.minVector.x, (float) this.minVector.y, (float) this.minVector.z, 1, (float) this.maxVector.y, (float) this.maxVector.z);
super.addCollisionBoxesToList(world, x, y, z, axisalignedbb, list, entity);
}
if (connectable[0] != null)
{
this.setBlockBounds((float) this.minVector.x, 0, (float) this.minVector.z, (float) this.maxVector.x, (float) this.maxVector.y, (float) this.maxVector.z);
super.addCollisionBoxesToList(world, x, y, z, axisalignedbb, list, entity);
}
if (connectable[1] != null)
{
this.setBlockBounds((float) this.minVector.x, (float) this.minVector.y, (float) this.minVector.z, (float) this.maxVector.x, 1, (float) this.maxVector.z);
super.addCollisionBoxesToList(world, x, y, z, axisalignedbb, list, entity);
}
if (connectable[2] != null)
{
this.setBlockBounds((float) this.minVector.x, (float) this.minVector.y, 0, (float) this.maxVector.x, (float) this.maxVector.y, (float) this.maxVector.z);
super.addCollisionBoxesToList(world, x, y, z, axisalignedbb, list, entity);
}
if (connectable[3] != null)
{
this.setBlockBounds((float) this.minVector.x, (float) this.minVector.y, (float) this.minVector.z, (float) this.maxVector.x, (float) this.maxVector.y, 1);
super.addCollisionBoxesToList(world, x, y, z, axisalignedbb, list, entity);
}
this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
}
}
else
{
super.addCollisionBoxesToList(world, x, y, z, axisalignedbb, list, entity);
}
}
}

83
APIs/universalelectricity/prefab/block/BlockRotatable.java
View file

@ -1,83 +0,0 @@
package universalelectricity.prefab.block;
import net.minecraft.block.material.Material;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemStack;
import net.minecraft.util.MathHelper;
import net.minecraft.world.World;
import net.minecraftforge.common.ForgeDirection;
/** A block that can rotate based on placed position and wrenching.
*
* @author Calclavia */
public abstract class BlockRotatable extends BlockTile implements IRotatableBlock
{
public BlockRotatable(int id, Material material)
{
super(id, material);
}
@Override
public void onBlockPlacedBy(World world, int x, int y, int z, EntityLivingBase entityLiving, ItemStack itemStack)
{
int angle = MathHelper.floor_double((entityLiving.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3;
int change = 3;
switch (angle)
{
case 0:
change = 2;
break;
case 1:
change = 5;
break;
case 2:
change = 3;
break;
case 3:
change = 4;
break;
}
world.setBlockMetadataWithNotify(x, y, z, change, 3);
}
@Override
public boolean onUseWrench(World world, int x, int y, int z, EntityPlayer par5EntityPlayer, int side, float hitX, float hitY, float hitZ)
{
this.rotateBlock(world, x, y, z, ForgeDirection.getOrientation(side));
return true;
}
public static boolean rotateBlock(World worldObj, int x, int y, int z, ForgeDirection axis, int mask)
{
int rotMeta = worldObj.getBlockMetadata(x, y, z);
int masked = rotMeta & ~mask;
ForgeDirection orientation = ForgeDirection.getOrientation(rotMeta & mask);
ForgeDirection rotated = orientation.getRotation(axis);
worldObj.setBlockMetadataWithNotify(x, y, z, rotated.ordinal() & mask | masked, 3);
return true;
}
@Override
public boolean onSneakMachineActivated(World world, int x, int y, int z, EntityPlayer entityPlayer, int side, float hitX, float hitY, float hitZ)
{
return false;
}
@Override
public ForgeDirection getDirection(World world, int x, int y, int z)
{
return ForgeDirection.getOrientation(world.getBlockMetadata(x, y, z));
}
@Override
public void setDirection(World world, int x, int y, int z, ForgeDirection direction)
{
world.setBlockMetadataWithNotify(x, y, z, direction.ordinal(), 3);
}
}

122
APIs/universalelectricity/prefab/block/BlockTile.java
View file

@ -1,122 +0,0 @@
package universalelectricity.prefab.block;
import java.util.Random;
import net.minecraft.block.ITileEntityProvider;
import net.minecraft.block.material.Material;
import net.minecraft.entity.item.EntityItem;
import net.minecraft.inventory.IInventory;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
/**
* An advanced block class that is to be extended for wrenching capabilities.
*/
public abstract class BlockTile extends BlockAdvanced implements ITileEntityProvider
{
public BlockTile(int id, Material material)
{
super(id, material);
this.isBlockContainer = true;
}
/**
* Called whenever the block is added into the world. Args: world, x, y, z
*/
@Override
public void onBlockAdded(World par1World, int par2, int par3, int par4)
{
super.onBlockAdded(par1World, par2, par3, par4);
}
/**
* ejects contained items into the world, and notifies neighbours of an update, as appropriate
*/
@Override
public void breakBlock(World world, int x, int y, int z, int par5, int par6)
{
this.dropEntireInventory(world, x, y, z, par5, par6);
super.breakBlock(world, x, y, z, par5, par6);
world.removeBlockTileEntity(x, y, z);
}
/**
* Called when the block receives a BlockEvent - see World.addBlockEvent. By default, passes it
* on to the tile entity at this location. Args: world, x, y, z, blockID, EventID, event
* parameter
*/
@Override
public boolean onBlockEventReceived(World par1World, int par2, int par3, int par4, int par5, int par6)
{
super.onBlockEventReceived(par1World, par2, par3, par4, par5, par6);
TileEntity tileentity = par1World.getBlockTileEntity(par2, par3, par4);
return tileentity != null ? tileentity.receiveClientEvent(par5, par6) : false;
}
/**
* Override this if you don't need it. This will eject all items out of this machine if it has
* an inventory.
*/
public void dropEntireInventory(World world, int x, int y, int z, int par5, int par6)
{
TileEntity tileEntity = world.getBlockTileEntity(x, y, z);
if (tileEntity != null)
{
if (tileEntity instanceof IInventory)
{
IInventory inventory = (IInventory) tileEntity;
for (int var6 = 0; var6 < inventory.getSizeInventory(); ++var6)
{
ItemStack var7 = inventory.getStackInSlot(var6);
if (var7 != null)
{
Random random = new Random();
float var8 = random.nextFloat() * 0.8F + 0.1F;
float var9 = random.nextFloat() * 0.8F + 0.1F;
float var10 = random.nextFloat() * 0.8F + 0.1F;
while (var7.stackSize > 0)
{
int var11 = random.nextInt(21) + 10;
if (var11 > var7.stackSize)
{
var11 = var7.stackSize;
}
var7.stackSize -= var11;
EntityItem var12 = new EntityItem(world, (x + var8), (y + var9), (z + var10), new ItemStack(var7.itemID, var11, var7.getItemDamage()));
if (var7.hasTagCompound())
{
var12.getEntityItem().setTagCompound((NBTTagCompound) var7.getTagCompound().copy());
}
float var13 = 0.05F;
var12.motionX = ((float) random.nextGaussian() * var13);
var12.motionY = ((float) random.nextGaussian() * var13 + 0.2F);
var12.motionZ = ((float) random.nextGaussian() * var13);
world.spawnEntityInWorld(var12);
}
}
}
}
}
}
/**
* Returns the TileEntity used by this block. You should use the metadata sensitive version of
* this to get the maximum optimization!
*/
@Override
public TileEntity createNewTileEntity(World var1)
{
return null;
}
}

17
APIs/universalelectricity/prefab/block/IRotatableBlock.java
View file

@ -1,17 +0,0 @@
package universalelectricity.prefab.block;
import net.minecraft.world.World;
import net.minecraftforge.common.ForgeDirection;
/** The interface is applied to Blocks that can rotate.
*
* @author DarkGuardsman */
public interface IRotatableBlock
{
/** @return Gets the facing direction. Always returns the front side of the block. */
public ForgeDirection getDirection(World world, int x, int y, int z);
/** @param Sets the facing direction. */
public void setDirection(World world, int x, int y, int z, ForgeDirection direection);
}

15
APIs/universalelectricity/prefab/network/IPacketReceiver.java
View file

@ -1,15 +0,0 @@
package universalelectricity.prefab.network;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.network.INetworkManager;
import net.minecraft.network.packet.Packet250CustomPayload;
import com.google.common.io.ByteArrayDataInput;
public interface IPacketReceiver
{
/**
* Sends some data to the tile entity.
*/
public void handlePacketData(INetworkManager network, int packetType, Packet250CustomPayload packet, EntityPlayer player, ByteArrayDataInput dataStream);
}

Some files were not shown because too many files have changed in this diff Show more