Bugfixes, magic defense system (item stack binding, calculation, ...)

build.gradle

@@ -22,7 +22,7 @@ compileJava {
 }
 
 minecraft {
-    version = "1.12-14.21.1.2428"
+    version = "1.12.1-14.22.0.2467"
     runDir = "run"
     
     // the mappings can be changed at any time, and must be in the following format.

src/main/java/me/km/KajetansMod.java

@@ -1,15 +1,18 @@
 package me.km;
 
+import me.km.capabilities.CapabilitiesEvents;
 import me.km.api.Module;
 import me.km.api.SimpleConfig;
 import me.km.api.CommandOverloader;
 import me.km.blockprotections.BlockProtectionBank;
 import me.km.blocks.BlockEvents;
+import me.km.capabilities.DamageUtils;
 import me.km.chatmanager.ChatManager;
 import me.km.databank.DataBank;
 import me.km.dimensions.ModWorldGeneration;
 import me.km.dimensions.WorldData;
 import me.km.effects.EffectUtils;
+import me.km.effects.passive.EntityDamageEffects;
 import me.km.events.CustomEventCaller;
 import me.km.fluids.ModFluids;
 import me.km.jobsystem.JobAPI;
@@ -70,7 +73,7 @@ public class KajetansMod
 
     public static final String MODID = "km";
     public static final String NAME = "Kajetans Mod";
-    public static final String VERSION = "0.0.9";
+    public static final String VERSION = "0.0.10";
 
     @Mod.Instance(MODID)
     public static KajetansMod instance;
@@ -91,6 +94,10 @@ public class KajetansMod
         System.out.println(NAME + " is loading!");
         ModFluids.init();
         GameRegistry.registerWorldGenerator(new ModWorldGeneration(), 3);
+        
+        DamageUtils.init();
+        CapabilitiesEvents.init();
+        MinecraftForge.EVENT_BUS.register(new CapabilitiesEvents());
     }
     
     @Mod.EventHandler
@@ -120,6 +127,25 @@ public class KajetansMod
         event = e;
         if(singlePlayer)
         {
+            /*perms = new PermissionManager("Permissions", "Perms", TextFormatting.DARK_PURPLE);
+            perms.registerEvents("me.km.permissions");
+            
+            scheduler = new SnuviScheduler("Scheduler", "Scheduler", TextFormatting.GREEN);
+            scheduler.registerEvents("me.km.scheduler");
+            
+            generalCommands = new Module("GeneralCommands", "Commands", TextFormatting.GOLD);
+            generalCommands.registerCommands(e, "me.km.commands");
+            
+            worldManager = new WorldData("WorldManager", "Worlds", TextFormatting.RED);
+            worldManager.registerCommands(e, "me.km.dimensions");          
+            worldManager.registerEvents("me.km.dimensions");
+            
+            effects = new EffectUtils("Effects", "Effects", TextFormatting.BLUE);
+            effects.registerCommands(e, "me.km.effects"); 
+            //effects.registerEvents("me.km.effects.passive"); 
+            MinecraftForge.EVENT_BUS.register(new EntityDamageEffects(effects));
+            
+            debugMode = true;*/
             return;
         }
         // Konfiguration und Error-Dummy

src/main/java/me/km/api/Utils.java

@@ -51,6 +51,7 @@ import net.minecraft.item.ItemStack;
 import net.minecraft.item.ItemSword; 
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.nbt.NBTUtil;
+import net.minecraft.network.play.server.SPacketEntityVelocity;
 import net.minecraft.tileentity.TileEntitySkull;
 import net.minecraft.util.CombatRules;
 import net.minecraft.util.DamageSource;
@@ -95,6 +96,7 @@ public class Utils
         ent.motionX = x;
         ent.motionY = y;
         ent.motionZ = z;
+        updateVelocity(ent);
     }
     
     public static void addVelocity(Entity ent, double x, double y, double z)
@@ -102,6 +104,17 @@ public class Utils
         ent.motionX += x;
         ent.motionY += y;
         ent.motionZ += z;
+        updateVelocity(ent);
+    }
+    
+    private static void updateVelocity(Entity ent)
+    {
+        if(ent instanceof EntityPlayerMP)
+        {
+            EntityPlayerMP p = (EntityPlayerMP) ent;
+            SPacketEntityVelocity packet = new SPacketEntityVelocity(p);
+            p.connection.sendPacket(packet);
+        }
     }
     
     public static void scaleVelocity(Entity ent, double scale)

src/main/java/me/km/capabilities/CapabilitiesEvents.java

@@ -0,0 +1,58 @@
+package me.km.capabilities;
+
+import java.util.List;
+import me.km.KajetansMod;
+import net.minecraft.item.ItemArmor;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraftforge.common.capabilities.CapabilityManager;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.event.AttachCapabilitiesEvent;
+import net.minecraftforge.event.entity.player.ItemTooltipEvent;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+public class CapabilitiesEvents 
+{
+    public static final ResourceLocation DEFENSE_CAP = new ResourceLocation(KajetansMod.MODID, "defense");
+    
+    public static void init()
+    {
+        CapabilityManager.INSTANCE.register(IDefense.class, new DefenseStorage(), ItemDefenseStats.class);
+    }
+    
+    @SubscribeEvent
+    public void attachDefenseData(AttachCapabilitiesEvent<ItemStack> e) 
+    {
+        if(e.getObject().getItem() instanceof ItemArmor)
+        {
+            e.addCapability(DEFENSE_CAP, new DefenseProvider());
+        }
+    }
+    
+    @SideOnly(Side.CLIENT)
+    @SubscribeEvent
+    public void showingTooltip(ItemTooltipEvent e) 
+    {
+        ItemStack stack = e.getItemStack();
+        if(stack.hasCapability(DefenseProvider.DEFENSE_CAP, null))
+        {
+            IDefense defense = stack.getCapability(DefenseProvider.DEFENSE_CAP, null);
+            int magic = defense.getMagicDefense();
+            if(magic != 0)
+            {
+                List<String> list = e.getToolTip();
+                String s = TextFormatting.BLUE + " +";
+                for(int i = 0; i < list.size(); i++)
+                {
+                    if(list.get(i).startsWith(s))
+                    {
+                        list.add(i, TextFormatting.BLUE + " +" + magic + " Magic Armor");
+                        break;
+                    }
+                }
+            }
+        }
+    }
+}

src/main/java/me/km/capabilities/DamageUtils.java

@@ -0,0 +1,39 @@
+package me.km.capabilities;
+
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.EnumFacing;
+
+public class DamageUtils 
+{
+    public static void init()
+    {
+        DamageSource.IN_FIRE.setMagicDamage();
+        DamageSource.LIGHTNING_BOLT.setMagicDamage();
+        DamageSource.ON_FIRE.setMagicDamage();
+        DamageSource.HOT_FLOOR.setMagicDamage();
+        DamageSource.WITHER.setMagicDamage();
+        DamageSource.DRAGON_BREATH.setMagicDamage();
+        
+        // Special
+        DamageSource.LAVA.setDamageBypassesArmor().setDamageIsAbsolute();
+        DamageSource.IN_WALL.setDamageIsAbsolute();
+        DamageSource.CRAMMING.setDamageIsAbsolute();
+        DamageSource.DROWN.setDamageIsAbsolute();
+        DamageSource.GENERIC.setDamageIsAbsolute();
+    }
+    
+    public static int getMagicDefense(EntityLivingBase liv)
+    {
+        int level = 0;
+        for(ItemStack stack : liv.getArmorInventoryList())
+        {
+            if(stack.hasCapability(DefenseProvider.DEFENSE_CAP, null))
+            {
+                level += stack.getCapability(DefenseProvider.DEFENSE_CAP, null).getMagicDefense();
+            }
+        }
+        return level;
+    }
+}

src/main/java/me/km/capabilities/DefenseProvider.java

@@ -0,0 +1,39 @@
+package me.km.capabilities;
+
+import net.minecraft.nbt.NBTBase;
+import net.minecraft.util.EnumFacing;
+import net.minecraftforge.common.capabilities.Capability;
+import net.minecraftforge.common.capabilities.CapabilityInject;
+import net.minecraftforge.common.capabilities.ICapabilitySerializable;
+
+public class DefenseProvider implements ICapabilitySerializable<NBTBase>
+{
+    @CapabilityInject(IDefense.class)
+    public static final Capability<IDefense> DEFENSE_CAP = null;
+
+    private final IDefense instance = DEFENSE_CAP.getDefaultInstance();
+
+    @Override
+    public boolean hasCapability(Capability<?> capability, EnumFacing facing)
+    {
+        return capability == DEFENSE_CAP;
+    }
+
+    @Override
+    public <T> T getCapability(Capability<T> capability, EnumFacing facing)
+    {
+        return capability == DEFENSE_CAP ? DEFENSE_CAP.<T>cast(this.instance) : null;
+    }
+
+    @Override
+    public NBTBase serializeNBT()
+    {
+        return DEFENSE_CAP.getStorage().writeNBT(DEFENSE_CAP, this.instance, null);
+    }
+
+    @Override
+    public void deserializeNBT(NBTBase nbt)
+    {
+        DEFENSE_CAP.getStorage().readNBT(DEFENSE_CAP, this.instance, null, nbt);
+    }
+}

src/main/java/me/km/capabilities/DefenseStorage.java

@@ -0,0 +1,23 @@
+package me.km.capabilities;
+
+import net.minecraft.nbt.NBTBase;
+import net.minecraft.nbt.NBTPrimitive;
+import net.minecraft.nbt.NBTTagInt;
+import net.minecraft.util.EnumFacing;
+import net.minecraftforge.common.capabilities.Capability;
+import net.minecraftforge.common.capabilities.Capability.IStorage;
+
+public class DefenseStorage implements IStorage<IDefense>
+{
+    @Override
+    public NBTBase writeNBT(Capability<IDefense> capability, IDefense instance, EnumFacing side) 
+    {
+        return new NBTTagInt(instance.getMagicDefense());
+    }
+
+    @Override
+    public void readNBT(Capability<IDefense> capability, IDefense instance, EnumFacing side, NBTBase nbt) 
+    {
+        instance.setMagicDefense(((NBTPrimitive) nbt).getInt());
+    }
+}

src/main/java/me/km/capabilities/IDefense.java

@@ -0,0 +1,7 @@
+package me.km.capabilities;
+
+public interface IDefense 
+{
+    public int getMagicDefense();
+    public void setMagicDefense(int magicDefense);
+}

src/main/java/me/km/capabilities/ItemDefenseStats.java

@@ -0,0 +1,23 @@
+package me.km.capabilities;
+
+public class ItemDefenseStats implements IDefense
+{
+    private int magicDefense;
+    
+    public ItemDefenseStats()
+    {
+        this.magicDefense = 0;
+    }
+
+    @Override
+    public int getMagicDefense() 
+    {
+        return magicDefense;
+    }
+
+    @Override
+    public void setMagicDefense(int magicDefense) 
+    {
+        this.magicDefense = magicDefense;
+    }
+}

src/main/java/me/km/commands/CommandTest.java

@@ -1,16 +1,17 @@
 package me.km.commands;
 
-import me.km.KajetansMod;
 import me.km.api.GlobalText;
 import me.km.api.Module;
 import me.km.api.ModuleCommand;
-import me.km.api.Utils;
-import me.km.exception.PlayerNotFoundException;
+import me.km.capabilities.CapabilitiesEvents;
+import me.km.capabilities.DefenseProvider;
+import me.km.capabilities.IDefense;
 import me.km.permissions.Permissions;
 import net.minecraft.command.ICommandSender;
-import net.minecraft.entity.player.EntityPlayerMP;
-import net.minecraft.network.play.server.SPacketRespawn;
-import net.minecraft.world.WorldServer;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.text.TextComponentString;
 
 public class CommandTest extends ModuleCommand
 {
@@ -25,27 +26,35 @@ public class CommandTest extends ModuleCommand
     @Override
     public boolean execute(ICommandSender cs, String[] arg) 
     {
-        /*if(!(cs instanceof EntityPlayer))
+        if(!(cs instanceof EntityPlayer))
         {
             this.getModule().send(cs, GlobalText.onlyPlayer());
             return true;
-        }*/
-        if(arg.length < 1)
-        {
-            return true;
         }
-        EntityPlayerMP p;
-        try
+        EntityPlayer p = (EntityPlayer) cs; 
+        ItemStack stack = p.getHeldItemMainhand();
+        if(stack.hasCapability(DefenseProvider.DEFENSE_CAP, null))
         {
-            p = Utils.getPlayerByName(arg[0]);    
+            IDefense wusi = stack.getCapability(DefenseProvider.DEFENSE_CAP, null);
+            if(arg.length >= 1)
+            {
+                try
+                {
+                    wusi.setMagicDefense(Integer.parseInt(arg[0]));
+                }
+                catch(NumberFormatException ex)
+                {
+                }
+            }
+            else
+            {
+                cs.sendMessage(new TextComponentString(" " + wusi.getMagicDefense()));
+            }
         }
-        catch(PlayerNotFoundException ex)
+        else
         {
-            this.getModule().send(cs, GlobalText.cantFindPlayer(arg[0]));
-            return true;
+            cs.sendMessage(new TextComponentString("Nichts"));
         }
-        WorldServer w = p.getServerWorld();
-        KajetansMod.server.getPlayerList().updateTimeAndWeatherForPlayer(p, w);
         return true;
     }
 }

src/main/java/me/km/datatools/CommandDataTools.java

@@ -10,6 +10,8 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
+import me.km.capabilities.DefenseProvider;
+import me.km.capabilities.IDefense;
 import me.km.permissions.Permissions;
 import me.km.utils.ItemStackUtils;
 import net.minecraft.command.ICommandSender;
@@ -249,6 +251,7 @@ public class CommandDataTools extends ModuleCommand
                     return true;
                 }
                 case "lore-item":
+                {
                     if(arg.length < 3)
                     {
                         break;
@@ -276,9 +279,53 @@ public class CommandDataTools extends ModuleCommand
                     ItemStackUtils.addLore(hand, ChatManager.colorMessage(Utils.connectSpaces(arg, 2), p), line);
                     m.send(cs, "Die neue Lore wurde hinzugefügt.");
                     return true;
+                }
+                case "magic":
+                {
+                    if(arg.length < 2)
+                    {
+                        break;
+                    }
+                    ItemStack hand = p.getHeldItemMainhand();
+                    if(hand == ItemStack.EMPTY)
+                    {
+                        m.send(cs, "Du musst ein Item in der Hand halten.");
+                        return true;
+                    }                          
+                    int value;
+                    try
+                    {
+                        value = Integer.parseInt(arg[1]);
+                        if(value < 0)
+                        {
+                            throw new NumberFormatException();
+                        }
+                    }
+                    catch(NumberFormatException ex)
+                    {
+                        m.send(cs, GlobalText.noNaturalNumber());
+                        return true;
+                    }         
+                    if(hand.hasCapability(DefenseProvider.DEFENSE_CAP, null))
+                    {
+                        IDefense wusi = hand.getCapability(DefenseProvider.DEFENSE_CAP, null);
+                        if(wusi == null)
+                        {
+                            // this wont happen, stinky compiler
+                            return true;
+                        }
+                        wusi.setMagicDefense(value);
+                        m.send(cs, "Die Magieresistenz wurde auf " + value + " gesetzt.");
+                    }
+                    else
+                    {
+                        m.send(cs, "Nur Rüstung kann Magieresistenz haben.");
+                    }
+                    return true;
+                }
             }
         }
-        
+                    
         m.send(cs, "/datatools ...");
         m.sendHelpListElement(cs, "print-nbt", "Gibt Information über eine Entity");
         m.sendHelpListElement(cs, "flag <flag>", "Fügt dem ItemStack eine Flag hinzu");
@@ -289,6 +336,7 @@ public class CommandDataTools extends ModuleCommand
         m.sendHelpListElement(cs, "name-entity <name>", "Setzt einen Namen für eine Entity");
         m.sendHelpListElement(cs, "name-item <name>", "Setzt einen Namen für ein Item");
         m.sendHelpListElement(cs, "lore-item <line> <lore>", "Setzt eine Lore für ein Item");
+        m.sendHelpListElement(cs, "magic <def>", "Setzt die Magieresistenz für ein Item");
         return true;  
     }
 }

src/main/java/me/km/effects/Effect.java

@@ -62,70 +62,83 @@ public enum Effect
     NO_ARMOR_DROPPING       ,
     
     // active effects
-    ARCANE_SHOT             (ArcaneShot.class),
+    POISON_VOLLEY           (PoisonVolley.class),
+    FIRE                    (Fire.class),
+    SHADOW_STEP             (ShadowStep.class),
     BLINDING_SHOT           (BlindingShot.class),
-    BUNNY_HOP               (BunnyHop.class),
-    CALL_BACK               (CallBack.class),
-    CLUSTER_BOMB            (ClusterBomb.class),
-    DAY                     (Day.class),
-    DOOMED                  (Doomed.class),
-    EARTHQUAKE              (Earthquake.class),
+    KICK                    (Kick.class),
+    CRIPPLE                 (Cripple.class),
     ELEVATION               (Elevation.class),
-    ELVISH_HORN             (ElvishHorn.class),
+    SUN                     (Sun.class),
+    IMMORTALITY             (Immortality.class),
+    LUCKY                   (Lucky.class),
+    POISONED_BLADE          (PoisonedBlade.class),
+    BUNNY_HOP               (BunnyHop.class),
+    CONSTANT_POWER          (ConstantPower.class),
+    ARMOR_PASSER            (ArmorPasser.class),
+    IMPACT_PUNCH            (ImpactPunch.class),
     ENDERCHEST              (Enderchest.class),
-    EXPLOSION               (Explosion.class),
-    FALL_IMMUNITY           (FallImmunity.class),
-    FIRE                    (Fire.class),
-    FIREBALL                (Fireball.class),
+    NAIL_DOWN               (NailDown.class),
+    DOOMED                  (Doomed.class),
+    PUSH                    (Push.class),
+    PUSH_UP                 (PushUp.class),
+    HUNGER_PUNCH            (HungerPunch.class),
     FIRE_SHOT               (FireShot.class),
-    FLYING                  (Flying.class),
-    FREEZE                  (Freeze.class),
-    GRAPPLING_HOOK          (GrapplingHook.class),
-    GRAVITY                 (Gravity.class),
-    HARM                    (Harm.class),
-    HARVEST                 (Harvest.class),
-    HEAL                    (Heal.class),
+    PULL                    (Pull.class),
     HEAL_RAIN               (HealRain.class),
-    HEARTS                  (Hearts.class),
-    HEART_SEEKER            (HeartSeeker.class),
-    IMMORTALITY             (Immortality.class),
-    INVISIBILITY            (Invisibility.class),
+    UNLUCKY                 (Unlucky.class),
+    NAIL_TRAP               (NailTrap.class),
+    NIGHT                   (Night.class),
+    AREA_DAMAGE             (AreaDamage.class),
+    EARTHQUAKE              (Earthquake.class),
+    FIREBALL                (Fireball.class),
     JUMP                    (Jump.class),
-    KICK                    (Kick.class),
-    LEAF_COCOON             (LeafCocoon.class),
+    THOR                    (Thor.class),
+    GRAPPLING_HOOK          (GrapplingHook.class),
+    QUICK_SHOT              (QuickShot.class),
+    CALL_BACK               (CallBack.class),
+    SHADOW_HIT              (ShadowHit.class),
     LOCK_PICK               (LockPick.class),
-    LUCKY                   (Lucky.class),
+    HEART_SEEKER            (HeartSeeker.class),
+    TELEPORT_PLAYER         (TeleportPlayer.class),
+    SPRINT                  (Sprint.class),
+    LIFE_BREAKER            (LifeBreaker.class),
+    POWER                   (Power.class),
     MUSKET                  (Musket.class),
-    NAIL_DOWN               (NailDown.class),
-    NAIL_TRAP               (NailTrap.class),
+    HEARTS                  (Hearts.class),
+    ROOTING                 (Rooting.class),
+    WORKBENCH               (Workbench.class),
     NET_TRAP                (NetTrap.class),
-    NIGHT                   (Night.class),
+    LEAF_COCOON             (LeafCocoon.class),
     POISON                  (Poison.class),
-    POISONED_BLADE          (PoisonedBlade.class),
-    POISON_VOLLEY           (PoisonVolley.class),
-    POWER                   (Power.class),
-    POWER_ATTACK            (PowerAttack.class),
-    PULL                    (Pull.class),
-    PUSH                    (Push.class),
-    QUICK_SHOT              (QuickShot.class),
-    RAIN                    (Rain.class),
-    RAPID_FIRE              (RapidFire.class),
-    ROOTING                 (Rooting.class),
+    SMASH                   (Smash.class),
+    LIFE_STEAL              (LifeSteal.class),
     SHADOW                  (Shadow.class),
-    SHADOW_HIT              (ShadowHit.class),
-    SHADOW_STEP             (ShadowStep.class),
-    SILENCE                 (Silence.class),
     SLOWING_SHOT            (SlowingShot.class),
-    SMOKE_BOMB              (SmokeBomb.class),
-    SPRINT                  (Sprint.class),
+    VINE_TRAP               (VineTrap.class),
+    RAPID_FIRE              (RapidFire.class),
     STONE                   (Stone.class),
-    SUN                     (Sun.class),
+    FIRE_PROTECTION_RAIN    (FireProtectionRain.class),
+    BONE_BREAKER            (BoneBreaker.class),
+    ARCANE_SHOT             (ArcaneShot.class),
+    RAIN                    (Rain.class),
+    INVISIBILITY            (Invisibility.class),
+    DAY                     (Day.class),
+    FLYING                  (Flying.class),
+    EXPLOSION               (Explosion.class),
+    SMOKE_BOMB              (SmokeBomb.class),
+    HARVEST                 (Harvest.class),
+    FREEZE                  (Freeze.class),
+    FALL_IMMUNITY           (FallImmunity.class),
+    ELVISH_HORN             (ElvishHorn.class),
+    GRAVITY                 (Gravity.class),
     TELEPORT_BLOCK          (TeleportBlock.class),
-    TELEPORT_PLAYER         (TeleportPlayer.class),
-    THOR                    (Thor.class),
-    UNLUCKY                 (Unlucky.class),
-    VINE_TRAP               (VineTrap.class),
-    WORKBENCH               (Workbench.class);
+    CLUSTER_BOMB            (ClusterBomb.class),
+    HARM                    (Harm.class),
+    SILENCE                 (Silence.class),
+    POWER_ATTACK            (PowerAttack.class),
+    HEAL                    (Heal.class),
+    JUMP_ATTACK             (JumpAttack.class);
     
     private final ArrayList<Skill> skills;
     private final Class<? extends ActiveEffectBase> c;

src/main/java/me/km/effects/EffectUtils.java

@@ -162,7 +162,7 @@ public class EffectUtils extends Module
                         KajetansMod.playerbank.getDataBank().getTag((EntityPlayer) ent, "pvp") >= 1))
                 .filter(ent -> !(ent instanceof EntityPlayer) || 
                         (id != KajetansMod.playerbank.getGuildId((EntityPlayer) ent)))
-                .filter(ent -> !(ent.equals(p)))
+                .filter(ent -> ent != p)
                 .collect(Collectors.toList());
     }
     

src/main/java/me/km/effects/active/LifeBreaker.java

@@ -6,6 +6,7 @@ import me.km.effects.EffectUtils;
 import net.minecraft.entity.EntityLivingBase;
 import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.init.MobEffects;
+import net.minecraft.util.DamageSource;
 
 public class LifeBreaker extends ActiveEffectBase
 {
@@ -13,11 +14,17 @@ public class LifeBreaker extends ActiveEffectBase
     protected boolean executeEffect(EntityPlayerMP p, int power) 
     {
         EntityLivingBase liv = Utils.getTargetedEntity(p, 6, EntityLivingBase.class);
-        if(liv == null || liv.getHealth() > liv.getMaxHealth() / 5)
+        if(liv == null)
         {
             return false;
         }
         Utils.teleportEntity(p, liv);
+        
+        DamageSource ds = DamageSource.causeMobDamage(p);
+        ds.setDamageIsAbsolute();
+        ds.setDamageBypassesArmor();
+        liv.attackEntityFrom(ds, p.getMaxHealth() / 5f);
+        
         EffectUtils.addPotionTo(liv, MobEffects.SLOWNESS, power * 20, 200);
         EffectUtils.addPotionTo(liv, MobEffects.JUMP_BOOST, power * 20, 128);
         EffectUtils.addPotionTo(liv, MobEffects.WEAKNESS, power * 20, 1);

src/main/java/me/km/effects/active/LifeSteal.java

@@ -13,7 +13,7 @@ public class LifeSteal extends ActiveEffectBase
     protected boolean executeEffect(EntityPlayerMP p, int power) 
     {
         EntityLivingBase liv = Utils.getTargetedEntity(p, 6, EntityLivingBase.class);
-        if(liv == null || liv.getHealth() > liv.getMaxHealth() / 5)
+        if(liv == null)
         {
             return false;
         }

src/main/java/me/km/effects/active/Push.java

@@ -15,7 +15,7 @@ public class Push extends ActiveEffectBase
         EffectUtils.getEntsOfNotGuild(p, power + 2).stream().forEach(ent -> 
         {
             Vec3d v2 = ent.getPositionVector().subtract(v).normalize();
-            Utils.setVelocity(ent, v2.x, v2.y, v2.z);
+            Utils.setVelocity(ent, v2.x, v2.y + 0.4d, v2.z);
         });
         return true;
     }

src/main/java/me/km/effects/active/PushUp.java

@@ -0,0 +1,27 @@
+package me.km.effects.active;
+
+import me.km.api.Utils;
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.math.Vec3d;
+
+public class PushUp extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        Vec3d v = p.getPositionVector();
+        EffectUtils.getEntsOfNotGuild(p, power + 2).stream().forEach(ent -> 
+        {
+            Utils.addVelocity(ent, 0, 1, 0);
+        });
+        return true;
+    }
+    
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 3 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/Smash.java

@@ -18,6 +18,7 @@ public class Smash extends ActiveEffectBase
         }
         DamageSource ds = DamageSource.causeMobDamage(p);
         ds.setDamageBypassesArmor();
+        ds.setDamageIsAbsolute();
         liv.attackEntityFrom(ds, power);
         return true;
     }

src/main/java/me/km/effects/passive/ArrowEffects.java

@@ -146,7 +146,7 @@ public class ArrowEffects extends ModuleListener
     public void handleSmokeBomb(ThrowableImpactEvent e)
     {       
         EntityThrowable pro = e.getEntityThrowable();
-        if(pro instanceof EntitySnowball || !(pro.getThrower() instanceof EntityPlayerMP) ||
+        if(!(pro instanceof EntitySnowball) || !(pro.getThrower() instanceof EntityPlayerMP) ||
             KajetansMod.effects.getEntityData(pro, "smokebomb") == null || 
             !KajetansMod.worldManager.getWorldPreferences(pro.world).skills)
         {

src/main/java/me/km/effects/passive/EntityDamageEffects.java

@@ -4,15 +4,18 @@ import me.km.KajetansMod;
 import me.km.api.Module;
 import me.km.api.ModuleListener;
 import me.km.api.Utils;
+import me.km.capabilities.DamageUtils;
 import me.km.effects.Effect;
 import me.km.effects.EffectUtils;
 import me.km.events.PlayerHurtEvent;
 import me.km.playerbank.PlayerData;
+import me.km.utils.ReflectionUtils;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.EntityLivingBase;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.init.MobEffects;
+import net.minecraft.util.CombatRules;
 import net.minecraft.util.DamageSource;
 import net.minecraftforge.event.entity.living.LivingHealEvent;
 import net.minecraftforge.event.entity.living.LivingHurtEvent;
@@ -71,6 +74,51 @@ public class EntityDamageEffects extends ModuleListener
     @SubscribeEvent(receiveCanceled = false)
     public void onEntityDamage(LivingHurtEvent e)
     {         
+        // ---------------------------------------------------------------------
+        // injection of new damage system
+        // ---------------------------------------------------------------------
+        
+        e.setCanceled(true);
+        KajetansMod.scheduler.scheduleTask(() -> 
+        {
+            float damageAmount = e.getAmount();
+            DamageSource ds = e.getSource();
+            EntityLivingBase liv = e.getEntityLiving();
+            
+            if(ds != DamageSource.LAVA && ds != DamageSource.IN_WALL && ds != DamageSource.CRAMMING && ds != DamageSource.DROWN)
+            {
+                if(ds.isMagicDamage() && !ds.isDamageAbsolute())
+                {
+                    ReflectionUtils.damageArmor(liv, damageAmount);
+                    damageAmount = CombatRules.getDamageAfterAbsorb(damageAmount, DamageUtils.getMagicDefense(liv), 0);
+                }
+                else
+                {
+                    damageAmount = ReflectionUtils.applyArmorCalculations(liv, ds, damageAmount);
+                }           
+                damageAmount = ReflectionUtils.applyPotionDamageCalculations(liv, ds, damageAmount);
+            }
+            else
+            {
+                damageAmount = liv.getMaxHealth() / 10;
+            }
+            
+            float f = damageAmount;
+            damageAmount = Math.max(damageAmount - liv.getAbsorptionAmount(), 0.0F);
+            liv.setAbsorptionAmount(liv.getAbsorptionAmount() - (f - damageAmount));
+
+            if (damageAmount != 0.0F)
+            {
+                float f1 = liv.getHealth();
+                liv.setHealth(f1 - damageAmount);
+                liv.getCombatTracker().trackDamage(ds, f1, damageAmount);
+                liv.setAbsorptionAmount(liv.getAbsorptionAmount() - damageAmount);
+            }
+        });
+        
+        // ---------------------------------------------------------------------
+        // end of new damage system injection
+        // ---------------------------------------------------------------------
         if(!KajetansMod.worldManager.getWorldPreferences(e.getEntity().world).skills)
         {
             return;

src/main/java/me/km/recipes/ModRecipes.java

@@ -103,19 +103,23 @@ public class ModRecipes
     
     private static String buildRegistryName(ItemStack stack)
     {
+        id++;
         if(stack.getMetadata() != 0)
-        {
-            return stack.getItem().getRegistryName().getResourcePath() + "_" + stack.getMetadata();
+        {          
+            return stack.getItem().getRegistryName().getResourcePath() + "_" + stack.getMetadata() + "_" + id;
         }
-        return stack.getItem().getRegistryName().getResourcePath();
+        return stack.getItem().getRegistryName().getResourcePath() + "_" + id;
     }
     
     // -----------------------------------------------------------------------------------
     // init recipes
     // -----------------------------------------------------------------------------------
     
+    private static int id = 0;
+    
     public static void init(IForgeRegistry<IRecipe> r) 
     {
+        id = 0;
         FurnaceRecipes fr = FurnaceRecipes.instance();        
         
         // misc
@@ -125,6 +129,19 @@ public class ModRecipes
             ModItems.copperIngot, ModItems.copperIngot, ModItems.copperIngot,
             ModItems.copperIngot, ModItems.copperIngot, ModItems.tinIngot
         });
+        registerShapeless(r, "", new ItemStack(Items.STRING, 4), new ItemStack[][] 
+        {
+            {new ItemStack(Blocks.WOOL)}
+        });
+        registerShaped(r, "", new String[] {"XXX", "XSX", " I "}, new ItemStack(Items.SADDLE), 
+                new char[] {'X', 'S', 'I'}, new ItemStack[][] 
+                {
+                    {new ItemStack(Items.LEATHER)},
+                    {new ItemStack(Items.STRING)},
+                    {new ItemStack(Items.IRON_INGOT)}
+                });
+        registerShaped(r, "", new String[] {"XXX", "XXX", "XXX"}, new ItemStack(ModItems.hayBundle, 9), 
+                new char[] {'X'}, new ItemStack[][] {{new ItemStack(Blocks.TALLGRASS, 1, 1), new ItemStack(Blocks.TALLGRASS, 1, 2)}});
         registerShaped(r, "", new String[] {"XXX"}, new ItemStack(ModItems.realHayBed, 3), 
                 new char[] {'X'}, new ItemStack[][] {{new ItemStack(ModBlocks.realHayBlock)}});
         registerShaped(r, "", new String[] {" X ", "XXX"}, new ItemStack(ModItems.strawHat), 
@@ -295,7 +312,7 @@ public class ModRecipes
                 ItemStack ingot = parts.copy();
                 ingot.setCount(1);
                 stacks[0][0] = ingot;
-                registerShaped(r, "", blockPattern, new ItemStack(block), chars, stacks);
+                registerShaped(r, "",  blockPattern, new ItemStack(block), chars, stacks);
                 stacks[0][0] = new ItemStack(block);
                 registerShaped(r, "", ingotPattern, parts, chars, stacks);
             }

src/main/java/me/km/utils/ItemStackUtils.java

@@ -76,7 +76,7 @@ public class ItemStackUtils
     
     public static void addAttribute(ItemStack stack, Attribute a, EntityEquipmentSlot slot, double amount, Operation op)
     {
-        stack.addAttributeModifier(a.getName(), new AttributeModifier("modifier", amount, op.ordinal()), slot);   
+        stack.addAttributeModifier(a.getName(), new AttributeModifier("modifier", amount, op.ordinal()), slot);
     }
     
     // -----------------------------------------------------------------------------------

src/main/java/me/km/utils/ReflectionUtils.java

@@ -1,18 +1,22 @@
 package me.km.utils;
 
 import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
 import java.util.Map;
 import java.util.Random;
 import java.util.UUID;
 import net.minecraft.block.Block;
 import net.minecraft.block.material.Material;
 import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
 import net.minecraft.entity.item.EntityItem;
 import net.minecraft.entity.passive.EntityVillager;
 import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.entity.player.PlayerCapabilities;
 import net.minecraft.entity.projectile.EntityArrow;
 import net.minecraft.server.management.PlayerList;
+import net.minecraft.util.DamageSource;
 import net.minecraft.util.FoodStats;
 import net.minecraft.world.Explosion;
 import net.minecraftforge.fml.relauncher.ReflectionHelper;
@@ -23,6 +27,19 @@ public class ReflectionUtils
     // helper stuff
     // -----------------------------------------------------------------------------------
     
+    private static Method getMethod(Class c, String name, String obfusName, Class... pars)
+    {
+        try
+        {
+            return ReflectionHelper.findMethod(c, name, obfusName, pars);
+        }
+        catch(SecurityException | ReflectionHelper.UnableToFindMethodException ex)
+        {
+            System.out.println(name + ", "  + obfusName + " - " + ex);
+        }
+        return null;
+    }
+    
     private static Field getField(Class c, String... field)
     {
         try
@@ -173,10 +190,10 @@ public class ReflectionUtils
     // explosion stuff
     // -----------------------------------------------------------------------------------
     
-    private final static Field IS_FLAMING = getField(Explosion.class, "field_77286_a", "isFlaming");
-    private final static Field IS_SMOKING = getField(Explosion.class, "field_82755_b", "isSmoking");
-    private final static Field EXPLOSION_RNG = getField(Explosion.class, "field_77290_i", "explosionRNG");
-    private final static Field EXPLOSION_SIZE = getField(Explosion.class, "field_77280_f", "explosionSize");
+    private final static Field IS_FLAMING = getField(Explosion.class, "field_77286_a", "causesFire");
+    private final static Field IS_SMOKING = getField(Explosion.class, "field_82755_b", "damagesTerrain");
+    private final static Field EXPLOSION_RNG = getField(Explosion.class, "field_77290_i", "random");
+    private final static Field EXPLOSION_SIZE = getField(Explosion.class, "field_77280_f", "size");
     private final static Field EXPLODER = getField(Explosion.class, "field_77283_e", "exploder");
     
     public static boolean isFlaming(Explosion ex)
@@ -245,4 +262,58 @@ public class ReflectionUtils
     {
         return getFieldValue(Material.class, b, BLOCK_MATERIAL);
     }
+    
+    // -----------------------------------------------------------------------------------
+    // EntityLivingBase stuff
+    // -----------------------------------------------------------------------------------
+    
+    private final static Method APPLY_ARMOR_CALCULATIONS = getMethod(
+            EntityLivingBase.class, 
+            "applyArmorCalculations", 
+            "func_70655_b", DamageSource.class, float.class);
+    
+    public static float applyArmorCalculations(EntityLivingBase liv, DamageSource ds, float damage)
+    {
+        try
+        {
+            return (float) APPLY_ARMOR_CALCULATIONS.invoke(liv, ds, damage);
+        }
+        catch(IllegalAccessException | IllegalArgumentException | InvocationTargetException ex)
+        {
+            return damage;
+        }
+    }
+    
+    private final static Method APPLY_POTION_DAMAGE_CALCULATIONS = getMethod(
+            EntityLivingBase.class, 
+            "applyPotionDamageCalculations", 
+            "func_70672_c", DamageSource.class, float.class);
+    
+    public static float applyPotionDamageCalculations(EntityLivingBase liv, DamageSource ds, float damage)
+    {
+        try
+        {
+            return (float) APPLY_POTION_DAMAGE_CALCULATIONS.invoke(liv, ds, damage);
+        }
+        catch(IllegalAccessException | IllegalArgumentException | InvocationTargetException ex)
+        {
+            return damage;
+        }
+    }
+    
+    private final static Method DAMAGE_ARMOR = getMethod(
+            EntityLivingBase.class, 
+            "damageArmor", 
+            "func_70675_k", float.class);
+    
+    public static void damageArmor(EntityLivingBase liv, float damage)
+    {
+        try
+        {
+            DAMAGE_ARMOR.invoke(liv, damage);
+        }
+        catch(IllegalAccessException | IllegalArgumentException | InvocationTargetException ex)
+        {
+        }
+    }
 }