diff options
Diffstat (limited to 'src/api/java/mekanism')
62 files changed, 5785 insertions, 0 deletions
diff --git a/src/api/java/mekanism/api/Chunk3D.java b/src/api/java/mekanism/api/Chunk3D.java new file mode 100644 index 0000000..f469d5d --- /dev/null +++ b/src/api/java/mekanism/api/Chunk3D.java @@ -0,0 +1,118 @@ +package mekanism.api; + +import net.minecraft.entity.Entity; +import net.minecraft.world.ChunkCoordIntPair; +import net.minecraft.world.World; +import net.minecraft.world.chunk.Chunk; + +/** + * Chunk3D - an integer-based way to keep track of and perform operations on chunks in a Minecraft-based environment. This also takes + * in account the dimension the chunk is in. + * @author aidancbrady + * + */ +public class Chunk3D +{ + public int dimensionId; + + public int xCoord; + public int zCoord; + + /** + * Creates a Chunk3D object from the given x and z coordinates, as well as a dimension. + * @param x - chunk x location + * @param z - chunk z location + * @param dimension - the dimension this Chunk3D is in + */ + public Chunk3D(int x, int z, int dimension) + { + xCoord = x; + zCoord = z; + + dimensionId = dimension; + } + + /** + * Creates a Chunk3D from an entity based on it's location and dimension. + * @param entity - the entity to get the Chunk3D object from + */ + public Chunk3D(Entity entity) + { + xCoord = ((int)entity.posX) >> 4; + zCoord = ((int)entity.posZ) >> 4; + + dimensionId = entity.dimension; + } + + /** + * Creates a Chunk3D from a Coord4D based on it's coordinates and dimension. + * @param coord - the Coord4D object to get this Chunk3D from + */ + public Chunk3D(Coord4D coord) + { + xCoord = coord.xCoord >> 4; + zCoord = coord.zCoord >> 4; + + dimensionId = coord.dimensionId; + } + + /** + * Whether or not this chunk exists in the given world. + * @param world - the world to check in + * @return if the chunk exists + */ + public boolean exists(World world) + { + return world.getChunkProvider().chunkExists(xCoord, zCoord); + } + + /** + * Gets a Chunk object corresponding to this Chunk3D's coordinates. + * @param world - the world to get the Chunk object from + * @return the corresponding Chunk object + */ + public Chunk getChunk(World world) + { + return world.getChunkFromChunkCoords(xCoord, zCoord); + } + + /** + * Returns this Chunk3D in the Minecraft-based ChunkCoordIntPair format. + * @return this Chunk3D as a ChunkCoordIntPair + */ + public ChunkCoordIntPair toPair() + { + return new ChunkCoordIntPair(xCoord, zCoord); + } + + @Override + public Coord4D clone() + { + return new Coord4D(xCoord, zCoord, dimensionId); + } + + @Override + public String toString() + { + return "[Chunk3D: " + xCoord + ", " + zCoord + ", dim=" + dimensionId + "]"; + } + + @Override + public boolean equals(Object obj) + { + return obj instanceof Chunk3D && + ((Chunk3D)obj).xCoord == xCoord && + ((Chunk3D)obj).zCoord == zCoord && + ((Chunk3D)obj).dimensionId == dimensionId; + } + + @Override + public int hashCode() + { + int code = 1; + code = 31 * code + xCoord; + code = 31 * code + zCoord; + code = 31 * code + dimensionId; + return code; + } +} diff --git a/src/api/java/mekanism/api/Coord4D.java b/src/api/java/mekanism/api/Coord4D.java new file mode 100644 index 0000000..1a0f7e4 --- /dev/null +++ b/src/api/java/mekanism/api/Coord4D.java @@ -0,0 +1,421 @@ +package mekanism.api; + +import cpw.mods.fml.common.network.NetworkRegistry.TargetPoint; +import io.netty.buffer.ByteBuf; +import net.minecraft.block.Block; +import net.minecraft.entity.Entity; +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.AxisAlignedBB; +import net.minecraft.util.MathHelper; +import net.minecraft.util.MovingObjectPosition; +import net.minecraft.world.IBlockAccess; +import net.minecraft.world.World; +import net.minecraft.world.chunk.Chunk; +import net.minecraftforge.common.util.ForgeDirection; + +import java.util.ArrayList; + +/** + * Coord4D - an integer-based way to keep track of and perform operations on blocks in a Minecraft-based environment. This also takes + * in account the dimension the coordinate is in. + * @author aidancbrady + * + */ +public class Coord4D +{ + public int xCoord; + public int yCoord; + public int zCoord; + + public int dimensionId; + + /** + * Creates a Coord4D WITHOUT a dimensionId. Don't use unless absolutely necessary. + * @param x - x coordinate + * @param y - y coordinate + * @param z - z coordinate + */ + public Coord4D(int x, int y, int z) + { + xCoord = x; + yCoord = y; + zCoord = z; + + dimensionId = 0; + } + + /** + * Creates a Coord4D from an entity's position, rounded down. + * @param entity - entity to create the Coord4D from + */ + public Coord4D(Entity entity) + { + xCoord = (int)entity.posX; + yCoord = (int)entity.posY; + zCoord = (int)entity.posZ; + + dimensionId = entity.worldObj.provider.dimensionId; + } + + /** + * Creates a Coord4D from the defined x, y, z, and dimension values. + * @param x - x coordinate + * @param y - y coordinate + * @param z - z coordinate + * @param dimension - dimension ID + */ + public Coord4D(int x, int y, int z, int dimension) + { + xCoord = x; + yCoord = y; + zCoord = z; + + dimensionId = dimension; + } + + public Coord4D(MovingObjectPosition mop) + { + xCoord = mop.blockX; + yCoord = mop.blockY; + zCoord = mop.blockZ; + } + + /** + * Gets the metadata of the block representing this Coord4D. + * @param world - world this Coord4D is in + * @return the metadata of this Coord4D's block + */ + public int getMetadata(IBlockAccess world) + { + return world.getBlockMetadata(xCoord, yCoord, zCoord); + } + + /** + * Gets the TileEntity of the block representing this Coord4D. + * @param world - world this Coord4D is in + * @return the TileEntity of this Coord4D's block + */ + public TileEntity getTileEntity(IBlockAccess world) + { + if(world instanceof World && !exists((World)world)) + { + return null; + } + + return world.getTileEntity(xCoord, yCoord, zCoord); + } + + /** + * Gets the Block value of the block representing this Coord4D. + * @param world - world this Coord4D is in + * @return the Block value of this Coord4D's block + */ + public Block getBlock(IBlockAccess world) + { + if(world instanceof World && !exists((World)world)) + { + return null; + } + + return world.getBlock(xCoord, yCoord, zCoord); + } + + /** + * Writes this Coord4D's data to an NBTTagCompound. + * @param nbtTags - tag compound to write to + * @return the tag compound with this Coord4D's data + */ + public NBTTagCompound write(NBTTagCompound nbtTags) + { + nbtTags.setInteger("x", xCoord); + nbtTags.setInteger("y", yCoord); + nbtTags.setInteger("z", zCoord); + nbtTags.setInteger("dimensionId", dimensionId); + + return nbtTags; + } + + /** + * Writes this Coord4D's data to an ArrayList for packet transfer. + * @param data - the ArrayList to add the data to + */ + public void write(ArrayList data) + { + data.add(xCoord); + data.add(yCoord); + data.add(zCoord); + data.add(dimensionId); + } + + /** + * Writes this Coord4D's data to a ByteBuf for packet transfer. + * @param dataStream - the ByteBuf to add the data to + */ + public void write(ByteBuf dataStream) + { + dataStream.writeInt(xCoord); + dataStream.writeInt(yCoord); + dataStream.writeInt(zCoord); + dataStream.writeInt(dimensionId); + } + + /** + * Translates this Coord4D by the defined x, y, and z values. + * @param x - x value to translate + * @param y - y value to translate + * @param z - z value to translate + * @return translated Coord4D + */ + public Coord4D translate(int x, int y, int z) + { + xCoord += x; + yCoord += y; + zCoord += z; + + return this; + } + + /** + * Translates this Coord4D by the defined Coord4D's coordinates, regardless of dimension. + * @param coord - coordinates to translate by + * @return translated Coord4D + */ + public Coord4D translate(Coord4D coord) + { + translate(coord.xCoord, coord.yCoord, coord.zCoord); + + return this; + } + + /** + * Creates and returns a new Coord4D translated to the defined offsets of the side. + * @param side - side to translate this Coord4D to + * @return translated Coord4D + */ + public Coord4D getFromSide(ForgeDirection side) + { + return getFromSide(side, 1); + } + + /** + * Creates and returns a new Coord4D translated to the defined offsets of the side by the defined amount. + * @param side - side to translate this Coord4D to + * @param amount - how far to translate this Coord4D + * @return translated Coord4D + */ + public Coord4D getFromSide(ForgeDirection side, int amount) + { + return new Coord4D(xCoord+(side.offsetX*amount), yCoord+(side.offsetY*amount), zCoord+(side.offsetZ*amount), dimensionId); + } + + public ItemStack getStack(IBlockAccess world) + { + Block block = getBlock(world); + + if(block == null || block == Blocks.air) + { + return null; + } + + return new ItemStack(block, 1, getMetadata(world)); + } + + /** + * Returns a new Coord4D from a defined TileEntity's xCoord, yCoord and zCoord values. + * @param tileEntity - TileEntity at the location that will represent this Coord4D + * @return the Coord4D object from the TileEntity + */ + public static Coord4D get(TileEntity tileEntity) + { + return new Coord4D(tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord, tileEntity.getWorldObj().provider.dimensionId); + } + + /** + * Returns a new Coord4D from a tag compound. + * @param tag - tag compound to read from + * @return the Coord4D from the tag compound + */ + public static Coord4D read(NBTTagCompound tag) + { + return new Coord4D(tag.getInteger("x"), tag.getInteger("y"), tag.getInteger("z"), tag.getInteger("id")); + } + + /** + * Returns a new Coord4D from a ByteBuf. + * @param dataStream - data input to read from + * @return the Coord4D from the data input + */ + public static Coord4D read(ByteBuf dataStream) + { + return new Coord4D(dataStream.readInt(), dataStream.readInt(), dataStream.readInt(), dataStream.readInt()); + } + + /** + * Creates and returns a new Coord4D with values representing the difference between the defined Coord4D + * @param other - the Coord4D to subtract from this + * @return a Coord4D representing the distance between the defined Coord4D + */ + public Coord4D difference(Coord4D other) + { + return new Coord4D(xCoord-other.xCoord, yCoord-other.yCoord, zCoord-other.zCoord, dimensionId); + } + + /** + * A method used to find the ForgeDirection represented by the distance of the defined Coord4D. Most likely won't have many + * applicable uses. + * @param other - Coord4D to find the side difference of + * @return ForgeDirection representing the side the defined relative Coord4D is on to this + */ + public ForgeDirection sideDifference(Coord4D other) + { + Coord4D diff = difference(other); + + for(ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) + { + if(side.offsetX == diff.xCoord && side.offsetY == diff.yCoord && side.offsetZ == diff.zCoord) + { + return side; + } + } + + return ForgeDirection.UNKNOWN; + } + + /** + * Gets the distance to a defined Coord4D. + * @param obj - the Coord4D to find the distance to + * @return the distance to the defined Coord4D + */ + public int distanceTo(Coord4D obj) + { + int subX = xCoord - obj.xCoord; + int subY = yCoord - obj.yCoord; + int subZ = zCoord - obj.zCoord; + return (int)MathHelper.sqrt_double(subX * subX + subY * subY + subZ * subZ); + } + + /** + * Whether or not the defined side of this Coord4D is visible. + * @param side - side to check + * @param world - world this Coord4D is in + * @return + */ + public boolean sideVisible(ForgeDirection side, IBlockAccess world) + { + return world.isAirBlock(xCoord+side.offsetX, yCoord+side.offsetY, zCoord+side.offsetZ); + } + + /** + * Gets a TargetPoint with the defined range from this Coord4D with the appropriate coordinates and dimension ID. + * @param range - the range the packet can be sent in of this Coord4D + * @return TargetPoint relative to this Coord4D + */ + public TargetPoint getTargetPoint(double range) + { + return new TargetPoint(dimensionId, xCoord, yCoord, zCoord, range); + } + + /** + * Steps this Coord4D in the defined side's offset without creating a new value. + * @param side - side to step towards + * @return this Coord4D + */ + public Coord4D step(ForgeDirection side) + { + return translate(side.offsetX, side.offsetY, side.offsetZ); + } + + /** + * Whether or not the chunk this Coord4D is in exists and is loaded. + * @param world - world this Coord4D is in + * @return the chunk of this Coord4D + */ + public boolean exists(World world) + { + return world.getChunkProvider() == null || world.getChunkProvider().chunkExists(xCoord >> 4, zCoord >> 4); + } + + /** + * Gets the chunk this Coord4D is in. + * @param world - world this Coord4D is in + * @return the chunk of this Coord4D + */ + public Chunk getChunk(World world) + { + return world.getChunkFromBlockCoords(xCoord, zCoord); + } + + /** + * Gets the Chunk3D object with chunk coordinates correlating to this Coord4D's location + * @return Chunk3D with correlating chunk coordinates. + */ + public Chunk3D getChunk3D() + { + return new Chunk3D(this); + } + + /** + * Whether or not the block this Coord4D represents is an air block. + * @param world - world this Coord4D is in + * @return if this Coord4D is an air block + */ + public boolean isAirBlock(IBlockAccess world) + { + return world.isAirBlock(xCoord, yCoord, zCoord); + } + + /** + * Whether or not this block this Coord4D represents is replaceable. + * @param world - world this Coord4D is in + * @return if this Coord4D is replaceable + */ + public boolean isReplaceable(IBlockAccess world) + { + return getBlock(world).isReplaceable(world, xCoord, yCoord, zCoord); + } + + /** + * Gets a bounding box that contains the area this Coord4D would take up in a world. + * @return this Coord4D's bounding box + */ + public AxisAlignedBB getBoundingBox() + { + return AxisAlignedBB.getBoundingBox(xCoord, yCoord, zCoord, xCoord+1, yCoord+1, zCoord+1); + } + + @Override + public Coord4D clone() + { + return new Coord4D(xCoord, yCoord, zCoord, dimensionId); + } + + @Override + public String toString() + { + return "[Coord4D: " + xCoord + ", " + yCoord + ", " + zCoord + ", dim=" + dimensionId + "]"; + } + + @Override + public boolean equals(Object obj) + { + return obj instanceof Coord4D && + ((Coord4D)obj).xCoord == xCoord && + ((Coord4D)obj).yCoord == yCoord && + ((Coord4D)obj).zCoord == zCoord && + ((Coord4D)obj).dimensionId == dimensionId; + } + + @Override + public int hashCode() + { + int code = 1; + code = 31 * code + xCoord; + code = 31 * code + yCoord; + code = 31 * code + zCoord; + code = 31 * code + dimensionId; + return code; + } +}
\ No newline at end of file diff --git a/src/api/java/mekanism/api/EnumColor.java b/src/api/java/mekanism/api/EnumColor.java new file mode 100644 index 0000000..df9ba74 --- /dev/null +++ b/src/api/java/mekanism/api/EnumColor.java @@ -0,0 +1,112 @@ +package mekanism.api; + +import net.minecraft.util.StatCollector; + +/** + * Simple color enum for adding colors to in-game GUI strings of text. + * @author AidanBrady + * + */ +public enum EnumColor +{ + BLACK("\u00a70", "black", "Black", new int[] {0, 0, 0}, 0), + DARK_BLUE("\u00a71", "darkBlue", "Blue", new int[] {0, 0, 170}, 4), + DARK_GREEN("\u00a72", "darkGreen", "Green", new int[] {0, 170, 0}, 2), + DARK_AQUA("\u00a73", "darkAqua", "Cyan", new int[] {0, 255, 255}, 6), + DARK_RED("\u00a74", "darkRed", null, new int[] {170, 0, 0}, -1), + PURPLE("\u00a75", "purple", "Purple", new int[] {170, 0, 170}, 5), + ORANGE("\u00a76", "orange", "Orange", new int[] {255, 170, 0}, 14), + GREY("\u00a77", "grey", "LightGray", new int[] {170, 170, 170}, 7), + DARK_GREY("\u00a78", "darkGrey", "Gray", new int[] {85, 85, 85}, 8), + INDIGO("\u00a79", "indigo", "LightBlue", new int[] {85, 85, 255}, 12), + BRIGHT_GREEN("\u00a7a", "brightGreen", "Lime", new int[] {85, 255, 85}, 10), + AQUA("\u00a7b", "aqua", null, new int[] {85, 255, 255}, -1), + RED("\u00a7c", "red", "Red", new int[] {255, 0, 0}, 1), + PINK("\u00a7d", "pink", "Magenta", new int[] {255, 85, 255}, 13), + YELLOW("\u00a7e", "yellow", "Yellow", new int[] {255, 255, 85}, 11), + WHITE("\u00a7f", "white", "White", new int[] {255, 255, 255}, 15), + //Extras for dye-completeness + BROWN("\u00a76", "brown", "Brown", new int[] {150, 75, 0}, 3), + BRIGHT_PINK("\u00a7d", "brightPink", "Pink", new int[] {255, 192, 203}, 9); + + public static EnumColor[] DYES = new EnumColor[] {BLACK, RED, DARK_GREEN, BROWN, DARK_BLUE, PURPLE, DARK_AQUA, GREY, DARK_GREY, BRIGHT_PINK, BRIGHT_GREEN, YELLOW, INDIGO, PINK, ORANGE, WHITE}; + + /** The color code that will be displayed */ + public final String code; + + public final int[] rgbCode; + + public final int mcMeta; + + /** A friendly name of the color. */ + public String unlocalizedName; + + public String dyeName; + + private EnumColor(String s, String n, String dye, int[] rgb, int meta) + { + code = s; + unlocalizedName = n; + dyeName = dye; + rgbCode = rgb; + mcMeta = meta; + } + + /** + * Gets the localized name of this color by translating the unlocalized name. + * @return localized name + */ + public String getLocalizedName() + { + return StatCollector.translateToLocal("color." + unlocalizedName); + } + + public String getDyeName() + { + return StatCollector.translateToLocal("dye." + unlocalizedName); + } + + public String getOreDictName() + { + return dyeName; + } + + /** + * Gets the name of this color with it's color prefix code. + * @return the color's name and color prefix + */ + public String getName() + { + return code + getLocalizedName(); + } + + public String getDyedName() + { + return code + getDyeName(); + } + + /** + * Gets the 0-1 of this color's RGB value by dividing by 255 (used for OpenGL coloring). + * @param index - R:0, G:1, B:2 + * @return the color value + */ + public float getColor(int index) + { + return (float)rgbCode[index]/255F; + } + + /** + * Gets the value of this color mapped to MC in-game item colors present in dyes and wool. + * @return mc meta value + */ + public int getMetaValue() + { + return mcMeta; + } + + @Override + public String toString() + { + return code; + } +} diff --git a/src/api/java/mekanism/api/IClientTicker.java b/src/api/java/mekanism/api/IClientTicker.java new file mode 100644 index 0000000..2288973 --- /dev/null +++ b/src/api/java/mekanism/api/IClientTicker.java @@ -0,0 +1,8 @@ +package mekanism.api; + +public interface IClientTicker +{ + public void clientTick(); + + public boolean needsTicks(); +} diff --git a/src/api/java/mekanism/api/IConfigurable.java b/src/api/java/mekanism/api/IConfigurable.java new file mode 100644 index 0000000..512fabf --- /dev/null +++ b/src/api/java/mekanism/api/IConfigurable.java @@ -0,0 +1,27 @@ +package mekanism.api; + +import net.minecraft.entity.player.EntityPlayer; + +/** + * Implement this in your TileEntity class if your block can be modified by a Configurator. + * @author aidancbrady + * + */ +public interface IConfigurable +{ + /** + * Called when a player shift-right clicks this block with a Configurator. + * @param player - the player who clicked the block + * @param side - the side the block was clicked on + * @return whether or not an action was performed + */ + public boolean onSneakRightClick(EntityPlayer player, int side); + + /** + * Called when a player right clicks this block with a Configurator. + * @param player - the player who clicked the block + * @param side - the side the block was clicked on + * @return whether or not an action was performed + */ + public boolean onRightClick(EntityPlayer player, int side); +} diff --git a/src/api/java/mekanism/api/IFilterAccess.java b/src/api/java/mekanism/api/IFilterAccess.java new file mode 100644 index 0000000..abdcf29 --- /dev/null +++ b/src/api/java/mekanism/api/IFilterAccess.java @@ -0,0 +1,31 @@ +package mekanism.api; + +import net.minecraft.nbt.NBTTagCompound; + +/** + * Implement this in your TileEntity class if you wish for Mekanism filters to be able to store any of their + * information. + * @author aidancbrady + * + */ +public interface IFilterAccess +{ + /** + * Collects the TileEntity's filter card data into the parameterized NBTTagCompound. + * @param nbtTags - the NBTTagCompound of the filter card ItemStack + * @return the NBTTagCompound that now contains the TileEntity's filter card data + */ + public NBTTagCompound getFilterData(NBTTagCompound nbtTags); + + /** + * Retrieves the TileEntity's data contained in the filter card based on the given NBTTagCompopund. + * @param nbtTags - the NBTTagCompound of the filter card ItemStack + */ + public void setFilterData(NBTTagCompound nbtTags); + + /** + * A String name of this TileEntity that will be displayed as the type of data on the filter card. + * @return the String name of this TileEntity + */ + public String getDataType(); +} diff --git a/src/api/java/mekanism/api/IHeatTransfer.java b/src/api/java/mekanism/api/IHeatTransfer.java new file mode 100644 index 0000000..da682e1 --- /dev/null +++ b/src/api/java/mekanism/api/IHeatTransfer.java @@ -0,0 +1,28 @@ +package mekanism.api; + +import net.minecraftforge.common.util.ForgeDirection; + +public interface IHeatTransfer +{ + /**The value of the zero point of our temperature scale in kelvin*/ + public static final double AMBIENT_TEMP = 300; + + /**The heat transfer coefficient for air*/ + public static final double AIR_INVERSE_COEFFICIENT = 10000; + + public double getTemp(); + + public double getInverseConductionCoefficient(); + + public double getInsulationCoefficient(ForgeDirection side); + + public void transferHeatTo(double heat); + + public double[] simulateHeat(); + + public double applyTemperatureChange(); + + public boolean canConnectHeat(ForgeDirection side); + + public IHeatTransfer getAdjacent(ForgeDirection side); +} diff --git a/src/api/java/mekanism/api/IMekWrench.java b/src/api/java/mekanism/api/IMekWrench.java new file mode 100644 index 0000000..6ac4b05 --- /dev/null +++ b/src/api/java/mekanism/api/IMekWrench.java @@ -0,0 +1,8 @@ +package mekanism.api; + +import net.minecraft.entity.player.EntityPlayer; + +public interface IMekWrench +{ + public boolean canUseWrench(EntityPlayer player, int x, int y, int z); +} diff --git a/src/api/java/mekanism/api/ISalinationSolar.java b/src/api/java/mekanism/api/ISalinationSolar.java new file mode 100644 index 0000000..20e3e1e --- /dev/null +++ b/src/api/java/mekanism/api/ISalinationSolar.java @@ -0,0 +1,11 @@ +package mekanism.api; + +/** + * Implement this class in a TileEntity if you wish for it to be able to heat up a Salination Plant. + * @author aidancbrady + * + */ +public interface ISalinationSolar +{ + public boolean seesSun(); +} diff --git a/src/api/java/mekanism/api/ItemRetriever.java b/src/api/java/mekanism/api/ItemRetriever.java new file mode 100644 index 0000000..c2820f0 --- /dev/null +++ b/src/api/java/mekanism/api/ItemRetriever.java @@ -0,0 +1,112 @@ +package mekanism.api; + +import net.minecraft.block.Block; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; + +/** + * Use this class's 'getItem()' method to retrieve ItemStacks from the 'Mekanism' + * class. + * @author AidanBrady + * + */ +public final class ItemRetriever +{ + /** The 'MekanismItems' class that items are retrieved from. */ + private static Class MekanismItems; + + /** The 'MekanismBlocks' class that blocks are retrieved from. */ + private static Class MekanismBlocks; + + /** + * Attempts to retrieve an ItemStack of an item with the declared identifier. + * + * Mekanism identifiers follow an easy-to-remember pattern. All identifiers + * are identical to the String returned by 'getItemName().' None include spaces, + * and all start with a capital letter. The name that shows up in-game can be + * stripped down to identifier form by removing spaces and all non-alphabetic + * characters (,./'=-_). Below is an example: + * + * ItemStack enrichedAlloy = ItemRetriever.getItem("EnrichedAlloy"); + * + * Note that for items or blocks that have specific metadata you will need to create + * a new ItemStack with that specified value, as this will only return an ItemStack + * with the meta value '0.' + * + * Make sure you run this in or after FMLPostInitializationEvent runs, because most + * items are registered when FMLInitializationEvent runs. However, some items ARE + * registered later in order to hook into other mods. In a rare circumstance you may + * have to add "after:Mekanism" in the @Mod 'dependencies' annotation. + * + * @param identifier - a String to be searched in the 'MekanismItems' class + * @return an ItemStack of the declared identifier, otherwise null. + */ + public static ItemStack getItem(String identifier) + { + try { + if(MekanismItems == null) + { + MekanismItems = Class.forName("mekanism.common.MekanismItems"); + } + + Object ret = MekanismItems.getField(identifier).get(null); + + if(ret instanceof Item) + { + return new ItemStack((Item)ret, 1); + } + else { + return null; + } + } catch(Exception e) { + System.err.println("Error retrieving item with identifier '" + identifier + "': " + e.getMessage()); + return null; + } + } + + /** + * Attempts to retrieve an ItemStack of a block with the declared identifier. + * + * Mekanism identifiers follow an easy-to-remember pattern. All identifiers + * are identical to the String returned by 'getItemName().' None include spaces, + * and all start with a capital letter. The name that shows up in-game can be + * stripped down to identifier form by removing spaces and all non-alphabetic + * characters (,./'=-_). Below is an example: + * + * ItemStack enrichedAlloy = ItemRetriever.getItem("EnrichedAlloy"); + * + * Note that for items or blocks that have specific metadata you will need to create + * a new ItemStack with that specified value, as this will only return an ItemStack + * with the meta value '0.' + * + * Make sure you run this in or after FMLPostInitializationEvent runs, because most + * items are registered when FMLInitializationEvent runs. However, some items ARE + * registered later in order to hook into other mods. In a rare circumstance you may + * have to add "after:Mekanism" in the @Mod 'dependencies' annotation. + * + * @param identifier - a String to be searched in the 'MekanismBlocks' class + * @return an ItemStack of the declared identifier, otherwise null. + */ + public static ItemStack getBlock(String identifier) + { + try { + if(MekanismBlocks == null) + { + MekanismBlocks = Class.forName("mekanism.common.MekanismBlocks"); + } + + Object ret = MekanismBlocks.getField(identifier).get(null); + + if(ret instanceof Block) + { + return new ItemStack((Block)ret, 1); + } + else { + return null; + } + } catch(Exception e) { + System.err.println("Error retrieving block with identifier '" + identifier + "': " + e.getMessage()); + return null; + } + } +} diff --git a/src/api/java/mekanism/api/MekanismAPI.java b/src/api/java/mekanism/api/MekanismAPI.java new file mode 100644 index 0000000..abdd6da --- /dev/null +++ b/src/api/java/mekanism/api/MekanismAPI.java @@ -0,0 +1,50 @@ +package mekanism.api; + +import java.util.HashSet; +import java.util.Set; + +import mekanism.api.util.BlockInfo; + +import net.minecraft.block.Block; +import net.minecraft.item.Item; +import net.minecraftforge.oredict.OreDictionary; +import cpw.mods.fml.common.eventhandler.Event; + +public class MekanismAPI +{ + //Add a BlockInfo value here if you don't want a certain block to be picked up by cardboard boxes + private static Set<BlockInfo> cardboardBoxIgnore = new HashSet<BlockInfo>(); + + /** Mekanism debug mode */ + public static boolean debug = false; + + public static boolean isBlockCompatible(Item item, int meta) + { + for(BlockInfo i : cardboardBoxIgnore) + { + if(i.block == Block.getBlockFromItem(item) && (i.meta == OreDictionary.WILDCARD_VALUE || i.meta == meta)) + { + return false; + } + } + + return true; + } + + public static void addBoxBlacklist(Block block, int meta) + { + cardboardBoxIgnore.add(new BlockInfo(block, meta)); + } + + public static void removeBoxBlacklist(Block block, int meta) + { + cardboardBoxIgnore.remove(new BlockInfo(block, meta)); + } + + public static Set<BlockInfo> getBoxIgnore() + { + return cardboardBoxIgnore; + } + + public static class BoxBlacklistEvent extends Event {} +} diff --git a/src/api/java/mekanism/api/MekanismConfig.java b/src/api/java/mekanism/api/MekanismConfig.java new file mode 100644 index 0000000..2f9ea68 --- /dev/null +++ b/src/api/java/mekanism/api/MekanismConfig.java @@ -0,0 +1,137 @@ +package mekanism.api; + +import java.util.HashMap; +import java.util.Map; + +import mekanism.api.util.UnitDisplayUtils.EnergyType; +import mekanism.api.util.UnitDisplayUtils.TempType; + +public class MekanismConfig +{ + public static class general + { + public static boolean updateNotifications = true; + public static boolean controlCircuitOreDict = true; + public static boolean logPackets = false; + public static boolean dynamicTankEasterEgg = false; + public static boolean voiceServerEnabled = true; + public static boolean cardboardSpawners = true; + public static boolean enableWorldRegeneration = true; + public static boolean creativeOverrideElectricChest = true; + public static boolean spawnBabySkeletons = true; + public static int obsidianTNTBlastRadius = 12; + public static int osmiumPerChunk = 12; + public static int copperPerChunk = 16; + public static int tinPerChunk = 14; + public static int saltPerChunk = 2; + public static int obsidianTNTDelay = 100; + public static int UPDATE_DELAY = 10; + public static int VOICE_PORT = 36123; + public static int maxUpgradeMultiplier = 10; + public static int userWorldGenVersion = 0; + public static double ENERGY_PER_REDSTONE = 10000; + public static int ETHENE_BURN_TIME = 40; + public static double DISASSEMBLER_USAGE = 10; + public static EnergyType activeType = EnergyType.J; + public static TempType tempUnit = TempType.K; + public static double TO_IC2; + public static double TO_TE; + public static double FROM_H2; + public static double FROM_IC2; + public static double FROM_TE; + public static int laserRange; + public static double laserEnergyNeededPerHardness; + public static double minerSilkMultiplier = 6; + public static boolean blacklistIC2; + public static boolean blacklistRF; + public static boolean destroyDisabledBlocks; + public static boolean enableAmbientLighting; + public static int ambientLightingLevel; + public static boolean prefilledPortableTanks; + public static double armoredJetpackDamageRatio; + public static int armoredJetpackDamageMax; + public static boolean aestheticWorldDamage; + public static boolean opsBypassRestrictions; + public static double solarEvaporationSpeed; + public static int maxJetpackGas; + public static int maxScubaGas; + public static int maxFlamethrowerGas; + } + + public static class client + { + public static boolean enablePlayerSounds = true; + public static boolean enableMachineSounds = true; + public static boolean fancyUniversalCableRender = true; + public static boolean holidays = true; + public static float baseSoundVolume = 1F; + public static boolean machineEffects = true; + public static boolean oldTransmitterRender = false; + public static boolean replaceSoundsWhenResuming = true; + public static boolean renderCTM = true; + } + + public static class machines + { + private static Map<String, Boolean> config = new HashMap<String, Boolean>(); + + public static boolean isEnabled(String type) + { + return config.get(type) != null && config.get(type); + } + + public static void setEntry(String type, boolean enabled) + { + config.put(type, enabled); + } + } + + public static class usage + { + public static double enrichmentChamberUsage; + public static double osmiumCompressorUsage; + public static double combinerUsage; + public static double crusherUsage; + public static double factoryUsage; + public static double metallurgicInfuserUsage; + public static double purificationChamberUsage; + public static double energizedSmelterUsage; + public static double digitalMinerUsage; + public static double electricPumpUsage; + public static double rotaryCondensentratorUsage; + public static double oxidationChamberUsage; + public static double chemicalInfuserUsage; + public static double chemicalInjectionChamberUsage; + public static double precisionSawmillUsage; + public static double chemicalDissolutionChamberUsage; + public static double chemicalWasherUsage; + public static double chemicalCrystallizerUsage; + public static double seismicVibratorUsage; + public static double pressurizedReactionBaseUsage; + public static double fluidicPlenisherUsage; + public static double laserUsage; + public static double gasCentrifugeUsage; + public static double heavyWaterElectrolysisUsage; + } + + public static class generators + { + public static double advancedSolarGeneration; + public static double bioGeneration; + public static double heatGeneration; + public static double heatGenerationLava; + public static double heatGenerationNether; + public static double solarGeneration; + + public static double windGenerationMin; + public static double windGenerationMax; + + public static int windGenerationMinY; + public static int windGenerationMaxY; + } + + public static class tools + { + public static double armorSpawnRate; + } +} diff --git a/src/api/java/mekanism/api/Pos3D.java b/src/api/java/mekanism/api/Pos3D.java new file mode 100644 index 0000000..75f83a0 --- /dev/null +++ b/src/api/java/mekanism/api/Pos3D.java @@ -0,0 +1,458 @@ +package mekanism.api; + +import net.minecraft.entity.Entity; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.AxisAlignedBB; +import net.minecraft.util.MathHelper; +import net.minecraft.util.MovingObjectPosition; +import net.minecraft.util.Vec3; +import net.minecraftforge.common.util.ForgeDirection; + +/** + * Pos3D - a way of performing operations on objects in a three dimensional environment. + * @author aidancbrady + * + */ +public class Pos3D +{ + public double xPos; + public double yPos; + public double zPos; + + public Pos3D() + { + this(0, 0, 0); + } + + public Pos3D(Vec3 vec) + { + xPos = vec.xCoord; + yPos = vec.yCoord; + zPos = vec.zCoord; + } + + public Pos3D(MovingObjectPosition mop) + { + xPos = mop.blockX; + yPos = mop.blockY; + zPos = mop.blockZ; + } + + public Pos3D(double x, double y, double z) + { + xPos = x; + yPos = y; + zPos = z; + } + + public Pos3D(Coord4D coord) + { + xPos = coord.xCoord; + yPos = coord.yCoord; + zPos = coord.zCoord; + } + + /** + * Creates a Pos3D with an entity's posX, posY, and posZ values. + * @param entity - entity to create the Pos3D from + */ + public Pos3D(Entity entity) + { + this(entity.posX, entity.posY, entity.posZ); + } + + /** + * Creates a Pos3D with a TileEntity's xCoord, yCoord and zCoord values. + * @param tileEntity - TileEntity to create the Pos3D from + */ + public Pos3D(TileEntity tileEntity) + { + this(tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord); + } + + /** + * Returns a new Pos3D from a tag compound. + * @param tag - tag compound to read from + * @return the Pos3D from the tag compound + */ + public static Pos3D read(NBTTagCompound tag) + { + return new Pos3D(tag.getDouble("x"), tag.getDouble("y"), tag.getDouble("z")); + } + + /** + * Writes this Pos3D's data to an NBTTagCompound. + * @param nbtTags - tag compound to write to + * @return the tag compound with this Pos3D's data + */ + public NBTTagCompound write(NBTTagCompound nbtTags) + { + nbtTags.setDouble("x", xPos); + nbtTags.setDouble("y", yPos); + nbtTags.setDouble("z", zPos); + + return nbtTags; + } + + /** + * Creates and returns a Pos3D with values representing the difference between this and the Pos3D in the parameters. + * @param pos - Pos3D to subtract + * @return difference of the two Pos3Ds + */ + public Pos3D diff(Pos3D pos) + { + return new Pos3D(xPos-pos.xPos, yPos-pos.yPos, zPos-pos.zPos); + } + + /** + * Creates a new Pos3D from the motion of an entity. + * @param entity + * @return Pos3D representing the motion of the given entity + */ + public static Pos3D fromMotion(Entity entity) + { + return new Pos3D(entity.motionX, entity.motionY, entity.motionZ); + } + + /** + * Creates a new Coord4D representing this Pos3D in the provided dimension. + * @param dimensionId - the dimension this Pos3D is in + * @return Coord4D representing this Pos3D + */ + public Coord4D getCoord(int dimensionId) + { + return new Coord4D((int)xPos, (int)yPos, (int)zPos, dimensionId); + } + + /** + * Centres a block-derived Pos3D + */ + public Pos3D centre() + { + return translate(0.5, 0.5, 0.5); + } + + /** + * Translates this Pos3D by the defined values. + * @param x - amount to translate on the x axis + * @param y - amount to translate on the y axis + * @param z - amount to translate on the z axis + * @return the translated Pos3D + */ + public Pos3D translate(double x, double y, double z) + { + xPos += x; + yPos += y; + zPos += z; + + return this; + } + + /** + * Performs the same operation as translate(x, y, z), but with a Pos3D value instead. + * @param pos - Pos3D value to translate by + * @return translated Pos3D + */ + public Pos3D translate(Pos3D pos) + { + return translate(pos.xPos, pos.yPos, pos.zPos); + } + + /** + * Performs the same operation as translate(x, y, z), but by a set amount in a ForgeDirection + */ + public Pos3D translate(ForgeDirection direction, double amount) + { + return translate(direction.offsetX * amount, direction.offsetY * amount, direction.offsetZ * amount); + } + + /** + * Performs the same operation as translate(x, y, z), but by a set amount in a ForgeDirection + */ + public Pos3D translateExcludingSide(ForgeDirection direction, double amount) + { + if(direction.offsetX == 0) xPos += amount; + if(direction.offsetY == 0) yPos += amount; + if(direction.offsetZ == 0) zPos += amount; + + return this; + } + + /** + * Returns the distance between this and the defined Pos3D. + * @param pos - the Pos3D to find the distance to + * @return the distance between this and the defined Pos3D + */ + public double distance(Pos3D pos) + { + double subX = xPos - pos.xPos; + double subY = yPos - pos.yPos; + double subZ = zPos - pos.zPos; + return MathHelper.sqrt_double(subX * subX + subY * subY + subZ * subZ); + } + + /** + * Rotates this Pos3D by the defined yaw value. + * @param yaw - yaw to rotate by + * @return rotated Pos3D + */ + public Pos3D rotateYaw(double yaw) + { + double yawRadians = Math.toRadians(yaw); + + double x = xPos; + double z = zPos; + + if(yaw != 0) + { + xPos = x * Math.cos(yawRadians) - z * Math.sin(yawRadians); + zPos = z * Math.cos(yawRadians) + x * Math.sin(yawRadians); + } + + return this; + } + + public Pos3D rotatePitch(double pitch) + { + double pitchRadians = Math.toRadians(pitch); + + double y = yPos; + double z = zPos; + + if(pitch != 0) + { + yPos = y * Math.cos(pitchRadians) - z * Math.sin(pitchRadians); + zPos = z * Math.cos(pitchRadians) + y * Math.sin(pitchRadians); + } + + return this; + } + + public Pos3D rotate(double yaw, double pitch) + { + return rotate(yaw, pitch, 0); + } + + public Pos3D rotate(double yaw, double pitch, double roll) + { + double yawRadians = Math.toRadians(yaw); + double pitchRadians = Math.toRadians(pitch); + double rollRadians = Math.toRadians(roll); + + double x = xPos; + double y = yPos; + double z = zPos; + + xPos = 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)); + zPos = 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)); + yPos = -x * Math.sin(pitchRadians) + z * Math.cos(pitchRadians) * Math.sin(rollRadians) + y * Math.cos(pitchRadians) * Math.cos(rollRadians); + + return this; + } + + public Pos3D multiply(Pos3D pos) + { + xPos *= pos.xPos; + yPos *= pos.yPos; + zPos *= pos.zPos; + + return this; + } + + /** + * Scales this Pos3D by the defined x, y, an z values. + * @param x - x value to scale by + * @param y - y value to scale by + * @param z - z value to scale by + * @return scaled Pos3D + */ + public Pos3D scale(double x, double y, double z) + { + xPos *= x; + yPos *= y; + zPos *= z; + + return this; + } + + /** + * Performs the same operation as scale(x, y, z), but with a value representing all three dimensions. + * @param scale - value to scale by + * @return scaled Pos3D + */ + public Pos3D scale(double scale) + { + return scale(scale, scale, scale); + } + + public Pos3D rotate(float angle, Pos3D axis) + { + return translateMatrix(getRotationMatrix(angle, axis), this); + } + + public double[] getRotationMatrix(float angle) + { + double[] matrix = new double[16]; + Pos3D axis = clone().normalize(); + + double x = axis.xPos; + double y = axis.yPos; + double z = axis.zPos; + + 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 Pos3D translateMatrix(double[] matrix, Pos3D translation) + { + double x = translation.xPos * matrix[0] + translation.yPos * matrix[1] + translation.zPos * matrix[2] + matrix[3]; + double y = translation.xPos * matrix[4] + translation.yPos * matrix[5] + translation.zPos * matrix[6] + matrix[7]; + double z = translation.xPos * matrix[8] + translation.yPos * matrix[9] + translation.zPos * matrix[10] + matrix[11]; + + translation.xPos = x; + translation.yPos = y; + translation.zPos = z; + + return translation; + } + + public static double[] getRotationMatrix(float angle, Pos3D axis) + { + return axis.getRotationMatrix(angle); + } + + public double anglePreNorm(Pos3D pos2) + { + return Math.acos(dotProduct(pos2)); + } + + public static double anglePreNorm(Pos3D pos1, Pos3D pos2) + { + return Math.acos(pos1.clone().dotProduct(pos2)); + } + + public double dotProduct(Pos3D pos) + { + return xPos * pos.xPos + yPos * pos.yPos + zPos * pos.zPos; + } + + public Pos3D crossProduct(Pos3D compare) + { + return clone().toCrossProduct(compare); + } + + public Pos3D toCrossProduct(Pos3D compare) + { + double newX = yPos * compare.zPos - zPos * compare.yPos; + double newY = zPos * compare.xPos - xPos * compare.zPos; + double newZ = xPos * compare.yPos - yPos * compare.xPos; + + xPos = newX; + yPos = newY; + zPos = newZ; + + return this; + } + + public Pos3D xCrossProduct() + { + return new Pos3D(0.0D, zPos, -yPos); + } + + public Pos3D zCrossProduct() + { + return new Pos3D(-yPos, xPos, 0.0D); + } + + public Pos3D getPerpendicular() + { + if(zPos == 0) + { + return zCrossProduct(); + } + + return xCrossProduct(); + } + + public Pos3D floor() + { + return new Pos3D(Math.floor(xPos), Math.floor(yPos), Math.floor(zPos)); + } + + public double getMagnitude() + { + return Math.sqrt(xPos * xPos + yPos * yPos + zPos * zPos); + } + + public Pos3D normalize() + { + double d = getMagnitude(); + + if (d != 0) + { + this.scale(1 / d); + } + + return this; + } + + public static AxisAlignedBB getAABB(Pos3D pos1, Pos3D pos2) + { + return AxisAlignedBB.getBoundingBox( + Math.min(pos1.xPos, pos2.xPos), + Math.min(pos1.yPos, pos2.yPos), + Math.min(pos1.zPos, pos2.zPos), + Math.max(pos1.xPos, pos2.xPos), + Math.max(pos1.yPos, pos2.yPos), + Math.max(pos1.zPos, pos2.zPos) + ); + } + + @Override + public Pos3D clone() + { + return new Pos3D(xPos, yPos, zPos); + } + + @Override + public String toString() + { + return "[Pos3D: " + xPos + ", " + yPos + ", " + zPos + "]"; + } + + @Override + public boolean equals(Object obj) + { + return obj instanceof Pos3D && + ((Pos3D)obj).xPos == xPos && + ((Pos3D)obj).yPos == yPos && + ((Pos3D)obj).zPos == zPos; + } + + @Override + public int hashCode() + { + int code = 1; + code = 31 * code + new Double(xPos).hashCode(); + code = 31 * code + new Double(yPos).hashCode(); + code = 31 * code + new Double(zPos).hashCode(); + return code; + } +} diff --git a/src/api/java/mekanism/api/Range4D.java b/src/api/java/mekanism/api/Range4D.java new file mode 100644 index 0000000..40905a6 --- /dev/null +++ b/src/api/java/mekanism/api/Range4D.java @@ -0,0 +1,114 @@ +package mekanism.api; + +import net.minecraft.entity.player.EntityPlayer; +import cpw.mods.fml.common.FMLCommonHandler; + +public class Range4D +{ + public int dimensionId; + + public int xMin; + public int yMin; + public int zMin; + public int xMax; + public int yMax; + public int zMax; + + public Range4D(int minX, int minY, int minZ, int maxX, int maxY, int maxZ, int dimension) + { + xMin = minX; + yMin = minY; + zMin = minZ; + xMax = maxX; + yMax = maxY; + zMax = maxZ; + + dimensionId = dimension; + } + + public Range4D(Chunk3D chunk) + { + xMin = chunk.xCoord*16; + yMin = 0; + zMin = chunk.zCoord*16; + xMax = xMin+16; + yMax = 255; + zMax = zMin+16; + + dimensionId = chunk.dimensionId; + } + + public Range4D(Coord4D coord) + { + xMin = coord.xCoord; + yMin = coord.yCoord; + zMin = coord.zCoord; + + xMax = coord.xCoord+1; + yMax = coord.yCoord+1; + zMax = coord.zCoord+1; + + dimensionId = coord.dimensionId; + } + + public static Range4D getChunkRange(EntityPlayer player) + { + int radius = FMLCommonHandler.instance().getMinecraftServerInstance().getConfigurationManager().getViewDistance(); + + return new Range4D(new Chunk3D(player)).expandChunks(radius); + } + + public Range4D expandChunks(int chunks) + { + xMin -= chunks*16; + xMax += chunks*16; + zMin -= chunks*16; + zMax += chunks*16; + + return this; + } + + public boolean intersects(Range4D range) + { + return (xMax+1 - 1.E-05D > range.xMin) && (range.xMax+1 - 1.E-05D > xMin) && (yMax+1 - 1.E-05D > range.yMin) && (range.yMax+1 - 1.E-05D > yMin) && (zMax+1 - 1.E-05D > range.zMin) && (range.zMax+1 - 1.E-05D > zMin); + } + + @Override + public Range4D clone() + { + return new Range4D(xMin, yMin, zMin, xMax, yMax, zMax, dimensionId); + } + + @Override + public String toString() + { + return "[Range4D: " + xMin + ", " + yMin + ", " + zMin + ", " + xMax + ", " + yMax + ", " + zMax + ", dim=" + dimensionId + "]"; + } + + @Override + public boolean equals(Object obj) + { + return obj instanceof Range4D && + ((Range4D)obj).xMin == xMin && + ((Range4D)obj).yMin == yMin && + ((Range4D)obj).zMin == zMin && + ((Range4D)obj).xMax == xMax && + ((Range4D)obj).yMax == yMax && + ((Range4D)obj).zMax == zMax && + ((Range4D)obj).dimensionId == dimensionId; + } + + @Override + public int hashCode() + { + int code = 1; + code = 31 * code + xMin; + code = 31 * code + yMin; + code = 31 * code + zMin; + code = 31 * code + xMax; + code = 31 * code + yMax; + code = 31 * code + zMax; + code = 31 * code + dimensionId; + return code; + } +} diff --git a/src/api/java/mekanism/api/TabProxy.java b/src/api/java/mekanism/api/TabProxy.java new file mode 100644 index 0000000..c562c02 --- /dev/null +++ b/src/api/java/mekanism/api/TabProxy.java @@ -0,0 +1,42 @@ +package mekanism.api; + +import net.minecraft.creativetab.CreativeTabs; + +/** + * Class used to indirectly reference the Mekanism creative tab. + * @author AidanBrady + * + */ +public final class TabProxy +{ + /** The 'Mekanism' class where the tab instance is stored. */ + public static Class Mekanism; + + /** + * Attempts to get the Mekanism creative tab instance from the 'Mekanism' class. Will return + * the tab if the mod is loaded, but otherwise will return the defined 'preferred' creative tab. This way + * you don't need to worry about NPEs! + * @return Mekanism creative tab if can, otherwise preferred tab + */ + public static CreativeTabs tabMekanism(CreativeTabs preferred) + { + try { + if(Mekanism == null) + { + Mekanism = Class.forName("mekanism.common.Mekanism"); + } + + Object ret = Mekanism.getField("tabMekanism").get(null); + + if(ret instanceof CreativeTabs) + { + return (CreativeTabs)ret; + } + + return preferred; + } catch(Exception e) { + System.err.println("Error retrieving Mekanism creative tab."); + return preferred; + } + } +} diff --git a/src/api/java/mekanism/api/energy/EnergizedItemManager.java b/src/api/java/mekanism/api/energy/EnergizedItemManager.java new file mode 100644 index 0000000..165bdf6 --- /dev/null +++ b/src/api/java/mekanism/api/energy/EnergizedItemManager.java @@ -0,0 +1,60 @@ +package mekanism.api.energy; + +import net.minecraft.item.ItemStack; + +public class EnergizedItemManager +{ + /** + * Discharges an IEnergizedItem with the defined amount of energy. + * @param itemStack - ItemStack to discharge + * @param amount - amount of energy to discharge from the item, usually the total amount of energy needed in a TileEntity + * @return amount of energy discharged + */ + public static double discharge(ItemStack itemStack, double amount) + { + if(itemStack != null) + { + if(itemStack.getItem() instanceof IEnergizedItem) + { + IEnergizedItem energizedItem = (IEnergizedItem)itemStack.getItem(); + + if(energizedItem.canSend(itemStack)) + { + double energyToUse = Math.min(energizedItem.getMaxTransfer(itemStack), Math.min(energizedItem.getEnergy(itemStack), amount)); + energizedItem.setEnergy(itemStack, energizedItem.getEnergy(itemStack) - energyToUse); + + return energyToUse; + } + } + } + + return 0; + } + + /** + * Charges an IEnergizedItem with the defined amount of energy. + * @param itemStack - ItemStack to charge + * @param amount - amount of energy to charge the item with, usually the total amount of energy stored in a TileEntity + * @return amount of energy charged + */ + public static double charge(ItemStack itemStack, double amount) + { + if(itemStack != null) + { + if(itemStack.getItem() instanceof IEnergizedItem) + { + IEnergizedItem energizedItem = (IEnergizedItem)itemStack.getItem(); + + if(energizedItem.canReceive(itemStack)) + { + double energyToSend = Math.min(energizedItem.getMaxTransfer(itemStack), Math.min(energizedItem.getMaxEnergy(itemStack) - energizedItem.getEnergy(itemStack), amount)); + energizedItem.setEnergy(itemStack, energizedItem.getEnergy(itemStack) + energyToSend); + + return energyToSend; + } + } + } + + return 0; + } +} diff --git a/src/api/java/mekanism/api/energy/EnergyStack.java b/src/api/java/mekanism/api/energy/EnergyStack.java new file mode 100644 index 0000000..3f57621 --- /dev/null +++ b/src/api/java/mekanism/api/energy/EnergyStack.java @@ -0,0 +1,14 @@ +package mekanism.api.energy; + +/** + * Created by ben on 27/03/15. + */ +public class EnergyStack +{ + public double amount; + + public EnergyStack(double newAmount) + { + amount = newAmount; + } +} diff --git a/src/api/java/mekanism/api/energy/ICableOutputter.java b/src/api/java/mekanism/api/energy/ICableOutputter.java new file mode 100644 index 0000000..015379c --- /dev/null +++ b/src/api/java/mekanism/api/energy/ICableOutputter.java @@ -0,0 +1,18 @@ +package mekanism.api.energy; + +import net.minecraftforge.common.util.ForgeDirection; + +/** + * Implement this if your TileEntity is capable of outputting energy to cables, overriding Mekanism's default implementation. + * @author AidanBrady + * + */ +public interface ICableOutputter +{ + /** + * Whether or not this block can output to a cable on a specific side. + * @param side - side to check + * @return if the block can output + */ + public boolean canOutputTo(ForgeDirection side); +} diff --git a/src/api/java/mekanism/api/energy/IEnergizedItem.java b/src/api/java/mekanism/api/energy/IEnergizedItem.java new file mode 100644 index 0000000..b672545 --- /dev/null +++ b/src/api/java/mekanism/api/energy/IEnergizedItem.java @@ -0,0 +1,59 @@ +package mekanism.api.energy; + +import net.minecraft.item.ItemStack; + +/** + * Implement this in an item's class if it should be able to store electricity. + * @author aidancbrady + * + */ +public interface IEnergizedItem +{ + /** + * Gets and returns the amount of energy stored in this item. + * @param itemStack - the ItemStack to check + * @return energy stored + */ + public double getEnergy(ItemStack itemStack); + + /** + * Sets this item's stored energy value to a new amount. + * @param itemStack - the ItemStack who's energy value is to be change + * @param amount - new amount of energy + */ + public void setEnergy(ItemStack itemStack, double amount); + + /** + * Gets and returns this item's maximum amount of energy that can be stored. + * @param itemStack - the ItemStack to check + * @return maximum energy + */ + public double getMaxEnergy(ItemStack itemStack); + + /** + * Gets and returns how much energy this item can transfer to and from charging slots. + * @param itemStack - the ItemStack to check + * @return transfer amount + */ + public double getMaxTransfer(ItemStack itemStack); + + /** + * Gets and returns whether or not this item can receive energy from a charging slot. + * @param itemStack - the ItemStack to check + * @return if the item can receive energy + */ + public boolean canReceive(ItemStack itemStack); + + /** + * Gets and returns whether or not this item can send energy to a charging slot. + * @param itemStack - the ItemStack to check + * @return if the item can send energy + */ + public boolean canSend(ItemStack itemStack); + + /** + * Returns whether or not this item contains metadata-specific subtypes instead of using metadata for damage display. + * @return if the item contains metadata-specific subtypes + */ + public boolean isMetadataSpecific(ItemStack itemStack); +} diff --git a/src/api/java/mekanism/api/energy/IStrictEnergyAcceptor.java b/src/api/java/mekanism/api/energy/IStrictEnergyAcceptor.java new file mode 100644 index 0000000..53edc68 --- /dev/null +++ b/src/api/java/mekanism/api/energy/IStrictEnergyAcceptor.java @@ -0,0 +1,25 @@ +package mekanism.api.energy; + +import net.minecraftforge.common.util.ForgeDirection; + +/** + * Implement this if your TileEntity can accept energy at a floating-point double value from Universal Cables. + * @author AidanBrady + * + */ +public interface IStrictEnergyAcceptor extends IStrictEnergyStorage +{ + /** + * Transfer a certain amount of energy to this acceptor. + * @param amount - amount to transfer + * @return energy used + */ + public double transferEnergyToAcceptor(ForgeDirection side, double amount); + + /** + * Whether or not this tile entity accepts energy from a certain side. + * @param side - side to check + * @return if tile entity accepts energy + */ + public boolean canReceiveEnergy(ForgeDirection side); +} diff --git a/src/api/java/mekanism/api/energy/IStrictEnergyStorage.java b/src/api/java/mekanism/api/energy/IStrictEnergyStorage.java new file mode 100644 index 0000000..fd560fa --- /dev/null +++ b/src/api/java/mekanism/api/energy/IStrictEnergyStorage.java @@ -0,0 +1,27 @@ +package mekanism.api.energy; + +/** + * Mekanism-specific energy storage for TileEntities, already implemented in IStrictEnergyAcceptor. + * @author aidancbrady + * + */ +public interface IStrictEnergyStorage +{ + /** + * Gets the amount of energy this TileEntity is currently storing. + * @return stored energy + */ + public double getEnergy(); + + /** + * Sets the amount of stored energy of this TileEntity to a new amount. + * @param energy - new energy value + */ + public void setEnergy(double energy); + + /** + * Gets the maximum amount of energy this TileEntity can store. + * @return maximum energy + */ + public double getMaxEnergy(); +} diff --git a/src/api/java/mekanism/api/energy/package-info.java b/src/api/java/mekanism/api/energy/package-info.java new file mode 100644 index 0000000..8f3d371 --- /dev/null +++ b/src/api/java/mekanism/api/energy/package-info.java @@ -0,0 +1,3 @@ +@API(apiVersion = "8.0.0", owner = "Mekanism", provides = "MekanismAPI|energy") +package mekanism.api.energy; +import cpw.mods.fml.common.API;
\ No newline at end of file diff --git a/src/api/java/mekanism/api/gas/Gas.java b/src/api/java/mekanism/api/gas/Gas.java new file mode 100644 index 0000000..f05be52 --- /dev/null +++ b/src/api/java/mekanism/api/gas/Gas.java @@ -0,0 +1,221 @@ +package mekanism.api.gas; + +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.IIcon; +import net.minecraft.util.StatCollector; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidRegistry; + +/** + * Gas - a class used to set specific properties of gasses when used or seen in-game. + * @author aidancbrady + * + */ +public class Gas +{ + private String name; + + private String unlocalizedName; + + private Fluid fluid; + + private IIcon icon; + + private boolean visible = true; + + private boolean from_fluid = false; + + /** + * Creates a new Gas object with a defined name or key value. + * @param s - name or key to associate this Gas with + */ + public Gas(String s) + { + unlocalizedName = name = s; + } + + /** + * Creates a new Gas object that corresponds to the given Fluid + */ + public Gas(Fluid f) + { + unlocalizedName = name = f.getName(); + icon = f.getStillIcon(); + fluid = f; + from_fluid = true; + } + + /** + * Gets the name (key) of this Gas. This is NOT a translated or localized display name. + * @return this Gas's name or key + */ + public String getName() + { + return name; + } + + /** + * Whether or not this is a visible gas. + * @return if this gas is visible + */ + public boolean isVisible() + { + return visible; + } + + /** + * Sets this gas's "visible" state to a new value. Setting it to 'false' will treat this gas as an internal gas, and it will not be displayed or accessed by other mods. + * @param v - new visible state + * @return this Gas object + */ + public Gas setVisible(boolean v) + { + visible = v; + + return this; + } + + /** + * Gets the unlocalized name of this Gas. + * @return this Gas's unlocalized name + */ + public String getUnlocalizedName() + { + return "gas." + unlocalizedName; + } + + /** + * Translates this Gas's unlocalized name and returns it as localized. + * @return this Gas's localized name + */ + public String getLocalizedName() + { + return StatCollector.translateToLocal(getUnlocalizedName()); + } + + /** + * Sets the unlocalized name of this Gas. + * @param s - unlocalized name to set + * @return this Gas object + */ + public Gas setUnlocalizedName(String s) + { + unlocalizedName = s; + + return this; + } + + /** + * Gets the IIcon associated with this Gas. + * @return associated IIcon + */ + public IIcon getIcon() + { + if(from_fluid) + { + return this.getFluid().getIcon(); + } + + return icon; + } + + /** + * Sets this gas's icon. + * @param i - IIcon to associate with this Gas + * @return this Gas object + */ + public Gas setIcon(IIcon i) + { + icon = i; + + if(hasFluid()) + { + fluid.setIcons(getIcon()); + } + + from_fluid = false; + + return this; + } + + /** + * Gets the ID associated with this gas. + * @return the associated gas ID + */ + public int getID() + { + return GasRegistry.getGasID(this); + } + + /** + * Writes this Gas to a defined tag compound. + * @param nbtTags - tag compound to write this Gas to + * @return the tag compound this gas was written to + */ + public NBTTagCompound write(NBTTagCompound nbtTags) + { + nbtTags.setString("gasName", getName()); + + return nbtTags; + } + + /** + * Returns the Gas stored in the defined tag compound. + * @param nbtTags - tag compound to get the Gas from + * @return Gas stored in the tag compound + */ + public static Gas readFromNBT(NBTTagCompound nbtTags) + { + if(nbtTags == null || nbtTags.hasNoTags()) + { + return null; + } + + return GasRegistry.getGas(nbtTags.getString("gasName")); + } + + /** + * Whether or not this Gas has an associated fluid. + * @return if this gas has a fluid + */ + public boolean hasFluid() + { + return fluid != null; + } + + /** + * Gets the fluid associated with this Gas. + * @return fluid associated with this gas + */ + public Fluid getFluid() + { + return fluid; + } + + /** + * Registers a new fluid out of this Gas or gets one from the FluidRegistry. + * @return this Gas object + */ + public Gas registerFluid() + { + if(fluid == null) + { + if(FluidRegistry.getFluid(getName()) == null) + { + fluid = new Fluid(getName()).setGaseous(true); + FluidRegistry.registerFluid(fluid); + } + else { + fluid = FluidRegistry.getFluid(getName()); + } + } + + return this; + } + + @Override + public String toString() + { + return name; + } +} diff --git a/src/api/java/mekanism/api/gas/GasNetwork.java b/src/api/java/mekanism/api/gas/GasNetwork.java new file mode 100644 index 0000000..ea81d12 --- /dev/null +++ b/src/api/java/mekanism/api/gas/GasNetwork.java @@ -0,0 +1,358 @@ +package mekanism.api.gas; + +import com.google.common.collect.Lists; +import cpw.mods.fml.common.FMLCommonHandler; +import cpw.mods.fml.common.eventhandler.Event; +import mekanism.api.Coord4D; +import mekanism.api.transmitters.DynamicNetwork; +import mekanism.api.transmitters.IGridTransmitter; +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.common.util.ForgeDirection; + +import java.util.*; + +/** + * A DynamicNetwork extension created specifically for the transfer of Gasses. By default this is server-only, but if ticked on + * the client side and if it's posted events are handled properly, it has the capability to visually display gasses network-wide. + * @author aidancbrady + * + */ +public class GasNetwork extends DynamicNetwork<IGasHandler, GasNetwork> +{ + public int transferDelay = 0; + + public boolean didTransfer; + public boolean prevTransfer; + + public float gasScale; + + public Gas refGas; + + public GasStack buffer; + public int prevStored; + + public int prevTransferAmount = 0; + + public GasNetwork() {} + + public GasNetwork(Collection<GasNetwork> networks) + { + for(GasNetwork net : networks) + { + if(net != null) + { + if(FMLCommonHandler.instance().getEffectiveSide().isClient()) + { + if(net.refGas != null && net.gasScale > gasScale) + { + gasScale = net.gasScale; + refGas = net.refGas; + buffer = net.buffer; + + net.gasScale = 0; + net.refGas = null; + net.buffer = null; + } + } else + { + if(net.buffer != null) + { + if(buffer == null) + { + buffer = net.buffer.copy(); + } else + { + if(buffer.isGasEqual(net.buffer)) + { + buffer.amount += net.buffer.amount; + } + else if(net.buffer.amount > buffer.amount) + { + buffer = net.buffer.copy(); + } + + } + + net.buffer = null; + } + } + + adoptTransmittersAndAcceptorsFrom(net); + net.deregister(); + } + } + + gasScale = getScale(); + + register(); + } + + @Override + public void absorbBuffer(IGridTransmitter<IGasHandler, GasNetwork> transmitter) + { + Object b = transmitter.getBuffer(); + + if(!(b instanceof GasStack) || ((GasStack)b).getGas() == null || ((GasStack)b).amount == 0) + { + return; + } + + GasStack gas = (GasStack)b; + + if(buffer == null || buffer.getGas() == null || buffer.amount == 0) + { + buffer = gas.copy(); + gas.amount = 0; + return; + } + + //TODO better multiple buffer impl + if(buffer.isGasEqual(gas)) + { + buffer.amount += gas.amount; + } + + gas.amount = 0; + } + + @Override + public void clampBuffer() + { + if(buffer != null && buffer.amount > getCapacity()) + { + buffer.amount = capacity; + } + } + + public int getGasNeeded() + { + return getCapacity()-(buffer != null ? buffer.amount : 0); + } + + public int tickEmit(GasStack stack) + { + List<IGasHandler> availableAcceptors = Lists.newArrayList(); + + availableAcceptors.addAll(getAcceptors(stack.getGas())); + + Collections.shuffle(availableAcceptors); + + int toSend = stack.amount; + int prevSending = toSend; + + if(!availableAcceptors.isEmpty()) + { + int divider = availableAcceptors.size(); + int remaining = toSend % divider; + int sending = (toSend-remaining)/divider; + + for(IGasHandler acceptor : availableAcceptors) + { + int currentSending = sending; + EnumSet<ForgeDirection> sides = acceptorDirections.get(Coord4D.get((TileEntity)acceptor)); + + if(remaining > 0) + { + currentSending++; + remaining--; + } + + for(ForgeDirection side : sides) + { + int prev = toSend; + + toSend -= acceptor.receiveGas(side, new GasStack(stack.getGas(), currentSending), true); + + if(toSend < prev) + { + break; + } + } + } + } + + int sent = prevSending-toSend; + + if(sent > 0 && FMLCommonHandler.instance().getEffectiveSide().isServer()) + { + didTransfer = true; + transferDelay = 2; + } + + return sent; + } + + public int emit(GasStack stack, boolean doTransfer) + { + if(buffer != null && buffer.getGas() != stack.getGas()) + { + return 0; + } + + int toUse = Math.min(getGasNeeded(), stack.amount); + + if(doTransfer) + { + if(buffer == null) + { + buffer = stack.copy(); + buffer.amount = toUse; + } + else { + buffer.amount += toUse; + } + } + + return toUse; + } + + @Override + public void onUpdate() + { + super.onUpdate(); + + if(FMLCommonHandler.instance().getEffectiveSide().isServer()) + { + prevTransferAmount = 0; + + if(transferDelay == 0) + { + didTransfer = false; + } + else { + transferDelay--; + } + + int stored = buffer != null ? buffer.amount : 0; + + if(stored != prevStored) + { + needsUpdate = true; + } + + prevStored = stored; + + if(didTransfer != prevTransfer || needsUpdate) + { + MinecraftForge.EVENT_BUS.post(new GasTransferEvent(this, buffer, didTransfer)); + needsUpdate = false; + } + + prevTransfer = didTransfer; + + if(buffer != null) + { + prevTransferAmount = tickEmit(buffer); + buffer.amount -= prevTransferAmount; + + if(buffer.amount <= 0) + { + buffer = null; + } + } + } + } + + @Override + public void clientTick() + { + super.clientTick(); + + gasScale = Math.max(gasScale, getScale()); + + if(didTransfer && gasScale < 1) + { + gasScale = Math.max(getScale(), Math.min(1, gasScale+0.02F)); + } + else if(!didTransfer && gasScale > 0) + { + gasScale = Math.max(getScale(), Math.max(0, gasScale-0.02F)); + + if(gasScale == 0) + { + buffer = null; + } + } + } + + @Override + public Set<IGasHandler> getAcceptors(Object data) + { + Gas type = (Gas)data; + Set<IGasHandler> toReturn = new HashSet<IGasHandler>(); + + if(FMLCommonHandler.instance().getEffectiveSide().isClient()) + { + return toReturn; + } + + for(Coord4D coord : possibleAcceptors.keySet()) + { + EnumSet<ForgeDirection> sides = acceptorDirections.get(coord); + TileEntity tile = coord.getTileEntity(getWorld()); + + if(!(tile instanceof IGasHandler) || sides == null || sides.isEmpty()) + { + continue; + } + + IGasHandler acceptor = (IGasHandler)tile; + + for(ForgeDirection side : sides) + { + if(acceptor != null && acceptor.canReceiveGas(side, type)) + { + toReturn.add(acceptor); + break; + } + } + } + + return toReturn; + } + + public static class GasTransferEvent extends Event + { + public final GasNetwork gasNetwork; + + public final GasStack transferType; + public final boolean didTransfer; + + public GasTransferEvent(GasNetwork network, GasStack type, boolean did) + { + gasNetwork = network; + transferType = type; + didTransfer = did; + } + } + + public float getScale() + { + return Math.min(1, (buffer == null || getCapacity() == 0 ? 0 : (float)buffer.amount/getCapacity())); + } + + @Override + public String toString() + { + return "[GasNetwork] " + transmitters.size() + " transmitters, " + possibleAcceptors.size() + " acceptors."; + } + + @Override + public String getNeededInfo() + { + return Integer.toString(getGasNeeded()); + } + + @Override + public String getStoredInfo() + { + return buffer != null ? buffer.getGas().getLocalizedName() + " (" + buffer.amount + ")" : "None"; + } + + @Override + public String getFlowInfo() + { + return Integer.toString(prevTransferAmount) + "/t"; + } +} diff --git a/src/api/java/mekanism/api/gas/GasRegistry.java b/src/api/java/mekanism/api/gas/GasRegistry.java new file mode 100644 index 0000000..25db966 --- /dev/null +++ b/src/api/java/mekanism/api/gas/GasRegistry.java @@ -0,0 +1,113 @@ +package mekanism.api.gas; + +import java.util.ArrayList; +import java.util.List; + +import net.minecraftforge.fluids.Fluid; + +public class GasRegistry +{ + private static ArrayList<Gas> registeredGasses = new ArrayList<Gas>(); + + /** + * Register a new gas into GasRegistry. + * @param gas - Gas to register + * @return the gas that has been registered, pulled right out of GasRegistry + */ + public static Gas register(Gas gas) + { + if(gas == null) + { + return null; + } + + registeredGasses.add(gas); + + return getGas(gas.getName()); + } + + /** + * Gets the gas associated with the defined ID. + * @param id - ID to check + * @return gas associated with defined ID + */ + public static Gas getGas(int id) + { + if(id == -1) + { + return null; + } + + return registeredGasses.get(id); + } + + /** + * Gets the gas associated with the defined fluid. + * @param f - fluid to check + * @return the gas associated with the fluid + */ + public static Gas getGas(Fluid f) + { + for(Gas gas : getRegisteredGasses()) + { + if(gas.hasFluid() && gas.getFluid() == f) + { + return gas; + } + } + + return null; + } + + /** + * Whether or not GasRegistry contains a gas with the specified name + * @param name - name to check + * @return if GasRegistry contains a gas with the defined name + */ + public static boolean containsGas(String name) + { + return getGas(name) != null; + } + + /** + * Gets the list of all gasses registered in GasRegistry. + * @return a cloned list of all registered gasses + */ + public static List<Gas> getRegisteredGasses() + { + return (List<Gas>)registeredGasses.clone(); + } + + /** + * Gets the gas associated with the specified name. + * @param name - name of the gas to get + * @return gas associated with the name + */ + public static Gas getGas(String name) + { + for(Gas gas : registeredGasses) + { + if(gas.getName().toLowerCase().equals(name.toLowerCase())) + { + return gas; + } + } + + return null; + } + + /** + * Gets the gas ID of a specified gas. + * @param gas - gas to get the ID from + * @return gas ID + */ + public static int getGasID(Gas gas) + { + if(gas == null || !containsGas(gas.getName())) + { + return -1; + } + + return registeredGasses.indexOf(gas); + } +} diff --git a/src/api/java/mekanism/api/gas/GasStack.java b/src/api/java/mekanism/api/gas/GasStack.java new file mode 100644 index 0000000..05e5ae6 --- /dev/null +++ b/src/api/java/mekanism/api/gas/GasStack.java @@ -0,0 +1,132 @@ +package mekanism.api.gas; + +import net.minecraft.nbt.NBTTagCompound; + +/** + * GasStack - a specified amount of a defined Gas with certain properties. + * @author aidancbrady + * + */ +public class GasStack +{ + private Gas type; + + public int amount; + + /** + * Creates a new GasStack with a defined gas ID and quantity. + * @param id - gas ID to associate this GasStack to, will perform a GasRegistry lookup in the constructor + * @param quantity - amount of gas to be referenced in this GasStack + */ + public GasStack(int id, int quantity) + { + type = GasRegistry.getGas(id); + amount = quantity; + } + + /** + * Creates a new GasStack with a defined Gas type and quantity. + * @param gas - gas type of the stack + * @param quantity - amount of gas to be referenced in this GasStack + */ + public GasStack(Gas gas, int quantity) + { + type = gas; + amount = quantity; + } + + private GasStack() {} + + /** + * Gets the Gas type of this GasStack. + * @return this GasStack's Gas type + */ + public Gas getGas() + { + return type; + } + + public GasStack withAmount(int newAmount) + { + amount = newAmount; + + return this; + } + + /** + * Writes this GasStack to a defined tag compound. + * @param nbtTags - tag compound to write to + * @return tag compound with this GasStack's data + */ + public NBTTagCompound write(NBTTagCompound nbtTags) + { + type.write(nbtTags); + nbtTags.setInteger("amount", amount); + + return nbtTags; + } + + /** + * Reads this GasStack's data from a defined tag compound. + * @param nbtTags - tag compound to read from + */ + public void read(NBTTagCompound nbtTags) + { + type = Gas.readFromNBT(nbtTags); + amount = nbtTags.getInteger("amount"); + } + + /** + * Returns the GasStack stored in the defined tag compound, or null if it doesn't exist. + * @param nbtTags - tag compound to read from + * @return GasStack stored in the tag compound + */ + public static GasStack readFromNBT(NBTTagCompound nbtTags) + { + if(nbtTags == null || nbtTags.hasNoTags()) + { + return null; + } + + GasStack stack = new GasStack(); + stack.read(nbtTags); + + if(stack.getGas() == null || stack.amount <= 0) + { + return null; + } + + return stack; + } + + /** + * Returns a copied form of this GasStack. + * @return copied GasStack + */ + public GasStack copy() + { + return new GasStack(type, amount); + } + + /** + * Whether or not this GasStack's gas type is equal to the other defined GasStack. + * @param stack - GasStack to check + * @return if the GasStacks contain the same gas type + */ + public boolean isGasEqual(GasStack stack) + { + return stack != null && getGas() == stack.getGas(); + } + + @Override + public String toString() + { + return "[" + type + ", " + amount + "]"; + } + + @Override + public int hashCode() + { + return type == null ? 0 : type.getID(); + } +} diff --git a/src/api/java/mekanism/api/gas/GasTank.java b/src/api/java/mekanism/api/gas/GasTank.java new file mode 100644 index 0000000..a5d4c20 --- /dev/null +++ b/src/api/java/mekanism/api/gas/GasTank.java @@ -0,0 +1,252 @@ +package mekanism.api.gas; + +import net.minecraft.nbt.NBTTagCompound; + +/** + * An optional way of managing and/or storing gasses. Would be very useful in TileEntity and Entity gas storage. + * @author aidancbrady + * + */ +public class GasTank +{ + public GasStack stored; + + private int maxGas; + + private GasTank() {} + + /** + * Creates a tank with a defined capacity. + * @param max - the maximum amount of gas this GasTank can hold + */ + public GasTank(int max) + { + maxGas = max; + } + + /** + * Sets this tank's GasStack value to a new value. Will cap the amount to this GasTank's capacity. + * @param stack - value to set this tank's GasStack value to + */ + public void setGas(GasStack stack) + { + stored = stack; + + if(stored != null) + { + stored.amount = Math.min(getMaxGas(), stored.amount); + } + } + + /** + * Draws a specified amount of gas out of this tank. + * @param amount - amount to draw + * @param doDraw - if the gas should actually be removed from this tank + * @return gas taken from this GasTank as a GasStack value + */ + public GasStack draw(int amount, boolean doDraw) + { + if(stored == null || amount <= 0) + { + return null; + } + + GasStack ret = new GasStack(getGas().getGas(), Math.min(getStored(), amount)); + + if(ret.amount > 0) + { + if(doDraw) + { + stored.amount -= ret.amount; + + if(stored.amount <= 0) + { + stored = null; + } + } + + return ret; + } + + return null; + } + + /** + * Adds a specified amount of gas to this tank. + * @param amount - the GasStack for this tank to receive + * @param doReceive - if the gas should actually be added to this tank + * @return the amount of gas accepted by this tank + */ + public int receive(GasStack amount, boolean doReceive) + { + if(amount == null || (stored != null && !(stored.amount != getMaxGas() && stored.isGasEqual(amount)))) + { + return 0; + } + + int toFill = Math.min(getMaxGas()-getStored(), amount.amount); + + if(doReceive) + { + if(stored == null) + { + stored = amount.copy().withAmount(getStored()+toFill); + } + else { + stored.amount = Math.min(getMaxGas(), getStored()+amount.amount); + } + } + + return toFill; + } + + /** + * If this GasTank can receive the specified type of gas. Will return false if this tank does not need anymore gas. + * @param gas - gas to check + * @return if this GasTank can accept the defined gas + */ + public boolean canReceive(Gas gas) + { + if(getNeeded() == 0 || stored != null && (gas != null && gas != stored.getGas())) + { + return false; + } + + return true; + } + + /** + * If this GasTank can receive the specified type of gas. Will return TRUE if this tank does not need anymore gas. + * @param gas - gas to check + * @return if this GasTank can accept the defined gas + */ + public boolean canReceiveType(Gas gas) + { + if(stored != null && (gas != null && gas != stored.getGas())) + { + return false; + } + + return true; + } + + /** + * If this GasTank can be drawn of the specified type of gas. Will return false if this tank does not contain any gas. + * @param gas - gas to check + * @return if this GasTank can be drawn of the defined gas + */ + public boolean canDraw(Gas gas) + { + if(stored == null || (gas != null && gas != stored.getGas())) + { + return false; + } + + return true; + } + + /** + * Gets the amount of gas needed by this GasTank. + * @return + */ + public int getNeeded() + { + return getMaxGas()-getStored(); + } + + /** + * Gets the maximum amount of gas this tank can hold. + * @return - max gas + */ + public int getMaxGas() + { + return maxGas; + } + + /** + * Sets the maximum amount of gas this tank can hold + */ + public void setMaxGas(int capacity) + { + maxGas = capacity; + } + + /** + * Gets the GasStack held by this GasTank. + * @return - GasStakc held by this tank + */ + public GasStack getGas() + { + return stored; + } + + /** + * Gets the type of gas currently stored in this GasTank. + * @return gas type contained + */ + public Gas getGasType() + { + return stored != null ? stored.getGas() : null; + } + + /** + * Gets the amount of gas stored by this GasTank. + * @return amount of gas stored + */ + public int getStored() + { + return stored != null ? stored.amount : 0; + } + + /** + * Writes this tank to a defined tag compound. + * @param nbtTags - tag compound to write to + * @return tag compound with this tank's data + */ + public NBTTagCompound write(NBTTagCompound nbtTags) + { + if(stored != null && stored.getGas() != null) + { + nbtTags.setTag("stored", stored.write(new NBTTagCompound())); + } + + nbtTags.setInteger("maxGas", maxGas); + + return nbtTags; + } + + /** + * Reads this tank's data from a defined tag compound. + * @param nbtTags - tag compound to read from + */ + public void read(NBTTagCompound nbtTags) + { + if(nbtTags.hasKey("stored")) + { + stored = GasStack.readFromNBT(nbtTags.getCompoundTag("stored")); + } + + if(nbtTags.hasKey("maxGas") && nbtTags.getInteger("maxGas") != 0) + { + maxGas = nbtTags.getInteger("maxGas"); + } + } + + /** + * Returns the tank stored in the defined tag compound, or null if it doesn't exist. + * @param nbtTags - tag compound to read from + * @return tank stored in the tag compound + */ + public static GasTank readFromNBT(NBTTagCompound nbtTags) + { + if(nbtTags == null || nbtTags.hasNoTags()) + { + return null; + } + + GasTank tank = new GasTank(); + tank.read(nbtTags); + + return tank; + } +} diff --git a/src/api/java/mekanism/api/gas/GasTransmission.java b/src/api/java/mekanism/api/gas/GasTransmission.java new file mode 100644 index 0000000..c043eb8 --- /dev/null +++ b/src/api/java/mekanism/api/gas/GasTransmission.java @@ -0,0 +1,181 @@ +package mekanism.api.gas; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; + +import mekanism.api.Coord4D; +import mekanism.api.transmitters.ITransmitterTile; +import mekanism.api.transmitters.TransmissionType; + +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.util.ForgeDirection; + +/** + * A handy class containing several utilities for efficient gas transfer. + * @author AidanBrady + * + */ +public final class GasTransmission +{ + /** + * Gets all the acceptors around a tile entity. + * @param tileEntity - center tile entity + * @return array of IGasAcceptors + */ + public static IGasHandler[] getConnectedAcceptors(TileEntity tileEntity) + { + IGasHandler[] acceptors = new IGasHandler[] {null, null, null, null, null, null}; + + for(ForgeDirection orientation : ForgeDirection.VALID_DIRECTIONS) + { + TileEntity acceptor = Coord4D.get(tileEntity).getFromSide(orientation).getTileEntity(tileEntity.getWorldObj()); + + if(acceptor instanceof IGasHandler) + { + acceptors[orientation.ordinal()] = (IGasHandler)acceptor; + } + } + + return acceptors; + } + + /** + * Gets all the tube connections around a tile entity. + * @param tileEntity - center tile entity + * @return array of ITubeConnections + */ + public static ITubeConnection[] getConnections(TileEntity tileEntity) + { + ITubeConnection[] connections = new ITubeConnection[] {null, null, null, null, null, null}; + + for(ForgeDirection orientation : ForgeDirection.VALID_DIRECTIONS) + { + TileEntity connection = Coord4D.get(tileEntity).getFromSide(orientation).getTileEntity(tileEntity.getWorldObj()); + + if(canConnect(connection, orientation)) + { + connections[orientation.ordinal()] = (ITubeConnection)connection; + } + } + + return connections; + } + + /** + * Whether or not a TileEntity can connect to a specified tile on a specified side. + * @param tileEntity - TileEntity to attempt connection to + * @param side - side to attempt connection on + * @return if this tile and side are connectable + */ + public static boolean canConnect(TileEntity tileEntity, ForgeDirection side) + { + if(tileEntity instanceof ITubeConnection && (!(tileEntity instanceof ITransmitterTile) || TransmissionType.checkTransmissionType(((ITransmitterTile)tileEntity).getTransmitter(), TransmissionType.GAS))) + { + if(((ITubeConnection)tileEntity).canTubeConnect(side.getOpposite())) + { + return true; + } + } + + return false; + } + + /** + * Removes a specified amount of gas from an IGasItem. + * @param itemStack - ItemStack of the IGasItem + * @param type - type of gas to remove from the IGasItem, null if it doesn't matter + * @param amount - amount of gas to remove from the ItemStack + * @return the GasStack removed by the IGasItem + */ + public static GasStack removeGas(ItemStack itemStack, Gas type, int amount) + { + if(itemStack != null && itemStack.getItem() instanceof IGasItem) + { + IGasItem item = (IGasItem)itemStack.getItem(); + + if(type != null && item.getGas(itemStack) != null && item.getGas(itemStack).getGas() != type || !item.canProvideGas(itemStack, type)) + { + return null; + } + + return item.removeGas(itemStack, amount); + } + + return null; + } + + /** + * Adds a specified amount of gas to an IGasItem. + * @param itemStack - ItemStack of the IGasItem + * @param stack - stack to add to the IGasItem + * @return amount of gas accepted by the IGasItem + */ + public static int addGas(ItemStack itemStack, GasStack stack) + { + if(itemStack != null && itemStack.getItem() instanceof IGasItem && ((IGasItem)itemStack.getItem()).canReceiveGas(itemStack, stack.getGas())) + { + return ((IGasItem)itemStack.getItem()).addGas(itemStack, stack.copy()); + } + + return 0; + } + + /** + * Emits gas from a central block by splitting the received stack among the sides given. + * @param sides - the list of sides to output from + * @param stack - the stack to output + * @param from - the TileEntity to output from + * @return the amount of gas emitted + */ + public static int emit(List<ForgeDirection> sides, GasStack stack, TileEntity from) + { + if(stack == null) + { + return 0; + } + + List<IGasHandler> availableAcceptors = new ArrayList<IGasHandler>(); + IGasHandler[] possibleAcceptors = getConnectedAcceptors(from); + + for(int i = 0; i < possibleAcceptors.length; i++) + { + IGasHandler handler = possibleAcceptors[i]; + + if(handler != null && handler.canReceiveGas(ForgeDirection.getOrientation(i).getOpposite(), stack.getGas())) + { + availableAcceptors.add(handler); + } + } + + Collections.shuffle(availableAcceptors); + + int toSend = stack.amount; + int prevSending = toSend; + + if(!availableAcceptors.isEmpty()) + { + int divider = availableAcceptors.size(); + int remaining = toSend % divider; + int sending = (toSend-remaining)/divider; + + for(IGasHandler acceptor : availableAcceptors) + { + int currentSending = sending; + + if(remaining > 0) + { + currentSending++; + remaining--; + } + + ForgeDirection dir = ForgeDirection.getOrientation(Arrays.asList(possibleAcceptors).indexOf(acceptor)).getOpposite(); + toSend -= acceptor.receiveGas(dir, new GasStack(stack.getGas(), currentSending), true); + } + } + + return prevSending-toSend; + } +} diff --git a/src/api/java/mekanism/api/gas/IGasHandler.java b/src/api/java/mekanism/api/gas/IGasHandler.java new file mode 100644 index 0000000..e069523 --- /dev/null +++ b/src/api/java/mekanism/api/gas/IGasHandler.java @@ -0,0 +1,47 @@ +package mekanism.api.gas; + +import net.minecraftforge.common.util.ForgeDirection; + +/** + * Implement this if your tile entity accepts gas from an external source. + * @author AidanBrady + * + */ +public interface IGasHandler +{ + /** + * Transfer a certain amount of gas to this block. + * @param stack - gas to add + * @return gas added + */ + public int receiveGas(ForgeDirection side, GasStack stack, boolean doTransfer); + + @Deprecated + public int receiveGas(ForgeDirection side, GasStack stack); + + /** + * Draws a certain amount of gas from this block. + * @param amount - amount to draw + * @return gas drawn + */ + public GasStack drawGas(ForgeDirection side, int amount, boolean doTransfer); + + @Deprecated + public GasStack drawGas(ForgeDirection side, int amount); + + /** + * Whether or not this block can accept gas from a certain side. + * @param side - side to check + * @param type - type of gas to check + * @return if block accepts gas + */ + public boolean canReceiveGas(ForgeDirection side, Gas type); + + /** + * Whether or not this block can be drawn of gas from a certain side. + * @param side - side to check + * @param type - type of gas to check + * @return if block can be drawn of gas + */ + public boolean canDrawGas(ForgeDirection side, Gas type); +} diff --git a/src/api/java/mekanism/api/gas/IGasItem.java b/src/api/java/mekanism/api/gas/IGasItem.java new file mode 100644 index 0000000..9c7d332 --- /dev/null +++ b/src/api/java/mekanism/api/gas/IGasItem.java @@ -0,0 +1,81 @@ +package mekanism.api.gas; + +import net.minecraft.item.ItemStack; + +/** + * Implement this in your item class if it can store or transfer certain gasses. + * @author AidanBrady + * + */ +public interface IGasItem +{ + /** + * Gets the rate of transfer this item can handle. + * @return + */ + public int getRate(ItemStack itemstack); + + /** + * Adds a defined amount of a certain gas to an item. + * @param itemstack - the itemstack to add gas to + * @param type - the type of gas to add + * @param amount - the amount of gas to add + * @return the gas that was accepted by the item + */ + public int addGas(ItemStack itemstack, GasStack stack); + + /** + * Removes the defined amount of a certain gas from the item. + * @param itemstack - the itemstack to remove gas from + * @param type - the type of gas to remove + * @param amount - the amount of gas to remove + * @return the gas that was removed by the item + */ + public GasStack removeGas(ItemStack itemstack, int amount); + + /** + * Whether or not this storage tank be given a specific gas. + * @param itemstack - the itemstack to check + * @param type - the type of gas the tank can possibly receive + * @return if the item be charged + */ + public boolean canReceiveGas(ItemStack itemstack, Gas type); + + /** + * Whether or not this item can give a gas receiver a certain type of gas. + * @param itemstack - the itemstack to check + * @param type - the type of gas the tank can provide + * @return if the item can provide gas + */ + public boolean canProvideGas(ItemStack itemstack, Gas type); + + /** + * Get the gas of a declared type. + * @param type - type of gas + * @param data - ItemStack parameter if necessary + * @return gas stored + */ + public GasStack getGas(ItemStack itemstack); + + /** + * Set the gas of a declared type to a new amount; + * @param type - type of gas + * @param data - ItemStack parameter if necessary + * @param amount - amount to store + */ + public void setGas(ItemStack itemstack, GasStack stack); + + /** + * Gets the maximum amount of gas this tile entity can store. + * @param type - type of gas + * @param data - ItemStack parameter if necessary + * @return maximum gas + */ + public int getMaxGas(ItemStack itemstack); + + /** + * Returns whether or not this item contains metadata-specific subtypes instead of using metadata for damage display. + * @return if the item contains metadata-specific subtypes + */ + public boolean isMetadataSpecific(ItemStack itemstack); +} diff --git a/src/api/java/mekanism/api/gas/IGasTransmitter.java b/src/api/java/mekanism/api/gas/IGasTransmitter.java new file mode 100644 index 0000000..57ec4c1 --- /dev/null +++ b/src/api/java/mekanism/api/gas/IGasTransmitter.java @@ -0,0 +1,10 @@ +package mekanism.api.gas; + +import mekanism.api.transmitters.IGridTransmitter; + +import net.minecraft.tileentity.TileEntity; + +public interface IGasTransmitter extends IGridTransmitter<IGasHandler, GasNetwork> +{ + public boolean canTransferGasToTube(TileEntity tile); +} diff --git a/src/api/java/mekanism/api/gas/ITubeConnection.java b/src/api/java/mekanism/api/gas/ITubeConnection.java new file mode 100644 index 0000000..b669fed --- /dev/null +++ b/src/api/java/mekanism/api/gas/ITubeConnection.java @@ -0,0 +1,18 @@ +package mekanism.api.gas; + +import net.minecraftforge.common.util.ForgeDirection; + +/** + * Implement this if your block can connect to Pressurized Tubes. + * @author AidanBrady + * + */ +public interface ITubeConnection +{ + /** + * Whether or not a tube can connect to a certain orientation. + * @param side - orientation to check + * @return if a tube can connect + */ + public boolean canTubeConnect(ForgeDirection side); +} diff --git a/src/api/java/mekanism/api/gas/OreGas.java b/src/api/java/mekanism/api/gas/OreGas.java new file mode 100644 index 0000000..316169c --- /dev/null +++ b/src/api/java/mekanism/api/gas/OreGas.java @@ -0,0 +1,38 @@ +package mekanism.api.gas; + +import net.minecraft.util.StatCollector; + +public class OreGas extends Gas +{ + private String oreName; + private OreGas cleanGas; + + public OreGas(String s, String name) + { + super(s); + + oreName = name; + } + + public boolean isClean() + { + return getCleanGas() == null; + } + + public OreGas getCleanGas() + { + return cleanGas; + } + + public OreGas setCleanGas(OreGas gas) + { + cleanGas = gas; + + return this; + } + + public String getOreName() + { + return StatCollector.translateToLocal(oreName); + } +} diff --git a/src/api/java/mekanism/api/gas/package-info.java b/src/api/java/mekanism/api/gas/package-info.java new file mode 100644 index 0000000..4418451 --- /dev/null +++ b/src/api/java/mekanism/api/gas/package-info.java @@ -0,0 +1,3 @@ +@API(apiVersion = "8.0.0", owner = "Mekanism", provides = "MekanismAPI|gas") +package mekanism.api.gas; +import cpw.mods.fml.common.API;
\ No newline at end of file diff --git a/src/api/java/mekanism/api/infuse/InfuseObject.java b/src/api/java/mekanism/api/infuse/InfuseObject.java new file mode 100644 index 0000000..a86c02f --- /dev/null +++ b/src/api/java/mekanism/api/infuse/InfuseObject.java @@ -0,0 +1,21 @@ +package mekanism.api.infuse; + +/** + * InfuseObject - an object associated with an ItemStack that can modify a Metallurgic Infuser's internal infuse. + * @author AidanBrady + * + */ +public class InfuseObject +{ + /** The type of infuse this item stores */ + public InfuseType type; + + /** How much infuse this item stores */ + public int stored; + + public InfuseObject(InfuseType infusion, int i) + { + type = infusion; + stored = i; + } +} diff --git a/src/api/java/mekanism/api/infuse/InfuseRegistry.java b/src/api/java/mekanism/api/infuse/InfuseRegistry.java new file mode 100644 index 0000000..308b9c5 --- /dev/null +++ b/src/api/java/mekanism/api/infuse/InfuseRegistry.java @@ -0,0 +1,113 @@ +package mekanism.api.infuse; + +import java.util.HashMap; +import java.util.Map; + +import net.minecraft.item.ItemStack; + +/** + * Use this class to add a new object that registers as an infuse object. + * @author AidanBrady + * + */ +public class InfuseRegistry +{ + /** The (private) map of ItemStacks and their related InfuseObjects. */ + private static Map<ItemStack, InfuseObject> infuseObjects = new HashMap<ItemStack, InfuseObject>(); + + /** The (private) map of infuse names and their corresponding InfuseTypes. */ + private static Map<String, InfuseType> infuseTypes = new HashMap<String, InfuseType>(); + + /** + * Registers an InfuseType into the registry. Call this in PreInit! + * @param infuse + */ + public static void registerInfuseType(InfuseType infuse) + { + if(infuseTypes.containsKey(infuse.name)) + { + return; + } + + infuseTypes.put(infuse.name, infuse); + } + + /** + * Gets an InfuseType from it's name, or null if it doesn't exist. + * @param name - the name of the InfuseType to get + * @return the name's corresponding InfuseType + */ + public static InfuseType get(String name) + { + if(name.equals("null")) + { + return null; + } + + return infuseTypes.get(name); + } + + /** + * Whether or not the registry contains a correspondent InfuseType to a name. + * @param name - the name to check + * @return if the name has a coorespondent InfuseType + */ + public static boolean contains(String name) + { + return get(name) != null; + } + + /** + * Registers a block or item that serves as an infuse object. An infuse object will store a certain type and amount of infuse, + * and will deliver this amount to the Metallurgic Infuser's buffer of infuse. The item's stack size will be decremented when + * it is placed in the Metallurgic Infuser's infuse slot, and the machine can accept the type and amount of infuse stored in the + * object. + * @param itemStack - stack the infuse object is linked to -- stack size is ignored + * @param infuseObject - the infuse object with the type and amount data + */ + public static void registerInfuseObject(ItemStack itemStack, InfuseObject infuseObject) + { + if(getObject(itemStack) != null) + { + return; + } + + infuseObjects.put(itemStack, infuseObject); + } + + /** + * Gets the InfuseObject data from an ItemStack. + * @param itemStack - the ItemStack to check + * @return the ItemStack's InfuseObject + */ + public static InfuseObject getObject(ItemStack itemStack) + { + for(Map.Entry<ItemStack, InfuseObject> obj : infuseObjects.entrySet()) + { + if(itemStack.isItemEqual(obj.getKey())) + { + return obj.getValue(); + } + } + + return null; + } + + /** + * Gets the private map for InfuseObjects. + * @return private InfuseObject map + */ + public static final Map<ItemStack, InfuseObject> getObjectMap() + { + return infuseObjects; + } + + /** + * Gets the private map for InfuseTypes. + * @return private InfuseType map + */ + public static final Map<String, InfuseType> getInfuseMap() + { + return infuseTypes; + } +} diff --git a/src/api/java/mekanism/api/infuse/InfuseType.java b/src/api/java/mekanism/api/infuse/InfuseType.java new file mode 100644 index 0000000..1f5215c --- /dev/null +++ b/src/api/java/mekanism/api/infuse/InfuseType.java @@ -0,0 +1,47 @@ +package mekanism.api.infuse; + +import net.minecraft.util.ResourceLocation; +import net.minecraft.util.StatCollector; + +/** + * The types of infuse currently available in Mekanism. + * @author AidanBrady + * + */ +public final class InfuseType +{ + /** The name of this infusion */ + public String name; + + /** The location of this infuse's GUI texture */ + public ResourceLocation texture; + + /** The infuse's GUI texture X offset. */ + public int texX; + + /** The infuse's GUI texture Y offset. */ + public int texY; + + /** The unlocalized name of this type. */ + public String unlocalizedName; + + public InfuseType(String s, ResourceLocation location, int x, int y) + { + name = s; + texture = location; + texX = x; + texY = y; + } + + public InfuseType setUnlocalizedName(String name) + { + unlocalizedName = name; + + return this; + } + + public String getLocalizedName() + { + return StatCollector.translateToLocal(unlocalizedName); + } +} diff --git a/src/api/java/mekanism/api/infuse/package-info.java b/src/api/java/mekanism/api/infuse/package-info.java new file mode 100644 index 0000000..8718996 --- /dev/null +++ b/src/api/java/mekanism/api/infuse/package-info.java @@ -0,0 +1,3 @@ +@API(apiVersion = "8.0.0", owner = "Mekanism", provides = "MekanismAPI|infuse") +package mekanism.api.infuse; +import cpw.mods.fml.common.API;
\ No newline at end of file diff --git a/src/api/java/mekanism/api/lasers/ILaserReceptor.java b/src/api/java/mekanism/api/lasers/ILaserReceptor.java new file mode 100644 index 0000000..641f3ca --- /dev/null +++ b/src/api/java/mekanism/api/lasers/ILaserReceptor.java @@ -0,0 +1,10 @@ +package mekanism.api.lasers; + +import net.minecraftforge.common.util.ForgeDirection; + +public interface ILaserReceptor +{ + public void receiveLaserEnergy(double energy, ForgeDirection side); + + public boolean canLasersDig(); +} diff --git a/src/api/java/mekanism/api/lasers/package-info.java b/src/api/java/mekanism/api/lasers/package-info.java new file mode 100644 index 0000000..b456937 --- /dev/null +++ b/src/api/java/mekanism/api/lasers/package-info.java @@ -0,0 +1,3 @@ +@API(apiVersion = "8.0.0", owner = "Mekanism", provides = "MekanismAPI|laser") +package mekanism.api.lasers; +import cpw.mods.fml.common.API;
\ No newline at end of file diff --git a/src/api/java/mekanism/api/package-info.java b/src/api/java/mekanism/api/package-info.java new file mode 100644 index 0000000..2b9fcab --- /dev/null +++ b/src/api/java/mekanism/api/package-info.java @@ -0,0 +1,3 @@ +@API(apiVersion = "8.0.0", owner = "Mekanism", provides = "MekanismAPI|core") +package mekanism.api; +import cpw.mods.fml.common.API;
\ No newline at end of file diff --git a/src/api/java/mekanism/api/reactor/IFusionReactor.java b/src/api/java/mekanism/api/reactor/IFusionReactor.java new file mode 100644 index 0000000..9d9d96d --- /dev/null +++ b/src/api/java/mekanism/api/reactor/IFusionReactor.java @@ -0,0 +1,66 @@ +package mekanism.api.reactor; + +import mekanism.api.IHeatTransfer; +import mekanism.api.gas.GasTank; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidTank; + +public interface IFusionReactor extends IHeatTransfer +{ + public void addTemperatureFromEnergyInput(double energyAdded); + + public void simulate(); + + public FluidTank getWaterTank(); + + public FluidTank getSteamTank(); + + public GasTank getDeuteriumTank(); + + public GasTank getTritiumTank(); + + public GasTank getFuelTank(); + + public double getBufferedEnergy(); + + public void setBufferedEnergy(double energy); + + public double getPlasmaTemp(); + + public void setPlasmaTemp(double temp); + + public double getCaseTemp(); + + public void setCaseTemp(double temp); + + public double getBufferSize(); + + public void formMultiblock(); + + public boolean isFormed(); + + public void setInjectionRate(int rate); + + public int getInjectionRate(); + + public boolean isBurning(); + + public void setBurning(boolean burn); + + public int getMinInjectionRate(boolean active); + + public double getMaxPlasmaTemperature(boolean active); + + public double getMaxCasingTemperature(boolean active); + + public double getIgnitionTemperature(boolean active); + + public double getPassiveGeneration(boolean active, boolean current); + + public int getSteamPerTick(boolean current); + + public void updateTemperatures(); + + public ItemStack[] getInventory(); +} diff --git a/src/api/java/mekanism/api/reactor/INeutronCapture.java b/src/api/java/mekanism/api/reactor/INeutronCapture.java new file mode 100644 index 0000000..6171a7f --- /dev/null +++ b/src/api/java/mekanism/api/reactor/INeutronCapture.java @@ -0,0 +1,6 @@ +package mekanism.api.reactor; + +public interface INeutronCapture extends IReactorBlock +{ + public int absorbNeutrons(int neutrons); +} diff --git a/src/api/java/mekanism/api/reactor/IReactorBlock.java b/src/api/java/mekanism/api/reactor/IReactorBlock.java new file mode 100644 index 0000000..b3b8518 --- /dev/null +++ b/src/api/java/mekanism/api/reactor/IReactorBlock.java @@ -0,0 +1,12 @@ +package mekanism.api.reactor; + + +public interface IReactorBlock +{ + public boolean isFrame(); + + public void setReactor(IFusionReactor reactor); + + public IFusionReactor getReactor(); + +} diff --git a/src/api/java/mekanism/api/reactor/package-info.java b/src/api/java/mekanism/api/reactor/package-info.java new file mode 100644 index 0000000..6a00fc6 --- /dev/null +++ b/src/api/java/mekanism/api/reactor/package-info.java @@ -0,0 +1,3 @@ +@API(apiVersion = "8.0.0", owner = "Mekanism", provides = "MekanismAPI|reactor") +package mekanism.api.reactor; +import cpw.mods.fml.common.API;
\ No newline at end of file diff --git a/src/api/java/mekanism/api/recipe/RecipeHelper.java b/src/api/java/mekanism/api/recipe/RecipeHelper.java new file mode 100644 index 0000000..1040aa2 --- /dev/null +++ b/src/api/java/mekanism/api/recipe/RecipeHelper.java @@ -0,0 +1,319 @@ +package mekanism.api.recipe; + +import java.lang.reflect.Method; + +import mekanism.api.gas.GasStack; +import mekanism.api.infuse.InfuseType; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidStack; + +/** + * SET TO BE REMOVED NEXT MINOR MEKANISM VERSION, PLEASE USE IMC INSTEAD. + * Use this handy class to add recipes to Mekanism machinery. + * @author AidanBrady + * + */ +@Deprecated +public final class RecipeHelper +{ + /** + * Add an Enrichment Chamber recipe. + * @param input - input ItemStack + * @param output - output ItemStack + */ + public static void addEnrichmentChamberRecipe(ItemStack input, ItemStack output) + { + try { + Class recipeClass = Class.forName("mekanism.common.recipe.RecipeHandler"); + Method m = recipeClass.getMethod("addEnrichmentChamberRecipe", ItemStack.class, ItemStack.class); + m.invoke(null, input, output); + } catch(Exception e) { + System.err.println("Error while adding recipe: " + e.getMessage()); + } + } + + /** + * Add an Osmium Compressor recipe. + * @param input - input ItemStack + * @param output - output ItemStack + */ + public static void addOsmiumCompressorRecipe(ItemStack input, ItemStack output) + { + try { + Class recipeClass = Class.forName("mekanism.common.recipe.RecipeHandler"); + Method m = recipeClass.getMethod("addOsmiumCompressorRecipe", ItemStack.class, ItemStack.class); + m.invoke(null, input, output); + } catch(Exception e) { + System.err.println("Error while adding recipe: " + e.getMessage()); + } + } + + /** + * Add a Combiner recipe. + * @param input - input ItemStack + * @param output - output ItemStack + */ + public static void addCombinerRecipe(ItemStack input, ItemStack output) + { + try { + Class recipeClass = Class.forName("mekanism.common.recipe.RecipeHandler"); + Method m = recipeClass.getMethod("addCombinerRecipe", ItemStack.class, ItemStack.class); + m.invoke(null, input, output); + } catch(Exception e) { + System.err.println("Error while adding recipe: " + e.getMessage()); + } + } + + /** + * Add a Crusher recipe. + * @param input - input ItemStack + * @param output - output ItemStack + */ + public static void addCrusherRecipe(ItemStack input, ItemStack output) + { + try { + Class recipeClass = Class.forName("mekanism.common.recipe.RecipeHandler"); + Method m = recipeClass.getMethod("addCrusherRecipe", ItemStack.class, ItemStack.class); + m.invoke(null, input, output); + } catch(Exception e) { + System.err.println("Error while adding recipe: " + e.getMessage()); + } + } + + /** + * Add a Purification Chamber recipe. + * @param input - input ItemStack + * @param output - output ItemStack + */ + public static void addPurificationChamberRecipe(ItemStack input, ItemStack output) + { + try { + Class recipeClass = Class.forName("mekanism.common.recipe.RecipeHandler"); + Method m = recipeClass.getMethod("addPurificationChamberRecipe", ItemStack.class, ItemStack.class); + m.invoke(null, input, output); + } catch(Exception e) { + System.err.println("Error while adding recipe: " + e.getMessage()); + } + } + + /** + * Add a Chemical Oxidizer recipe. + * @param input - input ItemStack + * @param output - output GasStack + */ + public static void addChemicalOxidizerRecipe(ItemStack input, GasStack output) + { + try { + Class recipeClass = Class.forName("mekanism.common.recipe.RecipeHandler"); + Method m = recipeClass.getMethod("addChemicalOxidizerRecipe", ItemStack.class, GasStack.class); + m.invoke(null, input, output); + } catch(Exception e) { + System.err.println("Error while adding recipe: " + e.getMessage()); + } + } + + /** + * Add a Chemical Infuser recipe. + * @param leftInput - left input GasStack + * @param rightInput - right input GasStack + * @param output - output GasStack + */ + public static void addChemicalInfuserRecipe(GasStack leftInput, GasStack rightInput, GasStack output) + { + try { + Class recipeClass = Class.forName("mekanism.common.recipe.RecipeHandler"); + Method m = recipeClass.getMethod("addChemicalInfuserRecipe", GasStack.class, GasStack.class, GasStack.class); + m.invoke(null, leftInput, rightInput, output); + } catch(Exception e) { + System.err.println("Error while adding recipe: " + e.getMessage()); + } + } + + /** + * Add a Precision Sawmill recipe. + * @param input - input ItemStack + * @param primaryOutput - guaranteed output + * @param secondaryOutput - possible extra output + * @param chance - probability of obtaining extra output + */ + public static void addPrecisionSawmillRecipe(ItemStack input, ItemStack primaryOutput, ItemStack secondaryOutput, double chance) + { + try { + Class recipeClass = Class.forName("mekanism.common.recipe.RecipeHandler"); + Method m = recipeClass.getMethod("addPrecisionSawmillRecipe", ItemStack.class, ItemStack.class, ItemStack.class, Double.TYPE); + m.invoke(null, input, primaryOutput, secondaryOutput, chance); + } catch(Exception e) { + System.err.println("Error while adding recipe: " + e.getMessage()); + } + } + + /** + * Add a Precision Sawmill recipe with no chance output + * @param input - input ItemStack + * @param primaryOutput - guaranteed output + */ + public static void addPrecisionSawmillRecipe(ItemStack input, ItemStack primaryOutput) + { + try { + Class recipeClass = Class.forName("mekanism.common.recipe.RecipeHandler"); + Method m = recipeClass.getMethod("addPrecisionSawmillRecipe", ItemStack.class, ItemStack.class); + m.invoke(null, input, primaryOutput); + } catch(Exception e) { + System.err.println("Error while adding recipe: " + e.getMessage()); + } + } + + /** + * Add a Chemical Injection Chamber recipe. + * @param input - input AdvancedInput + * @param output - output ItemStack + */ + public static void addChemicalInjectionChamberRecipe(ItemStack input, String gasName, ItemStack output) + { + try { + Class recipeClass = Class.forName("mekanism.common.recipe.RecipeHandler"); + Method m = recipeClass.getMethod("addChemicalInjectionChamberRecipe", ItemStack.class, String.class, ItemStack.class); + m.invoke(null, input, gasName, output); + } catch(Exception e) { + System.err.println("Error while adding recipe: " + e.getMessage()); + } + } + + /** + * Add an Electrolytic Separator recipe. + * @param input - input FluidStack + * @param energy - required energy + * @param leftOutput - left output GasStack + * @param rightOutput - right output GasStack + */ + public static void addElectrolyticSeparatorRecipe(FluidStack input, double energy, GasStack leftOutput, GasStack rightOutput) + { + try { + Class recipeClass = Class.forName("mekanism.common.recipe.RecipeHandler"); + Method m = recipeClass.getMethod("addElectrolyticSeparatorRecipe", FluidStack.class, Double.TYPE, GasStack.class, GasStack.class); + m.invoke(null, input, energy, leftOutput, rightOutput); + } catch(Exception e) { + System.err.println("Error while adding recipe: " + e.getMessage()); + } + } + + /** + * Add a Chemical Dissolution Chamber recipe. + * @param input - input ItemStack + * @param output - output GasStack + */ + public static void addChemicalDissolutionChamberRecipe(ItemStack input, GasStack output) + { + try { + Class recipeClass = Class.forName("mekanism.common.recipe.RecipeHandler"); + Method m = recipeClass.getMethod("addChemicalDissolutionChamberRecipe", ItemStack.class, GasStack.class); + m.invoke(null, input, output); + } catch(Exception e) { + System.err.println("Error while adding recipe: " + e.getMessage()); + } + } + + /** + * Add a Chemical Washer recipe. + * @param input - input GasStack + * @param output - output GasStack + */ + public static void addChemicalWasherRecipe(GasStack input, GasStack output) + { + try { + Class recipeClass = Class.forName("mekanism.common.recipe.RecipeHandler"); + Method m = recipeClass.getMethod("addChemicalWasherRecipe", GasStack.class, GasStack.class); + m.invoke(null, input, output); + } catch(Exception e) { + System.err.println("Error while adding recipe: " + e.getMessage()); + } + } + + /** + * Add a Chemical Crystallizer recipe. + * @param input - input GasStack + * @param output - output ItemStack + */ + public static void addChemicalCrystallizerRecipe(GasStack input, ItemStack output) + { + try { + Class recipeClass = Class.forName("mekanism.common.recipe.RecipeHandler"); + Method m = recipeClass.getMethod("addChemicalCrystallizerRecipe", GasStack.class, ItemStack.class); + m.invoke(null, input, output); + } catch(Exception e) { + System.err.println("Error while adding recipe: " + e.getMessage()); + } + } + + /** + * Add a Metallurgic Infuser recipe. + * @param infuse - which Infuse to use + * @param amount - how much Infuse to use + * @param input - input ItemStack + * @param output - output ItemStack + */ + public static void addMetallurgicInfuserRecipe(InfuseType infuse, int amount, ItemStack input, ItemStack output) + { + try { + Class recipeClass = Class.forName("mekanism.common.recipe.RecipeHandler"); + Method m = recipeClass.getMethod("addMetallurgicInfuserRecipe", InfuseType.class, Integer.TYPE, ItemStack.class, ItemStack.class); + m.invoke(null, infuse, amount, input, output); + } catch(Exception e) { + System.err.println("Error while adding recipe: " + e.getMessage()); + } + } + + /** + * Add a Pressurized Reaction Chamber recipe. + * @param inputSolid - input ItemStack + * @param inputFluid - input FluidStack + * @param inputGas - input GasStack + * @param outputSolid - output ItemStack + * @param outputGas - output GasStack + * @param extraEnergy - extra energy needed by the recipe + * @param ticks - amount of ticks it takes for this recipe to complete + */ + public static void addPRCRecipe(ItemStack inputSolid, FluidStack inputFluid, GasStack inputGas, ItemStack outputSolid, GasStack outputGas, double extraEnergy, int ticks) + { + try { + Class recipeClass = Class.forName("mekanism.common.recipe.RecipeHandler"); + Method m = recipeClass.getMethod("addPRCRecipe", ItemStack.class, FluidStack.class, GasStack.class, ItemStack.class, GasStack.class, Double.TYPE, Integer.TYPE); + m.invoke(null, inputSolid, inputFluid, inputGas, outputSolid, outputGas, extraEnergy, ticks); + } catch(Exception e) { + System.err.println("Error while adding recipe: " + e.getMessage()); + } + } + + /** + * Add a Solar Evaporation Plant recipe. + * @param input - input GasStack + * @param output - output GasStack + */ + public static void addSolarEvaporationRecipe(FluidStack input, FluidStack output) + { + try { + Class recipeClass = Class.forName("mekanism.common.recipe.RecipeHandler"); + Method m = recipeClass.getMethod("addSolarEvaporationRecipe", FluidStack.class, FluidStack.class); + m.invoke(null, input, output); + } catch(Exception e) { + System.err.println("Error while adding recipe: " + e.getMessage()); + } + } + + /** + * Add a Solar Neutron Activator recipe. + * @param input - input GasStack + * @param output - output GasStack + */ + public static void addSolarNeutronRecipe(GasStack input, GasStack output) + { + try { + Class recipeClass = Class.forName("mekanism.common.recipe.RecipeHandler"); + Method m = recipeClass.getMethod("addSolarEvaporationRecipe", GasStack.class, GasStack.class); + m.invoke(null, input, output); + } catch(Exception e) { + System.err.println("Error while adding recipe: " + e.getMessage()); + } + } +} diff --git a/src/api/java/mekanism/api/recipe/package-info.java b/src/api/java/mekanism/api/recipe/package-info.java new file mode 100644 index 0000000..f166da4 --- /dev/null +++ b/src/api/java/mekanism/api/recipe/package-info.java @@ -0,0 +1,3 @@ +@API(apiVersion = "8.0.0", owner = "Mekanism", provides = "MekanismAPI|recipe") +package mekanism.api.recipe; +import cpw.mods.fml.common.API;
\ No newline at end of file diff --git a/src/api/java/mekanism/api/transmitters/DynamicNetwork.java b/src/api/java/mekanism/api/transmitters/DynamicNetwork.java new file mode 100644 index 0000000..ee4e8a2 --- /dev/null +++ b/src/api/java/mekanism/api/transmitters/DynamicNetwork.java @@ -0,0 +1,456 @@ +package mekanism.api.transmitters; + +import com.google.common.collect.Lists; +import com.google.common.collect.Maps; +import com.google.common.collect.Sets; +import cpw.mods.fml.common.FMLCommonHandler; +import cpw.mods.fml.common.eventhandler.Event; +import mekanism.api.Coord4D; +import mekanism.api.IClientTicker; +import mekanism.api.Range4D; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.common.util.ForgeDirection; + +import java.util.*; +import java.util.Map.Entry; + +public abstract class DynamicNetwork<A, N extends DynamicNetwork<A, N>> implements IClientTicker, INetworkDataHandler +{ + public LinkedHashSet<IGridTransmitter<A, N>> transmitters = Sets.newLinkedHashSet(); + public LinkedHashSet<IGridTransmitter<A, N>> transmittersToAdd = Sets.newLinkedHashSet(); + public LinkedHashSet<IGridTransmitter<A, N>> transmittersAdded = Sets.newLinkedHashSet(); + + public HashMap<Coord4D, A> possibleAcceptors = new HashMap<Coord4D, A>(); + public HashMap<Coord4D, EnumSet<ForgeDirection>> acceptorDirections = new HashMap<Coord4D, EnumSet<ForgeDirection>>(); + public HashMap<IGridTransmitter<A, N>, EnumSet<ForgeDirection>> changedAcceptors = Maps.newHashMap(); + + private Set<DelayQueue> updateQueue = new LinkedHashSet<DelayQueue>(); + + protected Range4D packetRange = null; + + protected int capacity = 0; + protected double meanCapacity = 0; + + protected boolean needsUpdate = false; + protected int updateDelay = 0; + + protected boolean firstUpdate = true; + protected World worldObj = null; + + public void addNewTransmitters(Collection<IGridTransmitter<A, N>> newTransmitters) + { + transmittersToAdd.addAll(newTransmitters); + } + + public void commit() + { + if(!transmittersToAdd.isEmpty()) + { + for(IGridTransmitter<A, N> transmitter : transmittersToAdd) + { + if(transmitter.isValid()) + { + if(worldObj == null) + { + worldObj = transmitter.world(); + } + + for(ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) + { + updateTransmitterOnSide(transmitter, side); + } + + transmitter.setTransmitterNetwork((N)this); + absorbBuffer(transmitter); + transmitters.add(transmitter); + } + } + + updateCapacity(); + clampBuffer(); + queueClientUpdate(Lists.newArrayList(transmittersToAdd)); + transmittersToAdd.clear(); + } + + if(!changedAcceptors.isEmpty()) + { + for(Entry<IGridTransmitter<A, N>, EnumSet<ForgeDirection>> entry : changedAcceptors.entrySet()) + { + IGridTransmitter<A, N> transmitter = entry.getKey(); + + if(transmitter.isValid()) + { + EnumSet<ForgeDirection> directionsChanged = entry.getValue(); + + for(ForgeDirection side : directionsChanged) + { + updateTransmitterOnSide(transmitter, side); + } + } + } + + changedAcceptors.clear(); + } + } + + public void updateTransmitterOnSide(IGridTransmitter<A, N> transmitter, ForgeDirection side) + { + A acceptor = transmitter.getAcceptor(side); + Coord4D acceptorCoord = transmitter.coord().getFromSide(side); + EnumSet<ForgeDirection> directions = acceptorDirections.get(acceptorCoord); + + if(acceptor != null) + { + possibleAcceptors.put(acceptorCoord, acceptor); + + if(directions != null) + { + directions.add(side.getOpposite()); + } + else { + acceptorDirections.put(acceptorCoord, EnumSet.of(side.getOpposite())); + } + } + else { + if(directions != null) + { + directions.remove(side.getOpposite()); + + if(directions.isEmpty()) + { + possibleAcceptors.remove(acceptorCoord); + acceptorDirections.remove(acceptorCoord); + } + } + else { + possibleAcceptors.remove(acceptorCoord); + acceptorDirections.remove(acceptorCoord); + } + } + + } + + public abstract void absorbBuffer(IGridTransmitter<A, N> transmitter); + + public abstract void clampBuffer(); + + public void invalidate() + { + //Remove invalid transmitters first for share calculations + for(Iterator<IGridTransmitter<A, N>> iter = transmitters.iterator(); iter.hasNext();) + { + IGridTransmitter<A, N> transmitter = iter.next(); + + if(!transmitter.isValid()) + { + iter.remove(); + continue; + } + } + + //Clamp the new buffer + clampBuffer(); + + //Update all shares + for(IGridTransmitter<A, N> transmitter : transmitters) + { + transmitter.updateShare(); + } + + //Now invalidate the transmitters + for(IGridTransmitter<A, N> transmitter : transmitters) + { + invalidateTransmitter(transmitter); + } + + transmitters.clear(); + deregister(); + } + + public void invalidateTransmitter(IGridTransmitter<A, N> transmitter) + { + if(!worldObj.isRemote && transmitter.isValid()) + { + transmitter.takeShare(); + transmitter.setTransmitterNetwork(null); + TransmitterNetworkRegistry.registerOrphanTransmitter(transmitter); + } + } + + public void acceptorChanged(IGridTransmitter<A, N> transmitter, ForgeDirection side) + { + EnumSet<ForgeDirection> directions = changedAcceptors.get(transmitter); + + if(directions != null) + { + directions.add(side); + } + else { + changedAcceptors.put(transmitter, EnumSet.of(side)); + } + + TransmitterNetworkRegistry.registerChangedNetwork(this); + } + + public void adoptTransmittersAndAcceptorsFrom(N net) + { + for(IGridTransmitter<A, N> transmitter : net.transmitters) + { + transmitter.setTransmitterNetwork((N)this); + transmitters.add(transmitter); + transmittersAdded.add(transmitter); + } + + possibleAcceptors.putAll(net.possibleAcceptors); + + for(Entry<Coord4D, EnumSet<ForgeDirection>> entry : net.acceptorDirections.entrySet()) + { + Coord4D coord = entry.getKey(); + + if(acceptorDirections.containsKey(coord)) + { + acceptorDirections.get(coord).addAll(entry.getValue()); + } + else { + acceptorDirections.put(coord, entry.getValue()); + } + } + + } + + public Range4D getPacketRange() + { + if(packetRange == null) + { + return genPacketRange(); + } + + return packetRange; + } + + protected Range4D genPacketRange() + { + if(getSize() == 0) + { + deregister(); + return null; + } + + IGridTransmitter<A, N> initTransmitter = transmitters.iterator().next(); + Coord4D initCoord = initTransmitter.coord(); + + int minX = initCoord.xCoord; + int minY = initCoord.yCoord; + int minZ = initCoord.zCoord; + int maxX = initCoord.xCoord; + int maxY = initCoord.yCoord; + int maxZ = initCoord.zCoord; + + for(IGridTransmitter transmitter : transmitters) + { + Coord4D coord = transmitter.coord(); + + if(coord.xCoord < minX) minX = coord.xCoord; + if(coord.yCoord < minY) minY = coord.yCoord; + if(coord.zCoord < minZ) minZ = coord.zCoord; + if(coord.xCoord > maxX) maxX = coord.xCoord; + if(coord.yCoord > maxY) maxY = coord.yCoord; + if(coord.zCoord > maxZ) maxZ = coord.zCoord; + } + + return new Range4D(minX, minY, minZ, maxX, maxY, maxZ, initTransmitter.world().provider.dimensionId); + } + + public void register() + { + if(FMLCommonHandler.instance().getEffectiveSide().isServer()) + { + TransmitterNetworkRegistry.getInstance().registerNetwork(this); + } + else { + MinecraftForge.EVENT_BUS.post(new ClientTickUpdate(this, (byte)1)); + } + } + + public void deregister() + { + transmitters.clear(); + + if(FMLCommonHandler.instance().getEffectiveSide().isServer()) + { + TransmitterNetworkRegistry.getInstance().removeNetwork(this); + } + else { + MinecraftForge.EVENT_BUS.post(new ClientTickUpdate(this, (byte)0)); + } + } + + public int getSize() + { + return transmitters.size(); + } + + public int getAcceptorSize() + { + return possibleAcceptors.size(); + } + + public synchronized void updateCapacity() + { + updateMeanCapacity(); + capacity = (int)meanCapacity * transmitters.size(); + } + + /** + * Override this if things can have variable capacity along the network. + * @return An 'average' value of capacity. Calculate it how you will. + */ + protected synchronized void updateMeanCapacity() + { + if(transmitters.size() > 0) + { + meanCapacity = transmitters.iterator().next().getCapacity(); + } + else { + meanCapacity = 0; + } + } + + public int getCapacity() + { + return capacity; + } + + public World getWorld() + { + return worldObj; + } + + public abstract Set<A> getAcceptors(Object data); + + public void tick() + { + onUpdate(); + } + + public void onUpdate() + { + if(FMLCommonHandler.instance().getEffectiveSide().isServer()) + { + Iterator<DelayQueue> i = updateQueue.iterator(); + + try { + while(i.hasNext()) + { + DelayQueue q = i.next(); + + if(q.delay > 0) + { + q.delay--; + } + else { + transmittersAdded.addAll(transmitters); + updateDelay = 1; + i.remove(); + } + } + } catch(Exception e) {} + + if(updateDelay > 0) + { + updateDelay--; + + if(updateDelay == 0) + { + MinecraftForge.EVENT_BUS.post(new TransmittersAddedEvent(this, firstUpdate, (Collection)transmittersAdded)); + firstUpdate = false; + transmittersAdded.clear(); + needsUpdate = true; + } + } + } + } + + @Override + public boolean needsTicks() + { + return getSize() > 0; + } + + @Override + public void clientTick() {} + + public void queueClientUpdate(Collection<IGridTransmitter<A, N>> newTransmitters) + { + transmittersAdded.addAll(newTransmitters); + updateDelay = 3; + } + + public static class TransmittersAddedEvent extends Event + { + public DynamicNetwork<?, ?> network; + public boolean newNetwork; + public Collection<IGridTransmitter> newTransmitters; + + public TransmittersAddedEvent(DynamicNetwork net, boolean newNet, Collection<IGridTransmitter> added) + { + network = net; + newNetwork = newNet; + newTransmitters = added; + } + } + + public static class ClientTickUpdate extends Event + { + public DynamicNetwork network; + public byte operation; /*0 remove, 1 add*/ + + public ClientTickUpdate(DynamicNetwork net, byte b) + { + network = net; + operation = b; + } + } + + public static class NetworkClientRequest extends Event + { + public TileEntity tileEntity; + + public NetworkClientRequest(TileEntity tile) + { + tileEntity = tile; + } + } + + public void addUpdate(EntityPlayer player) + { + updateQueue.add(new DelayQueue(player)); + } + + public static class DelayQueue + { + public EntityPlayer player; + public int delay; + + public DelayQueue(EntityPlayer p) + { + player = p; + delay = 5; + } + + @Override + public int hashCode() + { + return player.hashCode(); + } + + @Override + public boolean equals(Object o) + { + return o instanceof DelayQueue && ((DelayQueue)o).player.equals(this.player); + } + } +} diff --git a/src/api/java/mekanism/api/transmitters/IBlockableConnection.java b/src/api/java/mekanism/api/transmitters/IBlockableConnection.java new file mode 100644 index 0000000..f6811fb --- /dev/null +++ b/src/api/java/mekanism/api/transmitters/IBlockableConnection.java @@ -0,0 +1,10 @@ +package mekanism.api.transmitters; + +import net.minecraftforge.common.util.ForgeDirection; + +public interface IBlockableConnection +{ + public boolean canConnectMutual(ForgeDirection side); + + public boolean canConnect(ForgeDirection side); +} diff --git a/src/api/java/mekanism/api/transmitters/IGridTransmitter.java b/src/api/java/mekanism/api/transmitters/IGridTransmitter.java new file mode 100644 index 0000000..9d82d48 --- /dev/null +++ b/src/api/java/mekanism/api/transmitters/IGridTransmitter.java @@ -0,0 +1,64 @@ +package mekanism.api.transmitters; + +import mekanism.api.Coord4D; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; + +import java.util.Collection; + +public interface IGridTransmitter<A, N extends DynamicNetwork<A, N>> extends ITransmitter +{ + public boolean hasTransmitterNetwork(); + + /** + * Gets the network currently in use by this transmitter segment. + * @return network this transmitter is using + */ + public N getTransmitterNetwork(); + + /** + * Sets this transmitter segment's network to a new value. + * @param network - network to set to + */ + public void setTransmitterNetwork(N network); + + public int getTransmitterNetworkSize(); + + public int getTransmitterNetworkAcceptorSize(); + + public String getTransmitterNetworkNeeded(); + + public String getTransmitterNetworkFlow(); + + public String getTransmitterNetworkBuffer(); + + public double getTransmitterNetworkCapacity(); + + public int getCapacity(); + + public World world(); + + public Coord4D coord(); + + public Coord4D getAdjacentConnectableTransmitterCoord(ForgeDirection side); + + public A getAcceptor(ForgeDirection side); + + public boolean isValid(); + + public boolean isOrphan(); + + public void setOrphan(boolean orphaned); + + public N createEmptyNetwork(); + + public N mergeNetworks(Collection<N> toMerge); + + public N getExternalNetwork(Coord4D from); + + public void takeShare(); + + public void updateShare(); + + public Object getBuffer(); +} diff --git a/src/api/java/mekanism/api/transmitters/INetworkDataHandler.java b/src/api/java/mekanism/api/transmitters/INetworkDataHandler.java new file mode 100644 index 0000000..38cd637 --- /dev/null +++ b/src/api/java/mekanism/api/transmitters/INetworkDataHandler.java @@ -0,0 +1,10 @@ +package mekanism.api.transmitters; + +public interface INetworkDataHandler +{ + public String getNeededInfo(); + + public String getStoredInfo(); + + public String getFlowInfo(); +} diff --git a/src/api/java/mekanism/api/transmitters/ITransmitter.java b/src/api/java/mekanism/api/transmitters/ITransmitter.java new file mode 100644 index 0000000..cddc76a --- /dev/null +++ b/src/api/java/mekanism/api/transmitters/ITransmitter.java @@ -0,0 +1,11 @@ +package mekanism.api.transmitters; + +public interface ITransmitter +{ + /** + * Get the transmitter's transmission type + * + * @return TransmissionType this transmitter uses + */ + public TransmissionType getTransmissionType(); +} diff --git a/src/api/java/mekanism/api/transmitters/ITransmitterTile.java b/src/api/java/mekanism/api/transmitters/ITransmitterTile.java new file mode 100644 index 0000000..3940b71 --- /dev/null +++ b/src/api/java/mekanism/api/transmitters/ITransmitterTile.java @@ -0,0 +1,6 @@ +package mekanism.api.transmitters; + +public interface ITransmitterTile<A, N extends DynamicNetwork<A, N>> +{ + public IGridTransmitter<A, N> getTransmitter(); +} diff --git a/src/api/java/mekanism/api/transmitters/TransmissionType.java b/src/api/java/mekanism/api/transmitters/TransmissionType.java new file mode 100644 index 0000000..7b54e9c --- /dev/null +++ b/src/api/java/mekanism/api/transmitters/TransmissionType.java @@ -0,0 +1,80 @@ +package mekanism.api.transmitters; + +import mekanism.api.gas.IGasTransmitter; + +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.StatCollector; + +public enum TransmissionType +{ + ENERGY("EnergyNetwork", "Energy"), + FLUID("FluidNetwork", "Fluids"), + GAS("GasNetwork", "Gases"), + ITEM("InventoryNetwork", "Items"), + HEAT("HeatNetwork", "Heat"); + + private String name; + private String transmission; + + private TransmissionType(String n, String t) + { + name = n; + transmission = t; + } + + public String getName() + { + return name; + } + + public String getTransmission() + { + return transmission; + } + + public String localize() + { + return StatCollector.translateToLocal("transmission." + getTransmission()); + } + + public static boolean checkTransmissionType(ITransmitter sideTile, TransmissionType type) + { + return type.checkTransmissionType(sideTile); + } + + public static boolean checkTransmissionType(TileEntity tile1, TransmissionType type) + { + return checkTransmissionType(tile1, type, null); + } + + public static boolean checkTransmissionType(TileEntity tile1, TransmissionType type, TileEntity tile2) + { + return type.checkTransmissionType(tile1, tile2); + } + + public boolean checkTransmissionType(ITransmitter transmitter) + { + return transmitter.getTransmissionType() == this; + } + + public boolean checkTransmissionType(TileEntity sideTile, TileEntity currentTile) + { + if(sideTile instanceof ITransmitter) + { + if(((ITransmitter)sideTile).getTransmissionType() == this) + { + return true; + } + } + + if(this == GAS && currentTile instanceof IGasTransmitter) + { + if(((IGasTransmitter)currentTile).canTransferGasToTube(sideTile)) + { + return true; + } + } + + return false; + } +}
\ No newline at end of file diff --git a/src/api/java/mekanism/api/transmitters/TransmitterNetworkRegistry.java b/src/api/java/mekanism/api/transmitters/TransmitterNetworkRegistry.java new file mode 100644 index 0000000..0f9c1c5 --- /dev/null +++ b/src/api/java/mekanism/api/transmitters/TransmitterNetworkRegistry.java @@ -0,0 +1,289 @@ +package mekanism.api.transmitters; + +import java.util.HashMap; +import java.util.HashSet; + +import mekanism.api.Coord4D; +import mekanism.api.MekanismAPI; +import net.minecraftforge.common.util.ForgeDirection; + +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; + +import com.google.common.collect.Maps; +import com.google.common.collect.Sets; + +import cpw.mods.fml.common.FMLCommonHandler; +import cpw.mods.fml.common.eventhandler.SubscribeEvent; +import cpw.mods.fml.common.gameevent.TickEvent.Phase; +import cpw.mods.fml.common.gameevent.TickEvent.ServerTickEvent; +import cpw.mods.fml.relauncher.Side; + +public class TransmitterNetworkRegistry +{ + private static TransmitterNetworkRegistry INSTANCE = new TransmitterNetworkRegistry(); + private static boolean loaderRegistered = false; + + private HashSet<DynamicNetwork> networks = Sets.newHashSet(); + private HashSet<DynamicNetwork> networksToChange = Sets.newHashSet(); + + private HashSet<IGridTransmitter> invalidTransmitters = Sets.newHashSet(); + private HashMap<Coord4D, IGridTransmitter> orphanTransmitters = Maps.newHashMap(); + + private Logger logger = LogManager.getLogger("MekanismTransmitters"); + + public static void initiate() + { + if(!loaderRegistered) + { + loaderRegistered = true; + + FMLCommonHandler.instance().bus().register(INSTANCE); + } + } + + public static void reset() + { + getInstance().networks.clear(); + getInstance().networksToChange.clear(); + getInstance().invalidTransmitters.clear(); + getInstance().orphanTransmitters.clear(); + } + + public static void invalidateTransmitter(IGridTransmitter transmitter) + { + getInstance().invalidTransmitters.add(transmitter); + } + + public static void registerOrphanTransmitter(IGridTransmitter transmitter) + { + getInstance().orphanTransmitters.put(transmitter.coord(), transmitter); + } + + public static void registerChangedNetwork(DynamicNetwork network) + { + getInstance().networksToChange.add(network); + } + + public static TransmitterNetworkRegistry getInstance() + { + return INSTANCE; + } + + public void registerNetwork(DynamicNetwork network) + { + networks.add(network); + } + + public void removeNetwork(DynamicNetwork network) + { + if(networks.contains(network)) + { + networks.remove(network); + } + } + + @SubscribeEvent + public void onTick(ServerTickEvent event) + { + if(event.phase == Phase.END && event.side == Side.SERVER) + { + tickEnd(); + } + } + + public void tickEnd() + { + removeInvalidTransmitters(); + + assignOrphans(); + + commitChanges(); + + for(DynamicNetwork net : networks) + { + net.tick(); + } + } + + public void removeInvalidTransmitters() + { + if(MekanismAPI.debug && !invalidTransmitters.isEmpty()) + { + logger.info("Dealing with " + invalidTransmitters.size() + " invalid Transmitters"); + } + + for(IGridTransmitter invalid : invalidTransmitters) + { + if(!(invalid.isOrphan() && invalid.isValid())) + { + DynamicNetwork n = invalid.getTransmitterNetwork(); + + if(n != null) + { + n.invalidate(); + } + } + } + + invalidTransmitters.clear(); + } + + public void assignOrphans() + { + if(MekanismAPI.debug && !orphanTransmitters.isEmpty()) + { + logger.info("Dealing with " + orphanTransmitters.size() + " orphan Transmitters"); + } + + for(IGridTransmitter orphanTransmitter : orphanTransmitters.values()) + { + DynamicNetwork network = getNetworkFromOrphan(orphanTransmitter); + + if(network != null) + { + networksToChange.add(network); + network.register(); + } + } + + orphanTransmitters.clear(); + } + + public <A, N extends DynamicNetwork<A, N>> DynamicNetwork<A, N> getNetworkFromOrphan(IGridTransmitter<A, N> startOrphan) + { + if(startOrphan.isValid() && startOrphan.isOrphan()) + { + OrphanPathFinder<A, N> finder = new OrphanPathFinder<A, N>(startOrphan); + finder.start(); + N network; + + switch(finder.networksFound.size()) + { + case 0: + if(MekanismAPI.debug) + { + logger.info("No networks found. Creating new network for " + finder.connectedTransmitters.size() + " transmitters"); + } + + network = startOrphan.createEmptyNetwork(); + + break; + case 1: + if(MekanismAPI.debug) + { + logger.info("Adding " + finder.connectedTransmitters.size() + " transmitters to single found network"); + } + + network = finder.networksFound.iterator().next(); + + break; + default: + if(MekanismAPI.debug) + { + logger.info("Merging " + finder.networksFound.size() + " networks with " + finder.connectedTransmitters.size() + " new transmitters"); + } + + network = startOrphan.mergeNetworks(finder.networksFound); + } + + network.addNewTransmitters(finder.connectedTransmitters); + + return network; + } + + return null; + } + + public void commitChanges() + { + for(DynamicNetwork network : networksToChange) + { + network.commit(); + } + + networksToChange.clear(); + } + + @Override + public String toString() + { + return "Network Registry:\n" + networks; + } + + public String[] toStrings() + { + String[] strings = new String[networks.size()]; + int i = 0; + + for(DynamicNetwork network : networks) + { + strings[i++] = network.toString(); + } + + return strings; + } + + public class OrphanPathFinder<A, N extends DynamicNetwork<A, N>> + { + public IGridTransmitter<A, N> startPoint; + + public HashSet<Coord4D> iterated = Sets.newHashSet(); + + public HashSet<IGridTransmitter<A, N>> connectedTransmitters = Sets.newHashSet(); + public HashSet<N> networksFound = Sets.newHashSet(); + + public OrphanPathFinder(IGridTransmitter<A, N> start) + { + startPoint = start; + } + + public void start() + { + iterate(startPoint.coord(), ForgeDirection.UNKNOWN); + } + + public void iterate(Coord4D from, ForgeDirection fromDirection) + { + if(iterated.contains(from)) + { + return; + } + + iterated.add(from); + + if(orphanTransmitters.containsKey(from)) + { + IGridTransmitter<A, N> transmitter = orphanTransmitters.get(from); + + if(transmitter.isValid() && transmitter.isOrphan()) + { + connectedTransmitters.add(transmitter); + transmitter.setOrphan(false); + + for(ForgeDirection direction : ForgeDirection.VALID_DIRECTIONS) + { + if(direction != fromDirection) + { + Coord4D directionCoord = transmitter.getAdjacentConnectableTransmitterCoord(direction); + + if(!(directionCoord == null || iterated.contains(directionCoord))) + { + iterate(directionCoord, direction.getOpposite()); + } + } + } + } + } + else { + addNetworkToIterated(from); + } + } + + public void addNetworkToIterated(Coord4D from) + { + N net = startPoint.getExternalNetwork(from); + if(net != null) networksFound.add(net); + } + } +} diff --git a/src/api/java/mekanism/api/transmitters/package-info.java b/src/api/java/mekanism/api/transmitters/package-info.java new file mode 100644 index 0000000..06819e7 --- /dev/null +++ b/src/api/java/mekanism/api/transmitters/package-info.java @@ -0,0 +1,3 @@ +@API(apiVersion = "8.0.0", owner = "Mekanism", provides = "MekanismAPI|transmitter") +package mekanism.api.transmitters; +import cpw.mods.fml.common.API;
\ No newline at end of file diff --git a/src/api/java/mekanism/api/util/BlockInfo.java b/src/api/java/mekanism/api/util/BlockInfo.java new file mode 100644 index 0000000..2cb40d7 --- /dev/null +++ b/src/api/java/mekanism/api/util/BlockInfo.java @@ -0,0 +1,38 @@ +package mekanism.api.util; + +import net.minecraft.block.Block; +import net.minecraft.item.ItemStack; + +public class BlockInfo +{ + public Block block; + public int meta; + + public BlockInfo(Block b, int j) + { + block = b; + meta = j; + } + + public static BlockInfo get(ItemStack stack) + { + return new BlockInfo(Block.getBlockFromItem(stack.getItem()), stack.getItemDamage()); + } + + @Override + public boolean equals(Object obj) + { + return obj instanceof BlockInfo && + ((BlockInfo)obj).block == block && + ((BlockInfo)obj).meta == meta; + } + + @Override + public int hashCode() + { + int code = 1; + code = 31 * code + block.getUnlocalizedName().hashCode(); + code = 31 * code + meta; + return code; + } +}
\ No newline at end of file diff --git a/src/api/java/mekanism/api/util/ItemInfo.java b/src/api/java/mekanism/api/util/ItemInfo.java new file mode 100644 index 0000000..f27065b --- /dev/null +++ b/src/api/java/mekanism/api/util/ItemInfo.java @@ -0,0 +1,38 @@ +package mekanism.api.util; + +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; + +public class ItemInfo +{ + public Item item; + public int meta; + + public ItemInfo(Item i, int j) + { + item = i; + meta = j; + } + + public static ItemInfo get(ItemStack stack) + { + return new ItemInfo(stack.getItem(), stack.getItemDamage()); + } + + @Override + public boolean equals(Object obj) + { + return obj instanceof ItemInfo && + ((ItemInfo)obj).item == item && + ((ItemInfo)obj).meta == meta; + } + + @Override + public int hashCode() + { + int code = 1; + code = 31 * code + System.identityHashCode(item); + code = 7 * code + meta; + return code; + } +} diff --git a/src/api/java/mekanism/api/util/ListUtils.java b/src/api/java/mekanism/api/util/ListUtils.java new file mode 100644 index 0000000..e20807c --- /dev/null +++ b/src/api/java/mekanism/api/util/ListUtils.java @@ -0,0 +1,282 @@ +package mekanism.api.util; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Set; + +public class ListUtils +{ + public static <V> List<V> inverse(List<V> list) + { + List<V> toReturn = new ArrayList<V>(); + + for(int i = list.size() - 1; i >= 0; i--) + { + toReturn.add(list.get(i)); + } + + return toReturn; + } + + public static <V> List<V> cap(List<V> list, int cap) + { + List<V> toReturn = new ArrayList<V>(); + + if(list.size() <= cap) + { + toReturn = copy(list); + } + else { + int count = 0; + + for(V obj : list) + { + count++; + + toReturn.add(obj); + + if(count == cap) + { + break; + } + } + } + + return toReturn; + } + + public static <V> List<V> copy(List<V> list) + { + List<V> toReturn = new ArrayList<V>(); + + for(V obj : list) + { + toReturn.add(obj); + } + + return toReturn; + } + + public static <V> List<V> merge(List<V> listOne, List<V> listTwo) + { + List<V> newList = new ArrayList<V>(); + + for(V obj : listOne) + { + newList.add(obj); + } + + for(V obj : listTwo) + { + newList.add(obj); + } + + return newList; + } + + public static <V> List<V> capRemains(List<V> list, int cap) + { + List<V> toReturn = new ArrayList<V>(); + + if(list.size() <= cap) + { + return toReturn; + } + else { + List<V> inverse = inverse(list); + + int iterNeeded = list.size() - cap; + int count = 0; + + for(V obj : list) + { + count++; + + toReturn.add(obj); + + if(count == iterNeeded) + { + break; + } + } + + return toReturn; + } + } + + public static <V> ArrayList<List<V>> split(List<V> list, int divide) + { + int remain = list.size() % divide; + int size = (list.size() - remain) / divide; + + ArrayList<List<V>> toReturn = new ArrayList<List<V>>(); + + for(int i = 0; i < divide; i++) + { + toReturn.add(i, new ArrayList<V>()); + } + + for(List<V> iterSet : toReturn) + { + List<V> removed = new ArrayList<V>(); + + int toAdd = size; + + if(remain > 0) + { + remain--; + toAdd++; + } + + for(V obj : list) + { + if(toAdd == 0) + { + break; + } + + iterSet.add(obj); + removed.add(obj); + toAdd--; + } + + for(V obj : removed) + { + list.remove(obj); + } + } + + return toReturn; + } + + public static <V> V getTop(List<V> list) + { + for(V obj : list) + { + return obj; + } + + return null; + } + + public static <V> List<V> asList(Set<V> set) + { + return (List<V>)Arrays.asList(set.toArray()); + } + + public static <V> List<V> asList(V... values) + { + return (List<V>)Arrays.asList(values); + } + + public static double[] splitDouble(int size, double num) + { + double[] split = new double[size]; + + for(int i = 0; i < size; i++) + { + double remain = num%size; + double ret = (num-remain)/size; + ret += remain; + + split[i] = ret; + num -= remain; + } + + return split; + } + + public static double[] percent(double[] values) + { + double[] ret = new double[values.length]; + double total = 0; + + for(double d : values) total += d; + + for(int i = 0; i < values.length; i++) + { + ret[i] = values[i]/total; + } + + return ret; + } + + public static int[] calcPercentInt(double[] percent, int val) + { + int[] ret = new int[percent.length]; + + for(int i = 0; i < percent.length; i++) + { + ret[i] = (int)Math.round(val*percent[i]); + } + + int newTotal = 0; + for(int i : ret) newTotal += i; + + int diff = val-newTotal; + + if(diff != val) + { + for(int i = 0; i < ret.length; i++) + { + int num = ret[i]; + + if(diff < 0 && num == 0) + { + continue; + } + + if(diff > 0) + { + ret[i]++; + diff--; + } + else if(diff < 0) + { + ret[i]--; + diff++; + } + + if(diff == 0) + { + return ret; + } + } + } + + return ret; + } + + public static int[] splitInt(int size, int num) + { + int[] split = new int[size]; + + for(int i = 0; i < size; i++) + { + int remain = num%size; + int ret = (num-remain)/size; + ret += remain; + + split[i] = ret; + num -= remain; + } + + return split; + } + + public static double[] percent(int[] values) + { + double[] ret = new double[values.length]; + double total = 0; + + for(double d : values) total += d; + + for(int i = 0; i < values.length; i++) + { + ret[i] = values[i]/total; + } + + return ret; + } +} diff --git a/src/api/java/mekanism/api/util/StackUtils.java b/src/api/java/mekanism/api/util/StackUtils.java new file mode 100644 index 0000000..7363c75 --- /dev/null +++ b/src/api/java/mekanism/api/util/StackUtils.java @@ -0,0 +1,254 @@ +package mekanism.api.util; + +import java.util.ArrayList; +import java.util.List; + +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraftforge.oredict.OreDictionary; + +public final class StackUtils +{ + public static List<ItemStack> split(ItemStack stack) + { + if(stack == null || stack.stackSize == 0) + { + return null; + } + + List<ItemStack> ret = new ArrayList<ItemStack>(); + + if(stack.stackSize == 1) + { + ret.add(stack); + return ret; + } + + int remain = stack.stackSize % 2; + int split = (int)((float)(stack.stackSize)/2F); + + ret.add(size(stack, split+remain)); + ret.add(size(stack, split)); + + return ret; + } + + public static Item getItem(ItemStack stack) + { + if(stack == null) + { + return null; + } + + return stack.getItem(); + } + + public static boolean diffIgnoreNull(ItemStack stack1, ItemStack stack2) + { + if(stack1 == null || stack2 == null) + { + return false; + } + + return stack1.getItem() != stack2.getItem() || stack1.getItemDamage() != stack2.getItemDamage(); + } + + public static boolean equalsWildcard(ItemStack wild, ItemStack check) + { + if(wild == null || check == null) + { + return check == wild; + } + + return wild.getItem() == check.getItem() && (wild.getItemDamage() == OreDictionary.WILDCARD_VALUE || wild.getItemDamage() == check.getItemDamage()); + } + + public static boolean equalsWildcardWithNBT(ItemStack wild, ItemStack check) + { + return equalsWildcard(wild, check) && (wild.stackTagCompound == null ? check.stackTagCompound == null : (wild.stackTagCompound == check.stackTagCompound || wild.stackTagCompound.equals(check.stackTagCompound))); + } + + public static List<ItemStack> even(ItemStack stack1, ItemStack stack2) + { + ArrayList<ItemStack> ret = new ArrayList<ItemStack>(); + + if(getSize(stack1) == getSize(stack2) || Math.abs(getSize(stack1)-getSize(stack2)) == 1) + { + ret.add(stack1); + ret.add(stack2); + + return ret; + } + + if(getSize(stack1) > getSize(stack2)) + { + int diff = getSize(stack1)-getSize(stack2); + + List<ItemStack> split = split(size(stack1, diff)); + + ret.add(subtract(stack1, split.get(0))); + ret.add(add(stack2, split.get(0))); + } + else if(getSize(stack2) > getSize(stack1)) + { + int diff = getSize(stack2)-getSize(stack1); + + List<ItemStack> split = split(size(stack2, diff)); + + ret.add(subtract(stack2, split.get(0))); + ret.add(add(stack1, split.get(0))); + } + + return ret; + } + + public static ItemStack add(ItemStack stack1, ItemStack stack2) + { + if(stack1 == null) + { + return stack2; + } + else if(stack2 == null) + { + return stack1; + } + + return size(stack1, getSize(stack1)+getSize(stack2)); + } + + public static ItemStack subtract(ItemStack stack1, ItemStack stack2) + { + if(stack1 == null) + { + return null; + } + else if(stack2 == null) + { + return stack1; + } + + return size(stack1, getSize(stack1)-getSize(stack2)); + } + + public static ItemStack size(ItemStack stack, int size) + { + if(size <= 0 || stack == null) + { + return null; + } + + ItemStack ret = stack.copy(); + ret.stackSize = size; + return ret; + } + + public static ItemStack copy(ItemStack stack) + { + if(stack == null) + { + return null; + } + + return stack.copy(); + } + + public static int getSize(ItemStack stack) + { + return stack != null ? stack.stackSize : 0; + } + + public static List<ItemStack> getMergeRejects(ItemStack[] orig, ItemStack[] toAdd) + { + List<ItemStack> ret = new ArrayList<ItemStack>(); + + for(int i = 0; i < toAdd.length; i++) + { + if(toAdd[i] != null) + { + ItemStack reject = getMergeReject(orig[i], toAdd[i]); + + if(reject != null) + { + ret.add(reject); + } + } + } + + return ret; + } + + public static void merge(ItemStack[] orig, ItemStack[] toAdd) + { + for(int i = 0; i < toAdd.length; i++) + { + if(toAdd[i] != null) + { + orig[i] = merge(orig[i], toAdd[i]); + } + } + } + + public static ItemStack merge(ItemStack orig, ItemStack toAdd) + { + if(orig == null) + { + return toAdd; + } + + if(toAdd == null) + { + return orig; + } + + if(!orig.isItemEqual(toAdd) || !ItemStack.areItemStackTagsEqual(orig, toAdd)) + { + return orig; + } + + return StackUtils.size(orig, Math.min(orig.getMaxStackSize(), orig.stackSize+toAdd.stackSize)); + } + + public static ItemStack getMergeReject(ItemStack orig, ItemStack toAdd) + { + if(orig == null) + { + return null; + } + + if(toAdd == null) + { + return orig; + } + + if(!orig.isItemEqual(toAdd) || !ItemStack.areItemStackTagsEqual(orig, toAdd)) + { + return orig; + } + + int newSize = orig.stackSize+toAdd.stackSize; + + if(newSize > orig.getMaxStackSize()) + { + return StackUtils.size(orig, newSize-orig.getMaxStackSize()); + } + else { + return StackUtils.size(orig, newSize); + } + } + + public static boolean contains(ItemStack container, ItemStack contained) + { + return equalsWildcardWithNBT(contained, container) && container.stackSize >= contained.stackSize; + } + + public static int hashItemStack(ItemStack stack) + { + if(stack == null || stack.getItem() == null) + { + return -1; + } + + String name = stack.getItemDamage() == OreDictionary.WILDCARD_VALUE ? stack.getItem().getUnlocalizedName() : stack.getItem().getUnlocalizedName(stack); + return name.hashCode() << 8 | stack.getItemDamage(); + } +} diff --git a/src/api/java/mekanism/api/util/UnitDisplayUtils.java b/src/api/java/mekanism/api/util/UnitDisplayUtils.java new file mode 100644 index 0000000..9dd3e28 --- /dev/null +++ b/src/api/java/mekanism/api/util/UnitDisplayUtils.java @@ -0,0 +1,295 @@ +package mekanism.api.util; + +/** + * Code taken from UE and modified to fit Mekanism. + */ +public class UnitDisplayUtils +{ + public static enum ElectricUnit + { + JOULES("Joule", "J"), + REDSTONE_FLUX("Redstone Flux", "RF"), + MINECRAFT_JOULES("Minecraft Joule", "MJ"), + ELECTRICAL_UNITS("Electrical Unit", "EU"); + + public String name; + public String symbol; + + private ElectricUnit(String s, String s1) + { + name = s; + symbol = s1; + } + + public String getPlural() + { + return this == REDSTONE_FLUX ? name : name + "s"; + } + } + + public static enum TemperatureUnit + { + KELVIN("Kelvin", "K", 0, 1), + CELSIUS("Celsius", "°C", 273.15, 1), + RANKINE("Rankine", "R", 0, 9D/5D), + FAHRENHEIT("Fahrenheit", "°F", 459.67, 9D/5D), + AMBIENT("Ambient", "+STP", 300, 1); + + public String name; + public String symbol; + double zeroOffset; + double intervalSize; + + private TemperatureUnit(String s, String s1, double offset, double size) + { + name = s; + symbol = s1; + zeroOffset = offset; + intervalSize = size; + } + + public double convertFromK(double T) + { + return (T * intervalSize) - zeroOffset; + } + + public double convertToK(double T) + { + return (T + zeroOffset) / intervalSize; + } + } + + /** Metric system of measurement. */ + public static enum MeasurementUnit + { + FEMTO("Femto", "f", 0.000000000000001D), + PICO("Pico", "p", 0.000000000001D), + NANO("Nano", "n", 0.000000001D), + MICRO("Micro", "u", 0.000001D), + MILLI("Milli", "m", 0.001D), + BASE("", "", 1), + KILO("Kilo", "k", 1000D), + MEGA("Mega", "M", 1000000D), + GIGA("Giga", "G", 1000000000D), + TERA("Tera", "T", 1000000000000D), + PETA("Peta", "P", 1000000000000000D), + EXA("Exa", "E", 1000000000000000000D), + ZETTA("Zetta", "Z", 1000000000000000000000D), + YOTTA("Yotta", "Y", 1000000000000000000000000D); + + /** 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 double value; + + private MeasurementUnit(String s, String s1, double v) + { + name = s; + symbol = s1; + value = v; + } + + public String getName(boolean getShort) + { + if(getShort) + { + return symbol; + } + else { + return name; + } + } + + public double process(double d) + { + return d / value; + } + + public boolean above(double d) + { + return d > value; + } + + public boolean below(double d) + { + return d < value; + } + } + + /** + * 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(double value, ElectricUnit unit, int decimalPlaces, boolean isShort) + { + String unitName = unit.name; + String prefix = ""; + + if(value < 0) + { + value = Math.abs(value); + prefix = "-"; + } + + 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.below(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.above(value) && upperMeasure.below(value)) || lowerMeasure.value == value) + { + return prefix + roundDecimals(lowerMeasure.process(value), decimalPlaces) + " " + lowerMeasure.getName(isShort) + unitName; + } + } + } + + return prefix + roundDecimals(value, decimalPlaces) + " " + unitName; + } + + public static String getDisplayShort(double value, ElectricUnit unit) + { + return getDisplay(value, unit, 2, true); + } + + public static String getDisplayShort(double value, ElectricUnit unit, int decimalPlaces) + { + return getDisplay(value, unit, decimalPlaces, true); + } + + public static String getDisplaySimple(double 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; + } + + public static String getDisplay(double T, TemperatureUnit unit, int decimalPlaces, boolean isShort) + { + String unitName = unit.name; + String prefix = ""; + + double value = unit.convertFromK(T); + + if(value < 0) + { + value = Math.abs(value); + prefix = "-"; + } + + if(isShort) + { + unitName = unit.symbol; + } + + if(value == 0) + { + return value + (isShort ? "" : " ") + unitName; + } + else { + for(int i = 0; i < MeasurementUnit.values().length; i++) + { + MeasurementUnit lowerMeasure = MeasurementUnit.values()[i]; + + if(lowerMeasure.below(value) && lowerMeasure.ordinal() == 0) + { + return prefix + roundDecimals(lowerMeasure.process(value), decimalPlaces) + (isShort ? "" : " ") + lowerMeasure.getName(isShort) + unitName; + } + + if(lowerMeasure.ordinal() + 1 >= MeasurementUnit.values().length) + { + return prefix + roundDecimals(lowerMeasure.process(value), decimalPlaces) + (isShort ? "" : " ") + lowerMeasure.getName(isShort) + unitName; + } + + MeasurementUnit upperMeasure = MeasurementUnit.values()[i + 1]; + + if((lowerMeasure.above(value) && upperMeasure.below(value)) || lowerMeasure.value == value) + { + return prefix + roundDecimals(lowerMeasure.process(value), decimalPlaces) + (isShort ? "" : " ") + lowerMeasure.getName(isShort) + unitName; + } + } + } + + return prefix + roundDecimals(value, decimalPlaces) + (isShort ? "" : " ") + unitName; + } + + public static String getDisplayShort(double value, TemperatureUnit unit) + { + return getDisplay(value, unit, 2, true); + } + + public static String getDisplayShort(double value, TemperatureUnit unit, int decimalPlaces) + { + return getDisplay(value, unit, decimalPlaces, true); + } + + 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); + } + + public static enum EnergyType + { + J, + RF, + EU, + MJ + } + + public static enum TempType + { + K, + C, + R, + F, + STP + } +} diff --git a/src/api/java/mekanism/api/util/package-info.java b/src/api/java/mekanism/api/util/package-info.java new file mode 100644 index 0000000..e5253bc --- /dev/null +++ b/src/api/java/mekanism/api/util/package-info.java @@ -0,0 +1,3 @@ +@API(apiVersion = "8.0.0", owner = "Mekanism", provides = "MekanismAPI|util") +package mekanism.api.util; +import cpw.mods.fml.common.API;
\ No newline at end of file |