@Mod(modid = Reference.MOD_ID, name = Reference.MOD_NAME, version = Reference.VERSION)
public class PvZ implements IFuelHandler, IGuiHandler {
	
	public static final Logger log = Logger.getLogger(Reference.MOD_ID);
	@Mod.Instance(Reference.MOD_ID)
	public static PvZ instance = new PvZ();
	@SidedProxy(clientSide = Reference.CLIENT_PROXY_CLASS,
			serverSide = Reference.SERVER_PROXY_CLASS)
	public static ServerProxy proxy;
	
	// ~Items~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	public static Item peaPod;
	public static Item snowPod;
	public static Item shroomPod;
	public static Item creeperPod;
	public static Item sunlight;
	public static Item chlorophyll;
	public static Item moonlight;
	public static Item trowel;
	public static Item transTrowel;
	public static Item basicPlants;
	public static Item nightPlants;
	public static Item specialPlants;
	public static int[] specialPlantIDs;
	public static Item guideBook;
	public static Item footballHelm;
	public static Item footballChest;
	public static Item footballLegs;
	public static Item footballBoots;
	public static Item flag;
	// ~Blocks~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	public static Block endowedGrass;
	public static String endowedGrass_top_Tex = Reference.BASE_TEX + "endowedGrass_Top";
	public static String endowedGrass_bottom_Tex = Reference.BASE_TEX + "endowedGrass_Bottom";
	public static String endowedGrass_side_Tex = Reference.BASE_TEX + "endowedGrass_Side";
	public static Block darkenedGrass;
	public static String darkenedGrass_top_Tex = Reference.BASE_TEX + "darkenedGrass_Top";
	public static String darkenedGrass_bottom_Tex = Reference.BASE_TEX + "darkenedGrass_Bottom";
	public static String darkenedGrass_side_Tex = Reference.BASE_TEX + "darkenedGrass_Side";
	public static Block chlorophyllBowl;
	public static String chlorophyllBowl_Empty_Tex = "/mods/CountryGamer_PlantsVsZombies/textures/blocks/Bowl Empty.png";
	public static String chlorophyllBowl_Filled_Tex = ":assets:" + Reference.BASE_TEX
			+ "textures:blocks:bowlFilled.png";
	public static Block gravestone;
	public static Block gravestoneReg;
	public static Block gravestoneFootball;
	public static Block gravestoneFlag;
	public static Block gravestoneCone;
	public static Block gravestoneBucket;
	public static Block[] gravestones = {
			gravestone, gravestoneReg, gravestoneFootball, gravestoneFlag, gravestoneCone,
			gravestoneBucket
	};
	public static String[] gravestoneStr = {
			"", "Regular", "Football", "Flag", "Cone", "Bucket"
	};
	public static Block greenhouse;
	
	// Plants
	public static final String[] basicDayNames = {
			"Sunflower", "Pea Shooter", "Snow Pea", "Repeater", "Three-Peater"
	};
	public static Class<? extends TileEntityPlant>[] basicDayTiles = new Class[] {
			TileEntitySunflower.class, TileEntityPeaShooter.class, TileEntitySnowPea.class,
			TileEntityRepeater.class, TileEntityThreePeater.class
	};
	public static BlockPlant[] basicDayPlants = new BlockPlant[PvZ.basicDayNames.length];
	
	// ~Other~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	public static int sunlightTimer;
	public static boolean holdSunlight;
	public static int basePodDamage;
	public static int basePlantHealth;
	public static int zombieSpawnDelay;
	public static boolean crops;
	public static double creeperPodRad;
	public static EnumCreatureAttribute plantAttribute = EnumHelper.addCreatureAttribute("PLANT");
	public static ItemArmor.ArmorMaterial footballArmor = EnumHelper.addArmorMaterial(
			"FOOTBALL_ARMOR", 12, new int[] {
					1, 4, 3, 1
			}, 0);
	// ~Packet~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	public static final PacketPipeline packetChannel = new PacketPipeline();
	
	public static Block sunflower;
	
	@Mod.EventHandler
	public void preInit(FMLPreInitializationEvent event) {
		this.doPreProxyThings();
		this.setupConfig(event);
		this.doProxyThings();
		this.registerHandlers();
		this.registerItems();
		proxy.registerItemRender();
		this.registerBlocks();
		this.registerCraftingRecipes();
		this.registerSmeltingRecipes();
		this.registerHarvestLevel();
		this.registerEntities();
		this.biomes();
		
	}
	
	public void doPreProxyThings() {
		proxy.registerRender();
	}
	
	public void setupConfig(FMLPreInitializationEvent event) {
		String general = "general";
		
		Configuration config = new Configuration(event.getSuggestedConfigurationFile());
		config.load();
		
		sunlightTimer = config.get(general, "Minutes between sunlight production", 5).getInt();
		basePodDamage = config.get(general, "Basic damage of a Pea Pod", 4).getInt();
		basePlantHealth = config.get(general, "Base health of all Plants", 2).getInt();
		zombieSpawnDelay = config.get(general,
				"Minutes in between waves of zombies. (Whole numbers only!)", 10).getInt();
		creeperPodRad = config.get(general, "Creeper Pod Explosion Radius", 1.0D).getDouble(1.0D);
		
		config.save();
	}
	
	public void doProxyThings() {
		proxy.registerThings();
	}
	
	public void registerHandlers() {
		MinecraftForge.EVENT_BUS.register(this);
		NetworkRegistry.INSTANCE.registerGuiHandler(this, this);
		
	}
	
	public void registerItems() {
		this.registerArmor();
		
		PvZ.chlorophyll = new ItemChlorophyll(Reference.MOD_ID, "Chlorophyll");
		Core.addItemToTab(PvZ.chlorophyll);
		
		PvZ.sunlight = new ItemSunlight(Reference.MOD_ID, "Sunlight");
		Core.addItemToTab(PvZ.sunlight);
		
		PvZ.moonlight = new ItemMoonlight(Reference.MOD_ID, "moonlight");
		Core.addItemToTab(PvZ.moonlight);
		
		PvZ.trowel = new ItemTrowel(Reference.MOD_ID, "trowel", 2.0F, Item.ToolMaterial.IRON,
				new Block[] {
						Blocks.dirt, Blocks.grass
				});
		Core.addItemToTab(PvZ.trowel);
		
		PvZ.transTrowel = new ItemTransTrowel(Reference.MOD_ID, "transtrowel", 2.0F,
				Item.ToolMaterial.IRON, new Block[] {
						Blocks.dirt, Blocks.grass
				});
		Core.addItemToTab(PvZ.transTrowel);
		
		PvZ.basicPlants = new ItemBasicPlants(Reference.MOD_ID);
		Core.addItemToTab(PvZ.basicPlants);
		
		PvZ.nightPlants = new ItemNightPlants(Reference.MOD_ID);
		Core.addItemToTab(PvZ.nightPlants);
		
		PvZ.peaPod = new ItemPeaPod(Reference.MOD_ID, "PeaPod");
		Core.addItemToTab(PvZ.peaPod);
		
		PvZ.snowPod = new ItemSnowPod(Reference.MOD_ID, "SnowPod");
		Core.addItemToTab(PvZ.snowPod);
		
		PvZ.shroomPod = new ItemShroomPod(Reference.MOD_ID, "ShroomPod");
		Core.addItemToTab(PvZ.shroomPod);
		
	}
	
	public void registerArmor() {
		int footBallMat = proxy.addArmor("football");
		
		PvZ.footballHelm = new ItemFootballHelm(Reference.MOD_ID, "football_helmet", footballArmor,
				0, footBallMat);
		Core.addItemToTab(PvZ.footballHelm);
		
		PvZ.footballChest = new ItemFootballChest(Reference.MOD_ID, "football_chest",
				footballArmor, 1, footBallMat);
		Core.addItemToTab(PvZ.footballChest);
		
		PvZ.footballLegs = new ItemFootballLegs(Reference.MOD_ID, "football_legs", footballArmor,
				2, footBallMat);
		Core.addItemToTab(PvZ.footballLegs);
		
		PvZ.footballBoots = new ItemFootballBoots(Reference.MOD_ID, "football_boots",
				footballArmor, 3, footBallMat);
		Core.addItemToTab(PvZ.footballBoots);
		
		PvZ.flag = new ItemFlag(Reference.MOD_ID, "flag");
		Core.addItemToTab(PvZ.flag);
		
	}
	
	public void registerBlocks() {
		PvZ.endowedGrass = new BlockEndowedGrass(Material.grass, Reference.MOD_ID, "endowedGrass")
				.setHardness(0.6F).setStepSound(Block.soundTypeGrass);
		Core.addBlockToTab(PvZ.endowedGrass);
		
		PvZ.darkenedGrass = new BlockDarkenedGrass(Material.grass, Reference.MOD_ID,
				"darkenedGrass").setHardness(0.6F).setStepSound(Block.soundTypeGrass);
		Core.addBlockToTab(PvZ.darkenedGrass);
		
		TileEntity.addMapping(TileEntityChlorophyllBowl.class, Reference.MOD_ID
				+ "_ChlorophyllBowl");
		PvZ.chlorophyllBowl = new BlockChlorophyllBowl(Material.wood, Reference.MOD_ID,
				"chlorophyllBowl", TileEntityChlorophyllBowl.class).setHardness(0.2F)
				.setResistance(3.0F);
		Core.addBlockToTab(PvZ.chlorophyllBowl);
		
		TileEntity.addMapping(TileEntityGreenhouse.class, Reference.MOD_ID + "_Greenhouse");
		PvZ.greenhouse = new BlockGreenhouse(Material.rock, Reference.MOD_ID, "greenhouse",
				TileEntityGreenhouse.class).setHardness(0.2F).setResistance(3.0F);
		Core.addBlockToTab(PvZ.greenhouse);
		
		/*
		for (int i = 0; i < PvZ.basicDayNames.length; i++) {
			String name = PvZ.basicDayNames[i];
			Class<? extends TileEntityPlant> tileEntClass = PvZ.basicDayTiles[i];
			
			TileEntity.addMapping(tileEntClass, Reference.MOD_ID + "_" + name);
			PvZ.basicDayPlants[i] = new BlockPlant(Material.plants, Reference.MOD_ID, name,
					tileEntClass);
			Core.addBlockToTab(PvZ.basicDayPlants[i]);
			
		}
		*/
		
	}
	
	public void registerCraftingRecipes() {
		GameRegistry.addRecipe(new ItemStack(peaPod, 1), new Object[] {
				" x ", "xxx", " x ", Character.valueOf('x'), chlorophyll
		});
		
		GameRegistry.addRecipe(new ItemStack(snowPod, 1), new Object[] {
				" x ", "xcx", " x ", Character.valueOf('x'), chlorophyll, Character.valueOf('c'),
				Items.snowball
		});
		
		GameRegistry.addRecipe(new ItemStack(shroomPod, 1), new Object[] {
				" x ", "xcx", " x ", Character.valueOf('x'), chlorophyll, Character.valueOf('c'),
				moonlight
		});
		
		GameRegistry.addRecipe(new ItemStack(chlorophyllBowl, 1), new Object[] {
				" x ", "xcx", " x ", Character.valueOf('x'), chlorophyll, Character.valueOf('c'),
				Items.bowl
		});
		
		Object[] chloIngred = {
				Blocks.tallgrass, Blocks.leaves, Items.wheat_seeds, Items.carrot, Items.potato,
				Blocks.cactus
		};
		
		int[] chloResult = {
				3, 4, 2, 2, 2, 5
		};
		
		if (chloIngred.length == chloResult.length) {
			for (int i = 0; i < chloIngred.length; i++) {
				GameRegistry.addShapelessRecipe(new ItemStack(chlorophyll, chloResult[i]),
						new Object[] {
							chloIngred[i]
						});
			}
		}
		else {
			GameRegistry.addShapelessRecipe(new ItemStack(sunlight, 1), new Object[] {
				chlorophyll
			});
		}
		
		GameRegistry.addRecipe(
				new ItemStack(trowel, 1),
				new Object[] {
						" x ", "xxx", " c ", Character.valueOf('x'), Items.iron_ingot,
						Character.valueOf('c'), Items.stick
				});
		
		GameRegistry.addShapelessRecipe(new ItemStack(transTrowel, 1), new Object[] {
				trowel, sunlight
		});
		
		GameRegistry.addRecipe(
				new ItemStack(greenhouse, 1),
				new Object[] {
						"xxx", "x x", "vcv", Character.valueOf('x'), Blocks.glass_pane,
						Character.valueOf('v'), Blocks.cobblestone, Character.valueOf('c'),
						Blocks.dirt
				});
	}
	
	public void registerSmeltingRecipes() {
	}
	
	public void registerHarvestLevel() {
		PvZ.trowel.setHarvestLevel("shovel", 2);
		PvZ.transTrowel.setHarvestLevel("shovel", 5);
		
		PvZ.chlorophyllBowl.setHarvestLevel("axe", 0);
		PvZ.greenhouse.setHarvestLevel("pickaxe", 0);
		// gravestone.setHarvestLevel("pickaxe", 2);
	}
	
	public void registerEntities() {
		int throwEntityID = 5;
		throwEntityID++;
		EntityRegistry.registerModEntity(EntityPeaPod.class, "Pea Pod", throwEntityID, this, 64, 1,
				true);
		
		throwEntityID++;
		EntityRegistry.registerModEntity(EntitySnowPod.class, "Snow Pod", throwEntityID, this, 64,
				1, true);
		
		throwEntityID++;
		EntityRegistry.registerModEntity(EntitySunlight.class, "Sunlight", throwEntityID, this, 64,
				1, true);
		
		throwEntityID++;
		EntityRegistry.registerModEntity(EntityMoonlight.class, "Moonlight", throwEntityID, this,
				64, 1, true);
		
		throwEntityID++;
		EntityRegistry.registerModEntity(EntityShroomPod.class, "Shroom Pod", throwEntityID, this,
				64, 1, true);
		
		throwEntityID++;
		EntityRegistry.registerModEntity(EntityCreeperPod.class, "Creeper Pod", throwEntityID,
				this, 64, 1, true);
		
		EntDec.mobEnts();
	}
	
	public void biomes() {
	}
	
	@Mod.EventHandler
	public void init(FMLInitializationEvent event) {
		this.packetChannel.initalise(Reference.MOD_ID);
		
	}
	
	@Mod.EventHandler
	public void postInit(FMLPostInitializationEvent event) {
		this.packetChannel.postInitialise();
	}
	
	// ~Events~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	/*
	@SubscribeEvent
	public void onEntityUpdate(LivingEvent.LivingUpdateEvent event) {
		EntityLivingBase targetEntity = event.entityLiving;

		if (targetEntity.isPotionActive(PvZ.empower)) {
			if ((targetEntity.worldObj.rand.nextInt(20) != 0)
					|| (targetEntity.getCreatureAttribute() == PvZ.plantAttribute)) {
				((EntityPlantBase) targetEntity)
				.heal(((EntityPlantBase) targetEntity).getMaxHealth());
			} else if (!(targetEntity instanceof EntityZombie)) {
				if ((targetEntity instanceof EntityPlayer)) {
					((EntityPlayer) targetEntity)
					.heal(((EntityPlayer) targetEntity).getMaxHealth());
				}

			}

			if (targetEntity.getActivePotionEffect(PvZ.empower).getDuration() == 0) {
				targetEntity.removePotionEffect(PvZ.empower.id);
				return;
			}
		}
	}
	 */
	// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	// ~Fuel Handler~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	@Override
	public int getBurnTime(ItemStack fuel) {
		return 0;
	}
	
	// ~Gui Handler~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	@Override
	public Object getServerGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) {
		TileEntity tileEnt = world.getTileEntity(x, y, z);
		if ((tileEnt instanceof TileEntityGreenhouse)) {
			return new ContainerGreenhouse(player.inventory, (TileEntityGreenhouse) tileEnt);
		}
		return null;
	}
	
	@Override
	public Object getClientGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) {
		TileEntity tileEnt = world.getTileEntity(x, y, z);
		if ((tileEnt instanceof TileEntityGreenhouse)) {
			return new GuiGreenhouse(player.inventory, (TileEntityGreenhouse) tileEnt);
		}
		if (ID == 3) {
			return new GuiGuide((ItemGuideBook) player.inventory.getCurrentItem().getItem());
		}
		return null;
	}
	
	public void gravestones() {
		GameRegistry.registerTileEntity(TileEntityGravestone.class, "Gravestone");
		
		gravestone = new BlockGravestone(0, Reference.MOD_ID, "gravestone",
				TileEntityGravestone.class);
		GameRegistry.registerBlock(gravestone, "gravestone");
		
		gravestoneReg = new BlockGravestone(1, Reference.MOD_ID, "gravestoneReg",
				TileEntityGravestone.class);
		GameRegistry.registerBlock(gravestoneReg, "gravestoneReg");
		
		gravestoneFootball = new BlockGravestone(2, Reference.MOD_ID, "gravestoneFootball",
				TileEntityGravestone.class);
		GameRegistry.registerBlock(gravestoneFootball, "gravestoneFootball");
		
		gravestoneFlag = new BlockGravestone(3, Reference.MOD_ID, "gravestoneFlag",
				TileEntityGravestone.class);
		GameRegistry.registerBlock(gravestoneFlag, "gravestoneFlag");
		
		gravestoneCone = new BlockGravestone(4, Reference.MOD_ID, "gravestoneCone",
				TileEntityGravestone.class);
		GameRegistry.registerBlock(gravestoneCone, "gravestoneCone");
		
		gravestoneBucket = new BlockGravestone(5, Reference.MOD_ID, "gravestoneBucket",
				TileEntityGravestone.class);
		GameRegistry.registerBlock(gravestoneBucket, "gravestoneBucket");
		
		gravestoneCraft();
	}
	
	public void gravestoneCraft() {
		GameRegistry.addRecipe(new ItemStack(gravestoneReg, 1), new Object[] {
				"xxx", "xcx", "xxx", Character.valueOf('c'), gravestone, Character.valueOf('x'),
				Items.rotten_flesh
		});
		
		GameRegistry.addShapelessRecipe(new ItemStack(gravestoneFootball, 1), new Object[] {
				gravestone, footballHelm, footballChest, footballLegs, footballBoots
		});
		
		GameRegistry.addShapelessRecipe(new ItemStack(gravestoneFlag, 1), new Object[] {
				gravestone, flag
		});
		
		GameRegistry.addShapelessRecipe(new ItemStack(gravestoneCone, 1), new Object[] {
			gravestone
		});
		
		GameRegistry.addShapelessRecipe(new ItemStack(gravestoneBucket, 1), new Object[] {
				gravestone, Items.bucket
		});
		
		GameRegistry.addRecipe(new ItemStack(gravestone, 1), new Object[] {
				"xx", "cc", "vv", Character.valueOf('x'), Blocks.stone, Character.valueOf('c'),
				darkenedGrass, Character.valueOf('v'), Items.rotten_flesh
		});
	}
	
} public class TileEntityPeaShooter extends TileEntityBase {
	
	public TileEntityPeaShooter() {
		
	}
	
} public class TileEntityRepeater extends TileEntityBase {
	
	public TileEntityRepeater() {
		
	}
	
} public class TileEntitySnowPea extends TileEntityBase {
	
	public TileEntitySnowPea() {
		
	}
	
} public class TileEntitySunflower extends TileEntityBase {
	
	public TileEntitySunflower() {
		
	}
	
} public class TileEntityThreePeater extends TileEntityBase {
	
	public TileEntityThreePeater() {
		
	}
	
} @SideOnly(Side.CLIENT)
public class RenderPlant extends TileEntitySpecialRenderer {
	
	protected ModelBase	model;
	private ResourceLocation texture;
	
	public RenderPlant(ModelBase model, ResourceLocation texture){
		this.model = model;
		this.texture = texture;
		
	}
		
	@Override
	public void renderTileEntityAt(TileEntity tileEnt, double x, double y, double z, float f) {
		GL11.glPushMatrix();
		int metadata = tileEnt.getBlockMetadata();
		int rotationAngleModel = 0;
		if (metadata % 4 == 0) {
			rotationAngleModel = 0;
		}
		if (metadata % 4 == 1) {
			rotationAngleModel = 270;
		}
		if (metadata % 4 == 2) {
			rotationAngleModel = 180;
		}
		if (metadata % 4 == 3) {
			rotationAngleModel = 90;
		}
		GL11.glTranslatef((float) x + 0.5F, (float) y + 1.5F, (float) z + 0.5F);
		
		GL11.glRotatef(180.0F, 0.0F, 0.0F, 1.0F);
		//GL11.glRotatef(rotationAngleModel, 0.0F, 1.0F, 0.0F);
		
		this.bindTexture(this.texture);
		
		this.model.renderModel(0.0625F);
		GL11.glPopMatrix();
	}
	
} public class ModelPeaShooter extends ModelBase {
	ModelRenderer	Stem;
	ModelRenderer	Head;
	ModelRenderer	Mouth;
	ModelRenderer	Head_Leaf;
	ModelRenderer	Shape1;
	ModelRenderer	Shape2;
	
	public ModelPeaShooter() {
		super(64, 64);
		
		this.Stem = new ModelRenderer(this, 6, 10);
		this.Stem.addBox(-1.0F, -10.0F, -1.0F, 2, 11, 2);
		this.Stem.setRotationPoint(0.0F, 23.0F, 0.0F);
		this.Stem.setTextureSize(64, 64);
		this.Stem.mirror = true;
		setRotation(this.Stem, 0.0F, 0.0F, 0.0F);
		this.modelList.add(this.Stem);
		
		this.Head = new ModelRenderer(this, 0, 0);
		this.Head.addBox(-2.5F, -5.0F, -2.5F, 5, 5, 5);
		this.Head.setRotationPoint(0.0F, 13.0F, 0.0F);
		this.Head.setTextureSize(64, 64);
		this.Head.mirror = true;
		setRotation(this.Head, 0.0F, 0.0F, 0.0F);
		this.modelList.add(this.Head);
		
		this.Mouth = new ModelRenderer(this, 20, 4);
		this.Mouth.addBox(-1.5F, -1.5F, -3.0F, 3, 3, 3);
		this.Mouth.setRotationPoint(0.0F, 11.5F, -2.5F);
		this.Mouth.setTextureSize(64, 64);
		this.Mouth.mirror = true;
		setRotation(this.Mouth, 0.0F, 0.0F, 0.0F);
		this.modelList.add(this.Mouth);
		
		this.Head_Leaf = new ModelRenderer(this, 20, 0);
		this.Head_Leaf.addBox(-0.5F, -0.5F, 0.0F, 1, 1, 3);
		this.Head_Leaf.setRotationPoint(0.0F, 9.0F, 2.0F);
		this.Head_Leaf.setTextureSize(64, 64);
		this.Head_Leaf.mirror = true;
		setRotation(this.Head_Leaf, 0.7853982F, 0.0F, 0.0F);
		this.modelList.add(this.Head_Leaf);
		
		this.Shape1 = new ModelRenderer(this, 0, 23);
		this.Shape1.addBox(0.0F, -0.5F, -5.0F, 5, 1, 5);
		this.Shape1.setRotationPoint(0.0F, 23.0F, 0.0F);
		this.Shape1.setTextureSize(64, 64);
		this.Shape1.mirror = true;
		setRotation(this.Shape1, -0.1745329F, -0.1745329F, -0.261799F);
		this.modelList.add(this.Shape1);
		
		this.Shape2 = new ModelRenderer(this, 0, 23);
		this.Shape2.addBox(-5.0F, -0.5F, -5.0F, 5, 1, 5);
		this.Shape2.setRotationPoint(0.0F, 23.0F, 0.0F);
		this.Shape2.setTextureSize(64, 64);
		this.Shape2.mirror = true;
		setRotation(this.Shape2, -0.261799F, 0.1745329F, 0.1745329F);
		this.modelList.add(this.Shape2);
		
	}
	
	
} public class ModelRepeater extends ModelBase {
	ModelRenderer Stem;
	ModelRenderer Head;
	ModelRenderer Mouth;
	ModelRenderer HLzTzR;
	ModelRenderer LEAFzL;
	ModelRenderer LEAFzR;
	ModelRenderer HLzTzL;
	ModelRenderer HLzLzC;
	ModelRenderer HLzRzC;
	
	public ModelRepeater() {
		super(64, 64);
		
		this.Stem = new ModelRenderer(this, 6, 10);
		this.Stem.addBox(-1.0F, -10.0F, -1.0F, 2, 11, 2);
		this.Stem.setRotationPoint(0.0F, 23.0F, 0.0F);
		this.Stem.setTextureSize(64, 64);
		this.Stem.mirror = true;
		setRotation(this.Stem, 0.0F, 0.0F, 0.0F);
		this.modelList.add(this.Stem);
		
		this.Head = new ModelRenderer(this, 0, 0);
		this.Head.addBox(-2.5F, -5.0F, -2.5F, 5, 5, 5);
		this.Head.setRotationPoint(0.0F, 13.0F, 0.0F);
		this.Head.setTextureSize(64, 64);
		this.Head.mirror = true;
		setRotation(this.Head, 0.0F, 0.0F, 0.0F);
		this.modelList.add(this.Head);
		
		this.Mouth = new ModelRenderer(this, 20, 4);
		this.Mouth.addBox(-1.5F, -1.5F, -3.0F, 3, 3, 3);
		this.Mouth.setRotationPoint(0.0F, 11.5F, -2.5F);
		this.Mouth.setTextureSize(64, 64);
		this.Mouth.mirror = true;
		setRotation(this.Mouth, 0.0F, 0.0F, 0.0F);
		this.modelList.add(this.Mouth);
		
		this.HLzTzR = new ModelRenderer(this, 20, 0);
		this.HLzTzR.addBox(-0.5F, -0.5F, 0.0F, 1, 1, 3);
		this.HLzTzR.setRotationPoint(-1.5F, 9.0F, 2.0F);
		this.HLzTzR.setTextureSize(64, 64);
		this.HLzTzR.mirror = true;
		setRotation(this.HLzTzR, 0.7853982F, 0.0F, 0.0F);
		this.modelList.add(this.HLzTzR);
		
		this.LEAFzL = new ModelRenderer(this, 0, 23);
		this.LEAFzL.addBox(0.0F, -0.5F, -5.0F, 5, 1, 5);
		this.LEAFzL.setRotationPoint(0.0F, 23.0F, 0.0F);
		this.LEAFzL.setTextureSize(64, 64);
		this.LEAFzL.mirror = true;
		setRotation(this.LEAFzL, -0.1745329F, -0.1745329F, -0.261799F);
		this.modelList.add(this.LEAFzL);
		
		this.LEAFzR = new ModelRenderer(this, 0, 23);
		this.LEAFzR.addBox(-5.0F, -0.5F, -5.0F, 5, 1, 5);
		this.LEAFzR.setRotationPoint(0.0F, 23.0F, 0.0F);
		this.LEAFzR.setTextureSize(64, 64);
		this.LEAFzR.mirror = true;
		setRotation(this.LEAFzR, -0.261799F, 0.1745329F, 0.1745329F);
		this.modelList.add(this.LEAFzR);
		
		this.HLzTzL = new ModelRenderer(this, 20, 0);
		this.HLzTzL.addBox(-0.5F, -0.5F, 0.0F, 1, 1, 3);
		this.HLzTzL.setRotationPoint(1.5F, 9.0F, 2.0F);
		this.HLzTzL.setTextureSize(64, 64);
		this.HLzTzL.mirror = true;
		setRotation(this.HLzTzL, 0.7853982F, 0.0F, 0.0F);
		this.modelList.add(this.HLzTzL);
		
		this.HLzLzC = new ModelRenderer(this, 20, 0);
		this.HLzLzC.addBox(-0.5F, -0.5F, 0.0F, 1, 1, 3);
		this.HLzLzC.setRotationPoint(2.0F, 10.0F, 2.0F);
		this.HLzLzC.setTextureSize(64, 64);
		this.HLzLzC.mirror = true;
		setRotation(this.HLzLzC, 0.349066F, 0.0F, 1.570796F);
		this.modelList.add(this.HLzLzC);
		
		this.HLzRzC = new ModelRenderer(this, 20, 0);
		this.HLzRzC.addBox(-0.5F, -0.5F, 0.0F, 1, 1, 3);
		this.HLzRzC.setRotationPoint(-2.0F, 10.0F, 2.0F);
		this.HLzRzC.setTextureSize(64, 64);
		this.HLzRzC.mirror = true;
		setRotation(this.HLzRzC, 0.349066F, 0.0F, -1.570796F);
		this.modelList.add(this.HLzRzC);
		
	}
	
} public class ModelSnowPea extends ModelBase {
	ModelRenderer Stem;
	ModelRenderer Head;
	ModelRenderer Mouth;
	ModelRenderer LEAFzL;
	ModelRenderer LEAFzR;
	ModelRenderer HLzTzL;
	ModelRenderer HLzTzR;
	ModelRenderer HLzLzT;
	ModelRenderer HLzTzC;
	ModelRenderer HLzLzB;
	ModelRenderer HLzRzT;
	ModelRenderer HLzRzB;
	ModelRenderer HLzBzC;
	ModelRenderer HLzBzR;
	ModelRenderer HLzBzL;
	
	public ModelSnowPea() {
		super(64, 64);
		
		this.Stem = new ModelRenderer(this, 6, 10);
		this.Stem.addBox(-1.0F, -10.0F, -1.0F, 2, 11, 2);
		this.Stem.setRotationPoint(0.0F, 23.0F, 0.0F);
		this.Stem.setTextureSize(64, 64);
		this.Stem.mirror = true;
		setRotation(this.Stem, 0.0F, 0.0F, 0.0F);
		this.modelList.add(this.Stem);
		
		this.Head = new ModelRenderer(this, 0, 0);
		this.Head.addBox(-2.5F, -5.0F, -2.5F, 5, 5, 5);
		this.Head.setRotationPoint(0.0F, 13.0F, 0.0F);
		this.Head.setTextureSize(64, 64);
		this.Head.mirror = true;
		setRotation(this.Head, 0.0F, 0.0F, 0.0F);
		this.modelList.add(this.Head);
		
		this.Mouth = new ModelRenderer(this, 20, 4);
		this.Mouth.addBox(-1.5F, -1.5F, -3.0F, 3, 3, 3);
		this.Mouth.setRotationPoint(0.0F, 11.5F, -2.5F);
		this.Mouth.setTextureSize(64, 64);
		this.Mouth.mirror = true;
		setRotation(this.Mouth, 0.0F, 0.0F, 0.0F);
		this.modelList.add(this.Mouth);
		
		this.LEAFzL = new ModelRenderer(this, 0, 23);
		this.LEAFzL.addBox(0.0F, -0.5F, -5.0F, 5, 1, 5);
		this.LEAFzL.setRotationPoint(0.0F, 23.0F, 0.0F);
		this.LEAFzL.setTextureSize(64, 64);
		this.LEAFzL.mirror = true;
		setRotation(this.LEAFzL, -0.1745329F, -0.1745329F, -0.261799F);
		this.modelList.add(this.LEAFzL);
		
		this.LEAFzR = new ModelRenderer(this, 0, 23);
		this.LEAFzR.addBox(-5.0F, -0.5F, -5.0F, 5, 1, 5);
		this.LEAFzR.setRotationPoint(0.0F, 23.0F, 0.0F);
		this.LEAFzR.setTextureSize(64, 64);
		this.LEAFzR.mirror = true;
		setRotation(this.LEAFzR, -0.261799F, 0.1745329F, 0.1745329F);
		this.modelList.add(this.LEAFzR);
		
		this.HLzTzL = new ModelRenderer(this, 20, 0);
		this.HLzTzL.addBox(-0.5F, -0.5F, 0.0F, 1, 1, 3);
		this.HLzTzL.setRotationPoint(1.5F, 9.0F, 2.0F);
		this.HLzTzL.setTextureSize(64, 64);
		this.HLzTzL.mirror = true;
		setRotation(this.HLzTzL, 0.7853982F, 0.0F, 0.0F);
		this.modelList.add(this.HLzTzL);
		
		this.HLzTzR = new ModelRenderer(this, 20, 0);
		this.HLzTzR.addBox(-0.5F, -0.5F, 0.0F, 1, 1, 3);
		this.HLzTzR.setRotationPoint(-1.5F, 9.0F, 2.0F);
		this.HLzTzR.setTextureSize(64, 64);
		this.HLzTzR.mirror = true;
		setRotation(this.HLzTzR, 0.7853982F, 0.0F, 0.0F);
		this.modelList.add(this.HLzTzR);
		
		this.HLzLzT = new ModelRenderer(this, 20, 0);
		this.HLzLzT.addBox(-0.5F, -0.5F, 0.0F, 1, 1, 3);
		this.HLzLzT.setRotationPoint(2.0F, 9.5F, 2.0F);
		this.HLzLzT.setTextureSize(64, 64);
		this.HLzLzT.mirror = true;
		setRotation(this.HLzLzT, 0.349066F, 0.0F, 1.570796F);
		this.modelList.add(this.HLzLzT);
		
		this.HLzTzC = new ModelRenderer(this, 20, 0);
		this.HLzTzC.addBox(-0.5F, -0.5F, 0.0F, 1, 1, 3);
		this.HLzTzC.setRotationPoint(0.0F, 9.0F, 2.0F);
		this.HLzTzC.setTextureSize(64, 64);
		this.HLzTzC.mirror = true;
		setRotation(this.HLzTzC, 0.7853982F, 0.0F, 0.0F);
		this.modelList.add(this.HLzTzC);
		
		this.HLzLzB = new ModelRenderer(this, 20, 0);
		this.HLzLzB.addBox(-0.5F, -0.5F, 0.0F, 1, 1, 3);
		this.HLzLzB.setRotationPoint(2.0F, 11.5F, 2.0F);
		this.HLzLzB.setTextureSize(64, 64);
		this.HLzLzB.mirror = true;
		setRotation(this.HLzLzB, 0.349066F, 0.0F, 1.570796F);
		this.modelList.add(this.HLzLzB);
		
		this.HLzRzT = new ModelRenderer(this, 20, 0);
		this.HLzRzT.addBox(-0.5F, -0.5F, 0.0F, 1, 1, 3);
		this.HLzRzT.setRotationPoint(-2.0F, 9.5F, 2.0F);
		this.HLzRzT.setTextureSize(64, 64);
		this.HLzRzT.mirror = true;
		setRotation(this.HLzRzT, 0.349066F, 0.0F, -1.570796F);
		this.modelList.add(this.HLzRzT);
		
		this.HLzRzB = new ModelRenderer(this, 20, 0);
		this.HLzRzB.addBox(-0.5F, -0.5F, 0.0F, 1, 1, 3);
		this.HLzRzB.setRotationPoint(-2.0F, 11.5F, 2.0F);
		this.HLzRzB.setTextureSize(64, 64);
		this.HLzRzB.mirror = true;
		setRotation(this.HLzRzB, 0.349066F, 0.0F, -1.570796F);
		this.modelList.add(this.HLzRzB);
		
		this.HLzBzC = new ModelRenderer(this, 20, 0);
		this.HLzBzC.addBox(-0.5F, -0.5F, 0.0F, 1, 1, 3);
		this.HLzBzC.setRotationPoint(0.0F, 12.0F, 2.0F);
		this.HLzBzC.setTextureSize(64, 64);
		this.HLzBzC.mirror = true;
		setRotation(this.HLzBzC, -0.5235988F, 0.0F, 0.0F);
		this.modelList.add(this.HLzBzC);
		
		this.HLzBzR = new ModelRenderer(this, 20, 0);
		this.HLzBzR.addBox(-0.5F, -0.5F, 0.0F, 1, 1, 3);
		this.HLzBzR.setRotationPoint(-1.5F, 12.0F, 2.0F);
		this.HLzBzR.setTextureSize(64, 64);
		this.HLzBzR.mirror = true;
		setRotation(this.HLzBzR, -0.5235988F, 0.0F, 0.017453F);
		this.modelList.add(this.HLzBzR);
		
		this.HLzBzL = new ModelRenderer(this, 20, 0);
		this.HLzBzL.addBox(-0.5F, -0.5F, 0.0F, 1, 1, 3);
		this.HLzBzL.setRotationPoint(1.5F, 12.0F, 2.0F);
		this.HLzBzL.setTextureSize(64, 64);
		this.HLzBzL.mirror = true;
		setRotation(this.HLzBzL, -0.5235988F, 0.0F, 0.0F);
		this.modelList.add(this.HLzBzL);
		
	}
	
} public class ModelSunflower extends ModelBase {
	ModelRenderer	Stem;
	ModelRenderer	Head;
	ModelRenderer	LEAFzL;
	ModelRenderer	LEAFzR;
	ModelRenderer	HLzTzL;
	ModelRenderer	HLzTzR;
	ModelRenderer	HLzLzT;
	ModelRenderer	HLzLzB;
	ModelRenderer	HLzRzT;
	ModelRenderer	HLzRzB;
	ModelRenderer	SHLzLzT;
	ModelRenderer	SHLzLzB;
	ModelRenderer	SHLzRzT;
	ModelRenderer	SHLzRzB;
	ModelRenderer	THLzT;
	ModelRenderer	THLzR;
	ModelRenderer	THLzL;
	
	public ModelSunflower() {
		super(64, 64);
		
		this.Stem = new ModelRenderer(this, 6, 10);
		this.Stem.addBox(-1.0F, -10.0F, -1.0F, 2, 11, 2);
		this.Stem.setRotationPoint(0.0F, 23.0F, 0.0F);
		this.Stem.setTextureSize(64, 64);
		this.Stem.mirror = true;
		setRotation(this.Stem, 0.0F, 0.0F, 0.0F);
		this.modelList.add(this.Stem);
		
		this.Head = new ModelRenderer(this, 0, 0);
		this.Head.addBox(-2.5F, -5.0F, -2.5F, 5, 5, 5);
		this.Head.setRotationPoint(0.0F, 13.0F, 0.0F);
		this.Head.setTextureSize(64, 64);
		this.Head.mirror = true;
		setRotation(this.Head, 0.0F, 0.0F, 0.0F);
		this.modelList.add(this.Head);
		
		this.LEAFzL = new ModelRenderer(this, 0, 23);
		this.LEAFzL.addBox(0.0F, -0.5F, -5.0F, 5, 1, 5);
		this.LEAFzL.setRotationPoint(0.0F, 23.0F, 0.0F);
		this.LEAFzL.setTextureSize(64, 64);
		this.LEAFzL.mirror = true;
		setRotation(this.LEAFzL, -0.1745329F, -0.1745329F, -0.261799F);
		this.modelList.add(this.LEAFzL);
		
		this.LEAFzR = new ModelRenderer(this, 0, 23);
		this.LEAFzR.addBox(-5.0F, -0.5F, -5.0F, 5, 1, 5);
		this.LEAFzR.setRotationPoint(0.0F, 23.0F, 0.0F);
		this.LEAFzR.setTextureSize(64, 64);
		this.LEAFzR.mirror = true;
		setRotation(this.LEAFzR, -0.261799F, 0.1745329F, 0.1745329F);
		this.modelList.add(this.LEAFzR);
		
		this.HLzTzL = new ModelRenderer(this, 20, 0);
		this.HLzTzL.addBox(-1.0F, -3.0F, -0.5F, 2, 3, 2);
		this.HLzTzL.setRotationPoint(1.5F, 8.0F, -0.5F);
		this.HLzTzL.setTextureSize(64, 64);
		this.HLzTzL.mirror = true;
		setRotation(this.HLzTzL, 0.0F, 0.0F, 0.0F);
		this.modelList.add(this.HLzTzL);
		
		this.HLzTzR = new ModelRenderer(this, 20, 0);
		this.HLzTzR.addBox(-1.0F, -3.0F, -0.5F, 2, 3, 2);
		this.HLzTzR.setRotationPoint(-1.5F, 8.0F, -0.5F);
		this.HLzTzR.setTextureSize(64, 64);
		this.HLzTzR.mirror = true;
		setRotation(this.HLzTzR, 0.0F, 0.0F, 0.0F);
		this.modelList.add(this.HLzTzR);
		
		this.HLzLzT = new ModelRenderer(this, 20, 0);
		this.HLzLzT.addBox(-1.0F, -3.0F, -0.5F, 2, 3, 2);
		this.HLzLzT.setRotationPoint(2.5F, 9.0F, -0.5F);
		this.HLzLzT.setTextureSize(64, 64);
		this.HLzLzT.mirror = true;
		setRotation(this.HLzLzT, 0.0F, 0.0F, 1.570796F);
		this.modelList.add(this.HLzLzT);
		
		this.HLzLzB = new ModelRenderer(this, 20, 0);
		this.HLzLzB.addBox(-1.0F, -3.0F, -0.5F, 2, 3, 2);
		this.HLzLzB.setRotationPoint(2.5F, 12.0F, -0.5F);
		this.HLzLzB.setTextureSize(64, 64);
		this.HLzLzB.mirror = true;
		setRotation(this.HLzLzB, 0.0F, 0.0F, 1.570796F);
		this.modelList.add(this.HLzLzB);
		
		this.HLzRzT = new ModelRenderer(this, 20, 0);
		this.HLzRzT.addBox(-1.0F, -3.0F, -0.5F, 2, 3, 2);
		this.HLzRzT.setRotationPoint(-2.5F, 9.0F, -0.5F);
		this.HLzRzT.setTextureSize(64, 64);
		this.HLzRzT.mirror = true;
		setRotation(this.HLzRzT, 0.0F, 0.0F, -1.570796F);
		this.modelList.add(this.HLzRzT);
		
		this.HLzRzB = new ModelRenderer(this, 20, 0);
		this.HLzRzB.addBox(-1.0F, -3.0F, -0.5F, 2, 3, 2);
		this.HLzRzB.setRotationPoint(-2.5F, 12.0F, -0.5F);
		this.HLzRzB.setTextureSize(64, 64);
		this.HLzRzB.mirror = true;
		setRotation(this.HLzRzB, 0.0F, 0.0F, -1.570796F);
		this.modelList.add(this.HLzRzB);
		
		this.SHLzLzT = new ModelRenderer(this, 28, 0);
		this.SHLzLzT.addBox(0.0F, 0.0F, 0.0F, 1, 1, 1);
		this.SHLzLzT.setRotationPoint(2.5F, 7.0F, -0.5F);
		this.SHLzLzT.setTextureSize(64, 64);
		this.SHLzLzT.mirror = true;
		setRotation(this.SHLzLzT, 0.0F, 0.0F, 0.0F);
		this.modelList.add(this.SHLzLzT);
		
		this.SHLzLzB = new ModelRenderer(this, 28, 2);
		this.SHLzLzB.addBox(0.0F, 0.0F, 0.0F, 2, 1, 1);
		this.SHLzLzB.setRotationPoint(1.0F, 13.0F, -0.5F);
		this.SHLzLzB.setTextureSize(64, 64);
		this.SHLzLzB.mirror = true;
		setRotation(this.SHLzLzB, 0.0F, 0.0F, 0.0F);
		this.modelList.add(this.SHLzLzB);
		
		this.SHLzRzT = new ModelRenderer(this, 28, 0);
		this.SHLzRzT.addBox(0.0F, 0.0F, 0.0F, 1, 1, 1);
		this.SHLzRzT.setRotationPoint(-3.5F, 7.0F, -0.5F);
		this.SHLzRzT.setTextureSize(64, 64);
		this.SHLzRzT.mirror = true;
		setRotation(this.SHLzRzT, 0.0F, 0.0F, 0.0F);
		this.modelList.add(this.SHLzRzT);
		
		this.SHLzRzB = new ModelRenderer(this, 28, 2);
		this.SHLzRzB.addBox(0.0F, 0.0F, 0.0F, 2, 1, 1);
		this.SHLzRzB.setRotationPoint(-3.0F, 13.0F, -0.5F);
		this.SHLzRzB.setTextureSize(64, 64);
		this.SHLzRzB.mirror = true;
		setRotation(this.SHLzRzB, 0.0F, 0.0F, 0.0F);
		this.modelList.add(this.SHLzRzB);
		
		this.THLzT = new ModelRenderer(this, 28, 4);
		this.THLzT.addBox(0.0F, 0.0F, 0.0F, 1, 1, 1);
		this.THLzT.setRotationPoint(-0.5F, 7.0F, -0.5F);
		this.THLzT.setTextureSize(64, 64);
		this.THLzT.mirror = true;
		setRotation(this.THLzT, 0.0F, 0.0F, 0.0F);
		this.modelList.add(this.THLzT);
		
		this.THLzR = new ModelRenderer(this, 28, 4);
		this.THLzR.addBox(0.0F, 0.0F, 0.0F, 1, 1, 1);
		this.THLzR.setRotationPoint(-3.5F, 10.0F, -0.5F);
		this.THLzR.setTextureSize(64, 64);
		this.THLzR.mirror = true;
		setRotation(this.THLzR, 0.0F, 0.0F, 0.0F);
		this.modelList.add(this.THLzR);
		
		this.THLzL = new ModelRenderer(this, 28, 4);
		this.THLzL.addBox(0.0F, 0.0F, 0.0F, 1, 1, 1);
		this.THLzL.setRotationPoint(2.5F, 10.0F, -0.5F);
		this.THLzL.setTextureSize(64, 64);
		this.THLzL.mirror = true;
		setRotation(this.THLzL, 0.0F, 0.0F, 0.0F);
		this.modelList.add(this.THLzL);
		
	}
	
} public class ModelThreePeater extends ModelBase {
	ModelRenderer STEMzC;
	ModelRenderer HEADzC;
	ModelRenderer MOUTHzC;
	ModelRenderer HEADLEAFzC;
	ModelRenderer LEAFzL;
	ModelRenderer LEAFzR;
	ModelRenderer STEMzR;
	ModelRenderer STEMzL;
	ModelRenderer HEADzL;
	ModelRenderer HEADLEAFzL;
	ModelRenderer MOUTHzL;
	ModelRenderer HEADzR;
	ModelRenderer HEADLEAFzR;
	ModelRenderer MOUTHzR;
	
	public ModelThreePeater() {
		super(64, 64);
		
		this.STEMzC = new ModelRenderer(this, 6, 8);
		this.STEMzC.addBox(-1.0F, -10.0F, -1.0F, 2, 11, 2);
		this.STEMzC.setRotationPoint(0.0F, 23.0F, 0.0F);
		this.STEMzC.setTextureSize(64, 64);
		this.STEMzC.mirror = true;
		setRotation(this.STEMzC, 0.0F, 0.0F, 0.0F);
		this.modelList.add(this.STEMzC);
		
		this.HEADzC = new ModelRenderer(this, 0, 0);
		this.HEADzC.addBox(-2.0F, -4.0F, -2.0F, 4, 4, 4);
		this.HEADzC.setRotationPoint(0.0F, 13.0F, 0.0F);
		this.HEADzC.setTextureSize(64, 64);
		this.HEADzC.mirror = true;
		setRotation(this.HEADzC, 0.0F, 0.0F, 0.0F);
		this.modelList.add(this.HEADzC);
		
		this.MOUTHzC = new ModelRenderer(this, 20, 4);
		this.MOUTHzC.addBox(-1.0F, -1.0F, -2.5F, 2, 2, 2);
		this.MOUTHzC.setRotationPoint(0.0F, 11.5F, -1.5F);
		this.MOUTHzC.setTextureSize(64, 64);
		this.MOUTHzC.mirror = true;
		setRotation(this.MOUTHzC, 0.0F, 0.0F, 0.0F);
		this.modelList.add(this.MOUTHzC);
		
		this.HEADLEAFzC = new ModelRenderer(this, 20, 0);
		this.HEADLEAFzC.addBox(-0.5F, -0.5F, 0.0F, 1, 1, 3);
		this.HEADLEAFzC.setRotationPoint(0.0F, 10.0F, 1.0F);
		this.HEADLEAFzC.setTextureSize(64, 64);
		this.HEADLEAFzC.mirror = true;
		setRotation(this.HEADLEAFzC, 0.7853982F, 0.0F, 0.0F);
		this.modelList.add(this.HEADLEAFzC);
		
		this.LEAFzL = new ModelRenderer(this, 0, 21);
		this.LEAFzL.addBox(0.0F, -0.5F, -5.0F, 5, 1, 5);
		this.LEAFzL.setRotationPoint(0.0F, 23.0F, 0.0F);
		this.LEAFzL.setTextureSize(64, 64);
		this.LEAFzL.mirror = true;
		setRotation(this.LEAFzL, -0.1745329F, -0.1745329F, -0.261799F);
		this.modelList.add(this.LEAFzL);
		
		this.LEAFzR = new ModelRenderer(this, 0, 21);
		this.LEAFzR.addBox(-5.0F, -0.5F, -5.0F, 5, 1, 5);
		this.LEAFzR.setRotationPoint(0.0F, 23.0F, 0.0F);
		this.LEAFzR.setTextureSize(64, 64);
		this.LEAFzR.mirror = true;
		setRotation(this.LEAFzR, -0.261799F, 0.1745329F, 0.1745329F);
		this.modelList.add(this.LEAFzR);
		
		this.STEMzR = new ModelRenderer(this, 6, 8);
		this.STEMzR.addBox(-1.0F, -11.0F, -1.0F, 2, 11, 2);
		this.STEMzR.setRotationPoint(0.0F, 24.0F, 0.0F);
		this.STEMzR.setTextureSize(64, 64);
		this.STEMzR.mirror = true;
		setRotation(this.STEMzR, 0.0F, 0.0F, -0.4363323F);
		this.modelList.add(this.STEMzR);
		
		this.STEMzL = new ModelRenderer(this, 6, 8);
		this.STEMzL.addBox(-1.0F, -11.0F, -1.0F, 2, 11, 2);
		this.STEMzL.setRotationPoint(0.0F, 24.0F, 0.0F);
		this.STEMzL.setTextureSize(64, 64);
		this.STEMzL.mirror = true;
		setRotation(this.STEMzL, 0.0F, 0.0F, 0.4363323F);
		this.modelList.add(this.STEMzL);
		
		this.HEADzL = new ModelRenderer(this, 0, 0);
		this.HEADzL.addBox(-2.0F, -4.0F, -2.0F, 4, 4, 4);
		this.HEADzL.setRotationPoint(4.5F, 14.0F, 0.0F);
		this.HEADzL.setTextureSize(64, 64);
		this.HEADzL.mirror = true;
		setRotation(this.HEADzL, 0.0F, 0.0F, 0.4363323F);
		this.modelList.add(this.HEADzL);
		
		this.HEADLEAFzL = new ModelRenderer(this, 20, 0);
		this.HEADLEAFzL.addBox(-0.5F, -0.5F, 0.0F, 1, 1, 3);
		this.HEADLEAFzL.setRotationPoint(6.0F, 11.0F, 1.0F);
		this.HEADLEAFzL.setTextureSize(64, 64);
		this.HEADLEAFzL.mirror = true;
		setRotation(this.HEADLEAFzL, 0.7853982F, 0.0F, 0.4363323F);
		this.modelList.add(this.HEADLEAFzL);
		
		this.MOUTHzL = new ModelRenderer(this, 20, 4);
		this.MOUTHzL.addBox(-1.0F, -1.0F, -2.0F, 2, 2, 2);
		this.MOUTHzL.setRotationPoint(5.25F, 12.25F, -2.0F);
		this.MOUTHzL.setTextureSize(64, 64);
		this.MOUTHzL.mirror = true;
		setRotation(this.MOUTHzL, 0.0F, 0.0F, 0.4363323F);
		this.modelList.add(this.MOUTHzL);
		
		this.HEADzR = new ModelRenderer(this, 0, 0);
		this.HEADzR.addBox(-2.0F, -4.0F, -2.0F, 4, 4, 4);
		this.HEADzR.setRotationPoint(-4.5F, 14.0F, 0.0F);
		this.HEADzR.setTextureSize(64, 64);
		this.HEADzR.mirror = true;
		setRotation(this.HEADzR, 0.0F, 0.0F, -0.4363323F);
		this.modelList.add(this.HEADzR);
		
		this.HEADLEAFzR = new ModelRenderer(this, 20, 0);
		this.HEADLEAFzR.addBox(-0.5F, -0.5F, 0.0F, 1, 1, 3);
		this.HEADLEAFzR.setRotationPoint(-6.0F, 11.0F, 1.0F);
		this.HEADLEAFzR.setTextureSize(64, 64);
		this.HEADLEAFzR.mirror = true;
		setRotation(this.HEADLEAFzR, 0.7853982F, 0.0F, -0.4363323F);
		this.modelList.add(this.HEADLEAFzR);
		
		this.MOUTHzR = new ModelRenderer(this, 20, 4);
		this.MOUTHzR.addBox(-1.0F, -1.0F, -2.0F, 2, 2, 2);
		this.MOUTHzR.setRotationPoint(-5.25F, 12.3F, -2.0F);
		this.MOUTHzR.setTextureSize(64, 64);
		this.MOUTHzR.mirror = true;
		setRotation(this.MOUTHzR, 0.0F, 0.0F, -0.4363323F);
		this.modelList.add(this.MOUTHzR);
		
	}
	
} public class TileEntityChlorophyllBowl extends TileEntityInventoryBase {

	public int delayControl = 1200 * PvZ.sunlightTimer;
	public int delay = this.delayControl;

	public int sunlightHeld = 0;

	public TileEntityChlorophyllBowl() {
		super("Chlorophyll Bowl", 36, 64);
	}

	public void sunlightControl() {
		World world = this.worldObj;
		int x = this.xCoord;
		int y = this.yCoord;
		int z = this.zCoord;

		if (!world.isRemote)
			if (Util.dayCheck(world)) {
				for (int i = 0; i <= 36; i++) {
					ItemStack slot = getStackInSlot(i);

					if (slot != null) {
						if (slot.getItem() == PvZ.sunlight) {
							ItemBase stackItem = (ItemBase) slot.getItem();
							if (slot.stackSize < stackItem.getMaxStackSize()) {
								slot.stackSize += 1;
								break;
							}
						}
					} else {
						ItemStack givenSunlight = new ItemStack(PvZ.sunlight,
								1, 0);

						setInventorySlotContents(i, givenSunlight);
						break;
					}

				}

			} else if (!Util.dayCheck(world)) {
				for (int i = 0; i <= 36; i++) {
					ItemStack slot = getStackInSlot(i);

					if (slot != null) {
						if (slot.getItem() == PvZ.moonlight) {
							ItemBase stackItem = (ItemBase) slot.getItem();
							if (slot.stackSize < stackItem.getMaxStackSize()) {
								slot.stackSize += 1;
								break;
							}
						}
					} else {
						ItemStack givenSunlight = new ItemStack(PvZ.moonlight,
								1, 0);

						setInventorySlotContents(i, givenSunlight);
						break;
					}
				}
			}
	}

	public void updateEntity() {
		if (this.delay > 0) {
			this.delay -= 1;

			return;
		}
		this.delay = this.delayControl;

		sunlightControl();

	}

} public class TileEntityGravestone extends TileEntity {
	public int facing = -1;
	public int type = 0;
	public ResourceLocation[] typeTexture = { Resources.gravestone,
			Resources.gravestoneReg, Resources.gravestoneFootball,
			Resources.gravestoneFlag, Resources.gravestoneCone,
			Resources.gravestoneBucket };

	private double spawnDelay = 120.0D;
	private int maxNearbyEntities = 10;

	public void updateEntity() {
		double spawnDelay = this.spawnDelay;

		if (!getWorldObj().isRemote) {
			if (spawnDelay > 0.0D) {
				spawnDelay -= 1.0D;
				return;
			}

			if (this.facing == -1) {
				this.facing = 0;
				System.out.println("facing was -1");
			}

			Entity entity = new EntityZombie(getWorldObj());

			List<?> entList = getWorldObj().getEntitiesWithinAABB(
					entity.getClass(),
					AxisAlignedBB.getAABBPool()
							.getAABB(this.xCoord - 3.0D, this.yCoord,
									this.zCoord - 3.0D, this.xCoord + 3.0D,
									this.yCoord, this.zCoord + 3.0D));

			int j = entList.size();
			if (j >= this.maxNearbyEntities) {
				return;
			}
			Util.checkUnder(getWorldObj(), this.xCoord, this.yCoord,
					this.zCoord, 4);
			System.out.println("Spawn wave");

			Util.spawnRandZombie(this.worldObj, this.xCoord, this.yCoord,
					this.zCoord, this.facing, this.type);

			spawnDelay = this.spawnDelay;
		}
		super.updateEntity();
	}

	public void readFromNBT(NBTTagCompound par1NBTTagCompound) {
		super.readFromNBT(par1NBTTagCompound);

		this.facing = par1NBTTagCompound.getShort("Facing");
		this.facing = par1NBTTagCompound.getShort("Type");
	}

	public void writeToNBT(NBTTagCompound par1NBTTagCompound) {
		super.writeToNBT(par1NBTTagCompound);
		par1NBTTagCompound.setShort("Facing", (short) this.facing);
		par1NBTTagCompound.setShort("Type", (short) this.type);
		NBTTagList nbttaglist = new NBTTagList();
	}
} public class TileEntityGreenhouse extends TileEntityInventoryBase {

	private static final int[] input = { 0 };
	private static final int[] modify = { 1, 2, 3 };
	private static final int[] output = { 4 };
	public int plantUpgradeTime;
	public int plantUpgradeTime1 = 400;
	public int upgradeSpeed;
	public int upgradeMultiplyer;
	public int upgradeSpecial;

	public TileEntityGreenhouse() {
		super("Greenhouse", 5, 64);
	}

	// Client Server Sync
	@Override
	public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity pkt) {
		NBTTagCompound tagCom = pkt.func_148857_g();
		this.readFromNBT(tagCom);
	}

	@Override
	public Packet getDescriptionPacket() {
		NBTTagCompound tagCom = new NBTTagCompound();
		this.writeToNBT(tagCom);
		return new S35PacketUpdateTileEntity(this.xCoord, this.yCoord,
				this.zCoord, this.blockMetadata, tagCom);
	}

	public void markDirty() {
		super.markDirty();
		this.getWorldObj().scheduleBlockUpdate(this.xCoord, this.yCoord,
				this.zCoord, PvZ.greenhouse, 10);
	}
	
	public void resync(int delay) {
		super.markDirty();
		this.getWorldObj().scheduleBlockUpdate(this.xCoord, this.yCoord,
				this.zCoord, PvZ.greenhouse, delay);
	}

	public boolean isItemValidForSlot(int i, ItemStack itemStack) {
		return Util.greenhouseSlotCheck(i, itemStack);
	}

	public int[] getAccessibleSlotsFromSide(int var1) {
		if (var1 == 0) {
			return output;
		}
		if (var1 == 1) {
			return input;
		}
		if ((var1 == 2) || (var1 == 3)) {
			return modify;
		}
		return null;
	}

	public boolean canInsertItem(int i, ItemStack itemStack, int j) {
		return isItemValidForSlot(i, itemStack);
	}

	public boolean canExtractItem(int i, ItemStack itemStack, int j) {
		return true;
	}

	@SideOnly(Side.CLIENT)
	public int getUpgradeProgressScaled(int par1) {
		return this.plantUpgradeTime * par1 / this.plantUpgradeTime1;
	}

	public void readFromNBT(NBTTagCompound tagCom) {
		super.readFromNBT(tagCom);

		this.plantUpgradeTime = tagCom.getShort("UpgradeTime");

	}

	public void writeToNBT(NBTTagCompound tagCom) {
		super.writeToNBT(tagCom);
		tagCom.setShort("UpgradeTime", (short) this.plantUpgradeTime);
	}

	public void updateEntity() {
		boolean canUpgrade = false;

		if (!this.worldObj.isRemote) {
			if (canUpgrade()) {
				this.plantUpgradeTime += 1;

				if (this.plantUpgradeTime == this.plantUpgradeTime1) {
					this.plantUpgradeTime = 0;
					upgradeItem();
					canUpgrade = true;
				}
				this.resync(1);
				this.markDirty();
			} else {
				this.plantUpgradeTime = 0;
			}
		}
	}

	private boolean canUpgrade() {
		if ((this.inv[0] != null) && (this.inv[1] != null)) {
			ItemStack itemStackWith = GreenhouseRecipes.smelting().getResult(
					this.inv[0], this.inv[1], this.inv[2]);

			ItemStack itemStackWOut = GreenhouseRecipes.smelting().getResult(
					this.inv[0], this.inv[1], Util.nullStack);
			ItemStack itemStack;
			if (itemStackWith == null)
				itemStack = itemStackWOut;
			else {
				itemStack = itemStackWith;
			}
			if (itemStack == null)
				return false;

			if (this.inv[4] == null) {
				return true;
			}
			if (this.inv[4].stackSize != getInventoryStackLimit()) {
				return true;
			}
			if (!this.inv[4].isItemEqual(itemStack)) {
				return false;
			}
		}
		return false;
	}

	public void upgradeItem() {
		if (canUpgrade()) {
			ItemStack itemStackResultWith = GreenhouseRecipes.smelting()
					.getResult(this.inv[0], this.inv[1], this.inv[2]);

			ItemStack itemStackResultWOut = GreenhouseRecipes.smelting()
					.getResult(this.inv[0], this.inv[1], Util.nullStack);
			ItemStack itemStackResult;
			if (itemStackResultWith == null)
				itemStackResult = itemStackResultWOut;
			else {
				itemStackResult = itemStackResultWith;
			}
			if (this.inv[4] == null) {
				this.inv[4] = itemStackResult.copy();
			} else if ((this.inv[4].isItemEqual(itemStackResult))
					&& (this.inv[4].stackSize + itemStackResult.stackSize <= this.inv[4]
							.getMaxStackSize())) {
				this.inv[4].stackSize += itemStackResult.stackSize;
			}
			this.inv[0].stackSize -= 1;
			this.inv[1].stackSize -= 1;

			if (this.inv[0].stackSize <= 0)
				this.inv[0] = null;
			if (this.inv[1].stackSize <= 0)
				this.inv[1] = null;
			if ((itemStackResult == itemStackResultWith)
					&& (this.inv[2] != null)) {
				this.inv[2].stackSize -= 1;
				if (this.inv[2].stackSize <= 0)
					this.inv[2] = null;
			}

			this.markDirty();
		}
	}

} public class RenderChlorophyllBowl extends TileEntitySpecialRenderer
{
  private ModelChlorophyllBowl aModel;

  public RenderChlorophyllBowl()
  {
    this.aModel = new ModelChlorophyllBowl();
  }
  @SideOnly(Side.CLIENT)
  public void renderAModelAt(TileEntityChlorophyllBowl tileEnt, double x, double y, double z, float f) {
    int metadata = tileEnt.getBlockMetadata();
    int rotationAngle = 0;
    if (metadata % 4 == 0) {
      rotationAngle = 0;
    }
    if (metadata % 4 == 1) {
      rotationAngle = 270;
    }
    if (metadata % 4 == 2) {
      rotationAngle = 180;
    }
    if (metadata % 4 == 3) {
      rotationAngle = 90;
    }

    GL11.glPushMatrix();
    GL11.glTranslatef((float)x + 0.5F, (float)y + 1.5F, (float)z + 0.5F);

    GL11.glRotatef(180.0F, 0.0F, 0.0F, 1.0F);
    GL11.glRotatef(rotationAngle, 0.0F, 1.0F, 0.0F);

    this.bindTexture(Resources.chlorophyllBowl);

    GL11.glPushMatrix();
    this.aModel.renderModel(0.0625F);
    GL11.glPopMatrix();
    GL11.glPopMatrix();
  }
  @SideOnly(Side.CLIENT)
  public void renderTileEntityAt(TileEntity tileentity, double x, double y, double z, float f) {
    renderAModelAt((TileEntityChlorophyllBowl)tileentity, x, y, z, f);
  }
} public class RenderGravestone extends TileEntitySpecialRenderer
{
  private ModelGravestone aModel;

  public RenderGravestone()
  {
    this.aModel = new ModelGravestone();
  }
  @SideOnly(Side.CLIENT)
  public void renderAModelAt(TileEntityGravestone tileEnt, double x, double y, double z, float f) {
    int metadata = tileEnt.facing;
    int rotationAngle = 0;
    if (metadata == 0) {
      rotationAngle = 0;
    }
    if (metadata == 1) {
      rotationAngle = 90;
    }
    if (metadata == 2) {
      rotationAngle = 180;
    }
    if (metadata == 3) {
      rotationAngle = 270;
    }

    GL11.glPushMatrix();
    GL11.glTranslatef((float)x + 0.5F, (float)y + 1.5F, (float)z + 0.5F);

    GL11.glRotatef(180.0F, 0.0F, 0.0F, 1.0F);
    GL11.glRotatef(rotationAngle, 0.0F, 1.0F, 0.0F);

    this.bindTexture(tileEnt.typeTexture[tileEnt.type]);

    GL11.glPushMatrix();
    this.aModel.renderModel(0.0625F);
    GL11.glPopMatrix();
    GL11.glPopMatrix();
  }
  @SideOnly(Side.CLIENT)
  public void renderTileEntityAt(TileEntity tileentity, double x, double y, double z, float f) {
    renderAModelAt((TileEntityGravestone)tileentity, x, y, z, f);
  }
} public class RenderGreenhouse extends TileEntitySpecialRenderer {

	private ModelGreenhouse aModel;

	private final RenderItem inputRender, modify1Render, outputRender;

	public RenderGreenhouse() {
		this.aModel = new ModelGreenhouse();

		RenderItem basicRender = new RenderItem() {
			@Override
			public byte getMiniBlockCount(ItemStack stack, byte original) {
				return 1;
			}

			@Override
			public byte getMiniItemCount(ItemStack stack, byte original) {
				return 1;
			}

			@Override
			public boolean shouldBob() {
				return true;
			}
		};
		
		this.inputRender = basicRender;
		this.inputRender.setRenderManager(RenderManager.instance);
		this.modify1Render = basicRender;
		this.modify1Render.setRenderManager(RenderManager.instance);
		this.outputRender = basicRender;
		this.outputRender.setRenderManager(RenderManager.instance);

	}

	@SideOnly(Side.CLIENT)
	public void renderAModelAt(TileEntityGreenhouse tileEnt, double x,
			double y, double z, float f) {
		tileEnt.getWorldObj().scheduleBlockUpdate(tileEnt.xCoord,
				tileEnt.yCoord, tileEnt.zCoord, PvZ.greenhouse, 10);

		GL11.glPushMatrix();
		int metadata = tileEnt.getBlockMetadata();
		int rotationAngleModel = 0;
		if (metadata % 4 == 0) {
			rotationAngleModel = 0;
		}
		if (metadata % 4 == 1) {
			rotationAngleModel = 270;
		}
		if (metadata % 4 == 2) {
			rotationAngleModel = 180;
		}
		if (metadata % 4 == 3) {
			rotationAngleModel = 90;
		}
		GL11.glTranslatef((float) x + 0.5F, (float) y + 1.5F, (float) z + 0.5F);

		GL11.glRotatef(180.0F, 0.0F, 0.0F, 1.0F);
		GL11.glRotatef(rotationAngleModel, 0.0F, 1.0F, 0.0F);

		this.bindTexture(Resources.greenhouse);

		this.aModel.renderModel(0.0625F);
		GL11.glPopMatrix();

		/**
		 * Render the ghost item inside of the Block, slowly spinning Taken from
		 * Pahimar's EE3 Aludel model
		 */
		ItemStack input = tileEnt.getStackInSlot(0);
		ItemStack mod1 = tileEnt.getStackInSlot(1);
		ItemStack mod2 = tileEnt.getStackInSlot(2);
		ItemStack output = tileEnt.getStackInSlot(4);
		GL11.glPushMatrix();
		if (mod1 != null) {
			this.renderItem(tileEnt, this.modify1Render, mod1,
					(float) x + 0.5F, (float) y + 1.0F, (float) z + 0.5F);
		}
		GL11.glPopMatrix();
		GL11.glPushMatrix();
		if (output != null) {
			this.renderItem(tileEnt, this.outputRender, output,
					(float) x + 0.5F, (float) y + 0.5F, (float) z + 0.5F);
		}
		GL11.glPopMatrix();

	}

	@SideOnly(Side.CLIENT)
	public void renderTileEntityAt(TileEntity tileentity, double x, double y,
			double z, float f) {
		renderAModelAt((TileEntityGreenhouse) tileentity, x, y, z, f);
	}

	private void renderItem(TileEntityInventoryBase tileEnt,
			RenderItem itemRender, ItemStack stack, float x, float y, float z) {
		GL11.glPushMatrix();
		float scaleFactor = CoreUtil.getGhostItemScaleFactor(this.outputRender,
				stack);
		float rotationAngle = (float) (720.0 * (System.currentTimeMillis() & 0x3FFFL) / 0x3FFFL);

		EntityItem ghostEntityItem = new EntityItem(tileEnt.getWorldObj());
		ghostEntityItem.hoverStart = 0.0F;
		ghostEntityItem.setEntityItemStack(stack);

		GL11.glTranslatef(x, y, z);
		GL11.glScalef(scaleFactor, scaleFactor, scaleFactor);
		GL11.glRotatef(rotationAngle, 0.0F, 1.0F, 0.0F);

		itemRender.doRender(ghostEntityItem, 0, 0, 0, 0, 0);
		GL11.glPopMatrix();
	}

} public class ModelFumeShroom extends ModelBase
{
  ModelRenderer Shape1;
  ModelRenderer Shape2;
  ModelRenderer Shape3;
  ModelRenderer Shape4;

  public ModelFumeShroom()
  {
    this.textureWidth = 64;
    this.textureHeight = 32;

    this.Shape1 = new ModelRenderer(this, 0, 19);
    this.Shape1.addBox(0.0F, 0.0F, 0.0F, 7, 7, 6);
    this.Shape1.setRotationPoint(-3.0F, 17.0F, -2.0F);
    this.Shape1.setTextureSize(64, 32);
    this.Shape1.mirror = true;
    setRotation(this.Shape1, 0.0F, 0.0F, 0.0F);
    this.Shape2 = new ModelRenderer(this, 0, 0);
    this.Shape2.addBox(0.0F, 0.0F, 0.0F, 9, 6, 8);
    this.Shape2.setRotationPoint(-4.0F, 11.0F, -3.0F);
    this.Shape2.setTextureSize(64, 32);
    this.Shape2.mirror = true;
    setRotation(this.Shape2, 0.0F, 0.0F, 0.0F);
    this.Shape3 = new ModelRenderer(this, 40, 4);
    this.Shape3.addBox(0.0F, 0.0F, 0.0F, 2, 2, 1);
    this.Shape3.setRotationPoint(-0.5333334F, 13.0F, -4.0F);
    this.Shape3.setTextureSize(64, 32);
    this.Shape3.mirror = true;
    setRotation(this.Shape3, 0.0F, 0.0F, 0.0F);
    this.Shape4 = new ModelRenderer(this, 39, 9);
    this.Shape4.addBox(0.0F, 0.0F, 0.0F, 3, 3, 1);
    this.Shape4.setRotationPoint(-0.9333333F, 12.5F, -5.0F);
    this.Shape4.setTextureSize(64, 32);
    this.Shape4.mirror = true;
    setRotation(this.Shape4, 0.0F, 0.0F, 0.0F);
  }

  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);
    this.Shape1.render(f5);
    this.Shape2.render(f5);
    this.Shape3.render(f5);
    this.Shape4.render(f5);
  }

  private void setRotation(ModelRenderer model, float x, float y, float z)
  {
    model.rotateAngleX = x;
    model.rotateAngleY = y;
    model.rotateAngleZ = z;
  }

  public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5)
  {
  }
} public class ModelMoonShroom extends ModelBase
{
  ModelRenderer Body;
  ModelRenderer Top1;
  ModelRenderer Top2;
  ModelRenderer Top3;
  ModelRenderer Top4;

  public ModelMoonShroom()
  {
    this.textureWidth = 64;
    this.textureHeight = 32;

    this.Body = new ModelRenderer(this, 28, 11);
    this.Body.addBox(0.0F, 0.0F, 0.0F, 5, 5, 5);
    this.Body.setRotationPoint(-2.5F, 19.0F, -2.5F);
    this.Body.setTextureSize(64, 32);
    this.Body.mirror = true;
    setRotation(this.Body, 0.0F, 0.0F, 0.0F);
    this.Top1 = new ModelRenderer(this, 21, 0);
    this.Top1.addBox(0.0F, 0.0F, 0.0F, 9, 2, 9);
    this.Top1.setRotationPoint(-4.5F, 17.0F, -4.5F);
    this.Top1.setTextureSize(64, 32);
    this.Top1.mirror = true;
    setRotation(this.Top1, 0.0F, 0.0F, 0.0F);
    this.Top2 = new ModelRenderer(this, 0, 15);
    this.Top2.addBox(0.0F, 0.0F, 0.0F, 8, 1, 8);
    this.Top2.setRotationPoint(-4.0F, 16.0F, -4.0F);
    this.Top2.setTextureSize(64, 32);
    this.Top2.mirror = true;
    setRotation(this.Top2, 0.0F, 0.0F, 0.0F);
    this.Top3 = new ModelRenderer(this, 0, 7);
    this.Top3.addBox(0.0F, 0.0F, 0.0F, 7, 1, 7);
    this.Top3.setRotationPoint(-3.5F, 15.0F, -3.5F);
    this.Top3.setTextureSize(64, 32);
    this.Top3.mirror = true;
    setRotation(this.Top3, 0.0F, 0.0F, 0.0F);
    this.Top4 = new ModelRenderer(this, 0, 0);
    this.Top4.addBox(0.0F, 0.0F, 0.0F, 6, 1, 6);
    this.Top4.setRotationPoint(-3.0F, 14.0F, -3.0F);
    this.Top4.setTextureSize(64, 32);
    this.Top4.mirror = true;
    setRotation(this.Top4, 0.0F, 0.0F, 0.0F);
  }

  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);
    this.Body.render(f5);
    this.Top1.render(f5);
    this.Top2.render(f5);
    this.Top3.render(f5);
    this.Top4.render(f5);
  }

  private void setRotation(ModelRenderer model, float x, float y, float z)
  {
    model.rotateAngleX = x;
    model.rotateAngleY = y;
    model.rotateAngleZ = z;
  }

  public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5)
  {
  }
} public class ModelPuffShroom extends ModelBase
{
  ModelRenderer UPzBODY;
  ModelRenderer UPzHATz1;
  ModelRenderer UPzNOSE;
  ModelRenderer UPzHATz2;
  ModelRenderer DOWNzBODY;
  ModelRenderer DOWNzHATz1;
  ModelRenderer DOWNzHATz2;

  public ModelPuffShroom()
  {
    this.textureWidth = 64;
    this.textureHeight = 32;

    this.UPzBODY = new ModelRenderer(this, 0, 13);
    this.UPzBODY.addBox(-2.0F, -4.0F, -2.0F, 4, 4, 4);
    this.UPzBODY.setRotationPoint(0.0F, 24.0F, 0.0F);
    this.UPzBODY.setTextureSize(64, 32);
    this.UPzBODY.mirror = true;
    setRotation(this.UPzBODY, 0.0F, 0.0F, 0.0F);
    this.UPzHATz1 = new ModelRenderer(this, 0, 5);
    this.UPzHATz1.addBox(-2.5F, -2.0F, -2.5F, 5, 2, 5);
    this.UPzHATz1.setRotationPoint(0.0F, 20.0F, 0.0F);
    this.UPzHATz1.setTextureSize(64, 32);
    this.UPzHATz1.mirror = true;
    setRotation(this.UPzHATz1, 0.0F, 0.0F, 0.0F);
    this.UPzNOSE = new ModelRenderer(this, 14, 1);
    this.UPzNOSE.addBox(-0.5F, -0.5F, -1.0F, 1, 1, 1);
    this.UPzNOSE.setRotationPoint(0.0F, 22.0F, -2.0F);
    this.UPzNOSE.setTextureSize(64, 32);
    this.UPzNOSE.mirror = true;
    setRotation(this.UPzNOSE, 0.0F, 0.0F, 0.0F);
    this.UPzHATz2 = new ModelRenderer(this, 0, 0);
    this.UPzHATz2.addBox(-1.5F, -1.0F, -1.5F, 3, 1, 3);
    this.UPzHATz2.setRotationPoint(0.0F, 18.0F, 0.0F);
    this.UPzHATz2.setTextureSize(64, 32);
    this.UPzHATz2.mirror = true;
    setRotation(this.UPzHATz2, 0.0F, 0.0F, 0.0F);
    this.DOWNzBODY = new ModelRenderer(this, 25, 13);
    this.DOWNzBODY.addBox(-2.0F, -3.0F, -2.0F, 4, 3, 4);
    this.DOWNzBODY.setRotationPoint(0.0F, 24.0F, 0.0F);
    this.DOWNzBODY.setTextureSize(64, 32);
    this.DOWNzBODY.mirror = true;
    setRotation(this.DOWNzBODY, 0.0F, 0.0F, 0.0F);
    this.DOWNzHATz1 = new ModelRenderer(this, 23, 5);
    this.DOWNzHATz1.addBox(-2.5F, -2.0F, -2.5F, 5, 2, 5);
    this.DOWNzHATz1.setRotationPoint(0.0F, 21.0F, 0.0F);
    this.DOWNzHATz1.setTextureSize(64, 32);
    this.DOWNzHATz1.mirror = true;
    setRotation(this.DOWNzHATz1, 0.0F, 0.0F, 0.0F);
    this.DOWNzHATz2 = new ModelRenderer(this, 27, 0);
    this.DOWNzHATz2.addBox(-1.5F, -1.0F, -1.5F, 3, 1, 3);
    this.DOWNzHATz2.setRotationPoint(0.0F, 19.0F, 0.0F);
    this.DOWNzHATz2.setTextureSize(64, 32);
    this.DOWNzHATz2.mirror = true;
    setRotation(this.DOWNzHATz2, 0.0F, 0.0F, 0.0F);
  }

  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);
    this.UPzBODY.render(f5);
    this.UPzHATz1.render(f5);
    this.UPzNOSE.render(f5);
    this.UPzHATz2.render(f5);
    this.DOWNzBODY.render(f5);
    this.DOWNzHATz1.render(f5);
    this.DOWNzHATz2.render(f5);
  }

  private void setRotation(ModelRenderer model, float x, float y, float z)
  {
    model.rotateAngleX = x;
    model.rotateAngleY = y;
    model.rotateAngleZ = z;
  }

  public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5)
  {
  }
} public class ModelScaredyShroom extends ModelBase
{
  ModelRenderer UPzSTALK;
  ModelRenderer UPzHEAD;
  ModelRenderer UPzHATz1;
  ModelRenderer UPzHATz2;
  ModelRenderer UPzNOSE;
  ModelRenderer DOWNzSTALK;
  ModelRenderer DOWNzHATz1;
  ModelRenderer DOWNzHATz2;

  public ModelScaredyShroom()
  {
    this.textureWidth = 64;
    this.textureHeight = 32;

    this.UPzSTALK = new ModelRenderer(this, 4, 9);
    this.UPzSTALK.addBox(-1.0F, -8.0F, -1.0F, 2, 8, 2);
    this.UPzSTALK.setRotationPoint(0.0F, 24.0F, 0.0F);
    this.UPzSTALK.setTextureSize(64, 32);
    this.UPzSTALK.mirror = true;
    setRotation(this.UPzSTALK, 0.0F, 0.0F, 0.0F);
    this.UPzHEAD = new ModelRenderer(this, 0, 0);
    this.UPzHEAD.addBox(-2.0F, -4.0F, -2.0F, 4, 5, 4);
    this.UPzHEAD.setRotationPoint(0.0F, 15.0F, 0.0F);
    this.UPzHEAD.setTextureSize(64, 32);
    this.UPzHEAD.mirror = true;
    setRotation(this.UPzHEAD, 0.0F, 0.0F, 0.0F);
    this.UPzHATz1 = new ModelRenderer(this, 16, 5);
    this.UPzHATz1.addBox(-3.0F, -1.0F, -3.0F, 6, 1, 6);
    this.UPzHATz1.setRotationPoint(0.0F, 11.0F, 0.0F);
    this.UPzHATz1.setTextureSize(64, 32);
    this.UPzHATz1.mirror = true;
    setRotation(this.UPzHATz1, 0.0F, 0.0F, 0.0F);
    this.UPzHATz2 = new ModelRenderer(this, 20, 0);
    this.UPzHATz2.addBox(-2.0F, -1.0F, -2.0F, 4, 1, 4);
    this.UPzHATz2.setRotationPoint(0.0F, 10.0F, 0.0F);
    this.UPzHATz2.setTextureSize(64, 32);
    this.UPzHATz2.mirror = true;
    setRotation(this.UPzHATz2, 0.0F, 0.0F, 0.0F);
    this.UPzNOSE = new ModelRenderer(this, 23, 15);
    this.UPzNOSE.addBox(-1.0F, -1.0F, -1.0F, 2, 2, 1);
    this.UPzNOSE.setRotationPoint(0.0F, 14.0F, -2.0F);
    this.UPzNOSE.setTextureSize(64, 32);
    this.UPzNOSE.mirror = true;
    setRotation(this.UPzNOSE, 0.0F, 0.0F, 0.0F);
    this.DOWNzSTALK = new ModelRenderer(this, 4, 25);
    this.DOWNzSTALK.addBox(-1.0F, -2.0F, -1.0F, 2, 2, 2);
    this.DOWNzSTALK.setRotationPoint(0.0F, 24.0F, 0.0F);
    this.DOWNzSTALK.setTextureSize(64, 32);
    this.DOWNzSTALK.mirror = true;
    setRotation(this.DOWNzSTALK, 0.0F, 0.0F, 0.0F);
    this.DOWNzHATz1 = new ModelRenderer(this, 12, 23);
    this.DOWNzHATz1.addBox(-3.0F, -1.0F, -3.0F, 6, 1, 6);
    this.DOWNzHATz1.setRotationPoint(0.0F, 22.0F, 0.0F);
    this.DOWNzHATz1.setTextureSize(64, 32);
    this.DOWNzHATz1.mirror = true;
    setRotation(this.DOWNzHATz1, 0.0F, 0.0F, 0.0F);
    this.DOWNzHATz2 = new ModelRenderer(this, 36, 25);
    this.DOWNzHATz2.addBox(-2.0F, -1.0F, -2.0F, 4, 1, 4);
    this.DOWNzHATz2.setRotationPoint(0.0F, 21.0F, 0.0F);
    this.DOWNzHATz2.setTextureSize(64, 32);
    this.DOWNzHATz2.mirror = true;
    setRotation(this.DOWNzHATz2, 0.0F, 0.0F, 0.0F);
  }

  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);
    this.UPzSTALK.render(f5);
    this.UPzHEAD.render(f5);
    this.UPzHATz1.render(f5);
    this.UPzHATz2.render(f5);
    this.UPzNOSE.render(f5);
    this.DOWNzSTALK.render(f5);
    this.DOWNzHATz1.render(f5);
    this.DOWNzHATz2.render(f5);
  }

  private void setRotation(ModelRenderer model, float x, float y, float z)
  {
    model.rotateAngleX = x;
    model.rotateAngleY = y;
    model.rotateAngleZ = z;
  }

  public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5)
  {
  }
} public class ModelWalnut extends ModelBase
{
  ModelRenderer Shape1;
  ModelRenderer Shape2;
  ModelRenderer Shape3;

  public ModelWalnut()
  {
    this.textureWidth = 64;
    this.textureHeight = 32;

    this.Shape1 = new ModelRenderer(this, 0, 14);
    this.Shape1.addBox(0.0F, 0.0F, 0.0F, 10, 6, 8);
    this.Shape1.setRotationPoint(-5.0F, 18.0F, -4.0F);
    this.Shape1.setTextureSize(64, 32);
    this.Shape1.mirror = true;
    setRotation(this.Shape1, 0.0F, 0.0F, 0.0F);
    this.Shape2 = new ModelRenderer(this, 0, 0);
    this.Shape2.addBox(0.0F, 0.0F, 0.0F, 9, 6, 7);
    this.Shape2.setRotationPoint(-4.5F, 12.0F, -3.5F);
    this.Shape2.setTextureSize(64, 32);
    this.Shape2.mirror = true;
    setRotation(this.Shape2, 0.0F, 0.0F, 0.0F);
    this.Shape3 = new ModelRenderer(this, 33, 0);
    this.Shape3.addBox(0.0F, 0.0F, 0.0F, 7, 2, 5);
    this.Shape3.setRotationPoint(-3.5F, 10.0F, -2.5F);
    this.Shape3.setTextureSize(64, 32);
    this.Shape3.mirror = true;
    setRotation(this.Shape3, 0.0F, 0.0F, 0.0F);
  }

  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);
    this.Shape1.render(f5);
    this.Shape2.render(f5);
    this.Shape3.render(f5);
  }

  private void setRotation(ModelRenderer model, float x, float y, float z)
  {
    model.rotateAngleX = x;
    model.rotateAngleY = y;
    model.rotateAngleZ = z;
  }

  public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5)
  {
  }
} @SideOnly(Side.CLIENT)
public class RenderAntiCreeper extends RenderLiving
{
  protected ModelRepeater model;

  @SideOnly(Side.CLIENT)
  public RenderAntiCreeper(ModelBase par1ModelBase, float par2)
  {
    super(par1ModelBase, par2);
    this.model = ((ModelRepeater)this.mainModel);
  }
  @SideOnly(Side.CLIENT)
  public void renderPeaShooter(EntityCreeperRepeater entity, double par2, double par4, double par6, float par8, float par9) {
    super.doRender(entity, par2, par4, par6, par8, par9);
  }
  @SideOnly(Side.CLIENT)
  public void doRenderLiving(EntityLiving par1EntityLiving, double par2, double par4, double par6, float par8, float par9) {
    renderPeaShooter((EntityCreeperRepeater)par1EntityLiving, par2, par4, par6, par8, par9);
  }
  @SideOnly(Side.CLIENT)
  public void doRender(Entity par1Entity, double par2, double par4, double par6, float par8, float par9) {
    renderPeaShooter((EntityCreeperRepeater)par1Entity, par2, par4, par6, par8, par9);
  }

  protected ResourceLocation getEntityTexture(Entity entity) {
    return Resources.antiCreeperMob;
  }
} @SideOnly(Side.CLIENT)
public class RenderFumeShroom extends RenderLiving {
	protected ModelFumeShroom model;

	@SideOnly(Side.CLIENT)
	public RenderFumeShroom(ModelBase par1ModelBase, float par2) {
		super(par1ModelBase, par2);
		this.model = ((ModelFumeShroom) this.mainModel);
	}

	@SideOnly(Side.CLIENT)
	public void renderFumeShroom(EntityFumeShroom entity, double par2,
			double par4, double par6, float par8, float par9) {
		super.doRender(entity, par2, par4, par6, par8, par9);
	}

	@SideOnly(Side.CLIENT)
	public void doRenderLiving(EntityLiving par1EntityLiving, double par2,
			double par4, double par6, float par8, float par9) {
		renderFumeShroom((EntityFumeShroom) par1EntityLiving, par2, par4, par6,
				par8, par9);
	}

	@SideOnly(Side.CLIENT)
	public void doRender(Entity par1Entity, double par2, double par4,
			double par6, float par8, float par9) {
		renderFumeShroom((EntityFumeShroom) par1Entity, par2, par4, par6, par8,
				par9);
	}

	protected ResourceLocation getEntityTexture(Entity entity) {
		return Resources.fumeShroomMob;
	}
} @SideOnly(Side.CLIENT)
public class RenderMoonShroom extends RenderLiving
{
  protected ModelMoonShroom model;

  @SideOnly(Side.CLIENT)
  public RenderMoonShroom(ModelBase par1ModelBase, float par2)
  {
    super(par1ModelBase, par2);
    this.model = ((ModelMoonShroom)this.mainModel);
  }
  @SideOnly(Side.CLIENT)
  public void renderPuffShroom(EntityMoonShroom entity, double par2, double par4, double par6, float par8, float par9) {
    super.doRender(entity, par2, par4, par6, par8, par9);
  }
  @SideOnly(Side.CLIENT)
  public void doRenderLiving(EntityLiving par1EntityLiving, double par2, double par4, double par6, float par8, float par9) {
    renderPuffShroom((EntityMoonShroom)par1EntityLiving, par2, par4, par6, par8, par9);
  }
  @SideOnly(Side.CLIENT)
  public void doRender(Entity par1Entity, double par2, double par4, double par6, float par8, float par9) {
    renderPuffShroom((EntityMoonShroom)par1Entity, par2, par4, par6, par8, par9);
  }

  protected ResourceLocation getEntityTexture(Entity entity) {
    return Resources.moonShroomMob;
  }
} @SideOnly(Side.CLIENT)
public class RenderPeaShooter extends RenderLiving
{
  protected ModelPeaShooter model;

  @SideOnly(Side.CLIENT)
  public RenderPeaShooter(ModelBase par1ModelBase, float par2)
  {
    super(par1ModelBase, par2);
    this.model = ((ModelPeaShooter)this.mainModel);
  }
  @SideOnly(Side.CLIENT)
  public void renderPeaShooter(EntityPeaShooter entity, double par2, double par4, double par6, float par8, float par9) {
    super.doRender(entity, par2, par4, par6, par8, par9);
  }
  @SideOnly(Side.CLIENT)
  public void doRenderLiving(EntityLiving par1EntityLiving, double par2, double par4, double par6, float par8, float par9) {
    renderPeaShooter((EntityPeaShooter)par1EntityLiving, par2, par4, par6, par8, par9);
  }
  @SideOnly(Side.CLIENT)
  public void doRender(Entity par1Entity, double par2, double par4, double par6, float par8, float par9) {
    renderPeaShooter((EntityPeaShooter)par1Entity, par2, par4, par6, par8, par9);
  }

  protected ResourceLocation getEntityTexture(Entity entity) {
    return Resources.peaShooterMob;
  }
} @SideOnly(Side.CLIENT)
public class RenderPuffShroom extends RenderLiving
{
  protected ModelPuffShroom model;
  private static ResourceLocation field_110887_f = Resources.puffShroomMob_0;

  @SideOnly(Side.CLIENT)
  public RenderPuffShroom(ModelBase par1ModelBase, float par2)
  {
    super(par1ModelBase, par2);
    this.model = ((ModelPuffShroom)this.mainModel);
  }
  @SideOnly(Side.CLIENT)
  public void renderPuffShroom(EntityPuffShroom entity, double par2, double par4, double par6, float par8, float par9) {
    super.doRender(entity, par2, par4, par6, par8, par9);
  }
  @SideOnly(Side.CLIENT)
  public void doRenderLiving(EntityLiving par1EntityLiving, double par2, double par4, double par6, float par8, float par9) {
    renderPuffShroom((EntityPuffShroom)par1EntityLiving, par2, par4, par6, par8, par9);
  }
  @SideOnly(Side.CLIENT)
  public void doRender(Entity par1Entity, double par2, double par4, double par6, float par8, float par9) {
    renderPuffShroom((EntityPuffShroom)par1Entity, par2, par4, par6, par8, par9);
  }

  protected ResourceLocation func_110886_a(EntityPuffShroom entity)
  {
    field_110887_f = entity.renderRL;
    return field_110887_f;
  }

  protected ResourceLocation getEntityTexture(Entity par1Entity)
  {
    return func_110886_a((EntityPuffShroom)par1Entity);
  }
} @SideOnly(Side.CLIENT)
public class RenderRepeater extends RenderLiving
{
  protected ModelRepeater model;

  @SideOnly(Side.CLIENT)
  public RenderRepeater(ModelBase par1ModelBase, float par2)
  {
    super(par1ModelBase, par2);
    this.model = ((ModelRepeater)this.mainModel);
  }
  @SideOnly(Side.CLIENT)
  public void renderRepeater(EntityRepeater entity, double par2, double par4, double par6, float par8, float par9) {
    super.doRender(entity, par2, par4, par6, par8, par9);
  }
  @SideOnly(Side.CLIENT)
  public void doRenderLiving(EntityLiving par1EntityLiving, double par2, double par4, double par6, float par8, float par9) {
    renderRepeater((EntityRepeater)par1EntityLiving, par2, par4, par6, par8, par9);
  }
  @SideOnly(Side.CLIENT)
  public void doRender(Entity par1Entity, double par2, double par4, double par6, float par8, float par9) {
    renderRepeater((EntityRepeater)par1Entity, par2, par4, par6, par8, par9);
  }

  protected ResourceLocation getEntityTexture(Entity entity) {
    return Resources.repeaterMob;
  }
} @SideOnly(Side.CLIENT)
public class RenderScaredyShroom extends RenderLiving
{
  protected ModelScaredyShroom model;

  @SideOnly(Side.CLIENT)
  public RenderScaredyShroom(ModelBase par1ModelBase, float par2)
  {
    super(par1ModelBase, par2);
    this.model = ((ModelScaredyShroom)this.mainModel);
  }
  @SideOnly(Side.CLIENT)
  public void renderScaredyShroom(EntityScaredyShroom entity, double par2, double par4, double par6, float par8, float par9) {
    super.doRender(entity, par2, par4, par6, par8, par9);
  }
  @SideOnly(Side.CLIENT)
  public void doRenderLiving(EntityLiving par1EntityLiving, double par2, double par4, double par6, float par8, float par9) {
    renderScaredyShroom((EntityScaredyShroom)par1EntityLiving, par2, par4, par6, par8, par9);
  }
  @SideOnly(Side.CLIENT)
  public void doRender(Entity par1Entity, double par2, double par4, double par6, float par8, float par9) {
    renderScaredyShroom((EntityScaredyShroom)par1Entity, par2, par4, par6, par8, par9);
  }

  protected ResourceLocation getEntityTexture(Entity entity) {
    return Resources.scaredyShroomMob_0;
  }
} @SideOnly(Side.CLIENT)
public class RenderSnowPea extends RenderLiving
{
  protected ModelSnowPea model;

  @SideOnly(Side.CLIENT)
  public RenderSnowPea(ModelBase par1ModelBase, float par2)
  {
    super(par1ModelBase, par2);
    this.model = ((ModelSnowPea)this.mainModel);
  }
  @SideOnly(Side.CLIENT)
  public void renderRepeater(EntitySnowPea entity, double par2, double par4, double par6, float par8, float par9) {
    super.doRender(entity, par2, par4, par6, par8, par9);
  }
  @SideOnly(Side.CLIENT)
  public void doRenderLiving(EntityLiving par1EntityLiving, double par2, double par4, double par6, float par8, float par9) {
    renderRepeater((EntitySnowPea)par1EntityLiving, par2, par4, par6, par8, par9);
  }
  @SideOnly(Side.CLIENT)
  public void doRender(Entity par1Entity, double par2, double par4, double par6, float par8, float par9) {
    renderRepeater((EntitySnowPea)par1Entity, par2, par4, par6, par8, par9);
  }

  protected ResourceLocation getEntityTexture(Entity entity) {
    return Resources.snowPeaMob;
  }
} @SideOnly(Side.CLIENT)
public class RenderSunflower extends RenderLiving
{
  protected ModelSunflower model;

  @SideOnly(Side.CLIENT)
  public RenderSunflower(ModelBase par1ModelBase, float par2)
  {
    super(par1ModelBase, par2);
    this.model = ((ModelSunflower)this.mainModel);
  }
  @SideOnly(Side.CLIENT)
  public void renderSunflower(EntitySunflower entity, double par2, double par4, double par6, float par8, float par9) {
    super.doRender(entity, par2, par4, par6, par8, par9);
  }
  @SideOnly(Side.CLIENT)
  public void doRenderLiving(EntityLiving par1EntityLiving, double par2, double par4, double par6, float par8, float par9) {
    label(par1EntityLiving);
    renderSunflower((EntitySunflower)par1EntityLiving, par2, par4, par6, par8, par9);
  }
  @SideOnly(Side.CLIENT)
  public void doRender(Entity par1Entity, double par2, double par4, double par6, float par8, float par9) {
    label(par1Entity);
    renderSunflower((EntitySunflower)par1Entity, par2, par4, par6, par8, par9);
  }

  protected ResourceLocation getEntityTexture(Entity entity) {
    return Resources.sunflowerMob;
  }

  public void label(Entity entity)
  {
  }
} @SideOnly(Side.CLIENT)
public class RenderThreePeater extends RenderLiving
{
  protected ModelThreePeater model;

  @SideOnly(Side.CLIENT)
  public RenderThreePeater(ModelBase par1ModelBase, float par2)
  {
    super(par1ModelBase, par2);
    this.model = ((ModelThreePeater)this.mainModel);
  }
  @SideOnly(Side.CLIENT)
  public void renderThreePeater(EntityThreePeater entity, double par2, double par4, double par6, float par8, float par9) {
    super.doRender(entity, par2, par4, par6, par8, par9);
  }
  @SideOnly(Side.CLIENT)
  public void doRenderLiving(EntityLiving par1EntityLiving, double par2, double par4, double par6, float par8, float par9) {
    renderThreePeater((EntityThreePeater)par1EntityLiving, par2, par4, par6, par8, par9);
  }
  @SideOnly(Side.CLIENT)
  public void doRender(Entity par1Entity, double par2, double par4, double par6, float par8, float par9) {
    renderThreePeater((EntityThreePeater)par1Entity, par2, par4, par6, par8, par9);
  }

  protected ResourceLocation getEntityTexture(Entity entity) {
    return Resources.threePeaterMob;
  }
} @SideOnly(Side.CLIENT)
public class RenderWalnut extends RenderLiving
{
  protected ModelWalnut model;

  @SideOnly(Side.CLIENT)
  public RenderWalnut(ModelBase par1ModelBase, float par2)
  {
    super(par1ModelBase, par2);
    this.model = ((ModelWalnut)this.mainModel);
  }
  @SideOnly(Side.CLIENT)
  public void renderWalnut(EntityWalnut entity, double par2, double par4, double par6, float par8, float par9) {
    super.doRender(entity, par2, par4, par6, par8, par9);
  }
  @SideOnly(Side.CLIENT)
  public void doRenderLiving(EntityLiving par1EntityLiving, double par2, double par4, double par6, float par8, float par9) {
    renderWalnut((EntityWalnut)par1EntityLiving, par2, par4, par6, par8, par9);
  }
  @SideOnly(Side.CLIENT)
  public void doRender(Entity par1Entity, double par2, double par4, double par6, float par8, float par9) {
    renderWalnut((EntityWalnut)par1Entity, par2, par4, par6, par8, par9);
  }

  protected ResourceLocation getEntityTexture(Entity entity) {
    return Resources.walnutMob;
  }
} public class EntityCreeperRepeater extends EntityPlantShooterBase
{
  public EntityCreeperRepeater(World par1World)
  {
    super(par1World, new ItemStack(PvZ.basicPlants, 1, 1));
  }

  public boolean canAttackClass(Class par1Class)
  {
    return (creeperCheck(par1Class)) || (ghastCheck(par1Class));
  }

  public EntityThrowable entitySelect(World world)
  {
    EntityCreeperPod ent = new EntityCreeperPod(world, this);
    return ent;
  }

  public void ai()
  {
    this.tasks.addTask(1, new EntityAIArrowAttack(this, 0.0D, 20, this.range));

    this.targetTasks.addTask(1, new EntityAINearestAttackableTarget(this, EntityLiving.class, 0, true, false, IMob.mobSelector));

    this.tasks.addTask(9, new EntityAIWatchClosest(this, EntityPlayer.class, 6.0F));
    this.tasks.addTask(10, new EntityAILookIdle(this));
  }
} public class EntityFumeShroom extends EntityShroomShooterBase
{
  public int min = 1; public int max = 6;

  public EntityFumeShroom(World world) { super(world, new ItemStack(PvZ.nightPlants, 1, 2));
  }

  public void dropFewItems(boolean par1, int par2)
  {
    int numbPods = this.min + (int)(Math.random() * (this.max - this.min + 1));

    dropItem(PvZ.shroomPod, numbPods);
  }

  public void attackEntityWithRangedAttack(EntityLivingBase entitylivingbase, float f)
  {
    if (entitySelect(this.worldObj) != null)
    {
      int numbPods = this.min + (int)(Math.random() * (this.max - this.min + 1));
      for (int i = 0; i < numbPods; i++) {
        EntityThrowable ent = entitySelect(this.worldObj);
        double toX = entitylivingbase.posX - this.posX;
        float percentToMouth = 0.5F;
        double toY = entitylivingbase.posY + this.height * percentToMouth - 1.0D - ent.posY;
        double toZ = entitylivingbase.posZ - this.posZ;
        float f1 = MathHelper.sqrt_double(toX * toX + toZ * toZ) * 0.2F;
        ent.setThrowableHeading(toX, toY + f1, toZ, 1.6F, 12.0F);
        playSound("random.bow", 1.0F, 1.0F / (getRNG().nextFloat() * 0.4F + 0.8F));
        this.worldObj.spawnEntityInWorld(ent);
      }
    }
  }
} public class EntityMoonShroom extends EntityShroomBase {
	public EntityMoonShroom(World par1World) {
		super(par1World, new ItemStack(PvZ.nightPlants, 1, 3));
	}

	public void dropFewItems(boolean par1, int par2) {
		dropItem(PvZ.moonlight, 2);
	}

	public void onLivingUpdate() {
		super.onLivingUpdate();

		int r = 3;
		List<?> rEntities = this.worldObj.getEntitiesWithinAABB(
				EntityLivingBase.class, AxisAlignedBB.getBoundingBox(this.posX
						- r, this.posY - r, this.posZ - r, this.posX + r,
						this.posY + r, this.posZ + r));

		ArrayList<EntityLivingBase> otherMob = new ArrayList<EntityLivingBase>();
		boolean wave = false;

		for (int i = 0; i < rEntities.size(); i++) {
			EntityLivingBase ent = (EntityLivingBase) rEntities.get(i);

			if (ent.getCreatureAttribute() == PvZ.plantAttribute) {
				if (ent.getAITarget() != null) {
					wave = true;
					break;
				}
				wave = false;
			} else {
				rEntities.remove(ent);
				otherMob.add(ent);
			}
		}
		double z;
		/*
		 * if (!wave) { for (EntityLivingBase ent : rEntities) { if ((ent
		 * instanceof EntityShroomBase)) { if (ent.getHealth() !=
		 * ent.getMaxHealth()) { double x = ent.posX + 0.5D; double y = ent.posY
		 * + 0.5D; z = ent.posZ + 0.5D; } }
		 * 
		 * }
		 * 
		 * } else { for (EntityLivingBase ent : otherMob) {
		 * System.out.println("slowness"); ent.addPotionEffect(new
		 * PotionEffect(Potion.moveSlowdown.getId(), 500, 5)); } }
		 */
	}
} public class EntityPeaShooter extends EntityPlantShooterBase {
	public EntityPeaShooter(World par1World) {
		super(par1World, new ItemStack(PvZ.basicPlants, 1, 1));

		setTexture("/mods/CountryGamer_PlantsVsZombies/textures/mobs/Pea Shooter.png");
	}

	protected Item getDropItem() {
		return PvZ.peaPod;
	}

	public boolean interact(EntityPlayer par1EntityPlayer) {
		return false;
	}

	public EntityThrowable entitySelect(World world) {
		EntityPeaPod ent = new EntityPeaPod(world, this);
		return ent;
	}
} public class EntityPuffShroom extends EntityShroomShooterBase {
	public EntityPuffShroom(World world) {
		super(world, new ItemStack(PvZ.nightPlants, 1, 0));
	}

	protected void applyEntityAttributes() {
		super.applyEntityAttributes();
		setMaxHealth(PvZ.basePlantHealth / 2);
		getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(
				this.baseHealth);
	}

	public void dropFewItems(boolean par1, int par2) {
		dropItem(PvZ.shroomPod, 1);
	}

	public void onUpdate() {
		super.onUpdate();
		int lightBright = this.worldObj.getBlockLightValue((int) this.posX,
				(int) this.posY, (int) this.posZ);

		if ((this.worldObj != null)
				&& (!this.worldObj.isRemote)
				&& (((this.worldObj.getWorldTime() < 0L) || (this.worldObj
						.getWorldTime() > 12000L)) || ((this.worldObj
						.getWorldTime() >= 12000L) && (this.worldObj
						.getWorldTime() <= 23999L))))
			;
	}
} public class EntityRepeater extends EntityPlantShooterBase {
	public EntityRepeater(World par1World) {
		super(par1World, new ItemStack(PvZ.basicPlants, 1, 3));

		setTexture("/mods/CountryGamer_PlantsVsZombies/textures/mobs/Pea Shooter.png");
	}

	protected void dropFewItems(boolean par1, int par2) {
		dropItem(PvZ.peaPod, 2);
	}

	public EntityThrowable entitySelect(World world) {
		EntityPeaPod ent = new EntityPeaPod(world, this);
		return ent;
	}

	public void ai() {
		this.tasks.addTask(1, new EntityAIArrowAttack(this, 0.0D, 25,
				this.range));

		this.targetTasks.addTask(1, new EntityAINearestAttackableTarget(this,
				EntityLiving.class, 0, true, false, IMob.mobSelector));

		this.tasks.addTask(9, new EntityAIWatchClosest(this,
				EntityPlayer.class, 6.0F));
		this.tasks.addTask(10, new EntityAILookIdle(this));
	}
} public class EntityScaredyShroom extends EntityShroomShooterBase {
	public EntityScaredyShroom(World world) {
		super(world, new ItemStack(PvZ.nightPlants, 1, 1));
	}

	public void dropFewItems(boolean par1, int par2) {
		dropItem(PvZ.shroomPod, 2);
	}
} public class EntitySnowPea extends EntityPlantShooterBase {
	public EntitySnowPea(World par1World) {
		super(par1World, new ItemStack(PvZ.basicPlants, 1, 2));

		setTexture("/mods/CountryGamer_PlantsVsZombies/textures/mobs/Snow Pea.png");
	}

	protected Item getDropItem() {
		return PvZ.snowPod;
	}

	public EntityThrowable entitySelect(World world) {
		EntitySnowPod ent = new EntitySnowPod(world, this);
		return ent;
	}
} public class EntitySunflower extends EntityPlantBase {
	private int delayControl = 600;

	public EntitySunflower(World par1World) {
		super(par1World, new ItemStack(PvZ.basicPlants, 1, 0));
	}

	public void dropFewItems(boolean par1, int par2) {
		dropItem(PvZ.sunlight, 2);
	}

	public void onLivingUpdate() {
		super.onLivingUpdate();

		int r = 3;
		List<?> rEntities = this.worldObj.getEntitiesWithinAABB(
				EntityLivingBase.class, AxisAlignedBB.getBoundingBox(this.posX
						- r, this.posY - r, this.posZ - r, this.posX + r,
						this.posY + r, this.posZ + r));

		ArrayList<EntityLivingBase> otherMob = new ArrayList<EntityLivingBase>();
		boolean wave = false;

		for (int i = 0; i < rEntities.size(); i++) {
			EntityLivingBase ent = (EntityLivingBase) rEntities.get(i);

			if (ent.getCreatureAttribute() == PvZ.plantAttribute) {
				if (ent.getAITarget() != null) {
					wave = true;
					break;
				}
				wave = false;
			} else {
				rEntities.remove(ent);
				otherMob.add(ent);
			}
		}

		int delay = this.delayControl;
		if (delay > 0) {
			delay--;
			return;
		}
		System.out.println("Delay wave check");
		delay = this.delayControl;
		double z;
		/*
		 * if (!wave) { for (EntityLivingBase ent : rEntities) { if (!(ent
		 * instanceof EntityShroomBase)) { if (ent.getHealth() !=
		 * ent.getMaxHealth()) { if (ent != this) ent.heal(ent.getMaxHealth());
		 * double x = ent.posX + 0.5D; double y = ent.posY + 0.5D; z = ent.posZ
		 * + 0.5D; } }
		 * 
		 * }
		 * 
		 * } else { for (EntityLivingBase ent1 : otherMob) if (!(ent1 instanceof
		 * EntityPlayer)) { System.out.println("slowness");
		 * ent1.addPotionEffect(new PotionEffect(Potion.moveSlowdown.getId(),
		 * 500, 5)); } }
		 */
	}
} public class EntityThreePeater extends EntityPlantShooterBase {
	public EntityThreePeater(World par1World) {
		super(par1World, new ItemStack(PvZ.basicPlants, 1, 4));

		setTexture("/mods/CountryGamer_PlantsVsZombies/textures/mobs/ThreePeater.png");
	}

	protected void dropFewItems(boolean par1, int par2) {
		dropItem(PvZ.peaPod, 3);
	}

	public EntityThrowable entitySelect(World world) {
		EntityPeaPod ent = new EntityPeaPod(world, this);
		return ent;
	}

	public void attackEntityWithRangedAttack(EntityLivingBase entitylivingbase,
			float f) {
		EntityThrowable ent1 = entitySelect(this.worldObj);

		int[] facingA = Util.entityDirectionSpawn(this);
		EntityThrowable ent2;
		EntityThrowable ent3;
		switch (Util.entityDirection(this)) {
		case 0:
			ent2 = new EntityPeaPod(this.worldObj, this,
					this.posX + facingA[0], this.posY, this.posZ);

			ent3 = new EntityPeaPod(this.worldObj, this,
					this.posX + facingA[1], this.posY, this.posZ);

			break;
		case 1:
			ent2 = new EntityPeaPod(this.worldObj, this, this.posX, this.posY,
					this.posZ + facingA[0]);

			ent3 = new EntityPeaPod(this.worldObj, this, this.posX, this.posY,
					this.posZ + facingA[1]);

			break;
		case 2:
			ent2 = new EntityPeaPod(this.worldObj, this,
					this.posX + facingA[0], this.posY, this.posZ);

			ent3 = new EntityPeaPod(this.worldObj, this,
					this.posX + facingA[1], this.posY, this.posZ);

			break;
		case 3:
			ent2 = new EntityPeaPod(this.worldObj, this, this.posX, this.posY,
					this.posZ + facingA[0]);

			ent3 = new EntityPeaPod(this.worldObj, this, this.posX, this.posY,
					this.posZ + facingA[1]);

			break;
		default:
			ent2 = new EntityPeaPod(this.worldObj, this, this.posX, this.posY,
					this.posZ);

			ent3 = new EntityPeaPod(this.worldObj, this, this.posX, this.posY,
					this.posZ);
		}

		double toX = entitylivingbase.posX - this.posX;
		float percentToMouth = 0.5F;
		double toY = entitylivingbase.posY + this.height * percentToMouth
				- 1.0D - ent1.posY;
		double toZ = entitylivingbase.posZ - this.posZ;
		float f1 = MathHelper.sqrt_double(toX * toX + toZ * toZ) * 0.2F;

		double podOffset = 0.7D;
		ent1.setThrowableHeading(toX, toY + f1, toZ, 1.6F, 12.0F);
		ent2.setThrowableHeading(toX + podOffset, toY + f1, toZ + podOffset,
				1.6F, 12.0F);
		ent3.setThrowableHeading(toX - podOffset, toY + f1, toZ - podOffset,
				1.6F, 12.0F);

		playSound("random.bow", 1.0F,
				1.0F / (getRNG().nextFloat() * 0.4F + 0.8F));
		this.worldObj.spawnEntityInWorld(ent1);
		this.worldObj.spawnEntityInWorld(ent2);
		this.worldObj.spawnEntityInWorld(ent3);

		Util.entityDirectionSpawn(this);
	}
} public class EntityWalnut extends EntityPlantBase {
	public EntityWalnut(World par1World) {
		super(par1World, new ItemStack(PvZ.sunlight, 1, 0));
	}

	protected void applyEntityAttributes() {
		super.applyEntityAttributes();
		setMaxHealth(PvZ.basePlantHealth * 16);
		getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(
				this.baseHealth);
	}

	public void onEntityUpdate() {
		super.onEntityUpdate();

		int r = 10;
		List<?> rEntities = this.worldObj.getEntitiesWithinAABB(
				EntityLivingBase.class, AxisAlignedBB.getBoundingBox(this.posX
						- r, this.posY, this.posZ - r, this.posX + r,
						this.posY + 1.0D, this.posZ + r));

		ArrayList<EntityLivingBase> otherMob = new ArrayList<EntityLivingBase>();
		for (int i = 0; i < rEntities.size(); i++) {
			EntityLivingBase ent = (EntityLivingBase) rEntities.get(i);
			if ((ent.getCreatureAttribute() == PvZ.plantAttribute)
					|| ((ent instanceof EntityPlayer))) {
				rEntities.remove(ent);
				otherMob.add(ent);
			} else {
				if ((((EntityCreature) ent).getEntityToAttack() instanceof EntityWalnut))
					continue;
			}
		}
	}
} public class EntityExplorerZombie extends EntityZombie {

	public EntityExplorerZombie(World world) {
		super(world);

		this.setCurrentItemOrArmor(4, new ItemStack(Items.leather_helmet));
		this.setCurrentItemOrArmor(3, new ItemStack(Items.leather_chestplate));
		this.setCurrentItemOrArmor(2, new ItemStack(Items.leather_leggings));
		this.setCurrentItemOrArmor(1, new ItemStack(Items.leather_boots));
		this.setCurrentItemOrArmor(0, new ItemStack(Blocks.torch));

	}

} public class EntityFlagZombie extends EntityZombie {

	public EntityFlagZombie(World world) {
		super(world);

		this.setCurrentItemOrArmor(0, new ItemStack(PvZ.flag));
	}
	
	/*
	public void onUpdate() {
		int minZombies = 1, maxZombies = 10;
		List list = this.worldObj.getEntitiesWithinAABB(EntityZombie.class,
				AxisAlignedBB.getBoundingBox(this.posX - 5, this.posY - 1,
						this.posY - 5, this.posX + 5, this.posY + 2,
						this.posZ + 5));
		Random rand = new Random();
		int randInt = rand.nextInt((maxZombies - minZombies) + 1) + minZombies;
		if (list.size() + randInt <= maxZombies) {
			int var = rand.nextInt(5);
			switch (var = 1) {
			case 0:
				for (int i = 0; i < randInt; i++) {
					EntityZombie ent = new EntityZombie(this.worldObj);
					ent.setPosition(this.posX, this.posY + 1.0D, this.posZ);
					if (!this.worldObj.isRemote)
						this.worldObj.spawnEntityInWorld(ent);
				}
				break;
			case 1:
				for (int i = 0; i < randInt; i++) {
					EntityFootballZombie ent = new EntityFootballZombie(
							this.worldObj);
					ent.setPosition(this.posX, this.posY + 1.0D, this.posZ);
					if (!this.worldObj.isRemote)
						this.worldObj.spawnEntityInWorld(ent);
				}
				break;
			case 2:
				break;
			case 3:
				break;
			case 4:
				break;
			}
		}

	}
	*/
	
	
} public class EntityFootballZombie extends EntityZombie
{
  public EntityFootballZombie(World par1World)
  {
    super(par1World);

    setCurrentItemOrArmor(4, new ItemStack(PvZ.footballHelm));
    setCurrentItemOrArmor(3, new ItemStack(PvZ.footballChest));
    setCurrentItemOrArmor(2, new ItemStack(PvZ.footballLegs));
    setCurrentItemOrArmor(1, new ItemStack(PvZ.footballBoots));
  }
} public class EntityCreeperPod extends EntityPodBase {
	public EntityCreeperPod(World world) {
		super(world);
	}

	public EntityCreeperPod(World world, EntityLivingBase entLiv) {
		super(world, entLiv);
	}

	public EntityCreeperPod(World world, double par2, double par4, double par6) {
		super(world, par2, par4, par6);
	}

	public void damageType(MovingObjectPosition movObjPos) {
		double damageMult = 0.5D;
		double damageMult2 = 4.0D;

		Entity ent = movObjPos.entityHit;
		boolean hitSomething = false;
		if ((ent instanceof EntityCreeper)) {
			this.toDamage = true;

			this.damage = (byte) (int) (damageMult * ((EntityCreeper) ent)
					.getMaxHealth());
		} else if ((ent instanceof EntityGhast)) {
			this.toDamage = true;
			this.damage = (byte) (int) (this.damage * damageMult2);

			if (this.damage >= ((EntityGhast) ent).getHealth()) {
				ent.setDead();
			}
			int x = (int) this.g.posX;
			int y = (int) this.g.posY;
			int z = (int) this.g.posZ;
			for (ItemStack itemStack : ghastDrops(0))
				;
		} else if ((ent instanceof EntityLivingBase)) {
			this.toDamage = false;
			hitSomething = true;
		} else if (!hitSomething) {
			impactExtra();
		}

		if ((movObjPos.entityHit != null) && (this.toDamage))
			movObjPos.entityHit.attackEntityFrom(
					DamageSource.causeThrownDamage(this, getThrower()),
					this.damage);
	}

	public void impactExtra() {
		if (this.g != null) {
			if (!(this.g instanceof EntityCreeperRepeater)) {
				float explosionRadius = (float) PvZ.creeperPodRad;
				this.worldObj.createExplosion(this, this.posX, this.posY,
						this.posZ, explosionRadius, true);
				setDead();
			}
		}
	}

	private ItemStack[] ghastDrops(int par2) {
		int j = this.rand.nextInt(2) + this.rand.nextInt(1 + par2);

		int tear = 0;
		for (int k = 0; k < j; k++)
			tear++;

		int powder = 0;
		j = this.rand.nextInt(3) + this.rand.nextInt(1 + par2);
		for (int k = 0; k < j; k++)
			powder++;

		ItemStack[] ghastDrops = { new ItemStack(Items.ghast_tear, tear),
				new ItemStack(Items.gunpowder, powder + 1) };

		return ghastDrops;
	}

	public boolean altCheck(Entity ent) {
		if ((ent instanceof EntityCreeper)) {
			this.toDamage = true;
			return true;
		}
		if ((ent instanceof EntityGhast)) {
			this.toDamage = true;
			return true;
		}
		return false;
	}
} public class EntityMoonlight extends EntityPodBase {
	public byte damage = 2;
	public boolean toDamage = false;
	public EntityLivingBase target = null;

	public EntityMoonlight(World world) {
		super(world);
	}

	public EntityMoonlight(World world, EntityLivingBase entLiv) {
		super(world, entLiv);
	}

	public EntityMoonlight(World world, double x, double y, double z) {
		super(world, x, y, z);
	}

	public boolean canAttackWithItem() {
		return false;
	}

	protected float getGravityVelocity() {
		return 0.01F;
	}

	protected void onImpact(MovingObjectPosition movObjPos) {
		int x = movObjPos.blockX;
		int y = movObjPos.blockY;
		int z = movObjPos.blockZ;
		World world = this.worldObj;
		EntityPlayer player = (EntityPlayer) getThrower();
		Random itemRand = new Random();

		Block block = world.getBlock(x, y, z);
		if ((block == Blocks.dirt) || (block == Blocks.grass)
				|| (block == Blocks.mycelium)) {
			world.setBlock(x, y, z, PvZ.darkenedGrass);
			setDead();
			return;
		}
		if (block == PvZ.endowedGrass) {
			Util.spawnItem(world, x, y, z, new ItemStack(PvZ.sunlight, 1));
			world.setBlock(x, y, z, PvZ.darkenedGrass);
			setDead();
			return;
		}
		Util.spawnItem(world, x, y, z, new ItemStack(PvZ.moonlight, 1));
		setDead();
	}
} public class EntityPeaPod extends EntityPodBase
{
  public EntityPeaPod(World world)
  {
    super(world);
  }
  public EntityPeaPod(World world, EntityLivingBase entLiv) {
    super(world, entLiv);
  }
  public EntityPeaPod(World world, double par2, double par4, double par6) {
    super(world, par2, par4, par6);
  }
  public EntityPeaPod(World world, EntityLivingBase entLiv, double par2, double par4, double par6) {
    super(world, par2, par4, par6);
    this.g = entLiv;
  }

  public void damageType(MovingObjectPosition movObjPos)
  {
    movObjPos.entityHit.attackEntityFrom(DamageSource.causeThrownDamage(this, getThrower()), this.damage);
  }
} public class EntityShroomPod extends EntityPodBase
{
  public EntityShroomPod(World world)
  {
    super(world);
  }
  public EntityShroomPod(World world, EntityLivingBase entLiv) {
    super(world, entLiv);
  }
  public EntityShroomPod(World world, double par2, double par4, double par6) {
    super(world, par2, par4, par6);
  }

  public void setDamage()
  {
    this.damage = (byte)(this.damage / 4);
    this.toDamage = true;
    if (!this.worldObj.isDaytime())
      this.damage = (byte)(this.damage * 2);
  }

  public void damageType(MovingObjectPosition movObjPos)
  {
    movObjPos.entityHit.attackEntityFrom(DamageSource.causeThrownDamage(this, getThrower()), this.damage);
  }
} public class EntitySnowPod extends EntityPodBase
{
  public int freezeLength = 200; public int freezeStrength = 1;

  public EntitySnowPod(World world)
  {
    super(world);
  }
  public EntitySnowPod(World world, EntityLivingBase entLiv) {
    super(world, entLiv);
  }
  public EntitySnowPod(World world, double par2, double par4, double par6) {
    super(world, par2, par4, par6);
  }

  public void setDamage()
  {
    this.damage = (byte)(this.damage / 2);
    this.toDamage = true;
  }

  public void damageType(MovingObjectPosition movObjPos)
  {
    ((EntityLiving)movObjPos.entityHit).addPotionEffect(new PotionEffect(Potion.moveSlowdown.getId(), this.freezeLength * 2, this.freezeStrength * 2));

    movObjPos.entityHit.attackEntityFrom(DamageSource.causeThrownDamage(this, getThrower()), this.damage);
  }
} public class EntitySunlight extends EntityPodBase {
	public byte damage = 2;
	public boolean toDamage = false;
	public EntityLivingBase target = null;

	public EntitySunlight(World world) {
		super(world);
	}

	public EntitySunlight(World world, EntityLivingBase entLiv) {
		super(world, entLiv);
	}

	public EntitySunlight(World world, double x, double y, double z) {
		super(world, x, y, z);
	}

	public boolean canAttackWithItem() {
		return false;
	}

	protected float getGravityVelocity() {
		return 0.01F;
	}

	protected void onImpact(MovingObjectPosition movObjPos) {
		int x = movObjPos.blockX;
		int y = movObjPos.blockY;
		int z = movObjPos.blockZ;
		World world = this.worldObj;
		EntityPlayer player = (EntityPlayer) getThrower();
		Random itemRand = new Random();

		Block block = world.getBlock(x, y, z);
		if ((block == Blocks.dirt) || (block == Blocks.grass)
				|| (block == Blocks.mycelium)) {
			world.setBlock(x, y, z, PvZ.endowedGrass);
			setDead();
			return;
		}
		if (block == PvZ.darkenedGrass) {
			Util.spawnItem(world, x, y, z, new ItemStack(PvZ.moonlight, 1));
			world.setBlock(x, y, z, PvZ.endowedGrass);
			setDead();
			return;
		}
		Util.spawnItem(world, x, y, z, new ItemStack(PvZ.sunlight, 1));
		setDead();
	}
} public class Resources {
	public static final ResourceLocation chlorophyllBowl = new ResourceLocation(
			Reference.MOD_ID, "textures/entities/blocks/bowlfilled.png");

	public static final ResourceLocation gravestone = new ResourceLocation(
			Reference.MOD_ID, "textures/entities/blocks/Gravestone.png");

	public static final ResourceLocation gravestoneReg = new ResourceLocation(
			Reference.MOD_ID, "textures/entities/blocks/Gravestone_Reg.png");

	public static final ResourceLocation gravestoneFootball = new ResourceLocation(
			Reference.MOD_ID,
			"textures/entities/blocks/Gravestone_Football.png");

	public static final ResourceLocation gravestoneFlag = new ResourceLocation(
			Reference.MOD_ID, "textures/entities/blocks/Gravestone_Flag.png");

	public static final ResourceLocation gravestoneCone = new ResourceLocation(
			Reference.MOD_ID, "textures/entities/blocks/Gravestone_Cone.png");

	public static final ResourceLocation gravestoneBucket = new ResourceLocation(
			Reference.MOD_ID, "textures/entities/blocks/Gravestone_Bucket.png");

	public static final ResourceLocation greenhouse = new ResourceLocation(
			Reference.MOD_ID, "textures/entities/blocks/greenhouse.png");

	public static final ResourceLocation sunflowerMob = new ResourceLocation(
			Reference.MOD_ID, "textures/entities/basicDay/sunflower.png");

	public static final ResourceLocation peaShooterMob = new ResourceLocation(
			Reference.MOD_ID, "textures/entities/basicDay/peashooter.png");

	public static final ResourceLocation snowPeaMob = new ResourceLocation(
			Reference.MOD_ID, "textures/entities/basicDay/snowpea.png");

	public static final ResourceLocation repeaterMob = new ResourceLocation(
			Reference.MOD_ID, "textures/entities/basicDay/repeater.png");

	public static final ResourceLocation threePeaterMob = new ResourceLocation(
			Reference.MOD_ID, "textures/entities/basicDay/threepeater.png");

	public static final ResourceLocation sunShroomMob_0 = new ResourceLocation(
			Reference.MOD_ID, "textures/entities/basicNight/sun_shroom_0.png");

	public static final ResourceLocation sunShroomMob_1 = new ResourceLocation(
			Reference.MOD_ID, "textures/entities/basicNight/sun_shroom_1.png");

	public static final ResourceLocation puffShroomMob_0 = new ResourceLocation(
			Reference.MOD_ID, "textures/entities/basicNight/puff_shroom_0.png");

	public static final ResourceLocation puffShroomMob_1 = new ResourceLocation(
			Reference.MOD_ID, "textures/entities/basicNight/puff_shroom_1.png");

	public static final ResourceLocation scaredyShroomMob_0 = new ResourceLocation(
			Reference.MOD_ID,
			"textures/entities/basicNight/scaredy_shroom_0.png");

	public static final ResourceLocation scaredyShroomMob_1 = new ResourceLocation(
			Reference.MOD_ID,
			"textures/entities/basicNight/scaredy_shroom_1.png");

	public static final ResourceLocation fumeShroomMob = new ResourceLocation(
			Reference.MOD_ID, "textures/entities/basicNight/fume_shroom_0.png");

	public static final ResourceLocation moonShroomMob = new ResourceLocation(
			Reference.MOD_ID, "textures/entities/basicNight/moonShroom.png");

	public static final ResourceLocation antiCreeperMob = new ResourceLocation(
			Reference.MOD_ID, "textures/entities/special/creeperrepeater.png");

	public static final ResourceLocation walnutMob = new ResourceLocation(
			Reference.MOD_ID, "textures/entities/special/walnut.png");
}
import net.minecraft.client.renderer.entity.RenderSnowball;
import net.minecraft.client.renderer.entity.RenderZombie;
import com.countrygamer.pvz.PvZ;
import com.countrygamer.pvz.block.plant.tile.TileEntityPeaShooter;
import com.countrygamer.pvz.block.plant.tile.TileEntityRepeater;
import com.countrygamer.pvz.block.plant.tile.TileEntitySnowPea;
import com.countrygamer.pvz.block.plant.tile.TileEntitySunflower;
import com.countrygamer.pvz.block.plant.tile.TileEntityThreePeater;
import com.countrygamer.pvz.block.plant.tile.client.RenderPlant;
import com.countrygamer.pvz.block.plant.tile.client.model.ModelPeaShooter;
import com.countrygamer.pvz.block.plant.tile.client.model.ModelRepeater;
import com.countrygamer.pvz.block.plant.tile.client.model.ModelSnowPea;
import com.countrygamer.pvz.block.plant.tile.client.model.ModelSunflower;
import com.countrygamer.pvz.block.plant.tile.client.model.ModelThreePeater;
import com.countrygamer.pvz.block.tile.TileEntityChlorophyllBowl;
import com.countrygamer.pvz.block.tile.TileEntityGravestone;
import com.countrygamer.pvz.block.tile.TileEntityGreenhouse;
import com.countrygamer.pvz.client.block.tile.RenderChlorophyllBowl;
import com.countrygamer.pvz.client.block.tile.RenderGravestone;
import com.countrygamer.pvz.client.block.tile.RenderGreenhouse;
import com.countrygamer.pvz.client.render.ModelFumeShroom;
import com.countrygamer.pvz.client.render.ModelMoonShroom;
import com.countrygamer.pvz.client.render.ModelPuffShroom;
import com.countrygamer.pvz.client.render.ModelScaredyShroom;
import com.countrygamer.pvz.client.render.ModelWalnut;
import com.countrygamer.pvz.client.render.RenderAntiCreeper;
import com.countrygamer.pvz.client.render.RenderFumeShroom;
import com.countrygamer.pvz.client.render.RenderMoonShroom;
import com.countrygamer.pvz.client.render.RenderPeaShooter;
import com.countrygamer.pvz.client.render.RenderPuffShroom;
import com.countrygamer.pvz.client.render.RenderRepeater;
import com.countrygamer.pvz.client.render.RenderScaredyShroom;
import com.countrygamer.pvz.client.render.RenderSnowPea;
import com.countrygamer.pvz.client.render.RenderSunflower;
import com.countrygamer.pvz.client.render.RenderThreePeater;
import com.countrygamer.pvz.client.render.RenderWalnut;
import com.countrygamer.pvz.entities.mobs.plants.EntityCreeperRepeater;
import com.countrygamer.pvz.entities.mobs.plants.EntityFumeShroom;
import com.countrygamer.pvz.entities.mobs.plants.EntityMoonShroom;
import com.countrygamer.pvz.entities.mobs.plants.EntityPeaShooter;
import com.countrygamer.pvz.entities.mobs.plants.EntityPuffShroom;
import com.countrygamer.pvz.entities.mobs.plants.EntityRepeater;
import com.countrygamer.pvz.entities.mobs.plants.EntityScaredyShroom;
import com.countrygamer.pvz.entities.mobs.plants.EntitySnowPea;
import com.countrygamer.pvz.entities.mobs.plants.EntitySunflower;
import com.countrygamer.pvz.entities.mobs.plants.EntityThreePeater;
import com.countrygamer.pvz.entities.mobs.plants.EntityWalnut;
import com.countrygamer.pvz.entities.mobs.zombies.EntityExplorerZombie;
import com.countrygamer.pvz.entities.mobs.zombies.EntityFlagZombie;
import com.countrygamer.pvz.entities.mobs.zombies.EntityFootballZombie;
import com.countrygamer.pvz.entities.projectiles.EntityCreeperPod;
import com.countrygamer.pvz.entities.projectiles.EntityMoonlight;
import com.countrygamer.pvz.entities.projectiles.EntityPeaPod;
import com.countrygamer.pvz.entities.projectiles.EntityShroomPod;
import com.countrygamer.pvz.entities.projectiles.EntitySnowPod;
import com.countrygamer.pvz.entities.projectiles.EntitySunlight;
import com.countrygamer.pvz.lib.Resources;
import cpw.mods.fml.client.registry.ClientRegistry;
import cpw.mods.fml.client.registry.RenderingRegistry;
package com.countrygamer.pvz.proxy;




public class ClientProxy extends ServerProxy {
	
	@Override
	public void registerRender() {
		ClientRegistry.bindTileEntitySpecialRenderer(TileEntityChlorophyllBowl.class,
				new RenderChlorophyllBowl());
		ClientRegistry.bindTileEntitySpecialRenderer(TileEntityGravestone.class,
				new RenderGravestone());
		ClientRegistry.bindTileEntitySpecialRenderer(TileEntityGreenhouse.class,
				new RenderGreenhouse());
		this.plantRenders();
		
		RenderingRegistry.registerEntityRenderingHandler(EntitySunflower.class,
				new RenderSunflower(new ModelSunflower(), 0.3F));
		RenderingRegistry.registerEntityRenderingHandler(EntityPeaShooter.class,
				new RenderPeaShooter(new ModelPeaShooter(), 0.3F));
		RenderingRegistry.registerEntityRenderingHandler(EntitySnowPea.class, new RenderSnowPea(
				new ModelSnowPea(), 0.3F));
		RenderingRegistry.registerEntityRenderingHandler(EntityRepeater.class, new RenderRepeater(
				new ModelRepeater(), 0.3F));
		RenderingRegistry.registerEntityRenderingHandler(EntityThreePeater.class,
				new RenderThreePeater(new ModelThreePeater(), 0.3F));
		RenderingRegistry.registerEntityRenderingHandler(EntityPuffShroom.class,
				new RenderPuffShroom(new ModelPuffShroom(), 0.3F));
		RenderingRegistry.registerEntityRenderingHandler(EntityFumeShroom.class,
				new RenderFumeShroom(new ModelFumeShroom(), 0.3F));
		RenderingRegistry.registerEntityRenderingHandler(EntityScaredyShroom.class,
				new RenderScaredyShroom(new ModelScaredyShroom(), 0.3F));
		RenderingRegistry.registerEntityRenderingHandler(EntityMoonShroom.class,
				new RenderMoonShroom(new ModelMoonShroom(), 0.3F));
		RenderingRegistry.registerEntityRenderingHandler(EntityCreeperRepeater.class,
				new RenderAntiCreeper(new ModelRepeater(), 0.3F));
		RenderingRegistry.registerEntityRenderingHandler(EntityWalnut.class, new RenderWalnut(
				new ModelWalnut(), 0.3F));
		
		RenderingRegistry.registerEntityRenderingHandler(EntityFootballZombie.class,