initial commit

java/src/game/entity/projectile/EntityPotion.java

@@ -0,0 +1,198 @@
+package game.entity.projectile;
+
+import java.util.List;
+
+import game.entity.types.EntityLiving;
+import game.entity.types.EntityThrowable;
+import game.entity.types.IObjectData;
+import game.init.Items;
+import game.item.ItemStack;
+import game.nbt.NBTTagCompound;
+import game.potion.Potion;
+import game.potion.PotionEffect;
+import game.world.BlockPos;
+import game.world.BoundingBox;
+import game.world.HitPosition;
+import game.world.World;
+
+public class EntityPotion extends EntityThrowable implements IObjectData
+{
+    /**
+     * The damage value of the thrown potion that this EntityPotion represents.
+     */
+    private ItemStack potionDamage;
+
+    public EntityPotion(World worldIn)
+    {
+        super(worldIn);
+    }
+
+    public EntityPotion(World worldIn, EntityLiving throwerIn, int meta)
+    {
+        this(worldIn, throwerIn, new ItemStack(Items.potion, 1, meta));
+    }
+
+    public EntityPotion(World worldIn, EntityLiving throwerIn, ItemStack potionDamageIn)
+    {
+        super(worldIn, throwerIn);
+        this.potionDamage = potionDamageIn;
+    }
+
+    public EntityPotion(World worldIn, double x, double y, double z, int data)
+    {
+        this(worldIn, x, y, z, new ItemStack(Items.potion, 1, data));
+    }
+
+    public EntityPotion(World worldIn, double x, double y, double z, ItemStack potionDamageIn)
+    {
+        super(worldIn, x, y, z);
+        this.potionDamage = potionDamageIn;
+    }
+
+    /**
+     * Gets the amount of gravity to apply to the thrown entity with each tick.
+     */
+    protected float getGravityVelocity()
+    {
+        return 0.05F;
+    }
+
+    protected float getVelocity()
+    {
+        return 0.5F;
+    }
+
+    protected float getInaccuracy()
+    {
+        return -20.0F;
+    }
+
+    /**
+     * Sets the PotionEffect by the given id of the potion effect.
+     */
+    public void setPotionDamage(int potionId)
+    {
+        if (this.potionDamage == null)
+        {
+            this.potionDamage = new ItemStack(Items.potion, 1, 0);
+        }
+
+        this.potionDamage.setItemDamage(potionId);
+    }
+
+    /**
+     * Returns the damage value of the thrown potion that this EntityPotion represents.
+     */
+    public int getPotionDamage()
+    {
+        if (this.potionDamage == null)
+        {
+            this.potionDamage = new ItemStack(Items.potion, 1, 0);
+        }
+
+        return this.potionDamage.getMetadata();
+    }
+
+    /**
+     * Called when this EntityThrowable hits a block or entity.
+     */
+    protected void onImpact(HitPosition p_70184_1_)
+    {
+        if (!this.worldObj.client)
+        {
+            List<PotionEffect> list = Items.potion.getEffects(this.potionDamage);
+
+            BoundingBox axisalignedbb = this.getEntityBoundingBox().expand(4.0D, 2.0D, 4.0D);
+            List<EntityLiving> list1 = this.worldObj.<EntityLiving>getEntitiesWithinAABB(EntityLiving.class, axisalignedbb);
+
+            if (!list1.isEmpty())
+            {
+                for (EntityLiving entitylivingbase : list1)
+                {
+                    double d0 = this.getDistanceSqToEntity(entitylivingbase);
+
+                    if (d0 < 16.0D)
+                    {
+                        if (list != null && !list.isEmpty())
+                        {
+                            double d1 = 1.0D - Math.sqrt(d0) / 4.0D;
+
+                            if (entitylivingbase == p_70184_1_.entity)
+                            {
+                                d1 = 1.0D;
+                            }
+                            
+                            for (PotionEffect potioneffect : list)
+                            {
+                                int i = potioneffect.getPotionID();
+
+                                if (Potion.POTION_TYPES[i].isInstant())
+                                {
+                                    Potion.POTION_TYPES[i].affectEntity(this, this.getThrower(), entitylivingbase, potioneffect.getAmplifier(), d1);
+                                }
+                                else
+                                {
+                                    int j = (int)(d1 * (double)potioneffect.getDuration() + 0.5D);
+
+                                    if (j > 20)
+                                    {
+                                        entitylivingbase.addEffect(new PotionEffect(i, j, potioneffect.getAmplifier()));
+                                    }
+                                }
+                            }
+                        }
+                        else {
+                        	entitylivingbase.extinguish();
+                        }
+                    }
+                }
+            }
+
+            this.worldObj.playAuxSFX(2002, new BlockPos(this), this.getPotionDamage());
+            this.setDead();
+        }
+    }
+
+    /**
+     * (abstract) Protected helper method to read subclass entity data from NBT.
+     */
+    public void readEntityFromNBT(NBTTagCompound tagCompund)
+    {
+        super.readEntityFromNBT(tagCompund);
+
+        if (tagCompund.hasKey("Potion", 10))
+        {
+            this.potionDamage = ItemStack.loadItemStackFromNBT(tagCompund.getCompoundTag("Potion"));
+        }
+        else
+        {
+            this.setPotionDamage(tagCompund.getInteger("potionValue"));
+        }
+
+        if (this.potionDamage == null)
+        {
+            this.setDead();
+        }
+    }
+
+    /**
+     * (abstract) Protected helper method to write subclass entity data to NBT.
+     */
+    public void writeEntityToNBT(NBTTagCompound tagCompound)
+    {
+        super.writeEntityToNBT(tagCompound);
+
+        if (this.potionDamage != null)
+        {
+            tagCompound.setTag("Potion", this.potionDamage.writeToNBT(new NBTTagCompound()));
+        }
+    }
+	
+	public int getPacketData() {
+		return this.getPotionDamage();
+	}
+	
+//	public boolean hasSpawnVelocity() {
+//		return false;
+//	}
+}