();
+
+ /**
+ * Checks to see if the passed item/block already has aspects associated with it.
+ * @param id
+ * @param meta
+ * @return
+ */
+ public static boolean exists(Item item, int meta) {
+ AspectList tmp = ThaumcraftApi.objectTags.get(Arrays.asList(item,meta));
+ if (tmp==null) {
+ tmp = ThaumcraftApi.objectTags.get(Arrays.asList(item,OreDictionary.WILDCARD_VALUE));
+ if (meta==OreDictionary.WILDCARD_VALUE && tmp==null) {
+ int index=0;
+ do {
+ tmp = ThaumcraftApi.objectTags.get(Arrays.asList(item,index));
+ index++;
+ } while (index<16 && tmp==null);
+ }
+ if (tmp==null) return false;
+ }
+
+ return true;
+ }
+
+ /**
+ * Used to assign apsects to the given item/block. Here is an example of the declaration for cobblestone:
+ * ThaumcraftApi.registerObjectTag(new ItemStack(Blocks.cobblestone), (new AspectList()).add(Aspect.ENTROPY, 1).add(Aspect.EARTH, 1));
+ * @param item the item passed. Pass OreDictionary.WILDCARD_VALUE if all damage values of this item/block should have the same aspects
+ * @param aspects A ObjectTags object of the associated aspects
+ */
+ public static void registerObjectTag(ItemStack item, AspectList aspects) {
+ if (aspects==null) aspects=new AspectList();
+ try {
+ objectTags.put(Arrays.asList(item.getItem(),item.getItemDamage()), aspects);
+ } catch (Exception e) {}
+ }
+
+
+ /**
+ * Used to assign apsects to the given item/block. Here is an example of the declaration for cobblestone:
+ * ThaumcraftApi.registerObjectTag(new ItemStack(Blocks.cobblestone), new int[]{0,1}, (new AspectList()).add(Aspect.ENTROPY, 1).add(Aspect.EARTH, 1));
+ * @param item
+ * @param meta A range of meta values if you wish to lump several item meta's together as being the "same" item (i.e. stair orientations)
+ * @param aspects A ObjectTags object of the associated aspects
+ */
+ public static void registerObjectTag(ItemStack item, int[] meta, AspectList aspects) {
+ if (aspects==null) aspects=new AspectList();
+ try {
+ objectTags.put(Arrays.asList(item.getItem(),meta), aspects);
+ } catch (Exception e) {}
+ }
+
+ /**
+ * Used to assign apsects to the given ore dictionary item.
+ * @param oreDict the ore dictionary name
+ * @param aspects A ObjectTags object of the associated aspects
+ */
+ public static void registerObjectTag(String oreDict, AspectList aspects) {
+ if (aspects==null) aspects=new AspectList();
+ ArrayList ores = OreDictionary.getOres(oreDict);
+ if (ores!=null && ores.size()>0) {
+ for (ItemStack ore:ores) {
+ try {
+ objectTags.put(Arrays.asList(ore.getItem(), ore.getItemDamage()), aspects);
+ } catch (Exception e) {}
+ }
+ }
+ }
+
+ /**
+ * Used to assign aspects to the given item/block.
+ * Attempts to automatically generate aspect tags by checking registered recipes.
+ * Here is an example of the declaration for pistons:
+ * ThaumcraftApi.registerComplexObjectTag(new ItemStack(Blocks.cobblestone), (new AspectList()).add(Aspect.MECHANISM, 2).add(Aspect.MOTION, 4));
+ * @param item, pass OreDictionary.WILDCARD_VALUE to meta if all damage values of this item/block should have the same aspects
+ * @param aspects A ObjectTags object of the associated aspects
+ */
+ public static void registerComplexObjectTag(ItemStack item, AspectList aspects ) {
+ if (!exists(item.getItem(),item.getItemDamage())) {
+ AspectList tmp = ThaumcraftApiHelper.generateTags(item.getItem(), item.getItemDamage());
+ if (tmp != null && tmp.size()>0) {
+ for(Aspect tag:tmp.getAspects()) {
+ aspects.add(tag, tmp.getAmount(tag));
+ }
+ }
+ registerObjectTag(item,aspects);
+ } else {
+ AspectList tmp = ThaumcraftApiHelper.getObjectAspects(item);
+ for(Aspect tag:aspects.getAspects()) {
+ tmp.merge(tag, tmp.getAmount(tag));
+ }
+ registerObjectTag(item,tmp);
+ }
+ }
+
+ //WARP ///////////////////////////////////////////////////////////////////////////////////////
+ private static HashMap warpMap = new HashMap();
+
+ /**
+ * This method is used to determine how much warp is gained if the item is crafted
+ * @param craftresult The item crafted
+ * @param amount how much warp is gained
+ */
+ public static void addWarpToItem(ItemStack craftresult, int amount) {
+ warpMap.put(Arrays.asList(craftresult.getItem(),craftresult.getItemDamage()),amount);
+ }
+
+ /**
+ * This method is used to determine how much warp is gained if the sent item is crafted
+ * @param in The item crafted
+ * @param amount how much warp is gained
+ */
+ public static void addWarpToResearch(String research, int amount) {
+ warpMap.put(research, amount);
+ }
+
+ /**
+ * Returns how much warp is gained from the item or research passed in
+ * @param in itemstack or string
+ * @return how much warp it will give
+ */
+ public static int getWarp(Object in) {
+ if (in==null) return 0;
+ if (in instanceof ItemStack && warpMap.containsKey(Arrays.asList(((ItemStack)in).getItem(),((ItemStack)in).getItemDamage()))) {
+ return warpMap.get(Arrays.asList(((ItemStack)in).getItem(),((ItemStack)in).getItemDamage()));
+ } else
+ if (in instanceof String && warpMap.containsKey((String)in)) {
+ return warpMap.get((String)in);
+ }
+ return 0;
+ }
+
+ //CROPS //////////////////////////////////////////////////////////////////////////////////////////
+
+ /**
+ * To define mod crops you need to use FMLInterModComms in your @Mod.Init method.
+ * There are two 'types' of crops you can add. Standard crops and clickable crops.
+ *
+ * Standard crops work like normal vanilla crops - they grow until a certain metadata
+ * value is reached and you harvest them by destroying the block and collecting the blocks.
+ * You need to create and ItemStack that tells the golem what block id and metadata represents
+ * the crop when fully grown. Sending a metadata of [OreDictionary.WILDCARD_VALUE] will mean the metadata won't get
+ * checked.
+ * Example for vanilla wheat:
+ * FMLInterModComms.sendMessage("Thaumcraft", "harvestStandardCrop", new ItemStack(Block.crops,1,7));
+ *
+ * Clickable crops are crops that you right click to gather their bounty instead of destroying them.
+ * As for standard crops, you need to create and ItemStack that tells the golem what block id
+ * and metadata represents the crop when fully grown. The golem will trigger the blocks onBlockActivated method.
+ * Sending a metadata of [OreDictionary.WILDCARD_VALUE] will mean the metadata won't get checked.
+ * Example (this will technically do nothing since clicking wheat does nothing, but you get the idea):
+ * FMLInterModComms.sendMessage("Thaumcraft", "harvestClickableCrop", new ItemStack(Block.crops,1,7));
+ *
+ * Stacked crops (like reeds) are crops that you wish the bottom block should remain after harvesting.
+ * As for standard crops, you need to create and ItemStack that tells the golem what block id
+ * and metadata represents the crop when fully grown. Sending a metadata of [OreDictionary.WILDCARD_VALUE] will mean the actualy md won't get
+ * checked. If it has the order upgrade it will only harvest if the crop is more than one block high.
+ * Example:
+ * FMLInterModComms.sendMessage("Thaumcraft", "harvestStackedCrop", new ItemStack(Block.reed,1,7));
+ */
+
+ //NATIVE CLUSTERS //////////////////////////////////////////////////////////////////////////////////
+
+ /**
+ * You can define certain ores that will have a chance to produce native clusters via FMLInterModComms
+ * in your @Mod.Init method using the "nativeCluster" string message.
+ * The format should be:
+ * "[ore item/block id],[ore item/block metadata],[cluster item/block id],[cluster item/block metadata],[chance modifier float]"
+ *
+ * NOTE: The chance modifier is a multiplier applied to the default chance for that cluster to be produced (default 27.5% for a pickaxe of the core)
+ *
+ * Example for vanilla iron ore to produce one of my own native iron clusters (assuming default id's) at double the default chance:
+ * FMLInterModComms.sendMessage("Thaumcraft", "nativeCluster","15,0,25016,16,2.0");
+ */
+
+ //LAMP OF GROWTH BLACKLIST ///////////////////////////////////////////////////////////////////////////
+ /**
+ * You can blacklist crops that should not be effected by the Lamp of Growth via FMLInterModComms
+ * in your @Mod.Init method using the "lampBlacklist" itemstack message.
+ * Sending a metadata of [OreDictionary.WILDCARD_VALUE] will mean the metadata won't get checked.
+ * Example for vanilla wheat:
+ * FMLInterModComms.sendMessage("Thaumcraft", "lampBlacklist", new ItemStack(Block.crops,1,OreDictionary.WILDCARD_VALUE));
+ */
+
+ //DIMENSION BLACKLIST ///////////////////////////////////////////////////////////////////////////
+ /**
+ * You can blacklist a dimension to not spawn certain thaumcraft features
+ * in your @Mod.Init method using the "dimensionBlacklist" string message in the format "[dimension]:[level]"
+ * The level values are as follows:
+ * [0] stop all tc spawning and generation
+ * [1] allow ore and node generation
+ * [2] allow mob spawning
+ * [3] allow ore and node gen + mob spawning
+ * Example:
+ * FMLInterModComms.sendMessage("Thaumcraft", "dimensionBlacklist", "15:1");
+ */
+
+ //BIOME BLACKLIST ///////////////////////////////////////////////////////////////////////////
+ /**
+ * You can blacklist a biome to not spawn certain thaumcraft features
+ * in your @Mod.Init method using the "biomeBlacklist" string message in the format "[biome id]:[level]"
+ * The level values are as follows:
+ * [0] stop all tc spawning and generation
+ * [1] allow ore and node generation
+ * [2] allow mob spawning
+ * [3] allow ore and node gen + mob spawning
+ * Example:
+ * FMLInterModComms.sendMessage("Thaumcraft", "biomeBlacklist", "180:2");
+ */
+}
diff --git a/src-backup/api/java/thaumcraft/api/ThaumcraftApiHelper.java b/src-backup/api/java/thaumcraft/api/ThaumcraftApiHelper.java
new file mode 100644
index 00000000..a4b6d42a
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/ThaumcraftApiHelper.java
@@ -0,0 +1,269 @@
+package thaumcraft.api;
+
+import java.lang.reflect.Method;
+import java.util.HashMap;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.oredict.OreDictionary;
+import thaumcraft.api.aspects.Aspect;
+import thaumcraft.api.aspects.AspectList;
+import thaumcraft.api.aspects.IEssentiaTransport;
+import cpw.mods.fml.common.FMLLog;
+
+public class ThaumcraftApiHelper {
+
+ public static AspectList cullTags(AspectList temp) {
+ AspectList temp2 = new AspectList();
+ for (Aspect tag:temp.getAspects()) {
+ if (tag!=null)
+ temp2.add(tag, temp.getAmount(tag));
+ }
+ while (temp2!=null && temp2.size()>10) {
+ Aspect lowest = null;
+ int low = Integer.MAX_VALUE;
+ for (Aspect tag:temp2.getAspects()) {
+ if (tag==null) continue;
+ if (temp2.getAmount(tag) allAspects= new HashMap();
+ private static HashMap allCompoundAspects= new HashMap();
+
+ public static AspectList getAllAspects(int amount) {
+ if (allAspects.get(amount)==null) {
+ AspectList al = new AspectList();
+ for (Aspect aspect:Aspect.aspects.values()) {
+ al.add(aspect, amount);
+ }
+ allAspects.put(amount, al);
+ }
+ return allAspects.get(amount);
+ }
+
+ public static AspectList getAllCompoundAspects(int amount) {
+ if (allCompoundAspects.get(amount)==null) {
+ AspectList al = new AspectList();
+ for (Aspect aspect:Aspect.getCompoundAspects()) {
+ al.add(aspect, amount);
+ }
+ allCompoundAspects.put(amount, al);
+ }
+ return allCompoundAspects.get(amount);
+ }
+
+ static Method consumeVisFromWand;
+ /**
+ * Use to subtract vis from a wand for most operations
+ * Wands store vis differently so "real" vis costs need to be multiplied by 100 before calling this method
+ * @param wand the wand itemstack
+ * @param player the player using the wand
+ * @param cost the cost of the operation.
+ * @param doit actually subtract the vis from the wand if true - if false just simulate the result
+ * @param crafting is this a crafting operation or not - if
+ * false then things like frugal and potency will apply to the costs
+ * @return was the vis successfully subtracted
+ */
+ public static boolean consumeVisFromWand(ItemStack wand, EntityPlayer player,
+ AspectList cost, boolean doit, boolean crafting) {
+ boolean ot = false;
+ try {
+ if(consumeVisFromWand == null) {
+ Class fake = Class.forName("thaumcraft.common.items.wands.ItemWandCasting");
+ consumeVisFromWand = fake.getMethod("consumeAllVis",
+ ItemStack.class, EntityPlayer.class, AspectList.class, boolean.class, boolean.class);
+ }
+ ot = (Boolean) consumeVisFromWand.invoke(
+ consumeVisFromWand.getDeclaringClass().cast(wand.getItem()), wand, player, cost, doit, crafting);
+ } catch(Exception ex) {
+ FMLLog.warning("[Thaumcraft API] Could not invoke thaumcraft.common.items.wands.ItemWandCasting method consumeAllVis");
+ }
+ return ot;
+ }
+
+ static Method consumeVisFromWandCrafting;
+ /**
+ * Subtract vis for use by a crafting mechanic. Costs are calculated slightly
+ * differently and things like the frugal enchant is ignored
+ * Must NOT be multiplied by 100 - send the actual vis cost
+ * @param wand the wand itemstack
+ * @param player the player using the wand
+ * @param cost the cost of the operation.
+ * @param doit actually subtract the vis from the wand if true - if false just simulate the result
+ * @return was the vis successfully subtracted
+ */
+ public static boolean consumeVisFromWandCrafting(ItemStack wand, EntityPlayer player,
+ AspectList cost, boolean doit) {
+ boolean ot = false;
+ try {
+ if(consumeVisFromWandCrafting == null) {
+ Class fake = Class.forName("thaumcraft.common.items.wands.ItemWandCasting");
+ consumeVisFromWandCrafting = fake.getMethod("consumeAllVisCrafting",
+ ItemStack.class, EntityPlayer.class, AspectList.class, boolean.class);
+ }
+ ot = (Boolean) consumeVisFromWandCrafting.invoke(
+ consumeVisFromWandCrafting.getDeclaringClass().cast(wand.getItem()), wand, player, cost, doit);
+ } catch(Exception ex) {
+ FMLLog.warning("[Thaumcraft API] Could not invoke thaumcraft.common.items.wands.ItemWandCasting method consumeAllVisCrafting");
+ }
+ return ot;
+ }
+
+ static Method consumeVisFromInventory;
+ /**
+ * Subtract vis from a wand the player is carrying. Works like consumeVisFromWand in that actual vis
+ * costs should be multiplied by 100. The costs are handled like crafting however and things like
+ * frugal don't effect them
+ * @param player the player using the wand
+ * @param cost the cost of the operation.
+ * @return was the vis successfully subtracted
+ */
+ public static boolean consumeVisFromInventory(EntityPlayer player, AspectList cost) {
+ boolean ot = false;
+ try {
+ if(consumeVisFromInventory == null) {
+ Class fake = Class.forName("thaumcraft.common.items.wands.WandManager");
+ consumeVisFromInventory = fake.getMethod("consumeVisFromInventory",
+ EntityPlayer.class, AspectList.class);
+ }
+ ot = (Boolean) consumeVisFromInventory.invoke(null, player, cost);
+ } catch(Exception ex) {
+ FMLLog.warning("[Thaumcraft API] Could not invoke thaumcraft.common.items.wands.WandManager method consumeVisFromInventory");
+ }
+ return ot;
+ }
+}
diff --git a/src-backup/api/java/thaumcraft/api/TileThaumcraft.java b/src-backup/api/java/thaumcraft/api/TileThaumcraft.java
new file mode 100644
index 00000000..56ccae87
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/TileThaumcraft.java
@@ -0,0 +1,63 @@
+package thaumcraft.api;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.network.NetworkManager;
+import net.minecraft.network.Packet;
+import net.minecraft.network.play.server.S35PacketUpdateTileEntity;
+import net.minecraft.tileentity.TileEntity;
+
+/**
+ *
+ * @author azanor
+ *
+ * Custom tile entity class I use for most of my tile entities. Setup in such a way that only
+ * the nbt data within readCustomNBT / writeCustomNBT will be sent to the client when the tile
+ * updates. Apart from all the normal TE data that gets sent that is.
+ *
+ */
+public class TileThaumcraft extends TileEntity {
+
+ //NBT stuff
+
+ @Override
+ public void readFromNBT(NBTTagCompound nbttagcompound)
+ {
+ super.readFromNBT(nbttagcompound);
+ readCustomNBT(nbttagcompound);
+ }
+
+ public void readCustomNBT(NBTTagCompound nbttagcompound)
+ {
+ //TODO
+ }
+
+ @Override
+ public void writeToNBT(NBTTagCompound nbttagcompound)
+ {
+ super.writeToNBT(nbttagcompound);
+ writeCustomNBT(nbttagcompound);
+ }
+
+ public void writeCustomNBT(NBTTagCompound nbttagcompound)
+ {
+ //TODO
+ }
+
+ //Client Packet stuff
+ @Override
+ public Packet getDescriptionPacket() {
+ NBTTagCompound nbttagcompound = new NBTTagCompound();
+ this.writeCustomNBT(nbttagcompound);
+ return new S35PacketUpdateTileEntity(this.xCoord, this.yCoord, this.zCoord, -999, nbttagcompound);
+ }
+
+ @Override
+ public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity pkt) {
+ super.onDataPacket(net, pkt);
+ this.readCustomNBT(pkt.func_148857_g());
+ }
+
+
+
+
+}
diff --git a/src-backup/api/java/thaumcraft/api/WorldCoordinates.java b/src-backup/api/java/thaumcraft/api/WorldCoordinates.java
new file mode 100644
index 00000000..6c620af5
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/WorldCoordinates.java
@@ -0,0 +1,117 @@
+package thaumcraft.api;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+
+public class WorldCoordinates implements Comparable
+{
+ public int x;
+
+ /** the y coordinate */
+ public int y;
+
+ /** the z coordinate */
+ public int z;
+
+ public int dim;
+
+ public WorldCoordinates() {}
+
+ public WorldCoordinates(int par1, int par2, int par3, int d)
+ {
+ this.x = par1;
+ this.y = par2;
+ this.z = par3;
+ this.dim = d;
+ }
+
+ public WorldCoordinates(TileEntity tile)
+ {
+ this.x = tile.xCoord;
+ this.y = tile.yCoord;
+ this.z = tile.zCoord;
+ this.dim = tile.getWorldObj().provider.dimensionId;
+ }
+
+ public WorldCoordinates(WorldCoordinates par1ChunkCoordinates)
+ {
+ this.x = par1ChunkCoordinates.x;
+ this.y = par1ChunkCoordinates.y;
+ this.z = par1ChunkCoordinates.z;
+ this.dim = par1ChunkCoordinates.dim;
+ }
+
+ public boolean equals(Object par1Obj)
+ {
+ if (!(par1Obj instanceof WorldCoordinates))
+ {
+ return false;
+ }
+ else
+ {
+ WorldCoordinates coordinates = (WorldCoordinates)par1Obj;
+ return this.x == coordinates.x && this.y == coordinates.y && this.z == coordinates.z && this.dim == coordinates.dim ;
+ }
+ }
+
+ public int hashCode()
+ {
+ return this.x + this.y << 8 + this.z << 16 + this.dim << 24;
+ }
+
+ /**
+ * Compare the coordinate with another coordinate
+ */
+ public int compareWorldCoordinate(WorldCoordinates par1)
+ {
+ return this.dim == par1.dim ? (
+ this.y == par1.y ? (this.z == par1.z ? this.x - par1.x : this.z - par1.z) : this.y - par1.y) : -1;
+ }
+
+ public void set(int par1, int par2, int par3, int d)
+ {
+ this.x = par1;
+ this.y = par2;
+ this.z = par3;
+ this.dim = d;
+ }
+
+ /**
+ * Returns the squared distance between this coordinates and the coordinates given as argument.
+ */
+ public float getDistanceSquared(int par1, int par2, int par3)
+ {
+ float f = (float)(this.x - par1);
+ float f1 = (float)(this.y - par2);
+ float f2 = (float)(this.z - par3);
+ return f * f + f1 * f1 + f2 * f2;
+ }
+
+ /**
+ * Return the squared distance between this coordinates and the ChunkCoordinates given as argument.
+ */
+ public float getDistanceSquaredToWorldCoordinates(WorldCoordinates par1ChunkCoordinates)
+ {
+ return this.getDistanceSquared(par1ChunkCoordinates.x, par1ChunkCoordinates.y, par1ChunkCoordinates.z);
+ }
+
+ public int compareTo(Object par1Obj)
+ {
+ return this.compareWorldCoordinate((WorldCoordinates)par1Obj);
+ }
+
+ public void readNBT(NBTTagCompound nbt) {
+ this.x = nbt.getInteger("w_x");
+ this.y = nbt.getInteger("w_y");
+ this.z = nbt.getInteger("w_z");
+ this.dim = nbt.getInteger("w_d");
+ }
+
+ public void writeNBT(NBTTagCompound nbt) {
+ nbt.setInteger("w_x",x);
+ nbt.setInteger("w_y",y);
+ nbt.setInteger("w_z",z);
+ nbt.setInteger("w_d",dim);
+ }
+
+}
diff --git a/src-backup/api/java/thaumcraft/api/aspects/Aspect.java b/src-backup/api/java/thaumcraft/api/aspects/Aspect.java
new file mode 100644
index 00000000..3c33a4a7
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/aspects/Aspect.java
@@ -0,0 +1,201 @@
+package thaumcraft.api.aspects;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.LinkedHashMap;
+
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.StatCollector;
+
+import org.apache.commons.lang3.text.WordUtils;
+
+public class Aspect {
+
+ String tag;
+ Aspect[] components;
+ int color;
+ private String chatcolor;
+ ResourceLocation image;
+ int blend;
+
+ /**
+ * Use this constructor to register your own aspects.
+ * @param tag the key that will be used to reference this aspect, as well as its latin display name
+ * @param color color to display the tag in
+ * @param components the aspects this one is formed from
+ * @param image ResourceLocation pointing to a 32x32 icon of the aspect
+ * @param blend GL11 blendmode (1 or 771). Used for rendering nodes. Default is 1
+ */
+ public Aspect(String tag, int color, Aspect[] components, ResourceLocation image, int blend) {
+ if (aspects.containsKey(tag)) throw new IllegalArgumentException(tag+" already registered!");
+ this.tag = tag;
+ this.components = components;
+ this.color = color;
+ this.image = image;
+ this.blend = blend;
+ aspects.put(tag, this);
+ }
+
+ /**
+ * Shortcut constructor I use for the default aspects - you shouldn't be using this.
+ */
+ public Aspect(String tag, int color, Aspect[] components) {
+ this(tag,color,components,new ResourceLocation("thaumcraft","textures/aspects/"+tag.toLowerCase()+".png"),1);
+ }
+
+ /**
+ * Shortcut constructor I use for the default aspects - you shouldn't be using this.
+ */
+ public Aspect(String tag, int color, Aspect[] components, int blend) {
+ this(tag,color,components,new ResourceLocation("thaumcraft","textures/aspects/"+tag.toLowerCase()+".png"),blend);
+ }
+
+ /**
+ * Shortcut constructor I use for the primal aspects -
+ * you shouldn't use this as making your own primal aspects will break all the things.
+ */
+ public Aspect(String tag, int color, String chatcolor, int blend) {
+ this(tag,color,(Aspect[])null, blend);
+ this.setChatcolor(chatcolor);
+ }
+
+ public int getColor() {
+ return color;
+ }
+
+ public String getName() {
+ return WordUtils.capitalizeFully(tag);
+ }
+
+ public String getLocalizedDescription() {
+ return StatCollector.translateToLocal("tc.aspect."+tag);
+ }
+
+ public String getTag() {
+ return tag;
+ }
+
+ public void setTag(String tag) {
+ this.tag = tag;
+ }
+
+ public Aspect[] getComponents() {
+ return components;
+ }
+
+ public void setComponents(Aspect[] components) {
+ this.components = components;
+ }
+
+ public ResourceLocation getImage() {
+ return image;
+ }
+
+ public static Aspect getAspect(String tag) {
+ return aspects.get(tag);
+ }
+
+ public int getBlend() {
+ return blend;
+ }
+
+ public void setBlend(int blend) {
+ this.blend = blend;
+ }
+
+ public boolean isPrimal() {
+ return getComponents()==null || getComponents().length!=2;
+ }
+
+ ///////////////////////////////
+ public static ArrayList getPrimalAspects() {
+ ArrayList primals = new ArrayList();
+ Collection pa = aspects.values();
+ for (Aspect aspect:pa) {
+ if (aspect.isPrimal()) primals.add(aspect);
+ }
+ return primals;
+ }
+
+ public static ArrayList getCompoundAspects() {
+ ArrayList compounds = new ArrayList();
+ Collection pa = aspects.values();
+ for (Aspect aspect:pa) {
+ if (!aspect.isPrimal()) compounds.add(aspect);
+ }
+ return compounds;
+ }
+
+ public String getChatcolor() {
+ return chatcolor;
+ }
+
+ public void setChatcolor(String chatcolor) {
+ this.chatcolor = chatcolor;
+ }
+
+
+ ///////////////////////////////
+ public static LinkedHashMap aspects = new LinkedHashMap();
+
+ //PRIMAL
+ public static final Aspect AIR = new Aspect("aer",0xffff7e,"e",1);
+ public static final Aspect EARTH = new Aspect("terra",0x56c000,"2",1);
+ public static final Aspect FIRE = new Aspect("ignis",0xff5a01,"c",1);
+ public static final Aspect WATER = new Aspect("aqua",0x3cd4fc,"3",1);
+ public static final Aspect ORDER = new Aspect("ordo",0xd5d4ec,"7",1);
+ public static final Aspect ENTROPY = new Aspect("perditio",0x404040,"8",771);
+
+ //SECONDARY
+ public static final Aspect VOID = new Aspect("vacuos",0x888888, new Aspect[] {AIR, ENTROPY},771);
+ public static final Aspect LIGHT = new Aspect("lux",0xfff663, new Aspect[] {AIR, FIRE});
+ public static final Aspect WEATHER = new Aspect("tempestas",0xFFFFFF, new Aspect[] {AIR, WATER});
+ public static final Aspect MOTION = new Aspect("motus",0xcdccf4, new Aspect[] {AIR, ORDER});
+ public static final Aspect COLD = new Aspect("gelum",0xe1ffff, new Aspect[] {FIRE, ENTROPY});
+ public static final Aspect CRYSTAL = new Aspect("vitreus",0x80ffff, new Aspect[] {EARTH, ORDER});
+ public static final Aspect LIFE = new Aspect("victus",0xde0005, new Aspect[] {WATER, EARTH});
+ public static final Aspect POISON = new Aspect("venenum",0x89f000, new Aspect[] {WATER, ENTROPY});
+ public static final Aspect ENERGY = new Aspect("potentia",0xc0ffff, new Aspect[] {ORDER, FIRE});
+ public static final Aspect EXCHANGE = new Aspect("permutatio",0x578357, new Aspect[] {ENTROPY, ORDER});
+// public static final Aspect ?? = new Aspect("??",0xcdccf4, new Aspect[] {AIR, EARTH});
+// public static final Aspect ?? = new Aspect("??",0xcdccf4, new Aspect[] {FIRE, EARTH});
+// public static final Aspect ?? = new Aspect("??",0xcdccf4, new Aspect[] {FIRE, WATER});
+// public static final Aspect ?? = new Aspect("??",0xcdccf4, new Aspect[] {ORDER, WATER});
+// public static final Aspect ?? = new Aspect("??",0xcdccf4, new Aspect[] {EARTH, ENTROPY});
+
+ //TERTIARY
+ public static final Aspect METAL = new Aspect("metallum",0xb5b5cd, new Aspect[] {EARTH, CRYSTAL});
+ public static final Aspect DEATH = new Aspect("mortuus",0x887788, new Aspect[] {LIFE, ENTROPY});
+ public static final Aspect FLIGHT = new Aspect("volatus",0xe7e7d7, new Aspect[] {AIR, MOTION});
+ public static final Aspect DARKNESS = new Aspect("tenebrae",0x222222, new Aspect[] {VOID, LIGHT});
+ public static final Aspect SOUL = new Aspect("spiritus",0xebebfb, new Aspect[] {LIFE, DEATH});
+ public static final Aspect HEAL = new Aspect("sano",0xff2f34, new Aspect[] {LIFE, ORDER});
+ public static final Aspect TRAVEL = new Aspect("iter",0xe0585b, new Aspect[] {MOTION, EARTH});
+ public static final Aspect ELDRITCH = new Aspect("alienis",0x805080, new Aspect[] {VOID, DARKNESS});
+ public static final Aspect MAGIC = new Aspect("praecantatio",0x9700c0, new Aspect[] {VOID, ENERGY});
+ public static final Aspect AURA = new Aspect("auram",0xffc0ff, new Aspect[] {MAGIC, AIR});
+ public static final Aspect TAINT = new Aspect("vitium",0x800080, new Aspect[] {MAGIC, ENTROPY});
+ public static final Aspect SLIME = new Aspect("limus",0x01f800, new Aspect[] {LIFE, WATER});
+ public static final Aspect PLANT = new Aspect("herba",0x01ac00, new Aspect[] {LIFE, EARTH});
+ public static final Aspect TREE = new Aspect("arbor",0x876531, new Aspect[] {AIR, PLANT});
+ public static final Aspect BEAST = new Aspect("bestia",0x9f6409, new Aspect[] {MOTION, LIFE});
+ public static final Aspect FLESH = new Aspect("corpus",0xee478d, new Aspect[] {DEATH, BEAST});
+ public static final Aspect UNDEAD = new Aspect("exanimis",0x3a4000, new Aspect[] {MOTION, DEATH});
+ public static final Aspect MIND = new Aspect("cognitio",0xffc2b3, new Aspect[] {EARTH, SOUL});
+ public static final Aspect SENSES = new Aspect("sensus",0x0fd9ff, new Aspect[] {AIR, SOUL});
+ public static final Aspect MAN = new Aspect("humanus",0xffd7c0, new Aspect[] {BEAST, MIND});
+ public static final Aspect CROP = new Aspect("messis",0xe1b371, new Aspect[] {PLANT, MAN});
+ public static final Aspect MINE = new Aspect("perfodio",0xdcd2d8, new Aspect[] {MAN, EARTH});
+ public static final Aspect TOOL = new Aspect("instrumentum",0x4040ee, new Aspect[] {MAN, ORDER});
+ public static final Aspect HARVEST = new Aspect("meto",0xeead82, new Aspect[] {CROP, TOOL});
+ public static final Aspect WEAPON = new Aspect("telum",0xc05050, new Aspect[] {TOOL, ENTROPY});
+ public static final Aspect ARMOR = new Aspect("tutamen",0x00c0c0, new Aspect[] {TOOL, EARTH});
+ public static final Aspect HUNGER = new Aspect("fames",0x9a0305, new Aspect[] {LIFE, VOID});
+ public static final Aspect GREED = new Aspect("lucrum",0xe6be44, new Aspect[] {MAN, HUNGER});
+ public static final Aspect CRAFT = new Aspect("fabrico",0x809d80, new Aspect[] {MAN, TOOL});
+ public static final Aspect CLOTH = new Aspect("pannus",0xeaeac2, new Aspect[] {TOOL, BEAST});
+ public static final Aspect MECHANISM = new Aspect("machina",0x8080a0, new Aspect[] {MOTION, TOOL});
+ public static final Aspect TRAP = new Aspect("vinculum",0x9a8080, new Aspect[] {MOTION, ENTROPY});
+
+
+}
diff --git a/src-backup/api/java/thaumcraft/api/aspects/AspectList.java b/src-backup/api/java/thaumcraft/api/aspects/AspectList.java
new file mode 100644
index 00000000..6b9dfcef
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/aspects/AspectList.java
@@ -0,0 +1,256 @@
+package thaumcraft.api.aspects;
+
+import java.io.Serializable;
+import java.util.LinkedHashMap;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import thaumcraft.api.ThaumcraftApiHelper;
+
+public class AspectList implements Serializable {
+
+ public LinkedHashMap aspects = new LinkedHashMap();//aspects associated with this object
+
+
+ /**
+ * this creates a new aspect list with preloaded values based off the aspects of the given item.
+ * @param the itemstack of the given item
+ */
+ public AspectList(ItemStack stack) {
+ try {
+ AspectList temp = ThaumcraftApiHelper.getObjectAspects(stack);
+ if (temp!=null)
+ for (Aspect tag:temp.getAspects()) {
+ add(tag,temp.getAmount(tag));
+ }
+ } catch (Exception e) {}
+ }
+
+ public AspectList() {
+ }
+
+ public AspectList copy() {
+ AspectList out = new AspectList();
+ for (Aspect a:this.getAspects())
+ out.add(a, this.getAmount(a));
+ return out;
+ }
+
+ /**
+ * @return the amount of different aspects in this collection
+ */
+ public int size() {
+ return aspects.size();
+ }
+
+ /**
+ * @return the amount of total vis in this collection
+ */
+ public int visSize() {
+ int q = 0;
+
+ for (Aspect as:aspects.keySet()) {
+ q+=this.getAmount(as);
+ }
+
+ return q;
+ }
+
+ /**
+ * @return an array of all the aspects in this collection
+ */
+ public Aspect[] getAspects() {
+ Aspect[] q = new Aspect[1];
+ return aspects.keySet().toArray(q);
+ }
+
+ /**
+ * @return an array of all the aspects in this collection
+ */
+ public Aspect[] getPrimalAspects() {
+ AspectList t = new AspectList();
+ for (Aspect as:aspects.keySet()) {
+ if (as.isPrimal()) {
+ t.add(as,1);
+ }
+ }
+ Aspect[] q = new Aspect[1];
+ return t.aspects.keySet().toArray(q);
+ }
+
+ /**
+ * @return an array of all the aspects in this collection sorted by name
+ */
+ public Aspect[] getAspectsSorted() {
+ try {
+ Aspect[] out = aspects.keySet().toArray(new Aspect[1]);
+ boolean change=false;
+ do {
+ change=false;
+ for(int a=0;a0) {
+ out[a] = e2;
+ out[a+1] = e1;
+ change = true;
+ break;
+ }
+ }
+ } while (change==true);
+ return out;
+ } catch (Exception e) {
+ return this.getAspects();
+ }
+ }
+
+ /**
+ * @return an array of all the aspects in this collection sorted by amount
+ */
+ public Aspect[] getAspectsSortedAmount() {
+ try {
+ Aspect[] out = aspects.keySet().toArray(new Aspect[1]);
+ boolean change=false;
+ do {
+ change=false;
+ for(int a=0;a0 && e2>0 && e2>e1) {
+ Aspect ea = out[a];
+ Aspect eb = out[a+1];
+ out[a] = eb;
+ out[a+1] = ea;
+ change = true;
+ break;
+ }
+ }
+ } while (change==true);
+ return out;
+ } catch (Exception e) {
+ return this.getAspects();
+ }
+ }
+
+ /**
+ * @param key
+ * @return the amount associated with the given aspect in this collection
+ */
+ public int getAmount(Aspect key) {
+ return aspects.get(key)==null?0:aspects.get(key);
+ }
+
+ /**
+ * Reduces the amount of an aspect in this collection by the given amount.
+ * @param key
+ * @param amount
+ * @return
+ */
+ public boolean reduce(Aspect key, int amount) {
+ if (getAmount(key)>=amount) {
+ int am = getAmount(key)-amount;
+ aspects.put(key, am);
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Reduces the amount of an aspect in this collection by the given amount.
+ * If reduced to 0 or less the aspect will be removed completely.
+ * @param key
+ * @param amount
+ * @return
+ */
+ public AspectList remove(Aspect key, int amount) {
+ int am = getAmount(key)-amount;
+ if (am<=0) aspects.remove(key); else
+ this.aspects.put(key, am);
+ return this;
+ }
+
+ /**
+ * Simply removes the aspect from the list
+ * @param key
+ * @param amount
+ * @return
+ */
+ public AspectList remove(Aspect key) {
+ aspects.remove(key);
+ return this;
+ }
+
+ /**
+ * Adds this aspect and amount to the collection.
+ * If the aspect exists then its value will be increased by the given amount.
+ * @param aspect
+ * @param amount
+ * @return
+ */
+ public AspectList add(Aspect aspect, int amount) {
+ if (this.aspects.containsKey(aspect)) {
+ int oldamount = this.aspects.get(aspect);
+ amount+=oldamount;
+ }
+ this.aspects.put( aspect, amount );
+ return this;
+ }
+
+
+ /**
+ * Adds this aspect and amount to the collection.
+ * If the aspect exists then only the highest of the old or new amount will be used.
+ * @param aspect
+ * @param amount
+ * @return
+ */
+ public AspectList merge(Aspect aspect, int amount) {
+ if (this.aspects.containsKey(aspect)) {
+ int oldamount = this.aspects.get(aspect);
+ if (amount0?aspects:null;
+ }
+ return null;
+ }
+
+ @Override
+ public void setAspects(ItemStack itemstack, AspectList aspects) {
+ if (!itemstack.hasTagCompound()) itemstack.setTagCompound(new NBTTagCompound());
+ aspects.writeToNBT(itemstack.getTagCompound());
+ }
+*/
\ No newline at end of file
diff --git a/src-backup/api/java/thaumcraft/api/aspects/IEssentiaTransport.java b/src-backup/api/java/thaumcraft/api/aspects/IEssentiaTransport.java
new file mode 100644
index 00000000..fecbc160
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/aspects/IEssentiaTransport.java
@@ -0,0 +1,100 @@
+package thaumcraft.api.aspects;
+
+import net.minecraftforge.common.util.ForgeDirection;
+
+
+/**
+ * @author Azanor
+ * This interface is used by tiles that use or transport vis.
+ * Only tiles that implement this interface will be able to connect to vis conduits or other thaumic devices
+ */
+public interface IEssentiaTransport {
+ /**
+ * Is this tile able to connect to other vis users/sources on the specified side?
+ * @param face
+ * @return
+ */
+ public boolean isConnectable(ForgeDirection face);
+
+ /**
+ * Is this side used to input essentia?
+ * @param face
+ * @return
+ */
+ boolean canInputFrom(ForgeDirection face);
+
+ /**
+ * Is this side used to output essentia?
+ * @param face
+ * @return
+ */
+ boolean canOutputTo(ForgeDirection face);
+
+ /**
+ * Sets the amount of suction this block will apply
+ * @param suction
+ */
+ public void setSuction(Aspect aspect, int amount);
+
+ /**
+ * Returns the type of suction this block is applying.
+ * @param loc
+ * the location from where the suction is being checked
+ * @return
+ * a return type of null indicates the suction is untyped and the first thing available will be drawn
+ */
+ public Aspect getSuctionType(ForgeDirection face);
+
+ /**
+ * Returns the strength of suction this block is applying.
+ * @param loc
+ * the location from where the suction is being checked
+ * @return
+ */
+ public int getSuctionAmount(ForgeDirection face);
+
+ /**
+ * remove the specified amount of essentia from this transport tile
+ * @return how much was actually taken
+ */
+ public int takeEssentia(Aspect aspect, int amount, ForgeDirection face);
+
+ /**
+ * add the specified amount of essentia to this transport tile
+ * @return how much was actually added
+ */
+ public int addEssentia(Aspect aspect, int amount, ForgeDirection face);
+
+ /**
+ * What type of essentia this contains
+ * @param face
+ * @return
+ */
+ public Aspect getEssentiaType(ForgeDirection face);
+
+ /**
+ * How much essentia this block contains
+ * @param face
+ * @return
+ */
+ public int getEssentiaAmount(ForgeDirection face);
+
+
+
+ /**
+ * Essentia will not be drawn from this container unless the suction exceeds this amount.
+ * @return the amount
+ */
+ public int getMinimumSuction();
+
+ /**
+ * Return true if you want the conduit to extend a little further into the block.
+ * Used by jars and alembics that have smaller than normal hitboxes
+ * @return
+ */
+ boolean renderExtendedTube();
+
+
+
+}
+
diff --git a/src-backup/api/java/thaumcraft/api/crafting/CrucibleRecipe.java b/src-backup/api/java/thaumcraft/api/crafting/CrucibleRecipe.java
new file mode 100644
index 00000000..9c1e8a62
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/crafting/CrucibleRecipe.java
@@ -0,0 +1,95 @@
+package thaumcraft.api.crafting;
+
+import java.util.ArrayList;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.oredict.OreDictionary;
+import thaumcraft.api.ThaumcraftApiHelper;
+import thaumcraft.api.aspects.Aspect;
+import thaumcraft.api.aspects.AspectList;
+
+public class CrucibleRecipe {
+
+ private ItemStack recipeOutput;
+
+
+ public Object catalyst;
+ public AspectList aspects;
+ public String key;
+
+ public CrucibleRecipe(String researchKey, ItemStack result, Object cat, AspectList tags) {
+ recipeOutput = result;
+ this.aspects = tags;
+ this.key = researchKey;
+ this.catalyst = cat;
+ if (cat instanceof String) {
+ this.catalyst = OreDictionary.getOres((String) cat);
+ }
+ }
+
+
+ public boolean matches(AspectList itags, ItemStack cat) {
+ if (catalyst instanceof ItemStack &&
+ !ThaumcraftApiHelper.itemMatches((ItemStack) catalyst,cat,false)) {
+ return false;
+ } else
+ if (catalyst instanceof ArrayList && ((ArrayList)catalyst).size()>0) {
+ ItemStack[] ores = ((ArrayList)catalyst).toArray(new ItemStack[]{});
+ if (!ThaumcraftApiHelper.containsMatch(false, new ItemStack[]{cat},ores)) return false;
+ }
+ if (itags==null) return false;
+ for (Aspect tag:aspects.getAspects()) {
+ if (itags.getAmount(tag))catalyst).size()>0) {
+ ItemStack[] ores = ((ArrayList)catalyst).toArray(new ItemStack[]{});
+ if (ThaumcraftApiHelper.containsMatch(false, new ItemStack[]{cat},ores)) return true;
+ }
+ return false;
+ }
+
+ public AspectList removeMatching(AspectList itags) {
+ AspectList temptags = new AspectList();
+ temptags.aspects.putAll(itags.aspects);
+
+ for (Aspect tag:aspects.getAspects()) {
+ temptags.remove(tag, aspects.getAmount(tag));
+// if (!temptags.remove(tag, aspects.getAmount(tag))) return null;
+ }
+
+ itags = temptags;
+ return itags;
+ }
+
+ public ItemStack getRecipeOutput() {
+ return recipeOutput;
+ }
+
+
+// @Override
+// public int hashCode() {
+// String hash = "";
+// if (catalyst instanceof ItemStack) {
+// hash += ((ItemStack)catalyst).toString();
+// } else if (catalyst instanceof ArrayList && ((ArrayList)catalyst).size()>0) {
+// for (ItemStack s:(ArrayList)catalyst) {
+// hash += s.toString();
+// }
+// } else {
+// hash += catalyst.hashCode();
+// }
+// hash += getRecipeOutput().toString();
+// for (Aspect a:aspects.getAspectsSorted()) {
+// hash += a.getTag() + aspects.getAmount(a);
+// }
+// return hash.hashCode();
+// }
+
+}
diff --git a/src-backup/api/java/thaumcraft/api/crafting/IArcaneRecipe.java b/src-backup/api/java/thaumcraft/api/crafting/IArcaneRecipe.java
new file mode 100644
index 00000000..bb5036d2
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/crafting/IArcaneRecipe.java
@@ -0,0 +1,35 @@
+package thaumcraft.api.crafting;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import thaumcraft.api.aspects.AspectList;
+
+public interface IArcaneRecipe
+{
+
+
+ /**
+ * Used to check if a recipe matches current crafting inventory
+ * @param player
+ */
+ boolean matches(IInventory var1, World world, EntityPlayer player);
+
+ /**
+ * Returns an Item that is the result of this recipe
+ */
+ ItemStack getCraftingResult(IInventory var1);
+
+ /**
+ * Returns the size of the recipe area
+ */
+ int getRecipeSize();
+
+ ItemStack getRecipeOutput();
+ AspectList getAspects();
+ AspectList getAspects(IInventory var1);
+ String getResearch();
+
+
+}
diff --git a/src-backup/api/java/thaumcraft/api/crafting/IInfusionStabiliser.java b/src-backup/api/java/thaumcraft/api/crafting/IInfusionStabiliser.java
new file mode 100644
index 00000000..d137ff24
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/crafting/IInfusionStabiliser.java
@@ -0,0 +1,19 @@
+package thaumcraft.api.crafting;
+
+import net.minecraft.world.World;
+
+/**
+ *
+ * @author Azanor
+ *
+ * Blocks that implement this interface act as infusion crafting stabilisers like candles and skulls
+ *
+ */
+public interface IInfusionStabiliser {
+
+ /**
+ * returns true if the block can stabilise things
+ */
+ public boolean canStabaliseInfusion(World world, int x, int y, int z);
+
+}
diff --git a/src-backup/api/java/thaumcraft/api/crafting/InfusionEnchantmentRecipe.java b/src-backup/api/java/thaumcraft/api/crafting/InfusionEnchantmentRecipe.java
new file mode 100644
index 00000000..6fb4d63d
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/crafting/InfusionEnchantmentRecipe.java
@@ -0,0 +1,156 @@
+package thaumcraft.api.crafting;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.Map;
+
+import net.minecraft.enchantment.Enchantment;
+import net.minecraft.enchantment.EnchantmentHelper;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import net.minecraftforge.oredict.OreDictionary;
+import thaumcraft.api.ThaumcraftApiHelper;
+import thaumcraft.api.aspects.AspectList;
+
+public class InfusionEnchantmentRecipe
+{
+
+ public AspectList aspects;
+ public String research;
+ public ItemStack[] components;
+ public Enchantment enchantment;
+ public int recipeXP;
+ public int instability;
+
+ public InfusionEnchantmentRecipe(String research, Enchantment input, int inst,
+ AspectList aspects2, ItemStack[] recipe) {
+ this.research = research;
+ this.enchantment = input;
+ this.aspects = aspects2;
+ this.components = recipe;
+ this.instability = inst;
+ this.recipeXP = Math.max(1, input.getMinEnchantability(1)/3);
+ }
+
+ /**
+ * Used to check if a recipe matches current crafting inventory
+ * @param player
+ */
+ public boolean matches(ArrayList input, ItemStack central, World world, EntityPlayer player) {
+ if (research.length()>0 && !ThaumcraftApiHelper.isResearchComplete(player.getCommandSenderName(), research)) {
+ return false;
+ }
+
+ if (!enchantment.canApply(central) || !central.getItem().isItemTool(central)) {
+ return false;
+ }
+
+ Map map1 = EnchantmentHelper.getEnchantments(central);
+ Iterator iterator = map1.keySet().iterator();
+ while (iterator.hasNext())
+ {
+ int j1 = ((Integer)iterator.next()).intValue();
+ Enchantment ench = Enchantment.enchantmentsList[j1];
+ if (j1 == enchantment.effectId &&
+ EnchantmentHelper.getEnchantmentLevel(j1, central)>=ench.getMaxLevel())
+ return false;
+ if (enchantment.effectId != ench.effectId &&
+ (!enchantment.canApplyTogether(ench) ||
+ !ench.canApplyTogether(enchantment))) {
+ return false;
+ }
+ }
+
+ ItemStack i2 = null;
+
+ ArrayList ii = new ArrayList();
+ for (ItemStack is:input) {
+ ii.add(is.copy());
+ }
+
+ for (ItemStack comp:components) {
+ boolean b=false;
+ for (int a=0;a stack0.getMaxStackSize() ? false : t1));
+ }
+
+
+ public Enchantment getEnchantment() {
+ return enchantment;
+
+ }
+
+ public AspectList getAspects() {
+ return aspects;
+
+ }
+
+ public String getResearch() {
+ return research;
+
+ }
+
+ public int calcInstability(ItemStack recipeInput) {
+ int i = 0;
+ Map map1 = EnchantmentHelper.getEnchantments(recipeInput);
+ Iterator iterator = map1.keySet().iterator();
+ while (iterator.hasNext())
+ {
+ int j1 = ((Integer)iterator.next()).intValue();
+ i += EnchantmentHelper.getEnchantmentLevel(j1, recipeInput);
+ }
+ return (i/2) + instability;
+ }
+
+ public int calcXP(ItemStack recipeInput) {
+ return recipeXP * (1+EnchantmentHelper.getEnchantmentLevel(enchantment.effectId, recipeInput));
+ }
+
+ public float getEssentiaMod(ItemStack recipeInput) {
+ float mod = EnchantmentHelper.getEnchantmentLevel(enchantment.effectId, recipeInput);
+ Map map1 = EnchantmentHelper.getEnchantments(recipeInput);
+ Iterator iterator = map1.keySet().iterator();
+ while (iterator.hasNext())
+ {
+ int j1 = ((Integer)iterator.next()).intValue();
+ if (j1 != enchantment.effectId)
+ mod += EnchantmentHelper.getEnchantmentLevel(j1, recipeInput) * .1f;
+ }
+ return mod;
+ }
+
+}
diff --git a/src-backup/api/java/thaumcraft/api/crafting/InfusionRecipe.java b/src-backup/api/java/thaumcraft/api/crafting/InfusionRecipe.java
new file mode 100644
index 00000000..fef0a347
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/crafting/InfusionRecipe.java
@@ -0,0 +1,128 @@
+package thaumcraft.api.crafting;
+
+import java.util.ArrayList;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import net.minecraftforge.oredict.OreDictionary;
+import thaumcraft.api.ThaumcraftApiHelper;
+import thaumcraft.api.aspects.AspectList;
+
+public class InfusionRecipe
+{
+ protected AspectList aspects;
+ protected String research;
+ private ItemStack[] components;
+ private ItemStack recipeInput;
+ protected Object recipeOutput;
+ protected int instability;
+
+ public InfusionRecipe(String research, Object output, int inst,
+ AspectList aspects2, ItemStack input, ItemStack[] recipe) {
+ this.research = research;
+ this.recipeOutput = output;
+ this.recipeInput = input;
+ this.aspects = aspects2;
+ this.components = recipe;
+ this.instability = inst;
+ }
+
+ /**
+ * Used to check if a recipe matches current crafting inventory
+ * @param player
+ */
+ public boolean matches(ArrayList input, ItemStack central, World world, EntityPlayer player) {
+ if (getRecipeInput()==null) return false;
+
+ if (research.length()>0 && !ThaumcraftApiHelper.isResearchComplete(player.getCommandSenderName(), research)) {
+ return false;
+ }
+
+ ItemStack i2 = central.copy();
+ if (getRecipeInput().getItemDamage()==OreDictionary.WILDCARD_VALUE) {
+ i2.setItemDamage(OreDictionary.WILDCARD_VALUE);
+ }
+
+ if (!areItemStacksEqual(i2, getRecipeInput(), true)) return false;
+
+ ArrayList ii = new ArrayList();
+ for (ItemStack is:input) {
+ ii.add(is.copy());
+ }
+
+ for (ItemStack comp:getComponents()) {
+ boolean b=false;
+ for (int a=0;a stack0.getMaxStackSize() ? false : t1));
+ }
+
+
+ public Object getRecipeOutput() {
+ return getRecipeOutput(this.getRecipeInput());
+ }
+
+ public AspectList getAspects() {
+ return getAspects(this.getRecipeInput());
+ }
+
+ public int getInstability() {
+ return getInstability(this.getRecipeInput());
+ }
+
+ public String getResearch() {
+ return research;
+ }
+
+ public ItemStack getRecipeInput() {
+ return recipeInput;
+ }
+
+ public ItemStack[] getComponents() {
+ return components;
+ }
+
+ public Object getRecipeOutput(ItemStack input) {
+ return recipeOutput;
+ }
+
+ public AspectList getAspects(ItemStack input) {
+ return aspects;
+ }
+
+ public int getInstability(ItemStack input) {
+ return instability;
+ }
+}
diff --git a/src-backup/api/java/thaumcraft/api/crafting/ShapedArcaneRecipe.java b/src-backup/api/java/thaumcraft/api/crafting/ShapedArcaneRecipe.java
new file mode 100644
index 00000000..40c7bc27
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/crafting/ShapedArcaneRecipe.java
@@ -0,0 +1,261 @@
+package thaumcraft.api.crafting;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import net.minecraftforge.oredict.OreDictionary;
+import thaumcraft.api.ThaumcraftApiHelper;
+import thaumcraft.api.aspects.AspectList;
+
+public class ShapedArcaneRecipe implements IArcaneRecipe
+{
+ //Added in for future ease of change, but hard coded for now.
+ private static final int MAX_CRAFT_GRID_WIDTH = 3;
+ private static final int MAX_CRAFT_GRID_HEIGHT = 3;
+
+ public ItemStack output = null;
+ public Object[] input = null;
+ public AspectList aspects = null;
+ public String research;
+ public int width = 0;
+ public int height = 0;
+ private boolean mirrored = true;
+
+ public ShapedArcaneRecipe(String research, Block result, AspectList aspects, Object... recipe){ this(research, new ItemStack(result), aspects, recipe); }
+ public ShapedArcaneRecipe(String research, Item result, AspectList aspects, Object... recipe){ this(research, new ItemStack(result), aspects, recipe); }
+ public ShapedArcaneRecipe(String research, ItemStack result, AspectList aspects, Object... recipe)
+ {
+ output = result.copy();
+ this.research = research;
+ this.aspects = aspects;
+ String shape = "";
+
+ int idx = 0;
+
+ if (recipe[idx] instanceof Boolean)
+ {
+ mirrored = (Boolean)recipe[idx];
+ if (recipe[idx+1] instanceof Object[])
+ {
+ recipe = (Object[])recipe[idx+1];
+ }
+ else
+ {
+ idx = 1;
+ }
+ }
+
+ if (recipe[idx] instanceof String[])
+ {
+ String[] parts = ((String[])recipe[idx++]);
+
+ for (String s : parts)
+ {
+ width = s.length();
+ shape += s;
+ }
+
+ height = parts.length;
+ }
+ else
+ {
+ while (recipe[idx] instanceof String)
+ {
+ String s = (String)recipe[idx++];
+ shape += s;
+ width = s.length();
+ height++;
+ }
+ }
+
+ if (width * height != shape.length())
+ {
+ String ret = "Invalid shaped ore recipe: ";
+ for (Object tmp : recipe)
+ {
+ ret += tmp + ", ";
+ }
+ ret += output;
+ throw new RuntimeException(ret);
+ }
+
+ HashMap itemMap = new HashMap();
+
+ for (; idx < recipe.length; idx += 2)
+ {
+ Character chr = (Character)recipe[idx];
+ Object in = recipe[idx + 1];
+
+ if (in instanceof ItemStack)
+ {
+ itemMap.put(chr, ((ItemStack)in).copy());
+ }
+ else if (in instanceof Item)
+ {
+ itemMap.put(chr, new ItemStack((Item)in));
+ }
+ else if (in instanceof Block)
+ {
+ itemMap.put(chr, new ItemStack((Block)in, 1, OreDictionary.WILDCARD_VALUE));
+ }
+ else if (in instanceof String)
+ {
+ itemMap.put(chr, OreDictionary.getOres((String)in));
+ }
+ else
+ {
+ String ret = "Invalid shaped ore recipe: ";
+ for (Object tmp : recipe)
+ {
+ ret += tmp + ", ";
+ }
+ ret += output;
+ throw new RuntimeException(ret);
+ }
+ }
+
+ input = new Object[width * height];
+ int x = 0;
+ for (char chr : shape.toCharArray())
+ {
+ input[x++] = itemMap.get(chr);
+ }
+ }
+
+ @Override
+ public ItemStack getCraftingResult(IInventory var1){ return output.copy(); }
+
+ @Override
+ public int getRecipeSize(){ return input.length; }
+
+ @Override
+ public ItemStack getRecipeOutput(){ return output; }
+
+ @Override
+ public boolean matches(IInventory inv, World world, EntityPlayer player)
+ {
+ if (research.length()>0 && !ThaumcraftApiHelper.isResearchComplete(player.getCommandSenderName(), research)) {
+ return false;
+ }
+ for (int x = 0; x <= MAX_CRAFT_GRID_WIDTH - width; x++)
+ {
+ for (int y = 0; y <= MAX_CRAFT_GRID_HEIGHT - height; ++y)
+ {
+ if (checkMatch(inv, x, y, false))
+ {
+ return true;
+ }
+
+ if (mirrored && checkMatch(inv, x, y, true))
+ {
+ return true;
+ }
+ }
+ }
+
+ return false;
+ }
+
+ private boolean checkMatch(IInventory inv, int startX, int startY, boolean mirror)
+ {
+ for (int x = 0; x < MAX_CRAFT_GRID_WIDTH; x++)
+ {
+ for (int y = 0; y < MAX_CRAFT_GRID_HEIGHT; y++)
+ {
+ int subX = x - startX;
+ int subY = y - startY;
+ Object target = null;
+
+ if (subX >= 0 && subY >= 0 && subX < width && subY < height)
+ {
+ if (mirror)
+ {
+ target = input[width - subX - 1 + subY * width];
+ }
+ else
+ {
+ target = input[subX + subY * width];
+ }
+ }
+
+ ItemStack slot = ThaumcraftApiHelper.getStackInRowAndColumn(inv, x, y);
+
+ if (target instanceof ItemStack)
+ {
+ if (!checkItemEquals((ItemStack)target, slot))
+ {
+ return false;
+ }
+ }
+ else if (target instanceof ArrayList)
+ {
+ boolean matched = false;
+
+ for (ItemStack item : (ArrayList)target)
+ {
+ matched = matched || checkItemEquals(item, slot);
+ }
+
+ if (!matched)
+ {
+ return false;
+ }
+ }
+ else if (target == null && slot != null)
+ {
+ return false;
+ }
+ }
+ }
+
+ return true;
+ }
+
+ private boolean checkItemEquals(ItemStack target, ItemStack input)
+ {
+ if (input == null && target != null || input != null && target == null)
+ {
+ return false;
+ }
+ return (target.getItem() == input.getItem() &&
+ (!target.hasTagCompound() || ItemStack.areItemStackTagsEqual(target, input)) &&
+ (target.getItemDamage() == OreDictionary.WILDCARD_VALUE|| target.getItemDamage() == input.getItemDamage()));
+ }
+
+ public ShapedArcaneRecipe setMirrored(boolean mirror)
+ {
+ mirrored = mirror;
+ return this;
+ }
+
+ /**
+ * Returns the input for this recipe, any mod accessing this value should never
+ * manipulate the values in this array as it will effect the recipe itself.
+ * @return The recipes input vales.
+ */
+ public Object[] getInput()
+ {
+ return this.input;
+ }
+
+ @Override
+ public AspectList getAspects() {
+ return aspects;
+ }
+
+ @Override
+ public AspectList getAspects(IInventory inv) {
+ return aspects;
+ }
+
+ @Override
+ public String getResearch() {
+ return research;
+ }
+}
diff --git a/src-backup/api/java/thaumcraft/api/crafting/ShapelessArcaneRecipe.java b/src-backup/api/java/thaumcraft/api/crafting/ShapelessArcaneRecipe.java
new file mode 100644
index 00000000..3d4ed508
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/crafting/ShapelessArcaneRecipe.java
@@ -0,0 +1,157 @@
+package thaumcraft.api.crafting;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import net.minecraftforge.oredict.OreDictionary;
+import thaumcraft.api.ThaumcraftApiHelper;
+import thaumcraft.api.aspects.AspectList;
+
+public class ShapelessArcaneRecipe implements IArcaneRecipe
+{
+ private ItemStack output = null;
+ private ArrayList input = new ArrayList();
+
+ public AspectList aspects = null;
+ public String research;
+
+ public ShapelessArcaneRecipe(String research, Block result, AspectList aspects, Object... recipe){ this(research,new ItemStack(result),aspects, recipe); }
+ public ShapelessArcaneRecipe(String research, Item result, AspectList aspects, Object... recipe){ this(research,new ItemStack(result),aspects, recipe); }
+
+ public ShapelessArcaneRecipe(String research, ItemStack result, AspectList aspects, Object... recipe)
+ {
+ output = result.copy();
+ this.research = research;
+ this.aspects = aspects;
+ for (Object in : recipe)
+ {
+ if (in instanceof ItemStack)
+ {
+ input.add(((ItemStack)in).copy());
+ }
+ else if (in instanceof Item)
+ {
+ input.add(new ItemStack((Item)in));
+ }
+ else if (in instanceof Block)
+ {
+ input.add(new ItemStack((Block)in));
+ }
+ else if (in instanceof String)
+ {
+ input.add(OreDictionary.getOres((String)in));
+ }
+ else
+ {
+ String ret = "Invalid shapeless ore recipe: ";
+ for (Object tmp : recipe)
+ {
+ ret += tmp + ", ";
+ }
+ ret += output;
+ throw new RuntimeException(ret);
+ }
+ }
+ }
+
+ @Override
+ public int getRecipeSize(){ return input.size(); }
+
+ @Override
+ public ItemStack getRecipeOutput(){ return output; }
+
+ @Override
+ public ItemStack getCraftingResult(IInventory var1){ return output.copy(); }
+
+ @Override
+ public boolean matches(IInventory var1, World world, EntityPlayer player)
+ {
+ if (research.length()>0 && !ThaumcraftApiHelper.isResearchComplete(player.getCommandSenderName(), research)) {
+ return false;
+ }
+
+ ArrayList required = new ArrayList(input);
+
+ for (int x = 0; x < 9; x++)
+ {
+ ItemStack slot = var1.getStackInSlot(x);
+
+ if (slot != null)
+ {
+ boolean inRecipe = false;
+ Iterator req = required.iterator();
+
+ while (req.hasNext())
+ {
+ boolean match = false;
+
+ Object next = req.next();
+
+ if (next instanceof ItemStack)
+ {
+ match = checkItemEquals((ItemStack)next, slot);
+ }
+ else if (next instanceof ArrayList)
+ {
+ for (ItemStack item : (ArrayList)next)
+ {
+ match = match || checkItemEquals(item, slot);
+ }
+ }
+
+ if (match)
+ {
+ inRecipe = true;
+ required.remove(next);
+ break;
+ }
+ }
+
+ if (!inRecipe)
+ {
+ return false;
+ }
+ }
+ }
+
+ return required.isEmpty();
+ }
+
+ private boolean checkItemEquals(ItemStack target, ItemStack input)
+ {
+ return (target.getItem() == input.getItem() &&
+ (!target.hasTagCompound() || ItemStack.areItemStackTagsEqual(target, input)) &&
+ (target.getItemDamage() == OreDictionary.WILDCARD_VALUE || target.getItemDamage() == input.getItemDamage()));
+ }
+
+ /**
+ * Returns the input for this recipe, any mod accessing this value should never
+ * manipulate the values in this array as it will effect the recipe itself.
+ * @return The recipes input vales.
+ */
+ public ArrayList getInput()
+ {
+ return this.input;
+ }
+
+ @Override
+ public AspectList getAspects() {
+ return aspects;
+ }
+
+ @Override
+ public AspectList getAspects(IInventory inv) {
+ return aspects;
+ }
+
+ @Override
+ public String getResearch() {
+ return research;
+ }
+}
diff --git a/src-backup/api/java/thaumcraft/api/damagesource/DamageSourceIndirectThaumcraftEntity.java b/src-backup/api/java/thaumcraft/api/damagesource/DamageSourceIndirectThaumcraftEntity.java
new file mode 100644
index 00000000..1562d052
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/damagesource/DamageSourceIndirectThaumcraftEntity.java
@@ -0,0 +1,32 @@
+package thaumcraft.api.damagesource;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.EntityDamageSourceIndirect;
+
+public class DamageSourceIndirectThaumcraftEntity extends EntityDamageSourceIndirect {
+
+ private boolean fireDamage;
+ private float hungerDamage;
+ private boolean isUnblockable;
+
+
+ public DamageSourceIndirectThaumcraftEntity(String par1Str,
+ Entity par2Entity, Entity par3Entity) {
+ super(par1Str, par2Entity, par3Entity);
+ }
+
+
+ public DamageSource setFireDamage()
+ {
+ this.fireDamage = true;
+ return this;
+ }
+
+ public DamageSource setDamageBypassesArmor()
+ {
+ this.isUnblockable = true;
+ this.hungerDamage = 0.0F;
+ return this;
+ }
+}
diff --git a/src-backup/api/java/thaumcraft/api/damagesource/DamageSourceThaumcraft.java b/src-backup/api/java/thaumcraft/api/damagesource/DamageSourceThaumcraft.java
new file mode 100644
index 00000000..7c277f28
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/damagesource/DamageSourceThaumcraft.java
@@ -0,0 +1,46 @@
+package thaumcraft.api.damagesource;
+
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.EntityDamageSource;
+
+public class DamageSourceThaumcraft extends DamageSource
+{
+
+ public static DamageSource taint = new DamageSourceThaumcraft("taint").setDamageBypassesArmor().setMagicDamage();
+ public static DamageSource tentacle = new DamageSourceThaumcraft("tentacle");
+ public static DamageSource swarm = new DamageSourceThaumcraft("swarm");
+
+ protected DamageSourceThaumcraft(String par1Str) {
+ super(par1Str);
+ }
+
+ /** This kind of damage can be blocked or not. */
+ private boolean isUnblockable = false;
+ private boolean isDamageAllowedInCreativeMode = false;
+ private float hungerDamage = 0.3F;
+
+ /** This kind of damage is based on fire or not. */
+ private boolean fireDamage;
+
+ /** This kind of damage is based on a projectile or not. */
+ private boolean projectile;
+
+ /**
+ * Whether this damage source will have its damage amount scaled based on the current difficulty.
+ */
+ private boolean difficultyScaled;
+ private boolean magicDamage = false;
+ private boolean explosion = false;
+
+ public static DamageSource causeSwarmDamage(EntityLivingBase par0EntityLiving)
+ {
+ return new EntityDamageSource("swarm", par0EntityLiving);
+ }
+
+ public static DamageSource causeTentacleDamage(EntityLivingBase par0EntityLiving)
+ {
+ return new EntityDamageSource("tentacle", par0EntityLiving);
+ }
+
+}
diff --git a/src-backup/api/java/thaumcraft/api/entities/ITaintedMob.java b/src-backup/api/java/thaumcraft/api/entities/ITaintedMob.java
new file mode 100644
index 00000000..83fb1fcb
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/entities/ITaintedMob.java
@@ -0,0 +1,5 @@
+package thaumcraft.api.entities;
+
+public interface ITaintedMob {
+
+}
diff --git a/src-backup/api/java/thaumcraft/api/nodes/INode.java b/src-backup/api/java/thaumcraft/api/nodes/INode.java
new file mode 100644
index 00000000..8c71414d
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/nodes/INode.java
@@ -0,0 +1,53 @@
+package thaumcraft.api.nodes;
+
+import thaumcraft.api.aspects.Aspect;
+import thaumcraft.api.aspects.AspectList;
+import thaumcraft.api.aspects.IAspectContainer;
+
+public interface INode extends IAspectContainer {
+
+ /**
+ * Unique identifier to distinguish nodes. Normal node id's are based on world id and coordinates
+ * @return
+ */
+ public String getId();
+
+ public AspectList getAspectsBase();
+
+ /**
+ * Return the type of node
+ * @return
+ */
+ public NodeType getNodeType();
+
+ /**
+ * Set the type of node
+ * @return
+ */
+ public void setNodeType(NodeType nodeType);
+
+ /**
+ * Return the node modifier
+ * @return
+ */
+ public void setNodeModifier(NodeModifier nodeModifier);
+
+ /**
+ * Set the node modifier
+ * @return
+ */
+ public NodeModifier getNodeModifier();
+
+ /**
+ * Return the maximum capacity of each aspect the node can hold
+ * @return
+ */
+ public int getNodeVisBase(Aspect aspect);
+
+ /**
+ * Set the maximum capacity of each aspect the node can hold
+ * @return
+ */
+ public void setNodeVisBase(Aspect aspect, short nodeVisBase);
+
+}
diff --git a/src-backup/api/java/thaumcraft/api/nodes/IRevealer.java b/src-backup/api/java/thaumcraft/api/nodes/IRevealer.java
new file mode 100644
index 00000000..14a19b54
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/nodes/IRevealer.java
@@ -0,0 +1,22 @@
+package thaumcraft.api.nodes;
+
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.item.ItemStack;
+
+/**
+ *
+ * @author Azanor
+ *
+ * Equipped head slot items that extend this class will make nodes visible in world.
+ *
+ */
+
+public interface IRevealer {
+
+ /*
+ * If this method returns true the nodes will be visible.
+ */
+ public boolean showNodes(ItemStack itemstack, EntityLivingBase player);
+
+
+}
diff --git a/src-backup/api/java/thaumcraft/api/nodes/NodeModifier.java b/src-backup/api/java/thaumcraft/api/nodes/NodeModifier.java
new file mode 100644
index 00000000..885b8678
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/nodes/NodeModifier.java
@@ -0,0 +1,6 @@
+package thaumcraft.api.nodes;
+
+public enum NodeModifier
+{
+ BRIGHT, PALE, FADING
+}
\ No newline at end of file
diff --git a/src-backup/api/java/thaumcraft/api/nodes/NodeType.java b/src-backup/api/java/thaumcraft/api/nodes/NodeType.java
new file mode 100644
index 00000000..355324b5
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/nodes/NodeType.java
@@ -0,0 +1,6 @@
+package thaumcraft.api.nodes;
+
+public enum NodeType
+{
+ NORMAL, UNSTABLE, DARK, TAINTED, HUNGRY, PURE
+}
\ No newline at end of file
diff --git a/src-backup/api/java/thaumcraft/api/package-info.java b/src-backup/api/java/thaumcraft/api/package-info.java
new file mode 100644
index 00000000..0de39267
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/package-info.java
@@ -0,0 +1,4 @@
+@API(owner = "Thaumcraft", apiVersion = "4.2.0.0", provides = "Thaumcraft|API")
+package thaumcraft.api;
+
+import cpw.mods.fml.common.API;
diff --git a/src-backup/api/java/thaumcraft/api/potions/PotionFluxTaint.java b/src-backup/api/java/thaumcraft/api/potions/PotionFluxTaint.java
new file mode 100644
index 00000000..b718de4b
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/potions/PotionFluxTaint.java
@@ -0,0 +1,67 @@
+package thaumcraft.api.potions;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.potion.Potion;
+import net.minecraft.util.ResourceLocation;
+import thaumcraft.api.damagesource.DamageSourceThaumcraft;
+import thaumcraft.api.entities.ITaintedMob;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class PotionFluxTaint extends Potion
+{
+ public static PotionFluxTaint instance = null; // will be instantiated at runtime
+ private int statusIconIndex = -1;
+
+ public PotionFluxTaint(int par1, boolean par2, int par3)
+ {
+ super(par1,par2,par3);
+ setIconIndex(0, 0);
+ }
+
+ public static void init()
+ {
+ instance.setPotionName("potion.fluxtaint");
+ instance.setIconIndex(3, 1);
+ instance.setEffectiveness(0.25D);
+ }
+
+ @Override
+ public boolean isBadEffect() {
+ return true;
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public int getStatusIconIndex() {
+ Minecraft.getMinecraft().renderEngine.bindTexture(rl);
+ return super.getStatusIconIndex();
+ }
+
+ ResourceLocation rl = new ResourceLocation("thaumcraft","textures/misc/potions.png");
+
+ @Override
+ public void performEffect(EntityLivingBase target, int par2) {
+ if (target instanceof ITaintedMob) {
+ target.heal(1);
+ } else
+ if (!target.isEntityUndead() && !(target instanceof EntityPlayer))
+ {
+ target.attackEntityFrom(DamageSourceThaumcraft.taint, 1);
+ }
+ else
+ if (!target.isEntityUndead() && (target.getMaxHealth() > 1 || (target instanceof EntityPlayer)))
+ {
+ target.attackEntityFrom(DamageSourceThaumcraft.taint, 1);
+ }
+ }
+
+ public boolean isReady(int par1, int par2)
+ {
+ int k = 40 >> par2;
+ return k > 0 ? par1 % k == 0 : true;
+ }
+
+}
diff --git a/src-backup/api/java/thaumcraft/api/research/IScanEventHandler.java b/src-backup/api/java/thaumcraft/api/research/IScanEventHandler.java
new file mode 100644
index 00000000..d0efac5f
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/research/IScanEventHandler.java
@@ -0,0 +1,9 @@
+package thaumcraft.api.research;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+
+public interface IScanEventHandler {
+ ScanResult scanPhenomena(ItemStack stack, World world, EntityPlayer player);
+}
diff --git a/src-backup/api/java/thaumcraft/api/research/ResearchCategories.java b/src-backup/api/java/thaumcraft/api/research/ResearchCategories.java
new file mode 100644
index 00000000..82309b36
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/research/ResearchCategories.java
@@ -0,0 +1,101 @@
+package thaumcraft.api.research;
+
+import java.util.Collection;
+import java.util.LinkedHashMap;
+
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.StatCollector;
+
+import org.apache.logging.log4j.Level;
+
+import cpw.mods.fml.common.FMLLog;
+
+public class ResearchCategories {
+
+ //Research
+ public static LinkedHashMap researchCategories = new LinkedHashMap ();
+
+ /**
+ * @param key
+ * @return the research item linked to this key
+ */
+ public static ResearchCategoryList getResearchList(String key) {
+ return researchCategories.get(key);
+ }
+
+ /**
+ * @param key
+ * @return the name of the research category linked to this key.
+ * Must be stored as localization information in the LanguageRegistry.
+ */
+ public static String getCategoryName(String key) {
+ return StatCollector.translateToLocal("tc.research_category."+key);
+ }
+
+ /**
+ * @param key the research key
+ * @return the ResearchItem object.
+ */
+ public static ResearchItem getResearch(String key) {
+ Collection rc = researchCategories.values();
+ for (Object cat:rc) {
+ Collection rl = ((ResearchCategoryList)cat).research.values();
+ for (Object ri:rl) {
+ if ((((ResearchItem)ri).key).equals(key)) return (ResearchItem)ri;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * This should only be done at the PostInit stage
+ * @param key the key used for this category
+ * @param icon the icon to be used for the research category tab
+ * @param background the resource location of the background image to use for this category
+ * @return the name of the research linked to this key
+ */
+ public static void registerCategory(String key, ResourceLocation icon, ResourceLocation background) {
+ if (getResearchList(key)==null) {
+ ResearchCategoryList rl = new ResearchCategoryList(icon, background);
+ researchCategories.put(key, rl);
+ }
+ }
+
+ public static void addResearch(ResearchItem ri) {
+ ResearchCategoryList rl = getResearchList(ri.category);
+ if (rl!=null && !rl.research.containsKey(ri.key)) {
+
+ if (!ri.isVirtual()) {
+ for (ResearchItem rr:rl.research.values()) {
+ if (rr.displayColumn == ri.displayColumn && rr.displayRow == ri.displayRow) {
+ FMLLog.log(Level.FATAL, "[Thaumcraft] Research ["+ri.getName()+"] not added as it overlaps with existing research ["+rr.getName()+"]");
+ return;
+ }
+ }
+ }
+
+
+ rl.research.put(ri.key, ri);
+
+ if (ri.displayColumn < rl.minDisplayColumn)
+ {
+ rl.minDisplayColumn = ri.displayColumn;
+ }
+
+ if (ri.displayRow < rl.minDisplayRow)
+ {
+ rl.minDisplayRow = ri.displayRow;
+ }
+
+ if (ri.displayColumn > rl.maxDisplayColumn)
+ {
+ rl.maxDisplayColumn = ri.displayColumn;
+ }
+
+ if (ri.displayRow > rl.maxDisplayRow)
+ {
+ rl.maxDisplayRow = ri.displayRow;
+ }
+ }
+ }
+}
diff --git a/src-backup/api/java/thaumcraft/api/research/ResearchCategoryList.java b/src-backup/api/java/thaumcraft/api/research/ResearchCategoryList.java
new file mode 100644
index 00000000..7eed0101
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/research/ResearchCategoryList.java
@@ -0,0 +1,37 @@
+package thaumcraft.api.research;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import net.minecraft.util.ResourceLocation;
+
+public class ResearchCategoryList {
+
+ /** Is the smallest column used on the GUI. */
+ public int minDisplayColumn;
+
+ /** Is the smallest row used on the GUI. */
+ public int minDisplayRow;
+
+ /** Is the biggest column used on the GUI. */
+ public int maxDisplayColumn;
+
+ /** Is the biggest row used on the GUI. */
+ public int maxDisplayRow;
+
+ /** display variables **/
+ public ResourceLocation icon;
+ public ResourceLocation background;
+
+ public ResearchCategoryList(ResourceLocation icon, ResourceLocation background) {
+ this.icon = icon;
+ this.background = background;
+ }
+
+ //Research
+ public Map research = new HashMap();
+
+
+
+
+}
diff --git a/src-backup/api/java/thaumcraft/api/research/ResearchItem.java b/src-backup/api/java/thaumcraft/api/research/ResearchItem.java
new file mode 100644
index 00000000..55b3820c
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/research/ResearchItem.java
@@ -0,0 +1,367 @@
+package thaumcraft.api.research;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.StatCollector;
+import thaumcraft.api.aspects.Aspect;
+import thaumcraft.api.aspects.AspectList;
+
+public class ResearchItem
+{
+ /**
+ * A short string used as a key for this research. Must be unique
+ */
+ public final String key;
+
+ /**
+ * A short string used as a reference to the research category to which this must be added.
+ */
+ public final String category;
+
+ /**
+ * The aspect tags and their values required to complete this research
+ */
+ public final AspectList tags;
+
+ /**
+ * This links to any research that needs to be completed before this research can be discovered or learnt.
+ */
+ public String[] parents = null;
+
+ /**
+ * Like parent above, but a line will not be displayed in the thaumonomicon linking them. Just used to prevent clutter.
+ */
+ public String[] parentsHidden = null;
+ /**
+ * any research linked to this that will be unlocked automatically when this research is complete
+ */
+ public String[] siblings = null;
+
+ /**
+ * the horizontal position of the research icon
+ */
+ public final int displayColumn;
+
+ /**
+ * the vertical position of the research icon
+ */
+ public final int displayRow;
+
+ /**
+ * the icon to be used for this research
+ */
+ public final ItemStack icon_item;
+
+ /**
+ * the icon to be used for this research
+ */
+ public final ResourceLocation icon_resource;
+
+ /**
+ * How large the research grid is. Valid values are 1 to 3.
+ */
+ private int complexity;
+
+ /**
+ * Special research has a spiky border. Used for important research milestones.
+ */
+ private boolean isSpecial;
+
+ /**
+ * Research that can be directly purchased with RP in normal research difficulty.
+ */
+ private boolean isSecondary;
+
+ /**
+ * This indicates if the research should use a circular icon border. Usually used for "passive" research
+ * that doesn't have recipes and grants passive effects, or that unlock automatically.
+ */
+ private boolean isRound;
+
+ /**
+ * Stub research cannot be discovered by normal means, but can be unlocked via the sibling system.
+ */
+ private boolean isStub;
+
+ /**
+ * This indicated that the research is completely hidden and cannot be discovered by any
+ * player-controlled means. The recipes will never show up in the thaumonomicon.
+ * Usually used to unlock "hidden" recipes via sibling unlocking, like
+ * the various cap and rod combos for wands.
+ */
+ private boolean isVirtual;
+
+ @Deprecated
+ private boolean isLost;
+
+ /**
+ * Concealed research does not display in the thaumonomicon until parent researches are discovered.
+ */
+ private boolean isConcealed;
+
+ /**
+ * Hidden research can only be discovered via scanning or knowledge fragments
+ */
+ private boolean isHidden;
+
+ /**
+ * These research items will automatically unlock for all players on game start
+ */
+ private boolean isAutoUnlock;
+
+ /**
+ * Scanning these items will have a chance of revealing hidden knowledge in the thaumonomicon
+ */
+ private ItemStack[] itemTriggers;
+
+ /**
+ * Scanning these entities will have a chance of revealing hidden knowledge in the thaumonomicon
+ */
+ private String[] entityTriggers;
+
+ /**
+ * Scanning things with these aspects will have a chance of revealing hidden knowledge in the thaumonomicon
+ */
+ private Aspect[] aspectTriggers;
+
+ private ResearchPage[] pages = null;
+
+ public ResearchItem(String key, String category)
+ {
+ this.key = key;
+ this.category = category;
+ this.tags = new AspectList();
+ this.icon_resource = null;
+ this.icon_item = null;
+ this.displayColumn = 0;
+ this.displayRow = 0;
+ this.setVirtual();
+
+ }
+
+ public ResearchItem(String key, String category, AspectList tags, int col, int row, int complex, ResourceLocation icon)
+ {
+ this.key = key;
+ this.category = category;
+ this.tags = tags;
+ this.icon_resource = icon;
+ this.icon_item = null;
+ this.displayColumn = col;
+ this.displayRow = row;
+ this.complexity = complex;
+ if (complexity < 1) this.complexity = 1;
+ if (complexity > 3) this.complexity = 3;
+ }
+
+ public ResearchItem(String key, String category, AspectList tags, int col, int row, int complex, ItemStack icon)
+ {
+ this.key = key;
+ this.category = category;
+ this.tags = tags;
+ this.icon_item = icon;
+ this.icon_resource = null;
+ this.displayColumn = col;
+ this.displayRow = row;
+ this.complexity = complex;
+ if (complexity < 1) this.complexity = 1;
+ if (complexity > 3) this.complexity = 3;
+ }
+
+ public ResearchItem setSpecial()
+ {
+ this.isSpecial = true;
+ return this;
+ }
+
+ public ResearchItem setStub()
+ {
+ this.isStub = true;
+ return this;
+ }
+
+ @Deprecated
+ public ResearchItem setLost()
+ {
+ this.isLost = true;
+ return this;
+ }
+
+ public ResearchItem setConcealed()
+ {
+ this.isConcealed = true;
+ return this;
+ }
+
+ public ResearchItem setHidden()
+ {
+ this.isHidden = true;
+ return this;
+ }
+
+ public ResearchItem setVirtual()
+ {
+ this.isVirtual = true;
+ return this;
+ }
+
+ public ResearchItem setParents(String... par)
+ {
+ this.parents = par;
+ return this;
+ }
+
+
+
+ public ResearchItem setParentsHidden(String... par)
+ {
+ this.parentsHidden = par;
+ return this;
+ }
+
+ public ResearchItem setSiblings(String... sib)
+ {
+ this.siblings = sib;
+ return this;
+ }
+
+ public ResearchItem setPages(ResearchPage... par)
+ {
+ this.pages = par;
+ return this;
+ }
+
+ public ResearchPage[] getPages() {
+ return pages;
+ }
+
+ public ResearchItem setItemTriggers(ItemStack... par)
+ {
+ this.itemTriggers = par;
+ return this;
+ }
+
+ public ResearchItem setEntityTriggers(String... par)
+ {
+ this.entityTriggers = par;
+ return this;
+ }
+
+ public ResearchItem setAspectTriggers(Aspect... par)
+ {
+ this.aspectTriggers = par;
+ return this;
+ }
+
+ public ItemStack[] getItemTriggers() {
+ return itemTriggers;
+ }
+
+ public String[] getEntityTriggers() {
+ return entityTriggers;
+ }
+
+ public Aspect[] getAspectTriggers() {
+ return aspectTriggers;
+ }
+
+ public ResearchItem registerResearchItem()
+ {
+ ResearchCategories.addResearch(this);
+ return this;
+ }
+
+ public String getName()
+ {
+ return StatCollector.translateToLocal("tc.research_name."+key);
+ }
+
+ public String getText()
+ {
+ return StatCollector.translateToLocal("tc.research_text."+key);
+ }
+
+ public boolean isSpecial()
+ {
+ return this.isSpecial;
+ }
+
+ public boolean isStub()
+ {
+ return this.isStub;
+ }
+
+ @Deprecated
+ public boolean isLost()
+ {
+ return this.isLost;
+ }
+
+ public boolean isConcealed()
+ {
+ return this.isConcealed;
+ }
+
+ public boolean isHidden()
+ {
+ return this.isHidden;
+ }
+
+ public boolean isVirtual()
+ {
+ return this.isVirtual;
+ }
+
+ public boolean isAutoUnlock() {
+ return isAutoUnlock;
+ }
+
+ public ResearchItem setAutoUnlock()
+ {
+ this.isAutoUnlock = true;
+ return this;
+ }
+
+ public boolean isRound() {
+ return isRound;
+ }
+
+ public ResearchItem setRound() {
+ this.isRound = true;
+ return this;
+ }
+
+ public boolean isSecondary() {
+ return isSecondary;
+ }
+
+ public ResearchItem setSecondary() {
+ this.isSecondary = true;
+ return this;
+ }
+
+ public int getComplexity() {
+ return complexity;
+ }
+
+ public ResearchItem setComplexity(int complexity) {
+ this.complexity = complexity;
+ return this;
+ }
+
+ /**
+ * @return the aspect aspects ordinal with the highest value. Used to determine scroll color and similar things
+ */
+ public Aspect getResearchPrimaryTag() {
+ Aspect aspect=null;
+ int highest=0;
+ if (tags!=null)
+ for (Aspect tag:tags.getAspects()) {
+ if (tags.getAmount(tag)>highest) {
+ aspect=tag;
+ highest=tags.getAmount(tag);
+ };
+ }
+ return aspect;
+ }
+
+}
diff --git a/src-backup/api/java/thaumcraft/api/research/ResearchPage.java b/src-backup/api/java/thaumcraft/api/research/ResearchPage.java
new file mode 100644
index 00000000..fdada843
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/research/ResearchPage.java
@@ -0,0 +1,193 @@
+package thaumcraft.api.research;
+
+import java.util.List;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.crafting.FurnaceRecipes;
+import net.minecraft.item.crafting.IRecipe;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.StatCollector;
+import thaumcraft.api.aspects.AspectList;
+import thaumcraft.api.crafting.CrucibleRecipe;
+import thaumcraft.api.crafting.IArcaneRecipe;
+import thaumcraft.api.crafting.InfusionEnchantmentRecipe;
+import thaumcraft.api.crafting.InfusionRecipe;
+
+public class ResearchPage {
+ public static enum PageType
+ {
+ TEXT,
+ TEXT_CONCEALED,
+ IMAGE,
+ CRUCIBLE_CRAFTING,
+ ARCANE_CRAFTING,
+ ASPECTS,
+ NORMAL_CRAFTING,
+ INFUSION_CRAFTING,
+ COMPOUND_CRAFTING,
+ INFUSION_ENCHANTMENT,
+ SMELTING
+ }
+
+ public PageType type = PageType.TEXT;
+
+ public String text=null;
+ public String research=null;
+ public ResourceLocation image=null;
+ public AspectList aspects=null;
+ public Object recipe=null;
+ public ItemStack recipeOutput=null;
+
+ /**
+ * @param text this can (but does not have to) be a reference to a localization variable, not the actual text.
+ */
+ public ResearchPage(String text) {
+ this.type = PageType.TEXT;
+ this.text = text;
+ }
+
+ /**
+ * @param research this page will only be displayed if the player has discovered this research
+ * @param text this can (but does not have to) be a reference to a localization variable, not the actual text.
+ */
+ public ResearchPage(String research, String text) {
+ this.type = PageType.TEXT_CONCEALED;
+ this.research = research;
+ this.text = text;
+ }
+
+ /**
+ * @param recipe a vanilla crafting recipe.
+ */
+ public ResearchPage(IRecipe recipe) {
+ this.type = PageType.NORMAL_CRAFTING;
+ this.recipe = recipe;
+ this.recipeOutput = recipe.getRecipeOutput();
+ }
+
+ /**
+ * @param recipe a collection of vanilla crafting recipes.
+ */
+ public ResearchPage(IRecipe[] recipe) {
+ this.type = PageType.NORMAL_CRAFTING;
+ this.recipe = recipe;
+ }
+
+ /**
+ * @param recipe a collection of arcane crafting recipes.
+ */
+ public ResearchPage(IArcaneRecipe[] recipe) {
+ this.type = PageType.ARCANE_CRAFTING;
+ this.recipe = recipe;
+ }
+
+ /**
+ * @param recipe a collection of arcane crafting recipes.
+ */
+ public ResearchPage(CrucibleRecipe[] recipe) {
+ this.type = PageType.CRUCIBLE_CRAFTING;
+ this.recipe = recipe;
+ }
+
+ /**
+ * @param recipe a collection of infusion crafting recipes.
+ */
+ public ResearchPage(InfusionRecipe[] recipe) {
+ this.type = PageType.INFUSION_CRAFTING;
+ this.recipe = recipe;
+ }
+
+ /**
+ * @param recipe a compound crafting recipe.
+ */
+ public ResearchPage(List recipe) {
+ this.type = PageType.COMPOUND_CRAFTING;
+ this.recipe = recipe;
+ }
+
+ /**
+ * @param recipe an arcane worktable crafting recipe.
+ */
+ public ResearchPage(IArcaneRecipe recipe) {
+ this.type = PageType.ARCANE_CRAFTING;
+ this.recipe = recipe;
+ this.recipeOutput = recipe.getRecipeOutput();
+ }
+
+ /**
+ * @param recipe an alchemy crafting recipe.
+ */
+ public ResearchPage(CrucibleRecipe recipe) {
+ this.type = PageType.CRUCIBLE_CRAFTING;
+ this.recipe = recipe;
+ this.recipeOutput = recipe.getRecipeOutput();
+ }
+
+ /**
+ * @param recipe a furnace smelting crafting recipe.
+ */
+ public ResearchPage(ItemStack input) {
+ this.type = PageType.SMELTING;
+ this.recipe = input;
+ this.recipeOutput = FurnaceRecipes.smelting().getSmeltingResult(input);
+ }
+
+ /**
+ * @param recipe an infusion crafting recipe.
+ */
+ public ResearchPage(InfusionRecipe recipe) {
+ this.type = PageType.INFUSION_CRAFTING;
+ this.recipe = recipe;
+ if (recipe.getRecipeOutput() instanceof ItemStack) {
+ this.recipeOutput = (ItemStack) recipe.getRecipeOutput();
+ } else {
+ this.recipeOutput = recipe.getRecipeInput();
+ }
+ }
+
+ /**
+ * @param recipe an infusion crafting recipe.
+ */
+ public ResearchPage(InfusionEnchantmentRecipe recipe) {
+ this.type = PageType.INFUSION_ENCHANTMENT;
+ this.recipe = recipe;
+// if (recipe.recipeOutput instanceof ItemStack) {
+// this.recipeOutput = (ItemStack) recipe.recipeOutput;
+// } else {
+// this.recipeOutput = recipe.recipeInput;
+// }
+ }
+
+ /**
+ * @param image
+ * @param caption this can (but does not have to) be a reference to a localization variable, not the actual text.
+ */
+ public ResearchPage(ResourceLocation image, String caption) {
+ this.type = PageType.IMAGE;
+ this.image = image;
+ this.text = caption;
+ }
+
+ /**
+ * This function should really not be called directly - used internally
+ */
+ public ResearchPage(AspectList as) {
+ this.type = PageType.ASPECTS;
+ this.aspects = as;
+ }
+
+ /**
+ * returns a localized text of the text field (if one exists). Returns the text field itself otherwise.
+ * @return
+ */
+ public String getTranslatedText() {
+ String ret="";
+ if (text != null) {
+ ret = StatCollector.translateToLocal(text);
+ if (ret.isEmpty()) ret = text;
+ }
+ return ret;
+ }
+
+
+}
diff --git a/src-backup/api/java/thaumcraft/api/research/ScanResult.java b/src-backup/api/java/thaumcraft/api/research/ScanResult.java
new file mode 100644
index 00000000..e1498f31
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/research/ScanResult.java
@@ -0,0 +1,39 @@
+package thaumcraft.api.research;
+
+import net.minecraft.entity.Entity;
+
+public class ScanResult {
+ public byte type = 0; //1=blocks,2=entities,3=phenomena
+ public int id;
+ public int meta;
+ public Entity entity;
+ public String phenomena;
+
+ public ScanResult(byte type, int blockId, int blockMeta, Entity entity,
+ String phenomena) {
+ super();
+ this.type = type;
+ this.id = blockId;
+ this.meta = blockMeta;
+ this.entity = entity;
+ this.phenomena = phenomena;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (obj instanceof ScanResult) {
+ ScanResult sr = (ScanResult) obj;
+ if (type != sr.type)
+ return false;
+ if (type == 1
+ && (id != sr.id || meta != sr.meta))
+ return false;
+ if (type == 2 && entity.getEntityId() != sr.entity.getEntityId())
+ return false;
+ if (type == 3 && !phenomena.equals(sr.phenomena))
+ return false;
+ }
+ return true;
+ }
+
+}
diff --git a/src-backup/api/java/thaumcraft/api/visnet/TileVisNode.java b/src-backup/api/java/thaumcraft/api/visnet/TileVisNode.java
new file mode 100644
index 00000000..84b1400d
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/visnet/TileVisNode.java
@@ -0,0 +1,188 @@
+package thaumcraft.api.visnet;
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashMap;
+
+import thaumcraft.api.TileThaumcraft;
+import thaumcraft.api.WorldCoordinates;
+import thaumcraft.api.aspects.Aspect;
+
+/**
+ * @author Azanor
+ *
+ * The tile entity used by nodes in the vis energy network. A node is either a source (like an aura node),
+ * a transport relay or vis receiver (like the infernal furnace).
+ *
+ */
+public abstract class TileVisNode extends TileThaumcraft {
+
+ WeakReference parent = null;
+ ArrayList> children = new ArrayList>();
+
+ /**
+ * @return the WorldCoordinates location of where this node is located
+ */
+ public WorldCoordinates getLocation() {
+ return new WorldCoordinates(this);
+ }
+
+ /**
+ * @return the number of blocks away this node will check for parent nodes to connect to.
+ */
+ public abstract int getRange();
+
+ /**
+ * @return true if this is the source or root node of the vis network.
+ */
+ public abstract boolean isSource();
+
+ /**
+ * This method should never be called directly. Use VisNetHandler.drainVis() instead
+ * @param aspect what aspect to drain
+ * @param vis how much to drain
+ * @return how much was actually drained
+ */
+ public int consumeVis(Aspect aspect, int vis) {
+ if (VisNetHandler.isNodeValid(getParent())) {
+ int out = getParent().get().consumeVis(aspect, vis);
+ if (out>0) {
+ triggerConsumeEffect(aspect);
+ }
+ return out;
+ }
+ return 0;
+ }
+
+ public void removeThisNode() {
+ for (WeakReference n:getChildren()) {
+ if (n!=null && n.get()!=null) {
+ n.get().removeThisNode();
+ }
+ }
+
+ children = new ArrayList>();
+ if (VisNetHandler.isNodeValid(this.getParent())) {
+ this.getParent().get().nodeRefresh=true;
+ }
+ this.setParent(null);
+ this.parentChanged();
+
+ if (this.isSource()) {
+ HashMap> sourcelist = VisNetHandler.sources.get(worldObj.provider.dimensionId);
+ if (sourcelist==null) {
+ sourcelist = new HashMap>();
+ }
+ sourcelist.remove(getLocation());
+ VisNetHandler.sources.put( worldObj.provider.dimensionId, sourcelist );
+ }
+
+ worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+ }
+
+
+
+ @Override
+ public void invalidate() {
+ removeThisNode();
+ super.invalidate();
+ }
+
+ public void triggerConsumeEffect(Aspect aspect) { }
+
+ /**
+ * @return
+ */
+ public WeakReference getParent() {
+ return parent;
+ }
+
+ /**
+ * @return
+ */
+ public WeakReference getRootSource() {
+ return VisNetHandler.isNodeValid(getParent()) ?
+ getParent().get().getRootSource() : this.isSource() ?
+ new WeakReference(this) : null;
+ }
+
+ /**
+ * @param parent
+ */
+ public void setParent(WeakReference parent) {
+ this.parent = parent;
+ }
+
+ /**
+ * @return
+ */
+ public ArrayList> getChildren() {
+ return children;
+ }
+
+ @Override
+ public boolean canUpdate() {
+ return true;
+ }
+
+ protected int nodeCounter = 0;
+ private boolean nodeRegged = false;
+ public boolean nodeRefresh = false;
+
+ @Override
+ public void updateEntity() {
+
+ if (!worldObj.isRemote && ((nodeCounter++) % 40==0 || nodeRefresh)) {
+ //check for changes
+ if (!nodeRefresh && children.size()>0) {
+ for (WeakReference n:children) {
+ if (n==null || n.get()==null) {
+ nodeRefresh=true;
+ break;
+ }
+ }
+ }
+
+ //refresh linked nodes
+ if (nodeRefresh) {
+ for (WeakReference n:children) {
+ if (n.get()!=null) {
+ n.get().nodeRefresh=true;
+ }
+ }
+ children.clear();
+ parent=null;
+ }
+
+ //redo stuff
+ if (isSource() && !nodeRegged) {
+ VisNetHandler.addSource(getWorldObj(), this);
+ nodeRegged = true;
+ } else
+ if (!isSource() && !VisNetHandler.isNodeValid(getParent())) {
+ setParent(VisNetHandler.addNode(getWorldObj(), this));
+ nodeRefresh=true;
+ }
+
+ if (nodeRefresh) {
+ worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+ parentChanged();
+ }
+ nodeRefresh=false;
+ }
+
+ }
+
+ public void parentChanged() { }
+
+ /**
+ * @return the type of shard this is attuned to:
+ * none -1, air 0, fire 1, water 2, earth 3, order 4, entropy 5
+ * Should return -1 for most implementations
+ */
+ public byte getAttunement() {
+ return -1;
+ }
+
+
+}
diff --git a/src-backup/api/java/thaumcraft/api/visnet/VisNetHandler.java b/src-backup/api/java/thaumcraft/api/visnet/VisNetHandler.java
new file mode 100644
index 00000000..baf46d8e
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/visnet/VisNetHandler.java
@@ -0,0 +1,284 @@
+package thaumcraft.api.visnet;
+
+import java.lang.ref.WeakReference;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.HashMap;
+
+import net.minecraft.world.World;
+import thaumcraft.api.WorldCoordinates;
+import thaumcraft.api.aspects.Aspect;
+import cpw.mods.fml.common.FMLLog;
+
+public class VisNetHandler {
+
+ // / NODE DRAINING
+ /**
+ * This method drains vis from a relay or source near the passed in
+ * location. The amount received can be less than the amount requested so
+ * take that into account.
+ *
+ * @param world
+ * @param x the x position of the draining block or entity
+ * @param y the y position of the draining block or entity
+ * @param z the z position of the draining block or entity
+ * @param aspect what aspect to drain
+ * @param vis how much to drain
+ * @return how much was actually drained
+ */
+ public static int drainVis(World world, int x, int y, int z, Aspect aspect, int amount) {
+
+ int drainedAmount = 0;
+
+ WorldCoordinates drainer = new WorldCoordinates(x, y, z,
+ world.provider.dimensionId);
+ if (!nearbyNodes.containsKey(drainer)) {
+ calculateNearbyNodes(world, x, y, z);
+ }
+
+ ArrayList> nodes = nearbyNodes.get(drainer);
+ if (nodes!=null && nodes.size()>0)
+ for (WeakReference noderef : nodes) {
+
+ TileVisNode node = noderef.get();
+
+ if (node == null) continue;
+
+ int a = node.consumeVis(aspect, amount);
+ drainedAmount += a;
+ amount -= a;
+ if (a>0) {
+ int color = Aspect.getPrimalAspects().indexOf(aspect);
+ generateVisEffect(world.provider.dimensionId, x, y, z, node.xCoord, node.yCoord, node.zCoord, color);
+ }
+ if (amount <= 0) {
+ break;
+ }
+ }
+
+ return drainedAmount;
+ }
+
+ static Method generateVisEffect;
+ public static void generateVisEffect(int dim, int x, int y, int z, int x2, int y2, int z2, int color) {
+ try {
+ if(generateVisEffect == null) {
+ Class fake = Class.forName("thaumcraft.common.lib.Utils");
+ generateVisEffect = fake.getMethod("generateVisEffect", int.class, int.class, int.class, int.class, int.class, int.class, int.class, int.class);
+ }
+ generateVisEffect.invoke(null, dim, x,y,z,x2,y2,z2,color);
+ } catch(Exception ex) {
+ FMLLog.warning("[Thaumcraft API] Could not invoke thaumcraft.common.lib.Utils method generateVisEffect");
+ }
+ }
+
+ public static HashMap>> sources = new HashMap>>();
+
+ public static void addSource(World world, TileVisNode vs) {
+ HashMap> sourcelist = sources
+ .get(world.provider.dimensionId);
+ if (sourcelist == null) {
+ sourcelist = new HashMap>();
+ }
+ sourcelist.put(vs.getLocation(), new WeakReference(vs));
+ sources.put(world.provider.dimensionId, sourcelist);
+ nearbyNodes.clear();
+ }
+
+ public static boolean isNodeValid(WeakReference node) {
+ if (node == null || node.get() == null || node.get().isInvalid())
+ return false;
+ return true;
+ }
+
+ public static WeakReference addNode(World world, TileVisNode vn) {
+ WeakReference ref = new WeakReference(vn);
+
+ HashMap> sourcelist = sources
+ .get(world.provider.dimensionId);
+ if (sourcelist == null) {
+ sourcelist = new HashMap>();
+ return null;
+ }
+
+ ArrayList nearby = new ArrayList();
+
+ for (WeakReference root : sourcelist.values()) {
+ if (!isNodeValid(root))
+ continue;
+
+ TileVisNode source = root.get();
+
+ float r = inRange(world, vn.getLocation(), source.getLocation(),
+ vn.getRange());
+ if (r > 0) {
+ nearby.add(new Object[] { source, r - vn.getRange() * 2 });
+ }
+ nearby = findClosestNodes(vn, source, nearby);
+ }
+
+ float dist = Float.MAX_VALUE;
+ TileVisNode closest = null;
+ if (nearby.size() > 0) {
+ for (Object[] o : nearby) {
+ if ((Float) o[1] < dist) {// && canNodeBeSeen(vn,(TileVisNode)
+ // o[0])) {
+ dist = (Float) o[1];
+ closest = (TileVisNode) o[0];
+ }
+ }
+ }
+ if (closest != null) {
+ closest.getChildren().add(ref);
+ nearbyNodes.clear();
+ return new WeakReference(closest);
+ }
+
+ return null;
+ }
+
+ public static ArrayList findClosestNodes(TileVisNode target,
+ TileVisNode root, ArrayList in) {
+ TileVisNode closestChild = null;
+
+ for (WeakReference child : root.getChildren()) {
+ TileVisNode n = child.get();
+
+ if (n != null
+ && !n.equals(target)
+ && !n.equals(root)
+ && (target.getAttunement() == -1 || n.getAttunement() == -1 || n
+ .getAttunement() == target.getAttunement())) {
+
+ float r2 = inRange(n.getWorldObj(), n.getLocation(),
+ target.getLocation(), target.getRange());
+ if (r2 > 0) {
+ in.add(new Object[] { n, r2 });
+ }
+
+ in = findClosestNodes(target, n, in);
+ }
+ }
+ return in;
+ }
+
+ private static float inRange(World world, WorldCoordinates cc1,
+ WorldCoordinates cc2, int range) {
+ float distance = cc1.getDistanceSquaredToWorldCoordinates(cc2);
+ return distance > range * range ? -1 : distance;
+ }
+
+ private static HashMap>> nearbyNodes = new HashMap>>();
+
+ private static void calculateNearbyNodes(World world, int x, int y, int z) {
+
+ HashMap> sourcelist = sources
+ .get(world.provider.dimensionId);
+ if (sourcelist == null) {
+ sourcelist = new HashMap>();
+ return;
+ }
+
+ ArrayList> cn = new ArrayList>();
+ WorldCoordinates drainer = new WorldCoordinates(x, y, z,
+ world.provider.dimensionId);
+
+ ArrayList nearby = new ArrayList();
+
+ for (WeakReference root : sourcelist.values()) {
+
+ if (!isNodeValid(root))
+ continue;
+
+ TileVisNode source = root.get();
+
+ TileVisNode closest = null;
+ float range = Float.MAX_VALUE;
+
+ float r = inRange(world, drainer, source.getLocation(),
+ source.getRange());
+ if (r > 0) {
+ range = r;
+ closest = source;
+ }
+
+ ArrayList> children = new ArrayList>();
+ children = getAllChildren(source,children);
+
+ for (WeakReference child : children) {
+ TileVisNode n = child.get();
+ if (n != null && !n.equals(root)) {
+
+ float r2 = inRange(n.getWorldObj(), n.getLocation(),
+ drainer, n.getRange());
+ if (r2 > 0 && r2 < range) {
+ range = r2;
+ closest = n;
+ }
+ }
+ }
+
+ if (closest != null) {
+
+ cn.add(new WeakReference(closest));
+ }
+ }
+
+ nearbyNodes.put(drainer, cn);
+ }
+
+ private static ArrayList> getAllChildren(TileVisNode source, ArrayList> list) {
+ for (WeakReference child : source.getChildren()) {
+ TileVisNode n = child.get();
+ if (n != null) {
+ list.add(child);
+ list = getAllChildren(n,list);
+ }
+ }
+ return list;
+ }
+
+ // public static boolean canNodeBeSeen(TileVisNode source,TileVisNode
+ // target)
+ // {
+ // double d = Math.sqrt(source.getDistanceFrom(target.xCoord, target.yCoord,
+ // target.zCoord));
+ // double xd = (source.xCoord-target.xCoord) / d;
+ // double yd = (source.yCoord-target.yCoord) / d;
+ // double zd = (source.zCoord-target.zCoord) / d;
+ // return source.getWorldObj().rayTraceBlocks(
+ // Vec3.createVectorHelper(source.xCoord-xd+.5+.5, source.yCoord-yd,
+ // source.zCoord-zd),
+ // Vec3.createVectorHelper(target.xCoord+.5, target.yCoord+.5,
+ // target.zCoord+.5)) == null;
+ // }
+
+ // public static HashMap>
+ // noderef = new HashMap>();
+ //
+ // public static TileVisNode getClosestNodeWithinRadius(World world, int x,
+ // int y, int z, int radius) {
+ // TileVisNode out = null;
+ // WorldCoordinates wc = null;
+ // float cd = Float.MAX_VALUE;
+ // for (int sx = x - radius; sx <= x + radius; sx++) {
+ // for (int sy = y - radius; sy <= y + radius; sy++) {
+ // for (int sz = z - radius; sz <= z + radius; sz++) {
+ // wc = new WorldCoordinates(sx,sy,sz,world.provider.dimensionId);
+ // if (noderef.containsKey(wc)) {
+ // float d = wc.getDistanceSquared(x, y, z);
+ // if (dAs a guide build the sort string from two alphanumeric characters followed by
+ * two numeric characters based on... whatever.
+ */
+ public String getSortingHelper(ItemStack itemstack);
+
+ boolean onFocusBlockStartBreak(ItemStack itemstack, int x, int y, int z, EntityPlayer player);
+
+ public boolean acceptsEnchant(int id);
+
+
+
+
+
+}
diff --git a/src-backup/api/java/thaumcraft/api/wands/IWandRodOnUpdate.java b/src-backup/api/java/thaumcraft/api/wands/IWandRodOnUpdate.java
new file mode 100644
index 00000000..4ef8c849
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/wands/IWandRodOnUpdate.java
@@ -0,0 +1,16 @@
+package thaumcraft.api.wands;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+
+/**
+ *
+ * @author azanor
+ *
+ * Implemented by a class that you wish to be called whenever a wand with this rod performs its
+ * update tick.
+ *
+ */
+public interface IWandRodOnUpdate {
+ void onUpdate(ItemStack itemstack, EntityPlayer player);
+}
diff --git a/src-backup/api/java/thaumcraft/api/wands/IWandTriggerManager.java b/src-backup/api/java/thaumcraft/api/wands/IWandTriggerManager.java
new file mode 100644
index 00000000..47465552
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/wands/IWandTriggerManager.java
@@ -0,0 +1,12 @@
+package thaumcraft.api.wands;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+
+public interface IWandTriggerManager {
+
+ public boolean performTrigger(World world, ItemStack wand, EntityPlayer player,
+ int x, int y, int z, int side, int event);
+
+}
diff --git a/src-backup/api/java/thaumcraft/api/wands/IWandable.java b/src-backup/api/java/thaumcraft/api/wands/IWandable.java
new file mode 100644
index 00000000..aeb9bac7
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/wands/IWandable.java
@@ -0,0 +1,25 @@
+package thaumcraft.api.wands;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+
+/**
+ *
+ * @author azanor
+ *
+ * Add this to a tile entity that you wish wands to interact with in some way.
+ *
+ */
+
+public interface IWandable {
+
+ public int onWandRightClick(World world, ItemStack wandstack, EntityPlayer player, int x, int y, int z, int side, int md);
+
+ public ItemStack onWandRightClick(World world, ItemStack wandstack, EntityPlayer player);
+
+ public void onUsingWandTick(ItemStack wandstack, EntityPlayer player, int count);
+
+ public void onWandStoppedUsing(ItemStack wandstack, World world, EntityPlayer player, int count);
+
+}
diff --git a/src-backup/api/java/thaumcraft/api/wands/ItemFocusBasic.java b/src-backup/api/java/thaumcraft/api/wands/ItemFocusBasic.java
new file mode 100644
index 00000000..35900520
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/wands/ItemFocusBasic.java
@@ -0,0 +1,166 @@
+package thaumcraft.api.wands;
+
+import java.text.DecimalFormat;
+import java.util.List;
+import java.util.Map;
+
+import net.minecraft.enchantment.EnchantmentHelper;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.EnumRarity;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.util.StatCollector;
+import net.minecraft.world.World;
+import thaumcraft.api.ThaumcraftApi;
+import thaumcraft.api.aspects.Aspect;
+import thaumcraft.api.aspects.AspectList;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class ItemFocusBasic extends Item implements IWandFocus {
+
+ public ItemFocusBasic ()
+ {
+ super();
+ maxStackSize = 1;
+ canRepair=false;
+ this.setMaxDamage(0);
+ }
+
+ public IIcon icon;
+
+ @SideOnly(Side.CLIENT)
+ @Override
+ public IIcon getIconFromDamage(int par1) {
+ return icon;
+ }
+
+ @Override
+ public boolean isItemTool(ItemStack par1ItemStack)
+ {
+ return true;
+ }
+
+ @Override
+ public boolean isDamageable() {
+ return true;
+ }
+
+ @Override
+ public void addInformation(ItemStack stack,EntityPlayer player, List list, boolean par4) {
+ AspectList al = this.getVisCost();
+ if (al!=null && al.size()>0) {
+ list.add(StatCollector.translateToLocal(isVisCostPerTick()?"item.Focus.cost2":"item.Focus.cost1"));
+ for (Aspect aspect:al.getAspectsSorted()) {
+ DecimalFormat myFormatter = new DecimalFormat("#####.##");
+ String amount = myFormatter.format(al.getAmount(aspect)/100f);
+ list.add(" \u00A7"+aspect.getChatcolor()+aspect.getName()+"\u00A7r x "+ amount);
+
+ }
+ }
+ }
+
+ @Override
+ public int getItemEnchantability() {
+ return 5;
+ }
+
+ @Override
+ public EnumRarity getRarity(ItemStack itemstack)
+ {
+ return EnumRarity.rare;
+ }
+
+
+ @Override
+ public int getFocusColor() {
+ // TODO Auto-generated method stub
+ return 0;
+ }
+
+ @Override
+ public AspectList getVisCost() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public ItemStack onFocusRightClick(ItemStack itemstack, World world,
+ EntityPlayer player, MovingObjectPosition movingobjectposition) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public void onUsingFocusTick(ItemStack itemstack, EntityPlayer player,
+ int count) {
+ // TODO Auto-generated method stub
+ }
+
+ @Override
+ public void onPlayerStoppedUsingFocus(ItemStack itemstack, World world,
+ EntityPlayer player, int count) {
+ // TODO Auto-generated method stub
+
+ }
+
+ /**
+ * Just insert two alphanumeric characters before this string in your focus item class
+ */
+ @Override
+ public String getSortingHelper(ItemStack itemstack) {
+ Map ench = EnchantmentHelper.getEnchantments(itemstack);
+ String out="";
+ for (Integer lvl:ench.values()) {
+ out = out + lvl + "";
+ }
+ return out;
+ }
+
+ @Override
+ public boolean isVisCostPerTick() {
+ return false;
+ }
+
+ @Override
+ public IIcon getOrnament() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public boolean onFocusBlockStartBreak(ItemStack itemstack, int x, int y,
+ int z, EntityPlayer player) {
+ // TODO Auto-generated method stub
+ return false;
+ }
+
+ @Override
+ public WandFocusAnimation getAnimation() {
+ return WandFocusAnimation.WAVE;
+ }
+
+ @Override
+ public IIcon getFocusDepthLayerIcon() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ /**
+ * @see thaumcraft.api.wands.IWandFocus#acceptsEnchant(int)
+ * By default fortune is off for all wands
+ **/
+ @Override
+ public boolean acceptsEnchant(int id) {
+ if (id==ThaumcraftApi.enchantFrugal||
+ id==ThaumcraftApi.enchantPotency) return true;
+ return false;
+ }
+
+
+
+
+
+}
diff --git a/src-backup/api/java/thaumcraft/api/wands/StaffRod.java b/src-backup/api/java/thaumcraft/api/wands/StaffRod.java
new file mode 100644
index 00000000..e7ae90f0
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/wands/StaffRod.java
@@ -0,0 +1,48 @@
+package thaumcraft.api.wands;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ResourceLocation;
+
+/**
+ *
+ * @author Azanor
+ *
+ * This class is used to keep the material information for the various rods.
+ * It is also used to generate the wand recipes ingame.
+ *
+ */
+public class StaffRod extends WandRod {
+
+ boolean runes=false;
+
+ public StaffRod(String tag, int capacity, ItemStack item, int craftCost) {
+ super(tag+"_staff", capacity, item, craftCost);
+ this.texture = new ResourceLocation("thaumcraft","textures/models/wand_rod_"+tag+".png");
+ }
+
+ public StaffRod(String tag, int capacity, ItemStack item, int craftCost,
+ IWandRodOnUpdate onUpdate, ResourceLocation texture) {
+ super(tag+"_staff", capacity, item, craftCost, onUpdate, texture);
+ }
+
+ public StaffRod(String tag, int capacity, ItemStack item, int craftCost,
+ IWandRodOnUpdate onUpdate) {
+ super(tag+"_staff", capacity, item, craftCost, onUpdate);
+ this.texture = new ResourceLocation("thaumcraft","textures/models/wand_rod_"+tag+".png");
+ }
+
+ public StaffRod(String tag, int capacity, ItemStack item, int craftCost,
+ ResourceLocation texture) {
+ super(tag+"_staff", capacity, item, craftCost, texture);
+ }
+
+ public boolean hasRunes() {
+ return runes;
+ }
+
+ public void setRunes(boolean hasRunes) {
+ this.runes = hasRunes;
+ }
+
+
+}
diff --git a/src-backup/api/java/thaumcraft/api/wands/WandCap.java b/src-backup/api/java/thaumcraft/api/wands/WandCap.java
new file mode 100644
index 00000000..17b4581c
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/wands/WandCap.java
@@ -0,0 +1,129 @@
+package thaumcraft.api.wands;
+
+import java.util.LinkedHashMap;
+import java.util.List;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ResourceLocation;
+import thaumcraft.api.aspects.Aspect;
+
+/**
+ * This class is used to keep the material information for the various caps.
+ * It is also used to generate the wand recipes ingame.
+ * @author Azanor
+ *
+ */
+public class WandCap {
+
+ private String tag;
+
+ /**
+ * Cost to craft this wand. Combined with the rod cost.
+ */
+ private int craftCost;
+
+ /**
+ * the amount by which all aspect costs are multiplied
+ */
+ float baseCostModifier;
+
+ /**
+ * specifies a list of primal aspects that use the special discount figure instead of the normal discount.
+ */
+ List specialCostModifierAspects;
+
+ /**
+ * the amount by which the specified aspect costs are multiplied
+ */
+ float specialCostModifier;
+
+ /**
+ * The texture that will be used for the ingame wand cap
+ */
+ ResourceLocation texture;
+
+ /**
+ * the actual item that makes up this cap and will be used to generate the wand recipes
+ */
+ ItemStack item;
+
+ public static LinkedHashMap caps = new LinkedHashMap();
+
+ public WandCap (String tag, float discount, ItemStack item, int craftCost) {
+ this.setTag(tag);
+ this.baseCostModifier = discount;
+ this.specialCostModifierAspects = null;
+ texture = new ResourceLocation("thaumcraft","textures/models/wand_cap_"+getTag()+".png");
+ this.item=item;
+ this.setCraftCost(craftCost);
+ caps.put(tag, this);
+ }
+
+ public WandCap (String tag, float discount, List specialAspects, float discountSpecial, ItemStack item, int craftCost) {
+ this.setTag(tag);
+ this.baseCostModifier = discount;
+ this.specialCostModifierAspects = specialAspects;
+ this.specialCostModifier = discountSpecial;
+ texture = new ResourceLocation("thaumcraft","textures/models/wand_cap_"+getTag()+".png");
+ this.item=item;
+ this.setCraftCost(craftCost);
+ caps.put(tag, this);
+ }
+
+ public float getBaseCostModifier() {
+ return baseCostModifier;
+ }
+
+ public List getSpecialCostModifierAspects() {
+ return specialCostModifierAspects;
+ }
+
+ public float getSpecialCostModifier() {
+ return specialCostModifier;
+ }
+
+ public ResourceLocation getTexture() {
+ return texture;
+ }
+
+ public void setTexture(ResourceLocation texture) {
+ this.texture = texture;
+ }
+
+ public String getTag() {
+ return tag;
+ }
+
+ public void setTag(String tag) {
+ this.tag = tag;
+ }
+
+
+ public ItemStack getItem() {
+ return item;
+ }
+
+ public void setItem(ItemStack item) {
+ this.item = item;
+ }
+
+ public int getCraftCost() {
+ return craftCost;
+ }
+
+ public void setCraftCost(int craftCost) {
+ this.craftCost = craftCost;
+ }
+
+ /**
+ * The research a player needs to have finished to be able to craft a wand with this cap.
+ */
+ public String getResearch() {
+ return "CAP_"+getTag();
+ }
+
+ // Some examples:
+ // WandCap WAND_CAP_IRON = new WandCap("iron", 1.1f, Arrays.asList(Aspect.ORDER),1, new ItemStack(ConfigItems.itemWandCap,1,0),1);
+ // WandCap WAND_CAP_GOLD = new WandCap("gold", 1f, new ItemStack(ConfigItems.itemWandCap,1,1),3);
+
+}
diff --git a/src-backup/api/java/thaumcraft/api/wands/WandRod.java b/src-backup/api/java/thaumcraft/api/wands/WandRod.java
new file mode 100644
index 00000000..85954e46
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/wands/WandRod.java
@@ -0,0 +1,158 @@
+package thaumcraft.api.wands;
+
+import java.util.LinkedHashMap;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ResourceLocation;
+
+/**
+ *
+ * @author Azanor
+ *
+ * This class is used to keep the material information for the various rods.
+ * It is also used to generate the wand recipes ingame.
+ *
+ */
+public class WandRod {
+
+
+ private String tag;
+
+ /**
+ * Cost to craft this wand. Combined with the rod cost.
+ */
+ private int craftCost;
+
+ /**
+ * The amount of vis that can be stored - this number is actually multiplied
+ * by 100 for use by the wands internals
+ */
+ int capacity;
+
+ /**
+ * The texture that will be used for the ingame wand rod
+ */
+ protected ResourceLocation texture;
+
+ /**
+ * the actual item that makes up this rod and will be used to generate the wand recipes
+ */
+ ItemStack item;
+
+ /**
+ * A class that will be called whenever the wand onUpdate tick is run
+ */
+ IWandRodOnUpdate onUpdate;
+
+ /**
+ * Does the rod glow in the dark?
+ */
+ boolean glow;
+
+ public static LinkedHashMap rods = new LinkedHashMap();
+
+ public WandRod (String tag, int capacity, ItemStack item, int craftCost, ResourceLocation texture) {
+ this.setTag(tag);
+ this.capacity = capacity;
+ this.texture = texture;
+ this.item=item;
+ this.setCraftCost(craftCost);
+ rods.put(tag, this);
+ }
+
+ public WandRod (String tag, int capacity, ItemStack item, int craftCost, IWandRodOnUpdate onUpdate, ResourceLocation texture) {
+ this.setTag(tag);
+ this.capacity = capacity;
+ this.texture = texture;
+ this.item=item;
+ this.setCraftCost(craftCost);
+ rods.put(tag, this);
+ this.onUpdate = onUpdate;
+ }
+
+ public WandRod (String tag, int capacity, ItemStack item, int craftCost) {
+ this.setTag(tag);
+ this.capacity = capacity;
+ this.texture = new ResourceLocation("thaumcraft","textures/models/wand_rod_"+getTag()+".png");
+ this.item=item;
+ this.setCraftCost(craftCost);
+ rods.put(tag, this);
+ }
+
+ public WandRod (String tag, int capacity, ItemStack item, int craftCost, IWandRodOnUpdate onUpdate) {
+ this.setTag(tag);
+ this.capacity = capacity;
+ this.texture = new ResourceLocation("thaumcraft","textures/models/wand_rod_"+getTag()+".png");
+ this.item=item;
+ this.setCraftCost(craftCost);
+ rods.put(tag, this);
+ this.onUpdate = onUpdate;
+ }
+
+ public String getTag() {
+ return tag;
+ }
+
+ public void setTag(String tag) {
+ this.tag = tag;
+ }
+
+ public int getCapacity() {
+ return capacity;
+ }
+
+ public void setCapacity(int capacity) {
+ this.capacity = capacity;
+ }
+
+ public ResourceLocation getTexture() {
+ return texture;
+ }
+
+ public void setTexture(ResourceLocation texture) {
+ this.texture = texture;
+ }
+
+ public ItemStack getItem() {
+ return item;
+ }
+
+ public void setItem(ItemStack item) {
+ this.item = item;
+ }
+
+ public int getCraftCost() {
+ return craftCost;
+ }
+
+ public void setCraftCost(int craftCost) {
+ this.craftCost = craftCost;
+ }
+
+ public IWandRodOnUpdate getOnUpdate() {
+ return onUpdate;
+ }
+
+ public void setOnUpdate(IWandRodOnUpdate onUpdate) {
+ this.onUpdate = onUpdate;
+ }
+
+ public boolean isGlowing() {
+ return glow;
+ }
+
+ public void setGlowing(boolean hasGlow) {
+ this.glow = hasGlow;
+ }
+
+ /**
+ * The research a player needs to have finished to be able to craft a wand with this rod.
+ */
+ public String getResearch() {
+ return "ROD_"+getTag();
+ }
+
+ // Some examples:
+ // WandRod WAND_ROD_WOOD = new WandRod("wood",25,new ItemStack(Item.stick),1);
+ // WandRod WAND_ROD_BLAZE = new WandRod("blaze",100,new ItemStack(Item.blazeRod),7,new WandRodBlazeOnUpdate());
+}
diff --git a/src-backup/api/java/thaumcraft/api/wands/WandTriggerRegistry.java b/src-backup/api/java/thaumcraft/api/wands/WandTriggerRegistry.java
new file mode 100644
index 00000000..68655cb7
--- /dev/null
+++ b/src-backup/api/java/thaumcraft/api/wands/WandTriggerRegistry.java
@@ -0,0 +1,72 @@
+package thaumcraft.api.wands;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+
+/**
+ * This class serves a similar function to IWandable in that it allows wands to interact
+ * with object in the world. In this case it is most useful for adding interaction with non-mod
+ * blocks where you can't control what happens in their code.
+ * Example where it is used is in crafting the thaumonomicon from a bookshelf and the
+ * crucible from a cauldron
+ *
+ * @author azanor
+ *
+ */
+public class WandTriggerRegistry {
+
+ /**
+ * Registers an action to perform when a casting wand right clicks on a specific block.
+ * A manager class needs to be created that implements IWandTriggerManager.
+ * @param manager
+ * @param event a logical number that you can use to differentiate different events or actions
+ * @param block
+ * @param meta send -1 as a wildcard value for all possible meta values
+ */
+ public static void registerWandBlockTrigger(IWandTriggerManager manager, int event, Block block, int meta) {
+ triggers.put(Arrays.asList(block,meta),
+ Arrays.asList(manager,event));
+
+ }
+
+ private static HashMap triggers = new HashMap();
+
+ public static boolean hasTrigger(Block block, int meta) {
+ if (triggers.containsKey(Arrays.asList(block,meta)) ||
+ triggers.containsKey(Arrays.asList(block,-1))) return true;
+ return false;
+ }
+
+ /**
+ * This is called by the onItemUseFirst function in wands.
+ * Parameters and return value functions like you would expect for that function.
+ * @param world
+ * @param wand
+ * @param player
+ * @param x
+ * @param y
+ * @param z
+ * @param side
+ * @param block
+ * @param meta
+ * @return
+ */
+ public static boolean performTrigger(World world, ItemStack wand, EntityPlayer player,
+ int x, int y, int z, int side, Block block, int meta) {
+
+ List l = triggers.get(Arrays.asList(block,meta));
+ if (l==null) l = triggers.get(Arrays.asList(block,-1));
+ if (l==null) return false;
+
+ IWandTriggerManager manager = (IWandTriggerManager) l.get(0);
+ int event = (Integer) l.get(1);
+ return manager.performTrigger(world, wand, player, x, y, z, side, event);
+ }
+
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/AlchemicalWizardry.java b/src-backup/main/java/WayofTime/alchemicalWizardry/AlchemicalWizardry.java
new file mode 100644
index 00000000..0bf14f74
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/AlchemicalWizardry.java
@@ -0,0 +1,1114 @@
+package WayofTime.alchemicalWizardry;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.List;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+
+import joshie.alchemicalWizardy.ShapedBloodOrbRecipe;
+import joshie.alchemicalWizardy.ShapelessBloodOrbRecipe;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.init.Blocks;
+import net.minecraft.init.Items;
+import net.minecraft.item.Item;
+import net.minecraft.item.Item.ToolMaterial;
+import net.minecraft.item.ItemArmor.ArmorMaterial;
+import net.minecraft.item.ItemStack;
+import net.minecraft.potion.Potion;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.WeightedRandomChestContent;
+import net.minecraftforge.common.ChestGenHooks;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.common.util.EnumHelper;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidContainerRegistry;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.oredict.OreDictionary;
+import net.minecraftforge.oredict.RecipeSorter;
+import net.minecraftforge.oredict.RecipeSorter.Category;
+import thaumcraft.api.ItemApi;
+import thaumcraft.api.ThaumcraftApi;
+import thaumcraft.api.aspects.Aspect;
+import thaumcraft.api.aspects.AspectList;
+import WayofTime.alchemicalWizardry.api.alchemy.AlchemicalPotionCreationHandler;
+import WayofTime.alchemicalWizardry.api.alchemy.AlchemyRecipeRegistry;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentRegistry;
+import WayofTime.alchemicalWizardry.api.altarRecipeRegistry.AltarRecipeRegistry;
+import WayofTime.alchemicalWizardry.api.bindingRegistry.BindingRegistry;
+import WayofTime.alchemicalWizardry.api.harvest.HarvestRegistry;
+import WayofTime.alchemicalWizardry.api.rituals.Rituals;
+import WayofTime.alchemicalWizardry.api.summoningRegistry.SummoningRegistry;
+import WayofTime.alchemicalWizardry.common.AlchemicalWizardryEventHooks;
+import WayofTime.alchemicalWizardry.common.AlchemicalWizardryFuelHandler;
+import WayofTime.alchemicalWizardry.common.CommonProxy;
+import WayofTime.alchemicalWizardry.common.EntityAirElemental;
+import WayofTime.alchemicalWizardry.common.LifeBucketHandler;
+import WayofTime.alchemicalWizardry.common.LifeEssence;
+import WayofTime.alchemicalWizardry.common.ModLivingDropsEvent;
+import WayofTime.alchemicalWizardry.common.NewPacketHandler;
+import WayofTime.alchemicalWizardry.common.alchemy.CombinedPotionRegistry;
+import WayofTime.alchemicalWizardry.common.block.ArmourForge;
+import WayofTime.alchemicalWizardry.common.bloodAltarUpgrade.UpgradedAltars;
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityBileDemon;
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityBoulderFist;
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityEarthElemental;
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityFallenAngel;
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityFireElemental;
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityHolyElemental;
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityIceDemon;
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityLowerGuardian;
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityShade;
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityShadeElemental;
+import WayofTime.alchemicalWizardry.common.entity.mob.EntitySmallEarthGolem;
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityWaterElemental;
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityWingedFireDemon;
+import WayofTime.alchemicalWizardry.common.harvest.BloodMagicHarvestHandler;
+import WayofTime.alchemicalWizardry.common.harvest.CactusReedHarvestHandler;
+import WayofTime.alchemicalWizardry.common.harvest.GourdHarvestHandler;
+import WayofTime.alchemicalWizardry.common.harvest.PamHarvestCompatRegistry;
+import WayofTime.alchemicalWizardry.common.items.ItemRitualDiviner;
+import WayofTime.alchemicalWizardry.common.items.sigil.SigilOfHolding;
+import WayofTime.alchemicalWizardry.common.items.thaumcraft.ItemSanguineArmour;
+import WayofTime.alchemicalWizardry.common.potion.PotionBoost;
+import WayofTime.alchemicalWizardry.common.potion.PotionDeaf;
+import WayofTime.alchemicalWizardry.common.potion.PotionDrowning;
+import WayofTime.alchemicalWizardry.common.potion.PotionFeatherFall;
+import WayofTime.alchemicalWizardry.common.potion.PotionFireFuse;
+import WayofTime.alchemicalWizardry.common.potion.PotionFlameCloak;
+import WayofTime.alchemicalWizardry.common.potion.PotionFlight;
+import WayofTime.alchemicalWizardry.common.potion.PotionHeavyHeart;
+import WayofTime.alchemicalWizardry.common.potion.PotionIceCloak;
+import WayofTime.alchemicalWizardry.common.potion.PotionInhibit;
+import WayofTime.alchemicalWizardry.common.potion.PotionPlanarBinding;
+import WayofTime.alchemicalWizardry.common.potion.PotionProjectileProtect;
+import WayofTime.alchemicalWizardry.common.potion.PotionReciprocation;
+import WayofTime.alchemicalWizardry.common.potion.PotionSoulFray;
+import WayofTime.alchemicalWizardry.common.potion.PotionSoulHarden;
+import WayofTime.alchemicalWizardry.common.renderer.AlchemyCircleRenderer;
+import WayofTime.alchemicalWizardry.common.rituals.RitualEffectAnimalGrowth;
+import WayofTime.alchemicalWizardry.common.rituals.RitualEffectAutoAlchemy;
+import WayofTime.alchemicalWizardry.common.rituals.RitualEffectBiomeChanger;
+import WayofTime.alchemicalWizardry.common.rituals.RitualEffectContainment;
+import WayofTime.alchemicalWizardry.common.rituals.RitualEffectCrushing;
+import WayofTime.alchemicalWizardry.common.rituals.RitualEffectEllipsoid;
+import WayofTime.alchemicalWizardry.common.rituals.RitualEffectEvaporation;
+import WayofTime.alchemicalWizardry.common.rituals.RitualEffectExpulsion;
+import WayofTime.alchemicalWizardry.common.rituals.RitualEffectFeatheredEarth;
+import WayofTime.alchemicalWizardry.common.rituals.RitualEffectFeatheredKnife;
+import WayofTime.alchemicalWizardry.common.rituals.RitualEffectFlight;
+import WayofTime.alchemicalWizardry.common.rituals.RitualEffectFullStomach;
+import WayofTime.alchemicalWizardry.common.rituals.RitualEffectGrowth;
+import WayofTime.alchemicalWizardry.common.rituals.RitualEffectHarvest;
+import WayofTime.alchemicalWizardry.common.rituals.RitualEffectHealing;
+import WayofTime.alchemicalWizardry.common.rituals.RitualEffectInterdiction;
+import WayofTime.alchemicalWizardry.common.rituals.RitualEffectItemSuction;
+import WayofTime.alchemicalWizardry.common.rituals.RitualEffectJumping;
+import WayofTime.alchemicalWizardry.common.rituals.RitualEffectLava;
+import WayofTime.alchemicalWizardry.common.rituals.RitualEffectLeap;
+import WayofTime.alchemicalWizardry.common.rituals.RitualEffectLifeConduit;
+import WayofTime.alchemicalWizardry.common.rituals.RitualEffectMagnetic;
+import WayofTime.alchemicalWizardry.common.rituals.RitualEffectSoulBound;
+import WayofTime.alchemicalWizardry.common.rituals.RitualEffectSpawnWard;
+import WayofTime.alchemicalWizardry.common.rituals.RitualEffectSummonMeteor;
+import WayofTime.alchemicalWizardry.common.rituals.RitualEffectSupression;
+import WayofTime.alchemicalWizardry.common.rituals.RitualEffectUnbinding;
+import WayofTime.alchemicalWizardry.common.rituals.RitualEffectVeilOfEvil;
+import WayofTime.alchemicalWizardry.common.rituals.RitualEffectWater;
+import WayofTime.alchemicalWizardry.common.rituals.RitualEffectWellOfSuffering;
+import WayofTime.alchemicalWizardry.common.spell.simple.HomSpellRegistry;
+import WayofTime.alchemicalWizardry.common.spell.simple.SpellEarthBender;
+import WayofTime.alchemicalWizardry.common.spell.simple.SpellExplosions;
+import WayofTime.alchemicalWizardry.common.spell.simple.SpellFireBurst;
+import WayofTime.alchemicalWizardry.common.spell.simple.SpellFrozenWater;
+import WayofTime.alchemicalWizardry.common.spell.simple.SpellHolyBlast;
+import WayofTime.alchemicalWizardry.common.spell.simple.SpellLightningBolt;
+import WayofTime.alchemicalWizardry.common.spell.simple.SpellTeleport;
+import WayofTime.alchemicalWizardry.common.spell.simple.SpellWateryGrave;
+import WayofTime.alchemicalWizardry.common.spell.simple.SpellWindGust;
+import WayofTime.alchemicalWizardry.common.summoning.SummoningHelperAW;
+import WayofTime.alchemicalWizardry.common.summoning.meteor.MeteorRegistry;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEAlchemicCalcinator;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEAltar;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEBellJar;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEConduit;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEDemonPortal;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEHomHeart;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEMasterStone;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEOrientable;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEPedestal;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEPlinth;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEReagentConduit;
+import WayofTime.alchemicalWizardry.common.tileEntity.TESchematicSaver;
+import WayofTime.alchemicalWizardry.common.tileEntity.TESocket;
+import WayofTime.alchemicalWizardry.common.tileEntity.TESpectralBlock;
+import WayofTime.alchemicalWizardry.common.tileEntity.TESpectralContainer;
+import WayofTime.alchemicalWizardry.common.tileEntity.TESpellEffectBlock;
+import WayofTime.alchemicalWizardry.common.tileEntity.TESpellEnhancementBlock;
+import WayofTime.alchemicalWizardry.common.tileEntity.TESpellModifierBlock;
+import WayofTime.alchemicalWizardry.common.tileEntity.TESpellParadigmBlock;
+import WayofTime.alchemicalWizardry.common.tileEntity.TETeleposer;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEWritingTable;
+import WayofTime.alchemicalWizardry.common.tileEntity.gui.GuiHandler;
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.Loader;
+import cpw.mods.fml.common.Mod;
+import cpw.mods.fml.common.Mod.EventHandler;
+import cpw.mods.fml.common.Mod.Instance;
+import cpw.mods.fml.common.SidedProxy;
+import cpw.mods.fml.common.event.FMLInitializationEvent;
+import cpw.mods.fml.common.event.FMLPostInitializationEvent;
+import cpw.mods.fml.common.event.FMLPreInitializationEvent;
+import cpw.mods.fml.common.network.NetworkRegistry;
+import cpw.mods.fml.common.registry.EntityRegistry;
+import cpw.mods.fml.common.registry.GameRegistry;
+
+@Mod(modid = "AWWayofTime", name = "AlchemicalWizardry", version = "v1.2.0")
+//@NetworkMod(clientSideRequired = true, serverSideRequired = false, channels = {"BloodAltar", "particle", "SetLifeEssence", "GetLifeEssence", "Ritual", "GetAltarEssence", "TESocket", "TEWritingTable", "CustomParticle", "SetPlayerVel", "SetPlayerPos", "TEPedestal", "TEPlinth", "TETeleposer", "InfiniteLPPath", "TEOrientor"}, packetHandler = PacketHandler.class)
+
+public class AlchemicalWizardry
+{
+ public static boolean doMeteorsDestroyBlocks = true;
+ public static String[] diamondMeteorArray;
+ public static int diamondMeteorRadius;
+ public static String[] stoneMeteorArray;
+ public static int stoneMeteorRadius;
+ public static String[] ironBlockMeteorArray;
+ public static int ironBlockMeteorRadius;
+ public static String[] netherStarMeteorArray;
+ public static int netherStarMeteorRadius;
+
+ public static String[] allowedCrushedOresArray;
+
+ public static Potion customPotionDrowning;
+ public static Potion customPotionBoost;
+ public static Potion customPotionProjProt;
+ public static Potion customPotionInhibit;
+ public static Potion customPotionFlight;
+ public static Potion customPotionReciprocation;
+ public static Potion customPotionFlameCloak;
+ public static Potion customPotionIceCloak;
+ public static Potion customPotionHeavyHeart;
+ public static Potion customPotionFireFuse;
+ public static Potion customPotionPlanarBinding;
+ public static Potion customPotionSoulFray;
+ public static Potion customPotionSoulHarden;
+ public static Potion customPotionDeaf;
+ public static Potion customPotionFeatherFall;
+
+ public static int customPotionDrowningID;
+ public static int customPotionBoostID;
+ public static int customPotionProjProtID;
+ public static int customPotionInhibitID;
+ public static int customPotionFlightID;
+ public static int customPotionReciprocationID;
+ public static int customPotionFlameCloakID;
+ public static int customPotionIceCloakID;
+ public static int customPotionHeavyHeartID;
+ public static int customPotionFireFuseID;
+ public static int customPotionPlanarBindingID;
+ public static int customPotionSoulFrayID;
+ public static int customPotionSoulHardenID;
+ public static int customPotionDeafID;
+ public static int customPotionFeatherFallID;
+
+ public static boolean isThaumcraftLoaded;
+ public static boolean isForestryLoaded;
+
+ public static boolean wimpySettings;
+ public static boolean respawnWithDebuff;
+ public static boolean lockdownAltar;
+ public static boolean causeHungerWithRegen;
+
+ public static List wellBlacklist;
+
+ public static CreativeTabs tabBloodMagic = new CreativeTabs("tabBloodMagic")
+ {
+ @Override
+ public ItemStack getIconItemStack()
+ {
+ return new ItemStack(ModItems.weakBloodOrb, 1, 0);
+ }
+
+ @Override
+ public Item getTabIconItem()
+ {
+ return ModItems.weakBloodOrb;
+ }
+ };
+
+ public static ToolMaterial bloodBoundToolMaterial = EnumHelper.addToolMaterial("BoundBlood", 4, 1000, 12.0f, 8.0f, 50);
+ public static ArmorMaterial sanguineArmourArmourMaterial = EnumHelper.addArmorMaterial("SanguineArmour", 33, new int[]{3, 8, 6, 3}, 30);
+
+ //Dungeon loot chances
+ public static int standardBindingAgentDungeonChance;
+ public static int mundanePowerCatalystDungeonChance;
+ public static int averagePowerCatalystDungeonChance;
+ public static int greaterPowerCatalystDungeonChance;
+ public static int mundaneLengtheningCatalystDungeonChance;
+ public static int averageLengtheningCatalystDungeonChance;
+ public static int greaterLengtheningCatalystDungeonChance;
+
+ //Mob IDs
+ public static int entityFallenAngelID = 20;
+ public static int entityLowerGuardianID = 21;
+ public static int entityBileDemonID = 22;
+ public static int entityWingedFireDemonID = 23;
+ public static int entitySmallEarthGolemID = 24;
+ public static int entityIceDemonID = 25;
+ public static int entityBoulderFistID = 26;
+ public static int entityShadeID = 27;
+ public static int entityAirElementalID = 28;
+ public static int entityWaterElementalID = 29;
+ public static int entityEarthElementalID = 30;
+ public static int entityFireElementalID = 31;
+ public static int entityShadeElementalID = 32;
+ public static int entityHolyElementalID = 33;
+
+
+ public static Fluid lifeEssenceFluid;
+
+ // The instance of your mod that Forge uses.
+ @Instance("AWWayofTime")
+ public static AlchemicalWizardry instance;
+
+ // Says where the client and server 'proxy' code is loaded.
+ @SidedProxy(clientSide = "WayofTime.alchemicalWizardry.client.ClientProxy", serverSide = "WayofTime.alchemicalWizardry.common.CommonProxy")
+ public static CommonProxy proxy;
+
+ @EventHandler
+ public void preInit(FMLPreInitializationEvent event)
+ {
+ File bmDirectory = new File("config/BloodMagic/schematics");
+
+ if(!bmDirectory.exists() && bmDirectory.mkdirs())
+ {
+ try
+ {
+ InputStream in = AlchemicalWizardry.class.getResourceAsStream("/assets/alchemicalwizardry/schematics/building/buildings.zip");
+ System.out.println("none yet!");
+ if(in != null)
+ {
+ System.out.println("I have found a zip!");
+ ZipInputStream zipStream = new ZipInputStream(in);
+ ZipEntry entry = null;
+
+ int extractCount = 0;
+
+ while((entry = zipStream.getNextEntry()) != null)
+ {
+ File file = new File(bmDirectory, entry.getName());
+ if(file.exists() && file.length() > 3L)
+ {
+ continue;
+ }
+ FileOutputStream out = new FileOutputStream(file);
+
+ byte[] buffer = new byte[8192];
+ int len;
+ while((len = zipStream.read(buffer)) != -1)
+ {
+ out.write(buffer, 0, len);
+ }
+ out.close();
+
+ extractCount++;
+ }
+ }
+ }
+ catch(Exception e)
+ {
+
+ }
+ }
+
+ TEDemonPortal.loadBuildingList();
+
+ MinecraftForge.EVENT_BUS.register(new LifeBucketHandler());
+ BloodMagicConfiguration.init(new File(event.getModConfigurationDirectory(), "AWWayofTime.cfg"));
+
+ //Custom config stuff goes here
+
+
+ Potion[] potionTypes = null;
+
+ for (Field f : Potion.class.getDeclaredFields())
+ {
+ f.setAccessible(true);
+
+ try
+ {
+ if (f.getName().equals("potionTypes") || f.getName().equals("field_76425_a"))
+ {
+ Field modfield = Field.class.getDeclaredField("modifiers");
+ modfield.setAccessible(true);
+ modfield.setInt(f, f.getModifiers() & ~Modifier.FINAL);
+ potionTypes = (Potion[]) f.get(null);
+ final Potion[] newPotionTypes = new Potion[256];
+ System.arraycopy(potionTypes, 0, newPotionTypes, 0, potionTypes.length);
+ f.set(null, newPotionTypes);
+ }
+ } catch (Exception e)
+ {
+ System.err.println("Severe error, please report this to the mod author:");
+ System.err.println(e);
+ }
+ }
+ AlchemicalWizardry.lifeEssenceFluid = new LifeEssence("Life Essence");
+ FluidRegistry.registerFluid(lifeEssenceFluid);
+
+ ModBlocks.init();
+
+
+ ModBlocks.registerBlocksInPre();
+
+ ModItems.init();
+
+ ModItems.registerItems();
+
+ RecipeSorter.INSTANCE.register("AWWayofTime:shapedorb", ShapedBloodOrbRecipe.class, Category.SHAPED, "before:minecraft:shapeless");
+ RecipeSorter.INSTANCE.register("AWWayofTime:shapelessorb", ShapelessBloodOrbRecipe.class, Category.SHAPELESS, "after:minecraft:shapeless");
+
+ Object eventHook = new AlchemicalWizardryEventHooks();
+ FMLCommonHandler.instance().bus().register(eventHook);
+ MinecraftForge.EVENT_BUS.register(eventHook);
+ NewPacketHandler.INSTANCE.ordinal();
+ }
+
+ @EventHandler
+ public void load(FMLInitializationEvent event)
+ {
+ int craftingConstant = OreDictionary.WILDCARD_VALUE;
+ //TickRegistry.registerTickHandler(new AlchemicalWizardryTickHandler(), Side.SERVER);
+
+ ModBlocks.registerBlocksInInit();
+ //blocks
+
+ proxy.registerRenderers();
+ proxy.registerEntities();
+ proxy.registerEntityTrackers();
+ proxy.registerEvents();
+ //ItemStacks used for crafting go here
+ ItemStack lapisStack = new ItemStack(Items.dye,1,4);
+ ItemStack lavaBucketStack = new ItemStack(Items.lava_bucket);
+ ItemStack cobblestoneStack = new ItemStack(Blocks.cobblestone, 1, craftingConstant);
+ ItemStack glassStack = new ItemStack(Blocks.glass, 1, craftingConstant);
+ ItemStack ironIngotStack = new ItemStack(Items.iron_ingot);
+ ItemStack diamondStack = new ItemStack(Items.diamond, 1, craftingConstant);
+ ItemStack woolStack = new ItemStack(Blocks.wool);
+ ItemStack goldNuggetStack = new ItemStack(Items.gold_nugget);
+ ItemStack stoneStack = new ItemStack(Blocks.stone, 1, craftingConstant);
+ ItemStack redstoneStack = new ItemStack(Items.redstone);
+ ItemStack glowstoneBlockStack = new ItemStack(Blocks.glowstone);
+ ItemStack ironBlockStack = new ItemStack(Blocks.iron_block);
+ ItemStack waterBucketStack = new ItemStack(Items.water_bucket);
+ ItemStack emptyBucketStack = new ItemStack(Items.bucket);
+ ItemStack magmaCreamStack = new ItemStack(Items.magma_cream);
+ ItemStack stringStack = new ItemStack(Items.string);
+ ItemStack obsidianStack = new ItemStack(Blocks.obsidian);
+ ItemStack diamondSwordStack = new ItemStack(Items.diamond_sword);
+ ItemStack goldIngotStack = new ItemStack(Items.gold_ingot);
+ ItemStack cauldronStack = new ItemStack(Blocks.cauldron);
+ ItemStack furnaceStack = new ItemStack(Blocks.furnace);
+ ItemStack sugarStack = new ItemStack(Items.sugar);
+ ItemStack featherStack = new ItemStack(Items.feather);
+ ItemStack ghastTearStack = new ItemStack(Items.ghast_tear);
+ ItemStack ironPickaxeStack = new ItemStack(Items.iron_pickaxe);
+ ItemStack ironAxeStack = new ItemStack(Items.iron_axe);
+ ItemStack ironShovelStack = new ItemStack(Items.iron_shovel);
+ ItemStack glowstoneDustStack = new ItemStack(Items.glowstone_dust);
+ ItemStack saplingStack = new ItemStack(Blocks.sapling);
+ ItemStack reedStack = new ItemStack(Items.reeds);
+ ItemStack blankSlateStack = new ItemStack(ModItems.blankSlate, 1, craftingConstant);
+ //ItemStack glassShardStack = new ItemStack(glassShard);
+ ItemStack weakBloodOrbStackCrafted = new ItemStack(ModItems.weakBloodOrb);
+ //ItemStack bloodiedShardStack = new ItemStack(bloodiedShard);
+ ItemStack reinforcedSlateStack = new ItemStack(ModItems.reinforcedSlate, 1, craftingConstant);
+ ItemStack weakBloodOrbStack = new ItemStack(ModItems.weakBloodOrb, 1, craftingConstant);
+ ItemStack imbuedSlateStack = new ItemStack(ModItems.imbuedSlate, 1, craftingConstant);
+ ItemStack demonSlateStack = new ItemStack(ModItems.demonicSlate, 1, craftingConstant);
+ ItemStack apprenticeBloodOrbStack = new ItemStack(ModItems.apprenticeBloodOrb, 1, craftingConstant);
+ ItemStack magicianBloodOrbStack = new ItemStack(ModItems.magicianBloodOrb, 1, craftingConstant);
+ ItemStack waterSigilStackCrafted = new ItemStack(ModItems.waterSigil);
+ ItemStack lavaSigilStackCrafted = new ItemStack(ModItems.lavaSigil);
+ ItemStack voidSigilStackCrafted = new ItemStack(ModItems.voidSigil);
+ ItemStack airSigilStack = new ItemStack(ModItems.airSigil);
+ ItemStack lavaCrystalStackCrafted = new ItemStack(ModItems.lavaCrystal);
+ ItemStack lavaCrystalStack = new ItemStack(ModItems.lavaCrystal);
+ ItemStack energySwordStack = new ItemStack(ModItems.energySword);
+ ItemStack energyBlasterStack = new ItemStack(ModItems.energyBlaster);
+ ItemStack sacrificialDaggerStack = new ItemStack(ModItems.sacrificialDagger);
+ ItemStack bloodAltarStack = new ItemStack(ModBlocks.blockAltar,1,0);
+ ItemStack bloodRuneCraftedStack = new ItemStack(ModBlocks.bloodRune, 1);
+ ItemStack bloodRuneStack = new ItemStack(ModBlocks.bloodRune);
+ ItemStack speedRuneStack = new ItemStack(ModBlocks.speedRune);
+ ItemStack efficiencyRuneStack = new ItemStack(ModBlocks.efficiencyRune);
+ ItemStack runeOfSacrificeStack = new ItemStack(ModBlocks.runeOfSacrifice);
+ ItemStack runeOfSelfSacrificeStack = new ItemStack(ModBlocks.runeOfSelfSacrifice);
+ ItemStack miningSigilStackCrafted = new ItemStack(ModItems.sigilOfTheFastMiner);
+ ItemStack divinationSigilStackCrafted = new ItemStack(ModItems.divinationSigil);
+ ItemStack seerSigilStackCrafted = new ItemStack(ModItems.itemSeerSigil);
+// ItemStack elementalInkWaterStack = new ItemStack(elementalInkWater);
+// ItemStack elementalInkFireStack = new ItemStack(elementalInkFire);
+// ItemStack elementalInkEarthStack = new ItemStack(elementalInkEarth);
+// ItemStack elementalInkAirStack = new ItemStack(elementalInkAir);
+ ItemStack waterScribeToolStack = new ItemStack(ModItems.waterScribeTool);
+ ItemStack fireScribeToolStack = new ItemStack(ModItems.fireScribeTool);
+ ItemStack earthScribeToolStack = new ItemStack(ModItems.earthScribeTool);
+ ItemStack airScribeToolStack = new ItemStack(ModItems.airScribeTool);
+ ItemStack ritualStoneStackCrafted = new ItemStack(ModBlocks.ritualStone, 4);
+ ItemStack ritualStoneStack = new ItemStack(ModBlocks.ritualStone);
+ ItemStack masterRitualStoneStack = new ItemStack(ModBlocks.blockMasterStone);
+ ItemStack imperfectRitualStoneStack = new ItemStack(ModBlocks.imperfectRitualStone);
+ ItemStack sigilOfElementalAffinityStackCrafted = new ItemStack(ModItems.sigilOfElementalAffinity);
+ ItemStack lavaSigilStack = new ItemStack(ModItems.lavaSigil);
+ ItemStack waterSigilStack = new ItemStack(ModItems.waterSigil);
+ ItemStack sigilOfHoldingStack = new ItemStack(ModItems.sigilOfHolding);
+ ItemStack weakBloodShardStack = new ItemStack(ModItems.weakBloodShard);
+ ItemStack emptySocketStack = new ItemStack(ModBlocks.emptySocket);
+ ItemStack bloodSocketStack = new ItemStack(ModBlocks.bloodSocket);
+ ItemStack armourForgeStack = new ItemStack(ModBlocks.armourForge);
+ ItemStack largeBloodStoneBrickStackCrafted = new ItemStack(ModBlocks.largeBloodStoneBrick, 32);
+ ItemStack largeBloodStoneBrickStack = new ItemStack(ModBlocks.largeBloodStoneBrick);
+ ItemStack bloodStoneBrickStackCrafted = new ItemStack(ModBlocks.bloodStoneBrick, 4);
+ ItemStack growthSigilStack = new ItemStack(ModItems.growthSigil);
+ ItemStack blockHomHeartStack = new ItemStack(ModBlocks.blockHomHeart);
+ ItemStack redWoolStack = new ItemStack(Blocks.wool, 1, 14);
+ ItemStack zombieHead = new ItemStack(Items.skull, 1, 2);
+ ItemStack simpleCatalystStack = new ItemStack(ModItems.simpleCatalyst);
+ ItemStack duskRitualDivinerStack = new ItemStack(ModItems.itemRitualDiviner);
+ ((ItemRitualDiviner) duskRitualDivinerStack.getItem()).setMaxRuneDisplacement(duskRitualDivinerStack, 1);
+ //weakBloodOrbStackCrafted.setItemDamage(weakBloodOrbStackCrafted.getMaxDamage());
+ waterSigilStackCrafted.setItemDamage(waterSigilStackCrafted.getMaxDamage());
+ lavaSigilStackCrafted.setItemDamage(lavaSigilStackCrafted.getMaxDamage());
+ voidSigilStackCrafted.setItemDamage(voidSigilStackCrafted.getMaxDamage());
+ lavaCrystalStackCrafted.setItemDamage(lavaCrystalStackCrafted.getMaxDamage());
+ miningSigilStackCrafted.setItemDamage(miningSigilStackCrafted.getMaxDamage());
+ sigilOfElementalAffinityStackCrafted.setItemDamage(sigilOfElementalAffinityStackCrafted.getMaxDamage());
+ ItemStack archmageBloodOrbStack = new ItemStack(ModItems.archmageBloodOrb);
+ ItemStack sanctusStack = new ItemStack(ModItems.sanctus);
+ ItemStack aetherStack = new ItemStack(ModItems.aether);
+ ItemStack terraeStack = new ItemStack(ModItems.terrae);
+ ItemStack incendiumStack = new ItemStack(ModItems.incendium);
+ ItemStack tennebraeStack = new ItemStack(ModItems.tennebrae);
+ ItemStack aquasalusStack = new ItemStack(ModItems.aquasalus);
+ ItemStack crystallosStack = new ItemStack(ModItems.crystallos);
+ ItemStack crepitousStack = new ItemStack(ModItems.crepitous);
+ ItemStack magicalesStack = new ItemStack(ModItems.magicales);
+ //All crafting goes here
+ // GameRegistry.addRecipe(orbOfTestingStack, "x x", " ", "x x", 'x', cobblestoneStack);
+ //GameRegistry.addRecipe(glassShardStack, " x", "y ", 'x', ironIngotStack, 'y', glassStack);
+ //GameRegistry.addRecipe(weakBloodOrbStackCrafted, "xxx", "xdx", "www", 'x', bloodiedShardStack, 'd', diamondStack, 'w', woolStack);
+ GameRegistry.addRecipe(sacrificialDaggerStack, "ggg", " dg", "i g", 'g', glassStack, 'd', goldIngotStack, 'i', ironIngotStack);
+ //GameRegistry.addRecipe(blankSlateStack, "sgs", "gig", "sgs", 's', stoneStack, 'g', goldNuggetStack, 'i', ironIngotStack);
+ //GameRegistry.addRecipe(reinforcedSlateStack, "rir", "ibi", "gig", 'r', redstoneStack, 'i', ironIngotStack, 'b', blankSlateStack, 'g', glowstoneBlockStack);
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(lavaCrystalStackCrafted, "glg", "lbl", "odo", 'g', glassStack, 'l', lavaBucketStack, 'b', weakBloodOrbStack, 'd', diamondStack, 'o', obsidianStack));
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(waterSigilStackCrafted, "www", "wbw", "wow", 'w', waterBucketStack, 'b', blankSlateStack, 'o', weakBloodOrbStack));
+ GameRegistry.addRecipe(lavaSigilStackCrafted, "lml", "lbl", "lcl", 'l', lavaBucketStack, 'b', blankSlateStack, 'm', magmaCreamStack, 'c', lavaCrystalStack);
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(voidSigilStackCrafted, "ese", "ere", "eoe", 'e', emptyBucketStack, 'r', reinforcedSlateStack, 'o', apprenticeBloodOrbStack, 's', stringStack));
+ GameRegistry.addRecipe(bloodAltarStack, "s s", "scs", "gdg", 's', stoneStack, 'c', furnaceStack, 'd', diamondStack, 'g', goldIngotStack);
+ //GameRegistry.addRecipe(energySwordStack, " o ", " o ", " s ", 'o', weakBloodOrbStack, 's', diamondSwordStack);
+ //GameRegistry.addRecipe(energyBlasterStack, "oi ", "gdi", " rd", 'o', weakBloodOrbStack, 'i', ironIngotStack, 'd', diamondStack, 'r', reinforcedSlateStack, 'g', goldIngotStack);
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(bloodRuneCraftedStack, "sss", "ror", "sss", 's', stoneStack, 'o', weakBloodOrbStack, 'r', blankSlateStack));
+ GameRegistry.addRecipe(speedRuneStack, "sbs", "uru", "sbs", 'u', sugarStack, 's', stoneStack, 'r', bloodRuneStack, 'b', blankSlateStack);
+ //GameRegistry.addRecipe(efficiencyRuneStack, "sbs", "rur", "sbs", 'r', redstoneStack, 's', stoneStack, 'u', bloodRuneStack,'b',blankSlateStack);
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(new ItemStack(ModBlocks.bloodRune, 1, 1), "sbs", "bob", "srs", 's', stoneStack, 'o', magicianBloodOrbStack, 'b', emptyBucketStack, 'r', new ItemStack(ModItems.imbuedSlate)));
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(new ItemStack(ModBlocks.bloodRune, 1, 2), "sbs", "bob", "srs", 's', stoneStack, 'o', magicianBloodOrbStack, 'b', waterBucketStack, 'r', new ItemStack(ModItems.imbuedSlate)));
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(new ItemStack(ModBlocks.bloodRune, 1, 3), "sws", "ror", "sws", 's', stoneStack, 'o', new ItemStack(ModItems.masterBloodOrb), 'w', weakBloodOrbStack, 'r', new ItemStack(ModItems.demonicSlate)));
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(new ItemStack(ModBlocks.bloodRune, 1, 4), "srs", "beb", "sos", 's', obsidianStack, 'o', new ItemStack(ModItems.masterBloodOrb), 'r', new ItemStack(ModItems.demonicSlate), 'b', emptyBucketStack,'e',new ItemStack(ModBlocks.bloodRune, 1, 1)));
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(airSigilStack, "fgf", "fsf", "fof", 'f', featherStack, 'g', ghastTearStack, 's', reinforcedSlateStack, 'o', apprenticeBloodOrbStack));
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(miningSigilStackCrafted, "sps", "hra", "sos", 'o', apprenticeBloodOrbStack, 's', stoneStack, 'p', ironPickaxeStack, 'h', ironShovelStack, 'a', ironAxeStack, 'r', reinforcedSlateStack));
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(runeOfSacrificeStack, "srs", "gog", "srs", 's', stoneStack, 'g', goldIngotStack, 'o', apprenticeBloodOrbStack, 'r', reinforcedSlateStack));
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(runeOfSelfSacrificeStack, "srs", "gog", "srs", 's', stoneStack, 'g', glowstoneDustStack, 'o', apprenticeBloodOrbStack, 'r', reinforcedSlateStack));
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(divinationSigilStackCrafted, "ggg", "gsg", "gog", 'g', glassStack, 's', blankSlateStack, 'o', weakBloodOrbStack));
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(seerSigilStackCrafted, "gbg", "gsg", "gog", 'g', glassStack, 's', divinationSigilStackCrafted, 'o', apprenticeBloodOrbStack, 'b', new ItemStack(ModItems.bucketLife)));
+
+// GameRegistry.addRecipe(waterScribeToolStack, "f", "i", 'f', featherStack, 'i', elementalInkWaterStack);
+// GameRegistry.addRecipe(fireScribeToolStack, "f", "i", 'f', featherStack, 'i', elementalInkFireStack);
+// GameRegistry.addRecipe(earthScribeToolStack, "f", "i", 'f', featherStack, 'i', elementalInkEarthStack);
+// GameRegistry.addRecipe(airScribeToolStack, "f", "i", 'f', featherStack, 'i', elementalInkAirStack);
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(ritualStoneStackCrafted, "srs", "ror", "srs", 's', obsidianStack, 'o', apprenticeBloodOrbStack, 'r', reinforcedSlateStack));
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(masterRitualStoneStack, "brb", "ror", "brb", 'b', obsidianStack, 'o', magicianBloodOrbStack, 'r', ritualStoneStack));
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(imperfectRitualStoneStack, "bsb", "sos", "bsb", 's', stoneStack, 'b', obsidianStack, 'o', weakBloodOrbStack));
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(sigilOfElementalAffinityStackCrafted, "oao", "wsl", "oro", 'o', obsidianStack, 'a', airSigilStack, 'w', waterSigilStack, 'l', lavaSigilStack, 'r', magicianBloodOrbStack, 's', imbuedSlateStack));
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(sigilOfHoldingStack, "asa", "srs", "aoa", 'a', blankSlateStack, 's', stoneStack, 'r', imbuedSlateStack, 'o', magicianBloodOrbStack));
+ GameRegistry.addRecipe(emptySocketStack, "bgb", "gdg", "bgb", 'b', weakBloodShardStack, 'g', glassStack, 'd', diamondStack);
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(armourForgeStack, "sfs", "fof", "sfs", 'f', bloodSocketStack, 's', stoneStack, 'o', magicianBloodOrbStack));
+ GameRegistry.addShapelessRecipe(largeBloodStoneBrickStackCrafted, weakBloodShardStack, stoneStack);
+ GameRegistry.addRecipe(bloodStoneBrickStackCrafted, "bb", "bb", 'b', largeBloodStoneBrickStack);
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(growthSigilStack, "srs", "rer", "sos", 's', saplingStack, 'r', reedStack, 'o', apprenticeBloodOrbStack, 'e', reinforcedSlateStack));
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(blockHomHeartStack, "www", "srs", "sos", 'w', redWoolStack, 's', stoneStack, 'r', bloodRuneStack, 'o', apprenticeBloodOrbStack));
+ GameRegistry.addShapelessRecipe(new ItemStack(Items.skull, 1, 2), new ItemStack(Items.skull, 1, 1), new ItemStack(Items.rotten_flesh), new ItemStack(Items.iron_ingot), new ItemStack(Items.leather));
+ GameRegistry.addShapelessRecipe(new ItemStack(Items.skull, 1, 0), new ItemStack(Items.skull, 1, 1), new ItemStack(Items.bow, 1, 0), new ItemStack(Items.arrow, 1, 0), new ItemStack(Items.bone));
+ GameRegistry.addShapelessRecipe(new ItemStack(Items.skull, 1, 4), new ItemStack(Items.skull, 1, 1), new ItemStack(Items.gunpowder), new ItemStack(Blocks.dirt), new ItemStack(Blocks.sand));
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(new ItemStack(ModBlocks.blockWritingTable), " s ", "ror", 's', new ItemStack(Items.brewing_stand), 'r', obsidianStack, 'o', weakBloodOrbStack));
+ GameRegistry.addRecipe(new ItemStack(ModBlocks.blockPedestal), "ooo", " c ", "ooo", 'o', obsidianStack, 'c', weakBloodShardStack);
+ GameRegistry.addRecipe(new ItemStack(ModBlocks.blockPlinth), "iii", " p ", "iii", 'i', ironBlockStack, 'p', new ItemStack(ModBlocks.blockPedestal));
+ GameRegistry.addShapelessRecipe(new ItemStack(ModItems.alchemyFlask, 1, 0), new ItemStack(ModItems.alchemyFlask, 1, craftingConstant), new ItemStack(Items.nether_wart), redstoneStack, glowstoneDustStack);
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(new ItemStack(ModItems.sigilOfHaste), "csc", "sts", "ror", 'c', new ItemStack(Items.cookie), 's', new ItemStack(Items.sugar), 't', ModItems.demonicSlate, 'r', obsidianStack, 'o', new ItemStack(ModItems.masterBloodOrb)));
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(new ItemStack(ModItems.sigilOfWind), "faf", "grg", "fof", 'f', featherStack, 'g', ghastTearStack, 'a', new ItemStack(ModItems.airSigil), 'o', new ItemStack(ModItems.masterBloodOrb), 'r', ModItems.demonicSlate));
+ GameRegistry.addRecipe(new ShapelessBloodOrbRecipe(new ItemStack(ModItems.weakBloodShard, 5, 0), new ItemStack(ModItems.masterBloodOrb), new ItemStack(ModItems.weakBloodShard), imbuedSlateStack));
+ GameRegistry.addRecipe(new ItemStack(ModBlocks.blockTeleposer), "ggg", "efe", "ggg", 'g', goldIngotStack, 'f', new ItemStack(ModItems.telepositionFocus), 'e', new ItemStack(Items.ender_pearl));
+ GameRegistry.addShapelessRecipe(new ItemStack(ModItems.reinforcedTelepositionFocus), new ItemStack(ModItems.enhancedTelepositionFocus), new ItemStack(ModItems.weakBloodShard));
+ GameRegistry.addShapelessRecipe(new ItemStack(ModItems.demonicTelepositionFocus), new ItemStack(ModItems.reinforcedTelepositionFocus), new ItemStack(ModItems.demonBloodShard));
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(new ItemStack(ModItems.sigilOfTheBridge), "nnn", "nsn", "ror", 'n', stoneStack, 'r', new ItemStack(Blocks.soul_sand), 's', imbuedSlateStack, 'o', magicianBloodOrbStack));
+ GameRegistry.addRecipe(new ItemStack(ModItems.armourInhibitor), " gg", "gsg", "gg ", 'g', goldIngotStack, 's', new ItemStack(ModItems.weakBloodShard));
+ GameRegistry.addRecipe(new ItemStack(ModItems.itemRitualDiviner), "d1d", "2e3", "d4d", '1', new ItemStack(ModItems.airScribeTool), '2', new ItemStack(ModItems.waterScribeTool), '3', new ItemStack(ModItems.fireScribeTool), '4', new ItemStack(ModItems.earthScribeTool), 'd', diamondStack, 'e', new ItemStack(Items.emerald));
+ GameRegistry.addRecipe(duskRitualDivinerStack, " d ", "srs", " d ", 'd', new ItemStack(ModItems.duskScribeTool), 's', new ItemStack(ModItems.demonicSlate), 'r', new ItemStack(ModItems.itemRitualDiviner));
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(new ItemStack(ModItems.sigilOfMagnetism), "bgb", "gsg", "bob", 'b', new ItemStack(Blocks.iron_block), 'g', goldIngotStack, 's', new ItemStack(ModItems.imbuedSlate), 'o', magicianBloodOrbStack));
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(new ItemStack(ModItems.energyBazooka), "Ocd", "cb ", "d w", 'O', archmageBloodOrbStack, 'c', crepitousStack, 'b', new ItemStack(ModItems.energyBlaster), 'd', diamondStack, 'w', new ItemStack(ModItems.weakBloodShard)));
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(new ItemStack(ModItems.itemBloodLightSigil), "btb", "sss", "bob", 'o', magicianBloodOrbStack, 'b', glowstoneBlockStack, 't', new ItemStack(Blocks.torch), 's', imbuedSlateStack));
+ GameRegistry.addRecipe(new ItemStack(ModItems.itemKeyOfDiablo), " gw", "gdg", "wg ", 'w', weakBloodShardStack, 'g', goldIngotStack, 'd', diamondStack);
+ customPotionDrowning = (new PotionDrowning(customPotionDrowningID, true, 0)).setIconIndex(0, 0).setPotionName("Drowning");
+ customPotionBoost = (new PotionBoost(customPotionBoostID, false, 0)).setIconIndex(0, 0).setPotionName("Boost");
+ customPotionProjProt = (new PotionProjectileProtect(customPotionProjProtID, false, 0)).setIconIndex(0, 0).setPotionName("Whirlwind");
+ customPotionInhibit = (new PotionInhibit(customPotionInhibitID, false, 0)).setIconIndex(0, 0).setPotionName("Inhibit");
+ customPotionFlight = (new PotionFlight(customPotionFlightID, false, 0)).setIconIndex(0, 0).setPotionName("Flight");
+ customPotionReciprocation = (new PotionReciprocation(customPotionReciprocationID, false, 0xFFFFFF)).setIconIndex(0, 0).setPotionName("Reciprocation");
+ customPotionFlameCloak = (new PotionFlameCloak(customPotionFlameCloakID,false,0).setIconIndex(0,0).setPotionName("Flame Cloak"));
+ customPotionIceCloak = (new PotionIceCloak(customPotionIceCloakID,false,0).setIconIndex(0,0).setPotionName("Ice Cloak"));
+ customPotionHeavyHeart = (new PotionHeavyHeart(customPotionHeavyHeartID,true,0).setIconIndex(0, 0).setPotionName("Heavy Heart"));
+ customPotionFireFuse = (new PotionFireFuse(customPotionFireFuseID,true,0).setIconIndex(0, 0).setPotionName("Fire Fuse"));
+ customPotionPlanarBinding = (new PotionPlanarBinding(customPotionPlanarBindingID,true,0).setIconIndex(0,0).setPotionName("Planar Binding"));
+ customPotionSoulFray = (new PotionSoulFray(customPotionSoulFrayID,true,0).setIconIndex(0,0).setPotionName("Soul Fray"));
+ customPotionSoulHarden = (new PotionSoulHarden(customPotionSoulHardenID,false,0).setIconIndex(0,0).setPotionName("Soul Harden"));
+ customPotionDeaf = (new PotionDeaf(customPotionDeafID,true,0).setIconIndex(0,0).setPotionName("Deafness"));
+ customPotionFeatherFall = (new PotionFeatherFall(customPotionFeatherFallID,false,0).setIconIndex(0,0).setPotionName("Feather Fall"));
+
+ ItemStack masterBloodOrbStack = new ItemStack(ModItems.masterBloodOrb);
+
+ //FluidStack lifeEssenceFluidStack = new FluidStack(lifeEssenceFluid, 1);
+ //LiquidStack lifeEssence = new LiquidStack(lifeEssenceFlowing, 1);
+ //LiquidDictionary.getOrCreateLiquid("Life Essence", lifeEssence);
+
+
+// ModBlocks.blockLifeEssence.setUnlocalizedName("lifeEssenceBlock");
+ FluidContainerRegistry.registerFluidContainer(lifeEssenceFluid, new ItemStack(ModItems.bucketLife), FluidContainerRegistry.EMPTY_BUCKET);
+
+ //lifeEssenceFluid.setUnlocalizedName("lifeEssence");
+ //LiquidContainerRegistry.registerLiquid(new LiquidContainerData(LiquidDictionary.getLiquid("Life Essence", LiquidContainerRegistry.BUCKET_VOLUME), new ItemStack(AlchemicalWizardry.bucketLife), new ItemStack(Items.bucketEmpty)));
+ //GameRegistry.registerBlock(testingBlock, "testingBlock");
+ //LanguageRegistry.addName(testingBlock, "Testing Block");
+ //(testingBlock, "pickaxe", 0);
+ ModBlocks.blockAltar.setHarvestLevel("pickaxe", 1);
+ //Register Tile Entity
+ GameRegistry.registerTileEntity(TEAltar.class, "containerAltar");
+ GameRegistry.registerTileEntity(TEMasterStone.class, "containerMasterStone");
+ GameRegistry.registerTileEntity(TESocket.class, "containerSocket");
+ GameRegistry.registerTileEntity(TEWritingTable.class, "containerWritingTable");
+ GameRegistry.registerTileEntity(TEHomHeart.class, "containerHomHeart");
+ GameRegistry.registerTileEntity(TEPedestal.class, "containerPedestal");
+ GameRegistry.registerTileEntity(TEPlinth.class, "containerPlinth");
+ GameRegistry.registerTileEntity(TETeleposer.class, "containerTeleposer");
+ GameRegistry.registerTileEntity(TEConduit.class, "containerConduit");
+ GameRegistry.registerTileEntity(TEOrientable.class, "containerOrientable");
+ GameRegistry.registerTileEntity(TESpellParadigmBlock.class, "containerSpellParadigmBlock");
+ GameRegistry.registerTileEntity(TESpellEffectBlock.class, "containerSpellEffectBlock");
+ GameRegistry.registerTileEntity(TESpellModifierBlock.class, "containerSpellModifierBlock");
+ GameRegistry.registerTileEntity(TESpellEnhancementBlock.class, "containerSpellEnhancementBlock");
+ GameRegistry.registerTileEntity(TESpectralContainer.class,"spectralContainerTileEntity");
+ GameRegistry.registerTileEntity(TEDemonPortal.class, "containerDemonPortal");
+ GameRegistry.registerTileEntity(TESchematicSaver.class, "containerSchematicSaver");
+ GameRegistry.registerTileEntity(TESpectralBlock.class, "containerSpectralBlock");
+ GameRegistry.registerTileEntity(TEReagentConduit.class, "containerReagentConduit");
+ GameRegistry.registerTileEntity(TEBellJar.class, "containerBellJar");
+ GameRegistry.registerTileEntity(TEAlchemicCalcinator.class, "containerAlchemicCalcinator");
+ //GameRegistry.registerBlock(ModBlocks.blockSpellEffect,"blockSpellEffect");
+ ModBlocks.bloodRune.setHarvestLevel("pickaxe", 2);
+ ModBlocks.speedRune.setHarvestLevel("pickaxe", 2);
+ ModBlocks.efficiencyRune.setHarvestLevel("pickaxe", 2);
+ ModBlocks.runeOfSacrifice.setHarvestLevel("pickaxe", 2);
+ ModBlocks.runeOfSelfSacrifice.setHarvestLevel("pickaxe", 2);
+ ModBlocks.ritualStone.setHarvestLevel("pickaxe", 2);
+ ModBlocks.bloodSocket.setHarvestLevel("pickaxe", 2);
+ ModBlocks.ritualStone.setHarvestLevel("pickaxe", 2);
+ ModBlocks.imperfectRitualStone.setHarvestLevel("pickaxe", 2);
+ ModBlocks.blockMasterStone.setHarvestLevel("pickaxe", 2);
+ ModBlocks.emptySocket.setHarvestLevel("pickaxe", 2);
+ ModBlocks.bloodStoneBrick.setHarvestLevel("pickaxe", 0);
+ ModBlocks.largeBloodStoneBrick.setHarvestLevel("pickaxe", 0);
+ ModBlocks.blockWritingTable.setHarvestLevel("pickaxe", 1);
+ ModBlocks.blockHomHeart.setHarvestLevel("pickaxe", 1);
+ ModBlocks.blockPedestal.setHarvestLevel("pickaxe", 2);
+ ModBlocks.blockPlinth.setHarvestLevel("pickaxe", 2);
+ ModBlocks.blockTeleposer.setHarvestLevel("pickaxe", 2);
+ //Fuel handler
+ GameRegistry.registerFuelHandler(new AlchemicalWizardryFuelHandler());
+ //EntityRegistry.registerModEntity(EnergyBlastProjectile.class, "BlasterProj", 0, this, 128, 5, true);
+
+ //Gui registration
+ // NetworkRegistry.instance().registerGuiHandler(this, new GuiHandlerAltar());
+ UpgradedAltars.loadAltars();
+ SigilOfHolding.initiateSigilOfHolding();
+ ArmourForge.initializeRecipes();
+ TEPlinth.initialize();
+
+ this.initAlchemyPotionRecipes();
+ this.initAltarRecipes();
+ this.initRituals();
+ this.initBindingRecipes();
+ this.initHarvestRegistry();
+ this.initCombinedAlchemyPotionRecipes();
+ ReagentRegistry.initReagents();
+
+ //MinecraftForge.setToolClass(ModItems.boundPickaxe, "pickaxe", 5);
+ //MinecraftForge.setToolClass(ModItems.boundAxe, "axe", 5);
+ //MinecraftForge.setToolClass(ModItems.boundShovel, "shovel", 5);
+ MinecraftForge.EVENT_BUS.register(new ModLivingDropsEvent());
+ proxy.InitRendering();
+ NetworkRegistry.INSTANCE.registerGuiHandler(this, new GuiHandler());
+// ItemStack[] comp = new ItemStack[5];
+// for(int i=0;i<5;i++)
+// {
+// comp[i] = redstoneStack;
+// }
+// AlchemyRecipeRegistry.registerRecipe(glowstoneDustStack, 2, comp, 2);
+
+ ItemStack gunpowderStack = new ItemStack(Items.gunpowder);
+
+ ItemStack offensaStack = new ItemStack(ModItems.baseAlchemyItems,1,0);
+ ItemStack praesidiumStack = new ItemStack(ModItems.baseAlchemyItems,1,1);
+ ItemStack orbisTerraeStack = new ItemStack(ModItems.baseAlchemyItems,1,2);
+ ItemStack strengthenedCatalystStack = new ItemStack(ModItems.baseAlchemyItems,1,3);
+ ItemStack concentratedCatalystStack = new ItemStack(ModItems.baseAlchemyItems,1,4);
+ ItemStack fracturedBoneStack = new ItemStack(ModItems.baseAlchemyItems,1,5);
+ ItemStack virtusStack = new ItemStack(ModItems.baseAlchemyItems,1,6);
+ ItemStack reductusStack = new ItemStack(ModItems.baseAlchemyItems,1,7);
+ ItemStack potentiaStack = new ItemStack(ModItems.baseAlchemyItems,1,8);
+
+ ItemStack strengthenedCatalystStackCrafted = new ItemStack(ModItems.baseAlchemyItems,2,3);
+ ItemStack fracturedBoneStackCrafted = new ItemStack(ModItems.baseAlchemyItems,4,5);
+
+ //TODO NEW RECIPES!
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(ModItems.weakBindingAgent), 10, new ItemStack[]{simpleCatalystStack, simpleCatalystStack, new ItemStack(Items.clay_ball)}, 2);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(ModItems.standardBindingAgent), 15, new ItemStack[]{new ItemStack(ModItems.weakBindingAgent), sanctusStack, new ItemStack(ModItems.crystallos)}, 3);
+ AlchemyRecipeRegistry.registerRecipe(simpleCatalystStack, 2, new ItemStack[]{sugarStack, redstoneStack, redstoneStack, glowstoneDustStack, new ItemStack(Items.gunpowder)}, 1);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(ModItems.incendium), 5, new ItemStack[]{lavaBucketStack, new ItemStack(Items.blaze_powder), new ItemStack(Items.blaze_powder), new ItemStack(Blocks.netherrack), simpleCatalystStack}, 2);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(ModItems.aether), 5, new ItemStack[]{featherStack, featherStack, glowstoneDustStack, ghastTearStack, simpleCatalystStack}, 2);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(ModItems.sanctus), 5, new ItemStack[]{glowstoneDustStack, new ItemStack(Items.gold_nugget), glowstoneDustStack, glassStack, simpleCatalystStack}, 2);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(ModItems.crepitous), 5, new ItemStack[]{new ItemStack(Items.gunpowder), new ItemStack(Items.gunpowder), cobblestoneStack, cobblestoneStack, simpleCatalystStack}, 2);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(ModItems.crystallos), 5, new ItemStack[]{new ItemStack(Blocks.ice), new ItemStack(Blocks.ice), new ItemStack(Blocks.snow), new ItemStack(Blocks.snow), simpleCatalystStack}, 2);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(ModItems.terrae), 5, new ItemStack[]{new ItemStack(Blocks.dirt), new ItemStack(Blocks.sand), obsidianStack, obsidianStack, simpleCatalystStack}, 2);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(ModItems.aquasalus), 5, new ItemStack[]{simpleCatalystStack, new ItemStack(Items.dye, 1, 0), new ItemStack(Items.potionitem, 1, 0), new ItemStack(Items.potionitem, 1, 0), new ItemStack(Items.potionitem, 1, 0)}, 2);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(ModItems.tennebrae), 5, new ItemStack[]{simpleCatalystStack, new ItemStack(Items.coal), new ItemStack(Items.coal), new ItemStack(Blocks.obsidian), new ItemStack(Items.clay_ball)}, 2);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(ModItems.magicales), 5, new ItemStack[]{redstoneStack, simpleCatalystStack, new ItemStack(Items.gunpowder), new ItemStack(Items.glowstone_dust), new ItemStack(Items.glowstone_dust)}, 2);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(ModItems.mundanePowerCatalyst), 10, new ItemStack[]{glowstoneDustStack, glowstoneDustStack, glowstoneDustStack, new ItemStack(ModItems.weakBindingAgent), simpleCatalystStack}, 3);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(ModItems.mundaneLengtheningCatalyst), 10, new ItemStack[]{redstoneStack, redstoneStack, redstoneStack, new ItemStack(ModItems.weakBindingAgent), simpleCatalystStack}, 3);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(ModItems.averagePowerCatalyst), 20, new ItemStack[]{new ItemStack(ModItems.mundanePowerCatalyst), new ItemStack(ModItems.mundanePowerCatalyst), new ItemStack(ModItems.standardBindingAgent)}, 4);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(ModItems.averageLengtheningCatalyst), 20, new ItemStack[]{new ItemStack(ModItems.mundaneLengtheningCatalyst), new ItemStack(ModItems.mundaneLengtheningCatalyst), new ItemStack(ModItems.standardBindingAgent)}, 4);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(ModItems.greaterPowerCatalyst), 30, new ItemStack[]{new ItemStack(ModItems.averagePowerCatalyst), new ItemStack(ModItems.averagePowerCatalyst), new ItemStack(ModItems.incendium)}, 4);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(ModItems.greaterLengtheningCatalyst), 30, new ItemStack[]{new ItemStack(ModItems.averageLengtheningCatalyst), new ItemStack(ModItems.averageLengtheningCatalyst), new ItemStack(ModItems.aquasalus)}, 4);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(ModItems.weakFillingAgent), 5, new ItemStack[]{simpleCatalystStack, new ItemStack(Items.nether_wart), redstoneStack, glowstoneDustStack}, 3);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(ModItems.standardFillingAgent), 10, new ItemStack[]{new ItemStack(ModItems.weakFillingAgent), new ItemStack(ModItems.terrae)}, 3);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(ModItems.enhancedFillingAgent), 25, new ItemStack[]{new ItemStack(ModItems.standardFillingAgent), new ItemStack(ModItems.aquasalus), new ItemStack(ModItems.magicales)}, 4);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(ModItems.activationCrystal, 1, 1), 100, new ItemStack[]{new ItemStack(ModItems.activationCrystal, 1, 0), new ItemStack(ModItems.demonBloodShard), incendiumStack, aquasalusStack, aetherStack}, 4);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(ModItems.activationCrystal, 1, 1), 100, new ItemStack[]{new ItemStack(ModItems.activationCrystal, 1, 0), new ItemStack(Items.nether_star), incendiumStack, aquasalusStack, aetherStack}, 4);
+
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(Blocks.web),2,new ItemStack[]{new ItemStack(Items.string),new ItemStack(Items.string),new ItemStack(Items.string),new ItemStack(Items.string),new ItemStack(Items.string)},1);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(Items.gunpowder,2,0), 2, new ItemStack[]{gunpowderStack, new ItemStack(Items.coal), new ItemStack(Blocks.sand)}, 1);
+
+ AlchemyRecipeRegistry.registerRecipe(strengthenedCatalystStackCrafted, 10, new ItemStack[]{simpleCatalystStack, simpleCatalystStack, new ItemStack(Items.dye,1,15), new ItemStack(Items.nether_wart)}, 3);
+ AlchemyRecipeRegistry.registerRecipe(offensaStack,10, new ItemStack[]{strengthenedCatalystStack,incendiumStack, new ItemStack(Items.arrow), new ItemStack(Items.flint), new ItemStack(Items.arrow)},3);
+ AlchemyRecipeRegistry.registerRecipe(praesidiumStack, 10, new ItemStack[]{strengthenedCatalystStack,tennebraeStack,ironIngotStack,new ItemStack(Blocks.web),redstoneStack}, 3);
+ AlchemyRecipeRegistry.registerRecipe(orbisTerraeStack, 10, new ItemStack[]{strengthenedCatalystStack,terraeStack, gunpowderStack, new ItemStack(Blocks.netherrack), new ItemStack(Blocks.sand)}, 3);
+ AlchemyRecipeRegistry.registerRecipe(concentratedCatalystStack,10,new ItemStack[]{strengthenedCatalystStack,fracturedBoneStack,goldNuggetStack},4);
+ AlchemyRecipeRegistry.registerRecipe(fracturedBoneStackCrafted, 2, new ItemStack[]{new ItemStack(Items.bone), new ItemStack(Items.bone),new ItemStack(Items.bone),new ItemStack(Items.bone), gunpowderStack},1);
+ AlchemyRecipeRegistry.registerRecipe(virtusStack,20, new ItemStack[]{redstoneStack, new ItemStack(Items.coal),strengthenedCatalystStack,redstoneStack,gunpowderStack}, 3);
+ AlchemyRecipeRegistry.registerRecipe(reductusStack,20,new ItemStack[]{redstoneStack, goldIngotStack, strengthenedCatalystStack,new ItemStack(Blocks.soul_sand), new ItemStack(Items.carrot)},3);
+ AlchemyRecipeRegistry.registerRecipe(potentiaStack,20, new ItemStack[]{glowstoneDustStack,strengthenedCatalystStack,lapisStack,lapisStack,new ItemStack(Items.quartz)}, 3);
+
+
+ HomSpellRegistry.registerBasicSpell(new ItemStack(Items.flint_and_steel), new SpellFireBurst());
+ HomSpellRegistry.registerBasicSpell(new ItemStack(Blocks.ice), new SpellFrozenWater());
+ HomSpellRegistry.registerBasicSpell(new ItemStack(Blocks.tnt), new SpellExplosions());
+ HomSpellRegistry.registerBasicSpell(new ItemStack(ModItems.apprenticeBloodOrb), new SpellHolyBlast());
+ HomSpellRegistry.registerBasicSpell(new ItemStack(Items.ghast_tear), new SpellWindGust());
+ HomSpellRegistry.registerBasicSpell(new ItemStack(Items.glowstone_dust), new SpellLightningBolt());
+ HomSpellRegistry.registerBasicSpell(new ItemStack(Items.water_bucket), new SpellWateryGrave());
+ HomSpellRegistry.registerBasicSpell(new ItemStack(Blocks.obsidian), new SpellEarthBender());
+ HomSpellRegistry.registerBasicSpell(new ItemStack(Items.ender_pearl), new SpellTeleport());
+ SummoningRegistry.registerSummon(new SummoningHelperAW(this.entityFallenAngelID), new ItemStack[]{sanctusStack, sanctusStack, sanctusStack, aetherStack, tennebraeStack, terraeStack}, new ItemStack[]{}, new ItemStack[]{}, 0, 4);
+ SummoningRegistry.registerSummon(new SummoningHelperAW(this.entityLowerGuardianID), new ItemStack[]{cobblestoneStack, cobblestoneStack, terraeStack, tennebraeStack, new ItemStack(Items.iron_ingot), new ItemStack(Items.gold_nugget)}, new ItemStack[]{}, new ItemStack[]{}, 0, 4);
+ SummoningRegistry.registerSummon(new SummoningHelperAW(this.entityBileDemonID), new ItemStack[]{new ItemStack(Items.poisonous_potato), tennebraeStack, terraeStack, new ItemStack(Items.porkchop), new ItemStack(Items.egg), new ItemStack(Items.beef)}, new ItemStack[]{crepitousStack, crepitousStack, terraeStack, ironBlockStack, ironBlockStack, diamondStack}, new ItemStack[]{}, 0, 5);
+ SummoningRegistry.registerSummon(new SummoningHelperAW(this.entityWingedFireDemonID), new ItemStack[]{aetherStack, incendiumStack, incendiumStack, incendiumStack, tennebraeStack, new ItemStack(Blocks.netherrack)}, new ItemStack[]{diamondStack, new ItemStack(Blocks.gold_block), magicalesStack, magicalesStack, new ItemStack(Items.fire_charge), new ItemStack(Blocks.coal_block)}, new ItemStack[]{}, 0, 5);
+ SummoningRegistry.registerSummon(new SummoningHelperAW(this.entitySmallEarthGolemID), new ItemStack[]{new ItemStack(Items.clay_ball), terraeStack, terraeStack}, new ItemStack[]{}, new ItemStack[]{}, 0, 4);
+ SummoningRegistry.registerSummon(new SummoningHelperAW(this.entityIceDemonID), new ItemStack[]{crystallosStack, crystallosStack, aquasalusStack, crystallosStack, sanctusStack, terraeStack}, new ItemStack[]{}, new ItemStack[]{}, 0, 4);
+ SummoningRegistry.registerSummon(new SummoningHelperAW(this.entityBoulderFistID), new ItemStack[]{terraeStack, sanctusStack, tennebraeStack, new ItemStack(Items.bone), new ItemStack(Items.cooked_beef), new ItemStack(Items.cooked_beef)}, new ItemStack[]{}, new ItemStack[]{}, 0, 4);
+ SummoningRegistry.registerSummon(new SummoningHelperAW(this.entityShadeID), new ItemStack[]{tennebraeStack, tennebraeStack, tennebraeStack, aetherStack, glassStack, new ItemStack(Items.glass_bottle)}, new ItemStack[]{}, new ItemStack[]{}, 0, 4);
+ SummoningRegistry.registerSummon(new SummoningHelperAW(this.entityAirElementalID), new ItemStack[]{aetherStack, aetherStack, aetherStack, aetherStack, aetherStack, aetherStack}, new ItemStack[]{}, new ItemStack[]{}, 0, 4);
+ SummoningRegistry.registerSummon(new SummoningHelperAW(this.entityWaterElementalID), new ItemStack[]{aquasalusStack, aquasalusStack, aquasalusStack, aquasalusStack, aquasalusStack, aquasalusStack}, new ItemStack[]{}, new ItemStack[]{}, 0, 4);
+ SummoningRegistry.registerSummon(new SummoningHelperAW(this.entityEarthElementalID), new ItemStack[]{terraeStack, terraeStack, terraeStack, terraeStack, terraeStack, terraeStack}, new ItemStack[]{}, new ItemStack[]{}, 0, 4);
+ SummoningRegistry.registerSummon(new SummoningHelperAW(this.entityFireElementalID), new ItemStack[]{incendiumStack, incendiumStack, incendiumStack, incendiumStack, incendiumStack, incendiumStack}, new ItemStack[]{}, new ItemStack[]{}, 0, 4);
+ SummoningRegistry.registerSummon(new SummoningHelperAW(this.entityShadeElementalID), new ItemStack[]{tennebraeStack,tennebraeStack,tennebraeStack,tennebraeStack,tennebraeStack,tennebraeStack}, new ItemStack[]{}, new ItemStack[]{}, 0, 4);
+ SummoningRegistry.registerSummon(new SummoningHelperAW(this.entityHolyElementalID), new ItemStack[]{sanctusStack, sanctusStack, sanctusStack, sanctusStack, sanctusStack, sanctusStack}, new ItemStack[]{}, new ItemStack[]{}, 0, 4);
+ //Custom mobs
+ EntityRegistry.registerModEntity(EntityFallenAngel.class, "FallenAngel", this.entityFallenAngelID, this, 80, 3, true);
+ EntityRegistry.registerModEntity(EntityLowerGuardian.class, "LowerGuardian", this.entityLowerGuardianID, this, 80, 3, true);
+ EntityRegistry.registerModEntity(EntityBileDemon.class, "BileDemon", this.entityBileDemonID, this, 80, 3, true);
+ EntityRegistry.registerModEntity(EntityWingedFireDemon.class, "WingedFireDemon", this.entityWingedFireDemonID, this, 80, 3, true);
+ EntityRegistry.registerModEntity(EntitySmallEarthGolem.class, "SmallEarthGolem", this.entitySmallEarthGolemID, this, 80, 3, true);
+ EntityRegistry.registerModEntity(EntityIceDemon.class, "IceDemon", this.entityIceDemonID, this, 80, 3, true);
+ EntityRegistry.registerModEntity(EntityBoulderFist.class, "BoulderFist", this.entityBoulderFistID, this, 80, 3, true);
+ EntityRegistry.registerModEntity(EntityShade.class, "Shade", this.entityShadeID, this, 80, 3, true);
+ EntityRegistry.registerModEntity(EntityAirElemental.class, "AirElemental", this.entityAirElementalID, this, 120, 3, true);
+ EntityRegistry.registerModEntity(EntityWaterElemental.class, "WaterElemental", this.entityWaterElementalID, this, 120, 3, true);
+ EntityRegistry.registerModEntity(EntityEarthElemental.class, "EarthElemental", this.entityEarthElementalID, this, 120, 3, true);
+ EntityRegistry.registerModEntity(EntityFireElemental.class, "FireElemental", this.entityFireElementalID, this, 120, 3, true);
+ EntityRegistry.registerModEntity(EntityShadeElemental.class, "ShadeElemental", this.entityShadeElementalID, this, 120, 3, true);
+ EntityRegistry.registerModEntity(EntityHolyElemental.class, "HolyElemental", this.entityHolyElementalID, this, 120, 3, true);
+ //EntityRegistry.addSpawn(EntityFallenAngel.class, 5, 1, 5, EnumCreatureType.creature, BiomeGenBase.biomeList);
+ ChestGenHooks.getInfo(ChestGenHooks.DUNGEON_CHEST).addItem(new WeightedRandomChestContent(new ItemStack(ModItems.standardBindingAgent), 1, 3, this.standardBindingAgentDungeonChance));
+ ChestGenHooks.getInfo(ChestGenHooks.DUNGEON_CHEST).addItem(new WeightedRandomChestContent(new ItemStack(ModItems.mundanePowerCatalyst), 1, 1, this.mundanePowerCatalystDungeonChance));
+ ChestGenHooks.getInfo(ChestGenHooks.DUNGEON_CHEST).addItem(new WeightedRandomChestContent(new ItemStack(ModItems.mundaneLengtheningCatalyst), 1, 1, this.mundaneLengtheningCatalystDungeonChance));
+ ChestGenHooks.getInfo(ChestGenHooks.DUNGEON_CHEST).addItem(new WeightedRandomChestContent(new ItemStack(ModItems.averagePowerCatalyst), 1, 1, this.averagePowerCatalystDungeonChance));
+ ChestGenHooks.getInfo(ChestGenHooks.DUNGEON_CHEST).addItem(new WeightedRandomChestContent(new ItemStack(ModItems.averageLengtheningCatalyst), 1, 1, this.averageLengtheningCatalystDungeonChance));
+ ChestGenHooks.getInfo(ChestGenHooks.DUNGEON_CHEST).addItem(new WeightedRandomChestContent(new ItemStack(ModItems.greaterPowerCatalyst), 1, 1, this.greaterPowerCatalystDungeonChance));
+ ChestGenHooks.getInfo(ChestGenHooks.DUNGEON_CHEST).addItem(new WeightedRandomChestContent(new ItemStack(ModItems.greaterLengtheningCatalyst), 1, 1, this.greaterLengtheningCatalystDungeonChance));
+ //Ore Dictionary Registration
+ OreDictionary.registerOre("oreCoal", Blocks.coal_ore);
+ MeteorRegistry.registerMeteorParadigm(diamondStack, diamondMeteorArray, diamondMeteorRadius);
+ MeteorRegistry.registerMeteorParadigm(stoneStack, this.stoneMeteorArray, this.stoneMeteorRadius);
+ MeteorRegistry.registerMeteorParadigm(ironBlockStack, this.ironBlockMeteorArray, this.ironBlockMeteorRadius);
+ MeteorRegistry.registerMeteorParadigm(new ItemStack(Items.nether_star), this.netherStarMeteorArray, this.netherStarMeteorRadius);
+
+ //Register spell component recipes
+ ItemStack complexSpellCrystalStack = new ItemStack(ModItems.itemComplexSpellCrystal);
+ ItemStack quartzRodStack = new ItemStack(ModItems.baseItems,1,0);
+ ItemStack emptyCoreStack = new ItemStack(ModItems.baseItems,1,1);
+ ItemStack magicalesCableStack = new ItemStack(ModItems.baseItems,1,2);
+ ItemStack woodBraceStack = new ItemStack(ModItems.baseItems,1,3);
+ ItemStack stoneBraceStack = new ItemStack(ModItems.baseItems,1,4);
+ ItemStack projectileCoreStack = new ItemStack(ModItems.baseItems,1,5);
+ ItemStack selfCoreStack = new ItemStack(ModItems.baseItems,1,6);
+ ItemStack meleeCoreStack = new ItemStack(ModItems.baseItems,1,7);
+ ItemStack toolCoreStack = new ItemStack(ModItems.baseItems,1,26);
+ ItemStack paradigmBackPlateStack = new ItemStack(ModItems.baseItems,1,8);
+ ItemStack outputCableStack = new ItemStack(ModItems.baseItems,1,9);
+ ItemStack flameCoreStack = new ItemStack(ModItems.baseItems,1,10);
+ ItemStack iceCoreStack = new ItemStack(ModItems.baseItems,1,11);
+ ItemStack windCoreStack = new ItemStack(ModItems.baseItems,1,12);
+ ItemStack earthCoreStack = new ItemStack(ModItems.baseItems,1,13);
+ ItemStack inputCableStack = new ItemStack(ModItems.baseItems,1,14);
+ ItemStack crackedRunicPlateStack = new ItemStack(ModItems.baseItems,1,15);
+ ItemStack runicPlateStack = new ItemStack(ModItems.baseItems,1,16);
+ ItemStack imbuedRunicPlateStack = new ItemStack(ModItems.baseItems,1,17);
+ ItemStack defaultCoreStack = new ItemStack(ModItems.baseItems,1,18);
+ ItemStack offenseCoreStack = new ItemStack(ModItems.baseItems,1,19);
+ ItemStack defensiveCoreStack = new ItemStack(ModItems.baseItems,1,20);
+ ItemStack environmentalCoreStack = new ItemStack(ModItems.baseItems,1,21);
+ ItemStack powerCoreStack = new ItemStack(ModItems.baseItems,1,22);
+ ItemStack costCoreStack = new ItemStack(ModItems.baseItems,1,23);
+ ItemStack potencyCoreStack = new ItemStack(ModItems.baseItems,1,24);
+ ItemStack obsidianBraceStack = new ItemStack(ModItems.baseItems,1,25);
+
+ ItemStack magicalesCraftedCableStack = new ItemStack(ModItems.baseItems,5,2);
+ ItemStack crackedRunicPlateStackCrafted = new ItemStack(ModItems.baseItems,2,15);
+ ItemStack runicPlateStackCrafted = new ItemStack(ModItems.baseItems,2,16);
+
+ GameRegistry.addRecipe(quartzRodStack, "qqq", 'q', new ItemStack(Items.quartz));
+ GameRegistry.addRecipe(emptyCoreStack,"gig","nrn","gig",'n',goldIngotStack,'i',ironIngotStack,'g',glassStack,'r',simpleCatalystStack);
+ GameRegistry.addRecipe(magicalesCraftedCableStack,"sss","mmm","sss",'s',new ItemStack(Items.string),'m',magicalesStack);
+ GameRegistry.addRecipe(woodBraceStack," il","ili","li ",'l', new ItemStack(Blocks.log,1,craftingConstant),'i',new ItemStack(Items.string));
+ GameRegistry.addRecipe(stoneBraceStack," is","isi","si ",'i', ironIngotStack,'s',reinforcedSlateStack);
+ GameRegistry.addRecipe(obsidianBraceStack," is","ibi","si ",'i', obsidianStack,'s',reinforcedSlateStack,'b',stoneBraceStack);
+
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(projectileCoreStack, "mbm","aca","mom",'c', emptyCoreStack,'b',weakBloodShardStack,'m', magicalesStack,'o', magicianBloodOrbStack,'a',new ItemStack(Items.arrow)));
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(selfCoreStack,"sbs","ncn","sos",'c', emptyCoreStack, 's',sanctusStack,'b', weakBloodShardStack,'o', magicianBloodOrbStack,'n',glowstoneDustStack));
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(meleeCoreStack,"sbs","ncn","sos",'c', emptyCoreStack, 's',incendiumStack,'b', weakBloodShardStack,'o', magicianBloodOrbStack,'n',new ItemStack(Items.fire_charge)));
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(toolCoreStack,"sbs","ncn","sos",'c', emptyCoreStack, 's',terraeStack,'b', weakBloodShardStack,'o', magicianBloodOrbStack,'n',new ItemStack(Blocks.obsidian)));
+
+ GameRegistry.addRecipe(paradigmBackPlateStack,"isi","rgr","isi",'i',ironIngotStack,'r',stoneStack,'g',goldIngotStack,'s',reinforcedSlateStack);
+ GameRegistry.addRecipe(outputCableStack, " si","s c"," si",'s',stoneStack,'i',ironIngotStack,'c',simpleCatalystStack);
+
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(flameCoreStack,"mdm","scs","mom",'m',incendiumStack,'c',emptyCoreStack,'o',magicianBloodOrbStack,'d',diamondStack,'s',weakBloodShardStack));
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(iceCoreStack,"mdm","scs","mom",'m',crystallosStack,'c',emptyCoreStack,'o',magicianBloodOrbStack,'d',diamondStack,'s',weakBloodShardStack));
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(windCoreStack,"mdm","scs","mom",'m',aetherStack,'c',emptyCoreStack,'o',magicianBloodOrbStack,'d',diamondStack,'s',weakBloodShardStack));
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(earthCoreStack,"mdm","scs","mom",'m',terraeStack,'c',emptyCoreStack,'o',magicianBloodOrbStack,'d',diamondStack,'s',weakBloodShardStack));
+
+ GameRegistry.addRecipe(inputCableStack, "ws ","rcs","ws ",'w',blankSlateStack,'s',stoneStack,'r',imbuedSlateStack,'c',simpleCatalystStack);
+
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(defaultCoreStack,"msm","geg","mom",'m', strengthenedCatalystStack,'e', emptyCoreStack, 'o', magicianBloodOrbStack, 's',weakBloodShardStack, 'g', goldIngotStack));
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(offenseCoreStack,"msm","geg","mom",'m', offensaStack,'e', emptyCoreStack, 'o', magicianBloodOrbStack, 's',weakBloodShardStack, 'g', goldIngotStack));
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(defensiveCoreStack,"msm","geg","mom",'m', praesidiumStack,'e', emptyCoreStack, 'o', magicianBloodOrbStack, 's',weakBloodShardStack, 'g', goldIngotStack));
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(environmentalCoreStack,"msm","geg","mom",'m', orbisTerraeStack,'e', emptyCoreStack, 'o', magicianBloodOrbStack, 's',weakBloodShardStack, 'g', goldIngotStack));
+
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(powerCoreStack,"msm","geg","mom",'m', virtusStack,'e', emptyCoreStack, 'o', masterBloodOrbStack, 's',weakBloodShardStack, 'g', goldIngotStack));
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(costCoreStack,"msm","geg","mom",'m', reductusStack,'e', emptyCoreStack, 'o', masterBloodOrbStack, 's',weakBloodShardStack, 'g', goldIngotStack));
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(potencyCoreStack,"msm","geg","mom",'m', potentiaStack,'e', emptyCoreStack, 'o', masterBloodOrbStack, 's',weakBloodShardStack, 'g', goldIngotStack));
+
+ AlchemyRecipeRegistry.registerRecipe(crackedRunicPlateStackCrafted, 10, new ItemStack[]{imbuedSlateStack,imbuedSlateStack,concentratedCatalystStack}, 4);
+ AlchemyRecipeRegistry.registerRecipe(runicPlateStack, 30, new ItemStack[]{crackedRunicPlateStack,terraeStack}, 5);
+ AlchemyRecipeRegistry.registerRecipe(imbuedRunicPlateStack, 100, new ItemStack[]{magicalesStack,incendiumStack,runicPlateStack, runicPlateStack,aquasalusStack}, 5);
+ AlchemyRecipeRegistry.registerRecipe(complexSpellCrystalStack,50,new ItemStack[]{new ItemStack(ModItems.blankSpell), weakBloodShardStack, weakBloodShardStack, diamondStack,goldIngotStack},3);
+
+ GameRegistry.addRecipe(new ItemStack(ModBlocks.blockConduit,1,0),"q q","ccc","q q",'q', quartzRodStack,'c', magicalesCableStack);
+
+ GameRegistry.addRecipe(new ItemStack(ModBlocks.blockSpellParadigm,1,0),"gb ","pcw","gb ",'p',paradigmBackPlateStack,'c', projectileCoreStack,'g',goldIngotStack,'b',stoneBraceStack,'w',outputCableStack);
+ GameRegistry.addRecipe(new ItemStack(ModBlocks.blockSpellParadigm,1,1),"gb ","pcw","gb ",'p',paradigmBackPlateStack,'c', selfCoreStack,'g',goldIngotStack,'b',stoneBraceStack,'w',outputCableStack);
+ GameRegistry.addRecipe(new ItemStack(ModBlocks.blockSpellParadigm,1,2),"gb ","pcw","gb ",'p',paradigmBackPlateStack,'c', meleeCoreStack,'g',goldIngotStack,'b',stoneBraceStack,'w',outputCableStack);
+ GameRegistry.addRecipe(new ItemStack(ModBlocks.blockSpellParadigm,1,3),"gb ","pcw","gb ",'p',paradigmBackPlateStack,'c', toolCoreStack,'g',goldIngotStack,'b',stoneBraceStack,'w',outputCableStack);
+
+ GameRegistry.addRecipe(new ItemStack(ModBlocks.blockSpellEffect,1,0),"bgb","ico","bgb",'c',flameCoreStack,'b',stoneBraceStack,'g',goldIngotStack,'i',inputCableStack,'o',outputCableStack);
+ GameRegistry.addRecipe(new ItemStack(ModBlocks.blockSpellEffect,1,1),"bgb","ico","bgb",'c',iceCoreStack,'b',stoneBraceStack,'g',goldIngotStack,'i',inputCableStack,'o',outputCableStack);
+ GameRegistry.addRecipe(new ItemStack(ModBlocks.blockSpellEffect,1,2),"bgb","ico","bgb",'c',windCoreStack,'b',stoneBraceStack,'g',goldIngotStack,'i',inputCableStack,'o',outputCableStack);
+ GameRegistry.addRecipe(new ItemStack(ModBlocks.blockSpellEffect,1,3),"bgb","ico","bgb",'c',earthCoreStack,'b',stoneBraceStack,'g',goldIngotStack,'i',inputCableStack,'o',outputCableStack);
+
+ GameRegistry.addRecipe(new ItemStack(ModBlocks.blockSpellModifier,1,0),"bgb","ico","bgb",'c',defaultCoreStack,'i',inputCableStack,'o',outputCableStack,'b',stoneBraceStack,'g',ironIngotStack);
+ GameRegistry.addRecipe(new ItemStack(ModBlocks.blockSpellModifier,1,1),"bgb","ico","bgb",'c',offenseCoreStack,'i',inputCableStack,'o',outputCableStack,'b',stoneBraceStack,'g',ironIngotStack);
+ GameRegistry.addRecipe(new ItemStack(ModBlocks.blockSpellModifier,1,2),"bgb","ico","bgb",'c',defensiveCoreStack,'i',inputCableStack,'o',outputCableStack,'b',stoneBraceStack,'g',ironIngotStack);
+ GameRegistry.addRecipe(new ItemStack(ModBlocks.blockSpellModifier,1,3),"bgb","ico","bgb",'c',environmentalCoreStack,'i',inputCableStack,'o',outputCableStack,'b',stoneBraceStack,'g',ironIngotStack);
+
+ GameRegistry.addRecipe(new ItemStack(ModBlocks.blockSpellEnhancement,1,0),"bpb","ico","bpb",'c', powerCoreStack,'b',woodBraceStack,'p',crackedRunicPlateStack,'i',inputCableStack,'o',outputCableStack);
+ GameRegistry.addRecipe(new ItemStack(ModBlocks.blockSpellEnhancement,1,1),"bpb","ico","bpb",'c', powerCoreStack,'b',stoneBraceStack,'p',runicPlateStack,'i',inputCableStack,'o',outputCableStack);
+ GameRegistry.addRecipe(new ItemStack(ModBlocks.blockSpellEnhancement,1,2),"bpb","ico","bpb",'c', powerCoreStack,'b',obsidianBraceStack,'p',imbuedRunicPlateStack,'i',inputCableStack,'o',outputCableStack);
+ GameRegistry.addRecipe(new ItemStack(ModBlocks.blockSpellEnhancement,1,5),"bpb","ico","bpb",'c', costCoreStack,'b',woodBraceStack,'p',crackedRunicPlateStack,'i',inputCableStack,'o',outputCableStack);
+ GameRegistry.addRecipe(new ItemStack(ModBlocks.blockSpellEnhancement,1,6),"bpb","ico","bpb",'c', costCoreStack,'b',stoneBraceStack,'p',runicPlateStack,'i',inputCableStack,'o',outputCableStack);
+ GameRegistry.addRecipe(new ItemStack(ModBlocks.blockSpellEnhancement,1,7),"bpb","ico","bpb",'c', costCoreStack,'b',obsidianBraceStack,'p',imbuedRunicPlateStack,'i',inputCableStack,'o',outputCableStack);
+ GameRegistry.addRecipe(new ItemStack(ModBlocks.blockSpellEnhancement,1,10),"bpb","ico","bpb",'c', potencyCoreStack,'b',woodBraceStack,'p',crackedRunicPlateStack,'i',inputCableStack,'o',outputCableStack);
+ GameRegistry.addRecipe(new ItemStack(ModBlocks.blockSpellEnhancement,1,11),"bpb","ico","bpb",'c', potencyCoreStack,'b',stoneBraceStack,'p',runicPlateStack,'i',inputCableStack,'o',outputCableStack);
+ GameRegistry.addRecipe(new ItemStack(ModBlocks.blockSpellEnhancement,1,12),"bpb","ico","bpb",'c', potencyCoreStack,'b',obsidianBraceStack,'p',imbuedRunicPlateStack,'i',inputCableStack,'o',outputCableStack);
+
+ GameRegistry.addRecipe(new ItemStack(ModItems.itemAttunedCrystal), "Sr ", " ar", "s S", 'r', quartzRodStack, 's', new ItemStack(Items.stick,1,craftingConstant), 'a', strengthenedCatalystStack, 'S', stoneStack);
+ GameRegistry.addRecipe(new ItemStack(ModItems.itemTankSegmenter), "gqi", " rq", "q g", 'q', quartzRodStack, 'i', ironIngotStack, 'r', strengthenedCatalystStack, 'g', goldIngotStack);
+ GameRegistry.addRecipe(new ItemStack(ModItems.itemDestinationClearer), "qcq", "c c", "qcq", 'q', quartzRodStack, 'c', simpleCatalystStack);
+
+ GameRegistry.addRecipe(new ItemStack(ModBlocks.blockAlchemicCalcinator), "pgp", "gsg", "ccc", 'p', crackedRunicPlateStack, 'g', glassStack, 's', strengthenedCatalystStack, 'c', cobblestoneStack);
+ GameRegistry.addRecipe(new ItemStack(ModBlocks.blockCrystalBelljar), "GGG", "GcG", "www", 'G', glassStack, 'c', concentratedCatalystStack, 'w', new ItemStack(Blocks.wooden_slab,1,craftingConstant));
+ GameRegistry.addRecipe(new ItemStack(ModBlocks.blockReagentConduit), "isi", "scs", "isi", 'c', concentratedCatalystStack, 's', stringStack, 'i', ironIngotStack);
+
+ GameRegistry.addShapelessRecipe(new ItemStack(Items.dye,5,15),fracturedBoneStack);
+
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(new ItemStack(ModItems.itemSigilOfSupression),"wtl","wvl","wol",'v',new ItemStack(ModItems.voidSigil),'t',new ItemStack(ModBlocks.blockTeleposer),'o',masterBloodOrbStack,'l',lavaBucketStack,'w',waterBucketStack));
+ GameRegistry.addRecipe(new ShapedBloodOrbRecipe(new ItemStack(ModItems.itemSigilOfEnderSeverance),"ptp","ese","pop",'s',new ItemStack(ModItems.demonicSlate),'t',weakBloodShardStack,'o',masterBloodOrbStack,'e',new ItemStack(Items.ender_eye),'p', new ItemStack(Items.ender_pearl)));
+
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(Items.flint,2,0), 1, new ItemStack[]{new ItemStack(Blocks.gravel),new ItemStack(Items.flint)}, 1);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(Blocks.grass), 2, new ItemStack[]{new ItemStack(Blocks.dirt),new ItemStack(Items.dye,1,15),new ItemStack(Items.wheat_seeds),new ItemStack(Items.wheat_seeds)}, 1);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(Items.leather,3,0), 2, new ItemStack[]{new ItemStack(Items.rotten_flesh),new ItemStack(Items.rotten_flesh),new ItemStack(Items.rotten_flesh),waterBucketStack,new ItemStack(Items.flint)}, 1);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(Items.bread), 1, new ItemStack[]{new ItemStack(Items.wheat),new ItemStack(Items.sugar)}, 1);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(Items.fire_charge,5,0), 3, new ItemStack[]{new ItemStack(Items.coal),new ItemStack(Items.blaze_powder),gunpowderStack}, 1);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(Blocks.sand,2,0), 1, new ItemStack[]{new ItemStack(Blocks.cobblestone),gunpowderStack}, 1);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(Blocks.clay,4,0), 2, new ItemStack[]{new ItemStack(Blocks.hardened_clay,1,craftingConstant),new ItemStack(Blocks.hardened_clay,1,craftingConstant),new ItemStack(Blocks.hardened_clay,1,craftingConstant),new ItemStack(Blocks.hardened_clay,1,craftingConstant),waterBucketStack}, 1);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(Items.string,4,0), 1, new ItemStack[]{new ItemStack(Blocks.wool,1,craftingConstant),new ItemStack(Items.flint)}, 1);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(Blocks.gravel,2,0), 1, new ItemStack[]{new ItemStack(Blocks.stone),gunpowderStack}, 1);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(Blocks.obsidian), 1, new ItemStack[]{waterBucketStack,lavaBucketStack}, 1);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(Items.paper), 1, new ItemStack[]{new ItemStack(Items.reeds)}, 1);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(Blocks.soul_sand,3,0), 3, new ItemStack[]{new ItemStack(Blocks.sand),new ItemStack(Blocks.sand),new ItemStack(Blocks.sand),waterBucketStack,weakBloodShardStack}, 3);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(Blocks.mycelium,1,0), 5, new ItemStack[]{new ItemStack(Blocks.grass),new ItemStack(Blocks.brown_mushroom), new ItemStack(Blocks.red_mushroom)}, 2);
+ AlchemyRecipeRegistry.registerRecipe(new ItemStack(Blocks.ice), 2, new ItemStack[]{waterBucketStack,new ItemStack(Items.snowball)}, 1);
+ }
+
+ @EventHandler
+ public void postInit(FMLPostInitializationEvent event)
+ {
+ //TODO Thaumcraft Integration
+ if (Loader.isModLoaded("Thaumcraft"))
+ {
+ this.isThaumcraftLoaded = true;
+
+ try
+ {
+ //do stuff
+ ModItems.sanguineHelmet = new ItemSanguineArmour(0).setUnlocalizedName("sanguineHelmet");
+ ModItems.sanguineRobe = new ItemSanguineArmour(1).setUnlocalizedName("sanguineRobe");
+ ModItems.sanguinePants = new ItemSanguineArmour(2).setUnlocalizedName("sanguinePants");
+ ModItems.sanguineBoots = new ItemSanguineArmour(3).setUnlocalizedName("sanguineBoots");
+ GameRegistry.registerItem(ModItems.sanguineHelmet, "sanguineHelmet");
+ GameRegistry.registerItem(ModItems.sanguineRobe, "sanguineRobe");
+ GameRegistry.registerItem(ModItems.sanguinePants, "sanguinePants");
+ GameRegistry.registerItem(ModItems.sanguineBoots, "sanguineBoots");
+
+ ItemStack itemGoggles = ItemApi.getItem("itemGoggles", 0);
+ Item itemThaumChest = GameRegistry.findItem("Thaumcraft", "ItemChestplateThaumium");
+ Item itemThaumLeggings = GameRegistry.findItem("Thaumcraft", "ItemLeggingsThaumium");
+ Item itemThaumBoots = GameRegistry.findItem("Thaumcraft", "ItemBootsThaumium");
+
+ AspectList aspectList = new AspectList();
+ aspectList.add(Aspect.ARMOR, 5).add(Aspect.MAGIC, 5);
+
+ ThaumcraftApi.registerObjectTag(new ItemStack(ModItems.sanguineHelmet), aspectList);
+ ThaumcraftApi.registerObjectTag(new ItemStack(ModItems.sanguineRobe), aspectList);
+ ThaumcraftApi.registerObjectTag(new ItemStack(ModItems.sanguinePants), aspectList);
+ ThaumcraftApi.registerObjectTag(new ItemStack(ModItems.sanguineBoots), aspectList);
+
+
+
+ if (itemGoggles != null)
+ {
+ BindingRegistry.registerRecipe(new ItemStack(ModItems.sanguineHelmet), itemGoggles);
+ }
+
+ if(itemThaumChest != null)
+ {
+ BindingRegistry.registerRecipe(new ItemStack(ModItems.sanguineRobe), new ItemStack(itemThaumChest));
+ }
+
+ if(itemThaumLeggings != null)
+ {
+ BindingRegistry.registerRecipe(new ItemStack(ModItems.sanguinePants), new ItemStack(itemThaumLeggings));
+ }
+
+ if(itemThaumBoots != null)
+ {
+ BindingRegistry.registerRecipe(new ItemStack(ModItems.sanguineBoots), new ItemStack(itemThaumBoots));
+ }
+
+ //LogHelper.log(Level.INFO, "Loaded RP2 World addon");
+ } catch (Exception e)
+ {
+ //LogHelper.log(Level.SEVERE, "Could not load RP2 World addon");
+ e.printStackTrace(System.err);
+ }
+ } else
+ {
+ this.isThaumcraftLoaded = false;
+ }
+
+ if(Loader.isModLoaded("Forestry"))
+ {
+ this.isForestryLoaded = true;
+
+// ModItems.itemBloodFrame = new ItemBloodFrame(this.itemBloodFrameItemID).setUnlocalizedName("bloodFrame");
+//
+// ItemStack provenFrame = GameRegistry.findItemStack("Forestry", "frameImpregnated", 1);
+//
+// if(provenFrame !=null)
+// {
+// AltarRecipeRegistry.registerAltarRecipe(new ItemStack(ModItems.itemBloodFrame), provenFrame, 3, 30000, 20, 20, false);
+// }
+ }else
+ {
+ this.isForestryLoaded = false;
+ }
+
+ if(Loader.isModLoaded("harvestcraft"))
+ {
+ PamHarvestCompatRegistry.registerPamHandlers();
+ System.out.println("Loaded Harvestcraft Handlers!");
+ }
+
+ BloodMagicConfiguration.loadBlacklist();
+ }
+
+ public static void initAlchemyPotionRecipes()
+ {
+ AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.ghast_tear), Potion.regeneration.id, 450);
+ AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.golden_carrot), Potion.nightVision.id, 2 * 60 * 20);
+ AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.magma_cream), Potion.fireResistance.id, 2 * 60 * 20);
+ AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.water_bucket), Potion.waterBreathing.id, 2 * 60 * 20);
+ AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.sugar), Potion.moveSpeed.id, 2 * 60 * 20);
+ AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.speckled_melon), Potion.heal.id, 2 * 60 * 20);
+ AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.spider_eye), Potion.poison.id, 450);
+ AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.dye,1,0), Potion.blindness.id, 450);
+ AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.fermented_spider_eye), Potion.weakness.id, 450);
+ AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.blaze_powder), Potion.damageBoost.id, 2 * 60 * 20);
+ AlchemicalPotionCreationHandler.addPotion(new ItemStack(ModItems.aether), Potion.jump.id, 2 * 60 * 20);
+ AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.clay_ball), Potion.moveSlowdown.id, 450);
+ AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.redstone), Potion.digSpeed.id, 2 * 60 * 20);
+ AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.potionitem, 1, 0), AlchemicalWizardry.customPotionDrowning.id, 450);
+ //AlchemicalPotionCreationHandler.addPotion(new ItemStack(Item.goldenCarrot),Potion.nightVision.id,2*60*20);
+ AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.glass_bottle), Potion.invisibility.id, 2 * 60 * 20);
+ AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.diamond), Potion.resistance.id, 2 * 60 * 20);
+ AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.poisonous_potato), Potion.field_76443_y.id, 2); //saturation
+ AlchemicalPotionCreationHandler.addPotion(new ItemStack(ModItems.demonBloodShard), Potion.field_76434_w.id, 4 * 60 * 20); //health boost
+ AlchemicalPotionCreationHandler.addPotion(new ItemStack(ModItems.weakBloodShard), Potion.field_76444_x.id, 4 * 60 * 20); //Absorption
+ AlchemicalPotionCreationHandler.addPotion(new ItemStack(ModItems.terrae), AlchemicalWizardry.customPotionBoost.id, 1 * 60 * 20);
+ AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.feather), AlchemicalWizardry.customPotionFlight.id, 1 * 60 * 20);
+ AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.arrow), AlchemicalWizardry.customPotionReciprocation.id, 1 * 60 * 20);
+ AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.ender_pearl),AlchemicalWizardry.customPotionPlanarBinding.id,1*60*20);
+ AlchemicalPotionCreationHandler.addPotion(new ItemStack(Blocks.soul_sand),AlchemicalWizardry.customPotionSoulFray.id,60*20);
+ AlchemicalPotionCreationHandler.addPotion(new ItemStack(ModItems.baseItems,1,16),AlchemicalWizardry.customPotionSoulHarden.id,60*20);
+ AlchemicalPotionCreationHandler.addPotion(new ItemStack(Items.slime_ball),AlchemicalWizardry.customPotionDeaf.id,60*20);
+ }
+
+ public static void initAltarRecipes()
+ {
+ AltarRecipeRegistry.registerAltarRecipe(new ItemStack(ModItems.weakBloodOrb), new ItemStack(Items.diamond),1,2000,2,1,false);
+ AltarRecipeRegistry.registerAltarRecipe(new ItemStack(ModItems.apprenticeBloodOrb), new ItemStack(Items.emerald),2,5000,5,5,false);
+ AltarRecipeRegistry.registerAltarRecipe(new ItemStack(ModItems.magicianBloodOrb), new ItemStack(Blocks.gold_block),3,25000,20,20,false);
+ AltarRecipeRegistry.registerAltarRecipe(new ItemStack(ModItems.masterBloodOrb), new ItemStack(ModItems.weakBloodShard),4,40000,30,50,false);
+ AltarRecipeRegistry.registerAltarRecipe(new ItemStack(ModItems.archmageBloodOrb), new ItemStack(ModItems.demonBloodShard),5,75000,50,100,false);
+
+ AltarRecipeRegistry.registerAltarOrbRecipe(new ItemStack(ModItems.weakBloodOrb),1,2);
+ AltarRecipeRegistry.registerAltarOrbRecipe(new ItemStack(ModItems.apprenticeBloodOrb),2,5);
+ AltarRecipeRegistry.registerAltarOrbRecipe(new ItemStack(ModItems.magicianBloodOrb),3,15);
+ AltarRecipeRegistry.registerAltarOrbRecipe(new ItemStack(ModItems.masterBloodOrb),4,25);
+ AltarRecipeRegistry.registerAltarOrbRecipe(new ItemStack(ModItems.archmageBloodOrb),5,50);
+
+ AltarRecipeRegistry.registerAltarRecipe(new ItemStack(ModItems.telepositionFocus), new ItemStack(Items.ender_pearl),4,2000,10,10,false);
+ AltarRecipeRegistry.registerAltarRecipe(new ItemStack(ModItems.enhancedTelepositionFocus), new ItemStack(ModItems.telepositionFocus),4,10000,25,15,false);
+ AltarRecipeRegistry.registerAltarRecipe(new ItemStack(ModItems.demonicSlate), new ItemStack(ModItems.imbuedSlate),4,15000,20,20,false);
+ AltarRecipeRegistry.registerAltarRecipe(new ItemStack(ModItems.duskScribeTool), new ItemStack(Blocks.coal_block),4,2000,20,10,false);
+ AltarRecipeRegistry.registerAltarRecipe(new ItemStack(ModBlocks.bloodSocket), new ItemStack(ModBlocks.emptySocket),3,30000,40,10,false);
+ AltarRecipeRegistry.registerAltarRecipe(new ItemStack(ModItems.earthScribeTool), new ItemStack(Blocks.obsidian),3,1000,5,5,false);
+ AltarRecipeRegistry.registerAltarRecipe(new ItemStack(ModItems.waterScribeTool), new ItemStack(Blocks.lapis_block),3,1000,5,5,false);
+ AltarRecipeRegistry.registerAltarRecipe(new ItemStack(ModItems.blankSpell), new ItemStack(Blocks.glass),2,1000,5,5,false);
+ AltarRecipeRegistry.registerAltarRecipe(new ItemStack(ModItems.blankSlate), new ItemStack(Blocks.stone),1,1000,5,5,false);
+ AltarRecipeRegistry.registerAltarRecipe(new ItemStack(ModItems.activationCrystal), new ItemStack(ModItems.lavaCrystal),3,10000,20,10,false);
+ AltarRecipeRegistry.registerAltarRecipe(new ItemStack(ModItems.fireScribeTool), new ItemStack(Items.magma_cream),3,1000,5,5,false);
+ AltarRecipeRegistry.registerAltarRecipe(new ItemStack(ModItems.airScribeTool), new ItemStack(Items.ghast_tear),3,1000,5,5,false);
+ AltarRecipeRegistry.registerAltarRecipe(new ItemStack(ModItems.imbuedSlate), new ItemStack(ModItems.reinforcedSlate),3,5000,15,10,false);
+ AltarRecipeRegistry.registerAltarRecipe(new ItemStack(ModItems.daggerOfSacrifice), new ItemStack(Items.iron_sword),2,3000,5,5,false);
+ AltarRecipeRegistry.registerAltarRecipe(new ItemStack(ModItems.alchemyFlask), new ItemStack(Items.glass_bottle),2,2000,5,5,false);
+ AltarRecipeRegistry.registerAltarRecipe(new ItemStack(ModItems.reinforcedSlate), new ItemStack(ModItems.blankSlate),2,2000,5,5,false);
+ AltarRecipeRegistry.registerAltarRecipe(new ItemStack(ModItems.bucketLife), new ItemStack(Items.bucket),1,1000,5,0,false);
+ }
+
+ public static void initRituals()
+ {
+ Rituals.registerRitual("AW001Water", 1, 500, new RitualEffectWater(), "Ritual of the Full Spring", new AlchemyCircleRenderer(new ResourceLocation("alchemicalwizardry:textures/models/SimpleTransCircle.png"),0,30,255,255,0,0.501,0.8,0, 1.5, false));
+ Rituals.registerRitual("AW002Lava", 1, 10000, new RitualEffectLava(), "Serenade of the Nether", new AlchemyCircleRenderer(new ResourceLocation("alchemicalwizardry:textures/models/SimpleTransCircle.png"),255,0,0,255,0,0.501,0.8,0, 1.5, false));
+ Rituals.registerRitual("AW003GreenGrove", 1, 1000, new RitualEffectGrowth(), "Ritual of the Green Grove", new AlchemyCircleRenderer(new ResourceLocation("alchemicalwizardry:textures/models/SimpleTransCircle.png"),244,164,96,255,0,1.0,1.6,0, 1.5, false));
+ Rituals.registerRitual("AW004Interdiction", 1, 1000, new RitualEffectInterdiction(), "Interdiction Ritual", new AlchemyCircleRenderer(new ResourceLocation("alchemicalwizardry:textures/models/SimpleTransCircle.png"),27,227,206,255,0,0.501,0.8, 0, 1.5, false));
+ Rituals.registerRitual("AW005Containment", 1, 2000, new RitualEffectContainment(), "Ritual of Containment", new AlchemyCircleRenderer(new ResourceLocation("alchemicalwizardry:textures/models/SimpleTransCircle.png"),186,21,21,255,0,2.5, 2.5, 0, 2.5, false));
+ Rituals.registerRitual("AW006Binding", 1, 5000, new RitualEffectSoulBound(), "Ritual of Binding", new AlchemyCircleRenderer(new ResourceLocation("alchemicalwizardry:textures/models/TransCircleBinding.png"),193,7,7,255,0,0.501,1.0,0, 2.5, true));
+ Rituals.registerRitual("AW007Unbinding", 1, 30000, new RitualEffectUnbinding(), "Ritual of Unbinding", new AlchemyCircleRenderer(new ResourceLocation("alchemicalwizardry:textures/models/SimpleTransCircle.png"),193,7,7,255, 0, 0.5, 0.8, 0, 2.5, false));
+ Rituals.registerRitual("AW008HighJump", 1, 1000, new RitualEffectJumping(), "Ritual of the High Jump", new AlchemyCircleRenderer(new ResourceLocation("alchemicalwizardry:textures/models/SimpleTransCircle.png"),10,183,173,255, 0, 0.501, 1.501, 0, 1.5, false));
+ Rituals.registerRitual("AW009Magnetism", 1, 5000, new RitualEffectMagnetic(), "Ritual of Magnetism", new AlchemyCircleRenderer(new ResourceLocation("alchemicalwizardry:textures/models/SimpleTransCircle.png"),126,39,0,255, 0, 0.501, 2.0, 0, 1.5, false));
+ Rituals.registerRitual("AW010Crusher", 1, 2500, new RitualEffectCrushing(), "Ritual of the Crusher", new AlchemyCircleRenderer(new ResourceLocation("alchemicalwizardry:textures/models/SimpleTransCircle.png"),0,0,0,255, 0, 0.501, 0.501, 0, 1.5, false));
+ Rituals.registerRitual("AW011Speed", 1, 1000, new RitualEffectLeap(), "Ritual of Speed", new AlchemyCircleRenderer(new ResourceLocation("alchemicalwizardry:textures/models/SimpleTransCircle.png"),0,0,0,255, 0, 0.501, 0.501, 0, 1.5, false));
+ Rituals.registerRitual("AW012AnimalGrowth", 1, 10000, new RitualEffectAnimalGrowth(), "Ritual of the Shepherd", new AlchemyCircleRenderer(new ResourceLocation("alchemicalwizardry:textures/models/SimpleTransCircle.png"),0,0,0,255, 0, 0.501, 0.501, 0, 1.5, false));
+ Rituals.registerRitual("AW013Suffering", 1, 50000, new RitualEffectWellOfSuffering(), "Well of Suffering", new AlchemyCircleRenderer(new ResourceLocation("alchemicalwizardry:textures/models/TransCircleSuffering.png"),0,0,0,255,0,0.501,0.8,0, 2.5, true));
+ Rituals.registerRitual("AW014Regen", 1, 25000, new RitualEffectHealing(), "Ritual of Regeneration", new AlchemyCircleRenderer(new ResourceLocation("alchemicalwizardry:textures/models/SimpleTransCircle.png"),0,0,0,255, 0, 0.501, 0.501, 0, 1.5, false));
+ Rituals.registerRitual("AW015FeatheredKnife", 1, 50000, new RitualEffectFeatheredKnife(), "Ritual of the Feathered Knife", new AlchemyCircleRenderer(new ResourceLocation("alchemicalwizardry:textures/models/SimpleTransCircle.png"),0,0,0,255, 0, 0.501, 0.501, 0, 1.5, false));
+ Rituals.registerRitual("AW016FeatheredEarth", 2, 100000, new RitualEffectFeatheredEarth(), "Ritual of the Feathered Earth", new AlchemyCircleRenderer(new ResourceLocation("alchemicalwizardry:textures/models/SimpleTransCircle.png"),0,0,0,255, 0, 0.501, 0.501, 0, 1.5, false));
+ Rituals.registerRitual("AW017Gaia", 2, 1000000, new RitualEffectBiomeChanger(), "Ritual of Gaia's Transformation", new AlchemyCircleRenderer(new ResourceLocation("alchemicalwizardry:textures/models/SimpleTransCircle.png"),0,0,0,255, 0, 0.501, 0.501, 0, 1.5, false));
+ Rituals.registerRitual("AW018Condor", 2, 1000000, new RitualEffectFlight(), "Reverence of the Condor", new AlchemyCircleRenderer(new ResourceLocation("alchemicalwizardry:textures/models/SimpleTransCircle.png"),0,0,0,255, 0, 0.501, 0.501, 0, 1.5, false));
+ Rituals.registerRitual("AW019FallingTower", 2, 1000000, new RitualEffectSummonMeteor(), "Mark of the Falling Tower", new AlchemyCircleRenderer(new ResourceLocation("alchemicalwizardry:textures/models/SimpleTransCircle.png"),0,0,0,255, 0, 0.501, 0.501, 0, 1.5, false));
+ Rituals.registerRitual("AW020BalladOfAlchemy", 1, 20000, new RitualEffectAutoAlchemy(), "Ballad of Alchemy", new AlchemyCircleRenderer(new ResourceLocation("alchemicalwizardry:textures/models/SimpleTransCircle.png"),0,0,0,255, 0, 0.501, 0.501, 0, 1.5, false));
+ Rituals.registerRitual("AW021Expulsion", 1, 1000000, new RitualEffectExpulsion(), "Aura of Expulsion", new AlchemyCircleRenderer(new ResourceLocation("alchemicalwizardry:textures/models/SimpleTransCircle.png"),0,0,0,255, 0, 0.501, 0.501, 0, 1.5, false));
+ Rituals.registerRitual("AW022Supression", 1, 10000, new RitualEffectSupression(), "Dome of Supression", new AlchemyCircleRenderer(new ResourceLocation("alchemicalwizardry:textures/models/SimpleTransCircle.png"),0,0,0,255, 0, 0.501, 0.501, 0, 1.5, false));
+ Rituals.registerRitual("AW023Zephyr", 1, 25000, new RitualEffectItemSuction(),"Call of the Zephyr", new AlchemyCircleRenderer(new ResourceLocation("alchemicalwizardry:textures/models/SimpleTransCircle.png"),0,0,0,255, 0, 0.501, 0.501, 0, 1.5, false));
+ Rituals.registerRitual("AW024Harvest", 1, 20000, new RitualEffectHarvest(), "Reap of the Harvest Moon", new AlchemyCircleRenderer(new ResourceLocation("alchemicalwizardry:textures/models/SimpleTransCircle.png"),0,0,0,255, 0, 0.501, 0.501, 0, 1.5, false));
+ Rituals.registerRitual("AW025Conduit", 2, 2000000, new RitualEffectLifeConduit(), "Cry of the Eternal Soul", new AlchemyCircleRenderer(new ResourceLocation("alchemicalwizardry:textures/models/SimpleTransCircle.png"),0,0,0,255, 0, 0.501, 0.501, 0, 1.5, false));
+ Rituals.registerRitual("AW026Ellipsoid", 1, 25000, new RitualEffectEllipsoid(), "Focus of the Ellipsoid", new AlchemyCircleRenderer(new ResourceLocation("alchemicalwizardry:textures/models/SimpleTransCircle.png"),0,0,0,255, 0, 0.501, 0.501, 0, 1.5, false));
+ Rituals.registerRitual("AW027Evaporation", 1, 20000, new RitualEffectEvaporation(), "Song of Evaporation", new AlchemyCircleRenderer(new ResourceLocation("alchemicalwizardry:textures/models/SimpleTransCircle.png"),0,0,0,255, 0, 0.501, 0.501, 0, 1.5, false));
+ Rituals.registerRitual("AW028SpawnWard", 1, 150000, new RitualEffectSpawnWard(), "Ward of Sacrosanctity", new AlchemyCircleRenderer(new ResourceLocation("alchemicalwizardry:textures/models/SimpleTransCircle.png"),0,0,0,255, 0, 0.501, 0.501, 0, 1.5, false));
+ Rituals.registerRitual("AW029VeilOfEvil", 1, 150000, new RitualEffectVeilOfEvil(), "Veil of Evil", new AlchemyCircleRenderer(new ResourceLocation("alchemicalwizardry:textures/models/SimpleTransCircle.png"),0,0,0,255, 0, 0.501, 0.501, 0, 1.5, false));
+ Rituals.registerRitual("AW030FullStomach", 1, 100000, new RitualEffectFullStomach(), "Requiem of the Satiated Stomach", new AlchemyCircleRenderer(new ResourceLocation("alchemicalwizardry:textures/models/SimpleTransCircle.png"),0,0,0,255, 0, 0.501, 0.501, 0, 1.5, false));
+ //Rituals.registerRitual(1,100,new RitualEffectApiaryOverclock(),"Apiary Overclock"));
+ }
+
+ public static void initBindingRecipes()
+ {
+ BindingRegistry.registerRecipe(new ItemStack(ModItems.boundPickaxe), new ItemStack(Items.diamond_pickaxe));
+ BindingRegistry.registerRecipe(new ItemStack(ModItems.boundAxe), new ItemStack(Items.diamond_axe));
+ BindingRegistry.registerRecipe(new ItemStack(ModItems.boundShovel), new ItemStack(Items.diamond_shovel));
+ BindingRegistry.registerRecipe(new ItemStack(ModItems.energySword), new ItemStack(Items.diamond_sword));
+ BindingRegistry.registerRecipe(new ItemStack(ModItems.energyBlaster), new ItemStack(ModItems.apprenticeBloodOrb));
+ }
+
+ public static void initHarvestRegistry()
+ {
+ HarvestRegistry.registerHarvestHandler(new BloodMagicHarvestHandler());
+ HarvestRegistry.registerHarvestHandler(new GourdHarvestHandler());
+ HarvestRegistry.registerHarvestHandler(new CactusReedHarvestHandler());
+ }
+
+ public static void initCombinedAlchemyPotionRecipes()
+ {
+ CombinedPotionRegistry.registerCombinedPotionRecipe(customPotionFlameCloak, Potion.moveSpeed, Potion.regeneration);
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/BloodMagicConfiguration.java b/src-backup/main/java/WayofTime/alchemicalWizardry/BloodMagicConfiguration.java
new file mode 100644
index 00000000..4e581591
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/BloodMagicConfiguration.java
@@ -0,0 +1,147 @@
+package WayofTime.alchemicalWizardry;
+
+import java.io.File;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map.Entry;
+
+import net.minecraft.entity.EntityList;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraftforge.common.config.Configuration;
+import WayofTime.alchemicalWizardry.client.renderer.ColourThreshold;
+import WayofTime.alchemicalWizardry.client.renderer.RenderHelper;
+import WayofTime.alchemicalWizardry.common.summoning.meteor.MeteorParadigm;
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.relauncher.Side;
+
+/**
+ * Created with IntelliJ IDEA.
+ * User: Pokefenn
+ * Date: 17/01/14
+ * Time: 19:50
+ */
+public class BloodMagicConfiguration
+{
+ private static final String DEFAULT_COLOR_LIST = "100,f; 80,7; 60,e; 40,6; 25,c; 10,4";
+ public static final List colorList = new ArrayList();
+
+ public static Configuration config;
+ public static final String CATEGORY_GAMEPLAY = "gameplay";
+
+
+ public static void init(File configFile)
+ {
+ for (String s : DEFAULT_COLOR_LIST.split(";"))
+ {
+ String[] ct = s.split(",");
+ colorList.add(new ColourThreshold(Integer.valueOf(ct[0].trim()), ct[1].trim()));
+ }
+
+
+ config = new Configuration(configFile);
+
+ try
+ {
+
+ config.load();
+
+ AlchemicalWizardry.standardBindingAgentDungeonChance = config.get("Dungeon Loot Chances", "standardBindingAgent", 30).getInt();
+ AlchemicalWizardry.mundanePowerCatalystDungeonChance = config.get("Dungeon Loot Chances", "mundanePowerCatalyst", 20).getInt();
+ AlchemicalWizardry.averagePowerCatalystDungeonChance = config.get("Dungeon Loot Chances", "averagePowerCatalyst", 10).getInt();
+ AlchemicalWizardry.greaterPowerCatalystDungeonChance = config.get("Dungeon Loot Chances", "greaterPowerCatalyst", 05).getInt();
+ AlchemicalWizardry.mundaneLengtheningCatalystDungeonChance = config.get("Dungeon Loot Chances", "mundaneLengtheningCatalyst", 20).getInt();
+ AlchemicalWizardry.averageLengtheningCatalystDungeonChance = config.get("Dungeon Loot Chances", "averageLengtheningCatalyst", 10).getInt();
+ AlchemicalWizardry.greaterLengtheningCatalystDungeonChance = config.get("Dungeon Loot Chances", "greaterLengtheningCatalyst", 05).getInt();
+ AlchemicalWizardry.customPotionDrowningID = config.get("Potion ID", "Drowning", 100).getInt();
+ AlchemicalWizardry.customPotionBoostID = config.get("Potion ID", "Boost", 101).getInt();
+ AlchemicalWizardry.customPotionProjProtID = config.get("Potion ID", "ProjProt", 102).getInt();
+ AlchemicalWizardry.customPotionInhibitID = config.get("Potion ID", "Inhibit", 103).getInt();
+ AlchemicalWizardry.customPotionFlightID = config.get("Potion ID", "Flight", 104).getInt();
+ AlchemicalWizardry.customPotionReciprocationID = config.get("Potion ID", "Reciprocation", 105).getInt();
+ AlchemicalWizardry.customPotionFlameCloakID = config.get("Potion ID","FlameCloak",106).getInt();
+ AlchemicalWizardry.customPotionIceCloakID = config.get("Potion ID","IceCloak",107).getInt();
+ AlchemicalWizardry.customPotionHeavyHeartID = config.get("Potion ID","HeavyHeart",108).getInt();
+ AlchemicalWizardry.customPotionFireFuseID = config.get("Potion ID","FireFuse",109).getInt();
+ AlchemicalWizardry.customPotionPlanarBindingID = config.get("Potion ID","PlanarBinding",110).getInt();
+ AlchemicalWizardry.customPotionSoulFrayID = config.get("Potion ID","SoulFray",111).getInt();
+ AlchemicalWizardry.customPotionSoulHardenID = config.get("Potion ID", "SoulHarden", 112).getInt();
+ AlchemicalWizardry.customPotionDeafID = config.get("Potion ID", "Deaf", 113).getInt();
+ AlchemicalWizardry.customPotionFeatherFallID = config.get("Potion ID", "FeatherFall", 114).getInt();
+
+ MeteorParadigm.maxChance = config.get("meteor", "maxChance", 1000).getInt();
+ AlchemicalWizardry.doMeteorsDestroyBlocks = config.get("meteor", "doMeteorsDestroyBlocks", true).getBoolean(true);
+ AlchemicalWizardry.diamondMeteorArray = config.get("meteor", "diamondMeteor", new String[]{"oreDiamond", "100", "oreEmerald", "75", "oreCinnabar", "200", "oreAmber", "200"}).getStringList();
+ AlchemicalWizardry.diamondMeteorRadius = config.get("meteor", "diamondMeteorRadius", 5).getInt();
+ AlchemicalWizardry.stoneMeteorArray = config.get("meteor", "stoneBlockMeteor", new String[]{"oreCoal", "150", "oreApatite", "50", "oreIron", "50"}).getStringList();
+ AlchemicalWizardry.stoneMeteorRadius = config.get("meteor", "stoneMeteorRadius", 16).getInt();
+ AlchemicalWizardry.ironBlockMeteorArray = config.get("meteor", "ironBlockMeteor", new String[]{"oreIron", "400", "oreGold", "30", "oreCopper", "200", "oreTin", "140", "oreSilver", "70", "oreLead", "80", "oreLapis", "60", "oreRedstone", "100"}).getStringList();
+ AlchemicalWizardry.ironBlockMeteorRadius = config.get("meteor", "ironBlockMeteorRadius", 7).getInt();
+ AlchemicalWizardry.netherStarMeteorArray = config.get("meteor", "netherStarMeteor", new String[]{"oreDiamond", "150", "oreEmerald", "100", "oreQuartz", "250", "oreSunstone", "5", "oreMoonstone", "50", "oreIridium", "5", "oreCertusQuartz", "150"}).getStringList();
+ AlchemicalWizardry.netherStarMeteorRadius = config.get("meteor", "netherStarMeteorRadius", 3).getInt();
+
+ AlchemicalWizardry.allowedCrushedOresArray = config.get("oreCrushing", "allowedOres", new String[]{"iron","gold","copper","tin","lead","silver","osmium"}).getStringList();
+
+ AlchemicalWizardry.wimpySettings = config.get("WimpySettings","IDontLikeFun",false).getBoolean(false);
+ AlchemicalWizardry.respawnWithDebuff = config.get("WimpySettings", "RespawnWithDebuff", true).getBoolean();
+ AlchemicalWizardry.causeHungerWithRegen = config.get("WimpySettings", "causeHungerWithRegen", true).getBoolean();
+// AlchemicalWizardry.lockdownAltar = config.get("WimpySettings", "LockdownAltarWithRegen", true).getBoolean();
+ AlchemicalWizardry.lockdownAltar = false;
+
+ Side side = FMLCommonHandler.instance().getSide();
+ if(side == Side.CLIENT)
+ {
+ RenderHelper.xOffset = config.get("ClientSettings", "AlchemyHUDxOffset", 50).getInt();
+ RenderHelper.yOffset = config.get("ClientSettings", "AlchemyHUDyOffset", 2).getInt();
+ }
+
+
+ } catch (Exception e)
+ {
+
+ //TODO Log
+ //FMLLog.log(Level.SEVERE, e, "Blood Magic" + " has had a problem loading its configuration, go ask on the forums :p");
+
+ } finally
+ {
+ config.save();
+ }
+ }
+
+ public static void set(String categoryName, String propertyName, String newValue)
+ {
+
+ config.load();
+ if (config.getCategoryNames().contains(categoryName))
+ {
+ if (config.getCategory(categoryName).containsKey(propertyName))
+ {
+ config.getCategory(categoryName).get(propertyName).set(newValue);
+ }
+ }
+ config.save();
+
+
+ }
+
+ public static void loadBlacklist()
+ {
+ AlchemicalWizardry.wellBlacklist=new ArrayList();
+ for( Object o : EntityList.stringToClassMapping.entrySet())
+ {
+ Entry entry=(Entry) o;
+ Class curClass=(Class)entry.getValue();
+ boolean valid=EntityLivingBase.class.isAssignableFrom(curClass) && !Modifier.isAbstract(curClass.getModifiers());
+ if(valid)
+ {
+ boolean blacklisted=config.get("wellOfSufferingBlackList", entry.getKey().toString(), false).getBoolean();
+ if(blacklisted)
+ AlchemicalWizardry.wellBlacklist.add(curClass);
+ }
+
+ }
+ config.save();
+ }
+
+
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/ModBlocks.java b/src-backup/main/java/WayofTime/alchemicalWizardry/ModBlocks.java
new file mode 100644
index 00000000..6c29b331
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/ModBlocks.java
@@ -0,0 +1,174 @@
+package WayofTime.alchemicalWizardry;
+
+import net.minecraft.block.Block;
+import WayofTime.alchemicalWizardry.common.block.ArmourForge;
+import WayofTime.alchemicalWizardry.common.block.BlockAlchemicCalcinator;
+import WayofTime.alchemicalWizardry.common.block.BlockAltar;
+import WayofTime.alchemicalWizardry.common.block.BlockBelljar;
+import WayofTime.alchemicalWizardry.common.block.BlockBloodLightSource;
+import WayofTime.alchemicalWizardry.common.block.BlockConduit;
+import WayofTime.alchemicalWizardry.common.block.BlockDemonPortal;
+import WayofTime.alchemicalWizardry.common.block.BlockHomHeart;
+import WayofTime.alchemicalWizardry.common.block.BlockMasterStone;
+import WayofTime.alchemicalWizardry.common.block.BlockPedestal;
+import WayofTime.alchemicalWizardry.common.block.BlockPlinth;
+import WayofTime.alchemicalWizardry.common.block.BlockReagentConduit;
+import WayofTime.alchemicalWizardry.common.block.BlockSchematicSaver;
+import WayofTime.alchemicalWizardry.common.block.BlockSocket;
+import WayofTime.alchemicalWizardry.common.block.BlockSpectralContainer;
+import WayofTime.alchemicalWizardry.common.block.BlockSpellEffect;
+import WayofTime.alchemicalWizardry.common.block.BlockSpellEnhancement;
+import WayofTime.alchemicalWizardry.common.block.BlockSpellModifier;
+import WayofTime.alchemicalWizardry.common.block.BlockSpellParadigm;
+import WayofTime.alchemicalWizardry.common.block.BlockTeleposer;
+import WayofTime.alchemicalWizardry.common.block.BlockWritingTable;
+import WayofTime.alchemicalWizardry.common.block.BloodRune;
+import WayofTime.alchemicalWizardry.common.block.BloodStoneBrick;
+import WayofTime.alchemicalWizardry.common.block.EfficiencyRune;
+import WayofTime.alchemicalWizardry.common.block.EmptySocket;
+import WayofTime.alchemicalWizardry.common.block.ImperfectRitualStone;
+import WayofTime.alchemicalWizardry.common.block.LargeBloodStoneBrick;
+import WayofTime.alchemicalWizardry.common.block.LifeEssenceBlock;
+import WayofTime.alchemicalWizardry.common.block.RitualStone;
+import WayofTime.alchemicalWizardry.common.block.RuneOfSacrifice;
+import WayofTime.alchemicalWizardry.common.block.RuneOfSelfSacrifice;
+import WayofTime.alchemicalWizardry.common.block.SpectralBlock;
+import WayofTime.alchemicalWizardry.common.block.SpeedRune;
+import WayofTime.alchemicalWizardry.common.items.ItemBlockCrystalBelljar;
+import WayofTime.alchemicalWizardry.common.items.ItemBloodRuneBlock;
+import WayofTime.alchemicalWizardry.common.items.ItemSpellEffectBlock;
+import WayofTime.alchemicalWizardry.common.items.ItemSpellEnhancementBlock;
+import WayofTime.alchemicalWizardry.common.items.ItemSpellModifierBlock;
+import WayofTime.alchemicalWizardry.common.items.ItemSpellParadigmBlock;
+import cpw.mods.fml.common.registry.GameRegistry;
+
+/**
+ * Created with IntelliJ IDEA.
+ * User: Pokefenn
+ * Date: 17/01/14
+ * Time: 19:48
+ */
+public class ModBlocks
+{
+
+ public static Block testingBlock;
+ public static Block bloodStoneBrick;
+ public static Block largeBloodStoneBrick;
+ // public static Block lifeEssenceStill;
+// public static Block lifeEssenceFlowing;
+ public static BlockAltar blockAltar;
+ public static BloodRune bloodRune;
+ public static SpeedRune speedRune;
+ public static EfficiencyRune efficiencyRune;
+ public static RuneOfSacrifice runeOfSacrifice;
+ public static RuneOfSelfSacrifice runeOfSelfSacrifice;
+ public static Block blockMasterStone;
+ public static Block ritualStone;
+ public static Block imperfectRitualStone;
+ public static Block bloodSocket;
+ public static Block emptySocket;
+ public static Block armourForge;
+ public static Block blockWritingTable;
+ public static Block blockHomHeart;
+ public static Block blockPedestal;
+ public static Block blockPlinth;
+ public static Block blockLifeEssence;
+ public static Block blockTeleposer;
+ public static Block spectralBlock;
+ public static Block blockConduit;
+ public static Block blockBloodLight;
+ public static Block blockSpellEffect;
+ public static Block blockSpellParadigm;
+ public static Block blockSpellModifier;
+ public static Block blockSpellEnhancement;
+ public static Block blockSpectralContainer;
+ public static Block blockBuildingSchematicSaver;
+ public static Block blockDemonPortal;
+ public static Block blockReagentConduit;
+ public static Block blockAlchemicCalcinator;
+ public static Block blockCrystalBelljar;
+
+ public static void init()
+ {
+ blockAltar = new BlockAltar();
+ bloodRune = new BloodRune();
+ speedRune = new SpeedRune();
+ efficiencyRune = new EfficiencyRune();
+ runeOfSacrifice = new RuneOfSacrifice();
+ runeOfSelfSacrifice = new RuneOfSelfSacrifice();
+
+ blockTeleposer = new BlockTeleposer();
+ spectralBlock = new SpectralBlock();
+ ritualStone = new RitualStone();
+ blockMasterStone = new BlockMasterStone();
+ imperfectRitualStone = new ImperfectRitualStone();
+ bloodSocket = new BlockSocket();
+ armourForge = new ArmourForge();
+ emptySocket = new EmptySocket();
+ largeBloodStoneBrick = new LargeBloodStoneBrick();
+ bloodStoneBrick = new BloodStoneBrick();
+ blockWritingTable = new BlockWritingTable();
+ blockHomHeart = new BlockHomHeart();
+ blockPedestal = new BlockPedestal();
+ blockPlinth = new BlockPlinth();
+ blockConduit = new BlockConduit();
+ blockBloodLight = new BlockBloodLightSource();
+ blockSpellEffect = new BlockSpellEffect();
+ blockSpellParadigm = new BlockSpellParadigm();
+ blockSpellModifier = new BlockSpellModifier();
+ blockSpellEnhancement = new BlockSpellEnhancement();
+ blockSpectralContainer = new BlockSpectralContainer();
+ blockDemonPortal = new BlockDemonPortal();
+ blockBuildingSchematicSaver = new BlockSchematicSaver();
+ blockReagentConduit = new BlockReagentConduit();
+ blockAlchemicCalcinator = new BlockAlchemicCalcinator();
+ blockCrystalBelljar = new BlockBelljar();
+
+ blockLifeEssence = new LifeEssenceBlock();
+ }
+
+ public static void registerBlocksInPre()
+ {
+ GameRegistry.registerBlock(ModBlocks.blockAltar, "Altar");
+ GameRegistry.registerBlock(ModBlocks.bloodRune, ItemBloodRuneBlock.class, "AlchemicalWizardry" + (ModBlocks.bloodRune.getUnlocalizedName().substring(5)));
+ GameRegistry.registerBlock(ModBlocks.blockLifeEssence, "lifeEssence");
+ GameRegistry.registerBlock(ModBlocks.speedRune, "speedRune");
+ GameRegistry.registerBlock(ModBlocks.efficiencyRune, "efficiencyRune");
+ GameRegistry.registerBlock(ModBlocks.runeOfSacrifice, "runeOfSacrifice");
+ GameRegistry.registerBlock(ModBlocks.runeOfSelfSacrifice, "runeOfSelfSacrifice");
+ GameRegistry.registerBlock(ModBlocks.ritualStone, "ritualStone");
+ GameRegistry.registerBlock(ModBlocks.blockMasterStone, "masterStone");
+ GameRegistry.registerBlock(ModBlocks.bloodSocket, "bloodSocket");
+ GameRegistry.registerBlock(ModBlocks.imperfectRitualStone, "imperfectRitualStone");
+
+ GameRegistry.registerBlock(ModBlocks.armourForge, "armourForge");
+ GameRegistry.registerBlock(ModBlocks.emptySocket, "emptySocket");
+ GameRegistry.registerBlock(ModBlocks.bloodStoneBrick, "bloodStoneBrick");
+ GameRegistry.registerBlock(ModBlocks.largeBloodStoneBrick, "largeBloodStoneBrick");
+ GameRegistry.registerBlock(ModBlocks.blockWritingTable, "blockWritingTable");
+ GameRegistry.registerBlock(ModBlocks.blockHomHeart, "blockHomHeart");
+ GameRegistry.registerBlock(ModBlocks.blockPedestal, "blockPedestal");
+ GameRegistry.registerBlock(ModBlocks.blockPlinth, "blockPlinth");
+ GameRegistry.registerBlock(ModBlocks.blockTeleposer, "blockTeleposer");
+ GameRegistry.registerBlock(ModBlocks.spectralBlock, "spectralBlock");
+ GameRegistry.registerBlock(ModBlocks.blockBloodLight, "bloodLight");
+
+ GameRegistry.registerBlock(ModBlocks.blockConduit,"blockConduit");
+ GameRegistry.registerBlock(ModBlocks.blockSpellParadigm, ItemSpellParadigmBlock.class, "AlchemicalWizardry" + (ModBlocks.blockSpellParadigm.getUnlocalizedName()));
+ GameRegistry.registerBlock(ModBlocks.blockSpellEnhancement, ItemSpellEnhancementBlock.class,"AlchemicalWizardry" + (ModBlocks.blockSpellEnhancement.getUnlocalizedName()));
+ GameRegistry.registerBlock(ModBlocks.blockSpellModifier, ItemSpellModifierBlock.class,"AlchemicalWizardry" + (ModBlocks.blockSpellModifier.getUnlocalizedName()));
+ GameRegistry.registerBlock(ModBlocks.blockSpellEffect, ItemSpellEffectBlock.class,"AlchemicalWizardry" + (ModBlocks.blockSpellEffect.getUnlocalizedName()));
+
+ GameRegistry.registerBlock(ModBlocks.blockSpectralContainer, "spectralContainer");
+ GameRegistry.registerBlock(ModBlocks.blockDemonPortal, "demonPortalMain");
+ GameRegistry.registerBlock(ModBlocks.blockBuildingSchematicSaver, "blockSchemSaver");
+ GameRegistry.registerBlock(ModBlocks.blockReagentConduit, "blockReagentConduit");
+ GameRegistry.registerBlock(ModBlocks.blockAlchemicCalcinator, "blockAlchemicCalcinator");
+ GameRegistry.registerBlock(ModBlocks.blockCrystalBelljar, ItemBlockCrystalBelljar.class, "blockCrystalBelljar");
+ }
+
+ public static void registerBlocksInInit()
+ {
+ //GameRegistry.registerBlock(ModBlocks.blockLifeEssence, "lifeEssence");
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/ModItems.java b/src-backup/main/java/WayofTime/alchemicalWizardry/ModItems.java
new file mode 100644
index 00000000..b7f2fcfa
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/ModItems.java
@@ -0,0 +1,384 @@
+package WayofTime.alchemicalWizardry;
+
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.init.Items;
+import net.minecraft.item.Item;
+import WayofTime.alchemicalWizardry.common.items.AWBaseItems;
+import WayofTime.alchemicalWizardry.common.items.ActivationCrystal;
+import WayofTime.alchemicalWizardry.common.items.AirScribeTool;
+import WayofTime.alchemicalWizardry.common.items.ApprenticeBloodOrb;
+import WayofTime.alchemicalWizardry.common.items.ArchmageBloodOrb;
+import WayofTime.alchemicalWizardry.common.items.ArmourInhibitor;
+import WayofTime.alchemicalWizardry.common.items.BlankSpell;
+import WayofTime.alchemicalWizardry.common.items.BloodShard;
+import WayofTime.alchemicalWizardry.common.items.BoundArmour;
+import WayofTime.alchemicalWizardry.common.items.BoundAxe;
+import WayofTime.alchemicalWizardry.common.items.BoundPickaxe;
+import WayofTime.alchemicalWizardry.common.items.BoundShovel;
+import WayofTime.alchemicalWizardry.common.items.CheatyItem;
+import WayofTime.alchemicalWizardry.common.items.DaggerOfSacrifice;
+import WayofTime.alchemicalWizardry.common.items.DemonPlacer;
+import WayofTime.alchemicalWizardry.common.items.DemonicTelepositionFocus;
+import WayofTime.alchemicalWizardry.common.items.DuskScribeTool;
+import WayofTime.alchemicalWizardry.common.items.EarthScribeTool;
+import WayofTime.alchemicalWizardry.common.items.EnergyBattery;
+import WayofTime.alchemicalWizardry.common.items.EnergyBazooka;
+import WayofTime.alchemicalWizardry.common.items.EnergyBlast;
+import WayofTime.alchemicalWizardry.common.items.EnergySword;
+import WayofTime.alchemicalWizardry.common.items.EnhancedTelepositionFocus;
+import WayofTime.alchemicalWizardry.common.items.FireScribeTool;
+import WayofTime.alchemicalWizardry.common.items.ItemAlchemyBase;
+import WayofTime.alchemicalWizardry.common.items.ItemComplexSpellCrystal;
+import WayofTime.alchemicalWizardry.common.items.ItemComponents;
+import WayofTime.alchemicalWizardry.common.items.ItemDiabloKey;
+import WayofTime.alchemicalWizardry.common.items.ItemRitualDiviner;
+import WayofTime.alchemicalWizardry.common.items.LavaCrystal;
+import WayofTime.alchemicalWizardry.common.items.LifeBucket;
+import WayofTime.alchemicalWizardry.common.items.MagicianBloodOrb;
+import WayofTime.alchemicalWizardry.common.items.MasterBloodOrb;
+import WayofTime.alchemicalWizardry.common.items.ReinforcedTelepositionFocus;
+import WayofTime.alchemicalWizardry.common.items.SacrificialDagger;
+import WayofTime.alchemicalWizardry.common.items.TelepositionFocus;
+import WayofTime.alchemicalWizardry.common.items.WaterScribeTool;
+import WayofTime.alchemicalWizardry.common.items.energy.ItemAttunedCrystal;
+import WayofTime.alchemicalWizardry.common.items.energy.ItemDestinationClearer;
+import WayofTime.alchemicalWizardry.common.items.energy.ItemTankSegmenter;
+import WayofTime.alchemicalWizardry.common.items.potion.AlchemyFlask;
+import WayofTime.alchemicalWizardry.common.items.potion.AlchemyReagent;
+import WayofTime.alchemicalWizardry.common.items.potion.AverageLengtheningCatalyst;
+import WayofTime.alchemicalWizardry.common.items.potion.AveragePowerCatalyst;
+import WayofTime.alchemicalWizardry.common.items.potion.CombinationalCatalyst;
+import WayofTime.alchemicalWizardry.common.items.potion.EnhancedFillingAgent;
+import WayofTime.alchemicalWizardry.common.items.potion.GreaterLengtheningCatalyst;
+import WayofTime.alchemicalWizardry.common.items.potion.GreaterPowerCatalyst;
+import WayofTime.alchemicalWizardry.common.items.potion.MundaneLengtheningCatalyst;
+import WayofTime.alchemicalWizardry.common.items.potion.MundanePowerCatalyst;
+import WayofTime.alchemicalWizardry.common.items.potion.StandardBindingAgent;
+import WayofTime.alchemicalWizardry.common.items.potion.StandardFillingAgent;
+import WayofTime.alchemicalWizardry.common.items.potion.WeakBindingAgent;
+import WayofTime.alchemicalWizardry.common.items.potion.WeakFillingAgent;
+import WayofTime.alchemicalWizardry.common.items.sigil.AirSigil;
+import WayofTime.alchemicalWizardry.common.items.sigil.DivinationSigil;
+import WayofTime.alchemicalWizardry.common.items.sigil.ItemBloodLightSigil;
+import WayofTime.alchemicalWizardry.common.items.sigil.ItemFluidSigil;
+import WayofTime.alchemicalWizardry.common.items.sigil.ItemSeerSigil;
+import WayofTime.alchemicalWizardry.common.items.sigil.ItemSigilOfEnderSeverance;
+import WayofTime.alchemicalWizardry.common.items.sigil.ItemSigilOfSupression;
+import WayofTime.alchemicalWizardry.common.items.sigil.LavaSigil;
+import WayofTime.alchemicalWizardry.common.items.sigil.SigilOfElementalAffinity;
+import WayofTime.alchemicalWizardry.common.items.sigil.SigilOfGrowth;
+import WayofTime.alchemicalWizardry.common.items.sigil.SigilOfHaste;
+import WayofTime.alchemicalWizardry.common.items.sigil.SigilOfHolding;
+import WayofTime.alchemicalWizardry.common.items.sigil.SigilOfMagnetism;
+import WayofTime.alchemicalWizardry.common.items.sigil.SigilOfTheBridge;
+import WayofTime.alchemicalWizardry.common.items.sigil.SigilOfTheFastMiner;
+import WayofTime.alchemicalWizardry.common.items.sigil.SigilOfWind;
+import WayofTime.alchemicalWizardry.common.items.sigil.VoidSigil;
+import WayofTime.alchemicalWizardry.common.items.sigil.WaterSigil;
+import WayofTime.alchemicalWizardry.common.items.spell.ItemSpellMultiTool;
+import cpw.mods.fml.common.registry.GameRegistry;
+
+/**
+ * Created with IntelliJ IDEA.
+ * User: Pokefenn
+ * Date: 17/01/14
+ * Time: 19:48
+ */
+public class ModItems
+{
+ public static Item weakBloodOrb;
+ public static Item apprenticeBloodOrb;
+ public static Item magicianBloodOrb;
+ public static Item energyBlaster;
+ public static Item energySword;
+ public static Item lavaCrystal;
+ public static Item waterSigil;
+ public static Item lavaSigil;
+ public static Item voidSigil;
+ public static Item blankSlate;
+ public static Item reinforcedSlate;
+ public static Item sacrificialDagger;
+ public static Item daggerOfSacrifice;
+ public static Item airSigil;
+ public static Item sigilOfTheFastMiner;
+ public static Item sigilOfElementalAffinity;
+ public static Item sigilOfHaste;
+ public static Item sigilOfHolding;
+ public static Item divinationSigil;
+ public static Item waterScribeTool;
+ public static Item fireScribeTool;
+ public static Item earthScribeTool;
+ public static Item airScribeTool;
+ public static Item activationCrystal;
+ public static Item boundPickaxe;
+ public static Item boundAxe;
+ public static Item boundShovel;
+ public static Item boundHelmet;
+ public static Item boundPlate;
+ public static Item boundLeggings;
+ public static Item boundBoots;
+ public static Item weakBloodShard;
+ public static Item growthSigil;
+ public static Item blankSpell;
+ public static Item masterBloodOrb;
+ public static Item alchemyFlask;
+ public static Item standardBindingAgent;
+ public static Item mundanePowerCatalyst;
+ public static Item averagePowerCatalyst;
+ public static Item greaterPowerCatalyst;
+ public static Item mundaneLengtheningCatalyst;
+ public static Item averageLengtheningCatalyst;
+ public static Item greaterLengtheningCatalyst;
+ public static Item incendium;
+ public static Item magicales;
+ public static Item sanctus;
+ public static Item aether;
+ public static Item simpleCatalyst;
+ public static Item crepitous;
+ public static Item crystallos;
+ public static Item terrae;
+ public static Item aquasalus;
+ public static Item tennebrae;
+ public static Item demonBloodShard;
+ public static Item archmageBloodOrb;
+ public static Item sigilOfWind;
+ public static Item telepositionFocus;
+ public static Item enhancedTelepositionFocus;
+ public static Item reinforcedTelepositionFocus;
+ public static Item demonicTelepositionFocus;
+ public static Item imbuedSlate;
+ public static Item demonicSlate;
+ public static Item duskScribeTool;
+ public static Item sigilOfTheBridge;
+ public static Item armourInhibitor;
+ public static Item creativeFiller;
+ public static Item demonPlacer;
+
+ public static Item baseItems;
+ public static Item baseAlchemyItems;
+
+ public static Item weakFillingAgent;
+ public static Item standardFillingAgent;
+ public static Item enhancedFillingAgent;
+ public static Item weakBindingAgent;
+ public static Item itemRitualDiviner;
+ public static Item sanguineHelmet;
+ public static Item sanguineRobe;
+ public static Item sanguinePants;
+ public static Item sanguineBoots;
+ public static Item focusBloodBlast;
+ public static Item focusGravityWell;
+ public static Item sigilOfMagnetism;
+ public static Item itemKeyOfDiablo;
+ public static Item energyBazooka;
+ public static Item itemBloodLightSigil;
+ public static Item itemComplexSpellCrystal;
+ public static Item itemBloodFrame;
+
+ public static Item itemSigilOfEnderSeverance;
+ public static Item itemSigilOfSupression;
+ public static Item itemFluidSigil;
+ public static Item itemSeerSigil;
+ public static Item itemCombinationalCatalyst;
+
+ public static Item customTool;
+
+ public static Item itemAttunedCrystal;
+ public static Item itemTankSegmenter;
+ public static Item itemDestinationClearer;
+
+ public static Item bucketLife;
+
+ public static void init()
+ {
+ weakBloodOrb = new EnergyBattery(5000).setUnlocalizedName("weakBloodOrb");
+ apprenticeBloodOrb = new ApprenticeBloodOrb(25000).setUnlocalizedName("apprenticeBloodOrb");
+ magicianBloodOrb = new MagicianBloodOrb(150000).setUnlocalizedName("magicianBloodOrb");
+ masterBloodOrb = new MasterBloodOrb(1000000).setUnlocalizedName("masterBloodOrb");
+ archmageBloodOrb = new ArchmageBloodOrb(10000000).setUnlocalizedName("archmageBloodOrb");
+ energyBlaster = new EnergyBlast().setUnlocalizedName("energyBlast");
+ energySword = new EnergySword().setUnlocalizedName("energySword");
+ lavaCrystal = new LavaCrystal().setUnlocalizedName("lavaCrystal");
+ waterSigil = new WaterSigil().setUnlocalizedName("waterSigil");
+ lavaSigil = new LavaSigil().setUnlocalizedName("lavaSigil");
+ voidSigil = new VoidSigil().setUnlocalizedName("voidSigil");
+ blankSlate = new AWBaseItems().setUnlocalizedName("blankSlate");
+ reinforcedSlate = new AWBaseItems().setUnlocalizedName("reinforcedSlate");
+ sacrificialDagger = new SacrificialDagger().setUnlocalizedName("sacrificialDagger");
+ daggerOfSacrifice = new DaggerOfSacrifice().setUnlocalizedName("daggerOfSacrifice");
+ airSigil = new AirSigil().setUnlocalizedName("airSigil");
+ sigilOfTheFastMiner = new SigilOfTheFastMiner().setUnlocalizedName("sigilOfTheFastMiner");
+ sigilOfElementalAffinity = new SigilOfElementalAffinity().setUnlocalizedName("sigilOfElementalAffinity");
+ sigilOfHaste = new SigilOfHaste().setUnlocalizedName("sigilOfHaste");
+ sigilOfHolding = new SigilOfHolding().setUnlocalizedName("sigilOfHolding");
+ divinationSigil = new DivinationSigil().setUnlocalizedName("divinationSigil");
+ waterScribeTool = new WaterScribeTool().setUnlocalizedName("waterScribeTool");
+ fireScribeTool = new FireScribeTool().setUnlocalizedName("fireScribeTool");
+ earthScribeTool = new EarthScribeTool().setUnlocalizedName("earthScribeTool");
+ airScribeTool = new AirScribeTool().setUnlocalizedName("airScribeTool");
+ activationCrystal = new ActivationCrystal();
+ boundPickaxe = new BoundPickaxe().setUnlocalizedName("boundPickaxe");
+ boundAxe = new BoundAxe().setUnlocalizedName("boundAxe");
+ boundShovel = new BoundShovel().setUnlocalizedName("boundShovel");
+ boundHelmet = new BoundArmour(0).setUnlocalizedName("boundHelmet");
+ boundPlate = new BoundArmour(1).setUnlocalizedName("boundPlate");
+ boundLeggings = new BoundArmour(2).setUnlocalizedName("boundLeggings");
+ boundBoots = new BoundArmour(3).setUnlocalizedName("boundBoots");
+ weakBloodShard = new BloodShard().setUnlocalizedName("weakBloodShard");
+ growthSigil = new SigilOfGrowth().setUnlocalizedName("growthSigil");
+ blankSpell = new BlankSpell().setUnlocalizedName("blankSpell");
+ alchemyFlask = new AlchemyFlask().setUnlocalizedName("alchemyFlask");
+ standardBindingAgent = new StandardBindingAgent().setUnlocalizedName("standardBindingAgent");
+ mundanePowerCatalyst = new MundanePowerCatalyst().setUnlocalizedName("mundanePowerCatalyst");
+ averagePowerCatalyst = new AveragePowerCatalyst().setUnlocalizedName("averagePowerCatalyst");
+ greaterPowerCatalyst = new GreaterPowerCatalyst().setUnlocalizedName("greaterPowerCatalyst");
+ mundaneLengtheningCatalyst = new MundaneLengtheningCatalyst().setUnlocalizedName("mundaneLengtheningCatalyst");
+ averageLengtheningCatalyst = new AverageLengtheningCatalyst().setUnlocalizedName("averageLengtheningCatalyst");
+ greaterLengtheningCatalyst = new GreaterLengtheningCatalyst().setUnlocalizedName("greaterLengtheningCatalyst");
+ incendium = new AlchemyReagent().setUnlocalizedName("incendium");
+ magicales = new AlchemyReagent().setUnlocalizedName("magicales");
+ sanctus = new AlchemyReagent().setUnlocalizedName("sanctus");
+ aether = new AlchemyReagent().setUnlocalizedName("aether");
+ simpleCatalyst = new AlchemyReagent().setUnlocalizedName("simpleCatalyst");
+ crepitous = new AlchemyReagent().setUnlocalizedName("crepitous");
+ crystallos = new AlchemyReagent().setUnlocalizedName("crystallos");
+ terrae = new AlchemyReagent().setUnlocalizedName("terrae");
+ aquasalus = new AlchemyReagent().setUnlocalizedName("aquasalus");
+ tennebrae = new AlchemyReagent().setUnlocalizedName("tennebrae");
+ demonBloodShard = new BloodShard().setUnlocalizedName("demonBloodShard");
+ sigilOfWind = new SigilOfWind().setUnlocalizedName("sigilOfWind");
+ telepositionFocus = new TelepositionFocus(1).setUnlocalizedName("telepositionFocus");
+ enhancedTelepositionFocus = new EnhancedTelepositionFocus().setUnlocalizedName("enhancedTelepositionFocus");
+ reinforcedTelepositionFocus = new ReinforcedTelepositionFocus().setUnlocalizedName("reinforcedTelepositionFocus");
+ demonicTelepositionFocus = new DemonicTelepositionFocus().setUnlocalizedName("demonicTelepositionFocus");
+ imbuedSlate = new AWBaseItems().setUnlocalizedName("imbuedSlate");
+ demonicSlate = new AWBaseItems().setUnlocalizedName("demonicSlate");
+ duskScribeTool = new DuskScribeTool().setUnlocalizedName("duskScribeTool");
+ sigilOfTheBridge = new SigilOfTheBridge().setUnlocalizedName("sigilOfTheBridge");
+ armourInhibitor = new ArmourInhibitor().setUnlocalizedName("armourInhibitor");
+ creativeFiller = new CheatyItem().setUnlocalizedName("cheatyItem");
+ demonPlacer = new DemonPlacer().setUnlocalizedName("demonPlacer");
+ weakFillingAgent = new WeakFillingAgent().setUnlocalizedName("weakFillingAgent");
+ standardFillingAgent = new StandardFillingAgent().setUnlocalizedName("standardFillingAgent");
+ enhancedFillingAgent = new EnhancedFillingAgent().setUnlocalizedName("enhancedFillingAgent");
+ weakBindingAgent = new WeakBindingAgent().setUnlocalizedName("weakBindingAgent");
+ itemRitualDiviner = new ItemRitualDiviner().setUnlocalizedName("ritualDiviner");
+ sigilOfMagnetism = new SigilOfMagnetism().setUnlocalizedName("sigilOfMagnetism");
+ itemKeyOfDiablo = new ItemDiabloKey().setUnlocalizedName("itemDiabloKey");
+ energyBazooka = new EnergyBazooka().setUnlocalizedName("energyBazooka");
+ itemBloodLightSigil = new ItemBloodLightSigil().setUnlocalizedName("bloodLightSigil");
+ itemComplexSpellCrystal = new ItemComplexSpellCrystal().setUnlocalizedName("itemComplexSpellCrystal");
+ bucketLife = (new LifeBucket(ModBlocks.blockLifeEssence)).setUnlocalizedName("bucketLife").setContainerItem(Items.bucket).setCreativeTab(CreativeTabs.tabMisc);
+ itemSigilOfEnderSeverance = (new ItemSigilOfEnderSeverance()).setUnlocalizedName("itemSigilOfEnderSeverance");
+ baseItems = new ItemComponents().setUnlocalizedName("baseItems");
+ baseAlchemyItems = new ItemAlchemyBase().setUnlocalizedName("baseAlchemyItems");
+ itemSigilOfSupression = new ItemSigilOfSupression().setUnlocalizedName("itemSigilOfSupression");
+ itemFluidSigil = new ItemFluidSigil().setUnlocalizedName("itemFluidSigil");
+ itemSeerSigil = new ItemSeerSigil().setUnlocalizedName("itemSeerSigil");
+ customTool = new ItemSpellMultiTool().setUnlocalizedName("multiTool");
+ itemCombinationalCatalyst = new CombinationalCatalyst().setUnlocalizedName("itemCombinationalCatalyst");
+ itemAttunedCrystal = new ItemAttunedCrystal().setUnlocalizedName("itemAttunedCrystal");
+ itemTankSegmenter = new ItemTankSegmenter().setUnlocalizedName("itemTankSegmenter");
+ itemDestinationClearer = new ItemDestinationClearer().setUnlocalizedName("destinationClearer");
+ }
+
+ public static void registerItems()
+ {
+ GameRegistry.registerItem(ModItems.weakBloodOrb, "weakBloodOrb");
+ GameRegistry.registerItem(ModItems.apprenticeBloodOrb, "apprenticeBloodOrb");
+ GameRegistry.registerItem(ModItems.magicianBloodOrb, "magicianBloodOrb");
+ GameRegistry.registerItem(ModItems.energyBlaster, "energyBlaster");
+
+ GameRegistry.registerItem(ModItems.energySword, "energySword");
+ GameRegistry.registerItem(ModItems.lavaCrystal, "lavaCrystal");
+ GameRegistry.registerItem(ModItems.waterSigil, "waterSigil");
+ GameRegistry.registerItem(ModItems.lavaSigil, "lavaSigil");
+ GameRegistry.registerItem(ModItems.voidSigil, "voidSigil");
+ GameRegistry.registerItem(ModItems.blankSlate, "blankSlate");
+ GameRegistry.registerItem(ModItems.reinforcedSlate, "reinforcedSlate");
+ GameRegistry.registerItem(ModItems.sacrificialDagger, "sacrificialKnife");
+ GameRegistry.registerItem(ModItems.daggerOfSacrifice, "daggerOfSacrifice");
+ GameRegistry.registerItem(ModItems.airSigil, "airSigil");
+ GameRegistry.registerItem(ModItems.sigilOfTheFastMiner, "sigilOfTheFastMiner");
+ GameRegistry.registerItem(ModItems.sigilOfElementalAffinity, "sigilOfElementalAffinity");
+ GameRegistry.registerItem(ModItems.sigilOfHaste, "sigilOfHaste");
+ GameRegistry.registerItem(ModItems.sigilOfHolding, "sigilOfHolding");
+ GameRegistry.registerItem(ModItems.divinationSigil, "divinationSigil");
+ GameRegistry.registerItem(ModItems.waterScribeTool, "waterScribeTool");
+ GameRegistry.registerItem(ModItems.fireScribeTool, "fireScribeTool");
+ GameRegistry.registerItem(ModItems.earthScribeTool, "earthScribeTool");
+ GameRegistry.registerItem(ModItems.airScribeTool, "airScribeTool");
+ GameRegistry.registerItem(ModItems.activationCrystal, "activationCrystal");
+ GameRegistry.registerItem(ModItems.boundPickaxe, "boundPickaxe");
+ GameRegistry.registerItem(ModItems.boundAxe, "boundAxe");
+ GameRegistry.registerItem(ModItems.boundShovel, "boundShovel");
+ GameRegistry.registerItem(ModItems.boundHelmet, "boundHelmet");
+ GameRegistry.registerItem(ModItems.boundPlate, "boundPlate");
+ GameRegistry.registerItem(ModItems.boundLeggings, "boundLeggings");
+ GameRegistry.registerItem(ModItems.boundBoots, "boundBoots");
+ GameRegistry.registerItem(ModItems.weakBloodShard, "weakBloodShard");
+ GameRegistry.registerItem(ModItems.growthSigil, "growthSigil");
+ GameRegistry.registerItem(ModItems.blankSpell, "blankSpell");
+ GameRegistry.registerItem(ModItems.masterBloodOrb, "masterBloodOrb");
+ GameRegistry.registerItem(ModItems.alchemyFlask, "alchemyFlask");
+ GameRegistry.registerItem(ModItems.standardBindingAgent, "standardBindingAgent");
+ GameRegistry.registerItem(ModItems.mundanePowerCatalyst, "mundanePowerCatalyst");
+ GameRegistry.registerItem(ModItems.averagePowerCatalyst, "averagePowerCatalyst");
+ GameRegistry.registerItem(ModItems.greaterPowerCatalyst, "greaterPowerCatalyst");
+ GameRegistry.registerItem(ModItems.mundaneLengtheningCatalyst, "mundaneLengtheningCatalyst");
+ GameRegistry.registerItem(ModItems.averageLengtheningCatalyst, "averageLengtheningCatalyst");
+ GameRegistry.registerItem(ModItems.greaterLengtheningCatalyst, "greaterLengtheningCatalyst");
+ GameRegistry.registerItem(ModItems.incendium, "incendium");
+ GameRegistry.registerItem(ModItems.magicales, "magicales");
+ GameRegistry.registerItem(ModItems.sanctus, "sanctus");
+ GameRegistry.registerItem(ModItems.aether, "aether");
+ GameRegistry.registerItem(ModItems.simpleCatalyst, "simpleCatalyst");
+ GameRegistry.registerItem(ModItems.crepitous, "crepitous");
+ GameRegistry.registerItem(ModItems.crystallos, "crystallos");
+ GameRegistry.registerItem(ModItems.terrae, "terrae");
+ GameRegistry.registerItem(ModItems.aquasalus, "aquasalus");
+ GameRegistry.registerItem(ModItems.tennebrae, "tennebrae");
+ GameRegistry.registerItem(ModItems.demonBloodShard, "demonBloodShard");
+ GameRegistry.registerItem(ModItems.archmageBloodOrb, "archmageBloodOrb");
+ GameRegistry.registerItem(ModItems.sigilOfWind, "sigilOfWind");
+ GameRegistry.registerItem(ModItems.telepositionFocus, "telepositionFocus");
+ GameRegistry.registerItem(ModItems.enhancedTelepositionFocus, "enhancedTelepositionFocus");
+ GameRegistry.registerItem(ModItems.reinforcedTelepositionFocus, "reinforcedTelepositionFocus");
+ GameRegistry.registerItem(ModItems.demonicTelepositionFocus, "demonicTelepositionFocus");
+ GameRegistry.registerItem(ModItems.imbuedSlate, "imbuedSlate");
+ GameRegistry.registerItem(ModItems.demonicSlate, "demonicSlate");
+ GameRegistry.registerItem(ModItems.duskScribeTool, "duskScribeTool");
+ GameRegistry.registerItem(ModItems.sigilOfTheBridge, "sigilOfTheBridge");
+ GameRegistry.registerItem(ModItems.armourInhibitor, "armourInhibitor");
+ GameRegistry.registerItem(ModItems.creativeFiller, "creativeFiller");
+ GameRegistry.registerItem(ModItems.demonPlacer, "demonPlacer");
+
+ GameRegistry.registerItem(ModItems.weakFillingAgent, "weakFillingAgent");
+ GameRegistry.registerItem(ModItems.standardFillingAgent, "standardFillingAgent");
+ GameRegistry.registerItem(ModItems.enhancedFillingAgent, "enhancedFillingAgent");
+ GameRegistry.registerItem(ModItems.weakBindingAgent, "weakBindingAgent");
+ GameRegistry.registerItem(ModItems.itemRitualDiviner, "itemRitualDiviner");
+ GameRegistry.registerItem(ModItems.sigilOfMagnetism, "sigilOfMagnetism");
+ GameRegistry.registerItem(ModItems.itemKeyOfDiablo, "itemKeyOfDiablo");
+ GameRegistry.registerItem(ModItems.energyBazooka, "energyBazooka");
+ GameRegistry.registerItem(ModItems.itemBloodLightSigil, "itemBloodLightSigil");
+ GameRegistry.registerItem(ModItems.itemComplexSpellCrystal, "itemComplexSpellCrystal");
+ GameRegistry.registerItem(ModItems.itemSigilOfSupression, "sigilOfSupression");
+ GameRegistry.registerItem(ModItems.itemSigilOfEnderSeverance, "sigilOfEnderSeverance");
+ GameRegistry.registerItem(ModItems.itemFluidSigil, "fluidSigil");
+ GameRegistry.registerItem(ModItems.itemSeerSigil, "seerSigil");
+
+ GameRegistry.registerItem(ModItems.customTool, "customTool");
+
+ GameRegistry.registerItem(ModItems.bucketLife, "bucketLife");
+ GameRegistry.registerItem(ModItems.itemCombinationalCatalyst, "itemCombinationalCatalyst");
+
+ GameRegistry.registerItem(ModItems.itemAttunedCrystal, "itemAttunedCrystal");
+ GameRegistry.registerItem(ModItems.itemTankSegmenter, "itemTankSegmenter");
+ GameRegistry.registerItem(ModItems.itemDestinationClearer, "itemDestinationClearer");
+
+ GameRegistry.registerItem(ModItems.baseItems, "bloodMagicBaseItems");
+ GameRegistry.registerItem(ModItems.baseAlchemyItems, "bloodMagicBaseAlchemyItems");
+ //GameRegistry.registerItem(ModItems.itemBloodFrame, "itemBloodFrame");
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/ColourAndCoords.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/ColourAndCoords.java
new file mode 100644
index 00000000..08f71bff
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/ColourAndCoords.java
@@ -0,0 +1,45 @@
+package WayofTime.alchemicalWizardry.api;
+
+import net.minecraft.nbt.NBTTagCompound;
+
+public class ColourAndCoords
+{
+ public int colourRed;
+ public int colourGreen;
+ public int colourBlue;
+ public int colourIntensity;
+
+ public int xCoord;
+ public int yCoord;
+ public int zCoord;
+
+ public ColourAndCoords(int red, int green, int blue, int intensity, int x, int y, int z)
+ {
+ this.colourRed = red;
+ this.colourGreen = green;
+ this.colourBlue = blue;
+ this.colourIntensity = intensity;
+
+ this.xCoord = x;
+ this.yCoord = y;
+ this.zCoord = z;
+ }
+
+ public static ColourAndCoords readFromNBT(NBTTagCompound tag)
+ {
+ return new ColourAndCoords(tag.getInteger("colourRed"), tag.getInteger("colourGreen"), tag.getInteger("colourBlue"), tag.getInteger("colourIntensity"), tag.getInteger("xCoord"), tag.getInteger("yCoord"), tag.getInteger("zCoord"));
+ }
+
+ public NBTTagCompound writeToNBT(NBTTagCompound tag)
+ {
+ tag.setInteger("colourRed", colourRed);
+ tag.setInteger("colourGreen", colourGreen);
+ tag.setInteger("colourBlue", colourBlue);
+ tag.setInteger("colourIntensity", colourIntensity);
+ tag.setInteger("xCoord", xCoord);
+ tag.setInteger("yCoord", yCoord);
+ tag.setInteger("zCoord", zCoord);
+
+ return tag;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/AlchemicalPotionCreationHandler.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/AlchemicalPotionCreationHandler.java
new file mode 100644
index 00000000..4a4b40e0
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/AlchemicalPotionCreationHandler.java
@@ -0,0 +1,79 @@
+package WayofTime.alchemicalWizardry.api.alchemy;
+
+import java.util.ArrayList;
+
+import net.minecraft.item.ItemStack;
+
+public class AlchemicalPotionCreationHandler
+{
+ public static ArrayList registeredPotionEffects = new ArrayList();
+
+ public static void addPotion(ItemStack itemStack, int potionID, int tickDuration)
+ {
+ registeredPotionEffects.add(new AlchemyPotionHandlerComponent(itemStack, potionID, tickDuration));
+ }
+
+ public static int getPotionIDForStack(ItemStack itemStack)
+ {
+ for (AlchemyPotionHandlerComponent aphc : registeredPotionEffects)
+ {
+ if (aphc.compareItemStack(itemStack))
+ {
+ return aphc.getPotionID();
+ }
+ }
+
+ return -1;
+ }
+
+ public static int getPotionTickDurationForStack(ItemStack itemStack)
+ {
+ {
+ for (AlchemyPotionHandlerComponent aphc : registeredPotionEffects)
+ {
+ if (aphc.compareItemStack(itemStack))
+ {
+ return aphc.getTickDuration();
+ }
+ }
+
+ return -1;
+ }
+ }
+
+ public static boolean containsRegisteredPotionIngredient(ItemStack[] stackList)
+ {
+ for (ItemStack is : stackList)
+ {
+ for (AlchemyPotionHandlerComponent aphc : registeredPotionEffects)
+ {
+ if (aphc.compareItemStack(is))
+ {
+ return true;
+ }
+ }
+ }
+
+ return false;
+ }
+
+ public static int getRegisteredPotionIngredientPosition(ItemStack[] stackList)
+ {
+ int i = 0;
+
+ for (ItemStack is : stackList)
+ {
+ for (AlchemyPotionHandlerComponent aphc : registeredPotionEffects)
+ {
+ if (aphc.compareItemStack(is))
+ {
+ return i;
+ }
+ }
+
+ i++;
+ }
+
+ return -1;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/AlchemyPotionHandlerComponent.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/AlchemyPotionHandlerComponent.java
new file mode 100644
index 00000000..6f0d461d
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/AlchemyPotionHandlerComponent.java
@@ -0,0 +1,52 @@
+package WayofTime.alchemicalWizardry.api.alchemy;
+
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+
+public class AlchemyPotionHandlerComponent
+{
+ private ItemStack itemStack;
+ private int potionID;
+ private int tickDuration;
+
+ public AlchemyPotionHandlerComponent(ItemStack itemStack, int potionID, int tickDuration)
+ {
+ this.itemStack = itemStack;
+ this.potionID = potionID;
+ this.tickDuration = tickDuration;
+ }
+
+ public boolean compareItemStack(ItemStack comparedStack)
+ {
+ if (comparedStack != null && itemStack != null)
+ {
+ if (comparedStack.getItem() instanceof ItemBlock)
+ {
+ if (itemStack.getItem() instanceof ItemBlock)
+ {
+ return comparedStack.getItem().equals(itemStack.getItem()) && comparedStack.getItemDamage() == itemStack.getItemDamage();
+ }
+ } else if (!(itemStack.getItem() instanceof ItemBlock))
+ {
+ return comparedStack.getItem().equals(itemStack.getItem()) && comparedStack.getItemDamage() == itemStack.getItemDamage();
+ }
+ }
+
+ return false;
+ }
+
+ public ItemStack getItemStack()
+ {
+ return itemStack;
+ }
+
+ public int getPotionID()
+ {
+ return this.potionID;
+ }
+
+ public int getTickDuration()
+ {
+ return this.tickDuration;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/AlchemyPotionHelper.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/AlchemyPotionHelper.java
new file mode 100644
index 00000000..d3462552
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/AlchemyPotionHelper.java
@@ -0,0 +1,76 @@
+package WayofTime.alchemicalWizardry.api.alchemy;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.potion.Potion;
+import net.minecraft.potion.PotionEffect;
+
+public class AlchemyPotionHelper
+{
+ private int potionID;
+ private int tickDuration;
+ private int concentration;
+ private int durationFactor;
+
+ public AlchemyPotionHelper(int potionID, int tickDuration, int concentration, int durationFactor)
+ {
+ this.potionID = potionID;
+ this.tickDuration = tickDuration;
+ this.concentration = concentration;
+ this.durationFactor = durationFactor;
+ }
+
+ public void setConcentration(int concentration)
+ {
+ this.concentration = concentration;
+ }
+
+ public void setDurationFactor(int durationFactor)
+ {
+ this.durationFactor = durationFactor;
+ }
+
+ public int getPotionID()
+ {
+ return this.potionID;
+ }
+
+ public int getTickDuration()
+ {
+ return this.tickDuration;
+ }
+
+ public int getConcentration()
+ {
+ return this.concentration;
+ }
+
+ public int getdurationFactor()
+ {
+ return this.durationFactor;
+ }
+
+ public PotionEffect getPotionEffect()
+ {
+ if (potionID == Potion.heal.id || potionID == Potion.harm.id)
+ {
+ return (new PotionEffect(potionID, 1, concentration));
+ }
+
+ return (new PotionEffect(potionID, (int) (tickDuration * Math.pow(0.5f, concentration) * Math.pow(8.0f / 3.0f, durationFactor)), concentration));
+ }
+
+ public static AlchemyPotionHelper readEffectFromNBT(NBTTagCompound tagCompound)
+ {
+ return new AlchemyPotionHelper(tagCompound.getInteger("potionID"), tagCompound.getInteger("tickDuration"), tagCompound.getInteger("concentration"), tagCompound.getInteger("durationFactor"));
+ }
+
+ public static NBTTagCompound setEffectToNBT(AlchemyPotionHelper aph)
+ {
+ NBTTagCompound tagCompound = new NBTTagCompound();
+ tagCompound.setInteger("potionID", aph.getPotionID());
+ tagCompound.setInteger("tickDuration", aph.getTickDuration());
+ tagCompound.setInteger("concentration", aph.getConcentration());
+ tagCompound.setInteger("durationFactor", aph.getdurationFactor());
+ return tagCompound;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/AlchemyRecipe.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/AlchemyRecipe.java
new file mode 100644
index 00000000..f773d063
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/AlchemyRecipe.java
@@ -0,0 +1,143 @@
+package WayofTime.alchemicalWizardry.api.alchemy;
+
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.oredict.OreDictionary;
+
+public class AlchemyRecipe
+{
+ private ItemStack output;
+ private ItemStack[] recipe;
+ private int bloodOrbLevel;
+ private int amountNeeded;
+
+ public AlchemyRecipe(ItemStack output, int amountNeeded, ItemStack[] recipe, int bloodOrbLevel)
+ {
+ this.output = output;
+ this.recipe = recipe;
+ this.amountNeeded = amountNeeded;
+ this.bloodOrbLevel = bloodOrbLevel;
+ }
+
+ public boolean doesRecipeMatch(ItemStack[] items, int slottedBloodOrbLevel)
+ {
+ if (slottedBloodOrbLevel < bloodOrbLevel)
+ {
+ return false;
+ }
+
+ ItemStack[] recipe = new ItemStack[5];
+
+ if (items.length < 5)
+ {
+ return false;
+ }
+
+ if (this.recipe.length != 5)
+ {
+ ItemStack[] newRecipe = new ItemStack[5];
+
+ for (int i = 0; i < 5; i++)
+ {
+ if (i + 1 > this.recipe.length)
+ {
+ newRecipe[i] = null;
+ } else
+ {
+ newRecipe[i] = this.recipe[i];
+ }
+ }
+
+ recipe = newRecipe;
+ } else
+ {
+ recipe = this.recipe;
+ }
+
+ boolean[] checkList = new boolean[5];
+
+ for (int i = 0; i < 5; i++)
+ {
+ checkList[i] = false;
+ }
+
+ for (int i = 0; i < 5; i++)
+ {
+ ItemStack recipeItemStack = recipe[i];
+
+ if (recipeItemStack == null)
+ {
+ continue;
+ }
+
+ boolean test = false;
+
+ for (int j = 0; j < 5; j++)
+ {
+ if (checkList[j])
+ {
+ continue;
+ }
+
+ ItemStack checkedItemStack = items[j];
+
+ if (checkedItemStack == null)
+ {
+ continue;
+ }
+
+ boolean quickTest = false;
+
+ if (recipeItemStack.getItem() instanceof ItemBlock)
+ {
+ if (checkedItemStack.getItem() instanceof ItemBlock)
+ {
+ quickTest = true;
+ }
+ } else if (!(checkedItemStack.getItem() instanceof ItemBlock))
+ {
+ quickTest = true;
+ }
+
+ if (!quickTest)
+ {
+ continue;
+ }
+
+ if ((checkedItemStack.getItemDamage() == recipeItemStack.getItemDamage() || OreDictionary.WILDCARD_VALUE == recipeItemStack.getItemDamage()) && checkedItemStack.getItem()==recipeItemStack.getItem())
+ {
+ test = true;
+ checkList[j] = true;
+ break;
+ }
+ }
+
+ if (!test)
+ {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ public ItemStack getResult()
+ {
+ return output.copy();
+ }
+
+ public int getAmountNeeded()
+ {
+ return this.amountNeeded;
+ }
+
+ public ItemStack[] getRecipe()
+ {
+ return this.recipe;
+ }
+
+ public int getOrbLevel()
+ {
+ return this.bloodOrbLevel;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/AlchemyRecipeRegistry.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/AlchemyRecipeRegistry.java
new file mode 100644
index 00000000..5753cff2
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/AlchemyRecipeRegistry.java
@@ -0,0 +1,85 @@
+package WayofTime.alchemicalWizardry.api.alchemy;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.item.ItemStack;
+import WayofTime.alchemicalWizardry.api.items.interfaces.IBloodOrb;
+
+public class AlchemyRecipeRegistry
+{
+ public static List recipes = new ArrayList();
+
+ public static void registerRecipe(ItemStack output, int amountNeeded, ItemStack[] recipe, int bloodOrbLevel)
+ {
+ recipes.add(new AlchemyRecipe(output, amountNeeded, recipe, bloodOrbLevel));
+ }
+
+ public static ItemStack getResult(ItemStack[] recipe, ItemStack bloodOrb)
+ {
+ if (bloodOrb == null)
+ {
+ return null;
+ }
+
+ if (!(bloodOrb.getItem() instanceof IBloodOrb))
+ {
+ return null;
+ }
+
+ int bloodOrbLevel = ((IBloodOrb) bloodOrb.getItem()).getOrbLevel();
+
+ for (AlchemyRecipe ar : recipes)
+ {
+ if (ar.doesRecipeMatch(recipe, bloodOrbLevel))
+ {
+ return (ar.getResult());
+ }
+ }
+
+ return null;
+ }
+
+ public static int getAmountNeeded(ItemStack[] recipe, ItemStack bloodOrb)
+ {
+ if (bloodOrb == null)
+ {
+ return 0;
+ }
+
+ if (!(bloodOrb.getItem() instanceof IBloodOrb))
+ {
+ return 0;
+ }
+
+ int bloodOrbLevel = ((IBloodOrb) bloodOrb.getItem()).getOrbLevel();
+
+ for (AlchemyRecipe ar : recipes)
+ {
+ if (ar.doesRecipeMatch(recipe, bloodOrbLevel))
+ {
+ return (ar.getAmountNeeded());
+ }
+ }
+
+ return 0;
+ }
+
+ public static ItemStack[] getRecipeForItemStack(ItemStack itemStack)
+ {
+ for (AlchemyRecipe ar : recipes)
+ {
+ ItemStack result = ar.getResult();
+
+ if (result != null)
+ {
+ if (result.isItemEqual(itemStack))
+ {
+ return ar.getRecipe();
+ }
+ }
+ }
+
+ return null;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/IAlchemyGoggles.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/IAlchemyGoggles.java
new file mode 100644
index 00000000..45eeaaa3
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/IAlchemyGoggles.java
@@ -0,0 +1,10 @@
+package WayofTime.alchemicalWizardry.api.alchemy.energy;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+
+public interface IAlchemyGoggles
+{
+ public boolean showIngameHUD(World world, ItemStack stack, EntityPlayer player);
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/IReagentContainer.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/IReagentContainer.java
new file mode 100644
index 00000000..91f93252
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/IReagentContainer.java
@@ -0,0 +1,18 @@
+package WayofTime.alchemicalWizardry.api.alchemy.energy;
+
+import net.minecraftforge.fluids.FluidTankInfo;
+
+public interface IReagentContainer
+{
+ public ReagentStack getReagent();
+
+ public int getReagentStackAmount();
+
+ public int getCapacity();
+
+ public int fill(ReagentStack resource, boolean doFill);
+
+ public ReagentStack drain(int maxDrain, boolean doDrain);
+
+ public ReagentContainerInfo getInfo();
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/IReagentHandler.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/IReagentHandler.java
new file mode 100644
index 00000000..37da7b69
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/IReagentHandler.java
@@ -0,0 +1,18 @@
+package WayofTime.alchemicalWizardry.api.alchemy.energy;
+
+import net.minecraftforge.common.util.ForgeDirection;
+
+public interface IReagentHandler
+{
+ int fill(ForgeDirection from, ReagentStack resource, boolean doFill);
+
+ ReagentStack drain(ForgeDirection from, ReagentStack resource, boolean doDrain);
+
+ ReagentStack drain(ForgeDirection from, int maxDrain, boolean doDrain);
+
+ boolean canFill(ForgeDirection from, Reagent reagent);
+
+ boolean canDrain(ForgeDirection from, Reagent reagent);
+
+ ReagentContainerInfo[] getContainerInfo(ForgeDirection from);
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/ISegmentedReagentHandler.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/ISegmentedReagentHandler.java
new file mode 100644
index 00000000..a6335d9e
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/ISegmentedReagentHandler.java
@@ -0,0 +1,14 @@
+package WayofTime.alchemicalWizardry.api.alchemy.energy;
+
+import java.util.Map;
+
+public interface ISegmentedReagentHandler extends IReagentHandler
+{
+ public int getNumberOfTanks();
+
+ public int getTanksTunedToReagent(Reagent reagent);
+
+ public void setTanksTunedToReagent(Reagent reagent, int total);
+
+ public Map getAttunedTankMap();
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/Reagent.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/Reagent.java
new file mode 100644
index 00000000..df4036b3
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/Reagent.java
@@ -0,0 +1,54 @@
+package WayofTime.alchemicalWizardry.api.alchemy.energy;
+
+import net.minecraft.item.ItemStack;
+
+public class Reagent
+{
+ public final String name;
+
+ public static final int REAGENT_SIZE = 1000;
+
+ private int colourRed = 0;
+ private int colourGreen = 0;
+ private int colourBlue = 0;
+ private int colourIntensity = 255;
+
+ public Reagent(String name)
+ {
+ this.name = name;
+ }
+
+ public void setColour(int red, int green, int blue, int intensity)
+ {
+ this.colourRed = red;
+ this.colourGreen = green;
+ this.colourBlue = blue;
+ this.colourIntensity = intensity;
+ }
+
+ public int getColourRed()
+ {
+ return colourRed;
+ }
+
+ public int getColourGreen()
+ {
+ return colourGreen;
+ }
+
+ public int getColourBlue()
+ {
+ return colourBlue;
+ }
+
+ public int getColourIntensity()
+ {
+ return colourIntensity;
+ }
+
+ @Override
+ public boolean equals(Object o)
+ {
+ return o instanceof Reagent ? this == o && name.equals(((Reagent)o).name) : false;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/ReagentContainer.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/ReagentContainer.java
new file mode 100644
index 00000000..ea6d8306
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/ReagentContainer.java
@@ -0,0 +1,158 @@
+package WayofTime.alchemicalWizardry.api.alchemy.energy;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.FluidTank;
+
+public class ReagentContainer implements IReagentContainer
+{
+ protected ReagentStack reagentStack;
+ protected int capacity;
+
+ public ReagentContainer(int capacity)
+ {
+ this(null, capacity);
+ }
+
+ public ReagentContainer(ReagentStack stack, int capacity)
+ {
+ this.reagentStack = stack;
+ this.capacity = capacity;
+ }
+
+ public ReagentContainer(Reagent reagent, int amount, int capacity)
+ {
+ this(new ReagentStack(reagent, amount), capacity);
+ }
+
+ public static ReagentContainer readFromNBT(NBTTagCompound nbt)
+ {
+ ReagentStack reagent = ReagentStack.loadReagentStackFromNBT(nbt);
+ int capacity = nbt.getInteger("capacity");
+
+ if (reagent != null)
+ {
+ return new ReagentContainer(reagent, capacity);
+ }else
+ {
+ return new ReagentContainer(null, capacity);
+ }
+ }
+
+ public NBTTagCompound writeToNBT(NBTTagCompound nbt)
+ {
+ if (reagentStack != null)
+ {
+ reagentStack.writeToNBT(nbt);
+ }
+
+ nbt.setInteger("capacity", capacity);
+
+ return nbt;
+ }
+
+ @Override
+ public ReagentStack getReagent()
+ {
+ return reagentStack;
+ }
+
+ @Override
+ public int getReagentStackAmount()
+ {
+ if (reagentStack == null)
+ {
+ return 0;
+ }
+ return reagentStack.amount;
+ }
+
+ @Override
+ public int getCapacity()
+ {
+ return capacity;
+ }
+
+ @Override
+ public int fill(ReagentStack resource, boolean doFill)
+ {
+ if (resource == null)
+ {
+ return 0;
+ }
+
+ if (!doFill)
+ {
+ if (reagentStack == null)
+ {
+ return Math.min(capacity, resource.amount);
+ }
+
+ if (!reagentStack.isReagentEqual(resource))
+ {
+ return 0;
+ }
+
+ return Math.min(capacity - reagentStack.amount, resource.amount);
+ }
+
+ if (reagentStack == null)
+ {
+ reagentStack = new ReagentStack(resource, Math.min(capacity, resource.amount));
+
+ return reagentStack.amount;
+ }
+
+ if (!reagentStack.isReagentEqual(resource))
+ {
+ return 0;
+ }
+ int filled = capacity - reagentStack.amount;
+
+ if (resource.amount < filled)
+ {
+ reagentStack.amount += resource.amount;
+ filled = resource.amount;
+ }
+ else
+ {
+ reagentStack.amount = capacity;
+ }
+
+ return filled;
+ }
+
+ @Override
+ public ReagentStack drain(int maxDrain, boolean doDrain)
+ {
+ if (reagentStack == null)
+ {
+ return null;
+ }
+
+ int drained = maxDrain;
+ if (reagentStack.amount < drained)
+ {
+ drained = reagentStack.amount;
+ }
+
+ ReagentStack stack = new ReagentStack(reagentStack, drained);
+ if (doDrain)
+ {
+ reagentStack.amount -= drained;
+ if (reagentStack.amount <= 0)
+ {
+ reagentStack = null;
+ }
+ }
+ return stack;
+ }
+
+ @Override
+ public ReagentContainerInfo getInfo()
+ {
+ return new ReagentContainerInfo(this);
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/ReagentContainerInfo.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/ReagentContainerInfo.java
new file mode 100644
index 00000000..8dea2a50
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/ReagentContainerInfo.java
@@ -0,0 +1,22 @@
+package WayofTime.alchemicalWizardry.api.alchemy.energy;
+
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.IFluidTank;
+
+public final class ReagentContainerInfo
+{
+ public final ReagentStack reagent;
+ public final int capacity;
+
+ public ReagentContainerInfo(ReagentStack reagent, int capacity)
+ {
+ this.reagent = reagent;
+ this.capacity = capacity;
+ }
+
+ public ReagentContainerInfo(IReagentContainer tank)
+ {
+ this.reagent = tank.getReagent();
+ this.capacity = tank.getCapacity();
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/ReagentRegistry.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/ReagentRegistry.java
new file mode 100644
index 00000000..2120d9ef
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/ReagentRegistry.java
@@ -0,0 +1,191 @@
+package WayofTime.alchemicalWizardry.api.alchemy.energy;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import net.minecraft.item.ItemStack;
+import WayofTime.alchemicalWizardry.ModItems;
+
+public class ReagentRegistry
+{
+ public static Map reagentList = new HashMap();
+ public static Map itemToReagentMap = new HashMap();
+
+ public static Reagent sanctusReagent;
+ public static Reagent incendiumReagent;
+ public static Reagent aquasalusReagent;
+ public static Reagent magicalesReagent;
+ public static Reagent aetherReagent;
+ public static Reagent crepitousReagent;
+ public static Reagent crystallosReagent;
+ public static Reagent terraeReagent;
+ public static Reagent tenebraeReagent;
+
+ public static Reagent offensaReagent;
+ public static Reagent praesidiumReagent;
+ public static Reagent orbisTerraeReagent;
+ public static Reagent virtusReagent;
+ public static Reagent reductusReagent;
+ public static Reagent potentiaReagent;
+
+ public static void initReagents()
+ {
+ sanctusReagent = new Reagent("sanctus");
+ incendiumReagent = new Reagent("incendium");
+ aquasalusReagent = new Reagent("aquasalus");
+ magicalesReagent = new Reagent("magicales");
+ aetherReagent = new Reagent("aether");
+ crepitousReagent = new Reagent("crepitous");
+ crystallosReagent = new Reagent("crystallos");
+ terraeReagent = new Reagent("terrae");
+ tenebraeReagent = new Reagent("tenebrae");
+ offensaReagent = new Reagent("offensa");
+ praesidiumReagent = new Reagent("praesidium");
+ orbisTerraeReagent = new Reagent("orbisTerrae");
+ virtusReagent = new Reagent("virtus");
+ reductusReagent = new Reagent("reductus");
+ potentiaReagent = new Reagent("potentia");
+
+ sanctusReagent.setColour(255, 255, 0, 255);
+ incendiumReagent.setColour(255, 0, 0, 255);
+ aquasalusReagent.setColour(47, 0, 196, 255);
+ magicalesReagent.setColour(150, 0, 146, 255);
+ aetherReagent.setColour(105, 223, 86, 255);
+ crepitousReagent.setColour(145, 145, 145, 255);
+ crystallosReagent.setColour(135, 255, 231, 255);
+ terraeReagent.setColour(147, 48, 13, 255);
+ tenebraeReagent.setColour(86, 86, 86, 255);
+ offensaReagent.setColour(126, 0, 0, 255);
+ praesidiumReagent.setColour(135, 135, 135, 255);
+ orbisTerraeReagent.setColour(32, 94, 14, 255);
+ virtusReagent.setColour(180, 0, 0, 255);
+ reductusReagent.setColour(20, 93, 2, 255);
+ potentiaReagent.setColour(64, 81, 208, 255);
+
+ registerReagent("sanctus", sanctusReagent);
+ registerReagent("incendium", incendiumReagent);
+ registerReagent("aquasalus", aquasalusReagent);
+ registerReagent("magicales", magicalesReagent);
+ registerReagent("aether", aetherReagent);
+ registerReagent("crepitous", crepitousReagent);
+ registerReagent("crystallos", crystallosReagent);
+ registerReagent("terrae", terraeReagent);
+ registerReagent("tenebrae", tenebraeReagent);
+ registerReagent("offensa", offensaReagent);
+ registerReagent("praesidium", praesidiumReagent);
+ registerReagent("orbisTerrae", orbisTerraeReagent);
+ registerReagent("virtus", virtusReagent);
+ registerReagent("reductus", reductusReagent);
+ registerReagent("potentia", potentiaReagent);
+
+ ReagentRegistry.registerItemAndReagent(new ItemStack(ModItems.sanctus), new ReagentStack(sanctusReagent, 1000));
+ ReagentRegistry.registerItemAndReagent(new ItemStack(ModItems.incendium), new ReagentStack(incendiumReagent, 1000));
+ ReagentRegistry.registerItemAndReagent(new ItemStack(ModItems.aquasalus), new ReagentStack(aquasalusReagent, 1000));
+ ReagentRegistry.registerItemAndReagent(new ItemStack(ModItems.magicales), new ReagentStack(magicalesReagent, 1000));
+ ReagentRegistry.registerItemAndReagent(new ItemStack(ModItems.aether), new ReagentStack(aetherReagent, 1000));
+ ReagentRegistry.registerItemAndReagent(new ItemStack(ModItems.crepitous), new ReagentStack(crepitousReagent, 1000));
+ ReagentRegistry.registerItemAndReagent(new ItemStack(ModItems.crystallos), new ReagentStack(crystallosReagent, 1000));
+ ReagentRegistry.registerItemAndReagent(new ItemStack(ModItems.terrae), new ReagentStack(terraeReagent, 1000));
+ ReagentRegistry.registerItemAndReagent(new ItemStack(ModItems.tennebrae), new ReagentStack(tenebraeReagent, 1000));
+ ReagentRegistry.registerItemAndReagent(new ItemStack(ModItems.baseAlchemyItems,1,0), new ReagentStack(offensaReagent, 1000));
+ ReagentRegistry.registerItemAndReagent(new ItemStack(ModItems.baseAlchemyItems,1,1), new ReagentStack(praesidiumReagent, 1000));
+ ReagentRegistry.registerItemAndReagent(new ItemStack(ModItems.baseAlchemyItems,1,2), new ReagentStack(orbisTerraeReagent, 1000));
+ ReagentRegistry.registerItemAndReagent(new ItemStack(ModItems.baseAlchemyItems,1,6), new ReagentStack(virtusReagent, 1000));
+ ReagentRegistry.registerItemAndReagent(new ItemStack(ModItems.baseAlchemyItems,1,7), new ReagentStack(reductusReagent, 1000));
+ ReagentRegistry.registerItemAndReagent(new ItemStack(ModItems.baseAlchemyItems,1,8), new ReagentStack(potentiaReagent, 1000));
+ }
+
+ public static boolean registerReagent(String key, Reagent reagent)
+ {
+ if(reagentList.containsKey(key) || reagent == null)
+ {
+ return false;
+ }
+
+ reagentList.put(key, reagent);
+
+ return true;
+ }
+
+ public static Reagent getReagentForKey(String key)
+ {
+ if(reagentList.containsKey(key))
+ {
+ return reagentList.get(key);
+ }
+
+ return null;
+ }
+
+ public static String getKeyForReagent(Reagent reagent)
+ {
+ if(reagentList.containsValue(reagent))
+ {
+ Set> set = reagentList.entrySet();
+ for(Entry entry : set)
+ {
+ if(entry.getValue().equals(reagent))
+ {
+ return entry.getKey();
+ }
+ }
+ }
+
+ return "";
+ }
+
+ public static void registerItemAndReagent(ItemStack stack, ReagentStack reagentStack)
+ {
+ itemToReagentMap.put(stack, reagentStack);
+ }
+
+ public static ReagentStack getReagentStackForItem(ItemStack stack)
+ {
+ if(stack == null)
+ {
+ return null;
+ }
+
+ for(Entry entry : itemToReagentMap.entrySet())
+ {
+ if(entry.getKey() != null && entry.getKey().isItemEqual(stack))
+ {
+ if(entry.getValue() == null)
+ {
+ return null;
+ }else
+ {
+ return entry.getValue().copy();
+ }
+ }
+ }
+
+ return null;
+ }
+
+ public static ItemStack getItemForReagent(Reagent reagent)
+ {
+ if(reagent == null)
+ {
+ return null;
+ }
+
+ for(Entry entry : itemToReagentMap.entrySet())
+ {
+ if(entry.getValue() != null && entry.getValue().reagent == reagent)
+ {
+ if(entry.getKey() == null)
+ {
+ return null;
+ }else
+ {
+ return entry.getKey().copy();
+ }
+ }
+ }
+
+ return null;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/ReagentStack.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/ReagentStack.java
new file mode 100644
index 00000000..f39b35ab
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/ReagentStack.java
@@ -0,0 +1,64 @@
+package WayofTime.alchemicalWizardry.api.alchemy.energy;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.fluids.FluidStack;
+
+public class ReagentStack
+{
+ public Reagent reagent;
+ public int amount;
+
+ public ReagentStack(Reagent reagent, int amount)
+ {
+ this.reagent = reagent;
+ this.amount = amount;
+ }
+
+ public ReagentStack(ReagentStack reagentStack, int amount)
+ {
+ this(reagentStack.reagent,amount);
+ }
+
+ public static ReagentStack loadReagentStackFromNBT(NBTTagCompound tag)
+ {
+ Reagent reagent = ReagentRegistry.getReagentForKey(tag.getString("Reagent"));
+
+ if(reagent == null)
+ {
+ return null;
+ }
+
+ int amount = tag.getInteger("amount");
+ ReagentStack stack = new ReagentStack(reagent, amount);
+
+ return stack;
+ }
+
+ public NBTTagCompound writeToNBT(NBTTagCompound tag)
+ {
+ tag.setString("Reagent", ReagentRegistry.getKeyForReagent(this.reagent));
+ tag.setInteger("amount", this.amount);
+
+ return tag;
+ }
+
+ public ReagentStack splitStack(int amount)
+ {
+ ReagentStack copyStack = this.copy();
+ int splitAmount = Math.min(amount, this.amount);
+ copyStack.amount = splitAmount;
+ this.amount -= splitAmount;
+
+ return copyStack;
+ }
+
+ public ReagentStack copy()
+ {
+ return new ReagentStack(this.reagent, this.amount);
+ }
+
+ public boolean isReagentEqual(ReagentStack other)
+ {
+ return other != null && this.reagent == other.reagent;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/TileReagentHandler.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/TileReagentHandler.java
new file mode 100644
index 00000000..270efaa3
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/TileReagentHandler.java
@@ -0,0 +1,68 @@
+
+package WayofTime.alchemicalWizardry.api.alchemy.energy;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidContainerRegistry;
+import net.minecraftforge.fluids.IFluidHandler;
+
+public class TileReagentHandler extends TileEntity implements IReagentHandler
+{
+ protected ReagentContainer tank = new ReagentContainer(4000);
+
+ @Override
+ public void readFromNBT(NBTTagCompound tag)
+ {
+ super.readFromNBT(tag);
+ tank.readFromNBT(tag);
+ }
+
+ @Override
+ public void writeToNBT(NBTTagCompound tag)
+ {
+ super.writeToNBT(tag);
+ tank.writeToNBT(tag);
+ }
+
+ /* IReagentHandler */
+ @Override
+ public int fill(ForgeDirection from, ReagentStack resource, boolean doFill)
+ {
+ return tank.fill(resource, doFill);
+ }
+
+ @Override
+ public ReagentStack drain(ForgeDirection from, ReagentStack resource, boolean doDrain)
+ {
+ if (resource == null || !resource.isReagentEqual(tank.getReagent()))
+ {
+ return null;
+ }
+ return tank.drain(resource.amount, doDrain);
+ }
+
+ @Override
+ public ReagentStack drain(ForgeDirection from, int maxDrain, boolean doDrain)
+ {
+ return tank.drain(maxDrain, doDrain);
+ }
+
+ @Override
+ public boolean canFill(ForgeDirection from, Reagent reagent)
+ {
+ return true;
+ }
+
+ @Override
+ public boolean canDrain(ForgeDirection from, Reagent reagent)
+ {
+ return true;
+ }
+
+ @Override
+ public ReagentContainerInfo[] getContainerInfo(ForgeDirection from)
+ {
+ return new ReagentContainerInfo[] {tank.getInfo()};
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/TileSegmentedReagentHandler.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/TileSegmentedReagentHandler.java
new file mode 100644
index 00000000..6cf25c04
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/TileSegmentedReagentHandler.java
@@ -0,0 +1,283 @@
+
+package WayofTime.alchemicalWizardry.api.alchemy.energy;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.util.Constants;
+import net.minecraftforge.common.util.ForgeDirection;
+
+public class TileSegmentedReagentHandler extends TileEntity implements ISegmentedReagentHandler
+{
+ protected ReagentContainer[] tanks;
+ protected Map attunedTankMap;
+
+ public TileSegmentedReagentHandler()
+ {
+ this(1);
+ }
+
+ public TileSegmentedReagentHandler(int numberOfTanks)
+ {
+ this(numberOfTanks, 1000);
+ }
+
+ public TileSegmentedReagentHandler(int numberOfTanks, int tankSize)
+ {
+ super();
+
+ this.attunedTankMap = new HashMap();
+ this.tanks = new ReagentContainer[numberOfTanks];
+ for(int i=0; i entry : this.attunedTankMap.entrySet())
+ {
+ NBTTagCompound savedTag = new NBTTagCompound();
+ savedTag.setString("reagent", ReagentRegistry.getKeyForReagent(entry.getKey()));
+ savedTag.setInteger("amount", entry.getValue());
+ attunedTagList.appendTag(savedTag);
+ }
+
+ tag.setTag("attunedTankMap", attunedTagList);
+ }
+
+ /* ISegmentedReagentHandler */
+ @Override
+ public int fill(ForgeDirection from, ReagentStack resource, boolean doFill)
+ {
+ int totalFill = 0;
+
+ boolean useTankLimit = !this.attunedTankMap.isEmpty();
+
+ if(resource != null)
+ {
+ int totalTanksFillable = useTankLimit ? this.getTanksTunedToReagent(resource.reagent) : this.tanks.length;
+ int tanksFilled = 0;
+
+ int maxFill = resource.amount;
+
+ for(int i=this.tanks.length-1; i>=0; i--)
+ {
+ ReagentStack remainingStack = resource.copy();
+ remainingStack.amount = maxFill - totalFill;
+
+ boolean doesReagentMatch = tanks[i].getReagent() == null ? false : tanks[i].getReagent().isReagentEqual(remainingStack);
+
+ if(doesReagentMatch)
+ {
+ totalFill += tanks[i].fill(remainingStack, doFill);
+ tanksFilled++;
+ }else
+ {
+ continue;
+ }
+
+ if(totalFill >= maxFill || tanksFilled >= totalTanksFillable)
+ {
+ return totalFill;
+ }
+ }
+
+ if(tanksFilled >= totalTanksFillable)
+ {
+ return totalFill;
+ }
+
+ for(int i=this.tanks.length-1; i>=0; i--)
+ {
+ ReagentStack remainingStack = resource.copy();
+ remainingStack.amount = maxFill - totalFill;
+
+ boolean isTankEmpty = tanks[i].getReagent() == null;
+
+ if(isTankEmpty)
+ {
+ totalFill += tanks[i].fill(remainingStack, doFill);
+ tanksFilled++;
+ }else
+ {
+ continue;
+ }
+
+ if(totalFill >= maxFill || tanksFilled >= totalTanksFillable)
+ {
+ return totalFill;
+ }
+ }
+ }
+ return totalFill;
+ }
+
+ @Override
+ public ReagentStack drain(ForgeDirection from, ReagentStack resource, boolean doDrain)
+ {
+ if(resource == null)
+ {
+ return null;
+ }
+
+ int maxDrain = resource.amount;
+ Reagent reagent = resource.reagent;
+ int drained = 0;
+
+ for(int i=0; i= maxDrain)
+ {
+ break;
+ }
+
+ if(resource.isReagentEqual(tanks[i].getReagent()))
+ {
+ ReagentStack drainStack = tanks[i].drain(maxDrain-drained, doDrain);
+ if(drainStack != null)
+ {
+ drained += drainStack.amount;
+ }
+ }
+ }
+
+ return new ReagentStack(reagent, drained);
+ }
+
+ /* Only returns the amount from the first available tank */
+ @Override
+ public ReagentStack drain(ForgeDirection from, int maxDrain, boolean doDrain)
+ {
+ for(int i=0; i getAttunedTankMap()
+ {
+ return this.attunedTankMap;
+ }
+
+ public boolean areTanksEmpty()
+ {
+ for(int i=0; i=minTier && this.requiredItem.isItemEqual(comparedStack);
+ }
+
+ public int getMinTier()
+ {
+ return this.minTier;
+ }
+
+ public int getLiquidRequired()
+ {
+ return this.liquidRequired;
+ }
+
+ public int getConsumptionRate()
+ {
+ return this.consumptionRate;
+ }
+
+ public int getDrainRate()
+ {
+ return this.drainRate;
+ }
+
+ public boolean getCanBeFilled()
+ {
+ return this.canBeFilled;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/altarRecipeRegistry/AltarRecipeRegistry.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/altarRecipeRegistry/AltarRecipeRegistry.java
new file mode 100644
index 00000000..89c0be46
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/altarRecipeRegistry/AltarRecipeRegistry.java
@@ -0,0 +1,60 @@
+package WayofTime.alchemicalWizardry.api.altarRecipeRegistry;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import net.minecraft.item.ItemStack;
+
+public class AltarRecipeRegistry
+{
+ public static List altarRecipes = new LinkedList();
+
+ public static void registerAltarRecipe(ItemStack result, ItemStack requiredItem, int minTier, int liquidRequired, int consumptionRate, int drainRate, boolean canBeFilled)
+ {
+ altarRecipes.add(new AltarRecipe(result, requiredItem, minTier, liquidRequired, consumptionRate, drainRate, canBeFilled));
+ }
+
+ public static void registerAltarOrbRecipe(ItemStack orbStack, int minTier, int consumptionRate)
+ {
+ registerAltarRecipe(null, orbStack, minTier, 0, consumptionRate, 0, true);
+ }
+
+ public static boolean isRequiredItemValid(ItemStack testItem, int currentTierAltar)
+ {
+ for(AltarRecipe recipe : altarRecipes)
+ {
+ if(recipe.doesRequiredItemMatch(testItem, currentTierAltar))
+ {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ public static ItemStack getItemForItemAndTier(ItemStack testItem, int currentTierAltar)
+ {
+ for(AltarRecipe recipe : altarRecipes)
+ {
+ if(recipe.doesRequiredItemMatch(testItem, currentTierAltar))
+ {
+ return ItemStack.copyItemStack(recipe.getResult());
+ }
+ }
+
+ return null;
+ }
+
+ public static AltarRecipe getAltarRecipeForItemAndTier(ItemStack testItem, int currentTierAltar)
+ {
+ for(AltarRecipe recipe : altarRecipes)
+ {
+ if(recipe.doesRequiredItemMatch(testItem, currentTierAltar))
+ {
+ return recipe;
+ }
+ }
+
+ return null;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/bindingRegistry/BindingRecipe.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/bindingRegistry/BindingRecipe.java
new file mode 100644
index 00000000..111f585f
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/bindingRegistry/BindingRecipe.java
@@ -0,0 +1,35 @@
+package WayofTime.alchemicalWizardry.api.bindingRegistry;
+
+import net.minecraft.item.ItemStack;
+
+public class BindingRecipe
+{
+ public ItemStack requiredItem;
+ public ItemStack outputItem;
+
+ public BindingRecipe(ItemStack outputItem, ItemStack requiredItem)
+ {
+ this.requiredItem = requiredItem;
+ this.outputItem = outputItem;
+ }
+
+ public boolean doesRequiredItemMatch(ItemStack testStack)
+ {
+ if(testStack == null || this.requiredItem == null)
+ {
+ return false;
+ }
+
+ return this.requiredItem.isItemEqual(testStack);
+ }
+
+ public ItemStack getResult(ItemStack inputItem)
+ {
+ return this.getResult();
+ }
+
+ public ItemStack getResult()
+ {
+ return this.outputItem;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/bindingRegistry/BindingRegistry.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/bindingRegistry/BindingRegistry.java
new file mode 100644
index 00000000..636fb3f6
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/bindingRegistry/BindingRegistry.java
@@ -0,0 +1,67 @@
+package WayofTime.alchemicalWizardry.api.bindingRegistry;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import net.minecraft.item.ItemStack;
+
+public class BindingRegistry
+{
+ public static List bindingRecipes = new LinkedList();
+
+ public static void registerRecipe(ItemStack output, ItemStack input)
+ {
+ bindingRecipes.add(new BindingRecipe(output, input));
+ }
+
+ public static boolean isRequiredItemValid(ItemStack testItem)
+ {
+ for(BindingRecipe recipe : bindingRecipes)
+ {
+ if(recipe.doesRequiredItemMatch(testItem))
+ {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ public static ItemStack getItemForItemAndTier(ItemStack testItem)
+ {
+ for(BindingRecipe recipe : bindingRecipes)
+ {
+ if(recipe.doesRequiredItemMatch(testItem))
+ {
+ return recipe.getResult(testItem).copy();
+ }
+ }
+
+ return null;
+ }
+
+ public static int getIndexForItem(ItemStack testItem)
+ {
+ int i=0;
+ for(BindingRecipe recipe : bindingRecipes)
+ {
+ if(recipe.doesRequiredItemMatch(testItem))
+ {
+ return i;
+ }
+ i++;
+ }
+
+ return -1;
+ }
+
+ public static ItemStack getOutputForIndex(int index)
+ {
+ if(bindingRecipes.size()<=index)
+ {
+ return null;
+ }
+
+ return bindingRecipes.get(index).getResult();
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/harvest/HarvestRegistry.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/harvest/HarvestRegistry.java
new file mode 100644
index 00000000..244e227c
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/harvest/HarvestRegistry.java
@@ -0,0 +1,33 @@
+package WayofTime.alchemicalWizardry.api.harvest;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.world.World;
+
+public class HarvestRegistry
+{
+ public static List handlerList = new ArrayList();
+
+ public static void registerHarvestHandler(IHarvestHandler handler)
+ {
+ handlerList.add(handler);
+ }
+
+ public static boolean harvestBlock(World world, int xCoord, int yCoord, int zCoord)
+ {
+ Block block = world.getBlock(xCoord, yCoord, zCoord);
+ int meta = world.getBlockMetadata(xCoord, yCoord, zCoord);
+
+ for(IHarvestHandler handler : handlerList)
+ {
+ if(handler.harvestAndPlant(world, xCoord, yCoord, zCoord, block, meta))
+ {
+ return true;
+ }
+ }
+
+ return false;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/harvest/IHarvestHandler.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/harvest/IHarvestHandler.java
new file mode 100644
index 00000000..888dff58
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/harvest/IHarvestHandler.java
@@ -0,0 +1,21 @@
+package WayofTime.alchemicalWizardry.api.harvest;
+
+import net.minecraft.block.Block;
+import net.minecraft.world.World;
+import net.minecraftforge.common.IPlantable;
+
+public interface IHarvestHandler
+{
+ /**
+ * A handler that is used to harvest and replant the block at the specified location
+ *
+ * @param world
+ * @param xCoord
+ * @param yCoord
+ * @param zCoord
+ * @param block block at this given location
+ * @param meta meta at this given location
+ * @return true if successfully harvested, false if not
+ */
+ public boolean harvestAndPlant(World world, int xCoord, int yCoord, int zCoord, Block block, int meta);
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/items/ShapedBloodOrbRecipe.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/items/ShapedBloodOrbRecipe.java
new file mode 100644
index 00000000..cdf82e6e
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/items/ShapedBloodOrbRecipe.java
@@ -0,0 +1,227 @@
+package WayofTime.alchemicalWizardry.api.items;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import net.minecraft.block.Block;
+import net.minecraft.inventory.InventoryCrafting;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.crafting.IRecipe;
+import net.minecraft.item.crafting.ShapedRecipes;
+import net.minecraft.world.World;
+import net.minecraftforge.oredict.OreDictionary;
+import WayofTime.alchemicalWizardry.api.items.interfaces.IBloodOrb;
+
+/** Shaped Blood Orb Recipe Handler by joshie **/
+public class ShapedBloodOrbRecipe implements IRecipe {
+ private static final int MAX_CRAFT_GRID_WIDTH = 3;
+ private static final int MAX_CRAFT_GRID_HEIGHT = 3;
+
+ private ItemStack output = null;
+ private Object[] input = null;
+ public int width = 0;
+ public int height = 0;
+ private boolean mirrored = true;
+
+ public ShapedBloodOrbRecipe(Block result, Object... recipe) {
+ this(new ItemStack(result), recipe);
+ }
+
+ public ShapedBloodOrbRecipe(Item result, Object... recipe) {
+ this(new ItemStack(result), recipe);
+ }
+
+ public ShapedBloodOrbRecipe(ItemStack result, Object... recipe) {
+ output = result.copy();
+
+ String shape = "";
+ int idx = 0;
+
+ if (recipe[idx] instanceof Boolean) {
+ mirrored = (Boolean) recipe[idx];
+ if (recipe[idx + 1] instanceof Object[]) {
+ recipe = (Object[]) recipe[idx + 1];
+ } else {
+ idx = 1;
+ }
+ }
+
+ if (recipe[idx] instanceof String[]) {
+ String[] parts = ((String[]) recipe[idx++]);
+
+ for (String s : parts) {
+ width = s.length();
+ shape += s;
+ }
+
+ height = parts.length;
+ } else {
+ while (recipe[idx] instanceof String) {
+ String s = (String) recipe[idx++];
+ shape += s;
+ width = s.length();
+ height++;
+ }
+ }
+
+ if (width * height != shape.length()) {
+ String ret = "Invalid shaped ore recipe: ";
+ for (Object tmp : recipe) {
+ ret += tmp + ", ";
+ }
+ ret += output;
+ throw new RuntimeException(ret);
+ }
+
+ HashMap itemMap = new HashMap();
+
+ for (; idx < recipe.length; idx += 2) {
+ Character chr = (Character) recipe[idx];
+ Object in = recipe[idx + 1];
+
+ if (in instanceof IBloodOrb || (in instanceof ItemStack && ((ItemStack)in).getItem() instanceof IBloodOrb)) { //If the item is an instanceof IBloodOrb then save the level of the orb
+ if(in instanceof ItemStack) itemMap.put(chr, (Integer)(((IBloodOrb)((ItemStack)in).getItem()).getOrbLevel()));
+ else itemMap.put(chr, (Integer)(((IBloodOrb)in).getOrbLevel()));
+ } else if (in instanceof ItemStack) {
+ itemMap.put(chr, ((ItemStack) in).copy());
+ } else if (in instanceof Item) {
+ itemMap.put(chr, new ItemStack((Item) in));
+ } else if (in instanceof Block) {
+ itemMap.put(chr, new ItemStack((Block) in, 1, OreDictionary.WILDCARD_VALUE));
+ } else if (in instanceof String) {
+ itemMap.put(chr, OreDictionary.getOres((String) in));
+ } else {
+ String ret = "Invalid shaped ore recipe: ";
+ for (Object tmp : recipe) {
+ ret += tmp + ", ";
+ }
+ ret += output;
+ throw new RuntimeException(ret);
+ }
+ }
+
+ input = new Object[width * height];
+ int x = 0;
+ for (char chr : shape.toCharArray()) {
+ input[x++] = itemMap.get(chr);
+ }
+ }
+
+ ShapedBloodOrbRecipe(ShapedRecipes recipe, Map replacements) {
+ output = recipe.getRecipeOutput();
+ width = recipe.recipeWidth;
+ height = recipe.recipeHeight;
+
+ input = new Object[recipe.recipeItems.length];
+
+ for (int i = 0; i < input.length; i++) {
+ ItemStack ingred = recipe.recipeItems[i];
+
+ if (ingred == null)
+ continue;
+
+ input[i] = recipe.recipeItems[i];
+
+ for (Entry replace : replacements.entrySet()) {
+ if (OreDictionary.itemMatches(replace.getKey(), ingred, true)) {
+ input[i] = OreDictionary.getOres(replace.getValue());
+ break;
+ }
+ }
+ }
+ }
+
+ @Override
+ public ItemStack getCraftingResult(InventoryCrafting var1) {
+ return output.copy();
+ }
+
+ @Override
+ public int getRecipeSize() {
+ return input.length;
+ }
+
+ @Override
+ public ItemStack getRecipeOutput() {
+ return output;
+ }
+
+ @Override
+ public boolean matches(InventoryCrafting inv, World world) {
+ for (int x = 0; x <= MAX_CRAFT_GRID_WIDTH - width; x++) {
+ for (int y = 0; y <= MAX_CRAFT_GRID_HEIGHT - height; ++y) {
+ if (checkMatch(inv, x, y, false)) {
+ return true;
+ }
+
+ if (mirrored && checkMatch(inv, x, y, true)) {
+ return true;
+ }
+ }
+ }
+
+ return false;
+ }
+
+ @SuppressWarnings("unchecked")
+ private boolean checkMatch(InventoryCrafting inv, int startX, int startY, boolean mirror) {
+ for (int x = 0; x < MAX_CRAFT_GRID_WIDTH; x++) {
+ for (int y = 0; y < MAX_CRAFT_GRID_HEIGHT; y++) {
+ int subX = x - startX;
+ int subY = y - startY;
+ Object target = null;
+
+ if (subX >= 0 && subY >= 0 && subX < width && subY < height) {
+ if (mirror) {
+ target = input[width - subX - 1 + subY * width];
+ } else {
+ target = input[subX + subY * width];
+ }
+ }
+
+ ItemStack slot = inv.getStackInRowAndColumn(x, y);
+ //If target is integer, then we should be check the blood orb value of the item instead
+ if(target instanceof Integer) {
+ if(slot != null && slot.getItem() instanceof IBloodOrb) {
+ IBloodOrb orb = (IBloodOrb) slot.getItem();
+ if(orb.getOrbLevel() < (Integer)target) {
+ return false;
+ }
+ } else return false;
+ } else if (target instanceof ItemStack) {
+ if (!OreDictionary.itemMatches((ItemStack) target, slot, false)) {
+ return false;
+ }
+ } else if (target instanceof ArrayList) {
+ boolean matched = false;
+
+ Iterator itr = ((ArrayList) target).iterator();
+ while (itr.hasNext() && !matched) {
+ matched = OreDictionary.itemMatches(itr.next(), slot, false);
+ }
+
+ if (!matched) {
+ return false;
+ }
+ } else if (target == null && slot != null) {
+ return false;
+ }
+ }
+ }
+
+ return true;
+ }
+
+ public ShapedBloodOrbRecipe setMirrored(boolean mirror) {
+ mirrored = mirror;
+ return this;
+ }
+
+ public Object[] getInput() {
+ return this.input;
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/items/ShapelessBloodOrbRecipe.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/items/ShapelessBloodOrbRecipe.java
new file mode 100644
index 00000000..fbf28a45
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/items/ShapelessBloodOrbRecipe.java
@@ -0,0 +1,140 @@
+package WayofTime.alchemicalWizardry.api.items;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import net.minecraft.block.Block;
+import net.minecraft.inventory.InventoryCrafting;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.crafting.IRecipe;
+import net.minecraft.item.crafting.ShapelessRecipes;
+import net.minecraft.world.World;
+import net.minecraftforge.oredict.OreDictionary;
+import WayofTime.alchemicalWizardry.api.items.interfaces.IBloodOrb;
+
+/** Shapeless Blood Orb Recipe Handler by joshie **/
+public class ShapelessBloodOrbRecipe implements IRecipe {
+ private ItemStack output = null;
+ private ArrayList input = new ArrayList();
+
+ public ShapelessBloodOrbRecipe(Block result, Object... recipe) {
+ this(new ItemStack(result), recipe);
+ }
+
+ public ShapelessBloodOrbRecipe(Item result, Object... recipe) {
+ this(new ItemStack(result), recipe);
+ }
+
+ public ShapelessBloodOrbRecipe(ItemStack result, Object... recipe) {
+ output = result.copy();
+ for (Object in : recipe) {
+ if (in instanceof ItemStack) {
+ input.add(((ItemStack) in).copy());
+ } else if (in instanceof IBloodOrb) { //If the item is an instanceof IBloodOrb then save the level of the orb
+ input.add((Integer)(((IBloodOrb)in).getOrbLevel()));
+ } else if (in instanceof Item) {
+ input.add(new ItemStack((Item) in));
+ } else if (in instanceof Block) {
+ input.add(new ItemStack((Block) in));
+ } else if (in instanceof String) {
+ input.add(OreDictionary.getOres((String) in));
+ } else {
+ String ret = "Invalid shapeless ore recipe: ";
+ for (Object tmp : recipe) {
+ ret += tmp + ", ";
+ }
+ ret += output;
+ throw new RuntimeException(ret);
+ }
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ ShapelessBloodOrbRecipe(ShapelessRecipes recipe, Map replacements) {
+ output = recipe.getRecipeOutput();
+
+ for (ItemStack ingred : ((List) recipe.recipeItems)) {
+ Object finalObj = ingred;
+ for (Entry replace : replacements.entrySet()) {
+ if (OreDictionary.itemMatches(replace.getKey(), ingred, false)) {
+ finalObj = OreDictionary.getOres(replace.getValue());
+ break;
+ }
+ }
+ input.add(finalObj);
+ }
+ }
+
+ @Override
+ public int getRecipeSize() {
+ return input.size();
+ }
+
+ @Override
+ public ItemStack getRecipeOutput() {
+ return output;
+ }
+
+ @Override
+ public ItemStack getCraftingResult(InventoryCrafting var1) {
+ return output.copy();
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ public boolean matches(InventoryCrafting var1, World world) {
+ ArrayList required = new ArrayList(input);
+
+ for (int x = 0; x < var1.getSizeInventory(); x++) {
+ ItemStack slot = var1.getStackInSlot(x);
+
+ if (slot != null) {
+ boolean inRecipe = false;
+ Iterator req = required.iterator();
+
+ while (req.hasNext()) {
+ boolean match = false;
+
+ Object next = req.next();
+
+ //If target is integer, then we should be check the blood orb value of the item instead
+ if(next instanceof Integer) {
+ if(slot != null && slot.getItem() instanceof IBloodOrb) {
+ IBloodOrb orb = (IBloodOrb) slot.getItem();
+ if(orb.getOrbLevel() < (Integer)next) {
+ return false;
+ }
+ } else return false;
+ } else if (next instanceof ItemStack) {
+ match = OreDictionary.itemMatches((ItemStack) next, slot, false);
+ } else if (next instanceof ArrayList) {
+ Iterator itr = ((ArrayList) next).iterator();
+ while (itr.hasNext() && !match) {
+ match = OreDictionary.itemMatches(itr.next(), slot, false);
+ }
+ }
+
+ if (match) {
+ inRecipe = true;
+ required.remove(next);
+ break;
+ }
+ }
+
+ if (!inRecipe) {
+ return false;
+ }
+ }
+ }
+
+ return required.isEmpty();
+ }
+
+ public ArrayList getInput() {
+ return this.input;
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/items/interfaces/ArmourUpgrade.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/items/interfaces/ArmourUpgrade.java
new file mode 100644
index 00000000..7fce7cd0
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/items/interfaces/ArmourUpgrade.java
@@ -0,0 +1,15 @@
+package WayofTime.alchemicalWizardry.api.items.interfaces;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+
+public interface ArmourUpgrade
+{
+ //Called when the armour ticks
+ public void onArmourUpdate(World world, EntityPlayer player, ItemStack thisItemStack);
+
+ public boolean isUpgrade();
+
+ public int getEnergyForTenSeconds();
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/items/interfaces/IBindable.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/items/interfaces/IBindable.java
new file mode 100644
index 00000000..46a79939
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/items/interfaces/IBindable.java
@@ -0,0 +1,5 @@
+package WayofTime.alchemicalWizardry.api.items.interfaces;
+
+public interface IBindable
+{
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/items/interfaces/IBloodOrb.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/items/interfaces/IBloodOrb.java
new file mode 100644
index 00000000..794172cc
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/items/interfaces/IBloodOrb.java
@@ -0,0 +1,8 @@
+package WayofTime.alchemicalWizardry.api.items.interfaces;
+
+public interface IBloodOrb
+{
+ public int getMaxEssence();
+
+ public int getOrbLevel();
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/items/interfaces/IHolding.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/items/interfaces/IHolding.java
new file mode 100644
index 00000000..cb07b998
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/items/interfaces/IHolding.java
@@ -0,0 +1,6 @@
+package WayofTime.alchemicalWizardry.api.items.interfaces;
+
+public interface IHolding
+{
+
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/items/interfaces/IReagentManipulator.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/items/interfaces/IReagentManipulator.java
new file mode 100644
index 00000000..df2c84bb
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/items/interfaces/IReagentManipulator.java
@@ -0,0 +1,9 @@
+package WayofTime.alchemicalWizardry.api.items.interfaces;
+
+/**
+ * Implement this interface to have reagent blocks return false on activating them, to allow manipulation of said block
+ */
+public interface IReagentManipulator
+{
+
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/rituals/IMasterRitualStone.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/rituals/IMasterRitualStone.java
new file mode 100644
index 00000000..be31cbf8
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/rituals/IMasterRitualStone.java
@@ -0,0 +1,36 @@
+package WayofTime.alchemicalWizardry.api.rituals;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ISegmentedReagentHandler;
+
+public interface IMasterRitualStone extends ISegmentedReagentHandler
+{
+ public void performRitual(World world, int x, int y, int z, String ritualID);
+
+ public String getOwner();
+
+ public void setCooldown(int newCooldown);
+
+ public int getCooldown();
+
+ public void setVar1(int newVar1);
+
+ public int getVar1();
+
+ public void setActive(boolean active);
+
+ public int getDirection();
+
+ public World getWorld();
+
+ public int getXCoord();
+
+ public int getYCoord();
+
+ public int getZCoord();
+
+ public NBTTagCompound getCustomRitualTag();
+
+ public void setCustomRitualTag(NBTTagCompound tag);
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/rituals/IRitualStone.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/rituals/IRitualStone.java
new file mode 100644
index 00000000..078cfd40
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/rituals/IRitualStone.java
@@ -0,0 +1,6 @@
+package WayofTime.alchemicalWizardry.api.rituals;
+
+public interface IRitualStone
+{
+
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/rituals/RitualComponent.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/rituals/RitualComponent.java
new file mode 100644
index 00000000..b7149858
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/rituals/RitualComponent.java
@@ -0,0 +1,43 @@
+package WayofTime.alchemicalWizardry.api.rituals;
+
+public class RitualComponent
+{
+ private int x;
+ private int y;
+ private int z;
+ private int stoneType;
+ public static final int BLANK = 0;
+ public static final int WATER = 1;
+ public static final int FIRE = 2;
+ public static final int EARTH = 3;
+ public static final int AIR = 4;
+ public static final int DUSK = 5;
+
+ public RitualComponent(int x, int y, int z, int stoneType)
+ {
+ this.x = x;
+ this.y = y;
+ this.z = z;
+ this.stoneType = stoneType;
+ }
+
+ public int getX()
+ {
+ return this.x;
+ }
+
+ public int getY()
+ {
+ return this.y;
+ }
+
+ public int getZ()
+ {
+ return this.z;
+ }
+
+ public int getStoneType()
+ {
+ return this.stoneType;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/rituals/RitualEffect.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/rituals/RitualEffect.java
new file mode 100644
index 00000000..f5339288
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/rituals/RitualEffect.java
@@ -0,0 +1,56 @@
+package WayofTime.alchemicalWizardry.api.rituals;
+
+import java.util.List;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraftforge.common.util.ForgeDirection;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.Reagent;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentStack;
+
+public abstract class RitualEffect
+{
+ public abstract void performEffect(IMasterRitualStone ritualStone);
+
+ public boolean startRitual(IMasterRitualStone ritualStone, EntityPlayer player)
+ {
+ return true;
+ }
+
+ public void onRitualBroken(IMasterRitualStone ritualStone)
+ {
+
+ }
+
+ public abstract int getCostPerRefresh();
+
+ public int getInitialCooldown()
+ {
+ return 0;
+ }
+
+ public abstract List getRitualComponentList();
+
+ public boolean canDrainReagent(IMasterRitualStone ritualStone, Reagent reagent, int amount, boolean doDrain)
+ {
+ if(ritualStone == null || reagent == null || amount == 0)
+ {
+ return false;
+ }
+
+ ReagentStack reagentStack = new ReagentStack(reagent, amount);
+
+ ReagentStack stack = ritualStone.drain(ForgeDirection.UNKNOWN, reagentStack, false);
+
+ if(stack != null && stack.amount >= amount)
+ {
+ if(doDrain)
+ {
+ ritualStone.drain(ForgeDirection.UNKNOWN, reagentStack, true);
+ }
+
+ return true;
+ }
+
+ return false;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/rituals/Rituals.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/rituals/Rituals.java
new file mode 100644
index 00000000..212a43e0
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/rituals/Rituals.java
@@ -0,0 +1,422 @@
+package WayofTime.alchemicalWizardry.api.rituals;
+
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.common.renderer.MRSRenderer;
+
+public class Rituals
+{
+ private int crystalLevel;
+ private int actCost;
+ private RitualEffect effect;
+ private String name;
+
+ private MRSRenderer customRenderer;
+
+ public static Map ritualMap = new HashMap();
+ public static List keyList = new LinkedList();
+
+ public Rituals(int crystalLevel, int actCost, RitualEffect effect, String name, MRSRenderer renderer)
+ {
+ this.crystalLevel = crystalLevel;
+ this.actCost = actCost;
+ this.effect = effect;
+ this.name = name;
+ keyList.add(name);
+ ritualMap.put(name, this);
+ this.customRenderer = renderer;
+ }
+
+ public Rituals(int crystalLevel, int actCost, RitualEffect effect, String name)
+ {
+ this(crystalLevel, actCost, effect, name, null);
+ }
+
+ /**
+ * Static method to register a ritual to the Ritual Registry
+ * @param key Unique identification key - must be different from all others to properly register
+ * @param crystalLevel Crystal level required to activate
+ * @param actCost LP amount required to activate
+ * @param effect The effect that will be ticked
+ * @param name The name of the ritual
+ * @return Returns true if properly registered, or false if the key is already used
+ */
+ public static boolean registerRitual(String key, int crystalLevel, int actCost, RitualEffect effect, String name, MRSRenderer renderer)
+ {
+ if(ritualMap.containsKey(key))
+ {
+ return false;
+ }
+ else
+ {
+ Rituals ritual = new Rituals(crystalLevel, actCost, effect, name, renderer);
+ ritual.removeRitualFromList();
+ ritualMap.put(key, ritual);
+ keyList.add(key);
+ return true;
+ }
+ }
+
+ public static boolean registerRitual(String key, int crystalLevel, int actCost, RitualEffect effect, String name)
+ {
+ if(ritualMap.containsKey(key))
+ {
+ return false;
+ }
+ else
+ {
+ Rituals ritual = new Rituals(crystalLevel, actCost, effect, name);
+ ritual.removeRitualFromList();
+ ritualMap.put(key, ritual);
+ keyList.add(key);
+ return true;
+ }
+ }
+
+ public void removeRitualFromList()
+ {
+ if(ritualMap.containsValue(this))
+ {
+ ritualMap.remove(ritualMap.remove(this.name));
+ }
+ if(keyList.contains(this.name))
+ {
+ keyList.remove(this.name);
+ }
+ }
+
+ public static String checkValidRitual(World world, int x, int y, int z)
+ {
+ for(String key : ritualMap.keySet())
+ {
+ if(checkRitualIsValid(world,x,y,z,key))
+ {
+ return key;
+ }
+ }
+
+ return "";
+ }
+
+ public static boolean canCrystalActivate(String ritualID, int crystalLevel)
+ {
+ if(ritualMap.containsKey(ritualID))
+ {
+ Rituals ritual = ritualMap.get(ritualID);
+ if(ritual != null)
+ {
+ return ritual.getCrystalLevel() <= crystalLevel;
+ }
+ }
+
+ return false;
+ }
+
+ public static boolean checkRitualIsValid(World world, int x, int y, int z, String ritualID)
+ {
+ int direction = Rituals.getDirectionOfRitual(world, x, y, z, ritualID);
+
+ if (direction != -1)
+ {
+ return true;
+ }
+
+ return false;
+ }
+
+ /**
+ * 1 - NORTH
+ * 2 - EAST
+ * 3 - SOUTH
+ * 4 - WEST
+ */
+ public static boolean checkDirectionOfRitualValid(World world, int x, int y, int z, String ritualID, int direction)
+ {
+ List ritual = Rituals.getRitualList(ritualID);
+
+ if (ritual == null)
+ {
+ return false;
+ }
+
+ Block test = null;
+
+ switch (direction)
+ {
+ case 1:
+ for (RitualComponent rc : ritual)
+ {
+ test = world.getBlock(x + rc.getX(), y + rc.getY(), z + rc.getZ());
+
+ if (!(test instanceof IRitualStone))
+ {
+ return false;
+ }
+
+ if (world.getBlockMetadata(x + rc.getX(), y + rc.getY(), z + rc.getZ()) != rc.getStoneType())
+ {
+ return false;
+ }
+ }
+
+ return true;
+
+ case 2:
+ for (RitualComponent rc : ritual)
+ {
+ test = world.getBlock(x - rc.getZ(), y + rc.getY(), z + rc.getX());
+
+ if (!(test instanceof IRitualStone))
+ {
+ return false;
+ }
+
+ if (world.getBlockMetadata(x - rc.getZ(), y + rc.getY(), z + rc.getX()) != rc.getStoneType())
+ {
+ return false;
+ }
+ }
+
+ return true;
+
+ case 3:
+ for (RitualComponent rc : ritual)
+ {
+ test = world.getBlock(x - rc.getX(), y + rc.getY(), z - rc.getZ());
+
+ if (!(test instanceof IRitualStone))
+ {
+ return false;
+ }
+
+ if (world.getBlockMetadata(x - rc.getX(), y + rc.getY(), z - rc.getZ()) != rc.getStoneType())
+ {
+ return false;
+ }
+ }
+
+ return true;
+
+ case 4:
+ for (RitualComponent rc : ritual)
+ {
+ test = world.getBlock(x + rc.getZ(), y + rc.getY(), z - rc.getX());
+
+ if (!(test instanceof IRitualStone))
+ {
+ return false;
+ }
+
+ if (world.getBlockMetadata(x + rc.getZ(), y + rc.getY(), z - rc.getX()) != rc.getStoneType())
+ {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ return false;
+ }
+
+ public static int getDirectionOfRitual(World world, int x, int y, int z, String ritualID)
+ {
+ for (int i = 1; i <= 4; i++)
+ {
+ if (Rituals.checkDirectionOfRitualValid(world, x, y, z, ritualID, i))
+ {
+ return i;
+ }
+ }
+
+ return -1;
+ }
+
+ public static int getCostForActivation(String ritualID)
+ {
+ if(ritualMap.containsKey(ritualID))
+ {
+ Rituals ritual = ritualMap.get(ritualID);
+ if(ritual != null)
+ {
+ return ritual.actCost;
+ }
+ }
+
+ return 0;
+ }
+
+ public static int getInitialCooldown(String ritualID)
+ {
+ if(ritualMap.containsKey(ritualID))
+ {
+ Rituals ritual = ritualMap.get(ritualID);
+ if(ritual != null && ritual.effect != null)
+ {
+ return ritual.effect.getInitialCooldown();
+ }
+ }
+
+ return 0;
+ }
+
+ public static List getRitualList(String ritualID)
+ {
+ if(ritualMap.containsKey(ritualID))
+ {
+ Rituals ritual = ritualMap.get(ritualID);
+ if(ritual != null)
+ {
+ return ritual.obtainComponents();
+ }else
+ {
+ return null;
+ }
+ }else
+ {
+ return null;
+ }
+ }
+
+ private List obtainComponents()
+ {
+ return this.effect.getRitualComponentList();
+ }
+
+ private int getCrystalLevel()
+ {
+ return this.crystalLevel;
+ }
+
+ private MRSRenderer getRenderer()
+ {
+ return this.customRenderer;
+ }
+
+ public static void performEffect(IMasterRitualStone ritualStone, String ritualID)
+ {
+ if(ritualMap.containsKey(ritualID))
+ {
+ Rituals ritual = ritualMap.get(ritualID);
+ if(ritual != null && ritual.effect != null)
+ {
+ ritual.effect.performEffect(ritualStone);
+ }
+ }
+ }
+
+ public static boolean startRitual(IMasterRitualStone ritualStone, String ritualID, EntityPlayer player)
+ {
+ if(ritualMap.containsKey(ritualID))
+ {
+ Rituals ritual = ritualMap.get(ritualID);
+ if(ritual != null && ritual.effect != null)
+ {
+ return ritual.effect.startRitual(ritualStone, player);
+ }
+ }
+
+ return false;
+ }
+
+ public static void onRitualBroken(IMasterRitualStone ritualStone, String ritualID)
+ {
+ if(ritualMap.containsKey(ritualID))
+ {
+ Rituals ritual = ritualMap.get(ritualID);
+ if(ritual != null && ritual.effect != null)
+ {
+ ritual.effect.onRitualBroken(ritualStone);
+ }
+ }
+ }
+
+ public static int getNumberOfRituals()
+ {
+ return ritualMap.size();
+ }
+
+ public String getRitualName()
+ {
+ return this.name;
+ }
+
+ public static String getNameOfRitual(String id)
+ {
+ if(ritualMap.containsKey(id))
+ {
+ Rituals ritual = ritualMap.get(id);
+ if(ritual != null)
+ {
+ return ritual.getRitualName();
+ }
+ }
+
+ return "";
+ }
+
+ public static String getNextRitualKey(String key)
+ {
+ boolean hasSpotted = false;
+ String firstKey = "";
+
+ for(String str : keyList)
+ {
+ if(firstKey.equals(""))
+ {
+ firstKey = str;
+ }
+ if(hasSpotted)
+ {
+ return str;
+ }
+ if(str.equals(key))
+ {
+ hasSpotted = true;
+ }
+ }
+
+ return firstKey;
+ }
+
+ public static String getPreviousRitualKey(String key)
+ {
+ boolean hasSpotted = false;
+ String lastKey = keyList.get(keyList.size()-1);
+
+ for(String str : keyList)
+ {
+ if(str.equals(key))
+ {
+ hasSpotted = true;
+ }
+ if(hasSpotted)
+ {
+ return lastKey;
+ }
+ lastKey = str;
+ }
+
+ return lastKey;
+ }
+
+ public static MRSRenderer getRendererForKey(String ritualID)
+ {
+ if(ritualMap.containsKey(ritualID))
+ {
+ Rituals ritual = ritualMap.get(ritualID);
+ if(ritual != null)
+ {
+ return ritual.getRenderer();
+ }
+ }
+
+ return null;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/soulNetwork/LifeEssenceNetwork.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/soulNetwork/LifeEssenceNetwork.java
new file mode 100644
index 00000000..61d24eee
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/soulNetwork/LifeEssenceNetwork.java
@@ -0,0 +1,26 @@
+package WayofTime.alchemicalWizardry.api.soulNetwork;
+
+import net.minecraft.nbt.NBTTagCompound;
+
+public class LifeEssenceNetwork extends net.minecraft.world.WorldSavedData
+{
+ public int currentEssence;
+
+ public LifeEssenceNetwork(String par1Str)
+ {
+ super(par1Str);
+ currentEssence = 0;
+ }
+
+ @Override
+ public void readFromNBT(NBTTagCompound nbttagcompound)
+ {
+ currentEssence = nbttagcompound.getInteger("currentEssence");
+ }
+
+ @Override
+ public void writeToNBT(NBTTagCompound nbttagcompound)
+ {
+ nbttagcompound.setInteger("currentEssence", currentEssence);
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/soulNetwork/SoulNetworkHandler.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/soulNetwork/SoulNetworkHandler.java
new file mode 100644
index 00000000..0bf21a6e
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/soulNetwork/SoulNetworkHandler.java
@@ -0,0 +1,292 @@
+package WayofTime.alchemicalWizardry.api.soulNetwork;
+
+import java.util.UUID;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.potion.Potion;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.util.DamageSource;
+import net.minecraft.world.World;
+
+import com.mojang.authlib.GameProfile;
+
+public class SoulNetworkHandler
+{
+ public static UUID getUUIDFromPlayer(EntityPlayer player)
+ {
+ return player.getPersistentID();
+ }
+
+ public static EntityPlayer getPlayerFromUUID(UUID uuid)
+ {
+ MinecraftServer server = MinecraftServer.getServer();
+ GameProfile gameProfile;
+ gameProfile = server.func_152358_ax().func_152652_a(uuid);
+// LogHelper.info("player is " + gameProfile.getName() + " : " + gameProfile.getId());
+
+ return null;
+ }
+
+ public static int syphonFromNetwork(ItemStack ist, int damageToBeDone)
+ {
+ if (ist.getTagCompound() != null && !(ist.getTagCompound().getString("ownerName").equals("")))
+ {
+ String ownerName = ist.getTagCompound().getString("ownerName");
+
+ return syphonFromNetwork(ownerName, damageToBeDone);
+ }
+ return 0;
+ }
+
+ public static int syphonFromNetwork(String ownerName, int damageToBeDone)
+ {
+ if (MinecraftServer.getServer() == null)
+ {
+ return 0;
+ }
+
+ World world = MinecraftServer.getServer().worldServers[0];
+ LifeEssenceNetwork data = (LifeEssenceNetwork) world.loadItemData(LifeEssenceNetwork.class, ownerName);
+
+ if (data == null)
+ {
+ data = new LifeEssenceNetwork(ownerName);
+ world.setItemData(ownerName, data);
+ }
+
+ if (data.currentEssence >= damageToBeDone)
+ {
+ data.currentEssence -= damageToBeDone;
+ data.markDirty();
+ return damageToBeDone;
+ }
+
+ return 0;
+ }
+
+ /**
+ * Master method used to syphon from the player's network, and will damage them accordingly if they do not have enough LP.
+ * Does not drain on the client side.
+ *
+ * @param ist Owned itemStack
+ * @param player Player using the item
+ * @param damageToBeDone
+ * @return True if server-sided, false if client-sided
+ */
+ public static boolean syphonAndDamageFromNetwork(ItemStack ist, EntityPlayer player, int damageToBeDone)
+ {
+ if(player.worldObj.isRemote)
+ {
+ return false;
+ }
+
+ int amount = SoulNetworkHandler.syphonFromNetwork(ist, damageToBeDone);
+
+ hurtPlayer(player, damageToBeDone-amount);
+
+ return true;
+ }
+
+ public static boolean canSyphonFromOnlyNetwork(ItemStack ist, int damageToBeDone)
+ {
+ if (ist.getTagCompound() != null && !(ist.getTagCompound().getString("ownerName").equals("")))
+ {
+ String ownerName = ist.getTagCompound().getString("ownerName");
+
+ return canSyphonFromOnlyNetwork(ownerName, damageToBeDone);
+ }
+
+ return false;
+ }
+
+ public static boolean canSyphonFromOnlyNetwork(String ownerName, int damageToBeDone)
+ {
+ if (MinecraftServer.getServer() == null)
+ {
+ return false;
+ }
+
+ World world = MinecraftServer.getServer().worldServers[0];
+ LifeEssenceNetwork data = (LifeEssenceNetwork) world.loadItemData(LifeEssenceNetwork.class, ownerName);
+
+ if (data == null)
+ {
+ data = new LifeEssenceNetwork(ownerName);
+ world.setItemData(ownerName, data);
+ }
+
+ return data.currentEssence >= damageToBeDone;
+ }
+
+ public static int getCurrentEssence(String ownerName)
+ {
+ if (MinecraftServer.getServer() == null)
+ {
+ return 0;
+ }
+
+ World world = MinecraftServer.getServer().worldServers[0];
+ LifeEssenceNetwork data = (LifeEssenceNetwork) world.loadItemData(LifeEssenceNetwork.class, ownerName);
+
+ if (data == null)
+ {
+ data = new LifeEssenceNetwork(ownerName);
+ world.setItemData(ownerName, data);
+ }
+
+ return data.currentEssence;
+ }
+
+ public static void setCurrentEssence(String ownerName, int essence)
+ {
+ if (MinecraftServer.getServer() == null)
+ {
+ return;
+ }
+
+ World world = MinecraftServer.getServer().worldServers[0];
+ LifeEssenceNetwork data = (LifeEssenceNetwork) world.loadItemData(LifeEssenceNetwork.class, ownerName);
+
+ if (data == null)
+ {
+ data = new LifeEssenceNetwork(ownerName);
+ world.setItemData(ownerName, data);
+ }
+
+ data.currentEssence = essence;
+ data.markDirty();
+ }
+
+ /**
+ * A method to add to an owner's network up to a maximum value.
+ *
+ * @param ownerName
+ * @param addedEssence
+ * @param maximum
+ * @return amount added to the network
+ */
+ public static int addCurrentEssenceToMaximum(String ownerName, int addedEssence, int maximum)
+ {
+ if (MinecraftServer.getServer() == null)
+ {
+ return 0;
+ }
+
+ World world = MinecraftServer.getServer().worldServers[0];
+ LifeEssenceNetwork data = (LifeEssenceNetwork) world.loadItemData(LifeEssenceNetwork.class, ownerName);
+
+ if (data == null)
+ {
+ data = new LifeEssenceNetwork(ownerName);
+ world.setItemData(ownerName, data);
+ }
+
+ int currEss = data.currentEssence;
+
+ if(currEss>=maximum)
+ {
+ return 0;
+ }
+
+ int newEss = Math.min(maximum, currEss+addedEssence);
+ data.currentEssence = newEss;
+
+ return newEss-currEss;
+ }
+
+ public static void hurtPlayer(EntityPlayer user, int energySyphoned)
+ {
+ if (energySyphoned < 100 && energySyphoned > 0)
+ {
+ if (!user.capabilities.isCreativeMode)
+ {
+ user.setHealth((user.getHealth() - 1));
+
+ if (user.getHealth() <= 0.0005f)
+ {
+ user.onDeath(DamageSource.generic);
+ }
+ }
+ } else if (energySyphoned >= 100)
+ {
+ if (!user.capabilities.isCreativeMode)
+ {
+ for (int i = 0; i < ((energySyphoned + 99) / 100); i++)
+ {
+ user.setHealth((user.getHealth() - 1));
+
+ if (user.getHealth() <= 0.0005f)
+ {
+ user.onDeath(DamageSource.generic);
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ public static void checkAndSetItemOwner(ItemStack item, EntityPlayer player)
+ {
+ if (item.stackTagCompound == null)
+ {
+ item.setTagCompound(new NBTTagCompound());
+ }
+
+ if (item.stackTagCompound.getString("ownerName").equals(""))
+ {
+ item.stackTagCompound.setString("ownerName", SoulNetworkHandler.getUsername(player));
+ }
+ }
+
+ public static void checkAndSetItemOwner(ItemStack item, String ownerName)
+ {
+ if (item.stackTagCompound == null)
+ {
+ item.setTagCompound(new NBTTagCompound());
+ }
+
+ if (item.stackTagCompound.getString("ownerName").equals(""))
+ {
+ item.stackTagCompound.setString("ownerName", ownerName);
+ }
+ }
+
+ public static String getUsername(EntityPlayer player)
+ {
+ return player.getDisplayName();
+ }
+
+ public static EntityPlayer getPlayerForUsername(String str)
+ {
+ if(MinecraftServer.getServer() == null)
+ {
+ return null;
+ }
+ return MinecraftServer.getServer().getConfigurationManager().func_152612_a(str);
+ }
+
+ public static void causeNauseaToPlayer(ItemStack stack)
+ {
+ if (stack.getTagCompound() != null && !(stack.getTagCompound().getString("ownerName").equals("")))
+ {
+ String ownerName = stack.getTagCompound().getString("ownerName");
+
+ SoulNetworkHandler.causeNauseaToPlayer(ownerName);
+ }
+ }
+
+ public static void causeNauseaToPlayer(String ownerName)
+ {
+ EntityPlayer entityOwner = SoulNetworkHandler.getPlayerForUsername(ownerName);
+
+ if (entityOwner == null)
+ {
+ return;
+ }
+
+ entityOwner.addPotionEffect(new PotionEffect(Potion.confusion.id, 80));
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/summoningRegistry/SummoningHelper.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/summoningRegistry/SummoningHelper.java
new file mode 100644
index 00000000..cccfe3f4
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/summoningRegistry/SummoningHelper.java
@@ -0,0 +1,21 @@
+package WayofTime.alchemicalWizardry.api.summoningRegistry;
+
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.world.World;
+
+public abstract class SummoningHelper
+{
+ protected int id;
+
+ public SummoningHelper(int id)
+ {
+ this.id = id;
+ }
+
+ public abstract EntityLivingBase getEntity(World worldObj);
+
+ public int getSummoningHelperID()
+ {
+ return id;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/summoningRegistry/SummoningRegistry.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/summoningRegistry/SummoningRegistry.java
new file mode 100644
index 00000000..9fda5822
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/summoningRegistry/SummoningRegistry.java
@@ -0,0 +1,70 @@
+package WayofTime.alchemicalWizardry.api.summoningRegistry;
+
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class SummoningRegistry
+{
+ public static List summoningList = new ArrayList();
+
+ public static void registerSummon(SummoningHelper s, ItemStack[] ring1, ItemStack[] ring2, ItemStack[] ring3, int amountUsed, int bloodOrbLevel)
+ {
+ summoningList.add(new SummoningRegistryComponent(s, ring1, ring2, ring3, amountUsed, bloodOrbLevel));
+ }
+
+ public static boolean isRecipeValid(int bloodOrbLevel, ItemStack[] test1, ItemStack[] test2, ItemStack[] test3)
+ {
+ for (SummoningRegistryComponent src : summoningList)
+ {
+ if (src.getBloodOrbLevel() <= bloodOrbLevel && src.compareRing(1, test1) && src.compareRing(2, test2) && src.compareRing(3, test3))
+ {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ public static SummoningRegistryComponent getRegistryComponent(int bloodOrbLevel, ItemStack[] test1, ItemStack[] test2, ItemStack[] test3)
+ {
+ for (SummoningRegistryComponent src : summoningList)
+ {
+ if (src.getBloodOrbLevel() <= bloodOrbLevel && src.compareRing(1, test1) && src.compareRing(2, test2) && src.compareRing(3, test3))
+ {
+ return src;
+ }
+ }
+
+ return null;
+ }
+
+ public static EntityLivingBase getEntity(World worldObj, int bloodOrbLevel, ItemStack[] test1, ItemStack[] test2, ItemStack[] test3)
+ {
+ for (SummoningRegistryComponent src : summoningList)
+ {
+ if (src.getBloodOrbLevel() <= bloodOrbLevel && src.compareRing(1, test1) && src.compareRing(2, test2) && src.compareRing(3, test3))
+ {
+ return src.getEntity(worldObj);
+ }
+ }
+
+ return null;
+ }
+
+ public static EntityLivingBase getEntityWithID(World worldObj, int id)
+ {
+ for (SummoningRegistryComponent src : summoningList)
+ {
+ if (src.getSummoningHelperID() == id)
+ {
+ return src.getEntity(worldObj);
+ }
+ }
+
+ return null;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/summoningRegistry/SummoningRegistryComponent.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/summoningRegistry/SummoningRegistryComponent.java
new file mode 100644
index 00000000..8496b0f2
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/summoningRegistry/SummoningRegistryComponent.java
@@ -0,0 +1,231 @@
+package WayofTime.alchemicalWizardry.api.summoningRegistry;
+
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import net.minecraftforge.oredict.OreDictionary;
+
+public class SummoningRegistryComponent
+{
+ public ItemStack[] ring1 = new ItemStack[6];
+ public ItemStack[] ring2 = new ItemStack[6];
+ public ItemStack[] ring3 = new ItemStack[6];
+ public SummoningHelper summoningHelper;
+ public int summoningCost;
+ public int bloodOrbLevel;
+
+ public SummoningRegistryComponent(SummoningHelper s, ItemStack[] newRing1, ItemStack[] newRing2, ItemStack[] newRing3, int amount, int bloodOrbLevel)
+ {
+ this.summoningHelper = s;
+ this.ring1 = newRing1;
+ this.ring2 = newRing2;
+ this.ring3 = newRing3;
+ this.summoningCost = amount;
+ this.bloodOrbLevel = bloodOrbLevel;
+
+ if (this.ring1.length != 6)
+ {
+ ItemStack[] newRecipe = new ItemStack[6];
+
+ for (int i = 0; i < 6; i++)
+ {
+ if (i + 1 > this.ring1.length)
+ {
+ newRecipe[i] = null;
+ } else
+ {
+ newRecipe[i] = this.ring1[i];
+ }
+ }
+
+ this.ring1 = newRecipe;
+ }
+
+ if (this.ring2.length != 6)
+ {
+ ItemStack[] newRecipe = new ItemStack[6];
+
+ for (int i = 0; i < 6; i++)
+ {
+ if (i + 1 > this.ring2.length)
+ {
+ newRecipe[i] = null;
+ } else
+ {
+ newRecipe[i] = this.ring2[i];
+ }
+ }
+
+ this.ring2 = newRecipe;
+ }
+
+ if (this.ring3.length != 6)
+ {
+ ItemStack[] newRecipe = new ItemStack[6];
+
+ for (int i = 0; i < 6; i++)
+ {
+ if (i + 1 > this.ring3.length)
+ {
+ newRecipe[i] = null;
+ } else
+ {
+ newRecipe[i] = this.ring3[i];
+ }
+ }
+
+ this.ring3 = newRecipe;
+ }
+ }
+
+ public boolean compareRing(int ring, ItemStack[] checkedRingRecipe)
+ {
+ ItemStack[] recipe;
+
+ if (checkedRingRecipe.length < 6)
+ {
+ return false;
+ }
+
+ switch (ring)
+ {
+ case 1:
+ recipe = ring1;
+ break;
+
+ case 2:
+ recipe = ring2;
+ break;
+
+ case 3:
+ recipe = ring3;
+ break;
+
+ default:
+ recipe = ring1;
+ }
+
+ if (recipe.length != 6)
+ {
+ ItemStack[] newRecipe = new ItemStack[6];
+
+ for (int i = 0; i < 6; i++)
+ {
+ if (i + 1 > recipe.length)
+ {
+ newRecipe[i] = null;
+ } else
+ {
+ newRecipe[i] = recipe[i];
+ }
+ }
+
+ recipe = newRecipe;
+ }
+
+ boolean[] checkList = new boolean[6];
+
+ for (int i = 0; i < 6; i++)
+ {
+ checkList[i] = false;
+ }
+
+ for (int i = 0; i < 6; i++)
+ {
+ ItemStack recipeItemStack = recipe[i];
+
+ if (recipeItemStack == null)
+ {
+ continue;
+ }
+
+ boolean test = false;
+
+ for (int j = 0; j < 6; j++)
+ {
+ if (checkList[j])
+ {
+ continue;
+ }
+
+ ItemStack checkedItemStack = checkedRingRecipe[j];
+
+ if (checkedItemStack == null)
+ {
+ continue;
+ }
+
+ boolean quickTest = false;
+
+ if (recipeItemStack.getItem() instanceof ItemBlock)
+ {
+ if (checkedItemStack.getItem() instanceof ItemBlock)
+ {
+ quickTest = true;
+ }
+ } else if (!(checkedItemStack.getItem() instanceof ItemBlock))
+ {
+ quickTest = true;
+ }
+
+ if (!quickTest)
+ {
+ continue;
+ }
+
+ if ((checkedItemStack.getItemDamage() == recipeItemStack.getItemDamage() || OreDictionary.WILDCARD_VALUE == recipeItemStack.getItemDamage()) && checkedItemStack.getItem() == recipeItemStack.getItem())
+ {
+ test = true;
+ checkList[j] = true;
+ break;
+ }
+ }
+
+ if (!test)
+ {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ public int getSummoningCost()
+ {
+ return summoningCost;
+ }
+
+ public EntityLivingBase getEntity(World world)
+ {
+ return this.summoningHelper.getEntity(world);
+ }
+
+ public int getBloodOrbLevel()
+ {
+ return this.bloodOrbLevel;
+ }
+
+ public ItemStack[] getRingRecipeForRing(int ring)
+ {
+ switch (ring)
+ {
+ case 1:
+ return ring1;
+
+ case 2:
+ return ring2;
+
+ case 3:
+ return ring3;
+
+ default:
+ return null;
+ }
+ }
+
+ public int getSummoningHelperID()
+ {
+ return this.summoningHelper.getSummoningHelperID();
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/api/tile/IBloodAltar.java b/src-backup/main/java/WayofTime/alchemicalWizardry/api/tile/IBloodAltar.java
new file mode 100644
index 00000000..c70d6188
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/api/tile/IBloodAltar.java
@@ -0,0 +1,26 @@
+package WayofTime.alchemicalWizardry.api.tile;
+
+/**
+ * Created by Pokefenn.
+ */
+public interface IBloodAltar
+{
+
+ public int getCapacity();
+
+ public int getCurrentBlood();
+
+ public int getTier();
+
+ public int getProgress();
+
+ public float getSacrificeMultiplier();
+
+ public float getSelfSacrificeMultiplier();
+
+ public float getOrbMultiplier();
+
+ public float getDislocationMultiplier();
+
+ public int getBufferCapacity();
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/client/ClientEventHandler.java b/src-backup/main/java/WayofTime/alchemicalWizardry/client/ClientEventHandler.java
new file mode 100644
index 00000000..864de3c4
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/client/ClientEventHandler.java
@@ -0,0 +1,58 @@
+package WayofTime.alchemicalWizardry.client;
+
+import org.lwjgl.opengl.GL11;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraftforge.client.event.RenderPlayerEvent;
+import net.minecraftforge.client.event.sound.SoundEvent;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.client.renderer.RenderHelper;
+import cpw.mods.fml.client.FMLClientHandler;
+import cpw.mods.fml.common.eventhandler.Event.Result;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.common.gameevent.TickEvent.Phase;
+import cpw.mods.fml.common.gameevent.TickEvent.RenderTickEvent;
+
+public class ClientEventHandler
+{
+ private Minecraft mcClient = FMLClientHandler.instance().getClient();
+
+ @SubscribeEvent
+ public void onPlayerSoundEvent(SoundEvent event)
+ {
+ if(Minecraft.getMinecraft() != null)
+ {
+ EntityPlayer player = Minecraft.getMinecraft().thePlayer;
+
+ if(player != null && player.isPotionActive(AlchemicalWizardry.customPotionDeaf))
+ {
+ event.setResult(Result.DENY);
+ }
+ }
+ }
+
+ @SubscribeEvent
+ public void onTick(RenderTickEvent event)
+ {
+ if (event.phase.equals(Phase.START))
+ return;
+
+ if (!RenderHelper.onTickInGame(mcClient))
+ {
+
+ }
+ }
+
+ @SubscribeEvent
+ public void onRenderLivingPlayerPre(RenderPlayerEvent.Pre event)
+ {
+ GL11.glDisable(2929);
+ }
+
+ @SubscribeEvent
+ public void onRenderLivingPlayerPost(RenderPlayerEvent.Post event)
+ {
+ GL11.glEnable(2929);
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/client/ClientProxy.java b/src-backup/main/java/WayofTime/alchemicalWizardry/client/ClientProxy.java
new file mode 100644
index 00000000..ac7d29e2
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/client/ClientProxy.java
@@ -0,0 +1,178 @@
+package WayofTime.alchemicalWizardry.client;
+
+import net.minecraft.item.ItemBlock;
+import net.minecraft.world.World;
+import net.minecraftforge.client.MinecraftForgeClient;
+import WayofTime.alchemicalWizardry.ModBlocks;
+import WayofTime.alchemicalWizardry.common.CommonProxy;
+import WayofTime.alchemicalWizardry.common.EntityAirElemental;
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityBileDemon;
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityBoulderFist;
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityEarthElemental;
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityFallenAngel;
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityFireElemental;
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityHolyElemental;
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityIceDemon;
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityLowerGuardian;
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityShade;
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityShadeElemental;
+import WayofTime.alchemicalWizardry.common.entity.mob.EntitySmallEarthGolem;
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityWaterElemental;
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityWingedFireDemon;
+import WayofTime.alchemicalWizardry.common.entity.projectile.EnergyBlastProjectile;
+import WayofTime.alchemicalWizardry.common.entity.projectile.EntityEnergyBazookaMainProjectile;
+import WayofTime.alchemicalWizardry.common.entity.projectile.EntityMeteor;
+import WayofTime.alchemicalWizardry.common.entity.projectile.EntityParticleBeam;
+import WayofTime.alchemicalWizardry.common.renderer.block.RenderAlchemicCalcinator;
+import WayofTime.alchemicalWizardry.common.renderer.block.RenderConduit;
+import WayofTime.alchemicalWizardry.common.renderer.block.RenderCrystalBelljar;
+import WayofTime.alchemicalWizardry.common.renderer.block.RenderMasterStone;
+import WayofTime.alchemicalWizardry.common.renderer.block.RenderPedestal;
+import WayofTime.alchemicalWizardry.common.renderer.block.RenderPlinth;
+import WayofTime.alchemicalWizardry.common.renderer.block.RenderReagentConduit;
+import WayofTime.alchemicalWizardry.common.renderer.block.RenderSpellEffectBlock;
+import WayofTime.alchemicalWizardry.common.renderer.block.RenderSpellEnhancementBlock;
+import WayofTime.alchemicalWizardry.common.renderer.block.RenderSpellModifierBlock;
+import WayofTime.alchemicalWizardry.common.renderer.block.RenderSpellParadigmBlock;
+import WayofTime.alchemicalWizardry.common.renderer.block.RenderWritingTable;
+import WayofTime.alchemicalWizardry.common.renderer.block.ShaderHelper;
+import WayofTime.alchemicalWizardry.common.renderer.block.TEAltarRenderer;
+import WayofTime.alchemicalWizardry.common.renderer.block.itemRender.TEAlchemicalCalcinatorItemRenderer;
+import WayofTime.alchemicalWizardry.common.renderer.block.itemRender.TEAltarItemRenderer;
+import WayofTime.alchemicalWizardry.common.renderer.block.itemRender.TEBellJarItemRenderer;
+import WayofTime.alchemicalWizardry.common.renderer.block.itemRender.TEConduitItemRenderer;
+import WayofTime.alchemicalWizardry.common.renderer.block.itemRender.TESpellEffectBlockItemRenderer;
+import WayofTime.alchemicalWizardry.common.renderer.block.itemRender.TESpellEnhancementBlockItemRenderer;
+import WayofTime.alchemicalWizardry.common.renderer.block.itemRender.TESpellModifierBlockItemRenderer;
+import WayofTime.alchemicalWizardry.common.renderer.block.itemRender.TESpellParadigmBlockItemRenderer;
+import WayofTime.alchemicalWizardry.common.renderer.mob.RenderBileDemon;
+import WayofTime.alchemicalWizardry.common.renderer.mob.RenderBoulderFist;
+import WayofTime.alchemicalWizardry.common.renderer.mob.RenderElemental;
+import WayofTime.alchemicalWizardry.common.renderer.mob.RenderFallenAngel;
+import WayofTime.alchemicalWizardry.common.renderer.mob.RenderIceDemon;
+import WayofTime.alchemicalWizardry.common.renderer.mob.RenderLowerGuardian;
+import WayofTime.alchemicalWizardry.common.renderer.mob.RenderShade;
+import WayofTime.alchemicalWizardry.common.renderer.mob.RenderSmallEarthGolem;
+import WayofTime.alchemicalWizardry.common.renderer.mob.RenderWingedFireDemon;
+import WayofTime.alchemicalWizardry.common.renderer.model.ModelBileDemon;
+import WayofTime.alchemicalWizardry.common.renderer.model.ModelBoulderFist;
+import WayofTime.alchemicalWizardry.common.renderer.model.ModelElemental;
+import WayofTime.alchemicalWizardry.common.renderer.model.ModelFallenAngel;
+import WayofTime.alchemicalWizardry.common.renderer.model.ModelIceDemon;
+import WayofTime.alchemicalWizardry.common.renderer.model.ModelLowerGuardian;
+import WayofTime.alchemicalWizardry.common.renderer.model.ModelShade;
+import WayofTime.alchemicalWizardry.common.renderer.model.ModelSmallEarthGolem;
+import WayofTime.alchemicalWizardry.common.renderer.model.ModelWingedFireDemon;
+import WayofTime.alchemicalWizardry.common.renderer.projectile.RenderEnergyBazookaMainProjectile;
+import WayofTime.alchemicalWizardry.common.renderer.projectile.RenderEnergyBlastProjectile;
+import WayofTime.alchemicalWizardry.common.renderer.projectile.RenderMeteor;
+import WayofTime.alchemicalWizardry.common.spell.complex.EntitySpellProjectile;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEAlchemicCalcinator;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEAltar;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEBellJar;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEConduit;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEMasterStone;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEPedestal;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEPlinth;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEReagentConduit;
+import WayofTime.alchemicalWizardry.common.tileEntity.TESpellEffectBlock;
+import WayofTime.alchemicalWizardry.common.tileEntity.TESpellEnhancementBlock;
+import WayofTime.alchemicalWizardry.common.tileEntity.TESpellModifierBlock;
+import WayofTime.alchemicalWizardry.common.tileEntity.TESpellParadigmBlock;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEWritingTable;
+import cpw.mods.fml.client.FMLClientHandler;
+import cpw.mods.fml.client.registry.ClientRegistry;
+import cpw.mods.fml.client.registry.RenderingRegistry;
+import cpw.mods.fml.common.FMLCommonHandler;
+
+public class ClientProxy extends CommonProxy
+{
+ public static int renderPass;
+ public static int altarRenderType;
+
+ @Override
+ public void registerRenderers()
+ {
+ //altarRenderType = RenderingRegistry.getNextAvailableRenderId();
+ RenderingRegistry.registerEntityRenderingHandler(EnergyBlastProjectile.class, new RenderEnergyBlastProjectile());
+ RenderingRegistry.registerEntityRenderingHandler(EntityEnergyBazookaMainProjectile.class, new RenderEnergyBazookaMainProjectile());
+ RenderingRegistry.registerEntityRenderingHandler(EntitySpellProjectile.class, new RenderEnergyBlastProjectile());
+ RenderingRegistry.registerEntityRenderingHandler(EntityParticleBeam.class, new RenderEnergyBlastProjectile());
+ RenderingRegistry.registerEntityRenderingHandler(EntityMeteor.class, new RenderMeteor());
+ //EntityRegistry.registerGlobalEntityID(EntityFallenAngel.class, "AlchemicalWizardry.FallenAngel", EntityRegistry.findGlobalUniqueEntityId(),0x40FF00, 0x0B610B);
+ RenderingRegistry.registerEntityRenderingHandler(EntityFallenAngel.class, new RenderFallenAngel(new ModelFallenAngel(), 0.5F));
+ //EntityRegistry.registerGlobalEntityID(EntityLowerGuardian.class, "AlchemicalWizardry.LowerGuardian", EntityRegistry.findGlobalUniqueEntityId(),0x40FF00, 0x0B610B);
+ RenderingRegistry.registerEntityRenderingHandler(EntityLowerGuardian.class, new RenderLowerGuardian(new ModelLowerGuardian(), 0.5F));
+ //EntityRegistry.registerGlobalEntityID(EntityBileDemon.class, "AlchemicalWizardry.BileDemon", EntityRegistry.findGlobalUniqueEntityId(),0x40FF00, 0x0B610B);
+ RenderingRegistry.registerEntityRenderingHandler(EntityBileDemon.class, new RenderBileDemon(new ModelBileDemon(), 1.5F));
+ //EntityRegistry.registerGlobalEntityID(EntityWingedFireDemon.class, "AlchemicalWizardry.WingedFireDemon", EntityRegistry.findGlobalUniqueEntityId(),0x40FF00, 0x0B610B);
+ RenderingRegistry.registerEntityRenderingHandler(EntityWingedFireDemon.class, new RenderWingedFireDemon(new ModelWingedFireDemon(), 1.0F));
+ //EntityRegistry.registerGlobalEntityID(EntitySmallEarthGolem.class, "AlchemicalWizardry.SmallEarthGolem", EntityRegistry.findGlobalUniqueEntityId(),0x40FF00, 0x0B610B);
+ RenderingRegistry.registerEntityRenderingHandler(EntitySmallEarthGolem.class, new RenderSmallEarthGolem(new ModelSmallEarthGolem(), 0.5F));
+ //EntityRegistry.registerGlobalEntityID(EntityIceDemon.class, "AlchemicalWizardry.IceDemon", EntityRegistry.findGlobalUniqueEntityId(),0x40FF00, 0x0B610B);
+ RenderingRegistry.registerEntityRenderingHandler(EntityIceDemon.class, new RenderIceDemon(new ModelIceDemon(), 0.5F));
+ // EntityRegistry.registerGlobalEntityID(EntityBoulderFist.class, "AlchemicalWizardry.BoulderFist", EntityRegistry.findGlobalUniqueEntityId(),0x40FF00, 0x0B610B);
+ RenderingRegistry.registerEntityRenderingHandler(EntityBoulderFist.class, new RenderBoulderFist(new ModelBoulderFist(), 0.5F));
+ //EntityRegistry.registerGlobalEntityID(EntityShade.class, "AlchemicalWizardry.Shade", EntityRegistry.findGlobalUniqueEntityId(),0x40FF00, 0x0B610B);
+ RenderingRegistry.registerEntityRenderingHandler(EntityShade.class, new RenderShade(new ModelShade(), 0.5F));
+ //EntityRegistry.registerGlobalEntityID(EntityAirElemental.class, "AlchemicalWizardry.AirElemental", EntityRegistry.findGlobalUniqueEntityId(),0x40FF00, 0x0B610B);
+ RenderingRegistry.registerEntityRenderingHandler(EntityAirElemental.class, new RenderElemental(new ModelElemental(), 0.5F));
+ //EntityRegistry.registerGlobalEntityID(EntityWaterElemental.class, "AlchemicalWizardry.WaterElemental", EntityRegistry.findGlobalUniqueEntityId(),0x40FF00, 0x0B610B);
+ RenderingRegistry.registerEntityRenderingHandler(EntityWaterElemental.class, new RenderElemental(new ModelElemental(), 0.5F));
+ //EntityRegistry.registerGlobalEntityID(EntityEarthElemental.class, "AlchemicalWizardry.EarthElemental", EntityRegistry.findGlobalUniqueEntityId(),0x40FF00, 0x0B610B);
+ RenderingRegistry.registerEntityRenderingHandler(EntityEarthElemental.class, new RenderElemental(new ModelElemental(), 0.5F));
+ //EntityRegistry.registerGlobalEntityID(EntityFireElemental.class, "AlchemicalWizardry.FireElemental", EntityRegistry.findGlobalUniqueEntityId(),0x40FF00, 0x0B610B);
+ RenderingRegistry.registerEntityRenderingHandler(EntityFireElemental.class, new RenderElemental(new ModelElemental(), 0.5F));
+ //EntityRegistry.registerGlobalEntityID(EntityShadeElemental.class, "AlchemicalWizardry.ShadeElemental", EntityRegistry.findGlobalUniqueEntityId(),0x40FF00, 0x0B610B);
+ RenderingRegistry.registerEntityRenderingHandler(EntityShadeElemental.class, new RenderElemental(new ModelElemental(), 0.5F));
+ //EntityRegistry.registerGlobalEntityID(EntityHolyElemental.class, "AlchemicalWizardry.HolyElemental", EntityRegistry.findGlobalUniqueEntityId(),0x40FF00, 0x0B610B);
+ RenderingRegistry.registerEntityRenderingHandler(EntityHolyElemental.class, new RenderElemental(new ModelElemental(), 0.5F));
+ ClientRegistry.bindTileEntitySpecialRenderer(TEAltar.class, new TEAltarRenderer());
+ ClientRegistry.bindTileEntitySpecialRenderer(TEPedestal.class, new RenderPedestal());
+ ClientRegistry.bindTileEntitySpecialRenderer(TEPlinth.class, new RenderPlinth());
+ ClientRegistry.bindTileEntitySpecialRenderer(TEWritingTable.class, new RenderWritingTable());
+ ClientRegistry.bindTileEntitySpecialRenderer(TEConduit.class, new RenderConduit());
+ ClientRegistry.bindTileEntitySpecialRenderer(TESpellEffectBlock.class, new RenderSpellEffectBlock());
+ ClientRegistry.bindTileEntitySpecialRenderer(TESpellEnhancementBlock.class, new RenderSpellEnhancementBlock());
+ ClientRegistry.bindTileEntitySpecialRenderer(TESpellParadigmBlock.class, new RenderSpellParadigmBlock());
+ ClientRegistry.bindTileEntitySpecialRenderer(TESpellModifierBlock.class, new RenderSpellModifierBlock());
+ ClientRegistry.bindTileEntitySpecialRenderer(TEReagentConduit.class, new RenderReagentConduit());
+ ClientRegistry.bindTileEntitySpecialRenderer(TEMasterStone.class, new RenderMasterStone());
+ ClientRegistry.bindTileEntitySpecialRenderer(TEAlchemicCalcinator.class, new RenderAlchemicCalcinator());
+ ClientRegistry.bindTileEntitySpecialRenderer(TEBellJar.class, new RenderCrystalBelljar());
+
+ //Item Renderer stuff
+ MinecraftForgeClient.registerItemRenderer(ItemBlock.getItemFromBlock(ModBlocks.blockConduit), new TEConduitItemRenderer());
+ MinecraftForgeClient.registerItemRenderer(ItemBlock.getItemFromBlock(ModBlocks.blockSpellEffect), new TESpellEffectBlockItemRenderer());
+ MinecraftForgeClient.registerItemRenderer(ItemBlock.getItemFromBlock(ModBlocks.blockSpellEnhancement), new TESpellEnhancementBlockItemRenderer());
+ MinecraftForgeClient.registerItemRenderer(ItemBlock.getItemFromBlock(ModBlocks.blockSpellParadigm), new TESpellParadigmBlockItemRenderer());
+ MinecraftForgeClient.registerItemRenderer(ItemBlock.getItemFromBlock(ModBlocks.blockSpellModifier), new TESpellModifierBlockItemRenderer());
+ MinecraftForgeClient.registerItemRenderer(ItemBlock.getItemFromBlock(ModBlocks.blockAlchemicCalcinator), new TEAlchemicalCalcinatorItemRenderer());
+ MinecraftForgeClient.registerItemRenderer(ItemBlock.getItemFromBlock(ModBlocks.blockCrystalBelljar), new TEBellJarItemRenderer());
+
+ //RenderingRegistry.registerEntityRenderingHandler(FireProjectile.class, new RenderFireProjectile());
+ //RenderingRegistry.registerBlockHandler(new AltarRenderer());
+
+ ShaderHelper.initShaders();
+ }
+
+ @Override
+ public World getClientWorld()
+ {
+ return FMLClientHandler.instance().getClient().theWorld;
+ }
+
+ @Override
+ public void InitRendering()
+ {
+
+ MinecraftForgeClient.registerItemRenderer(ItemBlock.getItemFromBlock(ModBlocks.blockAltar), new TEAltarItemRenderer());
+ //MinecraftForgeClient.registerItemRenderer(AlchemicalWizardry.blockWritingTable.blockID, new TEWritingTableItemRenderer());
+ }
+
+ @Override
+ public void registerEvents()
+ {
+ FMLCommonHandler.instance().bus().register(new ClientEventHandler());
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/client/renderer/ColourThreshold.java b/src-backup/main/java/WayofTime/alchemicalWizardry/client/renderer/ColourThreshold.java
new file mode 100644
index 00000000..f7ee748a
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/client/renderer/ColourThreshold.java
@@ -0,0 +1,49 @@
+package WayofTime.alchemicalWizardry.client.renderer;
+
+import java.util.List;
+/**
+ * This class is a utility class that was created by bspkrs.
+ * https://github.com/bspkrs/bspkrsCore/blob/master/src/main/java/bspkrs/client/util/ColorThreshold.java
+ */
+public class ColourThreshold implements Comparable
+{
+ public int threshold;
+ public String colorCode;
+
+ public ColourThreshold(int t, String c)
+ {
+ threshold = t;
+ colorCode = c;
+ }
+
+ @Override
+ public String toString()
+ {
+ return String.valueOf(threshold) + ", " + colorCode;
+ }
+
+ @Override
+ public int compareTo(ColourThreshold o)
+ {
+ if (this.threshold > o.threshold)
+ return 1;
+ else if (this.threshold < o.threshold)
+ return -1;
+ else
+ return 0;
+ }
+
+ /**
+ * Returns the colorCode attached to the first threshold in the list that is
+ * >= value. Expects that the list has been sorted by threshold ascending.
+ */
+ public static String getColorCode(List colorList, int value)
+ {
+ for (ColourThreshold ct : colorList)
+ if (value <= ct.threshold)
+ return ct.colorCode;
+
+ return "f";
+ }
+}
+
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/client/renderer/HUDElement.java b/src-backup/main/java/WayofTime/alchemicalWizardry/client/renderer/HUDElement.java
new file mode 100644
index 00000000..e597135f
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/client/renderer/HUDElement.java
@@ -0,0 +1,146 @@
+package WayofTime.alchemicalWizardry.client.renderer;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.RenderHelper;
+import net.minecraft.client.renderer.entity.RenderItem;
+import net.minecraft.item.ItemStack;
+
+import org.lwjgl.opengl.GL11;
+
+import WayofTime.alchemicalWizardry.BloodMagicConfiguration;
+
+public class HUDElement
+{
+ public final ItemStack itemStack;
+ public final int iconW;
+ public final int iconH;
+ public final int padW;
+ public final int value;
+ private int elementW;
+ private int elementH;
+ private String itemName = "";
+ private int itemNameW;
+ private String itemDamage = "";
+ private int itemDamageW;
+ private Minecraft mc = Minecraft.getMinecraft();
+
+ private static final int offset = 5;
+
+ public boolean enableItemName = false;
+ public boolean showValue = true;
+ public boolean showDamageOverlay = false;
+ public boolean showItemCount = false;
+
+ static RenderItem itemRenderer = new RenderItem();
+
+ public HUDElement(ItemStack itemStack, int iconW, int iconH, int padW, int value)
+ {
+ this.itemStack = itemStack;
+ this.iconW = iconW;
+ this.iconH = iconH;
+ this.padW = padW;
+ this.value = value;
+
+ initSize();
+ }
+
+ public int width()
+ {
+ return elementW;
+ }
+
+ public int height()
+ {
+ return elementH;
+ }
+
+ private void initSize()
+ {
+ elementH = enableItemName ? Math.max(Minecraft.getMinecraft().fontRenderer.FONT_HEIGHT * 2, iconH) :
+ Math.max(mc.fontRenderer.FONT_HEIGHT, iconH);
+
+ if (itemStack != null)
+ {
+ int damage = 1;
+ int maxDamage = 1;
+
+ if (showValue)
+ {
+ maxDamage = itemStack.getMaxDamage() + 1;
+ damage = maxDamage - itemStack.getItemDamageForDisplay();
+
+ boolean showSpecialValue = true;
+ boolean showValue = false;
+ boolean showPercent = false;
+
+ boolean showMaxDamage = true;
+ boolean thresholdPercent = true;
+
+ if(showSpecialValue)
+ {
+ itemDamage = "\247" + ColourThreshold.getColorCode(BloodMagicConfiguration.colorList,
+ (thresholdPercent ? damage * 100 / maxDamage : damage)) + this.value;
+ }
+ else if (showValue)
+ itemDamage = "\247" + ColourThreshold.getColorCode(BloodMagicConfiguration.colorList,
+ (thresholdPercent ? damage * 100 / maxDamage : damage)) + damage +
+ (showMaxDamage ? "/" + maxDamage : "");
+ else if (showPercent)
+ itemDamage = "\247" + ColourThreshold.getColorCode(BloodMagicConfiguration.colorList,
+ (thresholdPercent ? damage * 100 / maxDamage : damage)) +
+ (damage * 100 / maxDamage) + "%";
+ }
+
+ itemDamageW = mc.fontRenderer.getStringWidth(HUDUtils.stripCtrl(itemDamage));
+ elementW = padW + iconW + padW + itemDamageW + offset;
+
+ if (enableItemName)
+ {
+ itemName = itemStack.getDisplayName();
+ elementW = padW + iconW + padW +
+ Math.max(mc.fontRenderer.getStringWidth(HUDUtils.stripCtrl(itemName)), itemDamageW);
+ }
+
+ itemNameW = mc.fontRenderer.getStringWidth(HUDUtils.stripCtrl(itemName));
+ }
+ }
+
+ public void renderToHud(int x, int y)
+ {
+ GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
+ GL11.glEnable(32826 /* GL_RESCALE_NORMAL_EXT */);
+ RenderHelper.enableStandardItemLighting();
+ RenderHelper.enableGUIStandardItemLighting();
+ itemRenderer.zLevel = 200.0F;
+
+ //if (ArmorStatusHUD.alignMode.toLowerCase().contains("right"))
+ boolean toRight = true;
+ if(toRight)
+ {
+ itemRenderer.renderItemAndEffectIntoGUI(mc.fontRenderer, mc.getTextureManager(), itemStack, x - (iconW + padW), y);
+ HUDUtils.renderItemOverlayIntoGUI(mc.fontRenderer, itemStack, x - (iconW + padW), y, showDamageOverlay, showItemCount);
+
+ RenderHelper.disableStandardItemLighting();
+ GL11.glDisable(32826 /* GL_RESCALE_NORMAL_EXT */);
+ GL11.glDisable(GL11.GL_BLEND);
+
+ mc.fontRenderer.drawStringWithShadow(itemName + "\247r", x - (padW + iconW + padW) - itemNameW, y, 0xffffff);
+ mc.fontRenderer.drawStringWithShadow(itemDamage + "\247r", x - (padW + iconW + padW) - itemDamageW,
+ y + (enableItemName ? elementH / 2 : elementH / 4), 0xffffff);
+ }
+ else
+ {
+ itemRenderer.renderItemAndEffectIntoGUI(mc.fontRenderer, mc.getTextureManager(), itemStack, x, y);
+ HUDUtils.renderItemOverlayIntoGUI(mc.fontRenderer, itemStack, x, y, showDamageOverlay, showItemCount);
+
+ RenderHelper.disableStandardItemLighting();
+ GL11.glDisable(32826 /* GL_RESCALE_NORMAL_EXT */);
+ GL11.glDisable(GL11.GL_BLEND);
+
+ mc.fontRenderer.drawStringWithShadow(itemName + "\247r", x + iconW + padW, y, 0xffffff);
+ mc.fontRenderer.drawStringWithShadow(itemDamage + "\247r", x + iconW + padW,
+ y + (enableItemName ? elementH / 2 : elementH / 4), 0xffffff);
+ }
+ GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/client/renderer/HUDUtils.java b/src-backup/main/java/WayofTime/alchemicalWizardry/client/renderer/HUDUtils.java
new file mode 100644
index 00000000..08217699
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/client/renderer/HUDUtils.java
@@ -0,0 +1,272 @@
+package WayofTime.alchemicalWizardry.client.renderer;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.FontRenderer;
+import net.minecraft.client.renderer.OpenGlHelper;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Items;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ResourceLocation;
+
+import org.lwjgl.opengl.GL11;
+
+/**
+ * This class is a utility class that was created by bspkrs.
+ * https://github.com/bspkrs/bspkrsCore/blob/master/src/main/java/bspkrs/client/util/HUDUtils.java
+ */
+public final class HUDUtils
+{
+ private static int[] colorCodes = new int[] { 0, 170, 43520, 43690, 11141120, 11141290, 16755200, 11184810, 5592405, 5592575, 5635925, 5636095, 16733525, 16733695, 16777045, 16777215,
+ 0, 42, 10752, 10794, 2752512, 2752554, 2763264, 2763306, 1381653, 1381695, 1392405, 1392447, 4134165, 4134207, 4144917, 4144959 };
+
+ public static int getColorCode(char c, boolean isLighter)
+ {
+ return colorCodes[isLighter ? "0123456789abcdef".indexOf(c) : "0123456789abcdef".indexOf(c) + 16];
+ }
+
+ /**
+ * Draws a textured box of any size (smallest size is borderSize * 2 square) based on a fixed size textured box with continuous borders
+ * and filler. It is assumed that the desired texture ResourceLocation object has been bound using
+ * Minecraft.getMinecraft().getTextureManager().bindTexture(resourceLocation).
+ *
+ * @param x x axis offset
+ * @param y y axis offset
+ * @param u bound resource location image x offset
+ * @param v bound resource location image y offset
+ * @param width the desired box width
+ * @param height the desired box height
+ * @param textureWidth the width of the box texture in the resource location image
+ * @param textureHeight the height of the box texture in the resource location image
+ * @param borderSize the size of the box's borders
+ * @param zLevel the zLevel to draw at
+ */
+ public static void drawContinuousTexturedBox(int x, int y, int u, int v, int width, int height, int textureWidth, int textureHeight,
+ int borderSize, float zLevel)
+ {
+ drawContinuousTexturedBox(x, y, u, v, width, height, textureWidth, textureHeight, borderSize, borderSize, borderSize, borderSize, zLevel);
+ }
+
+ /**
+ * Draws a textured box of any size (smallest size is borderSize * 2 square) based on a fixed size textured box with continuous borders
+ * and filler. The provided ResourceLocation object will be bound using
+ * Minecraft.getMinecraft().getTextureManager().bindTexture(resourceLocation).
+ *
+ * @param res the ResourceLocation object that contains the desired image
+ * @param x x axis offset
+ * @param y y axis offset
+ * @param u bound resource location image x offset
+ * @param v bound resource location image y offset
+ * @param width the desired box width
+ * @param height the desired box height
+ * @param textureWidth the width of the box texture in the resource location image
+ * @param textureHeight the height of the box texture in the resource location image
+ * @param borderSize the size of the box's borders
+ * @param zLevel the zLevel to draw at
+ */
+ public static void drawContinuousTexturedBox(ResourceLocation res, int x, int y, int u, int v, int width, int height, int textureWidth, int textureHeight,
+ int borderSize, float zLevel)
+ {
+ drawContinuousTexturedBox(res, x, y, u, v, width, height, textureWidth, textureHeight, borderSize, borderSize, borderSize, borderSize, zLevel);
+ }
+
+ /**
+ * Draws a textured box of any size (smallest size is borderSize * 2 square) based on a fixed size textured box with continuous borders
+ * and filler. The provided ResourceLocation object will be bound using
+ * Minecraft.getMinecraft().getTextureManager().bindTexture(resourceLocation).
+ *
+ * @param res the ResourceLocation object that contains the desired image
+ * @param x x axis offset
+ * @param y y axis offset
+ * @param u bound resource location image x offset
+ * @param v bound resource location image y offset
+ * @param width the desired box width
+ * @param height the desired box height
+ * @param textureWidth the width of the box texture in the resource location image
+ * @param textureHeight the height of the box texture in the resource location image
+ * @param topBorder the size of the box's top border
+ * @param bottomBorder the size of the box's bottom border
+ * @param leftBorder the size of the box's left border
+ * @param rightBorder the size of the box's right border
+ * @param zLevel the zLevel to draw at
+ */
+ public static void drawContinuousTexturedBox(ResourceLocation res, int x, int y, int u, int v, int width, int height, int textureWidth, int textureHeight,
+ int topBorder, int bottomBorder, int leftBorder, int rightBorder, float zLevel)
+ {
+ Minecraft.getMinecraft().getTextureManager().bindTexture(res);
+ drawContinuousTexturedBox(x, y, u, v, width, height, textureWidth, textureHeight, topBorder, bottomBorder, leftBorder, rightBorder, zLevel);
+ }
+
+ /**
+ * Draws a textured box of any size (smallest size is borderSize * 2 square) based on a fixed size textured box with continuous borders
+ * and filler. It is assumed that the desired texture ResourceLocation object has been bound using
+ * Minecraft.getMinecraft().getTextureManager().bindTexture(resourceLocation).
+ *
+ * @param x x axis offset
+ * @param y y axis offset
+ * @param u bound resource location image x offset
+ * @param v bound resource location image y offset
+ * @param width the desired box width
+ * @param height the desired box height
+ * @param textureWidth the width of the box texture in the resource location image
+ * @param textureHeight the height of the box texture in the resource location image
+ * @param topBorder the size of the box's top border
+ * @param bottomBorder the size of the box's bottom border
+ * @param leftBorder the size of the box's left border
+ * @param rightBorder the size of the box's right border
+ * @param zLevel the zLevel to draw at
+ */
+ public static void drawContinuousTexturedBox(int x, int y, int u, int v, int width, int height, int textureWidth, int textureHeight,
+ int topBorder, int bottomBorder, int leftBorder, int rightBorder, float zLevel)
+ {
+ GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
+ GL11.glEnable(GL11.GL_BLEND);
+ OpenGlHelper.glBlendFunc(770, 771, 1, 0);
+ GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+
+ int fillerWidth = textureWidth - leftBorder - rightBorder;
+ int fillerHeight = textureHeight - topBorder - bottomBorder;
+ int canvasWidth = width - leftBorder - rightBorder;
+ int canvasHeight = height - topBorder - bottomBorder;
+ int xPasses = canvasWidth / fillerWidth;
+ int remainderWidth = canvasWidth % fillerWidth;
+ int yPasses = canvasHeight / fillerHeight;
+ int remainderHeight = canvasHeight % fillerHeight;
+
+ // Draw Border
+ // Top Left
+ drawTexturedModalRect(x, y, u, v, leftBorder, topBorder, zLevel);
+ // Top Right
+ drawTexturedModalRect(x + leftBorder + canvasWidth, y, u + leftBorder + fillerWidth, v, rightBorder, topBorder, zLevel);
+ // Bottom Left
+ drawTexturedModalRect(x, y + topBorder + canvasHeight, u, v + topBorder + fillerHeight, leftBorder, bottomBorder, zLevel);
+ // Bottom Right
+ drawTexturedModalRect(x + leftBorder + canvasWidth, y + topBorder + canvasHeight, u + leftBorder + fillerWidth, v + topBorder + fillerHeight, rightBorder, bottomBorder, zLevel);
+
+ for (int i = 0; i < xPasses + (remainderWidth > 0 ? 1 : 0); i++)
+ {
+ // Top Border
+ drawTexturedModalRect(x + leftBorder + (i * fillerWidth), y, u + leftBorder, v, (i == xPasses ? remainderWidth : fillerWidth), topBorder, zLevel);
+ // Bottom Border
+ drawTexturedModalRect(x + leftBorder + (i * fillerWidth), y + topBorder + canvasHeight, u + leftBorder, v + topBorder + fillerHeight, (i == xPasses ? remainderWidth : fillerWidth), bottomBorder, zLevel);
+
+ // Throw in some filler for good measure
+ for (int j = 0; j < yPasses + (remainderHeight > 0 ? 1 : 0); j++)
+ drawTexturedModalRect(x + leftBorder + (i * fillerWidth), y + topBorder + (j * fillerHeight), u + leftBorder, v + topBorder, (i == xPasses ? remainderWidth : fillerWidth), (j == yPasses ? remainderHeight : fillerHeight), zLevel);
+ }
+
+ // Side Borders
+ for (int j = 0; j < yPasses + (remainderHeight > 0 ? 1 : 0); j++)
+ {
+ // Left Border
+ drawTexturedModalRect(x, y + topBorder + (j * fillerHeight), u, v + topBorder, leftBorder, (j == yPasses ? remainderHeight : fillerHeight), zLevel);
+ // Right Border
+ drawTexturedModalRect(x + leftBorder + canvasWidth, y + topBorder + (j * fillerHeight), u + leftBorder + fillerWidth, v + topBorder, rightBorder, (j == yPasses ? remainderHeight : fillerHeight), zLevel);
+ }
+ }
+
+ public static void drawTexturedModalRect(int x, int y, int u, int v, int width, int height, float zLevel)
+ {
+ float var7 = 0.00390625F;
+ float var8 = 0.00390625F;
+ Tessellator tessellator = Tessellator.instance;
+ tessellator.startDrawingQuads();
+ tessellator.addVertexWithUV((x + 0), (y + height), zLevel, ((u + 0) * var7), ((v + height) * var8));
+ tessellator.addVertexWithUV((x + width), (y + height), zLevel, ((u + width) * var7), ((v + height) * var8));
+ tessellator.addVertexWithUV((x + width), (y + 0), zLevel, ((u + width) * var7), ((v + 0) * var8));
+ tessellator.addVertexWithUV((x + 0), (y + 0), zLevel, ((u + 0) * var7), ((v + 0) * var8));
+ tessellator.draw();
+ }
+
+ /**
+ * Renders the item's overlay information. Examples being stack count or damage on top of the item's image at the specified position.
+ */
+ public static void renderItemOverlayIntoGUI(FontRenderer fontRenderer, ItemStack itemStack, int x, int y)
+ {
+ renderItemOverlayIntoGUI(fontRenderer, itemStack, x, y, true, true);
+ }
+
+ /**
+ * Renders the item's overlay information. Examples being stack count or damage on top of the item's image at the specified position.
+ */
+ public static void renderItemOverlayIntoGUI(FontRenderer fontRenderer, ItemStack itemStack, int x, int y, boolean showDamageBar, boolean showCount)
+ {
+ if (itemStack != null && (showDamageBar || showCount))
+ {
+ if (itemStack.isItemDamaged() && showDamageBar)
+ {
+ int var11 = (int) Math.round(13.0D - itemStack.getItemDamageForDisplay() * 13.0D / itemStack.getMaxDamage());
+ int var7 = (int) Math.round(255.0D - itemStack.getItemDamageForDisplay() * 255.0D / itemStack.getMaxDamage());
+ GL11.glDisable(GL11.GL_LIGHTING);
+ GL11.glDisable(GL11.GL_DEPTH_TEST);
+ GL11.glDisable(GL11.GL_TEXTURE_2D);
+ Tessellator var8 = Tessellator.instance;
+ int var9 = 255 - var7 << 16 | var7 << 8;
+ int var10 = (255 - var7) / 4 << 16 | 16128;
+ renderQuad(var8, x + 2, y + 13, 13, 2, 0);
+ renderQuad(var8, x + 2, y + 13, 12, 1, var10);
+ renderQuad(var8, x + 2, y + 13, var11, 1, var9);
+ GL11.glEnable(GL11.GL_TEXTURE_2D);
+ GL11.glEnable(GL11.GL_LIGHTING);
+ GL11.glEnable(GL11.GL_DEPTH_TEST);
+ GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
+ }
+
+ if (showCount)
+ {
+ int count = 0;
+
+ if (itemStack.getMaxStackSize() > 1)
+ count = HUDUtils.countInInventory(Minecraft.getMinecraft().thePlayer, itemStack.getItem(), itemStack.getItemDamage());
+ else if (itemStack.getItem().equals(Items.bow))
+ count = HUDUtils.countInInventory(Minecraft.getMinecraft().thePlayer, Items.arrow);
+
+ if (count > 1)
+ {
+ String var6 = "" + count;
+ GL11.glDisable(GL11.GL_LIGHTING);
+ GL11.glDisable(GL11.GL_DEPTH_TEST);
+ fontRenderer.drawStringWithShadow(var6, x + 19 - 2 - fontRenderer.getStringWidth(var6), y + 6 + 3, 16777215);
+ GL11.glEnable(GL11.GL_LIGHTING);
+ GL11.glEnable(GL11.GL_DEPTH_TEST);
+ }
+ }
+ }
+ }
+
+ /**
+ * Adds a quad to the tesselator at the specified position with the set width and height and color. Args: tessellator, x, y, width,
+ * height, color
+ */
+ public static void renderQuad(Tessellator tessellator, int x, int y, int width, int height, int color)
+ {
+ tessellator.startDrawingQuads();
+ tessellator.setColorOpaque_I(color);
+ tessellator.addVertex((x + 0), (y + 0), 0.0D);
+ tessellator.addVertex((x + 0), (y + height), 0.0D);
+ tessellator.addVertex((x + width), (y + height), 0.0D);
+ tessellator.addVertex((x + width), (y + 0), 0.0D);
+ tessellator.draw();
+ }
+
+ public static int countInInventory(EntityPlayer player, Item item)
+ {
+ return countInInventory(player, item, -1);
+ }
+
+ public static int countInInventory(EntityPlayer player, Item item, int md)
+ {
+ int count = 0;
+ for (int i = 0; i < player.inventory.mainInventory.length; i++)
+ if (player.inventory.mainInventory[i] != null && item.equals(player.inventory.mainInventory[i].getItem()) && (md == -1 || player.inventory.mainInventory[i].getItemDamage() == md))
+ count += player.inventory.mainInventory[i].stackSize;
+ return count;
+ }
+
+ public static String stripCtrl(String s)
+ {
+ return s.replaceAll("(?i)\247[0-9a-fklmnor]", "");
+ }
+}
+
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/client/renderer/RenderHelper.java b/src-backup/main/java/WayofTime/alchemicalWizardry/client/renderer/RenderHelper.java
new file mode 100644
index 00000000..e9cfc87a
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/client/renderer/RenderHelper.java
@@ -0,0 +1,185 @@
+package WayofTime.alchemicalWizardry.client.renderer;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiChat;
+import net.minecraft.client.gui.ScaledResolution;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import org.lwjgl.opengl.GL11;
+
+import WayofTime.alchemicalWizardry.api.alchemy.energy.IAlchemyGoggles;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.IReagentHandler;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentContainerInfo;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentRegistry;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+
+public class RenderHelper
+{
+ public static boolean showEquippedItem = true;
+ public static boolean enableItemName = false;
+ public static boolean enabled = true;
+ public static boolean showInChat = true;
+
+ private static int xOffsetDefault = +50;
+ public static int xOffset = xOffsetDefault;
+ private static int yOffsetDefault = 2;
+ public static int yOffset = yOffsetDefault;
+ private static int yOffsetBottomCenterDefault = 41;
+ public static int yOffsetBottomCenter = yOffsetBottomCenterDefault;
+ private static boolean applyXOffsetToCenterDefault = true;
+ public static boolean applyXOffsetToCenter = applyXOffsetToCenterDefault;
+ private static boolean applyYOffsetToMiddleDefault = false;
+ public static boolean applyYOffsetToMiddle = applyYOffsetToMiddleDefault;
+
+ public static String listMode = "horizontal";
+ public static String alignMode = "bottomcenter";
+
+ private static ScaledResolution scaledResolution;
+
+ public static boolean onTickInGame(Minecraft mc)
+ {
+ if (enabled && (mc.inGameHasFocus || mc.currentScreen == null || (mc.currentScreen instanceof GuiChat && showInChat))
+ && !mc.gameSettings.showDebugInfo)
+ {
+ EntityPlayer player = mc.thePlayer;
+ World world = mc.theWorld;
+ if(SpellHelper.canPlayerSeeAlchemy(player))
+ {
+ GL11.glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
+ scaledResolution = new ScaledResolution(mc, mc.displayWidth, mc.displayHeight);
+ displayArmorStatus(mc);
+ GL11.glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
+ }
+
+ }
+
+ return true;
+ }
+
+ private static List getHUDElements(Minecraft mc)
+ {
+ List elements = new ArrayList();
+
+ MovingObjectPosition movingobjectposition = mc.objectMouseOver;
+ World world = mc.theWorld;
+
+ if (movingobjectposition == null)
+ {
+ return elements;
+ } else
+ {
+ if (movingobjectposition.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK)
+ {
+ int x = movingobjectposition.blockX;
+ int y = movingobjectposition.blockY;
+ int z = movingobjectposition.blockZ;
+
+ TileEntity tile = world.getTileEntity(x, y, z);
+
+ if(!(tile instanceof IReagentHandler))
+ {
+ return elements;
+ }
+
+ IReagentHandler relay = (IReagentHandler)tile;
+
+ ReagentContainerInfo[] infos = relay.getContainerInfo(ForgeDirection.getOrientation(movingobjectposition.sideHit));
+
+ if(infos != null)
+ {
+ for(ReagentContainerInfo info : infos)
+ {
+ if(info == null || info.reagent == null || info.reagent.reagent == null)
+ {
+ continue;
+ }
+
+ ItemStack itemStack = ReagentRegistry.getItemForReagent(info.reagent.reagent);
+
+ if (itemStack != null)
+ elements.add(new HUDElement(itemStack, 16, 16, 2, info.reagent.amount));
+ }
+ }
+ }
+ }
+
+ return elements;
+ }
+
+ private static int getX(int width)
+ {
+ if (alignMode.toLowerCase().contains("center"))
+ return scaledResolution.getScaledWidth() / 2 - width / 2 + (applyXOffsetToCenter ? xOffset : 0);
+ else if (alignMode.toLowerCase().contains("right"))
+ return scaledResolution.getScaledWidth() - width - xOffset;
+ else
+ return xOffset;
+ }
+
+ private static int getY(int rowCount, int height)
+ {
+ if (alignMode.toLowerCase().contains("middle"))
+ return (scaledResolution.getScaledHeight() / 2) - ((rowCount * height) / 2) + (applyYOffsetToMiddle ? yOffset : 0);
+ else if (alignMode.equalsIgnoreCase("bottomleft") || alignMode.equalsIgnoreCase("bottomright"))
+ return scaledResolution.getScaledHeight() - (rowCount * height) - yOffset;
+ else if (alignMode.equalsIgnoreCase("bottomcenter"))
+ return scaledResolution.getScaledHeight() - (rowCount * height) - yOffsetBottomCenter;
+ else
+ return yOffset;
+ }
+
+ private static int getElementsWidth(List elements)
+ {
+ int r = 0;
+ for (HUDElement he : elements)
+ r += he.width();
+
+ return r;
+ }
+
+ private static void displayArmorStatus(Minecraft mc)
+ {
+ List elements = getHUDElements(mc);
+
+ if (elements.size() > 0)
+ {
+ int yOffset = enableItemName ? 18 : 16;
+
+ if (listMode.equalsIgnoreCase("vertical"))
+ {
+ int yBase = getY(elements.size(), yOffset);
+
+ for (HUDElement e : elements)
+ {
+ e.renderToHud((alignMode.toLowerCase().contains("right") ? getX(0) : getX(e.width())), yBase);
+ yBase += yOffset;
+ }
+ }
+ else if (listMode.equalsIgnoreCase("horizontal"))
+ {
+ int totalWidth = getElementsWidth(elements);
+ int yBase = getY(1, yOffset);
+ int xBase = getX(totalWidth);
+ int prevX = 0;
+
+ for (HUDElement e : elements)
+ {
+ e.renderToHud(xBase + prevX + (alignMode.toLowerCase().contains("right") ? e.width() : 0), yBase);
+ prevX += (e.width());
+ }
+ }else if(listMode.equalsIgnoreCase("compound"))
+ {
+ //TODO
+ }
+ }
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/AlchemicalWizardryEventHooks.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/AlchemicalWizardryEventHooks.java
new file mode 100644
index 00000000..c3ed52af
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/AlchemicalWizardryEventHooks.java
@@ -0,0 +1,477 @@
+package WayofTime.alchemicalWizardry.common;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.IProjectile;
+import net.minecraft.entity.monster.EntityCreeper;
+import net.minecraft.entity.monster.EntityMob;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.PlayerCapabilities;
+import net.minecraft.entity.projectile.EntityArrow;
+import net.minecraft.entity.projectile.EntityThrowable;
+import net.minecraft.potion.Potion;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.Vec3;
+import net.minecraftforge.event.entity.living.EnderTeleportEvent;
+import net.minecraftforge.event.entity.living.LivingAttackEvent;
+import net.minecraftforge.event.entity.living.LivingEvent.LivingJumpEvent;
+import net.minecraftforge.event.entity.living.LivingEvent.LivingUpdateEvent;
+import net.minecraftforge.event.entity.living.LivingSpawnEvent.CheckSpawn;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.common.entity.projectile.EnergyBlastProjectile;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEMasterStone;
+import cpw.mods.fml.common.ObfuscationReflectionHelper;
+import cpw.mods.fml.common.eventhandler.Event.Result;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.common.gameevent.PlayerEvent.PlayerRespawnEvent;
+
+public class AlchemicalWizardryEventHooks
+{
+ public static Map playerFlightBuff = new HashMap();
+ public static Map playerBoostStepHeight = new HashMap();
+ public static List playersWith1Step = new ArrayList();
+
+ public static Map> respawnMap = new HashMap();
+ public static Map> forceSpawnMap = new HashMap();
+
+ @SubscribeEvent
+ public void onPlayerDamageEvent(LivingAttackEvent event)
+ {
+ if(event.source.isProjectile())
+ {
+ if (event.entityLiving.isPotionActive(AlchemicalWizardry.customPotionProjProt) && event.isCancelable())
+ {
+ event.setCanceled(true);
+ }
+ }
+ }
+
+ @SubscribeEvent
+ public void onLivingSpawnEvent(CheckSpawn event)
+ {
+ if(!(event.entityLiving instanceof EntityMob))
+ {
+ return;
+ }
+
+ String respawnRitual = "AW028SpawnWard";
+
+ Integer dimension = new Integer(event.world.provider.dimensionId);
+ if(respawnMap.containsKey(dimension))
+ {
+ List list = respawnMap.get(dimension);
+
+ if(list != null)
+ {
+ for(CoordAndRange coords : list)
+ {
+ TileEntity tile = event.world.getTileEntity(coords.xCoord, coords.yCoord, coords.zCoord);
+
+ if(tile instanceof TEMasterStone && ((TEMasterStone) tile).isRunning && ((TEMasterStone) tile).getCurrentRitual().equals(respawnRitual))
+ {
+ if(event.x > coords.xCoord-coords.horizRadius && event.x < coords.xCoord+coords.horizRadius && event.z > coords.zCoord-coords.horizRadius && event.z < coords.zCoord+coords.horizRadius && event.y > coords.yCoord-coords.vertRadius && event.y < coords.yCoord+coords.vertRadius)
+ {
+ switch(event.getResult())
+ {
+ case ALLOW:
+ event.setResult(Result.DEFAULT);
+ break;
+ case DEFAULT:
+ event.setResult(Result.DENY);
+ break;
+ case DENY:
+ break;
+ default:
+ break;
+ }
+ break;
+ }
+ }else
+ {
+ list.remove(coords);
+ }
+ }
+ }
+ }
+
+ if(event.entityLiving instanceof EntityCreeper)
+ {
+ return;
+ }
+
+ String forceSpawnRitual = "AW029VeilOfEvil";
+
+ if(forceSpawnMap.containsKey(dimension))
+ {
+ List list = forceSpawnMap.get(dimension);
+
+ if(list != null)
+ {
+ for(CoordAndRange coords : list)
+ {
+ TileEntity tile = event.world.getTileEntity(coords.xCoord, coords.yCoord, coords.zCoord);
+
+ if(tile instanceof TEMasterStone && ((TEMasterStone) tile).isRunning && ((TEMasterStone) tile).getCurrentRitual().equals(forceSpawnRitual))
+ {
+ if(event.x > coords.xCoord-coords.horizRadius && event.x < coords.xCoord+coords.horizRadius && event.z > coords.zCoord-coords.horizRadius && event.z < coords.zCoord+coords.horizRadius && event.y > coords.yCoord-coords.vertRadius && event.y < coords.yCoord+coords.vertRadius)
+ {
+ switch(event.getResult())
+ {
+ case ALLOW:
+ break;
+ case DEFAULT:
+ event.setResult(Result.ALLOW);
+ break;
+ case DENY:
+ event.setResult(Result.DEFAULT);
+ break;
+ default:
+ break;
+ }
+ break;
+ }
+ }else
+ {
+ list.remove(coords);
+ }
+ }
+ }
+ }
+ }
+
+ @SubscribeEvent
+ public void onPlayerRespawnEvent(PlayerRespawnEvent event)
+ {
+ if(AlchemicalWizardry.respawnWithDebuff)
+ {
+ event.player.addPotionEffect(new PotionEffect(AlchemicalWizardry.customPotionSoulFray.id, 20*60*5,0));
+ }
+ }
+
+ @SubscribeEvent
+ public void onLivingJumpEvent(LivingJumpEvent event)
+ {
+ if (event.entityLiving.isPotionActive(AlchemicalWizardry.customPotionBoost))
+ {
+ int i = event.entityLiving.getActivePotionEffect(AlchemicalWizardry.customPotionBoost).getAmplifier();
+ event.entityLiving.motionY += (0.1f) * (2 + i);
+ }
+
+ if(event.entityLiving.isPotionActive(AlchemicalWizardry.customPotionHeavyHeart))
+ {
+ event.entityLiving.motionY = 0;
+ }
+ }
+
+ @SubscribeEvent
+ public void onEndermanTeleportEvent(EnderTeleportEvent event)
+ {
+ if(event.entityLiving.isPotionActive(AlchemicalWizardry.customPotionPlanarBinding) && event.isCancelable())
+ {
+ event.setCanceled(true);
+ }
+ }
+
+ @SubscribeEvent
+ public void onEntityDamaged(LivingAttackEvent event)
+ {
+ EntityLivingBase entityAttacked = event.entityLiving;
+
+ if (entityAttacked.isPotionActive(AlchemicalWizardry.customPotionReciprocation))
+ {
+ Entity entityAttacking = event.source.getSourceOfDamage();
+
+ if (entityAttacking != null && entityAttacking instanceof EntityLivingBase)
+ {
+ int i = event.entityLiving.getActivePotionEffect(AlchemicalWizardry.customPotionReciprocation).getAmplifier();
+ float damageRecieve = event.ammount / 2 * (i + 1);
+ ((EntityLivingBase) entityAttacking).attackEntityFrom(DamageSource.generic, damageRecieve);
+ }
+ }
+
+ if(entityAttacked.isPotionActive(AlchemicalWizardry.customPotionFlameCloak))
+ {
+ int i = event.entityLiving.getActivePotionEffect(AlchemicalWizardry.customPotionFlameCloak).getAmplifier();
+
+ Entity entityAttacking = event.source.getSourceOfDamage();
+
+ if(entityAttacking != null && entityAttacking instanceof EntityLivingBase && !entityAttacking.isImmuneToFire() && !((EntityLivingBase)entityAttacking).isPotionActive(Potion.fireResistance))
+ {
+ entityAttacking.attackEntityFrom(DamageSource.inFire, 2*i+2);
+ entityAttacking.setFire(3);
+ }
+ }
+ }
+
+// @ForgeSubscribe
+// public void onFOVUpdate(FOVUpdateEvent event)
+// {
+// event.setResult(Result.DEFAULT);
+// }
+
+// @SubscribeEvent
+// public void onPlayerTickEnd(PlayerTickEvent event)
+// {
+// if(event.type.equals(Type.PLAYER) && event.phase.equals(TickEvent.Phase.END))
+// {
+// ObfuscationReflectionHelper.setPrivateValue(PlayerCapabilities.class, event.player.capabilities, Float.valueOf(0.1f), new String[]{"walkSpeed", "g", "field_75097_g"});
+// }
+// }
+
+ @SubscribeEvent
+ public void onEntityUpdate(LivingUpdateEvent event)
+ {
+ EntityLivingBase entityLiving = event.entityLiving;
+ double x = entityLiving.posX;
+ double y = entityLiving.posY;
+ double z = entityLiving.posZ;
+
+ Vec3 blockVector = SpellHelper.getEntityBlockVector(entityLiving);
+ int xPos = (int)(blockVector.xCoord);
+ int yPos = (int)(blockVector.yCoord);
+ int zPos = (int)(blockVector.zCoord);
+
+ if(entityLiving instanceof EntityPlayer)
+ {
+ ObfuscationReflectionHelper.setPrivateValue(PlayerCapabilities.class, ((EntityPlayer)event.entityLiving).capabilities, Float.valueOf(0.1f), new String[]{"walkSpeed", "g", "field_75097_g"});
+ }
+
+ if (entityLiving instanceof EntityPlayer && entityLiving.worldObj.isRemote)
+ {
+ EntityPlayer entityPlayer = (EntityPlayer) entityLiving;
+ boolean highStepListed = playersWith1Step.contains(entityPlayer.getDisplayName());
+ boolean hasHighStep = entityPlayer.isPotionActive(AlchemicalWizardry.customPotionBoost);
+
+ if (hasHighStep && !highStepListed)
+ {
+ playersWith1Step.add(SpellHelper.getUsername(entityPlayer));
+ }
+
+ if (!hasHighStep && highStepListed)
+ {
+ playersWith1Step.remove(SpellHelper.getUsername(entityPlayer));
+ entityPlayer.stepHeight = 0.5F;
+ }
+ }
+
+ if (event.entityLiving.isPotionActive(AlchemicalWizardry.customPotionFeatherFall))
+ {
+ event.entityLiving.fallDistance = 0;
+ }
+
+ if (event.entityLiving.isPotionActive(AlchemicalWizardry.customPotionDrowning))
+ {
+ int i = event.entityLiving.getActivePotionEffect(AlchemicalWizardry.customPotionDrowning).getAmplifier();
+
+ if (event.entityLiving.worldObj.getWorldTime() % ((int) (20 / (i + 1))) == 0)
+ {
+ event.entityLiving.attackEntityFrom(DamageSource.drown, 2);
+ event.entityLiving.hurtResistantTime = Math.min(event.entityLiving.hurtResistantTime, 20 / (i + 1));
+ }
+ }
+
+ if (event.entityLiving.isPotionActive(AlchemicalWizardry.customPotionBoost))
+ {
+ int i = event.entityLiving.getActivePotionEffect(AlchemicalWizardry.customPotionBoost).getAmplifier();
+ EntityLivingBase entity = event.entityLiving;
+ //if(!entity.isSneaking())
+ {
+ float percentIncrease = (i + 1) * 0.05f;
+
+ if (event.entityLiving instanceof EntityPlayer)
+ {
+ EntityPlayer entityPlayer = (EntityPlayer) event.entityLiving;
+ entityPlayer.stepHeight = 1.0f;
+
+ if((entityPlayer.onGround || entityPlayer.capabilities.isFlying) && entityPlayer.moveForward > 0F)
+ entityPlayer.moveFlying(0F, 1F, entityPlayer.capabilities.isFlying ? (percentIncrease/2.0f) : percentIncrease);
+ }
+ }
+ }
+
+ if (event.entityLiving.isPotionActive(AlchemicalWizardry.customPotionProjProt))
+ {
+ int i = event.entityLiving.getActivePotionEffect(AlchemicalWizardry.customPotionProjProt).getAmplifier();
+ EntityLivingBase entity = event.entityLiving;
+ int posX = (int) Math.round(entity.posX - 0.5f);
+ int posY = (int) Math.round(entity.posY);
+ int posZ = (int) Math.round(entity.posZ - 0.5f);
+ int d0 = (int)((i+1)*2.5);
+ AxisAlignedBB axisalignedbb = AxisAlignedBB.getBoundingBox(posX - 0.5, posY - 0.5, posZ - 0.5, posX + 0.5, posY + 0.5, posZ + 0.5).expand(d0, d0, d0);
+ List list = event.entityLiving.worldObj.getEntitiesWithinAABB(Entity.class, axisalignedbb);
+ Iterator iterator = list.iterator();
+ EntityLivingBase livingEntity;
+
+ while (iterator.hasNext())
+ {
+ Entity projectile = (Entity) iterator.next();
+
+ if (projectile == null)
+ {
+ continue;
+ }
+
+ if (!(projectile instanceof IProjectile))
+ {
+ continue;
+ }
+
+ Entity throwingEntity = null;
+
+ if (projectile instanceof EntityArrow)
+ {
+ throwingEntity = ((EntityArrow) projectile).shootingEntity;
+ } else if (projectile instanceof EnergyBlastProjectile)
+ {
+ throwingEntity = ((EnergyBlastProjectile) projectile).shootingEntity;
+ }else if(projectile instanceof EntityThrowable)
+ {
+ throwingEntity = ((EntityThrowable) projectile).getThrower();
+ }
+
+ if(throwingEntity != null && throwingEntity.equals(entity))
+ {
+ continue;
+ }
+
+ double delX = projectile.posX - entity.posX;
+ double delY = projectile.posY - entity.posY;
+ double delZ = projectile.posZ - entity.posZ;
+
+ if(throwingEntity != null)
+ {
+ delX = -projectile.posX + throwingEntity.posX;
+ delY = -projectile.posY + (throwingEntity.posY + throwingEntity.getEyeHeight());
+ delZ = -projectile.posZ + throwingEntity.posZ;
+ }
+
+ double curVel = Math.sqrt(delX * delX + delY * delY + delZ * delZ);
+
+ delX /= curVel;
+ delY /= curVel;
+ delZ /= curVel;
+ double newVel = Math.sqrt(projectile.motionX * projectile.motionX + projectile.motionY * projectile.motionY + projectile.motionZ * projectile.motionZ);
+ projectile.motionX = newVel * delX;
+ projectile.motionY = newVel * delY;
+ projectile.motionZ = newVel * delZ;
+ //TODO make this not affect player's projectiles
+ }
+ }
+
+ if (event.entityLiving.isPotionActive(AlchemicalWizardry.customPotionFlight))
+ {
+ if (event.entityLiving instanceof EntityPlayer)
+ {
+ EntityPlayer entityPlayer = (EntityPlayer) event.entityLiving;
+ String ownerName = SpellHelper.getUsername(entityPlayer);
+ playerFlightBuff.put(ownerName, true);
+ entityPlayer.capabilities.allowFlying = true;
+ //entityPlayer.sendPlayerAbilities();
+ }
+ } else
+ {
+ if (event.entityLiving instanceof EntityPlayer)
+ {
+ EntityPlayer entityPlayer = (EntityPlayer) event.entityLiving;
+ String ownerName = SpellHelper.getUsername(entityPlayer);
+
+ if (!playerFlightBuff.containsKey(ownerName))
+ {
+ playerFlightBuff.put(ownerName, false);
+ }
+
+ if (playerFlightBuff.get(ownerName))
+ {
+ playerFlightBuff.put(ownerName, false);
+
+ if (!entityPlayer.capabilities.isCreativeMode)
+ {
+ entityPlayer.capabilities.allowFlying = false;
+ entityPlayer.capabilities.isFlying = false;
+ entityPlayer.sendPlayerAbilities();
+ }
+ }
+ }
+ }
+
+ if(entityLiving.isPotionActive(AlchemicalWizardry.customPotionFlameCloak))
+ {
+ entityLiving.worldObj.spawnParticle("flame", x+SpellHelper.gaussian(1),y-1.3+SpellHelper.gaussian(0.3),z+SpellHelper.gaussian(1), 0, 0.06d, 0);
+
+ int i = event.entityLiving.getActivePotionEffect(AlchemicalWizardry.customPotionFlameCloak).getAmplifier();
+ double range = i*0.5;
+
+ List entities = SpellHelper.getEntitiesInRange(entityLiving.worldObj, x, y, z, range, range);
+ if(entities!=null)
+ {
+ for(Entity entity : entities)
+ {
+ if(!entity.equals(entityLiving)&&!entity.isImmuneToFire()&&!(entity instanceof EntityLivingBase && ((EntityLivingBase)entity).isPotionActive(Potion.fireResistance)))
+ {
+ entity.setFire(3);
+ }
+ }
+ }
+ }
+
+ if(entityLiving.isPotionActive(AlchemicalWizardry.customPotionIceCloak))
+ {
+ if(entityLiving.worldObj.getWorldTime()%2==0)
+ entityLiving.worldObj.spawnParticle("reddust", x+SpellHelper.gaussian(1),y-1.3+SpellHelper.gaussian(0.3),z+SpellHelper.gaussian(1), 0x74,0xbb,0xfb);
+
+ int r = event.entityLiving.getActivePotionEffect(AlchemicalWizardry.customPotionIceCloak).getAmplifier();
+ int horizRange = r+1;
+ int vertRange = 1;
+
+ if(!entityLiving.worldObj.isRemote)
+ {
+ for(int i=-horizRange; i<=horizRange;i++)
+ {
+ for(int k=-horizRange; k<=horizRange;k++)
+ {
+ for(int j=-vertRange-1; j<=vertRange-1; j++)
+ {
+ SpellHelper.freezeWaterBlock(entityLiving.worldObj, xPos+i, yPos+j, zPos+k);
+ }
+ }
+ }
+ }
+ }
+
+ if(entityLiving.isPotionActive(AlchemicalWizardry.customPotionHeavyHeart))
+ {
+ entityLiving.worldObj.spawnParticle("flame", x+SpellHelper.gaussian(1),y-1.3+SpellHelper.gaussian(0.3),z+SpellHelper.gaussian(1), 0, 0.06d, 0);
+
+ int i = event.entityLiving.getActivePotionEffect(AlchemicalWizardry.customPotionHeavyHeart).getAmplifier();
+ double decrease = 0.025*(i+1);
+
+ if(entityLiving.motionY>-0.9)
+ {
+ entityLiving.motionY-=decrease;
+ }
+ }
+
+ if(entityLiving.isPotionActive(AlchemicalWizardry.customPotionFireFuse))
+ {
+ entityLiving.worldObj.spawnParticle("flame", x+SpellHelper.gaussian(1),y-1.3+SpellHelper.gaussian(0.3),z+SpellHelper.gaussian(1), 0, 0.06d, 0);
+
+ int r = event.entityLiving.getActivePotionEffect(AlchemicalWizardry.customPotionFireFuse).getAmplifier();
+ int radius = r+1;
+
+ if(entityLiving.getActivePotionEffect(AlchemicalWizardry.customPotionFireFuse).getDuration()<=2)
+ {
+ entityLiving.worldObj.createExplosion(null, x, y, z, radius, false);
+ }
+ }
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/AlchemicalWizardryFuelHandler.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/AlchemicalWizardryFuelHandler.java
new file mode 100644
index 00000000..157237ab
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/AlchemicalWizardryFuelHandler.java
@@ -0,0 +1,72 @@
+package WayofTime.alchemicalWizardry.common;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.potion.Potion;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.server.MinecraftServer;
+import WayofTime.alchemicalWizardry.ModItems;
+import WayofTime.alchemicalWizardry.common.items.LavaCrystal;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+import cpw.mods.fml.common.IFuelHandler;
+
+public class AlchemicalWizardryFuelHandler implements IFuelHandler
+{
+ @Override
+ public int getBurnTime(ItemStack fuel)
+ {
+ ItemStack itemStack = fuel;
+ if(itemStack == null)
+ {
+ return 0;
+ }
+
+ Item fuelItem = itemStack.getItem();
+
+ if (fuelItem.equals(ModItems.lavaCrystal))
+ {
+ /*ItemStack newItem = new ItemStack(AlchemicalWizardry.lavaCrystal);
+ newItem.getItem().setDamage(newItem, 50);
+ fuel.getItem().setContainerItem(((LavaCrystal)newItem.getItem()).change());
+ */
+ LavaCrystal item = (LavaCrystal) fuel.getItem();
+
+ if (item.hasEnoughEssence(fuel))
+ {
+ return 200;
+ } else
+ {
+ NBTTagCompound tag = itemStack.stackTagCompound;
+
+ if (tag == null)
+ {
+ return 0;
+ }
+
+ if (MinecraftServer.getServer() == null)
+ {
+ return 0;
+ }
+
+ if (MinecraftServer.getServer().getConfigurationManager() == null)
+ {
+ return 0;
+ }
+
+ EntityPlayer owner = SpellHelper.getPlayerForUsername(tag.getString("ownerName"));
+
+ if (owner == null)
+ {
+ return 0;
+ }
+
+ owner.addPotionEffect(new PotionEffect(Potion.confusion.id, 80));
+ return 0;
+ }
+ }
+
+ return 0;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/AlchemicalWizardryTickHandler.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/AlchemicalWizardryTickHandler.java
new file mode 100644
index 00000000..40eaf0f1
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/AlchemicalWizardryTickHandler.java
@@ -0,0 +1,47 @@
+package WayofTime.alchemicalWizardry.common;
+
+import java.util.EnumSet;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.PlayerCapabilities;
+import net.minecraft.server.MinecraftServer;
+import cpw.mods.fml.common.ObfuscationReflectionHelper;
+
+@Deprecated
+public class AlchemicalWizardryTickHandler //implements ITickHandler
+{
+// public void tickStart(EnumSet type, Object... tickData)
+// {
+// }
+//
+// public EnumSet ticks()
+// {
+// return EnumSet.of(TickType.PLAYER);
+// }
+//
+// public String getLabel()
+// {
+// return "BloodMagic";
+// }
+//
+// public void tickEnd(EnumSet type, Object... tickData)
+// {
+// String[] usernames = MinecraftServer.getServer().getAllUsernames();
+//
+// if (usernames == null)
+// {
+// return;
+// }
+//
+// for (String userName : usernames)
+// {
+// EntityPlayer entityPlayer = MinecraftServer.getServer().getConfigurationManager().getPlayerForUsername(userName);
+//
+// if (entityPlayer != null)
+// {
+// ObfuscationReflectionHelper.setPrivateValue(PlayerCapabilities.class, entityPlayer.capabilities, Float.valueOf(0.1f), new String[]{"walkSpeed", "g", "field_75097_g"});
+// //entityPlayer.sendPlayerAbilities();
+// }
+// }
+// }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/ArmourComponent.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/ArmourComponent.java
new file mode 100644
index 00000000..fb4f155b
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/ArmourComponent.java
@@ -0,0 +1,23 @@
+package WayofTime.alchemicalWizardry.common;
+
+public class ArmourComponent
+{
+ private int xOff;
+ private int zOff;
+
+ public ArmourComponent(int xOff, int zOff)
+ {
+ this.xOff = xOff;
+ this.zOff = zOff;
+ }
+
+ public int getXOff()
+ {
+ return xOff;
+ }
+
+ public int getZOff()
+ {
+ return zOff;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/CommonProxy.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/CommonProxy.java
new file mode 100644
index 00000000..7135097c
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/CommonProxy.java
@@ -0,0 +1,94 @@
+package WayofTime.alchemicalWizardry.common;
+
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.common.entity.projectile.EnergyBlastProjectile;
+import WayofTime.alchemicalWizardry.common.entity.projectile.EntityBloodLightProjectile;
+import WayofTime.alchemicalWizardry.common.entity.projectile.EntityEnergyBazookaMainProjectile;
+import WayofTime.alchemicalWizardry.common.entity.projectile.EntityEnergyBazookaSecondaryProjectile;
+import WayofTime.alchemicalWizardry.common.entity.projectile.EntityMeteor;
+import WayofTime.alchemicalWizardry.common.entity.projectile.EntityParticleBeam;
+import WayofTime.alchemicalWizardry.common.entity.projectile.ExplosionProjectile;
+import WayofTime.alchemicalWizardry.common.entity.projectile.FireProjectile;
+import WayofTime.alchemicalWizardry.common.entity.projectile.HolyProjectile;
+import WayofTime.alchemicalWizardry.common.entity.projectile.IceProjectile;
+import WayofTime.alchemicalWizardry.common.entity.projectile.LightningBoltProjectile;
+import WayofTime.alchemicalWizardry.common.entity.projectile.MudProjectile;
+import WayofTime.alchemicalWizardry.common.entity.projectile.TeleportProjectile;
+import WayofTime.alchemicalWizardry.common.entity.projectile.WaterProjectile;
+import WayofTime.alchemicalWizardry.common.entity.projectile.WindGustProjectile;
+import WayofTime.alchemicalWizardry.common.spell.complex.EntitySpellProjectile;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEAltar;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEMasterStone;
+import cpw.mods.fml.common.registry.EntityRegistry;
+import cpw.mods.fml.common.registry.GameRegistry;
+
+public class CommonProxy
+{
+ public static String ITEMS_PNG = "/WayofTime/alchemicalWizardry/items.png";
+ public static String BLOCK_PNG = "/WayofTime/alchemicalWizardry/block.png";
+
+ // Client stuff
+ public void registerRenderers()
+ {
+ // Nothing here as the server doesn't render graphics!
+ }
+
+ public void registerEntities()
+ {
+ }
+
+ public World getClientWorld()
+ {
+ return null;
+ }
+
+ public void registerActions()
+ {
+ }
+
+ public void registerEvents()
+ {
+
+ }
+
+ public void registerSoundHandler()
+ {
+ // Nothing here as this is a server side proxy
+ }
+
+ public void registerTileEntities()
+ {
+ GameRegistry.registerTileEntity(TEAltar.class, "containerAltar");
+ GameRegistry.registerTileEntity(TEMasterStone.class, "containerMasterStone");
+ }
+
+ public void registerEntityTrackers()
+ {
+ EntityRegistry.registerModEntity(EnergyBlastProjectile.class, "energyBlastProjectile", 0, AlchemicalWizardry.instance, 128, 5, true);
+ EntityRegistry.registerModEntity(FireProjectile.class, "fireProjectile", 1, AlchemicalWizardry.instance, 128, 5, true);
+ EntityRegistry.registerModEntity(IceProjectile.class, "iceProjectile", 2, AlchemicalWizardry.instance, 128, 5, true);
+ EntityRegistry.registerModEntity(ExplosionProjectile.class, "explosionProjectile", 3, AlchemicalWizardry.instance, 128, 5, true);
+ EntityRegistry.registerModEntity(HolyProjectile.class, "holyProjectile", 4, AlchemicalWizardry.instance, 128, 5, true);
+ EntityRegistry.registerModEntity(WindGustProjectile.class, "windGustProjectile", 5, AlchemicalWizardry.instance, 128, 5, true);
+ EntityRegistry.registerModEntity(LightningBoltProjectile.class, "lightningBoltProjectile", 6, AlchemicalWizardry.instance, 128, 5, true);
+ EntityRegistry.registerModEntity(WaterProjectile.class, "waterProjectile", 7, AlchemicalWizardry.instance, 128, 5, true);
+ EntityRegistry.registerModEntity(MudProjectile.class, "mudProjectile", 8, AlchemicalWizardry.instance, 128, 5, true);
+ EntityRegistry.registerModEntity(TeleportProjectile.class, "teleportProjectile", 9, AlchemicalWizardry.instance, 128, 5, true);
+ EntityRegistry.registerModEntity(EntityEnergyBazookaMainProjectile.class, "energyBazookaMain", 10, AlchemicalWizardry.instance, 128, 3, true);
+ EntityRegistry.registerModEntity(EntityEnergyBazookaSecondaryProjectile.class, "energyBazookaSecondary", 11, AlchemicalWizardry.instance, 128, 3, true);
+ EntityRegistry.registerModEntity(EntityBloodLightProjectile.class, "bloodLightProjectile", 12, AlchemicalWizardry.instance, 128, 3, true);
+ EntityRegistry.registerModEntity(EntityMeteor.class, "meteor", 13, AlchemicalWizardry.instance, 120, 3, true);
+ EntityRegistry.registerModEntity(EntitySpellProjectile.class, "spellProjectile", 14, AlchemicalWizardry.instance, 128, 3, true);
+ EntityRegistry.registerModEntity(EntityParticleBeam.class, "particleBeam", 15, AlchemicalWizardry.instance, 120, 3, true);
+ }
+
+ public void registerTickHandlers()
+ {
+ }
+
+ public void InitRendering()
+ {
+ // TODO Auto-generated method stub
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/CoordAndRange.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/CoordAndRange.java
new file mode 100644
index 00000000..cb56ceb5
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/CoordAndRange.java
@@ -0,0 +1,25 @@
+package WayofTime.alchemicalWizardry.common;
+
+public class CoordAndRange
+{
+ public int xCoord;
+ public int yCoord;
+ public int zCoord;
+ public int horizRadius;
+ public int vertRadius;
+
+ public CoordAndRange(int x, int y, int z, int horiz, int vert)
+ {
+ this.xCoord = x;
+ this.yCoord = y;
+ this.zCoord = z;
+ this.horizRadius = horiz;
+ this.vertRadius = vert;
+ }
+
+ @Override
+ public boolean equals(Object o)
+ {
+ return o instanceof CoordAndRange ? ((CoordAndRange)o).xCoord == this.xCoord && ((CoordAndRange)o).yCoord == this.yCoord && ((CoordAndRange)o).zCoord == this.zCoord && ((CoordAndRange)o).horizRadius == this.horizRadius && ((CoordAndRange)o).vertRadius == this.vertRadius: false;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/EntityAIFly.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/EntityAIFly.java
new file mode 100644
index 00000000..dffc65cf
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/EntityAIFly.java
@@ -0,0 +1,5 @@
+package WayofTime.alchemicalWizardry.common;
+
+public class EntityAIFly
+{
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/EntityAITargetAggro.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/EntityAITargetAggro.java
new file mode 100644
index 00000000..2b6fb25a
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/EntityAITargetAggro.java
@@ -0,0 +1,24 @@
+package WayofTime.alchemicalWizardry.common;
+
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityDemon;
+import net.minecraft.entity.ai.EntityAINearestAttackableTarget;
+
+public class EntityAITargetAggro extends EntityAINearestAttackableTarget
+{
+ private EntityDemon theCreature;
+
+ public EntityAITargetAggro(EntityDemon par1EntityDemon, Class par2Class, int par3, boolean par4)
+ {
+ super(par1EntityDemon, par2Class, par3, par4);
+ this.theCreature = par1EntityDemon;
+ }
+
+ /**
+ * Returns whether the EntityAIBase should begin execution.
+ */
+ @Override
+ public boolean shouldExecute()
+ {
+ return theCreature.isAggro() && super.shouldExecute();
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/EntityAirElemental.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/EntityAirElemental.java
new file mode 100644
index 00000000..cc5ab8ed
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/EntityAirElemental.java
@@ -0,0 +1,33 @@
+package WayofTime.alchemicalWizardry.common;
+
+import ibxm.Player;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.monster.IMob;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityElemental;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+
+public class EntityAirElemental extends EntityElemental implements IMob
+{
+ public EntityAirElemental(World world)
+ {
+ super(world, AlchemicalWizardry.entityAirElementalID);
+ }
+
+ public void inflictEffectOnEntity(Entity target)
+ {
+ if (target instanceof EntityPlayer)
+ {
+ SpellHelper.setPlayerSpeedFromServer((EntityPlayer)target, target.motionX, target.motionY + 3, target.motionZ);
+ ((EntityLivingBase) target).addPotionEffect(new PotionEffect(AlchemicalWizardry.customPotionInhibit.id, 150, 0));
+ } else if (target instanceof EntityLivingBase)
+ {
+ ((EntityLivingBase) target).motionY += 3.0D;
+ ((EntityLivingBase) target).addPotionEffect(new PotionEffect(AlchemicalWizardry.customPotionInhibit.id, 150, 0));
+ }
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/IBindingAgent.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/IBindingAgent.java
new file mode 100644
index 00000000..534d4b68
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/IBindingAgent.java
@@ -0,0 +1,6 @@
+package WayofTime.alchemicalWizardry.common;
+
+public interface IBindingAgent
+{
+ public abstract float getSuccessRateForPotionNumber(int potionEffects);
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/ICatalyst.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/ICatalyst.java
new file mode 100644
index 00000000..230cd51c
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/ICatalyst.java
@@ -0,0 +1,8 @@
+package WayofTime.alchemicalWizardry.common;
+
+public interface ICatalyst
+{
+ public abstract int getCatalystLevel();
+
+ public abstract boolean isConcentration();
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/IDemon.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/IDemon.java
new file mode 100644
index 00000000..eab1d15e
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/IDemon.java
@@ -0,0 +1,10 @@
+package WayofTime.alchemicalWizardry.common;
+
+public interface IDemon
+{
+ public abstract void setSummonedConditions();
+
+ public boolean isAggro();
+
+ public void setAggro(boolean aggro);
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/IFillingAgent.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/IFillingAgent.java
new file mode 100644
index 00000000..2202a20d
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/IFillingAgent.java
@@ -0,0 +1,6 @@
+package WayofTime.alchemicalWizardry.common;
+
+public interface IFillingAgent
+{
+ public abstract int getFilledAmountForPotionNumber(int potionEffects);
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/Int3.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/Int3.java
new file mode 100644
index 00000000..a43776d9
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/Int3.java
@@ -0,0 +1,38 @@
+package WayofTime.alchemicalWizardry.common;
+
+import net.minecraft.nbt.NBTTagCompound;
+
+
+public class Int3
+{
+ public int xCoord;
+ public int yCoord;
+ public int zCoord;
+
+ public Int3(int xCoord, int yCoord, int zCoord)
+ {
+ this.xCoord = xCoord;
+ this.yCoord = yCoord;
+ this.zCoord = zCoord;
+ }
+
+ public static Int3 readFromNBT(NBTTagCompound tag)
+ {
+ return new Int3(tag.getInteger("xCoord"), tag.getInteger("yCoord"), tag.getInteger("zCoord"));
+ }
+
+ public NBTTagCompound writeToNBT(NBTTagCompound tag)
+ {
+ tag.setInteger("xCoord", xCoord);
+ tag.setInteger("yCoord", yCoord);
+ tag.setInteger("zCoord", zCoord);
+
+ return tag;
+ }
+
+ @Override
+ public boolean equals(Object o)
+ {
+ return o instanceof Int3 ? ((Int3)o).xCoord == this.xCoord && ((Int3)o).yCoord == this.yCoord && ((Int3)o).zCoord == this.zCoord : false;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/LifeBucketHandler.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/LifeBucketHandler.java
new file mode 100644
index 00000000..a7739d1b
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/LifeBucketHandler.java
@@ -0,0 +1,42 @@
+package WayofTime.alchemicalWizardry.common;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.World;
+import net.minecraftforge.event.entity.player.FillBucketEvent;
+import WayofTime.alchemicalWizardry.ModBlocks;
+import WayofTime.alchemicalWizardry.ModItems;
+import cpw.mods.fml.common.eventhandler.Event.Result;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+
+public class LifeBucketHandler
+{
+ @SubscribeEvent
+ public void onBucketFill(FillBucketEvent event)
+ {
+ ItemStack result = fillCustomBucket(event.world, event.target);
+
+ if (result == null)
+ {
+ return;
+ }
+
+ event.result = result;
+ event.setResult(Result.ALLOW);
+ }
+
+ public ItemStack fillCustomBucket(World world, MovingObjectPosition pos)
+ {
+ Block block = world.getBlock(pos.blockX, pos.blockY, pos.blockZ);
+
+ if (block!=null && (block.equals(ModBlocks.blockLifeEssence)) && world.getBlockMetadata(pos.blockX, pos.blockY, pos.blockZ) == 0)
+ {
+ world.setBlockToAir(pos.blockX, pos.blockY, pos.blockZ);
+ return new ItemStack(ModItems.bucketLife);
+ } else
+ {
+ return null;
+ }
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/LifeEssence.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/LifeEssence.java
new file mode 100644
index 00000000..22ede879
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/LifeEssence.java
@@ -0,0 +1,28 @@
+package WayofTime.alchemicalWizardry.common;
+
+import net.minecraftforge.fluids.Fluid;
+
+public class LifeEssence extends Fluid
+{
+ public LifeEssence(String fluidName)
+ {
+ super(fluidName);
+ //setUnlocalizedName("lifeEssence");
+ //setBlockID(id);
+ this.setDensity(2000);
+ this.setViscosity(2000);
+ //this.setFlowingIcon(flowingIcon)
+ }
+
+ @Override
+ public int getColor()
+ {
+ return 0xEEEEEE;
+ }
+
+ @Override
+ public String getLocalizedName()
+ {
+ return "Life Essence";
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/ModLivingDropsEvent.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/ModLivingDropsEvent.java
new file mode 100644
index 00000000..3659dbfe
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/ModLivingDropsEvent.java
@@ -0,0 +1,36 @@
+package WayofTime.alchemicalWizardry.common;
+
+import net.minecraft.entity.passive.EntityAnimal;
+import net.minecraft.potion.Potion;
+import net.minecraft.potion.PotionEffect;
+import net.minecraftforge.event.entity.living.LivingDropsEvent;
+import WayofTime.alchemicalWizardry.ModItems;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+
+public class ModLivingDropsEvent
+{
+ public static double rand;
+
+ @SubscribeEvent
+ public void onEntityDrop(LivingDropsEvent event)
+ {
+ if (event.source.getDamageType().equals("player"))
+ {
+ rand = Math.random();
+
+ if (!(event.entityLiving instanceof EntityAnimal))
+ {
+ PotionEffect effect = event.entityLiving.getActivePotionEffect(Potion.weakness);
+
+ if (effect != null)
+ {
+ if (effect.getAmplifier() >= 2)
+ if (rand < 0.50d)
+ {
+ event.entityLiving.dropItem(ModItems.weakBloodShard, 1);
+ }
+ }
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/NewPacketHandler.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/NewPacketHandler.java
new file mode 100644
index 00000000..1d526216
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/NewPacketHandler.java
@@ -0,0 +1,964 @@
+package WayofTime.alchemicalWizardry.common;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.SimpleChannelInboundHandler;
+
+import java.util.EnumMap;
+import java.util.LinkedList;
+import java.util.List;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.network.Packet;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.ColourAndCoords;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEAltar;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEMasterStone;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEOrientable;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEPedestal;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEPlinth;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEReagentConduit;
+import WayofTime.alchemicalWizardry.common.tileEntity.TESocket;
+import WayofTime.alchemicalWizardry.common.tileEntity.TETeleposer;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEWritingTable;
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.network.FMLEmbeddedChannel;
+import cpw.mods.fml.common.network.FMLIndexedMessageToMessageCodec;
+import cpw.mods.fml.common.network.FMLOutboundHandler;
+import cpw.mods.fml.common.network.NetworkRegistry;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+/**
+* Handles the packet wrangling for IronChest
+* @author cpw
+*
+*/
+public enum NewPacketHandler
+{
+ INSTANCE;
+
+ /**
+ * Our channel "pair" from {@link NetworkRegistry}
+ */
+ private EnumMap channels;
+
+
+ /**
+ * Make our packet handler, and add an {@link IronChestCodec} always
+ */
+ private NewPacketHandler()
+ {
+ // request a channel pair for IronChest from the network registry
+ // Add the IronChestCodec as a member of both channel pipelines
+ this.channels = NetworkRegistry.INSTANCE.newChannel("BloodMagic", new TEAltarCodec());
+ if (FMLCommonHandler.instance().getSide() == Side.CLIENT)
+ {
+ addClientHandler();
+ }
+ }
+
+ @SideOnly(Side.CLIENT)
+ private void addClientHandler()
+ {
+ FMLEmbeddedChannel clientChannel = this.channels.get(Side.CLIENT);
+
+ String tileAltarCodec = clientChannel.findChannelHandlerNameForType(TEAltarCodec.class);
+ clientChannel.pipeline().addAfter(tileAltarCodec, "TEAltarHandler", new TEAltarMessageHandler());
+ clientChannel.pipeline().addAfter(tileAltarCodec, "TEOrientableHandler", new TEOrientableMessageHandler());
+ clientChannel.pipeline().addAfter(tileAltarCodec, "TEPedestalHandler", new TEPedestalMessageHandler());
+ clientChannel.pipeline().addAfter(tileAltarCodec, "TEPlinthHandler", new TEPlinthMessageHandler());
+ clientChannel.pipeline().addAfter(tileAltarCodec, "TESocketHandler", new TESocketMessageHandler());
+ clientChannel.pipeline().addAfter(tileAltarCodec, "TETeleposerHandler", new TETeleposerMessageHandler());
+ clientChannel.pipeline().addAfter(tileAltarCodec, "TEWritingTableHandler", new TEWritingTableMessageHandler());
+ clientChannel.pipeline().addAfter(tileAltarCodec, "ParticleHandler", new ParticleMessageHandler());
+ clientChannel.pipeline().addAfter(tileAltarCodec, "VelocityHandler", new VelocityMessageHandler());
+ clientChannel.pipeline().addAfter(tileAltarCodec, "TEMasterStoneHandler", new TEMasterStoneMessageHandler());
+ clientChannel.pipeline().addAfter(tileAltarCodec, "TEReagentConduitHandler", new TEReagentConduitMessageHandler());
+ }
+
+
+ /**
+ * This class simply handles the {@link IronChestMessage} when it's received
+ * at the client side It can contain client only code, because it's only run
+ * on the client.
+ *
+ * @author cpw
+ *
+ */
+ private static class TEAltarMessageHandler extends SimpleChannelInboundHandler
+ {
+ @Override
+ protected void channelRead0(ChannelHandlerContext ctx, TEAltarMessage msg) throws Exception
+ {
+ World world = AlchemicalWizardry.proxy.getClientWorld();
+ TileEntity te = world.getTileEntity(msg.x, msg.y, msg.z);
+ if (te instanceof TEAltar)
+ {
+ TEAltar altar = (TEAltar) te;
+
+ altar.handlePacketData(msg.items, msg.fluids, msg.capacity);
+ }
+ }
+ }
+
+ private static class TEOrientableMessageHandler extends SimpleChannelInboundHandler
+ {
+ @Override
+ protected void channelRead0(ChannelHandlerContext ctx, TEOrientableMessage msg) throws Exception
+ {
+ World world = AlchemicalWizardry.proxy.getClientWorld();
+ TileEntity te = world.getTileEntity(msg.x, msg.y, msg.z);
+ if (te instanceof TEOrientable)
+ {
+ TEOrientable tile = (TEOrientable)te;
+
+ ((TEOrientable) te).setInputDirection(ForgeDirection.getOrientation(msg.input));
+ ((TEOrientable) te).setOutputDirection(ForgeDirection.getOrientation(msg.output));
+ }
+ }
+ }
+
+ private static class TEPedestalMessageHandler extends SimpleChannelInboundHandler
+ {
+ @Override
+ protected void channelRead0(ChannelHandlerContext ctx, TEPedestalMessage msg) throws Exception
+ {
+ World world = AlchemicalWizardry.proxy.getClientWorld();
+ TileEntity te = world.getTileEntity(msg.x, msg.y, msg.z);
+ if (te instanceof TEPedestal)
+ {
+ TEPedestal pedestal = (TEPedestal) te;
+
+ pedestal.handlePacketData(msg.items);
+ }
+ }
+ }
+
+ private static class TEPlinthMessageHandler extends SimpleChannelInboundHandler
+ {
+ @Override
+ protected void channelRead0(ChannelHandlerContext ctx, TEPlinthMessage msg) throws Exception
+ {
+ World world = AlchemicalWizardry.proxy.getClientWorld();
+ TileEntity te = world.getTileEntity(msg.x, msg.y, msg.z);
+ if (te instanceof TEPlinth)
+ {
+ TEPlinth Plinth = (TEPlinth) te;
+
+ Plinth.handlePacketData(msg.items);
+ }
+ }
+ }
+
+ private static class TESocketMessageHandler extends SimpleChannelInboundHandler
+ {
+ @Override
+ protected void channelRead0(ChannelHandlerContext ctx, TESocketMessage msg) throws Exception
+ {
+ World world = AlchemicalWizardry.proxy.getClientWorld();
+ TileEntity te = world.getTileEntity(msg.x, msg.y, msg.z);
+ if (te instanceof TESocket)
+ {
+ TESocket Socket = (TESocket) te;
+
+ Socket.handlePacketData(msg.items);
+ }
+ }
+ }
+
+ private static class TETeleposerMessageHandler extends SimpleChannelInboundHandler
+ {
+ @Override
+ protected void channelRead0(ChannelHandlerContext ctx, TETeleposerMessage msg) throws Exception
+ {
+ World world = AlchemicalWizardry.proxy.getClientWorld();
+ TileEntity te = world.getTileEntity(msg.x, msg.y, msg.z);
+ if (te instanceof TETeleposer)
+ {
+ TETeleposer Teleposer = (TETeleposer) te;
+
+ Teleposer.handlePacketData(msg.items);
+ }
+ }
+ }
+
+ private static class TEWritingTableMessageHandler extends SimpleChannelInboundHandler
+ {
+ @Override
+ protected void channelRead0(ChannelHandlerContext ctx, TEWritingTableMessage msg) throws Exception
+ {
+ World world = AlchemicalWizardry.proxy.getClientWorld();
+ TileEntity te = world.getTileEntity(msg.x, msg.y, msg.z);
+ if (te instanceof TEWritingTable)
+ {
+ TEWritingTable WritingTable = (TEWritingTable) te;
+
+ WritingTable.handlePacketData(msg.items);
+ }
+ }
+ }
+
+ private static class ParticleMessageHandler extends SimpleChannelInboundHandler
+ {
+ @Override
+ protected void channelRead0(ChannelHandlerContext ctx, ParticleMessage msg) throws Exception
+ {
+ World world = AlchemicalWizardry.proxy.getClientWorld();
+
+ world.spawnParticle(msg.particle, msg.xCoord, msg.yCoord, msg.zCoord, msg.xVel, msg.yVel, msg.zVel);
+ }
+ }
+
+ private static class VelocityMessageHandler extends SimpleChannelInboundHandler
+ {
+ @Override
+ protected void channelRead0(ChannelHandlerContext ctx, VelocityMessage msg) throws Exception
+ {
+ EntityPlayer player = Minecraft.getMinecraft().thePlayer;
+
+ if(player!=null)
+ {
+ player.motionX = msg.xVel;
+ player.motionY = msg.yVel;
+ player.motionZ = msg.zVel;
+ }
+ }
+ }
+
+ private static class TEMasterStoneMessageHandler extends SimpleChannelInboundHandler
+ {
+ @Override
+ protected void channelRead0(ChannelHandlerContext ctx, TEMasterStoneMessage msg) throws Exception
+ {
+ World world = AlchemicalWizardry.proxy.getClientWorld();
+ TileEntity te = world.getTileEntity(msg.x, msg.y, msg.z);
+ if (te instanceof TEMasterStone)
+ {
+ TEMasterStone masterStone = (TEMasterStone) te;
+
+ masterStone.setCurrentRitual(msg.ritual);
+ masterStone.isRunning = msg.isRunning;
+ }
+ }
+ }
+
+ private static class TEReagentConduitMessageHandler extends SimpleChannelInboundHandler
+ {
+ @Override
+ protected void channelRead0(ChannelHandlerContext ctx, TEReagentConduitMessage msg) throws Exception
+ {
+ World world = AlchemicalWizardry.proxy.getClientWorld();
+ TileEntity te = world.getTileEntity(msg.x, msg.y, msg.z);
+ if (te instanceof TEReagentConduit)
+ {
+ TEReagentConduit reagentConduit = (TEReagentConduit) te;
+
+ reagentConduit.destinationList = msg.destinationList;
+ }
+ }
+ }
+
+ public static class BMMessage
+ {
+ int index;
+ }
+
+ public static class TEAltarMessage extends BMMessage
+ {
+ int x;
+ int y;
+ int z;
+
+ int[] items;
+ int[] fluids;
+ int capacity;
+ }
+
+ public static class TEOrientableMessage extends BMMessage
+ {
+ int x;
+ int y;
+ int z;
+
+ int input;
+ int output;
+ }
+
+ public static class TEPedestalMessage extends BMMessage
+ {
+ int x;
+ int y;
+ int z;
+
+ int[] items;
+ }
+
+ public static class TEPlinthMessage extends BMMessage
+ {
+ int x;
+ int y;
+ int z;
+
+ int[] items;
+ }
+
+ public static class TESocketMessage extends BMMessage
+ {
+ int x;
+ int y;
+ int z;
+
+ int[] items;
+ }
+
+ public static class TETeleposerMessage extends BMMessage
+ {
+ int x;
+ int y;
+ int z;
+
+ int[] items;
+ }
+
+ public static class TEWritingTableMessage extends BMMessage
+ {
+ int x;
+ int y;
+ int z;
+
+ int[] items;
+ }
+
+ public static class ParticleMessage extends BMMessage
+ {
+ String particle;
+
+ double xCoord;
+ double yCoord;
+ double zCoord;
+
+ double xVel;
+ double yVel;
+ double zVel;
+ }
+
+ public static class VelocityMessage extends BMMessage
+ {
+ double xVel;
+ double yVel;
+ double zVel;
+ }
+
+ public static class TEMasterStoneMessage extends BMMessage
+ {
+ int x;
+ int y;
+ int z;
+
+ String ritual;
+ boolean isRunning;
+ }
+
+ public static class TEReagentConduitMessage extends BMMessage
+ {
+ int x;
+ int y;
+ int z;
+
+ List destinationList;
+ }
+
+ private class TEAltarCodec extends FMLIndexedMessageToMessageCodec
+ {
+ public TEAltarCodec()
+ {
+ addDiscriminator(0, TEAltarMessage.class);
+ addDiscriminator(1, TEOrientableMessage.class);
+ addDiscriminator(2, TEPedestalMessage.class);
+ addDiscriminator(3, TEPlinthMessage.class);
+ addDiscriminator(4, TESocketMessage.class);
+ addDiscriminator(5, TETeleposerMessage.class);
+ addDiscriminator(6, TEWritingTableMessage.class);
+ addDiscriminator(7, ParticleMessage.class);
+ addDiscriminator(8, VelocityMessage.class);
+ addDiscriminator(9, TEMasterStoneMessage.class);
+ addDiscriminator(10, TEReagentConduitMessage.class);
+ }
+
+ @Override
+ public void encodeInto(ChannelHandlerContext ctx, BMMessage msg, ByteBuf target) throws Exception
+ {
+ target.writeInt(msg.index);
+
+ switch(msg.index)
+ {
+ case 0:
+ target.writeInt(((TEAltarMessage)msg).x);
+ target.writeInt(((TEAltarMessage)msg).y);
+ target.writeInt(((TEAltarMessage)msg).z);
+
+ target.writeBoolean(((TEAltarMessage)msg).items != null);
+ if (((TEAltarMessage)msg).items != null)
+ {
+ int[] items = ((TEAltarMessage)msg).items;
+ for (int j = 0; j < items.length; j++)
+ {
+ int i = items[j];
+ target.writeInt(i);
+ }
+ }
+
+ target.writeBoolean(((TEAltarMessage)msg).fluids != null);
+ if(((TEAltarMessage)msg).fluids != null)
+ {
+ int[] fluids = ((TEAltarMessage)msg).fluids;
+ for (int j = 0; j < fluids.length; j++)
+ {
+ int i = fluids[j];
+ target.writeInt(i);
+ }
+ }
+
+ target.writeInt(((TEAltarMessage)msg).capacity);
+
+ break;
+
+ case 1:
+ target.writeInt(((TEOrientableMessage)msg).x);
+ target.writeInt(((TEOrientableMessage)msg).y);
+ target.writeInt(((TEOrientableMessage)msg).z);
+
+ target.writeInt(((TEOrientableMessage)msg).input);
+ target.writeInt(((TEOrientableMessage)msg).output);
+
+ break;
+
+ case 2:
+ target.writeInt(((TEPedestalMessage)msg).x);
+ target.writeInt(((TEPedestalMessage)msg).y);
+ target.writeInt(((TEPedestalMessage)msg).z);
+
+ target.writeBoolean(((TEPedestalMessage)msg).items != null);
+ if (((TEPedestalMessage)msg).items != null)
+ {
+ int[] items = ((TEPedestalMessage)msg).items;
+ for (int j = 0; j < items.length; j++)
+ {
+ int i = items[j];
+ target.writeInt(i);
+ }
+ }
+
+ break;
+
+ case 3:
+ target.writeInt(((TEPlinthMessage)msg).x);
+ target.writeInt(((TEPlinthMessage)msg).y);
+ target.writeInt(((TEPlinthMessage)msg).z);
+
+ target.writeBoolean(((TEPlinthMessage)msg).items != null);
+ if (((TEPlinthMessage)msg).items != null)
+ {
+ int[] items = ((TEPlinthMessage)msg).items;
+ for (int j = 0; j < items.length; j++)
+ {
+ int i = items[j];
+ target.writeInt(i);
+ }
+ }
+
+ break;
+
+ case 4:
+ target.writeInt(((TESocketMessage)msg).x);
+ target.writeInt(((TESocketMessage)msg).y);
+ target.writeInt(((TESocketMessage)msg).z);
+
+ target.writeBoolean(((TESocketMessage)msg).items != null);
+ if (((TESocketMessage)msg).items != null)
+ {
+ int[] items = ((TESocketMessage)msg).items;
+ for (int j = 0; j < items.length; j++)
+ {
+ int i = items[j];
+ target.writeInt(i);
+ }
+ }
+
+ break;
+
+ case 5:
+ target.writeInt(((TETeleposerMessage)msg).x);
+ target.writeInt(((TETeleposerMessage)msg).y);
+ target.writeInt(((TETeleposerMessage)msg).z);
+
+ target.writeBoolean(((TETeleposerMessage)msg).items != null);
+ if (((TETeleposerMessage)msg).items != null)
+ {
+ int[] items = ((TETeleposerMessage)msg).items;
+ for (int j = 0; j < items.length; j++)
+ {
+ int i = items[j];
+ target.writeInt(i);
+ }
+ }
+
+ break;
+
+ case 6:
+ target.writeInt(((TEWritingTableMessage)msg).x);
+ target.writeInt(((TEWritingTableMessage)msg).y);
+ target.writeInt(((TEWritingTableMessage)msg).z);
+
+ target.writeBoolean(((TEWritingTableMessage)msg).items != null);
+ if (((TEWritingTableMessage)msg).items != null)
+ {
+ int[] items = ((TEWritingTableMessage)msg).items;
+ for (int j = 0; j < items.length; j++)
+ {
+ int i = items[j];
+ target.writeInt(i);
+ }
+ }
+
+ break;
+
+ case 7:
+ String str = ((ParticleMessage)msg).particle;
+ target.writeInt(str.length());
+ for(int i=0; i list = ((TEReagentConduitMessage)msg).destinationList;
+ target.writeInt(list.size());
+
+ for(ColourAndCoords colourSet : list)
+ {
+ target.writeInt(colourSet.colourRed);
+ target.writeInt(colourSet.colourGreen);
+ target.writeInt(colourSet.colourBlue);
+ target.writeInt(colourSet.colourIntensity);
+ target.writeInt(colourSet.xCoord);
+ target.writeInt(colourSet.yCoord);
+ target.writeInt(colourSet.zCoord);
+ }
+
+ break;
+ }
+ }
+
+
+ @Override
+ public void decodeInto(ChannelHandlerContext ctx, ByteBuf dat, BMMessage msg)
+ {
+ int index = dat.readInt();
+
+ switch(index)
+ {
+ case 0:
+ ((TEAltarMessage)msg).x = dat.readInt();
+ ((TEAltarMessage)msg).y = dat.readInt();
+ ((TEAltarMessage)msg).z = dat.readInt();
+ boolean hasStacks = dat.readBoolean();
+
+ ((TEAltarMessage)msg).items = new int[TEAltar.sizeInv*3];
+ if (hasStacks)
+ {
+ ((TEAltarMessage)msg).items = new int[TEAltar.sizeInv*3];
+ for (int i = 0; i < ((TEAltarMessage)msg).items.length; i++)
+ {
+ ((TEAltarMessage)msg).items[i] = dat.readInt();
+ }
+ }
+
+ boolean hasFluids = dat.readBoolean();
+ ((TEAltarMessage)msg).fluids = new int[6];
+ if(hasFluids)
+ for (int i = 0; i < ((TEAltarMessage)msg).fluids.length; i++)
+ {
+ ((TEAltarMessage)msg).fluids[i] = dat.readInt();
+ }
+
+ ((TEAltarMessage)msg).capacity = dat.readInt();
+
+ break;
+
+ case 1:
+ ((TEOrientableMessage)msg).x = dat.readInt();
+ ((TEOrientableMessage)msg).y = dat.readInt();
+ ((TEOrientableMessage)msg).z = dat.readInt();
+
+ ((TEOrientableMessage)msg).input = dat.readInt();
+ ((TEOrientableMessage)msg).output = dat.readInt();
+
+ break;
+
+ case 2:
+ ((TEPedestalMessage)msg).x = dat.readInt();
+ ((TEPedestalMessage)msg).y = dat.readInt();
+ ((TEPedestalMessage)msg).z = dat.readInt();
+
+ boolean hasStacks1 = dat.readBoolean();
+
+ ((TEPedestalMessage)msg).items = new int[TEPedestal.sizeInv*3];
+ if (hasStacks1)
+ {
+ ((TEPedestalMessage)msg).items = new int[TEPedestal.sizeInv*3];
+ for (int i = 0; i < ((TEPedestalMessage)msg).items.length; i++)
+ {
+ ((TEPedestalMessage)msg).items[i] = dat.readInt();
+ }
+ }
+
+ break;
+
+ case 3:
+ ((TEPlinthMessage)msg).x = dat.readInt();
+ ((TEPlinthMessage)msg).y = dat.readInt();
+ ((TEPlinthMessage)msg).z = dat.readInt();
+
+ boolean hasStacks2 = dat.readBoolean();
+
+ ((TEPlinthMessage)msg).items = new int[TEPlinth.sizeInv*3];
+ if (hasStacks2)
+ {
+ ((TEPlinthMessage)msg).items = new int[TEPlinth.sizeInv*3];
+ for (int i = 0; i < ((TEPlinthMessage)msg).items.length; i++)
+ {
+ ((TEPlinthMessage)msg).items[i] = dat.readInt();
+ }
+ }
+
+ break;
+
+ case 4:
+ ((TESocketMessage)msg).x = dat.readInt();
+ ((TESocketMessage)msg).y = dat.readInt();
+ ((TESocketMessage)msg).z = dat.readInt();
+
+ boolean hasStacks3 = dat.readBoolean();
+
+ ((TESocketMessage)msg).items = new int[TESocket.sizeInv*3];
+ if (hasStacks3)
+ {
+ ((TESocketMessage)msg).items = new int[TESocket.sizeInv*3];
+ for (int i = 0; i < ((TESocketMessage)msg).items.length; i++)
+ {
+ ((TESocketMessage)msg).items[i] = dat.readInt();
+ }
+ }
+
+ break;
+
+ case 5:
+ ((TETeleposerMessage)msg).x = dat.readInt();
+ ((TETeleposerMessage)msg).y = dat.readInt();
+ ((TETeleposerMessage)msg).z = dat.readInt();
+
+ boolean hasStacks4 = dat.readBoolean();
+
+ ((TETeleposerMessage)msg).items = new int[TETeleposer.sizeInv*3];
+ if (hasStacks4)
+ {
+ ((TETeleposerMessage)msg).items = new int[TETeleposer.sizeInv*3];
+ for (int i = 0; i < ((TETeleposerMessage)msg).items.length; i++)
+ {
+ ((TETeleposerMessage)msg).items[i] = dat.readInt();
+ }
+ }
+
+ break;
+
+ case 6:
+ ((TEWritingTableMessage)msg).x = dat.readInt();
+ ((TEWritingTableMessage)msg).y = dat.readInt();
+ ((TEWritingTableMessage)msg).z = dat.readInt();
+
+ boolean hasStacks5 = dat.readBoolean();
+
+ ((TEWritingTableMessage)msg).items = new int[TEWritingTable.sizeInv*3];
+ if (hasStacks5)
+ {
+ ((TEWritingTableMessage)msg).items = new int[TEWritingTable.sizeInv*3];
+ for (int i = 0; i < ((TEWritingTableMessage)msg).items.length; i++)
+ {
+ ((TEWritingTableMessage)msg).items[i] = dat.readInt();
+ }
+ }
+
+ break;
+
+ case 7:
+ int size = dat.readInt();
+ String str = "";
+
+ for (int i = 0; i < size; i++)
+ {
+ str = str + dat.readChar();
+ }
+
+ ((ParticleMessage)msg).particle = str;
+
+ ((ParticleMessage)msg).xCoord = dat.readDouble();
+ ((ParticleMessage)msg).yCoord = dat.readDouble();
+ ((ParticleMessage)msg).zCoord = dat.readDouble();
+
+ ((ParticleMessage)msg).xVel = dat.readDouble();
+ ((ParticleMessage)msg).yVel = dat.readDouble();
+ ((ParticleMessage)msg).zVel = dat.readDouble();
+
+ break;
+
+ case 8:
+ ((VelocityMessage)msg).xVel = dat.readDouble();
+ ((VelocityMessage)msg).yVel = dat.readDouble();
+ ((VelocityMessage)msg).zVel = dat.readDouble();
+
+ break;
+
+ case 9:
+ ((TEMasterStoneMessage)msg).x = dat.readInt();
+ ((TEMasterStoneMessage)msg).y = dat.readInt();
+ ((TEMasterStoneMessage)msg).z = dat.readInt();
+
+ int ritualStrSize = dat.readInt();
+ String ritual = "";
+
+ for (int i = 0; i < ritualStrSize; i++)
+ {
+ ritual = ritual + dat.readChar();
+ }
+
+ ((TEMasterStoneMessage)msg).ritual = ritual;
+ ((TEMasterStoneMessage)msg).isRunning = dat.readBoolean();
+
+ break;
+
+ case 10:
+ ((TEReagentConduitMessage)msg).x = dat.readInt();
+ ((TEReagentConduitMessage)msg).y = dat.readInt();
+ ((TEReagentConduitMessage)msg).z = dat.readInt();
+
+ int listSize = dat.readInt();
+
+ List list = new LinkedList();
+
+ for(int i=0; i < listSize; i++)
+ {
+ list.add(new ColourAndCoords(dat.readInt(), dat.readInt(), dat.readInt(), dat.readInt(), dat.readInt(), dat.readInt(), dat.readInt()));
+ }
+
+ ((TEReagentConduitMessage)msg).destinationList = list;
+
+ break;
+ }
+ }
+ }
+
+ //Packets to be obtained
+ public static Packet getPacket(TEAltar tileAltar)
+ {
+ TEAltarMessage msg = new TEAltarMessage();
+ msg.index = 0;
+ msg.x = tileAltar.xCoord;
+ msg.y = tileAltar.yCoord;
+ msg.z = tileAltar.zCoord;
+ msg.items = tileAltar.buildIntDataList();
+ msg.fluids = tileAltar.buildFluidList();
+ msg.capacity = tileAltar.getCapacity();
+
+ return INSTANCE.channels.get(Side.SERVER).generatePacketFrom(msg);
+ }
+
+ public static Packet getPacket(TEOrientable tileOrientable)
+ {
+ TEOrientableMessage msg = new TEOrientableMessage();
+ msg.index = 1;
+ msg.x = tileOrientable.xCoord;
+ msg.y = tileOrientable.yCoord;
+ msg.z = tileOrientable.zCoord;
+ msg.input = tileOrientable.getIntForForgeDirection(tileOrientable.getInputDirection());
+ msg.output = tileOrientable.getIntForForgeDirection(tileOrientable.getOutputDirection());
+
+ return INSTANCE.channels.get(Side.SERVER).generatePacketFrom(msg);
+ }
+
+ public static Packet getPacket(TEPedestal tilePedestal)
+ {
+ TEPedestalMessage msg = new TEPedestalMessage();
+ msg.index = 2;
+ msg.x = tilePedestal.xCoord;
+ msg.y = tilePedestal.yCoord;
+ msg.z = tilePedestal.zCoord;
+ msg.items = tilePedestal.buildIntDataList();
+
+ return INSTANCE.channels.get(Side.SERVER).generatePacketFrom(msg);
+ }
+
+ public static Packet getPacket(TEPlinth tilePlinth)
+ {
+ TEPlinthMessage msg = new TEPlinthMessage();
+ msg.index = 3;
+ msg.x = tilePlinth.xCoord;
+ msg.y = tilePlinth.yCoord;
+ msg.z = tilePlinth.zCoord;
+ msg.items = tilePlinth.buildIntDataList();
+
+ return INSTANCE.channels.get(Side.SERVER).generatePacketFrom(msg);
+ }
+
+ public static Packet getPacket(TESocket tileSocket)
+ {
+ TESocketMessage msg = new TESocketMessage();
+ msg.index = 4;
+ msg.x = tileSocket.xCoord;
+ msg.y = tileSocket.yCoord;
+ msg.z = tileSocket.zCoord;
+ msg.items = tileSocket.buildIntDataList();
+
+ return INSTANCE.channels.get(Side.SERVER).generatePacketFrom(msg);
+ }
+
+ public static Packet getPacket(TETeleposer tileTeleposer)
+ {
+ TETeleposerMessage msg = new TETeleposerMessage();
+ msg.index = 5;
+ msg.x = tileTeleposer.xCoord;
+ msg.y = tileTeleposer.yCoord;
+ msg.z = tileTeleposer.zCoord;
+ msg.items = tileTeleposer.buildIntDataList();
+
+ return INSTANCE.channels.get(Side.SERVER).generatePacketFrom(msg);
+ }
+
+ public static Packet getPacket(TEWritingTable tileWritingTable)
+ {
+ TEWritingTableMessage msg = new TEWritingTableMessage();
+ msg.index = 6;
+ msg.x = tileWritingTable.xCoord;
+ msg.y = tileWritingTable.yCoord;
+ msg.z = tileWritingTable.zCoord;
+ msg.items = tileWritingTable.buildIntDataList();
+
+ return INSTANCE.channels.get(Side.SERVER).generatePacketFrom(msg);
+ }
+
+ public static Packet getParticlePacket(String str, double xCoord, double yCoord, double zCoord, double xVel, double yVel, double zVel)
+ {
+ ParticleMessage msg = new ParticleMessage();
+ msg.index = 7;
+ msg.particle = str;
+ msg.xCoord = xCoord;
+ msg.yCoord = yCoord;
+ msg.zCoord = zCoord;
+ msg.xVel = xVel;
+ msg.yVel = yVel;
+ msg.zVel = zVel;
+
+ return INSTANCE.channels.get(Side.SERVER).generatePacketFrom(msg);
+ }
+
+ public static Packet getVelSettingPacket(double xVel, double yVel, double zVel)
+ {
+ VelocityMessage msg = new VelocityMessage();
+ msg.index = 8;
+ msg.xVel = xVel;
+ msg.yVel = yVel;
+ msg.zVel = zVel;
+
+ return INSTANCE.channels.get(Side.SERVER).generatePacketFrom(msg);
+ }
+
+ public static Packet getPacket(TEMasterStone tile)
+ {
+ TEMasterStoneMessage msg = new TEMasterStoneMessage();
+ msg.index = 9;
+ msg.x = tile.xCoord;
+ msg.y = tile.yCoord;
+ msg.z = tile.zCoord;
+
+ msg.ritual = tile.getCurrentRitual();
+ msg.isRunning = tile.isRunning;
+
+ return INSTANCE.channels.get(Side.SERVER).generatePacketFrom(msg);
+ }
+
+ public static Packet getPacket(TEReagentConduit tile)
+ {
+ TEReagentConduitMessage msg = new TEReagentConduitMessage();
+ msg.index = 10;
+ msg.x = tile.xCoord;
+ msg.y = tile.yCoord;
+ msg.z = tile.zCoord;
+
+ msg.destinationList = tile.destinationList;
+
+ return INSTANCE.channels.get(Side.SERVER).generatePacketFrom(msg);
+ }
+
+ public void sendTo(Packet message, EntityPlayerMP player)
+ {
+ this.channels.get(Side.SERVER).attr(FMLOutboundHandler.FML_MESSAGETARGET).set(FMLOutboundHandler.OutboundTarget.PLAYER);
+ this.channels.get(Side.SERVER).attr(FMLOutboundHandler.FML_MESSAGETARGETARGS).set(player);
+ this.channels.get(Side.SERVER).writeAndFlush(message);
+ }
+
+ public void sendToAll(Packet message)
+ {
+ this.channels.get(Side.SERVER).attr(FMLOutboundHandler.FML_MESSAGETARGET).set(FMLOutboundHandler.OutboundTarget.ALL);
+ this.channels.get(Side.SERVER).writeAndFlush(message);
+ }
+
+ public void sendToAllAround(Packet message, NetworkRegistry.TargetPoint point)
+ {
+ this.channels.get(Side.SERVER).attr(FMLOutboundHandler.FML_MESSAGETARGET).set(FMLOutboundHandler.OutboundTarget.ALLAROUNDPOINT);
+ this.channels.get(Side.SERVER).attr(FMLOutboundHandler.FML_MESSAGETARGETARGS).set(point);
+ this.channels.get(Side.SERVER).writeAndFlush(message);
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/PacketHandler.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/PacketHandler.java
new file mode 100644
index 00000000..48642e37
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/PacketHandler.java
@@ -0,0 +1,966 @@
+package WayofTime.alchemicalWizardry.common;
+
+import ibxm.Player;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.Random;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.DamageSource;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidStack;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.common.bloodAltarUpgrade.UpgradedAltars;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEAltar;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEOrientable;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEPedestal;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEPlinth;
+import WayofTime.alchemicalWizardry.common.tileEntity.TESocket;
+import WayofTime.alchemicalWizardry.common.tileEntity.TETeleposer;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEWritingTable;
+
+import com.google.common.io.ByteArrayDataInput;
+import com.google.common.io.ByteStreams;
+import com.jcraft.jogg.Packet;
+
+public class PacketHandler //implements IPacketHandler
+{
+// @Override
+// public void onPacketData(INetworkManager manager, Packet250CustomPayload packet, Player player)
+// {
+// if (packet.channel.equals("BloodAltar"))
+// {
+// ByteArrayDataInput dat = ByteStreams.newDataInput(packet.data);
+// int x = dat.readInt();
+// int y = dat.readInt();
+// int z = dat.readInt();
+// boolean hasStacks = dat.readByte() != 0;
+// int[] items = new int[0];
+//
+// if (hasStacks)
+// {
+// items = new int[1 * 3];
+//
+// for (int i = 0; i < items.length; i++)
+// {
+// items[i] = dat.readInt();
+// }
+// }
+//
+// int fluidIDMain = dat.readInt();
+// int fluidAmountMain = dat.readInt();
+// int fluidIDOutput = dat.readInt();
+// int fluidAmountOutput = dat.readInt();
+// int fluidIDInput = dat.readInt();
+// int fluidAmountInput = dat.readInt();
+// int capacity = dat.readInt();
+// World world = AlchemicalWizardry.proxy.getClientWorld();
+// TileEntity tileEntity = world.getBlockTileEntity(x, y, z);
+//
+// if (tileEntity instanceof TEAltar)
+// {
+// TEAltar tileEntityAltar = (TEAltar) tileEntity;
+// FluidStack flMain = new FluidStack(fluidIDMain, fluidAmountMain);
+// FluidStack flOutput = new FluidStack(fluidIDOutput, fluidAmountOutput);
+// FluidStack flInput = new FluidStack(fluidIDInput, fluidAmountInput);
+// tileEntityAltar.handlePacketData(items, flMain, flOutput, flInput, capacity);
+// }
+// } else if (packet.channel.equals("FallReset"))
+// {
+// if (player instanceof EntityPlayer)
+// {
+// ((EntityPlayer) player).fallDistance = 0;
+// }
+// } else if (packet.channel.equals("particle"))
+// {
+// ByteArrayInputStream bin = new ByteArrayInputStream(packet.data);
+// DataInputStream din = new DataInputStream(bin);
+// Random rand = new Random();
+//
+// try
+// {
+// double x = din.readDouble();
+// double y = din.readDouble();
+// double z = din.readDouble();
+// short particleType = din.readShort();
+// World world = ((EntityPlayer) player).worldObj;
+//
+// if (particleType == 1)
+// {
+// world.spawnParticle("mobSpell", x + 0.5D + rand.nextGaussian() / 8, y + 1.1D, z + 0.5D + rand.nextGaussian() / 8, 0.5117D, 0.0117D, 0.0117D);
+// }
+//
+// if (particleType == 2)
+// {
+// world.spawnParticle("reddust", x + 0.5D + rand.nextGaussian() / 8, y + 1.1D, z + 0.5D + rand.nextGaussian() / 8, 0.82D, 0.941D, 0.91D);
+// }
+//
+// if (particleType == 3)
+// {
+// world.spawnParticle("mobSpell", x + 0.5D + rand.nextGaussian() / 8, y + 1.1D, z + 0.5D + rand.nextGaussian() / 8, 1.0D, 0.371D, 0.371D);
+// }
+//
+// if (particleType == 4)
+// {
+// float f = (float) 1.0F;
+// float f1 = f * 0.6F + 0.4F;
+// float f2 = f * f * 0.7F - 0.5F;
+// float f3 = f * f * 0.6F - 0.7F;
+//
+// for (int l = 0; l < 8; ++l)
+// {
+// world.spawnParticle("reddust", x + Math.random() - Math.random(), y + Math.random() - Math.random(), z + Math.random() - Math.random(), f1, f2, f3);
+// }
+// }
+// } catch (IOException e)
+// {
+// e.printStackTrace();
+// }
+// } else if (packet.channel.equals("CustomParticle"))
+// {
+// ByteArrayInputStream bin = new ByteArrayInputStream(packet.data);
+// DataInputStream din = new DataInputStream(bin);
+// Random rand = new Random();
+//
+// try
+// {
+// World world = ((EntityPlayer) player).worldObj;
+// int size = din.readInt();
+// String str = "";
+//
+// for (int i = 0; i < size; i++)
+// {
+// str = str + din.readChar();
+// }
+//
+// double x = din.readDouble();
+// double y = din.readDouble();
+// double z = din.readDouble();
+// double xVel = din.readDouble();
+// double yVel = din.readDouble();
+// double zVel = din.readDouble();
+// world.spawnParticle(str, x, y, z, xVel, yVel, zVel);
+// } catch (IOException e)
+// {
+// e.printStackTrace();
+// }
+// } else if (packet.channel.equals("SetLifeEssence")) //Sets the data for the character
+// {
+// ByteArrayInputStream bin = new ByteArrayInputStream(packet.data);
+// DataInputStream din = new DataInputStream(bin);
+//
+// try
+// {
+// EntityPlayer user = (EntityPlayer) player;
+// int length = din.readInt();
+// String ownerName = "";
+//
+// for (int i = 0; i < length; i++)
+// {
+// ownerName = ownerName + din.readChar();
+// }
+//
+// int addedEssence = din.readInt();
+// int maxEssence = din.readInt();
+// World world = MinecraftServer.getServer().worldServers[0];
+// LifeEssenceNetwork data = (LifeEssenceNetwork) world.loadItemData(LifeEssenceNetwork.class, ownerName);
+//
+// if (data == null)
+// {
+// data = new LifeEssenceNetwork(ownerName);
+// world.setItemData(ownerName, data);
+// }
+//
+// if (addedEssence > 0)
+// {
+// if (data.currentEssence < maxEssence)
+// {
+// data.currentEssence = Math.min(maxEssence, data.currentEssence + addedEssence);
+// data.markDirty();
+// }
+//
+// if (!user.capabilities.isCreativeMode)
+// {
+// for (int i = 0; i < ((addedEssence + 99) / 100); i++)
+// {
+// //player.setEntityHealth((player.getHealth()-1));
+// user.setHealth((user.getHealth() - 1));
+//
+// if (user.getHealth() <= 0.5f)
+// {
+// //user.inventory.dropAllItems();
+// user.onDeath(DamageSource.generic);
+// return;
+// }
+// }
+// }
+// } else
+// {
+// int removedEssence = -addedEssence;
+//
+// if ((data.currentEssence - removedEssence) >= 0)
+// {
+// data.currentEssence -= removedEssence;
+// data.markDirty();
+// } else
+// {
+// if (removedEssence >= 100)
+// {
+// for (int i = 0; i < ((removedEssence + 99) / 100); i++)
+// {
+// //player.setEntityHealth((player.getHealth()-1));
+// user.setHealth((user.getHealth() - 1));
+//
+// if (user.getHealth() <= 0.5f)
+// {
+// //user.inventory.dropAllItems();
+// user.onDeath(DamageSource.generic);
+// return;
+// }
+// }
+// } else
+// {
+// if (user.worldObj.rand.nextInt(100) <= removedEssence)
+// {
+// user.setHealth((user.getHealth() - 1));
+//
+// if (user.getHealth() <= 0.5f)
+// {
+// //user.inventory.dropAllItems();
+// user.onDeath(DamageSource.generic);
+// return;
+// }
+// }
+// }
+// }
+// }
+//
+// //PacketDispatcher.sendPacketToPlayer(PacketHandler.getPacket(ownerName), (Player)user);
+//// data.currentEssence = addedEssence;
+//// data.markDirty();
+// } catch (IOException e)
+// {
+// e.printStackTrace();
+// }
+// } else if (packet.channel.equals("InfiniteLPPath"))
+// {
+// ByteArrayInputStream bin = new ByteArrayInputStream(packet.data);
+// DataInputStream din = new DataInputStream(bin);
+//
+// try
+// {
+// EntityPlayer user = (EntityPlayer) player;
+// int length = din.readInt();
+// String ownerName = "";
+//
+// for (int i = 0; i < length; i++)
+// {
+// ownerName = ownerName + din.readChar();
+// }
+//
+// boolean fill = din.readBoolean();
+// World world = MinecraftServer.getServer().worldServers[0];
+// LifeEssenceNetwork data = (LifeEssenceNetwork) world.loadItemData(LifeEssenceNetwork.class, ownerName);
+//
+// if (data == null)
+// {
+// data = new LifeEssenceNetwork(ownerName);
+// world.setItemData(ownerName, data);
+// }
+//
+// if (fill)
+// {
+// data.currentEssence += 1000000;
+// data.markDirty();
+// } else
+// {
+// data.currentEssence = 0;
+// data.markDirty();
+// }
+//
+// //PacketDispatcher.sendPacketToPlayer(PacketHandler.getPacket(ownerName), (Player)user);
+//// data.currentEssence = addedEssence;
+//// data.markDirty();
+// } catch (IOException e)
+// {
+// e.printStackTrace();
+// }
+// } else if (packet.channel.equals("GetLifeEssence"))
+// {
+// ByteArrayInputStream bin = new ByteArrayInputStream(packet.data);
+// DataInputStream din = new DataInputStream(bin);
+//
+// try
+// {
+// int length = din.readInt();
+// String ownerName = "";
+//
+// for (int i = 0; i < length; i++)
+// {
+// ownerName = ownerName + din.readChar();
+// }
+//
+// World world = MinecraftServer.getServer().worldServers[0];
+// LifeEssenceNetwork data = (LifeEssenceNetwork) world.loadItemData(LifeEssenceNetwork.class, ownerName);
+//
+// if (data == null)
+// {
+// data = new LifeEssenceNetwork(ownerName);
+// world.setItemData(ownerName, data);
+// }
+//
+// if (player instanceof EntityPlayer)
+// {
+// EntityPlayer owner = (EntityPlayer) player;
+// ChatMessageComponent chatmessagecomponent = new ChatMessageComponent();
+// //chatmessagecomponent.func_111072_b("Current Essence: " + data.currentEssence + "LP");
+// chatmessagecomponent.addText("Current Essence: " + data.currentEssence + "LP");
+// owner.sendChatToPlayer(chatmessagecomponent);
+// }
+// } catch (IOException e)
+// {
+// e.printStackTrace();
+// }
+// } else if (packet.channel.equals("GetAltarEssence"))
+// {
+// ByteArrayInputStream bin = new ByteArrayInputStream(packet.data);
+// DataInputStream din = new DataInputStream(bin);
+//
+// try
+// {
+// int x = din.readInt();
+// int y = din.readInt();
+// int z = din.readInt();
+//
+// if (player instanceof EntityPlayer)
+// {
+// EntityPlayer owner = (EntityPlayer) player;
+// World world = owner.worldObj;
+// TEAltar tileEntity = (TEAltar) world.getBlockTileEntity(x, y, z);
+//
+// if (tileEntity != null)
+// {
+// int level = UpgradedAltars.isAltarValid(world, x, y, z);
+// ChatMessageComponent chatmessagecomponent = new ChatMessageComponent();
+// chatmessagecomponent.addText("Altar's Current Essence: " + tileEntity.getFluidAmount() + "LP" + "\n" + "Altar's Current Tier: " + level + "\nCapacity: " + tileEntity.getCapacity() + "LP");
+// //chatmessagecomponent.addText();
+// owner.sendChatToPlayer(chatmessagecomponent);
+// }
+// }
+// } catch (IOException e)
+// {
+// e.printStackTrace();
+// }
+// } else if (packet.channel.equals("TESocket"))
+// {
+// ByteArrayDataInput dat = ByteStreams.newDataInput(packet.data);
+// int x = dat.readInt();
+// int y = dat.readInt();
+// int z = dat.readInt();
+// boolean hasStacks = dat.readByte() != 0;
+// int[] items = new int[0];
+//
+// if (hasStacks)
+// {
+// items = new int[1 * 3];
+//
+// for (int i = 0; i < items.length; i++)
+// {
+// items[i] = dat.readInt();
+// }
+// }
+//
+// World world = AlchemicalWizardry.proxy.getClientWorld();
+// TileEntity tileEntity = world.getBlockTileEntity(x, y, z);
+//
+// if (tileEntity instanceof TESocket)
+// {
+// TESocket tileEntityAltar = (TESocket) tileEntity;
+// tileEntityAltar.handlePacketData(items);
+// }
+// } else if (packet.channel.equals("TEWritingTable"))
+// {
+// ByteArrayDataInput dat = ByteStreams.newDataInput(packet.data);
+// int x = dat.readInt();
+// int y = dat.readInt();
+// int z = dat.readInt();
+// boolean hasStacks = dat.readByte() != 0;
+// int[] items = new int[0];
+//
+// if (hasStacks)
+// {
+// items = new int[7 * 3];
+//
+// for (int i = 0; i < items.length; i++)
+// {
+// items[i] = dat.readInt();
+// }
+// }
+//
+// World world = AlchemicalWizardry.proxy.getClientWorld();
+// TileEntity tileEntity = world.getBlockTileEntity(x, y, z);
+//
+// if (tileEntity instanceof TEWritingTable)
+// {
+// TEWritingTable tileEntityAltar = (TEWritingTable) tileEntity;
+// tileEntityAltar.handlePacketData(items);
+// }
+// } else if (packet.channel.equals("TEOrientor"))
+// {
+// ByteArrayDataInput dat = ByteStreams.newDataInput(packet.data);
+// int x = dat.readInt();
+// int y = dat.readInt();
+// int z = dat.readInt();
+// World world = AlchemicalWizardry.proxy.getClientWorld();
+// TileEntity tileEntity = world.getBlockTileEntity(x, y, z);
+//
+// if (tileEntity instanceof TEOrientable)
+// {
+// TEOrientable tileEntityOrientable = (TEOrientable) tileEntity;
+// tileEntityOrientable.setInputDirection(ForgeDirection.getOrientation(dat.readInt()));
+// tileEntityOrientable.setOutputDirection(ForgeDirection.getOrientation(dat.readInt()));
+// world.markBlockForRenderUpdate(x, y, z);
+// }
+// } else if (packet.channel.equals("TEPedestal"))
+// {
+// ByteArrayDataInput dat = ByteStreams.newDataInput(packet.data);
+// int x = dat.readInt();
+// int y = dat.readInt();
+// int z = dat.readInt();
+// boolean hasStacks = dat.readByte() != 0;
+// int[] items = new int[0];
+//
+// if (hasStacks)
+// {
+// items = new int[1 * 3];
+//
+// for (int i = 0; i < items.length; i++)
+// {
+// items[i] = dat.readInt();
+// }
+// }
+//
+// World world = AlchemicalWizardry.proxy.getClientWorld();
+// TileEntity tileEntity = world.getBlockTileEntity(x, y, z);
+//
+// if (tileEntity instanceof TEPedestal)
+// {
+// TEPedestal tileEntityAltar = (TEPedestal) tileEntity;
+// tileEntityAltar.handlePacketData(items);
+// }
+// } else if (packet.channel.equals("TEPlinth"))
+// {
+// ByteArrayDataInput dat = ByteStreams.newDataInput(packet.data);
+// int x = dat.readInt();
+// int y = dat.readInt();
+// int z = dat.readInt();
+// boolean hasStacks = dat.readByte() != 0;
+// int[] items = new int[0];
+//
+// if (hasStacks)
+// {
+// items = new int[1 * 3];
+//
+// for (int i = 0; i < items.length; i++)
+// {
+// items[i] = dat.readInt();
+// }
+// }
+//
+// World world = AlchemicalWizardry.proxy.getClientWorld();
+// TileEntity tileEntity = world.getBlockTileEntity(x, y, z);
+//
+// if (tileEntity instanceof TEPlinth)
+// {
+// TEPlinth tileEntityAltar = (TEPlinth) tileEntity;
+// tileEntityAltar.handlePacketData(items);
+// }
+// } else if (packet.channel.equals("TETeleposer"))
+// {
+// ByteArrayDataInput dat = ByteStreams.newDataInput(packet.data);
+// int x = dat.readInt();
+// int y = dat.readInt();
+// int z = dat.readInt();
+// boolean hasStacks = dat.readByte() != 0;
+// int[] items = new int[0];
+//
+// if (hasStacks)
+// {
+// items = new int[1 * 3];
+//
+// for (int i = 0; i < items.length; i++)
+// {
+// items[i] = dat.readInt();
+// }
+// }
+//
+// World world = AlchemicalWizardry.proxy.getClientWorld();
+// TileEntity tileEntity = world.getBlockTileEntity(x, y, z);
+//
+// if (tileEntity instanceof TETeleposer)
+// {
+// TETeleposer tileEntityAltar = (TETeleposer) tileEntity;
+// tileEntityAltar.handlePacketData(items);
+// }
+// } else if (packet.channel.equals("SetPlayerVel"))
+// {
+// ByteArrayDataInput dat = ByteStreams.newDataInput(packet.data);
+// double xVel = dat.readDouble();
+// double yVel = dat.readDouble();
+// double zVel = dat.readDouble();
+// ((EntityPlayer) player).setVelocity(xVel, yVel, zVel);
+// } else if (packet.channel.equals("SetPlayerPos"))
+// {
+// ByteArrayDataInput dat = ByteStreams.newDataInput(packet.data);
+// double xVel = dat.readDouble();
+// double yVel = dat.readDouble();
+// double zVel = dat.readDouble();
+// ((EntityPlayer) player).setPosition(xVel, yVel, zVel);
+// }
+// }
+//
+// public static Packet getPacket(TEAltar tileEntity)
+// {
+// ByteArrayOutputStream bos = new ByteArrayOutputStream(140);
+// DataOutputStream dos = new DataOutputStream(bos);
+// int[] items = tileEntity.buildIntDataList();
+// boolean hasStacks = (items != null);
+//
+// try
+// {
+// dos.writeInt(tileEntity.xCoord);
+// dos.writeInt(tileEntity.yCoord);
+// dos.writeInt(tileEntity.zCoord);
+// dos.writeByte(hasStacks ? 1 : 0);
+//
+// if (hasStacks)
+// {
+// for (int i = 0; i < 3; i++)
+// {
+// dos.writeInt(items[i]);
+// }
+// }
+//
+// FluidStack flMain = tileEntity.getFluid();
+//
+// if (flMain == null)
+// {
+// dos.writeInt(AlchemicalWizardry.lifeEssenceFluid.getBlockID());
+// dos.writeInt(0);
+// } else
+// {
+// dos.writeInt(flMain.fluidID);
+// dos.writeInt(flMain.amount);
+// }
+//
+// FluidStack flOut = tileEntity.getOutputFluid();
+//
+// if (flOut == null)
+// {
+// dos.writeInt(AlchemicalWizardry.lifeEssenceFluid.getBlockID());
+// dos.writeInt(0);
+// } else
+// {
+// dos.writeInt(flOut.fluidID);
+// dos.writeInt(flOut.amount);
+// }
+//
+// FluidStack flIn = tileEntity.getInputFluid();
+//
+// if (flIn == null)
+// {
+// dos.writeInt(AlchemicalWizardry.lifeEssenceFluid.getBlockID());
+// dos.writeInt(0);
+// } else
+// {
+// dos.writeInt(flIn.fluidID);
+// dos.writeInt(flIn.amount);
+// }
+//
+// dos.writeInt(tileEntity.capacity);
+// } catch (IOException e)
+// {
+// e.printStackTrace();
+// }
+//
+// Packet250CustomPayload pkt = new Packet250CustomPayload();
+// pkt.channel = "BloodAltar";
+// pkt.data = bos.toByteArray();
+// pkt.length = bos.size();
+// pkt.isChunkDataPacket = true;
+// return pkt;
+// }
+//
+// public static Packet getPacket(TESocket tileEntity)
+// {
+// ByteArrayOutputStream bos = new ByteArrayOutputStream(140);
+// DataOutputStream dos = new DataOutputStream(bos);
+// int[] items = tileEntity.buildIntDataList();
+// boolean hasStacks = (items != null);
+//
+// try
+// {
+// dos.writeInt(tileEntity.xCoord);
+// dos.writeInt(tileEntity.yCoord);
+// dos.writeInt(tileEntity.zCoord);
+// dos.writeByte(hasStacks ? 1 : 0);
+//
+// if (hasStacks)
+// {
+// for (int i = 0; i < 3; i++)
+// {
+// dos.writeInt(items[i]);
+// }
+// }
+// } catch (IOException e)
+// {
+// e.printStackTrace();
+// }
+//
+// Packet250CustomPayload pkt = new Packet250CustomPayload();
+// pkt.channel = "TESocket";
+// pkt.data = bos.toByteArray();
+// pkt.length = bos.size();
+// pkt.isChunkDataPacket = true;
+// return pkt;
+// }
+//
+// public static Packet getPacket(String ownerName, int addedEssence, int maxEssence)
+// //Packet to be sent to server to change essence
+// {
+// ByteArrayOutputStream bos = new ByteArrayOutputStream(140);
+// DataOutputStream dos = new DataOutputStream(bos);
+//
+// try
+// {
+// dos.writeInt(ownerName.length());
+// dos.writeChars(ownerName);
+// dos.writeInt(addedEssence);
+// dos.writeInt(maxEssence); //Used for Blood Orbs, but does nothing for other items
+// } catch (IOException e)
+// {
+// e.printStackTrace();
+// }
+//
+// Packet250CustomPayload pkt = new Packet250CustomPayload();
+// pkt.channel = "SetLifeEssence";
+// pkt.data = bos.toByteArray();
+// pkt.length = bos.size();
+// //pkt.isChunkDataPacket = true;
+// return pkt;
+// }
+//
+// public static Packet getPacket(String ownerName) //stores the current essence in the player's NBT
+// {
+// ByteArrayOutputStream bos = new ByteArrayOutputStream(140);
+// DataOutputStream dos = new DataOutputStream(bos);
+//
+// try
+// {
+// dos.writeInt(ownerName.length());
+// dos.writeChars(ownerName);
+// } catch (IOException e)
+// {
+// e.printStackTrace();
+// }
+//
+// Packet250CustomPayload pkt = new Packet250CustomPayload();
+// pkt.channel = "GetLifeEssence";
+// pkt.data = bos.toByteArray();
+// pkt.length = bos.size();
+// //pkt.isChunkDataPacket = true;
+// return pkt;
+// }
+//
+// public static Packet getAltarPacket(int x, int y, int z)
+// {
+// ByteArrayOutputStream bos = new ByteArrayOutputStream(140);
+// DataOutputStream dos = new DataOutputStream(bos);
+//
+// try
+// {
+// dos.writeInt(x);
+// dos.writeInt(y);
+// dos.writeInt(z);
+// } catch (IOException e)
+// {
+// e.printStackTrace();
+// }
+//
+// Packet250CustomPayload pkt = new Packet250CustomPayload();
+// pkt.channel = "GetAltarEssence";
+// pkt.data = bos.toByteArray();
+// pkt.length = bos.size();
+// //pkt.isChunkDataPacket = true;
+// return pkt;
+// }
+//
+// public static Packet getPacket(TEWritingTable tileEntity)
+// {
+// // TODO Auto-generated method stub
+// ByteArrayOutputStream bos = new ByteArrayOutputStream(140);
+// DataOutputStream dos = new DataOutputStream(bos);
+// int[] items = tileEntity.buildIntDataList();
+// boolean hasStacks = (items != null);
+//
+// try
+// {
+// dos.writeInt(tileEntity.xCoord);
+// dos.writeInt(tileEntity.yCoord);
+// dos.writeInt(tileEntity.zCoord);
+// dos.writeByte(hasStacks ? 1 : 0);
+//
+// if (hasStacks)
+// {
+// for (int i = 0; i < 3 * 7; i++)
+// {
+// dos.writeInt(items[i]);
+// }
+// }
+// } catch (IOException e)
+// {
+// e.printStackTrace();
+// }
+//
+// Packet250CustomPayload pkt = new Packet250CustomPayload();
+// pkt.channel = "TEWritingTable";
+// pkt.data = bos.toByteArray();
+// pkt.length = bos.size();
+// pkt.isChunkDataPacket = true;
+// return pkt;
+// }
+//
+// public static Packet getPacket(TEPedestal tileEntity)
+// {
+// // TODO Auto-generated method stub
+// ByteArrayOutputStream bos = new ByteArrayOutputStream(140);
+// DataOutputStream dos = new DataOutputStream(bos);
+// int[] items = tileEntity.buildIntDataList();
+// boolean hasStacks = (items != null);
+//
+// try
+// {
+// dos.writeInt(tileEntity.xCoord);
+// dos.writeInt(tileEntity.yCoord);
+// dos.writeInt(tileEntity.zCoord);
+// dos.writeByte(hasStacks ? 1 : 0);
+//
+// if (hasStacks)
+// {
+// for (int i = 0; i < 3 * 1; i++)
+// {
+// dos.writeInt(items[i]);
+// }
+// }
+// } catch (IOException e)
+// {
+// e.printStackTrace();
+// }
+//
+// Packet250CustomPayload pkt = new Packet250CustomPayload();
+// pkt.channel = "TEPedestal";
+// pkt.data = bos.toByteArray();
+// pkt.length = bos.size();
+// pkt.isChunkDataPacket = true;
+// return pkt;
+// }
+//
+// public static Packet getPacket(TEPlinth tileEntity)
+// {
+// // TODO Auto-generated method stub
+// ByteArrayOutputStream bos = new ByteArrayOutputStream(140);
+// DataOutputStream dos = new DataOutputStream(bos);
+// int[] items = tileEntity.buildIntDataList();
+// boolean hasStacks = (items != null);
+//
+// try
+// {
+// dos.writeInt(tileEntity.xCoord);
+// dos.writeInt(tileEntity.yCoord);
+// dos.writeInt(tileEntity.zCoord);
+// dos.writeByte(hasStacks ? 1 : 0);
+//
+// if (hasStacks)
+// {
+// for (int i = 0; i < 3 * 1; i++)
+// {
+// dos.writeInt(items[i]);
+// }
+// }
+// } catch (IOException e)
+// {
+// e.printStackTrace();
+// }
+//
+// Packet250CustomPayload pkt = new Packet250CustomPayload();
+// pkt.channel = "TEPlinth";
+// pkt.data = bos.toByteArray();
+// pkt.length = bos.size();
+// pkt.isChunkDataPacket = true;
+// return pkt;
+// }
+//
+// public static Packet getPacket(TETeleposer tileEntity)
+// {
+// // TODO Auto-generated method stub
+// ByteArrayOutputStream bos = new ByteArrayOutputStream(140);
+// DataOutputStream dos = new DataOutputStream(bos);
+// int[] items = tileEntity.buildIntDataList();
+// boolean hasStacks = (items != null);
+//
+// try
+// {
+// dos.writeInt(tileEntity.xCoord);
+// dos.writeInt(tileEntity.yCoord);
+// dos.writeInt(tileEntity.zCoord);
+// dos.writeByte(hasStacks ? 1 : 0);
+//
+// if (hasStacks)
+// {
+// for (int i = 0; i < 3 * 1; i++)
+// {
+// dos.writeInt(items[i]);
+// }
+// }
+// } catch (IOException e)
+// {
+// e.printStackTrace();
+// }
+//
+// Packet250CustomPayload pkt = new Packet250CustomPayload();
+// pkt.channel = "TETeleposer";
+// pkt.data = bos.toByteArray();
+// pkt.length = bos.size();
+// pkt.isChunkDataPacket = true;
+// return pkt;
+// }
+//
+// public static Packet getCustomParticlePacket(String str, double x, double y, double z, double xVel, double yVel, double zVel)
+// {
+// ByteArrayOutputStream bos = new ByteArrayOutputStream(140);
+// DataOutputStream dos = new DataOutputStream(bos);
+//
+// try
+// {
+// dos.writeInt(str.length());
+// dos.writeChars(str);
+// dos.writeDouble(x);
+// dos.writeDouble(y);
+// dos.writeDouble(z);
+// dos.writeDouble(xVel);
+// dos.writeDouble(yVel);
+// dos.writeDouble(zVel);
+// } catch (IOException e)
+// {
+// e.printStackTrace();
+// }
+//
+// Packet250CustomPayload pkt = new Packet250CustomPayload();
+// pkt.channel = "CustomParticle";
+// pkt.data = bos.toByteArray();
+// pkt.length = bos.size();
+// pkt.isChunkDataPacket = false;
+// return pkt;
+// }
+//
+// public static Packet getPlayerVelocitySettingPacket(double xVel, double yVel, double zVel)
+// {
+// ByteArrayOutputStream bos = new ByteArrayOutputStream(140);
+// DataOutputStream dos = new DataOutputStream(bos);
+//
+// try
+// {
+// dos.writeDouble(xVel);
+// dos.writeDouble(yVel);
+// dos.writeDouble(zVel);
+// } catch (IOException e)
+// {
+// e.printStackTrace();
+// }
+//
+// Packet250CustomPayload pkt = new Packet250CustomPayload();
+// pkt.channel = "SetPlayerVel";
+// pkt.data = bos.toByteArray();
+// pkt.length = bos.size();
+// pkt.isChunkDataPacket = false;
+// return pkt;
+// }
+//
+// public static Packet getPlayerPositionSettingPacket(double xVel, double yVel, double zVel)
+// {
+// ByteArrayOutputStream bos = new ByteArrayOutputStream(140);
+// DataOutputStream dos = new DataOutputStream(bos);
+//
+// try
+// {
+// dos.writeDouble(xVel);
+// dos.writeDouble(yVel);
+// dos.writeDouble(zVel);
+// } catch (IOException e)
+// {
+// e.printStackTrace();
+// }
+//
+// Packet250CustomPayload pkt = new Packet250CustomPayload();
+// pkt.channel = "SetPlayerPos";
+// pkt.data = bos.toByteArray();
+// pkt.length = bos.size();
+// pkt.isChunkDataPacket = false;
+// return pkt;
+// }
+//
+// public static Packet getCreativeCheatPacket(String ownerName, boolean isFill)
+// {
+// ByteArrayOutputStream bos = new ByteArrayOutputStream(140);
+// DataOutputStream dos = new DataOutputStream(bos);
+//
+// try
+// {
+// dos.writeInt(ownerName.length());
+// dos.writeChars(ownerName);
+// dos.writeBoolean(isFill);
+// } catch (IOException e)
+// {
+// e.printStackTrace();
+// }
+//
+// Packet250CustomPayload pkt = new Packet250CustomPayload();
+// pkt.channel = "InfiniteLPPath";
+// pkt.data = bos.toByteArray();
+// pkt.length = bos.size();
+// pkt.isChunkDataPacket = false;
+// return pkt;
+// }
+//
+// public static Packet getBlockOrientationPacket(TEOrientable tileEntity)
+// {
+// ByteArrayOutputStream bos = new ByteArrayOutputStream(140);
+// DataOutputStream dos = new DataOutputStream(bos);
+//
+// try
+// {
+// dos.writeInt(tileEntity.xCoord);
+// dos.writeInt(tileEntity.yCoord);
+// dos.writeInt(tileEntity.zCoord);
+// dos.writeInt(tileEntity.getIntForForgeDirection(tileEntity.getInputDirection()));
+// dos.writeInt(tileEntity.getIntForForgeDirection(tileEntity.getOutputDirection()));
+// } catch (IOException e)
+// {
+// e.printStackTrace();
+// }
+//
+// Packet250CustomPayload pkt = new Packet250CustomPayload();
+// pkt.channel = "TEOrientor";
+// pkt.data = bos.toByteArray();
+// pkt.length = bos.size();
+// pkt.isChunkDataPacket = true;
+// return pkt;
+// }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/PlinthComponent.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/PlinthComponent.java
new file mode 100644
index 00000000..6232828a
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/PlinthComponent.java
@@ -0,0 +1,37 @@
+package WayofTime.alchemicalWizardry.common;
+
+public class PlinthComponent
+{
+ public int xOffset;
+ public int yOffset;
+ public int zOffset;
+ public int ring;
+
+ public PlinthComponent(int xOffset, int yOffset, int zOffset, int ring)
+ {
+ this.xOffset = xOffset;
+ this.yOffset = yOffset;
+ this.zOffset = zOffset;
+ this.ring = ring;
+ }
+
+ public int getXOffset()
+ {
+ return xOffset;
+ }
+
+ public int getYOffset()
+ {
+ return yOffset;
+ }
+
+ public int getZOffset()
+ {
+ return zOffset;
+ }
+
+ public int getRing()
+ {
+ return ring;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/alchemy/CombinedPotionComponent.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/alchemy/CombinedPotionComponent.java
new file mode 100644
index 00000000..25dfa1b4
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/alchemy/CombinedPotionComponent.java
@@ -0,0 +1,27 @@
+package WayofTime.alchemicalWizardry.common.alchemy;
+
+import net.minecraft.potion.Potion;
+
+public class CombinedPotionComponent
+{
+ public Potion result;
+ public Potion pot1;
+ public Potion pot2;
+
+ public CombinedPotionComponent(Potion result, Potion pot1, Potion pot2)
+ {
+ this.result = result;
+ this.pot1 = pot1;
+ this.pot2 = pot2;
+ }
+
+ public boolean isRecipeValid(Potion test1, Potion test2)
+ {
+ return (test1 == pot1 && test2 == pot2) || (test1 == pot2 && test2 == pot1);
+ }
+
+ public boolean isRecipeValid(int test1, int test2)
+ {
+ return (test1 == pot1.id && test2 == pot2.id) || (test1 == pot2.id && test2 == pot1.id);
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/alchemy/CombinedPotionRegistry.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/alchemy/CombinedPotionRegistry.java
new file mode 100644
index 00000000..0a138dec
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/alchemy/CombinedPotionRegistry.java
@@ -0,0 +1,182 @@
+package WayofTime.alchemicalWizardry.common.alchemy;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.potion.Potion;
+import net.minecraft.potion.PotionEffect;
+import WayofTime.alchemicalWizardry.api.alchemy.AlchemyPotionHelper;
+import WayofTime.alchemicalWizardry.common.items.potion.AlchemyFlask;
+
+public class CombinedPotionRegistry
+{
+ public static List potionList = new ArrayList();
+
+ public static void registerCombinedPotionRecipe(Potion result, Potion pot1, Potion pot2)
+ {
+ potionList.add(new CombinedPotionComponent(result, pot1, pot2));
+ }
+
+ public static boolean isRecipeValid(Potion pot1, Potion pot2)
+ {
+ for(CombinedPotionComponent recipe : potionList)
+ {
+ if(recipe.isRecipeValid(pot1, pot2))
+ {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ public static boolean isRecipeValid(int pot1, int pot2)
+ {
+ for(CombinedPotionComponent recipe : potionList)
+ {
+ if(recipe.isRecipeValid(pot1, pot2))
+ {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ public static Potion getPotion(Potion pot1, Potion pot2)
+ {
+ for(CombinedPotionComponent recipe : potionList)
+ {
+ if(recipe.isRecipeValid(pot1, pot2))
+ {
+ return recipe.result;
+ }
+ }
+
+ return null;
+ }
+
+ public static Potion getPotion(int pot1, int pot2)
+ {
+ for(CombinedPotionComponent recipe : potionList)
+ {
+ if(recipe.isRecipeValid(pot1, pot2))
+ {
+ return recipe.result;
+ }
+ }
+
+ return null;
+ }
+
+ public static ItemStack applyPotionEffect(ItemStack stack)
+ {
+ if(stack == null || !(stack.getItem() instanceof AlchemyFlask))
+ {
+ return null;
+ }
+
+ List list = AlchemyFlask.getEffects(stack);
+ if(list == null)
+ {
+ return stack;
+ }
+
+ boolean isDone = false;
+
+ for(AlchemyPotionHelper helper1 : list)
+ {
+ if(isDone)
+ {
+ continue;
+ }
+
+ for(int i=0; i list = AlchemyFlask.getEffects(stack);
+ if(list == null)
+ {
+ return false;
+ }
+
+ for(AlchemyPotionHelper helper1 : list)
+ {
+ for(AlchemyPotionHelper helper2 : list)
+ {
+ int pot1 = helper1.getPotionID();
+ int pot2 = helper2.getPotionID();
+
+ if(isRecipeValid(pot1, pot2))
+ {
+ return true;
+ }
+ }
+ }
+
+ return false;
+ }
+
+ public static PotionEffect getResultantPotion(AlchemyPotionHelper potE1, AlchemyPotionHelper potE2)
+ {
+ if(potE1 == null || potE2 == null)
+ {
+ return null;
+ }
+
+ int pot1 = potE1.getPotionID();
+ int pot2 = potE2.getPotionID();
+
+ if(isRecipeValid(pot1, pot2))
+ {
+ int duration = (int)((potE1.getTickDuration()* Math.pow(8.0f / 3.0f, potE1.getdurationFactor()) + potE2.getdurationFactor() * Math.pow(8.0f / 3.0f, potE2.getdurationFactor()))/2.0);
+ int amplifier = (potE1.getConcentration() + potE2.getConcentration())/2;
+
+ Potion pot = getPotion(pot1, pot2);
+
+ return new PotionEffect(pot.id, duration, amplifier);
+ }
+
+ return null;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/alchemy/ICombinationalCatalyst.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/alchemy/ICombinationalCatalyst.java
new file mode 100644
index 00000000..9acdc197
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/alchemy/ICombinationalCatalyst.java
@@ -0,0 +1,6 @@
+package WayofTime.alchemicalWizardry.common.alchemy;
+
+public interface ICombinationalCatalyst
+{
+
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/ArmourForge.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/ArmourForge.java
new file mode 100644
index 00000000..d1bc6a1d
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/ArmourForge.java
@@ -0,0 +1,336 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.effect.EntityLightningBolt;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.ModItems;
+import WayofTime.alchemicalWizardry.api.items.interfaces.ArmourUpgrade;
+import WayofTime.alchemicalWizardry.common.ArmourComponent;
+import WayofTime.alchemicalWizardry.common.items.BoundArmour;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEAltar;
+import WayofTime.alchemicalWizardry.common.tileEntity.TESocket;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class ArmourForge extends Block
+{
+ public static List helmetList = new ArrayList();
+ public static List plateList = new ArrayList();
+ public static List leggingsList = new ArrayList();
+ public static List bootsList = new ArrayList();
+
+ public ArmourForge()
+ {
+ super(Material.iron);
+ setHardness(2.0F);
+ setResistance(5.0F);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ this.setBlockName("armourForge");
+ //setUnlocalizedName("armourForge");
+ // TODO Auto-generated constructor stub
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerBlockIcons(IIconRegister iconRegister)
+ {
+ this.blockIcon = iconRegister.registerIcon("AlchemicalWizardry:SoulForge");
+ }
+
+ @Override
+ public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int idk, float what, float these, float are)
+ {
+ if (world.isRemote)
+ {
+ return false;
+ }
+
+ int armourType = getArmourType(world, x, y, z);
+
+ if (armourType == -1)
+ {
+ return false;
+ }
+
+ int direction = getDirectionForArmourType(world, x, y, z, armourType);
+
+ if (!isParadigmValid(armourType, direction, world, x, y, z))
+ {
+ return false;
+ }
+
+ List list = null;
+ ItemStack armourPiece = null;
+
+ switch (armourType)
+ {
+ case 0:
+ list = plateList;
+ armourPiece = new ItemStack(ModItems.boundPlate, 1, 0);
+ break;
+
+ case 1:
+ list = leggingsList;
+ armourPiece = new ItemStack(ModItems.boundLeggings, 1, 0);
+ break;
+
+ case 2:
+ list = helmetList;
+ armourPiece = new ItemStack(ModItems.boundHelmet, 1, 0);
+ break;
+
+ case 3:
+ list = bootsList;
+ armourPiece = new ItemStack(ModItems.boundBoots, 1, 0);
+ break;
+ }
+
+ if (list == null)
+ {
+ return false;
+ }
+
+ if (armourPiece == null)
+ {
+ return false;
+ }
+
+ if (armourPiece.stackTagCompound == null)
+ {
+ armourPiece.setTagCompound(new NBTTagCompound());
+ }
+
+ for (ArmourComponent ac : list)
+ {
+ int xOff = ac.getXOff();
+ int zOff = ac.getZOff();
+ TileEntity tileEntity;
+
+ switch (direction)
+ {
+ case 1:
+ tileEntity = world.getTileEntity(x + xOff, y, z - zOff);
+ break;
+
+ case 2:
+ tileEntity = world.getTileEntity(x + zOff, y, z + xOff);
+ break;
+
+ case 3:
+ tileEntity = world.getTileEntity(x - xOff, y, z + zOff);
+ break;
+
+ case 4:
+ tileEntity = world.getTileEntity(x - zOff, y, z - xOff);
+ break;
+
+ case 5:
+ tileEntity = world.getTileEntity(x + xOff, y + zOff, z);
+ break;
+
+ case 6:
+ tileEntity = world.getTileEntity(x, y + zOff, z + xOff);
+ break;
+
+ default:
+ tileEntity = null;
+ }
+
+ if (tileEntity instanceof TESocket)
+ {
+ ItemStack itemStack = ((TESocket) tileEntity).getStackInSlot(0);
+ int xCoord = tileEntity.xCoord;
+ int yCoord = tileEntity.yCoord;
+ int zCoord = tileEntity.zCoord;
+ ((TESocket) tileEntity).setInventorySlotContents(0, null);
+ world.setBlockToAir(tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord);
+
+ for (int i = 0; i < 8; i++)
+ {
+ //PacketDispatcher.sendPacketToAllAround(xCoord, yCoord, zCoord, 20, world.provider.dimensionId, TEAltar.getParticlePacket(xCoord, yCoord, zCoord, (short) 1));
+ SpellHelper.sendIndexedParticleToAllAround(world, xCoord, yCoord, zCoord, 20, world.provider.dimensionId, 1, xCoord, yCoord, zCoord);
+ }
+
+ if (itemStack != null)
+ {
+ Item item = itemStack.getItem();
+
+ if (item instanceof ArmourUpgrade)
+ {
+ ((BoundArmour) armourPiece.getItem()).hasAddedToInventory(armourPiece, itemStack.copy());
+ ((TESocket) tileEntity).setInventorySlotContents(0, null);
+ }
+ }
+ }
+ }
+
+ if (armourPiece != null)
+ {
+ int xOff = (world.rand.nextInt(11) - 5);
+ int zOff = (int) (Math.sqrt(25 - xOff * xOff) * (world.rand.nextInt(2) - 0.5) * 2);
+ world.addWeatherEffect(new EntityLightningBolt(world, x + xOff, y + 5, z + zOff));
+ world.spawnEntityInWorld(new EntityItem(world, x, y + 1, z, armourPiece));
+ }
+
+ return true;
+ }
+
+ //0 for plate, 1 for leggings, 2 for helmet, 3 for boots
+ public int getArmourType(World world, int x, int y, int z)
+ {
+ for (int i = 0; i <= 3; i++)
+ {
+ if (getDirectionForArmourType(world, x, y, z, i) != -1)
+ {
+ return i;
+ }
+ }
+
+ return -1;
+ }
+
+ public int getDirectionForArmourType(World world, int x, int y, int z, int armourType)
+ {
+ for (int i = 1; i <= 6; i++)
+ {
+ if (isParadigmValid(armourType, i, world, x, y, z))
+ {
+ return i;
+ }
+ }
+
+ return -1;
+ }
+
+ public boolean isParadigmValid(int armourType, int direction, World world, int x, int y, int z)
+ {
+ List list = null;
+
+ switch (armourType)
+ {
+ case 0:
+ list = plateList;
+ break;
+
+ case 1:
+ list = leggingsList;
+ break;
+
+ case 2:
+ list = helmetList;
+ break;
+
+ case 3:
+ list = bootsList;
+ break;
+ }
+
+ if (list == null)
+ {
+ return false;
+ }
+
+ for (ArmourComponent ac : list)
+ {
+ int xOff = ac.getXOff();
+ int zOff = ac.getZOff();
+
+ switch (direction)
+ {
+ case 1:
+ if (!(world.getTileEntity(x + xOff, y, z - zOff) instanceof TESocket))
+ {
+ return false;
+ }
+
+ break;
+
+ case 2:
+ if (!(world.getTileEntity(x + zOff, y, z + xOff) instanceof TESocket))
+ {
+ return false;
+ }
+
+ break;
+
+ case 3:
+ if (!(world.getTileEntity(x - xOff, y, z + zOff) instanceof TESocket))
+ {
+ return false;
+ }
+
+ break;
+
+ case 4:
+ if (!(world.getTileEntity(x - zOff, y, z - xOff) instanceof TESocket))
+ {
+ return false;
+ }
+
+ break;
+
+ case 5:
+ if (!(world.getTileEntity(x + xOff, y + zOff, z) instanceof TESocket))
+ {
+ return false;
+ }
+
+ break;
+
+ case 6:
+ if (!(world.getTileEntity(x, y + zOff, z + xOff) instanceof TESocket))
+ {
+ return false;
+ }
+
+ break;
+
+ default:
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ public static void initializeRecipes()
+ {
+ helmetList.add(new ArmourComponent(-1, 1));
+ helmetList.add(new ArmourComponent(0, 1));
+ helmetList.add(new ArmourComponent(1, 1));
+ helmetList.add(new ArmourComponent(-1, 0));
+ helmetList.add(new ArmourComponent(1, 0));
+ bootsList.add(new ArmourComponent(-1, 1));
+ bootsList.add(new ArmourComponent(1, 1));
+ bootsList.add(new ArmourComponent(-1, 0));
+ bootsList.add(new ArmourComponent(1, 0));
+ plateList.add(new ArmourComponent(-1, 0));
+ plateList.add(new ArmourComponent(1, 0));
+ plateList.add(new ArmourComponent(-1, -1));
+ plateList.add(new ArmourComponent(0, -1));
+ plateList.add(new ArmourComponent(1, -1));
+ plateList.add(new ArmourComponent(-1, -2));
+ plateList.add(new ArmourComponent(0, -2));
+ plateList.add(new ArmourComponent(1, -2));
+ leggingsList.add(new ArmourComponent(-1, 1));
+ leggingsList.add(new ArmourComponent(0, 1));
+ leggingsList.add(new ArmourComponent(1, 1));
+ leggingsList.add(new ArmourComponent(-1, 0));
+ leggingsList.add(new ArmourComponent(1, 0));
+ leggingsList.add(new ArmourComponent(-1, -1));
+ leggingsList.add(new ArmourComponent(1, -1));
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockAlchemicCalcinator.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockAlchemicCalcinator.java
new file mode 100644
index 00000000..6ed95221
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockAlchemicCalcinator.java
@@ -0,0 +1,168 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import java.util.Random;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockContainer;
+import net.minecraft.block.material.Material;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.items.interfaces.IBloodOrb;
+import WayofTime.alchemicalWizardry.api.items.interfaces.IReagentManipulator;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEAlchemicCalcinator;
+
+public class BlockAlchemicCalcinator extends BlockContainer
+{
+ public BlockAlchemicCalcinator()
+ {
+ super(Material.rock);
+ setHardness(2.0F);
+ setResistance(5.0F);
+ this.setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ this.setBlockName("alchemicCalcinator");
+ }
+
+ @Override
+ public TileEntity createNewTileEntity(World world, int meta)
+ {
+ return new TEAlchemicCalcinator();
+ }
+
+ @Override
+ public boolean renderAsNormalBlock()
+ {
+ return false;
+ }
+
+ @Override
+ public int getRenderType()
+ {
+ return -1;
+ }
+
+ @Override
+ public boolean isOpaqueCube()
+ {
+ return false;
+ }
+
+ @Override
+ public boolean hasTileEntity()
+ {
+ return true;
+ }
+
+ @Override
+ public boolean canProvidePower()
+ {
+ return true;
+ }
+
+ @Override
+ public void breakBlock(World world, int x, int y, int z, Block par5, int par6)
+ {
+ dropItems(world, x, y, z);
+ super.breakBlock(world, x, y, z, par5, par6);
+ }
+
+ private void dropItems(World world, int x, int y, int z)
+ {
+ Random rand = new Random();
+ TileEntity tileEntity = world.getTileEntity(x, y, z);
+
+ if (!(tileEntity instanceof IInventory))
+ {
+ return;
+ }
+
+ IInventory inventory = (IInventory) tileEntity;
+
+ for (int i = 0; i < inventory.getSizeInventory(); i++)
+ {
+ ItemStack item = inventory.getStackInSlot(i);
+
+ if (item != null && item.stackSize > 0)
+ {
+ float rx = rand.nextFloat() * 0.8F + 0.1F;
+ float ry = rand.nextFloat() * 0.8F + 0.1F;
+ float rz = rand.nextFloat() * 0.8F + 0.1F;
+ EntityItem entityItem = new EntityItem(world,
+ x + rx, y + ry, z + rz,
+ new ItemStack(item.getItem(), item.stackSize, item.getItemDamage()));
+
+ if (item.hasTagCompound())
+ {
+ entityItem.getEntityItem().setTagCompound((NBTTagCompound) item.getTagCompound().copy());
+ }
+
+ float factor = 0.05F;
+ entityItem.motionX = rand.nextGaussian() * factor;
+ entityItem.motionY = rand.nextGaussian() * factor + 0.2F;
+ entityItem.motionZ = rand.nextGaussian() * factor;
+ world.spawnEntityInWorld(entityItem);
+ item.stackSize = 0;
+ }
+ }
+ }
+
+ @Override
+ public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int idk, float what, float these, float are)
+ {
+ TEAlchemicCalcinator tileEntity = (TEAlchemicCalcinator) world.getTileEntity(x, y, z);
+
+ if (tileEntity == null || player.isSneaking())
+ {
+ return false;
+ }
+
+ ItemStack playerItem = player.getCurrentEquippedItem();
+
+ if (playerItem != null)
+ {
+ if(playerItem.getItem() instanceof IReagentManipulator)
+ {
+ return false;
+ }
+
+ if(playerItem.getItem() instanceof IBloodOrb)
+ {
+ if(tileEntity.getStackInSlot(0) == null)
+ {
+ ItemStack newItem = playerItem.copy();
+ newItem.stackSize = 1;
+ --playerItem.stackSize;
+ tileEntity.setInventorySlotContents(0, newItem);
+ }
+ }
+ else if(tileEntity.getStackInSlot(1) == null)
+ {
+ ItemStack newItem = playerItem.copy();
+ newItem.stackSize = 1;
+ --playerItem.stackSize;
+ tileEntity.setInventorySlotContents(1, newItem);
+ }
+
+ } else if (playerItem == null)
+ {
+ if(tileEntity.getStackInSlot(1) != null)
+ {
+ player.inventory.addItemStackToInventory(tileEntity.getStackInSlot(1));
+ tileEntity.setInventorySlotContents(1, null);
+ }else if(tileEntity.getStackInSlot(0) != null)
+ {
+ player.inventory.addItemStackToInventory(tileEntity.getStackInSlot(0));
+ tileEntity.setInventorySlotContents(0, null);
+ }
+ }
+
+ tileEntity.getWorldObj().markBlockForUpdate(x, y, z);
+
+ return true;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockAltar.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockAltar.java
new file mode 100644
index 00000000..8b1b2f8c
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockAltar.java
@@ -0,0 +1,314 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import java.util.Random;
+
+import javax.swing.Icon;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockContainer;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.ModItems;
+import WayofTime.alchemicalWizardry.common.PacketHandler;
+import WayofTime.alchemicalWizardry.common.items.EnergyBattery;
+import WayofTime.alchemicalWizardry.common.items.sigil.SigilOfHolding;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEAltar;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEBellJar;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class BlockAltar extends BlockContainer
+{
+ @SideOnly(Side.CLIENT)
+ private static IIcon topIcon;
+ @SideOnly(Side.CLIENT)
+ private static IIcon sideIcon1;
+ @SideOnly(Side.CLIENT)
+ private static IIcon sideIcon2;
+ @SideOnly(Side.CLIENT)
+ private static IIcon bottomIcon;
+
+ public BlockAltar()
+ {
+ super(Material.rock);
+ setHardness(2.0F);
+ setResistance(5.0F);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ this.setBlockName("bloodAltar");
+ //setUnlocalizedName("blockAltar");
+ //func_111022_d("AlchemicalWizardry:blocks");
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerBlockIcons(IIconRegister iconRegister)
+ {
+ this.topIcon = iconRegister.registerIcon("AlchemicalWizardry:BloodAltar_Top");
+ this.sideIcon1 = iconRegister.registerIcon("AlchemicalWizardry:BloodAltar_SideType1");
+ this.sideIcon2 = iconRegister.registerIcon("AlchemicalWizardry:BloodAltar_SideType2");
+ this.bottomIcon = iconRegister.registerIcon("AlchemicalWizardry:BloodAltar_Bottom");
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public IIcon getIcon(int side, int meta)
+ {
+ switch (side)
+ {
+ case 0:
+ return bottomIcon;
+
+ case 1:
+ return topIcon;
+
+ //case 2: return sideIcon1;
+ //case 3: return sideIcon1;
+ //case 4: return sideIcon2;
+ //case 5: return sideIcon2;
+ default:
+ return sideIcon2;
+ }
+ }
+
+ @Override
+ public boolean hasComparatorInputOverride()
+ {
+ return true;
+ }
+
+ @Override
+ public int getComparatorInputOverride(World world, int x, int y, int z, int meta)
+ {
+ TileEntity tile = world.getTileEntity(x, y, z);
+
+ if (tile instanceof TEAltar)
+ {
+ ItemStack stack = ((TEAltar) tile).getStackInSlot(0);
+
+ if (stack != null && stack.getItem() instanceof EnergyBattery)
+ {
+ EnergyBattery bloodOrb = (EnergyBattery) stack.getItem();
+ int maxEssence = bloodOrb.getMaxEssence();
+ int currentEssence = bloodOrb.getCurrentEssence(stack);
+ int level = currentEssence * 15 / maxEssence;
+ return ((int) (Math.min(15, level))) % 16;
+ }
+ }
+
+ return 0;
+ }
+
+ @Override
+ public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int idk, float what, float these, float are)
+ {
+ TEAltar tileEntity = (TEAltar) world.getTileEntity(x, y, z);
+
+// world.scheduleBlockUpdate(x, y, z, this.blockID, 0);
+
+ if (tileEntity == null || player.isSneaking())
+ {
+ return false;
+ }
+
+ ItemStack playerItem = player.getCurrentEquippedItem();
+
+ if (playerItem != null)
+ {
+ if (playerItem.getItem().equals(ModItems.divinationSigil))
+ {
+ if (player.worldObj.isRemote)
+ {
+ world.markBlockForUpdate(x, y, z);
+ }else
+ {
+ tileEntity.sendChatInfoToPlayer(player);
+ }
+
+ return true;
+ }
+ else if(playerItem.getItem().equals(ModItems.itemSeerSigil))
+ {
+ if (player.worldObj.isRemote)
+ {
+ world.markBlockForUpdate(x, y, z);
+ }else
+ {
+ tileEntity.sendMoreChatInfoToPlayer(player);
+ }
+
+ return true;
+ }
+ else if (playerItem.getItem().equals(ModItems.sigilOfHolding))
+ {
+ ItemStack item = ((SigilOfHolding) playerItem.getItem()).getCurrentItem(playerItem);
+
+ if (item != null && item.getItem().equals(ModItems.divinationSigil))
+ {
+ if (player.worldObj.isRemote)
+ {
+ world.markBlockForUpdate(x, y, z);
+ }else
+ {
+ tileEntity.sendChatInfoToPlayer(player);
+ }
+
+ return true;
+ }
+ else if(item !=null && item.getItem().equals(ModItems.itemSeerSigil))
+ {
+ if (player.worldObj.isRemote)
+ {
+ world.markBlockForUpdate(x, y, z);
+ }else
+ {
+ tileEntity.sendMoreChatInfoToPlayer(player);
+ }
+
+ return true;
+ }
+ }
+ }
+
+ if (tileEntity.getStackInSlot(0) == null && playerItem != null)
+ {
+ ItemStack newItem = playerItem.copy();
+ newItem.stackSize = 1;
+// if(newItem.getMaxDamage()==0)
+// {
+// newItem.setItemDamage(0);
+// }
+ --playerItem.stackSize;
+ tileEntity.setInventorySlotContents(0, newItem);
+ tileEntity.startCycle();
+ } else if (tileEntity.getStackInSlot(0) != null && playerItem == null)
+ {
+ /**stub method
+ * Add the item that is in the slot to the player's inventory, and
+ * then set the slot to null.
+ */
+ player.inventory.addItemStackToInventory(tileEntity.getStackInSlot(0));
+ tileEntity.setInventorySlotContents(0, null);
+ tileEntity.setActive();
+ }
+
+ world.markBlockForUpdate(x, y, z);
+ //player.openGui(AlchemicalWizardry.instance, 0, world, x, y, z);
+ //PacketDispatcher.sendPacketToServer(tileEntity.getDescriptionPacket());
+ return true;
+ }
+
+ @Override
+ public void breakBlock(World world, int x, int y, int z, Block par5, int par6)
+ {
+ dropItems(world, x, y, z);
+ super.breakBlock(world, x, y, z, par5, par6);
+ }
+
+ private void dropItems(World world, int x, int y, int z)
+ {
+ Random rand = new Random();
+ TileEntity tileEntity = world.getTileEntity(x, y, z);
+
+ if (!(tileEntity instanceof IInventory))
+ {
+ return;
+ }
+
+ IInventory inventory = (IInventory) tileEntity;
+
+ for (int i = 0; i < inventory.getSizeInventory(); i++)
+ {
+ ItemStack item = inventory.getStackInSlot(i);
+
+ if (item != null && item.stackSize > 0)
+ {
+ float rx = rand.nextFloat() * 0.8F + 0.1F;
+ float ry = rand.nextFloat() * 0.8F + 0.1F;
+ float rz = rand.nextFloat() * 0.8F + 0.1F;
+ EntityItem entityItem = new EntityItem(world,
+ x + rx, y + ry, z + rz,
+ new ItemStack(item.getItem(), item.stackSize, item.getItemDamage()));
+
+ if (item.hasTagCompound())
+ {
+ entityItem.getEntityItem().setTagCompound((NBTTagCompound) item.getTagCompound().copy());
+ }
+
+ float factor = 0.05F;
+ entityItem.motionX = rand.nextGaussian() * factor;
+ entityItem.motionY = rand.nextGaussian() * factor + 0.2F;
+ entityItem.motionZ = rand.nextGaussian() * factor;
+ world.spawnEntityInWorld(entityItem);
+ item.stackSize = 0;
+ }
+ }
+ }
+
+ @Override
+ public boolean renderAsNormalBlock()
+ {
+ return false;
+ }
+
+ @Override
+ public int getRenderType()
+ {
+ return -1;
+ }
+
+ @Override
+ public boolean isOpaqueCube()
+ {
+ return false;
+ }
+
+ @Override
+ public boolean hasTileEntity()
+ {
+ return true;
+ }
+
+ @Override
+ public void randomDisplayTick(World world, int x, int y, int z, Random rand)
+ {
+ TEAltar tileEntity = (TEAltar) world.getTileEntity(x, y, z);
+
+ if (!tileEntity.isActive())
+ {
+ return;
+ }
+
+ if (rand.nextInt(3) != 0)
+ {
+ return;
+ }
+ }
+
+// @Override
+// public int isProvidingStrongPower(IBlockAccess par1IBlockAccess, int par2, int par3, int par4, int par5)
+// {
+// return 1;
+// }
+
+// @Override
+// public boolean canProvidePower()
+// {
+// return true;
+// }
+
+ @Override
+ public TileEntity createNewTileEntity(World var1, int var2)
+ {
+ return new TEAltar();
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockBelljar.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockBelljar.java
new file mode 100644
index 00000000..767213e3
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockBelljar.java
@@ -0,0 +1,157 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import java.util.ArrayList;
+
+import net.minecraft.block.BlockContainer;
+import net.minecraft.block.material.Material;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentContainerInfo;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEBellJar;
+
+public class BlockBelljar extends BlockContainer
+{
+ public BlockBelljar()
+ {
+ super(Material.glass);
+ setHardness(2.0F);
+ setResistance(5.0F);
+ this.setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ this.setBlockName("crystalBelljar");
+ }
+
+ @Override
+ public void onBlockPlacedBy(World world, int x, int y, int z, EntityLivingBase entityLiving, ItemStack stack)
+ {
+ TileEntity tile = world.getTileEntity(x, y, z);
+
+ if(tile instanceof TEBellJar)
+ {
+ NBTTagCompound tag = stack.getTagCompound();
+ if(tag != null)
+ {
+ ((TEBellJar) tile).readTankNBTOnPlace(tag);
+ }
+ }
+ }
+
+// @Override
+// public void breakBlock(World world, int x, int y, int z, Block par5, int par6)
+// {
+// if(world.isRemote)
+// {
+// return;
+// }
+//
+// TileEntity tile = world.getTileEntity(x, y, z);
+//
+// if(tile == null)
+// {
+// System.out.println("Tile has been removed already!");
+// }
+//
+// if(tile instanceof TEBellJar)
+// {
+// if(((TEBellJar) tile).areTanksEmpty())
+// {
+// super.breakBlock(world, x, y, z, par5, par6);
+// return;
+// }
+// System.out.println("Writing...");
+// ItemStack droppedStack = new ItemStack(ModBlocks.blockCrystalBelljar);
+// droppedStack.setTagCompound(new NBTTagCompound());
+//
+// NBTTagCompound savedTag = droppedStack.getTagCompound();
+// ((TEBellJar) tile).writeTankNBT(savedTag);
+//
+// this.dropBlockAsItem(world, x, y, z, droppedStack);
+//
+// world.removeTileEntity(x, y, z);
+// return;
+// }
+//
+// super.breakBlock(world, x, y, z, par5, par6);
+// }
+
+ @Override
+ public TileEntity createNewTileEntity(World world, int meta)
+ {
+ return new TEBellJar();
+ }
+
+ @Override
+ public boolean renderAsNormalBlock()
+ {
+ return false;
+ }
+
+ @Override
+ public int getRenderType()
+ {
+ return -1;
+ }
+
+ @Override
+ public boolean isOpaqueCube()
+ {
+ return false;
+ }
+
+ @Override
+ public boolean hasTileEntity()
+ {
+ return true;
+ }
+
+ @Override
+ public boolean hasComparatorInputOverride()
+ {
+ return true;
+ }
+
+ @Override
+ public int getComparatorInputOverride(World world, int x, int y, int z, int meta)
+ {
+ TileEntity tile = world.getTileEntity(x, y, z);
+ if(tile instanceof TEBellJar)
+ {
+ return ((TEBellJar) tile).getRSPowerOutput();
+ }
+ return 15;
+ }
+
+ @Override
+ public void onBlockHarvested(World world, int x, int y, int z, int meta, EntityPlayer player)
+ {
+ this.dropBlockAsItem(world, x, y, z, meta, 0);
+
+ super.onBlockHarvested(world, x, y, z, meta, player);
+ }
+
+ @Override
+ public ArrayList getDrops(World world, int x, int y, int z, int metadata, int fortune)
+ {
+ ArrayList list = new ArrayList();
+
+ TileEntity tile = world.getTileEntity(x, y, z);
+
+ if(tile instanceof TEBellJar)
+ {
+ ItemStack drop = new ItemStack(this);
+ NBTTagCompound tag = new NBTTagCompound();
+ ((TEBellJar)tile).writeTankNBT(tag);
+ drop.stackTagCompound = tag;
+
+ list.add(drop);
+ }
+
+ return list;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockBloodLightSource.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockBloodLightSource.java
new file mode 100644
index 00000000..2ffc83e6
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockBloodLightSource.java
@@ -0,0 +1,75 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import java.util.List;
+import java.util.Random;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.Entity;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class BlockBloodLightSource extends Block
+{
+ public BlockBloodLightSource()
+ {
+ super(Material.cloth);
+ //setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ this.setBlockName("blockBloodLightSource");
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerBlockIcons(IIconRegister iconRegister)
+ {
+ this.blockIcon = iconRegister.registerIcon("AlchemicalWizardry:BlockBloodLight");
+ }
+
+ @Override
+ public int getLightValue(IBlockAccess world, int x, int y, int z)
+ {
+ return 15;
+ }
+
+ @Override
+ public boolean isOpaqueCube()
+ {
+ return false;
+ }
+
+ @Override
+ public boolean renderAsNormalBlock()
+ {
+ return false;
+ }
+
+ @Override
+ public void randomDisplayTick(World world, int x, int y, int z, Random rand)
+ {
+ if (rand.nextInt(3) != 0)
+ {
+ float f = (float) 1.0F;
+ float f1 = f * 0.6F + 0.4F;
+ float f2 = f * f * 0.7F - 0.5F;
+ float f3 = f * f * 0.6F - 0.7F;
+ world.spawnParticle("reddust", x + 0.5D + rand.nextGaussian() / 8, y + 0.5D, z + 0.5D + rand.nextGaussian() / 8, f1, f2, f3);
+ }
+ }
+
+ @Override
+
+ public void addCollisionBoxesToList(World par1World, int par2, int par3, int par4, AxisAlignedBB par5AxisAlignedBB, List par6List, Entity par7Entity)
+ {
+ this.setBlockBounds(0.40F, 0.40F, 0.40F, 0.60F, 0.60F, 0.60F);
+ //super.addCollisionBoxesToList(par1World, par2, par3, par4, par5AxisAlignedBB, par6List, par7Entity);
+ }
+
+ public int quantityDropped(Random par1Random)
+ {
+ return 0;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockConduit.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockConduit.java
new file mode 100644
index 00000000..c92daea7
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockConduit.java
@@ -0,0 +1,101 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEConduit;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class BlockConduit extends BlockOrientable
+{
+ @SideOnly(Side.CLIENT)
+ private static IIcon topIcon;
+ @SideOnly(Side.CLIENT)
+ private static IIcon sideIcon1;
+ @SideOnly(Side.CLIENT)
+ private static IIcon sideIcon2;
+ @SideOnly(Side.CLIENT)
+ private static IIcon bottomIcon;
+
+ public BlockConduit()
+ {
+ super();
+ setHardness(2.0F);
+ setResistance(5.0F);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ this.setBlockName("blockConduit");
+ //func_111022_d("AlchemicalWizardry:blocks");
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerBlockIcons(IIconRegister iconRegister)
+ {
+ this.topIcon = iconRegister.registerIcon("AlchemicalWizardry:BloodAltar_Top");
+ this.sideIcon1 = iconRegister.registerIcon("AlchemicalWizardry:BloodAltar_SideType1");
+ this.sideIcon2 = iconRegister.registerIcon("AlchemicalWizardry:BloodAltar_SideType2");
+ this.bottomIcon = iconRegister.registerIcon("AlchemicalWizardry:BloodAltar_Bottom");
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public IIcon getIcon(int side, int meta)
+ {
+ switch (side)
+ {
+ case 0:
+ return bottomIcon;
+
+ case 1:
+ return topIcon;
+
+ //case 2: return sideIcon1;
+ //case 3: return sideIcon1;
+ //case 4: return sideIcon2;
+ //case 5: return sideIcon2;
+ default:
+ return sideIcon2;
+ }
+ }
+
+ @Override
+ public void breakBlock(World world, int x, int y, int z, Block par5, int par6)
+ {
+ //dropItems(world, x, y, z);
+ super.breakBlock(world, x, y, z, par5, par6);
+ }
+
+ @Override
+ public TileEntity createNewTileEntity(World world, int noClue)
+ {
+ return new TEConduit();
+ }
+
+ @Override
+ public boolean renderAsNormalBlock()
+ {
+ return false;
+ }
+
+ @Override
+ public int getRenderType()
+ {
+ return -1;
+ }
+
+ @Override
+ public boolean isOpaqueCube()
+ {
+ return false;
+ }
+
+ @Override
+ public boolean hasTileEntity()
+ {
+ return true;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockDemonPortal.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockDemonPortal.java
new file mode 100644
index 00000000..c9d74de3
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockDemonPortal.java
@@ -0,0 +1,43 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import net.minecraft.block.BlockContainer;
+import net.minecraft.block.material.Material;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEAltar;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEDemonPortal;
+
+public class BlockDemonPortal extends BlockContainer
+{
+ public BlockDemonPortal()
+ {
+ super(Material.rock);
+ setHardness(2.0F);
+ setResistance(5.0F);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ this.setBlockName("demonPortal");
+ }
+
+ @Override
+ public TileEntity createNewTileEntity(World var1, int var2)
+ {
+ return new TEDemonPortal();
+ }
+
+ @Override
+ public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float what, float these, float are)
+ {
+ if(world.isRemote)
+ {
+ return false;
+ }
+
+ TEDemonPortal tileEntity = (TEDemonPortal) world.getTileEntity(x, y, z);
+
+ tileEntity.rightClickBlock(player, side);
+
+ return false;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockHomHeart.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockHomHeart.java
new file mode 100644
index 00000000..730b31f3
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockHomHeart.java
@@ -0,0 +1,101 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import net.minecraft.block.BlockContainer;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.common.items.BlankSpell;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEHomHeart;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class BlockHomHeart extends BlockContainer
+{
+ public IIcon bottomIcon;
+ public IIcon topIcon;
+ public IIcon sideIcon;
+
+ public BlockHomHeart()
+ {
+ super(Material.rock);
+ setHardness(2.0F);
+ setResistance(5.0F);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ this.setBlockName("blockHomHeart");
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerBlockIcons(IIconRegister iconRegister)
+ {
+ this.topIcon = iconRegister.registerIcon("AlchemicalWizardry:HomHeart_top");
+ this.bottomIcon = iconRegister.registerIcon("AlchemicalWizardry:HomHeart_bottom");
+ this.sideIcon = iconRegister.registerIcon("AlchemicalWizardry:HomHeart_side");
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public IIcon getIcon(int side, int meta)
+ {
+ switch (side)
+ {
+ case 0:
+ return bottomIcon;
+
+ case 1:
+ return topIcon;
+
+ //case 2: return sideIcon1;
+ //case 3: return sideIcon1;
+ //case 4: return sideIcon2;
+ //case 5: return sideIcon2;
+ default:
+ return sideIcon;
+ }
+ }
+
+ @Override
+ public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int idk, float what, float these, float are)
+ {
+ TEHomHeart tileEntity = (TEHomHeart) world.getTileEntity(x, y, z);
+
+ if (tileEntity == null || player.isSneaking())
+ {
+ return false;
+ }
+
+ ItemStack playerItem = player.getCurrentEquippedItem();
+
+ if (playerItem != null)
+ {
+ if (playerItem.getItem() instanceof BlankSpell)
+ {
+ if (playerItem.stackTagCompound == null)
+ {
+ playerItem.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound itemTag = playerItem.stackTagCompound;
+ itemTag.setInteger("xCoord", x);
+ itemTag.setInteger("yCoord", y);
+ itemTag.setInteger("zCoord", z);
+ itemTag.setInteger("dimensionId", world.provider.dimensionId);
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ @Override
+ public TileEntity createNewTileEntity(World world, int metaMaybe)
+ {
+ return new TEHomHeart();
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockMasterStone.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockMasterStone.java
new file mode 100644
index 00000000..2744f58a
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockMasterStone.java
@@ -0,0 +1,84 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import net.minecraft.block.BlockContainer;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.common.items.ActivationCrystal;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEMasterStone;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class BlockMasterStone extends BlockContainer
+{
+ public BlockMasterStone()
+ {
+ super(Material.iron);
+ setHardness(2.0F);
+ setResistance(5.0F);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ this.setBlockName("blockMasterStone");
+ // TODO Auto-generated constructor stub
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerBlockIcons(IIconRegister iconRegister)
+ {
+ this.blockIcon = iconRegister.registerIcon("AlchemicalWizardry:MasterStone");
+ }
+
+ @Override
+ public void onBlockHarvested(World world, int x, int y, int z, int meta, EntityPlayer player)
+ {
+ TileEntity tile = world.getTileEntity(x, y, z);
+ if(tile instanceof TEMasterStone)
+ {
+ ((TEMasterStone) tile).useOnRitualBroken();
+ }
+
+ super.onBlockHarvested(world, x, y, z, meta, player);
+ }
+
+ @Override
+ public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int idk, float what, float these, float are)
+ {
+ TEMasterStone tileEntity = (TEMasterStone) world.getTileEntity(x, y, z);
+
+ if (tileEntity == null || player.isSneaking())
+ {
+ return false;
+ }
+
+ ItemStack playerItem = player.getCurrentEquippedItem();
+
+ if (playerItem == null)
+ {
+ return false;
+ }
+
+ Item item = playerItem.getItem();
+
+ if (!(item instanceof ActivationCrystal))
+ {
+ return false;
+ }
+
+ ActivationCrystal acItem = (ActivationCrystal) item;
+ tileEntity.setOwner(acItem.getOwnerName(playerItem));
+ tileEntity.activateRitual(world, acItem.getCrystalLevel(playerItem), player);
+ world.markBlockForUpdate(x, y, z);
+ return true;
+ }
+
+ @Override
+ public TileEntity createNewTileEntity(World world, int meta)
+ {
+ return new TEMasterStone();
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockOrientable.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockOrientable.java
new file mode 100644
index 00000000..fbc115c8
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockOrientable.java
@@ -0,0 +1,190 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import javax.swing.Icon;
+
+import net.minecraft.block.BlockContainer;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEOrientable;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class BlockOrientable extends BlockContainer
+{
+ public BlockOrientable()
+ {
+ super(Material.rock);
+ setHardness(2.0F);
+ setResistance(5.0F);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ //setUnlocalizedName("bloodSocket");
+ //func_111022_d("AlchemicalWizardry:blocks");
+ }
+
+// @Override
+// public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int idk, float what, float these, float are)
+// {
+// return false;
+// }
+
+ @Override
+ public TileEntity createNewTileEntity(World world, int dunno)
+ {
+ return new TEOrientable();
+ }
+
+ @Override
+ public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float what, float these, float are)
+ {
+ //Right-click orients the output face. Shift-right-click orients the input face.
+ if (world.isRemote)
+ {
+ return false;
+ }
+
+ ForgeDirection sideClicked = ForgeDirection.getOrientation(side);
+ TileEntity tile = world.getTileEntity(x, y, z);
+
+ if (tile instanceof TEOrientable)
+ {
+ TEOrientable newTile = (TEOrientable)tile;
+ if(player.isSneaking())
+ {
+ int nextSide = TEOrientable.getIntForForgeDirection(newTile.getInputDirection())+1;
+
+ if(nextSide>5)
+ {
+ nextSide = 0;
+ }
+ if(ForgeDirection.getOrientation(nextSide)==newTile.getOutputDirection())
+ {
+ nextSide++;
+ if(nextSide>5)
+ {
+ nextSide = 0;
+ }
+ }
+
+ newTile.setInputDirection(ForgeDirection.getOrientation(nextSide));
+ }else
+ {
+ int nextSide = TEOrientable.getIntForForgeDirection(newTile.getOutputDirection())+1;
+
+ if(nextSide>5)
+ {
+ nextSide = 0;
+ }
+ if(ForgeDirection.getOrientation(nextSide)==newTile.getInputDirection())
+ {
+ nextSide++;
+ if(nextSide>5)
+ {
+ nextSide = 0;
+ }
+ }
+
+ newTile.setOutputDirection(ForgeDirection.getOrientation(nextSide));
+ }
+ }
+
+ world.markBlockForUpdate(x, y, z);
+ return true;
+ }
+
+ public int getTextureIndexForSideAndOrientation(int side, ForgeDirection input, ForgeDirection output)
+ {
+ if(ForgeDirection.getOrientation(side) == input)
+ {
+ return 0;
+ }
+ if(ForgeDirection.getOrientation(side) == output)
+ {
+ return 1;
+ }
+ if(ForgeDirection.getOrientation(side) == output.getOpposite())
+ {
+ return 6;
+ }
+
+ switch(side)
+ {
+ case 0: //BOTTOM
+ switch(output)
+ {
+ case NORTH: return 2; //UP
+ case SOUTH: return 3; //DOWN
+ case EAST: return 4; //LEFT
+ case WEST: return 5; //RIGHT
+ default: break;
+ }
+ break;
+ case 1: //TOP
+ switch(output)
+ {
+ case NORTH: return 2; //UP
+ case SOUTH: return 3; //DOWN
+ case EAST: return 5;
+ case WEST: return 4;
+ default: break;
+ }
+ break;
+ case 2: //NORTH
+ switch(output)
+ {
+ case DOWN: return 3;
+ case UP: return 2;
+ case EAST: return 4;
+ case WEST: return 5;
+ default: break;
+ }
+ break;
+ case 3: //SOUTH
+ switch(output)
+ {
+ case DOWN: return 3;
+ case UP: return 2;
+ case EAST: return 5;
+ case WEST: return 4;
+ default: break;
+ }
+ break;
+ case 4: //WEST
+ switch(output)
+ {
+ case DOWN: return 3;
+ case UP: return 2;
+ case NORTH: return 5;
+ case SOUTH: return 4;
+ default: break;
+ }
+ break;
+ case 5: //EAST
+ switch(output)
+ {
+ case DOWN: return 3;
+ case UP: return 2;
+ case NORTH: return 4;
+ case SOUTH: return 5;
+ default: break;
+ }
+ break;
+ }
+
+ return 0;
+ }
+
+ @Override
+ public int damageDropped(int metadata)
+ {
+ return metadata;
+ }
+
+
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockPedestal.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockPedestal.java
new file mode 100644
index 00000000..85dc2d68
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockPedestal.java
@@ -0,0 +1,193 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import java.util.Random;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockContainer;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.util.Vec3;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEPedestal;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class BlockPedestal extends BlockContainer
+{
+ @SideOnly(Side.CLIENT)
+ private static IIcon topIcon;
+ @SideOnly(Side.CLIENT)
+ private static IIcon sideIcon1;
+ @SideOnly(Side.CLIENT)
+ private static IIcon sideIcon2;
+ @SideOnly(Side.CLIENT)
+ private static IIcon bottomIcon;
+
+ public BlockPedestal()
+ {
+ super(Material.rock);
+ setHardness(2.0F);
+ setResistance(5.0F);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ this.setBlockName("bloodPedestal");
+ //func_111022_d("AlchemicalWizardry:blocks");
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerBlockIcons(IIconRegister iconRegister)
+ {
+ this.topIcon = iconRegister.registerIcon("AlchemicalWizardry:ArcanePedestal");
+ this.sideIcon1 = iconRegister.registerIcon("AlchemicalWizardry:BloodSocket");
+ this.sideIcon2 = iconRegister.registerIcon("AlchemicalWizardry:BloodSocket");
+ this.bottomIcon = iconRegister.registerIcon("AlchemicalWizardry:BloodSocket");
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public IIcon getIcon(int side, int meta)
+ {
+ switch (side)
+ {
+ case 0:
+ return bottomIcon;
+
+ case 1:
+ return topIcon;
+
+ //case 2: return sideIcon1;
+ //case 3: return sideIcon1;
+ //case 4: return sideIcon2;
+ //case 5: return sideIcon2;
+ default:
+ return sideIcon2;
+ }
+ }
+
+ @Override
+ public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int idk, float what, float these, float are)
+ {
+ TEPedestal tileEntity = (TEPedestal) world.getTileEntity(x, y, z);
+
+ if (tileEntity == null || player.isSneaking())
+ {
+ return false;
+ }
+
+ ItemStack playerItem = player.getCurrentEquippedItem();
+
+ if (tileEntity.getStackInSlot(0) == null && playerItem != null)
+ {
+ ItemStack newItem = playerItem.copy();
+ newItem.stackSize = 1;
+ --playerItem.stackSize;
+ tileEntity.setInventorySlotContents(0, newItem);
+ } else if (tileEntity.getStackInSlot(0) != null && playerItem == null)
+ {
+ /**stub method
+ * Add the item that is in the slot to the player's inventory, and
+ * then set the slot to null.
+ */
+ player.inventory.addItemStackToInventory(tileEntity.getStackInSlot(0));
+ tileEntity.setInventorySlotContents(0, null);
+ tileEntity.setActive();
+ }
+
+ world.markBlockForUpdate(x, y, z);
+ //player.openGui(AlchemicalWizardry.instance, 0, world, x, y, z);
+ //PacketDispatcher.sendPacketToServer(tileEntity.getDescriptionPacket());
+ return true;
+ }
+
+ @Override
+ public void breakBlock(World world, int x, int y, int z, Block par5, int par6)
+ {
+ dropItems(world, x, y, z);
+ super.breakBlock(world, x, y, z, par5, par6);
+ }
+
+ private void dropItems(World world, int x, int y, int z)
+ {
+ Random rand = new Random();
+ TileEntity tileEntity = world.getTileEntity(x, y, z);
+
+ if (!(tileEntity instanceof IInventory))
+ {
+ return;
+ }
+
+ IInventory inventory = (IInventory) tileEntity;
+
+ for (int i = 0; i < inventory.getSizeInventory(); i++)
+ {
+ ItemStack item = inventory.getStackInSlot(i);
+
+ if (item != null && item.stackSize > 0)
+ {
+ float rx = rand.nextFloat() * 0.8F + 0.1F;
+ float ry = rand.nextFloat() * 0.8F + 0.1F;
+ float rz = rand.nextFloat() * 0.8F + 0.1F;
+ EntityItem entityItem = new EntityItem(world, x + rx, y + ry, z + rz, new ItemStack(item.getItem(), item.stackSize, item.getItemDamage()));
+
+ if (item.hasTagCompound())
+ {
+ entityItem.getEntityItem().setTagCompound((NBTTagCompound) item.getTagCompound().copy());
+ }
+
+ float factor = 0.05F;
+ entityItem.motionX = rand.nextGaussian() * factor;
+ entityItem.motionY = rand.nextGaussian() * factor + 0.2F;
+ entityItem.motionZ = rand.nextGaussian() * factor;
+ world.spawnEntityInWorld(entityItem);
+ item.stackSize = 0;
+ }
+ }
+ }
+
+ @Override
+ public TileEntity createNewTileEntity(World world, int meta)
+ {
+ return new TEPedestal();
+ }
+
+ @Override
+ public boolean renderAsNormalBlock()
+ {
+ return false;
+ }
+
+ @Override
+ public int getRenderType()
+ {
+ return -1;
+ }
+
+ @Override
+ public boolean isOpaqueCube()
+ {
+ return false;
+ }
+
+ @Override
+ public boolean hasTileEntity()
+ {
+ return true;
+ }
+
+ @Override
+ public MovingObjectPosition collisionRayTrace(World par1World, int par2, int par3, int par4, Vec3 par5Vec3, Vec3 par6Vec3)
+ {
+ float f = 0.3125F;
+ this.setBlockBounds(0.5F - f, 0.0F, 0.5F - f, 0.5F + f, 0.6F, 0.5F + f);
+ return super.collisionRayTrace(par1World, par2, par3, par4, par5Vec3, par6Vec3);
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockPlinth.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockPlinth.java
new file mode 100644
index 00000000..619f61f1
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockPlinth.java
@@ -0,0 +1,193 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import java.util.Random;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockContainer;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.util.Vec3;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEPlinth;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class BlockPlinth extends BlockContainer
+{
+ @SideOnly(Side.CLIENT)
+ private static IIcon topIcon;
+ @SideOnly(Side.CLIENT)
+ private static IIcon sideIcon1;
+ @SideOnly(Side.CLIENT)
+ private static IIcon sideIcon2;
+ @SideOnly(Side.CLIENT)
+ private static IIcon bottomIcon;
+
+ public BlockPlinth()
+ {
+ super(Material.rock);
+ setHardness(2.0F);
+ setResistance(5.0F);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ this.setBlockName("bloodPlinth");
+ //func_111022_d("AlchemicalWizardry:blocks");
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerBlockIcons(IIconRegister iconRegister)
+ {
+ this.topIcon = iconRegister.registerIcon("AlchemicalWizardry:ArcanePlinth");
+ this.sideIcon1 = iconRegister.registerIcon("AlchemicalWizardry:BloodSocket");
+ this.sideIcon2 = iconRegister.registerIcon("AlchemicalWizardry:BloodSocket");
+ this.bottomIcon = iconRegister.registerIcon("AlchemicalWizardry:BloodSocket");
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public IIcon getIcon(int side, int meta)
+ {
+ switch (side)
+ {
+ case 0:
+ return bottomIcon;
+
+ case 1:
+ return topIcon;
+
+ //case 2: return sideIcon1;
+ //case 3: return sideIcon1;
+ //case 4: return sideIcon2;
+ //case 5: return sideIcon2;
+ default:
+ return sideIcon2;
+ }
+ }
+
+ @Override
+ public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int idk, float what, float these, float are)
+ {
+ TEPlinth tileEntity = (TEPlinth) world.getTileEntity(x, y, z);
+
+ if (tileEntity == null || player.isSneaking())
+ {
+ return false;
+ }
+
+ ItemStack playerItem = player.getCurrentEquippedItem();
+
+ if (tileEntity.getStackInSlot(0) == null && playerItem != null)
+ {
+ ItemStack newItem = playerItem.copy();
+ newItem.stackSize = 1;
+ --playerItem.stackSize;
+ tileEntity.setInventorySlotContents(0, newItem);
+ } else if (tileEntity.getStackInSlot(0) != null && playerItem == null)
+ {
+ /**stub method
+ * Add the item that is in the slot to the player's inventory, and
+ * then set the slot to null.
+ */
+ player.inventory.addItemStackToInventory(tileEntity.getStackInSlot(0));
+ tileEntity.setInventorySlotContents(0, null);
+ tileEntity.setActive();
+ }
+
+ world.markBlockForUpdate(x, y, z);
+ //player.openGui(AlchemicalWizardry.instance, 0, world, x, y, z);
+ //PacketDispatcher.sendPacketToServer(tileEntity.getDescriptionPacket());
+ return true;
+ }
+
+ @Override
+ public void breakBlock(World world, int x, int y, int z, Block par5, int par6)
+ {
+ dropItems(world, x, y, z);
+ super.breakBlock(world, x, y, z, par5, par6);
+ }
+
+ private void dropItems(World world, int x, int y, int z)
+ {
+ Random rand = new Random();
+ TileEntity tileEntity = world.getTileEntity(x, y, z);
+
+ if (!(tileEntity instanceof IInventory))
+ {
+ return;
+ }
+
+ IInventory inventory = (IInventory) tileEntity;
+
+ for (int i = 0; i < inventory.getSizeInventory(); i++)
+ {
+ ItemStack item = inventory.getStackInSlot(i);
+
+ if (item != null && item.stackSize > 0)
+ {
+ float rx = rand.nextFloat() * 0.8F + 0.1F;
+ float ry = rand.nextFloat() * 0.8F + 0.1F;
+ float rz = rand.nextFloat() * 0.8F + 0.1F;
+ EntityItem entityItem = new EntityItem(world, x + rx, y + ry, z + rz, new ItemStack(item.getItem(), item.stackSize, item.getItemDamage()));
+
+ if (item.hasTagCompound())
+ {
+ entityItem.getEntityItem().setTagCompound((NBTTagCompound) item.getTagCompound().copy());
+ }
+
+ float factor = 0.05F;
+ entityItem.motionX = rand.nextGaussian() * factor;
+ entityItem.motionY = rand.nextGaussian() * factor + 0.2F;
+ entityItem.motionZ = rand.nextGaussian() * factor;
+ world.spawnEntityInWorld(entityItem);
+ item.stackSize = 0;
+ }
+ }
+ }
+
+ @Override
+ public TileEntity createNewTileEntity(World world, int meta)
+ {
+ return new TEPlinth();
+ }
+
+ @Override
+ public boolean renderAsNormalBlock()
+ {
+ return false;
+ }
+
+ @Override
+ public int getRenderType()
+ {
+ return -1;
+ }
+
+ @Override
+ public boolean isOpaqueCube()
+ {
+ return false;
+ }
+
+ @Override
+ public boolean hasTileEntity()
+ {
+ return true;
+ }
+
+ @Override
+ public MovingObjectPosition collisionRayTrace(World par1World, int par2, int par3, int par4, Vec3 par5Vec3, Vec3 par6Vec3)
+ {
+ float f = 0.0625F;
+ this.setBlockBounds(f, 0.0F, f, 1.0f - f, 0.875f, 1.0f - f);
+ return super.collisionRayTrace(par1World, par2, par3, par4, par5Vec3, par6Vec3);
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockReagentConduit.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockReagentConduit.java
new file mode 100644
index 00000000..83c5a91c
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockReagentConduit.java
@@ -0,0 +1,83 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import net.minecraft.block.BlockContainer;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEReagentConduit;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class BlockReagentConduit extends BlockContainer
+{
+ public BlockReagentConduit()
+ {
+ super(Material.cloth);
+ setHardness(2.0F);
+ setResistance(5.0F);
+ this.setBlockName("blockReagentConduit");
+ this.setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerBlockIcons(IIconRegister iconRegister)
+ {
+ this.blockIcon = iconRegister.registerIcon("AlchemicalWizardry:SimpleTransCircle");
+ }
+
+ @Override
+ public TileEntity createNewTileEntity(World world, int meta)
+ {
+ return new TEReagentConduit();
+ }
+
+ @Override
+ public boolean canProvidePower()
+ {
+ return true;
+ }
+
+// @Override
+// @SideOnly(Side.CLIENT)
+// public void getSubBlocks(Item par1, CreativeTabs par2CreativeTabs, List par3List)
+// {
+// if (this.equals(ModBlocks.blockSpellParadigm))
+// {
+// par3List.add(new ItemStack(par1, 1, 0));
+// par3List.add(new ItemStack(par1, 1, 1));
+// par3List.add(new ItemStack(par1, 1, 2));
+// par3List.add(new ItemStack(par1, 1, 3));
+// } else
+// {
+// super.getSubBlocks(par1, par2CreativeTabs, par3List);
+// }
+// }
+
+ @Override
+ public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float what, float these, float are)
+ {
+ return super.onBlockActivated(world, x, y, z, player, side, what, these, are);
+ }
+
+ @Override
+ public boolean isOpaqueCube()
+ {
+ return false;
+ }
+
+ @Override
+ public boolean renderAsNormalBlock()
+ {
+ return false;
+ }
+
+ @Override
+ public int getRenderType()
+ {
+ return -1;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockSchematicSaver.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockSchematicSaver.java
new file mode 100644
index 00000000..9c85e4fa
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockSchematicSaver.java
@@ -0,0 +1,43 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import net.minecraft.block.BlockContainer;
+import net.minecraft.block.material.Material;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEDemonPortal;
+import WayofTime.alchemicalWizardry.common.tileEntity.TESchematicSaver;
+
+public class BlockSchematicSaver extends BlockContainer
+{
+ public BlockSchematicSaver()
+ {
+ super(Material.rock);
+ setHardness(2.0F);
+ setResistance(5.0F);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ this.setBlockName("schematicSaver");
+ }
+
+ @Override
+ public TileEntity createNewTileEntity(World var1, int var2)
+ {
+ return new TESchematicSaver();
+ }
+
+ @Override
+ public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float what, float these, float are)
+ {
+ if(world.isRemote)
+ {
+ return false;
+ }
+
+ TESchematicSaver tileEntity = (TESchematicSaver) world.getTileEntity(x, y, z);
+
+ tileEntity.rightClickBlock(player, side);
+
+ return false;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockSocket.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockSocket.java
new file mode 100644
index 00000000..e4e53890
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockSocket.java
@@ -0,0 +1,163 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import java.util.Random;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockContainer;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.items.interfaces.ArmourUpgrade;
+import WayofTime.alchemicalWizardry.common.tileEntity.TESocket;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class BlockSocket extends BlockContainer
+{
+ @SideOnly(Side.CLIENT)
+ private static IIcon topIcon;
+ @SideOnly(Side.CLIENT)
+ private static IIcon sideIcon1;
+ @SideOnly(Side.CLIENT)
+ private static IIcon sideIcon2;
+ @SideOnly(Side.CLIENT)
+ private static IIcon bottomIcon;
+
+ public BlockSocket()
+ {
+ super(Material.rock);
+ setHardness(2.0F);
+ setResistance(5.0F);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ this.setBlockName("bloodSocket");
+ //func_111022_d("AlchemicalWizardry:blocks");
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerBlockIcons(IIconRegister iconRegister)
+ {
+ this.topIcon = iconRegister.registerIcon("AlchemicalWizardry:BloodSocket");
+ this.sideIcon1 = iconRegister.registerIcon("AlchemicalWizardry:BloodSocket");
+ this.sideIcon2 = iconRegister.registerIcon("AlchemicalWizardry:BloodSocket");
+ this.bottomIcon = iconRegister.registerIcon("AlchemicalWizardry:BloodSocket");
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public IIcon getIcon(int side, int meta)
+ {
+ switch (side)
+ {
+ case 0:
+ return bottomIcon;
+
+ case 1:
+ return topIcon;
+
+ //case 2: return sideIcon1;
+ //case 3: return sideIcon1;
+ //case 4: return sideIcon2;
+ //case 5: return sideIcon2;
+ default:
+ return sideIcon2;
+ }
+ }
+
+ @Override
+ public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int idk, float what, float these, float are)
+ {
+ TESocket tileEntity = (TESocket) world.getTileEntity(x, y, z);
+
+ if (tileEntity == null || player.isSneaking())
+ {
+ return false;
+ }
+
+ ItemStack playerItem = player.getCurrentEquippedItem();
+
+ if (tileEntity.getStackInSlot(0) == null && playerItem != null)
+ {
+ if (playerItem.getItem() instanceof ArmourUpgrade)
+ {
+ ItemStack newItem = playerItem.copy();
+ newItem.stackSize = 1;
+ --playerItem.stackSize;
+ tileEntity.setInventorySlotContents(0, newItem);
+ }
+ } else if (tileEntity.getStackInSlot(0) != null && playerItem == null)
+ {
+ /**stub method
+ * Add the item that is in the slot to the player's inventory, and
+ * then set the slot to null.
+ */
+ player.inventory.addItemStackToInventory(tileEntity.getStackInSlot(0));
+ tileEntity.setInventorySlotContents(0, null);
+ tileEntity.setActive();
+ }
+
+ world.markBlockForUpdate(x, y, z);
+ //player.openGui(AlchemicalWizardry.instance, 0, world, x, y, z);
+ //PacketDispatcher.sendPacketToServer(tileEntity.getDescriptionPacket());
+ return true;
+ }
+
+ @Override
+ public void breakBlock(World world, int x, int y, int z, Block par5, int par6)
+ {
+ dropItems(world, x, y, z);
+ super.breakBlock(world, x, y, z, par5, par6);
+ }
+
+ private void dropItems(World world, int x, int y, int z)
+ {
+ Random rand = new Random();
+ TileEntity tileEntity = world.getTileEntity(x, y, z);
+
+ if (!(tileEntity instanceof IInventory))
+ {
+ return;
+ }
+
+ IInventory inventory = (IInventory) tileEntity;
+
+ for (int i = 0; i < inventory.getSizeInventory(); i++)
+ {
+ ItemStack item = inventory.getStackInSlot(i);
+
+ if (item != null && item.stackSize > 0)
+ {
+ float rx = rand.nextFloat() * 0.8F + 0.1F;
+ float ry = rand.nextFloat() * 0.8F + 0.1F;
+ float rz = rand.nextFloat() * 0.8F + 0.1F;
+ EntityItem entityItem = new EntityItem(world, x + rx, y + ry, z + rz, new ItemStack(item.getItem(), item.stackSize, item.getItemDamage()));
+
+ if (item.hasTagCompound())
+ {
+ entityItem.getEntityItem().setTagCompound((NBTTagCompound) item.getTagCompound().copy());
+ }
+
+ float factor = 0.05F;
+ entityItem.motionX = rand.nextGaussian() * factor;
+ entityItem.motionY = rand.nextGaussian() * factor + 0.2F;
+ entityItem.motionZ = rand.nextGaussian() * factor;
+ world.spawnEntityInWorld(entityItem);
+ item.stackSize = 0;
+ }
+ }
+ }
+
+ @Override
+ public TileEntity createNewTileEntity(World world, int meta)
+ {
+ return new TESocket();
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockSpectralContainer.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockSpectralContainer.java
new file mode 100644
index 00000000..95a48ce3
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockSpectralContainer.java
@@ -0,0 +1,75 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import java.util.List;
+import java.util.Random;
+
+import net.minecraft.block.BlockContainer;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.Entity;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.common.tileEntity.TESpectralContainer;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class BlockSpectralContainer extends BlockContainer
+{
+ public BlockSpectralContainer()
+ {
+ super(Material.cloth);
+ //setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ this.setBlockName("blockSpectralContainer");
+ this.setBlockBounds(0,0,0,0,0,0);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerBlockIcons(IIconRegister iconRegister)
+ {
+ this.blockIcon = iconRegister.registerIcon("AlchemicalWizardry:BlockBloodLight");
+ }
+
+ @Override
+ public boolean isOpaqueCube()
+ {
+ return false;
+ }
+
+ @Override
+ public boolean renderAsNormalBlock()
+ {
+ return false;
+ }
+
+ @Override
+ public void addCollisionBoxesToList(World par1World, int par2, int par3, int par4, AxisAlignedBB par5AxisAlignedBB, List par6List, Entity par7Entity)
+ {
+
+ }
+
+ public int quantityDropped(Random par1Random)
+ {
+ return 0;
+ }
+
+ @Override
+ public boolean isReplaceable(IBlockAccess world, int x, int y, int z)
+ {
+ return true;
+ }
+
+ @Override
+ public boolean isAir(IBlockAccess world, int x, int y, int z)
+ {
+ return true;
+ }
+
+ @Override
+ public TileEntity createNewTileEntity(World var1, int var2)
+ {
+ return new TESpectralContainer();
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockSpellEffect.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockSpellEffect.java
new file mode 100644
index 00000000..14846d23
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockSpellEffect.java
@@ -0,0 +1,62 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import java.util.List;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.ModBlocks;
+import WayofTime.alchemicalWizardry.common.tileEntity.TESpellEffectBlock;
+
+
+public class BlockSpellEffect extends BlockOrientable
+{
+ public BlockSpellEffect()
+ {
+ super();
+ this.setBlockName("blockSpellEffect");
+ }
+
+ @Override
+ public TileEntity createNewTileEntity(World world, int meta)
+ {
+ return new TESpellEffectBlock();
+ }
+
+ @Override
+ public boolean renderAsNormalBlock()
+ {
+ return false;
+ }
+
+ @Override
+ public int getRenderType()
+ {
+ return -1;
+ }
+
+ @Override
+ public boolean isOpaqueCube()
+ {
+ return false;
+ }
+
+ @SideOnly(Side.CLIENT)
+ public void getSubBlocks(Item par1, CreativeTabs par2CreativeTabs, List par3List)
+ {
+ if (this.equals(ModBlocks.blockSpellEffect))
+ {
+ for(int i=0; i<4; i++)
+ {
+ par3List.add(new ItemStack(par1, 1, i));
+ }
+ } else
+ {
+ super.getSubBlocks(par1, par2CreativeTabs, par3List);
+ }
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockSpellEnhancement.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockSpellEnhancement.java
new file mode 100644
index 00000000..14dc4af5
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockSpellEnhancement.java
@@ -0,0 +1,64 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import java.util.List;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.ModBlocks;
+import WayofTime.alchemicalWizardry.common.tileEntity.TESpellEffectBlock;
+import WayofTime.alchemicalWizardry.common.tileEntity.TESpellEnhancementBlock;
+import WayofTime.alchemicalWizardry.common.tileEntity.TESpellModifierBlock;
+
+
+public class BlockSpellEnhancement extends BlockOrientable
+{
+ public BlockSpellEnhancement()
+ {
+ super();
+ this.setBlockName("blockSpellEnhancement");
+ }
+
+ @Override
+ public TileEntity createNewTileEntity(World world, int meta)
+ {
+ return new TESpellEnhancementBlock();
+ }
+
+ @Override
+ public boolean renderAsNormalBlock()
+ {
+ return false;
+ }
+
+ @Override
+ public int getRenderType()
+ {
+ return -1;
+ }
+
+ @Override
+ public boolean isOpaqueCube()
+ {
+ return false;
+ }
+
+ @SideOnly(Side.CLIENT)
+ public void getSubBlocks(Item par1, CreativeTabs par2CreativeTabs, List par3List)
+ {
+ if (this.equals(ModBlocks.blockSpellEnhancement))
+ {
+ for(int i=0; i<15; i++)
+ {
+ par3List.add(new ItemStack(par1, 1, i));
+ }
+ } else
+ {
+ super.getSubBlocks(par1, par2CreativeTabs, par3List);
+ }
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockSpellModifier.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockSpellModifier.java
new file mode 100644
index 00000000..ae4e028f
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockSpellModifier.java
@@ -0,0 +1,63 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import java.util.List;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.ModBlocks;
+import WayofTime.alchemicalWizardry.common.tileEntity.TESpellEffectBlock;
+import WayofTime.alchemicalWizardry.common.tileEntity.TESpellModifierBlock;
+
+
+public class BlockSpellModifier extends BlockOrientable
+{
+ public BlockSpellModifier()
+ {
+ super();
+ this.setBlockName("blockSpellModifier");
+ }
+
+ @Override
+ public TileEntity createNewTileEntity(World world, int meta)
+ {
+ return new TESpellModifierBlock();
+ }
+
+ @SideOnly(Side.CLIENT)
+ public void getSubBlocks(Item par1, CreativeTabs par2CreativeTabs, List par3List)
+ {
+ if (this.equals(ModBlocks.blockSpellModifier))
+ {
+ for(int i=0; i<4; i++)
+ {
+ par3List.add(new ItemStack(par1, 1, i));
+ }
+ } else
+ {
+ super.getSubBlocks(par1, par2CreativeTabs, par3List);
+ }
+ }
+
+ @Override
+ public boolean isOpaqueCube()
+ {
+ return false;
+ }
+
+ @Override
+ public boolean renderAsNormalBlock()
+ {
+ return false;
+ }
+
+ @Override
+ public int getRenderType()
+ {
+ return -1;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockSpellParadigm.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockSpellParadigm.java
new file mode 100644
index 00000000..f1945778
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockSpellParadigm.java
@@ -0,0 +1,96 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.ModBlocks;
+import WayofTime.alchemicalWizardry.common.items.ItemComplexSpellCrystal;
+import WayofTime.alchemicalWizardry.common.tileEntity.TESpellParadigmBlock;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class BlockSpellParadigm extends BlockOrientable
+{
+ public static final float minPos = (3f/16f);
+ public static final float maxPos = (13f/16f);
+
+ public BlockSpellParadigm()
+ {
+ super();
+ this.setBlockName("blockSpellParadigm");
+ }
+
+ @Override
+ public TileEntity createNewTileEntity(World world, int meta)
+ {
+ return new TESpellParadigmBlock();
+ }
+
+ @SideOnly(Side.CLIENT)
+
+ /**
+ * returns a list of items with the same ID, but different meta (eg: dye returns 16 items)
+ */
+ public void getSubBlocks(Item par1, CreativeTabs par2CreativeTabs, List par3List)
+ {
+ if (this.equals(ModBlocks.blockSpellParadigm))
+ {
+ par3List.add(new ItemStack(par1, 1, 0));
+ par3List.add(new ItemStack(par1, 1, 1));
+ par3List.add(new ItemStack(par1, 1, 2));
+ par3List.add(new ItemStack(par1, 1, 3));
+ } else
+ {
+ super.getSubBlocks(par1, par2CreativeTabs, par3List);
+ }
+ }
+
+ @Override
+ public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float what, float these, float are)
+ {
+ ItemStack stack = player.getCurrentEquippedItem();
+
+ if(stack != null && stack.getItem() instanceof ItemComplexSpellCrystal)
+ {
+ if (stack.stackTagCompound == null)
+ {
+ stack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound itemTag = stack.stackTagCompound;
+ itemTag.setInteger("xCoord", x);
+ itemTag.setInteger("yCoord", y);
+ itemTag.setInteger("zCoord", z);
+ itemTag.setInteger("dimensionId", world.provider.dimensionId);
+ return true;
+ }
+
+ return super.onBlockActivated(world, x, y, z, player, side, what, these, are);
+ }
+
+ @Override
+ public boolean isOpaqueCube()
+ {
+ return false;
+ }
+
+ @Override
+ public boolean renderAsNormalBlock()
+ {
+ return false;
+ }
+
+ @Override
+ public int getRenderType()
+ {
+ return -1;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockTeleposer.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockTeleposer.java
new file mode 100644
index 00000000..545535ee
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockTeleposer.java
@@ -0,0 +1,260 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import java.util.Random;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockContainer;
+import net.minecraft.block.BlockMobSpawner;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.common.items.TelepositionFocus;
+import WayofTime.alchemicalWizardry.common.tileEntity.TETeleposer;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class BlockTeleposer extends BlockContainer
+{
+ @SideOnly(Side.CLIENT)
+ private static IIcon topIcon;
+ @SideOnly(Side.CLIENT)
+ private static IIcon sideIcon1;
+ @SideOnly(Side.CLIENT)
+ private static IIcon sideIcon2;
+ @SideOnly(Side.CLIENT)
+ private static IIcon bottomIcon;
+
+ public BlockTeleposer()
+ {
+ super(Material.rock);
+ setHardness(2.0F);
+ setResistance(5.0F);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ this.setBlockName("bloodTeleposer");
+ //func_111022_d("AlchemicalWizardry:blocks");
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerBlockIcons(IIconRegister iconRegister)
+ {
+ this.topIcon = iconRegister.registerIcon("AlchemicalWizardry:Teleposer_Top");
+ this.sideIcon1 = iconRegister.registerIcon("AlchemicalWizardry:Teleposer_Side");
+ this.sideIcon2 = iconRegister.registerIcon("AlchemicalWizardry:Teleposer_Side");
+ this.bottomIcon = iconRegister.registerIcon("AlchemicalWizardry:Teleposer_Side");
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public IIcon getIcon(int side, int meta)
+ {
+ switch (side)
+ {
+ case 0:
+ return bottomIcon;
+
+ case 1:
+ return topIcon;
+
+ //case 2: return sideIcon1;
+ //case 3: return sideIcon1;
+ //case 4: return sideIcon2;
+ //case 5: return sideIcon2;
+ default:
+ return sideIcon2;
+ }
+ }
+
+ @Override
+ public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int idk, float what, float these, float are)
+ {
+ TETeleposer tileEntity = (TETeleposer) world.getTileEntity(x, y, z);
+ ItemStack playerItem = player.getCurrentEquippedItem();
+
+ if (playerItem != null)
+ {
+ if (playerItem.getItem() instanceof TelepositionFocus)
+ {
+ if (playerItem.stackTagCompound == null)
+ {
+ playerItem.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound itemTag = playerItem.stackTagCompound;
+ itemTag.setInteger("xCoord", x);
+ itemTag.setInteger("yCoord", y);
+ itemTag.setInteger("zCoord", z);
+ itemTag.setInteger("dimensionId", world.provider.dimensionId);
+ return true;
+ }
+ }
+
+ player.openGui(AlchemicalWizardry.instance, 1, world, x, y, z);
+// this.swapBlocks(world, x, y+1, z, x, y+2, z);
+//
+// world.markBlockForUpdate(x, y, z);
+ //player.openGui(AlchemicalWizardry.instance, 0, world, x, y, z);
+ //PacketDispatcher.sendPacketToServer(tileEntity.getDescriptionPacket());
+ return true;
+ }
+
+ @Override
+ public void breakBlock(World world, int x, int y, int z, Block par5, int par6)
+ {
+ dropItems(world, x, y, z);
+ super.breakBlock(world, x, y, z, par5, par6);
+ }
+
+ private void dropItems(World world, int x, int y, int z)
+ {
+ Random rand = new Random();
+ TileEntity tileEntity = world.getTileEntity(x, y, z);
+
+ if (!(tileEntity instanceof IInventory))
+ {
+ return;
+ }
+
+ IInventory inventory = (IInventory) tileEntity;
+
+ for (int i = 0; i < inventory.getSizeInventory(); i++)
+ {
+ ItemStack item = inventory.getStackInSlot(i);
+
+ if (item != null && item.stackSize > 0)
+ {
+ float rx = rand.nextFloat() * 0.8F + 0.1F;
+ float ry = rand.nextFloat() * 0.8F + 0.1F;
+ float rz = rand.nextFloat() * 0.8F + 0.1F;
+ EntityItem entityItem = new EntityItem(world, x + rx, y + ry, z + rz, new ItemStack(item.getItem(), item.stackSize, item.getItemDamage()));
+
+ if (item.hasTagCompound())
+ {
+ entityItem.getEntityItem().setTagCompound((NBTTagCompound) item.getTagCompound().copy());
+ }
+
+ float factor = 0.05F;
+ entityItem.motionX = rand.nextGaussian() * factor;
+ entityItem.motionY = rand.nextGaussian() * factor + 0.2F;
+ entityItem.motionZ = rand.nextGaussian() * factor;
+ world.spawnEntityInWorld(entityItem);
+ item.stackSize = 0;
+ }
+ }
+ }
+
+ @Override
+ public TileEntity createNewTileEntity(World world, int meta)
+ {
+ return new TETeleposer();
+ }
+
+ public static boolean swapBlocks(World worldI, World worldF, int xi, int yi, int zi, int xf, int yf, int zf)
+ {
+ TileEntity tileEntityI = worldI.getTileEntity(xi, yi, zi);
+ TileEntity tileEntityF = worldF.getTileEntity(xf, yf, zf);
+ TileEntity tileI;
+ TileEntity tileF;
+
+ NBTTagCompound nbttag1 = new NBTTagCompound();
+ NBTTagCompound nbttag2 = new NBTTagCompound();
+
+ if (tileEntityI != null)
+ {
+ tileEntityI.writeToNBT(nbttag1);
+ }
+
+ if (tileEntityF != null)
+ {
+ tileEntityF.writeToNBT(nbttag2);
+ }
+
+ Block blockI = worldI.getBlock(xi, yi, zi);
+ Block blockF = worldF.getBlock(xf, yf, zf);
+
+
+ if (blockI.equals(Blocks.air) && blockF.equals(Blocks.air))
+ {
+ return false;
+ }
+
+ if (blockI instanceof BlockMobSpawner || blockF instanceof BlockMobSpawner)
+ {
+ return false;
+ }
+
+ int metaI = worldI.getBlockMetadata(xi, yi, zi);
+ int metaF = worldF.getBlockMetadata(xf, yf, zf);
+ worldI.playSoundEffect(xi, yi, zi, "mob.endermen.portal", 1.0F, 1.0F);
+ worldF.playSoundEffect(xf, yf, zf, "mob.endermen.portal", 1.0F, 1.0F);
+ //CLEAR TILES
+ Block finalBlock = blockF;
+
+ if (finalBlock != null)
+ {
+ TileEntity tileToSet = finalBlock.createTileEntity(worldF, metaF);
+
+ worldF.setTileEntity(xf, yf, zf, tileToSet);
+ }
+
+ Block initialBlock = blockI;
+
+ if (initialBlock != null)
+ {
+ TileEntity tileToSet = initialBlock.createTileEntity(worldI, metaI);
+
+ worldI.setTileEntity(xi, yi, zi, tileToSet);
+ }
+
+ //TILES CLEARED
+// worldF.destroyBlock(xf, yf, zf, false);
+// worldI.destroyBlock(xi, yi, zi, false);
+// worldI.setBlockToAir(xi, yi, zi);
+// worldF.setBlockToAir(xf, yf, zf);
+
+ worldF.setBlock(xf, yf, zf, initialBlock, metaI, 3);
+
+ if (tileEntityI != null)
+ {
+ TileEntity newTileEntityI = TileEntity.createAndLoadEntity(nbttag1);
+ worldF.setTileEntity(xf, yf, zf, newTileEntityI);
+ newTileEntityI.xCoord = xf;
+ newTileEntityI.yCoord = yf;
+ newTileEntityI.zCoord = zf;
+
+// TileEntity tile = worldI.getTileEntity(xf, yf, zf);
+// if(tile instanceof TileMultipart)
+// {
+// TileMultipart.createFromNBT(nbttag1);
+// }
+ }
+
+ worldI.setBlock(xi, yi, zi, finalBlock, metaF, 3);
+
+ if (tileEntityF != null)
+ {
+ TileEntity newTileEntityF = TileEntity.createAndLoadEntity(nbttag2);
+ worldI.setTileEntity(xi, yi, zi, newTileEntityF);
+ newTileEntityF.xCoord = xi;
+ newTileEntityF.yCoord = yi;
+ newTileEntityF.zCoord = zi;
+
+ TileEntity tile = worldI.getTileEntity(xi, yi, zi);
+// if(tile instanceof TileMultipart)
+// {
+// TileMultipart.createFromNBT(nbttag2);
+// }
+ }
+
+ return true;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockWritingTable.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockWritingTable.java
new file mode 100644
index 00000000..e7890015
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BlockWritingTable.java
@@ -0,0 +1,181 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import java.util.List;
+import java.util.Random;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockContainer;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEWritingTable;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class BlockWritingTable extends BlockContainer
+{
+ @SideOnly(Side.CLIENT)
+ private static IIcon topIcon;
+ @SideOnly(Side.CLIENT)
+ private static IIcon sideIcon1;
+ @SideOnly(Side.CLIENT)
+ private static IIcon sideIcon2;
+ @SideOnly(Side.CLIENT)
+ private static IIcon bottomIcon;
+
+ public BlockWritingTable()
+ {
+ super(Material.wood);
+ setHardness(2.0F);
+ setResistance(5.0F);
+ this.setBlockName("blockWritingTable");
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerBlockIcons(IIconRegister iconRegister)
+ {
+ this.topIcon = iconRegister.registerIcon("AlchemicalWizardry:AlchemicChemistrySet");
+ this.sideIcon1 = iconRegister.registerIcon("AlchemicalWizardry:BloodAltar_SideType1");
+ this.sideIcon2 = iconRegister.registerIcon("AlchemicalWizardry:BloodAltar_SideType2");
+ this.bottomIcon = iconRegister.registerIcon("AlchemicalWizardry:BloodAltar_Bottom");
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public IIcon getIcon(int side, int meta)
+ {
+ switch (side)
+ {
+ case 0:
+ return bottomIcon;
+
+ case 1:
+ return topIcon;
+
+ //case 2: return sideIcon1;
+ //case 3: return sideIcon1;
+ //case 4: return sideIcon2;
+ //case 5: return sideIcon2;
+ default:
+ return sideIcon2;
+ }
+ }
+
+ @Override
+ public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int metadata, float what, float these, float are)
+ {
+ TileEntity tileEntity = world.getTileEntity(x, y, z);
+
+ if (tileEntity == null || player.isSneaking())
+ {
+ return false;
+ }
+
+ //code to open gui explained later
+ player.openGui(AlchemicalWizardry.instance, 0, world, x, y, z);
+ return true;
+ }
+
+ @Override
+ public void breakBlock(World world, int x, int y, int z, Block par5, int par6)
+ {
+ dropItems(world, x, y, z);
+ super.breakBlock(world, x, y, z, par5, par6);
+ }
+
+ private void dropItems(World world, int x, int y, int z)
+ {
+ Random rand = new Random();
+ TileEntity tileEntity = world.getTileEntity(x, y, z);
+
+ if (!(tileEntity instanceof IInventory))
+ {
+ return;
+ }
+
+ IInventory inventory = (IInventory) tileEntity;
+
+ for (int i = 0; i < inventory.getSizeInventory(); i++)
+ {
+ ItemStack item = inventory.getStackInSlot(i);
+
+ if (item != null && item.stackSize > 0)
+ {
+ float rx = rand.nextFloat() * 0.8F + 0.1F;
+ float ry = rand.nextFloat() * 0.8F + 0.1F;
+ float rz = rand.nextFloat() * 0.8F + 0.1F;
+ EntityItem entityItem = new EntityItem(world,
+ x + rx, y + ry, z + rz,
+ new ItemStack(item.getItem(), item.stackSize, item.getItemDamage()));
+
+ if (item.hasTagCompound())
+ {
+ entityItem.getEntityItem().setTagCompound((NBTTagCompound) item.getTagCompound().copy());
+ }
+
+ float factor = 0.05F;
+ entityItem.motionX = rand.nextGaussian() * factor;
+ entityItem.motionY = rand.nextGaussian() * factor + 0.2F;
+ entityItem.motionZ = rand.nextGaussian() * factor;
+ world.spawnEntityInWorld(entityItem);
+ item.stackSize = 0;
+ }
+ }
+ }
+
+ @Override
+ public TileEntity createNewTileEntity(World world, int meta)
+ {
+ return new TEWritingTable();
+ }
+
+ @Override
+ public boolean renderAsNormalBlock()
+ {
+ return false;
+ }
+
+ @Override
+ public int getRenderType()
+ {
+ return -1;
+ }
+
+ @Override
+ public boolean isOpaqueCube()
+ {
+ return false;
+ }
+
+ @Override
+ public boolean hasTileEntity()
+ {
+ return true;
+ }
+
+ @Override
+ public void addCollisionBoxesToList(World par1World, int par2, int par3, int par4, AxisAlignedBB par5AxisAlignedBB, List par6List, Entity par7Entity)
+ {
+ this.setBlockBounds(0.4375F, 0.0F, 0.4375F, 0.5625F, 0.9375F, 0.5625F);
+ super.addCollisionBoxesToList(par1World, par2, par3, par4, par5AxisAlignedBB, par6List, par7Entity);
+ this.setBlockBoundsForItemRender();
+ super.addCollisionBoxesToList(par1World, par2, par3, par4, par5AxisAlignedBB, par6List, par7Entity);
+ }
+
+ public void setBlockBoundsForItemRender()
+ {
+ this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.125F, 1.0F);
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BloodRune.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BloodRune.java
new file mode 100644
index 00000000..b5df0d22
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BloodRune.java
@@ -0,0 +1,121 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import java.util.List;
+
+import javax.swing.Icon;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.IIcon;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.ModBlocks;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class BloodRune extends Block
+{
+ //private Icon bloodRuneIcon;
+ private IIcon altarCapacityRuneIcon;
+ private IIcon dislocationRuneIcon;
+ private IIcon orbCapacityRuneIcon;
+ private IIcon betterCapacityRuneIcon;
+
+ public BloodRune()
+ {
+ super(Material.iron);
+ this.setBlockName("bloodRune");
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ setHardness(2.0F);
+ setResistance(5.0F);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerBlockIcons(IIconRegister iconRegister)
+ {
+ this.blockIcon = iconRegister.registerIcon("AlchemicalWizardry:BlankRune");
+ this.altarCapacityRuneIcon = iconRegister.registerIcon("AlchemicalWizardry:AltarCapacityRune");
+ this.dislocationRuneIcon = iconRegister.registerIcon("AlchemicalWizardry:DislocationRune");
+ this.orbCapacityRuneIcon = iconRegister.registerIcon("AlchemicalWizardry:OrbCapacityRune");
+ this.betterCapacityRuneIcon = iconRegister.registerIcon("AlchemicalWizardry:BetterCapacityRune");
+ }
+
+ public int getRuneEffect(int metaData)
+ {
+ switch (metaData)
+ {
+ case 0:
+ return 0;
+
+ case 1: //Altar Capacity rune
+ return 5;
+
+ case 2: //Filling/emptying rune
+ return 6;
+
+ case 3: //Orb Capacity rune
+ return 7;
+
+ case 4: //Better Capacity rune
+ return 8;
+ }
+
+ return 0;
+ }
+
+ @SideOnly(Side.CLIENT)
+
+ /**
+ * returns a list of items with the same ID, but different meta (eg: dye returns 16 items)
+ */
+ public void getSubBlocks(Item par1, CreativeTabs par2CreativeTabs, List par3List)
+ {
+ if (this.equals(ModBlocks.bloodRune))
+ {
+ par3List.add(new ItemStack(par1, 1, 0));
+ par3List.add(new ItemStack(par1, 1, 1));
+ par3List.add(new ItemStack(par1, 1, 2));
+ par3List.add(new ItemStack(par1, 1, 3));
+ par3List.add(new ItemStack(par1, 1, 4));
+ } else
+ {
+ super.getSubBlocks(par1, par2CreativeTabs, par3List);
+ }
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public IIcon getIcon(int side, int meta)
+ {
+ switch (meta)
+ {
+ case 0:
+ return blockIcon;
+
+ case 1:
+ return altarCapacityRuneIcon;
+
+ case 2:
+ return dislocationRuneIcon;
+
+ case 3:
+ return this.orbCapacityRuneIcon;
+
+ case 4:
+ return this.betterCapacityRuneIcon;
+
+ default:
+ return blockIcon;
+ }
+ }
+
+ @Override
+ public int damageDropped(int metadata)
+ {
+ return metadata;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BloodStoneBrick.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BloodStoneBrick.java
new file mode 100644
index 00000000..0e33c138
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/BloodStoneBrick.java
@@ -0,0 +1,27 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class BloodStoneBrick extends Block
+{
+ public BloodStoneBrick()
+ {
+ super(Material.iron);
+ setHardness(2.0F);
+ setResistance(5.0F);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ this.setBlockName("bloodStoneBrick");
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerBlockIcons(IIconRegister iconRegister)
+ {
+ this.blockIcon = iconRegister.registerIcon("AlchemicalWizardry:BloodStoneBrick");
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/EfficiencyRune.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/EfficiencyRune.java
new file mode 100644
index 00000000..337b3e90
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/EfficiencyRune.java
@@ -0,0 +1,31 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class EfficiencyRune extends BloodRune
+{
+ public EfficiencyRune()
+ {
+ super();
+ this.setBlockName("efficiencyRune");
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ setHardness(2.0F);
+ setResistance(5.0F);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerBlockIcons(IIconRegister iconRegister)
+ {
+ this.blockIcon = iconRegister.registerIcon("AlchemicalWizardry:EfficiencyRune");
+ }
+
+ @Override
+ public int getRuneEffect(int metaData)
+ {
+ return 2;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/EmptySocket.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/EmptySocket.java
new file mode 100644
index 00000000..ec78e760
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/EmptySocket.java
@@ -0,0 +1,34 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class EmptySocket extends Block
+{
+ public EmptySocket()
+ {
+ super(Material.iron);
+ setHardness(2.0F);
+ setResistance(5.0F);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ this.setBlockName("emptySocket");
+ // TODO Auto-generated constructor stub
+ }
+
+ @Override
+ public boolean isOpaqueCube()
+ {
+ return false;
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerBlockIcons(IIconRegister iconRegister)
+ {
+ this.blockIcon = iconRegister.registerIcon("AlchemicalWizardry:EmptySocket");
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/IOrientable.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/IOrientable.java
new file mode 100644
index 00000000..93b170b0
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/IOrientable.java
@@ -0,0 +1,14 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import net.minecraftforge.common.util.ForgeDirection;
+
+public interface IOrientable
+{
+ public ForgeDirection getInputDirection();
+
+ public ForgeDirection getOutputDirection();
+
+ public void setInputDirection(ForgeDirection direction);
+
+ public void setOutputDirection(ForgeDirection direction);
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/ImperfectRitualStone.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/ImperfectRitualStone.java
new file mode 100644
index 00000000..224f4d55
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/ImperfectRitualStone.java
@@ -0,0 +1,142 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.effect.EntityLightningBolt;
+import net.minecraft.entity.monster.EntityZombie;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.potion.Potion;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.common.PacketHandler;
+import WayofTime.alchemicalWizardry.common.items.EnergyItems;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class ImperfectRitualStone extends Block
+{
+ public ImperfectRitualStone()
+ {
+ super(Material.iron);
+ setHardness(2.0F);
+ setResistance(5.0F);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ this.setBlockName("imperfectRitualStone");
+ // TODO Auto-generated constructor stub
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerBlockIcons(IIconRegister iconRegister)
+ {
+ this.blockIcon = iconRegister.registerIcon("AlchemicalWizardry:ImperfectRitualStone");
+ }
+
+ @Override
+ public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float xOff, float yOff, float zOff)
+ {
+ //ItemStack ist = player.getItemInUse();
+ //if (!world.isRemote)
+ {
+ Block block = world.getBlock(x, y + 1, z);
+
+ if (block == Blocks.water)
+ {
+ if (!player.capabilities.isCreativeMode && !world.isRemote)
+ {
+ EnergyItems.drainPlayerNetwork(player, 5000);
+ }
+
+ if (!world.isRemote)
+ {
+ world.addWeatherEffect(new EntityLightningBolt(world, x, y + 2, z));
+// if (!player.capabilities.isCreativeMode)
+// {
+// PacketDispatcher.sendPacketToServer(PacketHandler.getPacket(player.getEntityName(), -5000, 0));
+// }
+ }
+
+ world.getWorldInfo().setRaining(true);
+
+ if (world.isRemote)
+ {
+ world.setRainStrength(1.0F);
+ world.setThunderStrength(1.0f);
+ }
+
+ world.getWorldInfo().setThunderTime(0);
+ world.getWorldInfo().setThundering(true);
+ return true;
+ } else if (block == Blocks.coal_block)
+ {
+ if (!player.capabilities.isCreativeMode && !world.isRemote)
+ {
+ EnergyItems.drainPlayerNetwork(player, 5000);
+ }
+
+ //EntityFallenAngel zomb = new EntityFallenAngel(world);
+ EntityZombie zomb = new EntityZombie(world);
+ zomb.setPosition(x + 0.5, y + 2, z + 0.5);
+ // zomb.setCurrentItemOrArmor(4, new ItemStack(Item.helmetIron.itemID,1,0));
+ // zomb.setCurrentItemOrArmor(3, new ItemStack(Item.plateIron.itemID,1,0));
+ // zomb.setCurrentItemOrArmor(2, new ItemStack(Item.legsIron.itemID,1,0));
+ // zomb.setCurrentItemOrArmor(1, new ItemStack(Item.bootsIron.itemID,1,0));
+ //zomb.setCurrentItemOrArmor(0, new ItemStack(AlchemicalWizardry.energySword.itemID,1,0));
+ zomb.addPotionEffect(new PotionEffect(Potion.fireResistance.id, 2000));
+ zomb.addPotionEffect(new PotionEffect(Potion.damageBoost.id, 20000, 7));
+ zomb.addPotionEffect(new PotionEffect(Potion.resistance.id, 20000, 3));
+
+ if (!world.isRemote)
+ {
+ world.spawnEntityInWorld(zomb);
+ world.addWeatherEffect(new EntityLightningBolt(world, x, y + 2, z));
+// if (!player.capabilities.isCreativeMode)
+// {
+// PacketDispatcher.sendPacketToServer(PacketHandler.getPacket(player.getEntityName(), -5000, 0));
+// }
+ }
+
+ return true;
+ } else if (block== Blocks.lapis_block)
+ {
+ if (!player.capabilities.isCreativeMode && !world.isRemote)
+ {
+ EnergyItems.drainPlayerNetwork(player, 5000);
+ }
+
+ if (!world.isRemote)
+ {
+ world.addWeatherEffect(new EntityLightningBolt(world, x, y + 2, z));
+ world.setWorldTime((world.getWorldTime() / 24000) * 24000 + 13800);
+// if (!player.capabilities.isCreativeMode)
+// {
+// PacketDispatcher.sendPacketToServer(PacketHandler.getPacket(player.getEntityName(), -5000, 0));
+// }
+ }
+ } else if (block == Blocks.bedrock)
+ {
+ if (!player.capabilities.isCreativeMode && !world.isRemote)
+ {
+ EnergyItems.drainPlayerNetwork(player, 5000);
+ }
+
+ if (!world.isRemote)
+ {
+ world.addWeatherEffect(new EntityLightningBolt(world, x, y + 2, z));
+ //world.setWorldTime((world.getWorldTime()/24000)*24000+13800);
+// if (!player.capabilities.isCreativeMode)
+// {
+// PacketDispatcher.sendPacketToServer(PacketHandler.getPacket(player.getEntityName(), -5000, 0));
+// }
+ }
+
+ player.addPotionEffect(new PotionEffect(Potion.resistance.id, 60 * 20, 1));
+ }
+ }
+ return false;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/LargeBloodStoneBrick.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/LargeBloodStoneBrick.java
new file mode 100644
index 00000000..1969c452
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/LargeBloodStoneBrick.java
@@ -0,0 +1,27 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class LargeBloodStoneBrick extends Block
+{
+ public LargeBloodStoneBrick()
+ {
+ super(Material.iron);
+ setHardness(2.0F);
+ setResistance(5.0F);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ this.setBlockName("largeBloodStoneBrick");
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerBlockIcons(IIconRegister iconRegister)
+ {
+ this.blockIcon = iconRegister.registerIcon("AlchemicalWizardry:LargeBloodStoneBrick");
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/LifeEssenceBlock.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/LifeEssenceBlock.java
new file mode 100644
index 00000000..34676410
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/LifeEssenceBlock.java
@@ -0,0 +1,62 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+import net.minecraftforge.fluids.BlockFluidClassic;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class LifeEssenceBlock extends BlockFluidClassic
+{
+ public LifeEssenceBlock()
+ {
+ super(AlchemicalWizardry.lifeEssenceFluid, Material.water);
+ AlchemicalWizardry.lifeEssenceFluid.setBlock(this);
+
+ //setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ this.setBlockName("lifeEssenceFluidBlock");
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public IIcon getIcon(int side, int meta)
+ {
+ return this.blockIcon;
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerBlockIcons(IIconRegister iconRegister)
+ {
+ this.blockIcon = iconRegister.registerIcon("AlchemicalWizardry:lifeEssenceStill");
+ AlchemicalWizardry.lifeEssenceFluid.setFlowingIcon(blockIcon);
+ AlchemicalWizardry.lifeEssenceFluid.setStillIcon(blockIcon);
+ //this.getFluid().setIcons(blockIcon);
+ }
+
+ @Override
+ public boolean canDisplace(IBlockAccess world, int x, int y, int z)
+ {
+ if (world.getBlock(x, y, z).getMaterial().isLiquid())
+ {
+ return false;
+ }
+
+ return super.canDisplace(world, x, y, z);
+ }
+
+ @Override
+ public boolean displaceIfPossible(World world, int x, int y, int z)
+ {
+ if (world.getBlock(x, y, z).getMaterial().isLiquid())
+ {
+ return false;
+ }
+
+ return super.displaceIfPossible(world, x, y, z);
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/RitualStone.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/RitualStone.java
new file mode 100644
index 00000000..a847c360
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/RitualStone.java
@@ -0,0 +1,121 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.rituals.IRitualStone;
+import WayofTime.alchemicalWizardry.common.items.ScribeTool;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class RitualStone extends Block implements IRitualStone
+{
+ @SideOnly(Side.CLIENT)
+ private static IIcon blankIcon;
+ @SideOnly(Side.CLIENT)
+ private static IIcon waterStoneIcon;
+ @SideOnly(Side.CLIENT)
+ private static IIcon fireStoneIcon;
+ @SideOnly(Side.CLIENT)
+ private static IIcon earthStoneIcon;
+ @SideOnly(Side.CLIENT)
+ private static IIcon airStoneIcon;
+ @SideOnly(Side.CLIENT)
+ private static IIcon duskStoneIcon;
+
+ public RitualStone()
+ {
+ super(Material.iron);
+ setHardness(2.0F);
+ setResistance(5.0F);
+ this.setBlockName("ritualStone");
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerBlockIcons(IIconRegister iconRegister)
+ {
+ this.blankIcon = iconRegister.registerIcon("AlchemicalWizardry:RitualStone");
+ this.waterStoneIcon = iconRegister.registerIcon("AlchemicalWizardry:WaterRitualStone");
+ this.fireStoneIcon = iconRegister.registerIcon("AlchemicalWizardry:FireRitualStone");
+ this.earthStoneIcon = iconRegister.registerIcon("AlchemicalWizardry:EarthRitualStone");
+ this.airStoneIcon = iconRegister.registerIcon("AlchemicalWizardry:AirRitualStone");
+ this.duskStoneIcon = iconRegister.registerIcon("AlchemicalWizardry:DuskRitualStone");
+ }
+
+ @Override
+ public int damageDropped(int metadata)
+ {
+ return 0;
+ }
+
+ @Override
+ public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int idk, float what, float these, float are)
+ {
+ ItemStack playerItem = player.getCurrentEquippedItem();
+
+ if (playerItem == null)
+ {
+ return false;
+ }
+
+ Item item = playerItem.getItem();
+
+ if (!(item instanceof ScribeTool))
+ {
+ return false;
+ }
+
+ if (playerItem.getMaxDamage() <= playerItem.getItemDamage() && !(playerItem.getMaxDamage() == 0))
+ {
+ return false;
+ }
+
+ ScribeTool scribeTool = (ScribeTool) item;
+
+ if (!player.capabilities.isCreativeMode)
+ {
+ playerItem.setItemDamage(playerItem.getItemDamage() + 1);
+ }
+
+ world.setBlockMetadataWithNotify(x, y, z, scribeTool.getType(), 3);
+ world.markBlockForUpdate(x, y, z);
+ return true;
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public IIcon getIcon(int side, int metadata)
+ {
+ switch (metadata)
+ {
+ case 0:
+ return blankIcon;
+
+ case 1:
+ return waterStoneIcon;
+
+ case 2:
+ return fireStoneIcon;
+
+ case 3:
+ return earthStoneIcon;
+
+ case 4:
+ return airStoneIcon;
+
+ case 5:
+ return duskStoneIcon;
+
+ default:
+ return blankIcon;
+ }
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/RuneOfSacrifice.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/RuneOfSacrifice.java
new file mode 100644
index 00000000..d06ec80f
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/RuneOfSacrifice.java
@@ -0,0 +1,31 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class RuneOfSacrifice extends BloodRune
+{
+ public RuneOfSacrifice()
+ {
+ super();
+ this.setBlockName("runeOfSacrifice");
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ setHardness(2.0F);
+ setResistance(5.0F);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerBlockIcons(IIconRegister iconRegister)
+ {
+ this.blockIcon = iconRegister.registerIcon("AlchemicalWizardry:RuneOfSacrifice");
+ }
+
+ @Override
+ public int getRuneEffect(int metaData)
+ {
+ return 3;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/RuneOfSelfSacrifice.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/RuneOfSelfSacrifice.java
new file mode 100644
index 00000000..4032044d
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/RuneOfSelfSacrifice.java
@@ -0,0 +1,31 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class RuneOfSelfSacrifice extends BloodRune
+{
+ public RuneOfSelfSacrifice()
+ {
+ super();
+ this.setBlockName("runeOfSelfSacrifice");
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ setHardness(2.0F);
+ setResistance(5.0F);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerBlockIcons(IIconRegister iconRegister)
+ {
+ this.blockIcon = iconRegister.registerIcon("AlchemicalWizardry:RuneOfSelfSacrifice");
+ }
+
+ @Override
+ public int getRuneEffect(int metaData)
+ {
+ return 4;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/SpectralBlock.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/SpectralBlock.java
new file mode 100644
index 00000000..d3ceb131
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/SpectralBlock.java
@@ -0,0 +1,120 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import java.util.Random;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockContainer;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.Facing;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.common.tileEntity.TESpectralBlock;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class SpectralBlock extends BlockContainer
+{
+ public SpectralBlock()
+ {
+ super(Material.rock);
+ this.setBlockName("spectralBlock");
+ }
+
+// @Override
+// public int tickRate(World par1World)
+// {
+// return 10;
+// }
+
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerBlockIcons(IIconRegister iconRegister)
+ {
+ this.blockIcon = iconRegister.registerIcon("AlchemicalWizardry:SpectralBlock");
+ }
+
+ @Override
+ public boolean isOpaqueCube()
+ {
+ Block d;
+ return false;
+ }
+
+ @Override
+ public int quantityDropped(Random par1Random)
+ {
+ return 0;
+ }
+
+ @SideOnly(Side.CLIENT)
+ public boolean shouldSideBeRendered(IBlockAccess p_149646_1_, int p_149646_2_, int p_149646_3_, int p_149646_4_, int p_149646_5_)
+ {
+ Block block = p_149646_1_.getBlock(p_149646_2_, p_149646_3_, p_149646_4_);
+
+ if (p_149646_1_.getBlockMetadata(p_149646_2_, p_149646_3_, p_149646_4_) != p_149646_1_.getBlockMetadata(p_149646_2_ - Facing.offsetsXForSide[p_149646_5_], p_149646_3_ - Facing.offsetsYForSide[p_149646_5_], p_149646_4_ - Facing.offsetsZForSide[p_149646_5_]))
+ {
+ return true;
+ }
+
+ if (block == this)
+ {
+ return false;
+ }
+
+ return block == this ? false : super.shouldSideBeRendered(p_149646_1_, p_149646_2_, p_149646_3_, p_149646_4_, p_149646_5_);
+ }
+
+ @SideOnly(Side.CLIENT)
+ /**
+ * Returns which pass should this block be rendered on. 0 for solids and 1 for alpha
+ */
+ public int getRenderBlockPass()
+ {
+ return 1;
+ }
+
+ @Override
+ public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int idk, float what, float these, float are)
+ {
+ //TEAltar tileEntity = (TEAltar)world.getBlockTileEntity(x, y, z);
+ if (player.isSneaking())
+ {
+ return false;
+ }
+
+ ItemStack playerItem = player.getCurrentEquippedItem();
+
+ if (playerItem != null)
+ {
+ if (playerItem.getItem() instanceof ItemBlock)
+ {
+ world.setBlock(x, y, z, ((ItemBlock)(playerItem.getItem())).field_150939_a, playerItem.getItemDamage(), 3);
+
+ if (!player.capabilities.isCreativeMode)
+ {
+ playerItem.stackSize--;
+ }
+
+ return true;
+ } else
+ {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ @Override
+ public TileEntity createNewTileEntity(World p_149915_1_, int p_149915_2_)
+ {
+ return new TESpectralBlock();
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/SpeedRune.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/SpeedRune.java
new file mode 100644
index 00000000..0680b066
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/block/SpeedRune.java
@@ -0,0 +1,31 @@
+package WayofTime.alchemicalWizardry.common.block;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class SpeedRune extends BloodRune
+{
+ public SpeedRune()
+ {
+ super();
+ this.setBlockName("speedRune");
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ setHardness(2.0F);
+ setResistance(5.0F);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerBlockIcons(IIconRegister iconRegister)
+ {
+ this.blockIcon = iconRegister.registerIcon("AlchemicalWizardry:SpeedRune");
+ }
+
+ @Override
+ public int getRuneEffect(int metaData)
+ {
+ return 1;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/bloodAltarUpgrade/AltarComponent.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/bloodAltarUpgrade/AltarComponent.java
new file mode 100644
index 00000000..4aeb4e75
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/bloodAltarUpgrade/AltarComponent.java
@@ -0,0 +1,60 @@
+package WayofTime.alchemicalWizardry.common.bloodAltarUpgrade;
+
+import net.minecraft.block.Block;
+
+public class AltarComponent
+{
+ private int x;
+ private int y;
+ private int z;
+ private Block block;
+ private int metadata;
+ private boolean isBloodRune;
+ private boolean isUpgradeSlot;
+
+ public AltarComponent(int x, int y, int z, Block block, int metadata, boolean isBloodRune, boolean isUpgradeSlot)
+ {
+ this.x = x;
+ this.y = y;
+ this.z = z;
+ this.block = block;
+ this.metadata = metadata;
+ this.isBloodRune = isBloodRune;
+ this.isUpgradeSlot = isUpgradeSlot;
+ }
+
+ public int getX()
+ {
+ return x;
+ }
+
+ public int getY()
+ {
+ return y;
+ }
+
+ public int getZ()
+ {
+ return z;
+ }
+
+ public Block getBlock()
+ {
+ return block;
+ }
+
+ public int getMetadata()
+ {
+ return metadata;
+ }
+
+ public boolean isBloodRune()
+ {
+ return isBloodRune;
+ }
+
+ public boolean isUpgradeSlot()
+ {
+ return isUpgradeSlot;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/bloodAltarUpgrade/AltarUpgradeComponent.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/bloodAltarUpgrade/AltarUpgradeComponent.java
new file mode 100644
index 00000000..f6e231c2
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/bloodAltarUpgrade/AltarUpgradeComponent.java
@@ -0,0 +1,105 @@
+package WayofTime.alchemicalWizardry.common.bloodAltarUpgrade;
+
+public class AltarUpgradeComponent
+{
+ private int speedUpgrades;
+ private int efficiencyUpgrades;
+ private int sacrificeUpgrades;
+ private int selfSacrificeUpgrades;
+ private int displacementUpgrades;
+ private int altarCapacitiveUpgrades;
+ private int orbCapacitiveUpgrades;
+ private int betterCapacitiveUpgrades;
+
+ public AltarUpgradeComponent()
+ {
+ speedUpgrades = 0;
+ efficiencyUpgrades = 0;
+ sacrificeUpgrades = 0;
+ selfSacrificeUpgrades = 0;
+ displacementUpgrades = 0;
+ altarCapacitiveUpgrades = 0;
+ orbCapacitiveUpgrades = 0;
+ betterCapacitiveUpgrades = 0;
+ }
+
+ public void addSpeedUpgrade()
+ {
+ speedUpgrades++;
+ }
+
+ public void addEfficiencyUpgrade()
+ {
+ efficiencyUpgrades++;
+ }
+
+ public void addSacrificeUpgrade()
+ {
+ sacrificeUpgrades++;
+ }
+
+ public void addSelfSacrificeUpgrade()
+ {
+ selfSacrificeUpgrades++;
+ }
+
+ public void addDisplacementUpgrade()
+ {
+ displacementUpgrades++;
+ }
+
+ public void addaltarCapacitiveUpgrade()
+ {
+ altarCapacitiveUpgrades++;
+ }
+
+ public void addorbCapacitiveUpgrade()
+ {
+ orbCapacitiveUpgrades++;
+ }
+
+ public void addBetterCapacitiveUpgrade()
+ {
+ betterCapacitiveUpgrades++;
+ }
+
+ public int getSpeedUpgrades()
+ {
+ return speedUpgrades;
+ }
+
+ public int getEfficiencyUpgrades()
+ {
+ return efficiencyUpgrades;
+ }
+
+ public int getSacrificeUpgrades()
+ {
+ return sacrificeUpgrades;
+ }
+
+ public int getSelfSacrificeUpgrades()
+ {
+ return selfSacrificeUpgrades;
+ }
+
+ public int getDisplacementUpgrades()
+ {
+ return displacementUpgrades;
+ }
+
+ public int getAltarCapacitiveUpgrades()
+ {
+ return this.altarCapacitiveUpgrades;
+ }
+
+ public int getOrbCapacitiveUpgrades()
+ {
+ return this.orbCapacitiveUpgrades;
+ }
+
+ public int getBetterCapacitiveUpgrades()
+ {
+ return this.betterCapacitiveUpgrades;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/bloodAltarUpgrade/UpgradedAltars.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/bloodAltarUpgrade/UpgradedAltars.java
new file mode 100644
index 00000000..4c5ea30d
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/bloodAltarUpgrade/UpgradedAltars.java
@@ -0,0 +1,300 @@
+package WayofTime.alchemicalWizardry.common.bloodAltarUpgrade;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.init.Blocks;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.ModBlocks;
+import WayofTime.alchemicalWizardry.common.block.BloodRune;
+
+public class UpgradedAltars
+{
+ public static List secondTierAltar = new ArrayList();
+ public static List thirdTierAltar = new ArrayList();
+ public static List fourthTierAltar = new ArrayList();
+ public static List fifthTierAltar = new ArrayList();
+ public static int highestAltar = 5;
+
+ public static int isAltarValid(World world, int x, int y, int z)
+ {
+ for (int i = highestAltar; i >= 2; i--)
+ {
+ if (checkAltarIsValid(world, x, y, z, i))
+ {
+ return i;
+ }
+ }
+
+ return 1;
+ }
+
+ public static boolean checkAltarIsValid(World world, int x, int y, int z, int altarTier)
+ {
+ switch (altarTier)
+ {
+ case 1:
+ return true;
+
+ case 2:
+ for (AltarComponent ac : secondTierAltar)
+ {
+ if (ac.isBloodRune())
+ {
+ Block testBlock = world.getBlock(x + ac.getX(), y + ac.getY(), z + ac.getZ());
+
+ if (!(testBlock instanceof BloodRune))
+ {
+ return false;
+ }
+ } else
+ {
+ Block block = world.getBlock(x + ac.getX(), y + ac.getY(), z + ac.getZ());
+ int metadata = world.getBlockMetadata(x + ac.getX(), y + ac.getY(), z + ac.getZ());
+
+ if (((ac.getBlock() != block) || (ac.getMetadata() != metadata)) && !(ac.getBlock() == Blocks.stonebrick && !world.isAirBlock(x + ac.getX(), y + ac.getY(), z + ac.getZ())))
+ {
+ return false;
+ }
+ }
+ }
+
+ return true;
+
+ case 3:
+ for (AltarComponent ac : thirdTierAltar)
+ {
+ if (ac.isBloodRune())
+ {
+ Block testBlock = world.getBlock(x + ac.getX(), y + ac.getY(), z + ac.getZ());
+
+ if (!(testBlock instanceof BloodRune))
+ {
+ return false;
+ }
+ } else
+ {
+ Block block = world.getBlock(x + ac.getX(), y + ac.getY(), z + ac.getZ());
+ int metadata = world.getBlockMetadata(x + ac.getX(), y + ac.getY(), z + ac.getZ());
+
+ if (((ac.getBlock() != block) || (ac.getMetadata() != metadata)) && !(ac.getBlock() == Blocks.stonebrick && !world.isAirBlock(x + ac.getX(), y + ac.getY(), z + ac.getZ())))
+ {
+ return false;
+ }
+ }
+ }
+
+ return true;
+
+ case 4:
+ for (AltarComponent ac : fourthTierAltar)
+ {
+ if (ac.isBloodRune())
+ {
+ Block testBlock = world.getBlock(x + ac.getX(), y + ac.getY(), z + ac.getZ());
+
+ if (!(testBlock instanceof BloodRune))
+ {
+ return false;
+ }
+ } else
+ {
+ Block block = world.getBlock(x + ac.getX(), y + ac.getY(), z + ac.getZ());
+ int metadata = world.getBlockMetadata(x + ac.getX(), y + ac.getY(), z + ac.getZ());
+
+ if (((ac.getBlock() != block) || (ac.getMetadata() != metadata)) && !(ac.getBlock() == Blocks.stonebrick && !world.isAirBlock(x + ac.getX(), y + ac.getY(), z + ac.getZ())))
+ {
+ return false;
+ }
+ }
+ }
+
+ return true;
+
+ case 5:
+ for (AltarComponent ac : fifthTierAltar)
+ {
+ if (ac.isBloodRune())
+ {
+ Block testBlock = world.getBlock(x + ac.getX(), y + ac.getY(), z + ac.getZ());
+
+ if (!(testBlock instanceof BloodRune))
+ {
+ return false;
+ }
+ } else
+ {
+ Block block = world.getBlock(x + ac.getX(), y + ac.getY(), z + ac.getZ());
+ int metadata = world.getBlockMetadata(x + ac.getX(), y + ac.getY(), z + ac.getZ());
+
+ if (((ac.getBlock() != block) || (ac.getMetadata() != metadata)) && !(ac.getBlock() == Blocks.stonebrick && !world.isAirBlock(x + ac.getX(), y + ac.getY(), z + ac.getZ())))
+ {
+ return false;
+ }
+ }
+ }
+
+ return true;
+
+ default:
+ return false;
+ }
+ }
+
+ public static AltarUpgradeComponent getUpgrades(World world, int x, int y, int z, int altarTier)
+ {
+ AltarUpgradeComponent upgrades = new AltarUpgradeComponent();
+ List list = UpgradedAltars.getAltarUpgradeListForTier(altarTier);
+
+ for (AltarComponent ac : list)
+ {
+ if (ac.isUpgradeSlot())
+ {
+ //Currently checks the getRuneEffect.
+ //TODO Change so that it uses the metadata instead, with the BlockID.
+ Block testBlock = world.getBlock(x + ac.getX(), y + ac.getY(), z + ac.getZ());
+
+ if (testBlock instanceof BloodRune)
+ {
+ if (!world.isRemote)
+ {
+ switch (((BloodRune) testBlock).getRuneEffect(world.getBlockMetadata(x + ac.getX(), y + ac.getY(), z + ac.getZ())))
+ {
+ case 1:
+ upgrades.addSpeedUpgrade();
+ break;
+
+ case 2:
+ upgrades.addEfficiencyUpgrade();
+ break;
+
+ case 3:
+ upgrades.addSacrificeUpgrade();
+ break;
+
+ case 4:
+ upgrades.addSelfSacrificeUpgrade();
+ break;
+
+ case 5:
+ upgrades.addaltarCapacitiveUpgrade();
+ break;
+
+ case 6:
+ upgrades.addDisplacementUpgrade();
+ break;
+
+ case 7:
+ upgrades.addorbCapacitiveUpgrade();
+ break;
+
+ case 8:
+ upgrades.addBetterCapacitiveUpgrade();
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ return upgrades;
+ }
+
+ public static void loadAltars()
+ {
+ secondTierAltar.add(new AltarComponent(-1, -1, -1, ModBlocks.bloodRune, 0, true, false));
+ secondTierAltar.add(new AltarComponent(0, -1, -1, ModBlocks.bloodRune, 0, true, true));
+ secondTierAltar.add(new AltarComponent(1, -1, -1, ModBlocks.bloodRune, 0, true, false));
+ secondTierAltar.add(new AltarComponent(-1, -1, 0, ModBlocks.bloodRune, 0, true, true));
+ secondTierAltar.add(new AltarComponent(1, -1, 0, ModBlocks.bloodRune, 0, true, true));
+ secondTierAltar.add(new AltarComponent(-1, -1, 1, ModBlocks.bloodRune, 0, true, false));
+ secondTierAltar.add(new AltarComponent(0, -1, 1, ModBlocks.bloodRune, 0, true, true));
+ secondTierAltar.add(new AltarComponent(1, -1, 1, ModBlocks.bloodRune, 0, true, false));
+ thirdTierAltar.add(new AltarComponent(-1, -1, -1, ModBlocks.bloodRune, 0, true, true));
+ thirdTierAltar.add(new AltarComponent(0, -1, -1, ModBlocks.bloodRune, 0, true, true));
+ thirdTierAltar.add(new AltarComponent(1, -1, -1, ModBlocks.bloodRune, 0, true, true));
+ thirdTierAltar.add(new AltarComponent(-1, -1, 0, ModBlocks.bloodRune, 0, true, true));
+ thirdTierAltar.add(new AltarComponent(1, -1, 0, ModBlocks.bloodRune, 0, true, true));
+ thirdTierAltar.add(new AltarComponent(-1, -1, 1, ModBlocks.bloodRune, 0, true, true));
+ thirdTierAltar.add(new AltarComponent(0, -1, 1, ModBlocks.bloodRune, 0, true, true));
+ thirdTierAltar.add(new AltarComponent(1, -1, 1, ModBlocks.bloodRune, 0, true, true));
+ thirdTierAltar.add(new AltarComponent(-3, -1, -3, Blocks.stonebrick, 0, false, false));
+ thirdTierAltar.add(new AltarComponent(-3, 0, -3, Blocks.stonebrick, 0, false, false));
+ thirdTierAltar.add(new AltarComponent(3, -1, -3, Blocks.stonebrick, 0, false, false));
+ thirdTierAltar.add(new AltarComponent(3, 0, -3, Blocks.stonebrick, 0, false, false));
+ thirdTierAltar.add(new AltarComponent(-3, -1, 3, Blocks.stonebrick, 0, false, false));
+ thirdTierAltar.add(new AltarComponent(-3, 0, 3, Blocks.stonebrick, 0, false, false));
+ thirdTierAltar.add(new AltarComponent(3, -1, 3, Blocks.stonebrick, 0, false, false));
+ thirdTierAltar.add(new AltarComponent(3, 0, 3, Blocks.stonebrick, 0, false, false));
+ thirdTierAltar.add(new AltarComponent(-3, 1, -3, Blocks.glowstone, 0, false, false));
+ thirdTierAltar.add(new AltarComponent(3, 1, -3, Blocks.glowstone, 0, false, false));
+ thirdTierAltar.add(new AltarComponent(-3, 1, 3, Blocks.glowstone, 0, false, false));
+ thirdTierAltar.add(new AltarComponent(3, 1, 3, Blocks.glowstone, 0, false, false));
+
+ for (int i = -2; i <= 2; i++)
+ {
+ thirdTierAltar.add(new AltarComponent(3, -2, i, ModBlocks.bloodRune, 0, true, true));
+ thirdTierAltar.add(new AltarComponent(-3, -2, i, ModBlocks.bloodRune, 0, true, true));
+ thirdTierAltar.add(new AltarComponent(i, -2, 3, ModBlocks.bloodRune, 0, true, true));
+ thirdTierAltar.add(new AltarComponent(i, -2, -3, ModBlocks.bloodRune, 0, true, true));
+ }
+
+ fourthTierAltar.addAll(thirdTierAltar);
+
+ for (int i = -3; i <= 3; i++)
+ {
+ fourthTierAltar.add(new AltarComponent(5, -3, i, ModBlocks.bloodRune, 0, true, true));
+ fourthTierAltar.add(new AltarComponent(-5, -3, i, ModBlocks.bloodRune, 0, true, true));
+ fourthTierAltar.add(new AltarComponent(i, -3, 5, ModBlocks.bloodRune, 0, true, true));
+ fourthTierAltar.add(new AltarComponent(i, -3, -5, ModBlocks.bloodRune, 0, true, true));
+ }
+
+ for (int i = -2; i <= 1; i++)
+ {
+ fourthTierAltar.add(new AltarComponent(5, i, 5, Blocks.stonebrick, 0, false, false));
+ fourthTierAltar.add(new AltarComponent(5, i, -5, Blocks.stonebrick, 0, false, false));
+ fourthTierAltar.add(new AltarComponent(-5, i, -5, Blocks.stonebrick, 0, false, false));
+ fourthTierAltar.add(new AltarComponent(-5, i, 5, Blocks.stonebrick, 0, false, false));
+ }
+
+ fourthTierAltar.add(new AltarComponent(5, 2, 5, ModBlocks.largeBloodStoneBrick, 0, false, false));
+ fourthTierAltar.add(new AltarComponent(5, 2, -5, ModBlocks.largeBloodStoneBrick, 0, false, false));
+ fourthTierAltar.add(new AltarComponent(-5, 2, -5, ModBlocks.largeBloodStoneBrick, 0, false, false));
+ fourthTierAltar.add(new AltarComponent(-5, 2, 5, ModBlocks.largeBloodStoneBrick, 0, false, false));
+ fifthTierAltar.addAll(fourthTierAltar);
+ fifthTierAltar.add(new AltarComponent(-8, -3, 8, Blocks.beacon, 0, false, false));
+ fifthTierAltar.add(new AltarComponent(-8, -3, -8, Blocks.beacon, 0, false, false));
+ fifthTierAltar.add(new AltarComponent(8, -3, 8, Blocks.beacon, 0, false, false));
+ fifthTierAltar.add(new AltarComponent(8, -3, 8, Blocks.beacon, 0, false, false));
+
+ for (int i = -6; i <= 6; i++)
+ {
+ fifthTierAltar.add(new AltarComponent(8, -4, i, ModBlocks.bloodRune, 0, true, true));
+ fifthTierAltar.add(new AltarComponent(-8, -4, i, ModBlocks.bloodRune, 0, true, true));
+ fifthTierAltar.add(new AltarComponent(i, -4, 8, ModBlocks.bloodRune, 0, true, true));
+ fifthTierAltar.add(new AltarComponent(i, -4, -8, ModBlocks.bloodRune, 0, true, true));
+ }
+ }
+
+ public static List getAltarUpgradeListForTier(int tier)
+ {
+ switch (tier)
+ {
+ case 2:
+ return secondTierAltar;
+
+ case 3:
+ return thirdTierAltar;
+
+ case 4:
+ return fourthTierAltar;
+
+ case 5:
+ return fifthTierAltar;
+ }
+
+ return null;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/demonVillage/BlockSet.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/demonVillage/BlockSet.java
new file mode 100644
index 00000000..25398812
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/demonVillage/BlockSet.java
@@ -0,0 +1,195 @@
+package WayofTime.alchemicalWizardry.common.demonVillage;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockStairs;
+import net.minecraft.init.Blocks;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+import WayofTime.alchemicalWizardry.common.Int3;
+import cpw.mods.fml.common.registry.GameRegistry;
+import cpw.mods.fml.common.registry.GameRegistry.UniqueIdentifier;
+
+public class BlockSet
+{
+ protected String blockid;
+ protected int[] metadata;
+ protected List positions;
+
+ public BlockSet()
+ {
+ this(Blocks.stone);
+ }
+
+ public BlockSet(String blockid)
+ {
+ this.blockid = blockid;
+ this.metadata = new int[4];
+ positions = new ArrayList();
+ }
+
+ public BlockSet(Block block)
+ {
+ this(BlockSet.getPairedIdForBlock(block));
+ }
+
+ public BlockSet(Block block, int meta)
+ {
+ this(block);
+ for(int i=0; i getPositions()
+ {
+ return positions;
+ }
+
+ public void addPositionToBlock(int xOffset, int yOffset, int zOffset)
+ {
+ positions.add(new Int3(xOffset, yOffset, zOffset));
+ }
+
+ public Block getBlock()
+ {
+ return this.getBlockForString(blockid);
+ }
+
+ public static String getPairedIdForBlock(Block block)
+ {
+ UniqueIdentifier un = GameRegistry.findUniqueIdentifierFor(block);
+ String name = "";
+
+ if(un != null)
+ {
+ name = un.modId + ":" + un.name;
+ }
+
+ return name;
+ }
+
+ public static Block getBlockForString(String str)
+ {
+ String[] parts = str.split(":");
+ String modId = parts[0];
+ String name = parts[1];
+ return GameRegistry.findBlock(modId, name);
+ }
+
+ public int getMetaForDirection(ForgeDirection dir)
+ {
+ if(metadata.length < 4)
+ {
+ return 0;
+ }
+
+ switch(dir)
+ {
+ case NORTH:
+ return metadata[0];
+ case SOUTH:
+ return metadata[1];
+ case WEST:
+ return metadata[2];
+ case EAST:
+ return metadata[3];
+ default:
+ return 0;
+ }
+ }
+
+ public void buildAtIndex(World world, int xCoord, int yCoord, int zCoord, ForgeDirection dir, int index)
+ {
+ Block block = this.getBlock();
+ if(index >= positions.size() || block == null)
+ {
+ return;
+ }
+
+ Int3 position = positions.get(index);
+ int xOff = position.xCoord;
+ int yOff = position.yCoord;
+ int zOff = position.zCoord;
+ int meta = this.getMetaForDirection(dir);
+
+ switch(dir)
+ {
+ case NORTH:
+ break;
+ case SOUTH:
+ xOff *= -1;
+ zOff *= -1;
+ break;
+ case WEST:
+ int temp = zOff;
+ zOff = xOff * -1;
+ xOff = temp;
+ break;
+ case EAST:
+ int temp2 = zOff * -1;
+ zOff = xOff;
+ xOff = temp2;
+ break;
+ default:
+ }
+
+ world.setBlock(xCoord + xOff, yCoord + yOff, zCoord + zOff, block, meta, 3);
+ }
+
+ public void buildAll(World world, int xCoord, int yCoord, int zCoord, ForgeDirection dir)
+ {
+ for(int i=0; i blockList;
+
+ public BuildingSchematic()
+ {
+ this("");
+ }
+
+ public BuildingSchematic(String name)
+ {
+ this.name = name;
+ blockList = new ArrayList();
+ this.doorX = 0;
+ this.doorZ = 0;
+ this.doorY = 0;
+ this.buildingTier = 0;
+ this.buildingType = DemonBuilding.BUILDING_HOUSE;
+ }
+
+ public void addBlockWithMeta(Block block, int meta, int xOffset, int yOffset, int zOffset)
+ {
+ for(BlockSet set : blockList)
+ {
+ if(set.isContained(block, meta))
+ {
+ set.addPositionToBlock(xOffset, yOffset, zOffset);
+ return;
+ }
+ }
+
+ BlockSet set = new BlockSet(block, meta);
+ set.addPositionToBlock(xOffset, yOffset, zOffset);
+ blockList.add(set);
+ }
+
+ public void buildAll(World world, int xCoord, int yCoord, int zCoord, ForgeDirection dir)
+ {
+ for(BlockSet set : blockList)
+ {
+ set.buildAll(world, xCoord, yCoord, zCoord, dir);
+ }
+ }
+
+ public GridSpaceHolder createGSH()
+ {
+ GridSpaceHolder holder = new GridSpaceHolder();
+
+ for(BlockSet set : blockList)
+ {
+ for(Int3 coords : set.getPositions())
+ {
+ int gridX = (int)((coords.xCoord+2*Math.signum(coords.xCoord))/5);
+ int gridZ = (int)((coords.zCoord+2*Math.signum(coords.zCoord))/5);
+
+ holder.setGridSpace(gridX, gridZ, new GridSpace(GridSpace.HOUSE,0));
+ }
+ }
+
+ return holder;
+ }
+
+ public Int3 getGridSpotOfDoor()
+ {
+ int gridX = (int)((doorX+2*Math.signum(doorX))/5);
+ int gridZ = (int)((doorZ+2*Math.signum(doorZ))/5);
+
+ return new Int3(gridX, doorY, gridZ);
+ }
+
+ public List getGriddedPositions(ForgeDirection dir)
+ {
+ List positionList = new ArrayList();
+
+ for(BlockSet blockSet : blockList)
+ {
+ for(Int3 pos : blockSet.getPositions())
+ {
+ int xOff = pos.xCoord;
+ int zOff = pos.zCoord;
+
+ switch(dir)
+ {
+ case SOUTH:
+ xOff *= -1;
+ zOff *= -1;
+ break;
+ case WEST:
+ int temp = zOff;
+ zOff = xOff * -1;
+ xOff = temp;
+ break;
+ case EAST:
+ int temp2 = zOff * -1;
+ zOff = xOff;
+ xOff = temp2;
+ break;
+ default:
+ }
+
+ Int3 nextPos = new Int3(xOff, 0, zOff);
+ if(!positionList.contains(nextPos))
+ {
+ positionList.add(nextPos);
+ }
+ }
+ }
+
+ return positionList;
+ }
+
+ public void destroyAllInField(World world, int xCoord, int yCoord, int zCoord, ForgeDirection dir)
+ {
+ GridSpaceHolder grid = this.createGSH(); //GridSpaceHolder is not aware of the buildings - need to use the schematic
+
+ List positionList = getGriddedPositions(dir);
+
+ for(int i=this.getMinY(); i<=this.getMaxY(); i++)
+ {
+ for(Int3 pos : positionList)
+ {
+ Block block = world.getBlock(xCoord + pos.xCoord, yCoord + i, zCoord + pos.zCoord);
+ if(block != ModBlocks.blockDemonPortal)
+ {
+ world.setBlockToAir(xCoord + pos.xCoord, yCoord + i, zCoord + pos.zCoord);
+ }
+ }
+
+ //grid.destroyAllInGridSpaces(world, xCoord, yCoord + i, zCoord, dir); //Deprecated method
+ }
+ }
+
+ public int getMinY()
+ {
+ int min = 0;
+ for(BlockSet set : blockList)
+ {
+ for(Int3 pos : set.getPositions())
+ {
+ if(pos.yCoord < min)
+ {
+ min = pos.yCoord;
+ }
+ }
+ }
+
+ return min;
+ }
+
+ public int getMaxY()
+ {
+ int max = 0;
+ for(BlockSet set : blockList)
+ {
+ for(Int3 pos : set.getPositions())
+ {
+ if(pos.yCoord > max)
+ {
+ max = pos.yCoord;
+ }
+ }
+ }
+
+ return max;
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/demonVillage/DemonBuilding.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/demonVillage/DemonBuilding.java
new file mode 100644
index 00000000..b0777a46
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/demonVillage/DemonBuilding.java
@@ -0,0 +1,120 @@
+package WayofTime.alchemicalWizardry.common.demonVillage;
+
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+import WayofTime.alchemicalWizardry.common.Int3;
+
+public class DemonBuilding
+{
+ public static final int BUILDING_HOUSE = 0;
+ public static final int BUILDING_PORTAL = 1;
+
+ public BuildingSchematic schematic;
+ public GridSpaceHolder area;
+ public int buildingTier;
+ public int buildingType;
+ public Int3 doorGridSpace;
+
+ public DemonBuilding(BuildingSchematic schematic)
+ {
+ this.schematic = schematic;
+ this.buildingType = schematic.buildingType;
+ this.buildingTier = schematic.buildingTier;
+ this.area = this.createGSHForSchematic(schematic);
+ this.doorGridSpace = schematic.getGridSpotOfDoor();
+ }
+
+ public String getName()
+ {
+ return schematic.name;
+ }
+
+ public boolean isValid(GridSpaceHolder master, int gridX, int gridZ, ForgeDirection dir)
+ {
+ return area.doesContainAll(master, gridX, gridZ, dir);
+ }
+
+ public void buildAll(World world, int xCoord, int yCoord, int zCoord, ForgeDirection dir)
+ {
+ schematic.buildAll(world, xCoord, yCoord, zCoord, dir);
+ }
+
+ public void setAllGridSpaces(int xInit, int zInit, int yLevel, ForgeDirection dir, int type, GridSpaceHolder master)
+ {
+ area.setAllGridSpaces(xInit, zInit, yLevel, dir, type, master);
+ }
+
+ public GridSpaceHolder createGSHForSchematic(BuildingSchematic scheme)
+ {
+ switch(this.buildingType)
+ {
+ case DemonBuilding.BUILDING_HOUSE:
+ return scheme.createGSH();
+ case DemonBuilding.BUILDING_PORTAL:
+
+ }
+ return scheme.createGSH();
+ }
+
+ public Int3 getDoorSpace(ForgeDirection dir)
+ {
+ int x = 0;
+ int z = 0;
+ switch(dir)
+ {
+ case SOUTH:
+ x = -doorGridSpace.xCoord;
+ z = -doorGridSpace.zCoord;
+ break;
+ case WEST:
+ x = doorGridSpace.zCoord;
+ z = -doorGridSpace.xCoord;
+ break;
+ case EAST:
+ x = -doorGridSpace.zCoord;
+ z = doorGridSpace.xCoord;
+ break;
+ default:
+ x = doorGridSpace.xCoord;
+ z = doorGridSpace.zCoord;
+ break;
+ }
+
+ return new Int3(x, doorGridSpace.yCoord, z);
+ }
+
+ public Int3 getGridOffsetFromRoad(ForgeDirection sideOfRoad, int yLevel)
+ {
+ Int3 doorSpace = this.getDoorSpace(sideOfRoad);
+ int x = doorSpace.xCoord;
+ int z = doorSpace.zCoord;
+
+ switch(sideOfRoad)
+ {
+ case SOUTH:
+ z++;
+ break;
+ case EAST:
+ x++;
+ break;
+ case WEST:
+ x--;
+ break;
+ default:
+ z--;
+ break;
+ }
+
+ return new Int3(x, yLevel, z);
+ }
+
+ public void destroyAllInField(World world, int xCoord, int yCoord, int zCoord, ForgeDirection dir)
+ {
+ schematic.destroyAllInField(world, xCoord, yCoord, zCoord, dir);
+ }
+
+ public int getNumberOfGridSpaces()
+ {
+ return area.getNumberOfGridSpaces();
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/demonVillage/DemonCrosspath.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/demonVillage/DemonCrosspath.java
new file mode 100644
index 00000000..3b8a7a71
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/demonVillage/DemonCrosspath.java
@@ -0,0 +1,22 @@
+package WayofTime.alchemicalWizardry.common.demonVillage;
+
+import net.minecraft.world.World;
+
+public class DemonCrosspath
+{
+ private int xCoord;
+ private int yLevel;
+ private int zCoord;
+
+ public DemonCrosspath(int xCoord, int yLevel, int zCoord)
+ {
+ this.xCoord = xCoord;
+ this.yLevel = yLevel;
+ this.zCoord = zCoord;
+ }
+
+ public void createCrosspath(World world)
+ {
+
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/demonVillage/DemonVillagePath.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/demonVillage/DemonVillagePath.java
new file mode 100644
index 00000000..01645f35
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/demonVillage/DemonVillagePath.java
@@ -0,0 +1,135 @@
+package WayofTime.alchemicalWizardry.common.demonVillage;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+import WayofTime.alchemicalWizardry.ModBlocks;
+import WayofTime.alchemicalWizardry.common.Int3;
+
+public class DemonVillagePath
+{
+ public int xi;
+ public int yi;
+ public int zi;
+ public ForgeDirection dir;
+ public int length;
+
+ public DemonVillagePath(int xi, int yi, int zi, ForgeDirection dir, int length)
+ {
+ this.xi = xi;
+ this.yi = yi;
+ this.zi = zi;
+ this.dir = dir;
+ this.length = length;
+ }
+
+ public Int3 constructFullPath(World world, int clearance, Block block, int meta)
+ {
+ int xPos = this.xi;
+ int yPos = this.yi;
+ int zPos = this.zi;
+ int rad = this.getRoadRadius();
+
+ for(int i=-rad; i<=rad; i++)
+ {
+ this.constructPartialPath(world, clearance, block, meta, xPos-rad*dir.offsetX+i*dir.offsetZ, yPos, zPos-rad*dir.offsetZ+i*dir.offsetX, dir, length+2*rad);
+ }
+
+ return this.getFinalLocation(world, clearance);
+ }
+
+ public void constructPartialPath(World world, int clearance, Block roadBlock, int meta, int xi, int yi, int zi, ForgeDirection dir, int length)
+ {
+ int xPos = xi;
+ int yPos = yi;
+ int zPos = zi;
+
+ for(int i=0; i posXRadius|| x < -negXRadius || z > posZRadius || z < -negZRadius)
+ {
+ return new GridSpace();
+ }else
+ {
+ return (area[x + negXRadius][z + negZRadius]);
+ }
+ }
+
+ public void setGridSpace(int x, int z, GridSpace space)
+ {
+ if(x > posXRadius)
+ {
+ this.expandAreaInPosX();
+ this.setGridSpace(x, z, space);
+ return;
+ }else if(x < -negXRadius)
+ {
+ this.expandAreaInNegX();
+ this.setGridSpace(x, z, space);
+ return;
+ }else if(z > posZRadius)
+ {
+ this.expandAreaInPosZ();
+ this.setGridSpace(x, z, space);
+ return;
+ }else if(z < -negZRadius)
+ {
+ this.expandAreaInNegZ();
+ this.setGridSpace(x, z, space);
+ return;
+ }else
+ {
+ area[x + negXRadius][z + negZRadius] = space;
+ }
+ }
+
+ public boolean doesContainAll(GridSpaceHolder master, int xInit, int zInit, ForgeDirection dir)
+ {
+ if(master != null)
+ {
+ System.out.println("negXRadius: " + negXRadius + " posXRadius: " + posXRadius + " negZRadius: " + negZRadius + " posZRadius: " + posZRadius);
+ for(int i=-negXRadius; i<=posXRadius; i++)
+ {
+ for(int j=-negZRadius; j<=posZRadius; j++)
+ {
+ GridSpace thisSpace = this.getGridSpace(i, j);
+ if(thisSpace.isEmpty())
+ {
+ continue;
+ }
+
+ System.out.println("x: " + i + " z: " + j);
+
+ int xOff = 0;
+ int zOff = 0;
+
+ switch(dir)
+ {
+ case SOUTH:
+ xOff = -i;
+ zOff = -j;
+ break;
+ case WEST:
+ xOff = j;
+ zOff = -i;
+ break;
+ case EAST:
+ xOff = -j;
+ zOff = i;
+ break;
+ default:
+ xOff = i;
+ zOff = j;
+ break;
+ }
+ if(!master.getGridSpace(xInit + xOff, zInit + zOff).isEmpty())
+ {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+ return false;
+ }
+
+ public void setAllGridSpaces(int xInit, int zInit, int yLevel, ForgeDirection dir, int type, GridSpaceHolder master)
+ {
+ System.out.println("Grid space selected: (" + xInit + "," + zInit + ")");
+ if(master != null)
+ {
+ for(int i=-negXRadius; i<=posXRadius; i++)
+ {
+ for(int j=-negZRadius; j<=posZRadius; j++)
+ {
+ GridSpace thisSpace = this.getGridSpace(i, j);
+ if(thisSpace.isEmpty())
+ {
+ continue;
+ }
+
+ int xOff = 0;
+ int zOff = 0;
+
+ switch(dir)
+ {
+ case SOUTH:
+ xOff = -i;
+ zOff = -j;
+ break;
+ case WEST:
+ xOff = j;
+ zOff = -i;
+ break;
+ case EAST:
+ xOff = -j;
+ zOff = i;
+ break;
+ default:
+ xOff = i;
+ zOff = j;
+ break;
+ }
+
+ System.out.println("Grid space (" + (xInit + xOff) + "," + (zInit + zOff) + ")");
+
+ master.setGridSpace(xInit + xOff, zInit + zOff, new GridSpace(type, yLevel));
+ }
+ }
+ }
+ }
+
+ public void destroyAllInGridSpaces(World world, int xCoord, int yCoord, int zCoord, ForgeDirection dir)
+ {
+ for(int i=-negXRadius; i<=posXRadius; i++)
+ {
+ for(int j=-negZRadius; j<=posZRadius; j++)
+ {
+ GridSpace thisSpace = this.getGridSpace(i, j);
+ if(thisSpace.isEmpty())
+ {
+ continue;
+ }
+
+ int xOff = 0;
+ int zOff = 0;
+
+ switch(dir)
+ {
+ case SOUTH:
+ xOff = -i;
+ zOff = -j;
+ break;
+ case WEST:
+ xOff = j;
+ zOff = -i;
+ break;
+ case EAST:
+ xOff = -j;
+ zOff = i;
+ break;
+ default:
+ xOff = i;
+ zOff = j;
+ break;
+ }
+
+ for(int l = -2; l<=2; l++)
+ {
+ for(int m = -2; m<=2; m++)
+ {
+ Block block = world.getBlock(xCoord + xOff*5 + l, yCoord, zCoord + zOff*5 + m);
+ if(block == ModBlocks.blockDemonPortal)
+ {
+ continue;
+ }
+ world.setBlockToAir(xCoord + xOff*5 + l, yCoord, zCoord + zOff*5 + m);
+ }
+ }
+ }
+ }
+ }
+
+ public int getNumberOfGridSpaces()
+ {
+ int num = 0;
+ for(int i=-this.negXRadius; i<=this.posXRadius; i++)
+ {
+ for(int j=-this.negZRadius; j<=this.posZRadius; j++)
+ {
+ if(!this.getGridSpace(i, j).isEmpty())
+ {
+ num++;
+ }
+ }
+ }
+
+ return num;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/demonVillage/TileBlockSet.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/demonVillage/TileBlockSet.java
new file mode 100644
index 00000000..2209f58c
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/demonVillage/TileBlockSet.java
@@ -0,0 +1,8 @@
+package WayofTime.alchemicalWizardry.common.demonVillage;
+
+import net.minecraft.nbt.NBTTagCompound;
+
+public class TileBlockSet extends BlockSet
+{
+ public NBTTagCompound tag;
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityBileDemon.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityBileDemon.java
new file mode 100644
index 00000000..884b37f2
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityBileDemon.java
@@ -0,0 +1,488 @@
+package WayofTime.alchemicalWizardry.common.entity.mob;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityAgeable;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.SharedMonsterAttributes;
+import net.minecraft.entity.ai.EntityAIAttackOnCollide;
+import net.minecraft.entity.ai.EntityAIFollowOwner;
+import net.minecraft.entity.ai.EntityAIHurtByTarget;
+import net.minecraft.entity.ai.EntityAILookIdle;
+import net.minecraft.entity.ai.EntityAIOwnerHurtByTarget;
+import net.minecraft.entity.ai.EntityAIOwnerHurtTarget;
+import net.minecraft.entity.ai.EntityAISwimming;
+import net.minecraft.entity.ai.EntityAIWander;
+import net.minecraft.entity.ai.EntityAIWatchClosest;
+import net.minecraft.entity.monster.EntityCreeper;
+import net.minecraft.entity.monster.EntityGhast;
+import net.minecraft.entity.passive.EntityAnimal;
+import net.minecraft.entity.passive.EntityHorse;
+import net.minecraft.entity.passive.EntityWolf;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.projectile.EntityArrow;
+import net.minecraft.init.Items;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemFood;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.pathfinding.PathEntity;
+import net.minecraft.util.DamageSource;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.ModItems;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+
+public class EntityBileDemon extends EntityDemon
+{
+ private EntityAIAttackOnCollide aiAttackOnCollide = new EntityAIAttackOnCollide(this, EntityPlayer.class, 1.2D, false);
+
+ private static float maxTamedHealth = 100.0F;
+ private static float maxUntamedHealth = 200.0F;
+ private int attackTimer;
+
+ public EntityBileDemon(World par1World)
+ {
+ super(par1World, AlchemicalWizardry.entityBileDemonID);
+ this.setSize(1.3F, 2.0F);
+ this.getNavigator().setAvoidsWater(true);
+ this.tasks.addTask(1, new EntityAISwimming(this));
+ //this.tasks.addTask(3, new EntityAILeapAtTarget(this, 0.4F));
+ this.tasks.addTask(2, new EntityAIAttackOnCollide(this, 1.0D, true));
+ this.tasks.addTask(3, this.aiSit);
+ this.tasks.addTask(5, new EntityAIFollowOwner(this, 1.0D, 10.0F, 2.0F));
+ //this.tasks.addTask(6, new EntityAIMate(this, 1.0D));
+ this.tasks.addTask(7, new EntityAIWander(this, 1.0D));
+ //this.tasks.addTask(8, new EntityAIBeg(this, 8.0F));
+ this.tasks.addTask(9, new EntityAIWatchClosest(this, EntityPlayer.class, 8.0F));
+ this.tasks.addTask(9, new EntityAILookIdle(this));
+ this.targetTasks.addTask(1, new EntityAIOwnerHurtByTarget(this));
+ this.targetTasks.addTask(2, new EntityAIOwnerHurtTarget(this));
+ this.targetTasks.addTask(3, new EntityAIHurtByTarget(this, true));
+ //this.targetTasks.addTask(4, new EntityAITargetNonTamed(this, EntitySheep.class, 200, false));
+ this.setTamed(false);
+ attackTimer = 0;
+ //this.isImmuneToFire = true;
+ }
+
+ @Override
+ protected void applyEntityAttributes()
+ {
+ super.applyEntityAttributes();
+ //This line affects the speed of the monster
+ this.getEntityAttribute(SharedMonsterAttributes.movementSpeed).setBaseValue(0.20000001192092896D);
+
+ //My guess is that this will alter the max health
+ if (this.isTamed())
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxTamedHealth);
+ } else
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxUntamedHealth);
+ }
+
+ //this.func_110148_a(SharedMonsterAttributes.field_111267_a).func_111128_a(10.0D);
+ }
+
+ /**
+ * Returns true if the newer Entity AI code should be run
+ */
+ public boolean isAIEnabled()
+ {
+ return true;
+ }
+
+ /**
+ * Sets the active target the Task system uses for tracking
+ */
+ public void setAttackTarget(EntityLivingBase par1EntityLivingBase)
+ {
+ super.setAttackTarget(par1EntityLivingBase);
+
+ if (par1EntityLivingBase == null)
+ {
+ this.setAngry(false);
+ } else if (!this.isTamed())
+ {
+ this.setAngry(true);
+ }
+ }
+
+ /**
+ * main AI tick function, replaces updateEntityActionState
+ */
+ protected void updateAITick()
+ {
+ this.dataWatcher.updateObject(18, Float.valueOf(this.getHealth()));
+ }
+
+ protected void entityInit()
+ {
+ super.entityInit();
+ this.dataWatcher.addObject(18, new Float(this.getHealth()));
+ this.dataWatcher.addObject(19, new Byte((byte) 0));
+ //this.dataWatcher.addObject(20, new Byte((byte) BlockColored.getBlockFromDye(1)));
+ }
+
+ /**
+ * Plays step sound at given x, y, z for the entity
+ */
+ protected void playStepSound(int par1, int par2, int par3, int par4)
+ {
+ this.playSound("mob.zombie.step", 0.15F, 1.0F);
+ }
+
+ /**
+ * (abstract) Protected helper method to write subclass entity data to NBT.
+ */
+ public void writeEntityToNBT(NBTTagCompound par1NBTTagCompound)
+ {
+ super.writeEntityToNBT(par1NBTTagCompound);
+ par1NBTTagCompound.setBoolean("Angry", this.isAngry());
+ par1NBTTagCompound.setByte("attackTimer", (byte) attackTimer);
+ }
+
+ /**
+ * (abstract) Protected helper method to read subclass entity data from NBT.
+ */
+ public void readEntityFromNBT(NBTTagCompound par1NBTTagCompound)
+ {
+ super.readEntityFromNBT(par1NBTTagCompound);
+ this.setAngry(par1NBTTagCompound.getBoolean("Angry"));
+
+ attackTimer = par1NBTTagCompound.getByte("attackTimer");
+ }
+
+ /**
+ * Returns the sound this mob makes while it's alive.
+ */
+ protected String getLivingSound()
+ {
+ return "none";
+ }
+
+ /**
+ * Returns the sound this mob makes when it is hurt.
+ */
+ protected String getHurtSound()
+ {
+ return "mob.irongolem.hit";
+ }
+
+ /**
+ * Returns the sound this mob makes on death.
+ */
+ protected String getDeathSound()
+ {
+ return "mob.irongolem.death";
+ }
+
+ /**
+ * Returns the volume for the sounds this mob makes.
+ */
+ protected float getSoundVolume()
+ {
+ return 1.0F;
+ }
+
+ /**
+ * Returns the item ID for the item the mob drops on death.
+ */
+ protected int getDropItemId()
+ {
+ return -1;
+ }
+
+ /**
+ * Called frequently so the entity can update its state every tick as required. For example, zombies and skeletons
+ * use this to react to sunlight and start to burn.
+ */
+ public void onLivingUpdate()
+ {
+ super.onLivingUpdate();
+
+ if (attackTimer > 0)
+ {
+ attackTimer--;
+ }
+ }
+
+ public int getAttackTimer()
+ {
+ return attackTimer;
+ }
+
+ /**
+ * Called to update the entity's position/logic.
+ */
+ public void onUpdate()
+ {
+ super.onUpdate();
+ }
+
+ public float getEyeHeight()
+ {
+ return this.height * 0.8F;
+ }
+
+ /**
+ * The speed it takes to move the entityliving's rotationPitch through the faceEntity method. This is only currently
+ * use in wolves.
+ */
+ public int getVerticalFaceSpeed()
+ {
+ return this.isSitting() ? 20 : super.getVerticalFaceSpeed();
+ }
+
+ /**
+ * Called when the entity is attacked.
+ */
+ public boolean attackEntityFrom(DamageSource par1DamageSource, float par2)
+ {
+ if (this.isEntityInvulnerable())
+ {
+ return false;
+ } else
+ {
+ Entity entity = par1DamageSource.getEntity();
+ this.aiSit.setSitting(false);
+
+ if (entity != null && !(entity instanceof EntityPlayer) && !(entity instanceof EntityArrow))
+ {
+ par2 = (par2 + 1.0F) / 2.0F;
+ }
+
+ return super.attackEntityFrom(par1DamageSource, par2);
+ }
+ }
+
+ public boolean attackEntityAsMob(Entity par1Entity)
+ {
+ this.attackTimer = 10;
+ this.worldObj.setEntityState(this, (byte) 4);
+ boolean flag = par1Entity.attackEntityFrom(DamageSource.causeMobDamage(this), (float) (7 + this.rand.nextInt(15)));
+
+ if (flag)
+ {
+ par1Entity.motionY += 0.4000000059604645D;
+ }
+
+ this.playSound("mob.irongolem.throw", 1.0F, 1.0F);
+ return flag;
+ }
+
+ public void setTamed(boolean par1)
+ {
+ super.setTamed(par1);
+
+ if (par1)
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxTamedHealth);
+ } else
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxUntamedHealth);
+ }
+ }
+
+ /**
+ * Called when a player interacts with a mob. e.g. gets milk from a cow, gets into the saddle on a pig.
+ */
+ @Override
+ public boolean interact(EntityPlayer par1EntityPlayer)
+ {
+ ItemStack itemstack = par1EntityPlayer.inventory.getCurrentItem();
+
+ if (this.isTamed())
+ {
+ if (itemstack != null)
+ {
+ if (itemstack.getItem() instanceof ItemFood)
+ {
+ ItemFood itemfood = (ItemFood) itemstack.getItem();
+
+ if (itemfood.isWolfsFavoriteMeat() && this.dataWatcher.getWatchableObjectFloat(18) < this.maxTamedHealth)
+ {
+ if (!par1EntityPlayer.capabilities.isCreativeMode)
+ {
+ --itemstack.stackSize;
+ }
+
+ this.heal((float) itemfood.func_150905_g(itemstack));
+
+ if (itemstack.stackSize <= 0)
+ {
+ par1EntityPlayer.inventory.setInventorySlotContents(par1EntityPlayer.inventory.currentItem, (ItemStack) null);
+ }
+
+ return true;
+ }
+ }
+ }
+
+ if (this.getOwner() instanceof EntityPlayer && SpellHelper.getUsername(par1EntityPlayer).equalsIgnoreCase(SpellHelper.getUsername((EntityPlayer)this.getOwner())) && !this.isBreedingItem(itemstack))
+ {
+ if (!this.worldObj.isRemote)
+ {
+ this.aiSit.setSitting(!this.isSitting());
+ this.isJumping = false;
+ this.setPathToEntity((PathEntity) null);
+ this.setTarget((Entity) null);
+ this.setAttackTarget((EntityLivingBase) null);
+ }
+
+ this.sendSittingMessageToPlayer(par1EntityPlayer, !this.isSitting());
+ }
+ } else if (itemstack != null && itemstack.getItem().equals(ModItems.weakBloodOrb) && !this.isAngry())
+ {
+ if (!par1EntityPlayer.capabilities.isCreativeMode)
+ {
+ --itemstack.stackSize;
+ }
+
+ if (itemstack.stackSize <= 0)
+ {
+ par1EntityPlayer.inventory.setInventorySlotContents(par1EntityPlayer.inventory.currentItem, (ItemStack) null);
+ }
+
+ if (!this.worldObj.isRemote)
+ {
+ if (this.rand.nextInt(1) == 0)
+ {
+ this.setTamed(true);
+ this.setPathToEntity((PathEntity) null);
+ this.setAttackTarget((EntityLivingBase) null);
+ this.aiSit.setSitting(true);
+ this.setHealth(this.maxTamedHealth);
+ this.func_152115_b(par1EntityPlayer.getUniqueID().toString());
+ this.playTameEffect(true);
+ this.worldObj.setEntityState(this, (byte) 7);
+ } else
+ {
+ this.playTameEffect(false);
+ this.worldObj.setEntityState(this, (byte) 6);
+ }
+ }
+
+ return true;
+ }
+
+ return super.interact(par1EntityPlayer);
+ }
+
+ /**
+ * Checks if the parameter is an item which this animal can be fed to breed it (wheat, carrots or seeds depending on
+ * the animal type)
+ */
+ public boolean isBreedingItem(ItemStack par1ItemStack)
+ {
+ return false;
+ //return par1ItemStack == null ? false : (!(Item.itemsList[par1ItemStack.itemID] instanceof ItemFood) ? false : ((ItemFood)Item.itemsList[par1ItemStack.itemID]).isWolfsFavoriteMeat());
+ }
+
+ /**
+ * Determines whether this wolf is angry or not.
+ */
+ public boolean isAngry()
+ {
+ return (this.dataWatcher.getWatchableObjectByte(16) & 2) != 0;
+ }
+
+ /**
+ * Sets whether this wolf is angry or not.
+ */
+ public void setAngry(boolean par1)
+ {
+ byte b0 = this.dataWatcher.getWatchableObjectByte(16);
+
+ if (par1)
+ {
+ this.dataWatcher.updateObject(16, Byte.valueOf((byte) (b0 | 2)));
+ } else
+ {
+ this.dataWatcher.updateObject(16, Byte.valueOf((byte) (b0 & -3)));
+ }
+ }
+
+ /**
+ * Return this wolf's collar color.
+ */
+ public int getCollarColor()
+ {
+ return this.dataWatcher.getWatchableObjectByte(20) & 15;
+ }
+
+ /**
+ * Set this wolf's collar color.
+ */
+ public void setCollarColor(int par1)
+ {
+ this.dataWatcher.updateObject(20, Byte.valueOf((byte) (par1 & 15)));
+ }
+
+ /**
+ * This function is used when two same-species animals in 'love mode' breed to generate the new baby animal.
+ */
+ public EntityWolf spawnBabyAnimal(EntityAgeable par1EntityAgeable)
+ {
+ return null;
+ }
+
+ public void func_70918_i(boolean par1)
+ {
+ if (par1)
+ {
+ this.dataWatcher.updateObject(19, Byte.valueOf((byte) 1));
+ } else
+ {
+ this.dataWatcher.updateObject(19, Byte.valueOf((byte) 0));
+ }
+ }
+
+ /**
+ * Returns true if the mob is currently able to mate with the specified mob.
+ */
+ public boolean canMateWith(EntityAnimal par1EntityAnimal)
+ {
+ return false;
+ }
+
+ public boolean func_70922_bv()
+ {
+ return this.dataWatcher.getWatchableObjectByte(19) == 1;
+ }
+
+ /**
+ * Determines if an entity can be despawned, used on idle far away entities
+ */
+ protected boolean canDespawn()
+ {
+ //return !this.isTamed() && this.ticksExisted > 2400;
+ return false;
+ }
+
+ @Override
+ public boolean func_142018_a(EntityLivingBase par1EntityLivingBase, EntityLivingBase par2EntityLivingBase)
+ {
+ if (!(par1EntityLivingBase instanceof EntityCreeper) && !(par1EntityLivingBase instanceof EntityGhast))
+ {
+ if (par1EntityLivingBase instanceof EntityBileDemon)
+ {
+ EntityBileDemon entitywolf = (EntityBileDemon) par1EntityLivingBase;
+
+ if (entitywolf.isTamed() && entitywolf.getOwner() == par2EntityLivingBase)
+ {
+ return false;
+ }
+ }
+
+ return par1EntityLivingBase instanceof EntityPlayer && par2EntityLivingBase instanceof EntityPlayer && !((EntityPlayer) par2EntityLivingBase).canAttackPlayer((EntityPlayer) par1EntityLivingBase) ? false : !(par1EntityLivingBase instanceof EntityHorse) || !((EntityHorse) par1EntityLivingBase).isTame();
+ } else
+ {
+ return false;
+ }
+ }
+
+ public EntityAgeable createChild(EntityAgeable par1EntityAgeable)
+ {
+ return this.spawnBabyAnimal(par1EntityAgeable);
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityBoulderFist.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityBoulderFist.java
new file mode 100644
index 00000000..fa4106de
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityBoulderFist.java
@@ -0,0 +1,494 @@
+package WayofTime.alchemicalWizardry.common.entity.mob;
+
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.ModItems;
+import WayofTime.alchemicalWizardry.common.EntityAITargetAggro;
+import WayofTime.alchemicalWizardry.common.entity.projectile.HolyProjectile;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+import net.minecraft.block.BlockColored;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityAgeable;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.SharedMonsterAttributes;
+import net.minecraft.entity.ai.*;
+import net.minecraft.entity.monster.EntityCreeper;
+import net.minecraft.entity.monster.EntityGhast;
+import net.minecraft.entity.passive.EntityAnimal;
+import net.minecraft.entity.passive.EntityHorse;
+import net.minecraft.entity.passive.EntityWolf;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.projectile.EntityArrow;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemFood;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.pathfinding.PathEntity;
+import net.minecraft.util.DamageSource;
+import net.minecraft.world.World;
+
+public class EntityBoulderFist extends EntityDemon
+{
+ //private EntityAIArrowAttack aiArrowAttack = new EntityAIArrowAttack(this, 1.0D, 40, 40, 15.0F);
+ private EntityAIAttackOnCollide aiAttackOnCollide = new EntityAIAttackOnCollide(this, EntityPlayer.class, 1.2D, false);
+
+ private static float maxTamedHealth = 60.0F;
+ private static float maxUntamedHealth = 50.0F;
+
+ public EntityBoulderFist(World par1World)
+ {
+ super(par1World, AlchemicalWizardry.entityBoulderFistID);
+ this.setSize(0.8F, 1.2F);
+ this.getNavigator().setAvoidsWater(true);
+ this.tasks.addTask(1, new EntityAISwimming(this));
+ this.tasks.addTask(2, this.aiSit);
+ this.tasks.addTask(3, new EntityAILeapAtTarget(this, 0.4F));
+ this.tasks.addTask(4, new EntityAIAttackOnCollide(this, 1.0D, true));
+ this.tasks.addTask(5, new EntityAIFollowOwner(this, 1.0D, 10.0F, 2.0F));
+ //this.tasks.addTask(6, new EntityAIMate(this, 1.0D));
+ this.tasks.addTask(7, new EntityAIWander(this, 1.0D));
+ //this.tasks.addTask(8, new EntityAIBeg(this, 8.0F));
+ this.tasks.addTask(9, new EntityAIWatchClosest(this, EntityPlayer.class, 8.0F));
+ this.tasks.addTask(9, new EntityAILookIdle(this));
+ this.targetTasks.addTask(1, new EntityAIOwnerHurtByTarget(this));
+ this.targetTasks.addTask(2, new EntityAIOwnerHurtTarget(this));
+ this.targetTasks.addTask(3, new EntityAIHurtByTarget(this, true));
+ this.targetTasks.addTask(4, new EntityAITargetAggro(this, EntityPlayer.class, 0, false));
+ this.setAggro(false);
+ //this.targetTasks.addTask(4, new EntityAITargetNonTamed(this, EntitySheep.class, 200, false));
+ this.setTamed(false);
+
+ if (par1World != null && !par1World.isRemote)
+ {
+ this.setCombatTask();
+ }
+
+ //this.isImmuneToFire = true;
+ }
+
+ @Override
+ protected void applyEntityAttributes()
+ {
+ super.applyEntityAttributes();
+ //This line affects the speed of the monster
+ this.getEntityAttribute(SharedMonsterAttributes.movementSpeed).setBaseValue(0.30000001192092896D);
+
+ //My guess is that this will alter the max health
+ if (this.isTamed())
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxTamedHealth);
+ } else
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxUntamedHealth);
+ }
+
+ //this.func_110148_a(SharedMonsterAttributes.field_111267_a).func_111128_a(10.0D);
+ }
+
+ /**
+ * Returns true if the newer Entity AI code should be run
+ */
+ public boolean isAIEnabled()
+ {
+ return true;
+ }
+
+ /**
+ * Sets the active target the Task system uses for tracking
+ */
+ public void setAttackTarget(EntityLivingBase par1EntityLivingBase)
+ {
+ super.setAttackTarget(par1EntityLivingBase);
+
+ if (par1EntityLivingBase == null)
+ {
+ this.setAngry(false);
+ } else if (!this.isTamed())
+ {
+ this.setAngry(true);
+ }
+ }
+
+ /**
+ * main AI tick function, replaces updateEntityActionState
+ */
+ protected void updateAITick()
+ {
+ this.dataWatcher.updateObject(18, Float.valueOf(this.getHealth()));
+ }
+
+ protected void entityInit()
+ {
+ super.entityInit();
+ this.dataWatcher.addObject(18, new Float(this.getHealth()));
+ this.dataWatcher.addObject(19, new Byte((byte) 0));
+ //this.dataWatcher.addObject(20, new Byte((byte) BlockColored.getBlockFromDye(1)));
+ }
+
+ /**
+ * Plays step sound at given x, y, z for the entity
+ */
+ protected void playStepSound(int par1, int par2, int par3, int par4)
+ {
+ this.playSound("mob.zombie.step", 0.15F, 1.0F);
+ }
+
+ /**
+ * (abstract) Protected helper method to write subclass entity data to NBT.
+ */
+ public void writeEntityToNBT(NBTTagCompound par1NBTTagCompound)
+ {
+ super.writeEntityToNBT(par1NBTTagCompound);
+ par1NBTTagCompound.setByte("CollarColor", (byte) this.getCollarColor());
+ }
+
+ /**
+ * (abstract) Protected helper method to read subclass entity data from NBT.
+ */
+ public void readEntityFromNBT(NBTTagCompound par1NBTTagCompound)
+ {
+ super.readEntityFromNBT(par1NBTTagCompound);
+ this.setAngry(par1NBTTagCompound.getBoolean("Angry"));
+
+ this.setCombatTask();
+ }
+
+ /**
+ * Returns the sound this mob makes while it's alive.
+ */
+ protected String getLivingSound()
+ {
+ //TODO change sounds
+ return this.isAngry() ? "mob.wolf.growl" : (this.rand.nextInt(3) == 0 ? (this.isTamed() && this.dataWatcher.getWatchableObjectFloat(18) < 10.0F ? "mob.wolf.whine" : "mob.wolf.panting") : "mob.wolf.bark");
+ }
+
+ /**
+ * Returns the sound this mob makes when it is hurt.
+ */
+ protected String getHurtSound()
+ {
+ return "mob.wolf.hurt";
+ }
+
+ /**
+ * Returns the sound this mob makes on death.
+ */
+ protected String getDeathSound()
+ {
+ return "mob.wolf.death";
+ }
+
+ /**
+ * Returns the volume for the sounds this mob makes.
+ */
+ protected float getSoundVolume()
+ {
+ return 0.4F;
+ }
+
+ /**
+ * Returns the item ID for the item the mob drops on death.
+ */
+ protected int getDropItemId()
+ {
+ return -1;
+ }
+
+ /**
+ * Called frequently so the entity can update its state every tick as required. For example, zombies and skeletons
+ * use this to react to sunlight and start to burn.
+ */
+ public void onLivingUpdate()
+ {
+ super.onLivingUpdate();
+ }
+
+ /**
+ * Called to update the entity's position/logic.
+ */
+ public void onUpdate()
+ {
+ super.onUpdate();
+ }
+
+ public float getEyeHeight()
+ {
+ return this.height * 0.8F;
+ }
+
+ /**
+ * The speed it takes to move the entityliving's rotationPitch through the faceEntity method. This is only currently
+ * use in wolves.
+ */
+ public int getVerticalFaceSpeed()
+ {
+ return this.isSitting() ? 20 : super.getVerticalFaceSpeed();
+ }
+
+ /**
+ * Called when the entity is attacked.
+ */
+ public boolean attackEntityFrom(DamageSource par1DamageSource, float par2)
+ {
+ if (this.isEntityInvulnerable())
+ {
+ return false;
+ } else
+ {
+ Entity entity = par1DamageSource.getEntity();
+ this.aiSit.setSitting(false);
+
+ if (entity != null && !(entity instanceof EntityPlayer) && !(entity instanceof EntityArrow))
+ {
+ par2 = (par2 + 1.0F) / 2.0F;
+ }
+
+ return super.attackEntityFrom(par1DamageSource, par2);
+ }
+ }
+
+ public boolean attackEntityAsMob(Entity par1Entity)
+ {
+ int i = this.isTamed() ? 6 : 7;
+ return par1Entity.attackEntityFrom(DamageSource.causeMobDamage(this), (float) i);
+ }
+
+ public void setTamed(boolean par1)
+ {
+ super.setTamed(par1);
+
+ if (par1)
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxTamedHealth);
+ } else
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxUntamedHealth);
+ }
+ }
+
+ /**
+ * Called when a player interacts with a mob. e.g. gets milk from a cow, gets into the saddle on a pig.
+ */
+ @Override
+ public boolean interact(EntityPlayer par1EntityPlayer)
+ {
+ ItemStack itemstack = par1EntityPlayer.inventory.getCurrentItem();
+
+ if (this.isTamed())
+ {
+ if (itemstack != null)
+ {
+ if (itemstack.getItem() instanceof ItemFood)
+ {
+ ItemFood itemfood = (ItemFood) itemstack.getItem();
+
+ if (itemfood.isWolfsFavoriteMeat() && this.dataWatcher.getWatchableObjectFloat(18) < this.maxTamedHealth)
+ {
+ if (!par1EntityPlayer.capabilities.isCreativeMode)
+ {
+ --itemstack.stackSize;
+ }
+
+ this.heal((float) itemfood.func_150905_g(itemstack));
+
+ if (itemstack.stackSize <= 0)
+ {
+ par1EntityPlayer.inventory.setInventorySlotContents(par1EntityPlayer.inventory.currentItem, (ItemStack) null);
+ }
+
+ return true;
+ }
+ }
+ }
+
+ if (this.getOwner() instanceof EntityPlayer && SpellHelper.getUsername(par1EntityPlayer).equalsIgnoreCase(SpellHelper.getUsername((EntityPlayer)this.getOwner())) && !this.isBreedingItem(itemstack))
+ {
+ if (!this.worldObj.isRemote)
+ {
+ this.aiSit.setSitting(!this.isSitting());
+ this.isJumping = false;
+ this.setPathToEntity((PathEntity) null);
+ this.setTarget((Entity) null);
+ this.setAttackTarget((EntityLivingBase) null);
+ }
+
+ this.sendSittingMessageToPlayer(par1EntityPlayer, !this.isSitting());
+ }
+ } else if (itemstack != null && itemstack.getItem().equals(ModItems.weakBloodOrb) && !this.isAngry())
+ {
+ if (!par1EntityPlayer.capabilities.isCreativeMode)
+ {
+ --itemstack.stackSize;
+ }
+
+ if (itemstack.stackSize <= 0)
+ {
+ par1EntityPlayer.inventory.setInventorySlotContents(par1EntityPlayer.inventory.currentItem, (ItemStack) null);
+ }
+
+ if (!this.worldObj.isRemote)
+ {
+ if (this.rand.nextInt(1) == 0)
+ {
+ this.setTamed(true);
+ this.setPathToEntity((PathEntity) null);
+ this.setAttackTarget((EntityLivingBase) null);
+ this.aiSit.setSitting(true);
+ this.setHealth(this.maxTamedHealth);
+ this.func_152115_b(par1EntityPlayer.getUniqueID().toString());
+ this.playTameEffect(true);
+ this.worldObj.setEntityState(this, (byte) 7);
+ } else
+ {
+ this.playTameEffect(false);
+ this.worldObj.setEntityState(this, (byte) 6);
+ }
+ }
+
+ return true;
+ }
+
+ return super.interact(par1EntityPlayer);
+ }
+
+
+ /**
+ * Checks if the parameter is an item which this animal can be fed to breed it (wheat, carrots or seeds depending on
+ * the animal type)
+ */
+ public boolean isBreedingItem(ItemStack par1ItemStack)
+ {
+ return false;
+ //return par1ItemStack == null ? false : (!(Item.itemsList[par1ItemStack.itemID] instanceof ItemFood) ? false : ((ItemFood)Item.itemsList[par1ItemStack.itemID]).isWolfsFavoriteMeat());
+ }
+
+ /**
+ * Determines whether this wolf is angry or not.
+ */
+ public boolean isAngry()
+ {
+ return (this.dataWatcher.getWatchableObjectByte(16) & 2) != 0;
+ }
+
+ /**
+ * Sets whether this wolf is angry or not.
+ */
+ public void setAngry(boolean par1)
+ {
+ byte b0 = this.dataWatcher.getWatchableObjectByte(16);
+
+ if (par1)
+ {
+ this.dataWatcher.updateObject(16, Byte.valueOf((byte) (b0 | 2)));
+ } else
+ {
+ this.dataWatcher.updateObject(16, Byte.valueOf((byte) (b0 & -3)));
+ }
+ }
+
+ /**
+ * Return this wolf's collar color.
+ */
+ public int getCollarColor()
+ {
+ return this.dataWatcher.getWatchableObjectByte(20) & 15;
+ }
+
+ /**
+ * Set this wolf's collar color.
+ */
+ public void setCollarColor(int par1)
+ {
+ this.dataWatcher.updateObject(20, Byte.valueOf((byte) (par1 & 15)));
+ }
+
+ /**
+ * This function is used when two same-species animals in 'love mode' breed to generate the new baby animal.
+ */
+ public EntityWolf spawnBabyAnimal(EntityAgeable par1EntityAgeable)
+ {
+ return null;
+ }
+
+ public void func_70918_i(boolean par1)
+ {
+ if (par1)
+ {
+ this.dataWatcher.updateObject(19, Byte.valueOf((byte) 1));
+ } else
+ {
+ this.dataWatcher.updateObject(19, Byte.valueOf((byte) 0));
+ }
+ }
+
+ /**
+ * Returns true if the mob is currently able to mate with the specified mob.
+ */
+ public boolean canMateWith(EntityAnimal par1EntityAnimal)
+ {
+ return false;
+ }
+
+ public boolean func_70922_bv()
+ {
+ return this.dataWatcher.getWatchableObjectByte(19) == 1;
+ }
+
+ /**
+ * Determines if an entity can be despawned, used on idle far away entities
+ */
+ protected boolean canDespawn()
+ {
+ //return !this.isTamed() && this.ticksExisted > 2400;
+ return false;
+ }
+
+ @Override
+ public boolean func_142018_a(EntityLivingBase par1EntityLivingBase, EntityLivingBase par2EntityLivingBase)
+ {
+ if (!(par1EntityLivingBase instanceof EntityCreeper) && !(par1EntityLivingBase instanceof EntityGhast))
+ {
+ if (par1EntityLivingBase instanceof EntityBoulderFist)
+ {
+ EntityBoulderFist entitywolf = (EntityBoulderFist) par1EntityLivingBase;
+
+ if (entitywolf.isTamed() && entitywolf.getOwner() == par2EntityLivingBase)
+ {
+ return false;
+ }
+ }
+
+ return par1EntityLivingBase instanceof EntityPlayer && par2EntityLivingBase instanceof EntityPlayer && !((EntityPlayer) par2EntityLivingBase).canAttackPlayer((EntityPlayer) par1EntityLivingBase) ? false : !(par1EntityLivingBase instanceof EntityHorse) || !((EntityHorse) par1EntityLivingBase).isTame();
+ } else
+ {
+ return false;
+ }
+ }
+
+ public EntityAgeable createChild(EntityAgeable par1EntityAgeable)
+ {
+ return this.spawnBabyAnimal(par1EntityAgeable);
+ }
+
+ /**
+ * Attack the specified entity using a ranged attack.
+ */
+ public void attackEntityWithRangedAttack(EntityLivingBase par1EntityLivingBase, float par2)
+ {
+ double xCoord;
+ double yCoord;
+ double zCoord;
+ HolyProjectile hol = new HolyProjectile(worldObj, this, par1EntityLivingBase, 1.8f, 0f, 5, 600);
+ this.worldObj.spawnEntityInWorld(hol);
+ }
+
+ /**
+ * sets this entity's combat AI.
+ */
+ public void setCombatTask()
+ {
+ this.tasks.removeTask(this.aiAttackOnCollide);
+ //this.tasks.removeTask(this.aiArrowAttack);
+ ItemStack itemstack = this.getHeldItem();
+ this.tasks.addTask(4, this.aiAttackOnCollide);
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityDemon.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityDemon.java
new file mode 100644
index 00000000..fd56ebce
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityDemon.java
@@ -0,0 +1,99 @@
+package WayofTime.alchemicalWizardry.common.entity.mob;
+
+import net.minecraft.entity.EntityAgeable;
+import net.minecraft.entity.passive.EntityTameable;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ChatComponentText;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.ModItems;
+import WayofTime.alchemicalWizardry.common.IDemon;
+import WayofTime.alchemicalWizardry.common.items.DemonPlacer;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+
+public class EntityDemon extends EntityTameable implements IDemon
+{
+ private boolean isAggro;
+ private int demonID;
+
+ public EntityDemon(World par1World, int demonID)
+ {
+ super(par1World);
+ this.demonID = demonID;
+ }
+
+ @Override
+ public void setSummonedConditions()
+ {
+ this.setAggro(true);
+ }
+
+ @Override
+ public boolean isAggro()
+ {
+ return this.isAggro;
+ }
+
+ @Override
+ public void setAggro(boolean aggro)
+ {
+ this.isAggro = aggro;
+ }
+
+ @Override
+ public EntityAgeable createChild(EntityAgeable entityageable)
+ {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ protected void dropFewItems(boolean par1, int par2)
+ {
+ ItemStack drop = new ItemStack(ModItems.demonPlacer, 1, this.getDemonID());
+
+ if((this.getOwner() instanceof EntityPlayer))
+ {
+ DemonPlacer.setOwnerName(drop, SpellHelper.getUsername((EntityPlayer)this.getOwner()));
+ }
+
+ if (this.hasCustomNameTag())
+ {
+ drop.setStackDisplayName(this.getCustomNameTag());
+ }
+
+ this.entityDropItem(drop, 0.0f);
+ }
+
+ public void onLivingUpdate()
+ {
+ super.onLivingUpdate();
+
+ if (!this.isAggro() && worldObj.getWorldTime() % 100 == 0)
+ {
+ this.heal(1);
+ }
+ }
+
+ public void sendSittingMessageToPlayer(EntityPlayer owner, boolean isSitting)
+ {
+ if (owner != null && owner.worldObj.isRemote)
+ {
+ ChatComponentText chatmessagecomponent;
+
+ if (isSitting)
+ {
+ chatmessagecomponent = new ChatComponentText("I will stay here for now, Master.");
+ } else
+ {
+ chatmessagecomponent = new ChatComponentText("I shall follow and protect you!");
+ }
+
+ owner.addChatComponentMessage(chatmessagecomponent);
+ }
+ }
+
+ public int getDemonID()
+ {
+ return this.demonID;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityEarthElemental.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityEarthElemental.java
new file mode 100644
index 00000000..5d7b5045
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityEarthElemental.java
@@ -0,0 +1,28 @@
+package WayofTime.alchemicalWizardry.common.entity.mob;
+
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.monster.IMob;
+import net.minecraft.potion.Potion;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.util.DamageSource;
+import net.minecraft.world.World;
+
+public class EntityEarthElemental extends EntityElemental implements IMob
+{
+ public EntityEarthElemental(World world)
+ {
+ super(world, AlchemicalWizardry.entityEarthElementalID);
+ }
+
+ public void inflictEffectOnEntity(Entity target)
+ {
+ if (target instanceof EntityLivingBase)
+ {
+ ((EntityLivingBase) target).attackEntityFrom(DamageSource.causeMobDamage(this), 10);
+ ((EntityLivingBase) target).addPotionEffect(new PotionEffect(Potion.moveSlowdown.id, 100, 4));
+ ((EntityLivingBase) target).addPotionEffect(new PotionEffect(AlchemicalWizardry.customPotionInhibit.id, 150, 0));
+ }
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityElemental.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityElemental.java
new file mode 100644
index 00000000..f9492ece
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityElemental.java
@@ -0,0 +1,715 @@
+package WayofTime.alchemicalWizardry.common.entity.mob;
+
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.ModItems;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockColored;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityAgeable;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.SharedMonsterAttributes;
+import net.minecraft.entity.ai.EntityAIAttackOnCollide;
+import net.minecraft.entity.monster.EntityCreeper;
+import net.minecraft.entity.monster.EntityGhast;
+import net.minecraft.entity.passive.EntityAnimal;
+import net.minecraft.entity.passive.EntityHorse;
+import net.minecraft.entity.passive.EntityWolf;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.projectile.EntityArrow;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.MathHelper;
+import net.minecraft.world.World;
+
+import java.util.List;
+
+public class EntityElemental extends EntityDemon
+{
+ //private EntityAIArrowAttack aiArrowAttack = new EntityAIArrowAttack(this, 1.0D, 40, 40, 15.0F);
+ private EntityAIAttackOnCollide aiAttackOnCollide = new EntityAIAttackOnCollide(this, EntityPlayer.class, 1.2D, false);
+
+ private static float maxTamedHealth = 100.0F;
+ private static float maxUntamedHealth = 100.0F;
+
+ public EntityElemental(World par1World, int demonID)
+ {
+ super(par1World, demonID);
+ this.setSize(0.5F, 1.0F);
+ this.setAggro(false);
+ //this.targetTasks.addTask(4, new EntityAITargetNonTamed(this, EntitySheep.class, 200, false));
+ this.setTamed(false);
+
+ if (par1World != null && !par1World.isRemote)
+ {
+ this.setCombatTask();
+ }
+
+ //this.isImmuneToFire = true;
+ }
+
+ public int courseChangeCooldown;
+ public double waypointX;
+ public double waypointY;
+ public double waypointZ;
+ private Entity targetedEntity;
+
+ /**
+ * Cooldown time between target loss and new target aquirement.
+ */
+ private int aggroCooldown;
+ public int prevAttackCounter;
+ public int attackCounter;
+
+ /**
+ * The explosion radius of spawned fireballs.
+ */
+ //private int explosionStrength = 1;
+//
+// private int heightOffsetUpdateTime;
+// private float heightOffset = 0.5F;
+// private int field_70846_g;
+ protected void dropFewItems(boolean par1, int par2)
+ {
+ if (worldObj.rand.nextFloat() < (1 - Math.pow(0.6f, par2 + 1)))
+ {
+ this.entityDropItem(new ItemStack(ModItems.demonBloodShard, 1, 0), 0.0f);
+ }
+ }
+
+ protected void fall(float par1)
+ {
+ }
+
+ /**
+ * Takes in the distance the entity has fallen this tick and whether its on the ground to update the fall distance
+ * and deal fall damage if landing on the ground. Args: distanceFallenThisTick, onGround
+ */
+ protected void updateFallState(double par1, boolean par3)
+ {
+ }
+
+ /**
+ * Moves the entity based on the specified heading. Args: strafe, forward
+ */
+ public void moveEntityWithHeading(float par1, float par2)
+ {
+ if (this.isInWater())
+ {
+ this.moveFlying(par1, par2, 0.02F);
+ this.moveEntity(this.motionX, this.motionY, this.motionZ);
+ this.motionX *= 0.800000011920929D;
+ this.motionY *= 0.800000011920929D;
+ this.motionZ *= 0.800000011920929D;
+ } else if (this.handleLavaMovement())
+ {
+ this.moveFlying(par1, par2, 0.02F);
+ this.moveEntity(this.motionX, this.motionY, this.motionZ);
+ this.motionX *= 0.5D;
+ this.motionY *= 0.5D;
+ this.motionZ *= 0.5D;
+ } else
+ {
+ float f2 = 0.91F;
+
+ if (this.onGround)
+ {
+ f2 = 0.54600006F;
+ Block i = this.worldObj.getBlock(MathHelper.floor_double(this.posX), MathHelper.floor_double(this.boundingBox.minY) - 1, MathHelper.floor_double(this.posZ));
+
+ if (i != null)
+ {
+ f2 = i.slipperiness * 0.91F;
+ }
+ }
+
+ float f3 = 0.16277136F / (f2 * f2 * f2);
+ this.moveFlying(par1, par2, this.onGround ? 0.1F * f3 : 0.02F);
+ f2 = 0.91F;
+
+ if (this.onGround)
+ {
+ f2 = 0.54600006F;
+ Block j = this.worldObj.getBlock(MathHelper.floor_double(this.posX), MathHelper.floor_double(this.boundingBox.minY) - 1, MathHelper.floor_double(this.posZ));
+
+ if (j != null)
+ {
+ f2 = j.slipperiness * 0.91F;
+ }
+ }
+
+ this.moveEntity(this.motionX, this.motionY, this.motionZ);
+ this.motionX *= (double) f2;
+ this.motionY *= (double) f2;
+ this.motionZ *= (double) f2;
+ }
+
+ double d0 = this.posX - this.prevPosX;
+ double d1 = this.posZ - this.prevPosZ;
+ float f4 = MathHelper.sqrt_double(d0 * d0 + d1 * d1) * 4.0F;
+
+ if (f4 > 1.0F)
+ {
+ f4 = 1.0F;
+ }
+ }
+
+ /**
+ * returns true if this entity is by a ladder, false otherwise
+ */
+ public boolean isOnLadder()
+ {
+ return false;
+ }
+
+ @SideOnly(Side.CLIENT)
+ public boolean func_110182_bF()
+ {
+ return this.dataWatcher.getWatchableObjectByte(25) != 0;
+ }
+
+ protected void updateEntityActionState()
+ {
+// if (!this.worldObj.isRemote && this.worldObj.difficultySetting == 0)
+// {
+// this.setDead();
+// }
+
+ //this.despawnEntity();
+ if (this.getHealth() <= this.getMaxHealth() / 2.0f && worldObj.rand.nextInt(200) == 0)
+ {
+ this.addPotionEffect(new PotionEffect(AlchemicalWizardry.customPotionReciprocation.id, 100, 1));
+ }
+
+ this.prevAttackCounter = this.attackCounter;
+ double d0 = this.waypointX - this.posX;
+ double d1 = this.waypointY - this.posY;
+ double d2 = this.waypointZ - this.posZ;
+ double d3 = d0 * d0 + d1 * d1 + d2 * d2;
+
+ if (d3 < 1.0D || d3 > 3600.0D)
+ {
+ this.waypointX = this.posX + (double) ((this.rand.nextFloat() * 2.0F - 1.0F) * 16.0F);
+ this.waypointY = this.posY + (double) ((this.rand.nextFloat() * 2.0F - 1.0F) * 16.0F);
+ this.waypointZ = this.posZ + (double) ((this.rand.nextFloat() * 2.0F - 1.0F) * 16.0F);
+ }
+
+ if (this.courseChangeCooldown-- <= 0)
+ {
+ this.courseChangeCooldown += this.rand.nextInt(5) + 2;
+ d3 = (double) MathHelper.sqrt_double(d3);
+
+ if (this.isCourseTraversable(this.waypointX, this.waypointY, this.waypointZ, d3))
+ {
+ this.motionX += d0 / d3 * 0.1D;
+ this.motionY += d1 / d3 * 0.1D;
+ this.motionZ += d2 / d3 * 0.1D;
+ } else
+ {
+ this.waypointX = this.posX + (double) ((this.rand.nextFloat() * 2.0F - 1.0F) * 16.0F);
+ this.waypointY = this.posY + (double) ((this.rand.nextFloat() * 2.0F - 1.0F) * 16.0F);
+ this.waypointZ = this.posZ + (double) ((this.rand.nextFloat() * 2.0F - 1.0F) * 16.0F);
+ }
+ }
+
+ if (this.targetedEntity != null && this.targetedEntity.isDead)
+ {
+ this.targetedEntity = null;
+ }
+
+ if (this.targetedEntity == null || this.aggroCooldown-- <= 0)
+ {
+ this.targetedEntity = getClosestVulnerableMonsterToEntity(this, 100.0D);
+
+ if (this.targetedEntity != null)
+ {
+ this.aggroCooldown = 20;
+ }
+ }
+
+ double d4 = 64.0D;
+
+ if (this.targetedEntity != null && this.targetedEntity.getDistanceSqToEntity(this) < d4 * d4)
+ {
+ double d5 = this.targetedEntity.posX - this.posX;
+ double d6 = this.targetedEntity.boundingBox.minY + (double) (this.targetedEntity.height / 2.0F) - (this.posY + (double) (this.height / 2.0F));
+ double d7 = this.targetedEntity.posZ - this.posZ;
+ this.renderYawOffset = this.rotationYaw = -((float) Math.atan2(d5, d7)) * 180.0F / (float) Math.PI;
+
+ if (this.courseChangeCooldown <= 0)
+ {
+ if (isCourseTraversable(this.targetedEntity.posX, this.targetedEntity.posY, this.targetedEntity.posZ, Math.sqrt(d5 * d5 + d6 * d6 + d7 * d7)))
+ {
+ this.waypointX = this.targetedEntity.posX;
+ this.waypointY = this.targetedEntity.posY;
+ this.waypointZ = this.targetedEntity.posZ;
+ this.motionX += d5 / d3 * 0.1D;
+ this.motionY += d6 / d3 * 0.1D;
+ this.motionZ += d7 / d3 * 0.1D;
+ } else
+ {
+ this.waypointX = this.posX + (double) ((this.rand.nextFloat() * 2.0F - 1.0F) * 16.0F);
+ this.waypointY = this.posY + (double) ((this.rand.nextFloat() * 2.0F - 1.0F) * 16.0F);
+ this.waypointZ = this.posZ + (double) ((this.rand.nextFloat() * 2.0F - 1.0F) * 16.0F);
+ this.motionX += d5 / d3 * 0.1D;
+ this.motionY += d6 / d3 * 0.1D;
+ this.motionZ += d7 / d3 * 0.1D;
+ }
+ }
+
+ if (this.canEntityBeSeen(this.targetedEntity))
+ {
+ if (Math.sqrt(d5 * d5 + d6 * d6 + d7 * d7) < 4)
+ {
+// if (this.attackCounter == 10)
+// {
+// this.worldObj.playAuxSFXAtEntity((EntityPlayer)null, 1007, (int)this.posX, (int)this.posY, (int)this.posZ, 0);
+// }
+ ++this.attackCounter;
+
+ if (this.attackCounter >= 10)
+ {
+ this.worldObj.playAuxSFXAtEntity((EntityPlayer) null, 1008, (int) this.posX, (int) this.posY, (int) this.posZ, 0);
+ this.inflictEffectOnEntity(this.targetedEntity);
+ this.attackCounter = -40;
+ }
+ }
+ } else if (this.attackCounter > 0)
+ {
+ --this.attackCounter;
+ }
+ } else
+ {
+ this.renderYawOffset = this.rotationYaw = -((float) Math.atan2(this.motionX, this.motionZ)) * 180.0F / (float) Math.PI;
+
+ if (this.attackCounter > 0)
+ {
+ --this.attackCounter;
+ }
+ }
+
+ if (!this.worldObj.isRemote)
+ {
+ byte b0 = this.dataWatcher.getWatchableObjectByte(25);
+ byte b1 = (byte) (this.attackCounter > 10 ? 1 : 0);
+
+ if (b0 != b1)
+ {
+ this.dataWatcher.updateObject(25, Byte.valueOf(b1));
+ }
+ }
+ }
+
+ /**
+ * True if the ghast has an unobstructed line of travel to the waypoint.
+ */
+ private boolean isCourseTraversable(double par1, double par3, double par5, double par7)
+ {
+ double d4 = (this.waypointX - this.posX) / par7;
+ double d5 = (this.waypointY - this.posY) / par7;
+ double d6 = (this.waypointZ - this.posZ) / par7;
+ AxisAlignedBB axisalignedbb = this.boundingBox.copy();
+
+ for (int i = 1; (double) i < par7; ++i)
+ {
+ axisalignedbb.offset(d4, d5, d6);
+
+ if (!this.worldObj.getCollidingBoundingBoxes(this, axisalignedbb).isEmpty())
+ {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ /**
+ * Will return how many at most can spawn in a chunk at once.
+ */
+ public int getMaxSpawnedInChunk()
+ {
+ return 1;
+ }
+
+ /**
+ * (abstract) Protected helper method to write subclass entity data to NBT.
+ */
+ public void writeEntityToNBT(NBTTagCompound par1NBTTagCompound)
+ {
+ super.writeEntityToNBT(par1NBTTagCompound);
+ }
+
+ /**
+ * (abstract) Protected helper method to read subclass entity data from NBT.
+ */
+ public void readEntityFromNBT(NBTTagCompound par1NBTTagCompound)
+ {
+ super.readEntityFromNBT(par1NBTTagCompound);
+ this.setAngry(par1NBTTagCompound.getBoolean("Angry"));
+
+ this.setCombatTask();
+ }
+
+ @Override
+ protected void applyEntityAttributes()
+ {
+ super.applyEntityAttributes();
+ //This line affects the speed of the monster
+ this.getEntityAttribute(SharedMonsterAttributes.movementSpeed).setBaseValue(0.30000001192092896D);
+
+ //My guess is that this will alter the max health
+ if (this.isTamed())
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxTamedHealth);
+ } else
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxUntamedHealth);
+ }
+
+ //this.func_110148_a(SharedMonsterAttributes.field_111267_a).func_111128_a(10.0D);
+ }
+
+ /**
+ * Returns true if the newer Entity AI code should be run
+ */
+ public boolean isAIEnabled()
+ {
+ return false;
+ }
+
+ /**
+ * Sets the active target the Task system uses for tracking
+ */
+ public void setAttackTarget(EntityLivingBase par1EntityLivingBase)
+ {
+ super.setAttackTarget(par1EntityLivingBase);
+
+ if (par1EntityLivingBase == null)
+ {
+ this.setAngry(false);
+ } else if (!this.isTamed())
+ {
+ this.setAngry(true);
+ }
+ }
+
+ /**
+ * main AI tick function, replaces updateEntityActionState
+ */
+ protected void updateAITick()
+ {
+ this.dataWatcher.updateObject(18, Float.valueOf(this.getHealth()));
+ }
+
+ protected void entityInit()
+ {
+ super.entityInit();
+ this.dataWatcher.addObject(18, new Float(this.getHealth()));
+ this.dataWatcher.addObject(19, new Byte((byte) 0));
+ //this.dataWatcher.addObject(20, new Byte((byte) BlockColored.getBlockFromDye(1)));
+ this.dataWatcher.addObject(25, Byte.valueOf((byte) 0));
+ }
+
+ /**
+ * Plays step sound at given x, y, z for the entity
+ */
+ protected void playStepSound(int par1, int par2, int par3, int par4)
+ {
+ this.playSound("mob.zombie.step", 0.15F, 1.0F);
+ }
+
+ /**
+ * Returns the sound this mob makes while it's alive.
+ */
+ protected String getLivingSound()
+ {
+ //TODO change sounds
+ return "none";
+ }
+
+ /**
+ * Returns the sound this mob makes when it is hurt.
+ */
+ protected String getHurtSound()
+ {
+ return "none";
+ }
+
+ /**
+ * Returns the sound this mob makes on death.
+ */
+ protected String getDeathSound()
+ {
+ return "none";
+ }
+
+ /**
+ * Returns the volume for the sounds this mob makes.
+ */
+ protected float getSoundVolume()
+ {
+ return 0.4F;
+ }
+
+ /**
+ * Returns the item ID for the item the mob drops on death.
+ */
+ protected int getDropItemId()
+ {
+ return -1;
+ }
+
+ /**
+ * Called frequently so the entity can update its state every tick as required. For example, zombies and skeletons
+ * use this to react to sunlight and start to burn.
+ */
+ public void onLivingUpdate()
+ {
+ super.onLivingUpdate();
+ }
+
+ /**
+ * Called to update the entity's position/logic.
+ */
+ public void onUpdate()
+ {
+ super.onUpdate();
+ }
+
+ public float getEyeHeight()
+ {
+ return this.height * 0.8F;
+ }
+
+ /**
+ * The speed it takes to move the entityliving's rotationPitch through the faceEntity method. This is only currently
+ * use in wolves.
+ */
+ public int getVerticalFaceSpeed()
+ {
+ return this.isSitting() ? 20 : super.getVerticalFaceSpeed();
+ }
+
+ /**
+ * Called when the entity is attacked.
+ */
+ public boolean attackEntityFrom(DamageSource par1DamageSource, float par2)
+ {
+ if (this.isEntityInvulnerable())
+ {
+ return false;
+ } else
+ {
+ Entity entity = par1DamageSource.getEntity();
+ this.aiSit.setSitting(false);
+
+ if (entity != null && !(entity instanceof EntityPlayer) && !(entity instanceof EntityArrow))
+ {
+ par2 = (par2 + 1.0F) / 2.0F;
+ }
+
+ return super.attackEntityFrom(par1DamageSource, par2);
+ }
+ }
+
+ public boolean attackEntityAsMob(Entity par1Entity)
+ {
+ int i = this.isTamed() ? 6 : 7;
+ return par1Entity.attackEntityFrom(DamageSource.causeMobDamage(this), (float) i);
+ }
+
+ public void setTamed(boolean par1)
+ {
+ super.setTamed(par1);
+
+ if (par1)
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxTamedHealth);
+ } else
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxUntamedHealth);
+ }
+ }
+
+ /**
+ * Called when a player interacts with a mob. e.g. gets milk from a cow, gets into the saddle on a pig.
+ */
+
+ /**
+ * Checks if the parameter is an item which this animal can be fed to breed it (wheat, carrots or seeds depending on
+ * the animal type)
+ */
+ public boolean isBreedingItem(ItemStack par1ItemStack)
+ {
+ return false;
+ //return par1ItemStack == null ? false : (!(Item.itemsList[par1ItemStack.itemID] instanceof ItemFood) ? false : ((ItemFood)Item.itemsList[par1ItemStack.itemID]).isWolfsFavoriteMeat());
+ }
+
+ /**
+ * Determines whether this wolf is angry or not.
+ */
+ public boolean isAngry()
+ {
+ return (this.dataWatcher.getWatchableObjectByte(16) & 2) != 0;
+ }
+
+ /**
+ * Sets whether this wolf is angry or not.
+ */
+ public void setAngry(boolean par1)
+ {
+ byte b0 = this.dataWatcher.getWatchableObjectByte(16);
+
+ if (par1)
+ {
+ this.dataWatcher.updateObject(16, Byte.valueOf((byte) (b0 | 2)));
+ } else
+ {
+ this.dataWatcher.updateObject(16, Byte.valueOf((byte) (b0 & -3)));
+ }
+ }
+
+ public void func_70918_i(boolean par1)
+ {
+ if (par1)
+ {
+ this.dataWatcher.updateObject(19, Byte.valueOf((byte) 1));
+ } else
+ {
+ this.dataWatcher.updateObject(19, Byte.valueOf((byte) 0));
+ }
+ }
+
+ /**
+ * Returns true if the mob is currently able to mate with the specified mob.
+ */
+ public boolean canMateWith(EntityAnimal par1EntityAnimal)
+ {
+ return false;
+ }
+
+ public boolean func_70922_bv()
+ {
+ return this.dataWatcher.getWatchableObjectByte(19) == 1;
+ }
+
+ /**
+ * Determines if an entity can be despawned, used on idle far away entities
+ */
+ protected boolean canDespawn()
+ {
+ //return !this.isTamed() && this.ticksExisted > 2400;
+ return false;
+ }
+
+ @Override
+ public boolean func_142018_a(EntityLivingBase par1EntityLivingBase, EntityLivingBase par2EntityLivingBase)
+ {
+ if (!(par1EntityLivingBase instanceof EntityCreeper) && !(par1EntityLivingBase instanceof EntityGhast))
+ {
+ if (par1EntityLivingBase instanceof EntityBoulderFist)
+ {
+ EntityBoulderFist entitywolf = (EntityBoulderFist) par1EntityLivingBase;
+
+ if (entitywolf.isTamed() && entitywolf.getOwner() == par2EntityLivingBase)
+ {
+ return false;
+ }
+ }
+
+ return par1EntityLivingBase instanceof EntityPlayer && par2EntityLivingBase instanceof EntityPlayer && !((EntityPlayer) par2EntityLivingBase).canAttackPlayer((EntityPlayer) par1EntityLivingBase) ? false : !(par1EntityLivingBase instanceof EntityHorse) || !((EntityHorse) par1EntityLivingBase).isTame();
+ //return par1EntityLivingBase instanceof EntityPlayer && par2EntityLivingBase instanceof EntityPlayer && !((EntityPlayer)par2EntityLivingBase).func_96122_a((EntityPlayer)par1EntityLivingBase) ? false : !(par1EntityLivingBase instanceof EntityHorse) || !((EntityHorse)par1EntityLivingBase).func_110248_bS();
+ } else
+ {
+ return false;
+ }
+ }
+
+
+ /**
+ * sets this entity's combat AI.
+ */
+ public void setCombatTask()
+ {
+ this.tasks.removeTask(this.aiAttackOnCollide);
+ //this.tasks.removeTask(this.aiArrowAttack);
+ ItemStack itemstack = this.getHeldItem();
+ this.tasks.addTask(4, this.aiAttackOnCollide);
+ }
+
+ public void inflictEffectOnEntity(Entity target)
+ {
+ if (target instanceof EntityLivingBase)
+ {
+ ((EntityLivingBase) target).addPotionEffect(new PotionEffect(AlchemicalWizardry.customPotionDrowning.id, 100, 0));
+ }
+ }
+
+ public static Entity getClosestVulnerableMonsterToEntity(Entity par1Entity, double par2)
+ {
+ double d4 = -1.0D;
+ double par1 = par1Entity.posX;
+ double par3 = par1Entity.posY;
+ double par5 = par1Entity.posZ;
+
+ EntityLivingBase entityLiving = null;
+ World world = par1Entity.worldObj;
+
+ double range = Math.sqrt(par2);
+ double verticalRange = Math.sqrt(par2);
+ List entities = world.getEntitiesWithinAABB(EntityLivingBase.class, AxisAlignedBB.getBoundingBox(par1 - 0.5f, par3 - 0.5f, par5 - 0.5f, par1 + 0.5f, par3 + 0.5f, par5 + 0.5f).expand(range, verticalRange, range));
+ if (entities == null)
+ {
+ return null;
+ }
+
+ for (int i = 0; i < entities.size(); ++i)
+ {
+ EntityLivingBase entityLiving1 = entities.get(i);
+
+ if (!(entityLiving1 instanceof EntityPlayer && ((EntityPlayer) entityLiving1).capabilities.disableDamage) && entityLiving1.isEntityAlive())
+ {
+ double d5 = entityLiving1.getDistanceSq(par1, par3, par5);
+ double d6 = par2;
+
+ if (entityLiving1.isSneaking())
+ {
+ d6 = par2 * 0.800000011920929D;
+ }
+
+ if (entityLiving1.isInvisible())
+ {
+ float f = entityLiving1 instanceof EntityPlayer ? ((EntityPlayer) entityLiving1).getArmorVisibility() : 1.0f;
+
+ if (f < 0.1F)
+ {
+ f = 0.1F;
+ }
+
+ d6 *= (double) (0.7F * f);
+ }
+
+ if ((par2 < 0.0D || d5 < d6 * d6) && (d4 == -1.0D || d5 < d4))
+ {
+ if (par1Entity != entityLiving1)
+ {
+ d4 = d5;
+ entityLiving = entityLiving1;
+ }
+ }
+ }
+ }
+
+ return entityLiving;
+ }
+
+ @Override
+ public int getTotalArmorValue() //TODO
+ {
+ return 10;
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityFallenAngel.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityFallenAngel.java
new file mode 100644
index 00000000..6bd801a9
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityFallenAngel.java
@@ -0,0 +1,502 @@
+package WayofTime.alchemicalWizardry.common.entity.mob;
+
+import net.minecraft.block.BlockColored;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityAgeable;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.IRangedAttackMob;
+import net.minecraft.entity.SharedMonsterAttributes;
+import net.minecraft.entity.ai.EntityAIArrowAttack;
+import net.minecraft.entity.ai.EntityAIAttackOnCollide;
+import net.minecraft.entity.ai.EntityAIFollowOwner;
+import net.minecraft.entity.ai.EntityAIHurtByTarget;
+import net.minecraft.entity.ai.EntityAILookIdle;
+import net.minecraft.entity.ai.EntityAIOwnerHurtByTarget;
+import net.minecraft.entity.ai.EntityAIOwnerHurtTarget;
+import net.minecraft.entity.ai.EntityAISwimming;
+import net.minecraft.entity.ai.EntityAIWander;
+import net.minecraft.entity.ai.EntityAIWatchClosest;
+import net.minecraft.entity.monster.EntityCreeper;
+import net.minecraft.entity.monster.EntityGhast;
+import net.minecraft.entity.passive.EntityAnimal;
+import net.minecraft.entity.passive.EntityHorse;
+import net.minecraft.entity.passive.EntityWolf;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.projectile.EntityArrow;
+import net.minecraft.item.ItemFood;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.pathfinding.PathEntity;
+import net.minecraft.util.DamageSource;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.ModItems;
+import WayofTime.alchemicalWizardry.common.EntityAITargetAggro;
+import WayofTime.alchemicalWizardry.common.entity.projectile.HolyProjectile;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+
+public class EntityFallenAngel extends EntityDemon implements IRangedAttackMob
+{
+ private EntityAIArrowAttack aiArrowAttack = new EntityAIArrowAttack(this, 1.0D, 40, 40, 15.0F);
+ private EntityAIAttackOnCollide aiAttackOnCollide = new EntityAIAttackOnCollide(this, EntityPlayer.class, 1.2D, false);
+
+ private static float maxTamedHealth = 50.0F;
+ private static float maxUntamedHealth = 50.0F;
+
+ public EntityFallenAngel(World par1World)
+ {
+ super(par1World, AlchemicalWizardry.entityFallenAngelID);
+ this.setSize(0.7F, 1.8F);
+ this.getNavigator().setAvoidsWater(true);
+ this.tasks.addTask(1, new EntityAISwimming(this));
+ this.tasks.addTask(2, this.aiSit);
+ //this.tasks.addTask(3, new EntityAILeapAtTarget(this, 0.4F));
+ //this.tasks.addTask(4, new EntityAIAttackOnCollide(this, 1.0D, true));
+ this.tasks.addTask(5, new EntityAIFollowOwner(this, 1.0D, 10.0F, 2.0F));
+ //this.tasks.addTask(6, new EntityAIMate(this, 1.0D));
+ this.tasks.addTask(7, new EntityAIWander(this, 1.0D));
+ //this.tasks.addTask(8, new EntityAIBeg(this, 8.0F));
+ this.tasks.addTask(9, new EntityAIWatchClosest(this, EntityPlayer.class, 8.0F));
+ this.tasks.addTask(9, new EntityAILookIdle(this));
+ this.targetTasks.addTask(1, new EntityAIOwnerHurtByTarget(this));
+ this.targetTasks.addTask(2, new EntityAIOwnerHurtTarget(this));
+ this.targetTasks.addTask(3, new EntityAIHurtByTarget(this, true));
+ this.targetTasks.addTask(4, new EntityAITargetAggro(this, EntityPlayer.class, 0, false));
+ this.setAggro(false);
+ //this.targetTasks.addTask(4, new EntityAITargetNonTamed(this, EntitySheep.class, 200, false));
+ this.setTamed(false);
+
+ if (par1World != null && !par1World.isRemote)
+ {
+ this.setCombatTask();
+ }
+
+ //this.isImmuneToFire = true;
+ }
+
+ @Override
+ protected void applyEntityAttributes()
+ {
+ super.applyEntityAttributes();
+ //This line affects the speed of the monster
+ this.getEntityAttribute(SharedMonsterAttributes.movementSpeed).setBaseValue(0.30000001192092896D);
+
+ //My guess is that this will alter the max health
+ if (this.isTamed())
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxTamedHealth);
+ } else
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxUntamedHealth);
+ }
+
+ //this.func_110148_a(SharedMonsterAttributes.field_111267_a).func_111128_a(10.0D);
+ }
+
+ /**
+ * Returns true if the newer Entity AI code should be run
+ */
+ public boolean isAIEnabled()
+ {
+ return true;
+ }
+
+ /**
+ * Sets the active target the Task system uses for tracking
+ */
+ public void setAttackTarget(EntityLivingBase par1EntityLivingBase)
+ {
+ super.setAttackTarget(par1EntityLivingBase);
+
+ if (par1EntityLivingBase == null)
+ {
+ this.setAngry(false);
+ } else if (!this.isTamed())
+ {
+ this.setAngry(true);
+ }
+ }
+
+ /**
+ * main AI tick function, replaces updateEntityActionState
+ */
+ protected void updateAITick()
+ {
+ this.dataWatcher.updateObject(18, Float.valueOf(this.getHealth()));
+ }
+
+ protected void entityInit()
+ {
+ super.entityInit();
+ this.dataWatcher.addObject(18, new Float(this.getHealth()));
+ this.dataWatcher.addObject(19, new Byte((byte) 0));
+ //this.dataWatcher.addObject(20, new Byte((byte) BlockColored.getBlockFromDye(1)));
+ }
+
+ /**
+ * Plays step sound at given x, y, z for the entity
+ */
+ protected void playStepSound(int par1, int par2, int par3, int par4)
+ {
+ this.playSound("mob.zombie.step", 0.15F, 1.0F);
+ }
+
+ /**
+ * (abstract) Protected helper method to write subclass entity data to NBT.
+ */
+ public void writeEntityToNBT(NBTTagCompound par1NBTTagCompound)
+ {
+ super.writeEntityToNBT(par1NBTTagCompound);
+ par1NBTTagCompound.setBoolean("Angry", this.isAngry());
+ }
+
+ /**
+ * (abstract) Protected helper method to read subclass entity data from NBT.
+ */
+ public void readEntityFromNBT(NBTTagCompound par1NBTTagCompound)
+ {
+ super.readEntityFromNBT(par1NBTTagCompound);
+ this.setAngry(par1NBTTagCompound.getBoolean("Angry"));
+
+ this.setCombatTask();
+ }
+
+ /**
+ * Returns the sound this mob makes while it's alive.
+ */
+ protected String getLivingSound()
+ {
+ //TODO change sounds
+ return "none";
+ }
+
+ /**
+ * Returns the sound this mob makes when it is hurt.
+ */
+ protected String getHurtSound()
+ {
+ return "none";
+ }
+
+ /**
+ * Returns the sound this mob makes on death.
+ */
+ protected String getDeathSound()
+ {
+ return "mob.wolf.death";
+ }
+
+ /**
+ * Returns the volume for the sounds this mob makes.
+ */
+ protected float getSoundVolume()
+ {
+ return 0.4F;
+ }
+
+ /**
+ * Returns the item ID for the item the mob drops on death.
+ */
+ protected int getDropItemId()
+ {
+ return -1;
+ }
+
+ /**
+ * Called frequently so the entity can update its state every tick as required. For example, zombies and skeletons
+ * use this to react to sunlight and start to burn.
+ */
+ public void onLivingUpdate()
+ {
+ super.onLivingUpdate();
+ }
+
+ /**
+ * Called to update the entity's position/logic.
+ */
+ public void onUpdate()
+ {
+ super.onUpdate();
+ }
+
+ public float getEyeHeight()
+ {
+ return this.height * 0.8F;
+ }
+
+ /**
+ * The speed it takes to move the entityliving's rotationPitch through the faceEntity method. This is only currently
+ * use in wolves.
+ */
+ public int getVerticalFaceSpeed()
+ {
+ return this.isSitting() ? 20 : super.getVerticalFaceSpeed();
+ }
+
+ /**
+ * Called when the entity is attacked.
+ */
+ public boolean attackEntityFrom(DamageSource par1DamageSource, float par2)
+ {
+ if (this.isEntityInvulnerable())
+ {
+ return false;
+ } else
+ {
+ Entity entity = par1DamageSource.getEntity();
+ this.aiSit.setSitting(false);
+
+ if (entity != null && !(entity instanceof EntityPlayer) && !(entity instanceof EntityArrow))
+ {
+ par2 = (par2 + 1.0F) / 2.0F;
+ }
+
+ return super.attackEntityFrom(par1DamageSource, par2);
+ }
+ }
+
+ public boolean attackEntityAsMob(Entity par1Entity)
+ {
+ int i = this.isTamed() ? 4 : 2;
+ return par1Entity.attackEntityFrom(DamageSource.causeMobDamage(this), (float) i);
+ }
+
+ public void setTamed(boolean par1)
+ {
+ super.setTamed(par1);
+
+ if (par1)
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxTamedHealth);
+ } else
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxUntamedHealth);
+ }
+ }
+
+ /**
+ * Called when a player interacts with a mob. e.g. gets milk from a cow, gets into the saddle on a pig.
+ */
+ @Override
+ public boolean interact(EntityPlayer par1EntityPlayer)
+ {
+ ItemStack itemstack = par1EntityPlayer.inventory.getCurrentItem();
+
+ if (this.isTamed())
+ {
+ if (itemstack != null)
+ {
+ if (itemstack.getItem() instanceof ItemFood)
+ {
+ ItemFood itemfood = (ItemFood) itemstack.getItem();
+
+ if (itemfood.isWolfsFavoriteMeat() && this.dataWatcher.getWatchableObjectFloat(18) < this.maxTamedHealth)
+ {
+ if (!par1EntityPlayer.capabilities.isCreativeMode)
+ {
+ --itemstack.stackSize;
+ }
+
+ this.heal((float) itemfood.func_150905_g(itemstack));
+
+ if (itemstack.stackSize <= 0)
+ {
+ par1EntityPlayer.inventory.setInventorySlotContents(par1EntityPlayer.inventory.currentItem, (ItemStack) null);
+ }
+
+ return true;
+ }
+ }
+ }
+
+ if (this.getOwner() instanceof EntityPlayer && SpellHelper.getUsername(par1EntityPlayer).equalsIgnoreCase(SpellHelper.getUsername((EntityPlayer)this.getOwner())) && !this.isBreedingItem(itemstack))
+ {
+ if (!this.worldObj.isRemote)
+ {
+ this.aiSit.setSitting(!this.isSitting());
+ this.isJumping = false;
+ this.setPathToEntity((PathEntity) null);
+ this.setTarget((Entity) null);
+ this.setAttackTarget((EntityLivingBase) null);
+ }
+
+ this.sendSittingMessageToPlayer(par1EntityPlayer, !this.isSitting());
+ }
+ } else if (itemstack != null && itemstack.getItem().equals(ModItems.weakBloodOrb) && !this.isAngry())
+ {
+ if (!par1EntityPlayer.capabilities.isCreativeMode)
+ {
+ --itemstack.stackSize;
+ }
+
+ if (itemstack.stackSize <= 0)
+ {
+ par1EntityPlayer.inventory.setInventorySlotContents(par1EntityPlayer.inventory.currentItem, (ItemStack) null);
+ }
+
+ if (!this.worldObj.isRemote)
+ {
+ if (this.rand.nextInt(1) == 0)
+ {
+ this.setTamed(true);
+ this.setPathToEntity((PathEntity) null);
+ this.setAttackTarget((EntityLivingBase) null);
+ this.aiSit.setSitting(true);
+ this.setHealth(this.maxTamedHealth);
+ this.func_152115_b(par1EntityPlayer.getUniqueID().toString());
+ this.playTameEffect(true);
+ this.worldObj.setEntityState(this, (byte) 7);
+ } else
+ {
+ this.playTameEffect(false);
+ this.worldObj.setEntityState(this, (byte) 6);
+ }
+ }
+
+ return true;
+ }
+
+ return super.interact(par1EntityPlayer);
+ }
+
+
+ /**
+ * Checks if the parameter is an item which this animal can be fed to breed it (wheat, carrots or seeds depending on
+ * the animal type)
+ */
+ public boolean isBreedingItem(ItemStack par1ItemStack)
+ {
+ return false;
+ //return par1ItemStack == null ? false : (!(Item.itemsList[par1ItemStack.itemID] instanceof ItemFood) ? false : ((ItemFood)Item.itemsList[par1ItemStack.itemID]).isWolfsFavoriteMeat());
+ }
+
+ /**
+ * Determines whether this wolf is angry or not.
+ */
+ public boolean isAngry()
+ {
+ return (this.dataWatcher.getWatchableObjectByte(16) & 2) != 0;
+ }
+
+ /**
+ * Sets whether this wolf is angry or not.
+ */
+ public void setAngry(boolean par1)
+ {
+ byte b0 = this.dataWatcher.getWatchableObjectByte(16);
+
+ if (par1)
+ {
+ this.dataWatcher.updateObject(16, Byte.valueOf((byte) (b0 | 2)));
+ } else
+ {
+ this.dataWatcher.updateObject(16, Byte.valueOf((byte) (b0 & -3)));
+ }
+ }
+
+ /**
+ * Return this wolf's collar color.
+ */
+ public int getCollarColor()
+ {
+ return this.dataWatcher.getWatchableObjectByte(20) & 15;
+ }
+
+ /**
+ * Set this wolf's collar color.
+ */
+ public void setCollarColor(int par1)
+ {
+ this.dataWatcher.updateObject(20, Byte.valueOf((byte) (par1 & 15)));
+ }
+
+ /**
+ * This function is used when two same-species animals in 'love mode' breed to generate the new baby animal.
+ */
+ public EntityWolf spawnBabyAnimal(EntityAgeable par1EntityAgeable)
+ {
+ return null;
+ }
+
+ public void func_70918_i(boolean par1)
+ {
+ if (par1)
+ {
+ this.dataWatcher.updateObject(19, Byte.valueOf((byte) 1));
+ } else
+ {
+ this.dataWatcher.updateObject(19, Byte.valueOf((byte) 0));
+ }
+ }
+
+ /**
+ * Returns true if the mob is currently able to mate with the specified mob.
+ */
+ public boolean canMateWith(EntityAnimal par1EntityAnimal)
+ {
+ return false;
+ }
+
+ public boolean func_70922_bv()
+ {
+ return this.dataWatcher.getWatchableObjectByte(19) == 1;
+ }
+
+ /**
+ * Determines if an entity can be despawned, used on idle far away entities
+ */
+ protected boolean canDespawn()
+ {
+ //return !this.isTamed() && this.ticksExisted > 2400;
+ return false;
+ }
+
+ public boolean func_142018_a(EntityLivingBase par1EntityLivingBase, EntityLivingBase par2EntityLivingBase)
+ {
+ if (!(par1EntityLivingBase instanceof EntityCreeper) && !(par1EntityLivingBase instanceof EntityGhast))
+ {
+ if (par1EntityLivingBase instanceof EntityFallenAngel)
+ {
+ EntityFallenAngel entitywolf = (EntityFallenAngel) par1EntityLivingBase;
+
+ if (entitywolf.isTamed() && entitywolf.getOwner() == par2EntityLivingBase)
+ {
+ return false;
+ }
+ }
+
+ return par1EntityLivingBase instanceof EntityPlayer && par2EntityLivingBase instanceof EntityPlayer && !((EntityPlayer) par2EntityLivingBase).canAttackPlayer((EntityPlayer) par1EntityLivingBase) ? false : !(par1EntityLivingBase instanceof EntityHorse) || !((EntityHorse) par1EntityLivingBase).isTame();
+ } else
+ {
+ return false;
+ }
+ }
+
+ public EntityAgeable createChild(EntityAgeable par1EntityAgeable)
+ {
+ return this.spawnBabyAnimal(par1EntityAgeable);
+ }
+
+ /**
+ * Attack the specified entity using a ranged attack.
+ */
+ public void attackEntityWithRangedAttack(EntityLivingBase par1EntityLivingBase, float par2)
+ {
+ double xCoord;
+ double yCoord;
+ double zCoord;
+ HolyProjectile hol = new HolyProjectile(worldObj, this, par1EntityLivingBase, 1.8f, 0f, 5, 600);
+ this.worldObj.spawnEntityInWorld(hol);
+ }
+
+ /**
+ * sets this entity's combat AI.
+ */
+ public void setCombatTask()
+ {
+ this.tasks.removeTask(this.aiAttackOnCollide);
+ this.tasks.removeTask(this.aiArrowAttack);
+ ItemStack itemstack = this.getHeldItem();
+ this.tasks.addTask(4, this.aiArrowAttack);
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityFireElemental.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityFireElemental.java
new file mode 100644
index 00000000..a599be7c
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityFireElemental.java
@@ -0,0 +1,26 @@
+package WayofTime.alchemicalWizardry.common.entity.mob;
+
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.monster.IMob;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.world.World;
+
+public class EntityFireElemental extends EntityElemental implements IMob
+{
+ public EntityFireElemental(World world)
+ {
+ super(world, AlchemicalWizardry.entityFireElementalID);
+ this.isImmuneToFire = true;
+ }
+
+ public void inflictEffectOnEntity(Entity target)
+ {
+ if (target instanceof EntityLivingBase)
+ {
+ ((EntityLivingBase) target).setFire(10);
+ ((EntityLivingBase) target).addPotionEffect(new PotionEffect(AlchemicalWizardry.customPotionInhibit.id, 150, 0));
+ }
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityHolyElemental.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityHolyElemental.java
new file mode 100644
index 00000000..c4c626a0
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityHolyElemental.java
@@ -0,0 +1,28 @@
+package WayofTime.alchemicalWizardry.common.entity.mob;
+
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.monster.IMob;
+import net.minecraft.potion.Potion;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.util.DamageSource;
+import net.minecraft.world.World;
+
+public class EntityHolyElemental extends EntityElemental implements IMob
+{
+ public EntityHolyElemental(World world)
+ {
+ super(world, AlchemicalWizardry.entityHolyElementalID);
+ }
+
+ public void inflictEffectOnEntity(Entity target)
+ {
+ if (target instanceof EntityLivingBase)
+ {
+ ((EntityLivingBase) target).attackEntityFrom(DamageSource.causeMobDamage(this), 15);
+ ((EntityLivingBase) target).addPotionEffect(new PotionEffect(AlchemicalWizardry.customPotionInhibit.id, 150, 0));
+ ((EntityLivingBase) target).addPotionEffect(new PotionEffect(Potion.poison.id, 100, 1));
+ }
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityIceDemon.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityIceDemon.java
new file mode 100644
index 00000000..fafe24b7
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityIceDemon.java
@@ -0,0 +1,523 @@
+package WayofTime.alchemicalWizardry.common.entity.mob;
+
+import net.minecraft.block.BlockColored;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityAgeable;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.IRangedAttackMob;
+import net.minecraft.entity.SharedMonsterAttributes;
+import net.minecraft.entity.ai.EntityAIArrowAttack;
+import net.minecraft.entity.ai.EntityAIAttackOnCollide;
+import net.minecraft.entity.ai.EntityAIFollowOwner;
+import net.minecraft.entity.ai.EntityAIHurtByTarget;
+import net.minecraft.entity.ai.EntityAILookIdle;
+import net.minecraft.entity.ai.EntityAIOwnerHurtByTarget;
+import net.minecraft.entity.ai.EntityAIOwnerHurtTarget;
+import net.minecraft.entity.ai.EntityAISwimming;
+import net.minecraft.entity.ai.EntityAIWander;
+import net.minecraft.entity.ai.EntityAIWatchClosest;
+import net.minecraft.entity.monster.EntityCreeper;
+import net.minecraft.entity.monster.EntityGhast;
+import net.minecraft.entity.passive.EntityAnimal;
+import net.minecraft.entity.passive.EntityHorse;
+import net.minecraft.entity.passive.EntityWolf;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.projectile.EntityArrow;
+import net.minecraft.item.ItemFood;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.pathfinding.PathEntity;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.Vec3;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.ModItems;
+import WayofTime.alchemicalWizardry.common.EntityAITargetAggro;
+import WayofTime.alchemicalWizardry.common.entity.projectile.IceProjectile;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+
+public class EntityIceDemon extends EntityDemon implements IRangedAttackMob
+{
+ private EntityAIArrowAttack aiArrowAttack = new EntityAIArrowAttack(this, 1.0D, 30, 50, 15.0F);
+ private EntityAIAttackOnCollide aiAttackOnCollide = new EntityAIAttackOnCollide(this, EntityPlayer.class, 1.2D, false);
+
+ private static float maxTamedHealth = 50.0F;
+ private static float maxUntamedHealth = 30.0F;
+
+ public EntityIceDemon(World par1World)
+ {
+ super(par1World, AlchemicalWizardry.entityIceDemonID);
+ this.setSize(0.5F, 2.0F);
+ //this.getNavigator().setAvoidsWater(true);
+ this.tasks.addTask(1, new EntityAISwimming(this));
+ this.tasks.addTask(2, this.aiSit);
+ //this.tasks.addTask(3, new EntityAILeapAtTarget(this, 0.4F));
+ //this.tasks.addTask(4, new EntityAIAttackOnCollide(this, 1.0D, true));
+ this.tasks.addTask(5, new EntityAIFollowOwner(this, 1.0D, 10.0F, 2.0F));
+ //this.tasks.addTask(6, new EntityAIMate(this, 1.0D));
+ this.tasks.addTask(7, new EntityAIWander(this, 1.0D));
+ //this.tasks.addTask(8, new EntityAIBeg(this, 8.0F));
+ this.tasks.addTask(9, new EntityAIWatchClosest(this, EntityPlayer.class, 8.0F));
+ this.tasks.addTask(9, new EntityAILookIdle(this));
+ this.targetTasks.addTask(1, new EntityAIOwnerHurtByTarget(this));
+ this.targetTasks.addTask(2, new EntityAIOwnerHurtTarget(this));
+ this.targetTasks.addTask(3, new EntityAIHurtByTarget(this, true));
+ this.targetTasks.addTask(4, new EntityAITargetAggro(this, EntityPlayer.class, 0, false));
+ this.setAggro(false);
+ //this.targetTasks.addTask(4, new EntityAITargetNonTamed(this, EntitySheep.class, 200, false));
+ this.setTamed(false);
+
+ if (par1World != null && !par1World.isRemote)
+ {
+ this.setCombatTask();
+ }
+
+ //this.isImmuneToFire = true;
+ }
+
+ @Override
+ protected void applyEntityAttributes()
+ {
+ super.applyEntityAttributes();
+ //This line affects the speed of the monster
+ this.getEntityAttribute(SharedMonsterAttributes.movementSpeed).setBaseValue(0.40000001192092896D);
+
+ //My guess is that this will alter the max health
+ if (this.isTamed())
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxTamedHealth);
+ } else
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxUntamedHealth);
+ }
+
+ //this.func_110148_a(SharedMonsterAttributes.field_111267_a).func_111128_a(10.0D);
+ }
+
+ /**
+ * Returns true if the newer Entity AI code should be run
+ */
+ public boolean isAIEnabled()
+ {
+ return true;
+ }
+
+ /**
+ * Sets the active target the Task system uses for tracking
+ */
+ public void setAttackTarget(EntityLivingBase par1EntityLivingBase)
+ {
+ super.setAttackTarget(par1EntityLivingBase);
+
+ if (par1EntityLivingBase == null)
+ {
+ this.setAngry(false);
+ } else if (!this.isTamed())
+ {
+ this.setAngry(true);
+ }
+ }
+
+ /**
+ * main AI tick function, replaces updateEntityActionState
+ */
+ protected void updateAITick()
+ {
+ this.dataWatcher.updateObject(18, Float.valueOf(this.getHealth()));
+ }
+
+ protected void entityInit()
+ {
+ super.entityInit();
+ this.dataWatcher.addObject(18, new Float(this.getHealth()));
+ this.dataWatcher.addObject(19, new Byte((byte) 0));
+ //this.dataWatcher.addObject(20, new Byte((byte) BlockColored.getBlockFromDye(1)));
+ }
+
+ /**
+ * Plays step sound at given x, y, z for the entity
+ */
+ protected void playStepSound(int par1, int par2, int par3, int par4)
+ {
+ this.playSound("mob.zombie.step", 0.15F, 1.0F);
+ }
+
+ /**
+ * (abstract) Protected helper method to write subclass entity data to NBT.
+ */
+ public void writeEntityToNBT(NBTTagCompound par1NBTTagCompound)
+ {
+ super.writeEntityToNBT(par1NBTTagCompound);
+ par1NBTTagCompound.setBoolean("Angry", this.isAngry());
+ }
+
+ /**
+ * (abstract) Protected helper method to read subclass entity data from NBT.
+ */
+ public void readEntityFromNBT(NBTTagCompound par1NBTTagCompound)
+ {
+ super.readEntityFromNBT(par1NBTTagCompound);
+ this.setAngry(par1NBTTagCompound.getBoolean("Angry"));
+
+ this.setCombatTask();
+ }
+
+ /**
+ * Returns the sound this mob makes while it's alive.
+ */
+ protected String getLivingSound()
+ {
+ return "none";
+ }
+
+ /**
+ * Returns the sound this mob makes when it is hurt.
+ */
+ protected String getHurtSound()
+ {
+ return "mob.irongolem.hit";
+ }
+
+ /**
+ * Returns the sound this mob makes on death.
+ */
+ protected String getDeathSound()
+ {
+ return "mob.irongolem.death";
+ }
+
+ /**
+ * Returns the volume for the sounds this mob makes.
+ */
+ protected float getSoundVolume()
+ {
+ return 0.4F;
+ }
+
+ /**
+ * Returns the item ID for the item the mob drops on death.
+ */
+ protected int getDropItemId()
+ {
+ return -1;
+ }
+
+ /**
+ * Called frequently so the entity can update its state every tick as required. For example, zombies and skeletons
+ * use this to react to sunlight and start to burn.
+ */
+ public void onLivingUpdate()
+ {
+ super.onLivingUpdate();
+ int range = 2;
+
+ Vec3 blockVector = SpellHelper.getEntityBlockVector(this);
+
+ int xCoord = (int)(blockVector.xCoord);
+ int yCoord = (int)(blockVector.yCoord);
+ int zCoord = (int)(blockVector.zCoord);
+
+ for (int i = -range; i <= range; i++)
+ {
+ for (int j = -range; j <= range; j++)
+ {
+ for (int k = -range; k <= range; k++)
+ {
+ if (worldObj.rand.nextFloat() < 0.25f)
+ {
+ SpellHelper.freezeWaterBlock(worldObj, xCoord + i, yCoord + j, zCoord + k);
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * Called to update the entity's position/logic.
+ */
+ public void onUpdate()
+ {
+ super.onUpdate();
+ }
+
+ public float getEyeHeight()
+ {
+ return this.height * 0.8F;
+ }
+
+ /**
+ * The speed it takes to move the entityliving's rotationPitch through the faceEntity method. This is only currently
+ * use in wolves.
+ */
+ public int getVerticalFaceSpeed()
+ {
+ return this.isSitting() ? 20 : super.getVerticalFaceSpeed();
+ }
+
+ /**
+ * Called when the entity is attacked.
+ */
+ public boolean attackEntityFrom(DamageSource par1DamageSource, float par2)
+ {
+ if (this.isEntityInvulnerable())
+ {
+ return false;
+ } else
+ {
+ Entity entity = par1DamageSource.getEntity();
+ this.aiSit.setSitting(false);
+
+ if (entity != null && !(entity instanceof EntityPlayer) && !(entity instanceof EntityArrow))
+ {
+ par2 = (par2 + 1.0F) / 2.0F;
+ }
+
+ return super.attackEntityFrom(par1DamageSource, par2);
+ }
+ }
+
+ public boolean attackEntityAsMob(Entity par1Entity)
+ {
+ int i = this.isTamed() ? 4 : 2;
+ return par1Entity.attackEntityFrom(DamageSource.causeMobDamage(this), (float) i);
+ }
+
+ public void setTamed(boolean par1)
+ {
+ super.setTamed(par1);
+
+ if (par1)
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxTamedHealth);
+ } else
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxUntamedHealth);
+ }
+ }
+
+ /**
+ * Called when a player interacts with a mob. e.g. gets milk from a cow, gets into the saddle on a pig.
+ */
+ @Override
+ public boolean interact(EntityPlayer par1EntityPlayer)
+ {
+ ItemStack itemstack = par1EntityPlayer.inventory.getCurrentItem();
+
+ if (this.isTamed())
+ {
+ if (itemstack != null)
+ {
+ if (itemstack.getItem() instanceof ItemFood)
+ {
+ ItemFood itemfood = (ItemFood) itemstack.getItem();
+
+ if (itemfood.isWolfsFavoriteMeat() && this.dataWatcher.getWatchableObjectFloat(18) < this.maxTamedHealth)
+ {
+ if (!par1EntityPlayer.capabilities.isCreativeMode)
+ {
+ --itemstack.stackSize;
+ }
+
+ this.heal((float) itemfood.func_150905_g(itemstack));
+
+ if (itemstack.stackSize <= 0)
+ {
+ par1EntityPlayer.inventory.setInventorySlotContents(par1EntityPlayer.inventory.currentItem, (ItemStack) null);
+ }
+
+ return true;
+ }
+ }
+ }
+
+ if (this.getOwner() instanceof EntityPlayer && SpellHelper.getUsername(par1EntityPlayer).equalsIgnoreCase(SpellHelper.getUsername((EntityPlayer)this.getOwner())) && !this.isBreedingItem(itemstack))
+ {
+ if (!this.worldObj.isRemote)
+ {
+ this.aiSit.setSitting(!this.isSitting());
+ this.isJumping = false;
+ this.setPathToEntity((PathEntity) null);
+ this.setTarget((Entity) null);
+ this.setAttackTarget((EntityLivingBase) null);
+ }
+
+ this.sendSittingMessageToPlayer(par1EntityPlayer, !this.isSitting());
+ }
+ } else if (itemstack != null && itemstack.getItem().equals(ModItems.weakBloodOrb) && !this.isAngry())
+ {
+ if (!par1EntityPlayer.capabilities.isCreativeMode)
+ {
+ --itemstack.stackSize;
+ }
+
+ if (itemstack.stackSize <= 0)
+ {
+ par1EntityPlayer.inventory.setInventorySlotContents(par1EntityPlayer.inventory.currentItem, (ItemStack) null);
+ }
+
+ if (!this.worldObj.isRemote)
+ {
+ if (this.rand.nextInt(1) == 0)
+ {
+ this.setTamed(true);
+ this.setPathToEntity((PathEntity) null);
+ this.setAttackTarget((EntityLivingBase) null);
+ this.aiSit.setSitting(true);
+ this.setHealth(this.maxTamedHealth);
+ this.func_152115_b(par1EntityPlayer.getUniqueID().toString());
+ this.playTameEffect(true);
+ this.worldObj.setEntityState(this, (byte) 7);
+ } else
+ {
+ this.playTameEffect(false);
+ this.worldObj.setEntityState(this, (byte) 6);
+ }
+ }
+
+ return true;
+ }
+
+ return super.interact(par1EntityPlayer);
+ }
+
+
+ /**
+ * Checks if the parameter is an item which this animal can be fed to breed it (wheat, carrots or seeds depending on
+ * the animal type)
+ */
+ public boolean isBreedingItem(ItemStack par1ItemStack)
+ {
+ return false;
+ //return par1ItemStack == null ? false : (!(Item.itemsList[par1ItemStack.itemID] instanceof ItemFood) ? false : ((ItemFood)Item.itemsList[par1ItemStack.itemID]).isWolfsFavoriteMeat());
+ }
+
+ /**
+ * Determines whether this wolf is angry or not.
+ */
+ public boolean isAngry()
+ {
+ return (this.dataWatcher.getWatchableObjectByte(16) & 2) != 0;
+ }
+
+ /**
+ * Sets whether this wolf is angry or not.
+ */
+ public void setAngry(boolean par1)
+ {
+ byte b0 = this.dataWatcher.getWatchableObjectByte(16);
+
+ if (par1)
+ {
+ this.dataWatcher.updateObject(16, Byte.valueOf((byte) (b0 | 2)));
+ } else
+ {
+ this.dataWatcher.updateObject(16, Byte.valueOf((byte) (b0 & -3)));
+ }
+ }
+
+ /**
+ * Return this wolf's collar color.
+ */
+ public int getCollarColor()
+ {
+ return this.dataWatcher.getWatchableObjectByte(20) & 15;
+ }
+
+ /**
+ * Set this wolf's collar color.
+ */
+ public void setCollarColor(int par1)
+ {
+ this.dataWatcher.updateObject(20, Byte.valueOf((byte) (par1 & 15)));
+ }
+
+ /**
+ * This function is used when two same-species animals in 'love mode' breed to generate the new baby animal.
+ */
+ public EntityWolf spawnBabyAnimal(EntityAgeable par1EntityAgeable)
+ {
+ return null;
+ }
+
+ public void func_70918_i(boolean par1)
+ {
+ if (par1)
+ {
+ this.dataWatcher.updateObject(19, Byte.valueOf((byte) 1));
+ } else
+ {
+ this.dataWatcher.updateObject(19, Byte.valueOf((byte) 0));
+ }
+ }
+
+ /**
+ * Returns true if the mob is currently able to mate with the specified mob.
+ */
+ public boolean canMateWith(EntityAnimal par1EntityAnimal)
+ {
+ return false;
+ }
+
+ public boolean func_70922_bv()
+ {
+ return this.dataWatcher.getWatchableObjectByte(19) == 1;
+ }
+
+ /**
+ * Determines if an entity can be despawned, used on idle far away entities
+ */
+ protected boolean canDespawn()
+ {
+ //return !this.isTamed() && this.ticksExisted > 2400;
+ return false;
+ }
+
+ public boolean func_142018_a(EntityLivingBase par1EntityLivingBase, EntityLivingBase par2EntityLivingBase)
+ {
+ if (!(par1EntityLivingBase instanceof EntityCreeper) && !(par1EntityLivingBase instanceof EntityGhast))
+ {
+ if (par1EntityLivingBase instanceof EntityIceDemon)
+ {
+ EntityIceDemon entitywolf = (EntityIceDemon) par1EntityLivingBase;
+
+ if (entitywolf.isTamed() && entitywolf.getOwner() == par2EntityLivingBase)
+ {
+ return false;
+ }
+ }
+
+ return par1EntityLivingBase instanceof EntityPlayer && par2EntityLivingBase instanceof EntityPlayer && !((EntityPlayer) par2EntityLivingBase).canAttackPlayer((EntityPlayer) par1EntityLivingBase) ? false : !(par1EntityLivingBase instanceof EntityHorse) || !((EntityHorse) par1EntityLivingBase).isTame();
+ } else
+ {
+ return false;
+ }
+ }
+
+ public EntityAgeable createChild(EntityAgeable par1EntityAgeable)
+ {
+ return this.spawnBabyAnimal(par1EntityAgeable);
+ }
+
+ /**
+ * Attack the specified entity using a ranged attack.
+ */
+ public void attackEntityWithRangedAttack(EntityLivingBase par1EntityLivingBase, float par2)
+ {
+ double xCoord;
+ double yCoord;
+ double zCoord;
+ IceProjectile hol = new IceProjectile(worldObj, this, par1EntityLivingBase, 1.8f, 0f, 3, 600);
+ this.worldObj.spawnEntityInWorld(hol);
+ }
+
+ /**
+ * sets this entity's combat AI.
+ */
+ public void setCombatTask()
+ {
+ this.tasks.removeTask(this.aiAttackOnCollide);
+ this.tasks.removeTask(this.aiArrowAttack);
+ ItemStack itemstack = this.getHeldItem();
+ this.tasks.addTask(4, this.aiArrowAttack);
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityLowerGuardian.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityLowerGuardian.java
new file mode 100644
index 00000000..5d20a4e2
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityLowerGuardian.java
@@ -0,0 +1,486 @@
+package WayofTime.alchemicalWizardry.common.entity.mob;
+
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.ModItems;
+import WayofTime.alchemicalWizardry.common.EntityAITargetAggro;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+import net.minecraft.block.BlockColored;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityAgeable;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.SharedMonsterAttributes;
+import net.minecraft.entity.ai.*;
+import net.minecraft.entity.monster.EntityCreeper;
+import net.minecraft.entity.monster.EntityGhast;
+import net.minecraft.entity.passive.EntityAnimal;
+import net.minecraft.entity.passive.EntityHorse;
+import net.minecraft.entity.passive.EntityWolf;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.projectile.EntityArrow;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemFood;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.pathfinding.PathEntity;
+import net.minecraft.util.DamageSource;
+import net.minecraft.world.World;
+
+public class EntityLowerGuardian extends EntityDemon
+{
+ private EntityAIAttackOnCollide aiAttackOnCollide = new EntityAIAttackOnCollide(this, EntityPlayer.class, 1.2D, false);
+
+ private static float maxTamedHealth = 50.0F;
+ private static float maxUntamedHealth = 30.0F;
+ private int attackTimer;
+ private boolean isAggro;
+
+ public EntityLowerGuardian(World par1World)
+ {
+ super(par1World, AlchemicalWizardry.entityLowerGuardianID);
+ this.setSize(0.7F, 1.8F);
+ this.getNavigator().setAvoidsWater(true);
+ this.tasks.addTask(1, new EntityAISwimming(this));
+ //this.tasks.addTask(3, new EntityAILeapAtTarget(this, 0.4F));
+ this.tasks.addTask(2, new EntityAIAttackOnCollide(this, 1.0D, true));
+ this.tasks.addTask(3, this.aiSit);
+ this.tasks.addTask(5, new EntityAIFollowOwner(this, 1.0D, 10.0F, 2.0F));
+ //this.tasks.addTask(6, new EntityAIMate(this, 1.0D));
+ this.tasks.addTask(7, new EntityAIWander(this, 1.0D));
+ //this.tasks.addTask(8, new EntityAIBeg(this, 8.0F));
+ this.tasks.addTask(9, new EntityAIWatchClosest(this, EntityPlayer.class, 8.0F));
+ this.tasks.addTask(9, new EntityAILookIdle(this));
+ this.targetTasks.addTask(1, new EntityAIOwnerHurtByTarget(this));
+ this.targetTasks.addTask(2, new EntityAIOwnerHurtTarget(this));
+ this.targetTasks.addTask(3, new EntityAIHurtByTarget(this, true));
+ this.targetTasks.addTask(4, new EntityAITargetAggro(this, EntityPlayer.class, 0, false));
+ this.setAggro(false);
+ this.setTamed(false);
+ attackTimer = 0;
+ //isAggro = false;
+ //this.isImmuneToFire = true;
+ }
+
+ @Override
+ protected void applyEntityAttributes()
+ {
+ super.applyEntityAttributes();
+ //This line affects the speed of the monster
+ this.getEntityAttribute(SharedMonsterAttributes.movementSpeed).setBaseValue(0.30000001192092896D);
+
+ //My guess is that this will alter the max health
+ if (this.isTamed())
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxTamedHealth);
+ } else
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxUntamedHealth);
+ }
+
+ //this.func_110148_a(SharedMonsterAttributes.field_111267_a).func_111128_a(10.0D);
+ }
+
+ /**
+ * Returns true if the newer Entity AI code should be run
+ */
+ public boolean isAIEnabled()
+ {
+ return true;
+ }
+
+ /**
+ * Sets the active target the Task system uses for tracking
+ */
+ public void setAttackTarget(EntityLivingBase par1EntityLivingBase)
+ {
+ super.setAttackTarget(par1EntityLivingBase);
+
+ if (par1EntityLivingBase == null)
+ {
+ this.setAngry(false);
+ } else if (!this.isTamed())
+ {
+ this.setAngry(true);
+ }
+ }
+
+ /**
+ * main AI tick function, replaces updateEntityActionState
+ */
+ protected void updateAITick()
+ {
+ this.dataWatcher.updateObject(18, Float.valueOf(this.getHealth()));
+ }
+
+ protected void entityInit()
+ {
+ super.entityInit();
+ this.dataWatcher.addObject(18, new Float(this.getHealth()));
+ this.dataWatcher.addObject(19, new Byte((byte) 0));
+ //this.dataWatcher.addObject(20, new Byte((byte) BlockColored.getBlockFromDye(1)));
+ }
+
+ /**
+ * Plays step sound at given x, y, z for the entity
+ */
+ protected void playStepSound(int par1, int par2, int par3, int par4)
+ {
+ this.playSound("mob.zombie.step", 0.15F, 1.0F);
+ }
+
+ /**
+ * (abstract) Protected helper method to write subclass entity data to NBT.
+ */
+ public void writeEntityToNBT(NBTTagCompound par1NBTTagCompound)
+ {
+ super.writeEntityToNBT(par1NBTTagCompound);
+ par1NBTTagCompound.setBoolean("Angry", this.isAngry());
+ par1NBTTagCompound.setByte("attackTimer", (byte) attackTimer);
+ par1NBTTagCompound.setBoolean("isAggro", this.isAggro());
+ }
+
+ /**
+ * (abstract) Protected helper method to read subclass entity data from NBT.
+ */
+ public void readEntityFromNBT(NBTTagCompound par1NBTTagCompound)
+ {
+ super.readEntityFromNBT(par1NBTTagCompound);
+ this.setAngry(par1NBTTagCompound.getBoolean("Angry"));
+
+ attackTimer = par1NBTTagCompound.getByte("attackTimer");
+ isAggro = par1NBTTagCompound.getBoolean("isAggro");
+ }
+
+ /**
+ * Returns the sound this mob makes while it's alive.
+ */
+ protected String getLivingSound()
+ {
+ return "none";
+ }
+
+ /**
+ * Returns the sound this mob makes when it is hurt.
+ */
+ protected String getHurtSound()
+ {
+ return "mob.irongolem.hit";
+ }
+
+ /**
+ * Returns the sound this mob makes on death.
+ */
+ protected String getDeathSound()
+ {
+ return "mob.irongolem.death";
+ }
+
+ /**
+ * Returns the volume for the sounds this mob makes.
+ */
+ protected float getSoundVolume()
+ {
+ return 1.0F;
+ }
+
+ /**
+ * Returns the item ID for the item the mob drops on death.
+ */
+ protected int getDropItemId()
+ {
+ return -1;
+ }
+
+ /**
+ * Called frequently so the entity can update its state every tick as required. For example, zombies and skeletons
+ * use this to react to sunlight and start to burn.
+ */
+ public void onLivingUpdate()
+ {
+ super.onLivingUpdate();
+
+ if (attackTimer > 0)
+ {
+ attackTimer--;
+ }
+ }
+
+ public int getAttackTimer()
+ {
+ return attackTimer;
+ }
+
+ /**
+ * Called to update the entity's position/logic.
+ */
+ public void onUpdate()
+ {
+ super.onUpdate();
+ }
+
+ public float getEyeHeight()
+ {
+ return this.height * 0.8F;
+ }
+
+ /**
+ * The speed it takes to move the entityliving's rotationPitch through the faceEntity method. This is only currently
+ * use in wolves.
+ */
+ public int getVerticalFaceSpeed()
+ {
+ return this.isSitting() ? 20 : super.getVerticalFaceSpeed();
+ }
+
+ /**
+ * Called when the entity is attacked.
+ */
+ public boolean attackEntityFrom(DamageSource par1DamageSource, float par2)
+ {
+ if (this.isEntityInvulnerable())
+ {
+ return false;
+ } else
+ {
+ Entity entity = par1DamageSource.getEntity();
+ this.aiSit.setSitting(false);
+
+ if (entity != null && !(entity instanceof EntityPlayer) && !(entity instanceof EntityArrow))
+ {
+ par2 = (par2 + 1.0F) / 2.0F;
+ }
+
+ return super.attackEntityFrom(par1DamageSource, par2);
+ }
+ }
+
+ public boolean attackEntityAsMob(Entity par1Entity)
+ {
+ this.attackTimer = 10;
+ this.worldObj.setEntityState(this, (byte) 4);
+ boolean flag = par1Entity.attackEntityFrom(DamageSource.causeMobDamage(this), (float) (7 + this.rand.nextInt(15)));
+
+ if (flag)
+ {
+ par1Entity.motionY += 0.4000000059604645D;
+ }
+
+ this.playSound("mob.irongolem.throw", 1.0F, 1.0F);
+ return flag;
+ }
+
+ public void setTamed(boolean par1)
+ {
+ super.setTamed(par1);
+
+ if (par1)
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxTamedHealth);
+ } else
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxUntamedHealth);
+ }
+ }
+
+ /**
+ * Called when a player interacts with a mob. e.g. gets milk from a cow, gets into the saddle on a pig.
+ */
+ @Override
+ public boolean interact(EntityPlayer par1EntityPlayer)
+ {
+ ItemStack itemstack = par1EntityPlayer.inventory.getCurrentItem();
+
+ if (this.isTamed())
+ {
+ if (itemstack != null)
+ {
+ if (itemstack.getItem() instanceof ItemFood)
+ {
+ ItemFood itemfood = (ItemFood) itemstack.getItem();
+
+ if (itemfood.isWolfsFavoriteMeat() && this.dataWatcher.getWatchableObjectFloat(18) < this.maxTamedHealth)
+ {
+ if (!par1EntityPlayer.capabilities.isCreativeMode)
+ {
+ --itemstack.stackSize;
+ }
+
+ this.heal((float) itemfood.func_150905_g(itemstack));
+
+ if (itemstack.stackSize <= 0)
+ {
+ par1EntityPlayer.inventory.setInventorySlotContents(par1EntityPlayer.inventory.currentItem, (ItemStack) null);
+ }
+
+ return true;
+ }
+ }
+ }
+
+ if (this.getOwner() instanceof EntityPlayer && SpellHelper.getUsername(par1EntityPlayer).equalsIgnoreCase(SpellHelper.getUsername((EntityPlayer)this.getOwner())) && !this.isBreedingItem(itemstack))
+ {
+ if (!this.worldObj.isRemote)
+ {
+ this.aiSit.setSitting(!this.isSitting());
+ this.isJumping = false;
+ this.setPathToEntity((PathEntity) null);
+ this.setTarget((Entity) null);
+ this.setAttackTarget((EntityLivingBase) null);
+ }
+
+ this.sendSittingMessageToPlayer(par1EntityPlayer, !this.isSitting());
+ }
+ } else if (itemstack != null && itemstack.getItem().equals(ModItems.weakBloodOrb) && !this.isAngry())
+ {
+ if (!par1EntityPlayer.capabilities.isCreativeMode)
+ {
+ --itemstack.stackSize;
+ }
+
+ if (itemstack.stackSize <= 0)
+ {
+ par1EntityPlayer.inventory.setInventorySlotContents(par1EntityPlayer.inventory.currentItem, (ItemStack) null);
+ }
+
+ if (!this.worldObj.isRemote)
+ {
+ if (this.rand.nextInt(1) == 0)
+ {
+ this.setTamed(true);
+ this.setPathToEntity((PathEntity) null);
+ this.setAttackTarget((EntityLivingBase) null);
+ this.aiSit.setSitting(true);
+ this.setHealth(this.maxTamedHealth);
+ this.func_152115_b(par1EntityPlayer.getUniqueID().toString());
+ this.playTameEffect(true);
+ this.worldObj.setEntityState(this, (byte) 7);
+ } else
+ {
+ this.playTameEffect(false);
+ this.worldObj.setEntityState(this, (byte) 6);
+ }
+ }
+
+ return true;
+ }
+
+ return super.interact(par1EntityPlayer);
+ }
+
+
+ /**
+ * Checks if the parameter is an item which this animal can be fed to breed it (wheat, carrots or seeds depending on
+ * the animal type)
+ */
+ public boolean isBreedingItem(ItemStack par1ItemStack)
+ {
+ return false;
+ //return par1ItemStack == null ? false : (!(Item.itemsList[par1ItemStack.itemID] instanceof ItemFood) ? false : ((ItemFood)Item.itemsList[par1ItemStack.itemID]).isWolfsFavoriteMeat());
+ }
+
+ /**
+ * Determines whether this wolf is angry or not.
+ */
+ public boolean isAngry()
+ {
+ return (this.dataWatcher.getWatchableObjectByte(16) & 2) != 0;
+ }
+
+ /**
+ * Sets whether this wolf is angry or not.
+ */
+ public void setAngry(boolean par1)
+ {
+ byte b0 = this.dataWatcher.getWatchableObjectByte(16);
+
+ if (par1)
+ {
+ this.dataWatcher.updateObject(16, Byte.valueOf((byte) (b0 | 2)));
+ } else
+ {
+ this.dataWatcher.updateObject(16, Byte.valueOf((byte) (b0 & -3)));
+ }
+ }
+
+ /**
+ * Return this wolf's collar color.
+ */
+ public int getCollarColor()
+ {
+ return this.dataWatcher.getWatchableObjectByte(20) & 15;
+ }
+
+ /**
+ * Set this wolf's collar color.
+ */
+ public void setCollarColor(int par1)
+ {
+ this.dataWatcher.updateObject(20, Byte.valueOf((byte) (par1 & 15)));
+ }
+
+ /**
+ * This function is used when two same-species animals in 'love mode' breed to generate the new baby animal.
+ */
+ public EntityWolf spawnBabyAnimal(EntityAgeable par1EntityAgeable)
+ {
+ return null;
+ }
+
+ public void func_70918_i(boolean par1)
+ {
+ if (par1)
+ {
+ this.dataWatcher.updateObject(19, Byte.valueOf((byte) 1));
+ } else
+ {
+ this.dataWatcher.updateObject(19, Byte.valueOf((byte) 0));
+ }
+ }
+
+ /**
+ * Returns true if the mob is currently able to mate with the specified mob.
+ */
+ public boolean canMateWith(EntityAnimal par1EntityAnimal)
+ {
+ return false;
+ }
+
+ public boolean func_70922_bv()
+ {
+ return this.dataWatcher.getWatchableObjectByte(19) == 1;
+ }
+
+ /**
+ * Determines if an entity can be despawned, used on idle far away entities
+ */
+ protected boolean canDespawn()
+ {
+ //return !this.isTamed() && this.ticksExisted > 2400;
+ return false;
+ }
+
+ public boolean func_142018_a(EntityLivingBase par1EntityLivingBase, EntityLivingBase par2EntityLivingBase)
+ {
+ if (!(par1EntityLivingBase instanceof EntityCreeper) && !(par1EntityLivingBase instanceof EntityGhast))
+ {
+ if (par1EntityLivingBase instanceof EntityLowerGuardian)
+ {
+ EntityLowerGuardian entitywolf = (EntityLowerGuardian) par1EntityLivingBase;
+
+ if (entitywolf.isTamed() && entitywolf.getOwner() == par2EntityLivingBase)
+ {
+ return false;
+ }
+ }
+
+ return par1EntityLivingBase instanceof EntityPlayer && par2EntityLivingBase instanceof EntityPlayer && !((EntityPlayer) par2EntityLivingBase).canAttackPlayer((EntityPlayer) par1EntityLivingBase) ? false : !(par1EntityLivingBase instanceof EntityHorse) || !((EntityHorse) par1EntityLivingBase).isTame();
+ } else
+ {
+ return false;
+ }
+ }
+
+ public EntityAgeable createChild(EntityAgeable par1EntityAgeable)
+ {
+ return this.spawnBabyAnimal(par1EntityAgeable);
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityShade.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityShade.java
new file mode 100644
index 00000000..068095a2
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityShade.java
@@ -0,0 +1,493 @@
+package WayofTime.alchemicalWizardry.common.entity.mob;
+
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.ModItems;
+import WayofTime.alchemicalWizardry.common.EntityAITargetAggro;
+import WayofTime.alchemicalWizardry.common.entity.projectile.HolyProjectile;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+import net.minecraft.block.BlockColored;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityAgeable;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.SharedMonsterAttributes;
+import net.minecraft.entity.ai.*;
+import net.minecraft.entity.monster.EntityCreeper;
+import net.minecraft.entity.monster.EntityGhast;
+import net.minecraft.entity.passive.EntityAnimal;
+import net.minecraft.entity.passive.EntityHorse;
+import net.minecraft.entity.passive.EntityWolf;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.projectile.EntityArrow;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemFood;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.pathfinding.PathEntity;
+import net.minecraft.util.DamageSource;
+import net.minecraft.world.World;
+
+public class EntityShade extends EntityDemon
+{
+ //private EntityAIArrowAttack aiArrowAttack = new EntityAIArrowAttack(this, 1.0D, 40, 40, 15.0F);
+ private EntityAIAttackOnCollide aiAttackOnCollide = new EntityAIAttackOnCollide(this, EntityPlayer.class, 1.2D, false);
+
+ private static float maxTamedHealth = 50.0F;
+ private static float maxUntamedHealth = 100.0F;
+
+ public EntityShade(World par1World)
+ {
+ super(par1World, AlchemicalWizardry.entityShadeID);
+ this.setSize(0.8F, 2.0F);
+ this.getNavigator().setAvoidsWater(true);
+ this.tasks.addTask(1, new EntityAISwimming(this));
+ this.tasks.addTask(2, this.aiSit);
+ //this.tasks.addTask(3, new EntityAILeapAtTarget(this, 0.4F));
+ this.tasks.addTask(4, new EntityAIAttackOnCollide(this, 1.0D, true));
+ this.tasks.addTask(5, new EntityAIFollowOwner(this, 1.0D, 10.0F, 2.0F));
+ //this.tasks.addTask(6, new EntityAIMate(this, 1.0D));
+ this.tasks.addTask(7, new EntityAIWander(this, 1.0D));
+ //this.tasks.addTask(8, new EntityAIBeg(this, 8.0F));
+ this.tasks.addTask(9, new EntityAIWatchClosest(this, EntityPlayer.class, 8.0F));
+ this.tasks.addTask(9, new EntityAILookIdle(this));
+ this.targetTasks.addTask(1, new EntityAIOwnerHurtByTarget(this));
+ this.targetTasks.addTask(2, new EntityAIOwnerHurtTarget(this));
+ this.targetTasks.addTask(3, new EntityAIHurtByTarget(this, true));
+ this.targetTasks.addTask(4, new EntityAITargetAggro(this, EntityPlayer.class, 0, false));
+ this.setAggro(false);
+ //this.targetTasks.addTask(4, new EntityAITargetNonTamed(this, EntitySheep.class, 200, false));
+ this.setTamed(false);
+
+ if (par1World != null && !par1World.isRemote)
+ {
+ this.setCombatTask();
+ }
+
+ //this.isImmuneToFire = true;
+ }
+
+ @Override
+ protected void applyEntityAttributes()
+ {
+ super.applyEntityAttributes();
+ //This line affects the speed of the monster
+ this.getEntityAttribute(SharedMonsterAttributes.movementSpeed).setBaseValue(0.30000001192092896D);
+
+ //My guess is that this will alter the max health
+ if (this.isTamed())
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxTamedHealth);
+ } else
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxUntamedHealth);
+ }
+
+ //this.func_110148_a(SharedMonsterAttributes.field_111267_a).func_111128_a(10.0D);
+ }
+
+ /**
+ * Returns true if the newer Entity AI code should be run
+ */
+ public boolean isAIEnabled()
+ {
+ return true;
+ }
+
+ /**
+ * Sets the active target the Task system uses for tracking
+ */
+ public void setAttackTarget(EntityLivingBase par1EntityLivingBase)
+ {
+ super.setAttackTarget(par1EntityLivingBase);
+
+ if (par1EntityLivingBase == null)
+ {
+ this.setAngry(false);
+ } else if (!this.isTamed())
+ {
+ this.setAngry(true);
+ }
+ }
+
+ /**
+ * main AI tick function, replaces updateEntityActionState
+ */
+ protected void updateAITick()
+ {
+ this.dataWatcher.updateObject(18, Float.valueOf(this.getHealth()));
+ }
+
+ protected void entityInit()
+ {
+ super.entityInit();
+ this.dataWatcher.addObject(18, new Float(this.getHealth()));
+ this.dataWatcher.addObject(19, new Byte((byte) 0));
+ //this.dataWatcher.addObject(20, new Byte((byte) BlockColored.getBlockFromDye(1)));
+ }
+
+ /**
+ * Plays step sound at given x, y, z for the entity
+ */
+ protected void playStepSound(int par1, int par2, int par3, int par4)
+ {
+ this.playSound("mob.zombie.step", 0.15F, 1.0F);
+ }
+
+ /**
+ * (abstract) Protected helper method to write subclass entity data to NBT.
+ */
+ public void writeEntityToNBT(NBTTagCompound par1NBTTagCompound)
+ {
+ super.writeEntityToNBT(par1NBTTagCompound);
+ par1NBTTagCompound.setBoolean("Angry", this.isAngry());
+ }
+
+ /**
+ * (abstract) Protected helper method to read subclass entity data from NBT.
+ */
+ public void readEntityFromNBT(NBTTagCompound par1NBTTagCompound)
+ {
+ super.readEntityFromNBT(par1NBTTagCompound);
+ this.setAngry(par1NBTTagCompound.getBoolean("Angry"));
+
+ this.setCombatTask();
+ }
+
+ /**
+ * Returns the sound this mob makes while it's alive.
+ */
+ protected String getLivingSound()
+ {
+ //TODO change sounds
+ return "none";
+ }
+
+ /**
+ * Returns the sound this mob makes when it is hurt.
+ */
+ protected String getHurtSound()
+ {
+ return "none";
+ }
+
+ /**
+ * Returns the sound this mob makes on death.
+ */
+ protected String getDeathSound()
+ {
+ return "none";
+ }
+
+ /**
+ * Returns the volume for the sounds this mob makes.
+ */
+ protected float getSoundVolume()
+ {
+ return 0.4F;
+ }
+
+ /**
+ * Returns the item ID for the item the mob drops on death.
+ */
+ protected int getDropItemId()
+ {
+ return -1;
+ }
+
+ /**
+ * Called frequently so the entity can update its state every tick as required. For example, zombies and skeletons
+ * use this to react to sunlight and start to burn.
+ */
+ public void onLivingUpdate()
+ {
+ super.onLivingUpdate();
+ }
+
+ /**
+ * Called to update the entity's position/logic.
+ */
+ public void onUpdate()
+ {
+ super.onUpdate();
+ }
+
+ public float getEyeHeight()
+ {
+ return this.height * 0.8F;
+ }
+
+ /**
+ * The speed it takes to move the entityliving's rotationPitch through the faceEntity method. This is only currently
+ * use in wolves.
+ */
+ public int getVerticalFaceSpeed()
+ {
+ return this.isSitting() ? 20 : super.getVerticalFaceSpeed();
+ }
+
+ /**
+ * Called when the entity is attacked.
+ */
+ public boolean attackEntityFrom(DamageSource par1DamageSource, float par2)
+ {
+ if (this.isEntityInvulnerable())
+ {
+ return false;
+ } else
+ {
+ Entity entity = par1DamageSource.getEntity();
+ this.aiSit.setSitting(false);
+
+ if (entity != null && !(entity instanceof EntityPlayer) && !(entity instanceof EntityArrow))
+ {
+ par2 = (par2 + 1.0F) / 2.0F;
+ }
+
+ return super.attackEntityFrom(par1DamageSource, par2);
+ }
+ }
+
+ public boolean attackEntityAsMob(Entity par1Entity)
+ {
+ int i = this.isTamed() ? 6 : 7;
+ return par1Entity.attackEntityFrom(DamageSource.causeMobDamage(this), (float) i);
+ }
+
+ public void setTamed(boolean par1)
+ {
+ super.setTamed(par1);
+
+ if (par1)
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxTamedHealth);
+ } else
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxUntamedHealth);
+ }
+ }
+
+ /**
+ * Called when a player interacts with a mob. e.g. gets milk from a cow, gets into the saddle on a pig.
+ */
+ @Override
+ public boolean interact(EntityPlayer par1EntityPlayer)
+ {
+ ItemStack itemstack = par1EntityPlayer.inventory.getCurrentItem();
+
+ if (this.isTamed())
+ {
+ if (itemstack != null)
+ {
+ if (itemstack.getItem() instanceof ItemFood)
+ {
+ ItemFood itemfood = (ItemFood) itemstack.getItem();
+
+ if (itemfood.isWolfsFavoriteMeat() && this.dataWatcher.getWatchableObjectFloat(18) < this.maxTamedHealth)
+ {
+ if (!par1EntityPlayer.capabilities.isCreativeMode)
+ {
+ --itemstack.stackSize;
+ }
+
+ this.heal((float) itemfood.func_150905_g(itemstack));
+
+ if (itemstack.stackSize <= 0)
+ {
+ par1EntityPlayer.inventory.setInventorySlotContents(par1EntityPlayer.inventory.currentItem, (ItemStack) null);
+ }
+
+ return true;
+ }
+ }
+ }
+
+ if (this.getOwner() instanceof EntityPlayer && SpellHelper.getUsername(par1EntityPlayer).equalsIgnoreCase(SpellHelper.getUsername((EntityPlayer)this.getOwner())) && !this.isBreedingItem(itemstack))
+ {
+ if (!this.worldObj.isRemote)
+ {
+ this.aiSit.setSitting(!this.isSitting());
+ this.isJumping = false;
+ this.setPathToEntity((PathEntity) null);
+ this.setTarget((Entity) null);
+ this.setAttackTarget((EntityLivingBase) null);
+ }
+
+ this.sendSittingMessageToPlayer(par1EntityPlayer, !this.isSitting());
+ }
+ } else if (itemstack != null && itemstack.getItem().equals(ModItems.weakBloodOrb) && !this.isAngry())
+ {
+ if (!par1EntityPlayer.capabilities.isCreativeMode)
+ {
+ --itemstack.stackSize;
+ }
+
+ if (itemstack.stackSize <= 0)
+ {
+ par1EntityPlayer.inventory.setInventorySlotContents(par1EntityPlayer.inventory.currentItem, (ItemStack) null);
+ }
+
+ if (!this.worldObj.isRemote)
+ {
+ if (this.rand.nextInt(1) == 0)
+ {
+ this.setTamed(true);
+ this.setPathToEntity((PathEntity) null);
+ this.setAttackTarget((EntityLivingBase) null);
+ this.aiSit.setSitting(true);
+ this.setHealth(this.maxTamedHealth);
+ this.func_152115_b(par1EntityPlayer.getUniqueID().toString());
+ this.playTameEffect(true);
+ this.worldObj.setEntityState(this, (byte) 7);
+ } else
+ {
+ this.playTameEffect(false);
+ this.worldObj.setEntityState(this, (byte) 6);
+ }
+ }
+
+ return true;
+ }
+
+ return super.interact(par1EntityPlayer);
+ }
+
+
+ /**
+ * Checks if the parameter is an item which this animal can be fed to breed it (wheat, carrots or seeds depending on
+ * the animal type)
+ */
+ public boolean isBreedingItem(ItemStack par1ItemStack)
+ {
+ return false;
+ //return par1ItemStack == null ? false : (!(Item.itemsList[par1ItemStack.itemID] instanceof ItemFood) ? false : ((ItemFood)Item.itemsList[par1ItemStack.itemID]).isWolfsFavoriteMeat());
+ }
+
+ /**
+ * Determines whether this wolf is angry or not.
+ */
+ public boolean isAngry()
+ {
+ return (this.dataWatcher.getWatchableObjectByte(16) & 2) != 0;
+ }
+
+ /**
+ * Sets whether this wolf is angry or not.
+ */
+ public void setAngry(boolean par1)
+ {
+ byte b0 = this.dataWatcher.getWatchableObjectByte(16);
+
+ if (par1)
+ {
+ this.dataWatcher.updateObject(16, Byte.valueOf((byte) (b0 | 2)));
+ } else
+ {
+ this.dataWatcher.updateObject(16, Byte.valueOf((byte) (b0 & -3)));
+ }
+ }
+
+ /**
+ * Return this wolf's collar color.
+ */
+ public int getCollarColor()
+ {
+ return this.dataWatcher.getWatchableObjectByte(20) & 15;
+ }
+
+ /**
+ * Set this wolf's collar color.
+ */
+ public void setCollarColor(int par1)
+ {
+ this.dataWatcher.updateObject(20, Byte.valueOf((byte) (par1 & 15)));
+ }
+
+ /**
+ * This function is used when two same-species animals in 'love mode' breed to generate the new baby animal.
+ */
+ public EntityWolf spawnBabyAnimal(EntityAgeable par1EntityAgeable)
+ {
+ return null;
+ }
+
+ public void func_70918_i(boolean par1)
+ {
+ if (par1)
+ {
+ this.dataWatcher.updateObject(19, Byte.valueOf((byte) 1));
+ } else
+ {
+ this.dataWatcher.updateObject(19, Byte.valueOf((byte) 0));
+ }
+ }
+
+ /**
+ * Returns true if the mob is currently able to mate with the specified mob.
+ */
+ public boolean canMateWith(EntityAnimal par1EntityAnimal)
+ {
+ return false;
+ }
+
+ public boolean func_70922_bv()
+ {
+ return this.dataWatcher.getWatchableObjectByte(19) == 1;
+ }
+
+ /**
+ * Determines if an entity can be despawned, used on idle far away entities
+ */
+ protected boolean canDespawn()
+ {
+ //return !this.isTamed() && this.ticksExisted > 2400;
+ return false;
+ }
+
+ public boolean func_142018_a(EntityLivingBase par1EntityLivingBase, EntityLivingBase par2EntityLivingBase)
+ {
+ if (!(par1EntityLivingBase instanceof EntityCreeper) && !(par1EntityLivingBase instanceof EntityGhast))
+ {
+ if (par1EntityLivingBase instanceof EntityBoulderFist)
+ {
+ EntityBoulderFist entitywolf = (EntityBoulderFist) par1EntityLivingBase;
+
+ if (entitywolf.isTamed() && entitywolf.getOwner() == par2EntityLivingBase)
+ {
+ return false;
+ }
+ }
+
+ return par1EntityLivingBase instanceof EntityPlayer && par2EntityLivingBase instanceof EntityPlayer && !((EntityPlayer) par2EntityLivingBase).canAttackPlayer((EntityPlayer) par1EntityLivingBase) ? false : !(par1EntityLivingBase instanceof EntityHorse) || !((EntityHorse) par1EntityLivingBase).isTame();
+ } else
+ {
+ return false;
+ }
+ }
+
+ public EntityAgeable createChild(EntityAgeable par1EntityAgeable)
+ {
+ return this.spawnBabyAnimal(par1EntityAgeable);
+ }
+
+ /**
+ * Attack the specified entity using a ranged attack.
+ */
+ public void attackEntityWithRangedAttack(EntityLivingBase par1EntityLivingBase, float par2)
+ {
+ double xCoord;
+ double yCoord;
+ double zCoord;
+ HolyProjectile hol = new HolyProjectile(worldObj, this, par1EntityLivingBase, 1.8f, 0f, 5, 600);
+ this.worldObj.spawnEntityInWorld(hol);
+ }
+
+ /**
+ * sets this entity's combat AI.
+ */
+ public void setCombatTask()
+ {
+ this.tasks.removeTask(this.aiAttackOnCollide);
+ //this.tasks.removeTask(this.aiArrowAttack);
+ ItemStack itemstack = this.getHeldItem();
+ this.tasks.addTask(4, this.aiAttackOnCollide);
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityShadeElemental.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityShadeElemental.java
new file mode 100644
index 00000000..004fcce4
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityShadeElemental.java
@@ -0,0 +1,27 @@
+package WayofTime.alchemicalWizardry.common.entity.mob;
+
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.monster.IMob;
+import net.minecraft.potion.Potion;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.world.World;
+
+public class EntityShadeElemental extends EntityElemental implements IMob
+{
+ public EntityShadeElemental(World world)
+ {
+ super(world, AlchemicalWizardry.entityShadeElementalID);
+ }
+
+ public void inflictEffectOnEntity(Entity target)
+ {
+ if (target instanceof EntityLivingBase)
+ {
+ ((EntityLivingBase) target).addPotionEffect(new PotionEffect(Potion.blindness.id, 100, 1));
+ ((EntityLivingBase) target).addPotionEffect(new PotionEffect(AlchemicalWizardry.customPotionInhibit.id, 150, 0));
+ ((EntityLivingBase) target).addPotionEffect(new PotionEffect(Potion.nightVision.id, 100, 0));
+ }
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntitySmallEarthGolem.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntitySmallEarthGolem.java
new file mode 100644
index 00000000..73e4e076
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntitySmallEarthGolem.java
@@ -0,0 +1,500 @@
+package WayofTime.alchemicalWizardry.common.entity.mob;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityAgeable;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.IRangedAttackMob;
+import net.minecraft.entity.SharedMonsterAttributes;
+import net.minecraft.entity.ai.EntityAIArrowAttack;
+import net.minecraft.entity.ai.EntityAIAttackOnCollide;
+import net.minecraft.entity.ai.EntityAIFollowOwner;
+import net.minecraft.entity.ai.EntityAIHurtByTarget;
+import net.minecraft.entity.ai.EntityAILookIdle;
+import net.minecraft.entity.ai.EntityAIOwnerHurtByTarget;
+import net.minecraft.entity.ai.EntityAIOwnerHurtTarget;
+import net.minecraft.entity.ai.EntityAISwimming;
+import net.minecraft.entity.ai.EntityAIWander;
+import net.minecraft.entity.ai.EntityAIWatchClosest;
+import net.minecraft.entity.monster.EntityCreeper;
+import net.minecraft.entity.monster.EntityGhast;
+import net.minecraft.entity.passive.EntityAnimal;
+import net.minecraft.entity.passive.EntityHorse;
+import net.minecraft.entity.passive.EntityWolf;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.projectile.EntityArrow;
+import net.minecraft.item.ItemFood;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.pathfinding.PathEntity;
+import net.minecraft.util.DamageSource;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.ModItems;
+import WayofTime.alchemicalWizardry.common.EntityAITargetAggro;
+import WayofTime.alchemicalWizardry.common.entity.projectile.MudProjectile;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+
+public class EntitySmallEarthGolem extends EntityDemon implements IRangedAttackMob
+{
+ private EntityAIArrowAttack aiArrowAttack = new EntityAIArrowAttack(this, 1.0D, 25, 25, 15.0F);
+ private EntityAIAttackOnCollide aiAttackOnCollide = new EntityAIAttackOnCollide(this, EntityPlayer.class, 1.2D, false);
+
+ private static float maxTamedHealth = 20.0F;
+ private static float maxUntamedHealth = 10.0F;
+
+ public EntitySmallEarthGolem(World par1World)
+ {
+ super(par1World, AlchemicalWizardry.entitySmallEarthGolemID);
+ this.setSize(0.2F, 1.0F);
+ this.getNavigator().setAvoidsWater(true);
+ this.tasks.addTask(1, new EntityAISwimming(this));
+ this.tasks.addTask(2, this.aiSit);
+ //this.tasks.addTask(3, new EntityAILeapAtTarget(this, 0.4F));
+ //this.tasks.addTask(4, new EntityAIAttackOnCollide(this, 1.0D, true));
+ this.tasks.addTask(5, new EntityAIFollowOwner(this, 1.0D, 10.0F, 2.0F));
+ //this.tasks.addTask(6, new EntityAIMate(this, 1.0D));
+ this.tasks.addTask(7, new EntityAIWander(this, 1.0D));
+ //this.tasks.addTask(8, new EntityAIBeg(this, 8.0F));
+ this.tasks.addTask(9, new EntityAIWatchClosest(this, EntityPlayer.class, 8.0F));
+ this.tasks.addTask(9, new EntityAILookIdle(this));
+ this.targetTasks.addTask(1, new EntityAIOwnerHurtByTarget(this));
+ this.targetTasks.addTask(2, new EntityAIOwnerHurtTarget(this));
+ this.targetTasks.addTask(3, new EntityAIHurtByTarget(this, true));
+ this.targetTasks.addTask(4, new EntityAITargetAggro(this, EntityPlayer.class, 0, false));
+ this.setAggro(false);
+ //this.targetTasks.addTask(4, new EntityAITargetNonTamed(this, EntitySheep.class, 200, false));
+ this.setTamed(false);
+
+ if (par1World != null && !par1World.isRemote)
+ {
+ this.setCombatTask();
+ }
+
+ //this.isImmuneToFire = true;
+ }
+
+ @Override
+ protected void applyEntityAttributes()
+ {
+ super.applyEntityAttributes();
+ //This line affects the speed of the monster
+ this.getEntityAttribute(SharedMonsterAttributes.movementSpeed).setBaseValue(0.40000001192092896D);
+
+ //My guess is that this will alter the max health
+ if (this.isTamed())
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxTamedHealth);
+ } else
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxUntamedHealth);
+ }
+
+ //this.func_110148_a(SharedMonsterAttributes.field_111267_a).func_111128_a(10.0D);
+ }
+
+ /**
+ * Returns true if the newer Entity AI code should be run
+ */
+ public boolean isAIEnabled()
+ {
+ return true;
+ }
+
+ /**
+ * Sets the active target the Task system uses for tracking
+ */
+ public void setAttackTarget(EntityLivingBase par1EntityLivingBase)
+ {
+ super.setAttackTarget(par1EntityLivingBase);
+
+ if (par1EntityLivingBase == null)
+ {
+ this.setAngry(false);
+ } else if (!this.isTamed())
+ {
+ this.setAngry(true);
+ }
+ }
+
+ /**
+ * main AI tick function, replaces updateEntityActionState
+ */
+ protected void updateAITick()
+ {
+ this.dataWatcher.updateObject(18, Float.valueOf(this.getHealth()));
+ }
+
+ protected void entityInit()
+ {
+ super.entityInit();
+ this.dataWatcher.addObject(18, new Float(this.getHealth()));
+ this.dataWatcher.addObject(19, new Byte((byte) 0));
+ //this.dataWatcher.addObject(20, new Byte((byte) BlockColored.getBlockFromDye(1)));
+ }
+
+ /**
+ * Plays step sound at given x, y, z for the entity
+ */
+ protected void playStepSound(int par1, int par2, int par3, int par4)
+ {
+ this.playSound("mob.zombie.step", 0.15F, 1.0F);
+ }
+
+ /**
+ * (abstract) Protected helper method to write subclass entity data to NBT.
+ */
+ public void writeEntityToNBT(NBTTagCompound par1NBTTagCompound)
+ {
+ super.writeEntityToNBT(par1NBTTagCompound);
+ par1NBTTagCompound.setBoolean("Angry", this.isAngry());
+ }
+
+ /**
+ * (abstract) Protected helper method to read subclass entity data from NBT.
+ */
+ public void readEntityFromNBT(NBTTagCompound par1NBTTagCompound)
+ {
+ super.readEntityFromNBT(par1NBTTagCompound);
+ this.setAngry(par1NBTTagCompound.getBoolean("Angry"));
+
+ this.setCombatTask();
+ }
+
+ /**
+ * Returns the sound this mob makes while it's alive.
+ */
+ protected String getLivingSound()
+ {
+ return "none";
+ }
+
+ /**
+ * Returns the sound this mob makes when it is hurt.
+ */
+ protected String getHurtSound()
+ {
+ return "mob.irongolem.hit";
+ }
+
+ /**
+ * Returns the sound this mob makes on death.
+ */
+ protected String getDeathSound()
+ {
+ return "mob.irongolem.death";
+ }
+
+ /**
+ * Returns the volume for the sounds this mob makes.
+ */
+ protected float getSoundVolume()
+ {
+ return 0.4F;
+ }
+
+ /**
+ * Returns the item ID for the item the mob drops on death.
+ */
+ protected int getDropItemId()
+ {
+ return -1;
+ }
+
+ /**
+ * Called frequently so the entity can update its state every tick as required. For example, zombies and skeletons
+ * use this to react to sunlight and start to burn.
+ */
+ public void onLivingUpdate()
+ {
+ super.onLivingUpdate();
+ }
+
+ /**
+ * Called to update the entity's position/logic.
+ */
+ public void onUpdate()
+ {
+ super.onUpdate();
+ }
+
+ public float getEyeHeight()
+ {
+ return this.height * 0.8F;
+ }
+
+ /**
+ * The speed it takes to move the entityliving's rotationPitch through the faceEntity method. This is only currently
+ * use in wolves.
+ */
+ public int getVerticalFaceSpeed()
+ {
+ return this.isSitting() ? 20 : super.getVerticalFaceSpeed();
+ }
+
+ /**
+ * Called when the entity is attacked.
+ */
+ public boolean attackEntityFrom(DamageSource par1DamageSource, float par2)
+ {
+ if (this.isEntityInvulnerable())
+ {
+ return false;
+ } else
+ {
+ Entity entity = par1DamageSource.getEntity();
+ this.aiSit.setSitting(false);
+
+ if (entity != null && !(entity instanceof EntityPlayer) && !(entity instanceof EntityArrow))
+ {
+ par2 = (par2 + 1.0F) / 2.0F;
+ }
+
+ return super.attackEntityFrom(par1DamageSource, par2);
+ }
+ }
+
+ public boolean attackEntityAsMob(Entity par1Entity)
+ {
+ int i = this.isTamed() ? 4 : 2;
+ return par1Entity.attackEntityFrom(DamageSource.causeMobDamage(this), (float) i);
+ }
+
+ public void setTamed(boolean par1)
+ {
+ super.setTamed(par1);
+
+ if (par1)
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxTamedHealth);
+ } else
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxUntamedHealth);
+ }
+ }
+
+ /**
+ * Called when a player interacts with a mob. e.g. gets milk from a cow, gets into the saddle on a pig.
+ */
+ @Override
+ public boolean interact(EntityPlayer par1EntityPlayer)
+ {
+ ItemStack itemstack = par1EntityPlayer.inventory.getCurrentItem();
+
+ if (this.isTamed())
+ {
+ if (itemstack != null)
+ {
+ if (itemstack.getItem() instanceof ItemFood)
+ {
+ ItemFood itemfood = (ItemFood) itemstack.getItem();
+
+ if (itemfood.isWolfsFavoriteMeat() && this.dataWatcher.getWatchableObjectFloat(18) < this.maxTamedHealth)
+ {
+ if (!par1EntityPlayer.capabilities.isCreativeMode)
+ {
+ --itemstack.stackSize;
+ }
+
+ this.heal((float) itemfood.func_150905_g(itemstack));
+
+ if (itemstack.stackSize <= 0)
+ {
+ par1EntityPlayer.inventory.setInventorySlotContents(par1EntityPlayer.inventory.currentItem, (ItemStack) null);
+ }
+
+ return true;
+ }
+ }
+ }
+
+ if (this.getOwner() instanceof EntityPlayer && SpellHelper.getUsername(par1EntityPlayer).equalsIgnoreCase(SpellHelper.getUsername((EntityPlayer)this.getOwner())) && !this.isBreedingItem(itemstack))
+ {
+ if (!this.worldObj.isRemote)
+ {
+ this.aiSit.setSitting(!this.isSitting());
+ this.isJumping = false;
+ this.setPathToEntity((PathEntity) null);
+ this.setTarget((Entity) null);
+ this.setAttackTarget((EntityLivingBase) null);
+ }
+
+ this.sendSittingMessageToPlayer(par1EntityPlayer, !this.isSitting());
+ }
+ } else if (itemstack != null && itemstack.getItem().equals(ModItems.weakBloodOrb) && !this.isAngry())
+ {
+ if (!par1EntityPlayer.capabilities.isCreativeMode)
+ {
+ --itemstack.stackSize;
+ }
+
+ if (itemstack.stackSize <= 0)
+ {
+ par1EntityPlayer.inventory.setInventorySlotContents(par1EntityPlayer.inventory.currentItem, (ItemStack) null);
+ }
+
+ if (!this.worldObj.isRemote)
+ {
+ if (this.rand.nextInt(1) == 0)
+ {
+ this.setTamed(true);
+ this.setPathToEntity((PathEntity) null);
+ this.setAttackTarget((EntityLivingBase) null);
+ this.aiSit.setSitting(true);
+ this.setHealth(this.maxTamedHealth);
+ this.func_152115_b(par1EntityPlayer.getUniqueID().toString());
+ this.playTameEffect(true);
+ this.worldObj.setEntityState(this, (byte) 7);
+ } else
+ {
+ this.playTameEffect(false);
+ this.worldObj.setEntityState(this, (byte) 6);
+ }
+ }
+
+ return true;
+ }
+
+ return super.interact(par1EntityPlayer);
+ }
+
+
+ /**
+ * Checks if the parameter is an item which this animal can be fed to breed it (wheat, carrots or seeds depending on
+ * the animal type)
+ */
+ public boolean isBreedingItem(ItemStack par1ItemStack)
+ {
+ return false;
+ //return par1ItemStack == null ? false : (!(Item.itemsList[par1ItemStack.itemID] instanceof ItemFood) ? false : ((ItemFood)Item.itemsList[par1ItemStack.itemID]).isWolfsFavoriteMeat());
+ }
+
+ /**
+ * Determines whether this wolf is angry or not.
+ */
+ public boolean isAngry()
+ {
+ return (this.dataWatcher.getWatchableObjectByte(16) & 2) != 0;
+ }
+
+ /**
+ * Sets whether this wolf is angry or not.
+ */
+ public void setAngry(boolean par1)
+ {
+ byte b0 = this.dataWatcher.getWatchableObjectByte(16);
+
+ if (par1)
+ {
+ this.dataWatcher.updateObject(16, Byte.valueOf((byte) (b0 | 2)));
+ } else
+ {
+ this.dataWatcher.updateObject(16, Byte.valueOf((byte) (b0 & -3)));
+ }
+ }
+
+ /**
+ * Return this wolf's collar color.
+ */
+ public int getCollarColor()
+ {
+ return this.dataWatcher.getWatchableObjectByte(20) & 15;
+ }
+
+ /**
+ * Set this wolf's collar color.
+ */
+ public void setCollarColor(int par1)
+ {
+ this.dataWatcher.updateObject(20, Byte.valueOf((byte) (par1 & 15)));
+ }
+
+ /**
+ * This function is used when two same-species animals in 'love mode' breed to generate the new baby animal.
+ */
+ public EntityWolf spawnBabyAnimal(EntityAgeable par1EntityAgeable)
+ {
+ return null;
+ }
+
+ public void func_70918_i(boolean par1)
+ {
+ if (par1)
+ {
+ this.dataWatcher.updateObject(19, Byte.valueOf((byte) 1));
+ } else
+ {
+ this.dataWatcher.updateObject(19, Byte.valueOf((byte) 0));
+ }
+ }
+
+ /**
+ * Returns true if the mob is currently able to mate with the specified mob.
+ */
+ public boolean canMateWith(EntityAnimal par1EntityAnimal)
+ {
+ return false;
+ }
+
+ public boolean func_70922_bv()
+ {
+ return this.dataWatcher.getWatchableObjectByte(19) == 1;
+ }
+
+ /**
+ * Determines if an entity can be despawned, used on idle far away entities
+ */
+ protected boolean canDespawn()
+ {
+ //return !this.isTamed() && this.ticksExisted > 2400;
+ return false;
+ }
+
+ public boolean func_142018_a(EntityLivingBase par1EntityLivingBase, EntityLivingBase par2EntityLivingBase)
+ {
+ if (!(par1EntityLivingBase instanceof EntityCreeper) && !(par1EntityLivingBase instanceof EntityGhast))
+ {
+ if (par1EntityLivingBase instanceof EntitySmallEarthGolem)
+ {
+ EntitySmallEarthGolem entitywolf = (EntitySmallEarthGolem) par1EntityLivingBase;
+
+ if (entitywolf.isTamed() && entitywolf.getOwner() == par2EntityLivingBase)
+ {
+ return false;
+ }
+ }
+
+ return par1EntityLivingBase instanceof EntityPlayer && par2EntityLivingBase instanceof EntityPlayer && !((EntityPlayer) par2EntityLivingBase).canAttackPlayer((EntityPlayer) par1EntityLivingBase) ? false : !(par1EntityLivingBase instanceof EntityHorse) || !((EntityHorse) par1EntityLivingBase).isTame();
+ } else
+ {
+ return false;
+ }
+ }
+
+ public EntityAgeable createChild(EntityAgeable par1EntityAgeable)
+ {
+ return this.spawnBabyAnimal(par1EntityAgeable);
+ }
+
+ /**
+ * Attack the specified entity using a ranged attack.
+ */
+ public void attackEntityWithRangedAttack(EntityLivingBase par1EntityLivingBase, float par2)
+ {
+ double xCoord;
+ double yCoord;
+ double zCoord;
+ MudProjectile hol = new MudProjectile(worldObj, this, par1EntityLivingBase, 1.8f, 0f, 3, 600, false);
+ this.worldObj.spawnEntityInWorld(hol);
+ }
+
+ /**
+ * sets this entity's combat AI.
+ */
+ public void setCombatTask()
+ {
+ this.tasks.removeTask(this.aiAttackOnCollide);
+ this.tasks.removeTask(this.aiArrowAttack);
+ ItemStack itemstack = this.getHeldItem();
+ this.tasks.addTask(4, this.aiArrowAttack);
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityWaterElemental.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityWaterElemental.java
new file mode 100644
index 00000000..ab141887
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityWaterElemental.java
@@ -0,0 +1,25 @@
+package WayofTime.alchemicalWizardry.common.entity.mob;
+
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.monster.IMob;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.world.World;
+
+public class EntityWaterElemental extends EntityElemental implements IMob
+{
+ public EntityWaterElemental(World world)
+ {
+ super(world, AlchemicalWizardry.entityWaterElementalID);
+ }
+
+ public void inflictEffectOnEntity(Entity target)
+ {
+ if (target instanceof EntityLivingBase)
+ {
+ ((EntityLivingBase) target).addPotionEffect(new PotionEffect(AlchemicalWizardry.customPotionDrowning.id, 100, 2));
+ ((EntityLivingBase) target).addPotionEffect(new PotionEffect(AlchemicalWizardry.customPotionInhibit.id, 150, 0));
+ }
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityWingedFireDemon.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityWingedFireDemon.java
new file mode 100644
index 00000000..804cdb65
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/mob/EntityWingedFireDemon.java
@@ -0,0 +1,503 @@
+package WayofTime.alchemicalWizardry.common.entity.mob;
+
+import net.minecraft.block.BlockColored;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityAgeable;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.IRangedAttackMob;
+import net.minecraft.entity.SharedMonsterAttributes;
+import net.minecraft.entity.ai.EntityAIArrowAttack;
+import net.minecraft.entity.ai.EntityAIAttackOnCollide;
+import net.minecraft.entity.ai.EntityAIFollowOwner;
+import net.minecraft.entity.ai.EntityAIHurtByTarget;
+import net.minecraft.entity.ai.EntityAILookIdle;
+import net.minecraft.entity.ai.EntityAIOwnerHurtByTarget;
+import net.minecraft.entity.ai.EntityAIOwnerHurtTarget;
+import net.minecraft.entity.ai.EntityAISwimming;
+import net.minecraft.entity.ai.EntityAIWander;
+import net.minecraft.entity.ai.EntityAIWatchClosest;
+import net.minecraft.entity.monster.EntityCreeper;
+import net.minecraft.entity.monster.EntityGhast;
+import net.minecraft.entity.passive.EntityAnimal;
+import net.minecraft.entity.passive.EntityHorse;
+import net.minecraft.entity.passive.EntityWolf;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.projectile.EntityArrow;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemFood;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.pathfinding.PathEntity;
+import net.minecraft.util.DamageSource;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.ModItems;
+import WayofTime.alchemicalWizardry.common.EntityAITargetAggro;
+import WayofTime.alchemicalWizardry.common.entity.projectile.FireProjectile;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+
+public class EntityWingedFireDemon extends EntityDemon implements IRangedAttackMob
+{
+ private EntityAIArrowAttack aiArrowAttack = new EntityAIArrowAttack(this, 1.0D, 40, 40, 15.0F);
+ private EntityAIAttackOnCollide aiAttackOnCollide = new EntityAIAttackOnCollide(this, EntityPlayer.class, 1.2D, false);
+
+ private static float maxTamedHealth = 100.0F;
+ private static float maxUntamedHealth = 200.0F;
+
+ public EntityWingedFireDemon(World par1World)
+ {
+ super(par1World, AlchemicalWizardry.entityWingedFireDemonID);
+ this.setSize(0.7F, 1.8F);
+ this.getNavigator().setAvoidsWater(true);
+ this.tasks.addTask(1, new EntityAISwimming(this));
+ this.tasks.addTask(2, this.aiSit);
+ //this.tasks.addTask(3, new EntityAILeapAtTarget(this, 0.4F));
+ //this.tasks.addTask(4, new EntityAIAttackOnCollide(this, 1.0D, true));
+ this.tasks.addTask(5, new EntityAIFollowOwner(this, 1.0D, 10.0F, 2.0F));
+ //this.tasks.addTask(6, new EntityAIMate(this, 1.0D));
+ this.tasks.addTask(7, new EntityAIWander(this, 1.0D));
+ //this.tasks.addTask(8, new EntityAIBeg(this, 8.0F));
+ this.tasks.addTask(9, new EntityAIWatchClosest(this, EntityPlayer.class, 8.0F));
+ this.tasks.addTask(9, new EntityAILookIdle(this));
+ this.targetTasks.addTask(1, new EntityAIOwnerHurtByTarget(this));
+ this.targetTasks.addTask(2, new EntityAIOwnerHurtTarget(this));
+ this.targetTasks.addTask(3, new EntityAIHurtByTarget(this, true));
+ this.targetTasks.addTask(4, new EntityAITargetAggro(this, EntityPlayer.class, 0, false));
+ this.setAggro(false);
+ //this.targetTasks.addTask(4, new EntityAITargetNonTamed(this, EntitySheep.class, 200, false));
+ this.setTamed(false);
+
+ if (par1World != null && !par1World.isRemote)
+ {
+ this.setCombatTask();
+ }
+
+ this.isImmuneToFire = true;
+ }
+
+ @Override
+ protected void applyEntityAttributes()
+ {
+ super.applyEntityAttributes();
+ //This line affects the speed of the monster
+ this.getEntityAttribute(SharedMonsterAttributes.movementSpeed).setBaseValue(0.30000001192092896D);
+
+ //My guess is that this will alter the max health
+ if (this.isTamed())
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxTamedHealth);
+ } else
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxUntamedHealth);
+ }
+
+ //this.func_110148_a(SharedMonsterAttributes.field_111267_a).func_111128_a(10.0D);
+ }
+
+ /**
+ * Returns true if the newer Entity AI code should be run
+ */
+ public boolean isAIEnabled()
+ {
+ return true;
+ }
+
+ /**
+ * Sets the active target the Task system uses for tracking
+ */
+ public void setAttackTarget(EntityLivingBase par1EntityLivingBase)
+ {
+ super.setAttackTarget(par1EntityLivingBase);
+
+ if (par1EntityLivingBase == null)
+ {
+ this.setAngry(false);
+ } else if (!this.isTamed())
+ {
+ this.setAngry(true);
+ }
+ }
+
+ /**
+ * main AI tick function, replaces updateEntityActionState
+ */
+ protected void updateAITick()
+ {
+ this.dataWatcher.updateObject(18, Float.valueOf(this.getHealth()));
+ }
+
+ protected void entityInit()
+ {
+ super.entityInit();
+ this.dataWatcher.addObject(18, new Float(this.getHealth()));
+ this.dataWatcher.addObject(19, new Byte((byte) 0));
+ //this.dataWatcher.addObject(20, new Byte((byte) BlockColored.getBlockFromDye(1)));
+ }
+
+ /**
+ * Plays step sound at given x, y, z for the entity
+ */
+ protected void playStepSound(int par1, int par2, int par3, int par4)
+ {
+ this.playSound("mob.zombie.step", 0.15F, 1.0F);
+ }
+
+ /**
+ * (abstract) Protected helper method to write subclass entity data to NBT.
+ */
+ public void writeEntityToNBT(NBTTagCompound par1NBTTagCompound)
+ {
+ super.writeEntityToNBT(par1NBTTagCompound);
+ par1NBTTagCompound.setBoolean("Angry", this.isAngry());
+ }
+
+ /**
+ * (abstract) Protected helper method to read subclass entity data from NBT.
+ */
+ public void readEntityFromNBT(NBTTagCompound par1NBTTagCompound)
+ {
+ super.readEntityFromNBT(par1NBTTagCompound);
+ this.setAngry(par1NBTTagCompound.getBoolean("Angry"));
+
+ this.setCombatTask();
+ }
+
+ /**
+ * Returns the sound this mob makes while it's alive.
+ */
+ protected String getLivingSound()
+ {
+ return "mob.blaze.breathe";
+ }
+
+ /**
+ * Returns the sound this mob makes when it is hurt.
+ */
+ protected String getHurtSound()
+ {
+ return "mob.blaze.hit";
+ }
+
+ /**
+ * Returns the sound this mob makes on death.
+ */
+ protected String getDeathSound()
+ {
+ return "mob.blaze.death";
+ }
+
+ /**
+ * Returns the volume for the sounds this mob makes.
+ */
+ protected float getSoundVolume()
+ {
+ return 0.4F;
+ }
+
+ /**
+ * Returns the item ID for the item the mob drops on death.
+ */
+ protected int getDropItemId()
+ {
+ return -1;
+ }
+
+ /**
+ * Called frequently so the entity can update its state every tick as required. For example, zombies and skeletons
+ * use this to react to sunlight and start to burn.
+ */
+ public void onLivingUpdate()
+ {
+ super.onLivingUpdate();
+ }
+
+ /**
+ * Called to update the entity's position/logic.
+ */
+ public void onUpdate()
+ {
+ super.onUpdate();
+ }
+
+ public float getEyeHeight()
+ {
+ return this.height * 0.8F;
+ }
+
+ /**
+ * The speed it takes to move the entityliving's rotationPitch through the faceEntity method. This is only currently
+ * use in wolves.
+ */
+ public int getVerticalFaceSpeed()
+ {
+ return this.isSitting() ? 20 : super.getVerticalFaceSpeed();
+ }
+
+ /**
+ * Called when the entity is attacked.
+ */
+ public boolean attackEntityFrom(DamageSource par1DamageSource, float par2)
+ {
+ if (this.isEntityInvulnerable())
+ {
+ return false;
+ } else
+ {
+ Entity entity = par1DamageSource.getEntity();
+ this.aiSit.setSitting(false);
+
+ if (entity != null && !(entity instanceof EntityPlayer) && !(entity instanceof EntityArrow))
+ {
+ par2 = (par2 + 1.0F) / 2.0F;
+ }
+
+ return super.attackEntityFrom(par1DamageSource, par2);
+ }
+ }
+
+ public boolean attackEntityAsMob(Entity par1Entity)
+ {
+ int i = this.isTamed() ? 4 : 2;
+ return par1Entity.attackEntityFrom(DamageSource.causeMobDamage(this), (float) i);
+ }
+
+ public void setTamed(boolean par1)
+ {
+ super.setTamed(par1);
+
+ if (par1)
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxTamedHealth);
+ } else
+ {
+ this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxUntamedHealth);
+ }
+ }
+
+ /**
+ * Called when a player interacts with a mob. e.g. gets milk from a cow, gets into the saddle on a pig.
+ */
+ @Override
+ public boolean interact(EntityPlayer par1EntityPlayer)
+ {
+ ItemStack itemstack = par1EntityPlayer.inventory.getCurrentItem();
+
+ if (this.isTamed())
+ {
+ if (itemstack != null)
+ {
+ if (itemstack.getItem() instanceof ItemFood)
+ {
+ ItemFood itemfood = (ItemFood) itemstack.getItem();
+
+ if (itemfood.isWolfsFavoriteMeat() && this.dataWatcher.getWatchableObjectFloat(18) < this.maxTamedHealth)
+ {
+ if (!par1EntityPlayer.capabilities.isCreativeMode)
+ {
+ --itemstack.stackSize;
+ }
+
+ this.heal((float) itemfood.func_150905_g(itemstack));
+
+ if (itemstack.stackSize <= 0)
+ {
+ par1EntityPlayer.inventory.setInventorySlotContents(par1EntityPlayer.inventory.currentItem, (ItemStack) null);
+ }
+
+ return true;
+ }
+ }
+ }
+
+ if (this.getOwner() instanceof EntityPlayer && SpellHelper.getUsername(par1EntityPlayer).equalsIgnoreCase(SpellHelper.getUsername((EntityPlayer)this.getOwner())) && !this.isBreedingItem(itemstack))
+ {
+ if (!this.worldObj.isRemote)
+ {
+ this.aiSit.setSitting(!this.isSitting());
+ this.isJumping = false;
+ this.setPathToEntity((PathEntity) null);
+ this.setTarget((Entity) null);
+ this.setAttackTarget((EntityLivingBase) null);
+ }
+
+ this.sendSittingMessageToPlayer(par1EntityPlayer, !this.isSitting());
+ }
+ } else if (itemstack != null && itemstack.getItem().equals(ModItems.weakBloodOrb) && !this.isAngry())
+ {
+ if (!par1EntityPlayer.capabilities.isCreativeMode)
+ {
+ --itemstack.stackSize;
+ }
+
+ if (itemstack.stackSize <= 0)
+ {
+ par1EntityPlayer.inventory.setInventorySlotContents(par1EntityPlayer.inventory.currentItem, (ItemStack) null);
+ }
+
+ if (!this.worldObj.isRemote)
+ {
+ if (this.rand.nextInt(1) == 0)
+ {
+ this.setTamed(true);
+ this.setPathToEntity((PathEntity) null);
+ this.setAttackTarget((EntityLivingBase) null);
+ this.aiSit.setSitting(true);
+ this.setHealth(this.maxTamedHealth);
+ this.func_152115_b(par1EntityPlayer.getUniqueID().toString());
+ this.playTameEffect(true);
+ this.worldObj.setEntityState(this, (byte) 7);
+ } else
+ {
+ this.playTameEffect(false);
+ this.worldObj.setEntityState(this, (byte) 6);
+ }
+ }
+
+ return true;
+ }
+
+ return super.interact(par1EntityPlayer);
+ }
+
+
+ /**
+ * Checks if the parameter is an item which this animal can be fed to breed it (wheat, carrots or seeds depending on
+ * the animal type)
+ */
+ public boolean isBreedingItem(ItemStack par1ItemStack)
+ {
+ return false;
+ //return par1ItemStack == null ? false : (!(Item.itemsList[par1ItemStack.itemID] instanceof ItemFood) ? false : ((ItemFood)Item.itemsList[par1ItemStack.itemID]).isWolfsFavoriteMeat());
+ }
+
+ /**
+ * Determines whether this wolf is angry or not.
+ */
+ public boolean isAngry()
+ {
+ return (this.dataWatcher.getWatchableObjectByte(16) & 2) != 0;
+ }
+
+ /**
+ * Sets whether this wolf is angry or not.
+ */
+ public void setAngry(boolean par1)
+ {
+ byte b0 = this.dataWatcher.getWatchableObjectByte(16);
+
+ if (par1)
+ {
+ this.dataWatcher.updateObject(16, Byte.valueOf((byte) (b0 | 2)));
+ } else
+ {
+ this.dataWatcher.updateObject(16, Byte.valueOf((byte) (b0 & -3)));
+ }
+ }
+
+ /**
+ * Return this wolf's collar color.
+ */
+ public int getCollarColor()
+ {
+ return this.dataWatcher.getWatchableObjectByte(20) & 15;
+ }
+
+ /**
+ * Set this wolf's collar color.
+ */
+ public void setCollarColor(int par1)
+ {
+ this.dataWatcher.updateObject(20, Byte.valueOf((byte) (par1 & 15)));
+ }
+
+ /**
+ * This function is used when two same-species animals in 'love mode' breed to generate the new baby animal.
+ */
+ public EntityWolf spawnBabyAnimal(EntityAgeable par1EntityAgeable)
+ {
+ return null;
+ }
+
+ public void func_70918_i(boolean par1)
+ {
+ if (par1)
+ {
+ this.dataWatcher.updateObject(19, Byte.valueOf((byte) 1));
+ } else
+ {
+ this.dataWatcher.updateObject(19, Byte.valueOf((byte) 0));
+ }
+ }
+
+ /**
+ * Returns true if the mob is currently able to mate with the specified mob.
+ */
+ public boolean canMateWith(EntityAnimal par1EntityAnimal)
+ {
+ return false;
+ }
+
+ public boolean func_70922_bv()
+ {
+ return this.dataWatcher.getWatchableObjectByte(19) == 1;
+ }
+
+ /**
+ * Determines if an entity can be despawned, used on idle far away entities
+ */
+ protected boolean canDespawn()
+ {
+ //return !this.isTamed() && this.ticksExisted > 2400;
+ return false;
+ }
+
+ public boolean func_142018_a(EntityLivingBase par1EntityLivingBase, EntityLivingBase par2EntityLivingBase)
+ {
+ if (!(par1EntityLivingBase instanceof EntityCreeper) && !(par1EntityLivingBase instanceof EntityGhast))
+ {
+ if (par1EntityLivingBase instanceof EntityWingedFireDemon)
+ {
+ EntityWingedFireDemon entitywolf = (EntityWingedFireDemon) par1EntityLivingBase;
+
+ if (entitywolf.isTamed() && entitywolf.getOwner() == par2EntityLivingBase)
+ {
+ return false;
+ }
+ }
+
+ return par1EntityLivingBase instanceof EntityPlayer && par2EntityLivingBase instanceof EntityPlayer && !((EntityPlayer) par2EntityLivingBase).canAttackPlayer((EntityPlayer) par1EntityLivingBase) ? false : !(par1EntityLivingBase instanceof EntityHorse) || !((EntityHorse) par1EntityLivingBase).isTame();
+ } else
+ {
+ return false;
+ }
+ }
+
+ public EntityAgeable createChild(EntityAgeable par1EntityAgeable)
+ {
+ return this.spawnBabyAnimal(par1EntityAgeable);
+ }
+
+ /**
+ * Attack the specified entity using a ranged attack.
+ */
+ public void attackEntityWithRangedAttack(EntityLivingBase par1EntityLivingBase, float par2)
+ {
+ double xCoord;
+ double yCoord;
+ double zCoord;
+ this.worldObj.playAuxSFXAtEntity((EntityPlayer) null, 1009, (int) this.posX, (int) this.posY, (int) this.posZ, 0);
+ FireProjectile hol = new FireProjectile(worldObj, this, par1EntityLivingBase, 1.8f, 0f, 20, 600);
+ this.worldObj.spawnEntityInWorld(hol);
+ }
+
+ /**
+ * sets this entity's combat AI.
+ */
+ public void setCombatTask()
+ {
+ this.tasks.removeTask(this.aiAttackOnCollide);
+ this.tasks.removeTask(this.aiArrowAttack);
+ ItemStack itemstack = this.getHeldItem();
+ this.tasks.addTask(4, this.aiArrowAttack);
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/EnergyBlastProjectile.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/EnergyBlastProjectile.java
new file mode 100644
index 00000000..3b5d6e71
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/EnergyBlastProjectile.java
@@ -0,0 +1,526 @@
+package WayofTime.alchemicalWizardry.common.entity.projectile;
+
+import java.util.Iterator;
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.IProjectile;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.potion.Potion;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.MathHelper;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.util.Vec3;
+import net.minecraft.world.World;
+import cpw.mods.fml.common.registry.IThrowableEntity;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+//Shamelessly ripped off from x3n0ph0b3
+public class EnergyBlastProjectile extends Entity implements IProjectile, IThrowableEntity
+{
+ protected int xTile = -1;
+ protected int yTile = -1;
+ protected int zTile = -1;
+ protected int inTile = 0;
+ protected int inData = 0;
+ protected boolean inGround = false;
+ /**
+ * The owner of this arrow.
+ */
+ public EntityLivingBase shootingEntity;
+ protected int ticksInAir = 0;
+ protected int maxTicksInAir = 600;
+ private int ricochetCounter = 0;
+ private boolean scheduledForDeath = false;
+ protected int projectileDamage;
+
+ public EnergyBlastProjectile(World par1World)
+ {
+ super(par1World);
+ this.setSize(0.5F, 0.5F);
+ this.maxTicksInAir = 600;
+ }
+
+ public EnergyBlastProjectile(World par1World, double par2, double par4, double par6)
+ {
+ super(par1World);
+ this.setSize(0.5F, 0.5F);
+ this.setPosition(par2, par4, par6);
+ yOffset = 0.0F;
+ this.maxTicksInAir = 600;
+ }
+
+ public EnergyBlastProjectile(World par1World, EntityLivingBase par2EntityPlayer, int damage)
+ {
+ super(par1World);
+ shootingEntity = par2EntityPlayer;
+ float par3 = 0.8F;
+ this.setSize(0.5F, 0.5F);
+ this.setLocationAndAngles(par2EntityPlayer.posX, par2EntityPlayer.posY + par2EntityPlayer.getEyeHeight(), par2EntityPlayer.posZ, par2EntityPlayer.rotationYaw, par2EntityPlayer.rotationPitch);
+ posX -= MathHelper.cos(rotationYaw / 180.0F * (float) Math.PI) * 0.16F;
+ posY -= 0.2D;
+ posZ -= MathHelper.sin(rotationYaw / 180.0F * (float) Math.PI) * 0.16F;
+ this.setPosition(posX, posY, posZ);
+ yOffset = 0.0F;
+ motionX = -MathHelper.sin(rotationYaw / 180.0F * (float) Math.PI) * MathHelper.cos(rotationPitch / 180.0F * (float) Math.PI);
+ motionZ = MathHelper.cos(rotationYaw / 180.0F * (float) Math.PI) * MathHelper.cos(rotationPitch / 180.0F * (float) Math.PI);
+ motionY = -MathHelper.sin(rotationPitch / 180.0F * (float) Math.PI);
+ this.setThrowableHeading(motionX, motionY, motionZ, par3 * 1.5F, 1.0F);
+ this.projectileDamage = damage;
+ this.maxTicksInAir = 600;
+ }
+
+ public EnergyBlastProjectile(World par1World, EntityLivingBase par2EntityPlayer, int damage, int maxTicksInAir, double posX, double posY, double posZ, float rotationYaw, float rotationPitch)
+ {
+ super(par1World);
+ shootingEntity = par2EntityPlayer;
+ float par3 = 0.8F;
+ this.setSize(0.5F, 0.5F);
+ this.setLocationAndAngles(posX, posY, posZ, rotationYaw, rotationPitch);
+ posX -= MathHelper.cos(rotationYaw / 180.0F * (float) Math.PI) * 0.16F;
+ posY -= 0.2D;
+ posZ -= MathHelper.sin(rotationYaw / 180.0F * (float) Math.PI) * 0.16F;
+ this.setPosition(posX, posY, posZ);
+ yOffset = 0.0F;
+ motionX = -MathHelper.sin(rotationYaw / 180.0F * (float) Math.PI) * MathHelper.cos(rotationPitch / 180.0F * (float) Math.PI);
+ motionZ = MathHelper.cos(rotationYaw / 180.0F * (float) Math.PI) * MathHelper.cos(rotationPitch / 180.0F * (float) Math.PI);
+ motionY = -MathHelper.sin(rotationPitch / 180.0F * (float) Math.PI);
+ this.setThrowableHeading(motionX, motionY, motionZ, par3 * 1.5F, 1.0F);
+ this.projectileDamage = damage;
+ this.maxTicksInAir = maxTicksInAir;
+ }
+
+ public EnergyBlastProjectile(World par1World, EntityLivingBase par2EntityLivingBase, EntityLivingBase par3EntityLivingBase, float par4, float par5, int damage, int maxTicksInAir)
+ {
+ super(par1World);
+ this.renderDistanceWeight = 10.0D;
+ this.shootingEntity = par2EntityLivingBase;
+ this.posY = par2EntityLivingBase.posY + (double) par2EntityLivingBase.getEyeHeight() - 0.10000000149011612D;
+ double d0 = par3EntityLivingBase.posX - par2EntityLivingBase.posX;
+ double d1 = par3EntityLivingBase.boundingBox.minY + (double) (par3EntityLivingBase.height / 1.5F) - this.posY;
+ double d2 = par3EntityLivingBase.posZ - par2EntityLivingBase.posZ;
+ double d3 = (double) MathHelper.sqrt_double(d0 * d0 + d2 * d2);
+
+ if (d3 >= 1.0E-7D)
+ {
+ float f2 = (float) (Math.atan2(d2, d0) * 180.0D / Math.PI) - 90.0F;
+ float f3 = (float) (-(Math.atan2(d1, d3) * 180.0D / Math.PI));
+ double d4 = d0 / d3;
+ double d5 = d2 / d3;
+ this.setLocationAndAngles(par2EntityLivingBase.posX + d4, this.posY, par2EntityLivingBase.posZ + d5, f2, f3);
+ this.yOffset = 0.0F;
+ float f4 = (float) d3 * 0.2F;
+ this.setThrowableHeading(d0, d1, d2, par4, par5);
+ }
+
+ this.projectileDamage = damage;
+ this.maxTicksInAir = maxTicksInAir;
+ }
+
+ @Override
+ protected void entityInit()
+ {
+ dataWatcher.addObject(16, Byte.valueOf((byte) 0));
+ }
+
+ /**
+ * Similar to setArrowHeading, it's point the throwable entity to a x, y, z
+ * direction.
+ */
+ @Override
+ public void setThrowableHeading(double var1, double var3, double var5, float var7, float var8)
+ {
+ float var9 = MathHelper.sqrt_double(var1 * var1 + var3 * var3 + var5 * var5);
+ var1 /= var9;
+ var3 /= var9;
+ var5 /= var9;
+ var1 += rand.nextGaussian() * 0.007499999832361937D * var8;
+ var3 += rand.nextGaussian() * 0.007499999832361937D * var8;
+ var5 += rand.nextGaussian() * 0.007499999832361937D * var8;
+ var1 *= var7;
+ var3 *= var7;
+ var5 *= var7;
+ motionX = var1;
+ motionY = var3;
+ motionZ = var5;
+ float var10 = MathHelper.sqrt_double(var1 * var1 + var5 * var5);
+ prevRotationYaw = rotationYaw = (float) (Math.atan2(var1, var5) * 180.0D / Math.PI);
+ prevRotationPitch = rotationPitch = (float) (Math.atan2(var3, var10) * 180.0D / Math.PI);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ /**
+ * Sets the position and rotation. Only difference from the other one is no bounding on the rotation. Args: posX,
+ * posY, posZ, yaw, pitch
+ */
+ public void setPositionAndRotation2(double par1, double par3, double par5, float par7, float par8, int par9)
+ {
+ this.setPosition(par1, par3, par5);
+ this.setRotation(par7, par8);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ /**
+ * Sets the velocity to the args. Args: x, y, z
+ */
+ public void setVelocity(double par1, double par3, double par5)
+ {
+ motionX = par1;
+ motionY = par3;
+ motionZ = par5;
+
+ if (prevRotationPitch == 0.0F && prevRotationYaw == 0.0F)
+ {
+ float var7 = MathHelper.sqrt_double(par1 * par1 + par5 * par5);
+ prevRotationYaw = rotationYaw = (float) (Math.atan2(par1, par5) * 180.0D / Math.PI);
+ prevRotationPitch = rotationPitch = (float) (Math.atan2(par3, var7) * 180.0D / Math.PI);
+ prevRotationPitch = rotationPitch;
+ prevRotationYaw = rotationYaw;
+ this.setLocationAndAngles(posX, posY, posZ, rotationYaw, rotationPitch);
+ }
+ }
+
+ /**
+ * Called to update the entity's position/logic.
+ */
+ @Override
+ public void onUpdate()
+ {
+ super.onUpdate();
+
+ if (ticksInAir > maxTicksInAir)
+ {
+ this.setDead();
+ }
+
+ if (shootingEntity == null)
+ {
+ List players = worldObj.getEntitiesWithinAABB(EntityPlayer.class, AxisAlignedBB.getBoundingBox(posX - 1, posY - 1, posZ - 1, posX + 1, posY + 1, posZ + 1));
+ Iterator i = players.iterator();
+ double closestDistance = Double.MAX_VALUE;
+ EntityPlayer closestPlayer = null;
+
+ while (i.hasNext())
+ {
+ EntityPlayer e = (EntityPlayer) i.next();
+ double distance = e.getDistanceToEntity(this);
+
+ if (distance < closestDistance)
+ {
+ closestPlayer = e;
+ }
+ }
+
+ if (closestPlayer != null)
+ {
+ shootingEntity = closestPlayer;
+ }
+ }
+
+ if (prevRotationPitch == 0.0F && prevRotationYaw == 0.0F)
+ {
+ float var1 = MathHelper.sqrt_double(motionX * motionX + motionZ * motionZ);
+ prevRotationYaw = rotationYaw = (float) (Math.atan2(motionX, motionZ) * 180.0D / Math.PI);
+ prevRotationPitch = rotationPitch = (float) (Math.atan2(motionY, var1) * 180.0D / Math.PI);
+ }
+
+ Block var16 = worldObj.getBlock(xTile, yTile, zTile);
+
+ if (var16 != null)
+ {
+ var16.setBlockBoundsBasedOnState(worldObj, xTile, yTile, zTile);
+ AxisAlignedBB var2 = var16.getCollisionBoundingBoxFromPool(worldObj, xTile, yTile, zTile);
+
+ if (var2 != null && var2.isVecInside(Vec3.createVectorHelper(posX, posY, posZ)))
+ {
+ inGround = true;
+ }
+ }
+
+ if (inGround)
+ {
+ Block var18 = worldObj.getBlock(xTile, yTile, zTile);
+ int var19 = worldObj.getBlockMetadata(xTile, yTile, zTile);
+
+ if (var18.equals(Block.getBlockById(inTile)) && var19 == inData)
+ {
+ // this.groundImpact();
+ // this.setDead();
+ }
+ } else
+ {
+ ++ticksInAir;
+
+ if (ticksInAir > 1 && ticksInAir < 3)
+ {
+ //worldObj.spawnParticle("flame", posX + smallGauss(0.1D), posY + smallGauss(0.1D), posZ + smallGauss(0.1D), 0D, 0D, 0D);
+ for (int particles = 0; particles < 3; particles++)
+ {
+ this.doFiringParticles();
+ }
+ }
+
+ Vec3 var17 = Vec3.createVectorHelper(posX, posY, posZ);
+ Vec3 var3 = Vec3.createVectorHelper(posX + motionX, posY + motionY, posZ + motionZ);
+ MovingObjectPosition var4 = worldObj.func_147447_a(var17, var3, true, false, false);
+ var17 = Vec3.createVectorHelper(posX, posY, posZ);
+ var3 = Vec3.createVectorHelper(posX + motionX, posY + motionY, posZ + motionZ);
+
+ if (var4 != null)
+ {
+ var3 = Vec3.createVectorHelper(var4.hitVec.xCoord, var4.hitVec.yCoord, var4.hitVec.zCoord);
+ }
+
+ Entity var5 = null;
+ List var6 = worldObj.getEntitiesWithinAABBExcludingEntity(this, boundingBox.addCoord(motionX, motionY, motionZ).expand(1.0D, 1.0D, 1.0D));
+ double var7 = 0.0D;
+ Iterator var9 = var6.iterator();
+ float var11;
+
+ while (var9.hasNext())
+ {
+ Entity var10 = (Entity) var9.next();
+
+ if (var10.canBeCollidedWith() && (var10 != shootingEntity || ticksInAir >= 5))
+ {
+ var11 = 0.3F;
+ AxisAlignedBB var12 = var10.boundingBox.expand(var11, var11, var11);
+ MovingObjectPosition var13 = var12.calculateIntercept(var17, var3);
+
+ if (var13 != null)
+ {
+ double var14 = var17.distanceTo(var13.hitVec);
+
+ if (var14 < var7 || var7 == 0.0D)
+ {
+ var5 = var10;
+ var7 = var14;
+ }
+ }
+ }
+ }
+
+ if (var5 != null)
+ {
+ var4 = new MovingObjectPosition(var5);
+ }
+
+ if (var4 != null)
+ {
+ this.onImpact(var4);
+
+ if (scheduledForDeath)
+ {
+ this.setDead();
+ }
+ }
+
+ posX += motionX;
+ posY += motionY;
+ posZ += motionZ;
+ MathHelper.sqrt_double(motionX * motionX + motionZ * motionZ);
+ this.setPosition(posX, posY, posZ);
+ //this.doBlockCollisions();
+ }
+ }
+
+ public void doFiringParticles()
+ {
+ worldObj.spawnParticle("mobSpellAmbient", posX + smallGauss(0.1D), posY + smallGauss(0.1D), posZ + smallGauss(0.1D), 0.5D, 0.5D, 0.5D);
+ worldObj.spawnParticle("flame", posX, posY, posZ, gaussian(motionX), gaussian(motionY), gaussian(motionZ));
+ }
+
+ /**
+ * (abstract) Protected helper method to write subclass entity data to NBT.
+ */
+ @Override
+ public void writeEntityToNBT(NBTTagCompound par1NBTTagCompound)
+ {
+ par1NBTTagCompound.setShort("xTile", (short) xTile);
+ par1NBTTagCompound.setShort("yTile", (short) yTile);
+ par1NBTTagCompound.setShort("zTile", (short) zTile);
+ par1NBTTagCompound.setByte("inTile", (byte) inTile);
+ par1NBTTagCompound.setByte("inData", (byte) inData);
+ par1NBTTagCompound.setByte("inGround", (byte) (inGround ? 1 : 0));
+ par1NBTTagCompound.setInteger("ticksInAir", ticksInAir);
+ par1NBTTagCompound.setInteger("maxTicksInAir", maxTicksInAir);
+ par1NBTTagCompound.setInteger("projectileDamage", this.projectileDamage);
+ }
+
+ /**
+ * (abstract) Protected helper method to read subclass entity data from NBT.
+ */
+ @Override
+ public void readEntityFromNBT(NBTTagCompound par1NBTTagCompound)
+ {
+ xTile = par1NBTTagCompound.getShort("xTile");
+ yTile = par1NBTTagCompound.getShort("yTile");
+ zTile = par1NBTTagCompound.getShort("zTile");
+ inTile = par1NBTTagCompound.getByte("inTile") & 255;
+ inData = par1NBTTagCompound.getByte("inData") & 255;
+ inGround = par1NBTTagCompound.getByte("inGround") == 1;
+ ticksInAir = par1NBTTagCompound.getInteger("ticksInAir");
+ maxTicksInAir = par1NBTTagCompound.getInteger("maxTicksInAir");
+ projectileDamage = par1NBTTagCompound.getInteger("projectileDamage");
+ }
+
+ /**
+ * returns if this entity triggers Block.onEntityWalking on the blocks they
+ * walk on. used for spiders and wolves to prevent them from trampling crops
+ */
+ @Override
+ protected boolean canTriggerWalking()
+ {
+ return false;
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public float getShadowSize()
+ {
+ return 0.0F;
+ }
+
+ /**
+ * Sets the amount of knockback the arrow applies when it hits a mob.
+ */
+ public void setKnockbackStrength(int par1)
+ {
+ }
+
+ /**
+ * If returns false, the item will not inflict any damage against entities.
+ */
+ @Override
+ public boolean canAttackWithItem()
+ {
+ return false;
+ }
+
+ /**
+ * Whether the arrow has a stream of critical hit particles flying behind
+ * it.
+ */
+ public void setIsCritical(boolean par1)
+ {
+ byte var2 = dataWatcher.getWatchableObjectByte(16);
+
+ if (par1)
+ {
+ dataWatcher.updateObject(16, Byte.valueOf((byte) (var2 | 1)));
+ } else
+ {
+ dataWatcher.updateObject(16, Byte.valueOf((byte) (var2 & -2)));
+ }
+ }
+
+ /**
+ * Whether the arrow has a stream of critical hit particles flying behind
+ * it.
+ */
+ public boolean getIsCritical()
+ {
+ byte var1 = dataWatcher.getWatchableObjectByte(16);
+ return (var1 & 1) != 0;
+ }
+
+ public void onImpact(MovingObjectPosition mop)
+ {
+ if (mop.typeOfHit == MovingObjectPosition.MovingObjectType.ENTITY && mop.entityHit != null)
+ {
+ if (mop.entityHit == shootingEntity)
+ {
+ return;
+ }
+
+ this.onImpact(mop.entityHit);
+ } else if (mop.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK)
+ {
+ worldObj.createExplosion(shootingEntity, this.posX, this.posY, this.posZ, (float) (0.1), true);
+ this.setDead();
+ }
+ }
+
+ public void onImpact(Entity mop)
+ {
+ if (mop == shootingEntity && ticksInAir > 3)
+ {
+ shootingEntity.attackEntityFrom(DamageSource.causeMobDamage(shootingEntity), 1);
+ this.setDead();
+ } else
+ {
+ //doDamage(8 + d6(), mop);
+ if (mop instanceof EntityLivingBase)
+ {
+ ((EntityLivingBase) mop).addPotionEffect(new PotionEffect(Potion.weakness.id, 60, 2));
+ }
+
+ doDamage(projectileDamage, mop);
+ worldObj.createExplosion(shootingEntity, this.posX, this.posY, this.posZ, (float) (0.1), true);
+ }
+
+ spawnHitParticles("magicCrit", 8);
+ this.setDead();
+ }
+
+ private int d6()
+ {
+ return rand.nextInt(6) + 1;
+ }
+
+ protected void spawnHitParticles(String string, int i)
+ {
+ for (int particles = 0; particles < i; particles++)
+ {
+ worldObj.spawnParticle(string, posX, posY - (string == "portal" ? 1 : 0), posZ, gaussian(motionX), gaussian(motionY), gaussian(motionZ));
+ }
+ }
+
+ protected void doDamage(int i, Entity mop)
+ {
+ mop.attackEntityFrom(this.getDamageSource(), i);
+ }
+
+ public DamageSource getDamageSource()
+ {
+ return DamageSource.causeMobDamage(shootingEntity);
+ }
+
+ public double smallGauss(double d)
+ {
+ return (worldObj.rand.nextFloat() - 0.5D) * d;
+ }
+
+ public double gaussian(double d)
+ {
+ return d + d * ((rand.nextFloat() - 0.5D) / 4);
+ }
+
+ private int getRicochetMax()
+ {
+ return 0;
+ }
+
+ @Override
+ public Entity getThrower()
+ {
+ // TODO Auto-generated method stub
+ return this.shootingEntity;
+ }
+
+ @Override
+ public void setThrower(Entity entity)
+ {
+ if(entity instanceof EntityLivingBase)
+ this.shootingEntity = (EntityLivingBase)entity;
+
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/EntityBeamParticle.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/EntityBeamParticle.java
new file mode 100644
index 00000000..a0cf955c
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/EntityBeamParticle.java
@@ -0,0 +1,16 @@
+package WayofTime.alchemicalWizardry.common.entity.projectile;
+
+import net.minecraft.client.particle.EntityFX;
+import net.minecraft.world.World;
+
+public class EntityBeamParticle extends EntityFX
+{
+
+ protected EntityBeamParticle(World p_i1218_1_, double p_i1218_2_,
+ double p_i1218_4_, double p_i1218_6_)
+ {
+ super(p_i1218_1_, p_i1218_2_, p_i1218_4_, p_i1218_6_);
+ // TODO Auto-generated constructor stub
+ }
+
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/EntityBloodLightProjectile.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/EntityBloodLightProjectile.java
new file mode 100644
index 00000000..4a1729a0
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/EntityBloodLightProjectile.java
@@ -0,0 +1,131 @@
+package WayofTime.alchemicalWizardry.common.entity.projectile;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.init.Blocks;
+import net.minecraft.potion.Potion;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.ModBlocks;
+
+
+public class EntityBloodLightProjectile extends EnergyBlastProjectile
+{
+ public EntityBloodLightProjectile(World par1World)
+ {
+ super(par1World);
+ }
+
+ public EntityBloodLightProjectile(World par1World, double par2, double par4, double par6)
+ {
+ super(par1World, par2, par4, par6);
+ }
+
+ public EntityBloodLightProjectile(World par1World, EntityLivingBase par2EntityPlayer, int damage)
+ {
+ super(par1World, par2EntityPlayer, damage);
+ }
+
+ public EntityBloodLightProjectile(World par1World, EntityLivingBase par2EntityPlayer, int damage, int maxTicksInAir, double posX, double posY, double posZ, float rotationYaw, float rotationPitch)
+ {
+ super(par1World, par2EntityPlayer, damage, maxTicksInAir, posX, posY, posZ, rotationYaw, rotationPitch);
+ }
+
+ public EntityBloodLightProjectile(World par1World, EntityLivingBase par2EntityLivingBase, EntityLivingBase par3EntityLivingBase, float par4, float par5, int damage, int maxTicksInAir)
+ {
+ super(par1World, par2EntityLivingBase, par3EntityLivingBase, par4, par5, damage, maxTicksInAir);
+ }
+
+ @Override
+ public DamageSource getDamageSource()
+ {
+ return DamageSource.causeMobDamage(shootingEntity);
+ }
+
+ @Override
+ public void onImpact(MovingObjectPosition mop)
+ {
+ if (mop.typeOfHit == MovingObjectPosition.MovingObjectType.ENTITY && mop.entityHit != null)
+ {
+ if (mop.entityHit == shootingEntity)
+ {
+ return;
+ }
+
+ this.onImpact(mop.entityHit);
+ } else if (mop.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK)
+ {
+ int sideHit = mop.sideHit;
+ int blockX = mop.blockX;
+ int blockY = mop.blockY;
+ int blockZ = mop.blockZ;
+
+ if (sideHit == 0 && this.worldObj.isAirBlock(blockX, blockY - 1, blockZ))
+ {
+ this.worldObj.setBlock(blockX, blockY - 1, blockZ, ModBlocks.blockBloodLight);
+ }
+
+ if (sideHit == 1 && this.worldObj.isAirBlock(blockX, blockY + 1, blockZ))
+ {
+ this.worldObj.setBlock(blockX, blockY + 1, blockZ, ModBlocks.blockBloodLight);
+ }
+
+ if (sideHit == 2 && this.worldObj.isAirBlock(blockX, blockY, blockZ - 1))
+ {
+ this.worldObj.setBlock(blockX, blockY, blockZ - 1, ModBlocks.blockBloodLight);
+ }
+
+ if (sideHit == 3 && this.worldObj.isAirBlock(blockX, blockY, blockZ + 1))
+ {
+ this.worldObj.setBlock(blockX, blockY, blockZ + 1, ModBlocks.blockBloodLight);
+ }
+
+ if (sideHit == 4 && this.worldObj.isAirBlock(blockX - 1, blockY, blockZ))
+ {
+ this.worldObj.setBlock(blockX - 1, blockY, blockZ, ModBlocks.blockBloodLight);
+ }
+
+ if (sideHit == 5 && this.worldObj.isAirBlock(blockX + 1, blockY, blockZ))
+ {
+ this.worldObj.setBlock(blockX + 1, blockY, blockZ, ModBlocks.blockBloodLight);
+ }
+
+ //worldObj.createExplosion(this, this.posX, this.posY, this.posZ, (float)(0.1), true);
+ }
+
+ this.setDead();
+ }
+
+ @Override
+ public void onImpact(Entity mop)
+ {
+ if (mop == shootingEntity && ticksInAir > 3)
+ {
+ shootingEntity.attackEntityFrom(DamageSource.causeMobDamage(shootingEntity), 1);
+ this.setDead();
+ } else
+ {
+ //doDamage(8 + d6(), mop);
+ if (mop instanceof EntityLivingBase)
+ {
+ //((EntityLivingBase)mop).addPotionEffect(new PotionEffect(Potion.weakness.id, 60,2));
+
+ ((EntityLivingBase) mop).setRevengeTarget(shootingEntity);
+
+ doDamage(1, mop);
+
+ }
+
+ //worldObj.createExplosion(this, this.posX, this.posY, this.posZ, (float)(0.1), true);
+ }
+
+ if (worldObj.isAirBlock((int) this.posX, (int) this.posY, (int) this.posZ))
+ {
+ worldObj.setBlock((int) this.posX, (int) this.posY, (int) this.posZ, Blocks.fire);
+ }
+
+ spawnHitParticles("magicCrit", 8);
+ this.setDead();
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/EntityEnergyBazookaMainProjectile.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/EntityEnergyBazookaMainProjectile.java
new file mode 100644
index 00000000..9c55f452
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/EntityEnergyBazookaMainProjectile.java
@@ -0,0 +1,100 @@
+package WayofTime.alchemicalWizardry.common.entity.projectile;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.World;
+
+public class EntityEnergyBazookaMainProjectile extends EnergyBlastProjectile
+{
+ public EntityEnergyBazookaMainProjectile(World par1World)
+ {
+ super(par1World);
+ }
+
+ public EntityEnergyBazookaMainProjectile(World par1World, double par2, double par4, double par6)
+ {
+ super(par1World, par2, par4, par6);
+ }
+
+ public EntityEnergyBazookaMainProjectile(World par1World, EntityLivingBase par2EntityPlayer, int damage)
+ {
+ super(par1World, par2EntityPlayer, damage);
+ }
+
+ public EntityEnergyBazookaMainProjectile(World par1World, EntityLivingBase par2EntityPlayer, int damage, int maxTicksInAir, double posX, double posY, double posZ, float rotationYaw, float rotationPitch)
+ {
+ super(par1World, par2EntityPlayer, damage, maxTicksInAir, posX, posY, posZ, rotationYaw, rotationPitch);
+ }
+
+ public EntityEnergyBazookaMainProjectile(World par1World, EntityLivingBase par2EntityLivingBase, EntityLivingBase par3EntityLivingBase, float par4, float par5, int damage, int maxTicksInAir)
+ {
+ super(par1World, par2EntityLivingBase, par3EntityLivingBase, par4, par5, damage, maxTicksInAir);
+ }
+
+ @Override
+ public DamageSource getDamageSource()
+ {
+ return DamageSource.causeMobDamage(shootingEntity);
+ }
+
+ @Override
+ public void onImpact(MovingObjectPosition mop)
+ {
+ if (mop.typeOfHit == MovingObjectPosition.MovingObjectType.ENTITY && mop.entityHit != null)
+ {
+ if (mop.entityHit == shootingEntity)
+ {
+ return;
+ }
+
+ this.onImpact(mop.entityHit);
+ } else if (mop.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK)
+ {
+ worldObj.createExplosion(this.shootingEntity, this.posX, this.posY, this.posZ, (float) (5.0f), false);
+ this.spawnSecondaryProjectiles();
+ }
+
+ this.setDead();
+ }
+
+ @Override
+ public void onImpact(Entity mop)
+ {
+ if (mop == shootingEntity && ticksInAir > 3)
+ {
+ shootingEntity.attackEntityFrom(DamageSource.causeMobDamage(shootingEntity), 1);
+ this.setDead();
+ } else
+ {
+ //doDamage(8 + d6(), mop);
+ if (mop instanceof EntityLivingBase)
+ {
+ spawnSecondaryProjectiles();
+ }
+
+ worldObj.createExplosion(this.shootingEntity, this.posX, this.posY, this.posZ, (float) (5.0f), false);
+ }
+
+ spawnHitParticles("magicCrit", 8);
+ this.setDead();
+ }
+
+ public void spawnSecondaryProjectiles()
+ {
+ for (int i = 0; i < 20; i++)
+ {
+ EntityEnergyBazookaSecondaryProjectile secProj = new EntityEnergyBazookaSecondaryProjectile(worldObj, this.posX, this.posY, this.posZ, 15);
+ secProj.shootingEntity = this.shootingEntity;
+ float xVel = rand.nextFloat() - rand.nextFloat();
+ float yVel = rand.nextFloat() - rand.nextFloat();
+ float zVel = rand.nextFloat() - rand.nextFloat();
+ float wantedVel = 0.5f;
+ secProj.motionX = xVel * wantedVel;
+ secProj.motionY = yVel * wantedVel;
+ secProj.motionZ = zVel * wantedVel;
+ worldObj.spawnEntityInWorld(secProj);
+ }
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/EntityEnergyBazookaSecondaryProjectile.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/EntityEnergyBazookaSecondaryProjectile.java
new file mode 100644
index 00000000..cdbf72f4
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/EntityEnergyBazookaSecondaryProjectile.java
@@ -0,0 +1,508 @@
+package WayofTime.alchemicalWizardry.common.entity.projectile;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import net.minecraft.block.Block;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.IProjectile;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.*;
+import net.minecraft.world.World;
+
+import java.util.Iterator;
+import java.util.List;
+
+public class EntityEnergyBazookaSecondaryProjectile extends EnergyBlastProjectile implements IProjectile
+{
+ private int xTile = -1;
+ private int yTile = -1;
+ private int zTile = -1;
+ private int inTile = 0;
+ private int inData = 0;
+ private boolean inGround = false;
+ /**
+ * The owner of this arrow.
+ */
+ public EntityLivingBase shootingEntity;
+ private int ticksInAir = 0;
+ private int ricochetCounter = 0;
+ private boolean scheduledForDeath = false;
+ public int damage;
+
+ public EntityEnergyBazookaSecondaryProjectile(World par1World)
+ {
+ super(par1World);
+ this.setSize(0.5F, 0.5F);
+ damage = 5;
+ }
+
+ public EntityEnergyBazookaSecondaryProjectile(World par1World, double par2, double par4, double par6, int damage)
+ {
+ super(par1World);
+ this.setSize(0.5F, 0.5F);
+ this.setPosition(par2, par4, par6);
+ yOffset = 0.0F;
+ this.damage = damage;
+ }
+
+ public EntityEnergyBazookaSecondaryProjectile(World par1World, EntityPlayer par2EntityPlayer, int damage)
+ {
+ super(par1World);
+ shootingEntity = par2EntityPlayer;
+ float par3 = 0.8F;
+ this.setSize(0.1F, 0.1F);
+ this.setLocationAndAngles(par2EntityPlayer.posX, par2EntityPlayer.posY + par2EntityPlayer.getEyeHeight(), par2EntityPlayer.posZ, par2EntityPlayer.rotationYaw, par2EntityPlayer.rotationPitch);
+ posX -= MathHelper.cos(rotationYaw / 180.0F * (float) Math.PI) * 0.16F;
+ posY -= 0.2D;
+ posZ -= MathHelper.sin(rotationYaw / 180.0F * (float) Math.PI) * 0.16F;
+ this.setPosition(posX, posY, posZ);
+ yOffset = 0.0F;
+ motionX = -MathHelper.sin(rotationYaw / 180.0F * (float) Math.PI) * MathHelper.cos(rotationPitch / 180.0F * (float) Math.PI);
+ motionZ = MathHelper.cos(rotationYaw / 180.0F * (float) Math.PI) * MathHelper.cos(rotationPitch / 180.0F * (float) Math.PI);
+ motionY = -MathHelper.sin(rotationPitch / 180.0F * (float) Math.PI);
+ this.setThrowableHeading(motionX, motionY, motionZ, par3 * 1.5F, 1.0F);
+ this.damage = damage;
+ }
+
+ @Override
+ protected void entityInit()
+ {
+ dataWatcher.addObject(16, Byte.valueOf((byte) 0));
+ }
+
+ /**
+ * Similar to setArrowHeading, it's point the throwable entity to a x, y, z
+ * direction.
+ */
+ @Override
+ public void setThrowableHeading(double var1, double var3, double var5, float var7, float var8)
+ {
+ float var9 = MathHelper.sqrt_double(var1 * var1 + var3 * var3 + var5 * var5);
+ var1 /= var9;
+ var3 /= var9;
+ var5 /= var9;
+ var1 += rand.nextGaussian() * 0.007499999832361937D * var8;
+ var3 += rand.nextGaussian() * 0.007499999832361937D * var8;
+ var5 += rand.nextGaussian() * 0.007499999832361937D * var8;
+ var1 *= var7;
+ var3 *= var7;
+ var5 *= var7;
+ motionX = var1;
+ motionY = var3;
+ motionZ = var5;
+ float var10 = MathHelper.sqrt_double(var1 * var1 + var5 * var5);
+ prevRotationYaw = rotationYaw = (float) (Math.atan2(var1, var5) * 180.0D / Math.PI);
+ prevRotationPitch = rotationPitch = (float) (Math.atan2(var3, var10) * 180.0D / Math.PI);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ /**
+ * Sets the position and rotation. Only difference from the other one is no bounding on the rotation. Args: posX,
+ * posY, posZ, yaw, pitch
+ */
+ public void setPositionAndRotation2(double par1, double par3, double par5, float par7, float par8, int par9)
+ {
+ this.setPosition(par1, par3, par5);
+ this.setRotation(par7, par8);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ /**
+ * Sets the velocity to the args. Args: x, y, z
+ */
+ public void setVelocity(double par1, double par3, double par5)
+ {
+ motionX = par1;
+ motionY = par3;
+ motionZ = par5;
+
+ if (prevRotationPitch == 0.0F && prevRotationYaw == 0.0F)
+ {
+ float var7 = MathHelper.sqrt_double(par1 * par1 + par5 * par5);
+ prevRotationYaw = rotationYaw = (float) (Math.atan2(par1, par5) * 180.0D / Math.PI);
+ prevRotationPitch = rotationPitch = (float) (Math.atan2(par3, var7) * 180.0D / Math.PI);
+ prevRotationPitch = rotationPitch;
+ prevRotationYaw = rotationYaw;
+ this.setLocationAndAngles(posX, posY, posZ, rotationYaw, rotationPitch);
+ }
+ }
+
+ /**
+ * Called to update the entity's position/logic.
+ */
+ @Override
+ public void onUpdate()
+ {
+ super.onUpdate();
+
+ if (ticksInAir > maxTicksInAir)
+ {
+ this.setDead();
+ }
+
+ if (shootingEntity == null)
+ {
+ List players = worldObj.getEntitiesWithinAABB(EntityPlayer.class, AxisAlignedBB.getBoundingBox(posX - 1, posY - 1, posZ - 1, posX + 1, posY + 1, posZ + 1));
+ Iterator i = players.iterator();
+ double closestDistance = Double.MAX_VALUE;
+ EntityPlayer closestPlayer = null;
+
+ while (i.hasNext())
+ {
+ EntityPlayer e = (EntityPlayer) i.next();
+ double distance = e.getDistanceToEntity(this);
+
+ if (distance < closestDistance)
+ {
+ closestPlayer = e;
+ }
+ }
+
+ if (closestPlayer != null)
+ {
+ shootingEntity = closestPlayer;
+ }
+ }
+
+ if (prevRotationPitch == 0.0F && prevRotationYaw == 0.0F)
+ {
+ float var1 = MathHelper.sqrt_double(motionX * motionX + motionZ * motionZ);
+ prevRotationYaw = rotationYaw = (float) (Math.atan2(motionX, motionZ) * 180.0D / Math.PI);
+ prevRotationPitch = rotationPitch = (float) (Math.atan2(motionY, var1) * 180.0D / Math.PI);
+ }
+
+ Block var16 = worldObj.getBlock(xTile, yTile, zTile);
+
+ if (var16 != null)
+ {
+ var16.setBlockBoundsBasedOnState(worldObj, xTile, yTile, zTile);
+ AxisAlignedBB var2 = var16.getCollisionBoundingBoxFromPool(worldObj, xTile, yTile, zTile);
+
+ if (var2 != null && var2.isVecInside(Vec3.createVectorHelper(posX, posY, posZ)))
+ {
+ inGround = true;
+ }
+ }
+
+ if (inGround)
+ {
+ Block var18 = worldObj.getBlock(xTile, yTile, zTile);
+ int var19 = worldObj.getBlockMetadata(xTile, yTile, zTile);
+
+ if (var18.equals(Block.getBlockById(inTile)) && var19 == inData)
+ {
+ // this.groundImpact();
+ // this.setDead();
+ }
+ } else
+ {
+ ++ticksInAir;
+
+ if (ticksInAir > 1 && ticksInAir < 3)
+ {
+ //worldObj.spawnParticle("flame", posX + smallGauss(0.1D), posY + smallGauss(0.1D), posZ + smallGauss(0.1D), 0D, 0D, 0D);
+ for (int particles = 0; particles < 3; particles++)
+ {
+ this.doFiringParticles();
+ }
+ }
+
+ Vec3 var17 = Vec3.createVectorHelper(posX, posY, posZ);
+ Vec3 var3 = Vec3.createVectorHelper(posX + motionX, posY + motionY, posZ + motionZ);
+ MovingObjectPosition var4 = worldObj.func_147447_a(var17, var3, true, false, false);
+ var17 = Vec3.createVectorHelper(posX, posY, posZ);
+ var3 = Vec3.createVectorHelper(posX + motionX, posY + motionY, posZ + motionZ);
+
+ if (var4 != null)
+ {
+ var3 = Vec3.createVectorHelper(var4.hitVec.xCoord, var4.hitVec.yCoord, var4.hitVec.zCoord);
+ }
+
+ Entity var5 = null;
+ List var6 = worldObj.getEntitiesWithinAABBExcludingEntity(this, boundingBox.addCoord(motionX, motionY, motionZ).expand(1.0D, 1.0D, 1.0D));
+ double var7 = 0.0D;
+ Iterator var9 = var6.iterator();
+ float var11;
+
+ while (var9.hasNext())
+ {
+ Entity var10 = (Entity) var9.next();
+
+ if (var10.canBeCollidedWith() && (var10 != shootingEntity || ticksInAir >= 5))
+ {
+ var11 = 0.3F;
+ AxisAlignedBB var12 = var10.boundingBox.expand(var11, var11, var11);
+ MovingObjectPosition var13 = var12.calculateIntercept(var17, var3);
+
+ if (var13 != null)
+ {
+ double var14 = var17.distanceTo(var13.hitVec);
+
+ if (var14 < var7 || var7 == 0.0D)
+ {
+ var5 = var10;
+ var7 = var14;
+ }
+ }
+ }
+ }
+
+ if (var5 != null)
+ {
+ var4 = new MovingObjectPosition(var5);
+ }
+
+ if (var4 != null)
+ {
+ this.onImpact(var4);
+
+ if (scheduledForDeath)
+ {
+ this.setDead();
+ }
+ }
+
+ posX += motionX;
+ posY += motionY;
+ posZ += motionZ;
+ MathHelper.sqrt_double(motionX * motionX + motionZ * motionZ);
+ this.setPosition(posX, posY, posZ);
+ //this.doBlockCollisions();
+ }
+ }
+
+ public void doFiringParticles()
+ {
+ worldObj.spawnParticle("mobSpellAmbient", posX + smallGauss(0.1D), posY + smallGauss(0.1D), posZ + smallGauss(0.1D), 0.5D, 0.5D, 0.5D);
+ worldObj.spawnParticle("flame", posX, posY, posZ, gaussian(motionX), gaussian(motionY), gaussian(motionZ));
+ }
+
+ /**
+ * (abstract) Protected helper method to write subclass entity data to NBT.
+ */
+ @Override
+ public void writeEntityToNBT(NBTTagCompound par1NBTTagCompound)
+ {
+ par1NBTTagCompound.setShort("xTile", (short) xTile);
+ par1NBTTagCompound.setShort("yTile", (short) yTile);
+ par1NBTTagCompound.setShort("zTile", (short) zTile);
+ par1NBTTagCompound.setByte("inTile", (byte) inTile);
+ par1NBTTagCompound.setByte("inData", (byte) inData);
+ par1NBTTagCompound.setByte("inGround", (byte) (inGround ? 1 : 0));
+ }
+
+ /**
+ * (abstract) Protected helper method to read subclass entity data from NBT.
+ */
+ @Override
+ public void readEntityFromNBT(NBTTagCompound par1NBTTagCompound)
+ {
+ xTile = par1NBTTagCompound.getShort("xTile");
+ yTile = par1NBTTagCompound.getShort("yTile");
+ zTile = par1NBTTagCompound.getShort("zTile");
+ inTile = par1NBTTagCompound.getByte("inTile") & 255;
+ inData = par1NBTTagCompound.getByte("inData") & 255;
+ inGround = par1NBTTagCompound.getByte("inGround") == 1;
+ }
+
+ /**
+ * returns if this entity triggers Block.onEntityWalking on the blocks they
+ * walk on. used for spiders and wolves to prevent them from trampling crops
+ */
+ @Override
+ protected boolean canTriggerWalking()
+ {
+ return false;
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public float getShadowSize()
+ {
+ return 0.0F;
+ }
+
+ /**
+ * Sets the amount of knockback the arrow applies when it hits a mob.
+ */
+ public void setKnockbackStrength(int par1)
+ {
+ }
+
+ /**
+ * If returns false, the item will not inflict any damage against entities.
+ */
+ @Override
+ public boolean canAttackWithItem()
+ {
+ return false;
+ }
+
+ /**
+ * Whether the arrow has a stream of critical hit particles flying behind
+ * it.
+ */
+ public void setIsCritical(boolean par1)
+ {
+ byte var2 = dataWatcher.getWatchableObjectByte(16);
+
+ if (par1)
+ {
+ dataWatcher.updateObject(16, Byte.valueOf((byte) (var2 | 1)));
+ } else
+ {
+ dataWatcher.updateObject(16, Byte.valueOf((byte) (var2 & -2)));
+ }
+ }
+
+ /**
+ * Whether the arrow has a stream of critical hit particles flying behind
+ * it.
+ */
+ public boolean getIsCritical()
+ {
+ byte var1 = dataWatcher.getWatchableObjectByte(16);
+ return (var1 & 1) != 0;
+ }
+
+ public void onImpact(MovingObjectPosition mop)
+ {
+ if (mop.typeOfHit == MovingObjectPosition.MovingObjectType.ENTITY && mop.entityHit != null)
+ {
+ if (mop.entityHit == shootingEntity)
+ {
+ return;
+ }
+
+ this.onImpact(mop.entityHit);
+ } else if (mop.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK)
+ {
+ this.groundImpact(mop.sideHit);
+ worldObj.createExplosion(shootingEntity, posX, posY, posZ, 2, false);
+ }
+ }
+
+ public void onImpact(Entity mop)
+ {
+ if (mop == shootingEntity && ticksInAir > 3)
+ {
+ shootingEntity.attackEntityFrom(DamageSource.causeMobDamage(shootingEntity), 1);
+ this.setDead();
+ } else
+ {
+ doDamage(this.damage + d6(), mop);
+ worldObj.createExplosion(shootingEntity, posX, posY, posZ, 2, false);
+ }
+
+ spawnHitParticles("magicCrit", 8);
+ this.setDead();
+ }
+
+ private int d6()
+ {
+ return rand.nextInt(6) + 1;
+ }
+
+ public void spawnHitParticles(String string, int i)
+ {
+ for (int particles = 0; particles < i; particles++)
+ {
+ worldObj.spawnParticle(string, posX, posY - (string == "portal" ? 1 : 0), posZ, gaussian(motionX), gaussian(motionY), gaussian(motionZ));
+ }
+ }
+
+ public void doDamage(int i, Entity mop)
+ {
+ mop.attackEntityFrom(this.getDamageSource(), i);
+ }
+
+ public DamageSource getDamageSource()
+ {
+ return DamageSource.causeMobDamage(shootingEntity);
+ }
+
+ public void groundImpact(int sideHit)
+ {
+ this.ricochet(sideHit);
+ }
+
+ public double smallGauss(double d)
+ {
+ return (worldObj.rand.nextFloat() - 0.5D) * d;
+ }
+
+ public double gaussian(double d)
+ {
+ return d + d * ((rand.nextFloat() - 0.5D) / 4);
+ }
+
+ private void ricochet(int sideHit)
+ {
+ switch (sideHit)
+ {
+ case 0:
+ case 1:
+ // topHit, bottomHit, reflect Y
+ motionY = motionY * -1;
+ break;
+
+ case 2:
+ case 3:
+ // westHit, eastHit, reflect Z
+ motionZ = motionZ * -1;
+ break;
+
+ case 4:
+ case 5:
+ // southHit, northHit, reflect X
+ motionX = motionX * -1;
+ break;
+ }
+
+ ricochetCounter++;
+
+ if (ricochetCounter > this.getRicochetMax())
+ {
+ scheduledForDeath = true;
+
+ for (int particles = 0; particles < 4; particles++)
+ {
+ switch (sideHit)
+ {
+ case 0:
+ worldObj.spawnParticle("smoke", posX, posY, posZ, gaussian(0.1D), -gaussian(0.1D), gaussian(0.1D));
+ break;
+
+ case 1:
+ worldObj.spawnParticle("smoke", posX, posY, posZ, gaussian(0.1D), gaussian(0.1D), gaussian(0.1D));
+ break;
+
+ case 2:
+ worldObj.spawnParticle("smoke", posX, posY, posZ, gaussian(0.1D), gaussian(0.1D), -gaussian(0.1D));
+ break;
+
+ case 3:
+ worldObj.spawnParticle("smoke", posX, posY, posZ, gaussian(0.1D), gaussian(0.1D), gaussian(0.1D));
+ break;
+
+ case 4:
+ worldObj.spawnParticle("smoke", posX, posY, posZ, -gaussian(0.1D), gaussian(0.1D), gaussian(0.1D));
+ break;
+
+ case 5:
+ worldObj.spawnParticle("smoke", posX, posY, posZ, gaussian(0.1D), gaussian(0.1D), gaussian(0.1D));
+ break;
+ }
+ }
+ }
+ }
+
+ private int getRicochetMax()
+ {
+ return 3;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/EntityMeteor.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/EntityMeteor.java
new file mode 100644
index 00000000..a1f6bc9b
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/EntityMeteor.java
@@ -0,0 +1,90 @@
+package WayofTime.alchemicalWizardry.common.entity.projectile;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.common.summoning.meteor.MeteorRegistry;
+
+public class EntityMeteor extends EnergyBlastProjectile
+{
+ private int meteorID;
+
+ public boolean hasTerrae;
+ public boolean hasOrbisTerrae;
+ public boolean hasCrystallos;
+ public boolean hasIncendium;
+ public boolean hasTennebrae;
+
+ public EntityMeteor(World par1World)
+ {
+ super(par1World);
+ this.meteorID = 0;
+ }
+
+ public EntityMeteor(World par1World, double par2, double par4, double par6, int meteorID)
+ {
+ super(par1World, par2, par4, par6);
+ this.meteorID = meteorID;
+ }
+
+ @Override
+ public void writeEntityToNBT(NBTTagCompound par1NBTTagCompound)
+ {
+ super.writeEntityToNBT(par1NBTTagCompound);
+
+ par1NBTTagCompound.setInteger("meteorID", meteorID);
+ par1NBTTagCompound.setBoolean("hasTerrae", hasTerrae);
+ par1NBTTagCompound.setBoolean("hasOrbisTerrae", hasOrbisTerrae);
+ par1NBTTagCompound.setBoolean("hasCrystallos", hasCrystallos);
+ par1NBTTagCompound.setBoolean("hasIncendium", hasIncendium);
+ par1NBTTagCompound.setBoolean("hasTennebrae", hasTennebrae);
+ }
+
+ @Override
+ public void readEntityFromNBT(NBTTagCompound par1NBTTagCompound)
+ {
+ super.readEntityFromNBT(par1NBTTagCompound);
+
+ meteorID = par1NBTTagCompound.getInteger("meteorID");
+ hasTerrae = par1NBTTagCompound.getBoolean("hasTerrae");
+ hasOrbisTerrae = par1NBTTagCompound.getBoolean("hasOrbisTerrae");
+ hasIncendium = par1NBTTagCompound.getBoolean("hasIncendium");
+ hasCrystallos = par1NBTTagCompound.getBoolean("hasCrystallos");
+ hasTennebrae = par1NBTTagCompound.getBoolean("hasTennebrae");
+ }
+
+ @Override
+ public DamageSource getDamageSource()
+ {
+ return DamageSource.fallingBlock;
+ }
+
+ @Override
+ public void onImpact(MovingObjectPosition mop)
+ {
+ if (worldObj.isRemote)
+ {
+ return;
+ }
+
+ if (mop.typeOfHit == MovingObjectPosition.MovingObjectType.ENTITY && mop.entityHit != null)
+ {
+ this.onImpact(mop.entityHit);
+ } else if (mop.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK)
+ {
+ MeteorRegistry.createMeteorImpact(worldObj, mop.blockX, mop.blockY, mop.blockZ, this.meteorID, new boolean[]{hasTerrae, hasOrbisTerrae, hasCrystallos, hasIncendium, hasTennebrae});
+ }
+
+ this.setDead();
+ }
+
+ @Override
+ public void onImpact(Entity mop)
+ {
+ MeteorRegistry.createMeteorImpact(worldObj, (int) this.posX, (int) this.posY, (int) this.posZ, meteorID, new boolean[]{hasTerrae, hasOrbisTerrae, hasCrystallos, hasIncendium, hasTennebrae});
+
+ this.setDead();
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/EntityParticleBeam.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/EntityParticleBeam.java
new file mode 100644
index 00000000..564e7dea
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/EntityParticleBeam.java
@@ -0,0 +1,350 @@
+package WayofTime.alchemicalWizardry.common.entity.projectile;
+
+import net.minecraft.client.particle.EntityCloudFX;
+import net.minecraft.client.particle.EntityFX;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.IProjectile;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.MathHelper;
+import net.minecraft.world.World;
+import cpw.mods.fml.client.FMLClientHandler;
+import cpw.mods.fml.common.registry.IThrowableEntity;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+//Shamelessly ripped off from x3n0ph0b3
+public class EntityParticleBeam extends Entity implements IProjectile, IThrowableEntity
+{
+ protected int xTile = -1;
+ protected int yTile = -1;
+ protected int zTile = -1;
+ protected int inTile = 0;
+ protected int inData = 0;
+ protected float colourRed = 0f;
+ protected float colourGreen = 0f;
+ protected float colourBlue = 0f;
+ protected int xDest = 0;
+ protected int yDest = 0;
+ protected int zDest = 0;
+ protected boolean inGround = false;
+ /**
+ * The owner of this arrow.
+ */
+ public EntityLivingBase shootingEntity;
+ protected int ticksInAir = 0;
+ protected int maxTicksInAir = 600;
+ private int ricochetCounter = 0;
+ private boolean scheduledForDeath = false;
+ protected int projectileDamage;
+
+ public EntityParticleBeam(World par1World)
+ {
+ super(par1World);
+ this.setSize(0.5F, 0.5F);
+ this.maxTicksInAir = 600;
+ }
+
+ public EntityParticleBeam(World par1World, double par2, double par4, double par6)
+ {
+ super(par1World);
+ this.setSize(0.5F, 0.5F);
+ this.setPosition(par2, par4, par6);
+ yOffset = 0.0F;
+ this.maxTicksInAir = 600;
+ }
+
+ public EntityParticleBeam(World par1World, EntityLivingBase par2EntityPlayer, int damage)
+ {
+ super(par1World);
+ shootingEntity = par2EntityPlayer;
+ float par3 = 0.8F;
+ this.setSize(0.5F, 0.5F);
+ this.setLocationAndAngles(par2EntityPlayer.posX, par2EntityPlayer.posY + par2EntityPlayer.getEyeHeight(), par2EntityPlayer.posZ, par2EntityPlayer.rotationYaw, par2EntityPlayer.rotationPitch);
+ posX -= MathHelper.cos(rotationYaw / 180.0F * (float) Math.PI) * 0.16F;
+ posY -= 0.2D;
+ posZ -= MathHelper.sin(rotationYaw / 180.0F * (float) Math.PI) * 0.16F;
+ this.setPosition(posX, posY, posZ);
+ yOffset = 0.0F;
+ motionX = -MathHelper.sin(rotationYaw / 180.0F * (float) Math.PI) * MathHelper.cos(rotationPitch / 180.0F * (float) Math.PI);
+ motionZ = MathHelper.cos(rotationYaw / 180.0F * (float) Math.PI) * MathHelper.cos(rotationPitch / 180.0F * (float) Math.PI);
+ motionY = -MathHelper.sin(rotationPitch / 180.0F * (float) Math.PI);
+ this.setThrowableHeading(motionX, motionY, motionZ, par3 * 1.5F, 1.0F);
+ this.projectileDamage = damage;
+ this.maxTicksInAir = 600;
+ }
+
+ public EntityParticleBeam(World par1World, EntityLivingBase par2EntityPlayer, int damage, int maxTicksInAir, double posX, double posY, double posZ, float rotationYaw, float rotationPitch)
+ {
+ super(par1World);
+ shootingEntity = par2EntityPlayer;
+ float par3 = 0.8F;
+ this.setSize(0.5F, 0.5F);
+ this.setLocationAndAngles(posX, posY, posZ, rotationYaw, rotationPitch);
+ posX -= MathHelper.cos(rotationYaw / 180.0F * (float) Math.PI) * 0.16F;
+ posY -= 0.2D;
+ posZ -= MathHelper.sin(rotationYaw / 180.0F * (float) Math.PI) * 0.16F;
+ this.setPosition(posX, posY, posZ);
+ yOffset = 0.0F;
+ motionX = -MathHelper.sin(rotationYaw / 180.0F * (float) Math.PI) * MathHelper.cos(rotationPitch / 180.0F * (float) Math.PI);
+ motionZ = MathHelper.cos(rotationYaw / 180.0F * (float) Math.PI) * MathHelper.cos(rotationPitch / 180.0F * (float) Math.PI);
+ motionY = -MathHelper.sin(rotationPitch / 180.0F * (float) Math.PI);
+ this.setThrowableHeading(motionX, motionY, motionZ, par3 * 1.5F, 1.0F);
+ this.projectileDamage = damage;
+ this.maxTicksInAir = maxTicksInAir;
+ }
+
+ public EntityParticleBeam(World par1World, EntityLivingBase par2EntityLivingBase, EntityLivingBase par3EntityLivingBase, float par4, float par5, int damage, int maxTicksInAir)
+ {
+ super(par1World);
+ this.renderDistanceWeight = 10.0D;
+ this.shootingEntity = par2EntityLivingBase;
+ this.posY = par2EntityLivingBase.posY + (double) par2EntityLivingBase.getEyeHeight() - 0.10000000149011612D;
+ double d0 = par3EntityLivingBase.posX - par2EntityLivingBase.posX;
+ double d1 = par3EntityLivingBase.boundingBox.minY + (double) (par3EntityLivingBase.height / 1.5F) - this.posY;
+ double d2 = par3EntityLivingBase.posZ - par2EntityLivingBase.posZ;
+ double d3 = (double) MathHelper.sqrt_double(d0 * d0 + d2 * d2);
+
+ if (d3 >= 1.0E-7D)
+ {
+ float f2 = (float) (Math.atan2(d2, d0) * 180.0D / Math.PI) - 90.0F;
+ float f3 = (float) (-(Math.atan2(d1, d3) * 180.0D / Math.PI));
+ double d4 = d0 / d3;
+ double d5 = d2 / d3;
+ this.setLocationAndAngles(par2EntityLivingBase.posX + d4, this.posY, par2EntityLivingBase.posZ + d5, f2, f3);
+ this.yOffset = 0.0F;
+ float f4 = (float) d3 * 0.2F;
+ this.setThrowableHeading(d0, d1, d2, par4, par5);
+ }
+
+ this.projectileDamage = damage;
+ this.maxTicksInAir = maxTicksInAir;
+ }
+
+ @Override
+ protected void entityInit()
+ {
+ dataWatcher.addObject(16, Byte.valueOf((byte) 0));
+ }
+
+ /**
+ * Similar to setArrowHeading, it's point the throwable entity to a x, y, z
+ * direction.
+ */
+ @Override
+ public void setThrowableHeading(double var1, double var3, double var5, float var7, float var8)
+ {
+ float var9 = MathHelper.sqrt_double(var1 * var1 + var3 * var3 + var5 * var5);
+ var1 /= var9;
+ var3 /= var9;
+ var5 /= var9;
+ var1 += rand.nextGaussian() * 0.007499999832361937D * var8;
+ var3 += rand.nextGaussian() * 0.007499999832361937D * var8;
+ var5 += rand.nextGaussian() * 0.007499999832361937D * var8;
+ var1 *= var7;
+ var3 *= var7;
+ var5 *= var7;
+ motionX = var1;
+ motionY = var3;
+ motionZ = var5;
+ float var10 = MathHelper.sqrt_double(var1 * var1 + var5 * var5);
+ prevRotationYaw = rotationYaw = (float) (Math.atan2(var1, var5) * 180.0D / Math.PI);
+ prevRotationPitch = rotationPitch = (float) (Math.atan2(var3, var10) * 180.0D / Math.PI);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ /**
+ * Sets the position and rotation. Only difference from the other one is no bounding on the rotation. Args: posX,
+ * posY, posZ, yaw, pitch
+ */
+ public void setPositionAndRotation2(double par1, double par3, double par5, float par7, float par8, int par9)
+ {
+ this.setPosition(par1, par3, par5);
+ this.setRotation(par7, par8);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ /**
+ * Sets the velocity to the args. Args: x, y, z
+ */
+ public void setVelocity(double par1, double par3, double par5)
+ {
+ motionX = par1;
+ motionY = par3;
+ motionZ = par5;
+
+ if (prevRotationPitch == 0.0F && prevRotationYaw == 0.0F)
+ {
+ float var7 = MathHelper.sqrt_double(par1 * par1 + par5 * par5);
+ prevRotationYaw = rotationYaw = (float) (Math.atan2(par1, par5) * 180.0D / Math.PI);
+ prevRotationPitch = rotationPitch = (float) (Math.atan2(par3, var7) * 180.0D / Math.PI);
+ prevRotationPitch = rotationPitch;
+ prevRotationYaw = rotationYaw;
+ this.setLocationAndAngles(posX, posY, posZ, rotationYaw, rotationPitch);
+ }
+ }
+
+ /**
+ * Called to update the entity's position/logic.
+ */
+ @Override
+ public void onUpdate()
+ {
+ super.onUpdate();
+
+ if (ticksInAir > maxTicksInAir)
+ {
+ this.setDead();
+ }
+
+ posX += motionX;
+ posY += motionY;
+ posZ += motionZ;
+ MathHelper.sqrt_double(motionX * motionX + motionZ * motionZ);
+ this.setPosition(posX, posY, posZ);
+
+ this.doFiringParticles();
+
+ if(Math.pow(posX - xDest, 2) + Math.pow(posY - yDest, 2) + Math.pow(posZ - zDest, 2) <= 1)
+ {
+ this.scheduledForDeath = true;
+ }
+
+ if(this.scheduledForDeath)
+ {
+ this.setDead();
+ }
+ }
+
+ public void doFiringParticles()
+ {
+ if(!worldObj.isRemote)
+ {
+ return;
+ }
+ //worldObj.spawnParticle("mobSpellAmbient", posX + smallGauss(0.1D), posY + smallGauss(0.1D), posZ + smallGauss(0.1D), 0.5D, 0.5D, 0.5D);
+ EntityFX particle = new EntityCloudFX(worldObj, posX, posY, posZ, 0, 0, 0);
+ particle.setRBGColorF(colourRed + 0.15f * (worldObj.rand.nextFloat() - worldObj.rand.nextFloat()), colourGreen + 0.15f * (worldObj.rand.nextFloat() - worldObj.rand.nextFloat()), colourBlue + 0.15f * (worldObj.rand.nextFloat() - worldObj.rand.nextFloat()));
+ FMLClientHandler.instance().getClient().effectRenderer.addEffect(particle);
+ //worldObj.spawnParticle("happyVillager", posX, posY, posZ, 0, 0, 0);
+ }
+
+ /**
+ * (abstract) Protected helper method to write subclass entity data to NBT.
+ */
+ @Override
+ public void writeEntityToNBT(NBTTagCompound par1NBTTagCompound)
+ {
+ par1NBTTagCompound.setShort("xTile", (short) xTile);
+ par1NBTTagCompound.setShort("yTile", (short) yTile);
+ par1NBTTagCompound.setShort("zTile", (short) zTile);
+ par1NBTTagCompound.setByte("inTile", (byte) inTile);
+ par1NBTTagCompound.setByte("inData", (byte) inData);
+ par1NBTTagCompound.setByte("inGround", (byte) (inGround ? 1 : 0));
+ par1NBTTagCompound.setInteger("ticksInAir", ticksInAir);
+ par1NBTTagCompound.setInteger("maxTicksInAir", maxTicksInAir);
+ par1NBTTagCompound.setInteger("projectileDamage", this.projectileDamage);
+ par1NBTTagCompound.setFloat("colourRed", colourRed);
+ par1NBTTagCompound.setFloat("colourGreen", colourGreen);
+ par1NBTTagCompound.setFloat("colourBlue", colourBlue);
+ par1NBTTagCompound.setInteger("xDest", xDest);
+ par1NBTTagCompound.setInteger("yDest", yDest);
+ par1NBTTagCompound.setInteger("zDest", zDest);
+ }
+
+ /**
+ * (abstract) Protected helper method to read subclass entity data from NBT.
+ */
+ @Override
+ public void readEntityFromNBT(NBTTagCompound par1NBTTagCompound)
+ {
+ xTile = par1NBTTagCompound.getShort("xTile");
+ yTile = par1NBTTagCompound.getShort("yTile");
+ zTile = par1NBTTagCompound.getShort("zTile");
+ inTile = par1NBTTagCompound.getByte("inTile") & 255;
+ inData = par1NBTTagCompound.getByte("inData") & 255;
+ inGround = par1NBTTagCompound.getByte("inGround") == 1;
+ ticksInAir = par1NBTTagCompound.getInteger("ticksInAir");
+ maxTicksInAir = par1NBTTagCompound.getInteger("maxTicksInAir");
+ projectileDamage = par1NBTTagCompound.getInteger("projectileDamage");
+ colourRed = par1NBTTagCompound.getFloat("colourRed");
+ colourGreen = par1NBTTagCompound.getFloat("colourGreen");
+ colourBlue = par1NBTTagCompound.getFloat("colourBlue");
+ xDest = par1NBTTagCompound.getInteger("xDest");
+ yDest = par1NBTTagCompound.getInteger("yDest");
+ zDest = par1NBTTagCompound.getInteger("zDest");
+ }
+
+ @Override
+ protected boolean canTriggerWalking()
+ {
+ return false;
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public float getShadowSize()
+ {
+ return 0.0F;
+ }
+
+ protected void spawnHitParticles(String string, int i)
+ {
+ for (int particles = 0; particles < i; particles++)
+ {
+ worldObj.spawnParticle(string, posX, posY - (string == "portal" ? 1 : 0), posZ, gaussian(motionX), gaussian(motionY), gaussian(motionZ));
+ }
+ }
+
+ public DamageSource getDamageSource()
+ {
+ return DamageSource.causeMobDamage(shootingEntity);
+ }
+
+ public double smallGauss(double d)
+ {
+ return (worldObj.rand.nextFloat() - 0.5D) * d;
+ }
+
+ public double gaussian(double d)
+ {
+ return d + d * ((rand.nextFloat() - 0.5D) / 4);
+ }
+
+ private int getRicochetMax()
+ {
+ return 0;
+ }
+
+ @Override
+ public Entity getThrower()
+ {
+ // TODO Auto-generated method stub
+ return this.shootingEntity;
+ }
+
+ @Override
+ public void setThrower(Entity entity)
+ {
+ if(entity instanceof EntityLivingBase)
+ this.shootingEntity = (EntityLivingBase)entity;
+
+ }
+
+ public void setColour(float red, float green, float blue)
+ {
+ this.colourRed = red;
+ this.colourGreen = green;
+ this.colourBlue = blue;
+ }
+
+ public void setDestination(int xDest, int yDest, int zDest)
+ {
+ this.xDest = xDest;
+ this.yDest = yDest;
+ this.zDest = zDest;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/ExplosionProjectile.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/ExplosionProjectile.java
new file mode 100644
index 00000000..569aaf0b
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/ExplosionProjectile.java
@@ -0,0 +1,134 @@
+package WayofTime.alchemicalWizardry.common.entity.projectile;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.World;
+
+public class ExplosionProjectile extends EnergyBlastProjectile
+{
+ protected boolean causesEnvDamage;
+
+ public ExplosionProjectile(World par1World)
+ {
+ super(par1World);
+ }
+
+ public ExplosionProjectile(World par1World, double par2, double par4, double par6)
+ {
+ super(par1World, par2, par4, par6);
+ }
+
+ public ExplosionProjectile(World par1World, EntityLivingBase par2EntityPlayer, int damage, boolean flag)
+ {
+ super(par1World, par2EntityPlayer, damage);
+ causesEnvDamage = flag;
+ }
+
+ public ExplosionProjectile(World par1World, EntityLivingBase par2EntityPlayer, int damage, int maxTicksInAir, double posX, double posY, double posZ, float rotationYaw, float rotationPitch, boolean flag)
+ {
+ super(par1World, par2EntityPlayer, damage, maxTicksInAir, posX, posY, posZ, rotationYaw, rotationPitch);
+ causesEnvDamage = flag;
+ }
+
+ @Override
+ public DamageSource getDamageSource()
+ {
+ return DamageSource.causeMobDamage(shootingEntity);
+ }
+
+ @Override
+ public void onImpact(MovingObjectPosition mop)
+ {
+ if (mop.typeOfHit == MovingObjectPosition.MovingObjectType.ENTITY && mop.entityHit != null)
+ {
+ if (mop.entityHit == shootingEntity)
+ {
+ return;
+ }
+
+ worldObj.createExplosion(this, this.posX, this.posY, this.posZ, (float) (2), causesEnvDamage);
+ //this.onImpact(mop.entityHit);
+ } else if (mop.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK)
+ {
+// for(int i=-1;i<=1;i++)
+// {
+// for(int j=-1;j<=1;j++)
+// {
+// for(int k=-1;k<=1;k++)
+// {
+// if(worldObj.isAirBlock((int)this.posX+i, (int)this.posY+j, (int)this.posZ+k))
+// {
+// worldObj.setBlock( (int)this.posX+i, (int)this.posY+j, (int)this.posZ+k,Block.fire.blockID);
+// }
+// }
+// }
+// }
+ worldObj.createExplosion(this, this.posX, this.posY, this.posZ, (float) (2), causesEnvDamage);
+ }
+
+ this.setDead();
+ }
+
+ @Override
+ public void onImpact(Entity mop)
+ {
+ if (mop == shootingEntity && ticksInAir > 3)
+ {
+ shootingEntity.attackEntityFrom(DamageSource.causeMobDamage(shootingEntity), 1);
+ this.setDead();
+ } else
+ {
+ //doDamage(8 + d6(), mop);
+ if (mop instanceof EntityLivingBase)
+ {
+ //((EntityLivingBase)mop).addPotionEffect(new PotionEffect(Potion.weakness.id, 60,2));
+ //((EntityLivingBase)mop).setFire(50);
+ //((EntityLivingBase)mop).setRevengeTarget(shootingEntity);
+ if (((EntityLivingBase) mop).isImmuneToFire())
+ {
+ doDamage((int) (projectileDamage), mop);
+ } else
+ {
+ doDamage(projectileDamage, mop);
+ }
+ }
+
+ //worldObj.createExplosion(this, this.posX, this.posY, this.posZ, (float)(0.1), true);
+ }
+
+ if (worldObj.isAirBlock((int) this.posX, (int) this.posY, (int) this.posZ))
+ {
+ //worldObj.setBlock((int)this.posX, (int)this.posY, (int)this.posZ,Block.fire.blockID);
+ }
+
+ spawnHitParticles("magicCrit", 8);
+ this.setDead();
+ }
+
+ @Override
+ public void doFiringParticles()
+ {
+ worldObj.spawnParticle("mobSpellAmbient", posX + smallGauss(0.1D), posY + smallGauss(0.1D), posZ + smallGauss(0.1D), 0.5D, 0.5D, 0.5D);
+ worldObj.spawnParticle("explode", posX, posY, posZ, gaussian(motionX), gaussian(motionY), gaussian(motionZ));
+ }
+
+ @Override
+ public void writeEntityToNBT(NBTTagCompound par1NBTTagCompound)
+ {
+ super.writeEntityToNBT(par1NBTTagCompound);
+ par1NBTTagCompound.setBoolean("causesEnvDamage", causesEnvDamage);
+ }
+
+ /**
+ * (abstract) Protected helper method to read subclass entity data from NBT.
+ */
+ @Override
+ public void readEntityFromNBT(NBTTagCompound par1NBTTagCompound)
+ {
+ super.readEntityFromNBT(par1NBTTagCompound);
+ causesEnvDamage = par1NBTTagCompound.getBoolean("causesEnvDamage");
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/FireProjectile.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/FireProjectile.java
new file mode 100644
index 00000000..7ab8f052
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/FireProjectile.java
@@ -0,0 +1,115 @@
+package WayofTime.alchemicalWizardry.common.entity.projectile;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.init.Blocks;
+import net.minecraft.potion.Potion;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.World;
+
+public class FireProjectile extends EnergyBlastProjectile
+{
+ public FireProjectile(World par1World)
+ {
+ super(par1World);
+ }
+
+ public FireProjectile(World par1World, double par2, double par4, double par6)
+ {
+ super(par1World, par2, par4, par6);
+ }
+
+ public FireProjectile(World par1World, EntityLivingBase par2EntityPlayer, int damage)
+ {
+ super(par1World, par2EntityPlayer, damage);
+ }
+
+ public FireProjectile(World par1World, EntityLivingBase par2EntityPlayer, int damage, int maxTicksInAir, double posX, double posY, double posZ, float rotationYaw, float rotationPitch)
+ {
+ super(par1World, par2EntityPlayer, damage, maxTicksInAir, posX, posY, posZ, rotationYaw, rotationPitch);
+ }
+
+ public FireProjectile(World par1World, EntityLivingBase par2EntityLivingBase, EntityLivingBase par3EntityLivingBase, float par4, float par5, int damage, int maxTicksInAir)
+ {
+ super(par1World, par2EntityLivingBase, par3EntityLivingBase, par4, par5, damage, maxTicksInAir);
+ }
+
+ @Override
+ public DamageSource getDamageSource()
+ {
+ return DamageSource.causeMobDamage(shootingEntity);
+ }
+
+ @Override
+ public void onImpact(MovingObjectPosition mop)
+ {
+ if (mop.typeOfHit == MovingObjectPosition.MovingObjectType.ENTITY && mop.entityHit != null)
+ {
+ if (mop.entityHit == shootingEntity)
+ {
+ return;
+ }
+
+ this.onImpact(mop.entityHit);
+ } else if (mop.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK)
+ {
+ for (int i = -1; i <= 1; i++)
+ {
+ for (int j = -1; j <= 1; j++)
+ {
+ for (int k = -1; k <= 1; k++)
+ {
+ if (worldObj.isAirBlock((int) this.posX + i, (int) this.posY + j, (int) this.posZ + k))
+ {
+ worldObj.setBlock((int) this.posX + i, (int) this.posY + j, (int) this.posZ + k, Blocks.fire);
+ }
+ }
+ }
+ }
+
+ //worldObj.createExplosion(this, this.posX, this.posY, this.posZ, (float)(0.1), true);
+ }
+
+ this.setDead();
+ }
+
+ @Override
+ public void onImpact(Entity mop)
+ {
+ if (mop == shootingEntity && ticksInAir > 3)
+ {
+ shootingEntity.attackEntityFrom(DamageSource.causeMobDamage(shootingEntity), 1);
+ this.setDead();
+ } else
+ {
+ //doDamage(8 + d6(), mop);
+ if (mop instanceof EntityLivingBase)
+ {
+ //((EntityLivingBase)mop).addPotionEffect(new PotionEffect(Potion.weakness.id, 60,2));
+ ((EntityLivingBase) mop).setFire(50);
+ ((EntityLivingBase) mop).setRevengeTarget(shootingEntity);
+
+ if (((EntityLivingBase) mop).isPotionActive(Potion.fireResistance) || ((EntityLivingBase) mop).isImmuneToFire())
+ {
+ ((EntityLivingBase) mop).attackEntityFrom(DamageSource.causeMobDamage(shootingEntity), 1);
+ } else
+ {
+ doDamage(projectileDamage, mop);
+ ((EntityLivingBase) mop).hurtResistantTime = 0;
+ }
+ }
+
+ //worldObj.createExplosion(this, this.posX, this.posY, this.posZ, (float)(0.1), true);
+ }
+
+ if (worldObj.isAirBlock((int) this.posX, (int) this.posY, (int) this.posZ))
+ {
+ worldObj.setBlock((int) this.posX, (int) this.posY, (int) this.posZ, Blocks.fire);
+ }
+
+ spawnHitParticles("magicCrit", 8);
+ this.setDead();
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/HolyProjectile.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/HolyProjectile.java
new file mode 100644
index 00000000..062ccbf7
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/HolyProjectile.java
@@ -0,0 +1,117 @@
+package WayofTime.alchemicalWizardry.common.entity.projectile;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.common.PacketHandler;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+
+public class HolyProjectile extends EnergyBlastProjectile
+{
+ public HolyProjectile(World par1World)
+ {
+ super(par1World);
+ }
+
+ public HolyProjectile(World par1World, double par2, double par4, double par6)
+ {
+ super(par1World, par2, par4, par6);
+ }
+
+ public HolyProjectile(World par1World, EntityLivingBase par2EntityPlayer, int damage)
+ {
+ super(par1World, par2EntityPlayer, damage);
+ }
+
+ public HolyProjectile(World par1World, EntityLivingBase par2EntityPlayer, int damage, int maxTicksInAir, double posX, double posY, double posZ, float rotationYaw, float rotationPitch)
+ {
+ super(par1World, par2EntityPlayer, damage, maxTicksInAir, posX, posY, posZ, rotationYaw, rotationPitch);
+ }
+
+ public HolyProjectile(World par1World, EntityLivingBase par2EntityLivingBase, EntityLivingBase par3EntityLivingBase, float par4, float par5, int damage, int maxTicksInAir)
+ {
+ super(par1World, par2EntityLivingBase, par3EntityLivingBase, par4, par5, damage, maxTicksInAir);
+ }
+
+ @Override
+ public DamageSource getDamageSource()
+ {
+ return DamageSource.causeMobDamage(shootingEntity);
+ }
+
+ @Override
+ public void onImpact(MovingObjectPosition mop)
+ {
+ if (mop.typeOfHit == MovingObjectPosition.MovingObjectType.ENTITY && mop.entityHit != null)
+ {
+ if (mop.entityHit == shootingEntity)
+ {
+ return;
+ }
+
+ this.onImpact(mop.entityHit);
+ } else if (mop.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK)
+ {
+// for(int i=-1;i<=1;i++)
+// {
+// for(int j=-1;j<=1;j++)
+// {
+// for(int k=-1;k<=1;k++)
+// {
+// if(worldObj.isAirBlock((int)this.posX+i, (int)this.posY+j, (int)this.posZ+k))
+// {
+// worldObj.setBlock( (int)this.posX+i, (int)this.posY+j, (int)this.posZ+k,Block.fire.blockID);
+// }
+// }
+// }
+// }
+ }
+
+ this.setDead();
+ }
+
+ @Override
+ public void onImpact(Entity mop)
+ {
+ if (mop == shootingEntity && ticksInAir > 3)
+ {
+ shootingEntity.attackEntityFrom(DamageSource.causeMobDamage(shootingEntity), 1);
+ this.setDead();
+ } else
+ {
+ //doDamage(8 + d6(), mop);
+ if (mop instanceof EntityLivingBase)
+ {
+ //((EntityLivingBase)mop).addPotionEffect(new PotionEffect(Potion.weakness.id, 60,2));
+ //((EntityLivingBase)mop).setFire(50);
+ //((EntityLivingBase)mop).setRevengeTarget(shootingEntity);
+ if (((EntityLivingBase) mop).isEntityUndead())
+ {
+ doDamage((int) (projectileDamage * 2), mop);
+ } else
+ {
+ doDamage(projectileDamage, mop);
+ }
+ }
+
+ //worldObj.createExplosion(this, this.posX, this.posY, this.posZ, (float)(0.1), true);
+ }
+
+ if (worldObj.isAirBlock((int) this.posX, (int) this.posY, (int) this.posZ))
+ {
+ //worldObj.setBlock((int)this.posX, (int)this.posY, (int)this.posZ,Block.fire.blockID);
+ }
+
+ spawnHitParticles("magicCrit", 8);
+ this.setDead();
+ }
+
+ @Override
+ public void doFiringParticles()
+ {
+ SpellHelper.sendParticleToAllAround(worldObj, posX, posY, posZ, 30, worldObj.provider.dimensionId, "mobSpellAmbient", posX + smallGauss(0.1D), posY + smallGauss(0.1D), posZ + smallGauss(0.1D), 0.5D, 0.5D, 0.5D);
+ SpellHelper.sendParticleToAllAround(worldObj, posX, posY, posZ, 30, worldObj.provider.dimensionId, "mobSpell", posX, posY, posZ, 1.0F, 1.0F, 1.0F);
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/IceProjectile.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/IceProjectile.java
new file mode 100644
index 00000000..06867d81
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/IceProjectile.java
@@ -0,0 +1,123 @@
+package WayofTime.alchemicalWizardry.common.entity.projectile;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.potion.Potion;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.common.PacketHandler;
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityIceDemon;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+
+public class IceProjectile extends EnergyBlastProjectile
+{
+ public IceProjectile(World par1World)
+ {
+ super(par1World);
+ }
+
+ public IceProjectile(World par1World, double par2, double par4, double par6)
+ {
+ super(par1World, par2, par4, par6);
+ }
+
+ public IceProjectile(World par1World, EntityLivingBase par2EntityPlayer, int damage)
+ {
+ super(par1World, par2EntityPlayer, damage);
+ }
+
+ public IceProjectile(World par1World, EntityLivingBase par2EntityPlayer, int damage, int maxTicksInAir, double posX, double posY, double posZ, float rotationYaw, float rotationPitch)
+ {
+ super(par1World, par2EntityPlayer, damage, maxTicksInAir, posX, posY, posZ, rotationYaw, rotationPitch);
+ }
+
+ public IceProjectile(World worldObj, EntityIceDemon entityIceDemon, EntityLivingBase par1EntityLivingBase, float f, float g, int i, int j)
+ {
+ super(worldObj, entityIceDemon, par1EntityLivingBase, f, g, i, j);
+ }
+
+ @Override
+ public DamageSource getDamageSource()
+ {
+ return DamageSource.causeMobDamage(shootingEntity);
+ }
+
+ @Override
+ public void onImpact(MovingObjectPosition mop)
+ {
+ if (mop.typeOfHit == MovingObjectPosition.MovingObjectType.ENTITY && mop.entityHit != null)
+ {
+ if (mop.entityHit == shootingEntity)
+ {
+ return;
+ }
+
+ this.onImpact(mop.entityHit);
+ } else if (mop.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK)
+ {
+// for(int i=-1;i<=1;i++)
+// {
+// for(int j=-1;j<=1;j++)
+// {
+// for(int k=-1;k<=1;k++)
+// {
+// if(worldObj.isAirBlock((int)this.posX+i, (int)this.posY+j, (int)this.posZ+k))
+// {
+// worldObj.setBlock( (int)this.posX+i, (int)this.posY+j, (int)this.posZ+k,Block.fire.blockID);
+// }
+// }
+// }
+// }
+ //worldObj.createExplosion(this, this.posX, this.posY, this.posZ, (float)(0.1), true);
+ }
+
+ this.setDead();
+ }
+
+ @Override
+ public void onImpact(Entity mop)
+ {
+ if (mop == shootingEntity && ticksInAir > 3)
+ {
+ shootingEntity.attackEntityFrom(DamageSource.causeMobDamage(shootingEntity), 1);
+ this.setDead();
+ } else
+ {
+ //doDamage(8 + d6(), mop);
+ if (mop instanceof EntityLivingBase)
+ {
+ //((EntityLivingBase)mop).addPotionEffect(new PotionEffect(Potion.weakness.id, 60,2));
+ //((EntityLivingBase)mop).setFire(50);
+ //((EntityLivingBase)mop).setRevengeTarget(shootingEntity);
+ if (((EntityLivingBase) mop).isImmuneToFire())
+ {
+ doDamage((int) (projectileDamage * 2), mop);
+ ((EntityLivingBase) mop).addPotionEffect(new PotionEffect(Potion.moveSlowdown.id, 200, 2));
+ } else
+ {
+ doDamage(projectileDamage, mop);
+ ((EntityLivingBase) mop).addPotionEffect(new PotionEffect(Potion.moveSlowdown.id, 100, 1));
+ }
+ }
+
+ //worldObj.createExplosion(this, this.posX, this.posY, this.posZ, (float)(0.1), true);
+ }
+
+ if (worldObj.isAirBlock((int) this.posX, (int) this.posY, (int) this.posZ))
+ {
+ //worldObj.setBlock((int)this.posX, (int)this.posY, (int)this.posZ,Block.fire.blockID);
+ }
+
+ spawnHitParticles("magicCrit", 8);
+ this.setDead();
+ }
+
+ @Override
+ public void doFiringParticles()
+ {
+ SpellHelper.sendParticleToAllAround(worldObj, posX, posY, posZ, 30, worldObj.provider.dimensionId, "mobSpellAmbient", posX + smallGauss(0.1D), posY + smallGauss(0.1D), posZ + smallGauss(0.1D), 0.5D, 0.5D, 0.5D);
+ SpellHelper.sendParticleToAllAround(worldObj, posX, posY, posZ, 30, worldObj.provider.dimensionId, "explode", posX, posY, posZ, gaussian(motionX), gaussian(motionY), gaussian(motionZ));
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/LightningBoltProjectile.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/LightningBoltProjectile.java
new file mode 100644
index 00000000..106cf420
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/LightningBoltProjectile.java
@@ -0,0 +1,126 @@
+package WayofTime.alchemicalWizardry.common.entity.projectile;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.effect.EntityLightningBolt;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+
+public class LightningBoltProjectile extends EnergyBlastProjectile
+{
+ private boolean causeLightning;
+
+ public LightningBoltProjectile(World par1World)
+ {
+ super(par1World);
+ }
+
+ public LightningBoltProjectile(World par1World, double par2, double par4, double par6)
+ {
+ super(par1World, par2, par4, par6);
+ }
+
+ public LightningBoltProjectile(World par1World, EntityLivingBase par2EntityPlayer, int damage, boolean flag)
+ {
+ super(par1World, par2EntityPlayer, damage);
+ causeLightning = flag;
+ }
+
+ public LightningBoltProjectile(World par1World, EntityLivingBase par2EntityPlayer, int damage, int maxTicksInAir, double posX, double posY, double posZ, float rotationYaw, float rotationPitch, boolean flag)
+ {
+ super(par1World, par2EntityPlayer, damage, maxTicksInAir, posX, posY, posZ, rotationYaw, rotationPitch);
+ causeLightning = flag;
+ }
+
+ @Override
+ public DamageSource getDamageSource()
+ {
+ return DamageSource.causeMobDamage(shootingEntity);
+ }
+
+ @Override
+ public void onImpact(MovingObjectPosition mop)
+ {
+ if (mop.typeOfHit == MovingObjectPosition.MovingObjectType.ENTITY && mop.entityHit != null)
+ {
+ if (mop.entityHit == shootingEntity)
+ {
+ return;
+ }
+
+ this.onImpact(mop.entityHit);
+ } else if (mop.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK)
+ {
+ if (causeLightning)
+ {
+ this.worldObj.addWeatherEffect(new EntityLightningBolt(this.worldObj, this.posX, this.posY, this.posZ));
+ }
+ }
+
+ this.setDead();
+ }
+
+ @Override
+ public void onImpact(Entity mop)
+ {
+ if (mop == shootingEntity && ticksInAir > 3)
+ {
+ //shootingEntity.attackEntityFrom(DamageSource.causePlayerDamage(shootingEntity), 1);
+ this.setDead();
+ } else
+ {
+ //doDamage(8 + d6(), mop);
+ if (mop instanceof EntityLivingBase)
+ {
+ //((EntityLivingBase)mop).addPotionEffect(new PotionEffect(Potion.weakness.id, 60,2));
+ //((EntityLivingBase)mop).setFire(50);
+ //((EntityLivingBase)mop).setRevengeTarget(shootingEntity);
+// if(((EntityLivingBase)mop).isEntityUndead())
+// {
+// doDamage((int)(projectileDamage*2),mop);
+// }else
+// {
+// doDamage(projectileDamage, mop);
+// }
+ if (causeLightning)
+ {
+ this.worldObj.addWeatherEffect(new EntityLightningBolt(this.worldObj, ((EntityLivingBase) mop).posX, ((EntityLivingBase) mop).posY, ((EntityLivingBase) mop).posZ));
+ } else
+ {
+ doDamage(projectileDamage, mop);
+ }
+
+ //((EntityLivingBase)mop).setVelocity(this.motionX*2, ((EntityLivingBase)mop).motionY+1.5, this.motionZ*2);
+ }
+
+ //worldObj.createExplosion(this, this.posX, this.posY, this.posZ, (float)(0.1), true);
+ }
+
+ spawnHitParticles("magicCrit", 8);
+ this.setDead();
+ }
+
+ @Override
+ public void doFiringParticles()
+ {
+ SpellHelper.sendParticleToAllAround(worldObj, posX, posY, posZ, 30, worldObj.provider.dimensionId, "mobSpellAmbient", posX + smallGauss(0.1D), posY + smallGauss(0.1D), posZ + smallGauss(0.1D), 0.5D, 0.5D, 0.5D);
+ SpellHelper.sendParticleToAllAround(worldObj, posX, posY, posZ, 30, worldObj.provider.dimensionId, "mobSpell", posX, posY, posZ, 1.0F, 1.0F, 1.0F);
+ }
+
+ @Override
+ public void writeEntityToNBT(NBTTagCompound par1NBTTagCompound)
+ {
+ super.writeEntityToNBT(par1NBTTagCompound);
+ par1NBTTagCompound.setBoolean("causeLightning", causeLightning);
+ }
+
+ @Override
+ public void readEntityFromNBT(NBTTagCompound par1NBTTagCompound)
+ {
+ super.readEntityFromNBT(par1NBTTagCompound);
+ causeLightning = par1NBTTagCompound.getBoolean("causeLightning");
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/MudProjectile.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/MudProjectile.java
new file mode 100644
index 00000000..2c944959
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/MudProjectile.java
@@ -0,0 +1,131 @@
+package WayofTime.alchemicalWizardry.common.entity.projectile;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.potion.Potion;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.common.PacketHandler;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+
+public class MudProjectile extends EnergyBlastProjectile
+{
+ private boolean doesBlindness; //True for when it applies blindness, false for slowness
+
+ public MudProjectile(World par1World)
+ {
+ super(par1World);
+ }
+
+ public MudProjectile(World par1World, double par2, double par4, double par6)
+ {
+ super(par1World, par2, par4, par6);
+ }
+
+ public MudProjectile(World par1World, EntityLivingBase par2EntityPlayer, int damage, boolean flag)
+ {
+ super(par1World, par2EntityPlayer, damage);
+ doesBlindness = flag;
+ }
+
+ public MudProjectile(World par1World, EntityLivingBase par2EntityPlayer, int damage, int maxTicksInAir, double posX, double posY, double posZ, float rotationYaw, float rotationPitch, boolean flag)
+ {
+ super(par1World, par2EntityPlayer, damage, maxTicksInAir, posX, posY, posZ, rotationYaw, rotationPitch);
+ doesBlindness = flag;
+ }
+
+ public MudProjectile(World par1World, EntityLivingBase par2EntityLivingBase, EntityLivingBase par3EntityLivingBase, float par4, float par5, int damage, int maxTicksInAir, boolean flag)
+ {
+ super(par1World, par2EntityLivingBase, par3EntityLivingBase, par4, par5, damage, maxTicksInAir);
+ doesBlindness = flag;
+ }
+
+ @Override
+ public DamageSource getDamageSource()
+ {
+ return DamageSource.causeMobDamage(shootingEntity);
+ }
+
+ @Override
+ public void onImpact(MovingObjectPosition mop)
+ {
+ if (mop.typeOfHit == MovingObjectPosition.MovingObjectType.ENTITY && mop.entityHit != null)
+ {
+ if (mop.entityHit == shootingEntity)
+ {
+ return;
+ }
+
+ this.onImpact(mop.entityHit);
+ } else if (mop.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK)
+ {
+ }
+
+ this.setDead();
+ }
+
+ @Override
+ public void onImpact(Entity mop)
+ {
+ if (mop == shootingEntity && ticksInAir > 3)
+ {
+ //shootingEntity.attackEntityFrom(DamageSource.causePlayerDamage(shootingEntity), 1);
+ this.setDead();
+ } else
+ {
+ //doDamage(8 + d6(), mop);
+ if (mop instanceof EntityLivingBase)
+ {
+ //((EntityLivingBase)mop).addPotionEffect(new PotionEffect(Potion.weakness.id, 60,2));
+ //((EntityLivingBase)mop).setFire(50);
+ //((EntityLivingBase)mop).setRevengeTarget(shootingEntity);
+// if(((EntityLivingBase)mop).isEntityUndead())
+// {
+// doDamage((int)(projectileDamage*2),mop);
+// }else
+// {
+// doDamage(projectileDamage, mop);
+// }
+ if (doesBlindness)
+ {
+ ((EntityLivingBase) mop).addPotionEffect(new PotionEffect(Potion.blindness.id, 100, 0));
+ } else
+ {
+ ((EntityLivingBase) mop).addPotionEffect(new PotionEffect(Potion.moveSlowdown.id, 100, 2));
+ }
+
+ doDamage(projectileDamage, mop);
+ //((EntityLivingBase)mop).setVelocity(this.motionX*2, ((EntityLivingBase)mop).motionY+1.5, this.motionZ*2);
+ }
+
+ //worldObj.createExplosion(this, this.posX, this.posY, this.posZ, (float)(0.1), true);
+ }
+
+ spawnHitParticles("magicCrit", 8);
+ this.setDead();
+ }
+
+ @Override
+ public void doFiringParticles()
+ {
+ SpellHelper.sendParticleToAllAround(worldObj, posX, posY, posZ, 30, worldObj.provider.dimensionId, "mobSpellAmbient", posX + smallGauss(0.1D), posY + smallGauss(0.1D), posZ + smallGauss(0.1D), 0.5D, 0.5D, 0.5D);
+ SpellHelper.sendParticleToAllAround(worldObj, posX, posY, posZ, 30, worldObj.provider.dimensionId, "mobSpell", posX, posY, posZ, 0.5F, 0.297F, 0.0664F);
+ }
+
+ @Override
+ public void writeEntityToNBT(NBTTagCompound par1NBTTagCompound)
+ {
+ super.writeEntityToNBT(par1NBTTagCompound);
+ par1NBTTagCompound.setBoolean("doesBlindness", doesBlindness);
+ }
+
+ @Override
+ public void readEntityFromNBT(NBTTagCompound par1NBTTagCompound)
+ {
+ super.readEntityFromNBT(par1NBTTagCompound);
+ doesBlindness = par1NBTTagCompound.getBoolean("doesBlindness");
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/TeleportProjectile.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/TeleportProjectile.java
new file mode 100644
index 00000000..c448fadf
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/TeleportProjectile.java
@@ -0,0 +1,205 @@
+package WayofTime.alchemicalWizardry.common.entity.projectile;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.World;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.event.entity.living.EnderTeleportEvent;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+import WayofTime.alchemicalWizardry.common.spell.simple.SpellTeleport;
+
+public class TeleportProjectile extends EnergyBlastProjectile
+{
+ private boolean isEntityTeleport; //True if the entity firing teleports on hit
+
+ public TeleportProjectile(World par1World)
+ {
+ super(par1World);
+ this.motionX *= 3;
+ this.motionY *= 3;
+ this.motionZ *= 3;
+ }
+
+ public TeleportProjectile(World par1World, double par2, double par4, double par6)
+ {
+ super(par1World, par2, par4, par6);
+ this.motionX *= 3;
+ this.motionY *= 3;
+ this.motionZ *= 3;
+ }
+
+ public TeleportProjectile(World par1World, EntityLivingBase par2EntityPlayer, int damage, boolean flag)
+ {
+ super(par1World, par2EntityPlayer, damage);
+ isEntityTeleport = flag;
+ this.motionX *= 3;
+ this.motionY *= 3;
+ this.motionZ *= 3;
+ }
+
+ public TeleportProjectile(World par1World, EntityLivingBase par2EntityPlayer, int damage, int maxTicksInAir, double posX, double posY, double posZ, float rotationYaw, float rotationPitch, boolean flag)
+ {
+ super(par1World, par2EntityPlayer, damage, maxTicksInAir, posX, posY, posZ, rotationYaw, rotationPitch);
+ isEntityTeleport = flag;
+ this.motionX *= 3;
+ this.motionY *= 3;
+ this.motionZ *= 3;
+ }
+
+ @Override
+ public DamageSource getDamageSource()
+ {
+ return DamageSource.causeMobDamage(shootingEntity);
+ }
+
+ @Override
+ public void onImpact(MovingObjectPosition mop)
+ {
+ if (mop.typeOfHit == MovingObjectPosition.MovingObjectType.ENTITY && mop.entityHit != null)
+ {
+ if (mop.entityHit == shootingEntity)
+ {
+ return;
+ }
+
+ this.onImpact(mop.entityHit);
+ } else if (mop.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK)
+ {
+ if (isEntityTeleport)
+ {
+ if (shootingEntity != null && shootingEntity instanceof EntityPlayerMP)
+ {
+ EntityPlayerMP entityplayermp = (EntityPlayerMP) shootingEntity;
+
+ if(entityplayermp.worldObj == this.worldObj)
+ //if (!entityplayermp.playerNetServerHandler.connectionClosed && entityplayermp.worldObj == this.worldObj)
+ {
+ EnderTeleportEvent event = new EnderTeleportEvent(entityplayermp, this.posX, this.posY, this.posZ, 5.0F);
+
+ if (!MinecraftForge.EVENT_BUS.post(event))
+ {
+ if (shootingEntity.isRiding())
+ {
+ shootingEntity.mountEntity((Entity) null);
+ }
+
+ shootingEntity.setPositionAndUpdate(event.targetX, event.targetY, event.targetZ);
+// this.getThrower().fallDistance = 0.0F;
+// this.getThrower().attackEntityFrom(DamageSource.fall, event.attackDamage);
+ }
+ }
+ }
+ }
+ }
+
+ this.setDead();
+ }
+
+ @Override
+ public void onImpact(Entity mop)
+ {
+ if (mop == shootingEntity && ticksInAir > 3)
+ {
+ //shootingEntity.attackEntityFrom(DamageSource.causePlayerDamage(shootingEntity), 1);
+ this.setDead();
+ } else
+ {
+ //doDamage(8 + d6(), mop);
+ if (mop instanceof EntityLivingBase)
+ {
+ //((EntityLivingBase)mop).addPotionEffect(new PotionEffect(Potion.weakness.id, 60,2));
+ //((EntityLivingBase)mop).setFire(50);
+ //((EntityLivingBase)mop).setRevengeTarget(shootingEntity);
+// if(((EntityLivingBase)mop).isEntityUndead())
+// {
+// doDamage((int)(projectileDamage*2),mop);
+// }else
+// {
+// doDamage(projectileDamage, mop);
+// }
+ if (isEntityTeleport)
+ {
+ if (shootingEntity != null && shootingEntity instanceof EntityPlayerMP)
+ {
+ EntityPlayerMP entityplayermp = (EntityPlayerMP) shootingEntity;
+
+ if(entityplayermp.worldObj == this.worldObj)
+ //if (!entityplayermp.playerNetServerHandler.connectionClosed && entityplayermp.worldObj == this.worldObj)
+ {
+ EnderTeleportEvent event = new EnderTeleportEvent(entityplayermp, this.posX, this.posY, this.posZ, 5.0F);
+
+ if (!MinecraftForge.EVENT_BUS.post(event))
+ {
+ if (shootingEntity.isRiding())
+ {
+ shootingEntity.mountEntity((Entity) null);
+ }
+
+ shootingEntity.setPositionAndUpdate(event.targetX, event.targetY, event.targetZ);
+// this.getThrower().fallDistance = 0.0F;
+// this.getThrower().attackEntityFrom(DamageSource.fall, event.attackDamage);
+ }
+ }
+ }
+ } else
+ {
+// int x = (int)this.posX + mop.worldObj.rand.nextInt(100) - mop.worldObj.rand.nextInt(100);
+// int y = (int)this.posY + mop.worldObj.rand.nextInt(10) - mop.worldObj.rand.nextInt(10);
+// int z = (int)this.posZ + mop.worldObj.rand.nextInt(100) - mop.worldObj.rand.nextInt(100);
+//
+// boolean bool = false;
+// int i = 0;
+//
+// while(!bool&&i<100)
+// {
+// if(worldObj.isAirBlock(x, y, z)||worldObj.isAirBlock(x, y+1, z))
+// {
+// ((EntityLivingBase) mop).setPositionAndUpdate(x, y, z);
+// bool=true;
+// }else
+// {
+// x = (int)this.posX + mop.worldObj.rand.nextInt(100) - mop.worldObj.rand.nextInt(100);
+// y = (int)this.posY + mop.worldObj.rand.nextInt(10) - mop.worldObj.rand.nextInt(10);
+// z = (int)this.posZ + mop.worldObj.rand.nextInt(100) - mop.worldObj.rand.nextInt(100);
+// i++;
+// }
+// }
+ SpellTeleport.teleportRandomly((EntityLivingBase) mop, 64);
+ }
+
+ //doDamage(projectileDamage, mop);
+ //((EntityLivingBase)mop).setVelocity(this.motionX*2, ((EntityLivingBase)mop).motionY+1.5, this.motionZ*2);
+ }
+
+ //worldObj.createExplosion(this, this.posX, this.posY, this.posZ, (float)(0.1), true);
+ }
+
+ spawnHitParticles("magicCrit", 8);
+ this.setDead();
+ }
+
+ @Override
+ public void doFiringParticles()
+ {
+ SpellHelper.sendParticleToAllAround(worldObj, posX, posY, posZ, 30, worldObj.provider.dimensionId, "mobSpellAmbient", posX + smallGauss(0.1D), posY + smallGauss(0.1D), posZ + smallGauss(0.1D), 0.5D, 0.5D, 0.5D);
+ SpellHelper.sendParticleToAllAround(worldObj, posX, posY, posZ, 30, worldObj.provider.dimensionId, "portal", posX, posY, posZ, -motionX, -motionY, -motionZ);
+ }
+
+ @Override
+ public void writeEntityToNBT(NBTTagCompound par1NBTTagCompound)
+ {
+ super.writeEntityToNBT(par1NBTTagCompound);
+ par1NBTTagCompound.setBoolean("isEntityTeleport", isEntityTeleport);
+ }
+
+ @Override
+ public void readEntityFromNBT(NBTTagCompound par1NBTTagCompound)
+ {
+ super.readEntityFromNBT(par1NBTTagCompound);
+ isEntityTeleport = par1NBTTagCompound.getBoolean("isEntityTeleport");
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/WaterProjectile.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/WaterProjectile.java
new file mode 100644
index 00000000..8fa7704c
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/WaterProjectile.java
@@ -0,0 +1,107 @@
+package WayofTime.alchemicalWizardry.common.entity.projectile;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.common.PacketHandler;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+
+public class WaterProjectile extends EnergyBlastProjectile
+{
+ public WaterProjectile(World par1World)
+ {
+ super(par1World);
+ }
+
+ public WaterProjectile(World par1World, double par2, double par4, double par6)
+ {
+ super(par1World, par2, par4, par6);
+ }
+
+ public WaterProjectile(World par1World, EntityLivingBase par2EntityPlayer, int damage)
+ {
+ super(par1World, par2EntityPlayer, damage);
+ }
+
+ public WaterProjectile(World par1World, EntityLivingBase par2EntityPlayer, int damage, int maxTicksInAir, double posX, double posY, double posZ, float rotationYaw, float rotationPitch)
+ {
+ super(par1World, par2EntityPlayer, damage, maxTicksInAir, posX, posY, posZ, rotationYaw, rotationPitch);
+ }
+
+ @Override
+ public DamageSource getDamageSource()
+ {
+ return DamageSource.causeMobDamage(shootingEntity);
+ }
+
+ @Override
+ public void onImpact(MovingObjectPosition mop)
+ {
+ if (mop.typeOfHit == MovingObjectPosition.MovingObjectType.ENTITY && mop.entityHit != null)
+ {
+ if (mop.entityHit == shootingEntity)
+ {
+ return;
+ }
+
+ this.onImpact(mop.entityHit);
+ } else if (mop.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK)
+ {
+ }
+
+ this.setDead();
+ }
+
+ @Override
+ public void onImpact(Entity mop)
+ {
+ if (mop == shootingEntity && ticksInAir > 3)
+ {
+ //shootingEntity.attackEntityFrom(DamageSource.causePlayerDamage(shootingEntity), 1);
+ this.setDead();
+ } else
+ {
+ //doDamage(8 + d6(), mop);
+ if (mop instanceof EntityLivingBase)
+ {
+ //((EntityLivingBase)mop).addPotionEffect(new PotionEffect(Potion.weakness.id, 60,2));
+ //((EntityLivingBase)mop).setFire(50);
+ //((EntityLivingBase)mop).setRevengeTarget(shootingEntity);
+// if(((EntityLivingBase)mop).isEntityUndead())
+// {
+// doDamage((int)(projectileDamage*2),mop);
+// }else
+// {
+// doDamage(projectileDamage, mop);
+// }
+ if (((EntityLivingBase) mop).isImmuneToFire())
+ {
+ doDamage(projectileDamage * 2, mop);
+ ((EntityLivingBase) mop).addPotionEffect(new PotionEffect(AlchemicalWizardry.customPotionDrowning.id, 80, 1));
+ } else
+ {
+ doDamage(projectileDamage, mop);
+ ((EntityLivingBase) mop).addPotionEffect(new PotionEffect(AlchemicalWizardry.customPotionDrowning.id, 80, 0));
+ }
+
+ //((EntityLivingBase)mop).setVelocity(this.motionX*2, ((EntityLivingBase)mop).motionY+1.5, this.motionZ*2);
+ }
+
+ //worldObj.createExplosion(this, this.posX, this.posY, this.posZ, (float)(0.1), true);
+ }
+
+ spawnHitParticles("magicCrit", 8);
+ this.setDead();
+ }
+
+ @Override
+ public void doFiringParticles()
+ {
+ SpellHelper.sendParticleToAllAround(worldObj, posX, posY, posZ, 30, worldObj.provider.dimensionId, "portal", posX, posY, posZ, -motionX, -motionY, -motionZ);
+ SpellHelper.sendParticleToAllAround(worldObj, posX, posY, posZ, 30, worldObj.provider.dimensionId, "mobSpellAmbient", posX + smallGauss(0.1D), posY + smallGauss(0.1D), posZ + smallGauss(0.1D), 0.5D, 0.5D, 0.5D);
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/WindGustProjectile.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/WindGustProjectile.java
new file mode 100644
index 00000000..46fa01d7
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/entity/projectile/WindGustProjectile.java
@@ -0,0 +1,110 @@
+package WayofTime.alchemicalWizardry.common.entity.projectile;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+
+public class WindGustProjectile extends EnergyBlastProjectile
+{
+ public WindGustProjectile(World par1World)
+ {
+ super(par1World);
+ }
+
+ public WindGustProjectile(World par1World, double par2, double par4, double par6)
+ {
+ super(par1World, par2, par4, par6);
+ }
+
+ public WindGustProjectile(World par1World, EntityLivingBase par2EntityPlayer, int damage)
+ {
+ super(par1World, par2EntityPlayer, damage);
+ }
+
+ public WindGustProjectile(World par1World, EntityLivingBase par2EntityPlayer, int damage, int maxTicksInAir, double posX, double posY, double posZ, float rotationYaw, float rotationPitch)
+ {
+ super(par1World, par2EntityPlayer, damage, maxTicksInAir, posX, posY, posZ, rotationYaw, rotationPitch);
+ }
+
+ @Override
+ public DamageSource getDamageSource()
+ {
+ return DamageSource.causeMobDamage(shootingEntity);
+ }
+
+ @Override
+ public void onImpact(MovingObjectPosition mop)
+ {
+ if (mop.typeOfHit == MovingObjectPosition.MovingObjectType.ENTITY && mop.entityHit != null)
+ {
+ if (mop.entityHit == shootingEntity)
+ {
+ return;
+ }
+
+ this.onImpact(mop.entityHit);
+ } else if (mop.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK)
+ {
+// for(int i=-1;i<=1;i++)
+// {
+// for(int j=-1;j<=1;j++)
+// {
+// for(int k=-1;k<=1;k++)
+// {
+// if(worldObj.isAirBlock((int)this.posX+i, (int)this.posY+j, (int)this.posZ+k))
+// {
+// worldObj.setBlock( (int)this.posX+i, (int)this.posY+j, (int)this.posZ+k,Block.fire.blockID);
+// }
+// }
+// }
+// }
+ }
+
+ this.setDead();
+ }
+
+ @Override
+ public void onImpact(Entity mop)
+ {
+ if (mop == shootingEntity && ticksInAir > 3)
+ {
+ //shootingEntity.attackEntityFrom(DamageSource.causePlayerDamage(shootingEntity), 1);
+ this.setDead();
+ } else
+ {
+ //doDamage(8 + d6(), mop);
+ if (mop instanceof EntityLivingBase)
+ {
+ //((EntityLivingBase)mop).addPotionEffect(new PotionEffect(Potion.weakness.id, 60,2));
+ //((EntityLivingBase)mop).setFire(50);
+ //((EntityLivingBase)mop).setRevengeTarget(shootingEntity);
+// if(((EntityLivingBase)mop).isEntityUndead())
+// {
+// doDamage((int)(projectileDamage*2),mop);
+// }else
+// {
+// doDamage(projectileDamage, mop);
+// }
+ ((EntityLivingBase) mop).motionX = this.motionX * 2;
+ ((EntityLivingBase) mop).motionY = 1.5;
+ ((EntityLivingBase) mop).motionZ = this.motionZ * 2;
+ //((EntityLivingBase)mop).setVelocity(this.motionX*2, ((EntityLivingBase)mop).motionY+1.5, this.motionZ*2);
+ }
+
+ //worldObj.createExplosion(this, this.posX, this.posY, this.posZ, (float)(0.1), true);
+ }
+
+ spawnHitParticles("magicCrit", 8);
+ this.setDead();
+ }
+
+ @Override
+ public void doFiringParticles()
+ {
+ SpellHelper.sendParticleToAllAround(worldObj, posX, posY, posZ, 30, worldObj.provider.dimensionId, "mobSpellAmbient", posX + smallGauss(0.1D), posY + smallGauss(0.1D), posZ + smallGauss(0.1D), 0.5D, 0.5D, 0.5D);
+ SpellHelper.sendParticleToAllAround(worldObj, posX, posY, posZ, 30, worldObj.provider.dimensionId, "mobSpell", posX, posY, posZ, 1.0F, 1.0F, 1.0F);
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/harvest/BloodMagicHarvestHandler.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/harvest/BloodMagicHarvestHandler.java
new file mode 100644
index 00000000..fdf6e3c8
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/harvest/BloodMagicHarvestHandler.java
@@ -0,0 +1,129 @@
+package WayofTime.alchemicalWizardry.common.harvest;
+
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.init.Blocks;
+import net.minecraft.init.Items;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import net.minecraftforge.common.IPlantable;
+import WayofTime.alchemicalWizardry.api.harvest.IHarvestHandler;
+
+public class BloodMagicHarvestHandler implements IHarvestHandler
+{
+ public boolean canHandleBlock(Block block)
+ {
+ return block == Blocks.wheat || block == Blocks.carrots || block == Blocks.potatoes || block == Blocks.nether_wart;
+ }
+
+ public int getHarvestMeta(Block block)
+ {
+ if(block == Blocks.wheat)
+ {
+ return 7;
+ }
+ if(block == Blocks.carrots)
+ {
+ return 7;
+ }
+ if(block == Blocks.potatoes)
+ {
+ return 7;
+ }
+ if(block == Blocks.nether_wart)
+ {
+ return 3;
+ }
+ return 7;
+ }
+
+ @Override
+ public boolean harvestAndPlant(World world, int xCoord, int yCoord, int zCoord, Block block, int meta)
+ {
+ if(!this.canHandleBlock(block) || meta != this.getHarvestMeta(block))
+ {
+ return false;
+ }
+
+ IPlantable seed = this.getSeedItem(block);
+
+ if(seed == null)
+ {
+ return false;
+ }
+
+ int fortune = 0;
+
+ List list = block.getDrops(world, xCoord, yCoord, zCoord, meta, fortune);
+ boolean foundAndRemovedSeed = false;
+
+ for(ItemStack stack : list)
+ {
+ if(stack == null)
+ {
+ continue;
+ }
+
+ Item item = stack.getItem();
+ if(item == seed)
+ {
+ int itemSize = stack.stackSize;
+ if(itemSize > 1)
+ {
+ stack.stackSize--;
+ foundAndRemovedSeed = true;
+ break;
+ }else if(itemSize == 1)
+ {
+ list.remove(stack);
+ foundAndRemovedSeed = true;
+ break;
+ }
+ }
+ }
+
+ if(foundAndRemovedSeed)
+ {
+ int plantMeta = seed.getPlantMetadata(world, xCoord, yCoord, zCoord);
+ Block plantBlock = seed.getPlant(world, xCoord, yCoord, zCoord);
+
+ world.func_147480_a(xCoord, yCoord, zCoord, false);
+
+ world.setBlock(xCoord, yCoord, zCoord, plantBlock, plantMeta, 3);
+
+ for(ItemStack stack : list)
+ {
+ EntityItem itemEnt = new EntityItem(world, xCoord, yCoord, zCoord, stack);
+
+ world.spawnEntityInWorld(itemEnt);
+ }
+ }
+
+ return false;
+ }
+
+ public IPlantable getSeedItem(Block block)
+ {
+ if(block == Blocks.wheat)
+ {
+ return (IPlantable) Items.wheat_seeds;
+ }
+ if(block == Blocks.carrots)
+ {
+ return (IPlantable) Items.carrot;
+ }
+ if(block == Blocks.potatoes)
+ {
+ return (IPlantable) Items.potato;
+ }
+ if(block == Blocks.nether_wart)
+ {
+ return (IPlantable) Items.nether_wart;
+ }
+
+ return null;
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/harvest/CactusReedHarvestHandler.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/harvest/CactusReedHarvestHandler.java
new file mode 100644
index 00000000..e80e3e4f
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/harvest/CactusReedHarvestHandler.java
@@ -0,0 +1,39 @@
+package WayofTime.alchemicalWizardry.common.harvest;
+
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.init.Blocks;
+import net.minecraft.init.Items;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import net.minecraftforge.common.IPlantable;
+import WayofTime.alchemicalWizardry.api.harvest.IHarvestHandler;
+
+public class CactusReedHarvestHandler implements IHarvestHandler
+{
+ public boolean canHandleBlock(Block block)
+ {
+ return block == Blocks.reeds || block == Blocks.cactus;
+ }
+
+ @Override
+ public boolean harvestAndPlant(World world, int xCoord, int yCoord, int zCoord, Block block, int meta)
+ {
+ if(!this.canHandleBlock(block))
+ {
+ return false;
+ }
+
+ if(world.getBlock(xCoord, yCoord-1, zCoord) != block || world.getBlock(xCoord, yCoord-2, zCoord) != block)
+ {
+ return false;
+ }
+
+ world.func_147480_a(xCoord, yCoord, zCoord, true);
+
+ return true;
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/harvest/GenericPamSeedlessFruitHarvestHandler.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/harvest/GenericPamSeedlessFruitHarvestHandler.java
new file mode 100644
index 00000000..42fa189c
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/harvest/GenericPamSeedlessFruitHarvestHandler.java
@@ -0,0 +1,74 @@
+package WayofTime.alchemicalWizardry.common.harvest;
+
+import java.util.List;
+
+import cpw.mods.fml.common.registry.GameRegistry;
+import net.minecraft.block.Block;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.init.Blocks;
+import net.minecraft.init.Items;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import net.minecraftforge.common.IPlantable;
+import WayofTime.alchemicalWizardry.api.harvest.IHarvestHandler;
+
+public class GenericPamSeedlessFruitHarvestHandler implements IHarvestHandler
+{
+ public Block harvestBlock;
+ public int harvestMeta;
+ public int resetMeta;
+
+ public GenericPamSeedlessFruitHarvestHandler(String block, int harvestMeta, int resetMeta)
+ {
+ this.harvestBlock = getBlockForString(block);
+ this.harvestMeta = harvestMeta;
+ this.resetMeta = resetMeta;
+ }
+
+ public boolean isHarvesterValid()
+ {
+ return harvestBlock != null;
+ }
+
+ public static Block getBlockForString(String str)
+ {
+ String[] parts = str.split(":");
+ String modId = parts[0];
+ String name = parts[1];
+ return GameRegistry.findBlock(modId, name);
+ }
+
+ public static Item getItemForString(String str)
+ {
+ String[] parts = str.split(":");
+ String modId = parts[0];
+ String name = parts[1];
+ return GameRegistry.findItem(modId, name);
+ }
+
+ public boolean canHandleBlock(Block block)
+ {
+ return block == harvestBlock;
+ }
+
+ public int getHarvestMeta(Block block)
+ {
+ return harvestMeta;
+ }
+
+ @Override
+ public boolean harvestAndPlant(World world, int xCoord, int yCoord, int zCoord, Block block, int meta)
+ {
+ if(!this.canHandleBlock(block) || meta != this.getHarvestMeta(block))
+ {
+ return false;
+ }
+
+ world.func_147480_a(xCoord, yCoord, zCoord, true);
+
+ world.setBlock(xCoord, yCoord, zCoord, harvestBlock, resetMeta, 3);
+
+ return true;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/harvest/GenericSeededHarvestHandler.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/harvest/GenericSeededHarvestHandler.java
new file mode 100644
index 00000000..daea729c
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/harvest/GenericSeededHarvestHandler.java
@@ -0,0 +1,139 @@
+package WayofTime.alchemicalWizardry.common.harvest;
+
+import java.util.List;
+
+import cpw.mods.fml.common.registry.GameRegistry;
+import net.minecraft.block.Block;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.init.Blocks;
+import net.minecraft.init.Items;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import net.minecraftforge.common.IPlantable;
+import WayofTime.alchemicalWizardry.api.harvest.IHarvestHandler;
+
+public class GenericSeededHarvestHandler implements IHarvestHandler
+{
+ public Block harvestBlock;
+ public int harvestMeta;
+ public IPlantable harvestSeed;
+
+ public GenericSeededHarvestHandler(String block, int meta, String seed)
+ {
+ harvestBlock = getBlockForString(block);
+ harvestMeta = meta;
+ Item testSeed = getItemForString(seed);
+ if(testSeed instanceof IPlantable)
+ {
+ harvestSeed = (IPlantable)testSeed;
+ }else
+ {
+ harvestSeed = null;
+ }
+ }
+
+ public boolean isHarvesterValid()
+ {
+ return harvestBlock != null && harvestSeed != null;
+ }
+
+ public static Block getBlockForString(String str)
+ {
+ String[] parts = str.split(":");
+ String modId = parts[0];
+ String name = parts[1];
+ return GameRegistry.findBlock(modId, name);
+ }
+
+ public static Item getItemForString(String str)
+ {
+ String[] parts = str.split(":");
+ String modId = parts[0];
+ String name = parts[1];
+ return GameRegistry.findItem(modId, name);
+ }
+
+ public boolean canHandleBlock(Block block)
+ {
+ return block == harvestBlock;
+ }
+
+ public int getHarvestMeta(Block block)
+ {
+ return harvestMeta;
+ }
+
+ @Override
+ public boolean harvestAndPlant(World world, int xCoord, int yCoord, int zCoord, Block block, int meta)
+ {
+ if(!this.canHandleBlock(block) || meta != this.getHarvestMeta(block))
+ {
+ return false;
+ }
+
+ IPlantable seed = this.getSeedItem(block);
+
+ if(seed == null)
+ {
+ world.func_147480_a(xCoord, yCoord, zCoord, true);
+
+ return true;
+ }else
+ {
+ int fortune = 0;
+
+ List list = block.getDrops(world, xCoord, yCoord, zCoord, meta, fortune);
+ boolean foundAndRemovedSeed = false;
+
+ for(ItemStack stack : list)
+ {
+ if(stack == null)
+ {
+ continue;
+ }
+
+ Item item = stack.getItem();
+ if(item == seed)
+ {
+ int itemSize = stack.stackSize;
+ if(itemSize > 1)
+ {
+ stack.stackSize--;
+ foundAndRemovedSeed = true;
+ break;
+ }else if(itemSize == 1)
+ {
+ list.remove(stack);
+ foundAndRemovedSeed = true;
+ break;
+ }
+ }
+ }
+
+ if(foundAndRemovedSeed)
+ {
+ int plantMeta = seed.getPlantMetadata(world, xCoord, yCoord, zCoord);
+ Block plantBlock = seed.getPlant(world, xCoord, yCoord, zCoord);
+
+ world.func_147480_a(xCoord, yCoord, zCoord, false);
+
+ world.setBlock(xCoord, yCoord, zCoord, plantBlock, plantMeta, 3);
+
+ for(ItemStack stack : list)
+ {
+ EntityItem itemEnt = new EntityItem(world, xCoord, yCoord, zCoord, stack);
+
+ world.spawnEntityInWorld(itemEnt);
+ }
+ }
+
+ return false;
+ }
+ }
+
+ public IPlantable getSeedItem(Block block)
+ {
+ return harvestSeed;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/harvest/GourdHarvestHandler.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/harvest/GourdHarvestHandler.java
new file mode 100644
index 00000000..4ea2b7dc
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/harvest/GourdHarvestHandler.java
@@ -0,0 +1,34 @@
+package WayofTime.alchemicalWizardry.common.harvest;
+
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.init.Blocks;
+import net.minecraft.init.Items;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import net.minecraftforge.common.IPlantable;
+import WayofTime.alchemicalWizardry.api.harvest.IHarvestHandler;
+
+public class GourdHarvestHandler implements IHarvestHandler
+{
+ public boolean canHandleBlock(Block block)
+ {
+ return block == Blocks.melon_block || block == Blocks.pumpkin;
+ }
+
+ @Override
+ public boolean harvestAndPlant(World world, int xCoord, int yCoord, int zCoord, Block block, int meta)
+ {
+ if(!this.canHandleBlock(block))
+ {
+ return false;
+ }
+
+ world.func_147480_a(xCoord, yCoord, zCoord, true);
+
+ return true;
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/harvest/PamHarvestCompatRegistry.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/harvest/PamHarvestCompatRegistry.java
new file mode 100644
index 00000000..feff8da5
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/harvest/PamHarvestCompatRegistry.java
@@ -0,0 +1,125 @@
+package WayofTime.alchemicalWizardry.common.harvest;
+
+import WayofTime.alchemicalWizardry.api.harvest.HarvestRegistry;
+
+public class PamHarvestCompatRegistry
+{
+ public static void registerPamHandlers()
+ {
+ registerSeededHandler("blackberry", 7);
+ registerSeededHandler("blueberry", 7);
+ registerSeededHandler("candleberry", 7);
+ registerSeededHandler("raspberry", 7);
+ registerSeededHandler("strawberry", 7);
+ registerSeededHandler("cactusfruit", 7);
+ registerSeededHandler("asparagus", 7);
+ registerSeededHandler("barley", 7);
+ registerSeededHandler("oats", 7);
+ registerSeededHandler("rye", 7);
+ registerSeededHandler("corn", 7);
+ registerSeededHandler("bambooshoot", 7);
+ registerSeededHandler("cantaloupe", 7);
+ registerSeededHandler("cucumber", 7);
+ registerSeededHandler("windersquash", 7);
+ registerSeededHandler("zucchini", 7);
+ registerSeededHandler("beat", 7);
+ registerSeededHandler("onion", 7);
+ registerSeededHandler("parsnip", 7);
+ registerSeededHandler("peanut", 7);
+ registerSeededHandler("radish", 7);
+ registerSeededHandler("rutabaga", 7);
+ registerSeededHandler("sweetpotato", 7);
+ registerSeededHandler("turnip", 7);
+ registerSeededHandler("rhubarb", 7);
+ registerSeededHandler("celery", 7);
+ registerSeededHandler("garlic", 7);
+ registerSeededHandler("ginger", 7);
+ registerSeededHandler("spiceleaf", 7);
+ registerSeededHandler("tealeaf", 7);
+ registerSeededHandler("coffeebean", 7);
+ registerSeededHandler("mustardseeds", 7);
+ registerSeededHandler("brocolli", 7);
+ registerSeededHandler("cauliflower", 7);
+ registerSeededHandler("leek", 7);
+ registerSeededHandler("lettuce", 7);
+ registerSeededHandler("scallion", 7);
+ registerSeededHandler("artichoke", 7);
+ registerSeededHandler("brusselsprout", 7);
+ registerSeededHandler("cabbage", 7);
+ registerSeededHandler("whitemushroom", 7);
+ registerSeededHandler("bean", 7);
+ registerSeededHandler("soybean", 7);
+ registerSeededHandler("bellpepper", 7);
+ registerSeededHandler("chili", 7);
+ registerSeededHandler("eggplant", 7);
+ registerSeededHandler("pamokra", 7);
+ registerSeededHandler("peas", 7);
+ registerSeededHandler("tomato", 7);
+ registerSeededHandler("cotton", 7);
+ registerSeededHandler("pineapple", 7);
+ registerSeededHandler("grape", 7);
+ registerSeededHandler("kiwi", 7);
+ registerSeededHandler("cranberry", 7);
+ registerSeededHandler("rice", 7);
+ registerSeededHandler("seaweed", 7);
+
+ registerFruitHandler("apple", 7, 0);
+ registerFruitHandler("Almond", 7, 0);
+ registerFruitHandler("Apricot", 7, 0);
+ registerFruitHandler("Avocado", 7, 0);
+ registerFruitHandler("Banana", 7, 0);
+ registerFruitHandler("Cashew", 7, 0);
+ registerFruitHandler("Cherry", 7, 0);
+ registerFruitHandler("Chestnut", 7, 0);
+ registerFruitHandler("Cinnamon", 7, 0);
+ registerFruitHandler("Coconut", 7, 0);
+ registerFruitHandler("Date", 7, 0);
+ registerFruitHandler("Dragonfruit", 7, 0);
+ registerFruitHandler("Durian", 7, 0);
+ registerFruitHandler("Fig", 7, 0);
+ registerFruitHandler("Grapefruit", 7, 0);
+ registerFruitHandler("Lemon", 7, 0);
+ registerFruitHandler("Lime", 7, 0);
+ registerFruitHandler("Maple", 7, 0);
+ registerFruitHandler("Mango", 7, 0);
+ registerFruitHandler("Nutmeg", 7, 0);
+ registerFruitHandler("Olive", 7, 0);
+ registerFruitHandler("Orange", 7, 0);
+ registerFruitHandler("Papaya", 7, 0);
+ registerFruitHandler("Paperbark", 7, 0);
+ registerFruitHandler("Peach", 7, 0);
+ registerFruitHandler("Pear", 7, 0);
+ registerFruitHandler("Pecan", 7, 0);
+ registerFruitHandler("Peppercorn", 7, 0);
+ registerFruitHandler("Persimmon", 7, 0);
+ registerFruitHandler("Pistachio", 7, 0);
+ registerFruitHandler("Plum", 7, 0);
+ registerFruitHandler("Pomegranate", 7, 0);
+ registerFruitHandler("Starfruit", 7, 0);
+ registerFruitHandler("Vanillabean", 7, 0);
+ registerFruitHandler("Walnut", 7, 0);
+ }
+
+ public static void registerSeededHandler(String name, int meta)
+ {
+ String block = "harvestcraft:pam" + name + "Crop";
+ String seed = "harvestcraft:" + name + "Item";
+
+ GenericSeededHarvestHandler handler = new GenericSeededHarvestHandler(block, meta, seed);
+ if(handler.isHarvesterValid())
+ {
+ HarvestRegistry.registerHarvestHandler(handler);
+ }
+ }
+
+ public static void registerFruitHandler(String name, int harvestMeta, int resetMeta)
+ {
+ String block = "harvestcraft:pam" + name;
+
+ GenericPamSeedlessFruitHarvestHandler handler = new GenericPamSeedlessFruitHarvestHandler(block, harvestMeta, resetMeta);
+ if(handler.isHarvesterValid())
+ {
+ HarvestRegistry.registerHarvestHandler(handler);
+ }
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/AWBaseItems.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/AWBaseItems.java
new file mode 100644
index 00000000..dd3e4a69
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/AWBaseItems.java
@@ -0,0 +1,44 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.ModItems;
+
+public class AWBaseItems extends Item
+{
+ public AWBaseItems()
+ {
+ super();
+ setMaxStackSize(64);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ }
+
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ if (this.equals(ModItems.blankSlate))
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:BlankSlate");
+ } else if (this.equals(ModItems.reinforcedSlate))
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:ReinforcedSlate");
+ } else if (this.equals(ModItems.imbuedSlate))
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:InfusedSlate");
+ } else if (this.equals(ModItems.demonicSlate))
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:DemonSlate");
+ }
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Infused stone inside of");
+ par3List.add("a blood altar");
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ActivationCrystal.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ActivationCrystal.java
new file mode 100644
index 00000000..6c6c6fc2
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ActivationCrystal.java
@@ -0,0 +1,135 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import java.util.List;
+
+import javax.swing.Icon;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.MathHelper;
+import net.minecraft.world.World;
+
+import org.lwjgl.input.Keyboard;
+
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.alchemy.AlchemyRecipeRegistry;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class ActivationCrystal extends EnergyItems
+{
+ private static final String[] ACTIVATION_CRYSTAL_NAMES = new String[]{"Weak", "Awakened"};
+
+ @SideOnly(Side.CLIENT)
+ private IIcon[] icons;
+
+ public ActivationCrystal()
+ {
+ super();
+ this.maxStackSize = 1;
+ setEnergyUsed(100);
+ this.setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ this.hasSubtypes = true;
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ icons = new IIcon[ACTIVATION_CRYSTAL_NAMES.length];
+
+ for (int i = 0; i < ACTIVATION_CRYSTAL_NAMES.length; ++i)
+ {
+ icons[i] = iconRegister.registerIcon("AlchemicalWizardry:" + "activationCrystal" + ACTIVATION_CRYSTAL_NAMES[i]);
+ }
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ switch (par1ItemStack.getItemDamage())
+ {
+ case 0:
+ {
+ par3List.add("Activates low-level rituals");
+ break;
+ }
+
+ case 1:
+ {
+ par3List.add("Activates more powerful rituals");
+
+ if (Keyboard.isKeyDown(Keyboard.KEY_RSHIFT) || Keyboard.isKeyDown(Keyboard.KEY_LSHIFT))
+ {
+ ItemStack[] recipe = AlchemyRecipeRegistry.getRecipeForItemStack(par1ItemStack);
+
+ if (recipe != null)
+ {
+ par3List.add(EnumChatFormatting.BLUE + "Recipe:");
+
+ for (ItemStack item : recipe)
+ {
+ if (item != null)
+ {
+ par3List.add("" + item.getDisplayName());
+ }
+ }
+ }
+ } else
+ {
+ par3List.add("-Press " + EnumChatFormatting.BLUE + "shift" + EnumChatFormatting.GRAY + " for Recipe-");
+ }
+
+ break;
+ }
+ }
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+ }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par3EntityPlayer);
+ return par1ItemStack;
+ }
+
+ public int getCrystalLevel(ItemStack itemStack)
+ {
+ return itemStack.getItemDamage() + 1;
+ }
+
+ @Override
+ public String getUnlocalizedName(ItemStack itemStack)
+ {
+ //This is what will do all the localisation things on the alchemy components so you dont have to set it :D
+ int meta = MathHelper.clamp_int(itemStack.getItemDamage(), 0, ACTIVATION_CRYSTAL_NAMES.length - 1);
+ return ("" + "item.activationCrystal" + ACTIVATION_CRYSTAL_NAMES[meta]);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public IIcon getIconFromDamage(int meta)
+ {
+ int j = MathHelper.clamp_int(meta, 0, ACTIVATION_CRYSTAL_NAMES.length - 1);
+ return icons[j];
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void getSubItems(Item id, CreativeTabs creativeTab, List list)
+ {
+ for (int meta = 0; meta < ACTIVATION_CRYSTAL_NAMES.length; ++meta)
+ {
+ list.add(new ItemStack(id, 1, meta));
+ }
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/AirScribeTool.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/AirScribeTool.java
new file mode 100644
index 00000000..9f20b743
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/AirScribeTool.java
@@ -0,0 +1,20 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class AirScribeTool extends ScribeTool
+{
+ public AirScribeTool()
+ {
+ super(4);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:AirScribeTool");
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ApprenticeBloodOrb.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ApprenticeBloodOrb.java
new file mode 100644
index 00000000..3bc4a2eb
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ApprenticeBloodOrb.java
@@ -0,0 +1,21 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class ApprenticeBloodOrb extends EnergyBattery
+{
+ public ApprenticeBloodOrb(int damage)
+ {
+ super(damage);
+ orbLevel = 2;
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:ApprenticeBloodOrb");
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ArchmageBloodOrb.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ArchmageBloodOrb.java
new file mode 100644
index 00000000..6bd83098
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ArchmageBloodOrb.java
@@ -0,0 +1,21 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class ArchmageBloodOrb extends EnergyBattery
+{
+ public ArchmageBloodOrb(int damage)
+ {
+ super(damage);
+ orbLevel = 5;
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:ArchmageBloodOrb");
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ArmourInhibitor.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ArmourInhibitor.java
new file mode 100644
index 00000000..1b42a0de
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ArmourInhibitor.java
@@ -0,0 +1,215 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import java.util.List;
+
+import javax.swing.Icon;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class ArmourInhibitor extends EnergyItems
+{
+ private static IIcon activeIcon;
+ private static IIcon passiveIcon;
+ private int tickDelay = 200;
+
+ public ArmourInhibitor()
+ {
+ super();
+ this.maxStackSize = 1;
+ //setMaxDamage(1000);
+ setEnergyUsed(0);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Used to suppress a soul's");
+ par3List.add("unnatural abilities.");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ if (par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ par3List.add("Activated");
+ } else
+ {
+ par3List.add("Deactivated");
+ }
+
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:ArmourInhibitor_deactivated");
+ this.activeIcon = iconRegister.registerIcon("AlchemicalWizardry:ArmourInhibitor_activated");
+ this.passiveIcon = iconRegister.registerIcon("AlchemicalWizardry:ArmourInhibitor_deactivated");
+ }
+
+ @Override
+ public IIcon getIcon(ItemStack stack, int renderPass, EntityPlayer player, ItemStack usingItem, int useRemaining)
+ {
+ if (stack.stackTagCompound == null)
+ {
+ stack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = stack.stackTagCompound;
+
+ if (tag.getBoolean("isActive"))
+ {
+ return this.activeIcon;
+ } else
+ {
+ return this.passiveIcon;
+ }
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public IIcon getIconFromDamage(int par1)
+ {
+ if (par1 == 1)
+ {
+ return this.activeIcon;
+ } else
+ {
+ return this.passiveIcon;
+ }
+ }
+
+// @Override
+// public boolean onItemUse(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, World par3World, int par4, int par5, int par6, int par7, float par8, float par9, float par10)
+// {
+//
+// if(applyBonemeal(par1ItemStack,par3World,par4,par5,par6,par2EntityPlayer))
+// {
+// if (par3World.isRemote)
+// {
+// par3World.playAuxSFX(2005, par4, par5, par6, 0);
+// EnergyItems.syphonBatteries(par1ItemStack, par2EntityPlayer, getEnergyUsed());
+// return true;
+// }
+// return true;
+// }
+// return false;
+// }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par3EntityPlayer);
+
+ if (par3EntityPlayer.isSneaking())
+ {
+ return par1ItemStack;
+ }
+
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = par1ItemStack.stackTagCompound;
+ tag.setBoolean("isActive", !(tag.getBoolean("isActive")));
+
+ if (tag.getBoolean("isActive"))
+ {
+ par1ItemStack.setItemDamage(1);
+ tag.setInteger("worldTimeDelay", (int) (par2World.getWorldTime() - 1) % tickDelay);
+
+ if (!par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ //EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, getEnergyUsed());
+ }
+ } else
+ {
+ par1ItemStack.setItemDamage(par1ItemStack.getMaxDamage());
+ }
+
+ return par1ItemStack;
+ }
+
+ @Override
+ public void onUpdate(ItemStack par1ItemStack, World par2World, Entity par3Entity, int par4, boolean par5)
+ {
+ if (!(par3Entity instanceof EntityPlayer))
+ {
+ return;
+ }
+
+ EntityPlayer par3EntityPlayer = (EntityPlayer) par3Entity;
+
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ if (par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ if (par2World.getWorldTime() % tickDelay == par1ItemStack.stackTagCompound.getInteger("worldTimeDelay") && par3Entity instanceof EntityPlayer)
+ {
+ //EnergyItems.syphonBatteries(par1ItemStack, (EntityPlayer)par3Entity, getEnergyUsed());
+ }
+
+ //TODO Do stuff
+ par3EntityPlayer.addPotionEffect(new PotionEffect(AlchemicalWizardry.customPotionInhibit.id, 2, 0));
+ }
+
+ return;
+ }
+
+// @Override
+// public void onArmourUpdate(World world, EntityPlayer player, ItemStack thisItemStack) {
+//
+// int range = 5;
+// int verticalRange = 2;
+// int posX = (int)Math.round(player.posX-0.5f);
+// int posY = (int)player.posY;
+// int posZ = (int)Math.round(player.posZ-0.5f);
+//
+// for(int ix=posX-range;ix<=posX+range;ix++)
+// {
+// for(int iz=posZ-range;iz<=posZ+range;iz++)
+// {
+// for(int iy=posY-verticalRange;iy<=posY+verticalRange;iy++)
+// {
+// int id = world.getBlockId(ix, iy, iz);
+// Block block = Block.blocksList[id];
+// if(block instanceof IPlantable)
+// {
+// if(world.rand.nextInt(10)==0)
+// block.updateTick(world, ix, iy, iz, world.rand);
+// }
+// }
+// }
+// }
+//
+// }
+
+// @Override
+// public boolean isUpgrade() {
+// // TODO Auto-generated method stub
+// return true;
+// }
+//
+// @Override
+// public int getEnergyForTenSeconds() {
+// // TODO Auto-generated method stub
+// return 50;
+// }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/BlankSpell.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/BlankSpell.java
new file mode 100644
index 00000000..58c004d3
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/BlankSpell.java
@@ -0,0 +1,114 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+import net.minecraftforge.common.DimensionManager;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEHomHeart;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class BlankSpell extends EnergyItems
+{
+ public BlankSpell()
+ {
+ super();
+ this.setMaxStackSize(1);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:BlankSpell");
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Crystal of infinite possibilities.");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ NBTTagCompound itemTag = par1ItemStack.stackTagCompound;
+
+ if (!par1ItemStack.stackTagCompound.getString("ownerName").equals(""))
+ {
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+
+ par3List.add("Coords: " + itemTag.getInteger("xCoord") + ", " + itemTag.getInteger("yCoord") + ", " + itemTag.getInteger("zCoord"));
+ par3List.add("Bound Dimension: " + getDimensionID(par1ItemStack));
+ }
+ }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par3EntityPlayer);
+
+ if (par3EntityPlayer.isSneaking())
+ {
+ return par1ItemStack;
+ }
+
+ if (!par2World.isRemote)
+ {
+ //World world = MinecraftServer.getServer().worldServers[getDimensionID(par1ItemStack)];
+ World world = DimensionManager.getWorld(getDimensionID(par1ItemStack));
+
+ if (world != null)
+ {
+ NBTTagCompound itemTag = par1ItemStack.stackTagCompound;
+ TileEntity tileEntity = world.getTileEntity(itemTag.getInteger("xCoord"), itemTag.getInteger("yCoord"), itemTag.getInteger("zCoord"));
+
+ if (tileEntity instanceof TEHomHeart)
+ {
+ TEHomHeart homHeart = (TEHomHeart) tileEntity;
+
+ if (homHeart.canCastSpell(par1ItemStack, par2World, par3EntityPlayer))
+ {
+ EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, homHeart.castSpell(par1ItemStack, par2World, par3EntityPlayer));
+ } else
+ {
+ return par1ItemStack;
+ }
+ } else
+ {
+ return par1ItemStack;
+ }
+ } else
+ {
+ return par1ItemStack;
+ }
+ } else
+ {
+ return par1ItemStack;
+ }
+
+ par2World.playSoundAtEntity(par3EntityPlayer, "random.fizz", 0.5F, 0.4F / (itemRand.nextFloat() * 0.4F + 0.8F));
+// if (!par2World.isRemote)
+// {
+// //par2World.spawnEntityInWorld(new EnergyBlastProjectile(par2World, par3EntityPlayer, damage));
+// par2World.spawnEntityInWorld(new FireProjectile(par2World, par3EntityPlayer, 10));
+// }
+ return par1ItemStack;
+ }
+
+ public int getDimensionID(ItemStack itemStack)
+ {
+ if (itemStack.stackTagCompound == null)
+ {
+ itemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ return itemStack.stackTagCompound.getInteger("dimensionId");
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/BloodShard.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/BloodShard.java
new file mode 100644
index 00000000..43b5e5b8
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/BloodShard.java
@@ -0,0 +1,73 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.ModItems;
+import WayofTime.alchemicalWizardry.api.items.interfaces.ArmourUpgrade;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class BloodShard extends Item implements ArmourUpgrade
+{
+ public BloodShard()
+ {
+ super();
+ this.maxStackSize = 64;
+ //setEnergyUsed(100);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ if (this.equals(ModItems.weakBloodShard))
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:WeakBloodShard");
+ return;
+ }
+
+ if (this.equals(ModItems.demonBloodShard))
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:DemonBloodShard");
+ return;
+ }
+ }
+
+ public int getBloodShardLevel()
+ {
+ if (this.equals(ModItems.weakBloodShard))
+ {
+ return 1;
+ } else if (this.equals(ModItems.demonBloodShard))
+ {
+ return 2;
+ }
+
+ return 0;
+ }
+
+ @Override
+ public void onArmourUpdate(World world, EntityPlayer player, ItemStack thisItemStack)
+ {
+ // TODO Auto-generated method stub
+ }
+
+ @Override
+ public boolean isUpgrade()
+ {
+ // TODO Auto-generated method stub
+ return false;
+ }
+
+ @Override
+ public int getEnergyForTenSeconds()
+ {
+ // TODO Auto-generated method stub
+ return 0;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/BloodboundSword.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/BloodboundSword.java
new file mode 100644
index 00000000..07b4ac20
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/BloodboundSword.java
@@ -0,0 +1,103 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class BloodboundSword extends EnergyItems
+{
+ private float weaponDamage;
+ //private int maxMode = 3;
+ private NBTTagCompound data;
+
+ public BloodboundSword(int id)
+ {
+ super();
+ this.maxStackSize = 1;
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ setEnergyUsed(100);
+ setFull3D();
+ weaponDamage = 10.0F;
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:EnergySword");
+ }
+
+ public boolean hitEntity(ItemStack par1ItemStack, EntityLivingBase par2EntityLivingBase, EntityLivingBase par3EntityLivingBase)
+ {
+ if (par3EntityLivingBase instanceof EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, (EntityPlayer) par3EntityLivingBase);
+
+ if (!this.syphonBatteries(par1ItemStack, (EntityPlayer) par3EntityLivingBase, this.getEnergyUsed()))
+ {
+ //this.damagePlayer(null, (EntityPlayer)par3EntityLivingBase, (this.getEnergyUsed() + 99) / 100);
+ }
+ }
+
+ return true;
+ }
+
+ /*
+ public int getDamageVsEntity(Entity par1Entity)
+ {
+ return this.weaponDamage;
+ }
+ */
+
+ public float func_82803_g()
+ {
+ return 4.0F;
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Caution: may cause");
+ par3List.add("a bad day...");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+ }
+
+ @Override
+ public float getDigSpeed(ItemStack par1ItemStack, Block par2Block, int meta)
+ {
+ if (par2Block.equals(Blocks.web))
+ {
+ return 15.0F;
+ } else
+ {
+ Material material = par2Block.getMaterial();
+ return material != Material.plants && material != Material.vine && material != Material.coral && material != Material.leaves && material != Material.gourd ? 1.0F : 1.5F;
+ }
+ }
+
+ public boolean getIsRepairable(ItemStack par1ItemStack, ItemStack par2ItemStack)
+ {
+ return false;
+ }
+
+// public Multimap func_111205_h()
+// {
+// Multimap multimap = super.func_111205_h();
+// multimap.put(SharedMonsterAttributes.field_111264_e.func_111108_a(), new AttributeModifier(field_111210_e, "Weapon modifier", (double)this.weaponDamage, 0));
+// return multimap;
+// }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/BoundArmour.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/BoundArmour.java
new file mode 100644
index 00000000..1baaab9a
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/BoundArmour.java
@@ -0,0 +1,806 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import java.util.List;
+
+import net.minecraft.client.model.ModelBiped;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.EnumAction;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemArmor;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.potion.Potion;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+import net.minecraftforge.common.ISpecialArmor;
+import net.minecraftforge.common.util.Constants;
+import thaumcraft.api.IGoggles;
+import thaumcraft.api.IRunicArmor;
+import thaumcraft.api.nodes.IRevealer;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.ModItems;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.IAlchemyGoggles;
+import WayofTime.alchemicalWizardry.api.items.interfaces.ArmourUpgrade;
+import WayofTime.alchemicalWizardry.api.items.interfaces.IBindable;
+import WayofTime.alchemicalWizardry.common.renderer.model.ModelOmegaArmour;
+import cpw.mods.fml.common.Optional;
+import cpw.mods.fml.common.Optional.Interface;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+@Optional.InterfaceList(value = {@Interface(iface="thaumcraft.api.nodes.IRevealer", modid = "Thaumcraft"), @Interface(iface="thaumcraft.api.IGoggles", modid = "Thaumcraft"), @Interface(iface="thaumcraft.api.IRunicArmor", modid = "Thaumcraft")})
+public class BoundArmour extends ItemArmor implements IAlchemyGoggles,ISpecialArmor,IBindable ,IRevealer, IGoggles, IRunicArmor
+{
+ private static int invSize = 9;
+ private static IIcon helmetIcon;
+ private static IIcon plateIcon;
+ private static IIcon leggingsIcon;
+ private static IIcon bootsIcon;
+
+ private static final boolean tryComplexRendering = true;
+
+ public BoundArmour(int armorType)
+ {
+ super(ItemArmor.ArmorMaterial.GOLD, 0, armorType);
+ setMaxDamage(1000);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ }
+
+ ModelBiped model1 = null;
+ ModelBiped model2 = null;
+ ModelBiped model = null;
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public ModelBiped getArmorModel(EntityLivingBase entityLiving, ItemStack itemStack, int armorSlot)
+ {
+ if(tryComplexRendering)
+ {
+ int type = ((ItemArmor)itemStack.getItem()).armorType;
+ if(this.model1 == null)
+ {
+ this.model1 = new ModelOmegaArmour(1.0f, true, true, false, true);
+ }
+ if(this.model2 == null)
+ {
+ this.model2 = new ModelOmegaArmour(0.5f, false, false, true, false);
+ }
+
+ if(type == 1 || type == 3 || type == 0)
+ {
+ this.model = model1;
+ }else
+ {
+ this.model = model2;
+ }
+
+ if(this.model != null)
+ {
+ this.model.bipedHead.showModel = (type == 0);
+ this.model.bipedHeadwear.showModel = (type == 0);
+ this.model.bipedBody.showModel = ((type == 1) || (type == 2));
+ this.model.bipedLeftArm.showModel = (type == 1);
+ this.model.bipedRightArm.showModel = (type == 1);
+ this.model.bipedLeftLeg.showModel = (type == 2 || type == 3);
+ this.model.bipedRightLeg.showModel = (type == 2 || type == 3);
+ this.model.isSneak = entityLiving.isSneaking();
+
+ this.model.isRiding = entityLiving.isRiding();
+ this.model.isChild = entityLiving.isChild();
+
+ this.model.aimedBow = false;
+ this.model.heldItemRight = (entityLiving.getHeldItem() != null ? 1 : 0);
+
+ if ((entityLiving instanceof EntityPlayer))
+ {
+ if (((EntityPlayer)entityLiving).getItemInUseDuration() > 0)
+ {
+ EnumAction enumaction = ((EntityPlayer)entityLiving).getItemInUse().getItemUseAction();
+ if (enumaction == EnumAction.block)
+ {
+ this.model.heldItemRight = 3;
+ } else if (enumaction == EnumAction.bow)
+ {
+ this.model.aimedBow = true;
+ }
+ }
+ }
+ }
+
+ return model;
+
+ }else
+ {
+ return super.getArmorModel(entityLiving, itemStack, armorSlot);
+ }
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:SheathedItem");
+ this.helmetIcon = iconRegister.registerIcon("AlchemicalWizardry:BoundHelmet");
+ this.plateIcon = iconRegister.registerIcon("AlchemicalWizardry:BoundPlate");
+ this.leggingsIcon = iconRegister.registerIcon("AlchemicalWizardry:BoundLeggings");
+ this.bootsIcon = iconRegister.registerIcon("AlchemicalWizardry:BoundBoots");
+ }
+
+ @SideOnly(Side.CLIENT)
+ public IIcon getIconFromDamage(int par1)
+ {
+ if (this.equals(ModItems.boundHelmet))
+ {
+ return this.helmetIcon;
+ }
+
+ if (this.equals(ModItems.boundPlate))
+ {
+ return this.plateIcon;
+ }
+
+ if (this.equals(ModItems.boundLeggings))
+ {
+ return this.leggingsIcon;
+ }
+
+ if (this.equals(ModItems.boundBoots))
+ {
+ return this.bootsIcon;
+ }
+
+ return this.itemIcon;
+ }
+
+ @Override
+ public boolean getIsRepairable(ItemStack par1ItemStack, ItemStack par2ItemStack)
+ {
+ return false;
+ }
+
+ @Override
+ public ArmorProperties getProperties(EntityLivingBase player, ItemStack armor, DamageSource source, double damage, int slot)
+ {
+ double armourReduction = 0.0;
+
+ if(player.isPotionActive(AlchemicalWizardry.customPotionSoulFray))
+ {
+ int i = player.getActivePotionEffect(AlchemicalWizardry.customPotionSoulFray).getAmplifier() + 1;
+
+ armourReduction = (i+1)*0.1;
+ }
+
+ double damageAmount = 0.25;
+
+ if(player.isPotionActive(AlchemicalWizardry.customPotionSoulHarden))
+ {
+ int i = player.getActivePotionEffect(AlchemicalWizardry.customPotionSoulHarden).getAmplifier() + 1;
+ damageAmount /= Math.max((1 - i*0.1), 0.1);
+ }else
+ {
+ damageAmount *= 0.9;
+ }
+
+ damageAmount *= (1.0-armourReduction);
+
+ int maxAbsorption = 100000;
+
+ if (source.equals(DamageSource.drown))
+ {
+ return new ArmorProperties(-1, 0, 0);
+ }
+
+ if (source.equals(DamageSource.outOfWorld))
+ {
+ if (isImmuneToVoid(armor))
+ {
+ return new ArmorProperties(-1, damageAmount, maxAbsorption);
+ } else
+ {
+ return new ArmorProperties(-1, 0, 0);
+ }
+ }
+
+ ItemStack helmet = player.getEquipmentInSlot(4);
+ ItemStack plate = player.getEquipmentInSlot(3);
+ ItemStack leggings = player.getEquipmentInSlot(2);
+ ItemStack boots = player.getEquipmentInSlot(1);
+
+ if (helmet == null || plate == null || leggings == null || boots == null)
+ {
+ return new ArmorProperties(-1, 0, 0);
+ }
+
+ if (helmet.getItem().equals(ModItems.boundHelmet) && plate.getItem().equals(ModItems.boundPlate) && leggings.getItem().equals(ModItems.boundLeggings) && boots.getItem().equals(ModItems.boundBoots))
+ {
+ if (source.isUnblockable())
+ {
+ return new ArmorProperties(-1, damageAmount * 0.9d, maxAbsorption);
+ }
+
+ return new ArmorProperties(-1, damageAmount, maxAbsorption);
+ }
+
+ return new ArmorProperties(-1, 0, 0);
+ }
+
+ @Override
+ public int getArmorDisplay(EntityPlayer player, ItemStack armor, int slot)
+ {
+ if (armor.equals(ModItems.boundHelmet))
+ {
+ return 3;
+ }
+
+ if (armor.equals(ModItems.boundPlate))
+ {
+ return 8;
+ }
+
+ if (armor.equals(ModItems.boundLeggings))
+ {
+ return 6;
+ }
+
+ if (armor.equals(ModItems.boundBoots))
+ {
+ return 3;
+ }
+
+ return 5;
+ }
+
+ @Override
+ public void damageArmor(EntityLivingBase entity, ItemStack stack, DamageSource source, int damage, int slot)
+ {
+ if (entity instanceof EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(stack, (EntityPlayer) entity);
+
+ if (((EntityPlayer) entity).capabilities.isCreativeMode)
+ {
+ return;
+ }
+
+ //EnergyItems.syphonBatteries(stack, (EntityPlayer)entity, 200);
+ }
+
+ stack.setItemDamage(stack.getItemDamage() + damage);
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Devilish Protection");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ if (!par1ItemStack.stackTagCompound.getString("ownerName").equals(""))
+ {
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+
+ ItemStack[] inv = getInternalInventory(par1ItemStack);
+
+ if (inv == null)
+ {
+ return;
+ }
+
+ for (int i = 0; i < invSize; i++)
+ {
+ if (inv[i] != null)
+ {
+ par3List.add("Item in slot " + i + ": " + inv[i].getDisplayName());
+ }
+ }
+ }
+ }
+
+ @Override
+ public String getArmorTexture(ItemStack stack, Entity entity, int slot, String type)
+ {
+ if(this.tryComplexRendering)
+ {
+ return "alchemicalwizardry:models/armor/BloodArmour_WIP.png";
+ }
+
+ if (entity instanceof EntityLivingBase)
+ {
+ if (this.getIsInvisible(stack))
+ {
+ if (this== ModItems.boundHelmet || this == ModItems.boundPlate || this == ModItems.boundBoots)
+ {
+ return "alchemicalwizardry:models/armor/boundArmour_invisible_layer_1.png";
+ }
+
+ if (this == ModItems.boundLeggings)
+ {
+ return "alchemicalwizardry:models/armor/boundArmour_invisible_layer_2.png";
+ }
+ }
+ }
+
+ if (this == ModItems.boundHelmet || this == ModItems.boundPlate || this == ModItems.boundBoots)
+ {
+ return "alchemicalwizardry:models/armor/boundArmour_layer_1.png";
+ }
+
+ if (this == ModItems.boundLeggings)
+ {
+ return "alchemicalwizardry:models/armor/boundArmour_layer_2.png";
+ } else
+ {
+ return null;
+ }
+ }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par3EntityPlayer);
+ return super.onItemRightClick(par1ItemStack, par2World, par3EntityPlayer);
+ }
+
+ @Override
+ public void onArmorTick(World world, EntityPlayer player, ItemStack itemStack)
+ {
+ if (itemStack.stackTagCompound == null)
+ {
+ itemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ int maxBloodLevel = getMaxBloodShardLevel(itemStack);
+ ItemStack[] inv = getInternalInventory(itemStack);
+
+ if (inv != null)
+ {
+ int iSize = 0;
+ int iBlood = 0;
+ }
+
+ if (!player.isPotionActive(AlchemicalWizardry.customPotionInhibit))
+ {
+ tickInternalInventory(itemStack, world, player, 0, false);
+ }
+
+ this.setIsInvisible(itemStack, player.isPotionActive(Potion.invisibility.id));
+
+ if (itemStack.getItemDamage() > 0)
+ {
+ EnergyItems.checkAndSetItemOwner(itemStack, player);
+
+ if (!player.capabilities.isCreativeMode)
+ {
+ EnergyItems.syphonBatteries(itemStack, player, itemStack.getItemDamage() * 75);
+ itemStack.setItemDamage(0);
+ }
+ }
+
+ return;
+ }
+
+ public void tickInternalInventory(ItemStack par1ItemStack, World par2World, EntityPlayer par3Entity, int par4, boolean par5)
+ {
+ ItemStack[] inv = getInternalInventory(par1ItemStack);
+
+ if (inv == null)
+ {
+ return;
+ }
+
+ int blood = getMaxBloodShardLevel(par1ItemStack);
+
+ //int blood = 1;
+ for (int i = 0; i < invSize; i++)
+ {
+ if (inv[i] == null)
+ {
+ continue;
+ }
+
+ if (inv[i].getItem() instanceof ArmourUpgrade && blood > 0)
+ {
+ if (((ArmourUpgrade) inv[i].getItem()).isUpgrade())
+ {
+ ((ArmourUpgrade) inv[i].getItem()).onArmourUpdate(par2World, par3Entity, inv[i]);
+ blood--;
+ }
+
+ if (par2World.getWorldTime() % 200 == 0)
+ {
+ if (getUpgradeCostMultiplier(par1ItemStack) > 0.02f)
+ {
+ EnergyItems.syphonBatteries(par1ItemStack, par3Entity, (int) (((ArmourUpgrade) inv[i].getItem()).getEnergyForTenSeconds() * getUpgradeCostMultiplier(par1ItemStack)));
+ }
+ }
+ }
+ }
+ }
+
+ public int getMaxBloodShardLevel(ItemStack armourStack)
+ {
+ ItemStack[] inv = getInternalInventory(armourStack);
+
+ if (inv == null)
+ {
+ return 0;
+ }
+
+ int max = 0;
+
+ for (int i = 0; i < invSize; i++)
+ {
+ ItemStack itemStack = inv[i];
+
+ if (itemStack != null)
+ {
+ if (itemStack.getItem().equals(ModItems.weakBloodShard))
+ {
+ max = Math.max(max, 1);
+ }
+
+ if (itemStack.getItem().equals(ModItems.demonBloodShard))
+ {
+ max = Math.max(max, 2);
+ }
+ }
+ }
+
+ return max;
+ }
+
+ public boolean hasAddedToInventory(ItemStack sigilItemStack, ItemStack addedItemStack)
+ {
+ ItemStack[] inv = getInternalInventory(sigilItemStack);
+
+ if (inv == null)
+ {
+ return false;
+ }
+
+ if (addedItemStack == null)
+ {
+ return false;
+ }
+
+ Item item = addedItemStack.getItem();
+ int candidateSlot = -1;
+
+ for (int i = invSize - 1; i >= 0; i--)
+ {
+ ItemStack nextItem = inv[i];
+
+ if (nextItem == null)
+ {
+ candidateSlot = i;
+ continue;
+ }
+ }
+
+ if (candidateSlot == -1)
+ {
+ return false;
+ }
+
+ if (addedItemStack.getItem() instanceof ArmourUpgrade)
+ {
+ inv[candidateSlot] = addedItemStack;
+ saveInternalInventory(sigilItemStack, inv);
+ return true;
+ }
+
+ return false;
+ }
+
+ public ItemStack[] getInternalInventory(ItemStack itemStack)
+ {
+ NBTTagCompound itemTag = itemStack.stackTagCompound;
+
+ if (itemTag == null)
+ {
+ itemStack.setTagCompound(new NBTTagCompound());
+ }
+ itemTag = itemStack.stackTagCompound;
+
+ ItemStack[] inv = new ItemStack[9];
+ NBTTagList tagList = itemTag.getTagList("Inventory", Constants.NBT.TAG_COMPOUND);
+
+ if (tagList == null)
+ {
+ return null;
+ }
+
+ for (int i = 0; i < tagList.tagCount(); i++)
+ {
+ NBTTagCompound tag = (NBTTagCompound) tagList.getCompoundTagAt(i);
+ int slot = tag.getByte("Slot");
+
+ if (slot >= 0 && slot < invSize)
+ {
+ inv[slot] = ItemStack.loadItemStackFromNBT(tag);
+ }
+ }
+
+ return inv;
+ }
+
+ public void saveInternalInventory(ItemStack itemStack, ItemStack[] inventory)
+ {
+ NBTTagCompound itemTag = itemStack.stackTagCompound;
+
+ if (itemTag == null)
+ {
+ itemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagList itemList = new NBTTagList();
+
+ for (int i = 0; i < invSize; i++)
+ {
+ ItemStack stack = inventory[i];
+
+ if (inventory[i] != null)
+ {
+ NBTTagCompound tag = new NBTTagCompound();
+ tag.setByte("Slot", (byte) i);
+ inventory[i].writeToNBT(tag);
+ itemList.appendTag(tag);
+ }
+ }
+
+ itemTag.setTag("Inventory", itemList);
+ }
+
+ public boolean isImmuneToVoid(ItemStack itemStack)
+ {
+ ItemStack[] inv = getInternalInventory(itemStack);
+
+ if (inv == null)
+ {
+ return false;
+ }
+
+ for (ItemStack item : inv)
+ {
+ if (item == null)
+ {
+ continue;
+ }
+
+ if (item.getItem().equals(ModItems.voidSigil))
+ {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ @Optional.Method(modid = "Thaumcraft")
+ public boolean hasIRevealer(ItemStack itemStack)
+ {
+ ItemStack[] inv = getInternalInventory(itemStack);
+
+ if (inv == null)
+ {
+ return false;
+ }
+
+ for (ItemStack item : inv)
+ {
+ if (item == null)
+ {
+ continue;
+ }
+
+ if (item.getItem() instanceof IRevealer)
+ {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ @Optional.Method(modid = "Thaumcraft")
+ public boolean hasIGoggles(ItemStack itemStack)
+ {
+ ItemStack[] inv = getInternalInventory(itemStack);
+
+ if (inv == null)
+ {
+ return false;
+ }
+
+ for (ItemStack item : inv)
+ {
+ if (item == null)
+ {
+ continue;
+ }
+
+ if (item.getItem() instanceof IGoggles)
+ {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ public float getUpgradeCostMultiplier(ItemStack itemStack)
+ {
+ ItemStack[] inv = getInternalInventory(itemStack);
+
+ if (inv == null)
+ {
+ return 1.0f;
+ }
+
+ for (ItemStack item : inv)
+ {
+ if (item == null)
+ {
+ continue;
+ }
+
+ if (item.getItem().equals(ModItems.weakBloodOrb))
+ {
+ return 0.75f;
+ }
+
+ if (item.getItem().equals(ModItems.apprenticeBloodOrb))
+ {
+ return 0.50f;
+ }
+
+ if (item.getItem().equals(ModItems.magicianBloodOrb))
+ {
+ return 0.25f;
+ }
+
+ if (item.getItem().equals(ModItems.masterBloodOrb))
+ {
+ return 0.0f;
+ }
+
+ if (item.getItem().equals(ModItems.archmageBloodOrb))
+ {
+ return 0.0f;
+ }
+ }
+
+ return 1.0f;
+ }
+
+ public int getItemEnchantability()
+ {
+ return 0;
+ }
+
+ public boolean getIsInvisible(ItemStack armourStack)
+ {
+ NBTTagCompound tag = armourStack.getTagCompound();
+ if(tag != null)
+ {
+ return tag.getBoolean("invisible");
+ }
+
+ return false;
+ }
+
+ public void setIsInvisible(ItemStack armourStack, boolean invisible)
+ {
+ NBTTagCompound tag = armourStack.getTagCompound();
+
+ if(tag == null)
+ {
+ armourStack.setTagCompound(new NBTTagCompound());
+ tag = armourStack.getTagCompound();
+ }
+
+ tag.setBoolean("invisible", invisible);
+ }
+
+ @Override
+ @Optional.Method(modid = "Thaumcraft")
+ public boolean showNodes(ItemStack itemstack, EntityLivingBase player)
+ {
+ return this.hasIRevealer(itemstack);
+ }
+
+ @Override
+ @Optional.Method(modid = "Thaumcraft")
+ public boolean showIngamePopups(ItemStack itemstack, EntityLivingBase player)
+ {
+ return this.hasIGoggles(itemstack);
+ }
+
+ @Override
+ @Optional.Method(modid = "Thaumcraft")
+ public int getRunicCharge(ItemStack itemstack)
+ {
+ ItemStack[] inv = this.getInternalInventory(itemstack);
+ int shardLevel = this.getMaxBloodShardLevel(itemstack);
+ int count = 0;
+ int harden = 0;
+
+ if(inv == null)
+ {
+ return 0;
+ }
+
+ for(ItemStack stack : inv)
+ {
+ if(count >= shardLevel)
+ {
+ break;
+ }
+
+ if(stack == null || !(stack.getItem() instanceof ArmourUpgrade))
+ {
+ continue;
+ }
+
+ if(stack.getItem() instanceof ItemArmor && ((ItemArmor)stack.getItem()).armorType != this.armorType)
+ {
+ continue;
+ }
+
+ if(stack.hasTagCompound())
+ {
+ NBTTagCompound tag = stack.getTagCompound();
+
+ int enchLvl = tag.getByte("RS.HARDEN");
+
+ if(stack.getItem() instanceof IRunicArmor)
+ {
+ enchLvl += ((IRunicArmor)stack.getItem()).getRunicCharge(stack);
+ }
+
+ if(enchLvl > 0)
+ {
+ harden += enchLvl;
+ if(((ArmourUpgrade)stack.getItem()).isUpgrade())
+ {
+ count += 1;
+ }
+ }
+ }
+ }
+
+ return harden;
+ }
+
+ @Override
+ public boolean showIngameHUD(World world, ItemStack stack, EntityPlayer player)
+ {
+ ItemStack[] inv = getInternalInventory(stack);
+
+ if (inv == null)
+ {
+ return false;
+ }
+
+ for (ItemStack item : inv)
+ {
+ if (item == null)
+ {
+ continue;
+ }
+
+ if (item.getItem().equals(ModItems.itemSeerSigil))
+ {
+ return true;
+ }
+ }
+
+ return false;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/BoundAxe.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/BoundAxe.java
new file mode 100644
index 00000000..e6d0a770
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/BoundAxe.java
@@ -0,0 +1,360 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.swing.Icon;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockLeavesBase;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.enchantment.Enchantment;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemAxe;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.Vec3;
+import net.minecraft.world.World;
+import net.minecraftforge.common.ForgeHooks;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.items.interfaces.IBindable;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import net.minecraft.enchantment.EnchantmentHelper;
+
+public class BoundAxe extends ItemAxe implements IBindable
+{
+ /**
+ * Array of blocks the tool has extra effect against.
+ */
+ public static final Block[] blocksEffectiveAgainst = new Block[]{Blocks.planks, Blocks.bookshelf, Blocks.log, Blocks.chest, Blocks.stone_slab, Blocks.pumpkin, Blocks.lit_pumpkin};
+
+ public float efficiencyOnProperMaterial = 12.0F;
+
+ /**
+ * Damage versus entities.
+ */
+ public float damageVsEntity;
+
+ private static IIcon activeIcon;
+ private static IIcon passiveIcon;
+
+ private int energyUsed;
+
+ public BoundAxe()
+ {
+ super(AlchemicalWizardry.bloodBoundToolMaterial);
+ this.maxStackSize = 1;
+ //this.setMaxDamage(par3EnumToolMaterial.getMaxUses());
+ this.efficiencyOnProperMaterial = 12.0F;
+ this.damageVsEntity = 5;
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ setEnergyUsed(5);
+ }
+
+ public void setEnergyUsed(int i)
+ {
+ energyUsed = i;
+ }
+
+ public int getEnergyUsed()
+ {
+ return this.energyUsed;
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Axe me about my puns!");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ if (par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ par3List.add("Activated");
+ } else
+ {
+ par3List.add("Deactivated");
+ }
+
+ if (!par1ItemStack.stackTagCompound.getString("ownerName").equals(""))
+ {
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+ }
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:BoundAxe_activated");
+ this.activeIcon = iconRegister.registerIcon("AlchemicalWizardry:BoundAxe_activated");
+ this.passiveIcon = iconRegister.registerIcon("AlchemicalWizardry:SheathedItem");
+ }
+
+ @Override
+ public IIcon getIcon(ItemStack stack, int renderPass, EntityPlayer player, ItemStack usingItem, int useRemaining)
+ {
+ if (stack.stackTagCompound == null)
+ {
+ stack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = stack.stackTagCompound;
+
+ if (tag.getBoolean("isActive"))
+ {
+ return this.activeIcon;
+ } else
+ {
+ return this.passiveIcon;
+ }
+ }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par3EntityPlayer);
+
+ if (par3EntityPlayer.isSneaking())
+ {
+ this.setActivated(par1ItemStack, !getActivated(par1ItemStack));
+ par1ItemStack.stackTagCompound.setInteger("worldTimeDelay", (int) (par2World.getWorldTime() - 1) % 200);
+ return par1ItemStack;
+ }
+
+ if (!getActivated(par1ItemStack) || SpellHelper.isFakePlayer(par2World, par3EntityPlayer))
+ {
+ return par1ItemStack;
+ }
+
+ if (par3EntityPlayer.isPotionActive(AlchemicalWizardry.customPotionInhibit))
+ {
+ return par1ItemStack;
+ }
+
+ Vec3 blockVec = SpellHelper.getEntityBlockVector(par3EntityPlayer);
+ int posX = (int)(blockVec.xCoord);
+ int posY = (int)(blockVec.yCoord);
+ int posZ = (int)(blockVec.zCoord);
+ boolean silkTouch = EnchantmentHelper.getSilkTouchModifier(par3EntityPlayer);
+ int fortuneLvl = EnchantmentHelper.getFortuneModifier(par3EntityPlayer);
+
+ for (int i = -5; i <= 5; i++)
+ {
+ for (int j = 0; j <= 10; j++)
+ {
+ for (int k = -5; k <= 5; k++)
+ {
+ Block block = par2World.getBlock(posX + i, posY + j, posZ + k);
+ int meta = par2World.getBlockMetadata(posX + i, posY + j, posZ + k);
+
+ if (block != null)
+ {
+ float str = func_150893_a(par1ItemStack, block);
+
+ if (str > 1.1f || block instanceof BlockLeavesBase && par2World.canMineBlock(par3EntityPlayer, posX + i, posY + j, posZ + k))
+ {
+ //par1ItemStack.getEnchantmentTagList();
+ if (silkTouch)
+ {
+ ItemStack droppedItem = new ItemStack(block, 1, meta);
+
+ if (!par2World.isRemote)
+ {
+ par2World.spawnEntityInWorld(new EntityItem(par2World, posX, posY + par3EntityPlayer.getEyeHeight(), posZ, droppedItem));
+ }
+ } else
+ {
+ ArrayList itemDropList = block.getDrops(par2World, posX + i, posY + j, posZ + k, meta, fortuneLvl);
+
+ if (itemDropList != null)
+ {
+ for (ItemStack item : itemDropList)
+ {
+ if (!par2World.isRemote)
+ {
+ par2World.spawnEntityInWorld(new EntityItem(par2World, posX, posY + par3EntityPlayer.getEyeHeight(), posZ, item));
+ }
+ }
+ }
+ }
+
+ par2World.setBlockToAir(posX + i, posY + j, posZ + k);
+ }
+ }
+ }
+ }
+ }
+
+ EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, 10000);
+ return par1ItemStack;
+ }
+
+ @Override
+ public void onUpdate(ItemStack par1ItemStack, World par2World, Entity par3Entity, int par4, boolean par5)
+ {
+ if (!(par3Entity instanceof EntityPlayer))
+ {
+ return;
+ }
+
+ EntityPlayer par3EntityPlayer = (EntityPlayer) par3Entity;
+
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+// if(par1ItemStack.stackTagCompound.getBoolean("isActive"))
+// {
+// EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, 1);
+// }
+
+ if (par2World.getWorldTime() % 200 == par1ItemStack.stackTagCompound.getInteger("worldTimeDelay") && par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ if (!par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, 20);
+ }
+ }
+
+ par1ItemStack.setItemDamage(0);
+ return;
+ }
+
+ public void setActivated(ItemStack par1ItemStack, boolean newActivated)
+ {
+ NBTTagCompound itemTag = par1ItemStack.stackTagCompound;
+
+ if (itemTag == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ itemTag.setBoolean("isActive", newActivated);
+ }
+
+ public boolean getActivated(ItemStack par1ItemStack)
+ {
+ NBTTagCompound itemTag = par1ItemStack.stackTagCompound;
+
+ if (itemTag == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ return itemTag.getBoolean("isActive");
+ }
+
+ /**
+ * Returns the strength of the stack against a given block. 1.0F base, (Quality+1)*2 if correct blocktype, 1.5F if
+ * sword
+ */
+ @Override
+ public float func_150893_a(ItemStack par1ItemStack, Block par2Block)
+ {
+ if (!getActivated(par1ItemStack))
+ {
+ return 0.0F;
+ }
+
+ return super.func_150893_a(par1ItemStack, par2Block);
+ }
+
+ /**
+ * Current implementations of this method in child classes do not use the entry argument beside ev. They just raise
+ * the damage on the stack.
+ */
+ public boolean hitEntity(ItemStack par1ItemStack, EntityLivingBase par2EntityLivingBase, EntityLivingBase par3EntityLivingBase)
+ {
+ if (!getActivated(par1ItemStack))
+ {
+ return false;
+ }
+
+ //par1ItemStack.damageItem(2, par3EntityLivingBase);
+ return true;
+ }
+
+ public boolean onBlockDestroyed(ItemStack par1ItemStack, World par2World, Block par3, int par4, int par5, int par6, EntityLivingBase par7EntityLivingBase)
+ {
+ if ((double) par3.getBlockHardness(par2World, par4, par5, par6) != 0.0D)
+ {
+ //par1ItemStack.damageItem(1, par7EntityLivingBase);
+ }
+
+ return true;
+ }
+
+ @SideOnly(Side.CLIENT)
+
+ /**
+ * Returns True is the item is renderer in full 3D when hold.
+ */
+ public boolean isFull3D()
+ {
+ return true;
+ }
+
+ /**
+ * Return the enchantability factor of the item, most of the time is based on material.
+ */
+ @Override
+ public int getItemEnchantability()
+ {
+ return 30;
+ }
+
+ /**
+ * Return whether this item is repairable in an anvil.
+ */
+// public boolean getIsRepairable(ItemStack par1ItemStack, ItemStack par2ItemStack)
+// {
+// return true;
+// }
+
+ /**
+ * FORGE: Overridden to allow custom tool effectiveness
+ */
+ @Override
+ public float getDigSpeed(ItemStack stack, Block block, int meta)
+ {
+ if (!getActivated(stack))
+ {
+ return 0.0F;
+ }
+
+ if (ForgeHooks.isToolEffective(stack, block, meta))
+ {
+ return efficiencyOnProperMaterial;
+ }
+
+ return func_150893_a(stack, block);
+ }
+
+ @Override
+ public boolean onLeftClickEntity(ItemStack stack, EntityPlayer player, Entity entity)
+ {
+ return !getActivated(stack);
+ }
+
+ @Override
+ public int getHarvestLevel(ItemStack stack, String toolClass)
+ {
+ if("axe".equals(toolClass))
+ {
+ return 5;
+ }
+
+ return 0;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/BoundPickaxe.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/BoundPickaxe.java
new file mode 100644
index 00000000..922f59f9
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/BoundPickaxe.java
@@ -0,0 +1,376 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.enchantment.Enchantment;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemPickaxe;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.Vec3;
+import net.minecraft.world.World;
+import net.minecraftforge.common.ForgeHooks;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.items.interfaces.IBindable;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import net.minecraft.enchantment.EnchantmentHelper;
+
+public class BoundPickaxe extends ItemPickaxe implements IBindable
+{
+ /**
+ * Array of blocks the tool has extra effect against.
+ */
+ // public static final Block[] blocksEffectiveAgainst = new Block[]{Blocks.cobblestone, Blocks.stoneDoubleSlab, Blocks.stoneSingleSlab, Block.stone, Block.sandStone, Block.cobblestoneMossy, Block.oreIron, Block.blockIron, Block.oreCoal, Block.blockGold, Block.oreGold, Block.oreDiamond, Block.blockDiamond, Block.ice, Block.netherrack, Block.oreLapis, Block.blockLapis, Block.oreRedstone, Block.oreRedstoneGlowing, Block.rail, Block.railDetector, Block.railPowered, Block.railActivator};
+
+ public float efficiencyOnProperMaterial = 12.0F;
+
+ /**
+ * Damage versus entities.
+ */
+ public float damageVsEntity;
+
+ private static IIcon activeIcon;
+ private static IIcon passiveIcon;
+
+ private int energyUsed;
+
+ public BoundPickaxe()
+ {
+ super(AlchemicalWizardry.bloodBoundToolMaterial);
+ this.maxStackSize = 1;
+ //this.setMaxDamage(par3EnumToolMaterial.getMaxUses());
+ this.efficiencyOnProperMaterial = 12.0F;
+ this.damageVsEntity = 5;
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ this.setEnergyUsed(5);
+ }
+
+ public void setEnergyUsed(int i)
+ {
+ energyUsed = i;
+ }
+
+ public int getEnergyUsed()
+ {
+ return this.energyUsed;
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("The Souls of the Damned");
+ par3List.add("do not like stone...");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ if (par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ par3List.add("Activated");
+ } else
+ {
+ par3List.add("Deactivated");
+ }
+
+ if (!par1ItemStack.stackTagCompound.getString("ownerName").equals(""))
+ {
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+ }
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:BoundPickaxe_activated");
+ this.activeIcon = iconRegister.registerIcon("AlchemicalWizardry:BoundPickaxe_activated");
+ this.passiveIcon = iconRegister.registerIcon("AlchemicalWizardry:SheathedItem");
+ }
+
+ @Override
+ public IIcon getIcon(ItemStack stack, int renderPass, EntityPlayer player, ItemStack usingItem, int useRemaining)
+ {
+ if (stack.stackTagCompound == null)
+ {
+ stack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = stack.stackTagCompound;
+
+ if (tag.getBoolean("isActive"))
+ {
+ return this.activeIcon;
+ } else
+ {
+ return this.passiveIcon;
+ }
+ }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par3EntityPlayer);
+
+ if (par3EntityPlayer.isSneaking())
+ {
+ this.setActivated(par1ItemStack, !getActivated(par1ItemStack));
+ par1ItemStack.stackTagCompound.setInteger("worldTimeDelay", (int) (par2World.getWorldTime() - 1) % 200);
+ return par1ItemStack;
+ }
+
+ if (!getActivated(par1ItemStack) || SpellHelper.isFakePlayer(par2World, par3EntityPlayer))
+ {
+ return par1ItemStack;
+ }
+
+ if (par3EntityPlayer.isPotionActive(AlchemicalWizardry.customPotionInhibit))
+ {
+ return par1ItemStack;
+ }
+
+ if(par2World.isRemote)
+ {
+ return par1ItemStack;
+ }
+
+ Vec3 blockVec = SpellHelper.getEntityBlockVector(par3EntityPlayer);
+ int posX = (int)(blockVec.xCoord);
+ int posY = (int)(blockVec.yCoord);
+ int posZ = (int)(blockVec.zCoord);
+ boolean silkTouch = EnchantmentHelper.getSilkTouchModifier(par3EntityPlayer);
+ int fortuneLvl = EnchantmentHelper.getFortuneModifier(par3EntityPlayer);
+
+ for (int i = -5; i <= 5; i++)
+ {
+ for (int j = -5; j <= 5; j++)
+ {
+ for (int k = -5; k <= 5; k++)
+ {
+ Block block = par2World.getBlock(posX + i, posY + j, posZ + k);
+ int meta = par2World.getBlockMetadata(posX + i, posY + j, posZ + k);
+
+ if (block != null && block.getBlockHardness(par2World, posX + i, posY + j, posZ + k) != -1)
+ {
+ float str = func_150893_a(par1ItemStack, block);
+
+ if (str > 1.1f && par2World.canMineBlock(par3EntityPlayer, posX + i, posY + j, posZ + k))
+ {
+ //par1ItemStack.getEnchantmentTagList();
+ if (silkTouch)
+ {
+ ItemStack droppedItem = new ItemStack(block, 1, meta);
+
+ if (!par2World.isRemote)
+ {
+ par2World.spawnEntityInWorld(new EntityItem(par2World, posX, posY + par3EntityPlayer.getEyeHeight(), posZ, droppedItem));
+ }
+ } else
+ {
+ ArrayList itemDropList = block.getDrops(par2World, posX + i, posY + j, posZ + k, meta, fortuneLvl);
+
+ if (itemDropList != null)
+ {
+ for (ItemStack item : itemDropList)
+ {
+ if (!par2World.isRemote)
+ {
+ par2World.spawnEntityInWorld(new EntityItem(par2World, posX, posY + par3EntityPlayer.getEyeHeight(), posZ, item));
+ }
+ }
+ }
+ }
+
+ par2World.setBlockToAir(posX + i, posY + j, posZ + k);
+ }
+ }
+ }
+ }
+ }
+
+ EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, 10000);
+ return par1ItemStack;
+ }
+
+ @Override
+ public void onUpdate(ItemStack par1ItemStack, World par2World, Entity par3Entity, int par4, boolean par5)
+ {
+ if (!(par3Entity instanceof EntityPlayer))
+ {
+ return;
+ }
+
+ EntityPlayer par3EntityPlayer = (EntityPlayer) par3Entity;
+
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+// if(par1ItemStack.stackTagCompound.getBoolean("isActive"))
+// {
+// EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, 1);
+// }
+
+ if (par2World.getWorldTime() % 200 == par1ItemStack.stackTagCompound.getInteger("worldTimeDelay") && par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ if (!par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, 20);
+ }
+ }
+
+ par1ItemStack.setItemDamage(0);
+ return;
+ }
+
+ public void setActivated(ItemStack par1ItemStack, boolean newActivated)
+ {
+ NBTTagCompound itemTag = par1ItemStack.stackTagCompound;
+
+ if (itemTag == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ itemTag.setBoolean("isActive", newActivated);
+ }
+
+ public boolean getActivated(ItemStack par1ItemStack)
+ {
+ NBTTagCompound itemTag = par1ItemStack.stackTagCompound;
+
+ if (itemTag == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ return itemTag.getBoolean("isActive");
+ }
+
+ /**
+ * Returns the strength of the stack against a given block. 1.0F base, (Quality+1)*2 if correct blocktype, 1.5F if
+ * sword
+ */
+ @Override
+ public float func_150893_a(ItemStack par1ItemStack, Block par2Block) //getStrVsBlock
+ {
+ if (!getActivated(par1ItemStack))
+ {
+ return 0.0F;
+ }
+
+ return super.func_150893_a(par1ItemStack, par2Block);
+ }
+
+ /**
+ * Current implementations of this method in child classes do not use the entry argument beside ev. They just raise
+ * the damage on the stack.
+ */
+ public boolean hitEntity(ItemStack par1ItemStack, EntityLivingBase par2EntityLivingBase, EntityLivingBase par3EntityLivingBase)
+ {
+ if (!getActivated(par1ItemStack))
+ {
+ return false;
+ }
+
+ //par1ItemStack.damageItem(2, par3EntityLivingBase);
+ return true;
+ }
+
+ @Override
+ public boolean onBlockDestroyed(ItemStack par1ItemStack, World par2World, Block par3, int par4, int par5, int par6, EntityLivingBase par7EntityLivingBase)
+ {
+
+ if (par7EntityLivingBase instanceof EntityPlayer)
+ {
+ EnergyItems.syphonBatteries(par1ItemStack, (EntityPlayer) par7EntityLivingBase, getEnergyUsed());
+ }
+
+ //TODO Possibly add better functionality for the items?
+ //par7EntityLivingBase.getLookVec();
+ return true;
+ }
+
+ @SideOnly(Side.CLIENT)
+
+ /**
+ * Returns True is the item is renderer in full 3D when hold.
+ */
+ public boolean isFull3D()
+ {
+ return true;
+ }
+
+ /**
+ * Return the enchantability factor of the item, most of the time is based on material.
+ */
+ @Override
+ public int getItemEnchantability()
+ {
+ return 30;
+ }
+
+ /**
+ * Return whether this item is repairable in an anvil.
+ */
+// public boolean getIsRepairable(ItemStack par1ItemStack, ItemStack par2ItemStack)
+// {
+// return false;
+// }
+
+ /**
+ * FORGE: Overridden to allow custom tool effectiveness
+ */
+ @Override
+ public float getDigSpeed(ItemStack stack, Block block, int meta)
+ {
+ if (!getActivated(stack))
+ {
+ return 0.0F;
+ }
+
+ if (ForgeHooks.isToolEffective(stack, block, meta))
+ {
+ return efficiencyOnProperMaterial;
+ }
+
+ return func_150893_a(stack, block);
+ }
+
+// @Override
+//
+// /**
+// * Returns if the item (tool) can harvest results from the block type.
+// */
+// public boolean func_150897_b(Block par1Block) //canHarvestBlock
+// {
+// return par1Block == Blocks.obsidian ? true : (par1Block != Blocks.diamond_block && par1Block != Blocks.diamond_ore ? (par1Block != Blocks.emerald_ore && par1Block != Blocks.emerald_block ? (par1Block != Blocks.gold_block && par1Block != Blocks.gold_ore ? (par1Block != Blocks.iron_block && par1Block != Blocks.iron_ore ? (par1Block != Blocks.lapis_block && par1Block != Blocks.lapis_ore ? (par1Block != Blocks.redstone_ore && par1Block != Blocks.oreRedstoneGlowing ? (par1Block.getMaterial() == Material.rock ? true : (par1Block.blockMaterial == Material.iron ? true : par1Block.blockMaterial == Material.anvil)) : true) : true) : true) : true) : true) : true);
+// }
+
+ @Override
+ public boolean onLeftClickEntity(ItemStack stack, EntityPlayer player, Entity entity)
+ {
+ return !getActivated(stack);
+ }
+
+ @Override
+ public int getHarvestLevel(ItemStack stack, String toolClass)
+ {
+ if("pickaxe".equals(toolClass))
+ {
+ return 5;
+ }
+
+ return 0;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/BoundShovel.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/BoundShovel.java
new file mode 100644
index 00000000..df65ebcb
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/BoundShovel.java
@@ -0,0 +1,367 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.enchantment.Enchantment;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.SharedMonsterAttributes;
+import net.minecraft.entity.ai.attributes.AttributeModifier;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemSpade;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.Vec3;
+import net.minecraft.world.World;
+import net.minecraftforge.common.ForgeHooks;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.items.interfaces.IBindable;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+import net.minecraft.enchantment.EnchantmentHelper;
+
+import com.google.common.collect.Multimap;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class BoundShovel extends ItemSpade implements IBindable
+{
+ /**
+ * Array of blocks the tool has extra effect against.
+ */
+ //public static final Block[] blocksEffectiveAgainst = new Block[]{Block.grass, Block.dirt, Block.sand, Block.gravel, Block.snow, Block.blockSnow, Block.blockClay, Block.tilledField, Block.slowSand, Block.mycelium};
+
+ public float efficiencyOnProperMaterial = 12.0F;
+
+ /**
+ * Damage versus entities.
+ */
+ public float damageVsEntity;
+
+ private static IIcon activeIcon;
+ private static IIcon passiveIcon;
+
+ private int energyUsed;
+
+ public BoundShovel()
+ {
+ super(AlchemicalWizardry.bloodBoundToolMaterial);
+ this.maxStackSize = 1;
+ //this.setMaxDamage(par3EnumToolMaterial.getMaxUses());
+ this.efficiencyOnProperMaterial = 12.0F;
+ this.damageVsEntity = 5;
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ setEnergyUsed(5);
+ }
+
+ public void setEnergyUsed(int i)
+ {
+ energyUsed = i;
+ }
+
+ public int getEnergyUsed()
+ {
+ return this.energyUsed;
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("No, not that type of spade.");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ if (par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ par3List.add("Activated");
+ } else
+ {
+ par3List.add("Deactivated");
+ }
+
+ if (!par1ItemStack.stackTagCompound.getString("ownerName").equals(""))
+ {
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+ }
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:BoundShovel_activated");
+ this.activeIcon = iconRegister.registerIcon("AlchemicalWizardry:BoundShovel_activated");
+ this.passiveIcon = iconRegister.registerIcon("AlchemicalWizardry:SheathedItem");
+ }
+
+ @Override
+ public IIcon getIcon(ItemStack stack, int renderPass, EntityPlayer player, ItemStack usingItem, int useRemaining)
+ {
+ if (stack.stackTagCompound == null)
+ {
+ stack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = stack.stackTagCompound;
+
+ if (tag.getBoolean("isActive"))
+ {
+ return this.activeIcon;
+ } else
+ {
+ return this.passiveIcon;
+ }
+ }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par3EntityPlayer);
+
+ if (par3EntityPlayer.isSneaking())
+ {
+ this.setActivated(par1ItemStack, !getActivated(par1ItemStack));
+ par1ItemStack.stackTagCompound.setInteger("worldTimeDelay", (int) (par2World.getWorldTime() - 1) % 200);
+ return par1ItemStack;
+ }
+
+ if (!getActivated(par1ItemStack) || SpellHelper.isFakePlayer(par2World, par3EntityPlayer))
+ {
+ return par1ItemStack;
+ }
+
+ if (par3EntityPlayer.isPotionActive(AlchemicalWizardry.customPotionInhibit))
+ {
+ return par1ItemStack;
+ }
+
+ Vec3 blockVec = SpellHelper.getEntityBlockVector(par3EntityPlayer);
+ int posX = (int)(blockVec.xCoord);
+ int posY = (int)(blockVec.yCoord);
+ int posZ = (int)(blockVec.zCoord);
+ boolean silkTouch = EnchantmentHelper.getSilkTouchModifier(par3EntityPlayer);
+ int fortuneLvl = EnchantmentHelper.getFortuneModifier(par3EntityPlayer);
+
+ for (int i = -5; i <= 5; i++)
+ {
+ for (int j = 0; j <= 10; j++)
+ {
+ for (int k = -5; k <= 5; k++)
+ {
+ Block block = par2World.getBlock(posX + i, posY + j, posZ + k);
+ int meta = par2World.getBlockMetadata(posX + i, posY + j, posZ + k);
+
+ if (block != null)
+ {
+ float str = func_150893_a(par1ItemStack, block);
+
+ if (str > 1.1f && par2World.canMineBlock(par3EntityPlayer, posX + i, posY + j, posZ + k))
+ {
+ //par1ItemStack.getEnchantmentTagList();
+ if (silkTouch)
+ {
+ ItemStack droppedItem = new ItemStack(block, 1, meta);
+
+ if (!par2World.isRemote)
+ {
+ par2World.spawnEntityInWorld(new EntityItem(par2World, posX, posY + par3EntityPlayer.getEyeHeight(), posZ, droppedItem));
+ }
+ } else
+ {
+ ArrayList itemDropList = block.getDrops(par2World, posX + i, posY + j, posZ + k, meta, fortuneLvl);
+
+ if (itemDropList != null)
+ {
+ for (ItemStack item : itemDropList)
+ {
+ if (!par2World.isRemote)
+ {
+ par2World.spawnEntityInWorld(new EntityItem(par2World, posX, posY + par3EntityPlayer.getEyeHeight(), posZ, item));
+ }
+ }
+ }
+ }
+
+ par2World.setBlockToAir(posX + i, posY + j, posZ + k);
+ }
+ }
+ }
+ }
+ }
+
+ EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, 10000);
+ return par1ItemStack;
+ }
+
+ @Override
+ public void onUpdate(ItemStack par1ItemStack, World par2World, Entity par3Entity, int par4, boolean par5)
+ {
+ if (!(par3Entity instanceof EntityPlayer))
+ {
+ return;
+ }
+
+ EntityPlayer par3EntityPlayer = (EntityPlayer) par3Entity;
+
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+// if(par1ItemStack.stackTagCompound.getBoolean("isActive"))
+// {
+// EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, 1);
+// }
+
+ if (par2World.getWorldTime() % 200 == par1ItemStack.stackTagCompound.getInteger("worldTimeDelay") && par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ if (!par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, 20);
+ }
+ }
+
+ par1ItemStack.setItemDamage(0);
+ return;
+ }
+
+ public void setActivated(ItemStack par1ItemStack, boolean newActivated)
+ {
+ NBTTagCompound itemTag = par1ItemStack.stackTagCompound;
+
+ if (itemTag == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ itemTag.setBoolean("isActive", newActivated);
+ }
+
+ public boolean getActivated(ItemStack par1ItemStack)
+ {
+ NBTTagCompound itemTag = par1ItemStack.stackTagCompound;
+
+ if (itemTag == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ return itemTag.getBoolean("isActive");
+ }
+
+ /**
+ * Returns the strength of the stack against a given block. 1.0F base, (Quality+1)*2 if correct blocktype, 1.5F if
+ * sword
+ */
+ @Override
+ public float func_150893_a(ItemStack par1ItemStack, Block par2Block)
+ {
+ if (!getActivated(par1ItemStack))
+ {
+ return 0.0F;
+ }
+
+ return super.func_150893_a(par1ItemStack, par2Block);
+ }
+
+ /**
+ * Current implementations of this method in child classes do not use the entry argument beside ev. They just raise
+ * the damage on the stack.
+ */
+ public boolean hitEntity(ItemStack par1ItemStack, EntityLivingBase par2EntityLivingBase, EntityLivingBase par3EntityLivingBase)
+ {
+ if (!getActivated(par1ItemStack))
+ {
+ return false;
+ }
+
+ //par1ItemStack.damageItem(2, par3EntityLivingBase);
+ return true;
+ }
+
+ public boolean onBlockDestroyed(ItemStack par1ItemStack, World par2World, int par3, int par4, int par5, int par6, EntityLivingBase par7EntityLivingBase)
+ {
+ return true;
+ }
+
+ @SideOnly(Side.CLIENT)
+
+ /**
+ * Returns True is the item is renderer in full 3D when hold.
+ */
+ public boolean isFull3D()
+ {
+ return true;
+ }
+
+ /**
+ * Return the enchantability factor of the item, most of the time is based on material.
+ */
+ public int getItemEnchantability()
+ {
+ return 30;
+ }
+
+ /**
+ * Return whether this item is repairable in an anvil.
+ */
+// public boolean getIsRepairable(ItemStack par1ItemStack, ItemStack par2ItemStack)
+// {
+// return false;
+// }
+ @Override
+ public Multimap getItemAttributeModifiers()
+ {
+ Multimap multimap = super.getItemAttributeModifiers();
+ multimap.put(SharedMonsterAttributes.attackDamage.getAttributeUnlocalizedName(), new AttributeModifier(field_111210_e, "Tool modifier", (double) this.damageVsEntity, 0));
+ return multimap;
+ }
+
+ /**
+ * FORGE: Overridden to allow custom tool effectiveness
+ */
+ @Override
+ public float getDigSpeed(ItemStack stack, Block block, int meta)
+ {
+ if (!getActivated(stack))
+ {
+ return 0.0F;
+ }
+
+ if (ForgeHooks.isToolEffective(stack, block, meta))
+ {
+ return efficiencyOnProperMaterial;
+ }
+
+ return func_150893_a(stack, block);
+ }
+//
+// public boolean canHarvestBlock(Block par1Block)
+// {
+// return par1Block == Block.snow ? true : par1Block == Block.blockSnow;
+// }
+
+ @Override
+ public boolean onLeftClickEntity(ItemStack stack, EntityPlayer player, Entity entity)
+ {
+ return !getActivated(stack);
+ }
+
+ @Override
+ public int getHarvestLevel(ItemStack stack, String toolClass)
+ {
+ if("shovel".equals(toolClass))
+ {
+ return 5;
+ }
+
+ return 0;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/CheatyItem.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/CheatyItem.java
new file mode 100644
index 00000000..8b44398d
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/CheatyItem.java
@@ -0,0 +1,254 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.util.DamageSource;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.FakePlayer;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.items.interfaces.IBindable;
+import WayofTime.alchemicalWizardry.api.soulNetwork.LifeEssenceNetwork;
+import WayofTime.alchemicalWizardry.common.PacketHandler;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEAltar;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class CheatyItem extends Item implements IBindable
+{
+ // private int maxEssence;
+ //protected int orbLevel;
+
+ public CheatyItem()
+ {
+ super();
+ DamageSource damageSource = DamageSource.generic;
+ setMaxStackSize(1);
+ //setMaxDamage(damage);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ //setFull3D();
+ //maxEssence = damage;
+ //orbLevel = 1;
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:EnergyBattery");
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Creative only");
+ par3List.add("Right-click to fill network,");
+ par3List.add("shift-right to empty.");
+
+ //par3List.add("LP: " + (this.getMaxDamage() - this.getDamage(par1ItemStack)));
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+// EntityPlayer owner = MinecraftServer.getServer().getConfigurationManager().getPlayerForUsername(par1ItemStack.stackTagCompound.getString("ownerName"));
+// if(owner!=null)
+// {
+// NBTTagCompound tag = owner.getEntityData();
+// par3List.add("LP: " + tag.getInteger("currentEssence"));
+// }
+ }
+
+ //par3List.add("LP: " + par2EntityPlayer.getEntityData().getInteger("currentEssence"));
+ }
+
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par3EntityPlayer);
+ World world = par3EntityPlayer.worldObj;
+
+ if (par3EntityPlayer instanceof FakePlayer)
+ {
+ return par1ItemStack;
+ }
+
+ if (world != null)
+ {
+ double posX = par3EntityPlayer.posX;
+ double posY = par3EntityPlayer.posY;
+ double posZ = par3EntityPlayer.posZ;
+ world.playSoundEffect((double) ((float) posX + 0.5F), (double) ((float) posY + 0.5F), (double) ((float) posZ + 0.5F), "random.fizz", 0.5F, 2.6F + (world.rand.nextFloat() - world.rand.nextFloat()) * 0.8F);
+ SpellHelper.sendIndexedParticleToAllAround(world, posX, posY, posZ, 20, world.provider.dimensionId, 4, posX, posY, posZ);
+ }
+
+ if (!par3EntityPlayer.worldObj.isRemote)
+ {
+ return par1ItemStack;
+ }
+
+ NBTTagCompound itemTag = par1ItemStack.stackTagCompound;
+
+ if (itemTag == null || itemTag.getString("ownerName").equals(""))
+ {
+ return par1ItemStack;
+ }
+
+ if (par3EntityPlayer.isSneaking())
+ {
+ EnergyItems.setCurrentEssence(itemTag.getString("ownerName"), 0);
+ } else
+ {
+ EnergyItems.addEssenceToMaximum(itemTag.getString("ownerName"), 1000000, Integer.MAX_VALUE);
+ }
+
+ //PacketDispatcher.sendPacketToPlayer(PacketHandler.getPacket(itemTag.getString("ownerName")), (Player)par3EntityPlayer);
+// EntityPlayer owner = MinecraftServer.getServer().getConfigurationManager().getPlayerForUsername(itemTag.getString("ownerName"));
+// if(owner==null){return par1ItemStack;}
+// NBTTagCompound ownerTag = owner.getEntityData();
+// if(ownerTag.getInteger("currentEssence")<=this.maxEssence)
+// {
+// damagePlayer(par2World, par3EntityPlayer,2);
+// ownerTag.setInteger("currentEssence", Math.min(this.maxEssence, ownerTag.getInteger("currentEssence")+200/2));
+// }
+ return par1ItemStack;
+ }
+
+ /*
+ * @return the damage that was not deducted
+ */
+ public int damageItem(ItemStack par1ItemStack, int par2int)
+ {
+ if (par2int == 0)
+ {
+ return 0;
+ }
+
+ int before = this.getDamage(par1ItemStack);
+ this.setDamage(par1ItemStack, this.getDamage(par1ItemStack) + par2int);
+ return par2int - (this.getDamage(par1ItemStack) - before);
+ }
+
+ protected void damagePlayer(World world, EntityPlayer player, int damage)
+ {
+ if (world != null)
+ {
+ double posX = player.posX;
+ double posY = player.posY;
+ double posZ = player.posZ;
+ world.playSoundEffect((double) ((float) posX + 0.5F), (double) ((float) posY + 0.5F), (double) ((float) posZ + 0.5F), "random.fizz", 0.5F, 2.6F + (world.rand.nextFloat() - world.rand.nextFloat()) * 0.8F);
+ float f = (float) 1.0F;
+ float f1 = f * 0.6F + 0.4F;
+ float f2 = f * f * 0.7F - 0.5F;
+ float f3 = f * f * 0.6F - 0.7F;
+
+ for (int l = 0; l < 8; ++l)
+ {
+ world.spawnParticle("reddust", posX + Math.random() - Math.random(), posY + Math.random() - Math.random(), posZ + Math.random() - Math.random(), f1, f2, f3);
+ }
+ }
+
+ if (!player.capabilities.isCreativeMode)
+ {
+ for (int i = 0; i < damage; i++)
+ {
+ player.setHealth((player.getHealth() - 1));
+ //player.setEntityHealth(player.func_110143_aJ() - 1);
+ }
+ }
+
+ if (player.getHealth() <= 0)
+ {
+ player.inventory.dropAllItems();
+ }
+ }
+
+// public int getMaxEssence()
+// {
+// return this.maxEssence;
+// }
+//
+// public int getOrbLevel()
+// {
+// return orbLevel;
+// }
+//
+// @Override
+// public void onArmourUpdate(World world, EntityPlayer player,
+// ItemStack thisItemStack) {
+// // TODO Auto-generated method stub
+//
+// }
+//
+// @Override
+// public boolean isUpgrade()
+// {
+// // TODO Auto-generated method stub
+// return false;
+// }
+//
+// @Override
+// public int getEnergyForTenSeconds()
+// {
+// // TODO Auto-generated method stub
+// return 0;
+// }
+
+ @Override
+ public ItemStack getContainerItem(ItemStack itemStack)
+ {
+ //if(!syphonBatteries(itemStack, null, 10))
+ {
+ //syphonWhileInContainer(itemStack, this.getEnergyUsed());
+// ItemStack copiedStack = itemStack.copy();
+// copiedStack.setItemDamage(copiedStack.getItemDamage());
+// copiedStack.stackSize = 1;
+// return copiedStack;
+ }
+ return itemStack;
+ }
+
+ @Override
+ public boolean hasContainerItem()
+ {
+ return true;
+ }
+
+ //@SideOnly(Side.SERVER)
+ public int getCurrentEssence(ItemStack par1ItemStack)
+ {
+ if (par1ItemStack == null)
+ {
+ return 0;
+ }
+
+ NBTTagCompound itemTag = par1ItemStack.stackTagCompound;
+
+ if (itemTag == null || itemTag.getString("ownerName").equals(""))
+ {
+ return 0;
+ }
+
+ String owner = itemTag.getString("ownerName");
+ World worldSave = MinecraftServer.getServer().worldServers[0];
+ LifeEssenceNetwork data = (LifeEssenceNetwork) worldSave.loadItemData(LifeEssenceNetwork.class, owner);
+
+ if (data == null)
+ {
+ data = new LifeEssenceNetwork(owner);
+ worldSave.setItemData(owner, data);
+ }
+
+ int currentEssence = data.currentEssence;
+ return (currentEssence);
+ }
+
+ @Override
+ public boolean doesContainerItemLeaveCraftingGrid(ItemStack itemStack)
+ {
+ return false;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/DaggerOfSacrifice.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/DaggerOfSacrifice.java
new file mode 100644
index 00000000..a2569610
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/DaggerOfSacrifice.java
@@ -0,0 +1,268 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.SharedMonsterAttributes;
+import net.minecraft.entity.ai.attributes.AttributeModifier;
+import net.minecraft.entity.boss.EntityDragon;
+import net.minecraft.entity.boss.EntityWither;
+import net.minecraft.entity.boss.IBossDisplayData;
+import net.minecraft.entity.monster.EntityEnderman;
+import net.minecraft.entity.monster.EntitySlime;
+import net.minecraft.entity.passive.EntityAnimal;
+import net.minecraft.entity.passive.EntityVillager;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.DamageSource;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEAltar;
+
+import com.google.common.collect.Multimap;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class DaggerOfSacrifice extends EnergyItems
+{
+ private float weaponDamage;
+
+ public DaggerOfSacrifice()
+ {
+ super();
+ this.maxStackSize = 1;
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ setEnergyUsed(100);
+ setFull3D();
+ setMaxDamage(100);
+ weaponDamage = 1.0F;
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:DaggerOfSacrifice");
+ }
+
+ @Override
+ public boolean hitEntity(ItemStack par1ItemStack, EntityLivingBase par2EntityLivingBase, EntityLivingBase par3EntityLivingBase)
+ {
+ if (par3EntityLivingBase == null || par2EntityLivingBase == null || par3EntityLivingBase.worldObj.isRemote || (par3EntityLivingBase instanceof EntityPlayer && SpellHelper.isFakePlayer(par3EntityLivingBase.worldObj, (EntityPlayer) par3EntityLivingBase)))
+ {
+ return false;
+ }
+
+ //EntityWither d;
+ if (par2EntityLivingBase.isChild() || par2EntityLivingBase instanceof EntityWither || par2EntityLivingBase instanceof EntityDragon || par2EntityLivingBase instanceof EntityPlayer || par2EntityLivingBase instanceof IBossDisplayData)
+ {
+ return false;
+ }
+
+ World world = par2EntityLivingBase.worldObj;
+
+ if (par2EntityLivingBase.isDead || par2EntityLivingBase.getHealth() < 0.5f)
+ {
+ return false;
+ }
+
+ if (par2EntityLivingBase instanceof EntityVillager && !par2EntityLivingBase.isChild())
+ {
+ if (findAndFillAltar(par2EntityLivingBase.worldObj, par2EntityLivingBase, 2000))
+ {
+ double posX = par2EntityLivingBase.posX;
+ double posY = par2EntityLivingBase.posY;
+ double posZ = par2EntityLivingBase.posZ;
+
+
+
+ for (int i = 0; i < 8; i++)
+ {
+ SpellHelper.sendIndexedParticleToAllAround(world, posX, posY, posZ, 20, world.provider.dimensionId, 1, posX, posY, posZ);
+ }
+
+ par2EntityLivingBase.setHealth(-1);
+ par2EntityLivingBase.onDeath(DamageSource.generic);
+ return false;
+ }
+ }
+
+ if (par2EntityLivingBase instanceof EntitySlime && !par2EntityLivingBase.isChild())
+ {
+ if (findAndFillAltar(par2EntityLivingBase.worldObj, par2EntityLivingBase, 150))
+ {
+ double posX = par2EntityLivingBase.posX;
+ double posY = par2EntityLivingBase.posY;
+ double posZ = par2EntityLivingBase.posZ;
+
+ for (int i = 0; i < 8; i++)
+ {
+ SpellHelper.sendIndexedParticleToAllAround(world, posX, posY, posZ, 20, world.provider.dimensionId, 1, posX, posY, posZ);
+ }
+
+ par2EntityLivingBase.setHealth(-1);
+ par2EntityLivingBase.onDeath(DamageSource.generic);
+ return false;
+ }
+ }
+
+ if (par2EntityLivingBase instanceof EntityEnderman && !par2EntityLivingBase.isChild())
+ {
+ if (findAndFillAltar(par2EntityLivingBase.worldObj, par2EntityLivingBase, 200))
+ {
+ double posX = par2EntityLivingBase.posX;
+ double posY = par2EntityLivingBase.posY;
+ double posZ = par2EntityLivingBase.posZ;
+
+ for (int i = 0; i < 8; i++)
+ {
+ SpellHelper.sendIndexedParticleToAllAround(world, posX, posY, posZ, 20, world.provider.dimensionId, 1, posX, posY, posZ);
+ }
+
+ par2EntityLivingBase.setHealth(-1);
+ par2EntityLivingBase.onDeath(DamageSource.generic);
+ return false;
+ }
+ }
+
+ if (par2EntityLivingBase instanceof EntityAnimal && !par2EntityLivingBase.isChild())
+ {
+ if (findAndFillAltar(par2EntityLivingBase.worldObj, par2EntityLivingBase, 250))
+ {
+ double posX = par2EntityLivingBase.posX;
+ double posY = par2EntityLivingBase.posY;
+ double posZ = par2EntityLivingBase.posZ;
+
+ for (int i = 0; i < 8; i++)
+ {
+ SpellHelper.sendIndexedParticleToAllAround(world, posX, posY, posZ, 20, world.provider.dimensionId, 1, posX, posY, posZ);
+ }
+
+ par2EntityLivingBase.setHealth(-1);
+ par2EntityLivingBase.onDeath(DamageSource.generic);
+ return false;
+ }
+ }
+
+ if (findAndFillAltar(par2EntityLivingBase.worldObj, par2EntityLivingBase, 500))
+ {
+ double posX = par2EntityLivingBase.posX;
+ double posY = par2EntityLivingBase.posY;
+ double posZ = par2EntityLivingBase.posZ;
+
+ for (int i = 0; i < 8; i++)
+ {
+ SpellHelper.sendIndexedParticleToAllAround(world, posX, posY, posZ, 20, world.provider.dimensionId, 1, posX, posY, posZ);
+ }
+
+ par2EntityLivingBase.setHealth(-1);
+ par2EntityLivingBase.onDeath(DamageSource.generic);
+ return false;
+ }
+
+ return false;
+ }
+
+ public float func_82803_g()
+ {
+ return 4.0F;
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Caution: may cause");
+ par3List.add("a bad day...");
+ }
+
+ @Override
+ public float func_150893_a(ItemStack par1ItemStack, Block par2Block)
+ {
+ if (par2Block == Blocks.web)
+ {
+ return 15.0F;
+ } else
+ {
+ Material material = par2Block.getMaterial();
+ return material != Material.plants && material != Material.vine && material != Material.coral && material != Material.leaves && material != Material.gourd ? 1.0F : 1.5F;
+ }
+ }
+
+ @Override
+ public boolean getIsRepairable(ItemStack par1ItemStack, ItemStack par2ItemStack)
+ {
+ return false;
+ }
+
+ @Override
+
+ public Multimap getItemAttributeModifiers()
+ {
+ Multimap multimap = super.getItemAttributeModifiers();
+ multimap.put(SharedMonsterAttributes.attackDamage.getAttributeUnlocalizedName(), new AttributeModifier(field_111210_e, "Tool modifier", 1.0d, 0));
+ return multimap;
+ }
+
+ public boolean findAndFillAltar(World world, EntityLivingBase sacrifice, int amount)
+ {
+ int posX = (int) Math.round(sacrifice.posX - 0.5f);
+ int posY = (int) sacrifice.posY;
+ int posZ = (int) Math.round(sacrifice.posZ - 0.5f);
+ TEAltar altarEntity = this.getAltar(world, posX, posY, posZ);
+
+ if (altarEntity == null)
+ {
+ return false;
+ }
+
+ altarEntity.sacrificialDaggerCall(amount, true);
+ altarEntity.startCycle();
+ return true;
+ }
+
+ public TEAltar getAltar(World world, int x, int y, int z)
+ {
+ TileEntity tileEntity = null;
+
+ for (int i = -2; i <= 2; i++)
+ {
+ for (int j = -2; j <= 2; j++)
+ {
+ for (int k = -2; k <= 1; k++)
+ {
+ tileEntity = world.getTileEntity(i + x, k + y, j + z);
+
+ if ((tileEntity instanceof TEAltar))
+ {
+ return (TEAltar) tileEntity;
+ }
+ }
+
+ if ((tileEntity instanceof TEAltar))
+ {
+ return (TEAltar) tileEntity;
+ }
+ }
+
+ if ((tileEntity instanceof TEAltar))
+ {
+ return (TEAltar) tileEntity;
+ }
+ }
+
+ if ((tileEntity instanceof TEAltar))
+ {
+ return (TEAltar) tileEntity;
+ }
+
+ return null;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/DemonPlacer.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/DemonPlacer.java
new file mode 100644
index 00000000..6708cd74
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/DemonPlacer.java
@@ -0,0 +1,277 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityList;
+import net.minecraft.entity.EntityList.EntityEggInfo;
+import net.minecraft.entity.EntityLiving;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.Facing;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.MathHelper;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.api.summoningRegistry.SummoningRegistry;
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityDemon;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class DemonPlacer extends Item
+{
+ @SideOnly(Side.CLIENT)
+ private IIcon theIcon;
+
+ public DemonPlacer()
+ {
+ super();
+ this.setHasSubtypes(true);
+ this.setCreativeTab(CreativeTabs.tabMisc);
+ this.maxStackSize = 1;
+ }
+
+ public String getItemDisplayName(ItemStack par1ItemStack)
+ {
+// String s = ("" + StatCollector.translateToLocal(this.getUnlocalizedName() + ".name")).trim();
+// String s1 = EntityList.getStringFromID(par1ItemStack.getItemDamage());
+//
+// if (s1 != null)
+// {
+// s = s + " " + StatCollector.translateToLocal("entity." + s1 + ".name");
+// }
+//
+// return s;
+ return "Demon Crystal";
+ }
+
+ @SideOnly(Side.CLIENT)
+ public int getColorFromItemStack(ItemStack par1ItemStack, int par2)
+ {
+ EntityEggInfo entityegginfo = (EntityEggInfo) EntityList.entityEggs.get(Integer.valueOf(par1ItemStack.getItemDamage()));
+ return entityegginfo != null ? (par2 == 0 ? entityegginfo.primaryColor : entityegginfo.secondaryColor) : 16777215;
+ }
+
+ /**
+ * Callback for item usage. If the item does something special on right clicking, he will have one of those. Return
+ * True if something happen and false if it don't. This is for ITEMS, not BLOCKS
+ */
+ public boolean onItemUse(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, World par3World, int par4, int par5, int par6, int par7, float par8, float par9, float par10)
+ {
+ if (par3World.isRemote)
+ {
+ return true;
+ } else
+ {
+ Block i1 = par3World.getBlock(par4, par5, par6);
+ par4 += Facing.offsetsXForSide[par7];
+ par5 += Facing.offsetsYForSide[par7];
+ par6 += Facing.offsetsZForSide[par7];
+ double d0 = 0.0D;
+
+ if (par7 == 1 && i1 != null && i1.getRenderType() == 11)
+ {
+ d0 = 0.5D;
+ }
+
+ Entity entity = spawnCreature(par3World, par1ItemStack.getItemDamage(), (double) par4 + 0.5D, (double) par5 + d0, (double) par6 + 0.5D, par1ItemStack);
+
+ if (entity != null)
+ {
+ if (entity instanceof EntityLivingBase && par1ItemStack.hasDisplayName())
+ {
+ ((EntityLiving) entity).setCustomNameTag(par1ItemStack.getDisplayName());
+ }
+
+ if (!par2EntityPlayer.capabilities.isCreativeMode)
+ {
+ --par1ItemStack.stackSize;
+ }
+ }
+
+ return true;
+ }
+ }
+
+ /**
+ * Called whenever this item is equipped and the right mouse button is pressed. Args: itemStack, world, entityPlayer
+ */
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ if (par2World.isRemote)
+ {
+ return par1ItemStack;
+ } else
+ {
+ MovingObjectPosition movingobjectposition = this.getMovingObjectPositionFromPlayer(par2World, par3EntityPlayer, true);
+
+ if (movingobjectposition == null)
+ {
+ return par1ItemStack;
+ } else
+ {
+ if (movingobjectposition.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK)
+ {
+ int i = movingobjectposition.blockX;
+ int j = movingobjectposition.blockY;
+ int k = movingobjectposition.blockZ;
+
+ if (!par2World.canMineBlock(par3EntityPlayer, i, j, k))
+ {
+ return par1ItemStack;
+ }
+
+ if (!par3EntityPlayer.canPlayerEdit(i, j, k, movingobjectposition.sideHit, par1ItemStack))
+ {
+ return par1ItemStack;
+ }
+
+ if (par2World.getBlock(i, j, k).getMaterial() == Material.water)
+ {
+ Entity entity = spawnCreature(par2World, par1ItemStack.getItemDamage(), (double) i, (double) j, (double) k, par1ItemStack);
+
+ if (entity != null)
+ {
+ if (entity instanceof EntityLivingBase && par1ItemStack.hasDisplayName())
+ {
+ ((EntityLiving) entity).setCustomNameTag(par1ItemStack.getDisplayName());
+ }
+
+ if (!par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ --par1ItemStack.stackSize;
+ }
+ }
+ }
+ }
+
+ return par1ItemStack;
+ }
+ }
+ }
+
+ /**
+ * Spawns the creature specified by the egg's type in the location specified by the last three parameters.
+ * Parameters: world, entityID, x, y, z.
+ */
+ public static Entity spawnCreature(World par0World, int par1, double par2, double par4, double par6, ItemStack itemStack)
+ {
+// if (!EntityList.entityEggs.containsKey(Integer.valueOf(par1)))
+// {
+// return null;
+// }
+// else
+ {
+ Entity entity = null;
+
+ for (int j = 0; j < 1; ++j)
+ {
+ entity = SummoningRegistry.getEntityWithID(par0World, par1);
+
+ if (entity != null && entity instanceof EntityLivingBase)
+ {
+ EntityLiving entityliving = (EntityLiving) entity;
+ entity.setLocationAndAngles(par2, par4, par6, MathHelper.wrapAngleTo180_float(par0World.rand.nextFloat() * 360.0F), 0.0F);
+ entityliving.rotationYawHead = entityliving.rotationYaw;
+ entityliving.renderYawOffset = entityliving.rotationYaw;
+
+ //entityliving.onSpawnWithEgg((EntityLivingData)null);
+ if (entityliving instanceof EntityDemon)
+ {
+ ((EntityDemon) entityliving).func_152115_b(DemonPlacer.getOwnerName(itemStack));
+
+ if (!DemonPlacer.getOwnerName(itemStack).equals(""))
+ {
+ ((EntityDemon) entityliving).setTamed(true);
+ }
+ }
+
+ par0World.spawnEntityInWorld(entity);
+ entityliving.playLivingSound();
+ }
+ }
+
+ return entity;
+ }
+ }
+
+// @SideOnly(Side.CLIENT)
+// public boolean requiresMultipleRenderPasses()
+// {
+// return true;
+// }
+
+// @SideOnly(Side.CLIENT)
+//
+// /**
+// * Gets an icon index based on an item's damage value and the given render pass
+// */
+// public Icon getIconFromDamageForRenderPass(int par1, int par2)
+// {
+// return par2 > 0 ? this.theIcon : super.getIconFromDamageForRenderPass(par1, par2);
+// }
+
+// @SideOnly(Side.CLIENT)
+//
+// /**
+// * returns a list of items with the same ID, but different meta (eg: dye returns 16 items)
+// */
+// public void getSubItems(int par1, CreativeTabs par2CreativeTabs, List par3List)
+// {
+// Iterator iterator = EntityList.entityEggs.values().iterator();
+//
+// while (iterator.hasNext())
+// {
+// EntityEggInfo entityegginfo = (EntityEggInfo)iterator.next();
+// par3List.add(new ItemStack(par1, 1, entityegginfo.spawnedID));
+// }
+// }
+
+ public static void setOwnerName(ItemStack par1ItemStack, String ownerName)
+ {
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ par1ItemStack.stackTagCompound.setString("ownerName", ownerName);
+ }
+
+ public static String getOwnerName(ItemStack par1ItemStack)
+ {
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ return par1ItemStack.stackTagCompound.getString("ownerName");
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Used to spawn demons.");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ if (!par1ItemStack.stackTagCompound.getString("ownerName").equals(""))
+ {
+ par3List.add("Demon's Owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+ }
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:DemonPlacer");
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/DemonicTelepositionFocus.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/DemonicTelepositionFocus.java
new file mode 100644
index 00000000..d26de12d
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/DemonicTelepositionFocus.java
@@ -0,0 +1,47 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class DemonicTelepositionFocus extends TelepositionFocus
+{
+ public DemonicTelepositionFocus()
+ {
+ super(4);
+ // TODO Auto-generated constructor stub
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ //TODO
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:DemonicTeleposerFocus");
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("A stronger version of the focus,");
+ par3List.add("using a demonic shard");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ NBTTagCompound itemTag = par1ItemStack.stackTagCompound;
+
+ if (!par1ItemStack.stackTagCompound.getString("ownerName").equals(""))
+ {
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+
+ par3List.add("Coords: " + itemTag.getInteger("xCoord") + ", " + itemTag.getInteger("yCoord") + ", " + itemTag.getInteger("zCoord"));
+ par3List.add("Bound Dimension: " + getDimensionID(par1ItemStack));
+ }
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/DuskScribeTool.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/DuskScribeTool.java
new file mode 100644
index 00000000..ddbdbfe9
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/DuskScribeTool.java
@@ -0,0 +1,20 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class DuskScribeTool extends ScribeTool
+{
+ public DuskScribeTool()
+ {
+ super(5);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:DuskScribeTool");
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/EarthScribeTool.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/EarthScribeTool.java
new file mode 100644
index 00000000..290c6f91
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/EarthScribeTool.java
@@ -0,0 +1,20 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class EarthScribeTool extends ScribeTool
+{
+ public EarthScribeTool()
+ {
+ super(3);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:EarthScribeTool");
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/EnergyBattery.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/EnergyBattery.java
new file mode 100644
index 00000000..e935437e
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/EnergyBattery.java
@@ -0,0 +1,252 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.util.DamageSource;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.items.interfaces.ArmourUpgrade;
+import WayofTime.alchemicalWizardry.api.items.interfaces.IBindable;
+import WayofTime.alchemicalWizardry.api.items.interfaces.IBloodOrb;
+import WayofTime.alchemicalWizardry.api.soulNetwork.LifeEssenceNetwork;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class EnergyBattery extends Item implements ArmourUpgrade, IBindable, IBloodOrb
+{
+ private int maxEssence;
+ protected int orbLevel;
+
+ public EnergyBattery(int damage)
+ {
+ super();
+ DamageSource damageSource = DamageSource.generic;
+ setMaxStackSize(1);
+ //setMaxDamage(damage);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ //setFull3D();
+ maxEssence = damage;
+ orbLevel = 1;
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:EnergyBattery");
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Stores raw Life Essence");
+
+ //par3List.add("LP: " + (this.getMaxDamage() - this.getDamage(par1ItemStack)));
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+// EntityPlayer owner = MinecraftServer.getServer().getConfigurationManager().getPlayerForUsername(par1ItemStack.stackTagCompound.getString("ownerName"));
+// if(owner!=null)
+// {
+// NBTTagCompound tag = owner.getEntityData();
+// par3List.add("LP: " + tag.getInteger("currentEssence"));
+// }
+ }
+
+ //par3List.add("LP: " + par2EntityPlayer.getEntityData().getInteger("currentEssence"));
+ }
+
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par3EntityPlayer);
+ World world = par3EntityPlayer.worldObj;
+
+// if (par3EntityPlayer instanceof FakePlayer || par3EntityPlayer instanceof EntityPlayerMP)
+// {
+// return par1ItemStack;
+// }
+
+ if (world != null)
+ {
+ double posX = par3EntityPlayer.posX;
+ double posY = par3EntityPlayer.posY;
+ double posZ = par3EntityPlayer.posZ;
+ world.playSoundEffect((double) ((float) posX + 0.5F), (double) ((float) posY + 0.5F), (double) ((float) posZ + 0.5F), "random.fizz", 0.5F, 2.6F + (world.rand.nextFloat() - world.rand.nextFloat()) * 0.8F);
+ SpellHelper.sendIndexedParticleToAllAround(world, posX, posY, posZ, 20, world.provider.dimensionId, 4, posX, posY, posZ);
+ }
+
+// if (!(par3EntityPlayer.getClass().equals(EntityPlayerMP.class)))
+// {
+// return par1ItemStack;
+// }
+
+
+
+// if (Keyboard.isKeyDown(Keyboard.KEY_RSHIFT) || Keyboard.isKeyDown(Keyboard.KEY_LSHIFT))
+// {
+// return par1ItemStack;
+// }
+ NBTTagCompound itemTag = par1ItemStack.stackTagCompound;
+
+ if (itemTag == null || itemTag.getString("ownerName").equals(""))
+ {
+ return par1ItemStack;
+ }
+
+ if(world.isRemote)
+ {
+ return par1ItemStack;
+ }
+
+ EnergyItems.addEssenceToMaximum(itemTag.getString("ownerName"), 200, this.getMaxEssence());
+ EnergyItems.hurtPlayer(par3EntityPlayer, 200);
+ //PacketDispatcher.sendPacketToPlayer(PacketHandler.getPacket(itemTag.getString("ownerName")), (Player)par3EntityPlayer);
+// EntityPlayer owner = MinecraftServer.getServer().getConfigurationManager().getPlayerForUsername(itemTag.getString("ownerName"));
+// if(owner==null){return par1ItemStack;}
+// NBTTagCompound ownerTag = owner.getEntityData();
+// if(ownerTag.getInteger("currentEssence")<=this.maxEssence)
+// {
+// damagePlayer(par2World, par3EntityPlayer,2);
+// ownerTag.setInteger("currentEssence", Math.min(this.maxEssence, ownerTag.getInteger("currentEssence")+200/2));
+// }
+ return par1ItemStack;
+ }
+
+ /*
+ * @return the damage that was not deducted
+ */
+ public int damageItem(ItemStack par1ItemStack, int par2int)
+ {
+ if (par2int == 0)
+ {
+ return 0;
+ }
+
+ int before = this.getDamage(par1ItemStack);
+ this.setDamage(par1ItemStack, this.getDamage(par1ItemStack) + par2int);
+ return par2int - (this.getDamage(par1ItemStack) - before);
+ }
+
+ protected void damagePlayer(World world, EntityPlayer player, int damage)
+ {
+ if (world != null)
+ {
+ double posX = player.posX;
+ double posY = player.posY;
+ double posZ = player.posZ;
+ world.playSoundEffect((double) ((float) posX + 0.5F), (double) ((float) posY + 0.5F), (double) ((float) posZ + 0.5F), "random.fizz", 0.5F, 2.6F + (world.rand.nextFloat() - world.rand.nextFloat()) * 0.8F);
+ float f = (float) 1.0F;
+ float f1 = f * 0.6F + 0.4F;
+ float f2 = f * f * 0.7F - 0.5F;
+ float f3 = f * f * 0.6F - 0.7F;
+
+ for (int l = 0; l < 8; ++l)
+ {
+ world.spawnParticle("reddust", posX + Math.random() - Math.random(), posY + Math.random() - Math.random(), posZ + Math.random() - Math.random(), f1, f2, f3);
+ }
+ }
+
+ if (!player.capabilities.isCreativeMode)
+ {
+ for (int i = 0; i < damage; i++)
+ {
+ player.setHealth((player.getHealth() - 1));
+ //player.setEntityHealth(player.func_110143_aJ() - 1);
+ }
+ }
+
+ if (player.getHealth() <= 0)
+ {
+ player.inventory.dropAllItems();
+ }
+ }
+
+ public int getMaxEssence()
+ {
+ return this.maxEssence;
+ }
+
+ public int getOrbLevel()
+ {
+ return orbLevel;
+ }
+
+ @Override
+ public void onArmourUpdate(World world, EntityPlayer player, ItemStack thisItemStack)
+ {
+ }
+
+ @Override
+ public boolean isUpgrade()
+ {
+ return false;
+ }
+
+ @Override
+ public int getEnergyForTenSeconds()
+ {
+ return 0;
+ }
+
+ @Override
+ public ItemStack getContainerItem(ItemStack itemStack)
+ {
+ //if(!syphonBatteries(itemStack, null, 10))
+ {
+ //syphonWhileInContainer(itemStack, this.getEnergyUsed());
+// ItemStack copiedStack = itemStack.copy();
+// copiedStack.setItemDamage(copiedStack.getItemDamage());
+// copiedStack.stackSize = 1;
+// return copiedStack;
+ }
+ return itemStack;
+ }
+
+ @Override
+ public boolean hasContainerItem()
+ {
+ return true;
+ }
+
+ //@SideOnly(Side.SERVER)
+ public int getCurrentEssence(ItemStack par1ItemStack)
+ {
+ if (par1ItemStack == null)
+ {
+ return 0;
+ }
+
+ NBTTagCompound itemTag = par1ItemStack.stackTagCompound;
+
+ if (itemTag == null || itemTag.getString("ownerName").equals(""))
+ {
+ return 0;
+ }
+
+ String owner = itemTag.getString("ownerName");
+ World worldSave = MinecraftServer.getServer().worldServers[0];
+ LifeEssenceNetwork data = (LifeEssenceNetwork) worldSave.loadItemData(LifeEssenceNetwork.class, owner);
+
+ if (data == null)
+ {
+ data = new LifeEssenceNetwork(owner);
+ worldSave.setItemData(owner, data);
+ }
+
+ int currentEssence = data.currentEssence;
+ return (currentEssence);
+ }
+
+ @Override
+ public boolean doesContainerItemLeaveCraftingGrid(ItemStack itemStack)
+ {
+ return false;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/EnergyBazooka.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/EnergyBazooka.java
new file mode 100644
index 00000000..be0eddc2
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/EnergyBazooka.java
@@ -0,0 +1,219 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.Vec3;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.common.entity.projectile.EntityEnergyBazookaMainProjectile;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class EnergyBazooka extends EnergyItems
+{
+ private static IIcon activeIcon;
+ private static IIcon passiveIcon;
+ private static int damage;
+ //private static int delay;
+ private static final int maxDelay = 150;
+
+ public EnergyBazooka()
+ {
+ super();
+ setMaxStackSize(1);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ setFull3D();
+ setMaxDamage(250);
+ this.setEnergyUsed(20000);
+ damage = 12;
+ //delay = 0;
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:EnergyBazooka_activated");
+ this.activeIcon = iconRegister.registerIcon("AlchemicalWizardry:EnergyBazooka_activated");
+ this.passiveIcon = iconRegister.registerIcon("AlchemicalWizardry:SheathedItem");
+ }
+
+ @Override
+ public IIcon getIcon(ItemStack stack, int renderPass, EntityPlayer player, ItemStack usingItem, int useRemaining)
+ {
+ if (stack.stackTagCompound == null)
+ {
+ stack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = stack.stackTagCompound;
+
+ if (tag.getBoolean("isActive"))
+ {
+ return this.activeIcon;
+ } else
+ {
+ return this.passiveIcon;
+ }
+ }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par3EntityPlayer);
+
+ if (par3EntityPlayer.isSneaking())
+ {
+ this.setActivated(par1ItemStack, !getActivated(par1ItemStack));
+ par1ItemStack.stackTagCompound.setInteger("worldTimeDelay", (int) (par2World.getWorldTime() - 1) % 100);
+ return par1ItemStack;
+ }
+
+ if (!getActivated(par1ItemStack))
+ {
+ return par1ItemStack;
+ }
+
+ if (this.getDelay(par1ItemStack) > 0)
+ {
+ return par1ItemStack;
+ }
+
+ if (!par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ this.syphonBatteries(par1ItemStack, par3EntityPlayer, this.getEnergyUsed());
+ }
+
+ par2World.playSoundAtEntity(par3EntityPlayer, "random.bow", 0.5F, 0.4F / (itemRand.nextFloat() * 0.4F + 0.8F));
+
+ if (!par2World.isRemote)
+ {
+ //par2World.spawnEntityInWorld(new EntityEnergyBazookaMainProjectile(par2World, par3EntityPlayer, damage));
+ par2World.spawnEntityInWorld(new EntityEnergyBazookaMainProjectile(par2World, par3EntityPlayer, damage));
+ this.setDelay(par1ItemStack, maxDelay);
+ }
+
+ Vec3 vec = par3EntityPlayer.getLookVec();
+ double wantedVelocity = 3.0f;
+ par3EntityPlayer.motionX = -vec.xCoord * wantedVelocity;
+ par3EntityPlayer.motionY = -vec.yCoord * wantedVelocity;
+ par3EntityPlayer.motionZ = -vec.zCoord * wantedVelocity;
+ par2World.playSoundEffect((double) ((float) par3EntityPlayer.posX + 0.5F), (double) ((float) par3EntityPlayer.posY + 0.5F), (double) ((float) par3EntityPlayer.posZ + 0.5F), "random.fizz", 0.5F, 2.6F + (par2World.rand.nextFloat() - par2World.rand.nextFloat()) * 0.8F);
+ par3EntityPlayer.fallDistance = 0;
+ return par1ItemStack;
+ }
+
+ @Override
+ public void onUpdate(ItemStack par1ItemStack, World par2World, Entity par3Entity, int par4, boolean par5)
+ {
+ if (!(par3Entity instanceof EntityPlayer))
+ {
+ return;
+ }
+
+ EntityPlayer par3EntityPlayer = (EntityPlayer) par3Entity;
+
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+// if(par1ItemStack.stackTagCompound.getBoolean("isActive"))
+// {
+// EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, 1);
+// }
+ int delay = this.getDelay(par1ItemStack);
+
+ if (!par2World.isRemote && delay > 0)
+ {
+ this.setDelay(par1ItemStack, delay - 1);
+ }
+
+ if (par2World.getWorldTime() % 100 == par1ItemStack.stackTagCompound.getInteger("worldTimeDelay") && par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ if (!par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, 50);
+ }
+ }
+
+ par1ItemStack.setItemDamage(0);
+ return;
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Boom.");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ if (par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ par3List.add("Activated");
+ } else
+ {
+ par3List.add("Deactivated");
+ }
+
+ if (!par1ItemStack.stackTagCompound.getString("ownerName").equals(""))
+ {
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+ }
+ }
+
+ public void setActivated(ItemStack par1ItemStack, boolean newActivated)
+ {
+ NBTTagCompound itemTag = par1ItemStack.stackTagCompound;
+
+ if (itemTag == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ itemTag.setBoolean("isActive", newActivated);
+ }
+
+ public boolean getActivated(ItemStack par1ItemStack)
+ {
+ NBTTagCompound itemTag = par1ItemStack.stackTagCompound;
+
+ if (itemTag == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ return itemTag.getBoolean("isActive");
+ }
+
+ public void setDelay(ItemStack par1ItemStack, int newDelay)
+ {
+ NBTTagCompound itemTag = par1ItemStack.stackTagCompound;
+
+ if (itemTag == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ itemTag.setInteger("delay", newDelay);
+ }
+
+ public int getDelay(ItemStack par1ItemStack)
+ {
+ NBTTagCompound itemTag = par1ItemStack.stackTagCompound;
+
+ if (itemTag == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ return itemTag.getInteger("delay");
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/EnergyBlast.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/EnergyBlast.java
new file mode 100644
index 00000000..298c950d
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/EnergyBlast.java
@@ -0,0 +1,214 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.common.entity.projectile.EnergyBlastProjectile;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class EnergyBlast extends EnergyItems
+{
+ private static IIcon activeIcon;
+ private static IIcon passiveIcon;
+ private static int damage;
+ //private static int delay;
+ private static final int maxDelay = 15;
+
+ public EnergyBlast()
+ {
+ super();
+ setMaxStackSize(1);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ setUnlocalizedName("energyBlaster");
+ setFull3D();
+ setMaxDamage(250);
+ this.setEnergyUsed(150);
+ damage = 12;
+ //delay = 0;
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:EnergyBlaster_activated");
+ this.activeIcon = iconRegister.registerIcon("AlchemicalWizardry:EnergyBlaster_activated");
+ this.passiveIcon = iconRegister.registerIcon("AlchemicalWizardry:SheathedItem");
+ }
+
+ @Override
+ public IIcon getIcon(ItemStack stack, int renderPass, EntityPlayer player, ItemStack usingItem, int useRemaining)
+ {
+ if (stack.stackTagCompound == null)
+ {
+ stack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = stack.stackTagCompound;
+
+ if (tag.getBoolean("isActive"))
+ {
+ return this.activeIcon;
+ } else
+ {
+ return this.passiveIcon;
+ }
+ }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par3EntityPlayer);
+
+ if (par3EntityPlayer.isSneaking())
+ {
+ this.setActivated(par1ItemStack, !getActivated(par1ItemStack));
+ par1ItemStack.stackTagCompound.setInteger("worldTimeDelay", (int) (par2World.getWorldTime() - 1) % 100);
+ return par1ItemStack;
+ }
+
+ if (!getActivated(par1ItemStack))
+ {
+ return par1ItemStack;
+ }
+
+ if (this.getDelay(par1ItemStack) > 0)
+ {
+ return par1ItemStack;
+ }
+
+ if (!par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ this.syphonBatteries(par1ItemStack, par3EntityPlayer, this.getEnergyUsed());
+ }
+
+ par2World.playSoundAtEntity(par3EntityPlayer, "random.bow", 0.5F, 0.4F / (itemRand.nextFloat() * 0.4F + 0.8F));
+
+ if (!par2World.isRemote)
+ {
+ //par2World.spawnEntityInWorld(new EnergyBlastProjectile(par2World, par3EntityPlayer, damage));
+ par2World.spawnEntityInWorld(new EnergyBlastProjectile(par2World, par3EntityPlayer, damage));
+ this.setDelay(par1ItemStack, maxDelay);
+ }
+
+ return par1ItemStack;
+ }
+
+ @Override
+ public void onUpdate(ItemStack par1ItemStack, World par2World, Entity par3Entity, int par4, boolean par5)
+ {
+ if (!(par3Entity instanceof EntityPlayer))
+ {
+ return;
+ }
+
+ EntityPlayer par3EntityPlayer = (EntityPlayer) par3Entity;
+
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+// if(par1ItemStack.stackTagCompound.getBoolean("isActive"))
+// {
+// EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, 1);
+// }
+ int delay = this.getDelay(par1ItemStack);
+
+ if (!par2World.isRemote && delay > 0)
+ {
+ this.setDelay(par1ItemStack, delay - 1);
+ }
+
+ if (par2World.getWorldTime() % 100 == par1ItemStack.stackTagCompound.getInteger("worldTimeDelay") && par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ if (!par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, 50);
+ }
+ }
+
+ par1ItemStack.setItemDamage(0);
+ return;
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Used to fire devastating");
+ par3List.add("projectiles.");
+ par3List.add("Damage: " + damage);
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ if (par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ par3List.add("Activated");
+ } else
+ {
+ par3List.add("Deactivated");
+ }
+
+ if (!par1ItemStack.stackTagCompound.getString("ownerName").equals(""))
+ {
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+ }
+ }
+
+ public void setActivated(ItemStack par1ItemStack, boolean newActivated)
+ {
+ NBTTagCompound itemTag = par1ItemStack.stackTagCompound;
+
+ if (itemTag == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ itemTag.setBoolean("isActive", newActivated);
+ }
+
+ public boolean getActivated(ItemStack par1ItemStack)
+ {
+ NBTTagCompound itemTag = par1ItemStack.stackTagCompound;
+
+ if (itemTag == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ return itemTag.getBoolean("isActive");
+ }
+
+ public void setDelay(ItemStack par1ItemStack, int newDelay)
+ {
+ NBTTagCompound itemTag = par1ItemStack.stackTagCompound;
+
+ if (itemTag == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ itemTag.setInteger("delay", newDelay);
+ }
+
+ public int getDelay(ItemStack par1ItemStack)
+ {
+ NBTTagCompound itemTag = par1ItemStack.stackTagCompound;
+
+ if (itemTag == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ return itemTag.getInteger("delay");
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/EnergyItems.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/EnergyItems.java
new file mode 100644
index 00000000..88b7ef89
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/EnergyItems.java
@@ -0,0 +1,366 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.util.DamageSource;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.items.interfaces.IBindable;
+import WayofTime.alchemicalWizardry.api.soulNetwork.LifeEssenceNetwork;
+import WayofTime.alchemicalWizardry.api.soulNetwork.SoulNetworkHandler;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+
+public class EnergyItems extends Item implements IBindable
+{
+ private int energyUsed;
+
+ public EnergyItems()
+ {
+ super();
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ }
+
+ protected void setEnergyUsed(int par1int)
+ {
+ this.energyUsed = par1int;
+ }
+
+ protected int getEnergyUsed()
+ {
+ return this.energyUsed;
+ }
+ //Heals the player using the item. If the player is at full health, or if the durability cannot be used any more,
+ //the item is not used.
+
+ protected void damagePlayer(World world, EntityPlayer player, int damage)
+ {
+ if (world != null)
+ {
+ double posX = player.posX;
+ double posY = player.posY;
+ double posZ = player.posZ;
+ world.playSoundEffect((double) ((float) posX + 0.5F), (double) ((float) posY + 0.5F), (double) ((float) posZ + 0.5F), "random.fizz", 0.5F, 2.6F + (world.rand.nextFloat() - world.rand.nextFloat()) * 0.8F);
+ float f = (float) 1.0F;
+ float f1 = f * 0.6F + 0.4F;
+ float f2 = f * f * 0.7F - 0.5F;
+ float f3 = f * f * 0.6F - 0.7F;
+
+ for (int l = 0; l < 8; ++l)
+ {
+ world.spawnParticle("reddust", posX + Math.random() - Math.random(), posY + Math.random() - Math.random(), posZ + Math.random() - Math.random(), f1, f2, f3);
+ }
+ }
+
+ for (int i = 0; i < damage; i++)
+ {
+ //player.setEntityHealth((player.getHealth()-1));
+ player.setHealth((player.getHealth() - 1));
+
+ if (player.getHealth() <= 0.0005)
+ {
+ player.inventory.dropAllItems();
+ break;
+ }
+ }
+ }
+
+ public static boolean syphonBatteries(ItemStack ist, EntityPlayer player, int damageToBeDone)
+ {
+ if (!player.worldObj.isRemote)
+ {
+ return syphonAndDamageWhileInContainer(ist, player, damageToBeDone);
+ } else
+ {
+ World world = player.worldObj;
+
+ if (world != null)
+ {
+ double posX = player.posX;
+ double posY = player.posY;
+ double posZ = player.posZ;
+ //if(particles)
+ {
+ SpellHelper.sendIndexedParticleToAllAround(world, posX, posY, posZ, 20, world.provider.dimensionId, 4, posX, posY, posZ);
+ world.playSoundEffect((double) ((float) player.posX + 0.5F), (double) ((float) player.posY + 0.5F), (double) ((float) player.posZ + 0.5F), "random.fizz", 0.5F, 2.6F + (world.rand.nextFloat() - world.rand.nextFloat()) * 0.8F);
+ }
+ }
+ }
+
+ return true;
+ //return syphonBatteriesWithoutParticles(ist, player, damageToBeDone, true);
+ }
+
+ public static boolean syphonWhileInContainer(ItemStack ist, int damageToBeDone)
+ {
+ if (ist.getTagCompound() != null && !(ist.getTagCompound().getString("ownerName").equals("")))
+ {
+ String ownerName = ist.getTagCompound().getString("ownerName");
+
+ if (MinecraftServer.getServer() == null)
+ {
+ return false;
+ }
+
+ World world = MinecraftServer.getServer().worldServers[0];
+ LifeEssenceNetwork data = (LifeEssenceNetwork) world.loadItemData(LifeEssenceNetwork.class, ownerName);
+
+ if (data == null)
+ {
+ data = new LifeEssenceNetwork(ownerName);
+ world.setItemData(ownerName, data);
+ }
+
+ if (data.currentEssence >= damageToBeDone)
+ {
+ data.currentEssence -= damageToBeDone;
+ data.markDirty();
+ return true;
+ }
+
+// EntityPlayer ownerEntity = MinecraftServer.getServer().getConfigurationManager().getPlayerForUsername(ist.getTagCompound().getString("ownerName"));
+// if(ownerEntity==null){return false;}
+// NBTTagCompound tag = ownerEntity.getEntityData();
+// int currentEssence = tag.getInteger("currentEssence");
+// if(currentEssence>=damageToBeDone)
+// {
+// tag.setInteger("currentEssence", currentEssence-damageToBeDone);
+// return true;
+// }
+ }
+
+ return false;
+ }
+
+ public static boolean canSyphonInContainer(ItemStack ist, int damageToBeDone)
+ {
+ if (ist.getTagCompound() != null && !(ist.getTagCompound().getString("ownerName").equals("")))
+ {
+ String ownerName = ist.getTagCompound().getString("ownerName");
+
+ if (MinecraftServer.getServer() == null)
+ {
+ return false;
+ }
+
+ World world = MinecraftServer.getServer().worldServers[0];
+ LifeEssenceNetwork data = (LifeEssenceNetwork) world.loadItemData(LifeEssenceNetwork.class, ownerName);
+
+ if (data == null)
+ {
+ data = new LifeEssenceNetwork(ownerName);
+ world.setItemData(ownerName, data);
+ }
+
+ return data.currentEssence >= damageToBeDone;
+// EntityPlayer ownerEntity = MinecraftServer.getServer().getConfigurationManager().getPlayerForUsername(ist.getTagCompound().getString("ownerName"));
+// if(ownerEntity==null){return false;}
+// NBTTagCompound tag = ownerEntity.getEntityData();
+// int currentEssence = tag.getInteger("currentEssence");
+// if(currentEssence>=damageToBeDone)
+// {
+// tag.setInteger("currentEssence", currentEssence-damageToBeDone);
+// return true;
+// }
+ }
+
+ return false;
+ }
+
+ public static void hurtPlayer(EntityPlayer user, int energySyphoned)
+ {
+ if (energySyphoned < 100 && energySyphoned > 0)
+ {
+ if (!user.capabilities.isCreativeMode)
+ {
+ //player.setEntityHealth((player.getHealth()-1));
+ user.setHealth((user.getHealth() - 1));
+
+ if (user.getHealth() <= 0.0005f)
+ {
+ user.onDeath(DamageSource.generic);
+
+ }
+ }
+ } else if (energySyphoned >= 100)
+ {
+ if (!user.capabilities.isCreativeMode)
+ {
+ for (int i = 0; i < ((energySyphoned + 99) / 100); i++)
+ {
+ //player.setEntityHealth((player.getHealth()-1));
+ user.setHealth((user.getHealth() - 1));
+
+ if (user.getHealth() <= 0.0005f)
+ {
+ user.onDeath(DamageSource.generic);
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ public static boolean syphonAndDamageWhileInContainer(ItemStack ist, EntityPlayer player, int damageToBeDone)
+ {
+ if (!syphonWhileInContainer(ist, damageToBeDone))
+ {
+ hurtPlayer(player, damageToBeDone);
+ }
+
+ return true;
+ }
+
+ //Global static methods
+ public static void checkAndSetItemOwner(ItemStack item, EntityPlayer player)
+ {
+ if (item.stackTagCompound == null)
+ {
+ item.setTagCompound(new NBTTagCompound());
+ }
+
+ if (item.stackTagCompound.getString("ownerName").equals(""))
+ {
+ item.stackTagCompound.setString("ownerName", SoulNetworkHandler.getUsername(player));
+ }
+
+ initializePlayer(player);
+ }
+
+ public static void setItemOwner(ItemStack item, String ownerName)
+ {
+ if (item.stackTagCompound == null)
+ {
+ item.setTagCompound(new NBTTagCompound());
+ }
+
+ item.stackTagCompound.setString("ownerName", ownerName);
+ }
+
+ public static void checkAndSetItemOwner(ItemStack item, String ownerName)
+ {
+ if (item.stackTagCompound == null)
+ {
+ item.setTagCompound(new NBTTagCompound());
+ }
+
+ if (item.stackTagCompound.getString("ownerName").equals(""))
+ {
+ item.stackTagCompound.setString("ownerName", ownerName);
+ }
+ }
+
+ public static void initializePlayer(EntityPlayer player)
+ {
+ NBTTagCompound tag = player.getEntityData();
+
+ if (tag.getInteger("currentEssence") == 0)
+ {
+ tag.setInteger("currentEssence", 0);
+ }
+ }
+
+ public static String getOwnerName(ItemStack item)
+ {
+ if (item.stackTagCompound == null)
+ {
+ item.setTagCompound(new NBTTagCompound());
+ }
+
+ return item.stackTagCompound.getString("ownerName");
+ }
+
+ public static void drainPlayerNetwork(EntityPlayer player, int damageToBeDone)
+ {
+ String ownerName = SpellHelper.getUsername(player);
+
+ if (MinecraftServer.getServer() == null)
+ {
+ return;
+ }
+
+ World world = MinecraftServer.getServer().worldServers[0];
+ LifeEssenceNetwork data = (LifeEssenceNetwork) world.loadItemData(LifeEssenceNetwork.class, ownerName);
+
+ if (data == null)
+ {
+ data = new LifeEssenceNetwork(ownerName);
+ world.setItemData(ownerName, data);
+ }
+
+ if (data.currentEssence >= damageToBeDone)
+ {
+ data.currentEssence -= damageToBeDone;
+ data.markDirty();
+ }else
+ {
+ hurtPlayer(player, damageToBeDone);
+ }
+ }
+
+ public static int getCurrentEssence(String ownerName)
+ {
+ if (MinecraftServer.getServer() == null)
+ {
+ return 0;
+ }
+
+ World world = MinecraftServer.getServer().worldServers[0];
+ LifeEssenceNetwork data = (LifeEssenceNetwork) world.loadItemData(LifeEssenceNetwork.class, ownerName);
+
+ if (data == null)
+ {
+ data = new LifeEssenceNetwork(ownerName);
+ world.setItemData(ownerName, data);
+ }
+
+ return data.currentEssence;
+ }
+
+ public static void setCurrentEssence(String ownerName, int amount)
+ {
+ if (MinecraftServer.getServer() == null)
+ {
+ return;
+ }
+
+ World world = MinecraftServer.getServer().worldServers[0];
+ LifeEssenceNetwork data = (LifeEssenceNetwork) world.loadItemData(LifeEssenceNetwork.class, ownerName);
+
+ if (data == null)
+ {
+ data = new LifeEssenceNetwork(ownerName);
+ world.setItemData(ownerName, data);
+ }
+
+ data.currentEssence = amount;
+ data.markDirty();
+ }
+
+ public static void addEssenceToMaximum(String ownerName, int amount, int maximum)
+ {
+ if (MinecraftServer.getServer() == null)
+ {
+ return;
+ }
+
+ World world = MinecraftServer.getServer().worldServers[0];
+ LifeEssenceNetwork data = (LifeEssenceNetwork) world.loadItemData(LifeEssenceNetwork.class, ownerName);
+
+ if (data == null)
+ {
+ data = new LifeEssenceNetwork(ownerName);
+ world.setItemData(ownerName, data);
+ }
+
+ if(data.currentEssence>=maximum)
+ {
+ return;
+ }
+
+ data.currentEssence = Math.min(maximum, data.currentEssence + amount);
+ data.markDirty();
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/EnergySword.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/EnergySword.java
new file mode 100644
index 00000000..a4578599
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/EnergySword.java
@@ -0,0 +1,238 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.ItemSword;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.potion.Potion;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class EnergySword extends ItemSword
+{
+ //private float weaponDamaged;
+ //private int maxMode = 3;
+ private NBTTagCompound data;
+
+ private static IIcon activeIcon;
+ private static IIcon passiveIcon;
+
+ private int energyUsed;
+
+ public EnergySword()
+ {
+ super(AlchemicalWizardry.bloodBoundToolMaterial);
+ this.maxStackSize = 1;
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ setEnergyUsed(50);
+ setFull3D();
+ setMaxDamage(100);
+ //weaponDamaged = 12.0F;
+ }
+
+ public void setEnergyUsed(int i)
+ {
+ energyUsed = i;
+ }
+
+ public int getEnergyUsed()
+ {
+ return this.energyUsed;
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:BoundSword_activated");
+ this.activeIcon = iconRegister.registerIcon("AlchemicalWizardry:BoundSword_activated");
+ this.passiveIcon = iconRegister.registerIcon("AlchemicalWizardry:SheathedItem");
+ }
+
+ @Override
+ public IIcon getIcon(ItemStack stack, int renderPass, EntityPlayer player, ItemStack usingItem, int useRemaining)
+ {
+ if (stack.stackTagCompound == null)
+ {
+ stack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = stack.stackTagCompound;
+
+ if (tag.getBoolean("isActive"))
+ {
+ return this.activeIcon;
+ } else
+ {
+ return this.passiveIcon;
+ }
+ }
+
+ @Override
+ public boolean onLeftClickEntity(ItemStack stack, EntityPlayer player, Entity entity)
+ {
+ return !getActivated(stack);
+ }
+
+ @Override
+ public boolean hitEntity(ItemStack par1ItemStack, EntityLivingBase par2EntityLivingBase, EntityLivingBase par3EntityLivingBase)
+ {
+ if (par3EntityLivingBase instanceof EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, (EntityPlayer) par3EntityLivingBase);
+
+ if (!EnergyItems.syphonBatteries(par1ItemStack, (EntityPlayer) par3EntityLivingBase, this.getEnergyUsed()))
+ {
+ //this.damagePlayer(null, (EntityPlayer)par3EntityLivingBase, (this.getEnergyUsed() + 99) / 100);
+ }
+ }
+
+ par2EntityLivingBase.addPotionEffect(new PotionEffect(Potion.weakness.id, 60, 2));
+ return true;
+ }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par3EntityPlayer);
+
+ if (par3EntityPlayer.isSneaking())
+ {
+ this.setActivated(par1ItemStack, !getActivated(par1ItemStack));
+ par1ItemStack.stackTagCompound.setInteger("worldTimeDelay", (int) (par2World.getWorldTime() - 1) % 100);
+ return par1ItemStack;
+ }
+
+ if (!getActivated(par1ItemStack))
+ {
+ return par1ItemStack;
+ }
+
+ return par1ItemStack;
+ }
+
+ @Override
+ public int getItemEnchantability()
+ {
+ return 30;
+ }
+
+ @Override
+ public void onUpdate(ItemStack par1ItemStack, World par2World, Entity par3Entity, int par4, boolean par5)
+ {
+ if (!(par3Entity instanceof EntityPlayer))
+ {
+ return;
+ }
+
+ EntityPlayer par3EntityPlayer = (EntityPlayer) par3Entity;
+
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+// if(par1ItemStack.stackTagCompound.getBoolean("isActive"))
+// {
+// EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, 1);
+// }
+
+ if (par2World.getWorldTime() % 100 == par1ItemStack.stackTagCompound.getInteger("worldTimeDelay") && par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ if (!par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, 50);
+ }
+ }
+
+ par1ItemStack.setItemDamage(0);
+ return;
+ }
+
+ public void setActivated(ItemStack par1ItemStack, boolean newActivated)
+ {
+ NBTTagCompound itemTag = par1ItemStack.stackTagCompound;
+
+ if (itemTag == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ itemTag.setBoolean("isActive", newActivated);
+ }
+
+ public boolean getActivated(ItemStack par1ItemStack)
+ {
+ NBTTagCompound itemTag = par1ItemStack.stackTagCompound;
+
+ if (itemTag == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ return itemTag.getBoolean("isActive");
+ }
+
+// public int getDamageVsEntity(Entity par1Entity)
+// {
+// return (int) this.weaponDamage;
+// }
+
+ public float func_82803_g()
+ {
+ return 4.0F;
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Caution: may cause");
+ par3List.add("a bad day...");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ if (par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ par3List.add("Activated");
+ } else
+ {
+ par3List.add("Deactivated");
+ }
+
+ if (!par1ItemStack.stackTagCompound.getString("ownerName").equals(""))
+ {
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+ }
+ }
+
+ @Override
+ public float func_150893_a(ItemStack par1ItemStack, Block par2Block)
+ {
+ if (par2Block == Blocks.web)
+ {
+ return 15.0F;
+ } else
+ {
+ Material material = par2Block.getMaterial();
+ return material != Material.plants && material != Material.vine && material != Material.coral && material != Material.leaves && material != Material.gourd ? 1.0F : 1.5F;
+ }
+ }
+
+// public boolean getIsRepairable(ItemStack par1ItemStack, ItemStack par2ItemStack)
+// {
+// return false;
+// }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/EnhancedTelepositionFocus.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/EnhancedTelepositionFocus.java
new file mode 100644
index 00000000..4753fc05
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/EnhancedTelepositionFocus.java
@@ -0,0 +1,46 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class EnhancedTelepositionFocus extends TelepositionFocus
+{
+ public EnhancedTelepositionFocus()
+ {
+ super(2);
+ // TODO Auto-generated constructor stub
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ //TODO
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:EnhancedTeleposerFocus");
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("A focus further enhanced in an altar");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ NBTTagCompound itemTag = par1ItemStack.stackTagCompound;
+
+ if (!par1ItemStack.stackTagCompound.getString("ownerName").equals(""))
+ {
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+
+ par3List.add("Coords: " + itemTag.getInteger("xCoord") + ", " + itemTag.getInteger("yCoord") + ", " + itemTag.getInteger("zCoord"));
+ par3List.add("Bound Dimension: " + getDimensionID(par1ItemStack));
+ }
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/FireScribeTool.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/FireScribeTool.java
new file mode 100644
index 00000000..18fc3a52
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/FireScribeTool.java
@@ -0,0 +1,20 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class FireScribeTool extends ScribeTool
+{
+ public FireScribeTool()
+ {
+ super(2);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:FireScribeTool");
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ItemAlchemyBase.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ItemAlchemyBase.java
new file mode 100644
index 00000000..8319c4a8
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ItemAlchemyBase.java
@@ -0,0 +1,107 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.MathHelper;
+import net.minecraft.world.World;
+
+import org.lwjgl.input.Keyboard;
+
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.alchemy.AlchemyRecipeRegistry;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class ItemAlchemyBase extends Item
+{
+ private static final String[] ITEM_NAMES = new String[]{"Offensa","Praesidium","OrbisTerrae","StrengthenedCatalyst","ConcentratedCatalyst","FracturedBone","Virtus","Reductus","Potentia"};
+
+ @SideOnly(Side.CLIENT)
+ private IIcon[] icons;
+
+ public ItemAlchemyBase()
+ {
+ super();
+ this.maxStackSize = 64;
+ this.setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ this.hasSubtypes = true;
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ icons = new IIcon[ITEM_NAMES.length];
+
+ for (int i = 0; i < ITEM_NAMES.length; ++i)
+ {
+ icons[i] = iconRegister.registerIcon("AlchemicalWizardry:" + "baseAlchemyItem" + ITEM_NAMES[i]);
+ }
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Used in alchemy");
+
+ if (Keyboard.isKeyDown(Keyboard.KEY_RSHIFT) || Keyboard.isKeyDown(Keyboard.KEY_LSHIFT))
+ {
+ ItemStack[] recipe = AlchemyRecipeRegistry.getRecipeForItemStack(par1ItemStack);
+
+ if (recipe != null)
+ {
+ par3List.add(EnumChatFormatting.BLUE + "Recipe:");
+
+ for (ItemStack item : recipe)
+ {
+ if (item != null)
+ {
+ par3List.add("" + item.getDisplayName());
+ }
+ }
+ }
+ } else
+ {
+ par3List.add("-Press " + EnumChatFormatting.BLUE + "shift" + EnumChatFormatting.GRAY + " for Recipe-");
+ }
+ }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ return par1ItemStack;
+ }
+
+ @Override
+ public String getUnlocalizedName(ItemStack itemStack)
+ {
+ //This is what will do all the localisation things on the alchemy components so you dont have to set it :D
+ int meta = MathHelper.clamp_int(itemStack.getItemDamage(), 0, ITEM_NAMES.length - 1);
+ return ("" + "item.bloodMagicAlchemyItem." + ITEM_NAMES[meta]);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public IIcon getIconFromDamage(int meta)
+ {
+ int j = MathHelper.clamp_int(meta, 0, ITEM_NAMES.length - 1);
+ return icons[j];
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void getSubItems(Item id, CreativeTabs creativeTab, List list)
+ {
+ for (int meta = 0; meta < ITEM_NAMES.length; ++meta)
+ {
+ list.add(new ItemStack(id, 1, meta));
+ }
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ItemBlockCrystalBelljar.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ItemBlockCrystalBelljar.java
new file mode 100644
index 00000000..7788b60b
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ItemBlockCrystalBelljar.java
@@ -0,0 +1,96 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.Constants;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentContainer;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentStack;
+
+public class ItemBlockCrystalBelljar extends ItemBlock
+{
+ public ItemBlockCrystalBelljar(Block par1)
+ {
+ super(par1);
+// this.setUnlocalizedName("itemSpellEnhancementBlock");
+// setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ this.setHasSubtypes(true);
+ this.setMaxDamage(0);
+ this.setMaxStackSize(16);
+ }
+
+ public int getMetadata(int par1)
+ {
+ return par1;
+ }
+
+ public ReagentContainer[] getReagentContainers(ItemStack stack)
+ {
+ if(stack != null && stack.hasTagCompound())
+ {
+ NBTTagCompound tag = stack.getTagCompound();
+
+ NBTTagList tagList = tag.getTagList("reagentTanks", Constants.NBT.TAG_COMPOUND);
+
+ int size = tagList.tagCount();
+ ReagentContainer[] tanks = new ReagentContainer[size];
+
+ for(int i=0; i ritualList = Rituals.getRitualList(this.getCurrentRitual(par1ItemStack));
+ if(ritualList == null)
+ {
+ return;
+ }
+
+ int blankStones = 0;
+ int airStones = 0;
+ int waterStones = 0;
+ int fireStones = 0;
+ int earthStones = 0;
+ int duskStones = 0;
+
+ for (RitualComponent rc : ritualList)
+ {
+ switch (rc.getStoneType())
+ {
+ case RitualComponent.BLANK:
+ blankStones++;
+ break;
+
+ case RitualComponent.AIR:
+ airStones++;
+ break;
+
+ case RitualComponent.WATER:
+ waterStones++;
+ break;
+
+ case RitualComponent.FIRE:
+ fireStones++;
+ break;
+
+ case RitualComponent.EARTH:
+ earthStones++;
+ break;
+
+ case RitualComponent.DUSK:
+ duskStones++;
+ break;
+ }
+ }
+
+ par3List.add("Blank stones: " + blankStones);
+ par3List.add(EnumChatFormatting.AQUA + "Air stones: " + airStones);
+ par3List.add(EnumChatFormatting.BLUE + "Water stones: " + waterStones);
+ par3List.add(EnumChatFormatting.RED + "Fire stones: " + fireStones);
+ par3List.add(EnumChatFormatting.DARK_GREEN + "Earth stones: " + earthStones);
+ par3List.add(EnumChatFormatting.BOLD + "Dusk stones: " + duskStones);
+ //par3List.add("Ritual Name: " + Rituals.getNameOfRitual(ritualID));
+ }
+ }
+
+ @Override
+ public String getItemStackDisplayName(ItemStack par1ItemStack)
+ {
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ String ritualID = this.getCurrentRitual(par1ItemStack);
+ if(ritualID.equals(""))
+ {
+ return super.getItemStackDisplayName(par1ItemStack);
+ }
+ return "Ritual: " + Rituals.getNameOfRitual(ritualID);
+ //par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ } else
+ {
+ return super.getItemStackDisplayName(par1ItemStack);
+ }
+ }
+
+ @Override
+ public boolean onItemUse(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, World par3World, int par4, int par5, int par6, int par7, float par8, float par9, float par10)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par2EntityPlayer);
+ ItemStack[] playerInventory = par2EntityPlayer.inventory.mainInventory;
+ TileEntity tileEntity = par3World.getTileEntity(par4, par5, par6);
+
+ if (tileEntity instanceof TEMasterStone)
+ {
+ TEMasterStone masterStone = (TEMasterStone) tileEntity;
+ List ritualList = Rituals.getRitualList(this.getCurrentRitual(par1ItemStack));
+ if(ritualList == null)
+ {
+ return false;
+ }
+
+ int playerInvRitualStoneLocation = -1;
+
+ for (int i = 0; i < playerInventory.length; i++)
+ {
+ if (playerInventory[i] == null)
+ {
+ continue;
+ }
+
+ if (new ItemStack(ModBlocks.ritualStone).isItemEqual(playerInventory[i]))
+ {
+ playerInvRitualStoneLocation = i;
+ break;
+ }
+ }
+
+ for (RitualComponent rc : ritualList)
+ {
+ if (par3World.isAirBlock(par4 + rc.getX(), par5 + rc.getY(), par6 + rc.getZ()))
+ {
+ if (playerInvRitualStoneLocation >= 0)
+ {
+ if (rc.getStoneType() > this.maxMetaData + this.getMaxRuneDisplacement(par1ItemStack))
+ {
+ par3World.playAuxSFX(200, par4, par5 + 1, par6, 0);
+ return true;
+ }
+
+ if (!par2EntityPlayer.capabilities.isCreativeMode)
+ {
+ par2EntityPlayer.inventory.decrStackSize(playerInvRitualStoneLocation, 1);
+ }
+
+ par3World.setBlock(par4 + rc.getX(), par5 + rc.getY(), par6 + rc.getZ(), ModBlocks.ritualStone, rc.getStoneType(), 3);
+
+ if (par3World.isRemote)
+ {
+ par3World.playAuxSFX(2005, par4, par5 + 1, par6, 0);
+ EnergyItems.syphonBatteries(par1ItemStack, par2EntityPlayer, getEnergyUsed());
+ return true;
+ }
+
+ return true;
+ }
+ } else
+ {
+ Block block = par3World.getBlock(par4 + rc.getX(), par5 + rc.getY(), par6 + rc.getZ());
+
+ if (block == ModBlocks.ritualStone)
+ {
+ int metadata = par3World.getBlockMetadata(par4 + rc.getX(), par5 + rc.getY(), par6 + rc.getZ());
+
+ if (metadata != rc.getStoneType())
+ {
+ if (rc.getStoneType() > this.maxMetaData + this.getMaxRuneDisplacement(par1ItemStack))
+ {
+ par3World.playAuxSFX(200, par4, par5 + 1, par6, 0);
+ return true;
+ }
+
+ par3World.setBlockMetadataWithNotify(par4 + rc.getX(), par5 + rc.getY(), par6 + rc.getZ(), rc.getStoneType(), 3);
+ EnergyItems.syphonBatteries(par1ItemStack, par2EntityPlayer, getEnergyUsed());
+ return true;
+ }
+ } else
+ {
+ par3World.playAuxSFX(0000, par4, par5 + 1, par6, 0);
+ return true;
+ }
+ }
+ }
+
+// if (par3World.isRemote)
+// {
+// par3World.playAuxSFX(2005, par4, par5, par6, 0);
+// EnergyItems.syphonBatteries(par1ItemStack, par2EntityPlayer, getEnergyUsed());
+// return true;
+// }
+// return true;
+ }
+
+ return false;
+ }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par3EntityPlayer);
+
+ if (par3EntityPlayer.isSneaking())
+ {
+ int maxRitualID = Rituals.getNumberOfRituals();
+ String currentRitualID = this.getCurrentRitual(par1ItemStack);
+
+ this.setCurrentRitual(par1ItemStack, Rituals.getNextRitualKey(currentRitualID));
+
+ if (par2World.isRemote)
+ {
+ IChatComponent chatmessagecomponent = new ChatComponentText("Current Ritual: " + Rituals.getNameOfRitual(this.getCurrentRitual(par1ItemStack)));
+ //chatmessagecomponent.func_111072_b("Current Essence: " + data.currentEssence + "LP");
+ //chatmessagecomponent.addText("Current Ritual: " + Rituals.getNameOfRitual(this.getCurrentRitual(par1ItemStack)));
+ par3EntityPlayer.addChatComponentMessage(chatmessagecomponent);
+ }
+ }
+
+ return par1ItemStack;
+ }
+
+ @Override
+ public boolean onEntitySwing(EntityLivingBase entityLiving, ItemStack stack)
+ {
+ if(entityLiving instanceof EntityPlayer)
+ {
+ EntityPlayer player = (EntityPlayer) entityLiving;
+
+ if(player.isSneaking() && !player.isSwingInProgress)
+ {
+ int maxRitualID = Rituals.getNumberOfRituals();
+ String currentRitualID = this.getCurrentRitual(stack);
+
+ this.setCurrentRitual(stack, Rituals.getPreviousRitualKey(currentRitualID));
+
+ if (entityLiving.worldObj.isRemote)
+ {
+ IChatComponent chatmessagecomponent = new ChatComponentText("Current Ritual: " + Rituals.getNameOfRitual(this.getCurrentRitual(stack)));
+ //chatmessagecomponent.func_111072_b("Current Essence: " + data.currentEssence + "LP");
+ //chatmessagecomponent.addText("Current Ritual: " + Rituals.getNameOfRitual(this.getCurrentRitual(par1ItemStack)));
+ player.addChatComponentMessage(chatmessagecomponent);
+ }
+ }
+ }
+
+ return false;
+ }
+
+ public String getCurrentRitual(ItemStack par1ItemStack)
+ {
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ return par1ItemStack.stackTagCompound.getString("ritualID");
+ }
+
+ public void setCurrentRitual(ItemStack par1ItemStack, String ritualID)
+ {
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ par1ItemStack.stackTagCompound.setString("ritualID", ritualID);
+ }
+
+ public int getMaxRuneDisplacement(ItemStack par1ItemStack) //0 indicates the starting 4 runes, 1 indicates it can use Dusk runes
+ {
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ return par1ItemStack.stackTagCompound.getInteger("maxRuneDisplacement");
+ }
+
+ public void setMaxRuneDisplacement(ItemStack par1ItemStack, int displacement)
+ {
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ par1ItemStack.stackTagCompound.setInteger("maxRuneDisplacement", displacement);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void getSubItems(Item id, CreativeTabs creativeTab, List list)
+ {
+ list.add(new ItemStack(ModItems.itemRitualDiviner));
+ ItemStack duskRitualDivinerStack = new ItemStack(ModItems.itemRitualDiviner);
+ ((ItemRitualDiviner) duskRitualDivinerStack.getItem()).setMaxRuneDisplacement(duskRitualDivinerStack, 1);
+ list.add(duskRitualDivinerStack);
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ItemSpellEffectBlock.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ItemSpellEffectBlock.java
new file mode 100644
index 00000000..2c5e106d
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ItemSpellEffectBlock.java
@@ -0,0 +1,59 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import net.minecraft.block.Block;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+
+public class ItemSpellEffectBlock extends ItemBlock
+
+{
+ public ItemSpellEffectBlock(Block par1)
+ {
+ super(par1);
+ setHasSubtypes(true);
+// this.setUnlocalizedName("itemSpellEffectBlock");
+// setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+
+ }
+
+ public String getUnlocalizedName(ItemStack itemstack)
+
+ {
+ String name = "";
+
+ switch (itemstack.getItemDamage())
+ {
+ case 0:
+ {
+ name = "fire";
+ break;
+ }
+
+ case 1:
+ {
+ name = "ice";
+ break;
+ }
+
+ case 2:
+ name = "wind";
+ break;
+
+ case 3:
+ name = "earth";
+ break;
+
+ default:
+ name = "broken";
+ }
+
+ return getUnlocalizedName() + "." + name;
+ }
+
+ public int getMetadata(int par1)
+
+ {
+ return par1;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ItemSpellEnhancementBlock.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ItemSpellEnhancementBlock.java
new file mode 100644
index 00000000..670cbce8
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ItemSpellEnhancementBlock.java
@@ -0,0 +1,99 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import net.minecraft.block.Block;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+
+public class ItemSpellEnhancementBlock extends ItemBlock
+
+{
+ public ItemSpellEnhancementBlock(Block par1)
+ {
+ super(par1);
+ setHasSubtypes(true);
+// this.setUnlocalizedName("itemSpellEnhancementBlock");
+// setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+
+ }
+
+ public String getUnlocalizedName(ItemStack itemstack)
+
+ {
+ String name = "";
+
+ switch (itemstack.getItemDamage())
+ {
+ case 0:
+ name = "power1";
+ break;
+
+ case 1:
+ name = "power2";
+ break;
+
+ case 2:
+ name = "power3";
+ break;
+
+ case 3:
+ name = "power4";
+ break;
+
+ case 4:
+ name = "power5";
+ break;
+
+ case 5:
+ name = "cost1";
+ break;
+
+ case 6:
+ name = "cost2";
+ break;
+
+ case 7:
+ name = "cost3";
+ break;
+
+ case 8:
+ name = "cost4";
+ break;
+
+ case 9:
+ name = "cost5";
+ break;
+
+ case 10:
+ name = "potency1";
+ break;
+
+ case 11:
+ name = "potency2";
+ break;
+
+ case 12:
+ name = "potency3";
+ break;
+
+ case 13:
+ name = "potency4";
+ break;
+
+ case 14:
+ name = "potency5";
+ break;
+
+ default:
+ name = "broken";
+ }
+
+ return getUnlocalizedName() + "." + name;
+ }
+
+ public int getMetadata(int par1)
+
+ {
+ return par1;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ItemSpellModifierBlock.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ItemSpellModifierBlock.java
new file mode 100644
index 00000000..acd47516
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ItemSpellModifierBlock.java
@@ -0,0 +1,59 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import net.minecraft.block.Block;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+
+public class ItemSpellModifierBlock extends ItemBlock
+
+{
+ public ItemSpellModifierBlock(Block par1)
+ {
+ super(par1);
+ setHasSubtypes(true);
+// this.setUnlocalizedName("itemSpellModifierBlock");
+// setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+
+ }
+
+ public String getUnlocalizedName(ItemStack itemstack)
+
+ {
+ String name = "";
+
+ switch (itemstack.getItemDamage())
+ {
+ case 0:
+ {
+ name = "default";
+ break;
+ }
+
+ case 1:
+ {
+ name = "offensive";
+ break;
+ }
+
+ case 2:
+ name = "defensive";
+ break;
+
+ case 3:
+ name = "environmental";
+ break;
+
+ default:
+ name = "broken";
+ }
+
+ return getUnlocalizedName() + "." + name;
+ }
+
+ public int getMetadata(int par1)
+
+ {
+ return par1;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ItemSpellParadigmBlock.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ItemSpellParadigmBlock.java
new file mode 100644
index 00000000..5fb0b9e3
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ItemSpellParadigmBlock.java
@@ -0,0 +1,58 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import net.minecraft.block.Block;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+
+public class ItemSpellParadigmBlock extends ItemBlock
+
+{
+ public ItemSpellParadigmBlock(Block par1)
+ {
+ super(par1);
+ setHasSubtypes(true);
+ //this.setUnlocalizedName("itemSpellParadigmBlock");
+ }
+
+ @Override
+ public String getUnlocalizedName(ItemStack itemstack)
+
+ {
+ String name = "";
+
+ switch (itemstack.getItemDamage())
+ {
+ case 0:
+ {
+ name = "projectile";
+ break;
+ }
+
+ case 1:
+ {
+ name = "self";
+ break;
+ }
+
+ case 2:
+ name = "melee";
+ break;
+
+ case 3:
+ name = "tool";
+ break;
+
+ default:
+ name = "broken";
+ }
+
+ return getUnlocalizedName() + "." + name;
+ }
+
+ @Override
+ public int getMetadata(int par1)
+ {
+ return par1;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/LavaCrystal.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/LavaCrystal.java
new file mode 100644
index 00000000..87610c5e
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/LavaCrystal.java
@@ -0,0 +1,114 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.soulNetwork.LifeEssenceNetwork;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class LavaCrystal extends EnergyItems
+{
+ public LavaCrystal()
+ {
+ super();
+ //setMaxDamage(1000);
+ setMaxStackSize(1);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ setUnlocalizedName("lavaCrystal");
+ setEnergyUsed(25);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:LavaCrystal");
+ }
+
+ /*
+ * Used to have the item contain itself.
+ */
+ @Override
+ public ItemStack getContainerItem(ItemStack itemStack)
+ {
+ //if(!syphonBatteries(itemStack, null, 10))
+ {
+ syphonWhileInContainer(itemStack, this.getEnergyUsed());
+ ItemStack copiedStack = itemStack.copy();
+ copiedStack.setItemDamage(copiedStack.getItemDamage());
+ copiedStack.stackSize = 1;
+ return copiedStack;
+ }
+ //return itemStack;
+ }
+
+ @Override
+ public boolean hasContainerItem()
+ {
+ return true;
+ }
+
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par3EntityPlayer);
+ int damage = this.getDamage(par1ItemStack);
+ return par1ItemStack;
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Store life to smelt");
+ par3List.add("stuff in the furnace.");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+ }
+
+ public boolean hasEnoughEssence(ItemStack itemStack)
+ {
+ if (itemStack.getTagCompound() != null && !(itemStack.getTagCompound().getString("ownerName").equals("")))
+ {
+ String ownerName = itemStack.getTagCompound().getString("ownerName");
+
+ if (MinecraftServer.getServer() == null)
+ {
+ return false;
+ }
+
+ World world = MinecraftServer.getServer().worldServers[0];
+ LifeEssenceNetwork data = (LifeEssenceNetwork) world.loadItemData(LifeEssenceNetwork.class, ownerName);
+
+ if (data == null)
+ {
+ data = new LifeEssenceNetwork(ownerName);
+ world.setItemData(ownerName, data);
+ }
+
+ if (data.currentEssence >= this.getEnergyUsed())
+ {
+ return true;
+ }
+
+// EntityPlayer ownerEntity = MinecraftServer.getServer().getConfigurationManager().getPlayerForUsername(ist.getTagCompound().getString("ownerName"));
+// if(ownerEntity==null){return false;}
+// NBTTagCompound tag = ownerEntity.getEntityData();
+// int currentEssence = tag.getInteger("currentEssence");
+// if(currentEssence>=damageToBeDone)
+// {
+// tag.setInteger("currentEssence", currentEssence-damageToBeDone);
+// return true;
+// }
+ }
+
+ return false;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/LifeBucket.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/LifeBucket.java
new file mode 100644
index 00000000..80a29ed3
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/LifeBucket.java
@@ -0,0 +1,23 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.item.ItemBucket;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class LifeBucket extends ItemBucket
+{
+ public LifeBucket(Block block)
+ {
+ super(block);
+ // TODO Auto-generated constructor stub
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:LifeBucket");
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/MagicianBloodOrb.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/MagicianBloodOrb.java
new file mode 100644
index 00000000..e6081180
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/MagicianBloodOrb.java
@@ -0,0 +1,21 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class MagicianBloodOrb extends EnergyBattery
+{
+ public MagicianBloodOrb(int damage)
+ {
+ super(damage);
+ orbLevel = 3;
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:MagicianBloodOrb");
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/MasterBloodOrb.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/MasterBloodOrb.java
new file mode 100644
index 00000000..5e9c19c7
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/MasterBloodOrb.java
@@ -0,0 +1,21 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class MasterBloodOrb extends EnergyBattery
+{
+ public MasterBloodOrb(int damage)
+ {
+ super(damage);
+ orbLevel = 4;
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:MasterBloodOrb");
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/OrbOfTesting.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/OrbOfTesting.java
new file mode 100644
index 00000000..06482ac3
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/OrbOfTesting.java
@@ -0,0 +1,47 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class OrbOfTesting extends EnergyItems
+{
+ public OrbOfTesting()
+ {
+ super();
+ setMaxStackSize(1);
+ setCreativeTab(CreativeTabs.tabMisc);
+ setUnlocalizedName("orbOfTesting");
+ setMaxDamage(100);
+ setFull3D();
+ this.setEnergyUsed(100);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:Untitled");
+ }
+
+ //Heals the player using the item. If the player is at full health, or if the durability cannot be used any more,
+ //the item is not used.
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ if (!par3EntityPlayer.shouldHeal())
+ {
+ return par1ItemStack;
+ }
+
+ if (this.syphonBatteries(par1ItemStack, par3EntityPlayer, this.getEnergyUsed()))
+ {
+ par3EntityPlayer.heal(1);
+ }
+
+ return par1ItemStack;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ReinforcedTelepositionFocus.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ReinforcedTelepositionFocus.java
new file mode 100644
index 00000000..37134dbc
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ReinforcedTelepositionFocus.java
@@ -0,0 +1,47 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class ReinforcedTelepositionFocus extends TelepositionFocus
+{
+ public ReinforcedTelepositionFocus()
+ {
+ super(3);
+ // TODO Auto-generated constructor stub
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ //TODO
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:ReinforcedTeleposerFocus");
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("A stronger version of the focus,");
+ par3List.add("using a weak shard");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ NBTTagCompound itemTag = par1ItemStack.stackTagCompound;
+
+ if (!par1ItemStack.stackTagCompound.getString("ownerName").equals(""))
+ {
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+
+ par3List.add("Coords: " + itemTag.getInteger("xCoord") + ", " + itemTag.getInteger("yCoord") + ", " + itemTag.getInteger("zCoord"));
+ par3List.add("Bound Dimension: " + getDimensionID(par1ItemStack));
+ }
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/SacrificialDagger.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/SacrificialDagger.java
new file mode 100644
index 00000000..5452e519
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/SacrificialDagger.java
@@ -0,0 +1,167 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.DamageSource;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.FakePlayer;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEAltar;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class SacrificialDagger extends Item
+{
+ public SacrificialDagger()
+ {
+ super();
+ this.maxStackSize = 1;
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ setFull3D();
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ if(AlchemicalWizardry.wimpySettings)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:SheathedItem");
+ }else
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:SacrificialDagger");
+ }
+ }
+
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ if(AlchemicalWizardry.wimpySettings)
+ {
+ par3List.add("A slight draining feeling tickles your fingers");
+ }else
+ {
+ par3List.add("Just a prick of the");
+ par3List.add("finger will suffice...");
+ }
+ }
+
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ if (!par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ par3EntityPlayer.setHealth(par3EntityPlayer.getHealth() - 2);
+ }
+
+ if (par3EntityPlayer instanceof FakePlayer)
+ {
+ return par1ItemStack;
+ }
+
+ double posX = par3EntityPlayer.posX;
+ double posY = par3EntityPlayer.posY;
+ double posZ = par3EntityPlayer.posZ;
+ par2World.playSoundEffect((double) ((float) posX + 0.5F), (double) ((float) posY + 0.5F), (double) ((float) posZ + 0.5F), "random.fizz", 0.5F, 2.6F + (par2World.rand.nextFloat() - par2World.rand.nextFloat()) * 0.8F);
+ float f = (float) 1.0F;
+ float f1 = f * 0.6F + 0.4F;
+ float f2 = f * f * 0.7F - 0.5F;
+ float f3 = f * f * 0.6F - 0.7F;
+
+ for (int l = 0; l < 8; ++l)
+ {
+ par2World.spawnParticle("reddust", posX + Math.random() - Math.random(), posY + Math.random() - Math.random(), posZ + Math.random() - Math.random(), f1, f2, f3);
+ }
+
+ if(!par2World.isRemote && SpellHelper.isFakePlayer(par2World, par3EntityPlayer))
+ //if (!(par3EntityPlayer.getClass().equals(EntityPlayerMP.class)))
+ {
+ return par1ItemStack;
+ }
+
+ if(par3EntityPlayer.isPotionActive(AlchemicalWizardry.customPotionSoulFray))
+ {
+ findAndFillAltar(par2World, par3EntityPlayer, 20);
+ }else
+ {
+ findAndFillAltar(par2World, par3EntityPlayer, 200);
+ }
+
+ if (par3EntityPlayer.getHealth() <= 0.001f)
+ {
+ //par3EntityPlayer.inventory.dropAllItems();
+ par3EntityPlayer.onDeath(DamageSource.generic);
+ }
+
+ return par1ItemStack;
+ }
+
+ public void findAndFillAltar(World world, EntityPlayer player, int amount)
+ {
+ int posX = (int) Math.round(player.posX - 0.5f);
+ int posY = (int) player.posY;
+ int posZ = (int) Math.round(player.posZ - 0.5f);
+ TEAltar altarEntity = getAltar(world, posX, posY, posZ);
+
+ if (altarEntity == null)
+ {
+ return;
+ }
+
+ altarEntity.sacrificialDaggerCall(amount, false);
+ altarEntity.startCycle();
+ }
+
+ public TEAltar getAltar(World world, int x, int y, int z)
+ {
+ TileEntity tileEntity = null;
+
+ for (int i = -2; i <= 2; i++)
+ {
+ for (int j = -2; j <= 2; j++)
+ {
+ for (int k = -2; k <= 1; k++)
+ {
+ tileEntity = world.getTileEntity(i + x, k + y, j + z);
+
+ if ((tileEntity instanceof TEAltar))
+ {
+ return (TEAltar) tileEntity;
+ }
+ }
+
+ if ((tileEntity instanceof TEAltar))
+ {
+ return (TEAltar) tileEntity;
+ }
+ }
+
+ if ((tileEntity instanceof TEAltar))
+ {
+ return (TEAltar) tileEntity;
+ }
+ }
+
+ if ((tileEntity instanceof TEAltar))
+ {
+ return (TEAltar) tileEntity;
+ }
+
+ return null;
+ }
+
+ @Override
+ public String getItemStackDisplayName(ItemStack par1ItemStack)
+ {
+ if(AlchemicalWizardry.wimpySettings)
+ {
+ return "Sacrificial Orb";
+ }
+ return super.getItemStackDisplayName(par1ItemStack);
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ScribeTool.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ScribeTool.java
new file mode 100644
index 00000000..0dd3cd63
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/ScribeTool.java
@@ -0,0 +1,53 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+
+import java.util.List;
+
+public class ScribeTool extends EnergyItems
+{
+ private int meta;
+
+ public ScribeTool(int inkType)
+ {
+ super();
+ setMaxStackSize(1);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ setMaxDamage(10);
+ setEnergyUsed(10);
+ this.meta = inkType;
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("The writing is on the wall...");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+ }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par3EntityPlayer);
+
+ if (par1ItemStack.getItemDamage() > 0)
+ {
+ par1ItemStack.setItemDamage(par1ItemStack.getItemDamage() - 1);
+ syphonBatteries(par1ItemStack, par3EntityPlayer, this.getEnergyUsed());
+ }
+
+ return par1ItemStack;
+ }
+
+ public int getType()
+ {
+ return this.meta;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/TelepositionFocus.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/TelepositionFocus.java
new file mode 100644
index 00000000..192f34f4
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/TelepositionFocus.java
@@ -0,0 +1,124 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.world.World;
+import net.minecraftforge.common.DimensionManager;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class TelepositionFocus extends EnergyItems
+{
+ private int focusLevel;
+
+ public TelepositionFocus(int focusLevel)
+ {
+ super();
+ this.setMaxStackSize(1);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ this.focusLevel = focusLevel;
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ //TODO
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:TeleposerFocus");
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("An Enderpearl imbued with blood");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ NBTTagCompound itemTag = par1ItemStack.stackTagCompound;
+
+ if (!par1ItemStack.stackTagCompound.getString("ownerName").equals(""))
+ {
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+
+ par3List.add("Coords: " + itemTag.getInteger("xCoord") + ", " + itemTag.getInteger("yCoord") + ", " + itemTag.getInteger("zCoord"));
+ par3List.add("Bound Dimension: " + getDimensionID(par1ItemStack));
+ }
+ }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par3EntityPlayer);
+
+ if (par3EntityPlayer.isSneaking())
+ {
+ return par1ItemStack;
+ }
+
+// if (!par2World.isRemote)
+// {
+// //par2World.spawnEntityInWorld(new EnergyBlastProjectile(par2World, par3EntityPlayer, damage));
+// par2World.spawnEntityInWorld(new FireProjectile(par2World, par3EntityPlayer, 10));
+// }
+ return par1ItemStack;
+ }
+
+ public int getDimensionID(ItemStack itemStack)
+ {
+ if (itemStack.stackTagCompound == null)
+ {
+ itemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ return itemStack.stackTagCompound.getInteger("dimensionId");
+ }
+
+ public World getWorld(ItemStack itemStack)
+ {
+ return DimensionManager.getWorld(getDimensionID(itemStack));
+ }
+
+ public int xCoord(ItemStack itemStack)
+ {
+ if (!(itemStack.stackTagCompound == null))
+ {
+ return itemStack.stackTagCompound.getInteger("xCoord");
+ } else
+ {
+ return 0;
+ }
+ }
+
+ public int yCoord(ItemStack itemStack)
+ {
+ if (!(itemStack.stackTagCompound == null))
+ {
+ return itemStack.stackTagCompound.getInteger("yCoord");
+ } else
+ {
+ return 0;
+ }
+ }
+
+ public int zCoord(ItemStack itemStack)
+ {
+ if (!(itemStack.stackTagCompound == null))
+ {
+ return itemStack.stackTagCompound.getInteger("zCoord");
+ } else
+ {
+ return 0;
+ }
+ }
+
+ public int getFocusLevel()
+ {
+ return this.focusLevel;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/WaterScribeTool.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/WaterScribeTool.java
new file mode 100644
index 00000000..86132c84
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/WaterScribeTool.java
@@ -0,0 +1,22 @@
+package WayofTime.alchemicalWizardry.common.items;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class WaterScribeTool extends ScribeTool
+{
+ public WaterScribeTool()
+ {
+ super(1);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:WaterScribeTool");
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/energy/ItemAttunedCrystal.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/energy/ItemAttunedCrystal.java
new file mode 100644
index 00000000..1bf349ca
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/energy/ItemAttunedCrystal.java
@@ -0,0 +1,387 @@
+package WayofTime.alchemicalWizardry.common.items.energy;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ChatComponentText;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.IReagentHandler;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.Reagent;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentContainerInfo;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentRegistry;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentStack;
+import WayofTime.alchemicalWizardry.api.items.interfaces.IReagentManipulator;
+import WayofTime.alchemicalWizardry.common.Int3;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEReagentConduit;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class ItemAttunedCrystal extends Item implements IReagentManipulator
+{
+ public static final int maxDistance = 5;
+
+ public IIcon crystalBody;
+ public IIcon crystalLabel;
+
+ public ItemAttunedCrystal()
+ {
+ super();
+ this.setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ this.hasSubtypes = true;
+ this.maxStackSize = 1;
+ }
+
+ @Override
+ public String getItemStackDisplayName(ItemStack stack)
+ {
+ Reagent reagent = this.getReagent(stack);
+
+ String name = super.getItemStackDisplayName(stack);
+
+ if(reagent != null)
+ {
+ name = name + " (" + reagent.name + ")";
+ }
+
+ return name;
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("A tool to tune alchemy");
+ par3List.add("reagent transmission");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ Reagent reagent = this.getReagent(par1ItemStack);
+ if(reagent != null)
+ {
+ par3List.add("Currently selected reagent: " + reagent.name);
+ }
+
+ if(this.getHasSavedCoordinates(par1ItemStack))
+ {
+ par3List.add("");
+ Int3 coords = this.getCoordinates(par1ItemStack);
+ par3List.add("Coords: " + coords.xCoord + ", " + coords.yCoord + ", " + coords.zCoord);
+ par3List.add("Bound Dimension: " + getDimension(par1ItemStack));
+ }
+ }
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.crystalBody = iconRegister.registerIcon("AlchemicalWizardry:AttunedCrystal1");
+ this.crystalLabel = iconRegister.registerIcon("AlchemicalWizardry:AttunedCrystal2");
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public int getColorFromItemStack(ItemStack stack, int pass)
+ {
+ switch(pass)
+ {
+ case 0:
+ return 256*(256*255 + 255) + 255;
+ case 1:
+ Reagent reagent = this.getReagent(stack);
+ if(reagent != null)
+ {
+ return (reagent.getColourRed()*256*256 + reagent.getColourGreen()*256 + reagent.getColourBlue());
+ }
+ break;
+ }
+
+ return 256*(256*255 + 255) + 255;
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public boolean requiresMultipleRenderPasses()
+ {
+ return true;
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public int getRenderPasses(int meta)
+ {
+ return 2;
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public IIcon getIcon(ItemStack stack, int pass)
+ {
+ switch(pass)
+ {
+ case 0:
+ return this.crystalBody;
+ case 1:
+ return this.crystalLabel;
+ }
+ return this.itemIcon;
+ }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack itemStack, World world, EntityPlayer player)
+ {
+ if(world.isRemote)
+ {
+ return itemStack;
+ }
+
+ MovingObjectPosition movingobjectposition = this.getMovingObjectPositionFromPlayer(world, player, false);
+
+ if (movingobjectposition == null)
+ {
+ if(player.isSneaking())
+ {
+ this.setHasSavedCoordinates(itemStack, false);
+ player.addChatComponentMessage(new ChatComponentText("Clearing saved container..."));
+ }
+
+ return itemStack;
+ } else
+ {
+ if (movingobjectposition.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK)
+ {
+ int x = movingobjectposition.blockX;
+ int y = movingobjectposition.blockY;
+ int z = movingobjectposition.blockZ;
+
+ TileEntity tile = world.getTileEntity(x, y, z);
+
+ if(!(tile instanceof IReagentHandler))
+ {
+ return itemStack;
+ }
+
+ IReagentHandler relay = (IReagentHandler)tile;
+
+ if(player.isSneaking())
+ {
+ ReagentContainerInfo[] infos = relay.getContainerInfo(ForgeDirection.UNKNOWN);
+ if(infos != null)
+ {
+ List reagentList = new LinkedList();
+ for(ReagentContainerInfo info : infos)
+ {
+ if(info != null)
+ {
+ ReagentStack reagentStack = info.reagent;
+ if(reagentStack != null)
+ {
+ Reagent reagent = reagentStack.reagent;
+ if(reagent != null)
+ {
+ reagentList.add(reagent);
+ }
+ }
+ }
+ }
+
+ Reagent pastReagent = this.getReagent(itemStack);
+
+ if(reagentList.size() <= 0)
+ {
+ return itemStack;
+ }
+
+ int reagentLocation = -1;
+
+ reagentLocation = reagentList.indexOf(pastReagent);
+
+ if(reagentLocation == -1 || reagentLocation+1 >= reagentList.size())
+ {
+ this.setReagentWithNotification(itemStack, reagentList.get(0), player);
+ }else
+ {
+ this.setReagentWithNotification(itemStack, reagentList.get(reagentLocation + 1), player);
+ }
+ }
+ }else
+ {
+ if(this.getHasSavedCoordinates(itemStack))
+ {
+ Int3 coords = this.getCoordinates(itemStack);
+ int dimension = this.getDimension(itemStack);
+
+ if(coords == null)
+ {
+ return itemStack;
+ }
+
+ if(dimension != world.provider.dimensionId || Math.abs(coords.xCoord - x) > maxDistance || Math.abs(coords.yCoord - y) > maxDistance || Math.abs(coords.zCoord - z) > maxDistance)
+ {
+ player.addChatComponentMessage(new ChatComponentText("Linked container is either too far or is in a different dimension."));
+ return itemStack;
+ }
+
+ TileEntity pastTile = world.getTileEntity(coords.xCoord, coords.yCoord, coords.zCoord);
+ if(!(pastTile instanceof TEReagentConduit))
+ {
+ player.addChatComponentMessage(new ChatComponentText("Can no longer find linked container."));
+ return itemStack;
+ }
+
+ Reagent reagent = this.getReagent(itemStack);
+
+ if(reagent == null)
+ {
+ return itemStack;
+ }
+
+ TEReagentConduit pastRelay = (TEReagentConduit)pastTile;
+
+ if(player.isSneaking())
+ {
+ pastRelay.removeReagentDestinationViaActual(reagent, x, y, z);
+ }else
+ {
+ if(pastRelay.addReagentDestinationViaActual(reagent, x, y, z))
+ {
+ player.addChatComponentMessage(new ChatComponentText("Container is now linked. Transmitting: " + reagent.name));
+ }else
+ {
+ player.addChatComponentMessage(new ChatComponentText("Linked container has no connections remaining!"));
+ }
+ }
+ world.markBlockForUpdate(coords.xCoord, coords.yCoord, coords.zCoord);
+ }else
+ {
+ int dimension = world.provider.dimensionId;
+
+ this.setDimension(itemStack, dimension);
+ this.setCoordinates(itemStack, new Int3(x, y, z));
+
+ player.addChatComponentMessage(new ChatComponentText("Linking to selected container."));
+ }
+ }
+ }
+ }
+
+ return itemStack;
+ }
+
+ public void setCoordinates(ItemStack stack, Int3 coords)
+ {
+ if(!stack.hasTagCompound())
+ {
+ stack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = stack.getTagCompound();
+
+ coords.writeToNBT(tag);
+
+ this.setHasSavedCoordinates(stack, true);
+ }
+
+ public void setDimension(ItemStack stack, int dimension)
+ {
+ if(!stack.hasTagCompound())
+ {
+ stack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = stack.getTagCompound();
+
+ tag.setInteger("dimension", dimension);
+ }
+
+ public Int3 getCoordinates(ItemStack stack)
+ {
+ if(!stack.hasTagCompound())
+ {
+ stack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = stack.getTagCompound();
+
+ return Int3.readFromNBT(tag);
+ }
+
+ public int getDimension(ItemStack stack)
+ {
+ if(!stack.hasTagCompound())
+ {
+ stack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = stack.getTagCompound();
+
+ return tag.getInteger("dimension");
+ }
+
+ public void setHasSavedCoordinates(ItemStack stack, boolean flag)
+ {
+ if(!stack.hasTagCompound())
+ {
+ stack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = stack.getTagCompound();
+
+ tag.setBoolean("hasSavedCoordinates", flag);
+ }
+
+ public boolean getHasSavedCoordinates(ItemStack stack)
+ {
+ if(!stack.hasTagCompound())
+ {
+ stack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = stack.getTagCompound();
+
+ return tag.getBoolean("hasSavedCoordinates");
+ }
+
+ public Reagent getReagent(ItemStack stack)
+ {
+ if(!stack.hasTagCompound())
+ {
+ stack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = stack.getTagCompound();
+
+ return ReagentRegistry.getReagentForKey(tag.getString("reagent"));
+ }
+
+ public void setReagent(ItemStack stack, Reagent reagent)
+ {
+ if(!stack.hasTagCompound())
+ {
+ stack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = stack.getTagCompound();
+
+ tag.setString("reagent", ReagentRegistry.getKeyForReagent(reagent));
+ }
+
+ public void setReagentWithNotification(ItemStack stack, Reagent reagent, EntityPlayer player)
+ {
+ this.setReagent(stack, reagent);
+
+ if(reagent != null)
+ {
+ player.addChatComponentMessage(new ChatComponentText("Attuned Crystal now set to: " + reagent.name));
+ }
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/energy/ItemDestinationClearer.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/energy/ItemDestinationClearer.java
new file mode 100644
index 00000000..38ae34fc
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/energy/ItemDestinationClearer.java
@@ -0,0 +1,82 @@
+package WayofTime.alchemicalWizardry.common.items.energy;
+
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ChatComponentText;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.Reagent;
+import WayofTime.alchemicalWizardry.api.items.interfaces.IReagentManipulator;
+import WayofTime.alchemicalWizardry.common.Int3;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEReagentConduit;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class ItemDestinationClearer extends Item implements IReagentManipulator
+{
+ public ItemDestinationClearer()
+ {
+ super();
+ this.setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ this.maxStackSize = 1;
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:TankClearer");
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Used to clear the destination");
+ par3List.add("list for an alchemy container");
+ }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack itemStack, World world, EntityPlayer player)
+ {
+ if(world.isRemote)
+ {
+ return itemStack;
+ }
+
+ MovingObjectPosition movingobjectposition = this.getMovingObjectPositionFromPlayer(world, player, false);
+
+ if (movingobjectposition == null)
+ {
+ return itemStack;
+ } else
+ {
+ if (movingobjectposition.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK)
+ {
+ int x = movingobjectposition.blockX;
+ int y = movingobjectposition.blockY;
+ int z = movingobjectposition.blockZ;
+
+ TileEntity tile = world.getTileEntity(x, y, z);
+
+ if(!(tile instanceof TEReagentConduit))
+ {
+ return itemStack;
+ }
+
+ TEReagentConduit relay = (TEReagentConduit)tile;
+
+ relay.reagentTargetList.clear();
+
+ player.addChatComponentMessage(new ChatComponentText("Destination list now cleared."));
+ }
+ }
+
+ return itemStack;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/energy/ItemTankSegmenter.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/energy/ItemTankSegmenter.java
new file mode 100644
index 00000000..14772607
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/energy/ItemTankSegmenter.java
@@ -0,0 +1,278 @@
+package WayofTime.alchemicalWizardry.common.items.energy;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ChatComponentText;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.IReagentHandler;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ISegmentedReagentHandler;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.Reagent;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentContainerInfo;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentRegistry;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentStack;
+import WayofTime.alchemicalWizardry.api.items.interfaces.IReagentManipulator;
+import WayofTime.alchemicalWizardry.common.Int3;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class ItemTankSegmenter extends Item implements IReagentManipulator
+{
+ public IIcon crystalBody;
+ public IIcon crystalLabel;
+
+ public ItemTankSegmenter()
+ {
+ super();
+ this.setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ this.hasSubtypes = true;
+ this.maxStackSize = 1;
+ }
+
+ @Override
+ public String getItemStackDisplayName(ItemStack stack)
+ {
+ Reagent reagent = this.getReagent(stack);
+
+ String name = super.getItemStackDisplayName(stack);
+
+ if(reagent != null)
+ {
+ name = name + " (" + reagent.name + ")";
+ }
+
+ return name;
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Used to designate which");
+ par3List.add("reagents can go into a container");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ Reagent reagent = this.getReagent(par1ItemStack);
+ if(reagent != null)
+ {
+ par3List.add("Currently selected reagent: " + reagent.name);
+ }
+ }
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.crystalBody = iconRegister.registerIcon("AlchemicalWizardry:TankSegmenter1");
+ this.crystalLabel = iconRegister.registerIcon("AlchemicalWizardry:TankSegmenter2");
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public int getColorFromItemStack(ItemStack stack, int pass)
+ {
+ switch(pass)
+ {
+ case 0:
+ return 256*(256*255 + 255) + 255;
+ case 1:
+ Reagent reagent = this.getReagent(stack);
+ if(reagent != null)
+ {
+ return (reagent.getColourRed()*256*256 + reagent.getColourGreen()*256 + reagent.getColourBlue());
+ }
+ break;
+ }
+
+ return 256*(256*255 + 255) + 255;
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public boolean requiresMultipleRenderPasses()
+ {
+ return true;
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public int getRenderPasses(int meta)
+ {
+ return 2;
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public IIcon getIcon(ItemStack stack, int pass)
+ {
+ switch(pass)
+ {
+ case 0:
+ return this.crystalBody;
+ case 1:
+ return this.crystalLabel;
+ }
+ return this.itemIcon;
+ }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack itemStack, World world, EntityPlayer player)
+ {
+ if(world.isRemote)
+ {
+ return itemStack;
+ }
+
+ MovingObjectPosition movingobjectposition = this.getMovingObjectPositionFromPlayer(world, player, false);
+
+ if (movingobjectposition == null)
+ {
+ return itemStack;
+ } else
+ {
+ if (movingobjectposition.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK)
+ {
+ int x = movingobjectposition.blockX;
+ int y = movingobjectposition.blockY;
+ int z = movingobjectposition.blockZ;
+
+ TileEntity tile = world.getTileEntity(x, y, z);
+
+ if(!(tile instanceof ISegmentedReagentHandler))
+ {
+ return itemStack;
+ }
+
+ ISegmentedReagentHandler reagentHandler = (ISegmentedReagentHandler)tile;
+
+ if(player.isSneaking())
+ {
+ ReagentContainerInfo[] infos = reagentHandler.getContainerInfo(ForgeDirection.UNKNOWN);
+ if(infos != null)
+ {
+ List reagentList = new LinkedList();
+ for(ReagentContainerInfo info : infos)
+ {
+ if(info != null)
+ {
+ ReagentStack reagentStack = info.reagent;
+ if(reagentStack != null)
+ {
+ Reagent reagent = reagentStack.reagent;
+ if(reagent != null)
+ {
+ reagentList.add(reagent);
+ }
+ }
+ }
+ }
+
+ Reagent pastReagent = this.getReagent(itemStack);
+
+ boolean goForNext = false;
+ boolean hasFound = false;
+ for(Reagent reagent : reagentList)
+ {
+ if(goForNext)
+ {
+ goForNext = false;
+ break;
+ }
+
+ if(reagent == pastReagent)
+ {
+ goForNext = true;
+ hasFound = true;
+ }
+ }
+
+ if(hasFound)
+ {
+ if(goForNext)
+ {
+ this.setReagentWithNotification(itemStack, reagentList.get(0), player);
+ }
+ }else
+ {
+ if(reagentList.size() >= 1)
+ {
+ this.setReagentWithNotification(itemStack, reagentList.get(0), player);
+ }
+ }
+ }
+
+ }else
+ {
+ Reagent reagent = this.getReagent(itemStack);
+ if(reagent == null)
+ {
+ //TODO: Send message that "All are wiped"
+ reagentHandler.getAttunedTankMap().clear();
+ return itemStack;
+ }
+ int totalTankSize = reagentHandler.getNumberOfTanks();
+ int numberAssigned = reagentHandler.getTanksTunedToReagent(reagent) + 1;
+
+ if(numberAssigned > totalTankSize)
+ {
+ numberAssigned = 0;
+ }
+
+ player.addChatComponentMessage(new ChatComponentText("Tank now has " + numberAssigned + " tank(s) set to: " + reagent.name));
+
+ reagentHandler.setTanksTunedToReagent(reagent, numberAssigned);
+ }
+ }else if(movingobjectposition.typeOfHit == MovingObjectPosition.MovingObjectType.MISS)
+ {
+ this.setReagent(itemStack, null);
+ }
+ }
+
+ return itemStack;
+ }
+
+ public Reagent getReagent(ItemStack stack)
+ {
+ if(!stack.hasTagCompound())
+ {
+ stack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = stack.getTagCompound();
+
+ return ReagentRegistry.getReagentForKey(tag.getString("reagent"));
+ }
+
+ public void setReagent(ItemStack stack, Reagent reagent)
+ {
+ if(!stack.hasTagCompound())
+ {
+ stack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = stack.getTagCompound();
+
+ tag.setString("reagent", ReagentRegistry.getKeyForReagent(reagent));
+ }
+
+ public void setReagentWithNotification(ItemStack stack, Reagent reagent, EntityPlayer player)
+ {
+ this.setReagent(stack, reagent);
+
+ if(reagent != null)
+ {
+ player.addChatComponentMessage(new ChatComponentText("Tank Segmenter now set to: " + reagent.name));
+ }
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/forestry/ItemBloodFrame.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/forestry/ItemBloodFrame.java
new file mode 100644
index 00000000..32da83be
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/forestry/ItemBloodFrame.java
@@ -0,0 +1,151 @@
+package WayofTime.alchemicalWizardry.common.items.forestry;
+
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.common.items.EnergyItems;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class ItemBloodFrame extends EnergyItems //implements IHiveFrame
+{
+ public ItemBloodFrame()
+ {
+ super();
+ this.maxStackSize = 1;
+ this.setMaxDamage(10);
+ //setMaxDamage(1000);
+ setEnergyUsed(3000);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Stirs bees into a frenzy.");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:BloodFrame");
+ }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par3EntityPlayer);
+
+ if(par1ItemStack.getItemDamage()>0)
+ {
+ EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, getEnergyUsed());
+ par1ItemStack.setItemDamage(par1ItemStack.getItemDamage()-1);
+ }
+
+ return par1ItemStack;
+ }
+
+ /**TODO Bee Stuff
+ @Override
+ public float getTerritoryModifier(IBeeGenome genome, float currentModifier)
+ {
+ // TODO Auto-generated method stub
+ return 1;
+ }
+
+ @Override
+ public float getMutationModifier(IBeeGenome genome, IBeeGenome mate, float currentModifier)
+ {
+ // TODO Auto-generated method stub
+ return 1;
+ }
+
+ @Override
+ public float getLifespanModifier(IBeeGenome genome, IBeeGenome mate, float currentModifier)
+ {
+ // TODO Auto-generated method stub
+ return 0.0001f;
+ }
+
+ @Override
+ public float getProductionModifier(IBeeGenome genome, float currentModifier)
+ {
+ // TODO Auto-generated method stub
+ return 0;
+ }
+
+ @Override
+ public float getFloweringModifier(IBeeGenome genome, float currentModifier)
+ {
+ // TODO Auto-generated method stub
+ return 1;
+ }
+
+ @Override
+ public float getGeneticDecay(IBeeGenome genome, float currentModifier)
+ {
+ // TODO Auto-generated method stub
+ return 1;
+ }
+
+ @Override
+ public boolean isSealed()
+ {
+ // TODO Auto-generated method stub
+ return false;
+ }
+
+ @Override
+ public boolean isSelfLighted()
+ {
+ // TODO Auto-generated method stub
+ return false;
+ }
+
+ @Override
+ public boolean isSunlightSimulated()
+ {
+ // TODO Auto-generated method stub
+ return false;
+ }
+
+ @Override
+ public boolean isHellish()
+ {
+ // TODO Auto-generated method stub
+ return false;
+ }
+
+ @Override
+ public ItemStack frameUsed(IBeeHousing housing, ItemStack frame, IBee queen, int wear)
+ {
+ // TODO Auto-generated method stub
+ if(EnergyItems.canSyphonInContainer(frame, getEnergyUsed()*wear))
+ {
+ EnergyItems.syphonWhileInContainer(frame, getEnergyUsed()*wear);
+ return frame;
+ }else
+ {
+ frame.setItemDamage(frame.getItemDamage() + wear);
+ if(frame.getItemDamage()>=frame.getMaxDamage())
+ {
+ return null;
+ }
+ return frame;
+ }
+
+ }
+
+ */
+
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/AlchemyFlask.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/AlchemyFlask.java
new file mode 100644
index 00000000..05f3d698
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/AlchemyFlask.java
@@ -0,0 +1,435 @@
+package WayofTime.alchemicalWizardry.common.items.potion;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.ai.attributes.AttributeModifier;
+import net.minecraft.entity.ai.attributes.IAttribute;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.projectile.EntityPotion;
+import net.minecraft.init.Items;
+import net.minecraft.item.EnumAction;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.potion.Potion;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.StatCollector;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.Constants;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.alchemy.AlchemyPotionHelper;
+
+import com.google.common.collect.HashMultimap;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class AlchemyFlask extends Item
+{
+ private int maxPotionAmount = 20;
+
+ public AlchemyFlask()
+ {
+ super();
+ this.setMaxDamage(8);
+ this.setMaxStackSize(1);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ // TODO Auto-generated constructor stub
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:PotionFlask");
+ }
+
+ public static ArrayList getEffects(ItemStack par1ItemStack)
+ {
+ if (par1ItemStack.hasTagCompound() && par1ItemStack.getTagCompound().hasKey("CustomFlaskEffects"))
+ {
+ ArrayList arraylist = new ArrayList();
+ NBTTagList nbttaglist = par1ItemStack.getTagCompound().getTagList("CustomFlaskEffects", Constants.NBT.TAG_COMPOUND);
+
+ for (int i = 0; i < nbttaglist.tagCount(); ++i)
+ {
+ NBTTagCompound nbttagcompound = (NBTTagCompound) nbttaglist.getCompoundTagAt(i);
+ arraylist.add(AlchemyPotionHelper.readEffectFromNBT(nbttagcompound));
+ }
+
+ return arraylist;
+ } else
+ {
+ return null;
+ }
+ }
+
+ public static ArrayList getPotionEffects(ItemStack par1ItemStack)
+ {
+ ArrayList list = AlchemyFlask.getEffects(par1ItemStack);
+
+ if (list != null)
+ {
+ ArrayList newList = new ArrayList();
+
+ for (AlchemyPotionHelper aph : list)
+ {
+ newList.add(aph.getPotionEffect());
+ }
+
+ return newList;
+ } else
+ {
+ return null;
+ }
+ }
+
+ public static void setEffects(ItemStack par1ItemStack, List list)
+ {
+ NBTTagCompound itemTag = par1ItemStack.stackTagCompound;
+
+ if (itemTag == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagList nbttaglist = new NBTTagList();
+
+ for (AlchemyPotionHelper aph : list)
+ {
+ nbttaglist.appendTag(AlchemyPotionHelper.setEffectToNBT(aph));
+ }
+
+ par1ItemStack.stackTagCompound.setTag("CustomFlaskEffects", nbttaglist);
+ }
+
+ public ItemStack onEaten(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ if (!par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ par1ItemStack.setItemDamage(par1ItemStack.getItemDamage() + 1);
+ }
+
+ if (!par2World.isRemote)
+ {
+ ArrayList list = this.getEffects(par1ItemStack);
+
+ if (list != null)
+ {
+ for (AlchemyPotionHelper aph : list)
+ {
+ PotionEffect pe = aph.getPotionEffect();
+
+ if (pe != null)
+ {
+ //if(pe.get)
+ par3EntityPlayer.addPotionEffect(pe);
+ }
+ }
+ }
+ }
+
+ return par1ItemStack;
+ }
+
+ /**
+ * How long it takes to use or consume an item
+ */
+ public int getMaxItemUseDuration(ItemStack par1ItemStack)
+ {
+ return 32;
+ }
+
+ /**
+ * returns the action that specifies what animation to play when the items is being used
+ */
+ public EnumAction getItemUseAction(ItemStack par1ItemStack)
+ {
+ if (this.isPotionThrowable(par1ItemStack))
+ {
+ return EnumAction.none;
+ }
+
+ return EnumAction.drink;
+ }
+
+ /**
+ * Called whenever this item is equipped and the right mouse button is pressed. Args: itemStack, world, entityPlayer
+ */
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+// if(par3EntityPlayer.isSneaking())
+// {
+// this.setIsPotionThrowable(true, par1ItemStack);
+// return par1ItemStack;
+// }
+ if (par1ItemStack.getItemDamage() < par1ItemStack.getMaxDamage())
+ {
+ if (this.isPotionThrowable(par1ItemStack))
+ {
+ if (!par2World.isRemote)
+ {
+ EntityPotion entityPotion = this.getEntityPotion(par1ItemStack, par2World, par3EntityPlayer);
+
+ if (entityPotion != null)
+ {
+ float velocityChange = 2.0f;
+ entityPotion.motionX *= velocityChange;
+ entityPotion.motionY *= velocityChange;
+ entityPotion.motionZ *= velocityChange;
+ par2World.spawnEntityInWorld(entityPotion);
+ par1ItemStack.setItemDamage(par1ItemStack.getItemDamage() + 1);
+ }
+ }
+
+ return par1ItemStack;
+ }
+
+ par3EntityPlayer.setItemInUse(par1ItemStack, this.getMaxItemUseDuration(par1ItemStack));
+ }
+
+ return par1ItemStack;
+ }
+
+ public void setConcentrationOfPotion(ItemStack par1ItemStack, int potionID, int concentration)
+ {
+ ArrayList list = this.getEffects(par1ItemStack);
+
+ if (list != null)
+ {
+ for (AlchemyPotionHelper aph : list)
+ {
+ if (aph.getPotionID() == potionID)
+ {
+ aph.setConcentration(concentration);
+ break;
+ }
+ }
+
+ this.setEffects(par1ItemStack, list);
+ }
+ }
+
+ public void setDurationFactorOfPotion(ItemStack par1ItemStack, int potionID, int durationFactor)
+ {
+ ArrayList list = this.getEffects(par1ItemStack);
+
+ if (list != null)
+ {
+ for (AlchemyPotionHelper aph : list)
+ {
+ if (aph.getPotionID() == potionID)
+ {
+ aph.setDurationFactor(durationFactor);
+ break;
+ }
+ }
+
+ this.setEffects(par1ItemStack, list);
+ }
+ }
+
+ public boolean hasPotionEffect(ItemStack par1ItemStack, int potionID)
+ {
+ return false;
+ }
+
+ public int getNumberOfPotionEffects(ItemStack par1ItemStack)
+ {
+ if (getEffects(par1ItemStack) != null)
+ {
+ return getEffects(par1ItemStack).size();
+ } else
+ {
+ return 0;
+ }
+ }
+
+ public boolean addPotionEffect(ItemStack par1ItemStack, int potionID, int tickDuration)
+ {
+ int i = 0;
+ ArrayList list = this.getEffects(par1ItemStack);
+
+ if (list != null)
+ {
+ for (AlchemyPotionHelper aph : list)
+ {
+ if (aph.getPotionID() == potionID)
+ {
+ return false;
+ }
+
+ i++;
+ }
+
+ //if(i 0)
+ {
+ Iterator iterator1 = map.entrySet().iterator();
+
+ while (iterator1.hasNext())
+ {
+ Entry entry = (Entry) iterator1.next();
+ AttributeModifier attributemodifier = (AttributeModifier) entry.getValue();
+ AttributeModifier attributemodifier1 = new AttributeModifier(attributemodifier.getName(), potion.func_111183_a(potioneffect.getAmplifier(), attributemodifier), attributemodifier.getOperation());
+ hashmultimap.put(((IAttribute)entry.getKey()).getAttributeUnlocalizedName(), attributemodifier1);
+ }
+ }
+
+ if (potioneffect.getAmplifier() > 0)
+ {
+ s = s + " " + StatCollector.translateToLocal("potion.potency." + potioneffect.getAmplifier()).trim();
+ }
+
+ if (potioneffect.getDuration() > 20)
+ {
+ s = s + " (" + Potion.getDurationString(potioneffect) + ")";
+ }
+
+ if (potion.isBadEffect())
+ {
+ par3List.add(EnumChatFormatting.RED + s);
+ } else
+ {
+ par3List.add(EnumChatFormatting.GRAY + s);
+ }
+ }
+ } else
+ {
+ String s1 = StatCollector.translateToLocal("potion.empty").trim();
+ par3List.add(EnumChatFormatting.GRAY + s1);
+ }
+
+ if (!hashmultimap.isEmpty())
+ {
+ par3List.add("");
+ par3List.add(EnumChatFormatting.DARK_PURPLE + StatCollector.translateToLocal("potion.effects.whenDrank"));
+ iterator = hashmultimap.entries().iterator();
+
+ while (iterator.hasNext())
+ {
+ Entry entry1 = (Entry) iterator.next();
+ AttributeModifier attributemodifier2 = (AttributeModifier) entry1.getValue();
+ double d0 = attributemodifier2.getAmount();
+ double d1;
+
+ if (attributemodifier2.getOperation() != 1 && attributemodifier2.getOperation() != 2)
+ {
+ d1 = attributemodifier2.getAmount();
+ } else
+ {
+ d1 = attributemodifier2.getAmount() * 100.0D;
+ }
+
+ if (d0 > 0.0D)
+ {
+ par3List.add(EnumChatFormatting.BLUE + StatCollector.translateToLocalFormatted("attribute.modifier.plus." + attributemodifier2.getOperation(), new Object[]{ItemStack.field_111284_a.format(d1), StatCollector.translateToLocal("attribute.name." + (String) entry1.getKey())}));
+ } else if (d0 < 0.0D)
+ {
+ d1 *= -1.0D;
+ par3List.add(EnumChatFormatting.RED + StatCollector.translateToLocalFormatted("attribute.modifier.take." + attributemodifier2.getOperation(), new Object[]{ItemStack.field_111284_a.format(d1), StatCollector.translateToLocal("attribute.name." + (String) entry1.getKey())}));
+ }
+ }
+ }
+ }
+
+ public boolean isPotionThrowable(ItemStack par1ItemStack)
+ {
+ if (par1ItemStack.hasTagCompound() && par1ItemStack.getTagCompound().getBoolean("throwable"))
+ {
+ return true;
+ } else
+ {
+ return false;
+ }
+
+ //return false;
+ }
+
+ public void setIsPotionThrowable(boolean flag, ItemStack par1ItemStack)
+ {
+ if (!par1ItemStack.hasTagCompound())
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ par1ItemStack.stackTagCompound.setBoolean("throwable", flag);
+ }
+
+ public EntityPotion getEntityPotion(ItemStack par1ItemStack, World worldObj, EntityLivingBase entityLivingBase)
+ {
+ ItemStack potionStack = new ItemStack(Items.potionitem, 1, 0);
+ potionStack.setTagCompound(new NBTTagCompound());
+ ArrayList potionList = this.getPotionEffects(par1ItemStack);
+
+ if (potionList == null)
+ {
+ return null;
+ }
+
+ NBTTagList nbttaglist = new NBTTagList();
+
+ for (PotionEffect pe : potionList)
+ {
+ NBTTagCompound d = new NBTTagCompound();
+ d.setByte("Id", (byte) pe.getPotionID());
+ d.setByte("Amplifier", (byte) pe.getAmplifier());
+ //byte b1 = par0NBTTagCompound.getByte("Amplifier");
+ d.setInteger("Duration", pe.getDuration());
+ //int i = par0NBTTagCompound.getInteger("Duration");
+ d.setBoolean("Ambient", pe.getIsAmbient());
+ // boolean flag = par0NBTTagCompound.getBoolean("Ambient");
+ nbttaglist.appendTag(d);
+ }
+
+ potionStack.stackTagCompound.setTag("CustomPotionEffects", nbttaglist);
+ EntityPotion entityPotion = new EntityPotion(worldObj, entityLivingBase, potionStack);
+ return entityPotion;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/AlchemyReagent.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/AlchemyReagent.java
new file mode 100644
index 00000000..3987c581
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/AlchemyReagent.java
@@ -0,0 +1,120 @@
+package WayofTime.alchemicalWizardry.common.items.potion;
+
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumChatFormatting;
+
+import org.lwjgl.input.Keyboard;
+
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.ModItems;
+import WayofTime.alchemicalWizardry.api.alchemy.AlchemyRecipeRegistry;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class AlchemyReagent extends Item
+{
+ public AlchemyReagent()
+ {
+ super();
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ this.setMaxStackSize(64);
+ // TODO Auto-generated constructor stub
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ if (this == ModItems.incendium)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:Incendium");
+ return;
+ }
+
+ if (this == ModItems.magicales)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:Magicales");
+ return;
+ }
+
+ if (this == ModItems.sanctus)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:Sanctus");
+ return;
+ }
+
+ if (this == ModItems.aether)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:Aether");
+ return;
+ }
+
+ if (this == ModItems.simpleCatalyst)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:SimpleCatalyst");
+ return;
+ }
+
+ if (this == ModItems.crepitous)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:Crepitous");
+ return;
+ }
+
+ if (this == ModItems.crystallos)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:Crystallos");
+ return;
+ }
+
+ if (this == ModItems.terrae)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:Terrae");
+ return;
+ }
+
+ if (this == ModItems.aquasalus)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:Aquasalus");
+ return;
+ }
+
+ if (this == ModItems.tennebrae)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:Tennebrae");
+ return;
+ }
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Used in alchemy");
+
+ if (Keyboard.isKeyDown(Keyboard.KEY_RSHIFT) || Keyboard.isKeyDown(Keyboard.KEY_LSHIFT))
+ {
+ ItemStack[] recipe = AlchemyRecipeRegistry.getRecipeForItemStack(par1ItemStack);
+
+ if (recipe != null)
+ {
+ par3List.add(EnumChatFormatting.BLUE + "Recipe:");
+
+ for (ItemStack item : recipe)
+ {
+ if (item != null)
+ {
+ par3List.add("" + item.getDisplayName());
+ }
+ }
+ }
+ } else
+ {
+ par3List.add("-Press " + EnumChatFormatting.BLUE + "shift" + EnumChatFormatting.GRAY + " for Recipe-");
+ }
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/AverageLengtheningCatalyst.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/AverageLengtheningCatalyst.java
new file mode 100644
index 00000000..841a9729
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/AverageLengtheningCatalyst.java
@@ -0,0 +1,20 @@
+package WayofTime.alchemicalWizardry.common.items.potion;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class AverageLengtheningCatalyst extends LengtheningCatalyst
+{
+ public AverageLengtheningCatalyst()
+ {
+ super(2);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:AverageLengtheningCatalyst");
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/AveragePowerCatalyst.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/AveragePowerCatalyst.java
new file mode 100644
index 00000000..3ce2cde9
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/AveragePowerCatalyst.java
@@ -0,0 +1,20 @@
+package WayofTime.alchemicalWizardry.common.items.potion;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class AveragePowerCatalyst extends PowerCatalyst
+{
+ public AveragePowerCatalyst()
+ {
+ super(2);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:AveragePowerCatalyst");
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/CombinationalCatalyst.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/CombinationalCatalyst.java
new file mode 100644
index 00000000..8097cde0
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/CombinationalCatalyst.java
@@ -0,0 +1,24 @@
+package WayofTime.alchemicalWizardry.common.items.potion;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.item.Item;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.common.alchemy.ICombinationalCatalyst;
+
+public class CombinationalCatalyst extends Item implements ICombinationalCatalyst
+{
+ public CombinationalCatalyst()
+ {
+ super();
+ this.setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:CombinationalCatalyst");
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/EnhancedFillingAgent.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/EnhancedFillingAgent.java
new file mode 100644
index 00000000..ecbad19d
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/EnhancedFillingAgent.java
@@ -0,0 +1,57 @@
+package WayofTime.alchemicalWizardry.common.items.potion;
+
+import java.util.Random;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class EnhancedFillingAgent extends WeakFillingAgent
+{
+ public EnhancedFillingAgent()
+ {
+ super();
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ }
+
+ @Override
+ public int getFilledAmountForPotionNumber(int potionEffects)
+ {
+ Random rand = new Random();
+
+ if (potionEffects == 0)
+ {
+ return 8;
+ }
+
+ //if(potionEffects >=1 && potionEffects<=5)
+ {
+ switch (potionEffects)
+ {
+ case 1:
+ return 6;
+
+ case 2:
+ return 4;
+
+ case 3:
+ return 3;
+
+ case 4:
+ return 2;
+
+ case 5:
+ return 2;
+ }
+ }
+ return 0;
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:EnhancedFillingAgent");
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/GreaterLengtheningCatalyst.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/GreaterLengtheningCatalyst.java
new file mode 100644
index 00000000..65bb052e
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/GreaterLengtheningCatalyst.java
@@ -0,0 +1,20 @@
+package WayofTime.alchemicalWizardry.common.items.potion;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class GreaterLengtheningCatalyst extends LengtheningCatalyst
+{
+ public GreaterLengtheningCatalyst()
+ {
+ super(3);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:GreaterLengtheningCatalyst");
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/GreaterPowerCatalyst.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/GreaterPowerCatalyst.java
new file mode 100644
index 00000000..e5dd6d47
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/GreaterPowerCatalyst.java
@@ -0,0 +1,20 @@
+package WayofTime.alchemicalWizardry.common.items.potion;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class GreaterPowerCatalyst extends PowerCatalyst
+{
+ public GreaterPowerCatalyst()
+ {
+ super(3);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:GreaterPowerCatalyst");
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/LengtheningCatalyst.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/LengtheningCatalyst.java
new file mode 100644
index 00000000..7476f689
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/LengtheningCatalyst.java
@@ -0,0 +1,64 @@
+package WayofTime.alchemicalWizardry.common.items.potion;
+
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.alchemy.AlchemyRecipeRegistry;
+import WayofTime.alchemicalWizardry.common.ICatalyst;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumChatFormatting;
+
+import org.lwjgl.input.Keyboard;
+
+import java.util.List;
+
+public class LengtheningCatalyst extends Item implements ICatalyst
+{
+ private int catalystStrength;
+
+ public LengtheningCatalyst(int catalystStrength)
+ {
+ super();
+ this.catalystStrength = catalystStrength;
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ }
+
+ @Override
+ public int getCatalystLevel()
+ {
+ return catalystStrength;
+ }
+
+ @Override
+ public boolean isConcentration()
+ {
+ return false;
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Used in alchemy");
+
+ if (Keyboard.isKeyDown(Keyboard.KEY_RSHIFT) || Keyboard.isKeyDown(Keyboard.KEY_LSHIFT))
+ {
+ ItemStack[] recipe = AlchemyRecipeRegistry.getRecipeForItemStack(par1ItemStack);
+
+ if (recipe != null)
+ {
+ par3List.add(EnumChatFormatting.BLUE + "Recipe:");
+
+ for (ItemStack item : recipe)
+ {
+ if (item != null)
+ {
+ par3List.add("" + item.getDisplayName());
+ }
+ }
+ }
+ } else
+ {
+ par3List.add("-Press " + EnumChatFormatting.BLUE + "shift" + EnumChatFormatting.GRAY + " for Recipe-");
+ }
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/MundaneLengtheningCatalyst.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/MundaneLengtheningCatalyst.java
new file mode 100644
index 00000000..e945ed22
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/MundaneLengtheningCatalyst.java
@@ -0,0 +1,20 @@
+package WayofTime.alchemicalWizardry.common.items.potion;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class MundaneLengtheningCatalyst extends LengtheningCatalyst
+{
+ public MundaneLengtheningCatalyst()
+ {
+ super(1);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:MundaneLengtheningCatalyst");
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/MundanePowerCatalyst.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/MundanePowerCatalyst.java
new file mode 100644
index 00000000..86291dec
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/MundanePowerCatalyst.java
@@ -0,0 +1,20 @@
+package WayofTime.alchemicalWizardry.common.items.potion;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class MundanePowerCatalyst extends PowerCatalyst
+{
+ public MundanePowerCatalyst()
+ {
+ super(1);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:MundanePowerCatalyst");
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/PowerCatalyst.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/PowerCatalyst.java
new file mode 100644
index 00000000..60d98566
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/PowerCatalyst.java
@@ -0,0 +1,64 @@
+package WayofTime.alchemicalWizardry.common.items.potion;
+
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.alchemy.AlchemyRecipeRegistry;
+import WayofTime.alchemicalWizardry.common.ICatalyst;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumChatFormatting;
+
+import org.lwjgl.input.Keyboard;
+
+import java.util.List;
+
+public class PowerCatalyst extends Item implements ICatalyst
+{
+ private int catalystStrength;
+
+ public PowerCatalyst(int catalystStrength)
+ {
+ super();
+ this.catalystStrength = catalystStrength;
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ }
+
+ @Override
+ public int getCatalystLevel()
+ {
+ return catalystStrength;
+ }
+
+ @Override
+ public boolean isConcentration()
+ {
+ return true;
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Used in alchemy");
+
+ if (Keyboard.isKeyDown(Keyboard.KEY_RSHIFT) || Keyboard.isKeyDown(Keyboard.KEY_LSHIFT))
+ {
+ ItemStack[] recipe = AlchemyRecipeRegistry.getRecipeForItemStack(par1ItemStack);
+
+ if (recipe != null)
+ {
+ par3List.add(EnumChatFormatting.BLUE + "Recipe:");
+
+ for (ItemStack item : recipe)
+ {
+ if (item != null)
+ {
+ par3List.add("" + item.getDisplayName());
+ }
+ }
+ }
+ } else
+ {
+ par3List.add("-Press " + EnumChatFormatting.BLUE + "shift" + EnumChatFormatting.GRAY + " for Recipe-");
+ }
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/StandardBindingAgent.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/StandardBindingAgent.java
new file mode 100644
index 00000000..6a2edc0b
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/StandardBindingAgent.java
@@ -0,0 +1,66 @@
+package WayofTime.alchemicalWizardry.common.items.potion;
+
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumChatFormatting;
+
+import org.lwjgl.input.Keyboard;
+
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.alchemy.AlchemyRecipeRegistry;
+import WayofTime.alchemicalWizardry.common.IBindingAgent;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class StandardBindingAgent extends Item implements IBindingAgent
+{
+ public StandardBindingAgent()
+ {
+ super();
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ }
+
+ @Override
+ public float getSuccessRateForPotionNumber(int potions)
+ {
+ return (float) Math.pow(0.65, potions);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:StandardBindingAgent");
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Used in alchemy");
+
+ if (Keyboard.isKeyDown(Keyboard.KEY_RSHIFT) || Keyboard.isKeyDown(Keyboard.KEY_LSHIFT))
+ {
+ ItemStack[] recipe = AlchemyRecipeRegistry.getRecipeForItemStack(par1ItemStack);
+
+ if (recipe != null)
+ {
+ par3List.add(EnumChatFormatting.BLUE + "Recipe:");
+
+ for (ItemStack item : recipe)
+ {
+ if (item != null)
+ {
+ par3List.add("" + item.getDisplayName());
+ }
+ }
+ }
+ } else
+ {
+ par3List.add("-Press " + EnumChatFormatting.BLUE + "shift" + EnumChatFormatting.GRAY + " for Recipe-");
+ }
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/StandardFillingAgent.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/StandardFillingAgent.java
new file mode 100644
index 00000000..0cc4c9a8
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/StandardFillingAgent.java
@@ -0,0 +1,39 @@
+package WayofTime.alchemicalWizardry.common.items.potion;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class StandardFillingAgent extends WeakFillingAgent
+{
+ public StandardFillingAgent()
+ {
+ super();
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ }
+
+ @Override
+ public int getFilledAmountForPotionNumber(int potionEffects)
+ {
+ //Random rand = new Random();
+ if (potionEffects == 0)
+ {
+ return 8;
+ }
+
+ if (potionEffects >= 1 && potionEffects <= 3)
+ {
+ return (int) (4 * (Math.pow(0.5f, potionEffects - 1) + 0.01f));
+ }
+
+ return 0;
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:StandardFillingAgent");
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/WeakBindingAgent.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/WeakBindingAgent.java
new file mode 100644
index 00000000..24ee6f0b
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/WeakBindingAgent.java
@@ -0,0 +1,27 @@
+package WayofTime.alchemicalWizardry.common.items.potion;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class WeakBindingAgent extends StandardBindingAgent
+{
+ public WeakBindingAgent()
+ {
+ super();
+ // TODO Auto-generated constructor stub
+ }
+
+ @Override
+ public float getSuccessRateForPotionNumber(int potions)
+ {
+ return (float) Math.pow(0.4, potions);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:WeakBindingAgent");
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/WeakFillingAgent.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/WeakFillingAgent.java
new file mode 100644
index 00000000..cd858f16
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/potion/WeakFillingAgent.java
@@ -0,0 +1,85 @@
+package WayofTime.alchemicalWizardry.common.items.potion;
+
+import java.util.List;
+import java.util.Random;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumChatFormatting;
+
+import org.lwjgl.input.Keyboard;
+
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.alchemy.AlchemyRecipeRegistry;
+import WayofTime.alchemicalWizardry.common.IFillingAgent;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class WeakFillingAgent extends Item implements IFillingAgent
+{
+ public WeakFillingAgent()
+ {
+ super();
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ }
+
+ @Override
+ public int getFilledAmountForPotionNumber(int potionEffects)
+ {
+ Random rand = new Random();
+
+ if (potionEffects == 0)
+ {
+ return 8;
+ }
+
+ if (potionEffects == 1 || potionEffects == 2)
+ {
+ if (rand.nextFloat() > 0.5f)
+ {
+ return (4 - potionEffects);
+ } else
+ {
+ return 3 - potionEffects;
+ }
+ }
+
+ return 0;
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:WeakFillingAgent");
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Used in alchemy");
+
+ if (Keyboard.isKeyDown(Keyboard.KEY_RSHIFT) || Keyboard.isKeyDown(Keyboard.KEY_LSHIFT))
+ {
+ ItemStack[] recipe = AlchemyRecipeRegistry.getRecipeForItemStack(par1ItemStack);
+
+ if (recipe != null)
+ {
+ par3List.add(EnumChatFormatting.BLUE + "Recipe:");
+
+ for (ItemStack item : recipe)
+ {
+ if (item != null)
+ {
+ par3List.add("" + item.getDisplayName());
+ }
+ }
+ }
+ } else
+ {
+ par3List.add("-Press " + EnumChatFormatting.BLUE + "shift" + EnumChatFormatting.GRAY + " for Recipe-");
+ }
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/AirSigil.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/AirSigil.java
new file mode 100644
index 00000000..8858819b
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/AirSigil.java
@@ -0,0 +1,106 @@
+package WayofTime.alchemicalWizardry.common.items.sigil;
+
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.Vec3;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.items.interfaces.ArmourUpgrade;
+import WayofTime.alchemicalWizardry.common.items.EnergyItems;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class AirSigil extends EnergyItems implements ArmourUpgrade
+{
+ private int energyUsed;
+
+ public AirSigil()
+ {
+ super();
+ this.maxStackSize = 1;
+ //setMaxDamage(1000);
+ setEnergyUsed(50);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("I feel lighter already...");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:AirSigil");
+ }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par3EntityPlayer);
+
+ if (par3EntityPlayer.isSneaking())
+ {
+ return par1ItemStack;
+ }
+
+ Vec3 vec = par3EntityPlayer.getLookVec();
+ double wantedVelocity = 1.7;
+
+ if (par3EntityPlayer.isPotionActive(AlchemicalWizardry.customPotionBoost))
+ {
+ int i = par3EntityPlayer.getActivePotionEffect(AlchemicalWizardry.customPotionBoost).getAmplifier();
+ wantedVelocity += (1 + i) * (0.35);
+ }
+
+ par3EntityPlayer.motionX = vec.xCoord * wantedVelocity;
+ par3EntityPlayer.motionY = vec.yCoord * wantedVelocity;
+ par3EntityPlayer.motionZ = vec.zCoord * wantedVelocity;
+ par2World.playSoundEffect((double) ((float) par3EntityPlayer.posX + 0.5F), (double) ((float) par3EntityPlayer.posY + 0.5F), (double) ((float) par3EntityPlayer.posZ + 0.5F), "random.fizz", 0.5F, 2.6F + (par2World.rand.nextFloat() - par2World.rand.nextFloat()) * 0.8F);
+ par3EntityPlayer.fallDistance = 0;
+
+ if (!par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ if (!EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, getEnergyUsed()))
+ {
+ }
+ } else
+ {
+ return par1ItemStack;
+ }
+
+ return par1ItemStack;
+ }
+
+ @Override
+ public void onArmourUpdate(World world, EntityPlayer player,
+ ItemStack thisItemStack)
+ {
+ // TODO Auto-generated method stub
+ player.fallDistance = 0;
+ }
+
+ @Override
+ public boolean isUpgrade()
+ {
+ // TODO Auto-generated method stub
+ return true;
+ }
+
+ @Override
+ public int getEnergyForTenSeconds()
+ {
+ // TODO Auto-generated method stub
+ return 50;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/DivinationSigil.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/DivinationSigil.java
new file mode 100644
index 00000000..bf83193b
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/DivinationSigil.java
@@ -0,0 +1,141 @@
+package WayofTime.alchemicalWizardry.common.items.sigil;
+
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.potion.Potion;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ChatComponentText;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.IReagentHandler;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentContainerInfo;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentRegistry;
+import WayofTime.alchemicalWizardry.api.items.interfaces.ArmourUpgrade;
+import WayofTime.alchemicalWizardry.api.items.interfaces.IBindable;
+import WayofTime.alchemicalWizardry.api.items.interfaces.IReagentManipulator;
+import WayofTime.alchemicalWizardry.common.items.EnergyItems;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class DivinationSigil extends Item implements ArmourUpgrade, IReagentManipulator, IBindable
+{
+ public DivinationSigil()
+ {
+ super();
+ this.maxStackSize = 1;
+ //setMaxDamage(1000);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:DivinationSigil");
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Peer into the soul to");
+ par3List.add("get the current essence");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+ }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par3EntityPlayer);
+
+ if (par3EntityPlayer.worldObj.isRemote)
+ {
+ return par1ItemStack;
+ }
+
+ NBTTagCompound itemTag = par1ItemStack.stackTagCompound;
+
+ if (itemTag == null || itemTag.getString("ownerName").equals(""))
+ {
+ return par1ItemStack;
+ }
+
+ String ownerName = itemTag.getString("ownerName");
+ //PacketDispatcher.sendPacketToServer(PacketHandler.getPacket(ownerName));
+ int currentEssence = EnergyItems.getCurrentEssence(ownerName);
+
+ MovingObjectPosition movingobjectposition = this.getMovingObjectPositionFromPlayer(par2World, par3EntityPlayer, false);
+
+ if (movingobjectposition == null)
+ {
+ par3EntityPlayer.addChatMessage(new ChatComponentText("Current Essence: " + EnergyItems.getCurrentEssence(ownerName) + "LP"));
+
+ return par1ItemStack;
+ } else
+ {
+ if (movingobjectposition.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK)
+ {
+ int x = movingobjectposition.blockX;
+ int y = movingobjectposition.blockY;
+ int z = movingobjectposition.blockZ;
+
+ TileEntity tile = par2World.getTileEntity(x, y, z);
+
+ if(!(tile instanceof IReagentHandler))
+ {
+ par3EntityPlayer.addChatMessage(new ChatComponentText("Current Essence: " + EnergyItems.getCurrentEssence(ownerName) + "LP"));
+
+ return par1ItemStack;
+ }
+
+ IReagentHandler relay = (IReagentHandler)tile;
+
+ ReagentContainerInfo[] infoList = relay.getContainerInfo(ForgeDirection.UNKNOWN);
+ if(infoList != null)
+ {
+ for(ReagentContainerInfo info : infoList)
+ {
+ if(info != null && info.reagent != null && info.reagent.reagent != null)
+ {
+ par3EntityPlayer.addChatComponentMessage(new ChatComponentText("Reagent: " + ReagentRegistry.getKeyForReagent(info.reagent.reagent) + ", Amount: " + info.reagent.amount));
+ }
+ }
+ }
+ }
+ }
+
+ return par1ItemStack;
+ }
+
+ @Override
+ public void onArmourUpdate(World world, EntityPlayer player, ItemStack thisItemStack)
+ {
+ // TODO Auto-generated method stub
+ player.addPotionEffect(new PotionEffect(Potion.nightVision.id, 400, 9, true));
+ }
+
+ @Override
+ public boolean isUpgrade()
+ {
+ // TODO Auto-generated method stub
+ return true;
+ }
+
+ @Override
+ public int getEnergyForTenSeconds()
+ {
+ // TODO Auto-generated method stub
+ return 25;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/ItemBloodLightSigil.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/ItemBloodLightSigil.java
new file mode 100644
index 00000000..6134399a
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/ItemBloodLightSigil.java
@@ -0,0 +1,145 @@
+package WayofTime.alchemicalWizardry.common.items.sigil;
+
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.ModBlocks;
+import WayofTime.alchemicalWizardry.api.items.interfaces.IHolding;
+import WayofTime.alchemicalWizardry.common.entity.projectile.EntityBloodLightProjectile;
+import WayofTime.alchemicalWizardry.common.items.EnergyItems;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class ItemBloodLightSigil extends EnergyItems implements IHolding
+{
+ private int tickDelay = 100;
+
+ public ItemBloodLightSigil()
+ {
+ super();
+ this.maxStackSize = 1;
+ //setMaxDamage(1000);
+ setEnergyUsed(10);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ // TODO Auto-generated constructor stub
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("I see a light!");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:BloodLightSigil");
+ }
+
+ @Override
+ public boolean onItemUse(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, World par3World, int par4, int par5, int par6, int par7, float par8, float par9, float par10)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par2EntityPlayer);
+ EnergyItems.syphonBatteries(par1ItemStack, par2EntityPlayer, getEnergyUsed());
+
+ if (par3World.isRemote)
+ {
+ return true;
+ }
+
+ if (par7 == 0 && par3World.isAirBlock(par4, par5 - 1, par6))
+ {
+ par3World.setBlock(par4, par5 - 1, par6, ModBlocks.blockBloodLight);
+ }
+
+ if (par7 == 1 && par3World.isAirBlock(par4, par5 + 1, par6))
+ {
+ par3World.setBlock(par4, par5 + 1, par6, ModBlocks.blockBloodLight);
+ }
+
+ if (par7 == 2 && par3World.isAirBlock(par4, par5, par6 - 1))
+ {
+ par3World.setBlock(par4, par5, par6 - 1, ModBlocks.blockBloodLight);
+ }
+
+ if (par7 == 3 && par3World.isAirBlock(par4, par5, par6 + 1))
+ {
+ par3World.setBlock(par4, par5, par6 + 1, ModBlocks.blockBloodLight);
+ }
+
+ if (par7 == 4 && par3World.isAirBlock(par4 - 1, par5, par6))
+ {
+ par3World.setBlock(par4 - 1, par5, par6, ModBlocks.blockBloodLight);
+ }
+
+ if (par7 == 5 && par3World.isAirBlock(par4 + 1, par5, par6))
+ {
+ par3World.setBlock(par4 + 1, par5, par6, ModBlocks.blockBloodLight);
+ }
+
+ return true;
+ }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par3EntityPlayer);
+
+ if (par3EntityPlayer.isSneaking())
+ {
+ return par1ItemStack;
+ }
+
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, getEnergyUsed() * 5);
+
+ if (!par2World.isRemote)
+ {
+ par2World.spawnEntityInWorld(new EntityBloodLightProjectile(par2World, par3EntityPlayer, 10));
+ }
+
+ return par1ItemStack;
+ }
+
+ @Override
+ public void onUpdate(ItemStack par1ItemStack, World par2World, Entity par3Entity, int par4, boolean par5)
+ {
+ if (!(par3Entity instanceof EntityPlayer))
+ {
+ return;
+ }
+
+ EntityPlayer par3EntityPlayer = (EntityPlayer) par3Entity;
+
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ if (par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ if (par2World.getWorldTime() % tickDelay == par1ItemStack.stackTagCompound.getInteger("worldTimeDelay") && par3Entity instanceof EntityPlayer)
+ {
+ EnergyItems.syphonBatteries(par1ItemStack, (EntityPlayer) par3Entity, getEnergyUsed());
+ }
+ }
+
+ return;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/ItemFluidSigil.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/ItemFluidSigil.java
new file mode 100644
index 00000000..2af9459f
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/ItemFluidSigil.java
@@ -0,0 +1,811 @@
+package WayofTime.alchemicalWizardry.common.items.sigil;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.MaterialLiquid;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ChatComponentText;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.IFluidContainerItem;
+import net.minecraftforge.fluids.IFluidHandler;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.ModBlocks;
+import WayofTime.alchemicalWizardry.common.Int3;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class ItemFluidSigil extends Item implements IFluidContainerItem
+{
+ private int capacity = 128 * 1000;
+ private static final int STATE_SYPHON = 0;
+ private static final int STATE_FORCE_SYPHON = 1;
+ private static final int STATE_PLACE = 2;
+ private static final int STATE_INPUT_TANK = 3;
+ private static final int STATE_DRAIN_TANK = 4;
+ private static final int STATE_BEAST_DRAIN = 5;
+ private static final int maxNumOfStates = 6;
+
+ public ItemFluidSigil()
+ {
+ super();
+ this.setMaxDamage(0);
+ this.setMaxStackSize(1);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("A sigil with a lovely affinity for fluids");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ //par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+
+ switch(this.getActionState(par1ItemStack))
+ {
+ case STATE_SYPHON:
+ par3List.add("Syphoning Mode");
+ break;
+ case STATE_FORCE_SYPHON:
+ par3List.add("Force-syphon Mode");
+ break;
+ case STATE_PLACE:
+ par3List.add("Fluid Placement Mode");
+ break;
+ case STATE_INPUT_TANK:
+ par3List.add("Fill Tank Mode");
+ break;
+ case STATE_DRAIN_TANK:
+ par3List.add("Drain Tank Mode");
+ break;
+ case STATE_BEAST_DRAIN:
+ par3List.add("Beast Mode");
+ break;
+ }
+
+ FluidStack fluid = this.getFluid(par1ItemStack);
+ if(fluid!=null && fluid.amount>0)
+ {
+ String str = fluid.getFluid().getName();
+ int amount = fluid.amount;
+
+ par3List.add("" + amount + "mB of " + str);
+ }else
+ {
+ par3List.add("Empty");
+ }
+ }
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:WaterSigil");
+ }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ if(par3EntityPlayer.isSneaking())
+ {
+ int curState = this.cycleActionState(par1ItemStack);
+ this.sendMessageViaState(curState, par3EntityPlayer);
+ return par1ItemStack;
+ }
+
+// if(par2World.isRemote)
+// {
+// return par1ItemStack;
+// }
+
+ switch(this.getActionState(par1ItemStack))
+ {
+ case STATE_SYPHON:
+ return this.fillItemFromWorld(par1ItemStack, par2World, par3EntityPlayer,false);
+ case STATE_FORCE_SYPHON:
+ return this.fillItemFromWorld(par1ItemStack, par2World, par3EntityPlayer,true);
+ case STATE_PLACE:
+ return this.emptyItemToWorld(par1ItemStack, par2World, par3EntityPlayer);
+ case STATE_INPUT_TANK:
+ return this.fillSelectedTank(par1ItemStack, par2World, par3EntityPlayer);
+ case STATE_DRAIN_TANK:
+ return this.drainSelectedTank(par1ItemStack, par2World, par3EntityPlayer);
+ case STATE_BEAST_DRAIN:
+ return this.fillItemFromBeastWorld(par1ItemStack, par2World, par3EntityPlayer, true);
+ }
+
+ return par1ItemStack;
+ }
+
+ public int getActionState(ItemStack item)
+ {
+ if (item.stackTagCompound == null)
+ {
+ item.setTagCompound(new NBTTagCompound());
+ }
+
+ return item.stackTagCompound.getInteger("actionState");
+ }
+
+ public void setActionState(ItemStack item, int actionState)
+ {
+ if (item.stackTagCompound == null)
+ {
+ item.setTagCompound(new NBTTagCompound());
+ }
+
+ item.stackTagCompound.setInteger("actionState", actionState);
+ }
+
+ public int cycleActionState(ItemStack item)
+ {
+ int state = this.getActionState(item);
+
+ state++;
+
+ if(state>=maxNumOfStates)
+ {
+ state = 0;
+ }
+
+ this.setActionState(item, state);
+
+ return state;
+ }
+
+ public void sendMessageViaState(int state, EntityPlayer player)
+ {
+ if(player.worldObj.isRemote)
+ {
+ ChatComponentText cmc = new ChatComponentText("");
+ switch(state)
+ {
+ case STATE_SYPHON:
+ cmc.appendText("Now in Syphoning Mode");
+ break;
+ case STATE_FORCE_SYPHON:
+ cmc.appendText("Now in Force-syphon Mode");
+ break;
+ case STATE_PLACE:
+ cmc.appendText("Now in Fluid Placement Mode");
+ break;
+ case STATE_INPUT_TANK:
+ cmc.appendText("Now in Fill Tank Mode");
+ break;
+ case STATE_DRAIN_TANK:
+ cmc.appendText("Now in Drain Tank Mode");
+ break;
+ case STATE_BEAST_DRAIN:
+ cmc.appendText("Now in Beast Mode");
+ break;
+ }
+ player.addChatComponentMessage(cmc);
+ }
+ }
+
+ public ItemStack fillItemFromBeastWorld(ItemStack container, World world, EntityPlayer player, boolean forceFill)
+ {
+ if(world.isRemote)
+ {
+ return container;
+ }
+ int range = 5;
+
+ float f = 1.0F;
+ double d0 = player.prevPosX + (player.posX - player.prevPosX) * (double)f;
+ double d1 = player.prevPosY + (player.posY - player.prevPosY) * (double)f + 1.62D - (double)player.yOffset;
+ double d2 = player.prevPosZ + (player.posZ - player.prevPosZ) * (double)f;
+ boolean flag = true;
+ MovingObjectPosition movingobjectposition = this.getMovingObjectPositionFromPlayer(world, player, flag);
+
+ if (movingobjectposition == null)
+ {
+ return container;
+ }
+ else
+ {
+ if (movingobjectposition.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK)
+ {
+ int x = movingobjectposition.blockX;
+ int y = movingobjectposition.blockY;
+ int z = movingobjectposition.blockZ;
+
+ if (!world.canMineBlock(player, x, y, z))
+ {
+ return container;
+ }
+
+ if (!player.canPlayerEdit(x, y, z, movingobjectposition.sideHit, container))
+ {
+ return container;
+ }
+
+ boolean[][][] boolList = new boolean[range * 2 + 1][range * 2 + 1][range * 2 + 1];
+
+ for (int i = 0; i < 2 * range + 1; i++)
+ {
+ for (int j = 0; j < 2 * range + 1; j++)
+ {
+ for(int k = 0; k < 2 * range + 1; k++)
+ {
+ boolList[i][j][k] = false;
+ }
+ }
+ }
+
+ List positionList = new ArrayList();
+
+ boolList[range][range][range] = true;
+ positionList.add(new Int3(range, range, range));
+ boolean isReady = false;
+
+ while (!isReady)
+ {
+ isReady = true;
+
+ for (int i = 0; i < 2 * range + 1; i++)
+ {
+ for (int j = 0; j < 2 * range + 1; j++)
+ {
+ for(int k=0; k < 2*range+1;k++)
+ {
+ if (boolList[i][j][k])
+ {
+ if (i - 1 >= 0 && !boolList[i - 1][j][k])
+ {
+ Block block = world.getBlock(x - range + i - 1, y - range + j, z - range + k);
+ Fluid fluid = FluidRegistry.lookupFluidForBlock(block);
+
+ if (fluid != null)
+ {
+ boolList[i - 1][j][k] = true;
+ positionList.add(new Int3(i-1,j,k));
+ isReady = false;
+ }
+ }
+
+ if (j - 1 >= 0 && !boolList[i][j - 1][k])
+ {
+ Block block = world.getBlock(x - range + i, y - range + j - 1, z - range + k);
+ Fluid fluid = FluidRegistry.lookupFluidForBlock(block);
+
+ if (fluid != null)
+ {
+ boolList[i][j - 1][k] = true;
+ positionList.add(new Int3(i,j-1,k));
+ isReady = false;
+ }
+ }
+
+ if(k - 1 >=0 && !boolList[i][j][k - 1])
+ {
+ Block block = world.getBlock(x - range + i, y - range + j, z - range + k - 1);
+ Fluid fluid = FluidRegistry.lookupFluidForBlock(block);
+
+ if (fluid != null)
+ {
+ boolList[i][j][k - 1] = true;
+ positionList.add(new Int3(i,j,k-1));
+ isReady = false;
+ }
+ }
+
+ if (i + 1 <= 2 * range && !boolList[i + 1][j][k])
+ {
+ Block block = world.getBlock(x - range + i + 1, y - range + j, z - range + k);
+ Fluid fluid = FluidRegistry.lookupFluidForBlock(block);
+
+ if (fluid != null)
+ {
+ boolList[i + 1][j][k] = true;
+ positionList.add(new Int3(i+1,j,k));
+ isReady = false;
+ }
+ }
+
+ if (j + 1 <= 2 * range && !boolList[i][j + 1][k])
+ {
+ Block block = world.getBlock(x - range + i, y - range + j + 1, z - range + k);
+ Fluid fluid = FluidRegistry.lookupFluidForBlock(block);
+
+ if (fluid != null)
+ {
+ boolList[i][j + 1][k] = true;
+ positionList.add(new Int3(i,j+1,k));
+ isReady = false;
+ }
+ }
+
+ if(k + 1 <= 2*range && !boolList[i][j][k+1])
+ {
+ Block block = world.getBlock(x - range + i, y - range + j, z - range + k + 1);
+ Fluid fluid = FluidRegistry.lookupFluidForBlock(block);
+
+ if (fluid != null)
+ {
+ boolList[i][j][k+1] = true;
+ positionList.add(new Int3(i,j,k+1));
+ isReady = false;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ for(Int3 pos : positionList)
+ {
+ int i = pos.xCoord;
+ int j = pos.yCoord;
+ int k = pos.zCoord;
+
+ if(!boolList[i][j][k])
+ {
+ continue;
+ }
+ if (world.getBlock(x+i-range, y+j-range, z+k-range) != null && world.getBlock(x+i-range, y+j-range, z+k-range).getMaterial() instanceof MaterialLiquid)
+ {
+ //world.setBlockToAir(x+i-range, y+j-range, z+k-range);
+ Block block = world.getBlock(x+i-range, y+j-range, z+k-range);
+ if(block == null)
+ {
+ continue;
+ }
+ Fluid fluid = FluidRegistry.lookupFluidForBlock(block);
+
+ System.out.println("x: " + (i-range) + " y: " + (j-range) + " z: " + (k-range));
+
+
+ if(fluid==null || world.getBlockMetadata(x+i-range, y+j-range, z+k-range) != 0)
+ {
+ continue;
+ }
+
+
+ FluidStack fillStack = new FluidStack(fluid,1000);
+
+ int amount = this.fill(container, fillStack, false);
+
+ if((amount > 0 && forceFill) || (amount >=1000 && !forceFill))
+ {
+ //if(!player.capabilities.isCreativeMode)
+ {
+ world.setBlockToAir(x+i-range, y+j-range, z+k-range);
+
+ }
+
+ this.fill(container, new FluidStack(fluid,1000), true);
+ }
+ }
+ }
+ }
+
+ return container;
+ }
+ }
+
+ public ItemStack fillItemFromWorld(ItemStack container, World world, EntityPlayer player, boolean forceFill)
+ {
+ float f = 1.0F;
+ double d0 = player.prevPosX + (player.posX - player.prevPosX) * (double)f;
+ double d1 = player.prevPosY + (player.posY - player.prevPosY) * (double)f + 1.62D - (double)player.yOffset;
+ double d2 = player.prevPosZ + (player.posZ - player.prevPosZ) * (double)f;
+ boolean flag = true;
+ MovingObjectPosition movingobjectposition = this.getMovingObjectPositionFromPlayer(world, player, flag);
+
+ if (movingobjectposition == null)
+ {
+ return container;
+ }
+ else
+ {
+ if (movingobjectposition.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK)
+ {
+ int i = movingobjectposition.blockX;
+ int j = movingobjectposition.blockY;
+ int k = movingobjectposition.blockZ;
+
+ if (!world.canMineBlock(player, i, j, k))
+ {
+ return container;
+ }
+
+ if (!player.canPlayerEdit(i, j, k, movingobjectposition.sideHit, container))
+ {
+ return container;
+ }
+
+ if (world.getBlock(i, j, k) != null && world.getBlock(i, j, k).getMaterial() instanceof MaterialLiquid)
+ {
+ Block block = world.getBlock(i, j, k);
+ Fluid fluid = FluidRegistry.lookupFluidForBlock(block);
+
+ if(fluid==null)
+ {
+ return container;
+ }
+
+ FluidStack fillStack = new FluidStack(fluid,1000);
+
+ int amount = this.fill(container, fillStack, false);
+
+ if((amount > 0 && forceFill) || (amount >=1000 && !forceFill))
+ {
+ if(!player.capabilities.isCreativeMode)
+ {
+ world.setBlockToAir(i, j, k);
+ }
+
+ this.fill(container, new FluidStack(fluid,1000), true);
+
+ if (!player.capabilities.isCreativeMode)
+ {
+// if (!EnergyItems.syphonBatteries(container, player, getEnergyUsed()))
+// {
+// }
+ }
+ else
+ {
+ return container;
+ }
+ }
+ }
+ }
+
+ return container;
+ }
+ }
+
+ public ItemStack emptyItemToWorld(ItemStack container, World world, EntityPlayer player)
+ {
+ FluidStack simStack = this.drain(container, 1000, false);
+
+ if(simStack!=null && simStack.amount>=1000)
+ {
+ Block fluidBlock = simStack.getFluid().getBlock();
+
+ float f = 1.0F;
+ double d0 = player.prevPosX + (player.posX - player.prevPosX) * (double)f;
+ double d1 = player.prevPosY + (player.posY - player.prevPosY) * (double)f + 1.62D - (double)player.yOffset;
+ double d2 = player.prevPosZ + (player.posZ - player.prevPosZ) * (double)f;
+ boolean flag = false;
+ MovingObjectPosition movingobjectposition = this.getMovingObjectPositionFromPlayer(world, player, flag);
+
+ if (movingobjectposition == null)
+ {
+ return container;
+ }
+ else
+ {
+ if (movingobjectposition.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK)
+ {
+ int i = movingobjectposition.blockX;
+ int j = movingobjectposition.blockY;
+ int k = movingobjectposition.blockZ;
+
+ if (!world.canMineBlock(player, i, j, k))
+ {
+ return container;
+ }
+
+ if (movingobjectposition.sideHit == 0)
+ {
+ --j;
+ }
+
+ if (movingobjectposition.sideHit == 1)
+ {
+ ++j;
+ }
+
+ if (movingobjectposition.sideHit == 2)
+ {
+ --k;
+ }
+
+ if (movingobjectposition.sideHit == 3)
+ {
+ ++k;
+ }
+
+ if (movingobjectposition.sideHit == 4)
+ {
+ --i;
+ }
+
+ if (movingobjectposition.sideHit == 5)
+ {
+ ++i;
+ }
+
+ if (!player.canPlayerEdit(i, j, k, movingobjectposition.sideHit, container))
+ {
+ return container;
+ }
+
+ if (this.tryPlaceContainedLiquid(world, fluidBlock, d0, d1, d2, i, j, k) && !player.capabilities.isCreativeMode)
+ {
+ this.drain(container, 1000, true);
+
+ return container;
+ }
+
+ }
+
+ return container;
+ }
+ }
+
+ return container;
+ }
+
+ public boolean tryPlaceContainedLiquid(World par1World, Block block, double par2, double par4, double par6, int par8, int par9, int par10)
+ {
+ if (!par1World.isAirBlock(par8, par9, par10) && par1World.getBlock(par8, par9, par10).func_149730_j())
+ {
+ return false;
+ }
+ else if ((par1World.getBlock(par8, par9, par10).getMaterial() instanceof MaterialLiquid && (par1World.getBlockMetadata(par8, par9, par10) == 0)))
+ {
+ return false;
+ }
+ else
+ {
+ if ((block == Blocks.water || block == Blocks.flowing_water) && par1World.provider.isHellWorld)
+ {
+ par1World.playSoundEffect(par2 + 0.5D, par4 + 0.5D, par6 + 0.5D, "random.fizz", 0.5F, 2.6F + (par1World.rand.nextFloat() - par1World.rand.nextFloat()) * 0.8F);
+
+ for (int l = 0; l < 8; ++l)
+ {
+ par1World.spawnParticle("largesmoke", (double)par8 + Math.random(), (double)par9 + Math.random(), (double)par10 + Math.random(), 0.0D, 0.0D, 0.0D);
+ }
+ }
+ else
+ {
+ par1World.setBlock(par8, par9, par10, block, 0, 3);
+ }
+
+ return true;
+ }
+ }
+
+ public ItemStack fillSelectedTank(ItemStack container, World world, EntityPlayer player)
+ {
+ FluidStack fluid = this.getFluid(container);
+
+ if(fluid == null)
+ {
+ return container;
+ }
+
+ float f = 1.0F;
+ double d0 = player.prevPosX + (player.posX - player.prevPosX) * (double)f;
+ double d1 = player.prevPosY + (player.posY - player.prevPosY) * (double)f + 1.62D - (double)player.yOffset;
+ double d2 = player.prevPosZ + (player.posZ - player.prevPosZ) * (double)f;
+ boolean flag = false;
+ MovingObjectPosition movingobjectposition = this.getMovingObjectPositionFromPlayer(world, player, flag);
+
+ if (movingobjectposition == null)
+ {
+ return container;
+ }
+ else
+ {
+ if (movingobjectposition.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK)
+ {
+ int i = movingobjectposition.blockX;
+ int j = movingobjectposition.blockY;
+ int k = movingobjectposition.blockZ;
+
+ TileEntity tile = world.getTileEntity(i, j, k);
+
+ if(tile instanceof IFluidHandler)
+ {
+ int amount = ((IFluidHandler) tile).fill(ForgeDirection.getOrientation(movingobjectposition.sideHit), fluid, true);
+
+ this.drain(container, amount, true);
+ }
+ }
+ }
+
+ return container;
+ }
+
+ public ItemStack drainSelectedTank(ItemStack container, World world, EntityPlayer player)
+ {
+ float f = 1.0F;
+ double d0 = player.prevPosX + (player.posX - player.prevPosX) * (double)f;
+ double d1 = player.prevPosY + (player.posY - player.prevPosY) * (double)f + 1.62D - (double)player.yOffset;
+ double d2 = player.prevPosZ + (player.posZ - player.prevPosZ) * (double)f;
+ boolean flag = false;
+ MovingObjectPosition movingobjectposition = this.getMovingObjectPositionFromPlayer(world, player, flag);
+
+ if (movingobjectposition == null)
+ {
+ return container;
+ }
+ else
+ {
+ if (movingobjectposition.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK)
+ {
+ int i = movingobjectposition.blockX;
+ int j = movingobjectposition.blockY;
+ int k = movingobjectposition.blockZ;
+
+ TileEntity tile = world.getTileEntity(i, j, k);
+
+ if(tile instanceof IFluidHandler)
+ {
+ FluidStack fluidAmount = ((IFluidHandler) tile).drain(ForgeDirection.getOrientation(movingobjectposition.sideHit), this.getCapacity(container), false);
+
+ int amount = this.fill(container, fluidAmount, false);
+
+ if(amount>0)
+ {
+ ((IFluidHandler) tile).drain(ForgeDirection.getOrientation(movingobjectposition.sideHit), this.getCapacity(container), true);
+
+ this.fill(container, fluidAmount, true);
+ }
+ }
+ }
+ }
+
+ return container;
+ }
+
+ /* IFluidContainerItem */
+ @Override
+ public FluidStack getFluid(ItemStack container)
+ {
+ if (container.stackTagCompound == null || !container.stackTagCompound.hasKey("Fluid"))
+ {
+ return null;
+ }
+ return FluidStack.loadFluidStackFromNBT(container.stackTagCompound.getCompoundTag("Fluid"));
+ }
+
+ @Override
+ public int getCapacity(ItemStack container)
+ {
+ return capacity;
+ }
+
+ @Override
+ public int fill(ItemStack container, FluidStack resource, boolean doFill)
+ {
+ if (resource == null)
+ {
+ return 0;
+ }
+
+ if (!doFill)
+ {
+ if (container.stackTagCompound == null || !container.stackTagCompound.hasKey("Fluid"))
+ {
+ return Math.min(capacity, resource.amount);
+ }
+
+ FluidStack stack = FluidStack.loadFluidStackFromNBT(container.stackTagCompound.getCompoundTag("Fluid"));
+
+ if (stack == null || stack.amount <= 0)
+ {
+ return Math.min(capacity, resource.amount);
+ }
+
+ if (!stack.isFluidEqual(resource))
+ {
+ return 0;
+ }
+
+ return Math.min(capacity - stack.amount, resource.amount);
+ }
+
+ if (container.stackTagCompound == null)
+ {
+ container.stackTagCompound = new NBTTagCompound();
+ }
+
+ if (!container.stackTagCompound.hasKey("Fluid"))
+ {
+ NBTTagCompound fluidTag = resource.writeToNBT(new NBTTagCompound());
+
+ if (capacity < resource.amount)
+ {
+ fluidTag.setInteger("Amount", capacity);
+ container.stackTagCompound.setTag("Fluid", fluidTag);
+ return capacity;
+ }
+
+ container.stackTagCompound.setTag("Fluid", fluidTag);
+ return resource.amount;
+ }
+
+ NBTTagCompound fluidTag = container.stackTagCompound.getCompoundTag("Fluid");
+ FluidStack stack = FluidStack.loadFluidStackFromNBT(fluidTag);
+
+ if(stack==null || stack.amount<=0)
+ {
+ NBTTagCompound fluidTag1 = resource.writeToNBT(new NBTTagCompound());
+
+ if (capacity < resource.amount)
+ {
+ fluidTag1.setInteger("Amount", capacity);
+ container.stackTagCompound.setTag("Fluid", fluidTag1);
+ return capacity;
+ }
+
+ container.stackTagCompound.setTag("Fluid", fluidTag1);
+ return resource.amount;
+ }
+
+ if (!stack.isFluidEqual(resource))
+ {
+ return 0;
+ }
+
+ int filled = capacity - stack.amount;
+ if (resource.amount < filled)
+ {
+ stack.amount += resource.amount;
+ filled = resource.amount;
+ }
+ else
+ {
+ stack.amount = capacity;
+ }
+
+ container.stackTagCompound.setTag("Fluid", stack.writeToNBT(fluidTag));
+ return filled;
+ }
+
+ @Override
+ public FluidStack drain(ItemStack container, int maxDrain, boolean doDrain)
+ {
+ if (container.stackTagCompound == null || !container.stackTagCompound.hasKey("Fluid"))
+ {
+ return null;
+ }
+
+ FluidStack stack = FluidStack.loadFluidStackFromNBT(container.stackTagCompound.getCompoundTag("Fluid"));
+ if (stack == null)
+ {
+ return null;
+ }
+
+ stack.amount = Math.min(stack.amount, maxDrain);
+ if (doDrain)
+ {
+ if (maxDrain >= capacity)
+ {
+ container.stackTagCompound.removeTag("Fluid");
+
+ if (container.stackTagCompound.hasNoTags())
+ {
+ container.stackTagCompound = null;
+ }
+ return stack;
+ }
+
+ NBTTagCompound fluidTag = container.stackTagCompound.getCompoundTag("Fluid");
+ fluidTag.setInteger("Amount", fluidTag.getInteger("Amount") - maxDrain);
+ container.stackTagCompound.setTag("Fluid", fluidTag);
+ }
+ return stack;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/ItemSeerSigil.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/ItemSeerSigil.java
new file mode 100644
index 00000000..ea4e4db2
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/ItemSeerSigil.java
@@ -0,0 +1,88 @@
+package WayofTime.alchemicalWizardry.common.items.sigil;
+
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.items.interfaces.ArmourUpgrade;
+import WayofTime.alchemicalWizardry.api.items.interfaces.IHolding;
+import WayofTime.alchemicalWizardry.common.items.EnergyItems;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class ItemSeerSigil extends Item implements IHolding, ArmourUpgrade
+{
+ public ItemSeerSigil()
+ {
+ super();
+ this.maxStackSize = 1;
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:SeerSigil");
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("When seeing all is not enough");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+ }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par3EntityPlayer);
+
+ if (par3EntityPlayer.worldObj.isRemote)
+ {
+ return par1ItemStack;
+ }
+
+ NBTTagCompound itemTag = par1ItemStack.stackTagCompound;
+
+ if (itemTag == null || itemTag.getString("ownerName").equals(""))
+ {
+ return par1ItemStack;
+ }
+
+ String ownerName = itemTag.getString("ownerName");
+
+ return par1ItemStack;
+ }
+
+ @Override
+ public void onArmourUpdate(World world, EntityPlayer player,
+ ItemStack thisItemStack)
+ {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public boolean isUpgrade()
+ {
+ // TODO Auto-generated method stub
+ return false;
+ }
+
+ @Override
+ public int getEnergyForTenSeconds()
+ {
+ // TODO Auto-generated method stub
+ return 0;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/ItemSigilOfEnderSeverance.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/ItemSigilOfEnderSeverance.java
new file mode 100644
index 00000000..b341e859
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/ItemSigilOfEnderSeverance.java
@@ -0,0 +1,171 @@
+package WayofTime.alchemicalWizardry.common.items.sigil;
+
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLiving;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.items.interfaces.IHolding;
+import WayofTime.alchemicalWizardry.common.items.EnergyItems;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class ItemSigilOfEnderSeverance extends EnergyItems implements IHolding
+{
+ @SideOnly(Side.CLIENT)
+ private static IIcon activeIcon;
+ @SideOnly(Side.CLIENT)
+ private static IIcon passiveIcon;
+
+ public ItemSigilOfEnderSeverance()
+ {
+ super();
+ this.maxStackSize = 1;
+ setEnergyUsed(200);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Put those endermen in a Dire situation!");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ if (par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ par3List.add("Activated");
+ } else
+ {
+ par3List.add("Deactivated");
+ }
+
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:SigilOfSeverance_deactivated");
+ this.activeIcon = iconRegister.registerIcon("AlchemicalWizardry:SigilOfSeverance_activated");
+ this.passiveIcon = iconRegister.registerIcon("AlchemicalWizardry:SigilOfSeverance_deactivated");
+ }
+
+ @Override
+ public IIcon getIcon(ItemStack stack, int renderPass, EntityPlayer player, ItemStack usingItem, int useRemaining)
+ {
+ if (stack.stackTagCompound == null)
+ {
+ stack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = stack.stackTagCompound;
+
+ if (tag.getBoolean("isActive"))
+ {
+ return this.activeIcon;
+ } else
+ {
+ return this.passiveIcon;
+ }
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public IIcon getIconFromDamage(int par1)
+ {
+ if (par1 == 1)
+ {
+ return this.activeIcon;
+ } else
+ {
+ return this.passiveIcon;
+ }
+ }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par3EntityPlayer);
+
+ if (par3EntityPlayer.isSneaking())
+ {
+ return par1ItemStack;
+ }
+
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = par1ItemStack.stackTagCompound;
+ tag.setBoolean("isActive", !(tag.getBoolean("isActive")));
+
+ if (tag.getBoolean("isActive"))
+ {
+ par1ItemStack.setItemDamage(1);
+ tag.setInteger("worldTimeDelay", (int) (par2World.getWorldTime() - 1) % 200);
+
+ if (!par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ if (!EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, getEnergyUsed()))
+ {
+ }
+ }
+ } else
+ {
+ par1ItemStack.setItemDamage(par1ItemStack.getMaxDamage());
+ }
+
+ return par1ItemStack;
+ }
+
+ @Override
+ public void onUpdate(ItemStack par1ItemStack, World par2World, Entity par3Entity, int par4, boolean par5)
+ {
+ if (!(par3Entity instanceof EntityPlayer))
+ {
+ return;
+ }
+
+ EntityPlayer par3EntityPlayer = (EntityPlayer) par3Entity;
+
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ if (par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ List list = SpellHelper.getEntitiesInRange(par2World, par3Entity.posX, par3Entity.posY, par3Entity.posZ, 4.5, 4.5);
+ for(Entity entity : list)
+ {
+ if(!entity.equals(par3Entity)&&entity instanceof EntityLiving)
+ {
+ ((EntityLiving)entity).addPotionEffect(new PotionEffect(AlchemicalWizardry.customPotionPlanarBinding.id,5,0));
+ }
+ }
+ }
+
+ if (par2World.getWorldTime() % 200 == par1ItemStack.stackTagCompound.getInteger("worldTimeDelay") && par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ //par3EntityPlayer.addPotionEffect(new PotionEffect(Potion.field_76444_x.id, 2400,99));
+ if (!par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, getEnergyUsed());
+ }
+ }
+
+ return;
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/ItemSigilOfSupression.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/ItemSigilOfSupression.java
new file mode 100644
index 00000000..c7c607c4
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/ItemSigilOfSupression.java
@@ -0,0 +1,270 @@
+package WayofTime.alchemicalWizardry.common.items.sigil;
+
+import java.util.List;
+
+import javax.swing.Icon;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.Vec3;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.items.interfaces.ArmourUpgrade;
+import WayofTime.alchemicalWizardry.common.items.EnergyItems;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+import WayofTime.alchemicalWizardry.common.tileEntity.TESpectralContainer;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class ItemSigilOfSupression extends EnergyItems implements ArmourUpgrade
+{
+ private static IIcon activeIcon;
+ private static IIcon passiveIcon;
+ private int tickDelay = 200;
+ private int radius = 5;
+ private int refresh = 100;
+
+ public ItemSigilOfSupression()
+ {
+ super();
+ this.maxStackSize = 1;
+ setEnergyUsed(400);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Better than telekinesis");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ if (par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ par3List.add("Activated");
+ } else
+ {
+ par3List.add("Deactivated");
+ }
+
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:SigilOfSupression_deactivated");
+ this.activeIcon = iconRegister.registerIcon("AlchemicalWizardry:SigilOfSupression_activated");
+ this.passiveIcon = iconRegister.registerIcon("AlchemicalWizardry:SigilOfSupression_deactivated");
+ }
+
+ @Override
+ public IIcon getIcon(ItemStack stack, int renderPass, EntityPlayer player, ItemStack usingItem, int useRemaining)
+ {
+ if (stack.stackTagCompound == null)
+ {
+ stack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = stack.stackTagCompound;
+
+ if (tag.getBoolean("isActive"))
+ {
+ return this.activeIcon;
+ } else
+ {
+ return this.passiveIcon;
+ }
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public IIcon getIconFromDamage(int par1)
+ {
+ if (par1 == 1)
+ {
+ return this.activeIcon;
+ } else
+ {
+ return this.passiveIcon;
+ }
+ }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par3EntityPlayer);
+
+ if(SpellHelper.isFakePlayer(par2World, par3EntityPlayer))
+ {
+ return par1ItemStack;
+ }
+
+ if (par3EntityPlayer.isSneaking())
+ {
+ return par1ItemStack;
+ }
+
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = par1ItemStack.stackTagCompound;
+ tag.setBoolean("isActive", !(tag.getBoolean("isActive")));
+
+ if (tag.getBoolean("isActive"))
+ {
+ par1ItemStack.setItemDamage(1);
+ tag.setInteger("worldTimeDelay", (int) (par2World.getWorldTime() - 1) % tickDelay);
+
+ if (!par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, getEnergyUsed());
+ }
+ } else
+ {
+ par1ItemStack.setItemDamage(par1ItemStack.getMaxDamage());
+ }
+
+ return par1ItemStack;
+ }
+
+ @Override
+ public void onUpdate(ItemStack par1ItemStack, World par2World, Entity par3Entity, int par4, boolean par5)
+ {
+ if (!(par3Entity instanceof EntityPlayer))
+ {
+ return;
+ }
+
+ if(SpellHelper.isFakePlayer(par2World, (EntityPlayer)par3Entity))
+ {
+ return;
+ }
+
+ EntityPlayer par3EntityPlayer = (EntityPlayer) par3Entity;
+
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ if (par1ItemStack.stackTagCompound.getBoolean("isActive")&&(!par2World.isRemote))
+ {
+ Vec3 blockVec = SpellHelper.getEntityBlockVector(par3EntityPlayer);
+ int x = (int)blockVec.xCoord;
+ int y = (int)blockVec.yCoord;
+ int z = (int)blockVec.zCoord;
+
+ for (int i = -radius; i <= radius; i++)
+ {
+ for (int j = -radius; j <= radius; j++)
+ {
+ for(int k = -radius; k <= radius; k++)
+ {
+ if (i * i + j * j + k * k >= (radius + 0.50f) * (radius + 0.50f))
+ {
+ continue;
+ }
+
+ Block block = par2World.getBlock(x+i, y+j, z+k);
+
+
+ if(SpellHelper.isBlockFluid(block))
+ {
+ if(par2World.getTileEntity(x+i, y+j, z+k)!=null)
+ {
+ par2World.setBlockToAir(x+i, y+j, z+k);
+ }
+ TESpectralContainer.createSpectralBlockAtLocation(par2World, x+i, y+j, z+k, refresh);
+ }
+ else
+ {
+ TileEntity tile = par2World.getTileEntity(x+i, y+j, z+k);
+ if(tile instanceof TESpectralContainer)
+ {
+ ((TESpectralContainer) tile).resetDuration(refresh);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if (par2World.getWorldTime() % 200 == par1ItemStack.stackTagCompound.getInteger("worldTimeDelay") && par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ //par3EntityPlayer.addPotionEffect(new PotionEffect(Potion.field_76444_x.id, 2400,99));
+ if (!par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, getEnergyUsed());
+
+ }
+ }
+
+ return;
+ }
+
+ @Override
+ public void onArmourUpdate(World world, EntityPlayer player, ItemStack thisItemStack)
+ {
+ Vec3 blockVec = SpellHelper.getEntityBlockVector(player);
+ int x = (int)blockVec.xCoord;
+ int y = (int)blockVec.yCoord;
+ int z = (int)blockVec.zCoord;
+
+ for (int i = -radius; i <= radius; i++)
+ {
+ for (int j = -radius; j <= radius; j++)
+ {
+ for(int k = -radius; k <= radius; k++)
+ {
+ if (i * i + j * j + k * k >= (radius + 0.50f) * (radius + 0.50f))
+ {
+ continue;
+ }
+
+ Block block = world.getBlock(x+i, y+j, z+k);
+
+
+ if(SpellHelper.isBlockFluid(block))
+ {
+ if(world.getTileEntity(x+i, y+j, z+k)!=null)
+ {
+ world.setBlockToAir(x+i, y+j, z+k);
+ }
+ TESpectralContainer.createSpectralBlockAtLocation(world, x+i, y+j, z+k, refresh);
+ }
+ else
+ {
+ TileEntity tile = world.getTileEntity(x+i, y+j, z+k);
+ if(tile instanceof TESpectralContainer)
+ {
+ ((TESpectralContainer) tile).resetDuration(refresh);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ @Override
+ public boolean isUpgrade()
+ {
+ return true;
+ }
+
+ @Override
+ public int getEnergyForTenSeconds()
+ {
+ return 200;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/LavaSigil.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/LavaSigil.java
new file mode 100644
index 00000000..75028002
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/LavaSigil.java
@@ -0,0 +1,310 @@
+package WayofTime.alchemicalWizardry.common.items.sigil;
+
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemBucket;
+import net.minecraft.item.ItemStack;
+import net.minecraft.potion.Potion;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.IFluidHandler;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.items.interfaces.ArmourUpgrade;
+import WayofTime.alchemicalWizardry.common.items.EnergyBattery;
+import WayofTime.alchemicalWizardry.common.items.EnergyItems;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class LavaSigil extends ItemBucket implements ArmourUpgrade
+{
+ /**
+ * field for checking if the bucket has been filled.
+ */
+ private Block isFull = Blocks.lava;
+ private int energyUsed;
+
+ public LavaSigil()
+ {
+ super(Blocks.lava);
+ this.maxStackSize = 1;
+ //setMaxDamage(2000);
+ setEnergyUsed(1000);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:LavaSigil");
+ }
+
+ @Override
+ public ItemStack getContainerItem(ItemStack itemStack)
+ {
+ ItemStack copiedStack = itemStack.copy();
+ copiedStack.setItemDamage(copiedStack.getItemDamage() + getEnergyUsed());
+ copiedStack.stackSize = 1;
+ return copiedStack;
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Contact with liquid is");
+ par3List.add("highly unrecommended.");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+ }
+
+ /**
+ * Called whenever this item is equipped and the right mouse button is pressed. Args: itemStack, world, entityPlayer
+ */
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par3EntityPlayer);
+
+ if (par3EntityPlayer.isSneaking())
+ {
+ return par1ItemStack;
+ }
+
+ float f = 1.0F;
+ double d0 = par3EntityPlayer.prevPosX + (par3EntityPlayer.posX - par3EntityPlayer.prevPosX) * (double) f;
+ double d1 = par3EntityPlayer.prevPosY + (par3EntityPlayer.posY - par3EntityPlayer.prevPosY) * (double) f + 1.62D - (double) par3EntityPlayer.yOffset;
+ double d2 = par3EntityPlayer.prevPosZ + (par3EntityPlayer.posZ - par3EntityPlayer.prevPosZ) * (double) f;
+
+ MovingObjectPosition movingobjectposition = this.getMovingObjectPositionFromPlayer(par2World, par3EntityPlayer, false);
+
+ if (movingobjectposition == null)
+ {
+ return par1ItemStack;
+ } else
+ {
+ if (movingobjectposition.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK)
+ {
+ int i = movingobjectposition.blockX;
+ int j = movingobjectposition.blockY;
+ int k = movingobjectposition.blockZ;
+
+ if (!par2World.canMineBlock(par3EntityPlayer, i, j, k))
+ {
+ return par1ItemStack;
+ }
+
+ TileEntity tile = par2World.getTileEntity(i, j, k);
+ if(tile instanceof IFluidHandler)
+ {
+ FluidStack fluid = new FluidStack(FluidRegistry.LAVA,1000);
+ int amount = ((IFluidHandler) tile).fill(ForgeDirection.getOrientation(movingobjectposition.sideHit), fluid, false);
+
+ if(amount>0)
+ {
+ ((IFluidHandler) tile).fill(ForgeDirection.getOrientation(movingobjectposition.sideHit), fluid, true);
+ if (!par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ if (!EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, getEnergyUsed()))
+ {
+ }
+ }
+ }
+
+ return par1ItemStack;
+ }
+
+ //if (this.isFull == 0)
+ {
+ //Empty
+ } //else
+ {
+ if (movingobjectposition.sideHit == 0)
+ {
+ --j;
+ }
+
+ if (movingobjectposition.sideHit == 1)
+ {
+ ++j;
+ }
+
+ if (movingobjectposition.sideHit == 2)
+ {
+ --k;
+ }
+
+ if (movingobjectposition.sideHit == 3)
+ {
+ ++k;
+ }
+
+ if (movingobjectposition.sideHit == 4)
+ {
+ --i;
+ }
+
+ if (movingobjectposition.sideHit == 5)
+ {
+ ++i;
+ }
+
+ if (!par3EntityPlayer.canPlayerEdit(i, j, k, movingobjectposition.sideHit, par1ItemStack))
+ {
+ return par1ItemStack;
+ }
+
+ if (this.tryPlaceContainedLiquid(par2World, d0, d1, d2, i, j, k) && !par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ if (!par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ if (!EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, getEnergyUsed()))
+ {
+ }
+ } else
+ {
+ return par1ItemStack;
+ }
+ }
+ }
+ }
+
+ return par1ItemStack;
+ }
+ }
+
+ /**
+ * Attempts to place the liquid contained inside the bucket.
+ */
+ public boolean tryPlaceContainedLiquid(World par1World, double par2, double par4, double par6, int par8, int par9, int par10)
+ {
+ //if (this.isFull <= 0)
+ {
+ //return false;
+ } if (!par1World.isAirBlock(par8, par9, par10) && par1World.getBlock(par8, par9, par10).getMaterial().isSolid())
+ {
+ return false;
+ } else if ((par1World.getBlock(par8, par9, par10) == Blocks.lava || par1World.getBlock(par8, par9, par10) == Blocks.flowing_lava) && par1World.getBlockMetadata(par8, par9, par10) == 0)
+ {
+ return false;
+ } else
+ {
+ par1World.setBlock(par8, par9, par10, this.isFull, 0, 3);
+ return true;
+ }
+ }
+
+ protected void setEnergyUsed(int par1int)
+ {
+ this.energyUsed = par1int;
+ }
+
+ protected int getEnergyUsed()
+ {
+ return this.energyUsed;
+ }
+ //Heals the player using the item. If the player is at full health, or if the durability cannot be used any more,
+ //the item is not used.
+
+ // protected void damagePlayer(World world, EntityPlayer player, int damage)
+// {
+// if (world != null)
+// {
+// double posX = player.posX;
+// double posY = player.posY;
+// double posZ = player.posZ;
+// world.playSoundEffect((double)((float)posX + 0.5F), (double)((float)posY + 0.5F), (double)((float)posZ + 0.5F), "random.fizz", 0.5F, 2.6F + (world.rand.nextFloat() - world.rand.nextFloat()) * 0.8F);
+// float f = (float)1.0F;
+// float f1 = f * 0.6F + 0.4F;
+// float f2 = f * f * 0.7F - 0.5F;
+// float f3 = f * f * 0.6F - 0.7F;
+//
+// for (int l = 0; l < 8; ++l)
+// {
+// world.spawnParticle("reddust", posX + Math.random() - Math.random(), posY + Math.random() - Math.random(), posZ + Math.random() - Math.random(), f1, f2, f3);
+// }
+// }
+//
+// for (int i = 0; i < damage; i++)
+// {
+// //player.setEntityHealth((player.getHealth()-1));
+// player.setEntityHealth(player.func_110143_aJ() - 1);
+//
+// if (player.func_110143_aJ() <= 0)
+// {
+// player.inventory.dropAllItems();
+// }
+// }
+// }
+ protected boolean syphonBatteries(ItemStack ist, EntityPlayer player, int damageToBeDone)
+ {
+ if (!player.capabilities.isCreativeMode)
+ {
+ boolean usedBattery = false;
+ IInventory inventory = player.inventory;
+
+ for (int slot = 0; slot < inventory.getSizeInventory(); slot++)
+ {
+ ItemStack stack = inventory.getStackInSlot(slot);
+
+ if (stack == null)
+ {
+ continue;
+ }
+
+ if (stack.getItem() instanceof EnergyBattery && !usedBattery)
+ {
+ if (stack.getItemDamage() <= stack.getMaxDamage() - damageToBeDone)
+ {
+ stack.setItemDamage(stack.getItemDamage() + damageToBeDone);
+ usedBattery = true;
+ }
+ }
+ }
+
+ if (!usedBattery)
+ {
+ return false;
+ }
+
+ return true;
+ } else
+ {
+ return true;
+ }
+ }
+
+ @Override
+ public void onArmourUpdate(World world, EntityPlayer player,
+ ItemStack thisItemStack)
+ {
+ // TODO Auto-generated method stub
+ player.addPotionEffect(new PotionEffect(Potion.fireResistance.id, 2, 9,true));
+ player.extinguish();
+ }
+
+ @Override
+ public boolean isUpgrade()
+ {
+ // TODO Auto-generated method stub
+ return true;
+ }
+
+ @Override
+ public int getEnergyForTenSeconds()
+ {
+ // TODO Auto-generated method stub
+ return 100;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/SigilOfElementalAffinity.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/SigilOfElementalAffinity.java
new file mode 100644
index 00000000..daa017a1
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/SigilOfElementalAffinity.java
@@ -0,0 +1,171 @@
+package WayofTime.alchemicalWizardry.common.items.sigil;
+
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.potion.Potion;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.common.items.EnergyItems;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class SigilOfElementalAffinity extends EnergyItems
+{
+ @SideOnly(Side.CLIENT)
+ private static IIcon activeIcon;
+ @SideOnly(Side.CLIENT)
+ private static IIcon passiveIcon;
+
+ public SigilOfElementalAffinity()
+ {
+ super();
+ this.maxStackSize = 1;
+ setEnergyUsed(200);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Perfect for a fire-breathing fish");
+ par3List.add("who is afraid of heights!");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ if (par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ par3List.add("Activated");
+ } else
+ {
+ par3List.add("Deactivated");
+ }
+
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:SigilOfTheFastMiner");
+ this.activeIcon = iconRegister.registerIcon("AlchemicalWizardry:ElementalSigil_activated");
+ this.passiveIcon = iconRegister.registerIcon("AlchemicalWizardry:ElementalSigil_deactivated");
+ }
+
+ @Override
+ public IIcon getIcon(ItemStack stack, int renderPass, EntityPlayer player, ItemStack usingItem, int useRemaining)
+ {
+ if (stack.stackTagCompound == null)
+ {
+ stack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = stack.stackTagCompound;
+
+ if (tag.getBoolean("isActive"))
+ {
+ return this.activeIcon;
+ } else
+ {
+ return this.passiveIcon;
+ }
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public IIcon getIconFromDamage(int par1)
+ {
+ if (par1 == 1)
+ {
+ return this.activeIcon;
+ } else
+ {
+ return this.passiveIcon;
+ }
+ }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par3EntityPlayer);
+
+ if (par3EntityPlayer.isSneaking())
+ {
+ return par1ItemStack;
+ }
+
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = par1ItemStack.stackTagCompound;
+ tag.setBoolean("isActive", !(tag.getBoolean("isActive")));
+
+ if (tag.getBoolean("isActive"))
+ {
+ par1ItemStack.setItemDamage(1);
+ tag.setInteger("worldTimeDelay", (int) (par2World.getWorldTime() - 1) % 200);
+ par3EntityPlayer.addPotionEffect(new PotionEffect(Potion.waterBreathing.id, 2, 0, true));
+ par3EntityPlayer.addPotionEffect(new PotionEffect(Potion.fireResistance.id, 2, 0, true));
+
+ //Test with added health boost
+ //par3EntityPlayer.addPotionEffect(new PotionEffect(Potion.field_76444_x.id, 2400,99));
+ if (!par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ if (!EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, getEnergyUsed()))
+ {
+ }
+ }
+ } else
+ {
+ par1ItemStack.setItemDamage(par1ItemStack.getMaxDamage());
+ }
+
+ return par1ItemStack;
+ }
+
+ @Override
+ public void onUpdate(ItemStack par1ItemStack, World par2World, Entity par3Entity, int par4, boolean par5)
+ {
+ if (!(par3Entity instanceof EntityPlayer))
+ {
+ return;
+ }
+
+ EntityPlayer par3EntityPlayer = (EntityPlayer) par3Entity;
+
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ if (par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ par3EntityPlayer.fallDistance = 0;
+ par3EntityPlayer.addPotionEffect(new PotionEffect(Potion.waterBreathing.id, 2, 0, true));
+ par3EntityPlayer.addPotionEffect(new PotionEffect(Potion.fireResistance.id, 2, 0, true));
+ }
+
+ if (par2World.getWorldTime() % 200 == par1ItemStack.stackTagCompound.getInteger("worldTimeDelay") && par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ //par3EntityPlayer.addPotionEffect(new PotionEffect(Potion.field_76444_x.id, 2400,99));
+ if (!par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ if (!EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, getEnergyUsed()))
+ {
+ }
+ }
+ }
+
+ return;
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/SigilOfGrowth.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/SigilOfGrowth.java
new file mode 100644
index 00000000..54c64001
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/SigilOfGrowth.java
@@ -0,0 +1,305 @@
+package WayofTime.alchemicalWizardry.common.items.sigil;
+
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.IGrowable;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+import net.minecraftforge.common.IPlantable;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.event.entity.player.BonemealEvent;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.items.interfaces.ArmourUpgrade;
+import WayofTime.alchemicalWizardry.common.alchemy.ICombinationalCatalyst;
+import WayofTime.alchemicalWizardry.common.items.EnergyItems;
+import cpw.mods.fml.common.eventhandler.Event.Result;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class SigilOfGrowth extends EnergyItems implements ArmourUpgrade
+{
+ private static IIcon activeIcon;
+ private static IIcon passiveIcon;
+ private int tickDelay = 100;
+
+ public SigilOfGrowth()
+ {
+ super();
+ this.maxStackSize = 1;
+ //setMaxDamage(1000);
+ setEnergyUsed(150);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ // TODO Auto-generated constructor stub
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Who needs a green thumb when");
+ par3List.add("you have a green slate?");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ if (par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ par3List.add("Activated");
+ } else
+ {
+ par3List.add("Deactivated");
+ }
+
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:GrowthSigil_deactivated");
+ this.activeIcon = iconRegister.registerIcon("AlchemicalWizardry:GrowthSigil_activated");
+ this.passiveIcon = iconRegister.registerIcon("AlchemicalWizardry:GrowthSigil_deactivated");
+ }
+
+ @Override
+ public IIcon getIcon(ItemStack stack, int renderPass, EntityPlayer player, ItemStack usingItem, int useRemaining)
+ {
+ if (stack.stackTagCompound == null)
+ {
+ stack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = stack.stackTagCompound;
+
+ if (tag.getBoolean("isActive"))
+ {
+ return this.activeIcon;
+ } else
+ {
+ return this.passiveIcon;
+ }
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public IIcon getIconFromDamage(int par1)
+ {
+ if (par1 == 1)
+ {
+ return this.activeIcon;
+ } else
+ {
+ return this.passiveIcon;
+ }
+ }
+
+ @Override
+ public boolean onItemUse(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, World par3World, int par4, int par5, int par6, int par7, float par8, float par9, float par10)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par2EntityPlayer);
+
+ if (applyBonemeal(par1ItemStack, par3World, par4, par5, par6, par2EntityPlayer))
+ {
+ EnergyItems.syphonBatteries(par1ItemStack, par2EntityPlayer, getEnergyUsed());
+
+ if (par3World.isRemote)
+ {
+ par3World.playAuxSFX(2005, par4, par5, par6, 0);
+ return true;
+ }
+
+ return true;
+ }
+
+ return false;
+ }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par3EntityPlayer);
+
+ if(par2World.isRemote)
+ {
+ return par1ItemStack;
+ }
+
+ if (par3EntityPlayer.isSneaking())
+ {
+ return par1ItemStack;
+ }
+
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = par1ItemStack.stackTagCompound;
+ tag.setBoolean("isActive", !(tag.getBoolean("isActive")));
+
+ if (tag.getBoolean("isActive"))
+ {
+ par1ItemStack.setItemDamage(1);
+ tag.setInteger("worldTimeDelay", (int) (par2World.getWorldTime() - 1) % tickDelay);
+
+ if (!par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, getEnergyUsed());
+ }
+ } else
+ {
+ par1ItemStack.setItemDamage(par1ItemStack.getMaxDamage());
+ }
+
+ return par1ItemStack;
+ }
+
+ @Override
+ public void onUpdate(ItemStack par1ItemStack, World par2World, Entity par3Entity, int par4, boolean par5)
+ {
+ if (!(par3Entity instanceof EntityPlayer))
+ {
+ return;
+ }
+
+ EntityPlayer par3EntityPlayer = (EntityPlayer) par3Entity;
+
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ if (par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ if (par2World.getWorldTime() % tickDelay == par1ItemStack.stackTagCompound.getInteger("worldTimeDelay") && par3Entity instanceof EntityPlayer)
+ {
+ EnergyItems.syphonBatteries(par1ItemStack, (EntityPlayer) par3Entity, getEnergyUsed());
+ }
+
+ int range = 5;
+ int verticalRange = 2;
+ int posX = (int) Math.round(par3Entity.posX - 0.5f);
+ int posY = (int) par3Entity.posY;
+ int posZ = (int) Math.round(par3Entity.posZ - 0.5f);
+
+ for (int ix = posX - range; ix <= posX + range; ix++)
+ {
+ for (int iz = posZ - range; iz <= posZ + range; iz++)
+ {
+ for (int iy = posY - verticalRange; iy <= posY + verticalRange; iy++)
+ {
+ Block block = par2World.getBlock(ix, iy, iz);
+
+
+ if (block instanceof IPlantable)
+ {
+ if (par2World.rand.nextInt(20) == 0)
+ {
+ block.updateTick(par2World, ix, iy, iz, par2World.rand);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return;
+ }
+
+ public static boolean applyBonemeal(ItemStack p_150919_0_, World p_150919_1_, int p_150919_2_, int p_150919_3_, int p_150919_4_, EntityPlayer player)
+ {
+ Block block = p_150919_1_.getBlock(p_150919_2_, p_150919_3_, p_150919_4_);
+
+ BonemealEvent event = new BonemealEvent(player, p_150919_1_, block, p_150919_2_, p_150919_3_, p_150919_4_);
+ if (MinecraftForge.EVENT_BUS.post(event))
+ {
+ return false;
+ }
+
+ if (event.getResult() == Result.ALLOW)
+ {
+ if (!p_150919_1_.isRemote)
+ {
+
+ }
+ return true;
+ }
+
+ if (block instanceof IGrowable)
+ {
+ IGrowable igrowable = (IGrowable)block;
+
+ if (igrowable.func_149851_a(p_150919_1_, p_150919_2_, p_150919_3_, p_150919_4_, p_150919_1_.isRemote))
+ {
+ if (!p_150919_1_.isRemote)
+ {
+ if (igrowable.func_149852_a(p_150919_1_, p_150919_1_.rand, p_150919_2_, p_150919_3_, p_150919_4_))
+ {
+ igrowable.func_149853_b(p_150919_1_, p_150919_1_.rand, p_150919_2_, p_150919_3_, p_150919_4_);
+ }
+
+
+ }
+
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ @Override
+ public void onArmourUpdate(World world, EntityPlayer player, ItemStack thisItemStack)
+ {
+ if(world.isRemote)
+ {
+ return;
+ }
+
+ int range = 5;
+ int verticalRange = 2;
+ int posX = (int) Math.round(player.posX - 0.5f);
+ int posY = (int) player.posY;
+ int posZ = (int) Math.round(player.posZ - 0.5f);
+
+ for (int ix = posX - range; ix <= posX + range; ix++)
+ {
+ for (int iz = posZ - range; iz <= posZ + range; iz++)
+ {
+ for (int iy = posY - verticalRange; iy <= posY + verticalRange; iy++)
+ {
+ Block block = world.getBlock(ix, iy, iz);
+
+
+ if (block instanceof IPlantable)
+ {
+ if (world.rand.nextInt(10) == 0)
+ {
+ block.updateTick(world, ix, iy, iz, world.rand);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ @Override
+ public boolean isUpgrade()
+ {
+ // TODO Auto-generated method stub
+ return true;
+ }
+
+ @Override
+ public int getEnergyForTenSeconds()
+ {
+ // TODO Auto-generated method stub
+ return 50;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/SigilOfHaste.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/SigilOfHaste.java
new file mode 100644
index 00000000..2aecbf25
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/SigilOfHaste.java
@@ -0,0 +1,198 @@
+package WayofTime.alchemicalWizardry.common.items.sigil;
+
+import java.util.List;
+
+import javax.swing.Icon;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.items.interfaces.ArmourUpgrade;
+import WayofTime.alchemicalWizardry.common.items.EnergyItems;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class SigilOfHaste extends EnergyItems implements ArmourUpgrade
+{
+ @SideOnly(Side.CLIENT)
+ private static IIcon activeIcon;
+ @SideOnly(Side.CLIENT)
+ private static IIcon passiveIcon;
+
+ public SigilOfHaste()
+ {
+ super();
+ this.maxStackSize = 1;
+ //setMaxDamage(100);
+ setEnergyUsed(250);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("One dose of caffeine later...");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ if (par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ par3List.add("Activated");
+ } else
+ {
+ par3List.add("Deactivated");
+ }
+
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:HasteSigil_deactivated");
+ this.activeIcon = iconRegister.registerIcon("AlchemicalWizardry:HasteSigil_activated");
+ this.passiveIcon = iconRegister.registerIcon("AlchemicalWizardry:HasteSigil_deactivated");
+ }
+
+ @Override
+ public IIcon getIcon(ItemStack stack, int renderPass, EntityPlayer player, ItemStack usingItem, int useRemaining)
+ {
+ if (stack.stackTagCompound == null)
+ {
+ stack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = stack.stackTagCompound;
+
+ if (tag.getBoolean("isActive"))
+ {
+ return this.activeIcon;
+ } else
+ {
+ return this.passiveIcon;
+ }
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public IIcon getIconFromDamage(int par1)
+ {
+ if (par1 == 1)
+ {
+ return this.activeIcon;
+ } else
+ {
+ return this.passiveIcon;
+ }
+ }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par3EntityPlayer);
+
+ if (par3EntityPlayer.isSneaking())
+ {
+ return par1ItemStack;
+ }
+
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = par1ItemStack.stackTagCompound;
+ tag.setBoolean("isActive", !(tag.getBoolean("isActive")));
+
+ if (tag.getBoolean("isActive"))
+ {
+ par1ItemStack.setItemDamage(1);
+ tag.setInteger("worldTimeDelay", (int) (par2World.getWorldTime() - 1) % 200);
+ par3EntityPlayer.addPotionEffect(new PotionEffect(AlchemicalWizardry.customPotionBoost.id, 3, 1));
+ //par3EntityPlayer.addPotionEffect(new PotionEffect(AlchemicalWizardry.customPotionProjProt.id, 2, 2));
+
+ //Test with added health boost
+ //par3EntityPlayer.addPotionEffect(new PotionEffect(Potion.field_76444_x.id, 2400,99));
+ if (!par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ if (!EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, getEnergyUsed()))
+ {
+ }
+ }
+ } else
+ {
+ par1ItemStack.setItemDamage(par1ItemStack.getMaxDamage());
+ }
+
+ return par1ItemStack;
+ }
+
+ @Override
+ public void onUpdate(ItemStack par1ItemStack, World par2World, Entity par3Entity, int par4, boolean par5)
+ {
+ if (!(par3Entity instanceof EntityPlayer))
+ {
+ return;
+ }
+
+ EntityPlayer par3EntityPlayer = (EntityPlayer) par3Entity;
+
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ if (par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ par3EntityPlayer.addPotionEffect(new PotionEffect(AlchemicalWizardry.customPotionBoost.id, 3, 1));
+ }
+
+ if (par2World.getWorldTime() % 200 == par1ItemStack.stackTagCompound.getInteger("worldTimeDelay") && par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ //par3EntityPlayer.addPotionEffect(new PotionEffect(AlchemicalWizardry.customPotionBoost.id, 205, 1));
+
+ //par3EntityPlayer.addPotionEffect(new PotionEffect(AlchemicalWizardry.customPotionProjProt.id, 205, 2));
+ if (!par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ if (!EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, getEnergyUsed()))
+ {
+ }
+ }
+ }
+
+ return;
+ }
+
+ @Override
+ public void onArmourUpdate(World world, EntityPlayer player, ItemStack itemStack)
+ {
+ if (itemStack.stackTagCompound == null)
+ {
+ itemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ player.addPotionEffect(new PotionEffect(AlchemicalWizardry.customPotionBoost.id, 3, 1,true));
+ }
+
+ @Override
+ public boolean isUpgrade()
+ {
+ // TODO Auto-generated method stub
+ return true;
+ }
+
+ @Override
+ public int getEnergyForTenSeconds()
+ {
+ // TODO Auto-generated method stub
+ return 150;
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/SigilOfHolding.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/SigilOfHolding.java
new file mode 100644
index 00000000..03b1f730
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/SigilOfHolding.java
@@ -0,0 +1,371 @@
+package WayofTime.alchemicalWizardry.common.items.sigil;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.Constants;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.ModItems;
+import WayofTime.alchemicalWizardry.api.items.interfaces.IHolding;
+import WayofTime.alchemicalWizardry.common.items.EnergyItems;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class SigilOfHolding extends EnergyItems
+{
+ private int invSize = 4;
+
+ public static List allowedSigils = new ArrayList();
+
+ public SigilOfHolding()
+ {
+ super();
+ this.maxStackSize = 1;
+ //setEnergyUsed(100);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:SigilOfHolding");
+ }
+
+ @Override
+ public IIcon getIcon(ItemStack stack, int renderPass, EntityPlayer player, ItemStack usingItem, int useRemaining)
+ {
+ if (!(stack.stackTagCompound == null))
+ {
+ ItemStack[] inv = getInternalInventory(stack);
+
+ if (inv == null)
+ {
+ return this.itemIcon;
+ }
+
+ ItemStack item = inv[stack.stackTagCompound.getInteger("selectedSlot")];
+
+ if (item != null)
+ {
+ return item.getIconIndex();
+ }
+ }
+
+ return this.itemIcon;
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Used to hold several Sigils!");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+// par3List.add("Current slot: " + par1ItemStack.stackTagCompound.getInteger("selectedSlot"));
+ ItemStack[] inv = getInternalInventory(par1ItemStack);
+
+ if (inv == null)
+ {
+ return;
+ }
+
+ ItemStack item = inv[par1ItemStack.stackTagCompound.getInteger("selectedSlot")];
+
+ if (item != null)
+ {
+ par3List.add("Current item: " + item.getDisplayName());
+ }
+
+ for (int i = 0; i < invSize; i++)
+ {
+ if (inv[i] != null)
+ {
+ par3List.add("Item in slot " + i + ": " + inv[i].getDisplayName());
+ }
+ }
+ }
+ }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ //TODO Might be a good idea to have this item need to be in the player's first slot
+ //for it to search and consume sigils on right click. Might avoid confusion? At least
+ //will avoid the need to add a button just for it...
+ this.checkAndSetItemOwner(par1ItemStack, par3EntityPlayer);
+
+ if (par3EntityPlayer.isSneaking())
+ {
+ if (this.addSigilToInventory(par1ItemStack, par3EntityPlayer))
+ {
+ return par1ItemStack;
+ }
+
+ selectNextSlot(par1ItemStack);
+ return par1ItemStack;
+ }
+
+ int currentSlot = this.getSelectedSlot(par1ItemStack);
+ ItemStack[] inv = getInternalInventory(par1ItemStack);
+
+ if (inv == null)
+ {
+ return par1ItemStack;
+ }
+
+ ItemStack itemUsed = inv[currentSlot];
+
+ if (itemUsed == null)
+ {
+ return par1ItemStack;
+ }
+
+ itemUsed.getItem().onItemRightClick(itemUsed, par2World, par3EntityPlayer);
+ saveInternalInventory(par1ItemStack, inv);
+ return par1ItemStack;
+ }
+
+ @Override
+ public void onUpdate(ItemStack par1ItemStack, World par2World, Entity par3Entity, int par4, boolean par5)
+ {
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ this.tickInternalInventory(par1ItemStack, par2World, par3Entity, par4, par5);
+ }
+ }
+
+ public ItemStack[] getInternalInventory(ItemStack itemStack)
+ {
+ NBTTagCompound itemTag = itemStack.stackTagCompound;
+
+ if (itemTag == null)
+ {
+ itemStack.setTagCompound(new NBTTagCompound());
+ return null;
+ }
+
+ ItemStack[] inv = new ItemStack[9];
+ NBTTagList tagList = itemTag.getTagList("Inventory", Constants.NBT.TAG_COMPOUND);
+
+ if (tagList == null)
+ {
+ return null;
+ }
+
+ for (int i = 0; i < tagList.tagCount(); i++)
+ {
+ NBTTagCompound tag = (NBTTagCompound) tagList.getCompoundTagAt(i);
+ int slot = tag.getByte("Slot");
+
+ if (slot >= 0 && slot < invSize)
+ {
+ inv[slot] = ItemStack.loadItemStackFromNBT(tag);
+ }
+ }
+
+ return inv;
+ }
+
+ public void saveInternalInventory(ItemStack itemStack, ItemStack[] inventory)
+ {
+ NBTTagCompound itemTag = itemStack.stackTagCompound;
+
+ if (itemTag == null)
+ {
+ itemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagList itemList = new NBTTagList();
+
+ for (int i = 0; i < invSize; i++)
+ {
+ ItemStack stack = inventory[i];
+
+ if (inventory[i] != null)
+ {
+ NBTTagCompound tag = new NBTTagCompound();
+ tag.setByte("Slot", (byte) i);
+ inventory[i].writeToNBT(tag);
+ itemList.appendTag(tag);
+ }
+ }
+
+ itemTag.setTag("Inventory", itemList);
+ }
+
+ public void tickInternalInventory(ItemStack par1ItemStack, World par2World, Entity par3Entity, int par4, boolean par5)
+ {
+ ItemStack[] inv = getInternalInventory(par1ItemStack);
+
+ if (inv == null)
+ {
+ return;
+ }
+
+ for (int i = 0; i < invSize; i++)
+ {
+ if (inv[i] == null)
+ {
+ continue;
+ }
+
+ inv[i].getItem().onUpdate(inv[i], par2World, par3Entity, par4, par5);
+ }
+ }
+
+ public int getSelectedSlot(ItemStack itemStack)
+ {
+ NBTTagCompound itemTag = itemStack.stackTagCompound;
+
+ if (itemTag == null)
+ {
+ itemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ return itemTag.getInteger("selectedSlot");
+ }
+
+ public void selectNextSlot(ItemStack itemStack)
+ {
+ ItemStack[] inv = getInternalInventory(itemStack);
+ int filledSlots = 0;
+
+ for (int i = 0; i < invSize; i++)
+ {
+ if (inv[i] != null)
+ {
+ filledSlots++;
+ } else
+ {
+ break;
+ }
+ }
+
+ NBTTagCompound itemTag = itemStack.stackTagCompound;
+
+ if (itemTag == null)
+ {
+ itemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ if (getSelectedSlot(itemStack) + 1 < filledSlots)
+ {
+ itemTag.setInteger("selectedSlot", itemTag.getInteger("selectedSlot") + 1);
+ } else
+ {
+ itemTag.setInteger("selectedSlot", 0);
+ }
+ }
+
+ public boolean hasAddedToInventory(ItemStack sigilItemStack, ItemStack addedItemStack)
+ {
+ ItemStack[] inv = getInternalInventory(sigilItemStack);
+
+ if (inv == null)
+ {
+ return false;
+ }
+
+ if (addedItemStack == null)
+ {
+ return false;
+ }
+
+ Item item = addedItemStack.getItem();
+ int candidateSlot = -1;
+
+ for (int i = invSize - 1; i >= 0; i--)
+ {
+ ItemStack nextItem = inv[i];
+
+ if (nextItem == null)
+ {
+ candidateSlot = i;
+ continue;
+ }
+
+ if (item == nextItem.getItem())
+ {
+ return false;
+ }
+ }
+
+ if (candidateSlot == -1)
+ {
+ return false;
+ }
+
+ if(addedItemStack.getItem() instanceof IHolding)
+ {
+ inv[candidateSlot] = addedItemStack;
+ saveInternalInventory(sigilItemStack, inv);
+ return true;
+ }
+
+ for (ItemStack i : allowedSigils)
+ {
+ if (i != null && i.getItem() == item)
+ {
+ inv[candidateSlot] = addedItemStack;
+ saveInternalInventory(sigilItemStack, inv);
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ public boolean addSigilToInventory(ItemStack sigilItemStack, EntityPlayer player)
+ {
+ ItemStack[] playerInventory = player.inventory.mainInventory;
+
+ for (int i = 0; i < 36; i++)
+ {
+ if (this.hasAddedToInventory(sigilItemStack, playerInventory[i]))
+ {
+ player.inventory.consumeInventoryItem(playerInventory[i].getItem());
+ //playerInventory[i].stackSize--;
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ public static void initiateSigilOfHolding()
+ {
+ allowedSigils.add(new ItemStack(ModItems.waterSigil));
+ allowedSigils.add(new ItemStack(ModItems.lavaSigil));
+ allowedSigils.add(new ItemStack(ModItems.voidSigil));
+ allowedSigils.add(new ItemStack(ModItems.airSigil));
+ allowedSigils.add(new ItemStack(ModItems.sigilOfTheFastMiner));
+ allowedSigils.add(new ItemStack(ModItems.divinationSigil));
+ allowedSigils.add(new ItemStack(ModItems.sigilOfElementalAffinity));
+ allowedSigils.add(new ItemStack(ModItems.growthSigil));
+ allowedSigils.add(new ItemStack(ModItems.sigilOfHaste));
+ allowedSigils.add(new ItemStack(ModItems.sigilOfWind));
+ }
+
+ public ItemStack getCurrentItem(ItemStack sigilItemStack)
+ {
+ ItemStack[] items = this.getInternalInventory(sigilItemStack);
+
+ if (items == null)
+ {
+ return null;
+ }
+
+ return items[this.getSelectedSlot(sigilItemStack)];
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/SigilOfMagnetism.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/SigilOfMagnetism.java
new file mode 100644
index 00000000..5693d17f
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/SigilOfMagnetism.java
@@ -0,0 +1,222 @@
+package WayofTime.alchemicalWizardry.common.items.sigil;
+
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.items.interfaces.ArmourUpgrade;
+import WayofTime.alchemicalWizardry.common.items.EnergyItems;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class SigilOfMagnetism extends EnergyItems implements ArmourUpgrade
+{
+ private static IIcon activeIcon;
+ private static IIcon passiveIcon;
+ private int tickDelay = 300;
+
+ public SigilOfMagnetism()
+ {
+ super();
+ this.maxStackSize = 1;
+ //setMaxDamage(1000);
+ setEnergyUsed(50);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ // TODO Auto-generated constructor stub
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("I have a very magnetic personality!");
+// par3List.add("you have a green slate?");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ if (par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ par3List.add("Activated");
+ } else
+ {
+ par3List.add("Deactivated");
+ }
+
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:SigilOfMagnetism_deactivated");
+ this.activeIcon = iconRegister.registerIcon("AlchemicalWizardry:SigilOfMagnetism_activated");
+ this.passiveIcon = iconRegister.registerIcon("AlchemicalWizardry:SigilOfMagnetism_deactivated");
+ }
+
+ @Override
+ public IIcon getIcon(ItemStack stack, int renderPass, EntityPlayer player, ItemStack usingItem, int useRemaining)
+ {
+ if (stack.stackTagCompound == null)
+ {
+ stack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = stack.stackTagCompound;
+
+ if (tag.getBoolean("isActive"))
+ {
+ return this.activeIcon;
+ } else
+ {
+ return this.passiveIcon;
+ }
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public IIcon getIconFromDamage(int par1)
+ {
+ if (par1 == 1)
+ {
+ return this.activeIcon;
+ } else
+ {
+ return this.passiveIcon;
+ }
+ }
+
+// @Override
+// public boolean onItemUse(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, World par3World, int par4, int par5, int par6, int par7, float par8, float par9, float par10)
+// {
+// EnergyItems.checkAndSetItemOwner(par1ItemStack, par2EntityPlayer);
+// if(applyBonemeal(par1ItemStack,par3World,par4,par5,par6,par2EntityPlayer))
+// {
+// if (par3World.isRemote)
+// {
+// par3World.playAuxSFX(2005, par4, par5, par6, 0);
+// EnergyItems.syphonBatteries(par1ItemStack, par2EntityPlayer, getEnergyUsed());
+// return true;
+// }
+// return true;
+// }
+// return false;
+// }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par3EntityPlayer);
+
+ if (par3EntityPlayer.isSneaking())
+ {
+ return par1ItemStack;
+ }
+
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = par1ItemStack.stackTagCompound;
+ tag.setBoolean("isActive", !(tag.getBoolean("isActive")));
+
+ if (tag.getBoolean("isActive"))
+ {
+ par1ItemStack.setItemDamage(1);
+ tag.setInteger("worldTimeDelay", (int) (par2World.getWorldTime() - 1) % tickDelay);
+
+ if (!par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, getEnergyUsed());
+ }
+ } else
+ {
+ par1ItemStack.setItemDamage(par1ItemStack.getMaxDamage());
+ }
+
+ return par1ItemStack;
+ }
+
+ @Override
+ public void onUpdate(ItemStack par1ItemStack, World par2World, Entity par3Entity, int par4, boolean par5)
+ {
+ if (!(par3Entity instanceof EntityPlayer))
+ {
+ return;
+ }
+
+ EntityPlayer par3EntityPlayer = (EntityPlayer) par3Entity;
+
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ if (par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ if (par2World.getWorldTime() % tickDelay == par1ItemStack.stackTagCompound.getInteger("worldTimeDelay") && par3Entity instanceof EntityPlayer)
+ {
+ EnergyItems.syphonBatteries(par1ItemStack, (EntityPlayer) par3Entity, getEnergyUsed());
+ }
+
+ int range = 5;
+ int verticalRange = 5;
+ float posX = Math.round(par3Entity.posX);
+ float posY = (float) (par3Entity.posY - par3Entity.getEyeHeight());
+ float posZ = Math.round(par3Entity.posZ);
+ List entities = par3EntityPlayer.worldObj.getEntitiesWithinAABB(EntityItem.class, AxisAlignedBB.getBoundingBox(posX - 0.5f, posY - 0.5f, posZ - 0.5f, posX + 0.5f, posY + 0.5f, posZ + 0.5f).expand(range, verticalRange, range));
+
+ for (EntityItem entity : entities)
+ {
+ if (entity != null && !par2World.isRemote)
+ {
+ entity.onCollideWithPlayer(par3EntityPlayer);
+ }
+ }
+ }
+
+ return;
+ }
+
+ @Override
+ public void onArmourUpdate(World world, EntityPlayer player, ItemStack thisItemStack)
+ {
+ int range = 5;
+ int verticalRange = 5;
+ float posX = Math.round(player.posX);
+ float posY = (float) (player.posY - player.getEyeHeight());
+ float posZ = Math.round(player.posZ);
+ List entities = player.worldObj.getEntitiesWithinAABB(EntityItem.class, AxisAlignedBB.getBoundingBox(posX - 0.5f, posY - 0.5f, posZ - 0.5f, posX + 0.5f, posY + 0.5f, posZ + 0.5f).expand(range, verticalRange, range));
+
+ for (EntityItem entity : entities)
+ {
+ if (entity != null && !world.isRemote)
+ {
+ entity.onCollideWithPlayer(player);
+ }
+ }
+ }
+
+ @Override
+ public boolean isUpgrade()
+ {
+ // TODO Auto-generated method stub
+ return true;
+ }
+
+ @Override
+ public int getEnergyForTenSeconds()
+ {
+ // TODO Auto-generated method stub
+ return 25;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/SigilOfTheBridge.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/SigilOfTheBridge.java
new file mode 100644
index 00000000..424b4904
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/SigilOfTheBridge.java
@@ -0,0 +1,336 @@
+package WayofTime.alchemicalWizardry.common.items.sigil;
+
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.ModBlocks;
+import WayofTime.alchemicalWizardry.api.items.interfaces.ArmourUpgrade;
+import WayofTime.alchemicalWizardry.common.items.EnergyItems;
+import WayofTime.alchemicalWizardry.common.tileEntity.TESpectralBlock;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class SigilOfTheBridge extends EnergyItems implements ArmourUpgrade
+{
+ private static IIcon activeIcon;
+ private static IIcon passiveIcon;
+ private int tickDelay = 200;
+
+ public SigilOfTheBridge()
+ {
+ super();
+ this.maxStackSize = 1;
+ //setMaxDamage(1000);
+ setEnergyUsed(100);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ // TODO Auto-generated constructor stub
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Activate to create a bridge");
+ par3List.add("beneath your feet.");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ if (par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ par3List.add("Activated");
+ } else
+ {
+ par3List.add("Deactivated");
+ }
+
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:BridgeSigil_deactivated");
+ this.activeIcon = iconRegister.registerIcon("AlchemicalWizardry:BridgeSigil_activated");
+ this.passiveIcon = iconRegister.registerIcon("AlchemicalWizardry:BridgeSigil_deactivated");
+ }
+
+ @Override
+ public IIcon getIcon(ItemStack stack, int renderPass, EntityPlayer player, ItemStack usingItem, int useRemaining)
+ {
+ if (stack.stackTagCompound == null)
+ {
+ stack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = stack.stackTagCompound;
+
+ if (tag.getBoolean("isActive"))
+ {
+ return this.activeIcon;
+ } else
+ {
+ return this.passiveIcon;
+ }
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public IIcon getIconFromDamage(int par1)
+ {
+ if (par1 == 1)
+ {
+ return this.activeIcon;
+ } else
+ {
+ return this.passiveIcon;
+ }
+ }
+
+// @Override
+// public boolean onItemUse(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, World par3World, int par4, int par5, int par6, int par7, float par8, float par9, float par10)
+// {
+//
+// if(applyBonemeal(par1ItemStack,par3World,par4,par5,par6,par2EntityPlayer))
+// {
+// if (par3World.isRemote)
+// {
+// par3World.playAuxSFX(2005, par4, par5, par6, 0);
+// EnergyItems.syphonBatteries(par1ItemStack, par2EntityPlayer, getEnergyUsed());
+// return true;
+// }
+// return true;
+// }
+// return false;
+// }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par3EntityPlayer);
+
+ if (par3EntityPlayer.isSneaking())
+ {
+ return par1ItemStack;
+ }
+
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = par1ItemStack.stackTagCompound;
+ tag.setBoolean("isActive", !(tag.getBoolean("isActive")));
+
+ if (tag.getBoolean("isActive"))
+ {
+ par1ItemStack.setItemDamage(1);
+ tag.setInteger("worldTimeDelay", (int) (par2World.getWorldTime() - 1) % tickDelay);
+
+ if (!par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, getEnergyUsed());
+ }
+ } else
+ {
+ par1ItemStack.setItemDamage(par1ItemStack.getMaxDamage());
+ }
+
+ return par1ItemStack;
+ }
+
+ @Override
+ public void onUpdate(ItemStack par1ItemStack, World par2World, Entity par3Entity, int par4, boolean par5)
+ {
+ if (!(par3Entity instanceof EntityPlayer))
+ {
+ return;
+ }
+
+ EntityPlayer par3EntityPlayer = (EntityPlayer) par3Entity;
+
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ if (par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ if (par2World.getWorldTime() % tickDelay == par1ItemStack.stackTagCompound.getInteger("worldTimeDelay") && par3Entity instanceof EntityPlayer)
+ {
+ EnergyItems.syphonBatteries(par1ItemStack, (EntityPlayer) par3Entity, this.getLPUsed(par1ItemStack));
+ this.setLPUsed(par1ItemStack, 0);
+ }
+
+// if(par2World.isRemote)
+// {
+// return;
+// }
+ if (!par3EntityPlayer.onGround && !par3EntityPlayer.isSneaking())
+ {
+ return;
+ }
+
+ int range = 2;
+ int verticalOffset = -1;
+
+ if (par3EntityPlayer.isSneaking())
+ {
+ verticalOffset--;
+ }
+
+ if (par2World.isRemote)
+ {
+ verticalOffset--;
+ }
+
+ int posX = (int) Math.round(par3Entity.posX - 0.5f);
+ int posY = (int) par3Entity.posY;
+ int posZ = (int) Math.round(par3Entity.posZ - 0.5f);
+ int incremented = 0;
+
+ for (int ix = posX - range; ix <= posX + range; ix++)
+ {
+ for (int iz = posZ - range; iz <= posZ + range; iz++)
+ {
+ //for(int iy=posY-verticalRange;iy<=posY+verticalRange;iy++)
+ {
+ Block block = par2World.getBlock(ix, posY + verticalOffset, iz);
+
+ if (par2World.isAirBlock(ix, posY + verticalOffset, iz))
+ {
+ par2World.setBlock(ix, posY + verticalOffset, iz, ModBlocks.spectralBlock, 0, 3);
+
+ TileEntity tile = par2World.getTileEntity(ix, posY + verticalOffset, iz);
+ if(tile instanceof TESpectralBlock)
+ {
+ ((TESpectralBlock) tile).setDuration(100);
+ }
+
+ if (par2World.rand.nextInt(2) == 0)
+ {
+ incremented++;
+ }
+ }else if(block == ModBlocks.spectralBlock)
+ {
+ TileEntity tile = par2World.getTileEntity(ix, posY + verticalOffset, iz);
+ if(tile instanceof TESpectralBlock)
+ {
+ ((TESpectralBlock) tile).setDuration(100);
+ }
+ }
+ }
+ }
+ }
+
+ this.incrimentLPUSed(par1ItemStack, incremented);
+ }
+
+ return;
+ }
+
+ public int getLPUsed(ItemStack par1ItemStack)
+ {
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ return par1ItemStack.stackTagCompound.getInteger("LPUsed");
+ }
+
+ public void incrimentLPUSed(ItemStack par1ItemStack, int addedLP)
+ {
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ par1ItemStack.stackTagCompound.setInteger("LPUsed", par1ItemStack.stackTagCompound.getInteger("LPUsed") + addedLP);
+ }
+
+ public void setLPUsed(ItemStack par1ItemStack, int newLP)
+ {
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ par1ItemStack.stackTagCompound.setInteger("LPUsed", newLP);
+ }
+
+ @Override
+ public void onArmourUpdate(World world, EntityPlayer player, ItemStack thisItemStack)
+ {
+ if (!player.onGround && !player.isSneaking())
+ {
+ return;
+ }
+
+ int range = 2;
+ int verticalOffset = -1;
+
+ if (player.isSneaking())
+ {
+ verticalOffset--;
+ }
+
+ int posX = (int) Math.round(player.posX - 0.5f);
+ int posY = (int) player.posY;
+ int posZ = (int) Math.round(player.posZ - 0.5f);
+
+ //int incremented = 0;
+
+ for (int ix = posX - range; ix <= posX + range; ix++)
+ {
+ for (int iz = posZ - range; iz <= posZ + range; iz++)
+ {
+ //for(int iy=posY-verticalRange;iy<=posY+verticalRange;iy++)
+ {
+ Block block = world.getBlock(ix, posY + verticalOffset, iz);
+
+ if (world.isAirBlock(ix, posY + verticalOffset, iz))
+ {
+ world.setBlock(ix, posY + verticalOffset, iz, ModBlocks.spectralBlock, 0, 3);
+
+ TileEntity tile = world.getTileEntity(ix, posY + verticalOffset, iz);
+ if(tile instanceof TESpectralBlock)
+ {
+ ((TESpectralBlock) tile).setDuration(100);
+ }
+ }else if(block == ModBlocks.spectralBlock)
+ {
+ TileEntity tile = world.getTileEntity(ix, posY + verticalOffset, iz);
+ if(tile instanceof TESpectralBlock)
+ {
+ ((TESpectralBlock) tile).setDuration(100);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ @Override
+ public boolean isUpgrade()
+ {
+ // TODO Auto-generated method stub
+ return true;
+ }
+
+ @Override
+ public int getEnergyForTenSeconds()
+ {
+ // TODO Auto-generated method stub
+ return 100;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/SigilOfTheFastMiner.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/SigilOfTheFastMiner.java
new file mode 100644
index 00000000..4f439bfe
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/SigilOfTheFastMiner.java
@@ -0,0 +1,194 @@
+package WayofTime.alchemicalWizardry.common.items.sigil;
+
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.potion.Potion;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.items.interfaces.ArmourUpgrade;
+import WayofTime.alchemicalWizardry.common.items.EnergyItems;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class SigilOfTheFastMiner extends EnergyItems implements ArmourUpgrade
+{
+ @SideOnly(Side.CLIENT)
+ private static IIcon activeIcon;
+ @SideOnly(Side.CLIENT)
+ private static IIcon passiveIcon;
+
+ public SigilOfTheFastMiner()
+ {
+ super();
+ this.maxStackSize = 1;
+ //setMaxDamage(100);
+ setEnergyUsed(100);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Keep going and going and going...");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ if (par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ par3List.add("Activated");
+ } else
+ {
+ par3List.add("Deactivated");
+ }
+
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:SigilOfTheFastMiner");
+ this.activeIcon = iconRegister.registerIcon("AlchemicalWizardry:MiningSigil_activated");
+ this.passiveIcon = iconRegister.registerIcon("AlchemicalWizardry:MiningSigil_deactivated");
+ }
+
+ @Override
+ public IIcon getIcon(ItemStack stack, int renderPass, EntityPlayer player, ItemStack usingItem, int useRemaining)
+ {
+ if (stack.stackTagCompound == null)
+ {
+ stack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = stack.stackTagCompound;
+
+ if (tag.getBoolean("isActive"))
+ {
+ return this.activeIcon;
+ } else
+ {
+ return this.passiveIcon;
+ }
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public IIcon getIconFromDamage(int par1)
+ {
+ if (par1 == 1)
+ {
+ return this.activeIcon;
+ } else
+ {
+ return this.passiveIcon;
+ }
+ }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par3EntityPlayer);
+
+ if (par3EntityPlayer.isSneaking())
+ {
+ return par1ItemStack;
+ }
+
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = par1ItemStack.stackTagCompound;
+ tag.setBoolean("isActive", !(tag.getBoolean("isActive")));
+
+ if (tag.getBoolean("isActive"))
+ {
+ par1ItemStack.setItemDamage(1);
+ tag.setInteger("worldTimeDelay", (int) (par2World.getWorldTime() - 1) % 200);
+ par3EntityPlayer.addPotionEffect(new PotionEffect(Potion.digSpeed.id, 2, 1, true));
+
+ //Test with added health boost
+ //par3EntityPlayer.addPotionEffect(new PotionEffect(Potion.field_76444_x.id, 2400,99));
+ if (!par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ if (!EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, getEnergyUsed()))
+ {
+ }
+ }
+ } else
+ {
+ par1ItemStack.setItemDamage(par1ItemStack.getMaxDamage());
+ }
+
+ return par1ItemStack;
+ }
+
+ @Override
+ public void onUpdate(ItemStack par1ItemStack, World par2World, Entity par3Entity, int par4, boolean par5)
+ {
+ if (!(par3Entity instanceof EntityPlayer))
+ {
+ return;
+ }
+
+ EntityPlayer par3EntityPlayer = (EntityPlayer) par3Entity;
+
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ if (par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ par3EntityPlayer.addPotionEffect(new PotionEffect(Potion.digSpeed.id, 2, 1, true));
+ }
+
+ if (par2World.getWorldTime() % 200 == par1ItemStack.stackTagCompound.getInteger("worldTimeDelay") && par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ //par3EntityPlayer.addPotionEffect(new PotionEffect(Potion.field_76444_x.id, 2400,99));
+ if (!par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ if (!EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, getEnergyUsed()))
+ {
+ }
+ }
+ }
+
+ return;
+ }
+
+ @Override
+ public void onArmourUpdate(World world, EntityPlayer player, ItemStack itemStack)
+ {
+ if (itemStack.stackTagCompound == null)
+ {
+ itemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ player.addPotionEffect(new PotionEffect(Potion.digSpeed.id, 3, 1, true));
+ }
+
+ @Override
+ public boolean isUpgrade()
+ {
+ // TODO Auto-generated method stub
+ return true;
+ }
+
+ @Override
+ public int getEnergyForTenSeconds()
+ {
+ // TODO Auto-generated method stub
+ return 50;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/SigilOfWind.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/SigilOfWind.java
new file mode 100644
index 00000000..752797a7
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/SigilOfWind.java
@@ -0,0 +1,196 @@
+package WayofTime.alchemicalWizardry.common.items.sigil;
+
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.items.interfaces.ArmourUpgrade;
+import WayofTime.alchemicalWizardry.common.items.EnergyItems;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class SigilOfWind extends EnergyItems implements ArmourUpgrade
+{
+ @SideOnly(Side.CLIENT)
+ private static IIcon activeIcon;
+ @SideOnly(Side.CLIENT)
+ private static IIcon passiveIcon;
+
+ public SigilOfWind()
+ {
+ super();
+ this.maxStackSize = 1;
+ //setMaxDamage(100);
+ setEnergyUsed(250);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Best not to wear a skirt.");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ if (par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ par3List.add("Activated");
+ } else
+ {
+ par3List.add("Deactivated");
+ }
+
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:WindSigil_deactivated");
+ this.activeIcon = iconRegister.registerIcon("AlchemicalWizardry:WindSigil_activated");
+ this.passiveIcon = iconRegister.registerIcon("AlchemicalWizardry:WindSigil_deactivated");
+ }
+
+ @Override
+ public IIcon getIcon(ItemStack stack, int renderPass, EntityPlayer player, ItemStack usingItem, int useRemaining)
+ {
+ if (stack.stackTagCompound == null)
+ {
+ stack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = stack.stackTagCompound;
+
+ if (tag.getBoolean("isActive"))
+ {
+ return this.activeIcon;
+ } else
+ {
+ return this.passiveIcon;
+ }
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public IIcon getIconFromDamage(int par1)
+ {
+ if (par1 == 1)
+ {
+ return this.activeIcon;
+ } else
+ {
+ return this.passiveIcon;
+ }
+ }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par3EntityPlayer);
+
+ if (par3EntityPlayer.isSneaking())
+ {
+ return par1ItemStack;
+ }
+
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tag = par1ItemStack.stackTagCompound;
+ tag.setBoolean("isActive", !(tag.getBoolean("isActive")));
+
+ if (tag.getBoolean("isActive"))
+ {
+ par1ItemStack.setItemDamage(1);
+ tag.setInteger("worldTimeDelay", (int) (par2World.getWorldTime() - 1) % 200);
+ par3EntityPlayer.addPotionEffect(new PotionEffect(AlchemicalWizardry.customPotionProjProt.id, 2, 1));
+ //par3EntityPlayer.addPotionEffect(new PotionEffect(AlchemicalWizardry.customPotionProjProt.id, 2, 2));
+
+ //Test with added health boost
+ //par3EntityPlayer.addPotionEffect(new PotionEffect(Potion.field_76444_x.id, 2400,99));
+ if (!par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ if (!EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, getEnergyUsed()))
+ {
+ }
+ }
+ } else
+ {
+ par1ItemStack.setItemDamage(par1ItemStack.getMaxDamage());
+ }
+
+ return par1ItemStack;
+ }
+
+ @Override
+ public void onUpdate(ItemStack par1ItemStack, World par2World, Entity par3Entity, int par4, boolean par5)
+ {
+ if (!(par3Entity instanceof EntityPlayer))
+ {
+ return;
+ }
+
+ EntityPlayer par3EntityPlayer = (EntityPlayer) par3Entity;
+
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ if (par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ par3EntityPlayer.addPotionEffect(new PotionEffect(AlchemicalWizardry.customPotionProjProt.id, 2, 1));
+ }
+
+ if (par2World.getWorldTime() % 200 == par1ItemStack.stackTagCompound.getInteger("worldTimeDelay") && par1ItemStack.stackTagCompound.getBoolean("isActive"))
+ {
+ //par3EntityPlayer.addPotionEffect(new PotionEffect(AlchemicalWizardry.customPotionBoost.id, 205, 1));
+
+ //par3EntityPlayer.addPotionEffect(new PotionEffect(AlchemicalWizardry.customPotionProjProt.id, 205, 2));
+ if (!par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ if (!EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, getEnergyUsed()))
+ {
+ }
+ }
+ }
+
+ return;
+ }
+
+ @Override
+ public void onArmourUpdate(World world, EntityPlayer player, ItemStack itemStack)
+ {
+ if (itemStack.stackTagCompound == null)
+ {
+ itemStack.setTagCompound(new NBTTagCompound());
+ }
+
+ player.addPotionEffect(new PotionEffect(AlchemicalWizardry.customPotionProjProt.id, 3, 1));
+ }
+
+ @Override
+ public boolean isUpgrade()
+ {
+ // TODO Auto-generated method stub
+ return true;
+ }
+
+ @Override
+ public int getEnergyForTenSeconds()
+ {
+ // TODO Auto-generated method stub
+ return 150;
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/VoidSigil.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/VoidSigil.java
new file mode 100644
index 00000000..54695d21
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/VoidSigil.java
@@ -0,0 +1,195 @@
+package WayofTime.alchemicalWizardry.common.items.sigil;
+
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.MaterialLiquid;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemBucket;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.World;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.event.entity.player.FillBucketEvent;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.IFluidHandler;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.items.interfaces.ArmourUpgrade;
+import WayofTime.alchemicalWizardry.common.items.EnergyBattery;
+import WayofTime.alchemicalWizardry.common.items.EnergyItems;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class VoidSigil extends ItemBucket implements ArmourUpgrade
+{
+ private int isFull;
+ private int energyUsed;
+
+ public VoidSigil()
+ {
+ super(null);
+ this.maxStackSize = 1;
+ //setMaxDamage(1000);
+ setEnergyUsed(50);
+ isFull = 0;
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:VoidSigil");
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Better than a Swiffer!");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+ }
+
+ @Override
+ public ItemStack getContainerItem(ItemStack itemStack)
+ {
+ ItemStack copiedStack = itemStack.copy();
+ copiedStack.setItemDamage(copiedStack.getItemDamage() + getEnergyUsed());
+ copiedStack.stackSize = 1;
+ return copiedStack;
+ }
+
+ protected void setEnergyUsed(int par1int)
+ {
+ this.energyUsed = par1int;
+ }
+
+ protected int getEnergyUsed()
+ {
+ return this.energyUsed;
+ }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par3EntityPlayer);
+
+ if (par3EntityPlayer.isSneaking())
+ {
+ return par1ItemStack;
+ }
+
+ float f = 1.0F;
+ double d0 = par3EntityPlayer.prevPosX + (par3EntityPlayer.posX - par3EntityPlayer.prevPosX) * (double) f;
+ double d1 = par3EntityPlayer.prevPosY + (par3EntityPlayer.posY - par3EntityPlayer.prevPosY) * (double) f + 1.62D - (double) par3EntityPlayer.yOffset;
+ double d2 = par3EntityPlayer.prevPosZ + (par3EntityPlayer.posZ - par3EntityPlayer.prevPosZ) * (double) f;
+ boolean flag = this.isFull == 0;
+ MovingObjectPosition movingobjectposition = this.getMovingObjectPositionFromPlayer(par2World, par3EntityPlayer, flag);
+
+ if (movingobjectposition == null)
+ {
+ return par1ItemStack;
+ } else
+ {
+ FillBucketEvent event = new FillBucketEvent(par3EntityPlayer, par1ItemStack, par2World, movingobjectposition);
+
+ if (MinecraftForge.EVENT_BUS.post(event))
+ {
+ return par1ItemStack;
+ }
+
+ if (movingobjectposition.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK)
+ {
+ int i = movingobjectposition.blockX;
+ int j = movingobjectposition.blockY;
+ int k = movingobjectposition.blockZ;
+
+ if (!par2World.canMineBlock(par3EntityPlayer, i, j, k))
+ {
+ return par1ItemStack;
+ }
+
+ TileEntity tile = par2World.getTileEntity(i, j, k);
+ if(tile instanceof IFluidHandler)
+ {
+ FluidStack amount = ((IFluidHandler) tile).drain(ForgeDirection.getOrientation(movingobjectposition.sideHit), 1000, false);
+
+ if(amount != null && amount.amount > 0)
+ {
+ ((IFluidHandler) tile).drain(ForgeDirection.getOrientation(movingobjectposition.sideHit), 1000, true);
+ if (!par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ if (!EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, getEnergyUsed()))
+ {
+ }
+ }
+ }
+
+ return par1ItemStack;
+ }
+
+ if (this.isFull == 0)
+ {
+ if (!par3EntityPlayer.canPlayerEdit(i, j, k, movingobjectposition.sideHit, par1ItemStack))
+ {
+ return par1ItemStack;
+ }
+
+ if (par2World.getBlock(i, j, k).getMaterial() instanceof MaterialLiquid)
+ {
+ par2World.setBlockToAir(i, j, k);
+
+ if (!par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ if (!EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, getEnergyUsed()))
+ {
+ }
+ } else
+ {
+ return par1ItemStack;
+ }
+ }
+ }
+ }
+
+ return par1ItemStack;
+ }
+ }
+
+ /**
+ * Attempts to place the liquid contained inside the bucket.
+ */
+ public boolean tryPlaceContainedLiquid(World par1World, double par2, double par4, double par6, int par8, int par9, int par10)
+ {
+ return false;
+ }
+
+ @Override
+ public void onArmourUpdate(World world, EntityPlayer player,
+ ItemStack thisItemStack)
+ {
+ // TODO Auto-generated method stub
+ }
+
+ @Override
+ public boolean isUpgrade()
+ {
+ // TODO Auto-generated method stub
+ return true;
+ }
+
+ @Override
+ public int getEnergyForTenSeconds()
+ {
+ // TODO Auto-generated method stub
+ return 25;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/WaterSigil.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/WaterSigil.java
new file mode 100644
index 00000000..e8378c7a
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/sigil/WaterSigil.java
@@ -0,0 +1,285 @@
+package WayofTime.alchemicalWizardry.common.items.sigil;
+
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemBucket;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.potion.Potion;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.IFluidHandler;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.api.items.interfaces.ArmourUpgrade;
+import WayofTime.alchemicalWizardry.common.items.EnergyItems;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class WaterSigil extends ItemBucket implements ArmourUpgrade
+{
+ /**
+ * field for checking if the bucket has been filled.
+ */
+ private Block isFull = Blocks.water;
+ private int energyUsed;
+
+ public WaterSigil()
+ {
+ super(Blocks.water);
+ this.maxStackSize = 1;
+ //setMaxDamage(1000);
+ setEnergyUsed(100);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ }
+
+ @Override
+ public void onCreated(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ if (par1ItemStack.stackTagCompound == null)
+ {
+ par1ItemStack.setTagCompound(new NBTTagCompound());
+ }
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:WaterSigil");
+ }
+
+ @Override
+ public ItemStack getContainerItem(ItemStack itemStack)
+ {
+ ItemStack copiedStack = itemStack.copy();
+ copiedStack.setItemDamage(copiedStack.getItemDamage() + 1);
+ copiedStack.stackSize = 1;
+ return copiedStack;
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("Infinite water, anyone?");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+ }
+
+ /**
+ * Called whenever this item is equipped and the right mouse button is pressed. Args: itemStack, world, entityPlayer
+ */
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ EnergyItems.checkAndSetItemOwner(par1ItemStack, par3EntityPlayer);
+
+ if (par3EntityPlayer.isSneaking())
+ {
+ return par1ItemStack;
+ }
+
+ float f = 1.0F;
+ double d0 = par3EntityPlayer.prevPosX + (par3EntityPlayer.posX - par3EntityPlayer.prevPosX) * (double) f;
+ double d1 = par3EntityPlayer.prevPosY + (par3EntityPlayer.posY - par3EntityPlayer.prevPosY) * (double) f + 1.62D - (double) par3EntityPlayer.yOffset;
+ double d2 = par3EntityPlayer.prevPosZ + (par3EntityPlayer.posZ - par3EntityPlayer.prevPosZ) * (double) f;
+ //boolean flag = this.isFull == 0;
+ MovingObjectPosition movingobjectposition = this.getMovingObjectPositionFromPlayer(par2World, par3EntityPlayer, false);
+
+ if (movingobjectposition == null)
+ {
+ return par1ItemStack;
+ } else
+ {
+ if (movingobjectposition.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK)
+ {
+ int i = movingobjectposition.blockX;
+ int j = movingobjectposition.blockY;
+ int k = movingobjectposition.blockZ;
+
+ if (!par2World.canMineBlock(par3EntityPlayer, i, j, k))
+ {
+ return par1ItemStack;
+ }
+
+ TileEntity tile = par2World.getTileEntity(i, j, k);
+ if(tile instanceof IFluidHandler)
+ {
+ FluidStack fluid = new FluidStack(FluidRegistry.WATER,1000);
+ int amount = ((IFluidHandler) tile).fill(ForgeDirection.getOrientation(movingobjectposition.sideHit), fluid, false);
+
+ if(amount>0)
+ {
+ ((IFluidHandler) tile).fill(ForgeDirection.getOrientation(movingobjectposition.sideHit), fluid, true);
+ if (!par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ if (!EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, getEnergyUsed()))
+ {
+ }
+ }
+ }
+
+ return par1ItemStack;
+ }
+
+ {
+ if (movingobjectposition.sideHit == 0)
+ {
+ --j;
+ }
+
+ if (movingobjectposition.sideHit == 1)
+ {
+ ++j;
+ }
+
+ if (movingobjectposition.sideHit == 2)
+ {
+ --k;
+ }
+
+ if (movingobjectposition.sideHit == 3)
+ {
+ ++k;
+ }
+
+ if (movingobjectposition.sideHit == 4)
+ {
+ --i;
+ }
+
+ if (movingobjectposition.sideHit == 5)
+ {
+ ++i;
+ }
+
+ if (!par3EntityPlayer.canPlayerEdit(i, j, k, movingobjectposition.sideHit, par1ItemStack))
+ {
+ return par1ItemStack;
+ }
+
+ if (this.tryPlaceContainedLiquid(par2World, d0, d1, d2, i, j, k) && !par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ if (!par3EntityPlayer.capabilities.isCreativeMode)
+ {
+ if (!EnergyItems.syphonBatteries(par1ItemStack, par3EntityPlayer, getEnergyUsed()))
+ {
+ }
+ } else
+ {
+ return par1ItemStack;
+ }
+ }
+ }
+ }
+
+ return par1ItemStack;
+ }
+ }
+
+ /**
+ * Attempts to place the liquid contained inside the bucket.
+ */
+ public boolean tryPlaceContainedLiquid(World par1World, double par2, double par4, double par6, int par8, int par9, int par10)
+ {
+ if (!par1World.isAirBlock(par8, par9, par10) && par1World.getBlock(par8, par9, par10).getMaterial().isSolid())
+ {
+ return false;
+ } else if ((par1World.getBlock(par8, par9, par10) == Blocks.water || par1World.getBlock(par8, par9, par10) == Blocks.flowing_water) && par1World.getBlockMetadata(par8, par9, par10) == 0)
+ {
+ return false;
+ } else
+ {
+ if (par1World.provider.isHellWorld)
+ {
+ par1World.playSoundEffect(par2 + 0.5D, par4 + 0.5D, par6 + 0.5D, "random.fizz", 0.5F, 2.6F + (par1World.rand.nextFloat() - par1World.rand.nextFloat()) * 0.8F);
+
+ for (int l = 0; l < 8; ++l)
+ {
+ par1World.spawnParticle("largesmoke", (double) par8 + Math.random(), (double) par9 + Math.random(), (double) par10 + Math.random(), 0.0D, 0.0D, 0.0D);
+ }
+ } else
+ {
+ par1World.setBlock(par8, par9, par10, this.isFull, 0, 3);
+ }
+
+ return true;
+ }
+ }
+
+ protected void setEnergyUsed(int par1int)
+ {
+ this.energyUsed = par1int;
+ }
+
+ protected int getEnergyUsed()
+ {
+ return this.energyUsed;
+ }
+ //Heals the player using the item. If the player is at full health, or if the durability cannot be used any more,
+ //the item is not used.
+
+// protected void damagePlayer(World world, EntityPlayer player, int damage)
+// {
+// if (world != null)
+// {
+// double posX = player.posX;
+// double posY = player.posY;
+// double posZ = player.posZ;
+// world.playSoundEffect((double)((float)posX + 0.5F), (double)((float)posY + 0.5F), (double)((float)posZ + 0.5F), "random.fizz", 0.5F, 2.6F + (world.rand.nextFloat() - world.rand.nextFloat()) * 0.8F);
+// float f = (float)1.0F;
+// float f1 = f * 0.6F + 0.4F;
+// float f2 = f * f * 0.7F - 0.5F;
+// float f3 = f * f * 0.6F - 0.7F;
+//
+// for (int l = 0; l < 8; ++l)
+// {
+// world.spawnParticle("reddust", posX + Math.random() - Math.random(), posY + Math.random() - Math.random(), posZ + Math.random() - Math.random(), f1, f2, f3);
+// }
+// }
+//
+// for (int i = 0; i < damage; i++)
+// {
+// //player.setEntityHealth((player.getHealth()-1));
+// player.setEntityHealth(player.func_110143_aJ() - 1);
+// }
+//
+// if (player.func_110143_aJ() <= 0)
+// {
+// player.inventory.dropAllItems();
+// }
+// }
+
+ @Override
+ public void onArmourUpdate(World world, EntityPlayer player,
+ ItemStack thisItemStack)
+ {
+ // TODO Auto-generated method stub
+ //PotionEffect effect = new PotionEffect(Potion.waterBreathing.id, 2,9);
+ player.addPotionEffect(new PotionEffect(Potion.waterBreathing.id, 2, 9,true));
+ }
+
+ @Override
+ public boolean isUpgrade()
+ {
+ // TODO Auto-generated method stub
+ return true;
+ }
+
+ @Override
+ public int getEnergyForTenSeconds()
+ {
+ // TODO Auto-generated method stub
+ return 50;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/spell/ItemSpellMultiTool.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/spell/ItemSpellMultiTool.java
new file mode 100644
index 00000000..6f1806a1
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/spell/ItemSpellMultiTool.java
@@ -0,0 +1,861 @@
+package WayofTime.alchemicalWizardry.common.items.spell;
+
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.World;
+import net.minecraftforge.common.DimensionManager;
+import net.minecraftforge.common.util.Constants;
+import net.minecraftforge.common.util.ForgeDirection;
+import WayofTime.alchemicalWizardry.common.items.EnergyItems;
+import WayofTime.alchemicalWizardry.common.spell.complex.SpellParadigmTool;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellEffect;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+
+public class ItemSpellMultiTool extends Item
+{
+ private static final String harvestLevelSuffix = "harvestLvl";
+ private static final String digLevelSuffix = "digLvl";
+ private static final String tagName = "BloodMagicTool";
+ private Random rand = new Random();
+
+ public ItemSpellMultiTool()
+ {
+ super();
+ this.setMaxDamage(0);
+ this.setMaxStackSize(1);
+ this.setFull3D();
+ }
+
+ @Override
+ public void registerIcons (IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:BoundTool");
+ }
+
+ @Override
+ public boolean hitEntity(ItemStack par1ItemStack, EntityLivingBase par2EntityLivingBase, EntityLivingBase par3EntityLivingBase)
+ {
+ float damage = this.getCustomItemAttack(par1ItemStack);
+
+ SpellParadigmTool parad = this.loadParadigmFromStack(par1ItemStack);
+
+ if(parad != null)
+ {
+ parad.onLeftClickEntity(par1ItemStack, par2EntityLivingBase, par3EntityLivingBase);
+ }
+
+ damage += parad.getAddedDamageForEntity(par2EntityLivingBase);
+
+ if(rand.nextFloat() < this.getCritChance(par1ItemStack))
+ {
+ damage *= 1.75f;
+ }
+
+ if(par3EntityLivingBase instanceof EntityPlayer)
+ {
+ par2EntityLivingBase.attackEntityFrom(DamageSource.causePlayerDamage((EntityPlayer)par3EntityLivingBase), damage);
+ }
+ else
+ {
+ par2EntityLivingBase.attackEntityFrom(DamageSource.causeMobDamage(par3EntityLivingBase), damage);
+ }
+
+ return true;
+ }
+
+ @Override
+ public boolean onLeftClickEntity(ItemStack stack, EntityPlayer player, Entity entity)
+ {
+ SpellParadigmTool parad = this.loadParadigmFromStack(stack);
+
+ if(parad != null && entity instanceof EntityLivingBase)
+ {
+ parad.onLeftClickEntity(stack, (EntityLivingBase)entity, player);
+ }
+
+ return false;
+ }
+
+ @Override
+ public boolean onBlockStartBreak (ItemStack stack, int x, int y, int z, EntityPlayer player)
+ {
+ if(player.worldObj.isRemote)
+ {
+ return false;
+ }
+
+ if (!stack.hasTagCompound())
+ return false;
+
+ World world = player.worldObj;
+ Block block = player.worldObj.getBlock(x, y, z);
+ int meta = world.getBlockMetadata(x, y, z);
+ // Block block = Block.blocksList[bID];
+ if (block == null || block == Blocks.air)
+ return false;
+ int hlvl = -1;
+ float blockHardness = block.getBlockHardness(world, x, y, z);
+
+ MovingObjectPosition mop = SpellHelper.raytraceFromEntity(world, player, true, 5.0D);
+
+ Block localBlock = world.getBlock(x, y, z);
+ int localMeta = world.getBlockMetadata(x, y, z);
+ String toolClass = block.getHarvestTool(meta);
+ if (toolClass != null && this.getHarvestLevel(stack, toolClass) != -1)
+ hlvl = block.getHarvestLevel(meta);
+ int toolLevel = this.getHarvestLevel(stack, toolClass);
+
+ float localHardness = localBlock == null ? Float.MAX_VALUE : localBlock.getBlockHardness(world, x, y, z);
+
+ if (hlvl <= toolLevel && localHardness - 1.5 <= blockHardness)
+ {
+ boolean cancelHarvest = false;
+
+ if (!cancelHarvest)
+ {
+ if (localBlock != null && !(localHardness < 0))
+ {
+ boolean isEffective = false;
+
+ String localToolClass = this.getToolClassForMaterial(localBlock.getMaterial());
+
+ if(localToolClass != null && this.getHarvestLevel(stack, toolClass) >= localBlock.getHarvestLevel(localMeta))
+ {
+ isEffective = true;
+ }
+
+
+ if (localBlock.getMaterial().isToolNotRequired())
+ {
+ isEffective = true;
+ }
+
+ if (!player.capabilities.isCreativeMode)
+ {
+ if (isEffective)
+ {
+ if (localBlock.removedByPlayer(world, player, x, y, z))
+ {
+ localBlock.onBlockDestroyedByPlayer(world, x, y, z, localMeta);
+ }
+ //localBlock.harvestBlock(world, player, x, y, z, localMeta);
+ localBlock.onBlockHarvested(world, x, y, z, localMeta, player);
+ if (blockHardness > 0f)
+ onBlockDestroyed(stack, world, localBlock, x, y, z, player);
+
+ List items = SpellHelper.getItemsFromBlock(world, localBlock, x, y, z, localMeta, this.getSilkTouch(stack), this.getFortuneLevel(stack));
+
+ SpellParadigmTool parad = this.loadParadigmFromStack(stack);
+ List newItems = parad.handleItemList(stack, items);
+
+ if(!world.isRemote)
+ {
+ SpellHelper.spawnItemListInWorld(newItems, world, x + 0.5f, y + 0.5f, z + 0.5f);
+ }
+
+ world.func_147479_m(x, y, z);
+
+ int cost = 0;
+
+ cost += parad.digSurroundingArea(stack, world, player, mop, localToolClass, localHardness, toolLevel, this);
+
+ cost += parad.onBreakBlock(stack, world, player, localBlock, localMeta, x, y, z, ForgeDirection.getOrientation(mop.sideHit));
+
+ if(cost > 0)
+ {
+ EnergyItems.syphonAndDamageWhileInContainer(stack, player, cost);
+ }
+ }
+ else
+ {
+ world.setBlockToAir(x, y, z);
+ world.func_147479_m(x, y, z);
+ }
+
+ }
+ else
+ {
+ world.setBlockToAir(x, y, z);
+ world.func_147479_m(x, y, z);
+ }
+ }
+ }
+ }
+
+ if (!world.isRemote)
+ world.playAuxSFX(2001, x, y, z, Block.getIdFromBlock(block) + (meta << 12));
+ return true;
+
+ }
+
+ public Material[] getMaterialsForToolclass(String toolClass)
+ {
+ if("pickaxe".equals(toolClass))
+ {
+ return new Material[] { Material.rock, Material.iron, Material.ice, Material.glass, Material.piston, Material.anvil, Material.circuits };
+ }
+ else if("shovel".equals(toolClass))
+ {
+ return new Material[]{ Material.grass, Material.ground, Material.sand, Material.snow, Material.craftedSnow, Material.clay };
+ }
+ else if("axe".equals(toolClass))
+ {
+ return new Material[]{ Material.wood, Material.vine, Material.circuits, Material.cactus };
+ }
+ return new Material[0];
+ }
+
+ public String getToolClassForMaterial(Material mat)
+ {
+ String testString = "pickaxe";
+
+ Material[] matList = this.getMaterialsForToolclass(testString);
+ for(int i=0; i < matList.length; i++)
+ {
+ if(matList[i] == mat)
+ {
+ return testString;
+ }
+ }
+
+ testString = "shovel";
+ matList = this.getMaterialsForToolclass(testString);
+ for(int i=0; i < matList.length; i++)
+ {
+ if(matList[i] == mat)
+ {
+ return testString;
+ }
+ }
+
+ testString = "axe";
+ matList = this.getMaterialsForToolclass(testString);
+ for(int i=0; i < matList.length; i++)
+ {
+ if(matList[i] == mat)
+ {
+ return testString;
+ }
+ }
+
+ return null;
+ }
+
+ public Set getToolClasses(ItemStack stack)
+ {
+ Set set = new HashSet();
+
+ if(this.getHarvestLevel(stack, "pickaxe") > -1)
+ {
+ set.add("pickaxe");
+ }
+
+ if(this.getHarvestLevel(stack, "axe") > -1)
+ {
+ set.add("axe");
+ }
+
+ if(this.getHarvestLevel(stack, "shovel") > -1)
+ {
+ set.add("shovel");
+ }
+
+ return set;
+ }
+
+// @Override
+// public boolean onBlockDestroyed (ItemStack itemstack, World world, Block block, int x, int y, int z, EntityLivingBase player)
+// {
+// if (block != null && block.getMaterial() == Material.leaves)
+// return false;
+//
+//
+// return AbilityHelper.onBlockChanged(itemstack, world, block, x, y, z, player, random);
+// }
+
+ @Override
+ public float getDigSpeed(ItemStack stack, Block block, int meta)
+ {
+ String toolClass = block.getHarvestTool(meta);
+
+ if(toolClass == null || toolClass.equals(""))
+ {
+ return 1.0f;
+ }
+
+ //if (ForgeHooks.isToolEffective(stack, block, meta))
+ {
+ if(stack.hasTagCompound())
+ {
+ NBTTagCompound tag = stack.getTagCompound().getCompoundTag(tagName);
+
+ return tag.getFloat(digLevelSuffix + toolClass);
+ }
+ else
+ {
+ stack.setTagCompound(new NBTTagCompound());
+ }
+ }
+
+ return 1.0f;
+ }
+
+ @Override
+ public int getHarvestLevel(ItemStack stack, String toolClass)
+ {
+ if(stack.hasTagCompound())
+ {
+ NBTTagCompound tag = stack.getTagCompound().getCompoundTag(tagName);
+
+ if(tag.hasKey(harvestLevelSuffix + toolClass))
+ {
+ return tag.getInteger(harvestLevelSuffix + toolClass);
+ }else
+ {
+ return -1;
+ }
+ }
+ else
+ {
+ stack.setTagCompound(new NBTTagCompound());
+ }
+
+ return -1;
+ }
+
+// @Override
+// public float func_150893_a(ItemStack p_150893_1_, Block p_150893_2_)
+// {
+// return p_150893_2_.getMaterial() != Material.iron && p_150893_2_.getMaterial() != Material.anvil && p_150893_2_.getMaterial() != Material.rock ? super.func_150893_a(p_150893_1_, p_150893_2_) : 15;
+// }
+
+ @Override
+ public boolean canHarvestBlock(Block par1Block, ItemStack itemStack)
+ {
+
+ return true;
+ }
+
+ @Override
+ public boolean getIsRepairable(ItemStack par1ItemStack, ItemStack par2ItemStack)
+ {
+ return false;
+ }
+
+ @Override
+ public void onUpdate(ItemStack toolStack, World world, Entity par3Entity, int par4, boolean par5)
+ {
+ if(world.isRemote)
+ {
+ return;
+ }
+
+ SpellParadigmTool parad = this.loadParadigmFromStack(toolStack);
+ int cost = parad.onUpdate(toolStack, world, par3Entity, par4, par5);
+
+ if(par3Entity instanceof EntityPlayer && cost > 0)
+ EnergyItems.syphonAndDamageWhileInContainer(toolStack, (EntityPlayer)par3Entity, cost);
+
+ int duration = Math.max(this.getDuration(toolStack, world), 0);
+
+ if(duration <= 0 && par3Entity instanceof EntityPlayer)
+ {
+ int banishCost = parad.onBanishTool(toolStack, world, par3Entity, par4, par5);
+ EnergyItems.syphonAndDamageWhileInContainer(toolStack, (EntityPlayer)par3Entity, banishCost);
+ ((EntityPlayer) par3Entity).inventory.mainInventory[par4] = this.getContainedCrystal(toolStack);
+ }
+ }
+
+ @Override
+ public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+ {
+ if(par3EntityPlayer.isSneaking())
+ {
+ par3EntityPlayer.setCurrentItemOrArmor(0, this.getContainedCrystal(par1ItemStack));
+ return par1ItemStack;
+ }
+
+ SpellParadigmTool parad = this.loadParadigmFromStack(par1ItemStack);
+
+ MovingObjectPosition mop = this.getMovingObjectPositionFromPlayer(par2World, par3EntityPlayer, false);
+
+ int cost = 0;
+
+ if(mop != null && mop.typeOfHit.equals(MovingObjectPosition.MovingObjectType.BLOCK))
+ {
+ cost = parad.onRightClickBlock(par1ItemStack, par3EntityPlayer, par2World, mop);
+ }else
+ {
+ cost = parad.onRightClickAir(par1ItemStack, par2World, par3EntityPlayer);
+ }
+
+ if(cost > 0)
+ {
+ EnergyItems.syphonAndDamageWhileInContainer(par1ItemStack, par3EntityPlayer, cost);
+ }
+
+ return par1ItemStack;
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ par3List.add("A mace filled with ancient alchemy");
+
+ if (!(par1ItemStack.stackTagCompound == null))
+ {
+ if (!par1ItemStack.stackTagCompound.getString("ownerName").equals(""))
+ {
+ par3List.add("Current owner: " + par1ItemStack.stackTagCompound.getString("ownerName"));
+ }
+
+ for(String str : this.getToolListString(par1ItemStack))
+ {
+ par3List.add(str);
+ }
+
+ par3List.add("");
+ float damage = this.getCustomItemAttack(par1ItemStack);
+ par3List.add("\u00A79+" + ((int)(damage*10))/10.0f + " " + "Attack Damage");
+ float critChance = ((int)(this.getCritChance(par1ItemStack)*1000))/10.0f;
+ par3List.add("\u00A79+" + critChance + "% " + "Crit Chance");
+ }
+ }
+
+ //--------------Custom methods--------------//
+
+ public void setHarvestLevel(ItemStack stack, String toolClass, int harvestLevel)
+ {
+ if(stack.hasTagCompound())
+ {
+ NBTTagCompound tag = stack.getTagCompound().getCompoundTag(tagName);
+
+ tag.setInteger(harvestLevelSuffix + toolClass, Math.max(-1,harvestLevel));
+
+ stack.getTagCompound().setTag(tagName, tag);
+ }
+ else
+ {
+ stack.setTagCompound(new NBTTagCompound());
+
+ NBTTagCompound tag = stack.getTagCompound().getCompoundTag(tagName);
+
+ tag.setInteger(harvestLevelSuffix + toolClass, Math.max(-1,harvestLevel));
+
+ stack.getTagCompound().setTag(tagName, tag);
+ }
+ }
+
+ public void setDigSpeed(ItemStack stack, String toolClass, float digSpeed)
+ {
+ if(stack.hasTagCompound())
+ {
+ NBTTagCompound tag = stack.getTagCompound().getCompoundTag(tagName);
+
+ tag.setFloat(digLevelSuffix + toolClass, digSpeed);
+
+ stack.getTagCompound().setTag(tagName, tag);
+ }
+ else
+ {
+ stack.setTagCompound(new NBTTagCompound());
+
+ NBTTagCompound tag = stack.getTagCompound().getCompoundTag(tagName);
+
+ tag.setFloat(digLevelSuffix + toolClass, digSpeed);
+
+ stack.getTagCompound().setTag(tagName, tag);
+ }
+ }
+
+ public float getDigSpeed(ItemStack stack, String toolClass)
+ {
+ if(stack.hasTagCompound())
+ {
+ NBTTagCompound tag = stack.getTagCompound().getCompoundTag(tagName);
+
+ return tag.getFloat(digLevelSuffix + toolClass);
+ }
+ else
+ {
+ stack.setTagCompound(new NBTTagCompound());
+
+ return 0.0f;
+ }
+ }
+
+ public void setItemAttack(ItemStack stack, float damage)
+ {
+ if(stack.hasTagCompound())
+ {
+ NBTTagCompound tag = stack.getTagCompound().getCompoundTag(tagName);
+
+ tag.setFloat("itemAttack", Math.max(damage, 0.0f));
+
+ stack.stackTagCompound.setTag(tagName, tag);
+ }
+ else
+ {
+ stack.setTagCompound(new NBTTagCompound());
+
+ NBTTagCompound tag = stack.getTagCompound().getCompoundTag(tagName);
+
+ tag.setFloat("itemAttack", Math.max(damage, 0.0f));
+
+ stack.stackTagCompound.setTag(tagName, tag);
+ }
+ }
+
+ public float getCustomItemAttack(ItemStack stack)
+ {
+ if(stack.hasTagCompound())
+ {
+ NBTTagCompound tag = stack.getTagCompound().getCompoundTag(tagName);
+
+ return tag.getFloat("itemAttack");
+ }
+ else
+ {
+ stack.setTagCompound(new NBTTagCompound());
+
+ return 0.0f;
+ }
+ }
+
+ public ItemStack getContainedCrystal(ItemStack container)
+ {
+ if(container.hasTagCompound())
+ {
+ NBTTagCompound tag = container.getTagCompound().getCompoundTag(tagName).getCompoundTag("heldItem");
+
+ return ItemStack.loadItemStackFromNBT(tag);
+ }
+ else
+ {
+ container.setTagCompound(new NBTTagCompound());
+
+ return null;
+ }
+ }
+
+ public void setContainedCrystal(ItemStack container, ItemStack crystal)
+ {
+ if(container.hasTagCompound())
+ {
+ NBTTagCompound compTag = container.getTagCompound().getCompoundTag(tagName);
+ NBTTagCompound tag = compTag.getCompoundTag("heldItem");
+
+ crystal.writeToNBT(tag);
+
+ compTag.setTag("heldItem", tag);
+ container.getTagCompound().setTag(tagName, compTag);
+ }
+ else
+ {
+ container.setTagCompound(new NBTTagCompound());
+
+ NBTTagCompound compTag = container.getTagCompound().getCompoundTag(tagName);
+ NBTTagCompound tag = compTag.getCompoundTag("heldItem");
+
+ crystal.writeToNBT(tag);
+
+ compTag.setTag("heldItem", tag);
+ container.getTagCompound().setTag(tagName, compTag);
+ }
+ }
+
+ public void setDuration(ItemStack container, World world, int duration)
+ {
+ if(world.isRemote)
+ {
+ return;
+ }else
+ {
+ World overWorld = DimensionManager.getWorld(0);
+ long worldtime = overWorld.getTotalWorldTime();
+
+ if(container.hasTagCompound())
+ {
+ NBTTagCompound tag = container.getTagCompound().getCompoundTag(tagName);
+
+ tag.setLong("duration", Math.max(duration + worldtime, worldtime));
+
+ container.getTagCompound().setTag(tagName, tag);
+ }
+ else
+ {
+ container.setTagCompound(new NBTTagCompound());
+
+ NBTTagCompound tag = container.getTagCompound().getCompoundTag(tagName);
+
+ tag.setLong("duration", Math.max(duration + worldtime, worldtime));
+
+ container.getTagCompound().setTag(tagName, tag);
+ }
+ }
+ }
+
+ public int getDuration(ItemStack container, World world)
+ {
+ if(world.isRemote)
+ {
+ return 0;
+ }
+ else
+ {
+ World overWorld = DimensionManager.getWorld(0);
+ long worldtime = overWorld.getTotalWorldTime();
+
+ if(container.hasTagCompound())
+ {
+ NBTTagCompound tag = container.getTagCompound().getCompoundTag(tagName);
+
+ return (int)(tag.getLong("duration") - worldtime);
+ }
+ else
+ {
+ container.setTagCompound(new NBTTagCompound());
+
+ return 0;
+ }
+ }
+// if(container.hasTagCompound())
+// {
+// NBTTagCompound tag = container.getTagCompound().getCompoundTag(tagName);
+//
+// return tag.getInteger("duration");
+// }
+// else
+// {
+// container.setTagCompound(new NBTTagCompound());
+//
+// return 0;
+// }
+ }
+
+ public void loadParadigmIntoStack(ItemStack container, List list)
+ {
+ if(!container.hasTagCompound())
+ {
+ container.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tagiest = container.getTagCompound().getCompoundTag(tagName);
+
+ NBTTagList effectList = new NBTTagList();
+
+ for(SpellEffect eff : list)
+ {
+ effectList.appendTag(eff.getTag());
+ }
+
+ tagiest.setTag("Effects", effectList);
+
+ container.getTagCompound().setTag(tagName, tagiest);
+ }
+
+ public SpellParadigmTool loadParadigmFromStack(ItemStack container)
+ {
+ if(!container.hasTagCompound())
+ {
+ container.setTagCompound(new NBTTagCompound());
+ }
+ NBTTagCompound tagiest = container.getTagCompound().getCompoundTag(tagName);
+
+ NBTTagList tagList = tagiest.getTagList("Effects",Constants.NBT.TAG_COMPOUND);
+
+ List spellEffectList = new LinkedList();
+ for (int i = 0; i < tagList.tagCount(); i++)
+ {
+ NBTTagCompound tag = (NBTTagCompound) tagList.getCompoundTagAt(i);
+
+ SpellEffect eff = SpellEffect.getEffectFromTag(tag);
+ if(eff!=null)
+ {
+ spellEffectList.add(eff);
+ }
+ }
+
+ return SpellParadigmTool.getParadigmForEffectArray(spellEffectList);
+ }
+
+ public void setSilkTouch(ItemStack stack, boolean silkTouch)
+ {
+ if(stack.hasTagCompound())
+ {
+ NBTTagCompound tag = stack.getTagCompound().getCompoundTag(tagName);
+
+ tag.setBoolean("silkTouch", silkTouch);
+
+ stack.stackTagCompound.setTag(tagName, tag);
+ }
+ else
+ {
+ stack.setTagCompound(new NBTTagCompound());
+
+ NBTTagCompound tag = stack.getTagCompound().getCompoundTag(tagName);
+
+ tag.setBoolean("silkTouch", silkTouch);
+
+ stack.stackTagCompound.setTag(tagName, tag);
+ }
+ }
+
+ public boolean getSilkTouch(ItemStack stack)
+ {
+ if(stack.hasTagCompound())
+ {
+ NBTTagCompound tag = stack.getTagCompound().getCompoundTag(tagName);
+
+ return tag.getBoolean("silkTouch");
+ }
+ else
+ {
+ stack.setTagCompound(new NBTTagCompound());
+
+ return false;
+ }
+ }
+
+ public void setFortuneLevel(ItemStack stack, int fortune)
+ {
+ if(stack.hasTagCompound())
+ {
+ NBTTagCompound tag = stack.getTagCompound().getCompoundTag(tagName);
+
+ tag.setInteger("fortuneLevel", Math.max(fortune, 0));
+
+ stack.stackTagCompound.setTag(tagName, tag);
+ }
+ else
+ {
+ stack.setTagCompound(new NBTTagCompound());
+
+ NBTTagCompound tag = stack.getTagCompound().getCompoundTag(tagName);
+
+ tag.setInteger("fortuneLevel", Math.max(fortune, 0));
+
+ stack.stackTagCompound.setTag(tagName, tag);
+ }
+ }
+
+ public int getFortuneLevel(ItemStack stack)
+ {
+ if(stack.hasTagCompound())
+ {
+ NBTTagCompound tag = stack.getTagCompound().getCompoundTag(tagName);
+
+ return tag.getInteger("fortuneLevel");
+ }
+ else
+ {
+ stack.setTagCompound(new NBTTagCompound());
+
+ return 0;
+ }
+ }
+
+ public List getToolListString(ItemStack container)
+ {
+ if(!container.hasTagCompound())
+ {
+ container.setTagCompound(new NBTTagCompound());
+ }
+ NBTTagCompound tagiest = container.getTagCompound().getCompoundTag(tagName);
+
+ NBTTagList tagList = tagiest.getTagList("ToolTips",Constants.NBT.TAG_COMPOUND);
+
+ List toolTipList = new LinkedList();
+ for (int i = 0; i < tagList.tagCount(); i++)
+ {
+ NBTTagCompound tag = (NBTTagCompound) tagList.getCompoundTagAt(i);
+
+ String str = tag.getString("tip");
+ if(str!=null)
+ {
+ toolTipList.add(str);
+ }
+ }
+
+ return toolTipList;
+ }
+
+ public void setToolListString(ItemStack container, List toolTipString)
+ {
+ if(!container.hasTagCompound())
+ {
+ container.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound tagiest = container.getTagCompound().getCompoundTag(tagName);
+
+ NBTTagList stringList = new NBTTagList();
+
+ for(String str : toolTipString)
+ {
+ NBTTagCompound tag = new NBTTagCompound();
+ tag.setString("tip", str);
+
+ stringList.appendTag(tag);
+ }
+
+ tagiest.setTag("ToolTips", stringList);
+
+ container.getTagCompound().setTag(tagName, tagiest);
+ }
+
+ public void setCritChance(ItemStack container, float chance)
+ {
+ if(container.hasTagCompound())
+ {
+ NBTTagCompound tag = container.getTagCompound().getCompoundTag(tagName);
+
+ tag.setFloat("critChance", Math.max(chance, 0));
+
+ container.stackTagCompound.setTag(tagName, tag);
+ }
+ else
+ {
+ container.setTagCompound(new NBTTagCompound());
+
+ NBTTagCompound tag = container.getTagCompound().getCompoundTag(tagName);
+
+ tag.setFloat("critChance", Math.max(chance, 0));
+
+ container.stackTagCompound.setTag(tagName, tag);
+ }
+ }
+
+ public float getCritChance(ItemStack container)
+ {
+ if(container.hasTagCompound())
+ {
+ NBTTagCompound tag = container.getTagCompound().getCompoundTag(tagName);
+
+ return tag.getFloat("critChance");
+ }
+ else
+ {
+ container.setTagCompound(new NBTTagCompound());
+
+ return 0;
+ }
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/thaumcraft/ItemSanguineArmour.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/thaumcraft/ItemSanguineArmour.java
new file mode 100644
index 00000000..d5eec374
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/items/thaumcraft/ItemSanguineArmour.java
@@ -0,0 +1,186 @@
+package WayofTime.alchemicalWizardry.common.items.thaumcraft;
+
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemArmor;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+import net.minecraftforge.common.ISpecialArmor;
+import thaumcraft.api.IGoggles;
+import thaumcraft.api.IRepairable;
+import thaumcraft.api.IRunicArmor;
+import thaumcraft.api.IVisDiscountGear;
+import thaumcraft.api.ThaumcraftApi;
+import thaumcraft.api.aspects.Aspect;
+import thaumcraft.api.nodes.IRevealer;
+import WayofTime.alchemicalWizardry.AlchemicalWizardry;
+import WayofTime.alchemicalWizardry.ModItems;
+import WayofTime.alchemicalWizardry.api.items.interfaces.ArmourUpgrade;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class ItemSanguineArmour extends ItemArmor implements ArmourUpgrade, IGoggles, IVisDiscountGear, IRevealer, IRunicArmor, IRepairable
+{
+ private static IIcon helmetIcon;
+ private static IIcon plateIcon;
+ private static IIcon leggingsIcon;
+ private static IIcon bootsIcon;
+
+ public ItemSanguineArmour(int armorType)
+ {
+ super(AlchemicalWizardry.sanguineArmourArmourMaterial, 0, armorType);
+ setMaxDamage(1000);
+ setCreativeTab(AlchemicalWizardry.tabBloodMagic);
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void registerIcons(IIconRegister iconRegister)
+ {
+ this.itemIcon = iconRegister.registerIcon("AlchemicalWizardry:SheathedItem");
+ this.helmetIcon = iconRegister.registerIcon("AlchemicalWizardry:SanguineHelmet");
+ this.plateIcon = iconRegister.registerIcon("AlchemicalWizardry:BoundPlate");
+ this.leggingsIcon = iconRegister.registerIcon("AlchemicalWizardry:BoundLeggings");
+ this.bootsIcon = iconRegister.registerIcon("AlchemicalWizardry:BoundBoots");
+ }
+
+ @SideOnly(Side.CLIENT)
+ public IIcon getIconFromDamage(int par1)
+ {
+ if (this.equals(ModItems.sanguineHelmet))
+ {
+ return this.helmetIcon;
+ }
+
+ if (this.equals(ModItems.sanguineRobe))
+ {
+ return this.plateIcon;
+ }
+
+ if (this.equals(ModItems.sanguinePants))
+ {
+ return this.leggingsIcon;
+ }
+
+ if (this.equals(ModItems.sanguineBoots))
+ {
+ return this.bootsIcon;
+ }
+
+ return this.itemIcon;
+ }
+
+ @Override
+ public String getArmorTexture(ItemStack stack, Entity entity, int slot, String type)
+ {
+ if (this == ModItems.sanguineHelmet)
+ {
+ return "alchemicalwizardry:models/armor/sanguineArmour_layer_1.png";
+ }
+
+ if (this == ModItems.sanguineRobe || this == ModItems.sanguineBoots)
+ {
+ return "alchemicalwizardry:models/armor/sanguineArmour_layer_1.png";
+ }
+
+ if (this == ModItems.sanguinePants)
+ {
+ return "alchemicalwizardry:models/armor/sanguineArmour_layer_2.png";
+ } else
+ {
+ return null;
+ }
+ }
+
+ @Override
+ public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+ {
+ int discount = 0;
+
+ switch(this.armorType)
+ {
+ case 0:
+ discount = 6;
+ break;
+ case 1:
+ discount = 3;
+ break;
+ case 2:
+ discount = 3;
+ break;
+ case 3:
+ discount = 2;
+ break;
+ }
+
+ switch(this.armorType)
+ {
+ case 0:
+ par3List.add("A pair of goggles imbued with power");
+ break;
+ case 1:
+
+ case 2:
+
+ case 3:
+ par3List.add("Robes imbued with forbidden power");
+ }
+
+ par3List.add("Vis discount: " + discount + "%");
+ }
+
+ @Override
+ public void onArmourUpdate(World world, EntityPlayer player, ItemStack thisItemStack)
+ {
+ return;
+ }
+
+ @Override
+ public boolean isUpgrade()
+ {
+ return true;
+ }
+
+ @Override
+ public int getEnergyForTenSeconds()
+ {
+ return 0;
+ }
+
+ @Override
+ public boolean showNodes(ItemStack itemstack, EntityLivingBase player)
+ {
+ return true;
+ }
+
+ @Override
+ public int getVisDiscount(ItemStack stack, EntityPlayer player, Aspect aspect)
+ {
+ switch(this.armorType)
+ {
+ case 0: return 7;
+ case 1: return 3;
+ case 2: return 2;
+ case 3: return 2;
+ }
+ return 0;
+ }
+
+ @Override
+ public boolean showIngamePopups(ItemStack itemstack, EntityLivingBase player)
+ {
+ return true;
+ }
+
+ @Override
+ public int getRunicCharge(ItemStack itemstack) {
+ // TODO Auto-generated method stub
+ return 0;
+ }
+}
\ No newline at end of file
diff --git a/mcmod.info b/src-backup/main/java/WayofTime/alchemicalWizardry/common/mcmod.info
similarity index 76%
rename from mcmod.info
rename to src-backup/main/java/WayofTime/alchemicalWizardry/common/mcmod.info
index 81078021..cd89dc4c 100644
--- a/mcmod.info
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/mcmod.info
@@ -3,8 +3,8 @@
"modid": "AWWayofTime",
"name": "Blood Magic: Alchemical Wizardry",
"description": "Gruesome? Probably. Worth it? Definately!",
- "version": "0.4.0",
- "url": "http://www.minecraftforum.net/topic/1899223-162-blood-magic-v040/",
+ "version": "0.2.1c",
+ "url": "",
"updateUrl": "",
"logoFile": "",
"mcversion": "1.6.2",
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionBoost.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionBoost.java
new file mode 100644
index 00000000..132205bb
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionBoost.java
@@ -0,0 +1,18 @@
+package WayofTime.alchemicalWizardry.common.potion;
+
+import net.minecraft.potion.Potion;
+
+public class PotionBoost extends Potion
+{
+ public PotionBoost(int par1, boolean par2, int par3)
+ {
+ super(par1, par2, par3);
+ }
+
+ @Override
+ public Potion setIconIndex(int par1, int par2)
+ {
+ super.setIconIndex(par1, par2);
+ return this;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionDeaf.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionDeaf.java
new file mode 100644
index 00000000..fc46e77b
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionDeaf.java
@@ -0,0 +1,18 @@
+package WayofTime.alchemicalWizardry.common.potion;
+
+import net.minecraft.potion.Potion;
+
+public class PotionDeaf extends Potion
+{
+ public PotionDeaf(int par1, boolean par2, int par3)
+ {
+ super(par1, par2, par3);
+ }
+
+ @Override
+ public Potion setIconIndex(int par1, int par2)
+ {
+ super.setIconIndex(par1, par2);
+ return this;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionDrowning.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionDrowning.java
new file mode 100644
index 00000000..87558f26
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionDrowning.java
@@ -0,0 +1,18 @@
+package WayofTime.alchemicalWizardry.common.potion;
+
+import net.minecraft.potion.Potion;
+
+public class PotionDrowning extends Potion
+{
+ public PotionDrowning(int par1, boolean par2, int par3)
+ {
+ super(par1, par2, par3);
+ }
+
+ @Override
+ public Potion setIconIndex(int par1, int par2)
+ {
+ super.setIconIndex(par1, par2);
+ return this;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionFeatherFall.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionFeatherFall.java
new file mode 100644
index 00000000..0c35263b
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionFeatherFall.java
@@ -0,0 +1,18 @@
+package WayofTime.alchemicalWizardry.common.potion;
+
+import net.minecraft.potion.Potion;
+
+public class PotionFeatherFall extends Potion
+{
+ public PotionFeatherFall(int par1, boolean par2, int par3)
+ {
+ super(par1, par2, par3);
+ }
+
+ @Override
+ public Potion setIconIndex(int par1, int par2)
+ {
+ super.setIconIndex(par1, par2);
+ return this;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionFireFuse.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionFireFuse.java
new file mode 100644
index 00000000..8fe5d527
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionFireFuse.java
@@ -0,0 +1,18 @@
+package WayofTime.alchemicalWizardry.common.potion;
+
+import net.minecraft.potion.Potion;
+
+public class PotionFireFuse extends Potion
+{
+ public PotionFireFuse(int par1, boolean par2, int par3)
+ {
+ super(par1, par2, par3);
+ }
+
+ @Override
+ public Potion setIconIndex(int par1, int par2)
+ {
+ super.setIconIndex(par1, par2);
+ return this;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionFlameCloak.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionFlameCloak.java
new file mode 100644
index 00000000..b885d240
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionFlameCloak.java
@@ -0,0 +1,18 @@
+package WayofTime.alchemicalWizardry.common.potion;
+
+import net.minecraft.potion.Potion;
+
+public class PotionFlameCloak extends Potion
+{
+ public PotionFlameCloak(int par1, boolean par2, int par3)
+ {
+ super(par1, par2, par3);
+ }
+
+ @Override
+ public Potion setIconIndex(int par1, int par2)
+ {
+ super.setIconIndex(par1, par2);
+ return this;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionFlight.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionFlight.java
new file mode 100644
index 00000000..23e93e57
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionFlight.java
@@ -0,0 +1,18 @@
+package WayofTime.alchemicalWizardry.common.potion;
+
+import net.minecraft.potion.Potion;
+
+public class PotionFlight extends Potion
+{
+ public PotionFlight(int par1, boolean par2, int par3)
+ {
+ super(par1, par2, par3);
+ }
+
+ @Override
+ public Potion setIconIndex(int par1, int par2)
+ {
+ super.setIconIndex(par1, par2);
+ return this;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionHeavyHeart.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionHeavyHeart.java
new file mode 100644
index 00000000..952fb59c
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionHeavyHeart.java
@@ -0,0 +1,18 @@
+package WayofTime.alchemicalWizardry.common.potion;
+
+import net.minecraft.potion.Potion;
+
+public class PotionHeavyHeart extends Potion
+{
+ public PotionHeavyHeart(int par1, boolean par2, int par3)
+ {
+ super(par1, par2, par3);
+ }
+
+ @Override
+ public Potion setIconIndex(int par1, int par2)
+ {
+ super.setIconIndex(par1, par2);
+ return this;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionIceCloak.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionIceCloak.java
new file mode 100644
index 00000000..d169b4d9
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionIceCloak.java
@@ -0,0 +1,18 @@
+package WayofTime.alchemicalWizardry.common.potion;
+
+import net.minecraft.potion.Potion;
+
+public class PotionIceCloak extends Potion
+{
+ public PotionIceCloak(int par1, boolean par2, int par3)
+ {
+ super(par1, par2, par3);
+ }
+
+ @Override
+ public Potion setIconIndex(int par1, int par2)
+ {
+ super.setIconIndex(par1, par2);
+ return this;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionInhibit.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionInhibit.java
new file mode 100644
index 00000000..2214e105
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionInhibit.java
@@ -0,0 +1,18 @@
+package WayofTime.alchemicalWizardry.common.potion;
+
+import net.minecraft.potion.Potion;
+
+public class PotionInhibit extends Potion
+{
+ public PotionInhibit(int par1, boolean par2, int par3)
+ {
+ super(par1, par2, par3);
+ }
+
+ @Override
+ public Potion setIconIndex(int par1, int par2)
+ {
+ super.setIconIndex(par1, par2);
+ return this;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionPlanarBinding.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionPlanarBinding.java
new file mode 100644
index 00000000..54d6cd72
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionPlanarBinding.java
@@ -0,0 +1,18 @@
+package WayofTime.alchemicalWizardry.common.potion;
+
+import net.minecraft.potion.Potion;
+
+public class PotionPlanarBinding extends Potion
+{
+ public PotionPlanarBinding(int par1, boolean par2, int par3)
+ {
+ super(par1, par2, par3);
+ }
+
+ @Override
+ public Potion setIconIndex(int par1, int par2)
+ {
+ super.setIconIndex(par1, par2);
+ return this;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionProjectileProtect.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionProjectileProtect.java
new file mode 100644
index 00000000..317edd54
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionProjectileProtect.java
@@ -0,0 +1,18 @@
+package WayofTime.alchemicalWizardry.common.potion;
+
+import net.minecraft.potion.Potion;
+
+public class PotionProjectileProtect extends Potion
+{
+ public PotionProjectileProtect(int par1, boolean par2, int par3)
+ {
+ super(par1, par2, par3);
+ }
+
+ @Override
+ public Potion setIconIndex(int par1, int par2)
+ {
+ super.setIconIndex(par1, par2);
+ return this;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionReciprocation.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionReciprocation.java
new file mode 100644
index 00000000..ddceed0b
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionReciprocation.java
@@ -0,0 +1,18 @@
+package WayofTime.alchemicalWizardry.common.potion;
+
+import net.minecraft.potion.Potion;
+
+public class PotionReciprocation extends Potion
+{
+ public PotionReciprocation(int par1, boolean par2, int par3)
+ {
+ super(par1, par2, par3);
+ }
+
+ @Override
+ public Potion setIconIndex(int par1, int par2)
+ {
+ super.setIconIndex(par1, par2);
+ return this;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionSoulFray.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionSoulFray.java
new file mode 100644
index 00000000..78febaff
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionSoulFray.java
@@ -0,0 +1,18 @@
+package WayofTime.alchemicalWizardry.common.potion;
+
+import net.minecraft.potion.Potion;
+
+public class PotionSoulFray extends Potion
+{
+ public PotionSoulFray(int par1, boolean par2, int par3)
+ {
+ super(par1, par2, par3);
+ }
+
+ @Override
+ public Potion setIconIndex(int par1, int par2)
+ {
+ super.setIconIndex(par1, par2);
+ return this;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionSoulHarden.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionSoulHarden.java
new file mode 100644
index 00000000..0ac24694
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/potion/PotionSoulHarden.java
@@ -0,0 +1,18 @@
+package WayofTime.alchemicalWizardry.common.potion;
+
+import net.minecraft.potion.Potion;
+
+public class PotionSoulHarden extends Potion
+{
+ public PotionSoulHarden(int par1, boolean par2, int par3)
+ {
+ super(par1, par2, par3);
+ }
+
+ @Override
+ public Potion setIconIndex(int par1, int par2)
+ {
+ super.setIconIndex(par1, par2);
+ return this;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/AlchemyCircleRenderer.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/AlchemyCircleRenderer.java
new file mode 100644
index 00000000..eeae462b
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/AlchemyCircleRenderer.java
@@ -0,0 +1,92 @@
+package WayofTime.alchemicalWizardry.common.renderer;
+
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.util.MathHelper;
+import net.minecraft.util.ResourceLocation;
+
+import org.lwjgl.opengl.GL11;
+
+import WayofTime.alchemicalWizardry.common.tileEntity.TEMasterStone;
+
+public class AlchemyCircleRenderer extends MRSRenderer
+{
+ private ResourceLocation resourceLocation = new ResourceLocation("alchemicalwizardry:textures/models/TransCircle.png");
+ private int colourRed;
+ private int colourGreen;
+ private int colourBlue;
+ private int colourIntensity;
+ private double xOffset;
+ private double yOffset;
+ private double zOffset;
+ private double radius;
+ private double initialY;
+ private boolean renderWithoutReagents;
+
+ public AlchemyCircleRenderer(ResourceLocation resource, int red, int green, int blue, int intensity, double xOff, double initialY, double yOff, double zOff, double radius, boolean renderWithoutReagents)
+ {
+ this.resourceLocation = resource;
+ this.colourRed = red;
+ this.colourGreen = green;
+ this.colourBlue = blue;
+ this.colourIntensity = intensity;
+ this.xOffset = xOff;
+ this.initialY = initialY;
+ this.yOffset = yOff;
+ this.zOffset = zOff;
+ this.radius = radius;
+ this.renderWithoutReagents = renderWithoutReagents;
+ }
+
+ @Override
+ public void renderAt(TEMasterStone tile, double x, double y, double z)
+ {
+ if(tile.areTanksEmpty() && !renderWithoutReagents)
+ {
+ return;
+ }
+
+ GL11.glPushMatrix();
+ float f1 = 1.0f;
+ Tessellator tessellator = Tessellator.instance;
+ this.bindTexture(resourceLocation);
+ GL11.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, 10497.0F);
+ GL11.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, 10497.0F);
+ GL11.glDisable(GL11.GL_LIGHTING);
+ GL11.glDisable(GL11.GL_CULL_FACE);
+ float f2 = 0;
+ float f3 = -f2 * 0.2F - (float)MathHelper.floor_float(-f2 * 0.1F);
+ GL11.glEnable(GL11.GL_BLEND);
+ GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+
+ GL11.glDepthMask(false);
+
+ tessellator.startDrawingQuads();
+ tessellator.setColorRGBA(colourRed, colourGreen, colourBlue, colourIntensity);
+
+ GL11.glTranslated(x+0.5+xOffset, y+0.5+(yOffset-initialY)*(tile.runningTime/100d)+initialY, z+0.5+zOffset);
+
+ float rotationAngle = (float) (720.0 * (System.currentTimeMillis() & 0x3FFFL) / 0x3FFFL);
+
+ GL11.glRotatef(rotationAngle, 0F, 1F, 0F); //Rotate on planar axis
+ //GL11.glRotatef(30F, 0F, 0F, 1F); //Rotate vertical axis
+ //GL11.glRotatef(tileAltar.getWorldObj().getWorldTime()*2f, 1F, 0F, 0F); //Rotate cylindrically
+
+ tessellator.setBrightness(240);
+
+ double finalRadius = (radius)*(tile.runningTime/100d);
+
+ tessellator.addVertexWithUV(-finalRadius, 0, -finalRadius, 0.0d, 0.0d);
+ tessellator.addVertexWithUV(finalRadius, 0, -finalRadius, 1.0d, 0.0d);
+ tessellator.addVertexWithUV(finalRadius, 0, finalRadius, 1.0d, 1.0d);
+ tessellator.addVertexWithUV(-finalRadius, 0, finalRadius, 0.0d, 1.0d);
+
+ tessellator.draw();
+
+ GL11.glDepthMask(true);
+
+ GL11.glEnable(GL11.GL_LIGHTING);
+ GL11.glEnable(GL11.GL_TEXTURE_2D);
+ GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
+ GL11.glPopMatrix();
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/BeamRenderer.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/BeamRenderer.java
new file mode 100644
index 00000000..01f6d125
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/BeamRenderer.java
@@ -0,0 +1,155 @@
+package WayofTime.alchemicalWizardry.common.renderer;
+
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.texture.TextureManager;
+import net.minecraft.client.renderer.tileentity.TileEntityRendererDispatcher;
+import net.minecraft.util.MathHelper;
+import net.minecraft.util.ResourceLocation;
+
+import org.lwjgl.opengl.GL11;
+
+import WayofTime.alchemicalWizardry.api.ColourAndCoords;
+
+public class BeamRenderer
+{
+ private static final ResourceLocation field_110629_a = new ResourceLocation("textures/entity/beacon_beam.png");
+
+ public int xInit;
+ public int yInit;
+ public int zInit;
+
+ public int xFinal;
+ public int yFinal;
+ public int zFinal;
+
+ public int colourRed;
+ public int colourGreen;
+ public int colourBlue;
+ public int colourIntensity;
+
+ public double size;
+
+ public void setInitialPosition(int x, int y, int z)
+ {
+ this.xInit = x;
+ this.yInit = y;
+ this.zInit = z;
+ }
+
+ public void setColourAndFinalPosition(ColourAndCoords col)
+ {
+ this.colourRed = col.colourRed;
+ this.colourGreen = col.colourGreen;
+ this.colourBlue = col.colourBlue;
+ this.colourIntensity = col.colourIntensity;
+
+ this.xFinal = col.xCoord;
+ this.yFinal = col.yCoord;
+ this.zFinal = col.zCoord;
+ }
+
+ public void setSize(double size)
+ {
+ this.size = size;
+ }
+
+ protected static void bindTexture(ResourceLocation p_147499_1_)
+ {
+ TextureManager texturemanager = TileEntityRendererDispatcher.instance.field_147553_e;
+
+ if (texturemanager != null)
+ {
+ texturemanager.bindTexture(p_147499_1_);
+ }
+ }
+
+ public void render(double d0, double d1, double d2)
+ {
+ int xDiff = this.xFinal - this.xInit;
+ int yDiff = this.yFinal - this.yInit;
+ int zDiff = this.zFinal - this.zInit;
+
+ float planarAngle = (float)(Math.atan2(-zDiff, xDiff) * 180d / Math.PI); //Radians
+ float verticalAngle = (float)(Math.atan2(yDiff, Math.sqrt(xDiff*xDiff + zDiff+zDiff)) * 180d / Math.PI);
+
+ float distance = (float) Math.sqrt(xDiff*xDiff + yDiff*yDiff + zDiff*zDiff); //Total distance
+
+ GL11.glPushMatrix();
+ float f1 = 1.0f;
+ Tessellator tessellator = Tessellator.instance;
+ BeamRenderer.bindTexture(field_110629_a);
+ GL11.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, 10497.0F);
+ GL11.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, 10497.0F);
+ GL11.glDisable(GL11.GL_LIGHTING);
+ GL11.glDisable(GL11.GL_CULL_FACE);
+ float f2 = 0;
+ float f3 = -f2 * 0.2F - (float)MathHelper.floor_float(-f2 * 0.1F);
+ GL11.glEnable(GL11.GL_BLEND);
+ GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+
+
+ GL11.glDepthMask(false);
+
+ tessellator.startDrawingQuads();
+ tessellator.setColorRGBA(colourRed, colourGreen, colourBlue, colourIntensity);
+ //tessellator.setColorOpaque(255, 255, 255);
+
+ double inside = -(this.size/2d);
+ double outside = 1.0d-(0.50d - this.size/2d)-0.5d;
+
+ double d18 = inside;
+ double d19 = inside;
+ double d20 = outside;
+ double d21 = inside;
+ double d22 = inside;
+ double d23 = outside;
+ double d24 = outside;
+ double d25 = outside;
+ double d26 = (double)(distance * f1);// + 0.2;
+ double d27 = 0.0D;
+ double d28 = 1.0D;
+ double d29 = (double)(-1.0F + f3);
+ double d30 = (double)(distance * f1) + d29;
+
+ GL11.glTranslated(d0+0.5, d1+0.5, d2+0.5);
+
+ GL11.glRotatef(planarAngle, 0F, 1F, 0F); //Rotate on planar axis
+ GL11.glRotatef(verticalAngle, 0F, 0F, 1F); //Rotate vertical axis
+ //GL11.glRotatef(tileAltar.getWorldObj().getWorldTime()*2f, 1F, 0F, 0F); //Rotate cylindrically
+
+ double offset = 0;
+
+ tessellator.setBrightness(240);
+ float s = 1F / 16F;
+// GL11.glTranslatef(0F, s, s);
+// GL11.glScalef(1F, s * 14F, s * 14F);
+ tessellator.addVertexWithUV(d26, d18, d19, d28, d30);
+ tessellator.addVertexWithUV(offset, d18, d19, d28, d29);
+ tessellator.addVertexWithUV(offset, d20, d21, d27, d29);
+ tessellator.addVertexWithUV(d26, d20, d21, d27, d30);
+ tessellator.addVertexWithUV(d26, d24, d25, d28, d30);
+ tessellator.addVertexWithUV(offset, d24, d25, d28, d29);
+ tessellator.addVertexWithUV(offset, d22, d23, d27, d29);
+ tessellator.addVertexWithUV(d26, d22, d23, d27, d30);
+ tessellator.addVertexWithUV(d26, d20, d21, d28, d30);
+ tessellator.addVertexWithUV(offset, d20, d21, d28, d29);
+ tessellator.addVertexWithUV(offset, d24, d25, d27, d29);
+ tessellator.addVertexWithUV(d26, d24, d25, d27, d30);
+ tessellator.addVertexWithUV(d26, d22, d23, d28, d30);
+ tessellator.addVertexWithUV(offset, d22, d23, d28, d29);
+ tessellator.addVertexWithUV(offset, d18, d19, d27, d29);
+ tessellator.addVertexWithUV(d26, d18, d19, d27, d30);
+
+ //ShaderHelper.useShaderWithProps(ShaderHelper.beam, "time", (int) tileAltar.getWorldObj().getTotalWorldTime());
+ tessellator.draw();
+ //ShaderHelper.releaseShader();
+
+ GL11.glDepthMask(true);
+
+
+ GL11.glEnable(GL11.GL_LIGHTING);
+ GL11.glEnable(GL11.GL_TEXTURE_2D);
+ GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
+ GL11.glPopMatrix();
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/MRSRenderer.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/MRSRenderer.java
new file mode 100644
index 00000000..4bf6de31
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/MRSRenderer.java
@@ -0,0 +1,22 @@
+package WayofTime.alchemicalWizardry.common.renderer;
+
+import net.minecraft.client.renderer.texture.TextureManager;
+import net.minecraft.client.renderer.tileentity.TileEntityRendererDispatcher;
+import net.minecraft.util.ResourceLocation;
+import WayofTime.alchemicalWizardry.common.renderer.block.RenderMasterStone;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEMasterStone;
+
+public abstract class MRSRenderer
+{
+ public abstract void renderAt(TEMasterStone tile, double x, double y, double z);
+
+ protected void bindTexture(ResourceLocation p_147499_1_)
+ {
+ TextureManager texturemanager = TileEntityRendererDispatcher.instance.field_147553_e;
+
+ if (texturemanager != null)
+ {
+ texturemanager.bindTexture(p_147499_1_);
+ }
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderAlchemicCalcinator.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderAlchemicCalcinator.java
new file mode 100644
index 00000000..59c70a85
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderAlchemicCalcinator.java
@@ -0,0 +1,485 @@
+package WayofTime.alchemicalWizardry.common.renderer.block;
+
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.entity.RenderItem;
+import net.minecraft.client.renderer.entity.RenderManager;
+import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.MathHelper;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import org.lwjgl.opengl.GL11;
+
+import WayofTime.alchemicalWizardry.api.alchemy.energy.Reagent;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentContainerInfo;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentStack;
+import WayofTime.alchemicalWizardry.common.renderer.model.ModelAlchemicalCalcinator;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEAlchemicCalcinator;
+import cpw.mods.fml.client.FMLClientHandler;
+
+public class RenderAlchemicCalcinator extends TileEntitySpecialRenderer
+{
+ private final RenderItem customRenderItem;
+ private ModelAlchemicalCalcinator modelConduit = new ModelAlchemicalCalcinator();
+
+ private ResourceLocation resourceLocation = new ResourceLocation("alchemicalwizardry:textures/models/Reagent.png");
+
+ public RenderAlchemicCalcinator()
+ {
+ customRenderItem = new RenderItem()
+ {
+ @Override
+ public boolean shouldBob()
+ {
+ return false;
+ }
+ };
+ customRenderItem.setRenderManager(RenderManager.instance);
+ }
+
+ @Override
+ public void renderTileEntityAt(TileEntity tileEntity, double d0, double d1, double d2, float f)
+ {
+ if (tileEntity instanceof TEAlchemicCalcinator)
+ {
+ TEAlchemicCalcinator tileAltar = (TEAlchemicCalcinator) tileEntity;
+
+ GL11.glDisable(GL11.GL_LIGHTING);
+// GL11.glDisable(GL11.GL_CULL_FACE);
+ /**
+ * Render the ghost item inside of the Altar, slowly spinning
+ */
+ GL11.glPushMatrix();
+ GL11.glTranslatef((float) d0 + 0.5F, (float) d1 + 1.5F, (float) d2 + 0.5F);
+ ResourceLocation test = new ResourceLocation("alchemicalwizardry:textures/models/AlchemicalCalcinator.png");
+ FMLClientHandler.instance().getClient().renderEngine.bindTexture(test);
+ GL11.glPushMatrix();
+ GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
+ //GL11.glRotatef(90F, 0.0F, 0.0F, 1.0F);
+ //A reference to your Model file. Again, very important.
+ this.modelConduit.render((Entity) null, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0625F);
+ //Tell it to stop rendering for both the PushMatrix's
+ GL11.glPopMatrix();
+ GL11.glPopMatrix();
+// GL11.glEnable(GL11.GL_CULL_FACE);
+ GL11.glEnable(GL11.GL_LIGHTING);
+
+ GL11.glPushMatrix();
+
+ if (tileAltar.getStackInSlot(1) != null)
+ {
+ float scaleFactor = getGhostItemScaleFactor(tileAltar.getStackInSlot(1));
+ EntityItem ghostEntityItem = new EntityItem(tileAltar.getWorldObj());
+ ghostEntityItem.hoverStart = 0.0F;
+ ghostEntityItem.setEntityItemStack(tileAltar.getStackInSlot(1));
+ //translateGhostItemByOrientation(ghostEntityItem.getEntityItem(), d0, d1, d2, ForgeDirection.DOWN);
+ float displacement = 0.2F;
+
+ if (ghostEntityItem.getEntityItem().getItem() instanceof ItemBlock)
+ {
+ GL11.glTranslatef((float) d0 + 0.5F, (float) d1 + displacement + 0.7F, (float) d2 + 0.5F);
+ } else
+ {
+ GL11.glTranslatef((float) d0 + 0.5F, (float) d1 + displacement + 10.4f / 16.0f, (float) d2 + 0.5F - 0.0625f*2f);
+ }
+
+ //GL11.glTranslatef((float) tileAltar.xCoord + 0.5F, (float) tileAltar.yCoord + 2.7F, (float) tileAltar.zCoord + 0.5F);
+ GL11.glScalef(scaleFactor, scaleFactor, scaleFactor);
+
+ if (!(ghostEntityItem.getEntityItem().getItem() instanceof ItemBlock))
+ {
+ GL11.glRotatef(90f, 1.0f, 0.0f, 0.0F);
+ }
+
+ customRenderItem.doRender(ghostEntityItem, 0, 0, 0, 0, 0);
+ }
+
+
+ GL11.glPopMatrix();
+ GL11.glPushMatrix();
+
+ if (tileAltar.getStackInSlot(0) != null)
+ {
+ float scaleFactor = getGhostItemScaleFactor(tileAltar.getStackInSlot(0));
+ EntityItem ghostEntityItem = new EntityItem(tileAltar.getWorldObj());
+ ghostEntityItem.hoverStart = 0.0F;
+ ghostEntityItem.setEntityItemStack(tileAltar.getStackInSlot(0));
+ //translateGhostItemByOrientation(ghostEntityItem.getEntityItem(), d0, d1, d2, ForgeDirection.DOWN);
+ float displacement = -0.5F;
+
+ if (ghostEntityItem.getEntityItem().getItem() instanceof ItemBlock)
+ {
+ GL11.glTranslatef((float) d0 + 0.5F, (float) d1 + displacement + 0.7F, (float) d2 + 0.5F);
+ } else
+ {
+ GL11.glTranslatef((float) d0 + 0.5F, (float) d1 + displacement + 10.4f / 16.0f, (float) d2 + 0.5F - 0.0625f*2f);
+ }
+
+ //GL11.glTranslatef((float) tileAltar.xCoord + 0.5F, (float) tileAltar.yCoord + 2.7F, (float) tileAltar.zCoord + 0.5F);
+ GL11.glScalef(scaleFactor, scaleFactor, scaleFactor);
+
+ if (!(ghostEntityItem.getEntityItem().getItem() instanceof ItemBlock))
+ {
+ GL11.glRotatef(90f, 1.0f, 0.0f, 0.0F);
+ }
+
+ customRenderItem.doRender(ghostEntityItem, 0, 0, 0, 0, 0);
+ }
+
+ GL11.glPopMatrix();
+
+
+ ReagentContainerInfo[] info = tileAltar.getContainerInfo(ForgeDirection.UNKNOWN);
+ if(info.length >= 1 && info[0] != null)
+ {
+ ReagentStack reagentStack = info[0].reagent;
+ int capacity = info[0].capacity;
+ if(reagentStack != null && reagentStack.reagent != null)
+ {
+ Reagent reagent = reagentStack.reagent;
+ this.renderTankContents(d0, d1, d2, reagent.getColourRed(), reagent.getColourGreen(), reagent.getColourBlue(), 200 * reagentStack.amount / capacity);
+ }
+ }
+
+
+
+// for (int i = 0; i <= 1; i++)
+// {
+// GL11.glPushMatrix();
+//
+// if (tileAltar.getStackInSlot(i) != null)
+// {
+// float scaleFactor = getGhostItemScaleFactor(tileAltar.getStackInSlot(i));
+// float rotationAngle = (float) (720.0 * (System.currentTimeMillis() & 0x3FFFL) / 0x3FFFL);
+// EntityItem ghostEntityItem = new EntityItem(tileAltar.getWorldObj());
+// ghostEntityItem.hoverStart = 0.0F;
+// ghostEntityItem.setEntityItemStack(tileAltar.getStackInSlot(i));
+// //translateGhostItemByOrientation(ghostEntityItem.getEntityItem(), d0, d1, d2, ForgeDirection.DOWN);
+// float displacementX = getXDisplacementForSlot(i);
+// float displacementY = getYDisplacementForSlot(i);
+// float displacementZ = getZDisplacementForSlot(i);
+//
+// if (ghostEntityItem.getEntityItem().getItem() instanceof ItemBlock)
+// {
+// GL11.glTranslatef((float) d0 + 0.5F + displacementX, (float) d1 + displacementY + 0.7F, (float) d2 + 0.5F + displacementZ);
+// } else
+// {
+// GL11.glTranslatef((float) d0 + 0.5F + displacementX, (float) d1 + displacementY + 0.6F, (float) d2 + 0.5F + displacementZ);
+// }
+//
+// //GL11.glTranslatef((float) tileAltar.xCoord + 0.5F, (float) tileAltar.yCoord + 2.7F, (float) tileAltar.zCoord + 0.5F);
+// GL11.glScalef(scaleFactor, scaleFactor, scaleFactor);
+// GL11.glRotatef(rotationAngle, 0.0F, 1.0F, 0.0F);
+// customRenderItem.doRender(ghostEntityItem, 0, 0, 0, 0, 0);
+// }
+//
+// GL11.glPopMatrix();
+// }
+
+ GL11.glEnable(GL11.GL_CULL_FACE);
+ GL11.glEnable(GL11.GL_LIGHTING);
+ }
+ }
+
+ private void renderTankContents(double x, double y, double z, int colourRed, int colourGreen, int colourBlue, int colourIntensity)
+ {
+ GL11.glPushMatrix();
+ float f1 = 1.0f;
+ Tessellator tessellator = Tessellator.instance;
+ this.bindTexture(resourceLocation);
+ GL11.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, 10497.0F);
+ GL11.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, 10497.0F);
+ GL11.glDisable(GL11.GL_LIGHTING);
+ GL11.glDisable(GL11.GL_CULL_FACE);
+ float f2 = 0;
+ float f3 = -f2 * 0.2F - (float)MathHelper.floor_float(-f2 * 0.1F);
+ GL11.glEnable(GL11.GL_BLEND);
+ GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+
+ GL11.glDepthMask(false);
+
+ tessellator.startDrawingQuads();
+ tessellator.setColorRGBA(colourRed, colourGreen, colourBlue, colourIntensity);
+
+ GL11.glTranslated(x+0.5, y+0.5, z+0.5);
+ //GL11.glRotatef(30F, 0F, 0F, 1F); //Rotate vertical axis
+ //GL11.glRotatef(tileAltar.getWorldObj().getWorldTime()*2f, 1F, 0F, 0F); //Rotate cylindrically
+
+ tessellator.setBrightness(240);
+
+ double x1 = -7d/16d;
+ double x2 = 7d/16d;
+ double y1 = 1d/16d;
+ double y2 = 5d/16d;
+ double z1 = -7d/16d;
+ double z2 = 7d/16d;
+
+ double resx1 = 0.0d;
+ double resx2 = 0.0d;
+ double resy1 = 1.0d;
+ double resy2 = 1.0d;
+
+ tessellator.addVertexWithUV(x1, y1, z1, resx1, resy1);
+ tessellator.addVertexWithUV(x2, y1, z1, resx2, resy1);
+ tessellator.addVertexWithUV(x2, y2, z1, resx2, resy2);
+ tessellator.addVertexWithUV(x1, y2, z1, resx1, resy2);
+ tessellator.addVertexWithUV(x1, y1, z1, resx1, resy1);
+ tessellator.addVertexWithUV(x1, y1, z2, resx2, resy1);
+ tessellator.addVertexWithUV(x1, y2, z2, resx2, resy2);
+ tessellator.addVertexWithUV(x1, y2, z1, resx1, resy2);
+ tessellator.addVertexWithUV(x1, y1, z2, resx1, resy1);
+ tessellator.addVertexWithUV(x2, y1, z2, resx2, resy1);
+ tessellator.addVertexWithUV(x2, y2, z2, resx2, resy2);
+ tessellator.addVertexWithUV(x1, y2, z2, resx1, resy2);
+ tessellator.addVertexWithUV(x2, y1, z1, resx1, resy1);
+ tessellator.addVertexWithUV(x2, y1, z2, resx2, resy1);
+ tessellator.addVertexWithUV(x2, y2, z2, resx2, resy2);
+ tessellator.addVertexWithUV(x2, y2, z1, resx1, resy2);
+ tessellator.draw();
+
+ GL11.glDepthMask(true);
+
+ GL11.glEnable(GL11.GL_LIGHTING);
+ GL11.glEnable(GL11.GL_TEXTURE_2D);
+ GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
+ GL11.glPopMatrix();
+ }
+
+ private float getGhostItemScaleFactor(ItemStack itemStack)
+ {
+ float scaleFactor = 1.5F;
+
+ if (itemStack != null)
+ {
+ if (itemStack.getItem() instanceof ItemBlock)
+ {
+ switch (customRenderItem.getMiniBlockCount(itemStack,(byte)1))
+ {
+ case 1:
+ return 0.90F * scaleFactor;
+
+ case 2:
+ return 0.90F * scaleFactor;
+
+ case 3:
+ return 0.90F * scaleFactor;
+
+ case 4:
+ return 0.90F * scaleFactor;
+
+ case 5:
+ return 0.80F * scaleFactor;
+
+ default:
+ return 0.90F * scaleFactor;
+ }
+ } else
+ {
+ switch (customRenderItem.getMiniItemCount(itemStack,(byte)1))
+ {
+ case 1:
+ return 0.65F * scaleFactor;
+
+ case 2:
+ return 0.65F * scaleFactor;
+
+ case 3:
+ return 0.65F * scaleFactor;
+
+ case 4:
+ return 0.65F * scaleFactor;
+
+ default:
+ return 0.65F * scaleFactor;
+ }
+ }
+ }
+
+ return scaleFactor;
+ }
+
+ private float getXDisplacementForSlot(int slot)
+ {
+ switch (slot)
+ {
+ case 0:
+ return 0.0f;
+
+ case 1:
+ return -0.375f;
+
+ case 2:
+ return -0.125f;
+
+ case 3:
+ return 0.3125f;
+
+ case 4:
+ return 0.3125f;
+
+ case 5:
+ return -0.125f;
+
+ default:
+ return 0.0f;
+ }
+ }
+
+ private float getYDisplacementForSlot(int slot)
+ {
+ switch (slot)
+ {
+ case 0:
+ return 0.4f;
+
+ case 1:
+ return -0.35f;
+
+ case 6:
+ return 0.4f;
+
+ default:
+ return -0.35f;
+ }
+ }
+
+ private float getZDisplacementForSlot(int slot)
+ {
+ switch (slot)
+ {
+ case 0:
+ return 0.0f;
+
+ case 1:
+ return 0.0f;
+
+ case 2:
+ return 0.375f;
+
+ case 3:
+ return 0.25f;
+
+ case 4:
+ return -0.25f;
+
+ case 5:
+ return -0.375f;
+
+ default:
+ return 0.0f;
+ }
+ }
+
+ private void translateGhostItemByOrientation(ItemStack ghostItemStack, double x, double y, double z, ForgeDirection forgeDirection)
+ {
+ if (ghostItemStack != null)
+ {
+ if (ghostItemStack.getItem() instanceof ItemBlock)
+ {
+ switch (forgeDirection)
+ {
+ case DOWN:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 2.7F, (float) z + 0.5F);
+ return;
+ }
+
+ case UP:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.25F, (float) z + 0.5F);
+ return;
+ }
+
+ case NORTH:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.5F, (float) z + 0.7F);
+ return;
+ }
+
+ case SOUTH:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.5F, (float) z + 0.3F);
+ return;
+ }
+
+ case EAST:
+ {
+ GL11.glTranslatef((float) x + 0.3F, (float) y + 0.5F, (float) z + 0.5F);
+ return;
+ }
+
+ case WEST:
+ {
+ GL11.glTranslatef((float) x + 0.70F, (float) y + 0.5F, (float) z + 0.5F);
+ return;
+ }
+
+ case UNKNOWN:
+ {
+ return;
+ }
+
+ default:
+ {
+ return;
+ }
+ }
+ } else
+ {
+ switch (forgeDirection)
+ {
+ case DOWN:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.6F, (float) z + 0.5F);
+ return;
+ }
+
+ case UP:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.20F, (float) z + 0.5F);
+ return;
+ }
+
+ case NORTH:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.4F, (float) z + 0.7F);
+ return;
+ }
+
+ case SOUTH:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.4F, (float) z + 0.3F);
+ return;
+ }
+
+ case EAST:
+ {
+ GL11.glTranslatef((float) x + 0.3F, (float) y + 0.4F, (float) z + 0.5F);
+ return;
+ }
+
+ case WEST:
+ {
+ GL11.glTranslatef((float) x + 0.70F, (float) y + 0.4F, (float) z + 0.5F);
+ return;
+ }
+
+ case UNKNOWN:
+ {
+ return;
+ }
+
+ default:
+ {
+ return;
+ }
+ }
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderConduit.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderConduit.java
new file mode 100644
index 00000000..6c93e00e
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderConduit.java
@@ -0,0 +1,43 @@
+package WayofTime.alchemicalWizardry.common.renderer.block;
+
+import WayofTime.alchemicalWizardry.common.renderer.model.ModelConduit;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEConduit;
+import cpw.mods.fml.client.FMLClientHandler;
+import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
+import net.minecraft.entity.Entity;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ResourceLocation;
+import org.lwjgl.opengl.GL11;
+
+public class RenderConduit extends TileEntitySpecialRenderer
+{
+ private ModelConduit modelConduit = new ModelConduit();
+
+ @Override
+ public void renderTileEntityAt(TileEntity tileEntity, double d0, double d1, double d2, float f)
+ {
+ if (tileEntity instanceof TEConduit)
+ {
+ TEConduit tileConduit = (TEConduit) tileEntity;
+ GL11.glDisable(GL11.GL_LIGHTING);
+ GL11.glDisable(GL11.GL_CULL_FACE);
+ /**
+ * Render the ghost item inside of the Altar, slowly spinning
+ */
+ GL11.glPushMatrix();
+ GL11.glTranslatef((float) d0 + 0.5F, (float) d1 + 1.5F, (float) d2 + 0.5F);
+ ResourceLocation test = new ResourceLocation("alchemicalwizardry:textures/models/Conduit.png");
+ FMLClientHandler.instance().getClient().renderEngine.bindTexture(test);
+ GL11.glPushMatrix();
+ GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
+ //GL11.glRotatef(90F, 0.0F, 0.0F, 1.0F);
+ //A reference to your Model file. Again, very important.
+ this.modelConduit.render((Entity) null, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0625F, tileConduit.getInputDirection(), tileConduit.getOutputDirection());
+ //Tell it to stop rendering for both the PushMatrix's
+ GL11.glPopMatrix();
+ GL11.glPopMatrix();
+ GL11.glEnable(GL11.GL_CULL_FACE);
+ GL11.glEnable(GL11.GL_LIGHTING);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderCrystalBelljar.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderCrystalBelljar.java
new file mode 100644
index 00000000..c5d0a372
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderCrystalBelljar.java
@@ -0,0 +1,184 @@
+package WayofTime.alchemicalWizardry.common.renderer.block;
+
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.MathHelper;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import org.lwjgl.opengl.GL11;
+
+import WayofTime.alchemicalWizardry.api.alchemy.energy.Reagent;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentContainerInfo;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentStack;
+import WayofTime.alchemicalWizardry.common.renderer.model.ModelAlchemicalCalcinator;
+import WayofTime.alchemicalWizardry.common.renderer.model.ModelCrystalBelljar;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEBellJar;
+import cpw.mods.fml.client.FMLClientHandler;
+
+public class RenderCrystalBelljar extends TileEntitySpecialRenderer
+{
+ private ModelCrystalBelljar modelConduit = new ModelCrystalBelljar();
+
+ private ResourceLocation resourceLocation = new ResourceLocation("alchemicalwizardry:textures/models/Reagent.png");
+
+
+ @Override
+ public void renderTileEntityAt(TileEntity tileEntity, double d0, double d1, double d2, float f)
+ {
+ if (tileEntity instanceof TEBellJar)
+ {
+ TEBellJar tileAltar = (TEBellJar) tileEntity;
+
+ GL11.glDisable(GL11.GL_LIGHTING);
+// GL11.glDisable(GL11.GL_CULL_FACE);
+ /**
+ * Render the ghost item inside of the Altar, slowly spinning
+ */
+ GL11.glPushMatrix();
+ GL11.glTranslatef((float) d0 + 0.5F, (float) d1 + 1.5F, (float) d2 + 0.5F);
+ ResourceLocation test = new ResourceLocation("alchemicalwizardry:textures/models/CrystalBelljar.png");
+ FMLClientHandler.instance().getClient().renderEngine.bindTexture(test);
+ GL11.glPushMatrix();
+ GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
+ //GL11.glRotatef(90F, 0.0F, 0.0F, 1.0F);
+ //A reference to your Model file. Again, very important.
+ this.modelConduit.render((Entity) null, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0625F);
+ //Tell it to stop rendering for both the PushMatrix's
+ GL11.glPopMatrix();
+ GL11.glPopMatrix();
+// GL11.glEnable(GL11.GL_CULL_FACE);
+ GL11.glEnable(GL11.GL_LIGHTING);
+
+
+
+
+ ReagentContainerInfo[] info = tileAltar.getContainerInfo(ForgeDirection.UNKNOWN);
+ if(info.length >= 1 && info[0] != null)
+ {
+ ReagentStack reagentStack = info[0].reagent;
+ int capacity = info[0].capacity;
+ if(reagentStack != null && reagentStack.reagent != null)
+ {
+ Reagent reagent = reagentStack.reagent;
+ this.renderTankContents(d0, d1, d2, reagent.getColourRed(), reagent.getColourGreen(), reagent.getColourBlue(), 200 * reagentStack.amount / capacity);
+ }
+ }
+
+// this.renderTankContents(d0, d1, d2, 255, 0, 0, 200);
+
+
+
+
+// for (int i = 0; i <= 1; i++)
+// {
+// GL11.glPushMatrix();
+//
+// if (tileAltar.getStackInSlot(i) != null)
+// {
+// float scaleFactor = getGhostItemScaleFactor(tileAltar.getStackInSlot(i));
+// float rotationAngle = (float) (720.0 * (System.currentTimeMillis() & 0x3FFFL) / 0x3FFFL);
+// EntityItem ghostEntityItem = new EntityItem(tileAltar.getWorldObj());
+// ghostEntityItem.hoverStart = 0.0F;
+// ghostEntityItem.setEntityItemStack(tileAltar.getStackInSlot(i));
+// //translateGhostItemByOrientation(ghostEntityItem.getEntityItem(), d0, d1, d2, ForgeDirection.DOWN);
+// float displacementX = getXDisplacementForSlot(i);
+// float displacementY = getYDisplacementForSlot(i);
+// float displacementZ = getZDisplacementForSlot(i);
+//
+// if (ghostEntityItem.getEntityItem().getItem() instanceof ItemBlock)
+// {
+// GL11.glTranslatef((float) d0 + 0.5F + displacementX, (float) d1 + displacementY + 0.7F, (float) d2 + 0.5F + displacementZ);
+// } else
+// {
+// GL11.glTranslatef((float) d0 + 0.5F + displacementX, (float) d1 + displacementY + 0.6F, (float) d2 + 0.5F + displacementZ);
+// }
+//
+// //GL11.glTranslatef((float) tileAltar.xCoord + 0.5F, (float) tileAltar.yCoord + 2.7F, (float) tileAltar.zCoord + 0.5F);
+// GL11.glScalef(scaleFactor, scaleFactor, scaleFactor);
+// GL11.glRotatef(rotationAngle, 0.0F, 1.0F, 0.0F);
+// customRenderItem.doRender(ghostEntityItem, 0, 0, 0, 0, 0);
+// }
+//
+// GL11.glPopMatrix();
+// }
+
+ GL11.glEnable(GL11.GL_CULL_FACE);
+ GL11.glEnable(GL11.GL_LIGHTING);
+ }
+ }
+
+ private void renderTankContents(double x, double y, double z, int colourRed, int colourGreen, int colourBlue, int colourIntensity)
+ {
+ GL11.glPushMatrix();
+ float f1 = 1.0f;
+ Tessellator tessellator = Tessellator.instance;
+ this.bindTexture(resourceLocation);
+ GL11.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, 10497.0F);
+ GL11.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, 10497.0F);
+ GL11.glDisable(GL11.GL_LIGHTING);
+ GL11.glDisable(GL11.GL_CULL_FACE);
+ float f2 = 0;
+ float f3 = -f2 * 0.2F - (float)MathHelper.floor_float(-f2 * 0.1F);
+ GL11.glEnable(GL11.GL_BLEND);
+ GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+
+ GL11.glDepthMask(false);
+
+ tessellator.startDrawingQuads();
+ tessellator.setColorRGBA(colourRed, colourGreen, colourBlue, colourIntensity);
+
+ GL11.glTranslated(x+0.5, y+0.5, z+0.5);
+ //GL11.glRotatef(30F, 0F, 0F, 1F); //Rotate vertical axis
+ //GL11.glRotatef(tileAltar.getWorldObj().getWorldTime()*2f, 1F, 0F, 0F); //Rotate cylindrically
+
+ tessellator.setBrightness(240);
+
+ double x1 = -4d/16d;
+ double x2 = 4d/16d;
+ double y1 = -6d/16d;
+ double y2 = 4d/16d;
+ double z1 = -4d/16d;
+ double z2 = 4d/16d;
+
+ double resx1 = 0.0d;
+ double resx2 = 0.0d;
+ double resy1 = 1.0d;
+ double resy2 = 1.0d;
+
+ tessellator.addVertexWithUV(x1, y1, z1, resx1, resy1);
+ tessellator.addVertexWithUV(x2, y1, z1, resx2, resy1);
+ tessellator.addVertexWithUV(x2, y2, z1, resx2, resy2);
+ tessellator.addVertexWithUV(x1, y2, z1, resx1, resy2);
+ tessellator.addVertexWithUV(x1, y1, z1, resx1, resy1);
+ tessellator.addVertexWithUV(x1, y1, z2, resx2, resy1);
+ tessellator.addVertexWithUV(x1, y2, z2, resx2, resy2);
+ tessellator.addVertexWithUV(x1, y2, z1, resx1, resy2);
+ tessellator.addVertexWithUV(x1, y1, z2, resx1, resy1);
+ tessellator.addVertexWithUV(x2, y1, z2, resx2, resy1);
+ tessellator.addVertexWithUV(x2, y2, z2, resx2, resy2);
+ tessellator.addVertexWithUV(x1, y2, z2, resx1, resy2);
+ tessellator.addVertexWithUV(x2, y1, z1, resx1, resy1);
+ tessellator.addVertexWithUV(x2, y1, z2, resx2, resy1);
+ tessellator.addVertexWithUV(x2, y2, z2, resx2, resy2);
+ tessellator.addVertexWithUV(x2, y2, z1, resx1, resy2);
+ tessellator.addVertexWithUV(x1, y2, z1, resx1, resy1);
+ tessellator.addVertexWithUV(x2, y2, z1, resx2, resy1);
+ tessellator.addVertexWithUV(x2, y2, z2, resx2, resy2);
+ tessellator.addVertexWithUV(x1, y2, z2, resx1, resy2);
+ tessellator.draw();
+
+ GL11.glDepthMask(true);
+
+ GL11.glEnable(GL11.GL_CULL_FACE);
+ GL11.glEnable(GL11.GL_LIGHTING);
+ GL11.glEnable(GL11.GL_TEXTURE_2D);
+ GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
+ GL11.glPopMatrix();
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderMasterStone.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderMasterStone.java
new file mode 100644
index 00000000..0a54d29d
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderMasterStone.java
@@ -0,0 +1,30 @@
+package WayofTime.alchemicalWizardry.common.renderer.block;
+
+import org.lwjgl.opengl.GL11;
+
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.MathHelper;
+import net.minecraft.util.ResourceLocation;
+import WayofTime.alchemicalWizardry.api.rituals.Rituals;
+import WayofTime.alchemicalWizardry.common.renderer.MRSRenderer;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEMasterStone;
+
+public class RenderMasterStone extends TileEntitySpecialRenderer
+{
+ @Override
+ public void renderTileEntityAt(TileEntity tileEntity, double d0, double d1, double d2, float f)
+ {
+ if (tileEntity instanceof TEMasterStone)
+ {
+ String str = ((TEMasterStone) tileEntity).getCurrentRitual();
+ MRSRenderer renderer = Rituals.getRendererForKey(str);
+
+ if(renderer != null)
+ {
+ renderer.renderAt(((TEMasterStone) tileEntity), d0, d1, d2);
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderPedestal.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderPedestal.java
new file mode 100644
index 00000000..47e63753
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderPedestal.java
@@ -0,0 +1,273 @@
+package WayofTime.alchemicalWizardry.common.renderer.block;
+
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.entity.RenderItem;
+import net.minecraft.client.renderer.entity.RenderManager;
+import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.MathHelper;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import org.lwjgl.opengl.GL11;
+
+import WayofTime.alchemicalWizardry.common.renderer.model.ModelPedestal;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEPedestal;
+import cpw.mods.fml.client.FMLClientHandler;
+
+public class RenderPedestal extends TileEntitySpecialRenderer
+{
+ private ModelPedestal modelPedestal = new ModelPedestal();
+ private final RenderItem customRenderItem;
+
+ public RenderPedestal()
+ {
+ customRenderItem = new RenderItem()
+ {
+ @Override
+ public boolean shouldBob()
+ {
+ return false;
+ }
+ };
+ customRenderItem.setRenderManager(RenderManager.instance);
+ }
+
+ @Override
+ public void renderTileEntityAt(TileEntity tileEntity, double d0, double d1, double d2, float f)
+ {
+ if (tileEntity instanceof TEPedestal)
+ {
+ TEPedestal tileAltar = (TEPedestal) tileEntity;
+ GL11.glDisable(GL11.GL_LIGHTING);
+// GL11.glDisable(GL11.GL_CULL_FACE);
+ /**
+ * Render the ghost item inside of the Altar, slowly spinning
+ */
+ GL11.glPushMatrix();
+ GL11.glTranslatef((float) d0 + 0.5F, (float) d1 + 1.5F, (float) d2 + 0.5F);
+ ResourceLocation test = new ResourceLocation("alchemicalwizardry:textures/models/Pedestal.png");
+ FMLClientHandler.instance().getClient().renderEngine.bindTexture(test);
+ GL11.glPushMatrix();
+ GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
+ //A reference to your Model file. Again, very important.
+ this.modelPedestal.render((Entity) null, 0.0F, 0.0F, -0.1F, 0.0F, 0.0F, 0.0625F);
+ //Tell it to stop rendering for both the PushMatrix's
+ GL11.glPopMatrix();
+ GL11.glPopMatrix();
+ GL11.glPushMatrix();
+
+ if (tileAltar.getStackInSlot(0) != null)
+ {
+ float scaleFactor = getGhostItemScaleFactor(tileAltar.getStackInSlot(0));
+ float rotationAngle = (float) (720.0 * (System.currentTimeMillis() & 0x3FFFL) / 0x3FFFL);
+ EntityItem ghostEntityItem = new EntityItem(tileAltar.getWorldObj());
+ ghostEntityItem.hoverStart = 0.0F;
+ ghostEntityItem.setEntityItemStack(tileAltar.getStackInSlot(0));
+ //translateGhostItemByOrientation(ghostEntityItem.getEntityItem(), d0, d1, d2, ForgeDirection.DOWN);
+ float displacement = 0.2F;
+
+ if (ghostEntityItem.getEntityItem().getItem() instanceof ItemBlock)
+ {
+ GL11.glTranslatef((float) d0 + 0.5F, (float) d1 + displacement + 0.7F, (float) d2 + 0.5F);
+ } else
+ {
+ GL11.glTranslatef((float) d0 + 0.5F, (float) d1 + displacement + 0.6F, (float) d2 + 0.5F);
+ }
+
+ //GL11.glTranslatef((float) tileAltar.xCoord + 0.5F, (float) tileAltar.yCoord + 2.7F, (float) tileAltar.zCoord + 0.5F);
+ GL11.glScalef(scaleFactor, scaleFactor, scaleFactor);
+ GL11.glRotatef(rotationAngle, 0.0F, 1.0F, 0.0F);
+ customRenderItem.doRender(ghostEntityItem, 0, 0, 0, 0, 0);
+ }
+
+ GL11.glPopMatrix();
+ GL11.glEnable(GL11.GL_CULL_FACE);
+ GL11.glEnable(GL11.GL_LIGHTING);
+
+
+ GL11.glPushMatrix();
+ GL11.glDisable(GL11.GL_LIGHTING);
+// GL11.glDisable(GL11.GL_CULL_FACE);
+ GL11.glTranslatef((float) d0 + 0.5F, (float) d1 + 1.5F, (float) d2 + 0.5F);
+
+ FMLClientHandler.instance().getClient().renderEngine.bindTexture(test);
+ GL11.glPushMatrix();
+ GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
+// this.modelInputMirror.render((Entity) null, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0625F, tileSpellBlock.getInputDirection(), tileSpellBlock.getOutputDirection());
+ GL11.glPopMatrix();
+
+ GL11.glEnable(GL11.GL_CULL_FACE);
+ GL11.glEnable(GL11.GL_LIGHTING);
+ GL11.glPopMatrix();
+
+
+
+ }
+ }
+
+ private float getGhostItemScaleFactor(ItemStack itemStack)
+ {
+ float scaleFactor = 1.0F;
+
+ if (itemStack != null)
+ {
+ if (itemStack.getItem() instanceof ItemBlock)
+ {
+ switch (customRenderItem.getMiniBlockCount(itemStack,(byte)1))
+ {
+ case 1:
+ return 0.90F;
+
+ case 2:
+ return 0.90F;
+
+ case 3:
+ return 0.90F;
+
+ case 4:
+ return 0.90F;
+
+ case 5:
+ return 0.80F;
+
+ default:
+ return 0.90F;
+ }
+ } else
+ {
+ switch (customRenderItem.getMiniItemCount(itemStack,(byte)1))
+ {
+ case 1:
+ return 0.65F;
+
+ case 2:
+ return 0.65F;
+
+ case 3:
+ return 0.65F;
+
+ case 4:
+ return 0.65F;
+
+ default:
+ return 0.65F;
+ }
+ }
+ }
+
+ return scaleFactor;
+ }
+
+ private void translateGhostItemByOrientation(ItemStack ghostItemStack, double x, double y, double z, ForgeDirection forgeDirection)
+ {
+ if (ghostItemStack != null)
+ {
+ if (ghostItemStack.getItem() instanceof ItemBlock)
+ {
+ switch (forgeDirection)
+ {
+ case DOWN:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 2.7F, (float) z + 0.5F);
+ return;
+ }
+
+ case UP:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.25F, (float) z + 0.5F);
+ return;
+ }
+
+ case NORTH:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.5F, (float) z + 0.7F);
+ return;
+ }
+
+ case SOUTH:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.5F, (float) z + 0.3F);
+ return;
+ }
+
+ case EAST:
+ {
+ GL11.glTranslatef((float) x + 0.3F, (float) y + 0.5F, (float) z + 0.5F);
+ return;
+ }
+
+ case WEST:
+ {
+ GL11.glTranslatef((float) x + 0.70F, (float) y + 0.5F, (float) z + 0.5F);
+ return;
+ }
+
+ case UNKNOWN:
+ {
+ return;
+ }
+
+ default:
+ {
+ return;
+ }
+ }
+ } else
+ {
+ switch (forgeDirection)
+ {
+ case DOWN:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.6F, (float) z + 0.5F);
+ return;
+ }
+
+ case UP:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.20F, (float) z + 0.5F);
+ return;
+ }
+
+ case NORTH:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.4F, (float) z + 0.7F);
+ return;
+ }
+
+ case SOUTH:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.4F, (float) z + 0.3F);
+ return;
+ }
+
+ case EAST:
+ {
+ GL11.glTranslatef((float) x + 0.3F, (float) y + 0.4F, (float) z + 0.5F);
+ return;
+ }
+
+ case WEST:
+ {
+ GL11.glTranslatef((float) x + 0.70F, (float) y + 0.4F, (float) z + 0.5F);
+ return;
+ }
+
+ case UNKNOWN:
+ {
+ return;
+ }
+
+ default:
+ {
+ return;
+ }
+ }
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderPlinth.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderPlinth.java
new file mode 100644
index 00000000..6a233520
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderPlinth.java
@@ -0,0 +1,256 @@
+package WayofTime.alchemicalWizardry.common.renderer.block;
+
+import net.minecraft.client.renderer.entity.RenderItem;
+import net.minecraft.client.renderer.entity.RenderManager;
+import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import org.lwjgl.opengl.GL11;
+
+import WayofTime.alchemicalWizardry.common.renderer.model.ModelPlinth;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEPlinth;
+import cpw.mods.fml.client.FMLClientHandler;
+
+public class RenderPlinth extends TileEntitySpecialRenderer
+{
+ private ModelPlinth modelPlinth = new ModelPlinth();
+ private final RenderItem customRenderItem;
+
+ public RenderPlinth()
+ {
+ customRenderItem = new RenderItem()
+ {
+ @Override
+ public boolean shouldBob()
+ {
+ return false;
+ }
+ };
+ customRenderItem.setRenderManager(RenderManager.instance);
+ }
+
+ @Override
+ public void renderTileEntityAt(TileEntity tileEntity, double d0, double d1, double d2, float f)
+ {
+ if (tileEntity instanceof TEPlinth)
+ {
+ TEPlinth tileAltar = (TEPlinth) tileEntity;
+ GL11.glDisable(GL11.GL_LIGHTING);
+// GL11.glDisable(GL11.GL_CULL_FACE);
+ /**
+ * Render the ghost item inside of the Altar, slowly spinning
+ */
+ GL11.glPushMatrix();
+ GL11.glTranslatef((float) d0 + 0.5F, (float) d1 + 1.5F, (float) d2 + 0.5F);
+ ResourceLocation test = new ResourceLocation("alchemicalwizardry:textures/models/Plinth.png");
+ FMLClientHandler.instance().getClient().renderEngine.bindTexture(test);
+ GL11.glPushMatrix();
+ GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
+ //A reference to your Model file. Again, very important.
+ this.modelPlinth.render((Entity) null, 0.0F, 0.0F, -0.1F, 0.0F, 0.0F, 0.0625F);
+ //Tell it to stop rendering for both the PushMatrix's
+ GL11.glPopMatrix();
+ GL11.glPopMatrix();
+ GL11.glPushMatrix();
+
+ if (tileAltar.getStackInSlot(0) != null)
+ {
+ float scaleFactor = getGhostItemScaleFactor(tileAltar.getStackInSlot(0));
+ EntityItem ghostEntityItem = new EntityItem(tileAltar.getWorldObj());
+ ghostEntityItem.hoverStart = 0.0F;
+ ghostEntityItem.setEntityItemStack(tileAltar.getStackInSlot(0));
+ //translateGhostItemByOrientation(ghostEntityItem.getEntityItem(), d0, d1, d2, ForgeDirection.DOWN);
+ float displacement = 0.2F;
+
+ if (ghostEntityItem.getEntityItem().getItem() instanceof ItemBlock)
+ {
+ GL11.glTranslatef((float) d0 + 0.5F, (float) d1 + displacement + 0.7F, (float) d2 + 0.5F);
+ } else
+ {
+ GL11.glTranslatef((float) d0 + 0.5F, (float) d1 + displacement + 10.4f / 16.0f, (float) d2 + 0.5F - 0.1875f);
+ }
+
+ //GL11.glTranslatef((float) tileAltar.xCoord + 0.5F, (float) tileAltar.yCoord + 2.7F, (float) tileAltar.zCoord + 0.5F);
+ GL11.glScalef(scaleFactor, scaleFactor, scaleFactor);
+
+ if (!(ghostEntityItem.getEntityItem().getItem() instanceof ItemBlock))
+ {
+ GL11.glRotatef(90f, 1.0f, 0.0f, 0.0F);
+ }
+
+ customRenderItem.doRender(ghostEntityItem, 0, 0, 0, 0, 0);
+ }
+
+ GL11.glPopMatrix();
+ GL11.glEnable(GL11.GL_CULL_FACE);
+ GL11.glEnable(GL11.GL_LIGHTING);
+ }
+ }
+
+ private float getGhostItemScaleFactor(ItemStack itemStack)
+ {
+ float scaleFactor = 2.0F / 0.9F;
+
+ if (itemStack != null)
+ {
+ if (itemStack.getItem() instanceof ItemBlock)
+ {
+ switch (customRenderItem.getMiniBlockCount(itemStack, (byte) 1))
+ {
+ case 1:
+ return 0.90F * scaleFactor / 2;
+
+ case 2:
+ return 0.90F * scaleFactor / 2;
+
+ case 3:
+ return 0.90F * scaleFactor / 2;
+
+ case 4:
+ return 0.90F * scaleFactor / 2;
+
+ case 5:
+ return 0.80F * scaleFactor / 2;
+
+ default:
+ return 0.90F * scaleFactor / 2;
+ }
+ } else
+ {
+ switch (customRenderItem.getMiniItemCount(itemStack, (byte) 1))
+ {
+ case 1:
+ return 0.65F * scaleFactor;
+
+ case 2:
+ return 0.65F * scaleFactor;
+
+ case 3:
+ return 0.65F * scaleFactor;
+
+ case 4:
+ return 0.65F * scaleFactor;
+
+ default:
+ return 0.65F * scaleFactor;
+ }
+ }
+ }
+
+ return scaleFactor;
+ }
+
+ private void translateGhostItemByOrientation(ItemStack ghostItemStack, double x, double y, double z, ForgeDirection forgeDirection)
+ {
+ if (ghostItemStack != null)
+ {
+ if (ghostItemStack.getItem() instanceof ItemBlock)
+ {
+ switch (forgeDirection)
+ {
+ case DOWN:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 2.7F, (float) z + 0.5F);
+ return;
+ }
+
+ case UP:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.25F, (float) z + 0.5F);
+ return;
+ }
+
+ case NORTH:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.5F, (float) z + 0.7F);
+ return;
+ }
+
+ case SOUTH:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.5F, (float) z + 0.3F);
+ return;
+ }
+
+ case EAST:
+ {
+ GL11.glTranslatef((float) x + 0.3F, (float) y + 0.5F, (float) z + 0.5F);
+ return;
+ }
+
+ case WEST:
+ {
+ GL11.glTranslatef((float) x + 0.70F, (float) y + 0.5F, (float) z + 0.5F);
+ return;
+ }
+
+ case UNKNOWN:
+ {
+ return;
+ }
+
+ default:
+ {
+ return;
+ }
+ }
+ } else
+ {
+ switch (forgeDirection)
+ {
+ case DOWN:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.6F, (float) z + 0.5F);
+ return;
+ }
+
+ case UP:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.20F, (float) z + 0.5F);
+ return;
+ }
+
+ case NORTH:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.4F, (float) z + 0.7F);
+ return;
+ }
+
+ case SOUTH:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.4F, (float) z + 0.3F);
+ return;
+ }
+
+ case EAST:
+ {
+ GL11.glTranslatef((float) x + 0.3F, (float) y + 0.4F, (float) z + 0.5F);
+ return;
+ }
+
+ case WEST:
+ {
+ GL11.glTranslatef((float) x + 0.70F, (float) y + 0.4F, (float) z + 0.5F);
+ return;
+ }
+
+ case UNKNOWN:
+ {
+ return;
+ }
+
+ default:
+ {
+ return;
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderReagentConduit.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderReagentConduit.java
new file mode 100644
index 00000000..66c743d7
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderReagentConduit.java
@@ -0,0 +1,75 @@
+package WayofTime.alchemicalWizardry.common.renderer.block;
+
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.MathHelper;
+import net.minecraft.util.ResourceLocation;
+
+import org.lwjgl.opengl.GL11;
+
+import WayofTime.alchemicalWizardry.common.Int3;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEReagentConduit;
+
+public class RenderReagentConduit extends TileEntitySpecialRenderer
+{
+ private static final ResourceLocation field_110629_a = new ResourceLocation("alchemicalwizardry:textures/models/SimpleTransCircle.png");
+
+ @Override
+ public void renderTileEntityAt(TileEntity tileEntity, double d0, double d1, double d2, float f)
+ {
+ if (tileEntity instanceof TEReagentConduit)
+ {
+ int renderCount = ((TEReagentConduit)tileEntity).renderCount;
+ float key1 = (tileEntity.xCoord*54f - tileEntity.yCoord*38.72f + tileEntity.zCoord*10.432f);
+ float key2 = (tileEntity.xCoord*21.43f - tileEntity.yCoord*9.96f + tileEntity.zCoord*12.8f);
+
+ Int3 colourMap = ((TEReagentConduit) tileEntity).getColour();
+
+ GL11.glPushMatrix();
+ float f1 = 1.0f;
+ Tessellator tessellator = Tessellator.instance;
+ this.bindTexture(field_110629_a);
+ GL11.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, 10497.0F);
+ GL11.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, 10497.0F);
+ GL11.glDisable(GL11.GL_LIGHTING);
+ GL11.glDisable(GL11.GL_CULL_FACE);
+ float f2 = 0;
+ float f3 = -f2 * 0.2F - (float)MathHelper.floor_float(-f2 * 0.1F);
+ GL11.glEnable(GL11.GL_BLEND);
+ GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+
+
+ GL11.glDepthMask(false);
+
+ tessellator.startDrawingQuads();
+ tessellator.setColorRGBA(colourMap.xCoord, colourMap.yCoord, colourMap.zCoord, 200);
+ //tessellator.setColorOpaque(255, 255, 255);
+
+ GL11.glTranslated(d0+0.5, d1+0.5, d2+0.5);
+
+ GL11.glRotatef(tileEntity.getWorldObj().getWorldTime()/3.0f, 0F, 1F, 0F); //Rotate on planar axis
+ GL11.glRotatef(renderCount + key1, 0F, 0F, 1F); //Rotate vertical axis
+ GL11.glRotatef(renderCount*2f + key2, 1F, 0F, 0F); //Rotate cylindrically
+
+ double offset = 0;
+
+ tessellator.setBrightness(240);
+// GL11.glTranslatef(0F, s, s);
+// GL11.glScalef(1F, s * 14F, s * 14F);
+ tessellator.addVertexWithUV(-0.5d, 0, -0.5d, 0.0d, 0.0d);
+ tessellator.addVertexWithUV(0.5d, 0, -0.5d, 1.0d, 0.0d);
+ tessellator.addVertexWithUV(0.5d, 0, 0.5d, 1.0d, 1.0d);
+ tessellator.addVertexWithUV(-0.5d, 0, 0.5d, 0.0d, 1.0d);
+
+ tessellator.draw();
+
+ GL11.glDepthMask(true);
+
+ GL11.glEnable(GL11.GL_LIGHTING);
+ GL11.glEnable(GL11.GL_TEXTURE_2D);
+ GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
+ GL11.glPopMatrix();
+ }
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderSpellEffectBlock.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderSpellEffectBlock.java
new file mode 100644
index 00000000..644bb56b
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderSpellEffectBlock.java
@@ -0,0 +1,49 @@
+package WayofTime.alchemicalWizardry.common.renderer.block;
+
+import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
+import net.minecraft.entity.Entity;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ResourceLocation;
+
+import org.lwjgl.opengl.GL11;
+
+import WayofTime.alchemicalWizardry.common.renderer.model.ModelSpellEffectBlock;
+import WayofTime.alchemicalWizardry.common.tileEntity.TESpellEffectBlock;
+import cpw.mods.fml.client.FMLClientHandler;
+
+public class RenderSpellEffectBlock extends TileEntitySpecialRenderer
+{
+ private ModelSpellEffectBlock modelSpellEffectBlock = new ModelSpellEffectBlock();
+
+ @Override
+ public void renderTileEntityAt(TileEntity tileEntity, double d0, double d1, double d2, float f)
+ {
+ if (tileEntity instanceof TESpellEffectBlock)
+ {
+ TESpellEffectBlock tileSpellBlock = (TESpellEffectBlock) tileEntity;
+ GL11.glDisable(GL11.GL_LIGHTING);
+// GL11.glDisable(GL11.GL_CULL_FACE);
+ /**
+ * Render the ghost item inside of the Altar, slowly spinning
+ */
+ GL11.glPushMatrix();
+ GL11.glTranslatef((float) d0 + 0.5F, (float) d1 + 1.5F, (float) d2 + 0.5F);
+ ResourceLocation test = new ResourceLocation("alchemicalwizardry:textures/models/BlockSpellEffect.png");
+ int meta = tileEntity.getWorldObj().getBlockMetadata(tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord);
+ String resource = tileSpellBlock.getResourceLocationForMeta(meta);
+ test = new ResourceLocation(resource);
+
+ FMLClientHandler.instance().getClient().renderEngine.bindTexture(test);
+ GL11.glPushMatrix();
+ GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
+ //GL11.glRotatef(90F, 0.0F, 0.0F, 1.0F);
+ //A reference to your Model file. Again, very important.
+ this.modelSpellEffectBlock.render((Entity) null, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0625F, tileSpellBlock.getInputDirection(), tileSpellBlock.getOutputDirection());
+ //Tell it to stop rendering for both the PushMatrix's
+ GL11.glPopMatrix();
+ GL11.glPopMatrix();
+ GL11.glEnable(GL11.GL_CULL_FACE);
+ GL11.glEnable(GL11.GL_LIGHTING);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderSpellEnhancementBlock.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderSpellEnhancementBlock.java
new file mode 100644
index 00000000..ad2b22ae
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderSpellEnhancementBlock.java
@@ -0,0 +1,49 @@
+package WayofTime.alchemicalWizardry.common.renderer.block;
+
+import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
+import net.minecraft.entity.Entity;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ResourceLocation;
+
+import org.lwjgl.opengl.GL11;
+
+import WayofTime.alchemicalWizardry.common.renderer.model.ModelSpellEnhancementBlock;
+import WayofTime.alchemicalWizardry.common.tileEntity.TESpellEnhancementBlock;
+import cpw.mods.fml.client.FMLClientHandler;
+
+public class RenderSpellEnhancementBlock extends TileEntitySpecialRenderer
+{
+ private ModelSpellEnhancementBlock modelSpellEnhancementBlock = new ModelSpellEnhancementBlock();
+
+ @Override
+ public void renderTileEntityAt(TileEntity tileEntity, double d0, double d1, double d2, float f)
+ {
+ if (tileEntity instanceof TESpellEnhancementBlock)
+ {
+ TESpellEnhancementBlock tileSpellBlock = (TESpellEnhancementBlock) tileEntity;
+ GL11.glDisable(GL11.GL_LIGHTING);
+// GL11.glDisable(GL11.GL_CULL_FACE);
+ /**
+ * Render the ghost item inside of the Altar, slowly spinning
+ */
+ GL11.glPushMatrix();
+ GL11.glTranslatef((float) d0 + 0.5F, (float) d1 + 1.5F, (float) d2 + 0.5F);
+ ResourceLocation test = new ResourceLocation("alchemicalwizardry:textures/models/BlockSpellEnhancementPower1.png");
+ int meta = tileEntity.getWorldObj().getBlockMetadata(tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord);
+ String resource = tileSpellBlock.getResourceLocationForMeta(meta);
+ test = new ResourceLocation(resource);
+
+ FMLClientHandler.instance().getClient().renderEngine.bindTexture(test);
+ GL11.glPushMatrix();
+ GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
+ //GL11.glRotatef(90F, 0.0F, 0.0F, 1.0F);
+ //A reference to your Model file. Again, very important.
+ this.modelSpellEnhancementBlock.render((Entity) null, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0625F, tileSpellBlock.getInputDirection(), tileSpellBlock.getOutputDirection());
+ //Tell it to stop rendering for both the PushMatrix's
+ GL11.glPopMatrix();
+ GL11.glPopMatrix();
+ GL11.glEnable(GL11.GL_CULL_FACE);
+ GL11.glEnable(GL11.GL_LIGHTING);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderSpellModifierBlock.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderSpellModifierBlock.java
new file mode 100644
index 00000000..e61a6123
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderSpellModifierBlock.java
@@ -0,0 +1,49 @@
+package WayofTime.alchemicalWizardry.common.renderer.block;
+
+import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
+import net.minecraft.entity.Entity;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ResourceLocation;
+
+import org.lwjgl.opengl.GL11;
+
+import WayofTime.alchemicalWizardry.common.renderer.model.ModelSpellModifierBlock;
+import WayofTime.alchemicalWizardry.common.tileEntity.TESpellModifierBlock;
+import cpw.mods.fml.client.FMLClientHandler;
+
+public class RenderSpellModifierBlock extends TileEntitySpecialRenderer
+{
+ private ModelSpellModifierBlock modelSpellModifierBlock = new ModelSpellModifierBlock();
+
+ @Override
+ public void renderTileEntityAt(TileEntity tileEntity, double d0, double d1, double d2, float f)
+ {
+ if (tileEntity instanceof TESpellModifierBlock)
+ {
+ TESpellModifierBlock tileSpellBlock = (TESpellModifierBlock) tileEntity;
+ GL11.glDisable(GL11.GL_LIGHTING);
+// GL11.glDisable(GL11.GL_CULL_FACE);
+ /**
+ * Render the ghost item inside of the Altar, slowly spinning
+ */
+ GL11.glPushMatrix();
+ GL11.glTranslatef((float) d0 + 0.5F, (float) d1 + 1.5F, (float) d2 + 0.5F);
+ ResourceLocation test = new ResourceLocation("alchemicalwizardry:textures/models/BlockSpellModifier.png");
+ int meta = tileEntity.getWorldObj().getBlockMetadata(tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord);
+ String resource = tileSpellBlock.getResourceLocationForMeta(meta);
+ test = new ResourceLocation(resource);
+
+ FMLClientHandler.instance().getClient().renderEngine.bindTexture(test);
+ GL11.glPushMatrix();
+ GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
+ //GL11.glRotatef(90F, 0.0F, 0.0F, 1.0F);
+ //A reference to your Model file. Again, very important.
+ this.modelSpellModifierBlock.render((Entity) null, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0625F, tileSpellBlock.getInputDirection(), tileSpellBlock.getOutputDirection());
+ //Tell it to stop rendering for both the PushMatrix's
+ GL11.glPopMatrix();
+ GL11.glPopMatrix();
+ GL11.glEnable(GL11.GL_CULL_FACE);
+ GL11.glEnable(GL11.GL_LIGHTING);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderSpellParadigmBlock.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderSpellParadigmBlock.java
new file mode 100644
index 00000000..9b28f3fb
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderSpellParadigmBlock.java
@@ -0,0 +1,49 @@
+package WayofTime.alchemicalWizardry.common.renderer.block;
+
+import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
+import net.minecraft.entity.Entity;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ResourceLocation;
+
+import org.lwjgl.opengl.GL11;
+
+import WayofTime.alchemicalWizardry.common.renderer.model.ModelSpellParadigmBlock;
+import WayofTime.alchemicalWizardry.common.tileEntity.TESpellParadigmBlock;
+import cpw.mods.fml.client.FMLClientHandler;
+
+public class RenderSpellParadigmBlock extends TileEntitySpecialRenderer
+{
+ private ModelSpellParadigmBlock modelSpellParadigmBlock = new ModelSpellParadigmBlock();
+
+ @Override
+ public void renderTileEntityAt(TileEntity tileEntity, double d0, double d1, double d2, float f)
+ {
+ if (tileEntity instanceof TESpellParadigmBlock)
+ {
+ TESpellParadigmBlock tileSpellBlock = (TESpellParadigmBlock) tileEntity;
+ GL11.glDisable(GL11.GL_LIGHTING);
+// GL11.glDisable(GL11.GL_CULL_FACE);
+ /**
+ * Render the ghost item inside of the Altar, slowly spinning
+ */
+ GL11.glPushMatrix();
+ GL11.glTranslatef((float) d0 + 0.5F, (float) d1 + 1.5F, (float) d2 + 0.5F);
+ ResourceLocation test = new ResourceLocation("alchemicalwizardry:textures/models/BlockSpellParadigm.png");
+ int meta = tileEntity.getWorldObj().getBlockMetadata(tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord);
+ String resource = tileSpellBlock.getResourceLocationForMeta(meta);
+ test = new ResourceLocation(resource);
+
+ FMLClientHandler.instance().getClient().renderEngine.bindTexture(test);
+ GL11.glPushMatrix();
+ GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
+ //GL11.glRotatef(90F, 0.0F, 0.0F, 1.0F);
+ //A reference to your Model file. Again, very important.
+ this.modelSpellParadigmBlock.render((Entity) null, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0625F, tileSpellBlock.getInputDirection(), tileSpellBlock.getOutputDirection());
+ //Tell it to stop rendering for both the PushMatrix's
+ GL11.glPopMatrix();
+ GL11.glPopMatrix();
+ GL11.glEnable(GL11.GL_CULL_FACE);
+ GL11.glEnable(GL11.GL_LIGHTING);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderWritingTable.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderWritingTable.java
new file mode 100644
index 00000000..b53c496f
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/RenderWritingTable.java
@@ -0,0 +1,328 @@
+package WayofTime.alchemicalWizardry.common.renderer.block;
+
+import net.minecraft.client.renderer.entity.RenderItem;
+import net.minecraft.client.renderer.entity.RenderManager;
+import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import org.lwjgl.opengl.GL11;
+
+import WayofTime.alchemicalWizardry.common.renderer.model.ModelWritingTable;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEWritingTable;
+import cpw.mods.fml.client.FMLClientHandler;
+
+public class RenderWritingTable extends TileEntitySpecialRenderer
+{
+ private ModelWritingTable modelWritingTable = new ModelWritingTable();
+ private final RenderItem customRenderItem;
+
+ public RenderWritingTable()
+ {
+ customRenderItem = new RenderItem()
+ {
+ @Override
+ public boolean shouldBob()
+ {
+ return false;
+ }
+ };
+ customRenderItem.setRenderManager(RenderManager.instance);
+ }
+
+ @Override
+ public void renderTileEntityAt(TileEntity tileEntity, double d0, double d1, double d2, float f)
+ {
+ if (tileEntity instanceof TEWritingTable)
+ {
+ TEWritingTable tileAltar = (TEWritingTable) tileEntity;
+ GL11.glDisable(GL11.GL_LIGHTING);
+// GL11.glDisable(GL11.GL_CULL_FACE);
+ GL11.glPushMatrix();
+ GL11.glTranslatef((float) d0 + 0.5F, (float) d1 + 1.5F, (float) d2 + 0.5F);
+ ResourceLocation test = new ResourceLocation("alchemicalwizardry:textures/models/WritingTable.png");
+ FMLClientHandler.instance().getClient().renderEngine.bindTexture(test);
+ GL11.glPushMatrix();
+ GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
+ //A reference to your Model file. Again, very important.
+ this.modelWritingTable.render((Entity) null, 0.0F, 0.0F, -0.1F, 0.0F, 0.0F, 0.0625F);
+ //Tell it to stop rendering for both the PushMatrix's
+ GL11.glPopMatrix();
+ GL11.glPopMatrix();
+
+ for (int i = 1; i <= 6; i++)
+ {
+ GL11.glPushMatrix();
+
+ if (tileAltar.getStackInSlot(i) != null)
+ {
+ float scaleFactor = getGhostItemScaleFactor(tileAltar.getStackInSlot(i));
+ float rotationAngle = (float) (720.0 * (System.currentTimeMillis() & 0x3FFFL) / 0x3FFFL);
+ EntityItem ghostEntityItem = new EntityItem(tileAltar.getWorldObj());
+ ghostEntityItem.hoverStart = 0.0F;
+ ghostEntityItem.setEntityItemStack(tileAltar.getStackInSlot(i));
+ //translateGhostItemByOrientation(ghostEntityItem.getEntityItem(), d0, d1, d2, ForgeDirection.DOWN);
+ float displacementX = getXDisplacementForSlot(i);
+ float displacementY = getYDisplacementForSlot(i);
+ float displacementZ = getZDisplacementForSlot(i);
+
+ if (ghostEntityItem.getEntityItem().getItem() instanceof ItemBlock)
+ {
+ GL11.glTranslatef((float) d0 + 0.5F + displacementX, (float) d1 + displacementY + 0.7F, (float) d2 + 0.5F + displacementZ);
+ } else
+ {
+ GL11.glTranslatef((float) d0 + 0.5F + displacementX, (float) d1 + displacementY + 0.6F, (float) d2 + 0.5F + displacementZ);
+ }
+
+ //GL11.glTranslatef((float) tileAltar.xCoord + 0.5F, (float) tileAltar.yCoord + 2.7F, (float) tileAltar.zCoord + 0.5F);
+ GL11.glScalef(scaleFactor, scaleFactor, scaleFactor);
+ GL11.glRotatef(rotationAngle, 0.0F, 1.0F, 0.0F);
+ customRenderItem.doRender(ghostEntityItem, 0, 0, 0, 0, 0);
+ }
+
+ GL11.glPopMatrix();
+ }
+
+ GL11.glEnable(GL11.GL_CULL_FACE);
+ GL11.glEnable(GL11.GL_LIGHTING);
+ }
+ }
+
+ private float getGhostItemScaleFactor(ItemStack itemStack)
+ {
+ float scaleFactor = 0.8F;
+
+ if (itemStack != null)
+ {
+ if (itemStack.getItem() instanceof ItemBlock)
+ {
+ switch (customRenderItem.getMiniBlockCount(itemStack,(byte)1))
+ {
+ case 1:
+ return 0.90F * scaleFactor;
+
+ case 2:
+ return 0.90F * scaleFactor;
+
+ case 3:
+ return 0.90F * scaleFactor;
+
+ case 4:
+ return 0.90F * scaleFactor;
+
+ case 5:
+ return 0.80F * scaleFactor;
+
+ default:
+ return 0.90F * scaleFactor;
+ }
+ } else
+ {
+ switch (customRenderItem.getMiniItemCount(itemStack,(byte)1))
+ {
+ case 1:
+ return 0.65F * scaleFactor;
+
+ case 2:
+ return 0.65F * scaleFactor;
+
+ case 3:
+ return 0.65F * scaleFactor;
+
+ case 4:
+ return 0.65F * scaleFactor;
+
+ default:
+ return 0.65F * scaleFactor;
+ }
+ }
+ }
+
+ return scaleFactor;
+ }
+
+ private float getXDisplacementForSlot(int slot)
+ {
+ switch (slot)
+ {
+ case 0:
+ return 0.0f;
+
+ case 1:
+ return -0.375f;
+
+ case 2:
+ return -0.125f;
+
+ case 3:
+ return 0.3125f;
+
+ case 4:
+ return 0.3125f;
+
+ case 5:
+ return -0.125f;
+
+ default:
+ return 0.0f;
+ }
+ }
+
+ private float getYDisplacementForSlot(int slot)
+ {
+ switch (slot)
+ {
+ case 0:
+ return 0.4f;
+
+ case 1:
+ return -0.35f;
+
+ case 6:
+ return 0.4f;
+
+ default:
+ return -0.35f;
+ }
+ }
+
+ private float getZDisplacementForSlot(int slot)
+ {
+ switch (slot)
+ {
+ case 0:
+ return 0.0f;
+
+ case 1:
+ return 0.0f;
+
+ case 2:
+ return 0.375f;
+
+ case 3:
+ return 0.25f;
+
+ case 4:
+ return -0.25f;
+
+ case 5:
+ return -0.375f;
+
+ default:
+ return 0.0f;
+ }
+ }
+
+ private void translateGhostItemByOrientation(ItemStack ghostItemStack, double x, double y, double z, ForgeDirection forgeDirection)
+ {
+ if (ghostItemStack != null)
+ {
+ if (ghostItemStack.getItem() instanceof ItemBlock)
+ {
+ switch (forgeDirection)
+ {
+ case DOWN:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 2.7F, (float) z + 0.5F);
+ return;
+ }
+
+ case UP:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.25F, (float) z + 0.5F);
+ return;
+ }
+
+ case NORTH:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.5F, (float) z + 0.7F);
+ return;
+ }
+
+ case SOUTH:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.5F, (float) z + 0.3F);
+ return;
+ }
+
+ case EAST:
+ {
+ GL11.glTranslatef((float) x + 0.3F, (float) y + 0.5F, (float) z + 0.5F);
+ return;
+ }
+
+ case WEST:
+ {
+ GL11.glTranslatef((float) x + 0.70F, (float) y + 0.5F, (float) z + 0.5F);
+ return;
+ }
+
+ case UNKNOWN:
+ {
+ return;
+ }
+
+ default:
+ {
+ return;
+ }
+ }
+ } else
+ {
+ switch (forgeDirection)
+ {
+ case DOWN:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.6F, (float) z + 0.5F);
+ return;
+ }
+
+ case UP:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.20F, (float) z + 0.5F);
+ return;
+ }
+
+ case NORTH:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.4F, (float) z + 0.7F);
+ return;
+ }
+
+ case SOUTH:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.4F, (float) z + 0.3F);
+ return;
+ }
+
+ case EAST:
+ {
+ GL11.glTranslatef((float) x + 0.3F, (float) y + 0.4F, (float) z + 0.5F);
+ return;
+ }
+
+ case WEST:
+ {
+ GL11.glTranslatef((float) x + 0.70F, (float) y + 0.4F, (float) z + 0.5F);
+ return;
+ }
+
+ case UNKNOWN:
+ {
+ return;
+ }
+
+ default:
+ {
+ return;
+ }
+ }
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/ShaderHelper.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/ShaderHelper.java
new file mode 100644
index 00000000..46641497
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/ShaderHelper.java
@@ -0,0 +1,184 @@
+/**
+ * This class was created by . It's distributed as
+ * part of the Botania Mod. Get the Source Code in github:
+ * https://github.com/Vazkii/Botania
+ *
+ * Botania is Open Source and distributed under a
+ * Creative Commons Attribution-NonCommercial-ShareAlike 3.0 License
+ * (http://creativecommons.org/licenses/by-nc-sa/3.0/deed.en_GB)
+ *
+ * File Created @ [Apr 9, 2014, 11:20:26 PM (GMT)]
+ */
+package WayofTime.alchemicalWizardry.common.renderer.block;
+
+import java.io.BufferedReader;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.logging.Level;
+
+import org.lwjgl.opengl.ARBFragmentShader;
+import org.lwjgl.opengl.ARBShaderObjects;
+import org.lwjgl.opengl.ARBVertexShader;
+import org.lwjgl.opengl.GL11;
+
+import cpw.mods.fml.common.FMLLog;
+
+public final class ShaderHelper {
+
+ private static final int VERT = ARBVertexShader.GL_VERTEX_SHADER_ARB;
+ private static final int FRAG = ARBFragmentShader.GL_FRAGMENT_SHADER_ARB;
+
+ public static int beam = 0;
+
+ public static void initShaders() {
+// if(!useShaders())
+// return;
+
+ beam = createProgram(null, "/assets/alchemicalwizardry/shaders/beam.frag");
+ }
+
+ public static void useShaderWithProps(int shader, Object... props) {
+// if(!useShaders())
+// return;
+
+ ARBShaderObjects.glUseProgramObjectARB(shader);
+
+ if(shader != 0 && props.length % 2 == 0) {
+ int propCount = props.length / 2;
+ for(int i = 0; i < propCount; i++) {
+ String propName = (String) props[i * 2];
+ Object propVal = props[i * 2 + 1];
+
+ int uniform = ARBShaderObjects.glGetUniformLocationARB(shader, propName);
+ if(propVal instanceof Integer)
+ ARBShaderObjects.glUniform1iARB(uniform, (Integer) propVal);
+ if(propVal instanceof Float)
+ ARBShaderObjects.glUniform1fARB(uniform, (Float) propVal);
+ // Possible Vector2, Vector3 and Vector4, no need yet.
+ }
+ }
+ }
+
+ public static void useShader(int shader) {
+ useShaderWithProps(shader);
+ }
+
+ public static void releaseShader() {
+ useShader(0);
+ }
+
+ public static boolean useShaders() {
+ return true;//ConfigHandler.useShaders && OpenGlHelper.shadersSupported;
+ }
+
+ // Most of the code taken from the LWJGL wiki
+ // http://lwjgl.org/wiki/index.php?title=GLSL_Shaders_with_LWJGL
+
+ private static int createProgram(String vert, String frag) {
+ int vertId = 0, fragId = 0, program = 0;
+ if(vert != null)
+ vertId = createShader(vert, VERT);
+ if(frag != null)
+ fragId = createShader(frag, FRAG);
+
+ program = ARBShaderObjects.glCreateProgramObjectARB();
+ if(program == 0)
+ return 0;
+
+ if(vert != null)
+ ARBShaderObjects.glAttachObjectARB(program, vertId);
+ if(frag != null)
+ ARBShaderObjects.glAttachObjectARB(program, fragId);
+
+ ARBShaderObjects.glLinkProgramARB(program);
+ if(ARBShaderObjects.glGetObjectParameteriARB(program, ARBShaderObjects.GL_OBJECT_LINK_STATUS_ARB) == GL11.GL_FALSE) {
+// FMLLog.log(Level.WARNING, getLogInfo(program));
+ return 0;
+ }
+
+ ARBShaderObjects.glValidateProgramARB(program);
+ if (ARBShaderObjects.glGetObjectParameteriARB(program, ARBShaderObjects.GL_OBJECT_VALIDATE_STATUS_ARB) == GL11.GL_FALSE) {
+// FMLLog.log(Level.WARNING, getLogInfo(program));
+ return 0;
+ }
+
+ return program;
+ }
+
+ private static int createShader(String filename, int shaderType){
+ int shader = 0;
+ try {
+ shader = ARBShaderObjects.glCreateShaderObjectARB(shaderType);
+
+ if(shader == 0)
+ return 0;
+
+ ARBShaderObjects.glShaderSourceARB(shader, readFileAsString(filename));
+ ARBShaderObjects.glCompileShaderARB(shader);
+
+ if (ARBShaderObjects.glGetObjectParameteriARB(shader, ARBShaderObjects.GL_OBJECT_COMPILE_STATUS_ARB) == GL11.GL_FALSE)
+ throw new RuntimeException("Error creating shader: " + getLogInfo(shader));
+
+ return shader;
+ }
+ catch(Exception e) {
+ ARBShaderObjects.glDeleteObjectARB(shader);
+ e.printStackTrace();
+ return -1;
+ }
+ }
+
+ private static String getLogInfo(int obj) {
+ return ARBShaderObjects.glGetInfoLogARB(obj, ARBShaderObjects.glGetObjectParameteriARB(obj, ARBShaderObjects.GL_OBJECT_INFO_LOG_LENGTH_ARB));
+ }
+
+ private static String readFileAsString(String filename) throws Exception {
+ StringBuilder source = new StringBuilder();
+ InputStream in = ShaderHelper.class.getResourceAsStream(filename);
+ Exception exception = null;
+ BufferedReader reader;
+
+ if(in == null)
+ return "";
+
+ try {
+ reader = new BufferedReader(new InputStreamReader(in, "UTF-8"));
+
+ Exception innerExc= null;
+ try {
+ String line;
+ while((line = reader.readLine()) != null)
+ source.append(line).append('\n');
+ } catch(Exception exc) {
+ exception = exc;
+ } finally {
+ try {
+ reader.close();
+ } catch(Exception exc) {
+ if(innerExc == null)
+ innerExc = exc;
+ else exc.printStackTrace();
+ }
+ }
+
+ if(innerExc != null)
+ throw innerExc;
+ } catch(Exception exc) {
+ exception = exc;
+ } finally {
+ try {
+ in.close();
+ } catch(Exception exc) {
+ if(exception == null)
+ exception = exc;
+ else exc.printStackTrace();
+ }
+
+ if(exception != null)
+ throw exception;
+ }
+
+ return source.toString();
+ }
+}
+
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/TEAltarRenderer.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/TEAltarRenderer.java
new file mode 100644
index 00000000..4036f435
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/TEAltarRenderer.java
@@ -0,0 +1,241 @@
+package WayofTime.alchemicalWizardry.common.renderer.block;
+
+import net.minecraft.client.renderer.entity.RenderItem;
+import net.minecraft.client.renderer.entity.RenderManager;
+import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import org.lwjgl.opengl.GL11;
+
+import WayofTime.alchemicalWizardry.common.renderer.model.ModelBloodAltar;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEAltar;
+
+public class TEAltarRenderer extends TileEntitySpecialRenderer
+{
+ private ModelBloodAltar modelBloodAltar = new ModelBloodAltar();
+ private final RenderItem customRenderItem;
+
+ public TEAltarRenderer()
+ {
+ customRenderItem = new RenderItem()
+ {
+ @Override
+ public boolean shouldBob()
+ {
+ return false;
+ }
+ };
+ customRenderItem.setRenderManager(RenderManager.instance);
+ }
+
+ @Override
+ public void renderTileEntityAt(TileEntity tileEntity, double d0, double d1, double d2, float f)
+ {
+ modelBloodAltar.renderBloodAltar((TEAltar) tileEntity, d0, d1, d2);
+ modelBloodAltar.renderBloodLevel((TEAltar) tileEntity, d0, d1, d2);
+
+ if (tileEntity instanceof TEAltar)
+ {
+ TEAltar tileAltar = (TEAltar) tileEntity;
+ GL11.glDisable(GL11.GL_LIGHTING);
+// GL11.glDisable(GL11.GL_CULL_FACE);
+ /**
+ * Render the ghost item inside of the Altar, slowly spinning
+ */
+ GL11.glPushMatrix();
+
+ if (tileAltar.getStackInSlot(0) != null)
+ {
+ float scaleFactor = getGhostItemScaleFactor(tileAltar.getStackInSlot(0));
+ float rotationAngle = (float) (720.0 * (System.currentTimeMillis() & 0x3FFFL) / 0x3FFFL);
+ EntityItem ghostEntityItem = new EntityItem(tileAltar.getWorldObj());
+ ghostEntityItem.hoverStart = 0.0F;
+ ghostEntityItem.setEntityItemStack(tileAltar.getStackInSlot(0));
+ //translateGhostItemByOrientation(ghostEntityItem.getEntityItem(), d0, d1, d2, ForgeDirection.DOWN);
+ float displacement = 0.2F;
+
+ if (ghostEntityItem.getEntityItem().getItem() instanceof ItemBlock)
+ {
+ GL11.glTranslatef((float) d0 + 0.5F, (float) d1 + displacement + 0.7F, (float) d2 + 0.5F);
+ } else
+ {
+ GL11.glTranslatef((float) d0 + 0.5F, (float) d1 + displacement + 0.6F, (float) d2 + 0.5F);
+ }
+
+ //GL11.glTranslatef((float) tileAltar.xCoord + 0.5F, (float) tileAltar.yCoord + 2.7F, (float) tileAltar.zCoord + 0.5F);
+ GL11.glScalef(scaleFactor, scaleFactor, scaleFactor);
+ GL11.glRotatef(rotationAngle, 0.0F, 1.0F, 0.0F);
+ customRenderItem.doRender(ghostEntityItem, 0, 0, 0, 0, 0);
+ }
+
+ GL11.glPopMatrix();
+ GL11.glEnable(GL11.GL_CULL_FACE);
+ GL11.glEnable(GL11.GL_LIGHTING);
+ }
+ }
+
+ private float getGhostItemScaleFactor(ItemStack itemStack)
+ {
+ float scaleFactor = 1.0F;
+
+ if (itemStack != null)
+ {
+ if (itemStack.getItem() instanceof ItemBlock)
+ {
+ switch (customRenderItem.getMiniBlockCount(itemStack,(byte)1))
+ {
+ case 1:
+ return 0.90F;
+
+ case 2:
+ return 0.90F;
+
+ case 3:
+ return 0.90F;
+
+ case 4:
+ return 0.90F;
+
+ case 5:
+ return 0.80F;
+
+ default:
+ return 0.90F;
+ }
+ } else
+ {
+ switch (customRenderItem.getMiniItemCount(itemStack,(byte)1))
+ {
+ case 1:
+ return 0.65F;
+
+ case 2:
+ return 0.65F;
+
+ case 3:
+ return 0.65F;
+
+ case 4:
+ return 0.65F;
+
+ default:
+ return 0.65F;
+ }
+ }
+ }
+
+ return scaleFactor;
+ }
+
+ private void translateGhostItemByOrientation(ItemStack ghostItemStack, double x, double y, double z, ForgeDirection forgeDirection)
+ {
+ if (ghostItemStack != null)
+ {
+ if (ghostItemStack.getItem() instanceof ItemBlock)
+ {
+ switch (forgeDirection)
+ {
+ case DOWN:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 2.7F, (float) z + 0.5F);
+ return;
+ }
+
+ case UP:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.25F, (float) z + 0.5F);
+ return;
+ }
+
+ case NORTH:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.5F, (float) z + 0.7F);
+ return;
+ }
+
+ case SOUTH:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.5F, (float) z + 0.3F);
+ return;
+ }
+
+ case EAST:
+ {
+ GL11.glTranslatef((float) x + 0.3F, (float) y + 0.5F, (float) z + 0.5F);
+ return;
+ }
+
+ case WEST:
+ {
+ GL11.glTranslatef((float) x + 0.70F, (float) y + 0.5F, (float) z + 0.5F);
+ return;
+ }
+
+ case UNKNOWN:
+ {
+ return;
+ }
+
+ default:
+ {
+ return;
+ }
+ }
+ } else
+ {
+ switch (forgeDirection)
+ {
+ case DOWN:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.6F, (float) z + 0.5F);
+ return;
+ }
+
+ case UP:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.20F, (float) z + 0.5F);
+ return;
+ }
+
+ case NORTH:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.4F, (float) z + 0.7F);
+ return;
+ }
+
+ case SOUTH:
+ {
+ GL11.glTranslatef((float) x + 0.5F, (float) y + 0.4F, (float) z + 0.3F);
+ return;
+ }
+
+ case EAST:
+ {
+ GL11.glTranslatef((float) x + 0.3F, (float) y + 0.4F, (float) z + 0.5F);
+ return;
+ }
+
+ case WEST:
+ {
+ GL11.glTranslatef((float) x + 0.70F, (float) y + 0.4F, (float) z + 0.5F);
+ return;
+ }
+
+ case UNKNOWN:
+ {
+ return;
+ }
+
+ default:
+ {
+ return;
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/itemRender/TEAlchemicalCalcinatorItemRenderer.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/itemRender/TEAlchemicalCalcinatorItemRenderer.java
new file mode 100644
index 00000000..87b7cb94
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/itemRender/TEAlchemicalCalcinatorItemRenderer.java
@@ -0,0 +1,95 @@
+package WayofTime.alchemicalWizardry.common.renderer.block.itemRender;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.entity.Entity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.client.IItemRenderer;
+
+import org.lwjgl.opengl.GL11;
+
+import WayofTime.alchemicalWizardry.ModBlocks;
+import WayofTime.alchemicalWizardry.common.renderer.model.ModelAlchemicalCalcinator;
+import cpw.mods.fml.client.FMLClientHandler;
+
+public class TEAlchemicalCalcinatorItemRenderer implements IItemRenderer
+{
+ private ModelAlchemicalCalcinator modelConduit = new ModelAlchemicalCalcinator();
+
+ private void renderConduitItem(RenderBlocks render, ItemStack item, float translateX, float translateY, float translateZ)
+ {
+ Tessellator tessellator = Tessellator.instance;
+
+ Block block = ModBlocks.blockAlchemicCalcinator;
+
+ GL11.glEnable(GL11.GL_BLEND);
+ GL11.glEnable(GL11.GL_CULL_FACE);
+ GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+ /**
+ * Render the ghost item inside of the Altar, slowly spinning
+ */
+ GL11.glPushMatrix();
+ GL11.glTranslatef((float) translateX + 0.5F, (float) translateY + 1.5F, (float) translateZ + 0.5F);
+ ResourceLocation test = new ResourceLocation("alchemicalwizardry:textures/models/AlchemicalCalcinator.png");
+ FMLClientHandler.instance().getClient().renderEngine.bindTexture(test);
+ GL11.glPushMatrix();
+ GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
+ //GL11.glRotatef(90F, 0.0F, 0.0F, 1.0F);
+ //A reference to your Model file. Again, very important.
+ this.modelConduit.render((Entity) null, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0625F);
+ //Tell it to stop rendering for both the PushMatrix's
+ GL11.glPopMatrix();
+ GL11.glPopMatrix();
+
+ GL11.glDisable(GL11.GL_CULL_FACE);
+ GL11.glDisable(GL11.GL_BLEND);
+ }
+
+
+ /**
+ * IItemRenderer implementation *
+ */
+ @Override
+ public boolean handleRenderType(ItemStack item, ItemRenderType type) {
+ switch (type) {
+ case ENTITY:
+ return true;
+ case EQUIPPED:
+ return true;
+ case EQUIPPED_FIRST_PERSON:
+ return true;
+ case INVENTORY:
+ return true;
+ default:
+ return false;
+ }
+ }
+
+
+ @Override
+ public boolean shouldUseRenderHelper(ItemRenderType type, ItemStack item, ItemRendererHelper helper) {
+ return true;
+ }
+
+
+ @Override
+ public void renderItem(ItemRenderType type, ItemStack item, Object... data) {
+ switch (type) {
+ case ENTITY:
+ renderConduitItem((RenderBlocks) data[0], item, -0.5f, -0.5f, -0.5f);
+ break;
+ case EQUIPPED:
+ renderConduitItem((RenderBlocks) data[0], item, -0.4f, 0.50f, 0.35f);
+ break;
+ case EQUIPPED_FIRST_PERSON:
+ renderConduitItem((RenderBlocks) data[0], item, -0.4f, 0.50f, 0.35f);
+ break;
+ case INVENTORY:
+ renderConduitItem((RenderBlocks) data[0], item, -0.5f, -0.5f, -0.5f);
+ break;
+ default:
+ }
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/itemRender/TEAltarItemRenderer.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/itemRender/TEAltarItemRenderer.java
new file mode 100644
index 00000000..72945f5a
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/itemRender/TEAltarItemRenderer.java
@@ -0,0 +1,81 @@
+package WayofTime.alchemicalWizardry.common.renderer.block.itemRender;
+
+import WayofTime.alchemicalWizardry.common.renderer.model.ModelBloodAltar;
+import cpw.mods.fml.client.FMLClientHandler;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.client.IItemRenderer;
+
+import org.lwjgl.opengl.GL11;
+
+public class TEAltarItemRenderer implements IItemRenderer
+{
+ private ModelBloodAltar modelBloodAltar;
+
+ public TEAltarItemRenderer()
+ {
+ modelBloodAltar = new ModelBloodAltar();
+ }
+
+ @Override
+ public boolean handleRenderType(ItemStack item, ItemRenderType type)
+ {
+ // TODO Auto-generated method stub
+ return true;
+ }
+
+ @Override
+ public boolean shouldUseRenderHelper(ItemRenderType type, ItemStack item, ItemRendererHelper helper)
+ {
+ // TODO Auto-generated method stub
+ return true;
+ }
+
+ @Override
+ public void renderItem(ItemRenderType type, ItemStack item, Object... data)
+ {
+ float scale = 0.08f;
+
+ // TODO Auto-generated method stub
+ switch (type)
+ {
+ case ENTITY:
+ renderBloodAltar((RenderBlocks) data[0], item, 0, 0, 0, scale);
+ break;
+ case EQUIPPED:
+ renderBloodAltar((RenderBlocks) data[0], item, 0, 0, 0.5f, scale);
+ break;
+ case EQUIPPED_FIRST_PERSON:
+ renderBloodAltar((RenderBlocks) data[0], item, +0.5f, 0.5f, +0.5f, scale);
+ break;
+ case INVENTORY:
+ renderBloodAltar((RenderBlocks) data[0], item, -0.5f, -0.75f, -0.5f, scale);
+ break;
+
+ default:
+ return;
+ }
+ }
+
+ private void renderBloodAltar(RenderBlocks render, ItemStack item, float x, float y, float z, float scale)
+ {
+ GL11.glDisable(GL11.GL_LIGHTING);
+ GL11.glDisable(GL11.GL_CULL_FACE);
+ GL11.glPushMatrix();
+ // Disable Lighting Calculations
+ GL11.glTranslatef(x, y, z);
+ GL11.glScalef(scale, scale, scale);
+ GL11.glRotatef(180f, 0f, 1f, 0f);
+ //FMLClientHandler.instance().getClient().renderEngine.bindTexture("/mods/OBJTutorial/textures/models/TutBox.png");
+ ResourceLocation test = new ResourceLocation("alchemicalwizardry:textures/models/altar.png");
+ //FMLClientHandler.instance().getClient().renderEngine.bindTexture("/mods/alchemicalwizardry/textures/models/altar.png");
+ FMLClientHandler.instance().getClient().renderEngine.bindTexture(test);
+ modelBloodAltar.renderBloodAltar();
+ // Re-enable Lighting Calculations
+ GL11.glPopMatrix();
+ GL11.glEnable(GL11.GL_CULL_FACE);
+ GL11.glEnable(GL11.GL_LIGHTING);
+
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/itemRender/TEBellJarItemRenderer.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/itemRender/TEBellJarItemRenderer.java
new file mode 100644
index 00000000..706d7305
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/itemRender/TEBellJarItemRenderer.java
@@ -0,0 +1,206 @@
+package WayofTime.alchemicalWizardry.common.renderer.block.itemRender;
+
+import net.minecraft.client.renderer.ItemRenderer;
+import net.minecraft.client.renderer.OpenGlHelper;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.entity.Entity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.MathHelper;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.client.IItemRenderer;
+
+import org.lwjgl.opengl.GL11;
+
+import WayofTime.alchemicalWizardry.api.alchemy.energy.Reagent;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentContainerInfo;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentStack;
+import WayofTime.alchemicalWizardry.common.renderer.model.ModelCrystalBelljar;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEBellJar;
+import cpw.mods.fml.client.FMLClientHandler;
+
+public class TEBellJarItemRenderer implements IItemRenderer
+{
+ ItemRenderer d;
+ private ModelCrystalBelljar modelConduit = new ModelCrystalBelljar();
+ private ResourceLocation mainResource = new ResourceLocation("alchemicalwizardry:textures/models/CrystalBelljar.png");
+ private ResourceLocation resourceLocation = new ResourceLocation("alchemicalwizardry:textures/models/Reagent.png");
+
+ private void renderConduitItem(RenderBlocks render, ItemStack item, float translateX, float translateY, float translateZ)
+ {
+ GL11.glDepthMask(false);
+ Tessellator tessellator = Tessellator.instance;
+
+ GL11.glEnable(GL11.GL_BLEND);
+ GL11.glEnable(GL11.GL_CULL_FACE);
+ GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+
+ GL11.glPushMatrix();
+ GL11.glTranslatef((float) translateX + 0.5F, (float) translateY + 1.5F, (float) translateZ + 0.5F);
+ FMLClientHandler.instance().getClient().renderEngine.bindTexture(mainResource);
+ GL11.glPushMatrix();
+ GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
+ //GL11.glRotatef(90F, 0.0F, 0.0F, 1.0F);
+ //A reference to your Model file. Again, very important.
+ this.modelConduit.renderSpecialItem((Entity) null, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0625F, 0);
+ //Tell it to stop rendering for both the PushMatrix's
+ GL11.glPopMatrix();
+ GL11.glPopMatrix();
+
+ GL11.glDisable(GL11.GL_CULL_FACE);
+ GL11.glDisable(GL11.GL_BLEND);
+
+ GL11.glDepthMask(true);
+
+ ReagentContainerInfo[] info = TEBellJar.getContainerInfoFromItem(item);
+ if(info.length >= 1 && info[0] != null)
+ {
+ ReagentStack reagentStack = info[0].reagent;
+ int capacity = info[0].capacity;
+ if(reagentStack != null && reagentStack.reagent != null)
+ {
+ Reagent reagent = reagentStack.reagent;
+ this.renderTankContents(translateX, translateY, translateZ, reagent.getColourRed(), reagent.getColourGreen(), reagent.getColourBlue(), 200 * reagentStack.amount / capacity);
+ }
+ }
+
+ GL11.glDepthMask(false);
+
+ GL11.glEnable(GL11.GL_BLEND);
+ GL11.glEnable(GL11.GL_CULL_FACE);
+ GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+
+ GL11.glPushMatrix();
+ GL11.glTranslatef((float) translateX + 0.5F, (float) translateY + 1.5F, (float) translateZ + 0.5F);
+ FMLClientHandler.instance().getClient().renderEngine.bindTexture(mainResource);
+ GL11.glPushMatrix();
+ GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
+ //GL11.glRotatef(90F, 0.0F, 0.0F, 1.0F);
+ //A reference to your Model file. Again, very important.
+ this.modelConduit.renderSpecialItem((Entity) null, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0625F, 1);
+ //Tell it to stop rendering for both the PushMatrix's
+ GL11.glPopMatrix();
+ GL11.glPopMatrix();
+
+ GL11.glDisable(GL11.GL_CULL_FACE);
+ GL11.glDisable(GL11.GL_BLEND);
+// GL11.glEnable(GL11.GL_CULL_FACE);
+// GL11.glEnable(GL11.GL_LIGHTING);
+ GL11.glDepthMask(true);
+ }
+
+ private void renderTankContents(double x, double y, double z, int colourRed, int colourGreen, int colourBlue, int colourIntensity)
+ {
+ GL11.glPushMatrix();
+ float f1 = 1.0f;
+ Tessellator tessellator = Tessellator.instance;
+ FMLClientHandler.instance().getClient().renderEngine.bindTexture(resourceLocation);
+ GL11.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, 10497.0F);
+ GL11.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, 10497.0F);
+ GL11.glDisable(GL11.GL_LIGHTING);
+ GL11.glDisable(GL11.GL_CULL_FACE);
+ GL11.glEnable(GL11.GL_TEXTURE_2D);
+ float f2 = 0;
+ float f3 = -f2 * 0.2F - (float)MathHelper.floor_float(-f2 * 0.1F);
+ GL11.glEnable(GL11.GL_BLEND);
+ GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+
+ GL11.glDepthMask(false);
+
+ tessellator.startDrawingQuads();
+ tessellator.setColorRGBA(colourRed, colourGreen, colourBlue, colourIntensity);
+
+ GL11.glTranslated(x+0.5, y+0.5, z+0.5);
+ //GL11.glRotatef(30F, 0F, 0F, 1F); //Rotate vertical axis
+ //GL11.glRotatef(tileAltar.getWorldObj().getWorldTime()*2f, 1F, 0F, 0F); //Rotate cylindrically
+
+ tessellator.setBrightness(240);
+
+ double x1 = -4d/16d;
+ double x2 = 4d/16d;
+ double y1 = -6d/16d;
+ double y2 = 4d/16d;
+ double z1 = -4d/16d;
+ double z2 = 4d/16d;
+
+ double resx1 = 0.0d;
+ double resx2 = 0.0d;
+ double resy1 = 1.0d;
+ double resy2 = 1.0d;
+
+ tessellator.addVertexWithUV(x1, y1, z1, resx1, resy1);
+ tessellator.addVertexWithUV(x2, y1, z1, resx2, resy1);
+ tessellator.addVertexWithUV(x2, y2, z1, resx2, resy2);
+ tessellator.addVertexWithUV(x1, y2, z1, resx1, resy2);
+ tessellator.addVertexWithUV(x1, y1, z1, resx1, resy1);
+ tessellator.addVertexWithUV(x1, y1, z2, resx2, resy1);
+ tessellator.addVertexWithUV(x1, y2, z2, resx2, resy2);
+ tessellator.addVertexWithUV(x1, y2, z1, resx1, resy2);
+ tessellator.addVertexWithUV(x1, y1, z2, resx1, resy1);
+ tessellator.addVertexWithUV(x2, y1, z2, resx2, resy1);
+ tessellator.addVertexWithUV(x2, y2, z2, resx2, resy2);
+ tessellator.addVertexWithUV(x1, y2, z2, resx1, resy2);
+ tessellator.addVertexWithUV(x2, y1, z1, resx1, resy1);
+ tessellator.addVertexWithUV(x2, y1, z2, resx2, resy1);
+ tessellator.addVertexWithUV(x2, y2, z2, resx2, resy2);
+ tessellator.addVertexWithUV(x2, y2, z1, resx1, resy2);
+ tessellator.addVertexWithUV(x1, y2, z1, resx1, resy1);
+ tessellator.addVertexWithUV(x2, y2, z1, resx2, resy1);
+ tessellator.addVertexWithUV(x2, y2, z2, resx2, resy2);
+ tessellator.addVertexWithUV(x1, y2, z2, resx1, resy2);
+ tessellator.draw();
+
+ GL11.glDepthMask(true);
+
+ GL11.glEnable(GL11.GL_CULL_FACE);
+ GL11.glEnable(GL11.GL_LIGHTING);
+ GL11.glEnable(GL11.GL_TEXTURE_2D);
+ GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
+ GL11.glPopMatrix();
+ }
+
+ /**
+ * IItemRenderer implementation *
+ */
+ @Override
+ public boolean handleRenderType(ItemStack item, ItemRenderType type) {
+ switch (type) {
+ case ENTITY:
+ return true;
+ case EQUIPPED:
+ return true;
+ case EQUIPPED_FIRST_PERSON:
+ return true;
+ case INVENTORY:
+ return true;
+ default:
+ return false;
+ }
+ }
+
+
+ @Override
+ public boolean shouldUseRenderHelper(ItemRenderType type, ItemStack item, ItemRendererHelper helper) {
+ return true;
+ }
+
+
+ @Override
+ public void renderItem(ItemRenderType type, ItemStack item, Object... data) {
+ switch (type) {
+ case ENTITY:
+ renderConduitItem((RenderBlocks) data[0], item, -0.5f, -0.5f, -0.5f);
+ break;
+ case EQUIPPED:
+ renderConduitItem((RenderBlocks) data[0], item, -0.4f, 0.50f, 0.35f);
+ break;
+ case EQUIPPED_FIRST_PERSON:
+ renderConduitItem((RenderBlocks) data[0], item, -0.4f, 0.50f, 0.35f);
+ break;
+ case INVENTORY:
+ renderConduitItem((RenderBlocks) data[0], item, -0.5f, -0.5f, -0.5f);
+ break;
+ default:
+ }
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/itemRender/TEConduitItemRenderer.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/itemRender/TEConduitItemRenderer.java
new file mode 100644
index 00000000..9e76b9f8
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/itemRender/TEConduitItemRenderer.java
@@ -0,0 +1,96 @@
+package WayofTime.alchemicalWizardry.common.renderer.block.itemRender;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.entity.Entity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.client.IItemRenderer;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import org.lwjgl.opengl.GL11;
+
+import WayofTime.alchemicalWizardry.ModBlocks;
+import WayofTime.alchemicalWizardry.common.renderer.model.ModelConduit;
+import cpw.mods.fml.client.FMLClientHandler;
+
+public class TEConduitItemRenderer implements IItemRenderer
+{
+ private ModelConduit modelConduit = new ModelConduit();
+
+ private void renderConduitItem(RenderBlocks render, ItemStack item, float translateX, float translateY, float translateZ)
+ {
+ Tessellator tessellator = Tessellator.instance;
+
+ Block block = ModBlocks.blockConduit;
+
+ GL11.glDisable(GL11.GL_LIGHTING);
+ GL11.glDisable(GL11.GL_CULL_FACE);
+
+ /**
+ * Render the ghost item inside of the Altar, slowly spinning
+ */
+ GL11.glPushMatrix();
+ GL11.glTranslatef((float) translateX + 0.5F, (float) translateY + 1.5F, (float) translateZ + 0.5F);
+ ResourceLocation test = new ResourceLocation("alchemicalwizardry:textures/models/Conduit.png");
+ FMLClientHandler.instance().getClient().renderEngine.bindTexture(test);
+ GL11.glPushMatrix();
+ GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
+ //GL11.glRotatef(90F, 0.0F, 0.0F, 1.0F);
+ //A reference to your Model file. Again, very important.
+ this.modelConduit.render((Entity) null, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0625F, ForgeDirection.DOWN, ForgeDirection.UP);
+ //Tell it to stop rendering for both the PushMatrix's
+ GL11.glPopMatrix();
+ GL11.glPopMatrix();
+ GL11.glEnable(GL11.GL_CULL_FACE);
+ GL11.glEnable(GL11.GL_LIGHTING);
+ }
+
+
+ /**
+ * IItemRenderer implementation *
+ */
+ @Override
+ public boolean handleRenderType(ItemStack item, ItemRenderType type) {
+ switch (type) {
+ case ENTITY:
+ return true;
+ case EQUIPPED:
+ return true;
+ case EQUIPPED_FIRST_PERSON:
+ return true;
+ case INVENTORY:
+ return true;
+ default:
+ return false;
+ }
+ }
+
+
+ @Override
+ public boolean shouldUseRenderHelper(ItemRenderType type, ItemStack item, ItemRendererHelper helper) {
+ return true;
+ }
+
+
+ @Override
+ public void renderItem(ItemRenderType type, ItemStack item, Object... data) {
+ switch (type) {
+ case ENTITY:
+ renderConduitItem((RenderBlocks) data[0], item, -0.5f, -0.5f, -0.5f);
+ break;
+ case EQUIPPED:
+ renderConduitItem((RenderBlocks) data[0], item, -0.4f, 0.50f, 0.35f);
+ break;
+ case EQUIPPED_FIRST_PERSON:
+ renderConduitItem((RenderBlocks) data[0], item, -0.4f, 0.50f, 0.35f);
+ break;
+ case INVENTORY:
+ renderConduitItem((RenderBlocks) data[0], item, -0.5f, -0.5f, -0.5f);
+ break;
+ default:
+ }
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/itemRender/TESpellEffectBlockItemRenderer.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/itemRender/TESpellEffectBlockItemRenderer.java
new file mode 100644
index 00000000..30cb938a
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/itemRender/TESpellEffectBlockItemRenderer.java
@@ -0,0 +1,108 @@
+package WayofTime.alchemicalWizardry.common.renderer.block.itemRender;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.entity.Entity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.client.IItemRenderer;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import org.lwjgl.opengl.GL11;
+
+import WayofTime.alchemicalWizardry.ModBlocks;
+import WayofTime.alchemicalWizardry.common.renderer.model.ModelSpellEffectBlock;
+import cpw.mods.fml.client.FMLClientHandler;
+
+public class TESpellEffectBlockItemRenderer implements IItemRenderer
+{
+ private ModelSpellEffectBlock modelSpellBlock = new ModelSpellEffectBlock();
+
+ private void renderConduitItem(RenderBlocks render, ItemStack item, float translateX, float translateY, float translateZ)
+ {
+ Tessellator tessellator = Tessellator.instance;
+
+ Block block = ModBlocks.blockSpellEffect;
+ //Icon icon = item.getItem().getIconFromDamage(0);
+
+ GL11.glDisable(GL11.GL_LIGHTING);
+ GL11.glDisable(GL11.GL_CULL_FACE);
+ /**
+ * Render the ghost item inside of the Altar, slowly spinning
+ */
+ GL11.glPushMatrix();
+ GL11.glTranslatef((float) translateX + 0.5F, (float) translateY + 1.5F, (float) translateZ + 0.5F);
+ ResourceLocation test = new ResourceLocation(this.getResourceLocationForMeta(item.getItemDamage()));
+
+ FMLClientHandler.instance().getClient().renderEngine.bindTexture(test);
+ GL11.glPushMatrix();
+ GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
+ //GL11.glRotatef(90F, 0.0F, 0.0F, 1.0F);
+ //A reference to your Model file. Again, very important.
+ this.modelSpellBlock.render((Entity) null, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0625F, ForgeDirection.DOWN, ForgeDirection.UP);
+ //Tell it to stop rendering for both the PushMatrix's
+ GL11.glPopMatrix();
+ GL11.glPopMatrix();
+ GL11.glEnable(GL11.GL_CULL_FACE);
+ GL11.glEnable(GL11.GL_LIGHTING);
+ }
+
+
+ /**
+ * IItemRenderer implementation *
+ */
+ @Override
+ public boolean handleRenderType(ItemStack item, ItemRenderType type) {
+ switch (type) {
+ case ENTITY:
+ return true;
+ case EQUIPPED:
+ return true;
+ case EQUIPPED_FIRST_PERSON:
+ return true;
+ case INVENTORY:
+ return true;
+ default:
+ return false;
+ }
+ }
+
+
+ @Override
+ public boolean shouldUseRenderHelper(ItemRenderType type, ItemStack item, ItemRendererHelper helper) {
+ return true;
+ }
+
+
+ @Override
+ public void renderItem(ItemRenderType type, ItemStack item, Object... data) {
+ switch (type) {
+ case ENTITY:
+ renderConduitItem((RenderBlocks) data[0], item, -0.5f, -0.5f, -0.5f);
+ break;
+ case EQUIPPED:
+ renderConduitItem((RenderBlocks) data[0], item, -0.4f, 0.50f, 0.35f);
+ break;
+ case EQUIPPED_FIRST_PERSON:
+ renderConduitItem((RenderBlocks) data[0], item, -0.4f, 0.50f, 0.35f);
+ break;
+ case INVENTORY:
+ renderConduitItem((RenderBlocks) data[0], item, -0.5f, -0.5f, -0.5f);
+ break;
+ default:
+ }
+ }
+
+ public String getResourceLocationForMeta(int meta)
+ {
+ switch(meta)
+ {
+ case 0: return "alchemicalwizardry:textures/models/SpellEffectFire.png";
+ case 1: return "alchemicalwizardry:textures/models/SpellEffectIce.png";
+ case 2: return "alchemicalwizardry:textures/models/SpellEffectWind.png";
+ case 3: return "alchemicalwizardry:textures/models/SpellEffectEarth.png";
+ }
+ return "";
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/itemRender/TESpellEnhancementBlockItemRenderer.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/itemRender/TESpellEnhancementBlockItemRenderer.java
new file mode 100644
index 00000000..a25da6d7
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/itemRender/TESpellEnhancementBlockItemRenderer.java
@@ -0,0 +1,114 @@
+package WayofTime.alchemicalWizardry.common.renderer.block.itemRender;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.entity.Entity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.client.IItemRenderer;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import org.lwjgl.opengl.GL11;
+
+import WayofTime.alchemicalWizardry.ModBlocks;
+import WayofTime.alchemicalWizardry.common.renderer.model.ModelSpellEnhancementBlock;
+import cpw.mods.fml.client.FMLClientHandler;
+
+public class TESpellEnhancementBlockItemRenderer implements IItemRenderer
+{
+ private ModelSpellEnhancementBlock modelSpellBlock = new ModelSpellEnhancementBlock();
+
+ private void renderConduitItem(RenderBlocks render, ItemStack item, float translateX, float translateY, float translateZ)
+ {
+ Tessellator tessellator = Tessellator.instance;
+
+ Block block = ModBlocks.blockSpellEffect;
+ //Icon icon = item.getItem().getIconFromDamage(0);
+
+ GL11.glDisable(GL11.GL_LIGHTING);
+ GL11.glDisable(GL11.GL_CULL_FACE);
+ /**
+ * Render the ghost item inside of the Altar, slowly spinning
+ */
+ GL11.glPushMatrix();
+ GL11.glTranslatef((float) translateX + 0.5F, (float) translateY + 1.5F, (float) translateZ + 0.5F);
+ ResourceLocation test = new ResourceLocation(this.getResourceLocationForMeta(item.getItemDamage()));
+
+ FMLClientHandler.instance().getClient().renderEngine.bindTexture(test);
+ GL11.glPushMatrix();
+ GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
+ //GL11.glRotatef(90F, 0.0F, 0.0F, 1.0F);
+ //A reference to your Model file. Again, very important.
+ this.modelSpellBlock.render((Entity) null, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0625F, ForgeDirection.DOWN, ForgeDirection.UP);
+ //Tell it to stop rendering for both the PushMatrix's
+ GL11.glPopMatrix();
+ GL11.glPopMatrix();
+ GL11.glEnable(GL11.GL_CULL_FACE);
+ GL11.glEnable(GL11.GL_LIGHTING);
+ }
+
+
+ /**
+ * IItemRenderer implementation *
+ */
+ @Override
+ public boolean handleRenderType(ItemStack item, ItemRenderType type) {
+ switch (type) {
+ case ENTITY:
+ return true;
+ case EQUIPPED:
+ return true;
+ case EQUIPPED_FIRST_PERSON:
+ return true;
+ case INVENTORY:
+ return true;
+ default:
+ return false;
+ }
+ }
+
+
+ @Override
+ public boolean shouldUseRenderHelper(ItemRenderType type, ItemStack item, ItemRendererHelper helper) {
+ return true;
+ }
+
+
+ @Override
+ public void renderItem(ItemRenderType type, ItemStack item, Object... data) {
+ switch (type) {
+ case ENTITY:
+ renderConduitItem((RenderBlocks) data[0], item, -0.5f, -0.5f, -0.5f);
+ break;
+ case EQUIPPED:
+ renderConduitItem((RenderBlocks) data[0], item, -0.4f, 0.50f, 0.35f);
+ break;
+ case EQUIPPED_FIRST_PERSON:
+ renderConduitItem((RenderBlocks) data[0], item, -0.4f, 0.50f, 0.35f);
+ break;
+ case INVENTORY:
+ renderConduitItem((RenderBlocks) data[0], item, -0.5f, -0.5f, -0.5f);
+ break;
+ default:
+ }
+ }
+
+ public String getResourceLocationForMeta(int meta)
+ {
+ switch(meta)
+ {
+ case 0: return "alchemicalwizardry:textures/models/SpellEnhancementPower1.png";
+ case 1: return "alchemicalwizardry:textures/models/SpellEnhancementPower2.png";
+ case 2: return "alchemicalwizardry:textures/models/SpellEnhancementPower3.png";
+ case 5: return "alchemicalwizardry:textures/models/SpellEnhancementCost1.png";
+ case 6: return "alchemicalwizardry:textures/models/SpellEnhancementCost2.png";
+ case 7: return "alchemicalwizardry:textures/models/SpellEnhancementCost3.png";
+ case 10: return "alchemicalwizardry:textures/models/SpellEnhancementPotency1.png";
+ case 11: return "alchemicalwizardry:textures/models/SpellEnhancementPotency2.png";
+ case 12: return "alchemicalwizardry:textures/models/SpellEnhancementPotency3.png";
+
+ }
+ return "alchemicalwizardry:textures/models/SpellEnhancementPower1.png";
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/itemRender/TESpellModifierBlockItemRenderer.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/itemRender/TESpellModifierBlockItemRenderer.java
new file mode 100644
index 00000000..c7809540
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/itemRender/TESpellModifierBlockItemRenderer.java
@@ -0,0 +1,108 @@
+package WayofTime.alchemicalWizardry.common.renderer.block.itemRender;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.entity.Entity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.client.IItemRenderer;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import org.lwjgl.opengl.GL11;
+
+import WayofTime.alchemicalWizardry.ModBlocks;
+import WayofTime.alchemicalWizardry.common.renderer.model.ModelSpellModifierBlock;
+import cpw.mods.fml.client.FMLClientHandler;
+
+public class TESpellModifierBlockItemRenderer implements IItemRenderer
+{
+ private ModelSpellModifierBlock modelSpellBlock = new ModelSpellModifierBlock();
+
+ private void renderConduitItem(RenderBlocks render, ItemStack item, float translateX, float translateY, float translateZ)
+ {
+ Tessellator tessellator = Tessellator.instance;
+
+ Block block = ModBlocks.blockSpellEffect;
+ //Icon icon = item.getItem().getIconFromDamage(0);
+
+ GL11.glDisable(GL11.GL_LIGHTING);
+ GL11.glDisable(GL11.GL_CULL_FACE);
+ /**
+ * Render the ghost item inside of the Altar, slowly spinning
+ */
+ GL11.glPushMatrix();
+ GL11.glTranslatef((float) translateX + 0.5F, (float) translateY + 1.5F, (float) translateZ + 0.5F);
+ ResourceLocation test = new ResourceLocation(this.getResourceLocationForMeta(item.getItemDamage()));
+
+ FMLClientHandler.instance().getClient().renderEngine.bindTexture(test);
+ GL11.glPushMatrix();
+ GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
+ //GL11.glRotatef(90F, 0.0F, 0.0F, 1.0F);
+ //A reference to your Model file. Again, very important.
+ this.modelSpellBlock.render((Entity) null, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0625F, ForgeDirection.DOWN, ForgeDirection.UP);
+ //Tell it to stop rendering for both the PushMatrix's
+ GL11.glPopMatrix();
+ GL11.glPopMatrix();
+ GL11.glEnable(GL11.GL_CULL_FACE);
+ GL11.glEnable(GL11.GL_LIGHTING);
+ }
+
+
+ /**
+ * IItemRenderer implementation *
+ */
+ @Override
+ public boolean handleRenderType(ItemStack item, ItemRenderType type) {
+ switch (type) {
+ case ENTITY:
+ return true;
+ case EQUIPPED:
+ return true;
+ case EQUIPPED_FIRST_PERSON:
+ return true;
+ case INVENTORY:
+ return true;
+ default:
+ return false;
+ }
+ }
+
+
+ @Override
+ public boolean shouldUseRenderHelper(ItemRenderType type, ItemStack item, ItemRendererHelper helper) {
+ return true;
+ }
+
+
+ @Override
+ public void renderItem(ItemRenderType type, ItemStack item, Object... data) {
+ switch (type) {
+ case ENTITY:
+ renderConduitItem((RenderBlocks) data[0], item, -0.5f, -0.5f, -0.5f);
+ break;
+ case EQUIPPED:
+ renderConduitItem((RenderBlocks) data[0], item, -0.4f, 0.50f, 0.35f);
+ break;
+ case EQUIPPED_FIRST_PERSON:
+ renderConduitItem((RenderBlocks) data[0], item, -0.4f, 0.50f, 0.35f);
+ break;
+ case INVENTORY:
+ renderConduitItem((RenderBlocks) data[0], item, -0.5f, -0.5f, -0.5f);
+ break;
+ default:
+ }
+ }
+
+ public String getResourceLocationForMeta(int meta)
+ {
+ switch(meta)
+ {
+ case 0: return "alchemicalwizardry:textures/models/SpellModifierDefault.png";
+ case 1: return "alchemicalwizardry:textures/models/SpellModifierOffensive.png";
+ case 2: return "alchemicalwizardry:textures/models/SpellModifierDefensive.png";
+ case 3: return "alchemicalwizardry:textures/models/SpellModifierEnvironmental.png";
+ }
+ return "alchemicalwizardry:textures/models/SpellModifierDefault.png";
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/itemRender/TESpellParadigmBlockItemRenderer.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/itemRender/TESpellParadigmBlockItemRenderer.java
new file mode 100644
index 00000000..848d36ae
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/itemRender/TESpellParadigmBlockItemRenderer.java
@@ -0,0 +1,108 @@
+package WayofTime.alchemicalWizardry.common.renderer.block.itemRender;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.entity.Entity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.client.IItemRenderer;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import org.lwjgl.opengl.GL11;
+
+import WayofTime.alchemicalWizardry.ModBlocks;
+import WayofTime.alchemicalWizardry.common.renderer.model.ModelSpellParadigmBlock;
+import cpw.mods.fml.client.FMLClientHandler;
+
+public class TESpellParadigmBlockItemRenderer implements IItemRenderer
+{
+ private ModelSpellParadigmBlock modelSpellBlock = new ModelSpellParadigmBlock();
+
+ private void renderConduitItem(RenderBlocks render, ItemStack item, float translateX, float translateY, float translateZ)
+ {
+ Tessellator tessellator = Tessellator.instance;
+
+ Block block = ModBlocks.blockSpellEffect;
+ //Icon icon = item.getItem().getIconFromDamage(0);
+
+ GL11.glDisable(GL11.GL_LIGHTING);
+ GL11.glDisable(GL11.GL_CULL_FACE);
+ /**
+ * Render the ghost item inside of the Altar, slowly spinning
+ */
+ GL11.glPushMatrix();
+ GL11.glTranslatef((float) translateX + 0.5F, (float) translateY + 1.5F, (float) translateZ + 0.5F);
+ ResourceLocation test = new ResourceLocation(this.getResourceLocationForMeta(item.getItemDamage()));
+
+ FMLClientHandler.instance().getClient().renderEngine.bindTexture(test);
+ GL11.glPushMatrix();
+ GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
+ //GL11.glRotatef(90F, 0.0F, 0.0F, 1.0F);
+ //A reference to your Model file. Again, very important.
+ this.modelSpellBlock.render((Entity) null, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0625F, ForgeDirection.DOWN, ForgeDirection.UP);
+ //Tell it to stop rendering for both the PushMatrix's
+ GL11.glPopMatrix();
+ GL11.glPopMatrix();
+ GL11.glEnable(GL11.GL_CULL_FACE);
+ GL11.glEnable(GL11.GL_LIGHTING);
+ }
+
+
+ /**
+ * IItemRenderer implementation *
+ */
+ @Override
+ public boolean handleRenderType(ItemStack item, ItemRenderType type) {
+ switch (type) {
+ case ENTITY:
+ return true;
+ case EQUIPPED:
+ return true;
+ case EQUIPPED_FIRST_PERSON:
+ return true;
+ case INVENTORY:
+ return true;
+ default:
+ return false;
+ }
+ }
+
+
+ @Override
+ public boolean shouldUseRenderHelper(ItemRenderType type, ItemStack item, ItemRendererHelper helper) {
+ return true;
+ }
+
+
+ @Override
+ public void renderItem(ItemRenderType type, ItemStack item, Object... data) {
+ switch (type) {
+ case ENTITY:
+ renderConduitItem((RenderBlocks) data[0], item, -0.5f, -0.5f, -0.5f);
+ break;
+ case EQUIPPED:
+ renderConduitItem((RenderBlocks) data[0], item, -0.4f, 0.50f, 0.35f);
+ break;
+ case EQUIPPED_FIRST_PERSON:
+ renderConduitItem((RenderBlocks) data[0], item, -0.4f, 0.50f, 0.35f);
+ break;
+ case INVENTORY:
+ renderConduitItem((RenderBlocks) data[0], item, -0.5f, -0.5f, -0.5f);
+ break;
+ default:
+ }
+ }
+
+ public String getResourceLocationForMeta(int meta)
+ {
+ switch(meta)
+ {
+ case 0: return "alchemicalwizardry:textures/models/SpellParadigmProjectile.png";
+ case 1: return "alchemicalwizardry:textures/models/SpellParadigmSelf.png";
+ case 2: return "alchemicalwizardry:textures/models/SpellParadigmMelee.png";
+ case 3: return "alchemicalwizardry:textures/models/SpellParadigmTool.png";
+ }
+ return "alchemicalwizardry:textures/models/SpellParadigmProjectile.png";
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/itemRender/TEWritingTableItemRenderer.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/itemRender/TEWritingTableItemRenderer.java
new file mode 100644
index 00000000..9705879c
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/block/itemRender/TEWritingTableItemRenderer.java
@@ -0,0 +1,82 @@
+package WayofTime.alchemicalWizardry.common.renderer.block.itemRender;
+
+import WayofTime.alchemicalWizardry.common.renderer.model.ModelWritingTable;
+import cpw.mods.fml.client.FMLClientHandler;
+import net.minecraft.entity.Entity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.client.IItemRenderer;
+import org.lwjgl.opengl.GL11;
+
+public class TEWritingTableItemRenderer implements IItemRenderer
+{
+ private ModelWritingTable modelBloodAltar;
+
+ public TEWritingTableItemRenderer()
+ {
+ modelBloodAltar = new ModelWritingTable();
+ }
+
+ @Override
+ public boolean handleRenderType(ItemStack item, ItemRenderType type)
+ {
+ // TODO Auto-generated method stub
+ return true;
+ }
+
+ @Override
+ public boolean shouldUseRenderHelper(ItemRenderType type, ItemStack item, ItemRendererHelper helper)
+ {
+ // TODO Auto-generated method stub
+ return true;
+ }
+
+ @Override
+ public void renderItem(ItemRenderType type, ItemStack item, Object... data)
+ {
+ float scale = 0.08f;
+
+ // TODO Auto-generated method stub
+ switch (type)
+ {
+ case ENTITY:
+ {
+ renderBloodAltar(0f, 0f, 0f, scale);
+ return;
+ }
+
+ case EQUIPPED:
+ {
+ renderBloodAltar(0f, 0f, 0f, scale);
+ return;
+ }
+
+ case INVENTORY:
+ {
+ renderBloodAltar(0f, -0.25f, 0f, scale);
+ return;
+ }
+
+ default:
+ return;
+ }
+ }
+
+ private void renderBloodAltar(float x, float y, float z, float scale)
+ {
+ GL11.glPushMatrix();
+ // Disable Lighting Calculations
+ GL11.glDisable(GL11.GL_LIGHTING);
+ GL11.glTranslatef(x, y, z);
+ GL11.glScalef(scale, scale, scale);
+ GL11.glRotatef(180f, 0f, 1f, 0f);
+ //FMLClientHandler.instance().getClient().renderEngine.bindTexture("/mods/OBJTutorial/textures/models/TutBox.png");
+ ResourceLocation test = new ResourceLocation("alchemicalwizardry:textures/models/WritingTable.png");
+ //FMLClientHandler.instance().getClient().renderEngine.bindTexture("/mods/alchemicalwizardry/textures/models/altar.png");
+ FMLClientHandler.instance().getClient().renderEngine.bindTexture(test);
+ modelBloodAltar.render((Entity) null, 0, 0, 0, 0, 0, 0);
+ // Re-enable Lighting Calculations
+ GL11.glEnable(GL11.GL_LIGHTING);
+ GL11.glPopMatrix();
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/mob/RenderBileDemon.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/mob/RenderBileDemon.java
new file mode 100644
index 00000000..b09c6ca7
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/mob/RenderBileDemon.java
@@ -0,0 +1,27 @@
+package WayofTime.alchemicalWizardry.common.renderer.mob;
+
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityBileDemon;
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.renderer.entity.RenderLiving;
+import net.minecraft.entity.Entity;
+import net.minecraft.util.ResourceLocation;
+
+public class RenderBileDemon extends RenderLiving
+{
+ private static final ResourceLocation field_110833_a = new ResourceLocation("alchemicalwizardry", "textures/models/BileDemon.png"); //refers to:YourMod/modelsTextureFile/optionalFile/yourTexture.png
+
+ public RenderBileDemon(ModelBase par1ModelBase, float par2)
+ {
+ super(par1ModelBase, par2);
+ }
+
+ public ResourceLocation func_110832_a(EntityBileDemon par1EntityBileDemon)
+ {
+ return field_110833_a;
+ }
+
+ public ResourceLocation getEntityTexture(Entity par1Entity)
+ {
+ return this.func_110832_a((EntityBileDemon) par1Entity);
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/mob/RenderBoulderFist.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/mob/RenderBoulderFist.java
new file mode 100644
index 00000000..6db35edd
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/mob/RenderBoulderFist.java
@@ -0,0 +1,27 @@
+package WayofTime.alchemicalWizardry.common.renderer.mob;
+
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityBoulderFist;
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.renderer.entity.RenderLiving;
+import net.minecraft.entity.Entity;
+import net.minecraft.util.ResourceLocation;
+
+public class RenderBoulderFist extends RenderLiving
+{
+ private static final ResourceLocation field_110833_a = new ResourceLocation("alchemicalwizardry", "textures/models/BoulderFist.png"); //refers to:YourMod/modelsTextureFile/optionalFile/yourTexture.png
+
+ public RenderBoulderFist(ModelBase par1ModelBase, float par2)
+ {
+ super(par1ModelBase, par2);
+ }
+
+ public ResourceLocation func_110832_a(EntityBoulderFist par1EntityBoulderFist)
+ {
+ return field_110833_a;
+ }
+
+ public ResourceLocation getEntityTexture(Entity par1Entity)
+ {
+ return this.func_110832_a((EntityBoulderFist) par1Entity);
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/mob/RenderElemental.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/mob/RenderElemental.java
new file mode 100644
index 00000000..485adc3a
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/mob/RenderElemental.java
@@ -0,0 +1,63 @@
+package WayofTime.alchemicalWizardry.common.renderer.mob;
+
+import WayofTime.alchemicalWizardry.common.EntityAirElemental;
+import WayofTime.alchemicalWizardry.common.entity.mob.*;
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.renderer.entity.RenderLiving;
+import net.minecraft.entity.Entity;
+import net.minecraft.util.ResourceLocation;
+
+public class RenderElemental extends RenderLiving
+{
+ private static final ResourceLocation airBeacon = new ResourceLocation("alchemicalwizardry", "textures/models/AirFloatingBeacon.png"); //refers to:YourMod/modelsTextureFile/optionalFile/yourTexture.png
+ private static final ResourceLocation waterBeacon = new ResourceLocation("alchemicalwizardry", "textures/models/WaterFloatingBeacon.png");
+ private static final ResourceLocation earthBeacon = new ResourceLocation("alchemicalwizardry", "textures/models/EarthFloatingBeacon.png");
+ private static final ResourceLocation fireBeacon = new ResourceLocation("alchemicalwizardry", "textures/models/FireFloatingBeacon.png");
+ private static final ResourceLocation shadeBeacon = new ResourceLocation("alchemicalwizardry", "textures/models/DarkFloatingBeacon.png");
+ private static final ResourceLocation holyBeacon = new ResourceLocation("alchemicalwizardry", "textures/models/HolyFloatingBeacon.png");
+
+ public RenderElemental(ModelBase par1ModelBase, float par2)
+ {
+ super(par1ModelBase, par2);
+ }
+
+ public ResourceLocation func_110832_a(EntityElemental par1EntityElemental)
+ {
+ if (par1EntityElemental instanceof EntityAirElemental)
+ {
+ return airBeacon;
+ }
+
+ if (par1EntityElemental instanceof EntityWaterElemental)
+ {
+ return waterBeacon;
+ }
+
+ if (par1EntityElemental instanceof EntityEarthElemental)
+ {
+ return earthBeacon;
+ }
+
+ if (par1EntityElemental instanceof EntityFireElemental)
+ {
+ return fireBeacon;
+ }
+
+ if (par1EntityElemental instanceof EntityShadeElemental)
+ {
+ return shadeBeacon;
+ }
+
+ if (par1EntityElemental instanceof EntityHolyElemental)
+ {
+ return holyBeacon;
+ }
+
+ return airBeacon;
+ }
+
+ public ResourceLocation getEntityTexture(Entity par1Entity)
+ {
+ return this.func_110832_a((EntityElemental) par1Entity);
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/mob/RenderFallenAngel.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/mob/RenderFallenAngel.java
new file mode 100644
index 00000000..28a18eaa
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/mob/RenderFallenAngel.java
@@ -0,0 +1,30 @@
+package WayofTime.alchemicalWizardry.common.renderer.mob;
+
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityFallenAngel;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.renderer.entity.RenderLiving;
+import net.minecraft.entity.Entity;
+import net.minecraft.util.ResourceLocation;
+
+@SideOnly(Side.CLIENT)
+public class RenderFallenAngel extends RenderLiving
+{
+ private static final ResourceLocation field_110833_a = new ResourceLocation("alchemicalwizardry", "textures/models/WingedAngel.png"); //refers to:YourMod/modelsTextureFile/optionalFile/yourTexture.png
+
+ public RenderFallenAngel(ModelBase par1ModelBase, float par2)
+ {
+ super(par1ModelBase, par2);
+ }
+
+ public ResourceLocation func_110832_a(EntityFallenAngel par1EntityFallenAngel)
+ {
+ return field_110833_a;
+ }
+
+ public ResourceLocation getEntityTexture(Entity par1Entity)
+ {
+ return this.func_110832_a((EntityFallenAngel) par1Entity);
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/mob/RenderIceDemon.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/mob/RenderIceDemon.java
new file mode 100644
index 00000000..e7dd7219
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/mob/RenderIceDemon.java
@@ -0,0 +1,27 @@
+package WayofTime.alchemicalWizardry.common.renderer.mob;
+
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityIceDemon;
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.renderer.entity.RenderLiving;
+import net.minecraft.entity.Entity;
+import net.minecraft.util.ResourceLocation;
+
+public class RenderIceDemon extends RenderLiving
+{
+ private static final ResourceLocation field_110833_a = new ResourceLocation("alchemicalwizardry", "textures/models/IceDemon.png"); //refers to:YourMod/modelsTextureFile/optionalFile/yourTexture.png
+
+ public RenderIceDemon(ModelBase par1ModelBase, float par2)
+ {
+ super(par1ModelBase, par2);
+ }
+
+ public ResourceLocation func_110832_a(EntityIceDemon par1EntityIceDemon)
+ {
+ return field_110833_a;
+ }
+
+ public ResourceLocation getEntityTexture(Entity par1Entity)
+ {
+ return this.func_110832_a((EntityIceDemon) par1Entity);
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/mob/RenderLowerGuardian.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/mob/RenderLowerGuardian.java
new file mode 100644
index 00000000..4eeaa4d3
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/mob/RenderLowerGuardian.java
@@ -0,0 +1,27 @@
+package WayofTime.alchemicalWizardry.common.renderer.mob;
+
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityLowerGuardian;
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.renderer.entity.RenderLiving;
+import net.minecraft.entity.Entity;
+import net.minecraft.util.ResourceLocation;
+
+public class RenderLowerGuardian extends RenderLiving
+{
+ private static final ResourceLocation field_110833_a = new ResourceLocation("alchemicalwizardry", "textures/models/LowerGuardian.png"); //refers to:YourMod/modelsTextureFile/optionalFile/yourTexture.png
+
+ public RenderLowerGuardian(ModelBase par1ModelBase, float par2)
+ {
+ super(par1ModelBase, par2);
+ }
+
+ public ResourceLocation func_110832_a(EntityLowerGuardian par1EntityLowerGuardian)
+ {
+ return field_110833_a;
+ }
+
+ public ResourceLocation getEntityTexture(Entity par1Entity)
+ {
+ return this.func_110832_a((EntityLowerGuardian) par1Entity);
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/mob/RenderShade.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/mob/RenderShade.java
new file mode 100644
index 00000000..38868202
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/mob/RenderShade.java
@@ -0,0 +1,27 @@
+package WayofTime.alchemicalWizardry.common.renderer.mob;
+
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityShade;
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.renderer.entity.RenderLiving;
+import net.minecraft.entity.Entity;
+import net.minecraft.util.ResourceLocation;
+
+public class RenderShade extends RenderLiving
+{
+ private static final ResourceLocation field_110833_a = new ResourceLocation("alchemicalwizardry", "textures/models/ShadeMob.png"); //refers to:YourMod/modelsTextureFile/optionalFile/yourTexture.png
+
+ public RenderShade(ModelBase par1ModelBase, float par2)
+ {
+ super(par1ModelBase, par2);
+ }
+
+ public ResourceLocation func_110832_a(EntityShade par1EntityShade)
+ {
+ return field_110833_a;
+ }
+
+ public ResourceLocation getEntityTexture(Entity par1Entity)
+ {
+ return this.func_110832_a((EntityShade) par1Entity);
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/mob/RenderSmallEarthGolem.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/mob/RenderSmallEarthGolem.java
new file mode 100644
index 00000000..16772df4
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/mob/RenderSmallEarthGolem.java
@@ -0,0 +1,27 @@
+package WayofTime.alchemicalWizardry.common.renderer.mob;
+
+import WayofTime.alchemicalWizardry.common.entity.mob.EntitySmallEarthGolem;
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.renderer.entity.RenderLiving;
+import net.minecraft.entity.Entity;
+import net.minecraft.util.ResourceLocation;
+
+public class RenderSmallEarthGolem extends RenderLiving
+{
+ private static final ResourceLocation field_110833_a = new ResourceLocation("alchemicalwizardry", "textures/models/SmallEarthGolem.png"); //refers to:YourMod/modelsTextureFile/optionalFile/yourTexture.png
+
+ public RenderSmallEarthGolem(ModelBase par1ModelBase, float par2)
+ {
+ super(par1ModelBase, par2);
+ }
+
+ public ResourceLocation func_110832_a(EntitySmallEarthGolem par1EntitySmallEarthGolem)
+ {
+ return field_110833_a;
+ }
+
+ public ResourceLocation getEntityTexture(Entity par1Entity)
+ {
+ return this.func_110832_a((EntitySmallEarthGolem) par1Entity);
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/mob/RenderWingedFireDemon.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/mob/RenderWingedFireDemon.java
new file mode 100644
index 00000000..826f7832
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/mob/RenderWingedFireDemon.java
@@ -0,0 +1,27 @@
+package WayofTime.alchemicalWizardry.common.renderer.mob;
+
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityWingedFireDemon;
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.renderer.entity.RenderLiving;
+import net.minecraft.entity.Entity;
+import net.minecraft.util.ResourceLocation;
+
+public class RenderWingedFireDemon extends RenderLiving
+{
+ private static final ResourceLocation field_110833_a = new ResourceLocation("alchemicalwizardry", "textures/models/WingedFireDemon.png"); //refers to:YourMod/modelsTextureFile/optionalFile/yourTexture.png
+
+ public RenderWingedFireDemon(ModelBase par1ModelBase, float par2)
+ {
+ super(par1ModelBase, par2);
+ }
+
+ public ResourceLocation func_110832_a(EntityWingedFireDemon par1EntityWingedFireDemon)
+ {
+ return field_110833_a;
+ }
+
+ public ResourceLocation getEntityTexture(Entity par1Entity)
+ {
+ return this.func_110832_a((EntityWingedFireDemon) par1Entity);
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelAlchemicalCalcinator.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelAlchemicalCalcinator.java
new file mode 100644
index 00000000..499d34c5
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelAlchemicalCalcinator.java
@@ -0,0 +1,140 @@
+package WayofTime.alchemicalWizardry.common.renderer.model;
+
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.model.ModelRenderer;
+import net.minecraft.entity.Entity;
+
+public class ModelAlchemicalCalcinator extends ModelBase
+{
+ //fields
+ ModelRenderer top1;
+ ModelRenderer top2;
+ ModelRenderer top3;
+ ModelRenderer top4;
+ ModelRenderer tank;
+ ModelRenderer centreCollumn;
+ ModelRenderer furnaceShape;
+ ModelRenderer glassWindow;
+ ModelRenderer Shape1;
+ ModelRenderer Shape2;
+ ModelRenderer Shape3;
+ ModelRenderer Shape4;
+ ModelRenderer Shape5;
+
+ public ModelAlchemicalCalcinator()
+ {
+ textureWidth = 128;
+ textureHeight = 128;
+
+ top1 = new ModelRenderer(this, 0, 34);
+ top1.addBox(4F, -8F, -8F, 4, 3, 16);
+ top1.setRotationPoint(0F, 16F, 0F);
+ top1.setTextureSize(128, 128);
+ top1.mirror = true;
+ setRotation(top1, 0F, 0F, 0F);
+ top2 = new ModelRenderer(this, 41, 34);
+ top2.addBox(-8F, -8F, -8F, 4, 3, 16);
+ top2.setRotationPoint(0F, 16F, 0F);
+ top2.setTextureSize(128, 128);
+ top2.mirror = true;
+ setRotation(top2, 0F, 0F, 0F);
+ top3 = new ModelRenderer(this, 25, 55);
+ top3.addBox(-4F, -8F, 4F, 8, 3, 4);
+ top3.setRotationPoint(0F, 16F, 0F);
+ top3.setTextureSize(128, 128);
+ top3.mirror = true;
+ setRotation(top3, 0F, 0F, 0F);
+ top4 = new ModelRenderer(this, 0, 55);
+ top4.addBox(-4F, -8F, -8F, 8, 3, 4);
+ top4.setRotationPoint(0F, 16F, 0F);
+ top4.setTextureSize(128, 128);
+ top4.mirror = true;
+ setRotation(top4, 0F, 0F, 0F);
+ tank = new ModelRenderer(this, 0, 0);
+ tank.addBox(-8F, -5F, -8F, 16, 4, 16);
+ tank.setRotationPoint(0F, 16F, 0F);
+ tank.setTextureSize(128, 128);
+ tank.mirror = true;
+ setRotation(tank, 0F, 0F, 0F);
+ centreCollumn = new ModelRenderer(this, 0, 21);
+ centreCollumn.addBox(-4F, -5F, -4F, 8, 4, 8);
+ centreCollumn.setRotationPoint(0F, 16F, 0F);
+ centreCollumn.setTextureSize(128, 128);
+ centreCollumn.mirror = true;
+ setRotation(centreCollumn, 0F, 0F, 0F);
+ furnaceShape = new ModelRenderer(this, 0, 63);
+ furnaceShape.addBox(-8F, -1F, -8F, 16, 5, 16);
+ furnaceShape.setRotationPoint(0F, 16F, 0F);
+ furnaceShape.setTextureSize(128, 128);
+ furnaceShape.mirror = true;
+ setRotation(furnaceShape, 0F, 0F, 0F);
+ glassWindow = new ModelRenderer(this, 0, 85);
+ glassWindow.addBox(-4F, -8F, -4F, 8, 0, 8);
+ glassWindow.setRotationPoint(0F, 16F, 0F);
+ glassWindow.setTextureSize(128, 128);
+ glassWindow.mirror = true;
+ setRotation(glassWindow, 0F, 0F, 0F);
+ Shape1 = new ModelRenderer(this, 0, 94);
+ Shape1.addBox(-8F, 4F, -8F, 4, 4, 4);
+ Shape1.setRotationPoint(0F, 16F, 0F);
+ Shape1.setTextureSize(128, 128);
+ Shape1.mirror = true;
+ setRotation(Shape1, 0F, 0F, 0F);
+ Shape2 = new ModelRenderer(this, 0, 103);
+ Shape2.addBox(-4F, 6F, -4F, 8, 1, 8);
+ Shape2.setRotationPoint(0F, 16F, 0F);
+ Shape2.setTextureSize(128, 128);
+ Shape2.mirror = true;
+ setRotation(Shape2, 0F, 0F, 0F);
+ Shape3 = new ModelRenderer(this, 0, 94);
+ Shape3.addBox(4F, 4F, -8F, 4, 4, 4);
+ Shape3.setRotationPoint(0F, 16F, 0F);
+ Shape3.setTextureSize(128, 128);
+ Shape3.mirror = true;
+ setRotation(Shape3, 0F, 0F, 0F);
+ Shape4 = new ModelRenderer(this, 0, 94);
+ Shape4.addBox(-8F, 4F, 4F, 4, 4, 4);
+ Shape4.setRotationPoint(0F, 16F, 0F);
+ Shape4.setTextureSize(128, 128);
+ Shape4.mirror = true;
+ setRotation(Shape4, 0F, 0F, 0F);
+ Shape5 = new ModelRenderer(this, 0, 94);
+ Shape5.addBox(4F, 4F, 4F, 4, 4, 4);
+ Shape5.setRotationPoint(0F, 16F, 0F);
+ Shape5.setTextureSize(128, 128);
+ Shape5.mirror = true;
+ setRotation(Shape5, 0F, 0F, 0F);
+ }
+
+ public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
+ {
+ super.render(entity, f, f1, f2, f3, f4, f5);
+ setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ top1.render(f5);
+ top2.render(f5);
+ top3.render(f5);
+ top4.render(f5);
+ tank.render(f5);
+ centreCollumn.render(f5);
+ furnaceShape.render(f5);
+ glassWindow.render(f5);
+ Shape1.render(f5);
+ Shape2.render(f5);
+ Shape3.render(f5);
+ Shape4.render(f5);
+ Shape5.render(f5);
+ }
+
+ private void setRotation(ModelRenderer model, float x, float y, float z)
+ {
+ model.rotateAngleX = x;
+ model.rotateAngleY = y;
+ model.rotateAngleZ = z;
+ }
+
+ public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
+ {
+ super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ }
+
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelBileDemon.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelBileDemon.java
new file mode 100644
index 00000000..e09db58e
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelBileDemon.java
@@ -0,0 +1,181 @@
+package WayofTime.alchemicalWizardry.common.renderer.model;
+
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.model.ModelRenderer;
+import net.minecraft.entity.Entity;
+import net.minecraft.util.MathHelper;
+import org.lwjgl.opengl.GL11;
+
+public class ModelBileDemon extends ModelBase
+{
+ //fields
+ ModelRenderer belly;
+ ModelRenderer chest;
+ ModelRenderer head;
+ ModelRenderer nose;
+ ModelRenderer leftHorn;
+ ModelRenderer leftArmSpacer;
+ ModelRenderer leftArm;
+ ModelRenderer leftChain;
+ ModelRenderer leftBall;
+ ModelRenderer rightHorn;
+ ModelRenderer rightChain;
+ ModelRenderer rightBall;
+ ModelRenderer rightArmSpacer;
+ ModelRenderer rightArm;
+
+ public ModelBileDemon()
+ {
+ textureWidth = 128;
+ textureHeight = 64;
+ belly = new ModelRenderer(this, 0, 31);
+ belly.addBox(-8F, -1F, -10F, 16, 15, 18);
+ belly.setRotationPoint(0F, 10F, 0F);
+ belly.setTextureSize(128, 64);
+ belly.mirror = true;
+ setRotation(belly, 0F, 0F, 0F);
+ chest = new ModelRenderer(this, 70, 46);
+ chest.addBox(-7F, -4F, -6F, 14, 4, 14);
+ chest.setRotationPoint(0F, 10F, 0F);
+ chest.setTextureSize(128, 64);
+ chest.mirror = true;
+ setRotation(chest, -0.1115358F, 0F, 0F);
+ head = new ModelRenderer(this, 0, 0);
+ head.addBox(-4F, -8F, -4F, 8, 8, 8);
+ head.setRotationPoint(0F, 6F, 3F);
+ head.setTextureSize(128, 64);
+ head.mirror = true;
+ setRotation(head, 0F, 0F, 0F);
+ nose = new ModelRenderer(this, 0, 0);
+ nose.addBox(-1F, -4F, -5F, 2, 1, 1);
+ nose.setRotationPoint(0F, 6F, 3F);
+ nose.setTextureSize(128, 64);
+ nose.mirror = true;
+ setRotation(nose, 0F, 0F, 0F);
+ leftHorn = new ModelRenderer(this, 93, 1);
+ leftHorn.addBox(4F, -7F, 0F, 16, 1, 1);
+ leftHorn.setRotationPoint(0F, 6F, 3F);
+ leftHorn.setTextureSize(128, 64);
+ leftHorn.mirror = true;
+ setRotation(leftHorn, 0F, 0F, 0F);
+ leftArmSpacer = new ModelRenderer(this, 80, 1);
+ leftArmSpacer.addBox(0F, -2F, -2F, 1, 4, 4);
+ leftArmSpacer.setRotationPoint(7F, 8F, 3F);
+ leftArmSpacer.setTextureSize(128, 64);
+ leftArmSpacer.mirror = true;
+ setRotation(leftArmSpacer, 0F, 0F, 0F);
+ leftArm = new ModelRenderer(this, 62, 1);
+ leftArm.addBox(1F, -2F, -2F, 4, 18, 4);
+ leftArm.setRotationPoint(7F, 8F, 3F);
+ leftArm.setTextureSize(128, 64);
+ leftArm.mirror = true;
+ setRotation(leftArm, 0F, 0F, 0F);
+ leftChain = new ModelRenderer(this, 95, 5);
+ leftChain.addBox(17F, -6F, 0F, 1, 6, 1);
+ leftChain.setRotationPoint(0F, 6F, 3F);
+ leftChain.setTextureSize(128, 64);
+ leftChain.mirror = true;
+ setRotation(leftChain, 0F, 0F, 0F);
+ leftBall = new ModelRenderer(this, 107, 4);
+ leftBall.addBox(15F, 0F, -2F, 5, 5, 5);
+ leftBall.setRotationPoint(0F, 6F, 3F);
+ leftBall.setTextureSize(128, 64);
+ leftBall.mirror = true;
+ setRotation(leftBall, 0F, 0F, 0F);
+ rightHorn = new ModelRenderer(this, 93, 1);
+ rightHorn.mirror = true;
+ rightHorn.addBox(-20F, -7F, 0F, 16, 1, 1);
+ rightHorn.setRotationPoint(0F, 6F, 3F);
+ rightHorn.setTextureSize(128, 64);
+ rightHorn.mirror = true;
+ setRotation(rightHorn, 0F, 0F, 0F);
+ rightHorn.mirror = false;
+ rightChain = new ModelRenderer(this, 95, 5);
+ rightChain.mirror = true;
+ rightChain.addBox(-18F, -6F, 0F, 1, 6, 1);
+ rightChain.setRotationPoint(0F, 6F, 3F);
+ rightChain.setTextureSize(128, 64);
+ rightChain.mirror = true;
+ setRotation(rightChain, 0F, 0F, 0F);
+ rightChain.mirror = false;
+ rightBall = new ModelRenderer(this, 107, 4);
+ rightBall.mirror = true;
+ rightBall.addBox(-20F, 0F, -2F, 5, 5, 5);
+ rightBall.setRotationPoint(0F, 6F, 3F);
+ rightBall.setTextureSize(128, 64);
+ rightBall.mirror = true;
+ setRotation(rightBall, 0F, 0F, 0F);
+ rightBall.mirror = false;
+ rightArmSpacer = new ModelRenderer(this, 80, 1);
+ rightArmSpacer.mirror = true;
+ rightArmSpacer.addBox(-1F, -2F, -2F, 1, 4, 4);
+ rightArmSpacer.setRotationPoint(-7F, 8F, 3F);
+ rightArmSpacer.setTextureSize(128, 64);
+ rightArmSpacer.mirror = true;
+ setRotation(rightArmSpacer, 0F, 0F, 0F);
+ rightArmSpacer.mirror = false;
+ rightArm = new ModelRenderer(this, 62, 1);
+ rightArm.mirror = true;
+ rightArm.addBox(-5F, -2F, -2F, 4, 18, 4);
+ rightArm.setRotationPoint(-7F, 8F, 3F);
+ rightArm.setTextureSize(128, 64);
+ rightArm.mirror = true;
+ setRotation(rightArm, 0F, 0F, 0F);
+ rightArm.mirror = false;
+ }
+
+ public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
+ {
+ super.render(entity, f, f1, f2, f3, f4, f5);
+ setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ float scale = 1.3f;
+ GL11.glScalef(scale, scale, scale);
+ GL11.glTranslatef(0.0f, -(6.0f / 16.0f), 0.0f);
+ belly.render(f5);
+ chest.render(f5);
+ head.render(f5);
+ nose.render(f5);
+ leftHorn.render(f5);
+ leftArmSpacer.render(f5);
+ leftArm.render(f5);
+ leftChain.render(f5);
+ leftBall.render(f5);
+ rightHorn.render(f5);
+ rightChain.render(f5);
+ rightBall.render(f5);
+ rightArmSpacer.render(f5);
+ rightArm.render(f5);
+ }
+
+ private void setRotation(ModelRenderer model, float x, float y, float z)
+ {
+ model.rotateAngleX = x;
+ model.rotateAngleY = y;
+ model.rotateAngleZ = z;
+ }
+
+ public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
+ {
+ super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ this.head.rotateAngleX = f4 / (180F / (float) Math.PI);
+ this.head.rotateAngleY = f3 / (180F / (float) Math.PI);
+ this.rightArm.rotateAngleX = MathHelper.cos(f * 0.3662F + (float) Math.PI) * 1.0F * f1;
+ this.leftArm.rotateAngleX = MathHelper.cos(f * 0.3662F) * 1.0F * f1;
+ this.rightArmSpacer.rotateAngleX = MathHelper.cos(f * 0.3662F + (float) Math.PI) * 1.0F * f1;
+ this.leftArmSpacer.rotateAngleX = MathHelper.cos(f * 0.3662F) * 1.0F * f1;
+ this.leftBall.rotateAngleX = this.head.rotateAngleX;
+ this.leftBall.rotateAngleY = this.head.rotateAngleY;
+ this.rightBall.rotateAngleX = this.head.rotateAngleX;
+ this.rightBall.rotateAngleY = this.head.rotateAngleY;
+ this.leftChain.rotateAngleX = this.head.rotateAngleX;
+ this.leftChain.rotateAngleY = this.head.rotateAngleY;
+ this.rightChain.rotateAngleX = this.head.rotateAngleX;
+ this.rightChain.rotateAngleY = this.head.rotateAngleY;
+ this.leftHorn.rotateAngleX = this.head.rotateAngleX;
+ this.leftHorn.rotateAngleY = this.head.rotateAngleY;
+ this.rightHorn.rotateAngleX = this.head.rotateAngleX;
+ this.rightHorn.rotateAngleY = this.head.rotateAngleY;
+ this.nose.rotateAngleX = this.head.rotateAngleX;
+ this.nose.rotateAngleY = this.head.rotateAngleY;
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelBloodAltar.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelBloodAltar.java
new file mode 100644
index 00000000..eba407bb
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelBloodAltar.java
@@ -0,0 +1,72 @@
+package WayofTime.alchemicalWizardry.common.renderer.model;
+
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.client.model.AdvancedModelLoader;
+import net.minecraftforge.client.model.IModelCustom;
+
+import org.lwjgl.opengl.GL11;
+
+import WayofTime.alchemicalWizardry.common.tileEntity.TEAltar;
+import cpw.mods.fml.client.FMLClientHandler;
+
+public class ModelBloodAltar extends ModelBase
+{
+ private IModelCustom modelBloodAltar;
+ private IModelCustom modelBloodLevel; //TODO
+
+ public ModelBloodAltar()
+ {
+ modelBloodAltar = AdvancedModelLoader.loadModel(new ResourceLocation("alchemicalwizardry:models/bloodaltar-fixeUV.obj"));
+ modelBloodLevel = AdvancedModelLoader.loadModel(new ResourceLocation("alchemicalwizardry:models/bloodlevel.obj"));
+ }
+
+ public void renderBloodAltar()
+ {
+ modelBloodAltar.renderAll();
+ }
+
+ public void renderBloodLevel()
+ {
+ modelBloodLevel.renderAll();
+ }
+
+ public void renderBloodAltar(TEAltar altar, double x, double y, double z)
+ {
+ float scale = 0.1f;
+ // Push a blank matrix onto the stack
+ GL11.glPushMatrix();
+ // Move the object into the correct position on the block (because the OBJ's origin is the center of the object)
+ GL11.glTranslatef((float) x + 0.5f, (float) y, (float) z + 0.5f);
+ // Scale our object to about half-size in all directions (the OBJ file is a little large)
+ GL11.glScalef(scale, scale, scale);
+ // Bind the texture, so that OpenGL properly textures our block.
+ ResourceLocation test = new ResourceLocation("alchemicalwizardry:textures/models/altar.png");
+ //FMLClientHandler.instance().getClient().renderEngine.bindTexture("/mods/alchemicalwizardry/textures/models/altar.png");
+ FMLClientHandler.instance().getClient().renderEngine.bindTexture(test);
+ // Render the object, using modelTutBox.renderAll();
+ this.renderBloodAltar();
+ // Pop this matrix from the stack.
+ GL11.glPopMatrix();
+ }
+
+ public void renderBloodLevel(TEAltar altar, double x, double y, double z)
+ {
+ float scale = 0.1f;
+ // Push a blank matrix onto the stack
+ GL11.glPushMatrix();
+ float level = altar.getFluidAmount();
+ // Move the object into the correct position on the block (because the OBJ's origin is the center of the object)
+ GL11.glTranslatef((float) x + 0.5f, (float) y + 0.6499f + 0.12f * (level / altar.getCapacity()), (float) z + 0.5f);
+ // Scale our object to about half-size in all directions (the OBJ file is a little large)
+ GL11.glScalef(scale, scale, scale);
+ // Bind the texture, so that OpenGL properly textures our block.
+ ResourceLocation test = new ResourceLocation("alchemicalwizardry:textures/models/blood.png");
+ //FMLClientHandler.instance().getClient().renderEngine.bindTexture("/mods/alchemicalwizardry/textures/models/altar.png");
+ FMLClientHandler.instance().getClient().renderEngine.bindTexture(test);
+ // Render the object, using modelTutBox.renderAll();
+ this.renderBloodLevel();
+ // Pop this matrix from the stack.
+ GL11.glPopMatrix();
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelBoulderFist.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelBoulderFist.java
new file mode 100644
index 00000000..a2cebd46
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelBoulderFist.java
@@ -0,0 +1,153 @@
+package WayofTime.alchemicalWizardry.common.renderer.model;
+
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.model.ModelRenderer;
+import net.minecraft.entity.Entity;
+import net.minecraft.util.MathHelper;
+
+public class ModelBoulderFist extends ModelBase
+{
+ //fields
+ ModelRenderer leftFist;
+ ModelRenderer leftArm;
+ ModelRenderer body;
+ ModelRenderer leftLeg1;
+ ModelRenderer leftLeg2;
+ ModelRenderer leftFoot;
+ ModelRenderer rightFist;
+ ModelRenderer rightArm;
+ ModelRenderer rightLeg1;
+ ModelRenderer rightLeg2;
+ ModelRenderer rightFoot;
+ ModelRenderer head;
+
+ public ModelBoulderFist()
+ {
+ textureWidth = 64;
+ textureHeight = 64;
+ leftFist = new ModelRenderer(this, 33, 52);
+ leftFist.addBox(-1F, 12F, -3F, 6, 6, 6);
+ leftFist.setRotationPoint(5F, 6F, -6F);
+ leftFist.setTextureSize(64, 64);
+ leftFist.mirror = true;
+ setRotation(leftFist, 0F, 0F, 0F);
+ leftArm = new ModelRenderer(this, 48, 33);
+ leftArm.addBox(0F, -2F, -2F, 4, 14, 4);
+ leftArm.setRotationPoint(5F, 6F, -6F);
+ leftArm.setTextureSize(64, 64);
+ leftArm.mirror = true;
+ setRotation(leftArm, 0F, 0F, 0F);
+ body = new ModelRenderer(this, 0, 40);
+ body.addBox(-5F, -2F, -3F, 10, 18, 6);
+ body.setRotationPoint(0F, 6F, -6F);
+ body.setTextureSize(64, 64);
+ body.mirror = true;
+ setRotation(body, 1.22173F, 0F, 0F);
+ leftLeg1 = new ModelRenderer(this, 0, 25);
+ leftLeg1.addBox(0F, -1F, -1F, 4, 6, 2);
+ leftLeg1.setRotationPoint(5F, 11F, 7F);
+ leftLeg1.setTextureSize(64, 64);
+ leftLeg1.mirror = true;
+ setRotation(leftLeg1, -((float) Math.PI / 4F), 0F, 0F);
+ leftLeg2 = new ModelRenderer(this, 1, 25);
+ leftLeg2.addBox(0F, 5F, -1F, 4, 2, 12);
+ leftLeg2.setRotationPoint(5F, 11F, 7F);
+ leftLeg2.setTextureSize(64, 64);
+ leftLeg2.mirror = true;
+ setRotation(leftLeg2, -((float) Math.PI / 4F), 0F, 0F);
+ leftFoot = new ModelRenderer(this, 22, 25);
+ leftFoot.addBox(0F, 11F, -1F, 4, 2, 5);
+ leftFoot.setRotationPoint(5F, 11F, 7F);
+ leftFoot.setTextureSize(64, 64);
+ leftFoot.mirror = true;
+ setRotation(leftFoot, 0F, 0F, 0F);
+ rightFist = new ModelRenderer(this, 33, 52);
+ rightFist.mirror = true;
+ rightFist.addBox(-5F, 12F, -3F, 6, 6, 6);
+ rightFist.setRotationPoint(-5F, 6F, -6F);
+ rightFist.setTextureSize(64, 64);
+ rightFist.mirror = true;
+ setRotation(rightFist, 0F, 0F, 0F);
+ rightFist.mirror = false;
+ rightArm = new ModelRenderer(this, 48, 33);
+ rightArm.mirror = true;
+ rightArm.addBox(-4F, -2F, -2F, 4, 14, 4);
+ rightArm.setRotationPoint(-5F, 6F, -6F);
+ rightArm.setTextureSize(64, 64);
+ rightArm.mirror = true;
+ setRotation(rightArm, 0F, 0F, 0F);
+ rightArm.mirror = false;
+ rightLeg1 = new ModelRenderer(this, 0, 25);
+ rightLeg1.mirror = true;
+ rightLeg1.addBox(-4F, -1F, -1F, 4, 6, 2);
+ rightLeg1.setRotationPoint(-5F, 11F, 7F);
+ rightLeg1.setTextureSize(64, 64);
+ rightLeg1.mirror = true;
+ setRotation(rightLeg1, -((float) Math.PI / 4F), 0F, 0F);
+ rightLeg1.mirror = false;
+ rightLeg2 = new ModelRenderer(this, 1, 25);
+ rightLeg2.mirror = true;
+ rightLeg2.addBox(-4F, 5F, -1F, 4, 2, 12);
+ rightLeg2.setRotationPoint(-5F, 11F, 7F);
+ rightLeg2.setTextureSize(64, 64);
+ rightLeg2.mirror = true;
+ setRotation(rightLeg2, -((float) Math.PI / 4F), 0F, 0F);
+ rightLeg2.mirror = false;
+ rightFoot = new ModelRenderer(this, 22, 25);
+ rightFoot.mirror = true;
+ rightFoot.addBox(-4F, 11F, -1F, 4, 2, 5);
+ rightFoot.setRotationPoint(-5F, 11F, 7F);
+ rightFoot.setTextureSize(64, 64);
+ rightFoot.mirror = true;
+ setRotation(rightFoot, 0F, 0F, 0F);
+ rightFoot.mirror = false;
+ head = new ModelRenderer(this, 0, 0);
+ head.addBox(-3F, -5F, -5F, 6, 6, 6);
+ head.setRotationPoint(0F, 5F, -7F);
+ head.setTextureSize(64, 64);
+ head.mirror = true;
+ setRotation(head, 0F, 0F, 0F);
+ }
+
+ public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
+ {
+ super.render(entity, f, f1, f2, f3, f4, f5);
+ setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ leftFist.render(f5);
+ leftArm.render(f5);
+ body.render(f5);
+ leftLeg1.render(f5);
+ leftLeg2.render(f5);
+ leftFoot.render(f5);
+ rightFist.render(f5);
+ rightArm.render(f5);
+ rightLeg1.render(f5);
+ rightLeg2.render(f5);
+ rightFoot.render(f5);
+ head.render(f5);
+ }
+
+ private void setRotation(ModelRenderer model, float x, float y, float z)
+ {
+ model.rotateAngleX = x;
+ model.rotateAngleY = y;
+ model.rotateAngleZ = z;
+ }
+
+ public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
+ {
+ super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ this.head.rotateAngleX = f4 / (180F / (float) Math.PI);
+ this.head.rotateAngleY = f3 / (180F / (float) Math.PI);
+ this.leftFoot.rotateAngleX = MathHelper.cos(f * 0.6662F) * 0.8F * f1;
+ this.rightFoot.rotateAngleX = MathHelper.cos(f * 0.6662F + (float) Math.PI) * 0.8F * f1;
+ this.leftLeg1.rotateAngleX = leftFoot.rotateAngleX - ((float) Math.PI / 4F);
+ this.rightLeg1.rotateAngleX = rightFoot.rotateAngleX - ((float) Math.PI / 4F);
+ this.leftLeg2.rotateAngleX = leftFoot.rotateAngleX - ((float) Math.PI / 4F);
+ this.rightLeg2.rotateAngleX = rightFoot.rotateAngleX - ((float) Math.PI / 4F);
+ this.rightArm.rotateAngleX = MathHelper.cos(f * 0.6662F + (float) Math.PI) * 0.9f * f1;
+ this.leftArm.rotateAngleX = MathHelper.cos(f * 0.6662F) * 0.9f * f1;
+ this.leftFist.rotateAngleX = leftArm.rotateAngleX;
+ this.rightFist.rotateAngleX = rightArm.rotateAngleX;
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelConduit.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelConduit.java
new file mode 100644
index 00000000..a6a510c4
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelConduit.java
@@ -0,0 +1,287 @@
+package WayofTime.alchemicalWizardry.common.renderer.model;
+
+//Date: 11/26/2013 1:57:16 PM
+//Template version 1.1
+//Java generated by Techne
+//Keep in mind that you still need to fill in some blanks
+//- ZeuX
+
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.model.ModelRenderer;
+import net.minecraft.entity.Entity;
+import net.minecraftforge.common.util.ForgeDirection;
+
+public class ModelConduit extends ModelBase
+{
+ //fields
+ ModelRenderer curvedInput;
+ ModelRenderer curvedOutput;
+ ModelRenderer straightBar1;
+ ModelRenderer curvedBar1;
+ ModelRenderer spacer1;
+ ModelRenderer straightBar2;
+ ModelRenderer curvedBar2;
+ ModelRenderer spacer2;
+ ModelRenderer straightBar3;
+ ModelRenderer curvedBar3;
+ ModelRenderer straightBar4;
+ ModelRenderer curvedBar4;
+ ModelRenderer spacer3;
+ ModelRenderer spacer4;
+ ModelRenderer spacer5;
+ ModelRenderer spacer6;
+ ModelRenderer spacer7;
+ ModelRenderer spacer8;
+
+ public ModelConduit()
+ {
+ textureWidth = 64;
+ textureHeight = 32;
+ curvedInput = new ModelRenderer(this, 0, 0);
+ curvedInput.addBox(-2F, -2F, -8F, 4, 4, 10);
+ curvedInput.setRotationPoint(0F, 16F, 0F);
+ curvedInput.setTextureSize(64, 32);
+ curvedInput.mirror = true;
+ setRotation(curvedInput, 0F, 0F, 0F);
+ curvedOutput = new ModelRenderer(this, 18, 0);
+ curvedOutput.addBox(2F, -2F, -2F, 6, 4, 4);
+ curvedOutput.setRotationPoint(0F, 16F, 0F);
+ curvedOutput.setTextureSize(64, 32);
+ curvedOutput.mirror = true;
+ setRotation(curvedOutput, 0F, 0F, 0F);
+ straightBar1 = new ModelRenderer(this, 0, 17);
+ straightBar1.addBox(-5F, 3F, -8F, 2, 2, 13);
+ straightBar1.setRotationPoint(0F, 16F, 0F);
+ straightBar1.setTextureSize(64, 32);
+ straightBar1.mirror = true;
+ setRotation(straightBar1, 0F, 0F, 0F);
+ curvedBar1 = new ModelRenderer(this, 29, 10);
+ curvedBar1.addBox(-5F, 3F, 3F, 13, 2, 2);
+ curvedBar1.setRotationPoint(0F, 16F, 0F);
+ curvedBar1.setTextureSize(64, 32);
+ curvedBar1.mirror = true;
+ setRotation(curvedBar1, 0F, 0F, 0F);
+ spacer1 = new ModelRenderer(this, 40, 0);
+ spacer1.addBox(-5.5F, 2.5F, 2.5F, 3, 3, 3);
+ spacer1.setRotationPoint(0F, 16F, 0F);
+ spacer1.setTextureSize(64, 32);
+ spacer1.mirror = true;
+ setRotation(spacer1, 0F, 0F, 0F);
+ straightBar2 = new ModelRenderer(this, 0, 17);
+ straightBar2.addBox(-5F, -5F, -8F, 2, 2, 13);
+ straightBar2.setRotationPoint(0F, 16F, 0F);
+ straightBar2.setTextureSize(64, 32);
+ straightBar2.mirror = true;
+ setRotation(straightBar2, 0F, 0F, 0F);
+ curvedBar2 = new ModelRenderer(this, 29, 10);
+ curvedBar2.addBox(-5F, -5F, 3F, 13, 2, 2);
+ curvedBar2.setRotationPoint(0F, 16F, 0F);
+ curvedBar2.setTextureSize(64, 32);
+ curvedBar2.mirror = true;
+ setRotation(curvedBar2, 0F, 0F, 0F);
+ spacer2 = new ModelRenderer(this, 40, 0);
+ spacer2.addBox(-5.5F, -5.5F, 2.5F, 3, 3, 3);
+ spacer2.setRotationPoint(0F, 16F, 0F);
+ spacer2.setTextureSize(64, 32);
+ spacer2.mirror = true;
+ setRotation(spacer2, 0F, 0F, 0F);
+ straightBar3 = new ModelRenderer(this, 0, 17);
+ straightBar3.addBox(3F, 3F, -8F, 2, 2, 13);
+ straightBar3.setRotationPoint(0F, 16F, 0F);
+ straightBar3.setTextureSize(64, 32);
+ straightBar3.mirror = true;
+ setRotation(straightBar3, 0F, 0F, 0F);
+ curvedBar3 = new ModelRenderer(this, 29, 10);
+ curvedBar3.addBox(-5F, 3F, -5F, 13, 2, 2);
+ curvedBar3.setRotationPoint(0F, 16F, 0F);
+ curvedBar3.setTextureSize(64, 32);
+ curvedBar3.mirror = true;
+ setRotation(curvedBar3, 0F, 0F, 0F);
+ straightBar4 = new ModelRenderer(this, 0, 17);
+ straightBar4.addBox(3F, -5F, -8F, 2, 2, 13);
+ straightBar4.setRotationPoint(0F, 16F, 0F);
+ straightBar4.setTextureSize(64, 32);
+ straightBar4.mirror = true;
+ setRotation(straightBar4, 0F, 0F, 0F);
+ curvedBar4 = new ModelRenderer(this, 29, 10);
+ curvedBar4.addBox(-5F, -5F, -5F, 13, 2, 2);
+ curvedBar4.setRotationPoint(0F, 16F, 0F);
+ curvedBar4.setTextureSize(64, 32);
+ curvedBar4.mirror = true;
+ setRotation(curvedBar4, 0F, 0F, 0F);
+ spacer3 = new ModelRenderer(this, 40, 0);
+ spacer3.addBox(2.5F, 2.5F, 2.5F, 3, 3, 3);
+ spacer3.setRotationPoint(0F, 16F, 0F);
+ spacer3.setTextureSize(64, 32);
+ spacer3.mirror = true;
+ setRotation(spacer3, 0F, 0F, 0F);
+ spacer4 = new ModelRenderer(this, 40, 0);
+ spacer4.addBox(2.5F, 2.5F, -5.5F, 3, 3, 3);
+ spacer4.setRotationPoint(0F, 16F, 0F);
+ spacer4.setTextureSize(64, 32);
+ spacer4.mirror = true;
+ setRotation(spacer4, 0F, 0F, 0F);
+ spacer5 = new ModelRenderer(this, 40, 0);
+ spacer5.addBox(-5.5F, 2.5F, -5.484F, 3, 3, 3);
+ spacer5.setRotationPoint(0F, 16F, 0F);
+ spacer5.setTextureSize(64, 32);
+ spacer5.mirror = true;
+ setRotation(spacer5, 0F, 0F, 0F);
+ spacer6 = new ModelRenderer(this, 40, 0);
+ spacer6.addBox(2.5F, -5.5F, 2.5F, 3, 3, 3);
+ spacer6.setRotationPoint(0F, 16F, 0F);
+ spacer6.setTextureSize(64, 32);
+ spacer6.mirror = true;
+ setRotation(spacer6, 0F, 0F, 0F);
+ spacer7 = new ModelRenderer(this, 40, 0);
+ spacer7.addBox(2.5F, -5.5F, -5.5F, 3, 3, 3);
+ spacer7.setRotationPoint(0F, 16F, 0F);
+ spacer7.setTextureSize(64, 32);
+ spacer7.mirror = true;
+ setRotation(spacer7, 0F, 0F, 0F);
+ spacer8 = new ModelRenderer(this, 40, 0);
+ spacer8.addBox(-5.5F, -5.5F, -5.5F, 3, 3, 3);
+ spacer8.setRotationPoint(0F, 16F, 0F);
+ spacer8.setTextureSize(64, 32);
+ spacer8.mirror = true;
+ setRotation(spacer8, 0F, 0F, 0F);
+ }
+
+ public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5, ForgeDirection input, ForgeDirection output)
+ {
+ super.render(entity, f, f1, f2, f3, f4, f5);
+ setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ float xInputRot = 0.0f;
+ float yInputRot = 0.0f;
+ float zInputRot = 0.0f;
+ float xOutputRot = 0.0f;
+ float yOutputRot = 0.0f;
+ float zOutputRot = 0.0f;
+
+ switch (input)
+ {
+ case NORTH:
+ xInputRot = 0.0f;
+ yInputRot = 0.0f;
+ zInputRot = 0.0f;
+ break;
+
+ case EAST:
+ xInputRot = 0.0f;
+ yInputRot = (float) (0.5f * Math.PI);
+ zInputRot = 0.0f;
+ break;
+
+ case SOUTH:
+ xInputRot = 0.0f;
+ yInputRot = (float) (1.0f * Math.PI);
+ zInputRot = 0.0f;
+ break;
+
+ case WEST:
+ xInputRot = 0.0f;
+ yInputRot = (float) (-0.5f * Math.PI);
+ zInputRot = 0.0f;
+ break;
+
+ case UP:
+ xInputRot = (float) (-0.5f * Math.PI);
+ yInputRot = 0.0f;
+ zInputRot = 0.0f;
+ break;
+
+ case DOWN:
+ xInputRot = (float) (0.5f * Math.PI);
+ yInputRot = 0.0f;
+ zInputRot = 0.0f;
+ break;
+
+ default:
+ break;
+ }
+
+ switch (output)
+ {
+ case NORTH:
+ xOutputRot = 0.0f;
+ yOutputRot = (float) (0.5f * Math.PI);
+ zOutputRot = 0.0f;
+ break;
+
+ case EAST:
+ xOutputRot = 0.0f;
+ yOutputRot = (float) (1.0f * Math.PI);
+ zOutputRot = 0.0f;
+ break;
+
+ case SOUTH:
+ xOutputRot = 0.0f;
+ yOutputRot = (float) (-0.5f * Math.PI);
+ zOutputRot = 0.0f;
+ break;
+
+ case WEST:
+ xOutputRot = 0.0f;
+ yOutputRot = 0.0f;
+ zOutputRot = 0.0f;
+ break;
+
+ case UP:
+ xOutputRot = 0.0f;
+ yOutputRot = 0.0f;
+ zOutputRot = (float) (-0.5f * Math.PI);
+ break;
+
+ case DOWN:
+ xOutputRot = 0.0f;
+ yOutputRot = 0.0f;
+ zOutputRot = (float) (0.5f * Math.PI);
+ break;
+
+ default:
+ break;
+ }
+
+ this.setRotation(curvedInput, xInputRot, yInputRot, zInputRot);
+ this.setRotation(curvedOutput, xOutputRot, yOutputRot, zOutputRot);
+ this.setRotation(straightBar1, xInputRot, yInputRot, zInputRot);
+ this.setRotation(curvedBar1, xOutputRot, yOutputRot, zOutputRot);
+ this.setRotation(straightBar2, xInputRot, yInputRot, zInputRot);
+ this.setRotation(curvedBar2, xOutputRot, yOutputRot, zOutputRot);
+ this.setRotation(straightBar3, xInputRot, yInputRot, zInputRot);
+ this.setRotation(curvedBar3, xOutputRot, yOutputRot, zOutputRot);
+ this.setRotation(straightBar4, xInputRot, yInputRot, zInputRot);
+ this.setRotation(curvedBar4, xOutputRot, yOutputRot, zOutputRot);
+ curvedInput.render(f5);
+ curvedOutput.render(f5);
+ //setRotation(curvedOutput,0F,-(float)(Math.PI/2),0F);
+ straightBar1.render(f5);
+ curvedBar1.render(f5);
+ spacer1.render(f5);
+ straightBar2.render(f5);
+ curvedBar2.render(f5);
+ spacer2.render(f5);
+ straightBar3.render(f5);
+ curvedBar3.render(f5);
+ straightBar4.render(f5);
+ curvedBar4.render(f5);
+ spacer3.render(f5);
+ spacer4.render(f5);
+ spacer5.render(f5);
+ spacer6.render(f5);
+ spacer7.render(f5);
+ spacer8.render(f5);
+ }
+
+ private void setRotation(ModelRenderer model, float x, float y, float z)
+ {
+ model.rotateAngleX = x;
+ model.rotateAngleY = y;
+ model.rotateAngleZ = z;
+ }
+
+ public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
+ {
+ super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelCrystalBelljar.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelCrystalBelljar.java
new file mode 100644
index 00000000..ce6f7d52
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelCrystalBelljar.java
@@ -0,0 +1,119 @@
+package WayofTime.alchemicalWizardry.common.renderer.model;
+
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.model.ModelRenderer;
+import net.minecraft.entity.Entity;
+
+public class ModelCrystalBelljar extends ModelBase
+{
+ //fields
+ ModelRenderer handle1;
+ ModelRenderer handle2;
+ ModelRenderer jar1;
+ ModelRenderer woodBottom;
+ ModelRenderer jar2;
+ ModelRenderer jar3;
+ ModelRenderer jar4;
+ ModelRenderer jar5;
+
+ public ModelCrystalBelljar()
+ {
+ textureWidth = 128;
+ textureHeight = 64;
+
+ handle1 = new ModelRenderer(this, 0, 17);
+ handle1.addBox(-2F, -7F, -2F, 4, 1, 4);
+ handle1.setRotationPoint(0F, 16F, 0F);
+ handle1.setTextureSize(128, 64);
+ handle1.mirror = true;
+ setRotation(handle1, 0F, 0F, 0F);
+ handle2 = new ModelRenderer(this, 0, 23);
+ handle2.addBox(-1F, -6F, -1F, 2, 1, 2);
+ handle2.setRotationPoint(0F, 16F, 0F);
+ handle2.setTextureSize(128, 64);
+ handle2.mirror = true;
+ setRotation(handle2, 0F, 0F, 0F);
+ jar1 = new ModelRenderer(this, 0, 27);
+ jar1.addBox(-4F, -5F, -4F, 8, 1, 8);
+ jar1.setRotationPoint(0F, 16F, 0F);
+ jar1.setTextureSize(128, 64);
+ jar1.mirror = true;
+ setRotation(jar1, 0F, 0F, 0F);
+ woodBottom = new ModelRenderer(this, 0, 0);
+ woodBottom.addBox(-7F, 6F, -7F, 14, 2, 14);
+ woodBottom.setRotationPoint(0F, 16F, 0F);
+ woodBottom.setTextureSize(128, 64);
+ woodBottom.mirror = true;
+ setRotation(woodBottom, 0F, 0F, 0F);
+ jar2 = new ModelRenderer(this, 0, 38);
+ jar2.addBox(-5F, -4F, 4F, 10, 10, 1);
+ jar2.setRotationPoint(0F, 16F, 0F);
+ jar2.setTextureSize(128, 64);
+ jar2.mirror = true;
+ setRotation(jar2, 0F, 0F, 0F);
+ jar3 = new ModelRenderer(this, 46, 38);
+ jar3.addBox(4F, -4F, -4F, 1, 10, 8);
+ jar3.setRotationPoint(0F, 16F, 0F);
+ jar3.setTextureSize(128, 64);
+ jar3.mirror = true;
+ setRotation(jar3, 0F, 0F, 0F);
+ jar4 = new ModelRenderer(this, 23, 38);
+ jar4.addBox(-5F, -4F, -5F, 10, 10, 1);
+ jar4.setRotationPoint(0F, 16F, 0F);
+ jar4.setTextureSize(128, 64);
+ jar4.mirror = true;
+ setRotation(jar4, 0F, 0F, 0F);
+ jar5 = new ModelRenderer(this, 65, 38);
+ jar5.addBox(-5F, -4F, -4F, 1, 10, 8);
+ jar5.setRotationPoint(0F, 16F, 0F);
+ jar5.setTextureSize(128, 64);
+ jar5.mirror = true;
+ setRotation(jar5, 0F, 0F, 0F);
+ }
+
+ public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
+ {
+ super.render(entity, f, f1, f2, f3, f4, f5);
+ setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ handle1.render(f5);
+ handle2.render(f5);
+ jar1.render(f5);
+ woodBottom.render(f5);
+ jar2.render(f5);
+ jar3.render(f5);
+ jar4.render(f5);
+ jar5.render(f5);
+ }
+
+ public void renderSpecialItem(Entity entity, float f, float f1, float f2, float f3, float f4, float f5, int part)
+ {
+ super.render(entity, f, f1, f2, f3, f4, f5);
+ setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ if(part == 0)
+ {
+ woodBottom.render(f5);
+ }else
+ {
+ handle1.render(f5);
+ handle2.render(f5);
+ jar1.render(f5);
+ jar2.render(f5);
+ jar3.render(f5);
+ jar4.render(f5);
+ jar5.render(f5);
+ }
+ }
+
+ private void setRotation(ModelRenderer model, float x, float y, float z)
+ {
+ model.rotateAngleX = x;
+ model.rotateAngleY = y;
+ model.rotateAngleZ = z;
+ }
+
+ public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
+ {
+ super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ }
+
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelElemental.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelElemental.java
new file mode 100644
index 00000000..25cb2814
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelElemental.java
@@ -0,0 +1,81 @@
+package WayofTime.alchemicalWizardry.common.renderer.model;
+
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.model.ModelRenderer;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.monster.EntityBlaze;
+import net.minecraft.world.World;
+
+public class ModelElemental extends ModelBase
+{
+ //fields
+ ModelRenderer body;
+ ModelRenderer Shape2;
+ ModelRenderer Shape1;
+ ModelRenderer Shape3;
+
+ public ModelElemental()
+ {
+ textureWidth = 64;
+ textureHeight = 32;
+ body = new ModelRenderer(this, 33, 0);
+ body.addBox(-3F, -3F, -3F, 6, 6, 6);
+ body.setRotationPoint(0F, 14F, 0F);
+ body.setTextureSize(64, 32);
+ body.mirror = true;
+ setRotation(body, 0F, 0F, 0F);
+ Shape2 = new ModelRenderer(this, 0, 0);
+ Shape2.addBox(-4F, -4F, -4F, 8, 8, 8);
+ Shape2.setRotationPoint(0F, 14F, 0F);
+ Shape2.setTextureSize(64, 32);
+ Shape2.mirror = true;
+ setRotation(Shape2, ((float) Math.PI / 4F), ((float) Math.PI / 4F), 0F);
+ Shape1 = new ModelRenderer(this, 0, 0);
+ Shape1.addBox(-4F, -4F, -4F, 8, 8, 8);
+ Shape1.setRotationPoint(0F, 14F, 0F);
+ Shape1.setTextureSize(64, 32);
+ Shape1.mirror = true;
+ setRotation(Shape1, 0F, ((float) Math.PI / 4F), ((float) Math.PI / 4F));
+ Shape3 = new ModelRenderer(this, 0, 0);
+ Shape3.addBox(-4F, -4F, -4F, 8, 8, 8);
+ Shape3.setRotationPoint(0F, 14F, 0F);
+ Shape3.setTextureSize(64, 32);
+ Shape3.mirror = true;
+ setRotation(Shape3, ((float) Math.PI / 4F), 0F, ((float) Math.PI / 4F));
+ }
+
+ public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
+ {
+ super.render(entity, f, f1, f2, f3, f4, f5);
+ setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ body.render(f5);
+ Shape2.render(f5);
+ Shape1.render(f5);
+ Shape3.render(f5);
+ }
+
+ private void setRotation(ModelRenderer model, float x, float y, float z)
+ {
+ model.rotateAngleX = x;
+ model.rotateAngleY = y;
+ model.rotateAngleZ = z;
+ }
+
+ public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
+ {
+ super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ World world = entity.worldObj;
+
+ if (world == null)
+ {
+ return;
+ }
+
+ int ratio = 20;
+ float rot = (entity.worldObj.getWorldTime() % ratio) / ratio;
+ Shape1.rotateAngleX = f / 5;
+ Shape2.rotateAngleZ = f / 5;
+ Shape3.rotateAngleY = f / 5;
+ EntityBlaze d;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelEnergyBazookaMainProjectile.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelEnergyBazookaMainProjectile.java
new file mode 100644
index 00000000..de8e7e6b
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelEnergyBazookaMainProjectile.java
@@ -0,0 +1,122 @@
+package WayofTime.alchemicalWizardry.common.renderer.model;
+
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.model.ModelRenderer;
+import net.minecraft.entity.Entity;
+
+public class ModelEnergyBazookaMainProjectile extends ModelBase
+{
+ //fields
+ ModelRenderer thirdWarHead;
+ ModelRenderer firstWarHead;
+ ModelRenderer secondWarHead;
+ ModelRenderer support1;
+ ModelRenderer mainBody;
+ ModelRenderer support2;
+ ModelRenderer support3;
+ ModelRenderer support4;
+ ModelRenderer base1;
+ ModelRenderer base2;
+ ModelRenderer base3;
+
+ public ModelEnergyBazookaMainProjectile()
+ {
+ textureWidth = 64;
+ textureHeight = 32;
+ thirdWarHead = new ModelRenderer(this, 43, 0);
+ thirdWarHead.addBox(-1F, -1F, -9F, 2, 2, 1);
+ thirdWarHead.setRotationPoint(0F, 0F, 0F);
+ thirdWarHead.setTextureSize(64, 32);
+ thirdWarHead.mirror = true;
+ setRotation(thirdWarHead, 0F, 0F, 0F);
+ firstWarHead = new ModelRenderer(this, 52, 0);
+ firstWarHead.addBox(-2F, -2F, -8F, 4, 4, 2);
+ firstWarHead.setRotationPoint(0F, 0F, 0F);
+ firstWarHead.setTextureSize(64, 32);
+ firstWarHead.mirror = true;
+ setRotation(firstWarHead, 0F, 0F, 0F);
+ secondWarHead = new ModelRenderer(this, 48, 8);
+ secondWarHead.addBox(-3F, -3F, -6F, 6, 6, 2);
+ secondWarHead.setRotationPoint(0F, 0F, 0F);
+ secondWarHead.setTextureSize(64, 32);
+ secondWarHead.mirror = true;
+ setRotation(secondWarHead, 0F, 0F, 0F);
+ support1 = new ModelRenderer(this, 0, 0);
+ support1.addBox(2F, 2F, -4F, 1, 1, 9);
+ support1.setRotationPoint(0F, 0F, 0F);
+ support1.setTextureSize(64, 32);
+ support1.mirror = true;
+ setRotation(support1, 0F, 0F, 0F);
+ mainBody = new ModelRenderer(this, 0, 19);
+ mainBody.addBox(-2F, -2F, -4F, 4, 4, 9);
+ mainBody.setRotationPoint(0F, 0F, 0F);
+ mainBody.setTextureSize(64, 32);
+ mainBody.mirror = true;
+ setRotation(mainBody, 0F, 0F, 0F);
+ support2 = new ModelRenderer(this, 0, 0);
+ support2.addBox(-3F, 2F, -4F, 1, 1, 9);
+ support2.setRotationPoint(0F, 0F, 0F);
+ support2.setTextureSize(64, 32);
+ support2.mirror = true;
+ setRotation(support2, 0F, 0F, 0F);
+ support3 = new ModelRenderer(this, 0, 0);
+ support3.addBox(-3F, -3F, -4F, 1, 1, 9);
+ support3.setRotationPoint(0F, 0F, 0F);
+ support3.setTextureSize(64, 32);
+ support3.mirror = true;
+ setRotation(support3, 0F, 0F, 0F);
+ support4 = new ModelRenderer(this, 0, 0);
+ support4.addBox(2F, -3F, -4F, 1, 1, 9);
+ support4.setRotationPoint(0F, 0F, 0F);
+ support4.setTextureSize(64, 32);
+ support4.mirror = true;
+ setRotation(support4, 0F, 0F, 0F);
+ base1 = new ModelRenderer(this, 28, 0);
+ base1.addBox(-3F, -3F, 5F, 6, 6, 1);
+ base1.setRotationPoint(0F, 0F, 0F);
+ base1.setTextureSize(64, 32);
+ base1.mirror = true;
+ setRotation(base1, 0F, 0F, 0F);
+ base2 = new ModelRenderer(this, 28, 9);
+ base2.addBox(-2F, -2F, 6F, 4, 4, 1);
+ base2.setRotationPoint(0F, 0F, 0F);
+ base2.setTextureSize(64, 32);
+ base2.mirror = true;
+ setRotation(base2, 0F, 0F, 0F);
+ base3 = new ModelRenderer(this, 28, 15);
+ base3.addBox(-3F, -3F, 7F, 6, 6, 1);
+ base3.setRotationPoint(0F, 0F, 0F);
+ base3.setTextureSize(64, 32);
+ base3.mirror = true;
+ setRotation(base3, 0F, 0F, 0F);
+ }
+
+ public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
+ {
+ super.render(entity, f, f1, f2, f3, f4, f5);
+ setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ thirdWarHead.render(f5);
+ firstWarHead.render(f5);
+ secondWarHead.render(f5);
+ support1.render(f5);
+ mainBody.render(f5);
+ support2.render(f5);
+ support3.render(f5);
+ support4.render(f5);
+ base1.render(f5);
+ base2.render(f5);
+ base3.render(f5);
+ }
+
+ private void setRotation(ModelRenderer model, float x, float y, float z)
+ {
+ model.rotateAngleX = x;
+ model.rotateAngleY = y;
+ model.rotateAngleZ = z;
+ }
+
+ public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
+ {
+ super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelFallenAngel.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelFallenAngel.java
new file mode 100644
index 00000000..aacef80d
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelFallenAngel.java
@@ -0,0 +1,113 @@
+package WayofTime.alchemicalWizardry.common.renderer.model;
+
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.model.ModelRenderer;
+import net.minecraft.entity.Entity;
+import net.minecraft.util.MathHelper;
+
+public class ModelFallenAngel extends ModelBase
+{
+ //fields
+ ModelRenderer leftWing;
+ ModelRenderer rightWing;
+ ModelRenderer head;
+ ModelRenderer body;
+ ModelRenderer rightarm;
+ ModelRenderer leftarm;
+ ModelRenderer rightleg;
+ ModelRenderer leftleg;
+
+ public ModelFallenAngel()
+ {
+ textureWidth = 64;
+ textureHeight = 32;
+ leftWing = new ModelRenderer(this, 33, 8);
+ leftWing.mirror = true;
+ leftWing.addBox(0F, 0F, 0F, 10, 7, 0);
+ leftWing.setRotationPoint(0F, 1F, 2F);
+ leftWing.setTextureSize(64, 32);
+ leftWing.mirror = true;
+ setRotation(leftWing, 0F, 0F, 0F);
+ rightWing = new ModelRenderer(this, 33, 8);
+ rightWing.addBox(-10F, 0F, 0F, 10, 7, 0);
+ rightWing.setRotationPoint(0F, 1F, 2F);
+ rightWing.setTextureSize(64, 32);
+ rightWing.mirror = true;
+ setRotation(rightWing, 0F, 0F, 0F);
+ rightWing.mirror = false;
+ head = new ModelRenderer(this, 0, 0);
+ head.addBox(-4F, -8F, -4F, 8, 8, 8);
+ head.setRotationPoint(0F, 0F, 0F);
+ head.setTextureSize(64, 32);
+ head.mirror = true;
+ setRotation(head, 0F, 0F, 0F);
+ body = new ModelRenderer(this, 16, 16);
+ body.addBox(-4F, 0F, -2F, 8, 12, 4);
+ body.setRotationPoint(0F, 0F, 0F);
+ body.setTextureSize(64, 32);
+ body.mirror = true;
+ setRotation(body, 0F, 0F, 0F);
+ rightarm = new ModelRenderer(this, 40, 16);
+ rightarm.addBox(-3F, -2F, -2F, 4, 12, 4);
+ rightarm.setRotationPoint(-5F, 2F, 0F);
+ rightarm.setTextureSize(64, 32);
+ rightarm.mirror = true;
+ setRotation(rightarm, 0F, 0F, 0F);
+ rightarm.mirror = false;
+ leftarm = new ModelRenderer(this, 40, 16);
+ leftarm.mirror = true;
+ leftarm.addBox(-1F, -2F, -2F, 4, 12, 4);
+ leftarm.setRotationPoint(5F, 2F, 0F);
+ leftarm.setTextureSize(64, 32);
+ leftarm.mirror = true;
+ setRotation(leftarm, 0F, 0F, 0F);
+ rightleg = new ModelRenderer(this, 0, 16);
+ rightleg.addBox(-2F, 0F, -2F, 4, 12, 4);
+ rightleg.setRotationPoint(-2F, 12F, 0F);
+ rightleg.setTextureSize(64, 32);
+ rightleg.mirror = true;
+ setRotation(rightleg, 0F, 0F, 0F);
+ rightleg.mirror = false;
+ leftleg = new ModelRenderer(this, 0, 16);
+ leftleg.mirror = true;
+ leftleg.addBox(-2F, 0F, -2F, 4, 12, 4);
+ leftleg.setRotationPoint(2F, 12F, 0F);
+ leftleg.setTextureSize(64, 32);
+ leftleg.mirror = true;
+ setRotation(leftleg, 0F, 0F, 0F);
+ }
+
+ public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
+ {
+ super.render(entity, f, f1, f2, f3, f4, f5);
+ setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ leftWing.render(f5);
+ rightWing.render(f5);
+ head.render(f5);
+ body.render(f5);
+ rightarm.render(f5);
+ leftarm.render(f5);
+ rightleg.render(f5);
+ leftleg.render(f5);
+ }
+
+ private void setRotation(ModelRenderer model, float x, float y, float z)
+ {
+ model.rotateAngleX = x;
+ model.rotateAngleY = y;
+ model.rotateAngleZ = z;
+ }
+
+ public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
+ {
+ super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ this.head.rotateAngleX = f4 / (180F / (float) Math.PI);
+ this.head.rotateAngleY = f3 / (180F / (float) Math.PI);
+ this.leftleg.rotateAngleX = MathHelper.cos(f * 0.6662F) * 1.4F * f1;
+ this.rightleg.rotateAngleX = MathHelper.cos(f * 0.6662F + (float) Math.PI) * 1.4F * f1;
+ this.rightarm.rotateAngleX = MathHelper.cos(f * 0.6662F + (float) Math.PI) * 1.4F * f1;
+ this.leftarm.rotateAngleX = MathHelper.cos(f * 0.6662F) * 1.4F * f1;
+ this.rightWing.rotateAngleY = MathHelper.cos(0.1662F);
+ this.leftWing.rotateAngleY = MathHelper.cos(0.1662F + (float) Math.PI);
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelIceDemon.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelIceDemon.java
new file mode 100644
index 00000000..9c6d3c32
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelIceDemon.java
@@ -0,0 +1,197 @@
+package WayofTime.alchemicalWizardry.common.renderer.model;
+
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.model.ModelRenderer;
+import net.minecraft.entity.Entity;
+import net.minecraft.util.MathHelper;
+
+public class ModelIceDemon extends ModelBase
+{
+ //fields
+ ModelRenderer head;
+ ModelRenderer leftHorn;
+ ModelRenderer rightHorn;
+ ModelRenderer body;
+ ModelRenderer leftArm;
+ ModelRenderer leftWrist;
+ ModelRenderer leftIcicle1;
+ ModelRenderer leftIcicle2;
+ ModelRenderer leftIcicle3;
+ ModelRenderer leftLeg;
+ ModelRenderer rightArm;
+ ModelRenderer rightWrist;
+ ModelRenderer rightIcicle1;
+ ModelRenderer rightIcicle2;
+ ModelRenderer rightIcicle3;
+ ModelRenderer rightLeg;
+ ModelRenderer Shape1;
+
+ public ModelIceDemon()
+ {
+ textureWidth = 64;
+ textureHeight = 64;
+ head = new ModelRenderer(this, 40, 0);
+ head.addBox(-3F, -8F, -3F, 6, 8, 6);
+ head.setRotationPoint(0F, -3F, 0F);
+ head.setTextureSize(64, 64);
+ head.mirror = true;
+ setRotation(head, 0F, 0F, 0F);
+ leftHorn = new ModelRenderer(this, 0, 0);
+ leftHorn.addBox(3F, -7F, 2F, 1, 1, 10);
+ leftHorn.setRotationPoint(0F, -3F, 0F);
+ leftHorn.setTextureSize(64, 64);
+ leftHorn.mirror = true;
+ setRotation(leftHorn, 0.4363323F, 0F, 0F);
+ rightHorn = new ModelRenderer(this, 0, 0);
+ rightHorn.mirror = true;
+ rightHorn.addBox(-4F, -7F, 2F, 1, 1, 10);
+ rightHorn.setRotationPoint(0F, -3F, 0F);
+ rightHorn.setTextureSize(64, 64);
+ rightHorn.mirror = true;
+ setRotation(rightHorn, 0.4363323F, 0F, 0F);
+ rightHorn.mirror = false;
+ body = new ModelRenderer(this, 40, 15);
+ body.addBox(-4F, 0F, -2F, 8, 13, 4);
+ body.setRotationPoint(0F, -3F, 0F);
+ body.setTextureSize(64, 64);
+ body.mirror = true;
+ setRotation(body, 0F, 0F, 0F);
+ leftArm = new ModelRenderer(this, 0, 48);
+ leftArm.addBox(0F, -2F, -2F, 4, 12, 4);
+ leftArm.setRotationPoint(4F, -1F, 0F);
+ leftArm.setTextureSize(64, 64);
+ leftArm.mirror = true;
+ setRotation(leftArm, 0F, 0F, 0F);
+ leftWrist = new ModelRenderer(this, 32, 57);
+ leftWrist.addBox(0F, 6F, -2.5F, 5, 2, 5);
+ leftWrist.setRotationPoint(4F, -1F, 0F);
+ leftWrist.setTextureSize(64, 64);
+ leftWrist.mirror = true;
+ setRotation(leftWrist, 0F, 0F, 0F);
+ leftIcicle1 = new ModelRenderer(this, 0, 0);
+ leftIcicle1.addBox(4.9F, 0F, -0.5F, 1, 6, 1);
+ leftIcicle1.setRotationPoint(4F, -1F, 0F);
+ leftIcicle1.setTextureSize(64, 64);
+ leftIcicle1.mirror = true;
+ setRotation(leftIcicle1, 0F, 0F, 0.1396263F);
+ leftIcicle2 = new ModelRenderer(this, 0, 0);
+ leftIcicle2.addBox(5F, 0F, 0F, 1, 6, 1);
+ leftIcicle2.setRotationPoint(4F, -1F, 0F);
+ leftIcicle2.setTextureSize(64, 64);
+ leftIcicle2.mirror = true;
+ setRotation(leftIcicle2, 0F, 0.5585054F, 0.1919862F);
+ leftIcicle3 = new ModelRenderer(this, 0, 0);
+ leftIcicle3.addBox(5F, 0F, -1F, 1, 6, 1);
+ leftIcicle3.setRotationPoint(4F, -1F, 0F);
+ leftIcicle3.setTextureSize(64, 64);
+ leftIcicle3.mirror = true;
+ setRotation(leftIcicle3, 0F, -0.5585054F, 0.1919862F);
+ leftLeg = new ModelRenderer(this, 16, 46);
+ leftLeg.addBox(-2F, 0F, -2F, 4, 14, 4);
+ leftLeg.setRotationPoint(2F, 10F, 0F);
+ leftLeg.setTextureSize(64, 64);
+ leftLeg.mirror = true;
+ setRotation(leftLeg, 0F, 0F, 0F);
+ rightArm = new ModelRenderer(this, 0, 48);
+ rightArm.mirror = true;
+ rightArm.addBox(-4F, -2F, -2F, 4, 12, 4);
+ rightArm.setRotationPoint(-4F, -1F, 0F);
+ rightArm.setTextureSize(64, 64);
+ rightArm.mirror = true;
+ setRotation(rightArm, 0F, 0F, 0F);
+ rightArm.mirror = false;
+ rightWrist = new ModelRenderer(this, 32, 57);
+ rightWrist.mirror = true;
+ rightWrist.addBox(-5F, 6F, -2.5F, 5, 2, 5);
+ rightWrist.setRotationPoint(-4F, -1F, 0F);
+ rightWrist.setTextureSize(64, 64);
+ rightWrist.mirror = true;
+ setRotation(rightWrist, 0F, 0F, 0F);
+ rightWrist.mirror = false;
+ rightIcicle1 = new ModelRenderer(this, 0, 0);
+ rightIcicle1.addBox(-5.9F, 0F, -0.5F, 1, 6, 1);
+ rightIcicle1.setRotationPoint(-4F, -1F, 0F);
+ rightIcicle1.setTextureSize(64, 64);
+ rightIcicle1.mirror = true;
+ setRotation(rightIcicle1, 0F, 0F, -0.1396263F);
+ rightIcicle2 = new ModelRenderer(this, 0, 0);
+ rightIcicle2.addBox(-6F, 0F, 0F, 1, 6, 1);
+ rightIcicle2.setRotationPoint(-4F, -1F, 0F);
+ rightIcicle2.setTextureSize(64, 64);
+ rightIcicle2.mirror = true;
+ setRotation(rightIcicle2, 0F, -0.5585054F, -0.1919862F);
+ rightIcicle3 = new ModelRenderer(this, 0, 0);
+ rightIcicle3.addBox(-6F, 0F, -1F, 1, 6, 1);
+ rightIcicle3.setRotationPoint(-4F, -1F, 0F);
+ rightIcicle3.setTextureSize(64, 64);
+ rightIcicle3.mirror = true;
+ setRotation(rightIcicle3, 0F, 0.5585054F, -0.1919862F);
+ rightLeg = new ModelRenderer(this, 16, 46);
+ rightLeg.mirror = true;
+ rightLeg.addBox(-2F, 0F, -2F, 4, 14, 4);
+ rightLeg.setRotationPoint(-2F, 10F, 0F);
+ rightLeg.setTextureSize(64, 64);
+ rightLeg.mirror = true;
+ setRotation(rightLeg, 0F, 0F, 0F);
+ rightLeg.mirror = false;
+ Shape1 = new ModelRenderer(this, 0, 12);
+ Shape1.addBox(-0.5F, 0F, -0.5F, 1, 10, 1);
+ Shape1.setRotationPoint(0F, 8F, 1.5F);
+ Shape1.setTextureSize(64, 64);
+ Shape1.mirror = true;
+ setRotation(Shape1, 0.5948578F, 0F, 0F);
+ }
+
+ public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
+ {
+ super.render(entity, f, f1, f2, f3, f4, f5);
+ setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ head.render(f5);
+ leftHorn.render(f5);
+ rightHorn.render(f5);
+ body.render(f5);
+ leftArm.render(f5);
+ leftWrist.render(f5);
+ leftIcicle1.render(f5);
+ leftIcicle2.render(f5);
+ leftIcicle3.render(f5);
+ leftLeg.render(f5);
+ rightArm.render(f5);
+ rightWrist.render(f5);
+ rightIcicle1.render(f5);
+ rightIcicle2.render(f5);
+ rightIcicle3.render(f5);
+ rightLeg.render(f5);
+ Shape1.render(f5);
+ }
+
+ private void setRotation(ModelRenderer model, float x, float y, float z)
+ {
+ model.rotateAngleX = x;
+ model.rotateAngleY = y;
+ model.rotateAngleZ = z;
+ }
+
+ public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
+ {
+ super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ this.head.rotateAngleX = f4 / (180F / (float) Math.PI);
+ this.head.rotateAngleY = f3 / (180F / (float) Math.PI);
+ this.leftLeg.rotateAngleX = MathHelper.cos(f * 0.6662F) * 1.4F * f1;
+ this.rightLeg.rotateAngleX = MathHelper.cos(f * 0.6662F + (float) Math.PI) * 1.4F * f1;
+ this.rightArm.rotateAngleX = MathHelper.cos(f * 0.6662F + (float) Math.PI) * 1.4F * f1;
+ this.leftArm.rotateAngleX = MathHelper.cos(f * 0.6662F) * 1.4F * f1;
+ this.leftHorn.rotateAngleX = head.rotateAngleX + 0.4363323F;
+ this.leftHorn.rotateAngleY = head.rotateAngleY;
+ this.rightHorn.rotateAngleX = head.rotateAngleX + 0.4363323F;
+ this.rightHorn.rotateAngleY = head.rotateAngleY;
+ this.rightIcicle1.rotateAngleX = rightArm.rotateAngleX;
+ this.rightIcicle2.rotateAngleX = rightArm.rotateAngleX;
+ this.rightIcicle3.rotateAngleX = rightArm.rotateAngleX;
+ this.leftIcicle1.rotateAngleX = leftArm.rotateAngleX;
+ this.leftIcicle2.rotateAngleX = leftArm.rotateAngleX;
+ this.leftIcicle3.rotateAngleX = leftArm.rotateAngleX;
+ this.rightWrist.rotateAngleX = rightArm.rotateAngleX;
+ this.leftWrist.rotateAngleX = leftArm.rotateAngleX;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelLowerGuardian.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelLowerGuardian.java
new file mode 100644
index 00000000..61d7b85d
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelLowerGuardian.java
@@ -0,0 +1,207 @@
+package WayofTime.alchemicalWizardry.common.renderer.model;
+
+import WayofTime.alchemicalWizardry.common.entity.mob.EntityLowerGuardian;
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.model.ModelRenderer;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.util.MathHelper;
+
+public class ModelLowerGuardian extends ModelBase
+{
+ //fields
+ ModelRenderer Body;
+ ModelRenderer Torso;
+ ModelRenderer Head;
+ ModelRenderer leftArm;
+ ModelRenderer rightArm;
+ ModelRenderer leftLeg;
+ ModelRenderer leftFoot;
+ ModelRenderer rightLeg;
+ ModelRenderer rightFoot;
+ ModelRenderer leftHorn;
+ ModelRenderer hornAppendage1;
+ ModelRenderer hornAppendage2;
+ ModelRenderer rightHorn;
+ ModelRenderer hornAppendage3;
+ ModelRenderer hornAppendage4;
+
+ public ModelLowerGuardian()
+ {
+ textureWidth = 64;
+ textureHeight = 64;
+ Body = new ModelRenderer(this, 0, 0);
+ Body.addBox(-8F, -7F, -4F, 16, 14, 8);
+ Body.setRotationPoint(0F, -3F, 0F);
+ Body.setTextureSize(64, 64);
+ Body.mirror = true;
+ setRotation(Body, 0F, 0F, 0F);
+ Torso = new ModelRenderer(this, 0, 25);
+ Torso.addBox(-4F, 0F, -3F, 8, 4, 6);
+ Torso.setRotationPoint(0F, 4F, 0F);
+ Torso.setTextureSize(64, 64);
+ Torso.mirror = true;
+ setRotation(Torso, 0F, 0F, 0F);
+ Head = new ModelRenderer(this, 29, 25);
+ Head.addBox(-4F, -8F, -4F, 8, 8, 8);
+ Head.setRotationPoint(0F, -10F, 0F);
+ Head.setTextureSize(64, 64);
+ Head.mirror = true;
+ setRotation(Head, 0F, 0F, 0F);
+ leftArm = new ModelRenderer(this, 17, 42);
+ leftArm.addBox(0F, -2F, -2F, 4, 18, 4);
+ leftArm.setRotationPoint(8F, -8F, 0F);
+ leftArm.setTextureSize(64, 64);
+ leftArm.mirror = true;
+ setRotation(leftArm, 0F, 0F, 0F);
+ rightArm = new ModelRenderer(this, 17, 42);
+ rightArm.mirror = true;
+ rightArm.addBox(-4F, -2F, -2F, 4, 18, 4);
+ rightArm.setRotationPoint(-8F, -8F, 0F);
+ rightArm.setTextureSize(64, 64);
+ rightArm.mirror = true;
+ setRotation(rightArm, 0F, 0F, 0F);
+ rightArm.mirror = false;
+ leftLeg = new ModelRenderer(this, 0, 42);
+ leftLeg.addBox(0F, -2F, -2F, 4, 17, 4);
+ leftLeg.setRotationPoint(4F, 6F, 0F);
+ leftLeg.setTextureSize(64, 64);
+ leftLeg.mirror = true;
+ setRotation(leftLeg, 0F, 0F, 0F);
+ leftFoot = new ModelRenderer(this, 34, 42);
+ leftFoot.addBox(0F, 15F, -6F, 4, 3, 8);
+ leftFoot.setRotationPoint(4F, 6F, 0F);
+ leftFoot.setTextureSize(64, 64);
+ leftFoot.mirror = true;
+ setRotation(leftFoot, 0F, 0F, 0F);
+ rightLeg = new ModelRenderer(this, 0, 42);
+ rightLeg.mirror = true;
+ rightLeg.addBox(-4F, -2F, -2F, 4, 17, 4);
+ rightLeg.setRotationPoint(-4F, 6F, 0F);
+ rightLeg.setTextureSize(64, 64);
+ rightLeg.mirror = true;
+ setRotation(rightLeg, 0F, 0F, 0F);
+ rightLeg.mirror = false;
+ rightFoot = new ModelRenderer(this, 34, 42);
+ rightFoot.mirror = true;
+ rightFoot.addBox(-4F, 15F, -6F, 4, 3, 8);
+ rightFoot.setRotationPoint(-4F, 6F, 0F);
+ rightFoot.setTextureSize(64, 64);
+ rightFoot.mirror = true;
+ setRotation(rightFoot, 0F, 0F, 0F);
+ rightFoot.mirror = false;
+ leftHorn = new ModelRenderer(this, 0, 0);
+ leftHorn.addBox(4F, -11F, 0F, 1, 6, 1);
+ leftHorn.setRotationPoint(0F, -10F, 0F);
+ leftHorn.setTextureSize(64, 64);
+ leftHorn.mirror = true;
+ setRotation(leftHorn, 0F, 0F, 0F);
+ hornAppendage1 = new ModelRenderer(this, 0, 0);
+ hornAppendage1.addBox(4F, -7F, -1F, 1, 1, 1);
+ hornAppendage1.setRotationPoint(0F, -10F, 0F);
+ hornAppendage1.setTextureSize(64, 64);
+ hornAppendage1.mirror = true;
+ setRotation(hornAppendage1, 0F, 0F, 0F);
+ hornAppendage2 = new ModelRenderer(this, 0, 0);
+ hornAppendage2.addBox(4F, -6F, 1F, 1, 1, 1);
+ hornAppendage2.setRotationPoint(0F, -10F, 0F);
+ hornAppendage2.setTextureSize(64, 64);
+ hornAppendage2.mirror = true;
+ setRotation(hornAppendage2, 0F, 0F, 0F);
+ rightHorn = new ModelRenderer(this, 0, 0);
+ rightHorn.mirror = true;
+ rightHorn.addBox(-5F, -11F, 0F, 1, 6, 1);
+ rightHorn.setRotationPoint(0F, -10F, 0F);
+ rightHorn.setTextureSize(64, 64);
+ rightHorn.mirror = true;
+ setRotation(rightHorn, 0F, 0F, 0F);
+ rightHorn.mirror = false;
+ hornAppendage3 = new ModelRenderer(this, 0, 0);
+ hornAppendage3.mirror = true;
+ hornAppendage3.addBox(-5F, -7F, -1F, 1, 1, 1);
+ hornAppendage3.setRotationPoint(0F, -10F, 0F);
+ hornAppendage3.setTextureSize(64, 64);
+ hornAppendage3.mirror = true;
+ setRotation(hornAppendage3, 0F, 0F, 0F);
+ hornAppendage3.mirror = false;
+ hornAppendage4 = new ModelRenderer(this, 0, 0);
+ hornAppendage4.mirror = true;
+ hornAppendage4.addBox(-5F, -6F, 1F, 1, 1, 1);
+ hornAppendage4.setRotationPoint(0F, -10F, 0F);
+ hornAppendage4.setTextureSize(64, 64);
+ hornAppendage4.mirror = true;
+ setRotation(hornAppendage4, 0F, 0F, 0F);
+ hornAppendage4.mirror = false;
+ }
+
+ public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
+ {
+ super.render(entity, f, f1, f2, f3, f4, f5);
+ setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ Body.render(f5);
+ Torso.render(f5);
+ Head.render(f5);
+ leftArm.render(f5);
+ rightArm.render(f5);
+ leftLeg.render(f5);
+ leftFoot.render(f5);
+ rightLeg.render(f5);
+ rightFoot.render(f5);
+ leftHorn.render(f5);
+ hornAppendage1.render(f5);
+ hornAppendage2.render(f5);
+ rightHorn.render(f5);
+ hornAppendage3.render(f5);
+ hornAppendage4.render(f5);
+ }
+
+ private void setRotation(ModelRenderer model, float x, float y, float z)
+ {
+ model.rotateAngleX = x;
+ model.rotateAngleY = y;
+ model.rotateAngleZ = z;
+ }
+
+ public void setLivingAnimations(EntityLivingBase par1EntityLivingBase, float par2, float par3, float par4)
+ {
+ EntityLowerGuardian entityLowerGuardian = (EntityLowerGuardian) par1EntityLivingBase;
+ int i = entityLowerGuardian.getAttackTimer();
+
+ if (i > 0)
+ {
+ this.rightLeg.rotateAngleX = -2.0F + 1.5F * this.func_78172_a((float) i - par4, 10.0F);
+ this.rightFoot.rotateAngleX = -2.0F + 1.5F * this.func_78172_a((float) i - par4, 10.0F);
+ //this.ironGolemLeftArm.rotateAngleX = -2.0F + 1.5F * this.func_78172_a((float)i - par4, 10.0F);
+ }
+ }
+
+ private float func_78172_a(float par1, float par2)
+ {
+ return (Math.abs(par1 % par2 - par2 * 0.5F) - par2 * 0.25F) / (par2 * 0.25F);
+ }
+
+ public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
+ {
+ super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ this.Head.rotateAngleX = f4 / (180F / (float) Math.PI);
+ this.Head.rotateAngleY = f3 / (180F / (float) Math.PI);
+ this.leftLeg.rotateAngleX = MathHelper.cos(f * 0.3662F) * 1.0F * f1;
+ this.rightLeg.rotateAngleX = MathHelper.cos(f * 0.3662F + (float) Math.PI) * 1.0F * f1;
+ this.leftFoot.rotateAngleX = MathHelper.cos(f * 0.3662F) * 1.0F * f1;
+ this.rightFoot.rotateAngleX = MathHelper.cos(f * 0.3662F + (float) Math.PI) * 1.0F * f1;
+ this.rightArm.rotateAngleX = MathHelper.cos(f * 0.3662F + (float) Math.PI) * 1.0F * f1;
+ this.leftArm.rotateAngleX = MathHelper.cos(f * 0.3662F) * 1.0F * f1;
+ this.hornAppendage1.rotateAngleX = this.Head.rotateAngleX;
+ this.hornAppendage1.rotateAngleY = this.Head.rotateAngleY;
+ this.hornAppendage2.rotateAngleX = this.Head.rotateAngleX;
+ this.hornAppendage2.rotateAngleY = this.Head.rotateAngleY;
+ this.hornAppendage3.rotateAngleX = this.Head.rotateAngleX;
+ this.hornAppendage3.rotateAngleY = this.Head.rotateAngleY;
+ this.hornAppendage4.rotateAngleX = this.Head.rotateAngleX;
+ this.hornAppendage4.rotateAngleY = this.Head.rotateAngleY;
+ this.leftHorn.rotateAngleX = this.Head.rotateAngleX;
+ this.leftHorn.rotateAngleY = this.Head.rotateAngleY;
+ this.rightHorn.rotateAngleX = this.Head.rotateAngleX;
+ this.rightHorn.rotateAngleY = this.Head.rotateAngleY;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelMeteor.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelMeteor.java
new file mode 100644
index 00000000..26a94989
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelMeteor.java
@@ -0,0 +1,90 @@
+package WayofTime.alchemicalWizardry.common.renderer.model;
+
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.model.ModelRenderer;
+import net.minecraft.entity.Entity;
+
+public class ModelMeteor extends ModelBase
+{
+ //fields
+ ModelRenderer Shape1;
+ ModelRenderer Shape2;
+ ModelRenderer Shape3;
+ ModelRenderer Shape4;
+ ModelRenderer Shape5;
+ ModelRenderer Shape6;
+ ModelRenderer Shape7;
+
+ public ModelMeteor()
+ {
+ textureWidth = 64;
+ textureHeight = 64;
+ Shape1 = new ModelRenderer(this, 0, 0);
+ Shape1.addBox(-8F, -8F, -8F, 16, 16, 16);
+ Shape1.setRotationPoint(0F, 0F, 0F);
+ Shape1.setTextureSize(64, 64);
+ Shape1.mirror = true;
+ setRotation(Shape1, 0F, 0F, 0F);
+ Shape2 = new ModelRenderer(this, 0, 32);
+ Shape2.addBox(3F, -10F, -1F, 12, 12, 12);
+ Shape2.setRotationPoint(0F, 0F, 0F);
+ Shape2.setTextureSize(64, 64);
+ Shape2.mirror = true;
+ setRotation(Shape2, 0F, 0F, 0F);
+ Shape3 = new ModelRenderer(this, 0, 32);
+ Shape3.addBox(0F, 0F, -10F, 12, 12, 12);
+ Shape3.setRotationPoint(0F, 0F, 0F);
+ Shape3.setTextureSize(64, 64);
+ Shape3.mirror = true;
+ setRotation(Shape3, 0F, 0F, 0F);
+ Shape4 = new ModelRenderer(this, 0, 32);
+ Shape4.addBox(1F, 2F, 2F, 12, 12, 12);
+ Shape4.setRotationPoint(0F, 0F, 0F);
+ Shape4.setTextureSize(64, 64);
+ Shape4.mirror = true;
+ setRotation(Shape4, 0F, 0F, 0F);
+ Shape5 = new ModelRenderer(this, 0, 32);
+ Shape5.addBox(-12F, -5F, 0F, 12, 12, 12);
+ Shape5.setRotationPoint(0F, 0F, 0F);
+ Shape5.setTextureSize(64, 64);
+ Shape5.mirror = true;
+ setRotation(Shape5, 0F, 0F, 0F);
+ Shape6 = new ModelRenderer(this, 0, 32);
+ Shape6.addBox(-13F, -2F, -11F, 12, 12, 12);
+ Shape6.setRotationPoint(0F, 0F, 0F);
+ Shape6.setTextureSize(64, 64);
+ Shape6.mirror = true;
+ setRotation(Shape6, 0F, 0F, 0F);
+ Shape7 = new ModelRenderer(this, 0, 32);
+ Shape7.addBox(-6F, -14F, -9F, 12, 12, 12);
+ Shape7.setRotationPoint(0F, 0F, 0F);
+ Shape7.setTextureSize(64, 64);
+ Shape7.mirror = true;
+ setRotation(Shape7, 0F, 0F, 0F);
+ }
+
+ public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
+ {
+ super.render(entity, f, f1, f2, f3, f4, f5);
+ setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ Shape1.render(f5);
+ Shape2.render(f5);
+ Shape3.render(f5);
+ Shape4.render(f5);
+ Shape5.render(f5);
+ Shape6.render(f5);
+ Shape7.render(f5);
+ }
+
+ private void setRotation(ModelRenderer model, float x, float y, float z)
+ {
+ model.rotateAngleX = x;
+ model.rotateAngleY = y;
+ model.rotateAngleZ = z;
+ }
+
+ public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
+ {
+ super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelOmegaArmour.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelOmegaArmour.java
new file mode 100644
index 00000000..f583149e
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelOmegaArmour.java
@@ -0,0 +1,899 @@
+package WayofTime.alchemicalWizardry.common.renderer.model;
+
+import net.minecraft.client.model.ModelBiped;
+import net.minecraft.client.model.ModelRenderer;
+import net.minecraft.entity.Entity;
+
+public class ModelOmegaArmour extends ModelBiped
+{
+// ModelRenderer head;
+// ModelRenderer body;
+// ModelRenderer rightarm;
+// ModelRenderer leftarm;
+// ModelRenderer rightleg;
+// ModelRenderer leftleg;
+ ModelRenderer leftFacePlate;
+ ModelRenderer rightFacePlate;
+ ModelRenderer facePlate1;
+ ModelRenderer facePlate2;
+ ModelRenderer facePlate3;
+ ModelRenderer leftWingPlate1;
+ ModelRenderer leftWingPlate2;
+ ModelRenderer rightWingPlate1;
+ ModelRenderer rightWingPlate2;
+ ModelRenderer topPlate1;
+ ModelRenderer topPlate2;
+ ModelRenderer topPlate3;
+ ModelRenderer backPlate1;
+ ModelRenderer backPlate2;
+ ModelRenderer backPlate3;
+ ModelRenderer backPlate4;
+ ModelRenderer backPlate5;
+ ModelRenderer backPlate6;
+ ModelRenderer eyePlate;
+ ModelRenderer rightArmMain;
+ ModelRenderer rightKnucklePlate;
+ ModelRenderer rightKnuckleBrace;
+ ModelRenderer rightKnuckle1;
+ ModelRenderer rightKnuckle2;
+ ModelRenderer rightKnuckle3;
+ ModelRenderer rightKnuckle4;
+ ModelRenderer rightKnuckle5;
+ ModelRenderer rightKnuckle6;
+ ModelRenderer rightShoulder1;
+ ModelRenderer rightShoulder2;
+ ModelRenderer rightShoulder3;
+ ModelRenderer mainPlate;
+ ModelRenderer chestPlate1;
+ ModelRenderer chestPlate2;
+ ModelRenderer chestPlate3;
+ ModelRenderer chestPlate4;
+ ModelRenderer chestPlate5;
+ ModelRenderer chestPlate6;
+ ModelRenderer belt;
+ ModelRenderer leftArmMain;
+ ModelRenderer leftKnucklePlate;
+ ModelRenderer leftKnuckleBrace;
+ ModelRenderer leftKnuckle1;
+ ModelRenderer leftKnuckle2;
+ ModelRenderer leftKnuckle3;
+ ModelRenderer leftKnuckle4;
+ ModelRenderer leftKnuckle5;
+ ModelRenderer leftKnuckle6;
+ ModelRenderer leftShoulder1;
+ ModelRenderer leftShoulder2;
+ ModelRenderer leftShoulder3;
+ ModelRenderer leftBootBottom;
+ ModelRenderer leftBootPlate;
+ ModelRenderer leftBootBrace;
+ ModelRenderer leftBootWing1;
+ ModelRenderer leftBootWing2;
+ ModelRenderer rightBootBottom;
+ ModelRenderer rightBootPlate;
+ ModelRenderer rightBootBrace;
+ ModelRenderer rightBootWing1;
+ ModelRenderer rightBootWing2;
+ ModelRenderer leftLegSidePlate;
+ ModelRenderer leftLegMain;
+ ModelRenderer leftLegPlate1;
+ ModelRenderer leftLegPlate2;
+ ModelRenderer leftLegPlate3;
+ ModelRenderer leftLegPlate4;
+ ModelRenderer rightLegSidePlate;
+ ModelRenderer rightLegMain;
+ ModelRenderer rightLegPlate1;
+ ModelRenderer rightLegPlate2;
+ ModelRenderer rightLegPlate3;
+ ModelRenderer rightLegPlate4;
+
+ public ModelOmegaArmour(float f, boolean addHelmet, boolean addChestPiece, boolean addLeggings, boolean addBoots)
+ {
+ super(f, 0.0f, 128, 128);
+ textureWidth = 128;
+ textureHeight = 128;
+
+// boolean addHelmet = true;
+// boolean addChestPiece = true;
+// boolean addLeggings = true;
+// boolean addBoots = true;
+
+ /* Duplicate player model */
+ {
+// head = new ModelRenderer(this, 0, 0);
+// head.addBox(-4F, -8F, -4F, 8, 8, 8);
+// head.setRotationPoint(0F, 0F, 0F);
+// head.setTextureSize(128, 128);
+// head.mirror = true;
+// setRotation(head, 0F, 0F, 0F);
+// body = new ModelRenderer(this, 16, 16);
+// body.addBox(-4F, 0F, -2F, 8, 12, 4);
+// body.setRotationPoint(0F, 0F, 0F);
+// body.setTextureSize(128, 128);
+// body.mirror = true;
+// setRotation(body, 0F, 0F, 0F);
+// rightarm = new ModelRenderer(this, 40, 16);
+// rightarm.addBox(-3F, -2F, -2F, 4, 12, 4);
+// rightarm.setRotationPoint(0F, 0F, 0F);
+// rightarm.setTextureSize(128, 128);
+// rightarm.mirror = true;
+// setRotation(rightarm, 0F, 0F, 0F);
+// leftarm = new ModelRenderer(this, 40, 16);
+// leftarm.addBox(-1F, -2F, -2F, 4, 12, 4);
+// leftarm.setRotationPoint(0F, 0F, 0F);
+// leftarm.setTextureSize(128, 128);
+// leftarm.mirror = true;
+// setRotation(leftarm, 0F, 0F, 0F);
+// rightleg = new ModelRenderer(this, 0, 16);
+// rightleg.addBox(-2F, 0F, -2F, 4, 12, 4);
+// rightleg.setRotationPoint(-2F, 12F, 0F);
+// rightleg.setTextureSize(128, 128);
+// rightleg.mirror = true;
+// setRotation(rightleg, 0F, 0F, 0F);
+// leftleg = new ModelRenderer(this, 0, 16);
+// leftleg.addBox(-2F, 0F, -2F, 4, 12, 4);
+// leftleg.setRotationPoint(2F, 12F, 0F);
+// leftleg.setTextureSize(128, 128);
+// leftleg.mirror = true;
+// setRotation(leftleg, 0F, 0F, 0F);
+ }
+
+ /* Helmet */
+ {
+ leftFacePlate = new ModelRenderer(this, 66, 52);
+ leftFacePlate.addBox(-2F, -5F, -5F, 5, 4, 1);
+ leftFacePlate.setRotationPoint(0F, 0F, 0F);
+ leftFacePlate.setTextureSize(128, 128);
+ leftFacePlate.mirror = true;
+ setRotation(leftFacePlate, 0.296706F, -0.3490659F, -0.0872665F);
+
+ rightFacePlate = new ModelRenderer(this, 66, 52);
+ rightFacePlate.mirror = true;
+ rightFacePlate.addBox(-3F, -5F, -5F, 5, 4, 1);
+ rightFacePlate.setRotationPoint(0F, 0F, 0F);
+ rightFacePlate.setTextureSize(128, 128);
+ rightFacePlate.mirror = true;
+ setRotation(rightFacePlate, 0.296706F, 0.3490659F, 0.0872665F);
+ rightFacePlate.mirror = false;
+
+ facePlate1 = new ModelRenderer(this, 79, 52);
+ facePlate1.addBox(-5F, -8F, -5F, 10, 3, 1);
+ facePlate1.setRotationPoint(0F, 0F, 0F);
+ facePlate1.setTextureSize(128, 128);
+ facePlate1.mirror = true;
+ setRotation(facePlate1, 0F, 0F, 0F);
+
+ facePlate2 = new ModelRenderer(this, 79, 57);
+ facePlate2.addBox(-1F, -5F, -5F, 2, 1, 1);
+ facePlate2.setRotationPoint(0F, 0F, 0F);
+ facePlate2.setTextureSize(128, 128);
+ facePlate2.mirror = true;
+ setRotation(facePlate2, 0F, 0F, 0F);
+
+ facePlate3 = new ModelRenderer(this, 79, 60);
+ facePlate3.addBox(-3F, -4F, -5F, 6, 1, 1);
+ facePlate3.setRotationPoint(0F, 0F, 0F);
+ facePlate3.setTextureSize(128, 128);
+ facePlate3.mirror = true;
+ setRotation(facePlate3, 0F, 0F, 0F);
+
+ leftWingPlate1 = new ModelRenderer(this, 66, 58);
+ leftWingPlate1.addBox(5F, -5F, -2.5F, 1, 5, 8);
+ leftWingPlate1.setRotationPoint(0F, 0F, 0F);
+ leftWingPlate1.setTextureSize(128, 128);
+ leftWingPlate1.mirror = true;
+ setRotation(leftWingPlate1, 0.2617994F, 0.1745329F, 0F);
+
+ leftWingPlate2 = new ModelRenderer(this, 66, 72);
+ leftWingPlate2.addBox(5F, -8F, -2F, 1, 3, 10);
+ leftWingPlate2.setRotationPoint(0F, 0F, 0F);
+ leftWingPlate2.setTextureSize(128, 128);
+ leftWingPlate2.mirror = true;
+ setRotation(leftWingPlate2, 0.2617994F, 0.1745329F, 0F);
+
+ rightWingPlate1 = new ModelRenderer(this, 66, 58);
+ rightWingPlate1.mirror = true;
+ rightWingPlate1.addBox(-6F, -5F, -2.5F, 1, 5, 8);
+ rightWingPlate1.setRotationPoint(0F, 0F, 0F);
+ rightWingPlate1.setTextureSize(128, 128);
+ rightWingPlate1.mirror = true;
+ setRotation(rightWingPlate1, 0.2617994F, -0.1745329F, 0F);
+ rightWingPlate1.mirror = false;
+
+ rightWingPlate2 = new ModelRenderer(this, 66, 72);
+ rightWingPlate2.mirror = true;
+ rightWingPlate2.addBox(-6F, -8F, -2F, 1, 3, 10);
+ rightWingPlate2.setRotationPoint(0F, 0F, 0F);
+ rightWingPlate2.setTextureSize(128, 128);
+ rightWingPlate2.mirror = true;
+ setRotation(rightWingPlate2, 0.2617994F, -0.1745329F, 0F);
+ rightWingPlate2.mirror = false;
+
+ topPlate1 = new ModelRenderer(this, 79, 72);
+ topPlate1.addBox(-5F, -9F, -0.5F, 10, 1, 5);
+ topPlate1.setRotationPoint(0F, 0F, 0F);
+ topPlate1.setTextureSize(128, 128);
+ topPlate1.mirror = true;
+ setRotation(topPlate1, 0.4363323F, 0F, 0F);
+
+ topPlate2 = new ModelRenderer(this, 79, 72);
+ topPlate2.addBox(-5F, -8F, 1.5F, 10, 1, 5);
+ topPlate2.setRotationPoint(0F, 0F, 0F);
+ topPlate2.setTextureSize(128, 128);
+ topPlate2.mirror = true;
+ setRotation(topPlate2, 0.4363323F, 0F, 0F);
+
+ topPlate3 = new ModelRenderer(this, 79, 72);
+ topPlate3.addBox(-5F, -7F, 3.5F, 10, 1, 5);
+ topPlate3.setRotationPoint(0F, 0F, 0F);
+ topPlate3.setTextureSize(128, 128);
+ topPlate3.mirror = true;
+ setRotation(topPlate3, 0.4363323F, 0F, 0F);
+
+ backPlate1 = new ModelRenderer(this, 66, 86);
+ backPlate1.mirror = true;
+ backPlate1.addBox(-4.5F, -7F, 6F, 6, 4, 1);
+ backPlate1.setRotationPoint(0F, 0F, 0F);
+ backPlate1.setTextureSize(128, 128);
+ backPlate1.mirror = true;
+ setRotation(backPlate1, 0.2617994F, -0.2617994F, 0F);
+ backPlate1.mirror = false;
+
+ backPlate2 = new ModelRenderer(this, 66, 86);
+ backPlate2.mirror = true;
+ backPlate2.addBox(-4.5F, -6.5F, 6F, 6, 4, 1);
+ backPlate2.setRotationPoint(0F, 2F, 0F);
+ backPlate2.setTextureSize(128, 128);
+ backPlate2.mirror = true;
+ setRotation(backPlate2, 0.2617994F, -0.2617994F, 0F);
+ backPlate2.mirror = false;
+
+ backPlate3 = new ModelRenderer(this, 66, 86);
+ backPlate3.mirror = true;
+ backPlate3.addBox(-4.5F, -6F, 6F, 6, 4, 1);
+ backPlate3.setRotationPoint(0F, 4F, 0F);
+ backPlate3.setTextureSize(128, 128);
+ backPlate3.mirror = true;
+ setRotation(backPlate3, 0.2617994F, -0.2617994F, 0F);
+ backPlate3.mirror = false;
+
+ backPlate4 = new ModelRenderer(this, 66, 86);
+ backPlate4.addBox(-1.5F, -7F, 6F, 6, 4, 1);
+ backPlate4.setRotationPoint(0F, 0F, 0F);
+ backPlate4.setTextureSize(128, 128);
+ backPlate4.mirror = true;
+ setRotation(backPlate4, 0.2617994F, 0.2617994F, 0F);
+
+ backPlate5 = new ModelRenderer(this, 66, 86);
+ backPlate5.addBox(-1.5F, -7F, 6F, 6, 4, 1);
+ backPlate5.setRotationPoint(0F, 2.5F, 0F);
+ backPlate5.setTextureSize(128, 128);
+ backPlate5.mirror = true;
+ setRotation(backPlate5, 0.2617994F, 0.2617994F, 0F);
+
+ backPlate6 = new ModelRenderer(this, 66, 86);
+ backPlate6.addBox(-1.5F, -7F, 6F, 6, 4, 1);
+ backPlate6.setRotationPoint(0F, 5F, 0F);
+ backPlate6.setTextureSize(128, 128);
+ backPlate6.mirror = true;
+ setRotation(backPlate6, 0.2617994F, 0.2617994F, 0F);
+
+ eyePlate = new ModelRenderer(this, 63, 38);
+ eyePlate.addBox(-4F, -5F, -4.5F, 8, 2, 1);
+ eyePlate.setRotationPoint(0F, 0F, 0F);
+ eyePlate.setTextureSize(128, 128);
+ eyePlate.mirror = true;
+ setRotation(eyePlate, 0F, 0F, 0F);
+ }
+
+ /* Right arm */
+ {
+ rightArmMain = new ModelRenderer(this, 0, 33);
+ rightArmMain.mirror = true;
+ rightArmMain.addBox(-3.5F, -2.5F, -2.5F, 5, 11, 5);
+ rightArmMain.setRotationPoint(0F, 0F, 0F);
+ rightArmMain.setTextureSize(128, 128);
+ rightArmMain.mirror = true;
+ setRotation(rightArmMain, 0F, 0F, 0F);
+
+ rightKnucklePlate = new ModelRenderer(this, 0, 50);
+ rightKnucklePlate.addBox(-4F, 4F, -1.5F, 1, 5, 3);
+ rightKnucklePlate.setRotationPoint(0F, 0F, 0F);
+ rightKnucklePlate.setTextureSize(128, 128);
+ rightKnucklePlate.mirror = true;
+ setRotation(rightKnucklePlate, 0F, 0F, 0F);
+
+ rightKnuckleBrace = new ModelRenderer(this, 9, 50);
+ rightKnuckleBrace.mirror = true;
+ rightKnuckleBrace.addBox(-4F, 3F, -3F, 2, 1, 6);
+ rightKnuckleBrace.setRotationPoint(0F, 0F, 0F);
+ rightKnuckleBrace.setTextureSize(128, 128);
+ setRotation(rightKnuckleBrace, 0F, 0F, 0F);
+
+ rightKnuckle1 = new ModelRenderer(this, 0, 59);
+ rightKnuckle1.mirror = true;
+ rightKnuckle1.addBox(-4F, 7F, -2.5F, 1, 6, 1);
+ rightKnuckle1.setRotationPoint(0F, 0F, 0F);
+ rightKnuckle1.setTextureSize(128, 128);
+ setRotation(rightKnuckle1, 0F, 0F, 0F);
+
+ rightKnuckle2 = new ModelRenderer(this, 5, 59);
+ rightKnuckle2.mirror = true;
+ rightKnuckle2.addBox(-3F, 11F, -2.5F, 1, 3, 1);
+ rightKnuckle2.setRotationPoint(0F, 0F, 0F);
+ rightKnuckle2.setTextureSize(128, 128);
+ setRotation(rightKnuckle2, 0F, 0F, 0F);
+
+ rightKnuckle3 = new ModelRenderer(this, 0, 59);
+ rightKnuckle3.mirror = true;
+ rightKnuckle3.addBox(-4.5F, 8F, -0.5F, 1, 6, 1);
+ rightKnuckle3.setRotationPoint(0F, 0F, 0F);
+ rightKnuckle3.setTextureSize(128, 128);
+ setRotation(rightKnuckle3, 0F, 0F, 0F);
+
+ rightKnuckle4 = new ModelRenderer(this, 5, 59);
+ rightKnuckle4.mirror = true;
+ rightKnuckle4.addBox(-3.5F, 12F, -0.5F, 1, 3, 1);
+ rightKnuckle4.setRotationPoint(0F, 0F, 0F);
+ rightKnuckle4.setTextureSize(128, 128);
+ setRotation(rightKnuckle4, 0F, 0F, 0F);
+
+ rightKnuckle5 = new ModelRenderer(this, 0, 59);
+ rightKnuckle5.mirror = true;
+ rightKnuckle5.addBox(-4F, 7F, 1.5F, 1, 6, 1);
+ rightKnuckle5.setRotationPoint(0F, 0F, 0F);
+ rightKnuckle5.setTextureSize(128, 128);
+ setRotation(rightKnuckle5, 0F, 0F, 0F);
+
+ rightKnuckle6 = new ModelRenderer(this, 5, 59);
+ rightKnuckle6.mirror = true;
+ rightKnuckle6.addBox(-3F, 11F, 1.5F, 1, 3, 1);
+ rightKnuckle6.setRotationPoint(0F, 0F, 0F);
+ rightKnuckle6.setTextureSize(128, 128);
+ setRotation(rightKnuckle6, 0F, 0F, 0F);
+
+ rightShoulder1 = new ModelRenderer(this, 10, 59);
+ rightShoulder1.mirror = true;
+ rightShoulder1.addBox(-5F, -3F, -4F, 1, 4, 8);
+ rightShoulder1.setRotationPoint(0F, 0F, 0F);
+ rightShoulder1.setTextureSize(128, 128);
+ setRotation(rightShoulder1, 0F, 0F, 0.6981317F);
+
+ rightShoulder2 = new ModelRenderer(this, 10, 59);
+ rightShoulder2.mirror = true;
+ rightShoulder2.addBox(-4F, -1.5F, -4F, 1, 4, 8);
+ rightShoulder2.setRotationPoint(0F, 0F, 0F);
+ rightShoulder2.setTextureSize(128, 128);
+ setRotation(rightShoulder2, 0F, 0F, 0.6981317F);
+
+ rightShoulder3 = new ModelRenderer(this, 10, 59);
+ rightShoulder3.mirror = true;
+ rightShoulder3.addBox(-3F, 0F, -4F, 1, 4, 8);
+ rightShoulder3.setRotationPoint(0F, 0F, 0F);
+ rightShoulder3.setTextureSize(128, 128);
+ setRotation(rightShoulder3, 0F, 0F, 0.6981317F);
+ }
+
+ /* Chest piece main body */
+ {
+ mainPlate = new ModelRenderer(this, 31, 33);
+ mainPlate.addBox(-4.5F, -0.5F, -3F, 9, 12, 6);
+ mainPlate.setRotationPoint(0F, 0F, 0F);
+ mainPlate.setTextureSize(128, 128);
+ mainPlate.mirror = true;
+ setRotation(mainPlate, 0F, 0F, 0F);
+
+ chestPlate1 = new ModelRenderer(this, 63, 33);
+ chestPlate1.addBox(-1.5F, 3F, -4.5F, 6, 2, 1);
+ chestPlate1.setRotationPoint(0F, -3F, -1F);
+ chestPlate1.setTextureSize(128, 128);
+ setRotation(chestPlate1, 0.3490659F, 0F, -0.2617994F);
+
+ chestPlate2 = new ModelRenderer(this, 63, 33);
+ chestPlate2.addBox(-1.5F, 3F, -4.5F, 6, 2, 1);
+ chestPlate2.setRotationPoint(0F, -1.5F, -1F);
+ chestPlate2.setTextureSize(128, 128);
+ setRotation(chestPlate2, 0.3490659F, 0F, -0.2617994F);
+
+ chestPlate3 = new ModelRenderer(this, 63, 33);
+ chestPlate3.addBox(-1.5F, 3F, -4.5F, 6, 2, 1);
+ chestPlate3.setRotationPoint(0F, 0F, -1F);
+ chestPlate3.setTextureSize(128, 128);
+ setRotation(chestPlate3, 0.3490659F, 0F, -0.2617994F);
+
+ chestPlate4 = new ModelRenderer(this, 63, 33);
+ chestPlate4.mirror = true;
+ chestPlate4.addBox(-4.5F, 3F, -4.5F, 6, 2, 1);
+ chestPlate4.setRotationPoint(0F, -3F, -1F);
+ chestPlate4.setTextureSize(128, 128);
+ setRotation(chestPlate4, 0.3490659F, 0F, 0.2617994F);
+
+ chestPlate5 = new ModelRenderer(this, 63, 33);
+ chestPlate5.mirror = true;
+ chestPlate5.addBox(-4.5F, 3F, -4.5F, 6, 2, 1);
+ chestPlate5.setRotationPoint(0F, -1.5F, -1F);
+ chestPlate5.setTextureSize(128, 128);
+ setRotation(chestPlate5, 0.3490659F, 0F, 0.2617994F);
+
+ chestPlate6 = new ModelRenderer(this, 63, 33);
+ chestPlate6.mirror = true;
+ chestPlate6.addBox(-4.5F, 3F, -4.5F, 6, 2, 1);
+ chestPlate6.setRotationPoint(0F, 0F, -1F);
+ chestPlate6.setTextureSize(128, 128);
+ setRotation(chestPlate6, 0.3490659F, 0F, 0.2617994F);
+ }
+
+ /* Left arm */
+ {
+ leftArmMain = new ModelRenderer(this, 0, 33);
+ leftArmMain.addBox(-1.5F, -2.533333F, -2.5F, 5, 11, 5);
+ leftArmMain.setRotationPoint(0F, 0F, 0F);
+ leftArmMain.setTextureSize(128, 128);
+ leftArmMain.mirror = true;
+ setRotation(leftArmMain, 0F, 0F, 0F);
+
+ leftKnucklePlate = new ModelRenderer(this, 0, 50);
+ leftKnucklePlate.addBox(3F, 4F, -1.5F, 1, 5, 3);
+ leftKnucklePlate.setRotationPoint(0F, 0F, 0F);
+ leftKnucklePlate.setTextureSize(128, 128);
+ leftKnucklePlate.mirror = true;
+ setRotation(leftKnucklePlate, 0F, 0F, 0F);
+
+ leftKnuckleBrace = new ModelRenderer(this, 9, 50);
+ leftKnuckleBrace.addBox(2F, 3F, -3F, 2, 1, 6);
+ leftKnuckleBrace.setRotationPoint(0F, 0F, 0F);
+ leftKnuckleBrace.setTextureSize(128, 128);
+ leftKnuckleBrace.mirror = true;
+ setRotation(leftKnuckleBrace, 0F, 0F, 0F);
+
+ leftKnuckle1 = new ModelRenderer(this, 0, 59);
+ leftKnuckle1.addBox(3F, 7F, -2.5F, 1, 6, 1);
+ leftKnuckle1.setRotationPoint(0F, 0F, 0F);
+ leftKnuckle1.setTextureSize(128, 128);
+ leftKnuckle1.mirror = true;
+ setRotation(leftKnuckle1, 0F, 0F, 0F);
+
+ leftKnuckle2 = new ModelRenderer(this, 5, 59);
+ leftKnuckle2.addBox(2F, 11F, -2.5F, 1, 3, 1);
+ leftKnuckle2.setRotationPoint(0F, 0F, 0F);
+ leftKnuckle2.setTextureSize(128, 128);
+ leftKnuckle2.mirror = true;
+ setRotation(leftKnuckle2, 0F, 0F, 0F);
+
+ leftKnuckle3 = new ModelRenderer(this, 0, 59);
+ leftKnuckle3.addBox(3.5F, 8F, -0.5F, 1, 6, 1);
+ leftKnuckle3.setRotationPoint(0F, 0F, 0F);
+ leftKnuckle3.setTextureSize(128, 128);
+ leftKnuckle3.mirror = true;
+ setRotation(leftKnuckle3, 0F, 0F, 0F);
+
+ leftKnuckle4 = new ModelRenderer(this, 5, 59);
+ leftKnuckle4.addBox(2.5F, 12F, -0.5F, 1, 3, 1);
+ leftKnuckle4.setRotationPoint(0F, 0F, 0F);
+ leftKnuckle4.setTextureSize(128, 128);
+ leftKnuckle4.mirror = true;
+ setRotation(leftKnuckle4, 0F, 0F, 0F);
+
+ leftKnuckle5 = new ModelRenderer(this, 0, 59);
+ leftKnuckle5.addBox(3F, 7F, 1.5F, 1, 6, 1);
+ leftKnuckle5.setRotationPoint(0F, 0F, 0F);
+ leftKnuckle5.setTextureSize(128, 128);
+ leftKnuckle5.mirror = true;
+ setRotation(leftKnuckle5, 0F, 0F, 0F);
+
+ leftKnuckle6 = new ModelRenderer(this, 5, 59);
+ leftKnuckle6.addBox(2F, 11F, 1.5F, 1, 3, 1);
+ leftKnuckle6.setRotationPoint(0F, 0F, 0F);
+ leftKnuckle6.setTextureSize(128, 128);
+ leftKnuckle6.mirror = true;
+ setRotation(leftKnuckle6, 0F, 0F, 0F);
+
+ leftShoulder1 = new ModelRenderer(this, 10, 59);
+ leftShoulder1.addBox(4F, -3F, -4F, 1, 4, 8);
+ leftShoulder1.setRotationPoint(0F, 0F, 0F);
+ leftShoulder1.setTextureSize(128, 128);
+ leftShoulder1.mirror = true;
+ setRotation(leftShoulder1, 0F, 0F, -0.6981317F);
+
+ leftShoulder2 = new ModelRenderer(this, 10, 59);
+ leftShoulder2.addBox(3F, -1.5F, -4F, 1, 4, 8);
+ leftShoulder2.setRotationPoint(0F, 0F, 0F);
+ leftShoulder2.setTextureSize(128, 128);
+ leftShoulder2.mirror = true;
+ setRotation(leftShoulder2, 0F, 0F, -0.6981317F);
+
+ leftShoulder3 = new ModelRenderer(this, 10, 59);
+ leftShoulder3.addBox(2F, 0F, -4F, 1, 4, 8);
+ leftShoulder3.setRotationPoint(0F, 0F, 0F);
+ leftShoulder3.setTextureSize(128, 128);
+ leftShoulder3.mirror = true;
+ setRotation(leftShoulder3, 0F, 0F, -0.6981317F);
+ }
+
+ /* Left boot */
+ {
+ leftBootBottom = new ModelRenderer(this, 0, 84);
+ leftBootBottom.addBox(-2.5F, 9.5F, -5.5F, 6, 3, 8);
+ leftBootBottom.setRotationPoint(0F, 0F, 0F);
+ leftBootBottom.setTextureSize(128, 128);
+ leftBootBottom.mirror = true;
+ setRotation(leftBootBottom, 0F, 0F, 0F);
+
+ leftBootPlate = new ModelRenderer(this, 0, 96);
+ leftBootPlate.addBox(-2F, 6F, 6F, 5, 3, 1);
+ leftBootPlate.setRotationPoint(0F, 0F, 0F);
+ leftBootPlate.setTextureSize(128, 128);
+ leftBootPlate.mirror = true;
+ setRotation(leftBootPlate, -1.151917F, 0F, 0F);
+
+ leftBootBrace = new ModelRenderer(this, 0, 72);
+ leftBootBrace.addBox(-2F, 7F, -3F, 5, 3, 6);
+ leftBootBrace.setRotationPoint(0F, 0F, 0F);
+ leftBootBrace.setTextureSize(128, 128);
+ leftBootBrace.mirror = true;
+ setRotation(leftBootBrace, 0F, 0F, 0F);
+
+ leftBootWing1 = new ModelRenderer(this, 13, 96);
+ leftBootWing1.addBox(3F, 7F, -4F, 1, 1, 7);
+ leftBootWing1.setRotationPoint(0F, 0F, 0F);
+ leftBootWing1.setTextureSize(128, 128);
+ leftBootWing1.mirror = true;
+ setRotation(leftBootWing1, 0.2617994F, 0.1745329F, 0F);
+
+ leftBootWing2 = new ModelRenderer(this, 13, 96);
+ leftBootWing2.addBox(3F, 8F, -5F, 1, 1, 7);
+ leftBootWing2.setRotationPoint(0F, 0F, 0F);
+ leftBootWing2.setTextureSize(128, 128);
+ leftBootWing2.mirror = true;
+ setRotation(leftBootWing2, 0.2617994F, 0.1745329F, 0F);
+ }
+
+
+ /* Right boot */
+ {
+ rightBootBottom = new ModelRenderer(this, 0, 84);
+ rightBootBottom.mirror = true;
+ rightBootBottom.addBox(-3.5F, 9.5F, -5.5F, 6, 3, 8);
+ rightBootBottom.setRotationPoint(0F, 0F, 0F);
+ rightBootBottom.setTextureSize(128, 128);
+ setRotation(rightBootBottom, 0F, 0F, 0F);
+
+ rightBootPlate = new ModelRenderer(this, 0, 96);
+ rightBootPlate.mirror = true;
+ rightBootPlate.addBox(-3F, 6F, 6F, 5, 3, 1);
+ rightBootPlate.setRotationPoint(0F, 0F, 0F);
+ rightBootPlate.setTextureSize(128, 128);
+ setRotation(rightBootPlate, -1.151917F, 0F, 0F);
+
+ rightBootBrace = new ModelRenderer(this, 0, 72);
+ rightBootBrace.mirror = true;
+ rightBootBrace.addBox(-3F, 7F, -3F, 5, 3, 6);
+ rightBootBrace.setRotationPoint(0F, 0F, 0F);
+ rightBootBrace.setTextureSize(128, 128);
+ setRotation(rightBootBrace, 0F, 0F, 0F);
+
+ rightBootWing1 = new ModelRenderer(this, 13, 96);
+ rightBootWing1.mirror = true;
+ rightBootWing1.addBox(-4F, 7F, -4F, 1, 1, 7);
+ rightBootWing1.setRotationPoint(0F, 0F, 0F);
+ rightBootWing1.setTextureSize(128, 128);
+ setRotation(rightBootWing1, 0.2617994F, -0.1745329F, 0F);
+
+ rightBootWing2 = new ModelRenderer(this, 13, 96);
+ rightBootWing2.mirror = true;
+ rightBootWing2.addBox(-4F, 8F, -5F, 1, 1, 7);
+ rightBootWing2.setRotationPoint(0F, 0F, 0F);
+ rightBootWing2.setTextureSize(128, 128);
+ setRotation(rightBootWing2, 0.2617994F, -0.1745329F, 0F);
+ }
+
+ /* Main legs */
+ {
+ belt = new ModelRenderer(this, 31, 52);
+ belt.addBox(-5F, 9.5F, -3.5F, 10, 2, 7);
+ belt.setRotationPoint(0F, 0F, 0F);
+ belt.setTextureSize(128, 128);
+ belt.mirror = true;
+ setRotation(belt, 0F, 0F, 0F);
+ }
+
+ /* Left leg */
+ {
+ leftLegSidePlate = new ModelRenderer(this, 40, 93);
+ leftLegSidePlate.addBox(-0.5F, 12F, -3F, 1, 6, 6);
+ leftLegSidePlate.setRotationPoint(-2F, -12F, 0F);
+ leftLegSidePlate.setTextureSize(128, 128);
+ leftLegSidePlate.mirror = true;
+ setRotation(leftLegSidePlate, 0F, 0F, -0.3490659F);
+
+ leftLegMain = new ModelRenderer(this, 40, 93);
+ leftLegMain.addBox(-0.5F, 11F, -2.5F, 5, 9, 5);
+ leftLegMain.setRotationPoint(-2F, -12F, 0F);
+ leftLegMain.setTextureSize(128, 128);
+ leftLegMain.mirror = true;
+ setRotation(leftLegMain, 0F, 0F, 0F);
+
+ leftLegPlate1 = new ModelRenderer(this, 46, 71);
+ leftLegPlate1.addBox(-2.5F, 11F, -3F, 2, 6, 1);
+ leftLegPlate1.setRotationPoint(-2F, -12F, 0F);
+ leftLegPlate1.setTextureSize(128, 128);
+ leftLegPlate1.mirror = true;
+ setRotation(leftLegPlate1, 0F, 0F, -0.3490659F);
+
+ leftLegPlate2 = new ModelRenderer(this, 46, 71);
+ leftLegPlate2.addBox(-2.5F, 11F, 2F, 2, 6, 1);
+ leftLegPlate2.setRotationPoint(-2F, -12F, 0F);
+ leftLegPlate2.setTextureSize(128, 128);
+ leftLegPlate2.mirror = true;
+ setRotation(leftLegPlate2, 0F, 0F, -0.3490659F);
+
+ leftLegPlate3 = new ModelRenderer(this, 31, 62);
+ leftLegPlate3.addBox(0F, 11.9F, -1F, 4, 7, 1);
+ leftLegPlate3.setRotationPoint(-2F, -12F, 0F);
+ leftLegPlate3.setTextureSize(128, 128);
+ leftLegPlate3.mirror = true;
+ setRotation(leftLegPlate3, -0.1745329F, 0F, 0F);
+
+ leftLegPlate4 = new ModelRenderer(this, 42, 62);
+ leftLegPlate4.addBox(0F, 11.9F, 0F, 4, 7, 1);
+ leftLegPlate4.setRotationPoint(-2F, -12F, 0F);
+ leftLegPlate4.setTextureSize(128, 128);
+ leftLegPlate4.mirror = true;
+ setRotation(leftLegPlate4, 0.1745329F, 0F, 0F);
+ }
+
+ /* Right leg */
+ {
+ rightLegSidePlate = new ModelRenderer(this, 31, 71);
+ rightLegSidePlate.mirror = true;
+ rightLegSidePlate.addBox(-0.5F, 12F, -3F, 1, 6, 6);
+ rightLegSidePlate.setRotationPoint(2F, -12F, 0F);
+ rightLegSidePlate.setTextureSize(128, 128);
+ setRotation(rightLegSidePlate, 0F, 0F, 0.3490659F);
+
+ rightLegMain = new ModelRenderer(this, 40, 93);
+ rightLegMain.mirror = true;
+ rightLegMain.addBox(-4.5F, 11F, -2.5F, 5, 9, 5);
+ rightLegMain.setRotationPoint(2F, -12F, 0F);
+ rightLegMain.setTextureSize(128, 128);
+ setRotation(rightLegMain, 0F, 0F, 0F);
+
+ rightLegPlate1 = new ModelRenderer(this, 46, 71);
+ rightLegPlate1.mirror = true;
+ rightLegPlate1.addBox(0.5F, 11F, -3F, 2, 6, 1);
+ rightLegPlate1.setRotationPoint(2F, -12F, 0F);
+ rightLegPlate1.setTextureSize(128, 128);
+ setRotation(rightLegPlate1, 0F, 0F, 0.3490659F);
+
+ rightLegPlate2 = new ModelRenderer(this, 46, 71);
+ rightLegPlate2.mirror = true;
+ rightLegPlate2.addBox(0.5F, 11F, 2F, 2, 6, 1);
+ rightLegPlate2.setRotationPoint(2F, -12F, 0F);
+ rightLegPlate2.setTextureSize(128, 128);
+ setRotation(rightLegPlate2, 0F, 0F, 0.3490659F);
+
+ rightLegPlate3 = new ModelRenderer(this, 31, 62);
+ rightLegPlate3.mirror = true;
+ rightLegPlate3.addBox(-4F, 11.9F, -1F, 4, 7, 1);
+ rightLegPlate3.setRotationPoint(2F, -12F, 0F);
+ rightLegPlate3.setTextureSize(128, 128);
+ setRotation(rightLegPlate3, -0.1745329F, 0F, 0F);
+
+ rightLegPlate4 = new ModelRenderer(this, 42, 62);
+ rightLegPlate4.mirror = true;
+ rightLegPlate4.addBox(-4F, 11.9F, 0F, 4, 7, 1);
+ rightLegPlate4.setRotationPoint(2F, -12F, 0F);
+ rightLegPlate4.setTextureSize(128, 128);
+ setRotation(rightLegPlate4, 0.1745329F, 0F, 0F);
+ }
+
+ this.bipedHead.cubeList.clear();
+ this.bipedHeadwear.cubeList.clear();
+ if(addHelmet)
+ {
+ this.bipedHead.addChild(this.leftFacePlate);
+ this.bipedHead.addChild(this.rightFacePlate);
+ this.bipedHead.addChild(this.facePlate1);
+ this.bipedHead.addChild(this.facePlate2);
+ this.bipedHead.addChild(this.facePlate3);
+ this.bipedHead.addChild(this.leftWingPlate1);
+ this.bipedHead.addChild(this.leftWingPlate2);
+ this.bipedHead.addChild(this.rightWingPlate1);
+ this.bipedHead.addChild(this.rightWingPlate2);
+ this.bipedHead.addChild(this.topPlate1);
+ this.bipedHead.addChild(this.topPlate2);
+ this.bipedHead.addChild(this.topPlate3);
+ this.bipedHead.addChild(this.backPlate1);
+ this.bipedHead.addChild(this.backPlate2);
+ this.bipedHead.addChild(this.backPlate3);
+ this.bipedHead.addChild(this.backPlate4);
+ this.bipedHead.addChild(this.backPlate5);
+ this.bipedHead.addChild(this.backPlate6);
+ this.bipedHead.addChild(this.eyePlate);
+ }
+
+ this.bipedBody.cubeList.clear();
+ if(addChestPiece)
+ {
+ this.bipedBody.addChild(this.chestPlate1);
+ this.bipedBody.addChild(this.chestPlate2);
+ this.bipedBody.addChild(this.chestPlate3);
+ this.bipedBody.addChild(this.chestPlate4);
+ this.bipedBody.addChild(this.chestPlate5);
+ this.bipedBody.addChild(this.chestPlate6);
+ this.bipedBody.addChild(this.mainPlate);
+ }
+ if(addLeggings)
+ {
+ this.bipedBody.addChild(this.belt);
+ }
+
+ this.bipedRightArm.cubeList.clear();
+ if(addChestPiece)
+ {
+ this.bipedRightArm.addChild(rightArmMain);
+ this.bipedRightArm.addChild(this.rightKnucklePlate);
+ this.bipedRightArm.addChild(this.rightKnuckleBrace);
+ this.bipedRightArm.addChild(this.rightKnuckle1);
+ this.bipedRightArm.addChild(this.rightKnuckle2);
+ this.bipedRightArm.addChild(this.rightKnuckle3);
+ this.bipedRightArm.addChild(this.rightKnuckle4);
+ this.bipedRightArm.addChild(this.rightKnuckle5);
+ this.bipedRightArm.addChild(this.rightKnuckle6);
+ this.bipedRightArm.addChild(this.rightArmMain);
+ this.bipedRightArm.addChild(this.rightShoulder1);
+ this.bipedRightArm.addChild(this.rightShoulder2);
+ this.bipedRightArm.addChild(this.rightShoulder3);
+ }
+
+ this.bipedLeftArm.cubeList.clear();
+ if(addChestPiece)
+ {
+ this.bipedLeftArm.addChild(leftArmMain);
+ this.bipedLeftArm.addChild(this.leftKnucklePlate);
+ this.bipedLeftArm.addChild(this.leftKnuckleBrace);
+ this.bipedLeftArm.addChild(this.leftKnuckle1);
+ this.bipedLeftArm.addChild(this.leftKnuckle2);
+ this.bipedLeftArm.addChild(this.leftKnuckle3);
+ this.bipedLeftArm.addChild(this.leftKnuckle4);
+ this.bipedLeftArm.addChild(this.leftKnuckle5);
+ this.bipedLeftArm.addChild(this.leftKnuckle6);
+ this.bipedLeftArm.addChild(this.leftArmMain);
+ this.bipedLeftArm.addChild(this.leftShoulder1);
+ this.bipedLeftArm.addChild(this.leftShoulder2);
+ this.bipedLeftArm.addChild(this.leftShoulder3);
+ }
+
+ this.bipedLeftLeg.cubeList.clear();
+ if(addBoots)
+ {
+ this.bipedLeftLeg.addChild(this.leftBootBottom);
+ this.bipedLeftLeg.addChild(this.leftBootBrace);
+ this.bipedLeftLeg.addChild(this.leftBootPlate);
+ this.bipedLeftLeg.addChild(this.leftBootWing1);
+ this.bipedLeftLeg.addChild(this.leftBootWing2);
+ }
+ if(addLeggings)
+ {
+ this.bipedLeftLeg.addChild(this.leftLegMain);
+ this.bipedLeftLeg.addChild(this.leftLegSidePlate);
+ this.bipedLeftLeg.addChild(this.leftLegPlate1);
+ this.bipedLeftLeg.addChild(this.leftLegPlate2);
+ this.bipedLeftLeg.addChild(this.leftLegPlate3);
+ this.bipedLeftLeg.addChild(this.leftLegPlate4);
+ }
+
+ this.bipedRightLeg.cubeList.clear();
+ if(addBoots)
+ {
+ this.bipedRightLeg.addChild(this.rightBootBottom);
+ this.bipedRightLeg.addChild(this.rightBootBrace);
+ this.bipedRightLeg.addChild(this.rightBootPlate);
+ this.bipedRightLeg.addChild(this.rightBootWing1);
+ this.bipedRightLeg.addChild(this.rightBootWing2);
+ }
+ if(addLeggings)
+ {
+ this.bipedRightLeg.addChild(this.rightLegMain);
+ this.bipedRightLeg.addChild(this.rightLegSidePlate);
+ this.bipedRightLeg.addChild(this.rightLegPlate1);
+ this.bipedRightLeg.addChild(this.rightLegPlate2);
+ this.bipedRightLeg.addChild(this.rightLegPlate3);
+ this.bipedRightLeg.addChild(this.rightLegPlate4);
+ }
+ }
+
+ public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
+ {
+// super.render(entity, f, f1, f2, f3, f4, f5);
+
+
+
+ setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+
+ this.bipedHead.render(f5);
+ this.bipedBody.render(f5);
+ this.bipedLeftArm.render(f5);
+ this.bipedRightArm.render(f5);
+ this.bipedLeftLeg.render(f5);
+ this.bipedRightLeg.render(f5);
+
+// head.render(f5);
+// body.render(f5);
+// rightarm.render(f5);
+// leftarm.render(f5);
+// rightleg.render(f5);
+// leftleg.render(f5);
+// rightArmMain.render(f5);
+// rightKnucklePlate.render(f5);
+// rightKnuckleBrace.render(f5);
+// rightKnuckle1.render(f5);
+// rightKnuckle2.render(f5);
+// rightKnuckle3.render(f5);
+// rightKnuckle4.render(f5);
+// rightKnuckle5.render(f5);
+// rightKnuckle6.render(f5);
+// rightShoulder1.render(f5);
+// rightShoulder2.render(f5);
+// rightShoulder3.render(f5);
+// mainPlate.render(f5);
+// chestPlate1.render(f5);
+// chestPlate2.render(f5);
+// chestPlate3.render(f5);
+// chestPlate4.render(f5);
+// chestPlate5.render(f5);
+// chestPlate6.render(f5);
+// belt.render(f5);
+// leftArmMain.render(f5);
+// leftKnucklePlate.render(f5);
+// leftKnuckleBrace.render(f5);
+// leftKnuckle1.render(f5);
+// leftKnuckle2.render(f5);
+// leftKnuckle3.render(f5);
+// leftKnuckle4.render(f5);
+// leftKnuckle5.render(f5);
+// leftKnuckle6.render(f5);
+// leftShoulder1.render(f5);
+// leftShoulder2.render(f5);
+// leftShoulder3.render(f5);
+// leftBootBottom.render(f5);
+// leftBootPlate.render(f5);
+// leftBootBrace.render(f5);
+// leftBootWing1.render(f5);
+// leftBootWing2.render(f5);
+// rightBootBottom.render(f5);
+// rightBootPlate.render(f5);
+// rightBootBrace.render(f5);
+// rightBootWing1.render(f5);
+// rightBootWing2.render(f5);
+//
+// {
+// leftLegSidePlate.render(f5);
+// leftLegMain.render(f5);
+// leftLegPlate1.render(f5);
+// leftLegPlate2.render(f5);
+// leftLegPlate3.render(f5);
+// leftLegPlate4.render(f5);
+// }
+//
+// {
+// rightLegSidePlate.render(f5);
+// rightLegMain.render(f5);
+// rightLegPlate1.render(f5);
+// rightLegPlate2.render(f5);
+// rightLegPlate3.render(f5);
+// rightLegPlate4.render(f5);
+// }
+ }
+
+ private void setRotation(ModelRenderer model, float x, float y, float z)
+ {
+ model.rotateAngleX = x;
+ model.rotateAngleY = y;
+ model.rotateAngleZ = z;
+ }
+
+ public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
+ {
+ super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelPedestal.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelPedestal.java
new file mode 100644
index 00000000..753df6a5
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelPedestal.java
@@ -0,0 +1,58 @@
+package WayofTime.alchemicalWizardry.common.renderer.model;
+
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.model.ModelRenderer;
+import net.minecraft.entity.Entity;
+
+public class ModelPedestal extends ModelBase
+{
+ //fields
+ ModelRenderer base;
+ ModelRenderer top;
+ ModelRenderer middle;
+
+ public ModelPedestal()
+ {
+ textureWidth = 64;
+ textureHeight = 32;
+ base = new ModelRenderer(this, 0, 0);
+ base.addBox(0F, 0F, 0F, 10, 1, 10);
+ base.setRotationPoint(-5F, 23F, -5F);
+ base.setTextureSize(64, 32);
+ base.mirror = true;
+ setRotation(base, 0F, 0F, 0F);
+ top = new ModelRenderer(this, 0, 19);
+ top.addBox(0F, 0F, 0F, 6, 1, 6);
+ top.setRotationPoint(-3F, 14F, -3F);
+ top.setTextureSize(64, 32);
+ top.mirror = true;
+ setRotation(top, 0F, 0F, 0F);
+ middle = new ModelRenderer(this, 50, 0);
+ middle.addBox(0F, 0F, 0F, 2, 8, 2);
+ middle.setRotationPoint(-1F, 15F, -1F);
+ middle.setTextureSize(64, 32);
+ middle.mirror = true;
+ setRotation(middle, 0F, 0F, 0F);
+ }
+
+ public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
+ {
+ super.render(entity, f, f1, f2, f3, f4, f5);
+ setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ base.render(f5);
+ top.render(f5);
+ middle.render(f5);
+ }
+
+ private void setRotation(ModelRenderer model, float x, float y, float z)
+ {
+ model.rotateAngleX = x;
+ model.rotateAngleY = y;
+ model.rotateAngleZ = z;
+ }
+
+ public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
+ {
+ super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelPlinth.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelPlinth.java
new file mode 100644
index 00000000..f4190b5d
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelPlinth.java
@@ -0,0 +1,90 @@
+package WayofTime.alchemicalWizardry.common.renderer.model;
+
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.model.ModelRenderer;
+import net.minecraft.entity.Entity;
+
+public class ModelPlinth extends ModelBase
+{
+ //fields
+ ModelRenderer base;
+ ModelRenderer table;
+ ModelRenderer pillar;
+ ModelRenderer edge1;
+ ModelRenderer edge2;
+ ModelRenderer edge3;
+ ModelRenderer edge4;
+
+ public ModelPlinth()
+ {
+ textureWidth = 64;
+ textureHeight = 64;
+ base = new ModelRenderer(this, 0, 16);
+ base.addBox(0F, 0F, 0F, 10, 2, 10);
+ base.setRotationPoint(-5F, 22F, -5F);
+ base.setTextureSize(64, 64);
+ base.mirror = true;
+ setRotation(base, 0F, 0F, 0F);
+ table = new ModelRenderer(this, 0, 0);
+ table.addBox(0F, 0F, 0F, 14, 1, 14);
+ table.setRotationPoint(-7F, 11F, -7F);
+ table.setTextureSize(64, 64);
+ table.mirror = true;
+ setRotation(table, 0F, 0F, 0F);
+ pillar = new ModelRenderer(this, 0, 32);
+ pillar.addBox(0F, 0F, 0F, 6, 10, 6);
+ pillar.setRotationPoint(-3F, 12F, -3F);
+ pillar.setTextureSize(64, 64);
+ pillar.mirror = true;
+ setRotation(pillar, 0F, 0F, 0F);
+ edge1 = new ModelRenderer(this, 0, 29);
+ edge1.addBox(0F, 0F, 0F, 14, 1, 1);
+ edge1.setRotationPoint(-7F, 10F, 6F);
+ edge1.setTextureSize(64, 64);
+ edge1.mirror = true;
+ setRotation(edge1, 0F, 0F, 0F);
+ edge2 = new ModelRenderer(this, 0, 29);
+ edge2.addBox(0F, 0F, 0F, 14, 1, 1);
+ edge2.setRotationPoint(-7F, 10F, -7F);
+ edge2.setTextureSize(64, 64);
+ edge2.mirror = true;
+ setRotation(edge2, 0F, 0F, 0F);
+ edge3 = new ModelRenderer(this, 25, 32);
+ edge3.addBox(0F, 0F, 0F, 1, 1, 12);
+ edge3.setRotationPoint(-7F, 10F, -6F);
+ edge3.setTextureSize(64, 64);
+ edge3.mirror = true;
+ setRotation(edge3, 0F, 0F, 0F);
+ edge4 = new ModelRenderer(this, 25, 32);
+ edge4.addBox(0F, 0F, 0F, 1, 1, 12);
+ edge4.setRotationPoint(6F, 10F, -6F);
+ edge4.setTextureSize(64, 64);
+ edge4.mirror = true;
+ setRotation(edge4, 0F, 0F, 0F);
+ }
+
+ public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
+ {
+ super.render(entity, f, f1, f2, f3, f4, f5);
+ setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ base.render(f5);
+ table.render(f5);
+ pillar.render(f5);
+ edge1.render(f5);
+ edge2.render(f5);
+ edge3.render(f5);
+ edge4.render(f5);
+ }
+
+ private void setRotation(ModelRenderer model, float x, float y, float z)
+ {
+ model.rotateAngleX = x;
+ model.rotateAngleY = y;
+ model.rotateAngleZ = z;
+ }
+
+ public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
+ {
+ super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelShade.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelShade.java
new file mode 100644
index 00000000..8a7f2632
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelShade.java
@@ -0,0 +1,86 @@
+package WayofTime.alchemicalWizardry.common.renderer.model;
+
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.model.ModelRenderer;
+import net.minecraft.entity.Entity;
+
+public class ModelShade extends ModelBase
+{
+ //fields
+ ModelRenderer body;
+ ModelRenderer tail1;
+ ModelRenderer leftArm;
+ ModelRenderer rightArm;
+ ModelRenderer tail2;
+ ModelRenderer head;
+
+ public ModelShade()
+ {
+ textureWidth = 64;
+ textureHeight = 64;
+ body = new ModelRenderer(this, 0, 45);
+ body.addBox(-6F, 0F, -3F, 12, 12, 6);
+ body.setRotationPoint(0F, -4F, 0F);
+ body.setTextureSize(64, 64);
+ body.mirror = true;
+ setRotation(body, 0F, 0F, 0F);
+ tail1 = new ModelRenderer(this, 37, 43);
+ tail1.addBox(-2F, 1F, -2F, 4, 6, 4);
+ tail1.setRotationPoint(0F, 8F, 0F);
+ tail1.setTextureSize(64, 64);
+ tail1.mirror = true;
+ setRotation(tail1, 0.122173F, 0F, 0F);
+ leftArm = new ModelRenderer(this, 0, 0);
+ leftArm.addBox(0F, -4F, -2F, 4, 20, 4);
+ leftArm.setRotationPoint(6F, -2F, 0F);
+ leftArm.setTextureSize(64, 64);
+ leftArm.mirror = true;
+ setRotation(leftArm, 0F, 0F, 0F);
+ rightArm = new ModelRenderer(this, 0, 0);
+ rightArm.mirror = true;
+ rightArm.addBox(-4F, -4F, -2F, 4, 20, 4);
+ rightArm.setRotationPoint(-6F, -2F, 0F);
+ rightArm.setTextureSize(64, 64);
+ rightArm.mirror = true;
+ setRotation(rightArm, 0F, 0F, 0F);
+ rightArm.mirror = false;
+ tail2 = new ModelRenderer(this, 37, 54);
+ tail2.addBox(-1.5F, 6F, -3F, 3, 6, 3);
+ tail2.setRotationPoint(0F, 8F, 0F);
+ tail2.setTextureSize(64, 64);
+ tail2.mirror = true;
+ setRotation(tail2, 0.4363323F, 0F, 0F);
+ head = new ModelRenderer(this, 17, 0);
+ head.addBox(-4F, -8F, -4F, 8, 8, 8);
+ head.setRotationPoint(0F, -4F, -1F);
+ head.setTextureSize(64, 64);
+ head.mirror = true;
+ setRotation(head, 0F, 0F, 0F);
+ }
+
+ public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
+ {
+ super.render(entity, f, f1, f2, f3, f4, f5);
+ setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ body.render(f5);
+ tail1.render(f5);
+ leftArm.render(f5);
+ rightArm.render(f5);
+ tail2.render(f5);
+ head.render(f5);
+ }
+
+ private void setRotation(ModelRenderer model, float x, float y, float z)
+ {
+ model.rotateAngleX = x;
+ model.rotateAngleY = y;
+ model.rotateAngleZ = z;
+ }
+
+ public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
+ {
+ super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ this.head.rotateAngleX = f4 / (180F / (float) Math.PI);
+ this.head.rotateAngleY = f3 / (180F / (float) Math.PI);
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelSmallEarthGolem.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelSmallEarthGolem.java
new file mode 100644
index 00000000..45a232de
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelSmallEarthGolem.java
@@ -0,0 +1,127 @@
+package WayofTime.alchemicalWizardry.common.renderer.model;
+
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.model.ModelRenderer;
+import net.minecraft.entity.Entity;
+import net.minecraft.util.MathHelper;
+
+public class ModelSmallEarthGolem extends ModelBase
+{
+ //fields
+ ModelRenderer leftLeg;
+ ModelRenderer rightLeg;
+ ModelRenderer body;
+ ModelRenderer head;
+ ModelRenderer chest1;
+ ModelRenderer chest2;
+ ModelRenderer chest3;
+ ModelRenderer leftArm;
+ ModelRenderer rightArm;
+ ModelRenderer back1;
+
+ public ModelSmallEarthGolem()
+ {
+ textureWidth = 32;
+ textureHeight = 32;
+ leftLeg = new ModelRenderer(this, 13, 0);
+ leftLeg.addBox(-1F, 0F, -1F, 2, 5, 2);
+ leftLeg.setRotationPoint(1F, 19F, 0F);
+ leftLeg.setTextureSize(32, 32);
+ leftLeg.mirror = true;
+ setRotation(leftLeg, 0F, 0F, 0F);
+ rightLeg = new ModelRenderer(this, 13, 0);
+ rightLeg.mirror = true;
+ rightLeg.addBox(-1F, 0F, -1F, 2, 5, 2);
+ rightLeg.setRotationPoint(-1F, 19F, 0F);
+ rightLeg.setTextureSize(32, 32);
+ rightLeg.mirror = true;
+ setRotation(rightLeg, 0F, 0F, 0F);
+ rightLeg.mirror = false;
+ body = new ModelRenderer(this, 0, 7);
+ body.addBox(-2F, 0F, -1F, 4, 5, 2);
+ body.setRotationPoint(0F, 14F, 0F);
+ body.setTextureSize(32, 32);
+ body.mirror = true;
+ setRotation(body, 0F, 0F, 0F);
+ head = new ModelRenderer(this, 0, 0);
+ head.addBox(-1.5F, -3F, -2F, 3, 3, 3);
+ head.setRotationPoint(0F, 14F, 0F);
+ head.setTextureSize(32, 32);
+ head.mirror = true;
+ setRotation(head, 0F, 0F, 0F);
+ chest1 = new ModelRenderer(this, 22, 0);
+ chest1.addBox(-1F, 0.5F, -2F, 2, 3, 1);
+ chest1.setRotationPoint(0F, 14F, 0F);
+ chest1.setTextureSize(32, 32);
+ chest1.mirror = true;
+ setRotation(chest1, 0F, 0F, 0F);
+ chest2 = new ModelRenderer(this, 22, 5);
+ chest2.addBox(1F, 1.5F, -2F, 1, 1, 1);
+ chest2.setRotationPoint(0F, 14F, 0F);
+ chest2.setTextureSize(32, 32);
+ chest2.mirror = true;
+ setRotation(chest2, 0F, 0F, 0F);
+ chest3 = new ModelRenderer(this, 22, 5);
+ chest3.mirror = true;
+ chest3.addBox(-2F, 1.5F, -2F, 1, 1, 1);
+ chest3.setRotationPoint(0F, 14F, 0F);
+ chest3.setTextureSize(32, 32);
+ chest3.mirror = true;
+ setRotation(chest3, 0F, 0F, 0F);
+ chest3.mirror = false;
+ leftArm = new ModelRenderer(this, 13, 7);
+ leftArm.addBox(0F, -1F, -1F, 2, 5, 2);
+ leftArm.setRotationPoint(2F, 15F, 0F);
+ leftArm.setTextureSize(32, 32);
+ leftArm.mirror = true;
+ setRotation(leftArm, 0F, 0F, 0F);
+ rightArm = new ModelRenderer(this, 13, 7);
+ rightArm.mirror = true;
+ rightArm.addBox(-2F, -1F, -1F, 2, 5, 2);
+ rightArm.setRotationPoint(-2F, 15F, 0F);
+ rightArm.setTextureSize(32, 32);
+ rightArm.mirror = true;
+ setRotation(rightArm, 0F, 0F, 0F);
+ rightArm.mirror = false;
+ back1 = new ModelRenderer(this, 22, 8);
+ back1.addBox(-1.5F, 1.5F, 1F, 3, 1, 1);
+ back1.setRotationPoint(0F, 14F, 0F);
+ back1.setTextureSize(32, 32);
+ back1.mirror = true;
+ setRotation(back1, 0F, 0F, 0F);
+ }
+
+ public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
+ {
+ super.render(entity, f, f1, f2, f3, f4, f5);
+ setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ leftLeg.render(f5);
+ rightLeg.render(f5);
+ body.render(f5);
+ head.render(f5);
+ chest1.render(f5);
+ chest2.render(f5);
+ chest3.render(f5);
+ leftArm.render(f5);
+ rightArm.render(f5);
+ back1.render(f5);
+ }
+
+ private void setRotation(ModelRenderer model, float x, float y, float z)
+ {
+ model.rotateAngleX = x;
+ model.rotateAngleY = y;
+ model.rotateAngleZ = z;
+ }
+
+ public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
+ {
+ super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ this.head.rotateAngleX = f4 / (180F / (float) Math.PI);
+ this.head.rotateAngleY = f3 / (180F / (float) Math.PI);
+ this.leftLeg.rotateAngleX = MathHelper.cos(f * 0.6662F) * 1.4F * f1;
+ this.rightLeg.rotateAngleX = MathHelper.cos(f * 0.6662F + (float) Math.PI) * 1.4F * f1;
+ this.rightArm.rotateAngleX = MathHelper.cos(f * 0.6662F + (float) Math.PI) * 1.4F * f1;
+ this.leftArm.rotateAngleX = MathHelper.cos(f * 0.6662F) * 1.4F * f1;
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelSpellEffectBlock.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelSpellEffectBlock.java
new file mode 100644
index 00000000..61110926
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelSpellEffectBlock.java
@@ -0,0 +1,332 @@
+package WayofTime.alchemicalWizardry.common.renderer.model;
+
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.model.ModelRenderer;
+import net.minecraft.entity.Entity;
+import net.minecraftforge.common.util.ForgeDirection;
+
+public class ModelSpellEffectBlock extends ModelBase
+{
+ //fields
+ ModelRenderer core;
+ ModelRenderer frame1;
+ ModelRenderer frame2;
+ ModelRenderer frame3;
+ ModelRenderer frame4;
+ ModelRenderer frame5;
+ ModelRenderer frame6;
+ ModelRenderer frame7;
+ ModelRenderer frame8;
+ ModelRenderer frame9;
+ ModelRenderer frame10;
+ ModelRenderer frame11;
+ ModelRenderer frame12;
+ ModelRenderer inputSpacer1;
+ ModelRenderer inputFace;
+ ModelRenderer inputSpacer2;
+ ModelRenderer inputSpacer3;
+ ModelRenderer inputSpacer4;
+ ModelRenderer outputFace;
+ ModelRenderer outputPlug;
+ ModelRenderer outputSpacer1;
+ ModelRenderer outputSpacer2;
+ ModelRenderer outputSpacer3;
+ ModelRenderer outputSpacer4;
+
+ public ModelSpellEffectBlock()
+ {
+ textureWidth = 64;
+ textureHeight = 64;
+
+ core = new ModelRenderer(this, 0, 0);
+ core.addBox(-3F, -3F, -3F, 6, 6, 6);
+ core.setRotationPoint(0F, 16F, 0F);
+ core.setTextureSize(64, 64);
+ core.mirror = true;
+ setRotation(core, 0F, 0F, 0F);
+ frame1 = new ModelRenderer(this, 16, 18);
+ frame1.addBox(3F, -3F, -5F, 2, 6, 2);
+ frame1.setRotationPoint(0F, 16F, 0F);
+ frame1.setTextureSize(64, 64);
+ frame1.mirror = true;
+ setRotation(frame1, 0F, 0F, 0F);
+ frame2 = new ModelRenderer(this, 0, 18);
+ frame2.addBox(-5F, -3F, -5F, 2, 6, 2);
+ frame2.setRotationPoint(0F, 16F, 0F);
+ frame2.setTextureSize(64, 64);
+ frame2.mirror = true;
+ setRotation(frame2, 0F, 0F, 0F);
+ frame3 = new ModelRenderer(this, 0, 13);
+ frame3.addBox(-5F, -5F, -5F, 10, 2, 2);
+ frame3.setRotationPoint(0F, 16F, 0F);
+ frame3.setTextureSize(64, 64);
+ frame3.mirror = true;
+ setRotation(frame3, 0F, 0F, 0F);
+ frame4 = new ModelRenderer(this, 0, 27);
+ frame4.addBox(-5F, 3F, -5F, 10, 2, 2);
+ frame4.setRotationPoint(0F, 16F, 0F);
+ frame4.setTextureSize(64, 64);
+ frame4.mirror = true;
+ setRotation(frame4, 0F, 0F, 0F);
+ frame5 = new ModelRenderer(this, 0, 34);
+ frame5.addBox(-5F, -5F, 3F, 10, 2, 2);
+ frame5.setRotationPoint(0F, 16F, 0F);
+ frame5.setTextureSize(64, 64);
+ frame5.mirror = true;
+ setRotation(frame5, 0F, 0F, 0F);
+ frame6 = new ModelRenderer(this, 0, 48);
+ frame6.addBox(-5F, 3F, 3F, 10, 2, 2);
+ frame6.setRotationPoint(0F, 16F, 0F);
+ frame6.setTextureSize(64, 64);
+ frame6.mirror = true;
+ setRotation(frame6, 0F, 0F, 0F);
+ frame7 = new ModelRenderer(this, 16, 39);
+ frame7.addBox(-5F, -3F, 3F, 2, 6, 2);
+ frame7.setRotationPoint(0F, 16F, 0F);
+ frame7.setTextureSize(64, 64);
+ frame7.mirror = true;
+ setRotation(frame7, 0F, 0F, 0F);
+ frame8 = new ModelRenderer(this, 0, 39);
+ frame8.addBox(3F, -3F, 3F, 2, 6, 2);
+ frame8.setRotationPoint(0F, 16F, 0F);
+ frame8.setTextureSize(64, 64);
+ frame8.mirror = true;
+ setRotation(frame8, 0F, 0F, 0F);
+ frame9 = new ModelRenderer(this, 25, 9);
+ frame9.addBox(-5F, 3F, -3F, 2, 2, 6);
+ frame9.setRotationPoint(0F, 16F, 0F);
+ frame9.setTextureSize(64, 64);
+ frame9.mirror = true;
+ setRotation(frame9, 0F, 0F, 0F);
+ frame10 = new ModelRenderer(this, 25, 0);
+ frame10.addBox(-5F, -5F, -3F, 2, 2, 6);
+ frame10.setRotationPoint(0F, 16F, 0F);
+ frame10.setTextureSize(64, 64);
+ frame10.mirror = true;
+ setRotation(frame10, 0F, 0F, 0F);
+ frame11 = new ModelRenderer(this, 42, 0);
+ frame11.addBox(3F, -5F, -3F, 2, 2, 6);
+ frame11.setRotationPoint(0F, 16F, 0F);
+ frame11.setTextureSize(64, 64);
+ frame11.mirror = true;
+ setRotation(frame11, 0F, 0F, 0F);
+ frame12 = new ModelRenderer(this, 42, 9);
+ frame12.addBox(3F, 3F, -3F, 2, 2, 6);
+ frame12.setRotationPoint(0F, 16F, 0F);
+ frame12.setTextureSize(64, 64);
+ frame12.mirror = true;
+ setRotation(frame12, 0F, 0F, 0F);
+ inputSpacer1 = new ModelRenderer(this, 25, 27);
+ inputSpacer1.addBox(3F, -5F, -8F, 2, 2, 3);
+ inputSpacer1.setRotationPoint(0F, 16F, 0F);
+ inputSpacer1.setTextureSize(64, 64);
+ inputSpacer1.mirror = true;
+ setRotation(inputSpacer1, 0F, 0F, 0F);
+ inputFace = new ModelRenderer(this, 38, 27);
+ inputFace.addBox(-2F, -2F, -8F, 4, 4, 5);
+ inputFace.setRotationPoint(0F, 16F, 0F);
+ inputFace.setTextureSize(64, 64);
+ inputFace.mirror = true;
+ setRotation(inputFace, 0F, 0F, 0F);
+ inputSpacer2 = new ModelRenderer(this, 25, 27);
+ inputSpacer2.addBox(-5F, -5F, -8F, 2, 2, 3);
+ inputSpacer2.setRotationPoint(0F, 16F, 0F);
+ inputSpacer2.setTextureSize(64, 64);
+ inputSpacer2.mirror = true;
+ setRotation(inputSpacer2, 0F, 0F, 0F);
+ inputSpacer3 = new ModelRenderer(this, 25, 27);
+ inputSpacer3.addBox(3F, 3F, -8F, 2, 2, 3);
+ inputSpacer3.setRotationPoint(0F, 16F, 0F);
+ inputSpacer3.setTextureSize(64, 64);
+ inputSpacer3.mirror = true;
+ setRotation(inputSpacer3, 0F, 0F, 0F);
+ inputSpacer4 = new ModelRenderer(this, 25, 27);
+ inputSpacer4.addBox(-5F, 3F, -8F, 2, 2, 3);
+ inputSpacer4.setRotationPoint(0F, 16F, 0F);
+ inputSpacer4.setTextureSize(64, 64);
+ inputSpacer4.mirror = true;
+ setRotation(inputSpacer4, 0F, 0F, 0F);
+ outputFace = new ModelRenderer(this, 38, 37);
+ outputFace.addBox(6F, -2F, -2F, 2, 4, 4);
+ outputFace.setRotationPoint(0F, 16F, 0F);
+ outputFace.setTextureSize(64, 64);
+ outputFace.mirror = true;
+ setRotation(outputFace, 0F, 0F, 0F);
+ outputPlug = new ModelRenderer(this, 36, 48);
+ outputPlug.addBox(3F, -3F, -3F, 2, 6, 6);
+ outputPlug.setRotationPoint(0F, 16F, 0F);
+ outputPlug.setTextureSize(64, 64);
+ outputPlug.mirror = true;
+ setRotation(outputPlug, 0F, 0F, 0F);
+ outputSpacer1 = new ModelRenderer(this, 25, 48);
+ outputSpacer1.addBox(5F, -5F, -5F, 3, 2, 2);
+ outputSpacer1.setRotationPoint(0F, 16F, 0F);
+ outputSpacer1.setTextureSize(64, 64);
+ outputSpacer1.mirror = true;
+ setRotation(outputSpacer1, 0F, 0F, 0F);
+ outputSpacer2 = new ModelRenderer(this, 25, 48);
+ outputSpacer2.addBox(5F, -5F, 3F, 3, 2, 2);
+ outputSpacer2.setRotationPoint(0F, 16F, 0F);
+ outputSpacer2.setTextureSize(64, 64);
+ outputSpacer2.mirror = true;
+ setRotation(outputSpacer2, 0F, 0F, 0F);
+ outputSpacer3 = new ModelRenderer(this, 25, 48);
+ outputSpacer3.addBox(5F, 3F, -5F, 3, 2, 2);
+ outputSpacer3.setRotationPoint(0F, 16F, 0F);
+ outputSpacer3.setTextureSize(64, 64);
+ outputSpacer3.mirror = true;
+ setRotation(outputSpacer3, 0F, 0F, 0F);
+ outputSpacer4 = new ModelRenderer(this, 25, 48);
+ outputSpacer4.addBox(5F, 3F, 3F, 3, 2, 2);
+ outputSpacer4.setRotationPoint(0F, 16F, 0F);
+ outputSpacer4.setTextureSize(64, 64);
+ outputSpacer4.mirror = true;
+ setRotation(outputSpacer4, 0F, 0F, 0F);
+ }
+
+ public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5, ForgeDirection input, ForgeDirection output)
+ {
+ super.render(entity, f, f1, f2, f3, f4, f5);
+ setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ float xInputRot = 0.0f;
+ float yInputRot = 0.0f;
+ float zInputRot = 0.0f;
+ float xOutputRot = 0.0f;
+ float yOutputRot = 0.0f;
+ float zOutputRot = 0.0f;
+
+ switch (input)
+ {
+ case NORTH:
+ xInputRot = 0.0f;
+ yInputRot = 0.0f;
+ zInputRot = 0.0f;
+ break;
+
+ case EAST:
+ xInputRot = 0.0f;
+ yInputRot = (float) (0.5f * Math.PI);
+ zInputRot = 0.0f;
+ break;
+
+ case SOUTH:
+ xInputRot = 0.0f;
+ yInputRot = (float) (1.0f * Math.PI);
+ zInputRot = 0.0f;
+ break;
+
+ case WEST:
+ xInputRot = 0.0f;
+ yInputRot = (float) (-0.5f * Math.PI);
+ zInputRot = 0.0f;
+ break;
+
+ case UP:
+ xInputRot = (float) (-0.5f * Math.PI);
+ yInputRot = 0.0f;
+ zInputRot = 0.0f;
+ break;
+
+ case DOWN:
+ xInputRot = (float) (0.5f * Math.PI);
+ yInputRot = 0.0f;
+ zInputRot = 0.0f;
+ break;
+
+ default:
+ break;
+ }
+
+ switch (output)
+ {
+ case NORTH:
+ xOutputRot = 0.0f;
+ yOutputRot = (float) (0.5f * Math.PI);
+ zOutputRot = 0.0f;
+ break;
+
+ case EAST:
+ xOutputRot = 0.0f;
+ yOutputRot = (float) (1.0f * Math.PI);
+ zOutputRot = 0.0f;
+ break;
+
+ case SOUTH:
+ xOutputRot = 0.0f;
+ yOutputRot = (float) (-0.5f * Math.PI);
+ zOutputRot = 0.0f;
+ break;
+
+ case WEST:
+ xOutputRot = 0.0f;
+ yOutputRot = 0.0f;
+ zOutputRot = 0.0f;
+ break;
+
+ case UP:
+ xOutputRot = 0.0f;
+ yOutputRot = 0.0f;
+ zOutputRot = (float) (-0.5f * Math.PI);
+ break;
+
+ case DOWN:
+ xOutputRot = 0.0f;
+ yOutputRot = 0.0f;
+ zOutputRot = (float) (0.5f * Math.PI);
+ break;
+
+ default:
+ break;
+ }
+
+ this.setRotation(inputFace, xInputRot, yInputRot, zInputRot);
+ this.setRotation(outputFace, xOutputRot, yOutputRot, zOutputRot);
+ this.setRotation(inputSpacer1, xInputRot, yInputRot, zInputRot);
+ this.setRotation(inputSpacer2, xInputRot, yInputRot, zInputRot);
+ this.setRotation(inputSpacer3, xInputRot, yInputRot, zInputRot);
+ this.setRotation(inputSpacer4, xInputRot, yInputRot, zInputRot);
+ this.setRotation(outputPlug, xOutputRot, yOutputRot, zOutputRot);
+ this.setRotation(outputSpacer1, xOutputRot, yOutputRot, zOutputRot);
+ this.setRotation(outputSpacer2, xOutputRot, yOutputRot, zOutputRot);
+ this.setRotation(outputSpacer3, xOutputRot, yOutputRot, zOutputRot);
+ this.setRotation(outputSpacer4, xOutputRot, yOutputRot, zOutputRot);
+
+ core.render(f5);
+ frame1.render(f5);
+ frame2.render(f5);
+ frame3.render(f5);
+ frame4.render(f5);
+ frame5.render(f5);
+ frame6.render(f5);
+ frame7.render(f5);
+ frame8.render(f5);
+ frame9.render(f5);
+ frame10.render(f5);
+ frame11.render(f5);
+ frame12.render(f5);
+ inputSpacer1.render(f5);
+ inputFace.render(f5);
+ inputSpacer2.render(f5);
+ inputSpacer3.render(f5);
+ inputSpacer4.render(f5);
+ outputFace.render(f5);
+ outputPlug.render(f5);
+ outputSpacer1.render(f5);
+ outputSpacer2.render(f5);
+ outputSpacer3.render(f5);
+ outputSpacer4.render(f5);
+ }
+
+ private void setRotation(ModelRenderer model, float x, float y, float z)
+ {
+ model.rotateAngleX = x;
+ model.rotateAngleY = y;
+ model.rotateAngleZ = z;
+ }
+
+ public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
+ {
+ super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ }
+
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelSpellEnhancementBlock.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelSpellEnhancementBlock.java
new file mode 100644
index 00000000..f56dca24
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelSpellEnhancementBlock.java
@@ -0,0 +1,334 @@
+package WayofTime.alchemicalWizardry.common.renderer.model;
+
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.model.ModelRenderer;
+import net.minecraft.entity.Entity;
+import net.minecraftforge.common.util.ForgeDirection;
+
+
+public class ModelSpellEnhancementBlock extends ModelBase
+{
+ //fields
+ ModelRenderer core;
+ ModelRenderer frame1;
+ ModelRenderer frame2;
+ ModelRenderer frame3;
+ ModelRenderer frame4;
+ ModelRenderer frame5;
+ ModelRenderer frame6;
+ ModelRenderer frame7;
+ ModelRenderer frame8;
+ ModelRenderer frame9;
+ ModelRenderer frame10;
+ ModelRenderer frame11;
+ ModelRenderer frame12;
+ ModelRenderer outputMain;
+ ModelRenderer inputMain;
+ ModelRenderer output1;
+ ModelRenderer output2;
+ ModelRenderer output3;
+ ModelRenderer output4;
+ ModelRenderer input1;
+ ModelRenderer input2;
+ ModelRenderer input3;
+ ModelRenderer input4;
+ ModelRenderer outputSecond;
+
+ public ModelSpellEnhancementBlock()
+ {
+ textureWidth = 128;
+ textureHeight = 64;
+
+ core = new ModelRenderer(this, 0, 0);
+ core.addBox(-3F, -3F, -3F, 6, 6, 6);
+ core.setRotationPoint(0F, 16F, 0F);
+ core.setTextureSize(128, 64);
+ core.mirror = true;
+ setRotation(core, 0F, 0F, 0F);
+ frame1 = new ModelRenderer(this, 0, 32);
+ frame1.addBox(-7F, 5F, -7F, 14, 2, 2);
+ frame1.setRotationPoint(0F, 16F, 0F);
+ frame1.setTextureSize(128, 64);
+ frame1.mirror = true;
+ setRotation(frame1, 0F, 0F, 0F);
+ frame2 = new ModelRenderer(this, 24, 19);
+ frame2.addBox(5F, -5F, -7F, 2, 10, 2);
+ frame2.setRotationPoint(0F, 16F, 0F);
+ frame2.setTextureSize(128, 64);
+ frame2.mirror = true;
+ setRotation(frame2, 0F, 0F, 0F);
+ frame3 = new ModelRenderer(this, 0, 19);
+ frame3.addBox(-7F, -5F, -7F, 2, 10, 2);
+ frame3.setRotationPoint(0F, 16F, 0F);
+ frame3.setTextureSize(128, 64);
+ frame3.mirror = true;
+ setRotation(frame3, 0F, 0F, 0F);
+ frame4 = new ModelRenderer(this, 0, 14);
+ frame4.addBox(-7F, -7F, -7F, 14, 2, 2);
+ frame4.setRotationPoint(0F, 16F, 0F);
+ frame4.setTextureSize(128, 64);
+ frame4.mirror = true;
+ setRotation(frame4, 0F, 0F, 0F);
+ frame5 = new ModelRenderer(this, 0, 57);
+ frame5.addBox(-7F, 5F, 5F, 14, 2, 2);
+ frame5.setRotationPoint(0F, 16F, 0F);
+ frame5.setTextureSize(128, 64);
+ frame5.mirror = true;
+ setRotation(frame5, 0F, 0F, 0F);
+ frame6 = new ModelRenderer(this, 0, 44);
+ frame6.addBox(5F, -5F, 5F, 2, 10, 2);
+ frame6.setRotationPoint(0F, 16F, 0F);
+ frame6.setTextureSize(128, 64);
+ frame6.mirror = true;
+ setRotation(frame6, 0F, 0F, 0F);
+ frame7 = new ModelRenderer(this, 24, 44);
+ frame7.addBox(-7F, -5F, 5F, 2, 10, 2);
+ frame7.setRotationPoint(0F, 16F, 0F);
+ frame7.setTextureSize(128, 64);
+ frame7.mirror = true;
+ setRotation(frame7, 0F, 0F, 0F);
+ frame8 = new ModelRenderer(this, 0, 39);
+ frame8.addBox(-7F, -7F, 5F, 14, 2, 2);
+ frame8.setRotationPoint(0F, 16F, 0F);
+ frame8.setTextureSize(128, 64);
+ frame8.mirror = true;
+ setRotation(frame8, 0F, 0F, 0F);
+ frame9 = new ModelRenderer(this, 66, 14);
+ frame9.addBox(5F, 5F, -5F, 2, 2, 10);
+ frame9.setRotationPoint(0F, 16F, 0F);
+ frame9.setTextureSize(128, 64);
+ frame9.mirror = true;
+ setRotation(frame9, 0F, 0F, 0F);
+ frame10 = new ModelRenderer(this, 40, 14);
+ frame10.addBox(-7F, 5F, -5F, 2, 2, 10);
+ frame10.setRotationPoint(0F, 16F, 0F);
+ frame10.setTextureSize(128, 64);
+ frame10.mirror = true;
+ setRotation(frame10, 0F, 0F, 0F);
+ frame11 = new ModelRenderer(this, 66, 0);
+ frame11.addBox(5F, -7F, -5F, 2, 2, 10);
+ frame11.setRotationPoint(0F, 16F, 0F);
+ frame11.setTextureSize(128, 64);
+ frame11.mirror = true;
+ setRotation(frame11, 0F, 0F, 0F);
+ frame12 = new ModelRenderer(this, 40, 0);
+ frame12.addBox(-7F, -7F, -5F, 2, 2, 10);
+ frame12.setRotationPoint(0F, 16F, 0F);
+ frame12.setTextureSize(128, 64);
+ frame12.mirror = true;
+ setRotation(frame12, 0F, 0F, 0F);
+ outputMain = new ModelRenderer(this, 78, 36);
+ outputMain.addBox(6F, -2F, -2F, 2, 4, 4);
+ outputMain.setRotationPoint(0F, 16F, 0F);
+ outputMain.setTextureSize(128, 64);
+ outputMain.mirror = true;
+ setRotation(outputMain, 0F, 0F, 0F);
+ inputMain = new ModelRenderer(this, 40, 36);
+ inputMain.addBox(-2F, -2F, -8F, 4, 4, 5);
+ inputMain.setRotationPoint(0F, 16F, 0F);
+ inputMain.setTextureSize(128, 64);
+ inputMain.mirror = true;
+ setRotation(inputMain, 0F, 0F, 0F);
+ output1 = new ModelRenderer(this, 80, 30);
+ output1.addBox(5F, -5F, -5F, 3, 2, 2);
+ output1.setRotationPoint(0F, 16F, 0F);
+ output1.setTextureSize(128, 64);
+ output1.mirror = true;
+ setRotation(output1, 0F, 0F, 0F);
+ output2 = new ModelRenderer(this, 80, 30);
+ output2.addBox(5F, -5F, 3F, 3, 2, 2);
+ output2.setRotationPoint(0F, 16F, 0F);
+ output2.setTextureSize(128, 64);
+ output2.mirror = true;
+ setRotation(output2, 0F, 0F, 0F);
+ output3 = new ModelRenderer(this, 80, 30);
+ output3.addBox(5F, 3F, -5F, 3, 2, 2);
+ output3.setRotationPoint(0F, 16F, 0F);
+ output3.setTextureSize(128, 64);
+ output3.mirror = true;
+ setRotation(output3, 0F, 0F, 0F);
+ output4 = new ModelRenderer(this, 80, 30);
+ output4.addBox(5F, 3F, 3F, 3, 2, 2);
+ output4.setRotationPoint(0F, 16F, 0F);
+ output4.setTextureSize(128, 64);
+ output4.mirror = true;
+ setRotation(output4, 0F, 0F, 0F);
+ input1 = new ModelRenderer(this, 40, 27);
+ input1.addBox(3F, -5F, -8F, 2, 2, 5);
+ input1.setRotationPoint(0F, 16F, 0F);
+ input1.setTextureSize(128, 64);
+ input1.mirror = true;
+ setRotation(input1, 0F, 0F, 0F);
+ input2 = new ModelRenderer(this, 40, 27);
+ input2.addBox(-5F, -5F, -8F, 2, 2, 5);
+ input2.setRotationPoint(0F, 16F, 0F);
+ input2.setTextureSize(128, 64);
+ input2.mirror = true;
+ setRotation(input2, 0F, 0F, 0F);
+ input3 = new ModelRenderer(this, 40, 27);
+ input3.addBox(3F, 3F, -8F, 2, 2, 5);
+ input3.setRotationPoint(0F, 16F, 0F);
+ input3.setTextureSize(128, 64);
+ input3.mirror = true;
+ setRotation(input3, 0F, 0F, 0F);
+ input4 = new ModelRenderer(this, 40, 27);
+ input4.addBox(-5F, 3F, -8F, 2, 2, 5);
+ input4.setRotationPoint(0F, 16F, 0F);
+ input4.setTextureSize(128, 64);
+ input4.mirror = true;
+ setRotation(input4, 0F, 0F, 0F);
+ outputSecond = new ModelRenderer(this, 78, 47);
+ outputSecond.addBox(4F, -3F, -3F, 1, 6, 6);
+ outputSecond.setRotationPoint(0F, 16F, 0F);
+ outputSecond.setTextureSize(128, 64);
+ outputSecond.mirror = true;
+ setRotation(outputSecond, 0F, 0F, 0F);
+ }
+
+ public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5, ForgeDirection input, ForgeDirection output)
+ {
+ super.render(entity, f, f1, f2, f3, f4, f5);
+ setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+
+ float xInputRot = 0.0f;
+ float yInputRot = 0.0f;
+ float zInputRot = 0.0f;
+ float xOutputRot = 0.0f;
+ float yOutputRot = 0.0f;
+ float zOutputRot = 0.0f;
+
+ switch (input)
+ {
+ case NORTH:
+ xInputRot = 0.0f;
+ yInputRot = 0.0f;
+ zInputRot = 0.0f;
+ break;
+
+ case EAST:
+ xInputRot = 0.0f;
+ yInputRot = (float) (0.5f * Math.PI);
+ zInputRot = 0.0f;
+ break;
+
+ case SOUTH:
+ xInputRot = 0.0f;
+ yInputRot = (float) (1.0f * Math.PI);
+ zInputRot = 0.0f;
+ break;
+
+ case WEST:
+ xInputRot = 0.0f;
+ yInputRot = (float) (-0.5f * Math.PI);
+ zInputRot = 0.0f;
+ break;
+
+ case UP:
+ xInputRot = (float) (-0.5f * Math.PI);
+ yInputRot = 0.0f;
+ zInputRot = 0.0f;
+ break;
+
+ case DOWN:
+ xInputRot = (float) (0.5f * Math.PI);
+ yInputRot = 0.0f;
+ zInputRot = 0.0f;
+ break;
+
+ default:
+ break;
+ }
+
+ switch (output)
+ {
+ case NORTH:
+ xOutputRot = 0.0f;
+ yOutputRot = (float) (0.5f * Math.PI);
+ zOutputRot = 0.0f;
+ break;
+
+ case EAST:
+ xOutputRot = 0.0f;
+ yOutputRot = (float) (1.0f * Math.PI);
+ zOutputRot = 0.0f;
+ break;
+
+ case SOUTH:
+ xOutputRot = 0.0f;
+ yOutputRot = (float) (-0.5f * Math.PI);
+ zOutputRot = 0.0f;
+ break;
+
+ case WEST:
+ xOutputRot = 0.0f;
+ yOutputRot = 0.0f;
+ zOutputRot = 0.0f;
+ break;
+
+ case UP:
+ xOutputRot = 0.0f;
+ yOutputRot = 0.0f;
+ zOutputRot = (float) (-0.5f * Math.PI);
+ break;
+
+ case DOWN:
+ xOutputRot = 0.0f;
+ yOutputRot = 0.0f;
+ zOutputRot = (float) (0.5f * Math.PI);
+ break;
+
+ default:
+ break;
+ }
+
+ this.setRotation(inputMain, xInputRot, yInputRot, zInputRot);
+ this.setRotation(outputMain, xOutputRot, yOutputRot, zOutputRot);
+ this.setRotation(input1, xInputRot, yInputRot, zInputRot);
+ this.setRotation(input2, xInputRot, yInputRot, zInputRot);
+ this.setRotation(input3, xInputRot, yInputRot, zInputRot);
+ this.setRotation(input4, xInputRot, yInputRot, zInputRot);
+ this.setRotation(outputSecond, xOutputRot, yOutputRot, zOutputRot);
+ this.setRotation(output1, xOutputRot, yOutputRot, zOutputRot);
+ this.setRotation(output2, xOutputRot, yOutputRot, zOutputRot);
+ this.setRotation(output3, xOutputRot, yOutputRot, zOutputRot);
+ this.setRotation(output4, xOutputRot, yOutputRot, zOutputRot);
+
+ core.render(f5);
+ frame1.render(f5);
+ frame2.render(f5);
+ frame3.render(f5);
+ frame4.render(f5);
+ frame5.render(f5);
+ frame6.render(f5);
+ frame7.render(f5);
+ frame8.render(f5);
+ frame9.render(f5);
+ frame10.render(f5);
+ frame11.render(f5);
+ frame12.render(f5);
+ outputMain.render(f5);
+ inputMain.render(f5);
+ output1.render(f5);
+ output2.render(f5);
+ output3.render(f5);
+ output4.render(f5);
+ input1.render(f5);
+ input2.render(f5);
+ input3.render(f5);
+ input4.render(f5);
+ outputSecond.render(f5);
+ }
+
+ private void setRotation(ModelRenderer model, float x, float y, float z)
+ {
+ model.rotateAngleX = x;
+ model.rotateAngleY = y;
+ model.rotateAngleZ = z;
+ }
+
+ public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
+ {
+ super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ }
+
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelSpellModifierBlock.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelSpellModifierBlock.java
new file mode 100644
index 00000000..3ceed7e9
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelSpellModifierBlock.java
@@ -0,0 +1,303 @@
+package WayofTime.alchemicalWizardry.common.renderer.model;
+
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.model.ModelRenderer;
+import net.minecraft.entity.Entity;
+import net.minecraftforge.common.util.ForgeDirection;
+
+public class ModelSpellModifierBlock extends ModelBase
+{
+ //fields
+ ModelRenderer core;
+ ModelRenderer inputMain;
+ ModelRenderer Shape2;
+ ModelRenderer Shape3;
+ ModelRenderer Shape4;
+ ModelRenderer Shape5;
+ ModelRenderer Shape6;
+ ModelRenderer Shape7;
+ ModelRenderer Shape8;
+ ModelRenderer Shape9;
+ ModelRenderer outputMain;
+ ModelRenderer Shape11;
+ ModelRenderer Shape12;
+ ModelRenderer Shape13;
+ ModelRenderer Shape14;
+ ModelRenderer output1;
+ ModelRenderer output2;
+ ModelRenderer output3;
+ ModelRenderer output4;
+
+ public ModelSpellModifierBlock()
+ {
+ textureWidth = 64;
+ textureHeight = 64;
+
+ core = new ModelRenderer(this, 0, 0);
+ core.addBox(-3F, -3F, -3F, 6, 6, 6);
+ core.setRotationPoint(0F, 16F, 0F);
+ core.setTextureSize(64, 64);
+ core.mirror = true;
+ setRotation(core, 0F, 0F, 0F);
+ inputMain = new ModelRenderer(this, 25, 18);
+ inputMain.addBox(-2F, -2F, -8F, 4, 4, 1);
+ inputMain.setRotationPoint(0F, 16F, 0F);
+ inputMain.setTextureSize(64, 64);
+ inputMain.mirror = true;
+ setRotation(inputMain, 0F, 0F, 0F);
+ Shape2 = new ModelRenderer(this, 0, 13);
+ Shape2.addBox(-5F, -5F, -8F, 10, 2, 2);
+ Shape2.setRotationPoint(0F, 16F, 0F);
+ Shape2.setTextureSize(64, 64);
+ Shape2.mirror = true;
+ setRotation(Shape2, 0F, 0F, 0F);
+ Shape3 = new ModelRenderer(this, 0, 27);
+ Shape3.addBox(-5F, 3F, -8F, 10, 2, 2);
+ Shape3.setRotationPoint(0F, 16F, 0F);
+ Shape3.setTextureSize(64, 64);
+ Shape3.mirror = true;
+ setRotation(Shape3, 0F, 0F, 0F);
+ Shape4 = new ModelRenderer(this, 16, 18);
+ Shape4.addBox(3F, -3F, -8F, 2, 6, 2);
+ Shape4.setRotationPoint(0F, 16F, 0F);
+ Shape4.setTextureSize(64, 64);
+ Shape4.mirror = true;
+ setRotation(Shape4, 0F, 0F, 0F);
+ Shape5 = new ModelRenderer(this, 0, 18);
+ Shape5.addBox(-5F, -3F, -8F, 2, 6, 2);
+ Shape5.setRotationPoint(0F, 16F, 0F);
+ Shape5.setTextureSize(64, 64);
+ Shape5.mirror = true;
+ setRotation(Shape5, 0F, 0F, 0F);
+ Shape6 = new ModelRenderer(this, 0, 32);
+ Shape6.addBox(-1F, -6F, -7F, 2, 1, 5);
+ Shape6.setRotationPoint(0F, 16F, 0F);
+ Shape6.setTextureSize(64, 64);
+ Shape6.mirror = true;
+ setRotation(Shape6, 0F, 0F, 0F);
+ Shape7 = new ModelRenderer(this, 15, 32);
+ Shape7.addBox(-2F, -6F, -2F, 4, 1, 4);
+ Shape7.setRotationPoint(0F, 16F, 0F);
+ Shape7.setTextureSize(64, 64);
+ Shape7.mirror = true;
+ setRotation(Shape7, 0F, 0F, 0F);
+ Shape8 = new ModelRenderer(this, 15, 39);
+ Shape8.addBox(-2F, 5F, -2F, 4, 1, 4);
+ Shape8.setRotationPoint(0F, 16F, 0F);
+ Shape8.setTextureSize(64, 64);
+ Shape8.mirror = true;
+ setRotation(Shape8, 0F, 0F, 0F);
+ Shape9 = new ModelRenderer(this, 0, 39);
+ Shape9.addBox(-1F, 5F, -7F, 2, 1, 5);
+ Shape9.setRotationPoint(0F, 16F, 0F);
+ Shape9.setTextureSize(64, 64);
+ Shape9.mirror = true;
+ setRotation(Shape9, 0F, 0F, 0F);
+ outputMain = new ModelRenderer(this, 51, 23);
+ outputMain.addBox(7F, -2F, -2F, 1, 4, 4);
+ outputMain.setRotationPoint(0F, 16F, 0F);
+ outputMain.setTextureSize(64, 64);
+ outputMain.mirror = true;
+ setRotation(outputMain, 0F, 0F, 0F);
+ Shape11 = new ModelRenderer(this, 13, 46);
+ Shape11.addBox(5F, -2F, -2F, 1, 4, 4);
+ Shape11.setRotationPoint(0F, 16F, 0F);
+ Shape11.setTextureSize(64, 64);
+ Shape11.mirror = true;
+ setRotation(Shape11, 0F, 0F, 0F);
+ Shape12 = new ModelRenderer(this, 0, 46);
+ Shape12.addBox(5F, -1F, -7F, 1, 2, 5);
+ Shape12.setRotationPoint(0F, 16F, 0F);
+ Shape12.setTextureSize(64, 64);
+ Shape12.mirror = true;
+ setRotation(Shape12, 0F, 0F, 0F);
+ Shape13 = new ModelRenderer(this, 0, 56);
+ Shape13.addBox(-6F, -1F, -7F, 1, 2, 5);
+ Shape13.setRotationPoint(0F, 16F, 0F);
+ Shape13.setTextureSize(64, 64);
+ Shape13.mirror = true;
+ setRotation(Shape13, 0F, 0F, 0F);
+ Shape14 = new ModelRenderer(this, 13, 56);
+ Shape14.addBox(-6F, -2F, -2F, 1, 4, 4);
+ Shape14.setRotationPoint(0F, 16F, 0F);
+ Shape14.setTextureSize(64, 64);
+ Shape14.mirror = true;
+ setRotation(Shape14, 0F, 0F, 0F);
+ output1 = new ModelRenderer(this, 51, 18);
+ output1.addBox(5F, -5F, -5F, 3, 2, 2);
+ output1.setRotationPoint(0F, 16F, 0F);
+ output1.setTextureSize(64, 64);
+ output1.mirror = true;
+ setRotation(output1, 0F, 0F, 0F);
+ output2 = new ModelRenderer(this, 51, 18);
+ output2.addBox(5F, -5F, 3F, 3, 2, 2);
+ output2.setRotationPoint(0F, 16F, 0F);
+ output2.setTextureSize(64, 64);
+ output2.mirror = true;
+ setRotation(output2, 0F, 0F, 0F);
+ output3 = new ModelRenderer(this, 51, 18);
+ output3.addBox(5F, 3F, -5F, 3, 2, 2);
+ output3.setRotationPoint(0F, 16F, 0F);
+ output3.setTextureSize(64, 64);
+ output3.mirror = true;
+ setRotation(output3, 0F, 0F, 0F);
+ output4 = new ModelRenderer(this, 51, 18);
+ output4.addBox(5F, 3F, 3F, 3, 2, 2);
+ output4.setRotationPoint(0F, 16F, 0F);
+ output4.setTextureSize(64, 64);
+ output4.mirror = true;
+ setRotation(output4, 0F, 0F, 0F);
+ }
+
+ public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5, ForgeDirection input, ForgeDirection output)
+ {
+ super.render(entity, f, f1, f2, f3, f4, f5);
+ setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+
+ float xInputRot = 0.0f;
+ float yInputRot = 0.0f;
+ float zInputRot = 0.0f;
+ float xOutputRot = 0.0f;
+ float yOutputRot = 0.0f;
+ float zOutputRot = 0.0f;
+
+ switch (input)
+ {
+ case NORTH:
+ xInputRot = 0.0f;
+ yInputRot = 0.0f;
+ zInputRot = 0.0f;
+ break;
+
+ case EAST:
+ xInputRot = 0.0f;
+ yInputRot = (float) (0.5f * Math.PI);
+ zInputRot = 0.0f;
+ break;
+
+ case SOUTH:
+ xInputRot = 0.0f;
+ yInputRot = (float) (1.0f * Math.PI);
+ zInputRot = 0.0f;
+ break;
+
+ case WEST:
+ xInputRot = 0.0f;
+ yInputRot = (float) (-0.5f * Math.PI);
+ zInputRot = 0.0f;
+ break;
+
+ case UP:
+ xInputRot = (float) (-0.5f * Math.PI);
+ yInputRot = 0.0f;
+ zInputRot = 0.0f;
+ break;
+
+ case DOWN:
+ xInputRot = (float) (0.5f * Math.PI);
+ yInputRot = 0.0f;
+ zInputRot = 0.0f;
+ break;
+
+ default:
+ break;
+ }
+
+ switch (output)
+ {
+ case NORTH:
+ xOutputRot = 0.0f;
+ yOutputRot = (float) (0.5f * Math.PI);
+ zOutputRot = 0.0f;
+ break;
+
+ case EAST:
+ xOutputRot = 0.0f;
+ yOutputRot = (float) (1.0f * Math.PI);
+ zOutputRot = 0.0f;
+ break;
+
+ case SOUTH:
+ xOutputRot = 0.0f;
+ yOutputRot = (float) (-0.5f * Math.PI);
+ zOutputRot = 0.0f;
+ break;
+
+ case WEST:
+ xOutputRot = 0.0f;
+ yOutputRot = 0.0f;
+ zOutputRot = 0.0f;
+ break;
+
+ case UP:
+ xOutputRot = 0.0f;
+ yOutputRot = 0.0f;
+ zOutputRot = (float) (-0.5f * Math.PI);
+ break;
+
+ case DOWN:
+ xOutputRot = 0.0f;
+ yOutputRot = 0.0f;
+ zOutputRot = (float) (0.5f * Math.PI);
+ break;
+
+ default:
+ break;
+ }
+
+ this.setRotation(inputMain, xInputRot, yInputRot, zInputRot);
+ this.setRotation(Shape2, xInputRot, yInputRot, zInputRot);
+ this.setRotation(Shape3, xInputRot, yInputRot, zInputRot);
+ this.setRotation(Shape4, xInputRot, yInputRot, zInputRot);
+ this.setRotation(Shape5, xInputRot, yInputRot, zInputRot);
+ this.setRotation(Shape6, xInputRot, yInputRot, zInputRot);
+ this.setRotation(Shape7, xInputRot, yInputRot, zInputRot);
+ this.setRotation(Shape8, xInputRot, yInputRot, zInputRot);
+ this.setRotation(Shape9, xInputRot, yInputRot, zInputRot);
+ this.setRotation(Shape12, xInputRot, yInputRot, zInputRot);
+ this.setRotation(Shape11, xInputRot, yInputRot, zInputRot);
+ this.setRotation(Shape13, xInputRot, yInputRot, zInputRot);
+ this.setRotation(Shape14, xInputRot, yInputRot, zInputRot);
+
+ this.setRotation(outputMain, xOutputRot, yOutputRot, zOutputRot);
+ this.setRotation(output1, xOutputRot, yOutputRot, zOutputRot);
+ this.setRotation(output2, xOutputRot, yOutputRot, zOutputRot);
+ this.setRotation(output3, xOutputRot, yOutputRot, zOutputRot);
+ this.setRotation(output4, xOutputRot, yOutputRot, zOutputRot);
+
+
+ core.render(f5);
+ inputMain.render(f5);
+ Shape2.render(f5);
+ Shape3.render(f5);
+ Shape4.render(f5);
+ Shape5.render(f5);
+ Shape6.render(f5);
+ Shape7.render(f5);
+ Shape8.render(f5);
+ Shape9.render(f5);
+ outputMain.render(f5);
+ Shape11.render(f5);
+ Shape12.render(f5);
+ Shape13.render(f5);
+ Shape14.render(f5);
+ output1.render(f5);
+ output2.render(f5);
+ output3.render(f5);
+ output4.render(f5);
+ }
+
+ private void setRotation(ModelRenderer model, float x, float y, float z)
+ {
+ model.rotateAngleX = x;
+ model.rotateAngleY = y;
+ model.rotateAngleZ = z;
+ }
+
+ public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
+ {
+ super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ }
+
+}
+
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelSpellParadigmBlock.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelSpellParadigmBlock.java
new file mode 100644
index 00000000..da48b87d
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelSpellParadigmBlock.java
@@ -0,0 +1,234 @@
+package WayofTime.alchemicalWizardry.common.renderer.model;
+
+//Date: 07/03/2014 9:30:25 PM
+//Template version 1.1
+//Java generated by Techne
+//Keep in mind that you still need to fill in some blanks
+//- ZeuX
+
+
+
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.model.ModelRenderer;
+import net.minecraft.entity.Entity;
+import net.minecraftforge.common.util.ForgeDirection;
+
+public class ModelSpellParadigmBlock extends ModelBase
+{
+//fields
+ ModelRenderer core;
+ ModelRenderer outputMain;
+ ModelRenderer output1;
+ ModelRenderer output2;
+ ModelRenderer output3;
+ ModelRenderer output4;
+ ModelRenderer Shape1;
+ ModelRenderer Shape2;
+ ModelRenderer Shape3;
+ ModelRenderer Shape4;
+ ModelRenderer Shape5;
+
+public ModelSpellParadigmBlock()
+{
+ textureWidth = 64;
+ textureHeight = 64;
+
+ core = new ModelRenderer(this, 0, 0);
+ core.addBox(-3F, -3F, -3F, 6, 6, 6);
+ core.setRotationPoint(0F, 16F, 0F);
+ core.setTextureSize(64, 64);
+ core.mirror = true;
+ setRotation(core, 0F, 0F, 0F);
+ outputMain = new ModelRenderer(this, 0, 13);
+ outputMain.addBox(6F, -2F, -2F, 2, 4, 4);
+ outputMain.setRotationPoint(0F, 16F, 0F);
+ outputMain.setTextureSize(64, 64);
+ outputMain.mirror = true;
+ setRotation(outputMain, 0F, 0F, 0F);
+ output1 = new ModelRenderer(this, 0, 22);
+ output1.addBox(5F, -5F, -5F, 3, 2, 2);
+ output1.setRotationPoint(0F, 16F, 0F);
+ output1.setTextureSize(64, 64);
+ output1.mirror = true;
+ setRotation(output1, 0F, 0F, 0F);
+ output2 = new ModelRenderer(this, 0, 22);
+ output2.addBox(5F, -5F, 3F, 3, 2, 2);
+ output2.setRotationPoint(0F, 16F, 0F);
+ output2.setTextureSize(64, 64);
+ output2.mirror = true;
+ setRotation(output2, 0F, 0F, 0F);
+ output3 = new ModelRenderer(this, 0, 22);
+ output3.addBox(5F, 3F, -5F, 3, 2, 2);
+ output3.setRotationPoint(0F, 16F, 0F);
+ output3.setTextureSize(64, 64);
+ output3.mirror = true;
+ setRotation(output3, 0F, 0F, 0F);
+ output4 = new ModelRenderer(this, 0, 22);
+ output4.addBox(5F, 3F, 3F, 3, 2, 2);
+ output4.setRotationPoint(0F, 16F, 0F);
+ output4.setTextureSize(64, 64);
+ output4.mirror = true;
+ setRotation(output4, 0F, 0F, 0F);
+ Shape1 = new ModelRenderer(this, 0, 28);
+ Shape1.addBox(-5F, -5F, -1F, 10, 1, 2);
+ Shape1.setRotationPoint(0F, 16F, 0F);
+ Shape1.setTextureSize(64, 64);
+ Shape1.mirror = true;
+ setRotation(Shape1, 0F, 0F, 0F);
+ Shape2 = new ModelRenderer(this, 25, 28);
+ Shape2.addBox(-5F, -4F, -4F, 1, 8, 8);
+ Shape2.setRotationPoint(0F, 16F, 0F);
+ Shape2.setTextureSize(64, 64);
+ Shape2.mirror = true;
+ setRotation(Shape2, 0F, 0F, 0F);
+ Shape3 = new ModelRenderer(this, 0, 33);
+ Shape3.addBox(-5F, 4F, -1F, 10, 1, 2);
+ Shape3.setRotationPoint(0F, 16F, 0F);
+ Shape3.setTextureSize(64, 64);
+ Shape3.mirror = true;
+ setRotation(Shape3, 0F, 0F, 0F);
+ Shape4 = new ModelRenderer(this, 0, 38);
+ Shape4.addBox(-5F, -1F, -5F, 10, 2, 1);
+ Shape4.setRotationPoint(0F, 16F, 0F);
+ Shape4.setTextureSize(64, 64);
+ Shape4.mirror = true;
+ setRotation(Shape4, 0F, 0F, 0F);
+ Shape5 = new ModelRenderer(this, 0, 43);
+ Shape5.addBox(-5F, -1F, 4F, 10, 2, 1);
+ Shape5.setRotationPoint(0F, 16F, 0F);
+ Shape5.setTextureSize(64, 64);
+ Shape5.mirror = true;
+ setRotation(Shape5, 0F, 0F, 0F);
+}
+
+public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5, ForgeDirection input, ForgeDirection output)
+{
+ super.render(entity, f, f1, f2, f3, f4, f5);
+ setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ float xInputRot = 0.0f;
+ float yInputRot = 0.0f;
+ float zInputRot = 0.0f;
+ float xOutputRot = 0.0f;
+ float yOutputRot = 0.0f;
+ float zOutputRot = 0.0f;
+
+ switch (input)
+ {
+ case NORTH:
+ xInputRot = 0.0f;
+ yInputRot = 0.0f;
+ zInputRot = 0.0f;
+ break;
+
+ case EAST:
+ xInputRot = 0.0f;
+ yInputRot = (float) (0.5f * Math.PI);
+ zInputRot = 0.0f;
+ break;
+
+ case SOUTH:
+ xInputRot = 0.0f;
+ yInputRot = (float) (1.0f * Math.PI);
+ zInputRot = 0.0f;
+ break;
+
+ case WEST:
+ xInputRot = 0.0f;
+ yInputRot = (float) (-0.5f * Math.PI);
+ zInputRot = 0.0f;
+ break;
+
+ case UP:
+ xInputRot = (float) (-0.5f * Math.PI);
+ yInputRot = 0.0f;
+ zInputRot = 0.0f;
+ break;
+
+ case DOWN:
+ xInputRot = (float) (0.5f * Math.PI);
+ yInputRot = 0.0f;
+ zInputRot = 0.0f;
+ break;
+
+ default:
+ break;
+ }
+
+ switch (output)
+ {
+ case NORTH:
+ xOutputRot = 0.0f;
+ yOutputRot = (float) (0.5f * Math.PI);
+ zOutputRot = 0.0f;
+ break;
+
+ case EAST:
+ xOutputRot = 0.0f;
+ yOutputRot = (float) (1.0f * Math.PI);
+ zOutputRot = 0.0f;
+ break;
+
+ case SOUTH:
+ xOutputRot = 0.0f;
+ yOutputRot = (float) (-0.5f * Math.PI);
+ zOutputRot = 0.0f;
+ break;
+
+ case WEST:
+ xOutputRot = 0.0f;
+ yOutputRot = 0.0f;
+ zOutputRot = 0.0f;
+ break;
+
+ case UP:
+ xOutputRot = 0.0f;
+ yOutputRot = 0.0f;
+ zOutputRot = (float) (-0.5f * Math.PI);
+ break;
+
+ case DOWN:
+ xOutputRot = 0.0f;
+ yOutputRot = 0.0f;
+ zOutputRot = (float) (0.5f * Math.PI);
+ break;
+
+ default:
+ break;
+ }
+
+ this.setRotation(outputMain, xOutputRot, yOutputRot, zOutputRot);
+ this.setRotation(output1, xOutputRot, yOutputRot, zOutputRot);
+ this.setRotation(output2, xOutputRot, yOutputRot, zOutputRot);
+ this.setRotation(output3, xOutputRot, yOutputRot, zOutputRot);
+ this.setRotation(output4, xOutputRot, yOutputRot, zOutputRot);
+ this.setRotation(Shape1, xOutputRot, yOutputRot, zOutputRot);
+ this.setRotation(Shape2, xOutputRot, yOutputRot, zOutputRot);
+ this.setRotation(Shape3, xOutputRot, yOutputRot, zOutputRot);
+ this.setRotation(Shape4, xOutputRot, yOutputRot, zOutputRot);
+ this.setRotation(Shape5, xOutputRot, yOutputRot, zOutputRot);
+ core.render(f5);
+ outputMain.render(f5);
+ output1.render(f5);
+ output2.render(f5);
+ output3.render(f5);
+ output4.render(f5);
+ Shape1.render(f5);
+ Shape2.render(f5);
+ Shape3.render(f5);
+ Shape4.render(f5);
+ Shape5.render(f5);
+}
+
+private void setRotation(ModelRenderer model, float x, float y, float z)
+{
+ model.rotateAngleX = x;
+ model.rotateAngleY = y;
+ model.rotateAngleZ = z;
+}
+
+public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
+{
+ super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+}
+
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelWingedFireDemon.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelWingedFireDemon.java
new file mode 100644
index 00000000..07164ffd
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelWingedFireDemon.java
@@ -0,0 +1,203 @@
+package WayofTime.alchemicalWizardry.common.renderer.model;
+
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.model.ModelRenderer;
+import net.minecraft.entity.Entity;
+import net.minecraft.util.MathHelper;
+
+public class ModelWingedFireDemon extends ModelBase
+{
+ //fields
+ ModelRenderer leftLegPlate;
+ ModelRenderer leftLeg;
+ ModelRenderer codPiece;
+ ModelRenderer rightLegPlate;
+ ModelRenderer rightLeg;
+ ModelRenderer body;
+ ModelRenderer leftShoulder;
+ ModelRenderer leftArm;
+ ModelRenderer head;
+ ModelRenderer rightShoulder;
+ ModelRenderer rightArm;
+ ModelRenderer leftWing;
+ ModelRenderer rightWing;
+ ModelRenderer leftHorn1;
+ ModelRenderer rightHorn1;
+ ModelRenderer leftHorn2;
+ ModelRenderer rightHorn2;
+
+ public ModelWingedFireDemon()
+ {
+ textureWidth = 64;
+ textureHeight = 64;
+ leftLegPlate = new ModelRenderer(this, 40, 36);
+ leftLegPlate.addBox(0F, -3F, -3F, 6, 6, 6);
+ leftLegPlate.setRotationPoint(2F, 5F, 0F);
+ leftLegPlate.setTextureSize(64, 64);
+ leftLegPlate.mirror = true;
+ setRotation(leftLegPlate, 0F, 0F, 0F);
+ leftLeg = new ModelRenderer(this, 48, 16);
+ leftLeg.addBox(1F, 3F, -2F, 4, 16, 4);
+ leftLeg.setRotationPoint(2F, 5F, 0F);
+ leftLeg.setTextureSize(64, 64);
+ leftLeg.mirror = true;
+ setRotation(leftLeg, 0F, 0F, 0F);
+ codPiece = new ModelRenderer(this, 48, 0);
+ codPiece.addBox(-2F, 0F, -2F, 4, 6, 4);
+ codPiece.setRotationPoint(0F, 1F, 0F);
+ codPiece.setTextureSize(64, 64);
+ codPiece.mirror = true;
+ setRotation(codPiece, 0F, 0F, 0F);
+ rightLegPlate = new ModelRenderer(this, 40, 36);
+ rightLegPlate.mirror = true;
+ rightLegPlate.addBox(-6F, -3F, -3F, 6, 6, 6);
+ rightLegPlate.setRotationPoint(-2F, 5F, 0F);
+ rightLegPlate.setTextureSize(64, 64);
+ rightLegPlate.mirror = true;
+ setRotation(rightLegPlate, 0F, 0F, 0F);
+ rightLegPlate.mirror = false;
+ rightLeg = new ModelRenderer(this, 48, 16);
+ rightLeg.mirror = true;
+ rightLeg.addBox(-5F, 3F, -2F, 4, 16, 4);
+ rightLeg.setRotationPoint(-2F, 5F, 0F);
+ rightLeg.setTextureSize(64, 64);
+ rightLeg.mirror = true;
+ setRotation(rightLeg, 0F, 0F, 0F);
+ rightLeg.mirror = false;
+ body = new ModelRenderer(this, 0, 44);
+ body.addBox(-5F, -14F, -3F, 10, 14, 6);
+ body.setRotationPoint(0F, 1F, 0F);
+ body.setTextureSize(64, 64);
+ body.mirror = true;
+ setRotation(body, 0F, 0F, 0F);
+ leftShoulder = new ModelRenderer(this, 0, 29);
+ leftShoulder.addBox(0F, -5F, -4F, 8, 7, 8);
+ leftShoulder.setRotationPoint(5F, -10F, 0F);
+ leftShoulder.setTextureSize(64, 64);
+ leftShoulder.mirror = true;
+ setRotation(leftShoulder, 0F, 0F, 0F);
+ leftArm = new ModelRenderer(this, 32, 0);
+ leftArm.addBox(3F, 2F, -2F, 4, 12, 4);
+ leftArm.setRotationPoint(5F, -10F, 0F);
+ leftArm.setTextureSize(64, 64);
+ leftArm.mirror = true;
+ setRotation(leftArm, 0F, 0F, 0F);
+ head = new ModelRenderer(this, 32, 48);
+ head.addBox(-4F, -7F, -4F, 8, 8, 8);
+ head.setRotationPoint(0F, -14F, -1F);
+ head.setTextureSize(64, 64);
+ head.mirror = true;
+ setRotation(head, 0F, 0F, 0F);
+ rightShoulder = new ModelRenderer(this, 0, 29);
+ rightShoulder.mirror = true;
+ rightShoulder.mirror = true;
+ rightShoulder.addBox(-8F, -5F, -4F, 8, 7, 8);
+ rightShoulder.setRotationPoint(-5F, -10F, 0F);
+ rightShoulder.setTextureSize(64, 64);
+ rightShoulder.mirror = true;
+ setRotation(rightShoulder, 0F, 0F, 0F);
+ rightShoulder.mirror = false;
+ rightArm = new ModelRenderer(this, 32, 0);
+ rightArm.mirror = true;
+ rightArm.mirror = true;
+ rightArm.addBox(-7F, 2F, -2F, 4, 12, 4);
+ rightArm.setRotationPoint(-5F, -10F, 0F);
+ rightArm.setTextureSize(64, 64);
+ rightArm.mirror = true;
+ setRotation(rightArm, 0F, 0F, 0F);
+ rightArm.mirror = false;
+ leftWing = new ModelRenderer(this, 0, 0);
+ leftWing.addBox(0F, -2F, 0F, 16, 12, 0);
+ leftWing.setRotationPoint(0F, -11F, 3F);
+ leftWing.setTextureSize(64, 64);
+ leftWing.mirror = true;
+ setRotation(leftWing, 0F, -0.5061455F, 0F);
+ rightWing = new ModelRenderer(this, 0, 0);
+ rightWing.mirror = true;
+ rightWing.addBox(-16F, -2F, 0F, 16, 12, 0);
+ rightWing.setRotationPoint(0F, -11F, 3F);
+ rightWing.setTextureSize(64, 64);
+ rightWing.mirror = true;
+ setRotation(rightWing, 0F, 0.5061455F, 0F);
+ rightWing.mirror = false;
+ leftHorn1 = new ModelRenderer(this, 0, 12);
+ leftHorn1.addBox(4F, -9F, -1F, 1, 5, 1);
+ leftHorn1.setRotationPoint(0F, -14F, -1F);
+ leftHorn1.setTextureSize(64, 64);
+ leftHorn1.mirror = true;
+ setRotation(leftHorn1, 0F, 0F, 0F);
+ rightHorn1 = new ModelRenderer(this, 0, 12);
+ rightHorn1.mirror = true;
+ rightHorn1.addBox(-5F, -9F, -1F, 1, 5, 1);
+ rightHorn1.setRotationPoint(0F, -14F, -1F);
+ rightHorn1.setTextureSize(64, 64);
+ rightHorn1.mirror = true;
+ setRotation(rightHorn1, 0F, 0F, 0F);
+ rightHorn1.mirror = false;
+ leftHorn2 = new ModelRenderer(this, 4, 12);
+ leftHorn2.addBox(4F, -10F, 0F, 1, 5, 1);
+ leftHorn2.setRotationPoint(0F, -14F, -1F);
+ leftHorn2.setTextureSize(64, 64);
+ leftHorn2.mirror = true;
+ setRotation(leftHorn2, 0F, 0F, 0F);
+ rightHorn2 = new ModelRenderer(this, 4, 12);
+ rightHorn2.mirror = true;
+ rightHorn2.addBox(-5F, -10F, 0F, 1, 5, 1);
+ rightHorn2.setRotationPoint(0F, -14F, -1F);
+ rightHorn2.setTextureSize(64, 64);
+ rightHorn2.mirror = true;
+ setRotation(rightHorn2, 0F, 0F, 0F);
+ rightHorn2.mirror = false;
+ }
+
+ public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
+ {
+ super.render(entity, f, f1, f2, f3, f4, f5);
+ setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ leftLegPlate.render(f5);
+ leftLeg.render(f5);
+ codPiece.render(f5);
+ rightLegPlate.render(f5);
+ rightLeg.render(f5);
+ body.render(f5);
+ leftShoulder.render(f5);
+ leftArm.render(f5);
+ head.render(f5);
+ rightShoulder.render(f5);
+ rightArm.render(f5);
+ leftWing.render(f5);
+ rightWing.render(f5);
+ leftHorn1.render(f5);
+ rightHorn1.render(f5);
+ leftHorn2.render(f5);
+ rightHorn2.render(f5);
+ }
+
+ private void setRotation(ModelRenderer model, float x, float y, float z)
+ {
+ model.rotateAngleX = x;
+ model.rotateAngleY = y;
+ model.rotateAngleZ = z;
+ }
+
+ public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
+ {
+ super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ this.head.rotateAngleX = f4 / (180F / (float) Math.PI);
+ this.head.rotateAngleY = f3 / (180F / (float) Math.PI);
+ this.leftHorn1.rotateAngleX = head.rotateAngleX;
+ this.leftHorn1.rotateAngleY = head.rotateAngleY;
+ this.leftHorn2.rotateAngleX = head.rotateAngleX;
+ this.leftHorn2.rotateAngleY = head.rotateAngleY;
+ this.rightHorn1.rotateAngleX = head.rotateAngleX;
+ this.rightHorn1.rotateAngleY = head.rotateAngleY;
+ this.rightHorn2.rotateAngleX = head.rotateAngleX;
+ this.rightHorn2.rotateAngleY = head.rotateAngleY;
+ this.leftLeg.rotateAngleX = MathHelper.cos(f * 0.6662F) * 1.4F * f1;
+ this.rightLeg.rotateAngleX = MathHelper.cos(f * 0.6662F + (float) Math.PI) * 1.0F * f1;
+ this.rightArm.rotateAngleX = MathHelper.cos(f * 0.6662F + (float) Math.PI) * 1.0F * f1;
+ this.leftArm.rotateAngleX = MathHelper.cos(f * 0.6662F) * 1.4F * f1;
+ this.leftShoulder.rotateAngleX = this.leftArm.rotateAngleX;
+ this.rightShoulder.rotateAngleX = this.rightArm.rotateAngleX;
+ }
+}
\ No newline at end of file
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelWritingTable.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelWritingTable.java
new file mode 100644
index 00000000..15dede34
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/model/ModelWritingTable.java
@@ -0,0 +1,138 @@
+package WayofTime.alchemicalWizardry.common.renderer.model;
+
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.model.ModelRenderer;
+import net.minecraft.entity.Entity;
+
+public class ModelWritingTable extends ModelBase
+{
+ //fields
+ ModelRenderer base;
+ ModelRenderer support;
+ ModelRenderer appendage1;
+ ModelRenderer appendage2;
+ ModelRenderer appendage3;
+ ModelRenderer appendage4;
+ ModelRenderer appendage5;
+ ModelRenderer outputPad;
+ ModelRenderer input1;
+ ModelRenderer input5;
+ ModelRenderer input4;
+ ModelRenderer input3;
+ ModelRenderer Shape1;
+
+ public ModelWritingTable()
+ {
+ textureWidth = 64;
+ textureHeight = 64;
+ base = new ModelRenderer(this, 0, 0);
+ base.addBox(0F, 0F, 0F, 16, 2, 16);
+ base.setRotationPoint(-8F, 22F, -8F);
+ base.setTextureSize(64, 32);
+ base.mirror = true;
+ setRotation(base, 0F, 0F, 0F);
+ support = new ModelRenderer(this, 0, 0);
+ support.addBox(0F, 0F, 0F, 2, 12, 2);
+ support.setRotationPoint(-1F, 10F, -1F);
+ support.setTextureSize(64, 32);
+ support.mirror = true;
+ setRotation(support, 0F, 0F, 0F);
+ appendage1 = new ModelRenderer(this, 48, 0);
+ appendage1.addBox(1F, 0F, 0F, 7, 11, 0);
+ appendage1.setRotationPoint(0F, 10F, 0F);
+ appendage1.setTextureSize(64, 32);
+ appendage1.mirror = true;
+ setRotation(appendage1, 0F, 0F, 0F);
+ appendage2 = new ModelRenderer(this, 48, 0);
+ appendage2.addBox(1F, 0F, 0F, 7, 11, 0);
+ appendage2.setRotationPoint(0F, 10F, 0F);
+ appendage2.setTextureSize(64, 32);
+ appendage2.mirror = true;
+ setRotation(appendage2, 0F, ((float) Math.PI * 2F / 5F), 0F);
+ appendage3 = new ModelRenderer(this, 48, 0);
+ appendage3.addBox(1F, 0F, 0F, 7, 11, 0);
+ appendage3.setRotationPoint(0F, 10F, 0F);
+ appendage3.setTextureSize(64, 32);
+ appendage3.mirror = true;
+ setRotation(appendage3, 0F, 2.513274F, 0F);
+ appendage4 = new ModelRenderer(this, 48, 0);
+ appendage4.addBox(1F, 0F, 0F, 7, 11, 0);
+ appendage4.setRotationPoint(0F, 10F, 0F);
+ appendage4.setTextureSize(64, 32);
+ appendage4.mirror = true;
+ setRotation(appendage4, 0F, -2.513274F, 0F);
+ appendage5 = new ModelRenderer(this, 48, 0);
+ appendage5.addBox(1F, 0F, 0F, 7, 11, 0);
+ appendage5.setRotationPoint(0F, 10F, 0F);
+ appendage5.setTextureSize(64, 32);
+ appendage5.mirror = true;
+ setRotation(appendage5, 0F, -((float) Math.PI * 2F / 5F), 0F);
+ outputPad = new ModelRenderer(this, 0, 20);
+ outputPad.addBox(0F, 0F, 0F, 4, 1, 4);
+ outputPad.setRotationPoint(-2F, 9F, -2F);
+ outputPad.setTextureSize(64, 64);
+ outputPad.mirror = true;
+ setRotation(outputPad, 0F, 0F, 0F);
+ input1 = new ModelRenderer(this, 0, 20);
+ input1.addBox(4F, 0F, -2F, 4, 1, 4);
+ input1.setRotationPoint(0F, 21F, 0F);
+ input1.setTextureSize(64, 64);
+ input1.mirror = true;
+ setRotation(input1, 0F, 0F, 0F);
+ input5 = new ModelRenderer(this, 0, 20);
+ input5.addBox(0F, 0F, 0F, 4, 1, 4);
+ input5.setRotationPoint(0F, 21F, -8F);
+ input5.setTextureSize(64, 64);
+ input5.mirror = true;
+ setRotation(input5, 0F, 0F, 0F);
+ input4 = new ModelRenderer(this, 0, 20);
+ input4.addBox(-7F, 0F, -6F, 4, 1, 4);
+ input4.setRotationPoint(0F, 21F, 0F);
+ input4.setTextureSize(64, 64);
+ input4.mirror = true;
+ setRotation(input4, 0F, 0F, 0F);
+ input3 = new ModelRenderer(this, 0, 20);
+ input3.addBox(-7F, 0F, 2F, 4, 1, 4);
+ input3.setRotationPoint(0F, 21F, 0F);
+ input3.setTextureSize(64, 64);
+ input3.mirror = true;
+ setRotation(input3, 0F, 0F, 0F);
+ Shape1 = new ModelRenderer(this, 0, 20);
+ Shape1.addBox(0F, 0F, 4F, 4, 1, 4);
+ Shape1.setRotationPoint(0F, 21F, 0F);
+ Shape1.setTextureSize(64, 64);
+ Shape1.mirror = true;
+ setRotation(Shape1, 0F, 0F, 0F);
+ }
+
+ public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
+ {
+ super.render(entity, f, f1, f2, f3, f4, f5);
+ setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ base.render(f5);
+ support.render(f5);
+ appendage1.render(f5);
+ appendage2.render(f5);
+ appendage3.render(f5);
+ appendage4.render(f5);
+ appendage5.render(f5);
+ outputPad.render(f5);
+ input1.render(f5);
+ input5.render(f5);
+ input4.render(f5);
+ input3.render(f5);
+ Shape1.render(f5);
+ }
+
+ private void setRotation(ModelRenderer model, float x, float y, float z)
+ {
+ model.rotateAngleX = x;
+ model.rotateAngleY = y;
+ model.rotateAngleZ = z;
+ }
+
+ public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
+ {
+ super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/projectile/RenderEnergyBazookaMainProjectile.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/projectile/RenderEnergyBazookaMainProjectile.java
new file mode 100644
index 00000000..57df9912
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/projectile/RenderEnergyBazookaMainProjectile.java
@@ -0,0 +1,39 @@
+package WayofTime.alchemicalWizardry.common.renderer.projectile;
+
+import WayofTime.alchemicalWizardry.common.renderer.model.ModelEnergyBazookaMainProjectile;
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.renderer.entity.Render;
+import net.minecraft.entity.Entity;
+import net.minecraft.util.ResourceLocation;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL12;
+
+public class RenderEnergyBazookaMainProjectile extends Render
+{
+ public ModelBase model = new ModelEnergyBazookaMainProjectile();
+ private static final ResourceLocation field_110833_a = new ResourceLocation("alchemicalwizardry", "textures/models/EnergyBazookaMainProjectile.png"); //refers to:YourMod/modelsTextureFile/optionalFile/yourTexture.png
+ private float scale = 1.0f;
+
+ @Override
+ public void doRender(Entity entity, double d0, double d1, double d2, float f, float f1)
+ {
+ GL11.glPushMatrix();
+ GL11.glTranslatef((float) d0, (float) d1, (float) d2);
+ GL11.glEnable(GL12.GL_RESCALE_NORMAL);
+ GL11.glScalef(scale, scale, scale);
+ this.bindTexture(this.getEntityTexture(entity));
+ GL11.glRotatef(entity.prevRotationYaw + (entity.rotationYaw - entity.prevRotationYaw) * f1, 0.0F, 1.0F, 0.0F);
+ GL11.glRotatef(180.0f - entity.prevRotationPitch + (entity.rotationPitch - entity.prevRotationPitch) * f1, 1.0F, 0.0F, 0.0f);
+ model.render(entity, 0, (float) d0, (float) d1, (float) d2, f, f1);
+ //GL11.glRotatef(entity.getRotationYawHead(), 0.0F, 1.0F, 0.0F);
+ GL11.glDisable(GL12.GL_RESCALE_NORMAL);
+ GL11.glPopMatrix();
+ }
+
+ @Override
+ protected ResourceLocation getEntityTexture(Entity entity)
+ {
+ // TODO Auto-generated method stub
+ return field_110833_a;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/projectile/RenderEnergyBlastProjectile.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/projectile/RenderEnergyBlastProjectile.java
new file mode 100644
index 00000000..5e988929
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/projectile/RenderEnergyBlastProjectile.java
@@ -0,0 +1,101 @@
+package WayofTime.alchemicalWizardry.common.renderer.projectile;
+
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.entity.Render;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.IProjectile;
+import net.minecraft.util.ResourceLocation;
+
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL12;
+
+import WayofTime.alchemicalWizardry.common.entity.projectile.ExplosionProjectile;
+import WayofTime.alchemicalWizardry.common.entity.projectile.FireProjectile;
+import WayofTime.alchemicalWizardry.common.entity.projectile.HolyProjectile;
+import WayofTime.alchemicalWizardry.common.entity.projectile.IceProjectile;
+import WayofTime.alchemicalWizardry.common.entity.projectile.LightningBoltProjectile;
+import WayofTime.alchemicalWizardry.common.entity.projectile.MudProjectile;
+import WayofTime.alchemicalWizardry.common.entity.projectile.WaterProjectile;
+import WayofTime.alchemicalWizardry.common.entity.projectile.WindGustProjectile;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+@SideOnly(Side.CLIENT)
+public class RenderEnergyBlastProjectile extends Render
+{
+ public void doRenderEnergyBlastProjectile(Entity entityShot, double par2, double par4, double par6, float par8, float par9)
+ {
+ GL11.glPushMatrix();
+ GL11.glTranslatef((float) par2, (float) par4, (float) par6);
+ GL11.glEnable(GL12.GL_RESCALE_NORMAL);
+ GL11.glScalef(0.1F, 0.1F, 0.1F);
+ this.bindTexture(this.getEntityTexture(entityShot));
+ Tessellator var12 = Tessellator.instance;
+ GL11.glRotatef(180.0F - renderManager.playerViewY, 0.0F, 1.0F, 0.0F);
+ GL11.glRotatef(-renderManager.playerViewX, 1.0F, 0.0F, 0.0F);
+ var12.startDrawingQuads();
+ var12.setNormal(0.0F, 1.0F, 0.0F);
+ var12.addVertexWithUV(-0.5F, -0.25F, 0.0D, 0, 1);
+ var12.addVertexWithUV(0.5F, -0.25F, 0.0D, 1, 1);
+ var12.addVertexWithUV(0.5F, 0.75F, 0.0D, 1, 0);
+ var12.addVertexWithUV(-0.5F, 0.75F, 0.0D, 0, 0);
+ var12.draw();
+ GL11.glDisable(GL12.GL_RESCALE_NORMAL);
+ GL11.glPopMatrix();
+ }
+
+ @Override
+ public void doRender(Entity par1Entity, double par2, double par4, double par6, float par8, float par9)
+ {
+ if (par1Entity instanceof IProjectile)
+ {
+ this.doRenderEnergyBlastProjectile(par1Entity, par2, par4, par6, par8, par9);
+ }
+ }
+
+ @Override
+ protected ResourceLocation getEntityTexture(Entity entity)
+ {
+ if (entity instanceof IceProjectile)
+ {
+ return new ResourceLocation("alchemicalwizardry", "textures/entities/iceProjectile.png");
+ }
+
+ if (entity instanceof FireProjectile)
+ {
+ return new ResourceLocation("alchemicalwizardry", "textures/entities/fireProjectile.png");
+ }
+
+ if (entity instanceof ExplosionProjectile)
+ {
+ return new ResourceLocation("alchemicalwizardry", "textures/entities/explosionProjectile.png");
+ }
+
+ if (entity instanceof HolyProjectile)
+ {
+ return new ResourceLocation("alchemicalwizardry", "textures/entities/holyProjectile.png");
+ }
+
+ if (entity instanceof WindGustProjectile)
+ {
+ return new ResourceLocation("alchemicalwizardry", "textures/entities/windGustProjectile.png");
+ }
+
+ if (entity instanceof LightningBoltProjectile)
+ {
+ return new ResourceLocation("alchemicalwizardry", "textures/entities/lightningProjectile.png");
+ }
+
+ if (entity instanceof WaterProjectile)
+ {
+ return new ResourceLocation("alchemicalwizardry", "textures/entities/waterProjectile.png");
+ }
+
+ if (entity instanceof MudProjectile)
+ {
+ return new ResourceLocation("alchemicalwizardry", "textures/entities/mudProjectile.png");
+ }
+
+ return new ResourceLocation("alchemicalwizardry", "textures/entities/energyBlastProjectile.png");
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/projectile/RenderFireProjectile.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/projectile/RenderFireProjectile.java
new file mode 100644
index 00000000..cda739fe
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/projectile/RenderFireProjectile.java
@@ -0,0 +1,41 @@
+package WayofTime.alchemicalWizardry.common.renderer.projectile;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+@SideOnly(Side.CLIENT)
+public class RenderFireProjectile
+{
+// public void doRenderProjectile(FireProjectile entityShot, double par2, double par4, double par6, float par8, float par9)
+// {
+// GL11.glPushMatrix();
+// GL11.glTranslatef((float)par2, (float)par4, (float)par6);
+// GL11.glEnable(GL12.GL_RESCALE_NORMAL);
+// GL11.glScalef(0.1F, 0.1F, 0.1F);
+// this.func_110776_a(this.func_110775_a(entityShot));
+// Tessellator var12 = Tessellator.instance;
+// GL11.glRotatef(180.0F - renderManager.playerViewY, 0.0F, 1.0F, 0.0F);
+// GL11.glRotatef(-renderManager.playerViewX, 1.0F, 0.0F, 0.0F);
+// var12.startDrawingQuads();
+// var12.setNormal(0.0F, 1.0F, 0.0F);
+// var12.addVertexWithUV(-0.5F, -0.25F, 0.0D, 0, 1);
+// var12.addVertexWithUV(0.5F, -0.25F, 0.0D, 1, 1);
+// var12.addVertexWithUV(0.5F, 0.75F, 0.0D, 1, 0);
+// var12.addVertexWithUV(-0.5F, 0.75F, 0.0D, 0, 0);
+// var12.draw();
+// GL11.glDisable(GL12.GL_RESCALE_NORMAL);
+// GL11.glPopMatrix();
+// }
+//
+// @Override
+// public void doRender(Entity par1Entity, double par2, double par4, double par6, float par8, float par9)
+// {
+// this.doRenderProjectile((FireProjectile)par1Entity, par2, par4, par6, par8, par9);
+// }
+//
+// @Override
+// protected ResourceLocation func_110775_a(Entity entity)
+// {
+// return new ResourceLocation("alchemicalwizardry:/textures/entities/fireProjectile.png");
+// }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/projectile/RenderMeteor.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/projectile/RenderMeteor.java
new file mode 100644
index 00000000..c39dcb11
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/renderer/projectile/RenderMeteor.java
@@ -0,0 +1,39 @@
+package WayofTime.alchemicalWizardry.common.renderer.projectile;
+
+import WayofTime.alchemicalWizardry.common.renderer.model.ModelMeteor;
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.renderer.entity.Render;
+import net.minecraft.entity.Entity;
+import net.minecraft.util.ResourceLocation;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL12;
+
+public class RenderMeteor extends Render
+{
+ public ModelBase model = new ModelMeteor();
+ private static final ResourceLocation field_110833_a = new ResourceLocation("alchemicalwizardry", "textures/models/Meteor.png"); //refers to:YourMod/modelsTextureFile/optionalFile/yourTexture.png
+ private float scale = 1.0f;
+
+ @Override
+ public void doRender(Entity entity, double d0, double d1, double d2, float f, float f1)
+ {
+ GL11.glPushMatrix();
+ GL11.glTranslatef((float) d0, (float) d1, (float) d2);
+ GL11.glEnable(GL12.GL_RESCALE_NORMAL);
+ GL11.glScalef(scale, scale, scale);
+ this.bindTexture(this.getEntityTexture(entity));
+ GL11.glRotatef(entity.prevRotationYaw + (entity.rotationYaw - entity.prevRotationYaw) * f1, 0.0F, 1.0F, 0.0F);
+ GL11.glRotatef(180.0f - entity.prevRotationPitch + (entity.rotationPitch - entity.prevRotationPitch) * f1, 1.0F, 0.0F, 0.0f);
+ model.render(entity, 0, (float) d0, (float) d1, (float) d2, f, f1);
+ //GL11.glRotatef(entity.getRotationYawHead(), 0.0F, 1.0F, 0.0F);
+ GL11.glDisable(GL12.GL_RESCALE_NORMAL);
+ GL11.glPopMatrix();
+ }
+
+ @Override
+ protected ResourceLocation getEntityTexture(Entity entity)
+ {
+ // TODO Auto-generated method stub
+ return field_110833_a;
+ }
+}
diff --git a/src-backup/main/java/WayofTime/alchemicalWizardry/common/rituals/RitualEffectAnimalGrowth.java b/src-backup/main/java/WayofTime/alchemicalWizardry/common/rituals/RitualEffectAnimalGrowth.java
new file mode 100644
index 00000000..ed0e7130
--- /dev/null
+++ b/src-backup/main/java/WayofTime/alchemicalWizardry/common/rituals/RitualEffectAnimalGrowth.java
@@ -0,0 +1,163 @@
+package WayofTime.alchemicalWizardry.common.rituals;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import net.minecraft.entity.EntityAgeable;
+import net.minecraft.entity.passive.EntityAnimal;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.potion.Potion;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.world.World;
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentRegistry;
+import WayofTime.alchemicalWizardry.api.rituals.IMasterRitualStone;
+import WayofTime.alchemicalWizardry.api.rituals.RitualComponent;
+import WayofTime.alchemicalWizardry.api.rituals.RitualEffect;
+import WayofTime.alchemicalWizardry.api.soulNetwork.LifeEssenceNetwork;
+import WayofTime.alchemicalWizardry.api.soulNetwork.SoulNetworkHandler;
+import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
+
+public class RitualEffectAnimalGrowth extends RitualEffect
+{
+ public static final int breedingCost = 50;
+ public static final int reductusDrain = 1;
+ public static final int virtusDrain = 10;
+
+ @Override
+ public void performEffect(IMasterRitualStone ritualStone)
+ {
+ String owner = ritualStone.getOwner();
+
+ int currentEssence = SoulNetworkHandler.getCurrentEssence(owner);
+ World world = ritualStone.getWorld();
+ int x = ritualStone.getXCoord();
+ int y = ritualStone.getYCoord();
+ int z = ritualStone.getZCoord();
+
+ if (world.getWorldTime() % 20 != 0)
+ {
+ return;
+ }
+
+ double range = 2;
+
+ AxisAlignedBB axisalignedbb = AxisAlignedBB.getBoundingBox((double) x, (double) y + 1, (double) z, (double) (x + 1), (double) (y + 3), (double) (z + 1)).expand(range, 0, range);
+ List
