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

package me.km.effects;

import me.km.KajetansMod;
import me.km.utils.Utils;
import me.km.entities.EntityItemProjectile;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.item.EntityEnderPearl;
import net.minecraft.entity.item.EntityExpBottle;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.entity.projectile.*;
import net.minecraft.init.Items;
import net.minecraft.item.ItemStack;
import net.minecraft.potion.Potion;
import net.minecraft.potion.PotionEffect;
import net.minecraft.potion.PotionType;
import net.minecraft.potion.PotionUtils;
import net.minecraft.util.EnumParticleTypes;
import net.minecraft.util.SoundCategory;
import net.minecraft.util.SoundEvent;
import net.minecraft.util.math.Vec3d;
import net.minecraft.world.World;
import net.minecraft.world.WorldServer;

public class EffectUtils
{
    // -----------------------------------------------------------------------------------
    // Particles
    // -----------------------------------------------------------------------------------
    
    public static void spawnParticle(WorldServer w, EnumParticleTypes particle, double x, double y, double z, double offX, double offY, double offZ, int count, int... data)
    {
        w.spawnParticle(particle, false, x, y, z, count, offX, offY, offZ, 1, data);
    }
    
    public static void spawnParticle(WorldServer w, EnumParticleTypes particle, double x, double y, double z, double offX, double offY, double offZ, int count)
    {
        spawnParticle(w, particle, x, y, z, offX, offY, offZ, count, new int[0]);
    }
    
    public static void spawnParticle(WorldServer w, EnumParticleTypes particle, double x, double y, double z, int count)
    {
        spawnParticle(w, particle, x, y, z, 0, 0, 0, count);
    }
    
    public static void spawnParticle(WorldServer w, EnumParticleTypes particle, Entity ent, int count)
    {
        spawnParticle(w, particle, ent.posX, ent.posY, ent.posZ, count);
    }
    
    public static void spawnSpell(EntityPlayerMP p, int level)
    {
        spawnParticle(p.getServerWorld(), EnumParticleTypes.SPELL, p.posX, p.posY + 1, p.posZ, 0.5f, 0.5f, 0.5f, 10 + level);
    }
    
    public static void spawnParticleCircle(WorldServer w, double x, double y, double z, EnumParticleTypes particle, double radius, int counter, int... data)
    {
        double angle = 2 * Math.PI / counter;
        for(int i = 0; i < counter; i++)
        {
            spawnParticle(w, particle, x + Math.cos(i * angle) * radius, y, z + Math.sin(i * angle) * radius, 0, 0, 0, 1, data);
        }                
    }
    
    public static void spawnParticleCircle(WorldServer w, Entity ent, EnumParticleTypes particle, double radius, int counter, int... data)
    {
        spawnParticleCircle(w, ent.posX, ent.posY, ent.posZ, particle, radius, counter, data);              
    }
    
    public static void spawnParticleCircle(WorldServer w, double x, double y, double z, EnumParticleTypes particle, double radius, int counter)
    {
        spawnParticleCircle(w, x, y, z, particle, radius, counter, new int[0]);              
    }
    
    public static void spawnParticleCircle(WorldServer w, Entity ent, EnumParticleTypes particle, double radius, int counter)
    {
        spawnParticleCircle(w, ent.posX, ent.posY, ent.posZ, particle, radius, counter, new int[0]);              
    }
    
    // -----------------------------------------------------------------------------------
    // Sounds
    // -----------------------------------------------------------------------------------
    
    public static void playSound(World w, SoundEvent se, SoundCategory sc, double x, double y, double z)
    {
        w.playSound(null, x, y, z, se, sc, 1, w.rand.nextFloat() * 0.1f + 0.9f);
    }
    
    public static void playSound(EntityPlayer p, SoundEvent se, SoundCategory sc)
    {
        playSound(p.world, se, sc, p.posX, p.posY, p.posZ);
    }
    
    public static void playSound(EntityPlayer p, SoundEvent se)
    {
        playSound(p.world, se, SoundCategory.PLAYERS, p.posX, p.posY, p.posZ);
    }

    // -----------------------------------------------------------------------------------
    // Potions
    // -----------------------------------------------------------------------------------
    
    public static void addPotionTo(EntityLivingBase ent, Potion potion, int duration, int amplifier)
    {
        if(ent.isPotionActive(potion)) 
        {
            ent.removePotionEffect(potion);
        }
        ent.addPotionEffect(new PotionEffect(potion, duration, amplifier));
    }
    
    // -----------------------------------------------------------------------------------
    // Projectiles
    // -----------------------------------------------------------------------------------
    
    public static <T> T launchProjectile(EntityPlayer p, Class<? extends T> projectile, double scale, Object data) 
    {
        World w = p.world;
        Entity launch = null;

        if(EntityItemProjectile.class == projectile) 
        {
            if(data == null)
            {
                throw new NullPointerException("Data musn't be null for EntityItemProjectile");
            }
            ItemStack stack = (ItemStack) data;
            if(stack.isEmpty())
            {
                throw new IllegalArgumentException("Empty ItemStack not allowed here");
            }
            launch = new EntityItemProjectile(p, stack.copy());
            ((EntityItemProjectile) launch).setHeadingFromThrower(p, p.rotationPitch, p.rotationYaw, 0.0f, 1.5f, 1.0f);
        } 
        else if(EntitySnowball.class == projectile) 
        {
            launch = new EntitySnowball(w, p);
            ((EntitySnowball) launch).shoot(p, p.rotationPitch, p.rotationYaw, 0.0f, 1.5f, 1.0f);
        } 
        else if(EntityEgg.class == projectile)
        {
            launch = new EntityEgg(w, p);
            ((EntityEgg) launch).shoot(p, p.rotationPitch, p.rotationYaw, 0.0f, 1.5f, 1.0f);
        } 
        else if(EntityEnderPearl.class == projectile) 
        {
            launch = new EntityEnderPearl(w, p);
            ((EntityEnderPearl) launch).shoot(p, p.rotationPitch, p.rotationYaw, 0.0f, 1.5f, 1.0f);
        } 
        else if(EntityPotion.class == projectile) 
        {
            launch = new EntityPotion(w, p, (ItemStack) data);
            ((EntityPotion) launch).shoot(p, p.rotationPitch, p.rotationYaw, -20.0f, 0.5f, 1.0f);
        } 
        else if(EntityExpBottle.class == projectile) 
        {
            launch = new EntityExpBottle(w, p);
            ((EntityExpBottle) launch).shoot(p, p.rotationPitch, p.rotationYaw, -20.0f, 0.7f, 1.0f);
        } 
        else if(EntityArrow.class.isAssignableFrom(projectile)) 
        {
            if(EntityTippedArrow.class == projectile) 
            {
                launch = new EntityTippedArrow(w, p);
                ((EntityTippedArrow) launch).setPotionEffect((ItemStack) data);
            } 
            else if(EntitySpectralArrow.class == projectile) 
            {
                launch = new EntitySpectralArrow(w, p);
            } 
            else 
            {
                launch = new EntityTippedArrow(w, p);
            }
            ((EntityArrow) launch).shoot(p, p.rotationPitch, p.rotationYaw, 0.0F, 3.0F, 1.0F);
        } 
        else if(EntityFireball.class.isAssignableFrom(projectile)) 
        {
            Vec3d v = p.getLookVec().scale(10);
            if (EntitySmallFireball.class == projectile) 
            {
                launch = new EntitySmallFireball(w, p, v.x, v.y, v.z);
            } 
            else if (EntityWitherSkull.class == projectile) 
            {
                launch = new EntityWitherSkull(w, p, v.x, v.y, v.z);
            } 
            else if (EntityDragonFireball.class == projectile) 
            {
                launch = new EntityDragonFireball(w, p, v.x, v.y, v.z);
            } 
            else 
            {
                launch = new EntityLargeFireball(w, p, v.x, v.y, v.z);
            }
        } 

        Utils.scaleVelocity(launch, scale);
        w.spawnEntity(launch);
        return (T) launch;
    }
    
    public static EntityTippedArrow launchTippedArrow(EntityPlayer p, double scale, Potion potion, int duration, int amplifier) 
    {
        ItemStack stack = new ItemStack(Items.TIPPED_ARROW);
        PotionUtils.addPotionToItemStack(stack, new PotionType(new PotionEffect(potion, duration, amplifier)));
        EntityTippedArrow arrow = launchProjectile(p, EntityTippedArrow.class, scale, stack);
        return arrow;
    }
    
    public static void jumpTo(EntityLivingBase j, EntityLivingBase g)
    {
        Utils.setVelocity(j, (g.posX - g.posX) * 0.2, (g.posY - g.posY) * 0.2 + 0.9, (g.posZ - g.posZ) * 0.2);
        KajetansMod.scheduler.scheduleTask(() -> 
        {
            Utils.setVelocity(j, (g.posX - j.posX) * 0.2, (g.posY - j.posY) * 0.2, (g.posZ - j.posZ) * 0.2);
        }, 12);
    }
}