001    package net.minecraft.src;
002    
003    public class EntitySlime extends EntityLiving implements IMob
004    {
005        public float field_70813_a;
006        public float field_70811_b;
007        public float field_70812_c;
008    
009        /** the time between each jump of the slime */
010        private int slimeJumpDelay = 0;
011    
012        public EntitySlime(World par1World)
013        {
014            super(par1World);
015            this.texture = "/mob/slime.png";
016            int var2 = 1 << this.rand.nextInt(3);
017            this.yOffset = 0.0F;
018            this.slimeJumpDelay = this.rand.nextInt(20) + 10;
019            this.setSlimeSize(var2);
020        }
021    
022        protected void entityInit()
023        {
024            super.entityInit();
025            this.dataWatcher.addObject(16, new Byte((byte)1));
026        }
027    
028        public void setSlimeSize(int par1)
029        {
030            this.dataWatcher.updateObject(16, new Byte((byte)par1));
031            this.setSize(0.6F * (float)par1, 0.6F * (float)par1);
032            this.setPosition(this.posX, this.posY, this.posZ);
033            this.setEntityHealth(this.getMaxHealth());
034            this.experienceValue = par1;
035        }
036    
037        public int getMaxHealth()
038        {
039            int var1 = this.getSlimeSize();
040            return var1 * var1;
041        }
042    
043        /**
044         * Returns the size of the slime.
045         */
046        public int getSlimeSize()
047        {
048            return this.dataWatcher.getWatchableObjectByte(16);
049        }
050    
051        /**
052         * (abstract) Protected helper method to write subclass entity data to NBT.
053         */
054        public void writeEntityToNBT(NBTTagCompound par1NBTTagCompound)
055        {
056            super.writeEntityToNBT(par1NBTTagCompound);
057            par1NBTTagCompound.setInteger("Size", this.getSlimeSize() - 1);
058        }
059    
060        /**
061         * (abstract) Protected helper method to read subclass entity data from NBT.
062         */
063        public void readEntityFromNBT(NBTTagCompound par1NBTTagCompound)
064        {
065            super.readEntityFromNBT(par1NBTTagCompound);
066            this.setSlimeSize(par1NBTTagCompound.getInteger("Size") + 1);
067        }
068    
069        /**
070         * Returns the name of a particle effect that may be randomly created by EntitySlime.onUpdate()
071         */
072        protected String getSlimeParticle()
073        {
074            return "slime";
075        }
076    
077        /**
078         * Returns the name of the sound played when the slime jumps.
079         */
080        protected String getJumpSound()
081        {
082            return "mob.slime";
083        }
084    
085        /**
086         * Called to update the entity's position/logic.
087         */
088        public void onUpdate()
089        {
090            if (!this.worldObj.isRemote && this.worldObj.difficultySetting == 0 && this.getSlimeSize() > 0)
091            {
092                this.isDead = true;
093            }
094    
095            this.field_70811_b += (this.field_70813_a - this.field_70811_b) * 0.5F;
096            this.field_70812_c = this.field_70811_b;
097            boolean var1 = this.onGround;
098            super.onUpdate();
099    
100            if (this.onGround && !var1)
101            {
102                int var2 = this.getSlimeSize();
103    
104                for (int var3 = 0; var3 < var2 * 8; ++var3)
105                {
106                    float var4 = this.rand.nextFloat() * (float)Math.PI * 2.0F;
107                    float var5 = this.rand.nextFloat() * 0.5F + 0.5F;
108                    float var6 = MathHelper.sin(var4) * (float)var2 * 0.5F * var5;
109                    float var7 = MathHelper.cos(var4) * (float)var2 * 0.5F * var5;
110                    this.worldObj.spawnParticle(this.getSlimeParticle(), this.posX + (double)var6, this.boundingBox.minY, this.posZ + (double)var7, 0.0D, 0.0D, 0.0D);
111                }
112    
113                if (this.makesSoundOnLand())
114                {
115                    this.worldObj.playSoundAtEntity(this, this.getJumpSound(), this.getSoundVolume(), ((this.rand.nextFloat() - this.rand.nextFloat()) * 0.2F + 1.0F) / 0.8F);
116                }
117    
118                this.field_70813_a = -0.5F;
119            }
120            else if (!this.onGround && var1)
121            {
122                this.field_70813_a = 1.0F;
123            }
124    
125            this.func_70808_l();
126        }
127    
128        protected void updateEntityActionState()
129        {
130            this.despawnEntity();
131            EntityPlayer var1 = this.worldObj.getClosestVulnerablePlayerToEntity(this, 16.0D);
132    
133            if (var1 != null)
134            {
135                this.faceEntity(var1, 10.0F, 20.0F);
136            }
137    
138            if (this.onGround && this.slimeJumpDelay-- <= 0)
139            {
140                this.slimeJumpDelay = this.getJumpDelay();
141    
142                if (var1 != null)
143                {
144                    this.slimeJumpDelay /= 3;
145                }
146    
147                this.isJumping = true;
148    
149                if (this.makesSoundOnJump())
150                {
151                    this.worldObj.playSoundAtEntity(this, this.getJumpSound(), this.getSoundVolume(), ((this.rand.nextFloat() - this.rand.nextFloat()) * 0.2F + 1.0F) * 0.8F);
152                }
153    
154                this.moveStrafing = 1.0F - this.rand.nextFloat() * 2.0F;
155                this.moveForward = (float)(1 * this.getSlimeSize());
156            }
157            else
158            {
159                this.isJumping = false;
160    
161                if (this.onGround)
162                {
163                    this.moveStrafing = this.moveForward = 0.0F;
164                }
165            }
166        }
167    
168        protected void func_70808_l()
169        {
170            this.field_70813_a *= 0.6F;
171        }
172    
173        /**
174         * Gets the amount of time the slime needs to wait between jumps.
175         */
176        protected int getJumpDelay()
177        {
178            return this.rand.nextInt(20) + 10;
179        }
180    
181        protected EntitySlime createInstance()
182        {
183            return new EntitySlime(this.worldObj);
184        }
185    
186        /**
187         * Will get destroyed next tick.
188         */
189        public void setDead()
190        {
191            int var1 = this.getSlimeSize();
192    
193            if (!this.worldObj.isRemote && var1 > 1 && this.getHealth() <= 0)
194            {
195                int var2 = 2 + this.rand.nextInt(3);
196    
197                for (int var3 = 0; var3 < var2; ++var3)
198                {
199                    float var4 = ((float)(var3 % 2) - 0.5F) * (float)var1 / 4.0F;
200                    float var5 = ((float)(var3 / 2) - 0.5F) * (float)var1 / 4.0F;
201                    EntitySlime var6 = this.createInstance();
202                    var6.setSlimeSize(var1 / 2);
203                    var6.setLocationAndAngles(this.posX + (double)var4, this.posY + 0.5D, this.posZ + (double)var5, this.rand.nextFloat() * 360.0F, 0.0F);
204                    this.worldObj.spawnEntityInWorld(var6);
205                }
206            }
207    
208            super.setDead();
209        }
210    
211        /**
212         * Called by a player entity when they collide with an entity
213         */
214        public void onCollideWithPlayer(EntityPlayer par1EntityPlayer)
215        {
216            if (this.canDamagePlayer())
217            {
218                int var2 = this.getSlimeSize();
219    
220                if (this.canEntityBeSeen(par1EntityPlayer) && this.getDistanceSqToEntity(par1EntityPlayer) < 0.6D * (double)var2 * 0.6D * (double)var2 && par1EntityPlayer.attackEntityFrom(DamageSource.causeMobDamage(this), this.getAttackStrength()))
221                {
222                    this.worldObj.playSoundAtEntity(this, "mob.slimeattack", 1.0F, (this.rand.nextFloat() - this.rand.nextFloat()) * 0.2F + 1.0F);
223                }
224            }
225        }
226    
227        /**
228         * Indicates weather the slime is able to damage the player (based upon the slime's size)
229         */
230        protected boolean canDamagePlayer()
231        {
232            return this.getSlimeSize() > 1;
233        }
234    
235        /**
236         * Gets the amount of damage dealt to the player when "attacked" by the slime.
237         */
238        protected int getAttackStrength()
239        {
240            return this.getSlimeSize();
241        }
242    
243        /**
244         * Returns the sound this mob makes when it is hurt.
245         */
246        protected String getHurtSound()
247        {
248            return "mob.slime";
249        }
250    
251        /**
252         * Returns the sound this mob makes on death.
253         */
254        protected String getDeathSound()
255        {
256            return "mob.slime";
257        }
258    
259        /**
260         * Returns the item ID for the item the mob drops on death.
261         */
262        protected int getDropItemId()
263        {
264            return this.getSlimeSize() == 1 ? Item.slimeBall.shiftedIndex : 0;
265        }
266    
267        /**
268         * Checks if the entity's current position is a valid location to spawn this entity.
269         */
270        public boolean getCanSpawnHere()
271        {
272            Chunk var1 = this.worldObj.getChunkFromBlockCoords(MathHelper.floor_double(this.posX), MathHelper.floor_double(this.posZ));
273            return this.worldObj.getWorldInfo().getTerrainType().handleSlimeSpawnReduction(rand, worldObj) ? false : ((this.getSlimeSize() == 1 || this.worldObj.difficultySetting > 0) && this.rand.nextInt(10) == 0 && var1.getRandomWithSeed(987234911L).nextInt(10) == 0 && this.posY < 40.0D ? super.getCanSpawnHere() : false);
274        }
275    
276        /**
277         * Returns the volume for the sounds this mob makes.
278         */
279        protected float getSoundVolume()
280        {
281            return 0.4F * (float)this.getSlimeSize();
282        }
283    
284        /**
285         * The speed it takes to move the entityliving's rotationPitch through the faceEntity method. This is only currently
286         * use in wolves.
287         */
288        public int getVerticalFaceSpeed()
289        {
290            return 0;
291        }
292    
293        /**
294         * Returns true if the slime makes a sound when it jumps (based upon the slime's size)
295         */
296        protected boolean makesSoundOnJump()
297        {
298            return this.getSlimeSize() > 1;
299        }
300    
301        /**
302         * Returns true if the slime makes a sound when it lands after a jump (based upon the slime's size)
303         */
304        protected boolean makesSoundOnLand()
305        {
306            return this.getSlimeSize() > 2;
307        }
308    }