Minecraft Forums

package net.minecraft.src;

import java.util.Map;
import java.util.Random;

public class mod_GenTest extends BaseMod
{

        public void load()
        {
         ModLoader.registerEntityID(EntityJungleSlime.class, "In-gameEntityName", ModLoader.getUniqueEntityId());
         ModLoader.addSpawn(EntityJungleSlime.class, 15, 5, 7, EnumCreatureType.creature);
        }
        public void addRenderer(Map map)
        {
         map.put(EntityJungleSlime.class, new RenderJungleSlime(new ModelJungleSlime(0), null, 0));
        }
        public String getVersion()
        {
                return "1.1";
        }
}

package net.minecraft.src;

public class ModelJungleSlime extends ModelBase
{
    /** The slime's bodies, both the inside box and the outside box */
    ModelRenderer slimeBodies;

    /** The slime's right eye */
    ModelRenderer slimeRightEye;

    /** The slime's left eye */
    ModelRenderer slimeLeftEye;

    /** The slime's mouth */
    ModelRenderer slimeMouth;

    public ModelJungleSlime(int par1)
    {
        slimeBodies = new ModelRenderer(this, 0, par1);
        slimeBodies.addBox(-4F, 16F, -4F, 8, 8, 8);

        if (par1 > 0)
        {
            slimeBodies = new ModelRenderer(this, 0, par1);
            slimeBodies.addBox(-3F, 17F, -3F, 6, 6, 6);
            slimeRightEye = new ModelRenderer(this, 32, 0);
            slimeRightEye.addBox(-3.25F, 18F, -3.5F, 2, 2, 2);
            slimeLeftEye = new ModelRenderer(this, 32, 4);
            slimeLeftEye.addBox(1.25F, 18F, -3.5F, 2, 2, 2);
            slimeMouth = new ModelRenderer(this, 32, 8);
            slimeMouth.addBox(0.0F, 21F, -3.5F, 1, 1, 1);
        }
    }

    /**
     * Sets the models various rotation angles.
     */
    public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5)
    {
    }

    /**
     * Sets the models various rotation angles then renders the model.
     */
    public void render(Entity par1Entity, float par2, float par3, float par4, float par5, float par6, float par7)
    {
        setRotationAngles(par2, par3, par4, par5, par6, par7);
        slimeBodies.render(par7);

        if (slimeRightEye != null)
        {
            slimeRightEye.render(par7);
            slimeLeftEye.render(par7);
            slimeMouth.render(par7);
        }
    }
}

package net.minecraft.src;

import org.lwjgl.opengl.GL11;

public class RenderJungleSlime extends RenderLiving
{
    private ModelBase scaleAmount;

    public RenderJungleSlime(ModelBase par1ModelBase, ModelBase par2ModelBase, float par3)
    {
        super(par1ModelBase, par3);
        scaleAmount = par2ModelBase;
    }

    protected int func_40287_a(EntitySlime par1EntitySlime, int par2, float par3)
    {
        if (par2 == 0)
        {
            setRenderPassModel(scaleAmount);
            GL11.glEnable(GL11.GL_NORMALIZE);
            GL11.glEnable(GL11.GL_BLEND);
            GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
            return 1;
        }

        if (par2 == 1)
        {
            GL11.glDisable(GL11.GL_BLEND);
            GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
        }

        return -1;
    }

    /**
     * sets the scale for the slime based on getSlimeSize in EntitySlime
     */
    protected void scaleSlime(EntitySlime par1EntitySlime, float par2)
    {
        int i = par1EntitySlime.getSlimeSize();
        float f = (par1EntitySlime.field_767_b + (par1EntitySlime.field_768_a - par1EntitySlime.field_767_B) * par2) / ((float)i * 0.5F + 1.0F);
        float f1 = 1.0F / (f + 1.0F);
        float f2 = i;
        GL11.glScalef(f1 * f2, (1.0F / f1) * f2, f1 * f2);
    }

    /**
     * Allows the render to do any OpenGL state modifications necessary before the model is rendered. Args:
     * entityLiving, partialTickTime
     */
    protected void preRenderCallback(EntityLiving par1EntityLiving, float par2)
    {
        scaleSlime((EntitySlime)par1EntityLiving, par2);
    }

    /**
     * Queries whether should render the specified pass or not.
     */
    protected int shouldRenderPass(EntityLiving par1EntityLiving, int par2, float par3)
    {
        return func_40287_a((EntitySlime)par1EntityLiving, par2, par3);
    }
}

package net.minecraft.src;

import java.util.Random;

public class EntityJungleSlime extends EntityLiving implements IMob
{
    public float field_40139_a;
    public float field_768_a;
    public float field_767_b;

    /** the time between each jump of the slime */
    private int slimeJumpDelay;

    public EntityJungleSlime(World par1World)
    {
        super(par1World);
        slimeJumpDelay = 0;
        texture = "/mob/slime.png";
        int i = 1 << rand.nextInt(3);
        yOffset = 0.0F;
        slimeJumpDelay = rand.nextInt(20) + 10;
        setSlimeSize(i);
        experienceValue = i;
    }

    protected void entityInit()
    {
        super.entityInit();
        dataWatcher.addObject(16, new Byte((byte)1));
    }

    public void setSlimeSize(int par1)
    {
        dataWatcher.updateObject(16, new Byte((byte)par1));
        setSize(0.6F * (float)par1, 0.6F * (float)par1);
        setPosition(posX, posY, posZ);
        setEntityHealth(getMaxHealth());
    }

    public int getMaxHealth()
    {
        int i = getSlimeSize();
        return i * i;
    }

    /**
     * Returns the size of the slime.
     */
    public int getSlimeSize()
    {
        return dataWatcher.getWatchableObjectByte(16);
    }

    /**
     * (abstract) Protected helper method to write subclass entity data to NBT.
     */
    public void writeEntityToNBT(NBTTagCompound par1NBTTagCompound)
    {
        super.writeEntityToNBT(par1NBTTagCompound);
        par1NBTTagCompound.setInteger("Size", getSlimeSize() - 1);
    }

    /**
     * (abstract) Protected helper method to read subclass entity data from NBT.
     */
    public void readEntityFromNBT(NBTTagCompound par1NBTTagCompound)
    {
        super.readEntityFromNBT(par1NBTTagCompound);
        setSlimeSize(par1NBTTagCompound.getInteger("Size") + 1);
    }

    /**
     * Returns the name of a particle effect that may be randomly created by EntitySlime.onUpdate()
     */
    protected String getSlimeParticle()
    {
        return "slime";
    }

    protected String func_40138_aj()
    {
        return "mob.slime";
    }

    /**
     * Called to update the entity's position/logic.
     */
    public void onUpdate()
    {
        if (!worldObj.isRemote && worldObj.difficultySetting == 0 && getSlimeSize() > 0)
        {
            isDead = true;
        }

        field_768_a = field_768_a + (field_40139_a - field_768_a) * 0.5F;
        field_767_b = field_768_a;
        boolean flag = onGround;
        super.onUpdate();

        if (onGround && !flag)
        {
            int i = getSlimeSize();

            for (int j = 0; j < i * 8; j++)
            {
                float f = rand.nextFloat() * (float)Math.PI * 2.0F;
                float f1 = rand.nextFloat() * 0.5F + 0.5F;
                float f2 = MathHelper.sin(f) * (float)i * 0.5F * f1;
                float f3 = MathHelper.cos(f) * (float)i * 0.5F * f1;
                worldObj.spawnParticle(getSlimeParticle(), posX + (double)f2, boundingBox.minY, posZ + (double)f3, 0.0D, 0.0D, 0.0D);
            }

            if (func_40134_ak())
            {
                worldObj.playSoundAtEntity(this, func_40138_aj(), getSoundVolume(), ((rand.nextFloat() - rand.nextFloat()) * 0.2F + 1.0F) / 0.8F);
            }

            field_40139_a = -0.5F;
        }

        func_40136_ag();
    }

    protected void updateEntityActionState()
    {
        despawnEntity();
        EntityPlayer entityplayer = worldObj.getClosestVulnerablePlayerToEntity(this, 16D);

        if (entityplayer != null)
        {
            faceEntity(entityplayer, 10F, 20F);
        }

        if (onGround && slimeJumpDelay-- <= 0)
        {
            slimeJumpDelay = func_40131_af();

            if (entityplayer != null)
            {
                slimeJumpDelay /= 3;
            }

            isJumping = true;

            if (func_40133_ao())
            {
                worldObj.playSoundAtEntity(this, func_40138_aj(), getSoundVolume(), ((rand.nextFloat() - rand.nextFloat()) * 0.2F + 1.0F) * 0.8F);
            }

            field_40139_a = 1.0F;
            moveStrafing = 1.0F - rand.nextFloat() * 2.0F;
            moveForward = 1 * getSlimeSize();
        }
        else
        {
            isJumping = false;

            if (onGround)
            {
                moveStrafing = moveForward = 0.0F;
            }
        }
    }

    protected void func_40136_ag()
    {
        field_40139_a = field_40139_a * 0.6F;
    }

    protected int func_40131_af()
    {
        return rand.nextInt(20) + 10;
    }

    protected EntityJungleSlime createInstance()
    {
        return new EntityJungleSlime(worldObj);
    }

    /**
     * Will get destroyed next tick
     */
    public void setEntityDead()
    {
        int i = getSlimeSize();

        if (!worldObj.isRemote && i > 1 && getEntityHealth() <= 0)
        {
            int j = 2 + rand.nextInt(3);

            for (int k = 0; k < j; k++)
            {
                float f = (((float)(k % 2) - 0.5F) * (float)i) / 4F;
                float f1 = (((float)(k / 2) - 0.5F) * (float)i) / 4F;
                EntityJungleSlime entityslime = createInstance();
                entityslime.setSlimeSize(i / 2);
                entityslime.setLocationAndAngles(posX + (double)f, posY + 0.5D, posZ + (double)f1, rand.nextFloat() * 360F, 0.0F);
                worldObj.spawnEntityInWorld(entityslime);
            }
        }

        super.setEntityDead();
    }

    /**
     * Called by a player entity when they collide with an entity
     */
    public void onCollideWithPlayer(EntityPlayer par1EntityPlayer)
    {
        if (func_40137_ah())
        {
            int i = getSlimeSize();

            if (canEntityBeSeen(par1EntityPlayer) && (double)getDistanceToEntity(par1EntityPlayer) < 0.6D * (double)i && par1EntityPlayer.attackEntityFrom(DamageSource.causeMobDamage(this), func_40130_ai()))
            {
                worldObj.playSoundAtEntity(this, "mob.slimeattack", 1.0F, (rand.nextFloat() - rand.nextFloat()) * 0.2F + 1.0F);
            }
        }
    }

    protected boolean func_40137_ah()
    {
        return getSlimeSize() > 1;
    }

    protected int func_40130_ai()
    {
        return getSlimeSize();
    }

    /**
     * Returns the sound this mob makes when it is hurt.
     */
    protected String getHurtSound()
    {
        return "mob.slime";
    }

    /**
     * Returns the sound this mob makes on death.
     */
    protected String getDeathSound()
    {
        return "mob.slime";
    }

    /**
     * Returns the item ID for the item the mob drops on death.
     */
    protected int getDropItemId()
    {
        if (getSlimeSize() == 1)
        {
            return Item.slimeBall.shiftedIndex;
        }
        else
        {
            return 0;
        }
    }

    /**
     * Checks if the entity's current position is a valid location to spawn this entity.
     */
    public boolean getCanSpawnHere()
    {
        if (worldObj.rand.nextInt(3) == 0)
        {
            return false;
        }

        if (worldObj.checkIfAABBIsClear(boundingBox) && worldObj.getCollidingBoundingBoxes(this, boundingBox).size() == 0 && !worldObj.isAnyLiquid(boundingBox))
        {
            int i = MathHelper.floor_double(posX);
            int j = MathHelper.floor_double(boundingBox.minY);
            int k = MathHelper.floor_double(posZ);

            if (j < 63)
            {
                return false;
            }

            int l = worldObj.getBlockId(i, j - 1, k);

            if (l == Block.grass.blockID || l == Block.leaves.blockID)
            {
                return true;
            }
        }

        return false;
    }
    /**
     * Returns the volume for the sounds this mob makes.
     */
    protected float getSoundVolume()
    {
        return 0.4F * (float)getSlimeSize();
    }

    /**
     * The speed it takes to move the entityliving's rotationPitch through the faceEntity method. This is only currently
     * use in wolves.
     */
    public int getVerticalFaceSpeed()
    {
        return 0;
    }

    protected boolean func_40133_ao()
    {
        return getSlimeSize() > 1;
    }

    protected boolean func_40134_ak()
    {
        return getSlimeSize() > 2;
    }
}