+ Added some random entities.

4 files changed, 937 insertions, 0 deletions

diff --git a/src/Java/gtPlusPlus/core/entity/monster/EntitySickBlaze.java b/src/Java/gtPlusPlus/core/entity/monster/EntitySickBlaze.java
new file mode 100644
index 0000000000..4d46c0a5ca
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/entity/monster/EntitySickBlaze.java
@@ -0,0 +1,236 @@
+package gtPlusPlus.core.entity.monster;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import gtPlusPlus.core.entity.projectile.EntityToxinballSmall;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.SharedMonsterAttributes;
+import net.minecraft.entity.monster.EntityBlaze;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Items;
+import net.minecraft.item.Item;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.MathHelper;
+import net.minecraft.world.World;
+
+public class EntitySickBlaze extends EntityBlaze {
+	/** Random offset used in floating behaviour */
+	private float heightOffset = 0.5F;
+	/** ticks until heightOffset is randomized */
+	private int heightOffsetUpdateTime;
+	private int field_70846_g;
+
+	public EntitySickBlaze(World p_i1731_1_) {
+		super(p_i1731_1_);
+		this.isImmuneToFire = true;
+		this.experienceValue = 10;
+	}
+
+	@Override
+	protected void applyEntityAttributes() {
+		super.applyEntityAttributes();
+		this.getEntityAttribute(SharedMonsterAttributes.attackDamage).setBaseValue(6.0D);
+	}
+
+	@Override
+	protected void entityInit() {
+		super.entityInit();
+		this.dataWatcher.addObject(16, new Byte((byte) 0));
+	}
+
+	/**
+	 * Returns the sound this mob makes while it's alive.
+	 */
+	@Override
+	protected String getLivingSound() {
+		return "mob.blaze.breathe";
+	}
+
+	/**
+	 * Returns the sound this mob makes when it is hurt.
+	 */
+	@Override
+	protected String getHurtSound() {
+		return "mob.blaze.hit";
+	}
+
+	/**
+	 * Returns the sound this mob makes on death.
+	 */
+	@Override
+	protected String getDeathSound() {
+		return "mob.blaze.death";
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public int getBrightnessForRender(float p_70070_1_) {
+		return 15728880;
+	}
+
+	/**
+	 * Gets how bright this entity is.
+	 */
+	@Override
+	public float getBrightness(float p_70013_1_) {
+		return 1.0F;
+	}
+
+	/**
+	 * Called frequently so the entity can update its state every tick as
+	 * required. For example, zombies and skeletons use this to react to
+	 * sunlight and start to burn.
+	 */
+	@Override
+	public void onLivingUpdate() {
+		if (!this.worldObj.isRemote) {
+			if (this.isWet()) {
+				this.attackEntityFrom(DamageSource.drown, 1.0F);
+			}
+
+			--this.heightOffsetUpdateTime;
+
+			if (this.heightOffsetUpdateTime <= 0) {
+				this.heightOffsetUpdateTime = 100;
+				this.heightOffset = 0.5F + (float) this.rand.nextGaussian() * 3.0F;
+			}
+
+			if (this.getEntityToAttack() != null && this.getEntityToAttack().posY
+					+ this.getEntityToAttack().getEyeHeight() > this.posY + this.getEyeHeight() + this.heightOffset) {
+				this.motionY += (0.30000001192092896D - this.motionY) * 0.30000001192092896D;
+			}
+		}
+
+		if (this.rand.nextInt(24) == 0) {
+			this.worldObj.playSoundEffect(this.posX + 0.5D, this.posY + 0.5D, this.posZ + 0.5D, "fire.fire",
+					1.0F + this.rand.nextFloat(), this.rand.nextFloat() * 0.7F + 0.3F);
+		}
+
+		if (!this.onGround && this.motionY < 0.0D) {
+			this.motionY *= 0.6D;
+		}
+
+		for (int i = 0; i < 2; ++i) {
+			this.worldObj.spawnParticle("largesmoke", this.posX + (this.rand.nextDouble() - 0.5D) * this.width,
+					this.posY + this.rand.nextDouble() * this.height,
+					this.posZ + (this.rand.nextDouble() - 0.5D) * this.width, 0.0D, 0.0D, 0.0D);
+		}
+
+		super.onLivingUpdate();
+	}
+
+	/**
+	 * Basic mob attack. Default to touch of death in EntityCreature. Overridden
+	 * by each mob to define their attack.
+	 */
+	@Override
+	protected void attackEntity(Entity entity, float p_70785_2_) {
+		if (this.attackTime <= 0 && p_70785_2_ < 2.0F && entity.boundingBox.maxY > this.boundingBox.minY
+				&& entity.boundingBox.minY < this.boundingBox.maxY) {
+			this.attackTime = 20;
+			this.attackEntityAsMob(entity);
+		}
+		else if (p_70785_2_ < 30.0F) {
+			double d0 = entity.posX - this.posX;
+			double d1 = entity.boundingBox.minY + entity.height / 2.0F - (this.posY + this.height / 2.0F);
+			double d2 = entity.posZ - this.posZ;
+
+			if (this.attackTime == 0) {
+				++this.field_70846_g;
+
+				if (this.field_70846_g == 1) {
+					this.attackTime = 60;
+					this.func_70844_e(true);
+				}
+				else if (this.field_70846_g <= 4) {
+					this.attackTime = 6;
+				}
+				else {
+					this.attackTime = 100;
+					this.field_70846_g = 0;
+					this.func_70844_e(false);
+				}
+
+				if (this.field_70846_g > 1) {
+					float f1 = MathHelper.sqrt_float(p_70785_2_) * 0.5F;
+					this.worldObj.playAuxSFXAtEntity((EntityPlayer) null, 1009, (int) this.posX, (int) this.posY,
+							(int) this.posZ, 0);
+
+					for (int i = 0; i < 1; ++i) {
+						EntityToxinballSmall entitysmalltoxinball = new EntityToxinballSmall(this.worldObj, this,
+								d0 + this.rand.nextGaussian() * f1, d1, d2 + this.rand.nextGaussian() * f1);
+						entitysmalltoxinball.posY = this.posY + this.height / 2.0F + 0.5D;
+						this.worldObj.spawnEntityInWorld(entitysmalltoxinball);
+					}
+				}
+			}
+
+			this.rotationYaw = (float) (Math.atan2(d2, d0) * 180.0D / Math.PI) - 90.0F;
+			this.hasAttacked = true;
+		}
+	}
+
+	/**
+	 * Called when the mob is falling. Calculates and applies fall damage.
+	 */
+	@Override
+	protected void fall(float p_70069_1_) {
+	}
+
+	@Override
+	protected Item getDropItem() {
+		return Items.blaze_rod;
+	}
+
+	/**
+	 * Returns true if the entity is on fire. Used by render to add the fire
+	 * effect on rendering.
+	 */
+	@Override
+	public boolean isBurning() {
+		return this.func_70845_n();
+	}
+
+	/**
+	 * Drop 0-2 items of this living's type. @param par1 - Whether this entity
+	 * has recently been hit by a player. @param par2 - Level of Looting used to
+	 * kill this mob.
+	 */
+	@Override
+	protected void dropFewItems(boolean p_70628_1_, int p_70628_2_) {
+		if (p_70628_1_) {
+			int j = this.rand.nextInt(2 + p_70628_2_);
+
+			for (int k = 0; k < j; ++k) {
+				this.dropItem(Items.blaze_rod, 1);
+			}
+		}
+	}
+
+	@Override
+	public boolean func_70845_n() {
+		return (this.dataWatcher.getWatchableObjectByte(16) & 1) != 0;
+	}
+
+	@Override
+	public void func_70844_e(boolean p_70844_1_) {
+		byte b0 = this.dataWatcher.getWatchableObjectByte(16);
+
+		if (p_70844_1_) {
+			b0 = (byte) (b0 | 1);
+		}
+		else {
+			b0 &= -2;
+		}
+
+		this.dataWatcher.updateObject(16, Byte.valueOf(b0));
+	}
+
+	/**
+	 * Checks to make sure the light is not too bright where the mob is spawning
+	 */
+	@Override
+	protected boolean isValidLightLevel() {
+		return true;
+	}
+}
\ No newline at end of file
diff --git a/src/Java/gtPlusPlus/core/entity/monster/EntityStaballoyWarrior.java b/src/Java/gtPlusPlus/core/entity/monster/EntityStaballoyWarrior.java
new file mode 100644
index 0000000000..b6829f6985
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/entity/monster/EntityStaballoyWarrior.java
@@ -0,0 +1,283 @@
+package gtPlusPlus.core.entity.monster;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.entity.*;
+import net.minecraft.entity.ai.*;
+import net.minecraft.entity.monster.EntityGolem;
+import net.minecraft.entity.monster.IMob;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.init.Items;
+import net.minecraft.item.Item;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.*;
+import net.minecraft.village.Village;
+import net.minecraft.world.World;
+
+public class EntityStaballoyWarrior extends EntityGolem {
+	/** deincrements, and a distance-to-home check is done at 0 */
+	private int homeCheckTimer;
+	Village villageObj;
+	private int attackTimer;
+	private int holdRoseTick;
+
+	public EntityStaballoyWarrior(World world) {
+		super(world);
+		this.setSize(1.4F, 2.9F);
+		this.getNavigator().setAvoidsWater(true);
+		this.tasks.addTask(1, new EntityAIAttackOnCollide(this, 1.0D, true));
+		this.tasks.addTask(2, new EntityAIMoveTowardsTarget(this, 0.9D, 32.0F));
+		this.tasks.addTask(3, new EntityAIMoveThroughVillage(this, 0.6D, true));
+		this.tasks.addTask(4, new EntityAIMoveTowardsRestriction(this, 1.0D));
+		this.tasks.addTask(5, new EntityAIWander(this, 0.6D));
+		this.tasks.addTask(6, new EntityAIWatchClosest(this, EntityPlayer.class, 6.0F));
+		this.tasks.addTask(7, new EntityAILookIdle(this));
+		this.targetTasks.addTask(1, new EntityAIHurtByTarget(this, false));
+		this.targetTasks.addTask(2,
+				new EntityAINearestAttackableTarget(this, EntityLiving.class, 0, false, true, IMob.mobSelector));
+	}
+
+	@Override
+	protected void entityInit() {
+		super.entityInit();
+		this.dataWatcher.addObject(16, Byte.valueOf((byte) 0));
+	}
+
+	/**
+	 * Returns true if the newer Entity AI code should be run
+	 */
+	@Override
+	public boolean isAIEnabled() {
+		return true;
+	}
+
+	/**
+	 * main AI tick function, replaces updateEntityActionState
+	 */
+	@Override
+	protected void updateAITick() {
+		if (--this.homeCheckTimer <= 0) {
+			this.homeCheckTimer = 70 + this.rand.nextInt(50);
+			this.villageObj = this.worldObj.villageCollectionObj.findNearestVillage(MathHelper.floor_double(this.posX),
+					MathHelper.floor_double(this.posY), MathHelper.floor_double(this.posZ), 32);
+
+			if (this.villageObj == null) {
+				this.detachHome();
+			}
+			else {
+				ChunkCoordinates chunkcoordinates = this.villageObj.getCenter();
+				this.setHomeArea(chunkcoordinates.posX, chunkcoordinates.posY, chunkcoordinates.posZ,
+						(int) (this.villageObj.getVillageRadius() * 0.6F));
+			}
+		}
+
+		super.updateAITick();
+	}
+
+	@Override
+	protected void applyEntityAttributes() {
+		super.applyEntityAttributes();
+		this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(100.0D);
+		this.getEntityAttribute(SharedMonsterAttributes.movementSpeed).setBaseValue(0.25D);
+	}
+
+	/**
+	 * Decrements the entity's air supply when underwater
+	 */
+	@Override
+	protected int decreaseAirSupply(int p_70682_1_) {
+		return p_70682_1_;
+	}
+
+	@Override
+	protected void collideWithEntity(Entity p_82167_1_) {
+		if (p_82167_1_ instanceof IMob && this.getRNG().nextInt(20) == 0) {
+			this.setAttackTarget((EntityLivingBase) p_82167_1_);
+		}
+
+		super.collideWithEntity(p_82167_1_);
+	}
+
+	/**
+	 * Called frequently so the entity can update its state every tick as
+	 * required. For example, zombies and skeletons use this to react to
+	 * sunlight and start to burn.
+	 */
+	@Override
+	public void onLivingUpdate() {
+		super.onLivingUpdate();
+
+		if (this.attackTimer > 0) {
+			--this.attackTimer;
+		}
+
+		if (this.holdRoseTick > 0) {
+			--this.holdRoseTick;
+		}
+
+		if (this.motionX * this.motionX + this.motionZ * this.motionZ > 2.500000277905201E-7D
+				&& this.rand.nextInt(5) == 0) {
+			int i = MathHelper.floor_double(this.posX);
+			int j = MathHelper.floor_double(this.posY - 0.20000000298023224D - this.yOffset);
+			int k = MathHelper.floor_double(this.posZ);
+			Block block = this.worldObj.getBlock(i, j, k);
+
+			if (block.getMaterial() != Material.air) {
+				this.worldObj.spawnParticle(
+						"blockcrack_" + Block.getIdFromBlock(block) + "_" + this.worldObj.getBlockMetadata(i, j, k),
+						this.posX + (this.rand.nextFloat() - 0.5D) * this.width,
+						this.boundingBox.minY + 0.1D,
+						this.posZ + (this.rand.nextFloat() - 0.5D) * this.width,
+						4.0D * (this.rand.nextFloat() - 0.5D), 0.5D,
+						(this.rand.nextFloat() - 0.5D) * 4.0D);
+			}
+		}
+	}
+
+	/**
+	 * Returns true if this entity can attack entities of the specified class.
+	 */
+	@Override
+	public boolean canAttackClass(Class p_70686_1_) {
+		return this.isPlayerCreated() && EntityPlayer.class.isAssignableFrom(p_70686_1_) ? false
+				: super.canAttackClass(p_70686_1_);
+	}
+
+	/**
+	 * (abstract) Protected helper method to write subclass entity data to NBT.
+	 */
+	@Override
+	public void writeEntityToNBT(NBTTagCompound p_70014_1_) {
+		super.writeEntityToNBT(p_70014_1_);
+		p_70014_1_.setBoolean("PlayerCreated", this.isPlayerCreated());
+	}
+
+	/**
+	 * (abstract) Protected helper method to read subclass entity data from NBT.
+	 */
+	@Override
+	public void readEntityFromNBT(NBTTagCompound p_70037_1_) {
+		super.readEntityFromNBT(p_70037_1_);
+		this.setPlayerCreated(p_70037_1_.getBoolean("PlayerCreated"));
+	}
+
+	@Override
+	public boolean attackEntityAsMob(Entity p_70652_1_) {
+		this.attackTimer = 10;
+		this.worldObj.setEntityState(this, (byte) 4);
+		boolean flag = p_70652_1_.attackEntityFrom(DamageSource.causeMobDamage(this),
+				7 + this.rand.nextInt(15));
+
+		if (flag) {
+			p_70652_1_.motionY += 0.4000000059604645D;
+		}
+
+		this.playSound("mob.irongolem.throw", 1.0F, 1.0F);
+		return flag;
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void handleHealthUpdate(byte p_70103_1_) {
+		if (p_70103_1_ == 4) {
+			this.attackTimer = 10;
+			this.playSound("mob.irongolem.throw", 1.0F, 1.0F);
+		}
+		else if (p_70103_1_ == 11) {
+			this.holdRoseTick = 400;
+		}
+		else {
+			super.handleHealthUpdate(p_70103_1_);
+		}
+	}
+
+	public Village getVillage() {
+		return this.villageObj;
+	}
+
+	@SideOnly(Side.CLIENT)
+	public int getAttackTimer() {
+		return this.attackTimer;
+	}
+
+	public void setHoldingRose(boolean p_70851_1_) {
+		this.holdRoseTick = p_70851_1_ ? 400 : 0;
+		this.worldObj.setEntityState(this, (byte) 11);
+	}
+
+	/**
+	 * Returns the sound this mob makes when it is hurt.
+	 */
+	@Override
+	protected String getHurtSound() {
+		return "mob.irongolem.hit";
+	}
+
+	/**
+	 * Returns the sound this mob makes on death.
+	 */
+	@Override
+	protected String getDeathSound() {
+		return "mob.irongolem.death";
+	}
+
+	@Override
+	protected void func_145780_a(int p_145780_1_, int p_145780_2_, int p_145780_3_, Block p_145780_4_) {
+		this.playSound("mob.irongolem.walk", 1.0F, 1.0F);
+	}
+
+	/**
+	 * Drop 0-2 items of this living's type. @param par1 - Whether this entity
+	 * has recently been hit by a player. @param par2 - Level of Looting used to
+	 * kill this mob.
+	 */
+	@Override
+	protected void dropFewItems(boolean p_70628_1_, int p_70628_2_) {
+		int j = this.rand.nextInt(3);
+		int k;
+
+		for (k = 0; k < j; ++k) {
+			this.func_145778_a(Item.getItemFromBlock(Blocks.red_flower), 1, 0.0F);
+		}
+
+		k = 3 + this.rand.nextInt(3);
+
+		for (int l = 0; l < k; ++l) {
+			this.dropItem(Items.iron_ingot, 1);
+		}
+	}
+
+	public int getHoldRoseTick() {
+		return this.holdRoseTick;
+	}
+
+	public boolean isPlayerCreated() {
+		return (this.dataWatcher.getWatchableObjectByte(16) & 1) != 0;
+	}
+
+	public void setPlayerCreated(boolean p_70849_1_) {
+		byte b0 = this.dataWatcher.getWatchableObjectByte(16);
+
+		if (p_70849_1_) {
+			this.dataWatcher.updateObject(16, Byte.valueOf((byte) (b0 | 1)));
+		}
+		else {
+			this.dataWatcher.updateObject(16, Byte.valueOf((byte) (b0 & -2)));
+		}
+	}
+
+	/**
+	 * Called when the mob's health reaches 0.
+	 */
+	@Override
+	public void onDeath(DamageSource p_70645_1_) {
+		if (!this.isPlayerCreated() && this.attackingPlayer != null && this.villageObj != null) {
+			this.villageObj.setReputationForPlayer(this.attackingPlayer.getCommandSenderName(), -5);
+		}
+
+		super.onDeath(p_70645_1_);
+	}
+}
\ No newline at end of file
diff --git a/src/Java/gtPlusPlus/core/entity/projectile/EntityToxinball.java b/src/Java/gtPlusPlus/core/entity/projectile/EntityToxinball.java
new file mode 100644
index 0000000000..5fcdc67ed6
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/entity/projectile/EntityToxinball.java
@@ -0,0 +1,330 @@
+package gtPlusPlus.core.entity.projectile;
+
+import java.util.List;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import net.minecraft.block.Block;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.projectile.EntityFireball;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.util.*;
+import net.minecraft.world.World;
+
+public abstract class EntityToxinball extends EntityFireball {
+	protected int entityX = -1;
+	protected int entityY = -1;
+	protected int entityZ = -1;
+	private Block block;
+	private boolean inGround;
+	public EntityLivingBase shootingEntity;
+	private int ticksAlive;
+	private int ticksInAir;
+	public double accelerationX;
+	public double accelerationY;
+	public double accelerationZ;
+
+	public EntityToxinball(World world) {
+		super(world);
+		this.setSize(1.0F, 1.0F);
+	}
+
+	@Override
+	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
+	 */
+	@Override
+	@SideOnly(Side.CLIENT)
+	public boolean isInRangeToRenderDist(double p_70112_1_) {
+		double d1 = this.boundingBox.getAverageEdgeLength() * 4.0D;
+		d1 *= 64.0D;
+		return p_70112_1_ < d1 * d1;
+	}
+
+	public EntityToxinball(World world, double x, double y, double z, double f1, double f2, double f3) {
+		super(world);
+		this.setSize(1.0F, 1.0F);
+		this.setLocationAndAngles(x, y, z, this.rotationYaw, this.rotationPitch);
+		this.setPosition(x, y, z);
+		double d6 = MathHelper
+				.sqrt_double(f1 * f1 + f2 * f2 + f3 * f3);
+		this.accelerationX = f1 / d6 * 0.1D;
+		this.accelerationY = f2 / d6 * 0.1D;
+		this.accelerationZ = f3 / d6 * 0.1D;
+	}
+
+	public EntityToxinball(World world, EntityLivingBase entity, double x, double y, double z) {
+		super(world);
+		this.shootingEntity = entity;
+		this.setSize(1.0F, 1.0F);
+		this.setLocationAndAngles(entity.posX, entity.posY, entity.posZ, entity.rotationYaw,
+				entity.rotationPitch);
+		this.setPosition(this.entityX, this.entityY, this.entityZ);
+		this.yOffset = 0.0F;
+		this.motionX = this.motionY = this.motionZ = 0.0D;
+		x += this.rand.nextGaussian() * 0.4D;
+		y += this.rand.nextGaussian() * 0.4D;
+		z += this.rand.nextGaussian() * 0.4D;
+		double d3 = MathHelper.sqrt_double(x * x + y * y + z * z);
+		this.accelerationX = x / d3 * 0.1D;
+		this.accelerationY = y / d3 * 0.1D;
+		this.accelerationZ = z / d3 * 0.1D;
+	}
+
+	/**
+	 * Called to update the entity's position/logic.
+	 */
+	@Override
+	public void onUpdate() {
+		if (!this.worldObj.isRemote && (this.shootingEntity != null && this.shootingEntity.isDead
+				|| !this.worldObj.blockExists(this.entityX, this.entityY, this.entityZ))) {
+			this.setDead();
+		}
+		else {
+			super.onUpdate();
+			this.setFire(1);
+
+			if (this.inGround) {
+				if (this.worldObj.getBlock(this.entityX, this.entityY,
+						this.entityZ) == this.block) {
+					++this.ticksAlive;
+
+					if (this.ticksAlive == 600) {
+						this.setDead();
+					}
+
+					return;
+				}
+
+				this.inGround = false;
+				this.motionX *= this.rand.nextFloat() * 0.2F;
+				this.motionY *= this.rand.nextFloat() * 0.2F;
+				this.motionZ *= this.rand.nextFloat() * 0.2F;
+				this.ticksAlive = 0;
+				this.ticksInAir = 0;
+			}
+			else {
+				++this.ticksInAir;
+			}
+
+			Vec3 vec3 = Vec3.createVectorHelper(this.entityX, this.entityY, this.entityZ);
+			Vec3 vec31 = Vec3.createVectorHelper(this.entityX + this.motionX, this.entityY + this.motionY,
+					this.entityZ + this.motionZ);
+			MovingObjectPosition movingobjectposition = this.worldObj.rayTraceBlocks(vec3, vec31);
+			vec3 = Vec3.createVectorHelper(this.entityX, this.entityY, this.entityZ);
+			vec31 = Vec3.createVectorHelper(this.entityX + this.motionX, this.entityY + this.motionY,
+					this.entityZ + this.motionZ);
+
+			if (movingobjectposition != null) {
+				vec31 = Vec3.createVectorHelper(movingobjectposition.hitVec.xCoord, movingobjectposition.hitVec.yCoord,
+						movingobjectposition.hitVec.zCoord);
+			}
+
+			Entity entity = null;
+			List<?> list = this.worldObj.getEntitiesWithinAABBExcludingEntity(this,
+					this.boundingBox.addCoord(this.motionX, this.motionY, this.motionZ).expand(1.0D, 1.0D, 1.0D));
+			double d0 = 0.0D;
+
+			for (int i = 0; i < list.size(); ++i) {
+				Entity entity1 = (Entity) list.get(i);
+
+				if (entity1.canBeCollidedWith()
+						&& (!entity1.isEntityEqual(this.shootingEntity) || this.ticksInAir >= 25)) {
+					float f = 0.3F;
+					AxisAlignedBB axisalignedbb = entity1.boundingBox.expand(f, f, f);
+					MovingObjectPosition movingobjectposition1 = axisalignedbb.calculateIntercept(vec3, vec31);
+
+					if (movingobjectposition1 != null) {
+						double d1 = vec3.distanceTo(movingobjectposition1.hitVec);
+
+						if (d1 < d0 || d0 == 0.0D) {
+							entity = entity1;
+							d0 = d1;
+						}
+					}
+				}
+			}
+
+			if (entity != null) {
+				movingobjectposition = new MovingObjectPosition(entity);
+			}
+
+			if (movingobjectposition != null) {
+				this.onImpact(movingobjectposition);
+			}
+
+			this.entityX += this.motionX;
+			this.entityY += this.motionY;
+			this.entityZ += this.motionZ;
+			float f1 = MathHelper.sqrt_double(this.motionX * this.motionX + this.motionZ * this.motionZ);
+			this.rotationYaw = (float) (Math.atan2(this.motionZ, this.motionX) * 180.0D / Math.PI) + 90.0F;
+
+			for (this.rotationPitch = (float) (Math.atan2(f1, this.motionY) * 180.0D / Math.PI)
+					- 90.0F; this.rotationPitch - this.prevRotationPitch < -180.0F; this.prevRotationPitch -= 360.0F) {
+				;
+			}
+
+			while (this.rotationPitch - this.prevRotationPitch >= 180.0F) {
+				this.prevRotationPitch += 360.0F;
+			}
+
+			while (this.rotationYaw - this.prevRotationYaw < -180.0F) {
+				this.prevRotationYaw -= 360.0F;
+			}
+
+			while (this.rotationYaw - this.prevRotationYaw >= 180.0F) {
+				this.prevRotationYaw += 360.0F;
+			}
+
+			this.rotationPitch = this.prevRotationPitch + (this.rotationPitch - this.prevRotationPitch) * 0.2F;
+			this.rotationYaw = this.prevRotationYaw + (this.rotationYaw - this.prevRotationYaw) * 0.2F;
+			float f2 = this.getMotionFactor();
+
+			if (this.isInWater()) {
+				for (int j = 0; j < 4; ++j) {
+					float f3 = 0.25F;
+					this.worldObj.spawnParticle("bubble", this.entityX - this.motionX * f3, this.entityY - this.motionY * f3,
+							this.entityZ - this.motionZ * f3, this.motionX, this.motionY, this.motionZ);
+				}
+
+				f2 = 0.8F;
+			}
+
+			this.motionX += this.accelerationX;
+			this.motionY += this.accelerationY;
+			this.motionZ += this.accelerationZ;
+			this.motionX *= f2;
+			this.motionY *= f2;
+			this.motionZ *= f2;
+			this.worldObj.spawnParticle("smoke", this.entityX, this.entityY + 0.5D, this.entityZ, 0.0D, 0.0D, 0.0D);
+			this.setPosition(this.entityX, this.entityY, this.entityZ);
+		}
+	}
+
+	/**
+	 * Return the motion factor for this projectile. The factor is multiplied by
+	 * the original motion.
+	 */
+	@Override
+	protected float getMotionFactor() {
+		return 0.95F;
+	}
+
+	/**
+	 * Called when this EntityFireball hits a block or entity.
+	 */
+	@Override
+	protected abstract void onImpact(MovingObjectPosition p_70227_1_);
+
+	/**
+	 * (abstract) Protected helper method to write subclass entity data to NBT.
+	 */
+	@Override
+	public void writeEntityToNBT(NBTTagCompound aTag) {
+		aTag.setShort("xTile", (short) this.entityX);
+		aTag.setShort("yTile", (short) this.entityY);
+		aTag.setShort("zTile", (short) this.entityZ);
+		aTag.setByte("inTile", (byte) Block.getIdFromBlock(this.block));
+		aTag.setByte("inGround", (byte) (this.inGround ? 1 : 0));
+		aTag.setTag("direction",
+				this.newDoubleNBTList(new double[] { this.motionX, this.motionY, this.motionZ }));
+	}
+
+	/**
+	 * (abstract) Protected helper method to read subclass entity data from NBT.
+	 */
+	@Override
+	public void readEntityFromNBT(NBTTagCompound aTag) {
+		this.entityX = aTag.getShort("xTile");
+		this.entityY = aTag.getShort("yTile");
+		this.entityZ = aTag.getShort("zTile");
+		this.block = Block.getBlockById(aTag.getByte("inTile") & 255);
+		this.inGround = aTag.getByte("inGround") == 1;
+
+		if (aTag.hasKey("direction", 9)) {
+			NBTTagList nbttaglist = aTag.getTagList("direction", 6);
+			this.motionX = nbttaglist.func_150309_d(0);
+			this.motionY = nbttaglist.func_150309_d(1);
+			this.motionZ = nbttaglist.func_150309_d(2);
+		}
+		else {
+			this.setDead();
+		}
+	}
+
+	/**
+	 * Returns true if other Entities should be prevented from moving through
+	 * this Entity.
+	 */
+	@Override
+	public boolean canBeCollidedWith() {
+		return true;
+	}
+
+	@Override
+	public float getCollisionBorderSize() {
+		return 1.0F;
+	}
+
+	/**
+	 * Called when the entity is attacked.
+	 */
+	@Override
+	public boolean attackEntityFrom(DamageSource damage, float p_70097_2_) {
+		if (this.isEntityInvulnerable()) {
+			return false;
+		}
+		else {
+			this.setBeenAttacked();
+
+			if (damage.getEntity() != null) {
+				Vec3 vec3 = damage.getEntity().getLookVec();
+
+				if (vec3 != null) {
+					this.motionX = vec3.xCoord;
+					this.motionY = vec3.yCoord;
+					this.motionZ = vec3.zCoord;
+					this.accelerationX = this.motionX * 0.1D;
+					this.accelerationY = this.motionY * 0.1D;
+					this.accelerationZ = this.motionZ * 0.1D;
+				}
+
+				if (damage.getEntity() instanceof EntityLivingBase) {
+					this.shootingEntity = (EntityLivingBase) damage.getEntity();
+				}
+
+				return true;
+			}
+			else {
+				return false;
+			}
+		}
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public float getShadowSize() {
+		return 0.0F;
+	}
+
+	/**
+	 * Gets how bright this entity is.
+	 */
+	@Override
+	public float getBrightness(float p_70013_1_) {
+		return 1.0F;
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public int getBrightnessForRender(float p_70070_1_) {
+		return 15728880;
+	}
+}
\ No newline at end of file
diff --git a/src/Java/gtPlusPlus/core/entity/projectile/EntityToxinballSmall.java b/src/Java/gtPlusPlus/core/entity/projectile/EntityToxinballSmall.java
new file mode 100644
index 0000000000..78469c9dad
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/entity/projectile/EntityToxinballSmall.java
@@ -0,0 +1,88 @@
+package gtPlusPlus.core.entity.projectile;
+
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.init.Blocks;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.World;
+
+public class EntityToxinballSmall extends EntityToxinball {
+
+	public EntityToxinballSmall(World p_i1770_1_) {
+		super(p_i1770_1_);
+		this.setSize(0.3125F, 0.3125F);
+	}
+
+	public EntityToxinballSmall(World world, EntityLivingBase entity, double x, double y, double z) {
+		super(world, entity, x, y, z);
+		this.setSize(0.3125F, 0.3125F);
+	}
+
+	public EntityToxinballSmall(World p_i1772_1_, double p_i1772_2_, double p_i1772_4_, double p_i1772_6_, double p_i1772_8_, double p_i1772_10_, double p_i1772_12_) {
+		super(p_i1772_1_, p_i1772_2_, p_i1772_4_, p_i1772_6_, p_i1772_8_, p_i1772_10_, p_i1772_12_);
+		this.setSize(0.3125F, 0.3125F);
+	}
+
+	/**
+	 * Called when this EntityFireball hits a block or entity.
+	 */
+	@Override
+	protected void onImpact(MovingObjectPosition MoP) {
+		if (!this.worldObj.isRemote) {
+			if (MoP.entityHit != null) {
+				if (!MoP.entityHit.isImmuneToFire() && MoP.entityHit
+						.attackEntityFrom(DamageSource.causeFireballDamage(this, this.shootingEntity), 5.0F)) {
+					MoP.entityHit.setFire(5);
+				}
+			}
+			else {
+				int i = MoP.blockX;
+				int j = MoP.blockY;
+				int k = MoP.blockZ;
+
+				switch (MoP.sideHit) {
+					case 0:
+						--j;
+						break;
+					case 1:
+						++j;
+						break;
+					case 2:
+						--k;
+						break;
+					case 3:
+						++k;
+						break;
+					case 4:
+						--i;
+						break;
+					case 5:
+						++i;
+				}
+
+				if (this.worldObj.isAirBlock(i, j, k)) {
+					this.worldObj.setBlock(i, j, k, Blocks.fire);
+				}
+			}
+
+			this.setDead();
+		}
+	}
+
+	/**
+	 * Returns true if other Entities should be prevented from moving through
+	 * this Entity.
+	 */
+	@Override
+	public boolean canBeCollidedWith() {
+		return false;
+	}
+
+	/**
+	 * Called when the entity is attacked.
+	 */
+	@Override
+	public boolean attackEntityFrom(DamageSource p_70097_1_, float p_70097_2_) {
+		return false;
+	}
+}
\ No newline at end of file