View difference between Paste ID: wqQQLYU3 and 8fgP0T0P

 package net.minecraft.src;
 
 import java.util.List;
 import java.util.Random;
 
-public class EntityFireball extends Entity
+public class EntityTPHFlamethrower extends EntityFireball
 {
     private int xTile;
     private int yTile;
     private int zTile;
     private int inTile;
     private boolean inGround;
-    public EntityLiving shootingEntity;
+
     private int ticksInAir;
     public float moveSpeed;
-    public double accelerationX;
+    public double destX;
-    public double accelerationY;
+    public double destZ;
-    public double accelerationZ;
+
     public EntityTPHFlamethrower(World par1World, EntityLiving shooter, EntityLiving target)
-    public EntityFireball(World par1World)
+
         super(par1World);
         xTile = -1;
         yTile = -1;
         zTile = -1;
         inTile = 0;
         inGround = false;
         ticksInAir = 0;
         destX = target.posX;
         destZ = target.posZ;
         moveSpeed = 1.0F;
         shootingEntity = shooter;
         setSize(1.0F, 1.0F);
     }
 
     protected void entityInit()
     {
     }
 
     /**
      * Checks if the entity is in range to render by using the past in distance and comparing it to its average edge
      * length * 64 * renderDistanceWeight Args: distance
      */
     public boolean isInRangeToRenderDist(double par1)
     {
         double d = boundingBox.getAverageEdgeLength() * 4D;
         d *= 64D;
-    public EntityFireball(World par1World, double par2, double par4, double par6, double par8, double par10, double par12)
+
     }
 
     /**
      * Called to update the entity's position/logic.
      */
     public void onUpdate()
     {
         if (something((int)posX, (int)posY, (int)posZ))
         {
-        setLocationAndAngles(par2, par4, par6, rotationYaw, rotationPitch);
+        	if (something((int)posX, (int)posY + 1, (int)posZ))
-        setPosition(par2, par4, par6);
+        	{
-        double d = MathHelper.sqrt_double(par8 * par8 + par10 * par10 + par12 * par12);
+	            setDead();
-        accelerationX = (par8 / d) * 0.10000000000000001D;
+	            return;
-        accelerationY = (par10 / d) * 0.10000000000000001D;
+        	} else posY += 1;
-        accelerationZ = (par12 / d) * 0.10000000000000001D;
+        } else if (!something((int)posX, (int)posY - 1, (int)posZ)) {
         	if (!something((int)posX, (int)posY - 2, (int)posZ)){
         		setDead();
-    public EntityFireball(World par1World, EntityLiving par2EntityLiving, double par3, double par5, double par7)
+        		return;
         	} else posY -= 1;
         }
 
         worldObj.setBlockWithNotify((int) posX, (int) posY, (int) posZ, Block.fire.blockID);
         super.onUpdate();
         setFire(1);
 
         //if (inGround)
-        shootingEntity = par2EntityLiving;
+        //{
             //int i = worldObj.getBlockId(xTile, yTile, zTile);
-        setLocationAndAngles(par2EntityLiving.posX, par2EntityLiving.posY, par2EntityLiving.posZ, par2EntityLiving.rotationYaw, par2EntityLiving.rotationPitch);
+
             //if (i != inTile)
-        yOffset = 0.0F;
+            //{
-        motionX = motionY = motionZ = 0.0D;
+            //    inGround = false;
-        par3 += rand.nextGaussian() * 0.40000000000000002D;
+            //    motionX *= rand.nextFloat() * 0.2F;
-        par5 += rand.nextGaussian() * 0.40000000000000002D;
+            //    motionY *= rand.nextFloat() * 0.2F;
-        par7 += rand.nextGaussian() * 0.40000000000000002D;
+            //    motionZ *= rand.nextFloat() * 0.2F;
-        double d = MathHelper.sqrt_double(par3 * par3 + par5 * par5 + par7 * par7);
+            //    ticksAlive = 0;
-        accelerationX = (par3 / d) * 0.10000000000000001D;
+            //    ticksInAir = 0;
-        accelerationY = (par5 / d) * 0.10000000000000001D;
+            //}
-        accelerationZ = (par7 / d) * 0.10000000000000001D;
+            //else
             //{
                 ticksAlive++;
 
                 if (ticksAlive >= 100)
                 {
                     setDead();
                     worldObj.newExplosion(null, posX, posY, posZ, 1.0F, true);
-        if (!worldObj.isRemote && (shootingEntity != null && shootingEntity.isDead || !worldObj.blockExists((int)posX, (int)posY, (int)posZ)))
+
 
                 //return;
-            return;
+            //}
         //}
         //else
         //{
             ticksInAir++;
         //}
-        if (inGround)
+
         Vec3D vec3d = Vec3D.createVector(posX, posY, posZ);
-            int i = worldObj.getBlockId(xTile, yTile, zTile);
+
         MovingObjectPosition movingobjectposition = worldObj.rayTraceBlocks(vec3d, vec3d1);
-            if (i != inTile)
+
         vec3d1 = Vec3D.createVector(posX + motionX, posY + motionY, posZ + motionZ);
-                inGround = false;
+
-                motionX *= rand.nextFloat() * 0.2F;
+
-                motionY *= rand.nextFloat() * 0.2F;
+
-                motionZ *= rand.nextFloat() * 0.2F;
+
-                ticksAlive = 0;
+
-                ticksInAir = 0;
+
         Entity entity = null;
-            else
+
         double d = 0.0D;
 
         for (int j = 0; j < list.size(); j++)
-                if (ticksAlive == 600)
+
             Entity entity1 = (Entity)list.get(j);
 
             if (!entity1.canBeCollidedWith() || entity1.isEntityEqual(shootingEntity) && ticksInAir < 25)
             {
-                return;
+
             }
 
-        else
+
             AxisAlignedBB axisalignedbb = entity1.boundingBox.expand(f2, f2, f2);
             MovingObjectPosition movingobjectposition1 = axisalignedbb.calculateIntercept(vec3d, vec3d1);
 
             if (movingobjectposition1 == null)
             {
                 continue;
             }
 
             double d1 = vec3d.distanceTo(movingobjectposition1.hitVec);
 
             if (d1 < d || d == 0.0D)
             {
                 entity = entity1;
                 d = d1;
             }
         }
 
         if (entity != null)
         {
             movingobjectposition = new MovingObjectPosition(entity);
         }
 
         if (movingobjectposition != null)
         {
             func_40071_a(movingobjectposition);
         }
 
         posX += motionX;
         posY += motionY;
         posZ += motionZ;
         float f = MathHelper.sqrt_double(motionX * motionX + motionZ * motionZ);
         //rotationYaw = (float)((Math.atan2(motionX, motionZ) * 180D) / Math.PI);
 
         //for (rotationPitch = (float)((Math.atan2(motionY, f) * 180D) / Math.PI); rotationPitch - prevRotationPitch < -180F; prevRotationPitch -= 360F) { }
 
         //for (; rotationPitch - prevRotationPitch >= 180F; prevRotationPitch += 360F) { }
 
         //for (; rotationYaw - prevRotationYaw < -180F; prevRotationYaw -= 360F) { }
 
         //for (; rotationYaw - prevRotationYaw >= 180F; prevRotationYaw += 360F) { }
 
         //rotationPitch = prevRotationPitch + (rotationPitch - prevRotationPitch) * 0.2F;
         //rotationYaw = prevRotationYaw + (rotationYaw - prevRotationYaw) * 0.2F;
         float f1 = 0.95F;
 
         if (isInWater())
         {
             for (int k = 0; k < 4; k++)
             {
                 float f3 = 0.25F;
                 worldObj.spawnParticle("bubble", posX - motionX * (double)f3, posY - motionY * (double)f3, posZ - motionZ * (double)f3, motionX, motionY, motionZ);
             }
 
             f1 = 0.8F;
         }
 
         //motionX += accelerationX;
         //motionY += accelerationY;
         //motionZ += accelerationZ;
         //motionX *= f1;
-        rotationYaw = (float)((Math.atan2(motionX, motionZ) * 180D) / Math.PI);
+        //motionY *= f1;
         //motionZ *= f1;
-        for (rotationPitch = (float)((Math.atan2(motionY, f) * 180D) / Math.PI); rotationPitch - prevRotationPitch < -180F; prevRotationPitch -= 360F) { }
+
         motionX = Math.cos(Math.toRadians(rotationYaw)) * moveSpeed;
-        for (; rotationPitch - prevRotationPitch >= 180F; prevRotationPitch += 360F) { }
+        motionY = 0;
         motionZ = Math.sin(Math.toRadians(rotationYaw)) * moveSpeed;
-        for (; rotationYaw - prevRotationYaw < -180F; prevRotationYaw -= 360F) { }
+        float n = (float) Math.atan2(destZ - 100, destX - 100) - rotationYaw;
         rotationYaw += (n > ticksAlive) ? (float) ticksAlive : n;
-        for (; rotationYaw - prevRotationYaw >= 180F; prevRotationYaw += 360F) { }
+        //worldObj.spawnParticle("smoke", posX, posY + 0.5D, posZ, 0.0D, 0.0D, 0.0D);
         setPosition(posX, posY, posZ);
-        rotationPitch = prevRotationPitch + (rotationPitch - prevRotationPitch) * 0.2F;
+
-        rotationYaw = prevRotationYaw + (rotationYaw - prevRotationYaw) * 0.2F;
+
     protected void func_40071_a(MovingObjectPosition par1MovingObjectPosition)
     {
         if (!worldObj.isRemote)
         {
             if (par1MovingObjectPosition.entityHit != null)
             {
                 if (!par1MovingObjectPosition.entityHit.attackEntityFrom(DamageSource.causeFireballDamage((EntityFireball) this, shootingEntity), 4));
             }
 
             worldObj.newExplosion(null, posX, posY, posZ, 1.0F, true);
             setDead();
         }
     }
-        motionX += accelerationX;
+
-        motionY += accelerationY;
+
-        motionZ += accelerationZ;
+
-        motionX *= f1;
+
-        motionY *= f1;
+
-        motionZ *= f1;
+
-        worldObj.spawnParticle("smoke", posX, posY + 0.5D, posZ, 0.0D, 0.0D, 0.0D);
+
         par1NBTTagCompound.setShort("yTile", (short)yTile);
         par1NBTTagCompound.setShort("zTile", (short)zTile);
         par1NBTTagCompound.setByte("inTile", (byte)inTile);
         par1NBTTagCompound.setByte("inGround", (byte)(inGround ? 1 : 0));
     }
 
     /**
      * (abstract) Protected helper method to read subclass entity data from NBT.
      */
-                if (!par1MovingObjectPosition.entityHit.attackEntityFrom(DamageSource.causeFireballDamage(this, shootingEntity), 4));
+
     {
         xTile = par1NBTTagCompound.getShort("xTile");
         yTile = par1NBTTagCompound.getShort("yTile");
         zTile = par1NBTTagCompound.getShort("zTile");
         inTile = par1NBTTagCompound.getByte("inTile") & 0xff;
         inGround = par1NBTTagCompound.getByte("inGround") == 1;
     }
 
     /**
      * Returns true if other Entities should be prevented from moving through this Entity.
      */
     public boolean canBeCollidedWith()
     {
         return true;
     }
 
     public float getCollisionBorderSize()
     {
         return 1.0F;
     }
 
     public boolean attackEntityFrom(DamageSource par1DamageSource, int par2)
     {
     	setBeenAttacked();
     	if (par1DamageSource.getEntity() != null)
     		return true;
     	else
     		return false;
     }
 
     public float getShadowSize()
     {
         return 0.0F;
     }
 
     /**
      * Gets how bright this entity is.
      */
     public float getBrightness(float par1)
     {
         return 1.0F;
     }
 
     public int getBrightnessForRender(float par1)
     {
-     * Called when the entity is attacked.
+
     }
 
     /**
-        setBeenAttacked();
+     * @param Radius
      * @param OriginX
-        if (par1DamageSource.getEntity() != null)
+     * @param OriginY
      * @param Angle
-            Vec3D vec3d = par1DamageSource.getEntity().getLookVec();
+     * @return Point on circumference of circle at that angle
      */
-            if (vec3d != null)
+    public double[] GetCircumferencePoints(double Radius, double OriginX, double OriginY, double Angle)
     {
-                motionX = vec3d.xCoord;
+    	double X = OriginX+Radius*Math.sin(Angle*Math.PI/180);
-                motionY = vec3d.yCoord;
+    	double Y = OriginY+Radius*-Math.cos(Angle*Math.PI/180);
-                motionZ = vec3d.zCoord;
+    	return new double[] {X, Y};
-                accelerationX = motionX * 0.10000000000000001D;
+
-                accelerationY = motionY * 0.10000000000000001D;
+
-                accelerationZ = motionZ * 0.10000000000000001D;
+    public boolean something(int x, int y, int z)
     {
     	return (worldObj.blockExists(x, y, z) && worldObj.getBlockId(x, y, z) != Block.fire.blockID);
-            if (par1DamageSource.getEntity() instanceof EntityLiving)
+
 }