Custom spawn egg crash!

package net.minecraft.src;

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

public class EntityList
{
/** Provides a mapping between entity classes and a string */
private static Map stringToClassMapping = new HashMap();

/** Provides a mapping between a string and an entity classes */
private static Map classToStringMapping = new HashMap();

/** provides a mapping between an entityID and an Entity Class */
private static Map IDtoClassMapping = new HashMap();

/** provides a mapping between an Entity Class and an entity ID */
private static Map classToIDMapping = new HashMap();

/** Maps entity names to their numeric identifiers */
private static Map stringToIDMapping = new HashMap();

/** This is a HashMap of the Creative Entity Eggs/Spawners. */
public static HashMap entityEggs = new LinkedHashMap();

/**
* adds a mapping between Entity classes and both a string representation and an ID
*/
private static void addMapping(Class par0Class, String par1Str, int par2)
{
stringToClassMapping.put(par1Str, par0Class);
classToStringMapping.put(par0Class, par1Str);
IDtoClassMapping.put(Integer.valueOf(par2), par0Class);
classToIDMapping.put(par0Class, Integer.valueOf(par2));
stringToIDMapping.put(par1Str, Integer.valueOf(par2));
}

/**
* Adds a entity mapping with egg info.
*/
private static void addMapping(Class par0Class, String par1Str, int par2, int par3, int par4)
{
addMapping(par0Class, par1Str, par2);
entityEggs.put(Integer.valueOf(par2), new EntityEggInfo(par2, par3, par4));
}

/**
* Create a new instance of an entity in the world by using the entity name.
*/
public static Entity createEntityByName(String par0Str, World par1World)
{
Entity var2 = null;

try
{
Class var3 = (Class)stringToClassMapping.get(par0Str);

if (var3 != null)
{
var2 = (Entity)var3.getConstructor(new Class[] {World.class}).newInstance(new Object[] {par1World});
}
}
catch (Exception var4)
{
var4.printStackTrace();
}

return var2;
}

/**
* create a new instance of an entity from NBT store
*/
public static Entity createEntityFromNBT(NBTTagCompound par0NBTTagCompound, World par1World)
{
Entity var2 = null;

if ("Minecart".equals(par0NBTTagCompound.getString("id")))
{
switch (par0NBTTagCompound.getInteger("Type"))
{
case 0:
par0NBTTagCompound.setString("id", "MinecartRideable");
break;

case 1:
par0NBTTagCompound.setString("id", "MinecartChest");
break;

case 2:
par0NBTTagCompound.setString("id", "MinecartFurnace");
}

par0NBTTagCompound.removeTag("Type");
}

try
{
Class var3 = (Class)stringToClassMapping.get(par0NBTTagCompound.getString("id"));

if (var3 != null)
{
var2 = (Entity)var3.getConstructor(new Class[] {World.class}).newInstance(new Object[] {par1World});
}
}
catch (Exception var4)
{
var4.printStackTrace();
}

if (var2 != null)
{
var2.readFromNBT(par0NBTTagCompound);
}
else
{
par1World.getWorldLogAgent().logWarning("Skipping Entity with id " + par0NBTTagCompound.getString("id"));
}

return var2;
}

/**
* Create a new instance of an entity in the world by using an entity ID.
*/
public static Entity createEntityByID(int par0, World par1World)
{
Entity var2 = null;

try
{
Class var3 = getClassFromID(par0);

if (var3 != null)
{
var2 = (Entity)var3.getConstructor(new Class[] {World.class}).newInstance(new Object[] {par1World});
}
}
catch (Exception var4)
{
var4.printStackTrace();
}

if (var2 == null)
{
par1World.getWorldLogAgent().logWarning("Skipping Entity with id " + par0);
}

return var2;
}

/**
* gets the entityID of a specific entity
*/
public static int getEntityID(Entity par0Entity)
{
Class var1 = par0Entity.getClass();
return classToIDMapping.containsKey(var1) ? ((Integer)classToIDMapping.get(var1)).intValue() : 0;
}

/**
* Return the class assigned to this entity ID.
*/
public static Class getClassFromID(int par0)
{
return (Class)IDtoClassMapping.get(Integer.valueOf(par0));
}

/**
* Gets the string representation of a specific entity.
*/
public static String getEntityString(Entity par0Entity)
{
return (String)classToStringMapping.get(par0Entity.getClass());
}

/**
* Finds the class using IDtoClassMapping and classToStringMapping
*/
public static String getStringFromID(int par0)
{
Class var1 = getClassFromID(par0);
return var1 != null ? (String)classToStringMapping.get(var1) : null;
}

static
{
addMapping(EntityItem.class, "Item", 1);
addMapping(EntityXPOrb.class, "XPOrb", 2);
addMapping(EntityPainting.class, "Painting", 9);
addMapping(EntityArrow.class, "Arrow", 10);
addMapping(EntitySnowball.class, "Snowball", 11);
addMapping(EntityLargeFireball.class, "Fireball", 12);
addMapping(EntitySmallFireball.class, "SmallFireball", 13);
addMapping(EntityEnderPearl.class, "ThrownEnderpearl", 14);
addMapping(EntityEnderEye.class, "EyeOfEnderSignal", 15);
addMapping(EntityPotion.class, "ThrownPotion", 16);
addMapping(EntityExpBottle.class, "ThrownExpBottle", 17);
addMapping(EntityItemFrame.class, "ItemFrame", 18);
addMapping(EntityWitherSkull.class, "WitherSkull", 19);
addMapping(EntityTNTPrimed.class, "PrimedTnt", 20);
addMapping(EntityFallingSand.class, "FallingSand", 21);
addMapping(EntityFireworkRocket.class, "FireworksRocketEntity", 22);
addMapping(EntityBoat.class, "Boat", 41);
addMapping(EntityMinecartEmpty.class, "MinecartRideable", 42);
addMapping(EntityMinecartChest.class, "MinecartChest", 43);
addMapping(EntityMinecartFurnace.class, "MinecartFurnace", 44);
addMapping(EntityMinecartTNT.class, "MinecartTNT", 45);
addMapping(EntityMinecartHopper.class, "MinecartHopper", 46);
addMapping(EntityMinecartMobSpawner.class, "MinecartSpawner", 47);
addMapping(EntityLiving.class, "Mob", 48);
addMapping(EntityMob.class, "Monster", 49);
addMapping(EntityCreeper.class, "Creeper", 50, 894731, 0);
addMapping(EntitySkeleton.class, "Skeleton", 51, 12698049, 4802889);
addMapping(EntitySpider.class, "Spider", 52, 3419431, 11013646);
addMapping(EntityGiantZombie.class, "Giant", 53);
addMapping(EntityZombie.class, "Zombie", 54, 44975, 7969893);
addMapping(EntitySlime.class, "Slime", 55, 5349438, 8306542);
addMapping(EntityGhast.class, "Ghast", 56, 16382457, 12369084);
addMapping(EntityPigZombie.class, "PigZombie", 57, 15373203, 5009705);
addMapping(EntityEnderman.class, "Enderman", 58, 1447446, 0);
addMapping(EntityCaveSpider.class, "CaveSpider", 59, 803406, 11013646);
addMapping(EntitySilverfish.class, "Silverfish", 60, 7237230, 3158064);
addMapping(EntityBlaze.class, "Blaze", 61, 16167425, 16775294);
addMapping(EntityMagmaCube.class, "LavaSlime", 62, 3407872, 16579584);
addMapping(EntityDragon.class, "EnderDragon", 63);
addMapping(EntityWither.class, "WitherBoss", 64);
addMapping(EntityBat.class, "Bat", 65, 4996656, 986895);
addMapping(EntityWitch.class, "Witch", 66, 3407872, 5349438);
addMapping(EntityPig.class, "Pig", 90, 15771042, 14377823);
addMapping(EntitySheep.class, "Sheep", 91, 15198183, 16758197);
addMapping(EntityCow.class, "Cow", 92, 4470310, 10592673);
addMapping(EntityChicken.class, "Chicken", 93, 10592673, 16711680);
addMapping(EntitySquid.class, "Squid", 94, 2243405, 7375001);
addMapping(EntityWolf.class, "Wolf", 95, 14144467, 13545366);
addMapping(EntityMooshroom.class, "MushroomCow", 96, 10489616, 12040119);
addMapping(EntitySnowman.class, "SnowMan", 97);
addMapping(EntityOcelot.class, "Ozelot", 98, 15720061, 5653556);
addMapping(EntityIronGolem.class, "VillagerGolem", 99);
addMapping(EntityVillager.class, "Villager", 120, 5651507, 12422002);
addMapping(EntityEnderCrystal.class, "EnderCrystal", 200);
addMapping(EntitySilkie.class, "Silkie", 444, 12698049, 14377823);
}
}

package net.minecraft.src;

public class EntitySilkie extends EntityTameable
{
public boolean field_70885_d = false;
public float field_70886_e = 0.0F;
public float destPos = 0.0F;
public float field_70884_g;
public float field_70888_h;
public float field_70889_i = 1.0F;



public EntitySilkie(World par1World)
{
super(par1World);
this.texture = "/mob/silkie.png";
this.setSize(0.3F, 0.7F);
this.moveSpeed = 0.3F;
this.tasks.addTask(0, new EntityAISwimming(this));
this.tasks.addTask(1, new EntityAIPanic(this, 0.38F));
this.tasks.addTask(2, new EntityAITempt(this, 0.25F, Item.melon.itemID, false));
this.tasks.addTask(3, new EntityAIFollowParent(this, 0.28F));
this.tasks.addTask(4, new EntityAIWander(this, 0.5F));
this.tasks.addTask(5, new EntityAIWatchClosest(this, EntityPlayer.class, 6.0F));
this.tasks.addTask(6, new EntityAILookIdle(this));
this.tasks.addTask(7, new EntityAIFollowOwner(this, this.moveSpeed, 10.0F, 2.0F));
}

/**
* Returns true if the newer Entity AI code should be run
*/
public boolean isAIEnabled()
{
return true;
}

public int getMaxHealth()
{
return 7;
}

/**
* Called frequently so the entity can update its state every tick as required. For example, zombies and skeletons
* use this to react to sunlight and start to burn.
*/
public void onLivingUpdate()
{
super.onLivingUpdate();
this.field_70888_h = this.field_70886_e;
this.field_70884_g = this.destPos;
this.destPos = (float)((double)this.destPos + (double)(this.onGround ? -1 : 4) * 0.3D);

if (this.destPos < 0.0F)
{
this.destPos = 0.0F;
}

if (this.destPos > 1.0F)
{
this.destPos = 1.0F;
}

if (!this.onGround && this.field_70889_i < 1.0F)
{
this.field_70889_i = 1.0F;
}

this.field_70889_i = (float)((double)this.field_70889_i * 0.9D);

if (!this.onGround && this.motionY < 0.0D)
{
this.motionY *= 0.6D;
}

}

/**
* Called when the mob is falling. Calculates and applies fall damage.
*/

/**
* Returns the sound this mob makes while it's alive.
*/
protected String getLivingSound()
{
return "mob.worm.say";
}

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

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

/**
* Plays step sound at given x, y, z for the entity
*/
protected void playStepSound(int par1, int par2, int par3, int par4)
{
this.playSound("mob.chicken.step", 0.15F, 1.0F);
}

/**
* Returns the item ID for the item the mob drops on death.
*/
protected int getDropItemId()
{
return Item.slimeBall.itemID;
}

/**
* Drop 0-2 items of this living's type. @param par1 - Whether this entity has recently been hit by a player. @param
* par2 - Level of Looting used to kill this mob.
*/
protected void dropFewItems(boolean par1, int par2)
{
int var3 = this.rand.nextInt(3) + this.rand.nextInt(1 + par2);

for (int var4 = 0; var4 < var3; ++var4)
{
this.dropItem(Item.slimeBall.itemID, 1);
}

if (this.isBurning())
{
this.dropItem(Item.speckledMelon.itemID, 1);
}
else
{
this.dropItem(Item.melon.itemID, 1);
}
}

/**
* This function is used when two same-species animals in 'love mode' breed to generate the new baby animal.
*/
public EntitySilkie spawnBabyAnimal(EntityAgeable par1EntityAgeable)
{
return new EntitySilkie(this.worldObj);
}

/**
* Checks if the parameter is an item which this animal can be fed to breed it (wheat, carrots or seeds depending on
* the animal type)
*/
public boolean isBreedingItem(ItemStack par1ItemStack)
{
return par1ItemStack != null && par1ItemStack.itemID == Item.speckledMelon.itemID;
}

public EntityAgeable createChild(EntityAgeable par1EntityAgeable)
{
return this.spawnBabyAnimal(par1EntityAgeable);
}
}

<code>package net.minecraft.src;

public class RenderSilkie extends RenderLiving
{
public RenderSilkie()
{
super(new ModelSilkie(), 0.3F);
}

/**
* Return the silverfish's maximum death rotation.
*/
protected float getSilkieDeathRotation(EntitySilkie par1EntitySilkie)
{
return 180.0F;
}

/**
* Renders the silverfish.
*/
public void renderSilkie(EntitySilkie par1EntitySilkie, double par2, double par4, double par6, float par8, float par9)
{
super.doRenderLiving(par1EntitySilkie, par2, par4, par6, par8, par9);
}

/**
* Disallows the silverfish to render the renderPassModel.
*/
protected int shouldSilkieRenderPass(EntitySilkie par1EntitySilkie, int par2, float par3)
{
return -1;
}

protected float getDeathMaxRotation(EntityLiving par1EntityLiving)
{
return this.getSilkieDeathRotation((EntitySilkie)par1EntityLiving);
}

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

public void doRenderLiving(EntityLiving par1EntityLiving, double par2, double par4, double par6, float par8, float par9)
{
this.renderSilkie((EntitySilkie)par1EntityLiving, par2, par4, par6, par8, par9);
}

/**
* Actually renders the given argument. This is a synthetic bridge method, always casting down its argument and then
* handing it off to a worker function which does the actual work. In all probabilty, the class Render is generic
* (Render<T extends Entity) and this method has signature public void doRender(T entity, double d, double d1,
* double d2, float f, float f1). But JAD is pre 1.5 so doesn't do that.
*/
public void doRender(Entity par1Entity, double par2, double par4, double par6, float par8, float par9)
{
this.renderSilkie((EntitySilkie)par1Entity, par2, par4, par6, par8, par9);
}
}
</code>

<code>package net.minecraft.src;
//Exported java file
//Keep in mind that you still need to fill in some blanks
// - ZeuX

public class ModelSilkie extends ModelBase
{
public ModelSilkie()
{
Head = new ModelRenderer(this, 26, 0);
Head.addBox(-2F, -2F, -4F, 4, 4, 4, 0F);
Head.setRotationPoint(0F, 20F, -5F);
Head.rotateAngleX = 0.001046509F;
Head.rotateAngleY = 0F;
Head.rotateAngleZ = 0F;
Head.mirror = false;
Body = new ModelRenderer(this, 42, 0);
Body.addBox(-3F, -1.5F, -2F, 6, 6, 7, 0F);
Body.setRotationPoint(0F, 17.6F, -3F);
Body.rotateAngleX = 0F;
Body.rotateAngleY = 0F;
Body.rotateAngleZ = 0F;
Body.mirror = false;
Tail1 = new ModelRenderer(this, 68, 0);
Tail1.addBox(-2.5F, -1.866667F, 0F, 5, 5, 5, 0F);
Tail1.setRotationPoint(0F, 19F, 1F);
Tail1.rotateAngleX = 0F;
Tail1.rotateAngleY = 0F;
Tail1.rotateAngleZ = 0F;
Tail1.mirror = false;
Tail3 = new ModelRenderer(this, 104, 0);
Tail3.addBox(-1F, -1F, 0F, 2, 2, 2, 0F);
Tail3.setRotationPoint(0F, 20F, 10F);
Tail3.rotateAngleX = 0F;
Tail3.rotateAngleY = 0F;
Tail3.rotateAngleZ = 0F;
Tail3.mirror = false;
Tail2 = new ModelRenderer(this, 88, 0);
Tail2.addBox(-2F, -2F, 0F, 4, 4, 4, 0F);
Tail2.setRotationPoint(0F, 20F, 6F);
Tail2.rotateAngleX = 0F;
Tail2.rotateAngleY = 0F;
Tail2.rotateAngleZ = 0F;
Tail2.mirror = false;
AntennaL = new ModelRenderer(this, 20, 0);
AntennaL.addBox(0F, -2F, -2F, 0, 3, 3, 0F);
AntennaL.setRotationPoint(1F, 18F, -7.8F);
AntennaL.rotateAngleX = -0.07435722F;
AntennaL.rotateAngleY = -0.1858931F;
AntennaL.rotateAngleZ = 0.5114124F;
AntennaL.mirror = false;
Tail4 = new ModelRenderer(this, 112, 0);
Tail4.addBox(0F, -2F, 0F, 0, 3, 3, 0F);
Tail4.setRotationPoint(0F, 20F, 11.2F);
Tail4.rotateAngleX = 0F;
Tail4.rotateAngleY = 0F;
Tail4.rotateAngleZ = 0F;
Tail4.mirror = false;
AntennaR = new ModelRenderer(this, 20, 0);
AntennaR.addBox(0F, -2F, -2F, 0, 3, 3, 0F);
AntennaR.setRotationPoint(-1F, 18F, -7.8F);
AntennaR.rotateAngleX = 0F;
AntennaR.rotateAngleY = 0.1487144F;
AntennaR.rotateAngleZ = -0.4924101F;
AntennaR.mirror = false;
LegBackR = new ModelRenderer(this, 0, 0);
LegBackR.addBox(0F, 0F, 0F, 1, 2, 1, 0F);
LegBackR.setRotationPoint(-2F, 22F, 2F);
LegBackR.rotateAngleX = 0F;
LegBackR.rotateAngleY = 0F;
LegBackR.rotateAngleZ = 0F;
LegBackR.mirror = false;
LegFrontR = new ModelRenderer(this, 0, 0);
LegFrontR.addBox(-1F, 0F, 0F, 1, 2, 1, 0F);
LegFrontR.setRotationPoint(-2F, 22F, -5F);
LegFrontR.rotateAngleX = 0F;
LegFrontR.rotateAngleY = 0F;
LegFrontR.rotateAngleZ = 0F;
LegFrontR.mirror = false;
LegFrontL = new ModelRenderer(this, 0, 0);
LegFrontL.addBox(0F, 0F, 0F, 1, 2, 1, 0F);
LegFrontL.setRotationPoint(2F, 22F, -5F);
LegFrontL.rotateAngleX = 0F;
LegFrontL.rotateAngleY = 0F;
LegFrontL.rotateAngleZ = 0F;
LegFrontL.mirror = false;
LegMid2R = new ModelRenderer(this, 0, 0);
LegMid2R.addBox(-1F, 0F, 0F, 1, 2, 1, 0F);
LegMid2R.setRotationPoint(-2F, 22F, 0F);
LegMid2R.rotateAngleX = 0F;
LegMid2R.rotateAngleY = 0F;
LegMid2R.rotateAngleZ = 0F;
LegMid2R.mirror = false;
LegBackL = new ModelRenderer(this, 0, 0);
LegBackL.addBox(-1F, 0F, 0F, 1, 2, 1, 0F);
LegBackL.setRotationPoint(2F, 22F, 2F);
LegBackL.rotateAngleX = 0F;
LegBackL.rotateAngleY = 0F;
LegBackL.rotateAngleZ = 0F;
LegBackL.mirror = false;
LegMid1R = new ModelRenderer(this, 0, 0);
LegMid1R.addBox(-1F, 0F, 0F, 1, 2, 1, 0F);
LegMid1R.setRotationPoint(-2F, 22F, -2F);
LegMid1R.rotateAngleX = 0F;
LegMid1R.rotateAngleY = 0F;
LegMid1R.rotateAngleZ = 0F;
LegMid1R.mirror = false;
LegMid1L = new ModelRenderer(this, 0, 0);
LegMid1L.addBox(0F, 0F, 0F, 1, 2, 1, 0F);
LegMid1L.setRotationPoint(2F, 22F, -2F);
LegMid1L.rotateAngleX = 0F;
LegMid1L.rotateAngleY = 0F;
LegMid1L.rotateAngleZ = 0F;
LegMid1L.mirror = false;
LegMid2L = new ModelRenderer(this, 0, 0);
LegMid2L.addBox(0F, 0F, 0F, 1, 2, 1, 0F);
LegMid2L.setRotationPoint(2F, 22F, 0F);
LegMid2L.rotateAngleX = 0F;
LegMid2L.rotateAngleY = 0F;
LegMid2L.rotateAngleZ = 0F;
LegMid2L.mirror = false;
}

public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
{
super.render(entity, f, f1, f2, f3, f4, f5);
setRotationAngles(f, f1, f2, f3, f4, f5, entity);
Head.render(f5);
Body.render(f5);
Tail1.render(f5);
Tail3.render(f5);
Tail2.render(f5);
AntennaL.render(f5);
Tail4.render(f5);
AntennaR.render(f5);
LegBackR.render(f5);
LegFrontR.render(f5);
LegFrontL.render(f5);
LegMid2R.render(f5);
LegBackL.render(f5);
LegMid1R.render(f5);
LegMid1L.render(f5);
LegMid2L.render(f5);
}

public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
{
super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
}

//fields
public ModelRenderer Head;
public ModelRenderer Body;
public ModelRenderer Tail1;
public ModelRenderer Tail3;
public ModelRenderer Tail2;
public ModelRenderer AntennaL;
public ModelRenderer Tail4;
public ModelRenderer AntennaR;
public ModelRenderer LegBackR;
public ModelRenderer LegFrontR;
public ModelRenderer LegFrontL;
public ModelRenderer LegMid2R;
public ModelRenderer LegBackL;
public ModelRenderer LegMid1R;
public ModelRenderer LegMid1L;
public ModelRenderer LegMid2L;
}
</code>