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.SharedMonsterAttributes;
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.LivingAttackEvent;
import net.minecraftforge.event.entity.living.LivingDeathEvent;
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
    public void onEntityDamage(LivingHurtEvent e)
    {         
        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(priority = EventPriority.LOWEST)
    public void newDamageSystem(LivingHurtEvent e)
    {         
        // ---------------------------------------------------------------------
        // injection of new damage system
        // ---------------------------------------------------------------------
        if(!e.isCanceled())
        {
            e.setCanceled(true);

            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);
                    int armor = DamageUtils.getMagicDefense(liv);
                    if(liv instanceof EntityPlayerMP)
                    {
                        Float f = KajetansMod.playerbank.getData((EntityPlayerMP) liv).getData("magicarmorboost", Float.class);
                        if(f != null)
                        {
                            armor = Math.round(armor * f);
                        }
                    }
                    damageAmount = CombatRules.getDamageAfterAbsorb(damageAmount, armor, 0);
                }
                else
                {
                    if(!ds.isUnblockable())
                    {
                        ReflectionUtils.damageArmor(liv, damageAmount);
                        int armor = liv.getTotalArmorValue();
                        Float thorns = null;
                        if(liv instanceof EntityPlayerMP)
                        {
                            Float f = KajetansMod.playerbank.getData((EntityPlayerMP) liv).getData("armorboost", Float.class);
                            thorns = KajetansMod.playerbank.getData((EntityPlayerMP) liv).getData("thorns", Float.class);
                            if(f != null)
                            {
                                armor = Math.round(armor * f);
                            }
                        }
                        damageAmount = CombatRules.getDamageAfterAbsorb(damageAmount, armor, 
                                (float) liv.getEntityAttribute(SharedMonsterAttributes.ARMOR_TOUGHNESS).getAttributeValue());
                        // physical damage - doing thorns here
                        if(thorns != null)
                        {
                            Entity ent = ds.getImmediateSource();
                            if(ent != null)
                            {
                                DamageSource reflect = DamageSource.causePlayerDamage((EntityPlayerMP) liv);
                                reflect.setMagicDamage();
                                ent.attackEntityFrom(reflect, thorns * damageAmount);
                            }
                        }
                        // end of thorns
                    }
                }           
                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);
            }
        }
    }
    
    @SubscribeEvent(receiveCanceled = false)
    public void handleDodging(LivingAttackEvent e)
    {        
        EntityLivingBase liv = e.getEntityLiving();
        if(!KajetansMod.worldManager.getWorldPreferences(liv.world).skills || !(liv instanceof EntityPlayerMP))
        {
            return;
        }
        int dodge = EffectUtils.getEffectLevel((EntityPlayerMP) liv, Effect.DODGE);
        if(dodge > 0 && liv.getRNG().nextInt(20) + 1 <= dodge)
        {
            e.setCanceled(true);
        }
    }
    
    @SubscribeEvent
    public void handleBloodThirst(LivingDeathEvent e)
    {        
        EntityLivingBase liv = e.getEntityLiving();
        if(!KajetansMod.worldManager.getWorldPreferences(liv.world).skills)
        {
            return;
        }
        float heal = liv instanceof EntityPlayer ? 30 : 6;
        Utils.getPlayers(liv, 5).forEach(p -> 
        {
            if(EffectUtils.getEffectLevel(p, Effect.BLOOD_THIRST) >= 1)
            {
                p.heal(heal);
            }
        });
    }
    
    @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);
        }
    }
}