minecraft-kajetans-mod/src/main/java/me/km/effects/passive/EntityDamageEffects.java

package me.km.effects.passive;

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;
import net.minecraftforge.fml.common.eventhandler.EventPriority;
import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;

public class EntityDamageEffects extends ModuleListener
{
    public EntityDamageEffects(Module m) 
    {
        super(m);
    }
    
    @SubscribeEvent(receiveCanceled = false)
    public void damageHandler(PlayerHurtEvent e)
    {          
        EntityPlayerMP p = e.getEntityPlayer();
        if(!KajetansMod.worldManager.getWorldPreferences(p.world).skills)
        {
            return;
        } 
        
        int reducer = EffectUtils.getEffectLevel(p, Effect.LESS_DAMAGE);
        if(reducer > 0)
        {
            e.setAmount(e.getAmount() / (reducer + 1));
        }
        
        PlayerData data = KajetansMod.playerbank.getData(p);
        if(data.hasData("shadow"))
        {
            p.setInvisible(false);
            data.removeData("shadow");
        } 
        
        DamageSource cause = e.getSource();
        
        if(cause.isMagicDamage() && EffectUtils.getEffectLevel(p, Effect.NO_POISON) >= 1)
        {
            e.setCanceled(true);
        } 
        else if(cause == DamageSource.FALL)
        {
            if(data.hasData("fallimmunity"))
            {
                e.setCanceled(true);
                return;
            }
            int fall = EffectUtils.getEffectLevel(p, Effect.LESS_FALL_DAMAGE);
            if(fall >= 1)
            {
                e.setAmount(e.getAmount() / (fall * 2 + 1));
            }
        }
    }
    
    @SubscribeEvent(priority = EventPriority.LOWEST)
    public void onEntityDamage(LivingHurtEvent e)
    {         
        // ---------------------------------------------------------------------
        // injection of new damage system
        // ---------------------------------------------------------------------
        
        if(!e.isCanceled())
        {
            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);
                }
            });
        }
        else
        {
            return;
        }
        
        // ---------------------------------------------------------------------
        // end of new damage system injection
        // ---------------------------------------------------------------------
        if(!KajetansMod.worldManager.getWorldPreferences(e.getEntity().world).skills)
        {
            return;
        }  
        Entity pEnt = e.getSource().getImmediateSource();
        if(pEnt == null || !(pEnt instanceof EntityPlayerMP))
        {
            return;
        } 
        EntityPlayerMP p = (EntityPlayerMP) pEnt;
        Utils.ToolTypes tt = Utils.getToolType(p.getHeldItemMainhand());
        float damageBonus = 1;
        if(tt != null)
        {
            switch(tt)
            {
                case AXE:
                    damageBonus += 0.1f * EffectUtils.getEffectLevel(p, Effect.MORE_AXE_DAMAGE);
                    break;
                case HOE:  
                    damageBonus += 0.1f * EffectUtils.getEffectLevel(p, Effect.MORE_HOE_DAMAGE);
                    break;
                case PICKAXE:
                    damageBonus += 0.1f * EffectUtils.getEffectLevel(p, Effect.MORE_PICKAXE_DAMAGE);
                    break;
                case SHOVEL:
                    damageBonus += 0.1f * EffectUtils.getEffectLevel(p, Effect.MORE_SHOVEL_DAMAGE);
                    break;
                case SWORD:
                    damageBonus += 0.1f * EffectUtils.getEffectLevel(p, Effect.MORE_SWORD_DAMAGE);
                    break;
                case DAGGER:
                    damageBonus += 0.1f * EffectUtils.getEffectLevel(p, Effect.MORE_DAGGER_DAMAGE);
                    break;
                case HAMMER:
                    damageBonus += 0.1f * EffectUtils.getEffectLevel(p, Effect.MORE_HAMMER_DAMAGE);
                    break;
                case STICK:
                    damageBonus += 0.1f * EffectUtils.getEffectLevel(p, Effect.MORE_STICK_DAMAGE);
                    break;
            }
        }
        
        EntityLivingBase ent = e.getEntityLiving();
        PlayerData data = KajetansMod.playerbank.getData(p);

        if(data.removeData("shadowhit"))
        {
            EffectUtils.addPotionTo(p, MobEffects.SPEED, 40, 1);
            EffectUtils.addPotionTo(p, MobEffects.INVISIBILITY, 40, 0);
        }
        
        if(ent instanceof EntityPlayerMP)
        {
            EntityPlayerMP victim = (EntityPlayerMP) ent;
            EntityPlayer damager = KajetansMod.playerbank.getData(victim).getData("doomed", EntityPlayer.class);
            if(damager != null && damager.equals(p))
            {
                damageBonus *= 1.2f;
            }
        }
        
        if(data.hasData("poisonedblade"))
        {
            EffectUtils.addPotionTo(ent, MobEffects.POISON, 80, 1);
        }
        
        if(data.hasData("armorpasser"))
        {
            float reduced = e.getAmount() - Utils.getDamagerAfterArmor(ent, e.getSource(), e.getAmount());
            e.setAmount(e.getAmount() + reduced * 0.35f);
        }
        
        double powerAttack = data.getDouble("powerattack");
        if(powerAttack != 0)
        {
            damageBonus *= powerAttack;
            data.removeData("powerattack");
        }
        powerAttack = data.getDouble("cpower");
        if(powerAttack != 0)
        {
            damageBonus *= powerAttack;
        }
        powerAttack = data.getDouble("impactpunch");
        if(powerAttack != 0)
        {
            damageBonus *= powerAttack;
            EffectUtils.addPotionTo(ent, MobEffects.SLOWNESS, (int) (powerAttack * 20), 1);
            data.removeData("impactpunch");
        }
        
        e.setAmount(e.getAmount() * damageBonus);
    }
    
    @SubscribeEvent(receiveCanceled = false)
    public void onEntityHeal(LivingHealEvent e)
    {         
        if(!KajetansMod.worldManager.getWorldPreferences(e.getEntity().world).skills)
        {
            return;
        }  
        Entity ent = e.getEntityLiving();
        if(!(ent instanceof EntityPlayerMP))
        {
            return;
        } 
        EntityPlayerMP p = (EntityPlayerMP) ent;
        PlayerData data = KajetansMod.playerbank.getData(p);
        if(data.hasData("lessheal"))
        {
            e.setAmount(e.getAmount() / 2);
        }
    }
}