initial commit

java/src/game/entity/attributes/Attribute.java

@@ -0,0 +1,84 @@
+package game.entity.attributes;
+
+import java.util.Map;
+
+import game.ExtMath;
+import game.collect.Maps;
+
+public class Attribute
+{
+	private static final Map<String, Attribute> ATTRIBUTES = Maps.newHashMap();
+	
+    private final String name;
+    private final String display;
+    private final double defValue;
+    private final double minValue;
+    private final double maxValue;
+    private final boolean shouldWatch;
+    
+    public static Attribute getAttribute(String name) {
+    	return ATTRIBUTES.get(name);
+    }
+
+    public Attribute(String name, String display, double def, double min, double max, boolean watch)
+    {
+        this.name = name;
+        this.display = display;
+        this.defValue = def;
+        if(name == null)
+            throw new IllegalArgumentException("Name cannot be null!");
+        this.minValue = min;
+        this.maxValue = max;
+        this.shouldWatch = watch;
+
+        if (min > max)
+        {
+            throw new IllegalArgumentException("Minimum value cannot be bigger than maximum value!");
+        }
+        else if (def < min)
+        {
+            throw new IllegalArgumentException("Default value cannot be lower than minimum value!");
+        }
+        else if (def > max)
+        {
+            throw new IllegalArgumentException("Default value cannot be bigger than maximum value!");
+        }
+        
+        ATTRIBUTES.put(name, this);
+    }
+
+    public String getUnlocalizedName()
+    {
+        return this.name;
+    }
+
+    public String getDisplayName()
+    {
+        return this.display;
+    }
+
+    public double getDefaultValue()
+    {
+        return this.defValue;
+    }
+
+    public boolean getShouldWatch()
+    {
+        return this.shouldWatch;
+    }
+
+    public double clampValue(double value)
+    {
+        return ExtMath.clampd(value, this.minValue, this.maxValue);
+    }
+
+    public int hashCode()
+    {
+        return this.name.hashCode();
+    }
+
+    public boolean equals(Object obj)
+    {
+        return obj instanceof Attribute && this.name.equals(((Attribute)obj).getUnlocalizedName());
+    }
+}

java/src/game/entity/attributes/AttributeInstance.java

@@ -0,0 +1,191 @@
+package game.entity.attributes;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+
+import game.collect.Lists;
+import game.collect.Maps;
+import game.collect.Sets;
+
+public class AttributeInstance
+{
+    private final AttributeMap attributeMap;
+    private final Attribute genericAttribute;
+    private final Set<AttributeModifier> additions = Sets.<AttributeModifier>newHashSet();
+    private final Set<AttributeModifier> multipliers = Sets.<AttributeModifier>newHashSet();
+    private final Map<String, Set<AttributeModifier>> mapByName = Maps.<String, Set<AttributeModifier>>newHashMap();
+    private final Map<Long, AttributeModifier> mapByID = Maps.<Long, AttributeModifier>newHashMap();
+    private double baseValue;
+    private boolean needsUpdate = true;
+    private double cachedValue;
+
+    public AttributeInstance(AttributeMap attributeMapIn, Attribute genericAttributeIn)
+    {
+        this.attributeMap = attributeMapIn;
+        this.genericAttribute = genericAttributeIn;
+        this.baseValue = genericAttributeIn.getDefaultValue();
+    }
+
+    public Attribute getAttribute()
+    {
+        return this.genericAttribute;
+    }
+
+    public double getBaseValue()
+    {
+        return this.baseValue;
+    }
+
+    public void setBaseValue(double baseValue)
+    {
+        if (baseValue != this.getBaseValue())
+        {
+            this.baseValue = baseValue;
+            this.flagForUpdate();
+        }
+    }
+
+//    public Collection<AttributeModifier> getModifiersByOperation(AttributeOp operation)
+//    {
+//        return (Collection)this.mapByOperation.get(operation);
+//    }
+
+    public Collection<AttributeModifier> func_111122_c()
+    {
+        Set<AttributeModifier> set = Sets.<AttributeModifier>newHashSet();
+
+//        for (AttributeOp op : AttributeOp.values())
+//        {
+//            set.addAll(this.getModifiersByOperation(op));
+//        }
+        set.addAll(this.additions);
+        set.addAll(this.multipliers);
+
+        return set;
+    }
+
+    public AttributeModifier getModifier(long id)
+    {
+        return (AttributeModifier)this.mapByID.get(id);
+    }
+
+    public boolean hasModifier(AttributeModifier modifier)
+    {
+        return this.mapByID.get(modifier.getID()) != null;
+    }
+
+    public void applyModifier(AttributeModifier modifier)
+    {
+        if (this.getModifier(modifier.getID()) != null)
+        {
+            throw new IllegalArgumentException("Modifier is already applied on this attribute!");
+        }
+        else
+        {
+            Set<AttributeModifier> set = (Set)this.mapByName.get(modifier.getName());
+
+            if (set == null)
+            {
+                set = Sets.<AttributeModifier>newHashSet();
+                this.mapByName.put(modifier.getName(), set);
+            }
+
+            (modifier.isMultiplied() ? this.multipliers : this.additions).add(modifier);
+            set.add(modifier);
+            this.mapByID.put(modifier.getID(), modifier);
+            this.flagForUpdate();
+        }
+    }
+
+    protected void flagForUpdate()
+    {
+        this.needsUpdate = true;
+        this.attributeMap.flagDirty(this);
+    }
+
+    public void removeModifier(AttributeModifier modifier)
+    {
+//        for (AttributeOp op : AttributeOp.values())
+//        {
+//            Set<AttributeModifier> set = (Set)this.mapByOperation.get(op);
+//            set.remove(modifier);
+//        }
+        this.additions.remove(modifier);
+        this.multipliers.remove(modifier);
+
+        Set<AttributeModifier> set1 = (Set)this.mapByName.get(modifier.getName());
+
+        if (set1 != null)
+        {
+            set1.remove(modifier);
+
+            if (set1.isEmpty())
+            {
+                this.mapByName.remove(modifier.getName());
+            }
+        }
+
+        this.mapByID.remove(modifier.getID());
+        this.flagForUpdate();
+    }
+
+    public void removeAllModifiers()
+    {
+        Collection<AttributeModifier> collection = this.func_111122_c();
+
+        if (collection != null)
+        {
+            for (AttributeModifier attributemodifier : Lists.newArrayList(collection))
+            {
+                this.removeModifier(attributemodifier);
+            }
+        }
+    }
+
+    public double getAttributeValue()
+    {
+        if (this.needsUpdate)
+        {
+            this.cachedValue = this.computeValue();
+            this.needsUpdate = false;
+        }
+
+        return this.cachedValue;
+    }
+
+    private double computeValue()
+    {
+        double base = this.getBaseValue();
+
+        for (AttributeModifier attributemodifier : this.additions)
+        {
+            base += attributemodifier.getAmount();
+        }
+
+        for (AttributeModifier attributemodifier2 : this.multipliers)
+        {
+        	base *= 1.0D + attributemodifier2.getAmount();
+        }
+
+        return this.genericAttribute.clampValue(base);
+    }
+
+//    private Collection<AttributeModifier> getModifierList(AttributeOp operation)
+//    {
+//        // Set<AttributeModifier> set = 
+//        return Sets.newHashSet(this.getModifiersByOperation(operation));
+//
+////        for (BaseAttribute iattribute = this.genericAttribute.func_180372_d(); iattribute != null; iattribute = iattribute.func_180372_d())
+////        {
+////            ModifiableAttributeInstance iattributeinstance = this.attributeMap.getAttributeInstance(iattribute);
+////
+////            if (iattributeinstance != null)
+////            {
+////                set.addAll(iattributeinstance.getModifiersByOperation(operation));
+////            }
+////        }
+//
+//        // return set;
+//    }
+}

java/src/game/entity/attributes/AttributeMap.java

@@ -0,0 +1,161 @@
+package game.entity.attributes;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import game.collect.Maps;
+import game.collect.Sets;
+
+public class AttributeMap
+{
+    protected final Map<Attribute, AttributeInstance> attributes = Maps.<Attribute, AttributeInstance>newHashMap();
+    protected final Map<String, AttributeInstance> nameMap = new LowerStringMap();
+    private final Set<AttributeInstance> dirtyAttributes;
+    
+    public AttributeMap(boolean client) {
+    	this.dirtyAttributes = client ? null : Sets.<AttributeInstance>newHashSet();
+    }
+
+    public AttributeInstance getAttributeInstance(Attribute attribute)
+    {
+        return (AttributeInstance)this.attributes.get(attribute);
+    }
+
+    public AttributeInstance getAttributeInstanceByName(String attributeName)
+    {
+//    	AttributeInstance iattributeinstance = 
+    	return (AttributeInstance)this.nameMap.get(attributeName);
+
+//        if (iattributeinstance == null)
+//        {
+//            iattributeinstance = (AttributeInstance)this.descMap.get(attributeName);
+//        }
+//
+//        return (AttributeInstance)iattributeinstance;
+    }
+
+    public AttributeInstance registerAttribute(Attribute attribute)
+    {
+        if(this.nameMap.containsKey(attribute.getUnlocalizedName()))
+            throw new IllegalArgumentException("Attribute is already registered!");
+        AttributeInstance inst = new AttributeInstance(this, attribute);
+        this.nameMap.put(attribute.getUnlocalizedName(), inst);
+        this.attributes.put(attribute, inst);
+//            for (BaseAttribute iattribute = attribute.func_180372_d(); iattribute != null; iattribute = iattribute.func_180372_d())
+//            {
+//                this.field_180377_c.put(iattribute, attribute);
+//            }
+//        if(attribute.getDescription() != null)
+//            this.descMap.put(attribute.getDescription(), inst);
+        return inst;
+    }
+
+    public Collection<AttributeInstance> getAllAttributes()
+    {
+        return this.nameMap.values();
+    }
+
+    public void flagDirty(AttributeInstance instance)
+    {
+        if (this.dirtyAttributes != null && instance.getAttribute().getShouldWatch())
+        {
+            this.dirtyAttributes.add(instance);
+        }
+
+//        for (BaseAttribute iattribute : this.field_180377_c.get(instance.getAttribute()))
+//        {
+//            ModifiableAttributeInstance modifiableattributeinstance = this.getAttributeInstance(iattribute);
+//
+//            if (modifiableattributeinstance != null)
+//            {
+//                modifiableattributeinstance.flagForUpdate();
+//            }
+//        }
+    }
+
+    public Set<AttributeInstance> getDirty()
+    {
+        return this.dirtyAttributes;
+    }
+
+    public Collection<AttributeInstance> getWatchedAttributes()
+    {
+        Set<AttributeInstance> set = Sets.<AttributeInstance>newHashSet();
+
+        for (AttributeInstance iattributeinstance : this.getAllAttributes())
+        {
+            if (iattributeinstance.getAttribute().getShouldWatch())
+            {
+                set.add(iattributeinstance);
+            }
+        }
+
+        return set;
+    }
+
+    public void removeAttributeModifiers(Map<Attribute, Set<AttributeModifier>> modifiers)
+    {
+        for (Entry<Attribute, Set<AttributeModifier>> entry : modifiers.entrySet())
+        {
+            AttributeInstance iattributeinstance = this.getAttributeInstanceByName(entry.getKey().getUnlocalizedName());
+
+            if (iattributeinstance != null)
+            {
+            	for(AttributeModifier mod : entry.getValue()) {
+            		iattributeinstance.removeModifier(mod);
+            	}
+            }
+        }
+    }
+
+    public void applyAttributeModifiers(Map<Attribute, Set<AttributeModifier>> modifiers)
+    {
+        for (Entry<Attribute, Set<AttributeModifier>> entry : modifiers.entrySet())
+        {
+            AttributeInstance iattributeinstance = this.getAttributeInstanceByName(entry.getKey().getUnlocalizedName());
+
+            if (iattributeinstance != null)
+            {
+            	for(AttributeModifier mod : entry.getValue()) {
+	                iattributeinstance.removeModifier(mod);
+	                iattributeinstance.applyModifier(mod);
+            	}
+            }
+        }
+    }
+
+    public void removeAttributeModifiers(Map<Attribute, Set<AttributeModifier>> modifiers, int slot, int amount)
+    {
+        for (Entry<Attribute, Set<AttributeModifier>> entry : modifiers.entrySet())
+        {
+            AttributeInstance iattributeinstance = this.getAttributeInstanceByName(entry.getKey().getUnlocalizedName());
+
+            if (iattributeinstance != null)
+            {
+            	for(AttributeModifier mod : entry.getValue()) {
+	            	AttributeModifier nmod = new AttributeModifier(mod, slot+1, amount);
+	                iattributeinstance.removeModifier(nmod);
+            	}
+            }
+        }
+    }
+
+    public void applyAttributeModifiers(Map<Attribute, Set<AttributeModifier>> modifiers, int slot, int amount)
+    {
+        for (Entry<Attribute, Set<AttributeModifier>> entry : modifiers.entrySet())
+        {
+            AttributeInstance iattributeinstance = this.getAttributeInstanceByName(entry.getKey().getUnlocalizedName());
+
+            if (iattributeinstance != null)
+            {
+            	for(AttributeModifier mod : entry.getValue()) {
+	            	AttributeModifier nmod = new AttributeModifier(mod, slot+1, amount);
+	                iattributeinstance.removeModifier(nmod);
+	                iattributeinstance.applyModifier(nmod);
+            	}
+            }
+        }
+    }
+}

java/src/game/entity/attributes/AttributeModifier.java

@@ -0,0 +1,134 @@
+package game.entity.attributes;
+
+import game.rng.Random;
+
+public class AttributeModifier
+{
+    private final double amount;
+    private final boolean multiply;
+    private final String name;
+    private final long id;
+    private final boolean isSaved;
+    private final boolean inventory;
+    
+    public static long getModifierId(String name) {
+    	if(name.length() > 7)
+    		throw new IllegalArgumentException("Name darf höchstens 7 Zeichen enthalten");
+    	long id = '@';
+    	for(int z = 0; z < name.length(); z++) {
+    		id <<= 8;
+    		char c = name.charAt(z);
+    		if(c > 0xff)
+    			throw new IllegalArgumentException("Name darf keine 16-Bit-Zeichen enthalten");
+    		id |= (long)c;
+    	}
+//    	Log.CONFIG.debug(String.format("Modifikator '%s' -> 0x%016x", name, id));
+    	return id;
+    }
+
+    public AttributeModifier(String nameIn, double amountIn, boolean multiplyIn)
+    {
+        this(new Random().longv() | 0x8000000000000000L, nameIn, amountIn, multiplyIn, true, false);
+    }
+    
+    public AttributeModifier(long idIn, String nameIn, double amountIn, boolean multiplyIn) {
+    	this(idIn, nameIn, amountIn, multiplyIn, true, false);
+    }
+    
+    public AttributeModifier(long idIn, String nameIn, double amountIn, boolean multiplyIn, boolean saved) {
+    	this(idIn, nameIn, amountIn, multiplyIn, saved, false);
+    }
+
+    public AttributeModifier(long idIn, String nameIn, double amountIn, boolean multiplyIn, boolean saved, boolean inv)
+    {
+        this.isSaved = saved;
+        this.inventory = inv;
+        this.id = idIn;
+        this.name = nameIn;
+        this.amount = amountIn;
+        this.multiply = multiplyIn;
+        if (nameIn == null) {
+			throw new NullPointerException("Modifier name cannot be empty");
+		}
+        else if (nameIn.length() == 0) {
+			throw new IllegalArgumentException("Modifier name cannot be empty");
+		}
+//        else if (operationIn == null) {
+//			throw new IllegalArgumentException("Invalid operation");
+//		}
+    }
+
+    public AttributeModifier(AttributeModifier attr, int slot, int amount) {
+    	this(attr.id + (long)slot, attr.name, attr.amount * (double)amount, attr.multiply, attr.isSaved);
+    }
+
+    public long getID()
+    {
+        return this.id;
+    }
+
+    public String getName()
+    {
+        return this.name;
+    }
+
+    public boolean isMultiplied()
+    {
+        return this.multiply;
+    }
+
+    public double getAmount()
+    {
+        return this.amount;
+    }
+
+    public boolean isSaved()
+    {
+        return this.isSaved;
+    }
+
+    public boolean isInventory()
+    {
+        return this.inventory;
+    }
+
+    public boolean equals(Object obj)
+    {
+        if (this == obj)
+        {
+            return true;
+        }
+        else if (obj != null && this.getClass() == obj.getClass())
+        {
+            AttributeModifier attributemodifier = (AttributeModifier)obj;
+
+            if (this.id != 0L)
+            {
+                if (this.id != attributemodifier.id)
+                {
+                    return false;
+                }
+            }
+            else if (attributemodifier.id != 0L)
+            {
+                return false;
+            }
+
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    }
+
+    public int hashCode()
+    {
+        return this.id != 0L ? Long.hashCode(this.id) : 0;
+    }
+
+    public String toString()
+    {
+        return "AttributeModifier{amount=" + this.amount + ", multiply=" + this.multiply + ", name=\'" + this.name + '\'' + ", id=" + this.id + ", serialize=" + this.isSaved + '}';
+    }
+}

java/src/game/entity/attributes/Attributes.java

@@ -0,0 +1,161 @@
+package game.entity.attributes;
+
+import java.util.Collection;
+
+import game.Log;
+import game.nbt.NBTTagCompound;
+import game.nbt.NBTTagList;
+
+public class Attributes
+{
+    public static final Attribute MAX_HEALTH = (new Attribute("generic.maxHealth", "Maximale Gesundheit", 20.0D, 0.0D, 1024.0D, true));
+    public static final Attribute FOLLOW_RANGE = (new Attribute("generic.followRange", "Kreaturen-Folgedistanz", 32.0D, 0.0D, 2048.0D, false));
+    public static final Attribute KNOCKBACK_RESISTANCE = (new Attribute("generic.knockbackResistance", "Standfestigkeit", 0.0D, 0.0D, 1.0D, false));
+    public static final Attribute MOVEMENT_SPEED = (new Attribute("generic.movementSpeed", "Geschwindigkeit", 0.699999988079071D, 0.0D, 1024.0D, true));
+    public static final Attribute ATTACK_DAMAGE = new Attribute("generic.attackDamage", "Angriffsschaden", 2.0D, 0.0D, 2048.0D, false);
+    public static final Attribute RADIATION = new Attribute("generic.radiation", "Strahlung", 0.0D, 0.0D, 16384.0D, false);
+    public static final Attribute RADIATION_RESISTANCE = new Attribute("generic.radiationResistance", "Strahlungsresistenz", 10.0D, 0.0D, 16384.0D, false);
+    public static final Attribute MANA_CAPACITY = new Attribute("generic.manaCapacity", "Mana-Kapazität", 0.0D, 0.0D, 2048.0D, false);
+    public static final Attribute MAGIC_RESISTANCE = new Attribute("generic.magicResistance", "Magieresistenz", 0.0D, 0.0D, 4096.0D, false);
+	public static final Attribute REINFORCEMENT_CHANCE = (new Attribute("zombie.spawnReinforcements", "Zombie-Verstärkung", 0.0D, 0.0D, 1.0D, false));
+	public static final Attribute HORSE_JUMP_STRENGTH = (new Attribute("horse.jumpStrength", "Pferdesprungstärke", 0.7D, 0.0D, 2.0D, true));
+
+//	public static final long ATTACK_SPEED_ID = AttributeModifier.getModifierId("EnderSp");
+//	public static final AttributeModifier ATTACK_SPEED_MOD = (new AttributeModifier(ATTACK_SPEED_ID, "Attacking speed boost", 0.15000000596046448D, false, false));
+	public static final long RUSHING_SPEED_ID = AttributeModifier.getModifierId("RushSpd");
+	public static final AttributeModifier RUSHING_SPEED_MOD = (new AttributeModifier(RUSHING_SPEED_ID, "Attacking speed boost", 0.05D, false, false));
+	public static final long MAGE_POTSPEED_ID = AttributeModifier.getModifierId("MagePot");
+	public static final AttributeModifier MAGE_POTSPEED_MOD = (new AttributeModifier(MAGE_POTSPEED_ID, "Drinking speed penalty", -0.25D, false, false));
+	public static final long ZOMBIE_BABY_ID = AttributeModifier.getModifierId("ZombSpd");
+	public static final AttributeModifier ZOMBIE_BABY_MOD = new AttributeModifier(ZOMBIE_BABY_ID, "Baby speed boost", 0.5D, true);
+	public static final long FLEEING_SPEED_ID = AttributeModifier.getModifierId("FleeSpd");
+	public static final AttributeModifier FLEEING_SPEED_MOD = (new AttributeModifier(FLEEING_SPEED_ID, "Fleeing speed bonus", 2.0D, true, false));
+	public static final long SPRINT_SPEED_ID = AttributeModifier.getModifierId("Sprint");
+	public static final AttributeModifier SPRINT_SPEED_MOD = (new AttributeModifier(SPRINT_SPEED_ID, "Sprinting speed boost", 0.30000001192092896D, true, false));
+	public static final long ITEM_VAL_ID = AttributeModifier.getModifierId("ItemVal");
+	public static final long RADIATION_BASE = AttributeModifier.getModifierId("NukeVal");
+	public static final long MOUSE_SPEEDY_ID = AttributeModifier.getModifierId("SpeedyG");
+	public static final AttributeModifier MOUSE_SPEEDY_MOD = new AttributeModifier(MOUSE_SPEEDY_ID, "Mouse speed boost", 1.0D, true);
+
+    /**
+     * Creates an NBTTagList from a BaseAttributeMap, including all its AttributeInstances
+     */
+    public static NBTTagList writeBaseAttributeMapToNBT(AttributeMap map)
+    {
+        NBTTagList nbttaglist = new NBTTagList();
+
+        for (AttributeInstance iattributeinstance : map.getAllAttributes())
+        {
+            nbttaglist.appendTag(writeAttributeInstanceToNBT(iattributeinstance));
+        }
+
+        return nbttaglist;
+    }
+
+    /**
+     * Creates an NBTTagCompound from an AttributeInstance, including its AttributeModifiers
+     */
+    private static NBTTagCompound writeAttributeInstanceToNBT(AttributeInstance instance)
+    {
+        NBTTagCompound nbttagcompound = new NBTTagCompound();
+        Attribute iattribute = instance.getAttribute();
+        nbttagcompound.setString("Name", iattribute.getUnlocalizedName());
+        nbttagcompound.setDouble("Base", instance.getBaseValue());
+        Collection<AttributeModifier> collection = instance.func_111122_c();
+
+        if (collection != null && !collection.isEmpty())
+        {
+            NBTTagList nbttaglist = new NBTTagList();
+
+            for (AttributeModifier attributemodifier : collection)
+            {
+                if (attributemodifier.isSaved())
+                {
+                    nbttaglist.appendTag(writeAttributeModifierToNBT(attributemodifier));
+                }
+            }
+
+            nbttagcompound.setTag("Modifiers", nbttaglist);
+        }
+
+        return nbttagcompound;
+    }
+
+    /**
+     * Creates an NBTTagCompound from an AttributeModifier
+     */
+    private static NBTTagCompound writeAttributeModifierToNBT(AttributeModifier modifier)
+    {
+        NBTTagCompound nbttagcompound = new NBTTagCompound();
+        nbttagcompound.setString("Name", modifier.getName());
+        nbttagcompound.setDouble("Amount", modifier.getAmount());
+        nbttagcompound.setBoolean("Multiply", modifier.isMultiplied());
+        nbttagcompound.setLong("AttrId", modifier.getID());
+        return nbttagcompound;
+    }
+
+    public static void setAttributeModifiers(AttributeMap map, NBTTagList list)
+    {
+        for (int i = 0; i < list.tagCount(); ++i)
+        {
+            NBTTagCompound nbttagcompound = list.getCompoundTagAt(i);
+            AttributeInstance iattributeinstance = map.getAttributeInstanceByName(nbttagcompound.getString("Name"));
+
+            if (iattributeinstance != null)
+            {
+                applyModifiersToAttributeInstance(iattributeinstance, nbttagcompound);
+            }
+            else
+            {
+            	Log.JNI.warn("Ignoriere unbekannte Attribute \'" + nbttagcompound.getString("Name") + "\'");
+            }
+        }
+    }
+
+    private static void applyModifiersToAttributeInstance(AttributeInstance instance, NBTTagCompound compound)
+    {
+        instance.setBaseValue(compound.getDouble("Base"));
+
+        if (compound.hasKey("Modifiers", 9))
+        {
+            NBTTagList nbttaglist = compound.getTagList("Modifiers", 10);
+
+            for (int i = 0; i < nbttaglist.tagCount(); ++i)
+            {
+                AttributeModifier attributemodifier = readAttributeModifierFromNBT(nbttaglist.getCompoundTagAt(i));
+
+                if (attributemodifier != null)
+                {
+                    AttributeModifier attributemodifier1 = instance.getModifier(attributemodifier.getID());
+
+                    if (attributemodifier1 != null)
+                    {
+                        instance.removeModifier(attributemodifier1);
+                    }
+
+                    instance.applyModifier(attributemodifier);
+                }
+            }
+        }
+    }
+
+    /**
+     * Creates an AttributeModifier from an NBTTagCompound
+     */
+    public static AttributeModifier readAttributeModifierFromNBT(NBTTagCompound compound)
+    {
+        long id = compound.getLong("AttrId");
+        if(id == 0L)
+        	return null;
+
+        try
+        {
+            return new AttributeModifier(id, compound.getString("Name"), compound.getDouble("Amount"), compound.getBoolean("Multiply"));
+        }
+        catch (Exception exception)
+        {
+        	Log.JNI.warn("Konnte Attribute nicht erstellen: " + exception.getMessage());
+            return null;
+        }
+    }
+}

java/src/game/entity/attributes/LowerStringMap.java

@@ -0,0 +1,75 @@
+package game.entity.attributes;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+
+import game.collect.Maps;
+
+public class LowerStringMap<V> implements Map<String, V>
+{
+    private final Map<String, V> internalMap = Maps.<String, V>newLinkedHashMap();
+
+    public int size()
+    {
+        return this.internalMap.size();
+    }
+
+    public boolean isEmpty()
+    {
+        return this.internalMap.isEmpty();
+    }
+
+    public boolean containsKey(Object p_containsKey_1_)
+    {
+        return this.internalMap.containsKey(p_containsKey_1_.toString().toLowerCase());
+    }
+
+    public boolean containsValue(Object p_containsValue_1_)
+    {
+        return this.internalMap.containsKey(p_containsValue_1_);
+    }
+
+    public V get(Object p_get_1_)
+    {
+        return this.internalMap.get(p_get_1_.toString().toLowerCase());
+    }
+
+    public V put(String p_put_1_, V p_put_2_)
+    {
+        return this.internalMap.put(p_put_1_.toLowerCase(), p_put_2_);
+    }
+
+    public V remove(Object p_remove_1_)
+    {
+        return this.internalMap.remove(p_remove_1_.toString().toLowerCase());
+    }
+
+    public void putAll(Map <? extends String, ? extends V > p_putAll_1_)
+    {
+        for (Entry <? extends String, ? extends V > entry : p_putAll_1_.entrySet())
+        {
+            this.put((String)entry.getKey(), entry.getValue());
+        }
+    }
+
+    public void clear()
+    {
+        this.internalMap.clear();
+    }
+
+    public Set<String> keySet()
+    {
+        return this.internalMap.keySet();
+    }
+
+    public Collection<V> values()
+    {
+        return this.internalMap.values();
+    }
+
+    public Set<Entry<String, V>> entrySet()
+    {
+        return this.internalMap.entrySet();
+    }
+}