Cleanup
removed IC2, computer Craft and railcraft api. Wasn't using them anyways so no point keeping them especial when i can't have IC2 uploaded like that anyways
This commit is contained in:
Rseifert
parent
97113441eb
commit
d96e10e63e
|
|
@ -101,19 +101,6 @@ public class ItemGuage extends Item
|
|||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
public String getType(int type)
|
||||
{
|
||||
switch(type)
|
||||
{
|
||||
case 0: return "Steam";
|
||||
case 1: return "Water";
|
||||
case 2: return "Lava";
|
||||
case 3: return "Oil";
|
||||
case 4: return "Fuel";
|
||||
case 5: return "Air";
|
||||
default: return "???";
|
||||
}
|
||||
}
|
||||
public String getItemNameIS(ItemStack par1ItemStack)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ public class TileEntityPump extends TileEntityElectricityReceiver implements ILi
|
|||
{
|
||||
this.type = bellow;
|
||||
}
|
||||
|
||||
//eStored+=200;
|
||||
if(!worldObj.isRemote)
|
||||
{
|
||||
if(bBlock == type.Still && this.eStored >= 200 && this.lStored < this.wMax)
|
||||
|
|
|
|||
|
|
@ -1,131 +0,0 @@
|
|||
|
||||
package dan200.computer.api;
|
||||
|
||||
/**
|
||||
* The interface passed to peripherals by computers or turtles, providing methods
|
||||
* that they can call. This should not be implemented by your classes. Do not interact
|
||||
* with computers except via this interface.
|
||||
*/
|
||||
public interface IComputerAccess
|
||||
{
|
||||
/**
|
||||
* Creates a new numbered directory in a subPath of the users game save, and return that number. To be used with mountSaveDir.<br>
|
||||
* For example: n = createNewSaveDir( "computer/cdrom" ), will create a new
|
||||
* numbered folder in the "computer/cdrom" subdirectory of the users save file, and return that number.
|
||||
* mountSaveDir( "computer/rom", n ) could then be used to mount that folder onto the computers directory
|
||||
* structure, and the value n could be saved out and used again in future to give the peripheral
|
||||
* persistant storage.
|
||||
* @param subPath A relative file path from the users world save, where the directory should be located.
|
||||
* @return The numeric represenation of the name of the folder created. Will be positive.
|
||||
* @see #mountSaveDir(String, String, int, boolean, long)
|
||||
*/
|
||||
public int createNewSaveDir( String subPath );
|
||||
|
||||
/**
|
||||
* Equivalent to mountSaveDir( String desiredLocation, String subPath, int id, boolean readOnly, long spaceLimit ) with no space limit.
|
||||
* Mounts created with this method will have unlimited capacity.
|
||||
* @see #mountSaveDir(String, String, int, boolean, long)
|
||||
*/
|
||||
public String mountSaveDir( String desiredLocation, String subPath, int id, boolean readOnly );
|
||||
|
||||
/**
|
||||
* Mounts a directory into the computers file system, from a real directory a subPath of the users game save,
|
||||
* with a numerical name. To be used with createNewSaveDir.<br>
|
||||
* For example: n = createNewSaveDir( "computer/cdrom" ), will create a new
|
||||
* numbered folder in the "computer/cdrom" subdirectory of the users save file, and return that number.
|
||||
* mountSaveDir( "computer/rom", n ) could then be used to mount that folder onto the computers directory
|
||||
* structure, and the value n can be saved out by the peripheral and used again, to give the peripheral
|
||||
* persistant storage.<br>
|
||||
* When a directory is mounted, it will appear in the computers file system, and the user will be
|
||||
* able to use file operation to read from and write to the directory (unless readOnly, then only writes will be allowed).
|
||||
* @param desiredLocation The desired location in the computers file system where you would like the directory to appear.
|
||||
* If this location already exists, a number will be appended until a free name is found, and the
|
||||
* actual location will be returned. eg: "cdrom" can become "cdrom2" if two peripherals attempt to
|
||||
* mount "cdrom", or a "cdrom" folder already exists.
|
||||
* @param subPath The real relative file path from the users world save, where the directory to mount can be located.
|
||||
* @param id The numerical name of the folder to mount from the subPath: ex: mountSaveDir( "cdrom", "computer/cdrom", 7 )
|
||||
* will mount the directory "computer/cdrom/7". Use createNewSaveDir to obtain a unique directory id.
|
||||
* @param readOnly Whether the computer will be disallowed from making changes to the mounted directory and modifing or creating files therin.
|
||||
* @param spaceLimit The size limit of the mount, in bytes.
|
||||
* @return The location in the computers file system where the directory was mounted. This may differ from "desiredLocation", so the
|
||||
* return value should be kept track of so the folder can be unmounted later.
|
||||
* @see #createNewSaveDir(String)
|
||||
* @see #mountFixedDir(String, String, boolean, long)
|
||||
* @see #unmount(String)
|
||||
*/
|
||||
public String mountSaveDir( String desiredLocation, String subPath, int id, boolean readOnly, long spaceLimit );
|
||||
|
||||
/**
|
||||
* Equivalent to mountFixedDir( String desiredLocation, String path, boolean readOnly, long spaceLimit ) with no space limit.
|
||||
* Mounts created with this method will have unlimited capacity.
|
||||
* @see #mountFixedDir(String, String, boolean, long)
|
||||
*/
|
||||
public String mountFixedDir( String desiredLocation, String path, boolean readOnly );
|
||||
|
||||
/**
|
||||
* Mounts a directory into the computers file system, from a real directory in the Minecraft install folder.<br>
|
||||
* For example: mountFixedDir( "stuff", "mods/mymod/lua/stuff", true ), will mount the "lua/stuff" folder from
|
||||
* your mod's directory into the computers filesystem at the location "stuff", with readonly permission, giving the
|
||||
* computer access to those files.<br>
|
||||
* When a directory is mounted, it will appear in the computers file system, and the user will be
|
||||
* able to use file operation to read from and write to the directory (unless readOnly, then only writes will be allowed).<br>
|
||||
* mountFixedDir can also be used to mount files, for example: mountFixedDir( "rom/apis/myapi", "mods/mymod/lua/myapi.lua", true ) can
|
||||
* be used to have the peripheral install an API onto the computer it attaches to.
|
||||
* @param desiredLocation The desired location in the computers file system where you would like the directory to appear.
|
||||
* If this location already exists, a number will be appended until a free name is found, and the
|
||||
* actual location will be returned. eg: "cdrom" can become "cdrom2" if two peripherals attempt to
|
||||
* mount "cdrom", or a "cdrom" folder already exists.
|
||||
* @param subPath The real relative file path from the minecraft install root, where the directory to mount can be located.
|
||||
* @param readOnly Whether the computer will be disallowed from making changes to the mounted directory and modifing or creating files therin.
|
||||
* @param spaceLimit The size limit of the mount, in bytes.
|
||||
* @return The location in the computers file system where the directory was mounted. This may differ from "desiredLocation", so the
|
||||
* return value should be kept track of so the folder can be unmounted later.
|
||||
* @see #mountSaveDir(String, String, int, boolean, long)
|
||||
* @see #unmount(String)
|
||||
*/
|
||||
public String mountFixedDir( String desiredLocation, String path, boolean readOnly, long spaceLimit );
|
||||
|
||||
/**
|
||||
* Unmounts a directory previously mounted onto the computers file system by mountSaveDir or mountFixedDir.<br>
|
||||
* When a directory is unmounted, it will disappear from the computers file system, and the user will no longer be able to
|
||||
* access it. All directories mounted by a mountFixedDir or mountSaveDir are automatically unmounted when the peripheral
|
||||
* is attached if they have not been explicitly unmounted.
|
||||
* @param location The desired location in the computers file system of the directory to unmount.
|
||||
* This must be the location of a directory previously mounted by mountFixedDir() or mountSaveDir(), as
|
||||
* indicated by their return value.
|
||||
* @see #mountSaveDir(String, String, int, boolean, long)
|
||||
* @see #mountFixedDir(String, String, boolean, long)
|
||||
*/
|
||||
public void unmount( String location );
|
||||
|
||||
/**
|
||||
* Returns the numerical ID of this computer.<br>
|
||||
* This is the same number obtained by calling os.getComputerID() or running the "id" program from lua,
|
||||
* and is guarunteed unique. This number will be positive.
|
||||
* @return The identifier.
|
||||
*/
|
||||
public int getID();
|
||||
|
||||
/**
|
||||
* Equivalent to queueEvent( String event, Object[] arguments ) with an empty arguments array.
|
||||
* @see #queueEvent(String, Object[])
|
||||
*/
|
||||
public void queueEvent( String event );
|
||||
|
||||
/**
|
||||
* Causes an event to be raised on this computer, which the computer can respond to by calling
|
||||
* os.pullEvent(). This can be used to notify the computer when things happen in the world or to
|
||||
* this peripheral.
|
||||
* @param event A string identifying the type of event that has occurred, this will be
|
||||
* returned as the first value from os.pullEvent(). It is recommended that you
|
||||
* you choose a name that is unique, and recognisable as originating from your
|
||||
* peripheral. eg: If your peripheral type is "button", a suitable event would be
|
||||
* "button_pressed".
|
||||
* @param arguments In addition to a name, you may pass an array of extra arguments to the event, that will
|
||||
* be supplied as extra return values to os.pullEvent(). Objects in the array will be converted
|
||||
* to lua data types in the same fashion as the return values of IPeripheral.callMethod().<br>
|
||||
* You may supply null to indicate that no arguments are to be supplied.
|
||||
* @see IPeripheral#callMethod
|
||||
*/
|
||||
public void queueEvent( String event, Object[] arguments );
|
||||
}
|
||||
|
|
@ -1,103 +0,0 @@
|
|||
|
||||
package dan200.computer.api;
|
||||
|
||||
/**
|
||||
* The interface that defines a peripheral. This should be implemented by the
|
||||
* TileEntity of any block that you wish to be interacted with by
|
||||
* computer or turtle.
|
||||
*/
|
||||
public interface IPeripheral
|
||||
{
|
||||
/**
|
||||
* Should return a string that uniquely identifies this type of peripheral.
|
||||
* This can be queried from lua by calling peripheral.getType()
|
||||
* @return A string identifying the type of peripheral.
|
||||
*/
|
||||
public String getType();
|
||||
|
||||
/**
|
||||
* Should return an array of strings that identify the methods that this
|
||||
* peripheral exposes to Lua. This will be called once before each attachment,
|
||||
* and should not change when called multiple times.
|
||||
* @return An array of strings representing method names.
|
||||
* @see #callMethod
|
||||
*/
|
||||
public String[] getMethodNames();
|
||||
|
||||
/**
|
||||
* This is called when a lua program on an attached computer calls peripheral.call() with
|
||||
* one of the methods exposed by getMethodNames().<br>
|
||||
* <br>
|
||||
* Be aware that this will be called from the ComputerCraft Lua thread, and must be thread-safe
|
||||
* when interacting with minecraft objects.
|
||||
* @param computer The interface to the computer that is making the call. Remember that multiple
|
||||
* computers can be attached to a peripheral at once.
|
||||
* @param method An integer identifying which of the methods from getMethodNames() the computer
|
||||
* wishes to call. The integer indicates the index into the getMethodNames() table
|
||||
* that corresponds to the string passed into peripheral.call()
|
||||
* @param arguments An array of objects, representing the arguments passed into peripheral.call().<br>
|
||||
* Lua values of type "string" will be represented by Object type String.<br>
|
||||
* Lua values of type "number" will be represented by Object type Double.<br>
|
||||
* Lua values of type "boolean" will be represented by Object type Boolean.<br>
|
||||
* Lua values of any other type will be represented by a null object.<br>
|
||||
* This array will be empty if no arguments are passed.
|
||||
* @return An array of objects, representing values you wish to return to the lua program.<br>
|
||||
* Integers, Doubles, Floats, Strings, Booleans and null be converted to their corresponding lua type.<br>
|
||||
* All other types will be converted to nil.<br>
|
||||
* You may return null to indicate no values should be returned.
|
||||
* @throws Exception If you throw any exception from this function, a lua error will be raised with the
|
||||
* same message as your exception. Use this to throw appropriate errors if the wrong
|
||||
* arguments are supplied to your method.
|
||||
* @see #getMethodNames
|
||||
*/
|
||||
public Object[] callMethod( IComputerAccess computer, int method, Object[] arguments ) throws Exception;
|
||||
|
||||
/**
|
||||
* Is called before the computer attempts to attach to the peripheral, and should return whether to allow
|
||||
* the attachment. Use this to restrict the number of computers that can attach, or to limit attachments to
|
||||
* certain world directions.<br>
|
||||
* If true is returned, attach() will be called shortly afterwards, and the computer will be able to make method calls.
|
||||
* If false is returned, attach() will not be called, and the peripheral will be invisible to the computer.
|
||||
* @param side The world direction (0=bottom, 1=top, etc) that the computer lies relative to the peripheral.
|
||||
* @return Whether to allow the attachment, as a boolean.
|
||||
* @see #attach
|
||||
*/
|
||||
public boolean canAttachToSide( int side );
|
||||
|
||||
/**
|
||||
* Is called when canAttachToSide has returned true, and a computer is attaching to the peripheral.
|
||||
* This will occur when a peripheral is placed next to an active computer, when a computer is turned on next to a peripheral,
|
||||
* or when a turtle travels into a square next to a peripheral.
|
||||
* Between calls to attach() and detach(), the attached computer can make method calls on the peripheral using peripheral.call().
|
||||
* This method can be used to keep track of which computers are attached to the peripheral, or to take action when attachment
|
||||
* occurs.<br>
|
||||
* <br>
|
||||
* Be aware that this will be called from the ComputerCraft Lua thread, and must be thread-safe
|
||||
* when interacting with minecraft objects.
|
||||
* @param computer The interface to the computer that is being attached. Remember that multiple
|
||||
* computers can be attached to a peripheral at once.
|
||||
* @param computerSide A string indicating which "side" of the computer the peripheral is attaching,
|
||||
* relative to the computers orientation. This value will be one of "top", "bottom",
|
||||
* "left", "right", "front" or "back". This can be used to uniquely identify the
|
||||
* peripheral when raising events or returning values to the computer.
|
||||
* @see #canAttachToSide
|
||||
* @see #detach
|
||||
*/
|
||||
public void attach( IComputerAccess computer, String computerSide );
|
||||
|
||||
/**
|
||||
* Is called when a computer is detaching from the peripheral.
|
||||
* This will occur when a computer shuts down, when the peripheral is removed while attached to computers,
|
||||
* or when a turtle moves away from a square attached to a peripheral.
|
||||
* This method can be used to keep track of which computers are attached to the peripheral, or to take action when detachment
|
||||
* occurs.<br>
|
||||
* <br>
|
||||
* Be aware that this will be called from the ComputerCraft Lua thread, and must be thread-safe
|
||||
* when interacting with minecraft objects.
|
||||
* @param computer The interface to the computer that is being detached. Remember that multiple
|
||||
* computers can be attached to a peripheral at once.
|
||||
* @see #canAttachToSide
|
||||
* @see #detach
|
||||
*/
|
||||
public void detach( IComputerAccess computer );
|
||||
}
|
||||
|
|
@ -1,56 +0,0 @@
|
|||
package ic2.api;
|
||||
|
||||
/**
|
||||
* Base agriculture seed. Used to determine the state of a plant once it is planted from an item.
|
||||
*/
|
||||
public class BaseSeed {
|
||||
/**
|
||||
* Plant ID.
|
||||
*/
|
||||
public int id;
|
||||
|
||||
/**
|
||||
* Plant size.
|
||||
*/
|
||||
public int size;
|
||||
|
||||
/**
|
||||
* Plant growth stat.
|
||||
*/
|
||||
public int statGrowth;
|
||||
|
||||
/**
|
||||
* Plant gain stat.
|
||||
*/
|
||||
public int statGain;
|
||||
|
||||
/**
|
||||
* Plant resistance stat.
|
||||
*/
|
||||
public int statResistance;
|
||||
|
||||
/**
|
||||
* For internal usage only.
|
||||
*/
|
||||
public int stackSize;
|
||||
|
||||
/**
|
||||
* Create a BaseSeed object.
|
||||
*
|
||||
* @param id plant ID
|
||||
* @param size plant size
|
||||
* @param statGrowth plant growth stat
|
||||
* @param statGain plant gain stat
|
||||
* @param statResistance plant resistance stat
|
||||
* @param stackSize for internal usage only
|
||||
*/
|
||||
public BaseSeed(int id, int size, int statGrowth, int statGain, int statResistance, int stackSize) {
|
||||
super();
|
||||
this.id = id;
|
||||
this.size = size;
|
||||
this.statGrowth = statGrowth;
|
||||
this.statGain = statGain;
|
||||
this.statResistance = statResistance;
|
||||
this.stackSize = stackSize;
|
||||
}
|
||||
}
|
||||
|
|
@ -1,475 +0,0 @@
|
|||
package ic2.api;
|
||||
|
||||
import java.util.HashMap;
|
||||
|
||||
import net.minecraft.src.Entity;
|
||||
import net.minecraft.src.EntityLiving;
|
||||
import net.minecraft.src.EntityPlayer;
|
||||
import net.minecraft.src.ItemStack;
|
||||
|
||||
/**
|
||||
* Base agriculture crop.
|
||||
*
|
||||
* Any crop extending this can be registered using registerCrop to be added into the game.
|
||||
*/
|
||||
public abstract class CropCard
|
||||
{
|
||||
/**
|
||||
* Plant name. Will be displayed to the player.
|
||||
*
|
||||
* @return Plant name
|
||||
*/
|
||||
public abstract String name();
|
||||
|
||||
/**
|
||||
* Your name here, will be shown in "Discovered by:" when analyzing seeds.
|
||||
*
|
||||
* @return Your name
|
||||
*/
|
||||
public String discoveredBy() {return "Alblaka";}
|
||||
|
||||
/**
|
||||
* Description of your plant. Keep it short, a few characters per line for up to two lines.
|
||||
* Default is showing attributes of your plant, 2 per line.
|
||||
*
|
||||
* @param i line to get, starting from 0
|
||||
* @return The line
|
||||
*/
|
||||
public String desc(int i)
|
||||
{
|
||||
String[] att = attributes();
|
||||
if (att == null || att.length==0) return "";
|
||||
if (i == 0)
|
||||
{
|
||||
String s = att[0];
|
||||
if (att.length >= 2)
|
||||
{
|
||||
s+=", "+att[1];
|
||||
if (att.length >= 3) s+=",";
|
||||
}
|
||||
return s;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (att.length < 3) return "";
|
||||
String s = att[2];
|
||||
if (att.length >= 4) s+=", "+att[3];
|
||||
return s;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Tier of the plant. Ranges from 1 to 16, 0 is Weed.
|
||||
* Valuable and powerful crops have higher tiers, useless and weak ones have lower tiers.
|
||||
*
|
||||
* @return Tier
|
||||
*/
|
||||
public abstract int tier();
|
||||
|
||||
/**
|
||||
* Describe the plant through a set of stats, influencing breeding.
|
||||
* Plants sharing stats and attributes will tend to cross-breed more often.
|
||||
*
|
||||
* Stats:
|
||||
* - 0: Chemistry (Industrial uses based on chemical plant components)
|
||||
* - 1: Consumable (Food, potion ingredients, stuff meant to be eaten or similarly used)
|
||||
* - 2: Defensive (Plants with defense capabilities (damaging, explosive, chemical) or special abilities in general)
|
||||
* - 3: Colorful (How colorful/aesthetically/beautiful is the plant, like dye-plants or plants without actual effects)
|
||||
* - 4: Weed (Is this plant weed-like and rather unwanted/quick-spreading? Rare super-breed plants should have low values here)
|
||||
*
|
||||
* @param n index of the requested stat
|
||||
* @return The requested value of the stats
|
||||
*/
|
||||
public abstract int stat(int n);
|
||||
|
||||
/**
|
||||
* Additional attributes of the plant, also influencing breeding.
|
||||
* Plants sharing stats and attributes will tend to cross-breed more often.
|
||||
*
|
||||
* @return Attributes as an array of strings
|
||||
*/
|
||||
public abstract String[] attributes();
|
||||
|
||||
/**
|
||||
* Sprite index the crop is meant to be rendered with.
|
||||
*
|
||||
* @param crop reference to TECrop
|
||||
* @return 0-255, representing the sprite index on the crop's spritesheet.
|
||||
*/
|
||||
public abstract int getSpriteIndex(TECrop crop);
|
||||
|
||||
/**
|
||||
* Get the crop's spritesheet.
|
||||
* Per default crops_0.png of ic2-sprites
|
||||
* @return Texture file path
|
||||
*/
|
||||
public String getTextureFile() {
|
||||
return "/ic2/sprites/crops_0.png";
|
||||
}
|
||||
|
||||
/**
|
||||
* Amount of growth points needed to increase the plant's size.
|
||||
* Default is 200 * tier.
|
||||
*/
|
||||
public int growthDuration(TECrop crop)
|
||||
{
|
||||
return tier()*200;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check whether the plant can grow further.
|
||||
*
|
||||
* Consider:
|
||||
* - Humidity, nutrients and air quality
|
||||
* - Current size
|
||||
* - Light level
|
||||
* - Special biomes or conditions, accessible through crop.worldObj
|
||||
*
|
||||
* This method will be called upon empty upgraded crops to check whether a neighboring plant can cross onto it! Don't check if the size is greater than 0 and if the ID is real.
|
||||
*
|
||||
* @param crop reference to TECrop
|
||||
* @return Whether the crop can grow
|
||||
*/
|
||||
public abstract boolean canGrow(TECrop crop);
|
||||
|
||||
/**
|
||||
* Calculate the influence for the plant to grow based on humidity, nutrients and air.
|
||||
* Normal behavior is rating the three stats "normal", with each of them ranging from 0-30.
|
||||
* Basic rule: Assume everything returns 10. All together must equal 30. Add the factors to your likings, for example (humidity*0.7)+(nutrients*0.9)+(air*1.4)
|
||||
*
|
||||
* Default is humidity + nutrients + air (no factors).
|
||||
*
|
||||
* @param crop reference to TECrop
|
||||
* @param humidity ground humidity, influenced by hydration
|
||||
* @param nutrients nutrient quality in ground, based on fertilizers
|
||||
* @param air air quality, influences by open gardens and less crops surrounding this one
|
||||
* @return 0-30
|
||||
*/
|
||||
public int weightInfluences(TECrop crop, float humidity, float nutrients, float air)
|
||||
{
|
||||
return (int) (humidity+nutrients+air);
|
||||
}
|
||||
|
||||
/**
|
||||
* Used to determine whether the plant can crossbreed with another crop.
|
||||
* Default is allow crossbreeding if the size is greater or equal than 3.
|
||||
*
|
||||
* @param crop crop to crossbreed with
|
||||
*/
|
||||
public boolean canCross(TECrop crop)
|
||||
{
|
||||
return crop.size >= 3;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Called when the plant is rightclicked by a player.
|
||||
* Default action is harvesting.
|
||||
*
|
||||
* @param crop reference to TECrop
|
||||
* @param player player rightclicking the crop
|
||||
* @return Whether the plant has changed
|
||||
*/
|
||||
public boolean rightclick(TECrop crop, EntityPlayer player)
|
||||
{
|
||||
return crop.harvest(true);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check whether the crop can be harvested.
|
||||
*
|
||||
* @param crop reference to TECrop
|
||||
* @return Whether the crop can be harvested in its current state.
|
||||
*/
|
||||
public abstract boolean canBeHarvested(TECrop crop);
|
||||
|
||||
/**
|
||||
* Base chance for dropping the plant's gains, specify values greater than 1 for multiple drops.
|
||||
* Default is 0.95^tier.
|
||||
*
|
||||
* @return Chance to drop the gains
|
||||
*/
|
||||
public float dropGainChance()
|
||||
{
|
||||
float base = 1F;
|
||||
for (int i = 0; i < tier(); i++) {base*=0.95;}
|
||||
return base;
|
||||
}
|
||||
|
||||
/**
|
||||
* Item obtained from harvesting the plant.
|
||||
*
|
||||
* @param crop reference to TECrop
|
||||
* @return Item obtained
|
||||
*/
|
||||
public abstract ItemStack getGain(TECrop crop);
|
||||
|
||||
/**
|
||||
* Get the size of the plant after harvesting.
|
||||
* Default is 1.
|
||||
*
|
||||
* @param crop reference to TECrop
|
||||
* @return Plant size after harvesting
|
||||
*/
|
||||
public byte getSizeAfterHarvest(TECrop crop) {return 1;}
|
||||
|
||||
|
||||
/**
|
||||
* Called when the plant is leftclicked by a player.
|
||||
* Default action is picking the plant.
|
||||
*
|
||||
* @param crop reference to TECrop
|
||||
* @param player player leftclicked the crop
|
||||
* @return Whether the plant has changed
|
||||
*/
|
||||
public boolean leftclick(TECrop crop, EntityPlayer player)
|
||||
{
|
||||
return crop.pick(true);
|
||||
}
|
||||
|
||||
/**
|
||||
* Base chance for dropping seeds when the plant is picked.
|
||||
* Default is 0.5*0.8^tier with a bigger chance for sizes greater than 2 and absolutely no chance for size 0.
|
||||
*
|
||||
* @param crop reference to TECrop
|
||||
* @return Chance to drop the seeds
|
||||
*/
|
||||
public float dropSeedChance(TECrop crop)
|
||||
{
|
||||
if (crop.size == 1) return 0;
|
||||
float base = 0.5F;
|
||||
if (crop.size == 2) base/=2F;
|
||||
for (int i = 0; i < tier(); i++) {base*=0.8;}
|
||||
return base;
|
||||
}
|
||||
|
||||
/**
|
||||
* Obtain seeds dropped when the plant is picked.
|
||||
* Multiple drops of the returned ItemStack can occur.
|
||||
* Default action is generating a seed from this crop.
|
||||
*
|
||||
* @param crop reference to TECrop
|
||||
* @return Seeds
|
||||
*/
|
||||
public ItemStack getSeeds(TECrop crop)
|
||||
{
|
||||
return crop.generateSeeds(crop.id, crop.statGrowth, crop.statGain, crop.statResistance, crop.scanLevel);
|
||||
}
|
||||
|
||||
/**
|
||||
* Called when a neighbor block to the crop has changed.
|
||||
*
|
||||
* @param crop reference to TECrop
|
||||
*/
|
||||
public void onNeighbourChange(TECrop crop){}
|
||||
|
||||
/**
|
||||
* Check if the crop should emit redstone.
|
||||
*
|
||||
* @return Whether the crop should emit redstone
|
||||
*/
|
||||
public boolean emitRedstone(TECrop crop){return false;}
|
||||
|
||||
/**
|
||||
* Called when the crop is destroyed.
|
||||
*
|
||||
* @param crop reference to TECrop
|
||||
*/
|
||||
public void onBlockDestroyed(TECrop crop){}
|
||||
|
||||
/**
|
||||
* Get the light value emitted by the plant.
|
||||
*
|
||||
* @param crop reference to TECrop
|
||||
* @return Light value emitted
|
||||
*/
|
||||
public int getEmittedLight(TECrop crop) {return 0;}
|
||||
|
||||
/**
|
||||
* Default is true if the entity is an EntityLiving in jumping or sprinting state.
|
||||
*
|
||||
* @param crop reference to TECrop
|
||||
* @param entity entity colliding
|
||||
* @return Whether trampling calculation should happen, return false if the plant is no longer valid.
|
||||
*/
|
||||
public boolean onEntityCollision(TECrop crop, Entity entity)
|
||||
{
|
||||
if (entity instanceof EntityLiving)
|
||||
{
|
||||
return ((EntityLiving)entity).isSprinting();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Called every time the crop ticks.
|
||||
* Should be called every 256 ticks or around 13 seconds.
|
||||
*
|
||||
* @param crop reference to TECrop
|
||||
*/
|
||||
public void tick(TECrop crop) {}
|
||||
|
||||
/**
|
||||
* Check whether this plant spreads weed to surrounding tiles.
|
||||
* Default is true if the plant has a high growth stat (or is weeds) and size greater or equal than 2.
|
||||
*
|
||||
* @param crop reference to TECrop
|
||||
* @return Whether the plant spreads weed
|
||||
*/
|
||||
public boolean isWeed(TECrop crop)
|
||||
{
|
||||
return crop.size>=2 && (crop.id==0 || crop.statGrowth>=24);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Get this plant's ID.
|
||||
*
|
||||
* @return ID of this CropCard or -1 if it's not registered
|
||||
*/
|
||||
public final int getId()
|
||||
{
|
||||
for (int i = 0; i < cropCardList.length; i++)
|
||||
{
|
||||
if (this == cropCardList[i])
|
||||
{
|
||||
return i;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
private static final CropCard[] cropCardList = new CropCard[256];
|
||||
|
||||
/**
|
||||
* Get the size of the plant list.
|
||||
*
|
||||
* @return Plant list size
|
||||
*/
|
||||
public static int cropCardListLength() {return cropCardList.length;}
|
||||
|
||||
/**
|
||||
* Return the CropCard assigned to the given ID.
|
||||
* If the ID is out of bounds, weed should be returned. If the ID is not registered, weed should be returned and a console print will notify.
|
||||
*
|
||||
* @param id plant ID
|
||||
* @return Plant class
|
||||
*/
|
||||
public static final CropCard getCrop(int id)
|
||||
{
|
||||
if (id < 0 || id >= cropCardList.length)
|
||||
{// Out of bounds
|
||||
return cropCardList[0];
|
||||
}
|
||||
if (cropCardList[id]==null)
|
||||
{// Out of bounds
|
||||
System.out.println("[IndustrialCraft] Something tried to access non-existant cropID #"+id+"!!!");
|
||||
return cropCardList[0];
|
||||
}
|
||||
|
||||
return cropCardList[id];
|
||||
}
|
||||
|
||||
/**
|
||||
* Check whether the specified plant ID is already assigned.
|
||||
* @param id ID to be checked
|
||||
* @return true if the the given id is inbounds and the registered slot is not null
|
||||
*/
|
||||
public static final boolean idExists(int id)
|
||||
{
|
||||
return !(id < 0 || id >= cropCardList.length || cropCardList[id]==null);
|
||||
}
|
||||
|
||||
/**
|
||||
* Auto-assign an ID to a plant and register it.
|
||||
* Usage of this method is not recommended! Other plants could take your IDs and cause your plants to turn into other plants.
|
||||
*
|
||||
* @param crop plant to register
|
||||
* @return The ID assigned to the plant
|
||||
*/
|
||||
public static final short registerCrop(CropCard crop)
|
||||
{
|
||||
for (short x = 0; x < cropCardList.length; x++)
|
||||
{// Iterate through list
|
||||
if (cropCardList[x]==null)
|
||||
{// Found empty slot, add crop here
|
||||
cropCardList[x]=crop;
|
||||
nameReference.addLocal("item.cropSeed"+x+".name", crop.name()+" Seeds");
|
||||
return x;
|
||||
}
|
||||
}
|
||||
//No free slot avaible
|
||||
return -1;
|
||||
}
|
||||
|
||||
/**
|
||||
* Attempt to register a plant to an ID.
|
||||
* If the ID is taken, the crop will not be registered and a console print will notify the user.
|
||||
*
|
||||
* @param crop plant to register
|
||||
* @param i ID to register the plant to
|
||||
* @return Whether the crop was registered
|
||||
*/
|
||||
public static final boolean registerCrop(CropCard crop, int i)
|
||||
{
|
||||
if (i < 0 || i >= cropCardList.length)
|
||||
{// Out of bounds
|
||||
return false;
|
||||
}
|
||||
if (cropCardList[i]==null)
|
||||
{
|
||||
cropCardList[i]=crop;
|
||||
nameReference.addLocal("item.cropSeed"+i+".name", crop.name()+" Seeds");
|
||||
return true;
|
||||
}
|
||||
System.out.println("[IndustrialCraft] Cannot add crop:"+crop.name()+" on ID #"+i+", slot already occupied by crop:"+cropCardList[i].name());
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* For internal usage only.
|
||||
*/
|
||||
public static TECrop nameReference;
|
||||
|
||||
private static HashMap<ItemStack, BaseSeed> baseseeds = new HashMap<ItemStack, BaseSeed>();
|
||||
|
||||
/**
|
||||
* Registers a base seed, an item used to plant a crop.
|
||||
*
|
||||
* @param stack item
|
||||
* @param id plant ID
|
||||
* @param size initial size
|
||||
* @param growth initial growth stat
|
||||
* @param gain initial gain stat
|
||||
* @param resistance initial resistance stat
|
||||
* @return True if successful
|
||||
*/
|
||||
public static boolean registerBaseSeed(ItemStack stack, int id, int size, int growth, int gain, int resistance)
|
||||
{
|
||||
for (ItemStack key : baseseeds.keySet())
|
||||
if (key.itemID==stack.itemID && key.getItemDamage()==stack.getItemDamage()) return false;
|
||||
|
||||
baseseeds.put(stack, new BaseSeed(id, size, growth, gain, resistance, stack.stackSize));
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Finds a base seed from the given item.
|
||||
*
|
||||
* @return Base seed or null if none found
|
||||
*/
|
||||
public static BaseSeed getBaseSeed(ItemStack stack)
|
||||
{
|
||||
if (stack == null) return null;
|
||||
for (ItemStack key : baseseeds.keySet())
|
||||
{
|
||||
if (key.itemID == stack.itemID &&
|
||||
(key.getItemDamage() == -1 || key.getItemDamage() == stack.getItemDamage()))
|
||||
{
|
||||
return baseseeds.get(key);
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
|
@ -1,47 +0,0 @@
|
|||
package ic2.api;
|
||||
|
||||
import java.util.HashMap;
|
||||
|
||||
import net.minecraft.src.BiomeGenBase;
|
||||
|
||||
/**
|
||||
* General management of the crop system. All crop management methods will be moved here in the 2.00 update.
|
||||
*/
|
||||
public class Crops {
|
||||
private static final HashMap<BiomeGenBase,Integer> humidityBiomeBonus = new HashMap<BiomeGenBase,Integer>();
|
||||
private static final HashMap<BiomeGenBase,Integer> nutrientBiomeBonus = new HashMap<BiomeGenBase,Integer>();
|
||||
|
||||
/**
|
||||
* Add a crop humidity and nutrient biome bonus.
|
||||
*
|
||||
* 0 indicates no bonus and negative values indicate a penalty.
|
||||
*
|
||||
* @param biome Biome to apply the bonus in
|
||||
* @param humidityBonus Humidity stat bonus
|
||||
* @param nutrientsBonus Nutrient stat bonus
|
||||
*/
|
||||
public static void addBiomeBonus(BiomeGenBase biome, int humidityBonus, int nutrientsBonus) {
|
||||
humidityBiomeBonus.put(biome, humidityBonus);
|
||||
nutrientBiomeBonus.put(biome, nutrientsBonus);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the humidity bonus for a biome.
|
||||
*
|
||||
* @param biome biome to check
|
||||
* @return Humidity bonus or 0 if none
|
||||
*/
|
||||
public static int getHumidityBiomeBonus(BiomeGenBase biome) {
|
||||
return humidityBiomeBonus.containsKey(biome) ? humidityBiomeBonus.get(biome) : 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the nutrient bonus for a biome.
|
||||
*
|
||||
* @param biome biome to check
|
||||
* @return Nutrient bonus or 0 if none
|
||||
*/
|
||||
public static int getNutrientBiomeBonus(BiomeGenBase biome) {
|
||||
return nutrientBiomeBonus.containsKey(biome) ? nutrientBiomeBonus.get(biome) : 0;
|
||||
}
|
||||
}
|
||||
|
|
@ -1,106 +0,0 @@
|
|||
package ic2.api;
|
||||
|
||||
import net.minecraft.src.TileEntity;
|
||||
import net.minecraftforge.common.ForgeDirection;
|
||||
|
||||
/**
|
||||
* Represents the 6 possible directions along the axis of a block.
|
||||
*/
|
||||
public enum Direction {
|
||||
/**
|
||||
* -X
|
||||
*/
|
||||
XN(0),
|
||||
/**
|
||||
* +X
|
||||
*/
|
||||
XP(1),
|
||||
|
||||
/**
|
||||
* -Y
|
||||
*/
|
||||
YN(2), //MC-Code starts with 0 here
|
||||
/**
|
||||
* +Y
|
||||
*/
|
||||
YP(3), // 1...
|
||||
|
||||
/**
|
||||
* -Z
|
||||
*/
|
||||
ZN(4),
|
||||
/**
|
||||
* +Z
|
||||
*/
|
||||
ZP(5);
|
||||
|
||||
Direction(int dir) {
|
||||
this.dir = dir;
|
||||
}
|
||||
|
||||
/*public CoordinateTuple ApplyToCoordinates(CoordinateTuple coordinates) {
|
||||
CoordinateTuple ret = new CoordinateTuple(coordinates);
|
||||
|
||||
ret.coords[dir/2] += GetSign();
|
||||
|
||||
return ret;
|
||||
}*/
|
||||
|
||||
/**
|
||||
* Get the tile entity next to a tile entity following this direction.
|
||||
*
|
||||
* @param tileEntity tile entity to check
|
||||
* @return Adjacent tile entity or null if none exists
|
||||
*/
|
||||
public TileEntity applyToTileEntity(TileEntity tileEntity) {
|
||||
int coords[] = { tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord };
|
||||
|
||||
coords[dir/2] += getSign();
|
||||
|
||||
if (tileEntity.worldObj != null && tileEntity.worldObj.blockExists(coords[0], coords[1], coords[2])) {
|
||||
return tileEntity.worldObj.getBlockTileEntity(coords[0], coords[1], coords[2]);
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the inverse of this direction (XN -> XP, XP -> XN, etc.)
|
||||
*
|
||||
* @return Inverse direction
|
||||
*/
|
||||
public Direction getInverse() {
|
||||
int inverseDir = dir - getSign();
|
||||
|
||||
for (Direction direction: Direction.values()) {
|
||||
if (direction.dir == inverseDir) return direction;
|
||||
}
|
||||
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert this direction to a Minecraft side value.
|
||||
*
|
||||
* @return Minecraft side value
|
||||
*/
|
||||
public int toSideValue() {
|
||||
return (dir + 4) % 6;
|
||||
}
|
||||
|
||||
/**
|
||||
* Determine direction sign (N for negative or P for positive).
|
||||
*
|
||||
* @return -1 if the direction is negative, +1 if the direction is positive
|
||||
*/
|
||||
private int getSign() {
|
||||
return (dir % 2) * 2 - 1;
|
||||
}
|
||||
|
||||
public ForgeDirection toForgeDirection() {
|
||||
return ForgeDirection.getOrientation(toSideValue());
|
||||
}
|
||||
|
||||
private int dir;
|
||||
}
|
||||
|
||||
|
|
@ -1,128 +0,0 @@
|
|||
package ic2.api;
|
||||
|
||||
import java.lang.reflect.Method;
|
||||
|
||||
import net.minecraft.src.EntityPlayer;
|
||||
import net.minecraft.src.ItemStack;
|
||||
|
||||
/**
|
||||
* Allows for charging, discharging and using electric items (IElectricItem).
|
||||
*
|
||||
* The charge or remaining capacity of an item can be determined by calling charge/discharge with
|
||||
* ignoreTransferLimit and simulate set to true.
|
||||
*/
|
||||
public final class ElectricItem {
|
||||
/**
|
||||
* Charge an item with a specified amount of energy
|
||||
*
|
||||
* @param itemStack electric item's stack
|
||||
* @param amount amount of energy to charge in EU
|
||||
* @param tier tier of the charging device, has to be at least as high as the item to charge
|
||||
* @param ignoreTransferLimit ignore the transfer limit specified by getTransferLimit()
|
||||
* @param simulate don't actually change the item, just determine the return value
|
||||
* @return Energy transferred into the electric item
|
||||
*/
|
||||
public static int charge(ItemStack itemStack, int amount, int tier, boolean ignoreTransferLimit, boolean simulate) {
|
||||
try {
|
||||
if (ElectricItem_charge == null) ElectricItem_charge = Class.forName(getPackage() + ".common.ElectricItem").getMethod("charge", ItemStack.class, Integer.TYPE, Integer.TYPE, Boolean.TYPE, Boolean.TYPE);
|
||||
|
||||
return (Integer) ElectricItem_charge.invoke(null, itemStack, amount, tier, ignoreTransferLimit, simulate);
|
||||
} catch (Exception e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Discharge an item by a specified amount of energy
|
||||
*
|
||||
* @param itemStack electric item's stack
|
||||
* @param amount amount of energy to charge in EU
|
||||
* @param tier tier of the discharging device, has to be at least as high as the item to discharge
|
||||
* @param ignoreTransferLimit ignore the transfer limit specified by getTransferLimit()
|
||||
* @param simulate don't actually discharge the item, just determine the return value
|
||||
* @return Energy retrieved from the electric item
|
||||
*/
|
||||
public static int discharge(ItemStack itemStack, int amount, int tier, boolean ignoreTransferLimit, boolean simulate) {
|
||||
try {
|
||||
if (ElectricItem_discharge == null) ElectricItem_discharge = Class.forName(getPackage() + ".common.ElectricItem").getMethod("discharge", ItemStack.class, Integer.TYPE, Integer.TYPE, Boolean.TYPE, Boolean.TYPE);
|
||||
|
||||
return (Integer) ElectricItem_discharge.invoke(null, itemStack, amount, tier, ignoreTransferLimit, simulate);
|
||||
} catch (Exception e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Determine if the specified electric item has at least a specific amount of EU.
|
||||
* This is supposed to be used in the item code during operation, for example if you want to implement your own electric item.
|
||||
* BatPacks are not taken into account.
|
||||
*
|
||||
* @param itemStack electric item's stack
|
||||
* @param amount minimum amount of energy required
|
||||
* @return true if there's enough energy
|
||||
*/
|
||||
public static boolean canUse(ItemStack itemStack, int amount) {
|
||||
try {
|
||||
if (ElectricItem_canUse == null) ElectricItem_canUse = Class.forName(getPackage() + ".common.ElectricItem").getMethod("canUse", ItemStack.class, Integer.TYPE);
|
||||
|
||||
return (Boolean) ElectricItem_canUse.invoke(null, itemStack, amount);
|
||||
} catch (Exception e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Try to retrieve a specific amount of energy from an Item, and if applicable, a BatPack.
|
||||
* This is supposed to be used in the item code during operation, for example if you want to implement your own electric item.
|
||||
*
|
||||
* @param itemStack electric item's stack
|
||||
* @param amount amount of energy to discharge in EU
|
||||
* @param player player holding the item
|
||||
* @return true if the operation succeeded
|
||||
*/
|
||||
public static boolean use(ItemStack itemStack, int amount, EntityPlayer player) {
|
||||
try {
|
||||
if (ElectricItem_use == null) ElectricItem_use = Class.forName(getPackage() + ".common.ElectricItem").getMethod("use", ItemStack.class, Integer.TYPE, EntityPlayer.class);
|
||||
|
||||
return (Boolean) ElectricItem_use.invoke(null, itemStack, amount, player);
|
||||
} catch (Exception e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Charge an item from the BatPack a player is wearing.
|
||||
* This is supposed to be used in the item code during operation, for example if you want to implement your own electric item.
|
||||
* use() already contains this functionality.
|
||||
*
|
||||
* @param itemStack electric item's stack
|
||||
* @param player player holding the item
|
||||
*/
|
||||
public static void chargeFromArmor(ItemStack itemStack, EntityPlayer player) {
|
||||
try {
|
||||
if (ElectricItem_chargeFromArmor == null) ElectricItem_chargeFromArmor = Class.forName(getPackage() + ".common.ElectricItem").getMethod("chargeFromArmor", ItemStack.class, EntityPlayer.class);
|
||||
|
||||
ElectricItem_chargeFromArmor.invoke(null, itemStack, player);
|
||||
} catch (Exception e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the base IC2 package name, used internally.
|
||||
*
|
||||
* @return IC2 package name, if unable to be determined defaults to ic2
|
||||
*/
|
||||
private static String getPackage() {
|
||||
Package pkg = ElectricItem.class.getPackage();
|
||||
if (pkg != null) return pkg.getName().substring(0, pkg.getName().lastIndexOf('.'));
|
||||
else return "ic2";
|
||||
}
|
||||
|
||||
private static Method ElectricItem_charge;
|
||||
private static Method ElectricItem_discharge;
|
||||
private static Method ElectricItem_canUse;
|
||||
private static Method ElectricItem_use;
|
||||
private static Method ElectricItem_chargeFromArmor;
|
||||
}
|
||||
|
||||
|
|
@ -1,119 +0,0 @@
|
|||
package ic2.api;
|
||||
|
||||
import java.lang.reflect.Method;
|
||||
|
||||
import net.minecraft.src.TileEntity;
|
||||
import net.minecraft.src.World;
|
||||
|
||||
/**
|
||||
* Provides access to the energy network.
|
||||
*/
|
||||
public final class EnergyNet {
|
||||
/**
|
||||
* Gets the EnergyNet instance for the specified world.
|
||||
*
|
||||
* @param world world
|
||||
* @return EnergyNet instance for the world
|
||||
*/
|
||||
public static EnergyNet getForWorld(World world) {
|
||||
try {
|
||||
if (EnergyNet_getForWorld == null) EnergyNet_getForWorld = Class.forName(getPackage() + ".common.EnergyNet").getMethod("getForWorld", World.class);
|
||||
|
||||
return new EnergyNet(EnergyNet_getForWorld.invoke(null, world));
|
||||
} catch (Exception e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
|
||||
private EnergyNet(Object energyNetInstance) {
|
||||
this.energyNetInstance = energyNetInstance;
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a tile entity to the energy network.
|
||||
* The tile entity has to be valid and initialized.
|
||||
*
|
||||
* @param addedTileEntity tile entity to add
|
||||
*/
|
||||
public void addTileEntity(TileEntity addedTileEntity) {
|
||||
try {
|
||||
if (EnergyNet_addTileEntity == null) EnergyNet_addTileEntity = Class.forName(getPackage() + ".common.EnergyNet").getMethod("addTileEntity", TileEntity.class);
|
||||
|
||||
EnergyNet_addTileEntity.invoke(energyNetInstance, addedTileEntity);
|
||||
} catch (Exception e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Removes a tile entity from the energy network.
|
||||
* The tile entity has to be still valid.
|
||||
*
|
||||
* @param removedTileEntity tile entity to remove
|
||||
*/
|
||||
public void removeTileEntity(TileEntity removedTileEntity) {
|
||||
try {
|
||||
if (EnergyNet_removeTileEntity == null) EnergyNet_removeTileEntity = Class.forName(getPackage() + ".common.EnergyNet").getMethod("removeTileEntity", TileEntity.class);
|
||||
|
||||
EnergyNet_removeTileEntity.invoke(energyNetInstance, removedTileEntity);
|
||||
} catch (Exception e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Emit energy from an energy source to the energy network.
|
||||
*
|
||||
* @param energySource energy source to emit energy from
|
||||
* @param amount amount of energy to emit in EU
|
||||
* @return Leftover (unused) power
|
||||
*/
|
||||
public int emitEnergyFrom(IEnergySource energySource, int amount) {
|
||||
try {
|
||||
if (EnergyNet_emitEnergyFrom == null) EnergyNet_emitEnergyFrom = Class.forName(getPackage() + ".common.EnergyNet").getMethod("emitEnergyFrom", IEnergySource.class, Integer.TYPE);
|
||||
|
||||
return ((Integer) EnergyNet_emitEnergyFrom.invoke(energyNetInstance, energySource, amount)).intValue();
|
||||
} catch (Exception e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the amount of energy currently being conducted by a conductor.
|
||||
* Call this twice with a delay to get the average conducted power by doing (call2 - call1) / 2.
|
||||
*
|
||||
* @param tileEntity conductor
|
||||
*/
|
||||
public long getTotalEnergyConducted(TileEntity tileEntity) {
|
||||
try {
|
||||
if (EnergyNet_getTotalEnergyConducted == null) EnergyNet_getTotalEnergyConducted = Class.forName(getPackage() + ".common.EnergyNet").getMethod("getTotalEnergyConducted", TileEntity.class);
|
||||
|
||||
return ((Long) EnergyNet_getTotalEnergyConducted.invoke(energyNetInstance, tileEntity)).longValue();
|
||||
} catch (Exception e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the base IC2 package name, used internally.
|
||||
*
|
||||
* @return IC2 package name, if unable to be determined defaults to ic2
|
||||
*/
|
||||
private static String getPackage() {
|
||||
Package pkg = EnergyNet.class.getPackage();
|
||||
if (pkg != null) return pkg.getName().substring(0, pkg.getName().lastIndexOf('.'));
|
||||
else return "ic2";
|
||||
}
|
||||
|
||||
/**
|
||||
* Instance of the energy network.
|
||||
*/
|
||||
Object energyNetInstance;
|
||||
|
||||
private static Method EnergyNet_getForWorld;
|
||||
private static Method EnergyNet_addTileEntity;
|
||||
private static Method EnergyNet_removeTileEntity;
|
||||
private static Method EnergyNet_emitEnergyFrom;
|
||||
private static Method EnergyNet_getTotalEnergyConducted;
|
||||
}
|
||||
|
||||
|
|
@ -1,46 +0,0 @@
|
|||
package ic2.api;
|
||||
|
||||
import java.util.*;
|
||||
|
||||
import net.minecraft.src.Block;
|
||||
|
||||
/**
|
||||
* Blocks on this whitelist will not resist an explosion but won't be destroyed.
|
||||
*
|
||||
* The explosion code by default ignores blocks which absorb more than 1000 explosion power to
|
||||
* prevent abusing personal safes, Trade-O-Mats and other blocks to serve as a cheap and
|
||||
* invulnerable reactor chambers. Said blocks will not shield the explosion and won't get
|
||||
* destroyed.
|
||||
*/
|
||||
public final class ExplosionWhitelist {
|
||||
/**
|
||||
* Add a block to the whitelist.
|
||||
*
|
||||
* @param block block to add
|
||||
*/
|
||||
public static void addWhitelistedBlock(Block block) {
|
||||
whitelist.add(block);
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove a block from the whitelist.
|
||||
*
|
||||
* @param block block to remove
|
||||
*/
|
||||
public static void removeWhitelistedBlock(Block block) {
|
||||
whitelist.remove(block);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a block is on the whitelist.
|
||||
*
|
||||
* @param block block to check if whitelisted
|
||||
* @return Whether the block is whitelisted
|
||||
*/
|
||||
public static boolean isBlockWhitelisted(Block block) {
|
||||
return whitelist.contains(block);
|
||||
}
|
||||
|
||||
private static Set<Block> whitelist = new HashSet<Block>();
|
||||
}
|
||||
|
||||
|
|
@ -1,18 +0,0 @@
|
|||
package ic2.api;
|
||||
|
||||
import net.minecraft.src.ItemStack;
|
||||
|
||||
/**
|
||||
* Provides custom toolbox storage behavior for items.
|
||||
*
|
||||
* The normal condition for storing an item in a toolbox is having a maximum stack size of 1.
|
||||
*/
|
||||
public interface IBoxable {
|
||||
/**
|
||||
* Determine whether an item can be stored in a toolbox or not.
|
||||
*
|
||||
* @param itemstack item to be stored
|
||||
* @return Whether to store the item in the toolbox or not
|
||||
*/
|
||||
public abstract boolean canBeStoredInToolbox(ItemStack itemstack);
|
||||
}
|
||||
|
|
@ -1,52 +0,0 @@
|
|||
package ic2.api;
|
||||
|
||||
/**
|
||||
* Provides the ability to store energy on the implementing item.
|
||||
*
|
||||
* The item should have a maximum damage of 13.
|
||||
*/
|
||||
public interface IElectricItem {
|
||||
/**
|
||||
* Determine if the item can be used in a machine to supply energy.
|
||||
*
|
||||
* @return Whether the item can supply energy
|
||||
*/
|
||||
boolean canProvideEnergy();
|
||||
|
||||
/**
|
||||
* Get the item ID to use for a charge energy greater than 0.
|
||||
*
|
||||
* @return Item ID to use
|
||||
*/
|
||||
int getChargedItemId();
|
||||
|
||||
/**
|
||||
* Get the item ID to use for a charge energy of 0.
|
||||
*
|
||||
* @return Item ID to use
|
||||
*/
|
||||
int getEmptyItemId();
|
||||
|
||||
/**
|
||||
* Get the item's maximum charge energy in EU.
|
||||
*
|
||||
* @return Maximum charge energy
|
||||
*/
|
||||
int getMaxCharge();
|
||||
|
||||
/**
|
||||
* Get the item's tier, lower tiers can't send energy to higher ones.
|
||||
* Batteries are Tier 1, Energy Crystals are Tier 2, Lapotron Crystals are Tier 3.
|
||||
*
|
||||
* @return Item's tier
|
||||
*/
|
||||
int getTier();
|
||||
|
||||
/**
|
||||
* Get the item's transfer limit in EU per transfer operation.
|
||||
*
|
||||
* @return Transfer limit
|
||||
*/
|
||||
int getTransferLimit();
|
||||
}
|
||||
|
||||
|
|
@ -1,20 +0,0 @@
|
|||
package ic2.api;
|
||||
|
||||
import net.minecraft.src.TileEntity;
|
||||
|
||||
/**
|
||||
* For internal usage only.
|
||||
*
|
||||
* @see IEnergySink
|
||||
* @see IEnergyConductor
|
||||
*/
|
||||
public interface IEnergyAcceptor extends IEnergyTile {
|
||||
/**
|
||||
* Determine if this acceptor can accept current from an adjacent emitter in a direction.
|
||||
*
|
||||
* @param emitter energy emitter
|
||||
* @param direction direction the energy is being received from
|
||||
*/
|
||||
boolean acceptsEnergyFrom(TileEntity emitter, Direction direction);
|
||||
}
|
||||
|
||||
|
|
@ -1,51 +0,0 @@
|
|||
package ic2.api;
|
||||
|
||||
/**
|
||||
* Tile entities which conduct energy pulses without buffering (mostly cables) have to implement this
|
||||
* interface.
|
||||
*/
|
||||
public interface IEnergyConductor extends IEnergyAcceptor, IEnergyEmitter {
|
||||
/**
|
||||
* Energy loss for the conductor in EU per block.
|
||||
*
|
||||
* @return Energy loss
|
||||
*/
|
||||
double getConductionLoss();
|
||||
|
||||
/**
|
||||
* Amount of energy the insulation will handle before shocking nearby players and mobs.
|
||||
*
|
||||
* @return Insulation energy absorption in EU
|
||||
*/
|
||||
int getInsulationEnergyAbsorption();
|
||||
|
||||
/**
|
||||
* Amount of energy the insulation will handle before it is destroyed.
|
||||
* Ensure that this value is greater than the insulation energy absorption + 64.
|
||||
*
|
||||
* @return Insulation-destroying energy in EU
|
||||
*/
|
||||
int getInsulationBreakdownEnergy();
|
||||
|
||||
/**
|
||||
* Amount of energy the conductor will handle before it melts.
|
||||
*
|
||||
* @return Conductor-destroying energy in EU
|
||||
*/
|
||||
int getConductorBreakdownEnergy();
|
||||
|
||||
/**
|
||||
* Remove the conductor's insulation if the insulation breakdown energy was exceeded.
|
||||
*
|
||||
* @see #getInsulationBreakdownEnergy()
|
||||
*/
|
||||
void removeInsulation();
|
||||
|
||||
/**
|
||||
* Remove the conductor if the conductor breakdown energy was exceeded.
|
||||
*
|
||||
* @see #getConductorBreakdownEnergy()
|
||||
*/
|
||||
void removeConductor();
|
||||
}
|
||||
|
||||
|
|
@ -1,21 +0,0 @@
|
|||
package ic2.api;
|
||||
|
||||
import net.minecraft.src.TileEntity;
|
||||
|
||||
/**
|
||||
* For internal usage only.
|
||||
*
|
||||
* @see IEnergySource
|
||||
* @see IEnergyConductor
|
||||
*/
|
||||
public interface IEnergyEmitter extends IEnergyTile {
|
||||
/**
|
||||
* Determine if this emitter can emit energy to an adjacent receiver.
|
||||
*
|
||||
* @param receiver receiver
|
||||
* @param direction direction the receiver is from the emitter
|
||||
* @return Whether energy should be emitted
|
||||
*/
|
||||
boolean emitsEnergyTo(TileEntity receiver, Direction direction);
|
||||
}
|
||||
|
||||
|
|
@ -1,23 +0,0 @@
|
|||
package ic2.api;
|
||||
|
||||
/**
|
||||
* Allows a tile entity (mostly a machine) to receive energy.
|
||||
*/
|
||||
public interface IEnergySink extends IEnergyAcceptor {
|
||||
/**
|
||||
* Determine whether the sink requires energy.
|
||||
*
|
||||
* @return Whether the sink is requiring energy
|
||||
*/
|
||||
boolean demandsEnergy();
|
||||
|
||||
/**
|
||||
* Transfer energy to the sink.
|
||||
*
|
||||
* @param directionFrom direction from which the energy comes from
|
||||
* @param amount energy to be transferred
|
||||
* @return Energy not consumed (leftover)
|
||||
*/
|
||||
int injectEnergy(Direction directionFrom, int amount);
|
||||
}
|
||||
|
||||
|
|
@ -1,15 +0,0 @@
|
|||
package ic2.api;
|
||||
|
||||
/**
|
||||
* Allows a tile entity (mostly a generator) to emit energy.
|
||||
*/
|
||||
public interface IEnergySource extends IEnergyEmitter {
|
||||
/**
|
||||
* Maximum energy output provided by the source.
|
||||
* If unsure, use Integer.MAX_VALUE.
|
||||
*
|
||||
* @return Maximum energy output
|
||||
*/
|
||||
int getMaxEnergyOutput();
|
||||
}
|
||||
|
||||
|
|
@ -1,27 +0,0 @@
|
|||
package ic2.api;
|
||||
|
||||
/**
|
||||
* Interface implemented by the tile entity of energy storage blocks.
|
||||
*/
|
||||
public interface IEnergyStorage {
|
||||
/**
|
||||
* Get the amount of energy currently stored in the block.
|
||||
*
|
||||
* @return Energy stored in the block
|
||||
*/
|
||||
public int getStored();
|
||||
|
||||
/**
|
||||
* Get the maximum amount of energy the block can store.
|
||||
*
|
||||
* @return Maximum energy stored
|
||||
*/
|
||||
public int getCapacity();
|
||||
|
||||
/**
|
||||
* Get the block's energy output.
|
||||
*
|
||||
* @return Energy output in EU/t
|
||||
*/
|
||||
public int getOutput();
|
||||
}
|
||||
|
|
@ -1,18 +0,0 @@
|
|||
package ic2.api;
|
||||
|
||||
/**
|
||||
* For internal usage only.
|
||||
*
|
||||
* @see IEnergySink
|
||||
* @see IEnergySource
|
||||
* @see IEnergyConductor
|
||||
*/
|
||||
public interface IEnergyTile {
|
||||
/**
|
||||
* Determine if this tile entity has been added to the energy network
|
||||
*
|
||||
* @return Whether the tile entity has been added
|
||||
*/
|
||||
boolean isAddedToEnergyNet();
|
||||
}
|
||||
|
||||
|
|
@ -1,20 +0,0 @@
|
|||
package ic2.api;
|
||||
|
||||
import net.minecraft.src.EntityPlayer;
|
||||
import net.minecraft.src.ItemStack;
|
||||
|
||||
/**
|
||||
* Armor items implementing this can be considered metal armor.
|
||||
*
|
||||
* Currently used for determining which boots can be used to slide up a magnetic pole.
|
||||
*/
|
||||
public interface IMetalArmor {
|
||||
/**
|
||||
* Determine if the given armor piece is metal armor.
|
||||
*
|
||||
* @param itemstack Armor piece as worn by the player
|
||||
* @param player The player
|
||||
* @return Whether the armor piece is metal armor
|
||||
*/
|
||||
public boolean isMetalArmor(ItemStack itemstack, EntityPlayer player);
|
||||
}
|
||||
|
|
@ -1,17 +0,0 @@
|
|||
package ic2.api;
|
||||
|
||||
import net.minecraft.src.EntityPlayer;
|
||||
|
||||
/**
|
||||
* Allows a tile entity to receive network events received from clients.
|
||||
*/
|
||||
public interface INetworkClientTileEntityEventListener {
|
||||
/**
|
||||
* Called when a network event is received.
|
||||
*
|
||||
* @param player client which sent the event
|
||||
* @param event event ID
|
||||
*/
|
||||
void onNetworkEvent(EntityPlayer player, int event);
|
||||
}
|
||||
|
||||
|
|
@ -1,18 +0,0 @@
|
|||
package ic2.api;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Tile entities which want to synchronized specific fields between client and server have to implement this.
|
||||
*
|
||||
* The fields don't update themselves, a field update must be sent every time a synchronized field changes.
|
||||
*/
|
||||
public interface INetworkDataProvider {
|
||||
/**
|
||||
* Get the list of synchronized fields.
|
||||
*
|
||||
* @return Names of the synchronized fields
|
||||
*/
|
||||
List<String> getNetworkedFields();
|
||||
}
|
||||
|
||||
|
|
@ -1,18 +0,0 @@
|
|||
package ic2.api;
|
||||
|
||||
import net.minecraft.src.EntityPlayer;
|
||||
|
||||
/**
|
||||
* Allows an item to receive network events received from the server.
|
||||
*/
|
||||
public interface INetworkItemEventListener {
|
||||
/**
|
||||
* Called when a network event is received.
|
||||
*
|
||||
* @param metaData item metadata
|
||||
* @param player player containing the item
|
||||
* @param event event ID
|
||||
*/
|
||||
void onNetworkEvent(int metaData, EntityPlayer player, int event);
|
||||
}
|
||||
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
package ic2.api;
|
||||
|
||||
/**
|
||||
* Allows a tile entity to receive network events received from the server.
|
||||
*/
|
||||
public interface INetworkTileEntityEventListener {
|
||||
/**
|
||||
* Called when a network event is received.
|
||||
*
|
||||
* @param event Event ID
|
||||
*/
|
||||
void onNetworkEvent(int event);
|
||||
}
|
||||
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
package ic2.api;
|
||||
|
||||
/**
|
||||
* Allows a tile entity to receive field sync updates received from the server.
|
||||
*/
|
||||
public interface INetworkUpdateListener {
|
||||
/**
|
||||
* Called when a field is synchronized.
|
||||
*
|
||||
* @param field field synchronized
|
||||
*/
|
||||
void onNetworkUpdate(String field);
|
||||
}
|
||||
|
||||
|
|
@ -1,21 +0,0 @@
|
|||
package ic2.api;
|
||||
|
||||
import net.minecraft.src.World;
|
||||
|
||||
/**
|
||||
* Allows a block to be painted by a Painter.
|
||||
*/
|
||||
public interface IPaintableBlock
|
||||
{
|
||||
/**
|
||||
* Color the block.
|
||||
*
|
||||
* @param world block's world
|
||||
* @param x block X position
|
||||
* @param y block Y position
|
||||
* @param z block Z position
|
||||
* @param color painter color, same as dye metadata values
|
||||
* @return Whether the block was painted and the painter should be damaged
|
||||
*/
|
||||
public boolean colorBlock(World world, int x, int y, int z, int color);
|
||||
}
|
||||
|
|
@ -1,134 +0,0 @@
|
|||
package ic2.api;
|
||||
|
||||
import net.minecraft.src.ChunkCoordinates;
|
||||
import net.minecraft.src.ItemStack;
|
||||
import net.minecraft.src.World;
|
||||
|
||||
/**
|
||||
* Interface implemented by the tile entity of nuclear reactors.
|
||||
*/
|
||||
public interface IReactor {
|
||||
/**
|
||||
* Get the reactor's position in the world.
|
||||
*
|
||||
* @return Position of the reactor
|
||||
*/
|
||||
public ChunkCoordinates getPosition();
|
||||
|
||||
/**
|
||||
* Get the reactor's corresponding world.
|
||||
*
|
||||
* @return The reactor's world
|
||||
*/
|
||||
public World getWorld();
|
||||
|
||||
/**
|
||||
* Get the reactor's heat.
|
||||
*
|
||||
* @return The reactor's heat
|
||||
*/
|
||||
public int getHeat();
|
||||
|
||||
/**
|
||||
* Set the reactor's heat.
|
||||
*
|
||||
* @param heat reactor heat
|
||||
*/
|
||||
public void setHeat(int heat);
|
||||
|
||||
/**
|
||||
* Increase the reactor's heat.
|
||||
*
|
||||
* Use negative values to decrease.
|
||||
*
|
||||
* @param amount amount of heat to add
|
||||
* @return The reactor's heat after adding the specified amount
|
||||
*/
|
||||
public int addHeat(int amount);
|
||||
|
||||
/**
|
||||
* Get the reactor's maximum heat before exploding.
|
||||
*
|
||||
* @return Maximum heat value
|
||||
*/
|
||||
public int getMaxHeat();
|
||||
|
||||
/**
|
||||
* Set the reactor's stored maxHeat variable.
|
||||
* Used by plating to increase the reactors MaxHeat capacity.
|
||||
* Needs to be called during each cycle process.
|
||||
*/
|
||||
public void setMaxHeat(int newMaxHeat);
|
||||
|
||||
/**
|
||||
* Get's the reactor's HEM (Heat Effect Modifier)
|
||||
* Basic value is 1.0F.
|
||||
* Reducing the value causes a weakening/reduction of the heat-based sideeffects of reactors
|
||||
* (F.e. water evaporation, melting, damaging entitys, etc)
|
||||
*
|
||||
* @return HEM
|
||||
*/
|
||||
public float getHeatEffectModifier();
|
||||
|
||||
/**
|
||||
* Set's the reactor's HEM
|
||||
* Needs to be called during each cycle process.
|
||||
*/
|
||||
public void setHeatEffectModifier(float newHEM);
|
||||
|
||||
/**
|
||||
* Get the reactor's energy output.
|
||||
*
|
||||
* @return Energy output in EU/t
|
||||
*/
|
||||
public int getOutput();
|
||||
|
||||
/**
|
||||
* Add's the given amount of energy to the Reactor's output.
|
||||
*
|
||||
* @return Energy output after adding the value, in EU/t
|
||||
*/
|
||||
public int addOutput(int energy);
|
||||
|
||||
/**
|
||||
* Get's the EU worth of a single basic Uranium pulse
|
||||
* Please use this variable to alter energy output, as it represents the config modifiers as well.
|
||||
*/
|
||||
public int getPulsePower();
|
||||
|
||||
/**
|
||||
* Get the item at the specified grid coordinates.
|
||||
*
|
||||
* @param x X position of the item
|
||||
* @param y Y position of the item
|
||||
* @return The item or null if there is no item
|
||||
*/
|
||||
public ItemStack getItemAt(int x, int y);
|
||||
|
||||
/**
|
||||
* Set the item at the specified grid coordinates.
|
||||
*
|
||||
* @param x X position of the item
|
||||
* @param y Y position of the item
|
||||
* @param item The item to set.
|
||||
*/
|
||||
public void setItemAt(int x, int y, ItemStack item);
|
||||
|
||||
/**
|
||||
* Explode the reactor.
|
||||
*/
|
||||
public void explode();
|
||||
|
||||
/**
|
||||
* Get the reactor's tick rate (game ticks per reactor tick).
|
||||
*
|
||||
* @return Tick rate
|
||||
*/
|
||||
public int getTickRate();
|
||||
|
||||
/**
|
||||
* Get whether the reactor is active and supposed to produce energy
|
||||
* @return Whether the reactor is active
|
||||
*/
|
||||
public boolean produceEnergy();
|
||||
}
|
||||
|
|
@ -1,13 +0,0 @@
|
|||
package ic2.api;
|
||||
|
||||
/**
|
||||
* Interface implemented by the reactor chamber tile entity.
|
||||
*/
|
||||
public interface IReactorChamber {
|
||||
/**
|
||||
* Get the chamber's reactor.
|
||||
*
|
||||
* @return The reactor
|
||||
*/
|
||||
public IReactor getReactor();
|
||||
}
|
||||
|
|
@ -1,97 +0,0 @@
|
|||
package ic2.api;
|
||||
|
||||
import net.minecraft.src.ItemStack;
|
||||
|
||||
/**
|
||||
* Design custom Reactor components by implementing this Interface
|
||||
* Items implementing the interface will not be ejected from Reactors in their clean-up
|
||||
* and can/will be interacted with by other elements, f.e. Uranium Cells.
|
||||
*
|
||||
* All IC2 ReactorComponents implement and use this Interface
|
||||
*
|
||||
*/
|
||||
public interface IReactorComponent
|
||||
{
|
||||
/**
|
||||
* Called by reactor upon iterating through it's inventory (every cycle).
|
||||
* Perform all necessary calculation/interaction here
|
||||
*
|
||||
* @param reactor Reference to the Reactor
|
||||
* @param yourStack Reference to the specific instance of iterated ItemStack
|
||||
* @param x X-coordinate of the stack in the grid
|
||||
* @param y Y-coordinate of the stack in the grid
|
||||
*/
|
||||
public void processChamber(IReactor reactor, ItemStack yourStack, int x, int y);
|
||||
|
||||
/**
|
||||
* Can be called by Uranium-Components who attempt to generate energy by pulsing to other components.
|
||||
* Uranium-Uranium interaction (f.e.) uses this method.
|
||||
* @param reactor Reference to the Reactor
|
||||
* @param yourStack Reference to the specific instance of called ItemStack
|
||||
* @param pulsingStack Reference to the specific instance of pulsing ItemStack
|
||||
* @param youX X-coordinate of your stack in the grid
|
||||
* @param youY Y-coordinate of your stack in the grid
|
||||
* @param pulseX X-coordinate of pulsing stack in the grid
|
||||
* @param pulseY Y-coordinate of pulsing stack in the grid
|
||||
* @return true if this component reacts to the pulse (and pulse is therefore meant to produce heat)
|
||||
*/
|
||||
public boolean acceptUraniumPulse(IReactor reactor, ItemStack yourStack, ItemStack pulsingStack, int youX, int youY, int pulseX, int pulseY);
|
||||
|
||||
/**
|
||||
* Called by components to determine whether your component can be heated.
|
||||
* @param reactor Reference to the Reactor
|
||||
* @param yourStack Reference to the specific instance of iterated ItemStack
|
||||
* @param x X-coordinate of the stack in the grid
|
||||
* @param y Y-coordinate of the stack in the grid
|
||||
* @return true if your component can take heat
|
||||
*/
|
||||
public boolean canStoreHeat(IReactor reactor, ItemStack yourStack, int x, int y);
|
||||
|
||||
/**
|
||||
* Called by heat-switches to determine how much heat to distribute into which direction.
|
||||
* Please return the maximum capacity of your heat-containing component here.
|
||||
* @param reactor Reference to the Reactor
|
||||
* @param yourStack Reference to the specific instance of iterated ItemStack
|
||||
* @param x X-coordinate of the stack in the grid
|
||||
* @param y Y-coordinate of the stack in the grid
|
||||
* @return Maximum heat
|
||||
*/
|
||||
public int getMaxHeat(IReactor reactor, ItemStack yourStack, int x, int y);
|
||||
|
||||
/**
|
||||
* Called by heat-switches to determine how much heat to distribute into which direction.
|
||||
* Please return the current amount of heat stored in this component
|
||||
* @param reactor Reference to the Reactor
|
||||
* @param yourStack Reference to the specific instance of iterated ItemStack
|
||||
* @param x X-coordinate of the stack in the grid
|
||||
* @param y Y-coordinate of the stack in the grid
|
||||
* @return Current Heat
|
||||
*/
|
||||
public int getCurrentHeat(IReactor reactor, ItemStack yourStack, int x, int y);
|
||||
|
||||
/**
|
||||
* Called by components to distribute heat to your component.
|
||||
* Perform heating-calculations and increase your heat (dmg) level accordingly.
|
||||
* This method will as well be called to REDUCE heat, by providing a negative amount.
|
||||
*
|
||||
* @param reactor Reference to the Reactor
|
||||
* @param yourStack Reference to the specific instance of iterated ItemStack
|
||||
* @param x X-coordinate of the stack in the grid
|
||||
* @param y Y-coordinate of the stack in the grid
|
||||
* @param heat Amount of heat to be added (may be negative to subtract heat)
|
||||
* @return 0 if the 'order' was accepted, return >0 to indicate the 'remaining' heat which couldn't be absorbed (and vice versa for <0)
|
||||
*/
|
||||
public int alterHeat(IReactor reactor, ItemStack yourStack, int x, int y, int heat);
|
||||
|
||||
/**
|
||||
* Called upon reactor explosion
|
||||
* Alter the explosion size.
|
||||
* Returning a float 0 < f < 1 will be counted as multiplier.
|
||||
* Anything else will be counted as a flat addition (in case of <0 = reduction).
|
||||
*
|
||||
* @param reactor Reference to the Reactor
|
||||
* @param yourStack Reference to the specific instance of iterated ItemStack
|
||||
* @return your explosion modifier
|
||||
*/
|
||||
public float influenceExplosion(IReactor reactor, ItemStack yourStack);
|
||||
}
|
||||
|
|
@ -1,35 +0,0 @@
|
|||
package ic2.api;
|
||||
|
||||
import net.minecraft.src.World;
|
||||
|
||||
/**
|
||||
* Allows an item to act as a terraformer blueprint.
|
||||
*/
|
||||
public interface ITerraformingBP
|
||||
{
|
||||
/**
|
||||
* Get the energy consumption per operation of the blueprint.
|
||||
*
|
||||
* @return Energy consumption in EU
|
||||
*/
|
||||
public abstract int getConsume();
|
||||
|
||||
/**
|
||||
* Get the maximum range of the blueprint.
|
||||
* Should be a divisor of 5.
|
||||
*
|
||||
* @return Maximum range in blocks
|
||||
*/
|
||||
public abstract int getRange();
|
||||
|
||||
/**
|
||||
* Perform the terraforming operation.
|
||||
*
|
||||
* @param world world to terraform
|
||||
* @param x X position to terraform
|
||||
* @param z Z position to terraform
|
||||
* @param yCoord Y position of the terraformer
|
||||
* @return Whether the operation was successful and the terraformer should consume energy.
|
||||
*/
|
||||
public abstract boolean terraform(World world, int x, int z, int yCoord);
|
||||
}
|
||||
|
|
@ -1,50 +0,0 @@
|
|||
package ic2.api;
|
||||
|
||||
import net.minecraft.src.EntityPlayer;
|
||||
|
||||
/**
|
||||
* Allows a tile entity to make use of the wrench's removal and rotation functions.
|
||||
*/
|
||||
public interface IWrenchable {
|
||||
/**
|
||||
* Determine if the wrench can be used to set the block's facing.
|
||||
* Called before wrenchCanRemove().
|
||||
*
|
||||
* @param entityPlayer player using the wrench
|
||||
* @param side block's side the wrench was clicked on
|
||||
* @return Whether the wrenching was done and the wrench should be damaged
|
||||
*/
|
||||
boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side);
|
||||
|
||||
/**
|
||||
* Get the block's facing.
|
||||
*
|
||||
* @return Block facing
|
||||
*/
|
||||
short getFacing();
|
||||
|
||||
/**
|
||||
* Set the block's facing
|
||||
*
|
||||
* @param facing facing to set the block to
|
||||
*/
|
||||
void setFacing(short facing);
|
||||
|
||||
/**
|
||||
* Determine if the wrench can be used to remove the block.
|
||||
* Called if wrenchSetFacing fails.
|
||||
*
|
||||
* @param entityPlayer player using the wrench
|
||||
* @return Whether the wrenching was done and the wrench should be damaged
|
||||
*/
|
||||
boolean wrenchCanRemove(EntityPlayer entityPlayer);
|
||||
|
||||
/**
|
||||
* Determine the probability to drop the block as it is.
|
||||
* The first entry in getBlockDropped will be replaced by blockid:meta if the drop is successful.
|
||||
*
|
||||
* @return Probability from 0 to 1
|
||||
*/
|
||||
float getWrenchDropRate();
|
||||
}
|
||||
|
||||
|
|
@ -1,358 +0,0 @@
|
|||
package ic2.api;
|
||||
|
||||
import java.lang.reflect.Array;
|
||||
import java.util.AbstractMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
import net.minecraft.src.Block;
|
||||
import net.minecraft.src.Item;
|
||||
import net.minecraft.src.ItemStack;
|
||||
|
||||
/**
|
||||
* Provides access to Compressor, Extractor and Macerator recipes, as well as charge-aware recipes
|
||||
* and the Recycler blacklist.
|
||||
*
|
||||
* The recipes are only valid after IC2 has been loaded and are metadata and stack size sensitive,
|
||||
* for example you can create a recipe to compress 3 wooden planks into 2 sticks.
|
||||
*/
|
||||
public final class Ic2Recipes {
|
||||
/**
|
||||
* Add a charge-aware shaped crafting recipe.
|
||||
*/
|
||||
public static void addCraftingRecipe(ItemStack result, Object... args) {
|
||||
try {
|
||||
Class.forName(getPackage() + ".common.AdvRecipe").getMethod("addAndRegister", ItemStack.class, Array.newInstance(Object.class, 0).getClass()).invoke(null, result, args);
|
||||
} catch (Exception e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a charge-aware shapeless crafting recipe.
|
||||
*/
|
||||
public static void addShapelessCraftingRecipe(ItemStack result, Object... args) {
|
||||
try {
|
||||
Class.forName(getPackage() + ".common.AdvShapelessRecipe").getMethod("addAndRegister", ItemStack.class, Array.newInstance(Object.class, 0).getClass()).invoke(null, result, args);
|
||||
} catch (Exception e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieve the registered Compressor recipes.
|
||||
*
|
||||
* @return Recipe list as a list of map entries, the key is the input and the value is the output
|
||||
*/
|
||||
public static List<Map.Entry<ItemStack, ItemStack> > getCompressorRecipes() {
|
||||
if (TileEntityCompressor_recipes == null) {
|
||||
try {
|
||||
TileEntityCompressor_recipes = (List<Map.Entry<ItemStack, ItemStack> >) Class.forName(getPackage() + ".common.TileEntityCompressor").getField("recipes").get(null);
|
||||
} catch (Exception e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
|
||||
return TileEntityCompressor_recipes;
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a Compressor recipe.
|
||||
*
|
||||
* @param input Input
|
||||
* @param output Output
|
||||
*/
|
||||
public static void addCompressorRecipe(ItemStack input, ItemStack output) {
|
||||
getCompressorRecipes().add(new AbstractMap.SimpleEntry<ItemStack, ItemStack>(input, output));
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Get the Compressor output for an input item.
|
||||
*
|
||||
* @param input input item
|
||||
* @param adjustInput remove the processing requirements from input
|
||||
* @return Output item as an independent stack
|
||||
*/
|
||||
public static ItemStack getCompressorOutputFor(ItemStack input, boolean adjustInput) {
|
||||
return getOutputFor(input, adjustInput, getCompressorRecipes());
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieve the registered Extractor recipes.
|
||||
*
|
||||
* @return Recipe list as a list of map entries, the key is the input and the value is the output
|
||||
*/
|
||||
public static List<Map.Entry<ItemStack, ItemStack> > getExtractorRecipes() {
|
||||
if (TileEntityExtractor_recipes == null) {
|
||||
try {
|
||||
TileEntityExtractor_recipes = (List<Map.Entry<ItemStack, ItemStack> >) Class.forName(getPackage() + ".common.TileEntityExtractor").getField("recipes").get(null);
|
||||
} catch (Exception e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
|
||||
return TileEntityExtractor_recipes;
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a Extractor recipe.
|
||||
*
|
||||
* @param input Input
|
||||
* @param output Output
|
||||
*/
|
||||
public static void addExtractorRecipe(ItemStack input, ItemStack output) {
|
||||
getExtractorRecipes().add(new AbstractMap.SimpleEntry<ItemStack, ItemStack>(input, output));
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Get the Extractor output for an input item.
|
||||
*
|
||||
* @param input input item
|
||||
* @param adjustInput remove the processing requirements from input
|
||||
* @return Output item as an independent stack
|
||||
*/
|
||||
public static ItemStack getExtractorOutputFor(ItemStack input, boolean adjustInput) {
|
||||
return getOutputFor(input, adjustInput, getExtractorRecipes());
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieve the registered Macerator recipes.
|
||||
*
|
||||
* @return Recipe list as a list of map entries, the key is the input and the value is the output
|
||||
*/
|
||||
public static List<Map.Entry<ItemStack, ItemStack> > getMaceratorRecipes() {
|
||||
if (TileEntityMacerator_recipes == null) {
|
||||
try {
|
||||
TileEntityMacerator_recipes = (List<Map.Entry<ItemStack, ItemStack> >) Class.forName(getPackage() + ".common.TileEntityMacerator").getField("recipes").get(null);
|
||||
} catch (Exception e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
|
||||
return TileEntityMacerator_recipes;
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a Macerator recipe.
|
||||
*
|
||||
* @param input Input
|
||||
* @param output Output
|
||||
*/
|
||||
public static void addMaceratorRecipe(ItemStack input, ItemStack output) {
|
||||
getMaceratorRecipes().add(new AbstractMap.SimpleEntry<ItemStack, ItemStack>(input, output));
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Get the Macerator output for an input item.
|
||||
*
|
||||
* @param input input item
|
||||
* @param adjustInput remove the processing requirements from input
|
||||
* @return Output item as an independent stack
|
||||
*/
|
||||
public static ItemStack getMaceratorOutputFor(ItemStack input, boolean adjustInput) {
|
||||
return getOutputFor(input, adjustInput, getMaceratorRecipes());
|
||||
}
|
||||
|
||||
|
||||
private static ItemStack getOutputFor(ItemStack input, boolean adjustInput, List<Map.Entry<ItemStack, ItemStack> > recipeList) {
|
||||
assert input != null;
|
||||
|
||||
for (Map.Entry<ItemStack, ItemStack> entry: recipeList) {
|
||||
if (entry.getKey().isItemEqual(input) && input.stackSize >= entry.getKey().stackSize) {
|
||||
if (adjustInput) input.stackSize -= entry.getKey().stackSize;
|
||||
|
||||
return entry.getValue().copy();
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Retrieve the registered Recycler blacklist items.
|
||||
*
|
||||
* @return Blacklist
|
||||
*/
|
||||
public static List<ItemStack> getRecyclerBlacklist() {
|
||||
if (TileEntityRecycler_blacklist == null) {
|
||||
try {
|
||||
TileEntityRecycler_blacklist = (List<ItemStack>) Class.forName(getPackage() + ".common.TileEntityRecycler").getField("blacklist").get(null);
|
||||
} catch (Exception e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
|
||||
return TileEntityRecycler_blacklist;
|
||||
}
|
||||
|
||||
/**
|
||||
* Add an item stack to the Recycler blacklist.
|
||||
*
|
||||
* @param newBlacklistedItem item stack to add
|
||||
*/
|
||||
public static void addRecyclerBlacklistItem(ItemStack newBlacklistedItem) {
|
||||
getRecyclerBlacklist().add(newBlacklistedItem);
|
||||
}
|
||||
|
||||
/**
|
||||
* Add an item to the Recycler blacklist.
|
||||
*
|
||||
* @param newBlacklistedItem item to add
|
||||
*/
|
||||
public static void addRecyclerBlacklistItem(Item newBlacklistedItem) {
|
||||
addRecyclerBlacklistItem(new ItemStack(newBlacklistedItem, 1, -1));
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a block to the Recycler blacklist.
|
||||
*
|
||||
* @param newBlacklistedBlock block to add
|
||||
*/
|
||||
public static void addRecyclerBlacklistItem(Block newBlacklistedBlock) {
|
||||
addRecyclerBlacklistItem(new ItemStack(newBlacklistedBlock, 1, -1));
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Determine if an item is in the Recycler blacklist.
|
||||
*
|
||||
* @param itemStack item to check
|
||||
* @return Whether the item is blacklisted or not
|
||||
*/
|
||||
public static boolean isRecyclerInputBlacklisted(ItemStack itemStack) {
|
||||
for (ItemStack blackItem: getRecyclerBlacklist()) {
|
||||
if (itemStack.isItemEqual(blackItem)) return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieve the registered Scrap Box drops.
|
||||
*
|
||||
* @return Drops as a list of item stack and float (chance) pairs
|
||||
*/
|
||||
public static List<Map.Entry<ItemStack,Float>> getScrapboxDrops() {
|
||||
try {
|
||||
return (List<Map.Entry<ItemStack,Float>>) Class.forName(getPackage() + ".common.ItemScrapbox").getMethod("getDropList").invoke(null);
|
||||
} catch (Exception e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Reference scrap box chance values:
|
||||
*
|
||||
* 0.1: Diamond
|
||||
* 0.5: Cake, Gold Helmet, Iron Ore, Gold Ore
|
||||
* 1.0: Wooden tools, Soul Sand, Sign, Leather, Feather, Bone
|
||||
* 1.5: Apple, Bread
|
||||
* 2.0: Netherrack, Rotten Flesh
|
||||
* 3.0: Grass, Gravel
|
||||
* 4.0: Stick
|
||||
* 5.0: Dirt, Wooden Hoe
|
||||
*/
|
||||
|
||||
/**
|
||||
* Add an item stack to the Scrap Box drops.
|
||||
*
|
||||
* @param dropItem item stack to add
|
||||
* @param chance chance for the item to drop, see the code comments for reference values
|
||||
*/
|
||||
public static void addScrapboxDrop(ItemStack dropItem, float chance) {
|
||||
try {
|
||||
Class.forName(getPackage() + ".common.ItemScrapbox").getMethod("addDrop", ItemStack.class, float.class).invoke(null, dropItem, chance);
|
||||
} catch (Exception e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Add an item to the Scrap Box drops.
|
||||
*
|
||||
* @param dropItem item to add
|
||||
* @param chance chance for the item to drop, see the code comments for reference values
|
||||
*/
|
||||
public static void addScrapboxDrop(Item dropItem, float chance) {
|
||||
addScrapboxDrop(new ItemStack(dropItem, 1), chance);
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a block to the Scrap Box drops.
|
||||
*
|
||||
* @param dropItem item to add
|
||||
* @param chance chance for the item to drop, see the code comments for reference values
|
||||
*/
|
||||
public static void addScrapboxDrop(Block dropItem, float chance) {
|
||||
addScrapboxDrop(new ItemStack(dropItem), chance);
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieve the registered Mass Fabricator amplifiers.
|
||||
*
|
||||
* @return Amplifiers as a list of item stack and integer (amplifier value) pairs
|
||||
*/
|
||||
public static List<Map.Entry<ItemStack, Integer> > getMatterAmplifiers() {
|
||||
if (TileEntityMatter_amplifiers == null) {
|
||||
try {
|
||||
TileEntityMatter_amplifiers = (List<Map.Entry<ItemStack, Integer> >) Class.forName(getPackage() + ".common.TileEntityMatter").getField("amplifiers").get(null);
|
||||
} catch (Exception e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
|
||||
return TileEntityMatter_amplifiers;
|
||||
}
|
||||
|
||||
/**
|
||||
* Add an item stack to the Mass Fabricator amplifiers.
|
||||
*
|
||||
* @param amplifierItem item stack to add
|
||||
* @param value amplifier value for the item, scrap is 5000
|
||||
*/
|
||||
public static void addMatterAmplifier(ItemStack amplifierItem, int value) {
|
||||
getMatterAmplifiers().add(new AbstractMap.SimpleEntry<ItemStack,Integer>(amplifierItem, value));
|
||||
}
|
||||
|
||||
/**
|
||||
* Add an item to the Mass Fabricator amplifiers.
|
||||
*
|
||||
* @param amplifierItem item to add
|
||||
* @param value amplifier value for the item, scrap is 5000
|
||||
*/
|
||||
public static void addMatterAmplifier(Item amplifierItem, int value) {
|
||||
addMatterAmplifier(new ItemStack(amplifierItem, 1, -1), value);
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a block to the Mass Fabricator amplifiers.
|
||||
*
|
||||
* @param amplifierItem item to add
|
||||
* @param value amplifier value for the item, scrap is 5000
|
||||
*/
|
||||
public static void addMatterAmplifier(Block amplifierItem, int value) {
|
||||
addMatterAmplifier(new ItemStack(amplifierItem, 1, -1), value);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the base IC2 package name, used internally.
|
||||
*
|
||||
* @return IC2 package name, if unable to be determined defaults to ic2
|
||||
*/
|
||||
private static String getPackage() {
|
||||
Package pkg = Ic2Recipes.class.getPackage();
|
||||
if (pkg != null) return pkg.getName().substring(0, pkg.getName().lastIndexOf('.'));
|
||||
else return "ic2";
|
||||
}
|
||||
|
||||
private static List<Map.Entry<ItemStack, ItemStack> > TileEntityCompressor_recipes;
|
||||
private static List<Map.Entry<ItemStack, ItemStack> > TileEntityExtractor_recipes;
|
||||
private static List<Map.Entry<ItemStack, ItemStack> > TileEntityMacerator_recipes;
|
||||
private static List<ItemStack> TileEntityRecycler_blacklist;
|
||||
private static List<Map.Entry<ItemStack, Integer> > TileEntityMatter_amplifiers;
|
||||
}
|
||||
|
||||
|
|
@ -1,401 +0,0 @@
|
|||
package ic2.api;
|
||||
|
||||
import net.minecraft.src.ItemStack;
|
||||
|
||||
/**
|
||||
* Provides access to IC2 blocks and items.
|
||||
*
|
||||
* Some items can be acquired through the ore dictionary which is the recommended way.
|
||||
* The items are initialized while IC2 is being loaded - try to use ModsLoaded() or load your mod after IC2.
|
||||
* Some blocks/items can be disabled by a config setting, so it's recommended to check if they're null first.
|
||||
*
|
||||
* Getting the associated Block/Item for an ItemStack x:
|
||||
* Blocks: Block.blocksList[x.itemID]
|
||||
* Items: x.getItem()
|
||||
*/
|
||||
public final class Items {
|
||||
/**
|
||||
* Get an ItemStack for a specific item name, example: Items.getItem("resin")
|
||||
* See the list below for item names.
|
||||
* Make sure to copy() the ItemStack if you want to modify it.
|
||||
*
|
||||
* @param name item name
|
||||
* @return The item or null if the item does not exist or an error occurred
|
||||
*/
|
||||
public static ItemStack getItem(String name) {
|
||||
try {
|
||||
if (Ic2Items == null) Ic2Items = Class.forName(getPackage() + ".common.Ic2Items");
|
||||
|
||||
Object ret = Ic2Items.getField(name).get(null);
|
||||
|
||||
if (ret instanceof ItemStack) {
|
||||
return (ItemStack) ret;
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
} catch (Exception e) {
|
||||
System.out.println("IC2 API: Call getItem failed for "+name);
|
||||
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/* Possible values:
|
||||
|
||||
----- blocks -----
|
||||
|
||||
ores
|
||||
copperOre Copper Ore block, currently not meta sensitive, meta in ItemStack set to 0, ore dictionary: oreCopper, null with enableWorldGenOreCopper=false
|
||||
tinOre Tin Ore block, currently not meta sensitive, meta in ItemStack set to 0, ore dictionary: oreTin, null with enableWorldGenOreTin=false
|
||||
uraniumOre Tin Ore block, currently not meta sensitive, meta in ItemStack set to 0, ore dictionary: oreUranium, null with enableWorldGenOreUranium=false
|
||||
|
||||
rubber related
|
||||
Rubber wood block, meta reflects the state, meta in ItemStack set to 0, ore dictionary: woodRubber (with meta 0), null with enableWorldGenTreeRubber=false
|
||||
dropped (as an item) -> metadata 0
|
||||
block, no resin spot -> metadata 0 or 1
|
||||
block, wet resin spot -> metadata 2-5 (according to the side)
|
||||
block, dry resin spot -> metadata 8-11 (wet state + 6)
|
||||
|
||||
rubberWood
|
||||
rubberLeaves Rubber Leaves block, currently not meta sensitive, meta in ItemStack set to 0, null with enableWorldGenTreeRubber=false
|
||||
rubberSapling Rubber Sapling block, currently not meta sensitive, meta in ItemStack set to 0, null with enableWorldGenTreeRubber=false
|
||||
resinSheet Resin Sheet block, currently not meta sensitive
|
||||
rubberTrampoline Rubber Trampoline block, meta reflects internal state, meta in ItemStack set to 0
|
||||
|
||||
building/storage
|
||||
ironFence Iron Fence block, currently not meta sensitive
|
||||
|
||||
reinforcedStone Reinforced Stone block, currently not meta sensitive
|
||||
reinforcedGlass Reinforced Glass block, currently not meta sensitive
|
||||
reinforcedDoorBlock Reinforced Door block, meta reflects the state (see vanilla doors), meta in ItemStack set to 0
|
||||
|
||||
constructionFoam Construction Foam block, currently not meta sensitive
|
||||
constructionFoamWall Construction Foam Wall block, meta = color, implements IPaintableBlock
|
||||
scaffold Scaffold block, meta reflects internal physical model data
|
||||
|
||||
bronzeBlock Bronze block, meta sensitive
|
||||
copperBlock Copper block, meta sensitive
|
||||
tinBlock Tin block, meta sensitive
|
||||
uraniumBlock Uranium block, meta sensitive
|
||||
|
||||
cables (when placed as a block, inventory items are different TE implements IEnergyConductor)
|
||||
copperCableBlock Copper Cable block, meta sensitive
|
||||
insulatedCopperCableBlock Insulated Copper Cable block, meta sensitive
|
||||
|
||||
goldCableBlock Gold Cable block, meta sensitive
|
||||
insulatedGoldCableBlock Insulated Gold Cable block, meta sensitive
|
||||
doubleInsulatedGoldCableBlock Double Insulated Gold Cable block, meta sensitive
|
||||
|
||||
ironCableBlock Iron Cable block, meta sensitive
|
||||
insulatedIronCableBlock Insulated Iron Cable block, meta sensitive
|
||||
doubleInsulatedIronCableBlock Double Insulated Iron Cable block, meta sensitive
|
||||
trippleInsulatedIronCableBlock Tripple Insulated Iron Cable block, meta sensitive
|
||||
|
||||
glassFiberCableBlock Glass Fiber Cable block, meta sensitive
|
||||
|
||||
tinCableBlock Tin Cable block, meta sensitive
|
||||
|
||||
detectorCableBlock Detector Cable block, meta sensitive
|
||||
splitterCableBlock Splitter Cable block, meta sensitive
|
||||
|
||||
generators + related (TE implements IEnergySource ex. reactorChamber)
|
||||
generator Generator block, meta sensitive
|
||||
geothermalGenerator Geothermal Generator block, meta sensitive
|
||||
waterMill Water Mill block, meta sensitive
|
||||
solarPanel Solar Panel block, meta sensitive
|
||||
windMill Wind Mill block, meta sensitive
|
||||
nuclearReactor Nuclear Reactor block, meta sensitive
|
||||
reactorChamber Reactor Chamber block, currently not meta sensitive
|
||||
|
||||
energy storages (TE implements IEnergySource and IEnergyConductor)
|
||||
batBox BatBox block, meta sensitive
|
||||
mfeUnit MFE Unit block, meta sensitive
|
||||
mfsUnit MFS Unit block, meta sensitive
|
||||
|
||||
transformers (TE implements IEnergySource and IEnergyConductor)
|
||||
lvTransformer LV Transformer block, meta sensitive
|
||||
mvTransformer MV Transformer block, meta sensitive
|
||||
hvTransformer HV Transformer block, meta sensitive
|
||||
|
||||
machines + related (TE implements IEnergySink ex. machine, miningPipe, miningPipeTip)
|
||||
machine Machine block, meta sensitive
|
||||
advancedMachine Advanced Machine block, meta sensitive
|
||||
|
||||
ironFurnace Iron Furnace block, meta sensitive
|
||||
electroFurnace Electro Furnace block, meta sensitive
|
||||
macerator Macerator block, meta sensitive
|
||||
extractor Extractor block, meta sensitive
|
||||
compressor Compressor block, meta sensitive
|
||||
canner Canner block, meta sensitive
|
||||
miner Miner block, meta sensitive
|
||||
pump Pump block, meta sensitive
|
||||
magnetizer Magnetizer block, meta sensitive
|
||||
electrolyzer Electrolyzer block, meta sensitive
|
||||
recycler Recycler block, meta sensitive
|
||||
inductionFurnace Induction Furnace block, meta sensitive
|
||||
massFabricator Mass Fabricator block, meta sensitive
|
||||
terraformer Terraformer block, meta sensitive
|
||||
teleporter Teleporter block, meta sensitive
|
||||
teslaCoil Tesla Coil block, meta sensitive
|
||||
luminator Passive (dark) Luminator block, meta = facing
|
||||
activeLuminator Active (bright) Luminator block, meta = facing
|
||||
|
||||
miningPipe Mining Pipe block, currently not meta sensitive, meta in ItemStack set to 0
|
||||
miningPipeTip Mining Pipe Tip block, currently not meta sensitive, meta in ItemStack set to 0
|
||||
|
||||
personal blocks
|
||||
personalSafe Personal Safe block, meta sensitive
|
||||
tradeOMat Trade-O-Mat block, meta sensitive
|
||||
energyOMat Energy-O-Mat block, meta sensitive
|
||||
|
||||
explosives
|
||||
industrialTnt Industrial TNT block, currently not meta sensitive
|
||||
nuke Nuke block, currently not meta sensitive
|
||||
dynamiteStick Dynamite Stick block, meta = placement, meta in ItemStack set to 0
|
||||
dynamiteStickWithRemote Dynamite Stick with Remote block, meta = placement, meta in ItemStack set to 0
|
||||
|
||||
Agriculture Stuff
|
||||
crop Crop Block, empty, not meta sensitive
|
||||
|
||||
|
||||
----- items -----
|
||||
|
||||
rubber + related
|
||||
resin Resin item, currently not meta sensitive
|
||||
rubber Rubber item, currently not meta sensitive, ore dictionary: itemRubber
|
||||
|
||||
ore drops
|
||||
uraniumDrop Uranium Drop item, currently not meta sensitive, ore dictionary: itemDropUranium
|
||||
|
||||
dusts
|
||||
bronzeDust Bronze Dust item, currently not meta sensitive
|
||||
clayDust Clay Dust item, currently not meta sensitive
|
||||
coalDust Coal Dust item, currently not meta sensitive
|
||||
copperDust Copper Dust item, currently not meta sensitive
|
||||
goldDust Gold Dust item, currently not meta sensitive
|
||||
ironDust Iron Dust item, currently not meta sensitive
|
||||
silverDust Silver Dust item, currently not meta sensitive
|
||||
smallIronDust Small Iron Dust item, currently not meta sensitive
|
||||
tinDust Tin Dust item, currently not meta sensitive
|
||||
hydratedCoalDust Hydrated Coal Dust item, currently not meta sensitive
|
||||
|
||||
ingots
|
||||
refinedIronIngot Refined Iron Ingot item, currently not meta sensitive, ore dictionary: ingotRefinedIron
|
||||
copperIngot Copper Ingot item, currently not meta sensitive, ore dictionary: ingotCopper
|
||||
tinIngot Tin Ingot item, currently not meta sensitive, ore dictionary: ingotTin
|
||||
bronzeIngot Bronze Ingot item, currently not meta sensitive, ore dictionary: ingotBronze
|
||||
mixedMetalIngot Mixed Metal Ingot item, currently not meta sensitive
|
||||
uraniumIngot Uranium Ingot item, currently not meta sensitive, ore dictionary: ingotUranium
|
||||
|
||||
tools/weapons (without electric tools)
|
||||
treetap Treetap item, meta = damage value
|
||||
wrench Wrench item, meta = damage value
|
||||
cutter Insulation Cutter item, meta = damage value
|
||||
constructionFoamSprayer Construction Foam Sprayer item, meta = charges (as of v1.45)
|
||||
|
||||
bronzePickaxe Bronze Pickaxe item, meta = damage value
|
||||
bronzeAxe Bronze Axe item, meta = damage value
|
||||
bronzeSword Bronze Sword item, meta = damage value
|
||||
bronzeShovel Bronze Shovel item, meta = damage value
|
||||
bronzeHoe Bronze Hoe item, meta = damage value
|
||||
|
||||
el. tools/devices/weapons
|
||||
miningDrill Mining Drill item, meta = visual charge indicator, implements IElectricItem
|
||||
diamondDrill Diamond Tipped Mining Drill item, meta = visual charge indicator, implements IElectricItem
|
||||
chainsaw Chainsaw item, meta = visual charge indicator, implements IElectricItem
|
||||
electricWrench Electric Wrench item, meta = visual charge indicator, implements IElectricItem
|
||||
electricTreetap Electric Treetap item, meta = visual charge indicator, implements IElectricItem
|
||||
miningLaser Mining Laser item, meta = visual charge indicator, implements IElectricItem
|
||||
|
||||
ecMeter EC-Mater item, currently not meta sensitive
|
||||
odScanner Ore Density Scanner item, meta = damage value for charge level, implements IElectricItem
|
||||
ovScanner Ore Value Scanner item, meta = visual charge indicator, implements IElectricItem
|
||||
|
||||
frequencyTransmitter Frequency Transmitter item, currently not meta sensitive
|
||||
|
||||
nanoSaber Idle Nano Saber item, meta = visual charge indicator, implements IElectricItem
|
||||
enabledNanoSaber Enabled Nano Saber item, meta = visual charge indicator, implements IElectricItem
|
||||
|
||||
armor/wearable
|
||||
rubberBoots Rubber Boots item, meta = damage value
|
||||
|
||||
bronzeHelmet Bronze Helmet Armor item, meta = damage value
|
||||
bronzeChestplate Bronze Chestplate Armor item, meta = damage value
|
||||
bronzeLeggings Bronze Leggings Armor item, meta = damage value
|
||||
bronzeBoots Bronze Boots Armor item, meta = damage value
|
||||
|
||||
compositeArmor Composite Armor item, meta = damage value for charge level
|
||||
|
||||
nanoHelmet Nano Helmet Armor item, meta = visual charge indicator, implements IElectricItem
|
||||
nanoBodyarmor Nano Bodyarmor item, meta = visual charge indicator, implements IElectricItem
|
||||
nanoLeggings Nano Leggings Armor item, meta = visual charge indicator, implements IElectricItem
|
||||
nanoBoots Nano Boots Armor item, meta = visual charge indicator, implements IElectricItem
|
||||
|
||||
quantumHelmet Quantum Helmet Armor item, meta = visual charge indicator, implements IElectricItem
|
||||
quantumBodyarmor Quantum Bodyarmor item, meta = visual charge indicator, implements IElectricItem
|
||||
quantumLeggings Quantum Leggings Armor item, meta = visual charge indicator, implements IElectricItem
|
||||
quantumBoots Quantum Boots Armor item, meta = visual charge indicator, implements IElectricItem
|
||||
|
||||
jetpack Jetpack item, meta = damage value for fuel level
|
||||
electricJetpack Electric Jetpack item, meta = visual charge indicator, implements IElectricItem
|
||||
|
||||
batPack BatPack item, meta = visual charge indicator, implements IElectricItem, can provide energy
|
||||
lapPack LapPack item, meta = visual charge indicator, implements IElectricItem, can provide energy
|
||||
|
||||
cfPack CF Pack item, meta = charges (as of v1.45)
|
||||
|
||||
solarHelmet Solar Helmet item, currently not meta sensitive
|
||||
staticBoots Static Boots item, currently not meta sensitive
|
||||
|
||||
batteries
|
||||
reBattery Empty RE Battery item, currently not meta sensitive, implements IElectricItem
|
||||
chargedReBattery RE Battery item, meta = visual charge indicator, implements IElectricItem, can provide energy
|
||||
energyCrystal Energy Crystal item, meta = visual charge indicator, implements IElectricItem, can provide energy
|
||||
lapotronCrystal Lapotron Crystal item, meta = visual charge indicator, implements IElectricItem, can provide energy
|
||||
suBattery SU Battery item, currently not meta sensitive
|
||||
|
||||
cables
|
||||
copperCableItem Copper Cable item, meta sensitive
|
||||
insulatedCopperCableItem Insulated Copper Cable item, meta sensitive
|
||||
|
||||
goldCableItem Gold Cable item, meta sensitive
|
||||
insulatedGoldCableItem Insulated Gold Cable item, meta sensitive
|
||||
doubleInsulatedGoldCableItem Double Insulated Gold Cable item, meta sensitive
|
||||
|
||||
ironCableItem Iron Cable item, meta sensitive
|
||||
insulatedIronCableItem Insulated Iron Cable item, meta sensitive
|
||||
doubleInsulatedIronCableItem Double Insulated Iron Cable item, meta sensitive
|
||||
trippleInsulatedIronCableItem Tripple Insulated Iron Cable item, meta sensitive
|
||||
|
||||
glassFiberCableItem Glass Fiber Cable item, meta sensitive
|
||||
|
||||
tinCableItem Tin Cable item, meta sensitive
|
||||
|
||||
detectorCableItem Detector Cable item, meta sensitive
|
||||
splitterCableItem Splitter Cable item, meta sensitive
|
||||
|
||||
cells/containers (without reactor components)
|
||||
cell Empty Cell item, currently not meta sensitive
|
||||
lavaCell Lava Cell item, currently not meta sensitive
|
||||
hydratedCoalCell Hydrated Coal Cell item, currently not meta sensitive
|
||||
bioCell Bio Cell item, currently not meta sensitive
|
||||
coalfuelCell Coalfuel Cell item, currently not meta sensitive
|
||||
biofuelCell Biofuel Cell item, currently not meta sensitive
|
||||
waterCell Water Cell item, currently not meta sensitive
|
||||
electrolyzedWaterCell Electrolyzed Water Cell item, currently not meta sensitive
|
||||
|
||||
fuelCan Empty Fuel Can item, currently not meta sensitive
|
||||
filledFuelCan Fuel Can item, meta = fuel value (as of v1.45)
|
||||
|
||||
tinCan Empty Tin Can item, currently not meta sensitive
|
||||
filledTinCan Filled Tin Can item, currently not meta sensitive
|
||||
|
||||
reactor components
|
||||
uraniumCell Uranium Cell item, meta = damage value
|
||||
coolingCell Cooling Cell item, meta = damage value
|
||||
|
||||
depletedIsotopeCell Depleted Isotope Cell item, meta = damage value
|
||||
reEnrichedUraniumCell Re-Enriched Uranium Cell item, currently not meta sensitive
|
||||
nearDepletedUraniumCell Near-Depleted Uranium Cell item, currently not meta sensitive
|
||||
|
||||
integratedReactorPlating Integrated Reactor Plating item, meta = damage value
|
||||
integratedHeatDisperser Integrated Heat Disperser item, meta = damage value
|
||||
|
||||
terraformer blueprints
|
||||
terraformerBlueprint Empty Terraformer Blueprint item, currently not meta sensitive
|
||||
cultivationTerraformerBlueprint Cultivation Terraformer Blueprint item, currently not meta sensitive
|
||||
irrigationTerraformerBlueprint Irrigation Terraformer Blueprint item, currently not meta sensitive
|
||||
chillingTerraformerBlueprint Chilling Terraformer Blueprint item, currently not meta sensitive
|
||||
desertificationTerraformerBlueprint Desertification Terraformer Blueprint item, currently not meta sensitive
|
||||
flatificatorTerraformerBlueprint Flatificator Terraformer Blueprint item, currently not meta sensitive
|
||||
mushroomTerraformerBlueprint Mushroom Terraformer Blueprint item, currently not meta sensitive
|
||||
|
||||
diamond chain
|
||||
coalBall Coal Ball item, currently not meta sensitive
|
||||
compressedCoalBall Compressed Coal Ball item, currently not meta sensitive
|
||||
coalChunk Coal Chunk item, currently not meta sensitive
|
||||
industrialDiamond Industrial Diamond item, currently not meta sensitive, DEPRECATED
|
||||
|
||||
recycler chain
|
||||
scrap Scrap item, currently not meta sensitive
|
||||
scrapBox Scrap Box item, currently not meta sensitive
|
||||
|
||||
fuel production chain
|
||||
hydratedCoalClump Hydrated Coal Clump item, currently not meta sensitive
|
||||
plantBall Plant Ball item, currently not meta sensitive
|
||||
compressedPlantBall Compressed Plant Ball item, currently not meta sensitive
|
||||
|
||||
painting
|
||||
painter Painter item, currently not meta sensitive
|
||||
|
||||
blackPainter Black Painter item, meta = damage value
|
||||
redPainter Red Painter item, meta = damage value
|
||||
greenPainter Green Painter item, meta = damage value
|
||||
brownPainter Brown Painter item, meta = damage value
|
||||
bluePainter Blue Painter item, meta = damage value
|
||||
purplePainter Purple Painter item, meta = damage value
|
||||
cyanPainter Cyan Painter item, meta = damage value
|
||||
lightGreyPainter Light Grey Painter item, meta = damage value
|
||||
darkGreyPainter Dark Grey Painter item, meta = damage value
|
||||
pinkPainter Pink Painter item, meta = damage value
|
||||
limePainter Lime Painter item, meta = damage value
|
||||
yellowPainter Yellow Painter item, meta = damage value
|
||||
cloudPainter Cloud Painter item, meta = damage value
|
||||
magentaPainter Magenta Painter item, meta = damage value
|
||||
orangePainter Orange Painter item, meta = damage value
|
||||
whitePainter White Painter item, meta = damage value
|
||||
|
||||
explosives + related
|
||||
dynamite Throwable Dynamite item, currently not meta sensitive
|
||||
stickyDynamite Throwable Sticky Dynamite item, currently not meta sensitive
|
||||
|
||||
remote Dynamite Remote item, currently not meta sensitive
|
||||
|
||||
misc intermediate recipe ingredients
|
||||
electronicCircuit Electronic Circuit item, currently not meta sensitive
|
||||
advancedCircuit Advanced Circuit item, currently not meta sensitive
|
||||
|
||||
advancedAlloy Advanced Alloy item, currently not meta sensitive
|
||||
|
||||
carbonFiber Raw Carbon Fiber item, currently not meta sensitive
|
||||
carbonMesh Raw Carbon Mesh item, currently not meta sensitive
|
||||
carbonPlate Carbon Plate item, currently not meta sensitive
|
||||
|
||||
matter UU-Matter item, currently not meta sensitive
|
||||
iridiumOre Iridium Ore item, currently not meta sensitive
|
||||
iridiumPlate Iridium Plate item, currently not meta sensitive
|
||||
|
||||
upgrade modules
|
||||
overclockerUpgrade overclocker upgrade item, meta sensitive
|
||||
transformerUpgrade transformer upgrade item, meta sensitive
|
||||
energyStorageUpgrade energy storage upgrade item, meta sensitive
|
||||
|
||||
misc
|
||||
coin Coin item, currently not meta sensitive
|
||||
reinforcedDoor Reinforced Door item, currently not meta sensitive
|
||||
constructionFoamPellet Construction Foam Pellet item, currently not meta sensitive
|
||||
cropSeed Crop seeds, stuff stored in NBT, don't use for crafting recipes!
|
||||
cropnalyzer Cropnalyzer handheld device
|
||||
fertilizer Basic IC2Item, used to provide nutrients toCropBlocks
|
||||
hydratingCell Cell used to hydrate Crops, meta = Content, 0 = Full, 9999 = Near empty
|
||||
electricHoe Electric Hoe, meta = charge level
|
||||
solarHelmet Solar Helmet item, currently not meta sensitive
|
||||
terraWart Terra Wart item, cures potion effects
|
||||
weedEx Weed-EX can, meta = uses left
|
||||
|
||||
*/
|
||||
|
||||
/**
|
||||
* Get the base IC2 package name, used internally.
|
||||
*
|
||||
* @return IC2 package name, if unable to be determined defaults to ic2
|
||||
*/
|
||||
private static String getPackage() {
|
||||
Package pkg = Items.class.getPackage();
|
||||
if (pkg != null) return pkg.getName().substring(0, pkg.getName().lastIndexOf('.'));
|
||||
else return "ic2";
|
||||
}
|
||||
|
||||
private static Class Ic2Items;
|
||||
}
|
||||
|
||||
|
|
@ -1,236 +0,0 @@
|
|||
package ic2.api;
|
||||
|
||||
import java.lang.reflect.Method;
|
||||
|
||||
import net.minecraft.src.EntityPlayer;
|
||||
import net.minecraft.src.ItemStack;
|
||||
import net.minecraft.src.TileEntity;
|
||||
import net.minecraft.src.World;
|
||||
|
||||
/**
|
||||
* Provides methods to initiate events and synchronize tile entity fields in SMP.
|
||||
*
|
||||
* The methods are transparent between singleplayer and multiplayer - if a method is called in
|
||||
* singleplayer, the associated callback will be locally executed. The implementation is different
|
||||
* between the client and server versions of IC2.
|
||||
*
|
||||
* You'll usually want to use the server->client methods defined here to synchronize information
|
||||
* which is needed by the clients outside the GUI, such as rendering the block, playing sounds or
|
||||
* producing effects. Anything which is only visible inside the GUI should be synchronized through
|
||||
* the Container class associated to the GUI in Container.updateProgressBar().
|
||||
*/
|
||||
public final class NetworkHelper {
|
||||
// server -> client
|
||||
|
||||
|
||||
/**
|
||||
* Schedule a TileEntity's field to be updated to the clients in range.
|
||||
*
|
||||
* The updater will query the field's value during the next update, updates happen usually
|
||||
* every 2 ticks. If low latency is important use initiateTileEntityEvent instead.
|
||||
*
|
||||
* IC2's network updates have to get triggered every time, it doesn't continuously poll/send
|
||||
* the field value. Just call updateTileEntityField after every change to a field which needs
|
||||
* network synchronization.
|
||||
*
|
||||
* The following field data types are currently supported:
|
||||
* - int, int[], short, short[], byte, byte[], long, long[]
|
||||
* - float, float[], double, double[]
|
||||
* - boolean, boolean[]
|
||||
* - String, String[]
|
||||
* - ItemStack
|
||||
* - NBTBase (includes NBTTagCompound)
|
||||
* - Block, Item, Achievement, Potion, Enchantment
|
||||
* - ChunkCoordinates, ChunkCoordIntPair
|
||||
* - TileEntity (does not sync the actual tile entity, instead looks up the tile entity by its position in the client world)
|
||||
* - World (does not sync the actual world, instead looks up the world by its dimension ID)
|
||||
*
|
||||
* Once the update has been processed by the client, it'll call onNetworkUpdate on the client-
|
||||
* side TileEntity if it implements INetworkUpdateListener.
|
||||
*
|
||||
* If this method is being executed on the client (i.e. Singleplayer), it'll just call
|
||||
* INetworkUpdateListener.onNetworkUpdate (if implemented by the te).
|
||||
*
|
||||
* @param te TileEntity to update
|
||||
* @param field Name of the field to update
|
||||
*/
|
||||
public static void updateTileEntityField(TileEntity te, String field) {
|
||||
try {
|
||||
if (NetworkManager_updateTileEntityField == null) NetworkManager_updateTileEntityField = Class.forName(getPackage() + ".common.NetworkManager").getMethod("updateTileEntityField", TileEntity.class, String.class);
|
||||
if (instance == null) instance = getInstance();
|
||||
|
||||
NetworkManager_updateTileEntityField.invoke(instance, te, field);
|
||||
} catch (Exception e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Immediately send an event for the specified TileEntity to the clients in range.
|
||||
*
|
||||
* If this method is being executed on the client (i.e. Singleplayer), it'll just call
|
||||
* INetworkTileEntityEventListener.onNetworkEvent (if implemented by the te).
|
||||
*
|
||||
* @param te TileEntity to notify, should implement INetworkTileEntityEventListener
|
||||
* @param event Arbitrary integer to represent the event, choosing the values is up to you
|
||||
* @param limitRange Limit the notification range to (currently) 20 blocks instead of the
|
||||
* tracking distance if true
|
||||
*/
|
||||
public static void initiateTileEntityEvent(TileEntity te, int event, boolean limitRange) {
|
||||
try {
|
||||
if (NetworkManager_initiateTileEntityEvent == null) NetworkManager_initiateTileEntityEvent = Class.forName(getPackage() + ".common.NetworkManager").getMethod("initiateTileEntityEvent", TileEntity.class, Integer.TYPE, Boolean.TYPE);
|
||||
if (instance == null) instance = getInstance();
|
||||
|
||||
NetworkManager_initiateTileEntityEvent.invoke(null, te, event, limitRange);
|
||||
} catch (Exception e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Immediately send an event for the specified Item to the clients in range.
|
||||
*
|
||||
* The item should implement INetworkItemEventListener to receive the event.
|
||||
*
|
||||
* If this method is being executed on the client (i.e. Singleplayer), it'll just call
|
||||
* INetworkItemEventListener.onNetworkEvent (if implemented by the item).
|
||||
*
|
||||
* @param player EntityPlayer holding the item
|
||||
* @param itemStack ItemStack containing the item
|
||||
* @param event Arbitrary integer to represent the event, choosing the values is up to you
|
||||
* @param limitRange Limit the notification range to (currently) 20 blocks instead of the
|
||||
* tracking distance if true
|
||||
*/
|
||||
public static void initiateItemEvent(EntityPlayer player, ItemStack itemStack, int event, boolean limitRange) {
|
||||
try {
|
||||
if (NetworkManager_initiateItemEvent == null) NetworkManager_initiateItemEvent = Class.forName(getPackage() + ".common.NetworkManager").getMethod("initiateItemEvent", EntityPlayer.class, ItemStack.class, Integer.TYPE, Boolean.TYPE);
|
||||
if (instance == null) instance = getInstance();
|
||||
|
||||
NetworkManager_initiateItemEvent.invoke(instance, player, itemStack, event, limitRange);
|
||||
} catch (Exception e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Schedule a block update (re-render) on the clients in range.
|
||||
*
|
||||
* If this method is being executed on the client (i.e. Singleplayer), it'll just trigger the
|
||||
* block update locally.
|
||||
*
|
||||
* @param world World containing the block
|
||||
* @param x The block's x coordinate
|
||||
* @param y The block's y coordinate
|
||||
* @param z The block's z coordinate
|
||||
*/
|
||||
public static void announceBlockUpdate(World world, int x, int y, int z) {
|
||||
try {
|
||||
if (NetworkManager_announceBlockUpdate == null) NetworkManager_announceBlockUpdate = Class.forName(getPackage() + ".common.NetworkManager").getMethod("announceBlockUpdate", World.class, Integer.TYPE, Integer.TYPE, Integer.TYPE);
|
||||
|
||||
NetworkManager_announceBlockUpdate.invoke(null, world, x, y, z);
|
||||
} catch (Exception e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// client -> server
|
||||
|
||||
|
||||
/**
|
||||
* Ask the server to send the values of the fields specified.
|
||||
*
|
||||
* See updateTileEntityField for the supported field types.
|
||||
*
|
||||
* The implementation is currently limited to TileEntitys as data providers. The tile entity
|
||||
* has to be fully initialized when executing this method (i.e. valid worldObj+coords).
|
||||
*
|
||||
* This method doesn't do anything if executed on the server.
|
||||
*
|
||||
* @param dataProvider Object implementing the INetworkDataProvider interface
|
||||
*/
|
||||
public static void requestInitialData(INetworkDataProvider dataProvider) {
|
||||
try {
|
||||
if (NetworkManager_requestInitialData == null) NetworkManager_requestInitialData = Class.forName(getPackage() + ".common.NetworkManager").getMethod("requestInitialData", INetworkDataProvider.class);
|
||||
if (instance == null) instance = getInstance();
|
||||
|
||||
NetworkManager_requestInitialData.invoke(instance, dataProvider);
|
||||
} catch (Exception e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Immediately send an event for the specified TileEntity to the server.
|
||||
*
|
||||
* This method doesn't do anything if executed on the server.
|
||||
*
|
||||
* @param te TileEntity to notify, should implement INetworkClientTileEntityEventListener
|
||||
* @param event Arbitrary integer to represent the event, choosing the values is up to you
|
||||
*/
|
||||
public static void initiateClientTileEntityEvent(TileEntity te, int event) {
|
||||
try {
|
||||
if (NetworkManager_initiateClientTileEntityEvent == null) NetworkManager_initiateClientTileEntityEvent = Class.forName(getPackage() + ".common.NetworkManager").getMethod("initiateClientTileEntityEvent", TileEntity.class, Integer.TYPE);
|
||||
if (instance == null) instance = getInstance();
|
||||
|
||||
NetworkManager_initiateClientTileEntityEvent.invoke(instance, te, event);
|
||||
} catch (Exception e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Immediately send an event for the specified Item to the clients in range.
|
||||
*
|
||||
* The item should implement INetworkItemEventListener to receive the event.
|
||||
*
|
||||
* This method doesn't do anything if executed on the server.
|
||||
*
|
||||
* @param itemStack ItemStack containing the item
|
||||
* @param event Arbitrary integer to represent the event, choosing the values is up to you
|
||||
*/
|
||||
public static void initiateClientItemEvent(ItemStack itemStack, int event) {
|
||||
try {
|
||||
if (NetworkManager_initiateClientItemEvent == null) NetworkManager_initiateClientItemEvent = Class.forName(getPackage() + ".common.NetworkManager").getMethod("initiateClientItemEvent", ItemStack.class, Integer.TYPE);
|
||||
if (instance == null) instance = getInstance();
|
||||
|
||||
NetworkManager_initiateClientItemEvent.invoke(instance, itemStack, event);
|
||||
} catch (Exception e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the base IC2 package name, used internally.
|
||||
*
|
||||
* @return IC2 package name, if unable to be determined defaults to ic2
|
||||
*/
|
||||
private static String getPackage() {
|
||||
Package pkg = NetworkHelper.class.getPackage();
|
||||
if (pkg != null) return pkg.getName().substring(0, pkg.getName().lastIndexOf('.'));
|
||||
else return "ic2";
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the NetworkManager instance, used internally.
|
||||
*
|
||||
* @return NetworkManager instance
|
||||
*/
|
||||
private static Object getInstance() {
|
||||
try {
|
||||
return Class.forName(getPackage() + ".common.IC2").getDeclaredField("network").get(null);
|
||||
} catch (Throwable e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
|
||||
private static Object instance;
|
||||
private static Method NetworkManager_updateTileEntityField;
|
||||
private static Method NetworkManager_initiateTileEntityEvent;
|
||||
private static Method NetworkManager_initiateItemEvent;
|
||||
private static Method NetworkManager_announceBlockUpdate;
|
||||
private static Method NetworkManager_requestInitialData;
|
||||
private static Method NetworkManager_initiateClientTileEntityEvent;
|
||||
private static Method NetworkManager_initiateClientItemEvent;
|
||||
}
|
||||
|
||||
|
|
@ -1,161 +0,0 @@
|
|||
package ic2.api;
|
||||
|
||||
import net.minecraft.src.Block;
|
||||
import net.minecraft.src.ItemStack;
|
||||
import net.minecraft.src.TileEntity;
|
||||
|
||||
/**
|
||||
* Provides access to a crop tile entity. Contains all methods and fields you can access from your CropCard.
|
||||
*/
|
||||
public abstract class TECrop extends TileEntity
|
||||
{
|
||||
/**
|
||||
* ID of the plant currently on the crop.
|
||||
* -1 if there is no plant currently on the crop.
|
||||
*/
|
||||
public short id = -1;
|
||||
|
||||
/**
|
||||
* Current size of the plant.
|
||||
* 1 is the starting size and the maximum size varies from plant to plant.
|
||||
*/
|
||||
public byte size = 0;
|
||||
|
||||
/**
|
||||
* Growth ability of a plant.
|
||||
* Higher values give faster growth.
|
||||
*/
|
||||
public byte statGrowth = 0;
|
||||
/**
|
||||
* Chances and amount of gain and seeds from harvested crops.
|
||||
* Higher values give more drops.
|
||||
*/
|
||||
public byte statGain = 0;
|
||||
/**
|
||||
* Ability for the plant to resist trampling.
|
||||
* Higher values give more resistance against trampling.
|
||||
*/
|
||||
public byte statResistance = 0;
|
||||
|
||||
/**
|
||||
* Scan level, increases each time a seed goes through analysis.
|
||||
*/
|
||||
public byte scanLevel = 0;
|
||||
|
||||
/**
|
||||
* Custom data stored along a TECrop.
|
||||
*/
|
||||
public short[] custumData = new short[16];
|
||||
|
||||
/**
|
||||
* Crop nutrients.
|
||||
* Ranges from 0 (empty) to 100 (full).
|
||||
*/
|
||||
public int nutrientStorage = 0;
|
||||
/**
|
||||
* Crop hydration.
|
||||
* Values are:
|
||||
* - 0 for nothing
|
||||
* - 1-10 for water hydration
|
||||
* - 11-100 for distilled water (hydration cell) hydration
|
||||
*/
|
||||
public int waterStorage = 0;
|
||||
/**
|
||||
* Remaining duration of WeedEX
|
||||
* PRevents weed from growing and protects against (unimplemented) insects or similar stuff
|
||||
*/
|
||||
public int exStorage = 0;
|
||||
|
||||
/**
|
||||
* Crop humidity.
|
||||
* Ranges from 0 (dry) to 10 (humid).
|
||||
* Updates every couple of seconds or when an update is requested.
|
||||
*
|
||||
* @see #updateState()
|
||||
*/
|
||||
public abstract byte getHumidity();
|
||||
|
||||
/**
|
||||
* Get the crop's nutrient level.
|
||||
* Ranges from 0 (empty) to 10 (full).
|
||||
* Updates every couple of seconds or when an update is requested.
|
||||
*
|
||||
* @see #updateState()
|
||||
*/
|
||||
public abstract byte getNutrients();
|
||||
|
||||
/**
|
||||
* Get the crop's air quality.
|
||||
* Ranges from 0 (cluttered) to 10 (fresh).
|
||||
* Updates every couple of seconds or when an update is requested.
|
||||
*
|
||||
* @see #updateState()
|
||||
*
|
||||
* @return Crop air quality
|
||||
*/
|
||||
public abstract byte getAirQuality();
|
||||
|
||||
/**
|
||||
* Get the crop's light level.
|
||||
*
|
||||
* @return Crop light level
|
||||
*/
|
||||
public int getLightLevel()
|
||||
{
|
||||
return worldObj.getBlockLightValue(xCoord, yCoord, zCoord);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Pick the crop, removing and giving seeds for the plant.
|
||||
*
|
||||
* @param manual whether it was done by hand (not automated)
|
||||
* @return true if successfully picked
|
||||
*/
|
||||
public abstract boolean pick(boolean manual);
|
||||
|
||||
/**
|
||||
* Harvest the crop, turning it into gain and resetting its size.
|
||||
*
|
||||
* @param manual whether it one by hand (not automated)
|
||||
* @return true if successfully harvested
|
||||
*/
|
||||
public abstract boolean harvest(boolean manual);
|
||||
|
||||
/**
|
||||
* Fully clears the crop without dropping anything.
|
||||
*/
|
||||
public abstract void reset();
|
||||
|
||||
/**
|
||||
* Request a texture and lighting update.
|
||||
*/
|
||||
public abstract void updateState();
|
||||
|
||||
/**
|
||||
* Check if a block is under the farmland containing the crop.
|
||||
* Searches up to 2 blocks below the farmland or an air space, whichever appears first.
|
||||
*
|
||||
* @param block block to search
|
||||
* @return Whether the block was found
|
||||
*/
|
||||
public abstract boolean isBlockBelow(Block block);
|
||||
|
||||
/**
|
||||
* Generate plant seeds with the given parameters.
|
||||
*
|
||||
* @param plant plant ID
|
||||
* @param growth plant growth stat
|
||||
* @param gain plant gain stat
|
||||
* @param resis plant resistance stat
|
||||
* @param scan plant scan level
|
||||
* @return Plant seed item
|
||||
*/
|
||||
public abstract ItemStack generateSeeds(short plant, byte growth, byte gain, byte resis, byte scan);
|
||||
|
||||
/**
|
||||
* For internal usage only.
|
||||
*/
|
||||
public abstract void addLocal(String s1, String s2);
|
||||
|
||||
}
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
package railcraft.common.api.core.items;
|
||||
|
||||
/**
|
||||
* Any item that performs the same function as a crowbar should implement this interface.
|
||||
* Making a new crowbar item is as simple as implementing this empty interface.
|
||||
* Doing so will make all the blocks, tracks, and entities aware of that the item
|
||||
* should be treated identically to a crowbar.
|
||||
*
|
||||
* @author CovertJaguar <railcraft.wikispaces.com>
|
||||
*/
|
||||
public interface ICrowbar
|
||||
{
|
||||
|
||||
}
|
||||
|
|
@ -46,7 +46,7 @@ public class TileEntitySteamPiston extends TileEntityMachine implements IPacketR
|
|||
super.updateEntity();
|
||||
if(tickCount++ >=10)
|
||||
{tickCount = 0;
|
||||
|
||||
//this.pos += 1; if(pos >= 8){pos = 0;}
|
||||
//++tCount;if(tCount > 120){tCount = 0;}
|
||||
|
||||
int meta = worldObj.getBlockMetadata(xCoord, yCoord, zCoord);
|
||||
|
|
|
|||
Loading…
Reference in a new issue