Getting ma groove on

build.gradle

@@ -22,7 +22,7 @@ group = "com.pahimar.ee3" // http://maven.apache.org/guides/mini/guide-naming-co
 archivesBaseName = "EquivalentExchange3"
 
 minecraft {
-    version = "1.7.2-10.12.1.1061"
+    version = "1.7.2-10.12.1.1063"
     assetDir = "eclipse/assets"
 }
 processResources

src/main/java/com/pahimar/ee3/EquivalentExchange3.java

@@ -3,10 +3,13 @@ package com.pahimar.ee3;
 import com.pahimar.ee3.block.ModBlocks;
 import com.pahimar.ee3.handler.CraftingHandler;
 import com.pahimar.ee3.handler.GuiHandler;
+import com.pahimar.ee3.item.EquivalencyStack;
 import com.pahimar.ee3.item.ModItems;
+import com.pahimar.ee3.network.PacketHandler;
 import com.pahimar.ee3.proxy.IProxy;
 import com.pahimar.ee3.reference.EventHandlers;
 import com.pahimar.ee3.reference.Reference;
+import com.pahimar.ee3.util.LogHelper;
 import cpw.mods.fml.common.FMLCommonHandler;
 import cpw.mods.fml.common.Mod;
 import cpw.mods.fml.common.Mod.EventHandler;
@@ -15,6 +18,7 @@ import cpw.mods.fml.common.SidedProxy;
 import cpw.mods.fml.common.event.*;
 import cpw.mods.fml.common.event.FMLInterModComms.IMCEvent;
 import cpw.mods.fml.common.network.NetworkRegistry;
+import net.minecraft.init.Items;
 import net.minecraftforge.common.MinecraftForge;
 
 @Mod(modid = Reference.MOD_ID, name = Reference.MOD_NAME, certificateFingerprint = Reference.FINGERPRINT, version = "0.2")
@@ -46,6 +50,8 @@ public class EquivalentExchange3
 
         // Initialize mod blocks
         ModBlocks.init();
+
+        PacketHandler.init();
     }
 
     @EventHandler
@@ -70,7 +76,12 @@ public class EquivalentExchange3
     @EventHandler
     public void postInit(FMLPostInitializationEvent event)
     {
+        EquivalencyStack equivalencyStack = new EquivalencyStack(Items.beef);
 
+        for (Object object : equivalencyStack.getEquivalentStacks())
+        {
+            LogHelper.info(object);
+        }
     }
 
     @EventHandler

src/main/java/com/pahimar/ee3/exchange/EnergyComponent.java

@@ -0,0 +1,70 @@
+package com.pahimar.ee3.exchange;
+
+public class EnergyComponent implements Comparable<EnergyComponent>
+{
+
+    public final EnergyType type;
+    public final int weight;
+
+    public EnergyComponent(EnergyType type, int weight)
+    {
+
+        this.type = type;
+
+        if (weight > 0)
+        {
+            this.weight = weight;
+        }
+        else
+        {
+            this.weight = -1;
+        }
+    }
+
+    public EnergyComponent(EnergyType type)
+    {
+
+        this(type, 1);
+    }
+
+    @Override
+    public boolean equals(Object object)
+    {
+
+        if (!(object instanceof EnergyComponent))
+        {
+            return false;
+        }
+
+        EnergyComponent energyComponent = (EnergyComponent) object;
+
+        return ((this.type == energyComponent.type) && (this.weight == energyComponent.weight));
+    }
+
+    @Override
+    public String toString()
+    {
+        return String.format("<EMC Type: %s, Weight: %s>", type, weight);
+    }
+
+    @Override
+    public int compareTo(EnergyComponent energyComponent)
+    {
+
+        if (energyComponent != null)
+        {
+            if (this.type == energyComponent.type)
+            {
+                return (this.weight - energyComponent.weight);
+            }
+            else
+            {
+                return this.type.compareTo(energyComponent.type);
+            }
+        }
+        else
+        {
+            return 1;
+        }
+    }
+}

src/main/java/com/pahimar/ee3/exchange/EnergyType.java

@@ -0,0 +1,10 @@
+package com.pahimar.ee3.exchange;
+
+public enum EnergyType
+{
+    OMNI, CORPOREAL, KINETIC, TEMPORAL, ESSENTIA, AMORPHOUS, VOID;
+
+    public static final EnergyType[] TYPES = EnergyType.values();
+
+    public static final EnergyType DEFAULT = EnergyType.CORPOREAL;
+}

src/main/java/com/pahimar/ee3/exchange/EnergyValue.java

@@ -0,0 +1,319 @@
+package com.pahimar.ee3.exchange;
+
+import com.google.gson.*;
+import com.pahimar.ee3.util.LogHelper;
+
+import java.lang.reflect.Type;
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Equivalent-Exchange-3
+ * <p/>
+ * EMCEntry
+ *
+ * @author pahimar
+ */
+public class EnergyValue implements Comparable<EnergyValue>, JsonDeserializer<EnergyValue>, JsonSerializer<EnergyValue>
+{
+    // Gson serializer for serializing to/deserializing from json
+    private static final Gson gsonSerializer = (new GsonBuilder()).registerTypeAdapter(EnergyValue.class, new EnergyValue()).create();
+    private static final int PRECISION = 4;
+
+    public final float[] components;
+
+    public EnergyValue()
+    {
+        this(new float[EnergyType.TYPES.length]);
+    }
+
+    public EnergyValue(int value)
+    {
+        this((float) value);
+    }
+
+    public EnergyValue(float value)
+    {
+        this(value, EnergyType.DEFAULT);
+    }
+
+    public EnergyValue(float value, EnergyComponent component)
+    {
+        this(value, component.type);
+    }
+
+    public EnergyValue(int value, EnergyType energyType)
+    {
+        this((float) value, energyType);
+    }
+
+    public EnergyValue(float value, EnergyType energyType)
+    {
+        this(value, Arrays.asList(new EnergyComponent(energyType)));
+    }
+
+    public EnergyValue(float[] components)
+    {
+        if (components.length == EnergyType.TYPES.length)
+        {
+            this.components = new float[components.length];
+            for (int i = 0; i < this.components.length; i++)
+            {
+                BigDecimal bigComponent = BigDecimal.valueOf(components[i]).setScale(PRECISION, BigDecimal.ROUND_HALF_DOWN);
+                this.components[i] = bigComponent.floatValue();
+            }
+        }
+        else
+        {
+            this.components = null;
+        }
+    }
+
+    public EnergyValue(int value, List<EnergyComponent> componentList)
+    {
+        this((float) value, componentList);
+    }
+
+    public EnergyValue(float value, List<EnergyComponent> componentList)
+    {
+        this.components = new float[EnergyType.TYPES.length];
+
+        List<EnergyComponent> collatedComponents = collateComponents(componentList);
+
+        int totalComponents = 0;
+
+        for (EnergyComponent component : collatedComponents)
+        {
+            if (component.weight > 0)
+            {
+                totalComponents += component.weight;
+            }
+        }
+
+        if (totalComponents > 0)
+        {
+            for (EnergyComponent component : collatedComponents)
+            {
+                if (component.weight > 0)
+                {
+                    this.components[component.type.ordinal()] = value * (component.weight * 1F / totalComponents);
+                }
+            }
+        }
+        else
+        {
+            this.components[EnergyType.DEFAULT.ordinal()] = value;
+        }
+
+        for (int i = 0; i < this.components.length; i++)
+        {
+            BigDecimal bigComponent = BigDecimal.valueOf(this.components[i]).setScale(PRECISION, BigDecimal.ROUND_HALF_DOWN);
+            this.components[i] = bigComponent.floatValue();
+        }
+    }
+
+    /**
+     * Deserializes an EnergyValue object from the given serialized json String
+     *
+     * @param jsonEmcValue
+     *         Json encoded String representing a EnergyValue object
+     *
+     * @return The EnergyValue that was encoded as json, or null if a valid EnergyValue could not be decoded from given
+     * String
+     */
+    @SuppressWarnings("unused")
+    public static EnergyValue createFromJson(String jsonEmcValue)
+    {
+        try
+        {
+            return gsonSerializer.fromJson(jsonEmcValue, EnergyValue.class);
+        }
+        catch (JsonSyntaxException exception)
+        {
+            LogHelper.error(exception.getMessage());
+        }
+        catch (JsonParseException exception)
+        {
+            LogHelper.error(exception.getMessage());
+        }
+
+        return null;
+    }
+
+    private static List<EnergyComponent> collateComponents(List<EnergyComponent> uncollatedComponents)
+    {
+        Integer[] componentCount = new Integer[EnergyType.TYPES.length];
+
+        for (EnergyComponent energyComponent : uncollatedComponents)
+        {
+            if (componentCount[energyComponent.type.ordinal()] == null)
+            {
+                componentCount[energyComponent.type.ordinal()] = 0;
+            }
+
+            if (energyComponent.weight >= 0)
+            {
+                componentCount[energyComponent.type.ordinal()] = componentCount[energyComponent.type.ordinal()] + energyComponent.weight;
+            }
+        }
+
+        List<EnergyComponent> collatedComponents = new ArrayList<EnergyComponent>();
+
+        for (int i = 0; i < EnergyType.TYPES.length; i++)
+        {
+            if (componentCount[i] != null)
+            {
+                collatedComponents.add(new EnergyComponent(EnergyType.TYPES[i], componentCount[i]));
+            }
+        }
+
+        Collections.sort(collatedComponents);
+
+        return collatedComponents;
+    }
+
+    private static int compareComponents(float[] first, float[] second)
+    {
+        if (first.length == EnergyType.TYPES.length && second.length == EnergyType.TYPES.length)
+        {
+
+            for (EnergyType energyType : EnergyType.TYPES)
+            {
+                if (Float.compare(first[energyType.ordinal()], second[energyType.ordinal()]) != 0)
+                {
+                    return Float.compare(first[energyType.ordinal()], second[energyType.ordinal()]);
+                }
+            }
+
+            return 0;
+        }
+        else
+        {
+            throw new ArrayIndexOutOfBoundsException();
+        }
+    }
+
+    public float getValue()
+    {
+        float sumSubValues = 0;
+
+        for (float subValue : this.components)
+        {
+            if (subValue > 0)
+            {
+                sumSubValues += subValue;
+            }
+        }
+
+        return sumSubValues;
+    }
+
+    @Override
+    public boolean equals(Object object)
+    {
+        return object instanceof EnergyValue && (compareTo((EnergyValue) object) == 0);
+    }
+
+    @Override
+    public String toString()
+    {
+        StringBuilder stringBuilder = new StringBuilder();
+
+        stringBuilder.append("[");
+        for (EnergyType energyType : EnergyType.TYPES)
+        {
+            if (components[energyType.ordinal()] > 0)
+            {
+                stringBuilder.append(String.format(" %s:%s ", energyType, components[energyType.ordinal()]));
+            }
+        }
+        stringBuilder.append("]");
+
+        return stringBuilder.toString();
+    }
+
+    @Override
+    public int hashCode()
+    {
+        int hashCode = 1;
+
+        hashCode = 37 * hashCode + Float.floatToIntBits(getValue());
+        for (float subValue : components)
+        {
+            hashCode = 37 * hashCode + Float.floatToIntBits(subValue);
+        }
+
+        return hashCode;
+    }
+
+    @Override
+    public int compareTo(EnergyValue energyValue)
+    {
+        if (energyValue != null)
+        {
+            return compareComponents(this.components, energyValue.components);
+        }
+        else
+        {
+            return -1;
+        }
+    }
+
+    /**
+     * Returns this EnergyValue as a json serialized String
+     *
+     * @return Json serialized String of this EnergyValue
+     */
+    public String toJson()
+    {
+        return gsonSerializer.toJson(this);
+    }
+
+    @Override
+    public JsonElement serialize(EnergyValue energyValue, Type type, JsonSerializationContext context)
+    {
+        JsonObject jsonEmcValue = new JsonObject();
+
+        for (EnergyType energyType : EnergyType.TYPES)
+        {
+            jsonEmcValue.addProperty(energyType.toString(), energyValue.components[energyType.ordinal()]);
+        }
+
+        return jsonEmcValue;
+    }
+
+    @Override
+    public EnergyValue deserialize(JsonElement jsonElement, Type type, JsonDeserializationContext context) throws JsonParseException
+    {
+
+        float[] emcValueComponents = new float[EnergyType.TYPES.length];
+        JsonObject jsonEmcValue = (JsonObject) jsonElement;
+
+        for (EnergyType energyType : EnergyType.TYPES)
+        {
+            if ((jsonEmcValue.get(energyType.toString()) != null) && (jsonEmcValue.get(energyType.toString()).isJsonPrimitive()))
+            {
+                try
+                {
+                    emcValueComponents[energyType.ordinal()] = jsonEmcValue.get(energyType.toString()).getAsFloat();
+                }
+                catch (UnsupportedOperationException exception)
+                {
+                    LogHelper.error(exception.getMessage());
+                }
+            }
+        }
+
+        EnergyValue energyValue = new EnergyValue(emcValueComponents);
+
+        if (energyValue.getValue() > 0f)
+        {
+            return energyValue;
+        }
+
+        return null;
+    }
+}

src/main/java/com/pahimar/ee3/item/EquivalencyStack.java

@@ -0,0 +1,87 @@
+package com.pahimar.ee3.item;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidStack;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class EquivalencyStack
+{
+    private final List<Object> equivalentStacks;
+    private int stackSize;
+
+    public EquivalencyStack()
+    {
+        stackSize = -1;
+        equivalentStacks = new ArrayList<Object>();
+    }
+
+    public EquivalencyStack(Object object)
+    {
+        if (object instanceof Item)
+        {
+            object = new ItemStack((Item) object);
+        }
+        else if (object instanceof Block)
+        {
+            object = new ItemStack((Block) object);
+        }
+        else if (object instanceof Fluid)
+        {
+            object = new FluidStack((Fluid) object, 1000);
+        }
+
+        if (object instanceof ItemStack)
+        {
+            ItemStack copiedItemStack = ((ItemStack) object).copy();
+            this.stackSize = copiedItemStack.stackSize;
+            copiedItemStack.stackSize = 1;
+            equivalentStacks = new ArrayList<Object>();
+            equivalentStacks.add(copiedItemStack);
+        }
+        else if (object instanceof ArrayList)
+        {
+            equivalentStacks = new ArrayList<Object>();
+        }
+        else
+        {
+            stackSize = -1;
+            equivalentStacks = new ArrayList<Object>();
+        }
+    }
+
+    public int getStackSize()
+    {
+        return this.stackSize;
+    }
+
+    public void setStackSize(int stackSize)
+    {
+        this.stackSize = stackSize;
+    }
+
+    public List<Object> getEquivalentStacks()
+    {
+        return this.equivalentStacks;
+    }
+
+    @Override
+    public String toString()
+    {
+        StringBuilder stringBuilder = new StringBuilder();
+        stringBuilder.append("[");
+
+        for (Object object : equivalentStacks)
+        {
+            stringBuilder.append(object.toString() + " ");
+        }
+
+        stringBuilder.append("]");
+
+        return stringBuilder.toString();
+    }
+}

src/main/java/com/pahimar/ee3/network/PacketHandler.java

@@ -0,0 +1,40 @@
+package com.pahimar.ee3.network;
+
+import com.pahimar.ee3.network.message.MessageTileEntity;
+import com.pahimar.ee3.reference.Reference;
+import com.pahimar.ee3.tileentity.TileEntityEE;
+import cpw.mods.fml.client.FMLClientHandler;
+import cpw.mods.fml.common.network.NetworkRegistry;
+import cpw.mods.fml.common.network.simpleimpl.IMessage;
+import cpw.mods.fml.common.network.simpleimpl.IMessageHandler;
+import cpw.mods.fml.common.network.simpleimpl.MessageContext;
+import cpw.mods.fml.common.network.simpleimpl.SimpleNetworkWrapper;
+import cpw.mods.fml.relauncher.Side;
+import net.minecraft.tileentity.TileEntity;
+
+public class PacketHandler
+{
+    public static final SimpleNetworkWrapper INSTANCE = NetworkRegistry.INSTANCE.newSimpleChannel(Reference.MOD_ID.toLowerCase());
+
+    public static void init()
+    {
+        INSTANCE.registerMessage(TileEntityUpdateHandler.class, MessageTileEntity.class, 0, Side.CLIENT);
+    }
+
+    public class TileEntityUpdateHandler implements IMessageHandler<MessageTileEntity, IMessage>
+    {
+        @Override
+        public IMessage onMessage(MessageTileEntity message, MessageContext ctx)
+        {
+            TileEntity tileEntity = FMLClientHandler.instance().getClient().theWorld.getTileEntity(message.x, message.y, message.z);
+
+            if (tileEntity instanceof TileEntityEE)
+            {
+                ((TileEntityEE) tileEntity).setOrientation(message.orientation);
+                ((TileEntityEE) tileEntity).setState(message.state);
+            }
+
+            return null;
+        }
+    }
+}

src/main/java/com/pahimar/ee3/network/message/MessageTileCalcinator.java

@@ -0,0 +1,5 @@
+package com.pahimar.ee3.network.message;
+
+public class MessageTileCalcinator
+{
+}

src/main/java/com/pahimar/ee3/network/message/MessageTileEntity.java

@@ -0,0 +1,45 @@
+package com.pahimar.ee3.network.message;
+
+import com.pahimar.ee3.tileentity.TileEntityEE;
+import cpw.mods.fml.common.network.simpleimpl.IMessage;
+import io.netty.buffer.ByteBuf;
+
+public class MessageTileEntity implements IMessage
+{
+    public int x, y, z;
+    public byte orientation, state;
+    public String customName, owner;
+
+    public MessageTileEntity()
+    {
+    }
+
+    public MessageTileEntity(TileEntityEE tileEntityEE)
+    {
+        this.x = tileEntityEE.xCoord;
+        this.y = tileEntityEE.yCoord;
+        this.z = tileEntityEE.zCoord;
+        this.orientation = (byte) tileEntityEE.getOrientation().ordinal();
+        this.state = (byte) tileEntityEE.getState();
+    }
+
+    @Override
+    public void fromBytes(ByteBuf buf)
+    {
+        this.x = buf.readInt();
+        this.y = buf.readInt();
+        this.z = buf.readInt();
+        this.orientation = buf.readByte();
+        this.state = buf.readByte();
+    }
+
+    @Override
+    public void toBytes(ByteBuf buf)
+    {
+        buf.writeInt(x);
+        buf.writeInt(y);
+        buf.writeInt(z);
+        buf.writeByte(orientation);
+        buf.writeByte(state);
+    }
+}

src/main/java/com/pahimar/ee3/registry/RecipeRegistry.java

@@ -0,0 +1,5 @@
+package com.pahimar.ee3.registry;
+
+public class RecipeRegistry
+{
+}

src/main/java/com/pahimar/ee3/registry/SkillRegistry.java

@@ -0,0 +1,5 @@
+package com.pahimar.ee3.registry;
+
+public class SkillRegistry
+{
+}

src/main/java/com/pahimar/ee3/registry/ValueRegistry.java

@@ -0,0 +1,5 @@
+package com.pahimar.ee3.registry;
+
+public class ValueRegistry
+{
+}

src/main/java/com/pahimar/ee3/tileentity/TileEntityEE.java

@@ -1,7 +1,10 @@
 package com.pahimar.ee3.tileentity;
 
+import com.pahimar.ee3.network.PacketHandler;
+import com.pahimar.ee3.network.message.MessageTileEntity;
 import com.pahimar.ee3.reference.Names;
 import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.network.Packet;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraftforge.common.util.ForgeDirection;
 
@@ -25,16 +28,16 @@ public class TileEntityEE extends TileEntity
         return orientation;
     }
 
-    public void setOrientation(ForgeDirection orientation)
-    {
-        this.orientation = orientation;
-    }
-
     public void setOrientation(int orientation)
     {
         this.orientation = ForgeDirection.getOrientation(orientation);
     }
 
+    public void setOrientation(ForgeDirection orientation)
+    {
+        this.orientation = orientation;
+    }
+
     public short getState()
     {
         return state;
@@ -119,4 +122,10 @@ public class TileEntityEE extends TileEntity
             nbtTagCompound.setString(Names.NBT.OWNER, owner);
         }
     }
+
+    @Override
+    public Packet getDescriptionPacket()
+    {
+        return PacketHandler.INSTANCE.getPacketFrom(new MessageTileEntity(this));
+    }
 }

src/main/java/com/pahimar/ee3/util/LogHelper.java

@@ -8,7 +8,7 @@ public class LogHelper
 {
     public static void log(Level logLevel, Object object)
     {
-        FMLLog.log(Reference.MOD_NAME, logLevel, String.valueOf(object));
+        FMLLog.log(Reference.MOD_NAME, logLevel, "[EE3] " + String.valueOf(object));
     }
 
     public static void all(Object object)