Minecraft Forums

package lostworld.entities;

import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import lostworld.blocks.Blocks;
import lostworld.items.Items;
import lostworld.lib.Methods;
import lostworld.lib.XYZpoint;
import net.minecraft.block.Block;
import net.minecraft.enchantment.EnchantmentThorns;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.IProjectile;
import net.minecraft.entity.monster.EntityEnderman;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.network.packet.Packet70GameEvent;
import net.minecraft.util.*;
import net.minecraft.world.World;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;

/**
 * Created with IntelliJ IDEA.
 * User: Slash
 * Date: 1/3/14
 * Time: 2:22 PM
 */
public class EntityGlowingArrow extends Entity implements IProjectile {
private int xTile = -1;
private int yTile = -1;
private int zTile = -1;
private int inTile;
private int inData;
private boolean inGround;
private List<XYZpoint> xyzLightBlocks = new ArrayList<XYZpoint>();

/** 1 if the player can pick up the arrow */
public int canBePickedUp;

/** Seems to be some sort of timer for animating an arrow. */
public int arrowShake;

/** The owner of this arrow. */
public Entity shootingEntity;
private int ticksInGround;
private int ticksInAir;
private double damage = 2.0D;

/** The amount of knockback an arrow applies when it hits a mob. */
private int knockbackStrength;

public EntityGlowingArrow(World par1World)
{
super(par1World);
this.renderDistanceWeight = 10.0D;
this.setSize(0.5F, 0.5F);
}

public EntityGlowingArrow(World par1World, double par2, double par4, double par6)
{
super(par1World);
this.renderDistanceWeight = 10.0D;
this.setSize(0.5F, 0.5F);
this.setPosition(par2, par4, par6);
this.yOffset = 0.0F;
}

public EntityGlowingArrow(World par1World, EntityLivingBase par2EntityLivingBase, EntityLivingBase par3EntityLivingBase, float par4, float par5)
{
super(par1World);
this.renderDistanceWeight = 10.0D;
this.shootingEntity = par2EntityLivingBase;

if (par2EntityLivingBase instanceof EntityPlayer)
{
this.canBePickedUp = 1;
}

this.posY = par2EntityLivingBase.posY + (double)par2EntityLivingBase.getEyeHeight() - 0.10000000149011612D;
double d0 = par3EntityLivingBase.posX - par2EntityLivingBase.posX;
double d1 = par3EntityLivingBase.boundingBox.minY + (double)(par3EntityLivingBase.height / 3.0F) - this.posY;
double d2 = par3EntityLivingBase.posZ - par2EntityLivingBase.posZ;
double d3 = (double)MathHelper.sqrt_double(d0 * d0 + d2 * d2);

if (d3 >= 1.0E-7D)
{
float f2 = (float)(Math.atan2(d2, d0) * 180.0D / Math.PI) - 90.0F;
float f3 = (float)(-(Math.atan2(d1, d3) * 180.0D / Math.PI));
double d4 = d0 / d3;
double d5 = d2 / d3;
this.setLocationAndAngles(par2EntityLivingBase.posX + d4, this.posY, par2EntityLivingBase.posZ + d5, f2, f3);
this.yOffset = 0.0F;
float f4 = (float)d3 * 0.2F;
this.setThrowableHeading(d0, d1 + (double)f4, d2, par4, par5);
}
}

public EntityGlowingArrow(World par1World, EntityLivingBase par2EntityLivingBase, float par3)
{
super(par1World);
this.renderDistanceWeight = 10.0D;
this.shootingEntity = par2EntityLivingBase;

this.canBePickedUp = 1;

this.setSize(0.5F, 0.5F);
this.setLocationAndAngles(par2EntityLivingBase.posX, par2EntityLivingBase.posY + (double)par2EntityLivingBase.getEyeHeight(), par2EntityLivingBase.posZ, par2EntityLivingBase.rotationYaw, par2EntityLivingBase.rotationPitch);
this.posX -= (double)(MathHelper.cos(this.rotationYaw / 180.0F * (float)Math.PI) * 0.16F);
this.posY -= 0.10000000149011612D;
this.posZ -= (double)(MathHelper.sin(this.rotationYaw / 180.0F * (float)Math.PI) * 0.16F);
this.setPosition(this.posX, this.posY, this.posZ);
this.yOffset = 0.0F;
this.motionX = (double)(-MathHelper.sin(this.rotationYaw / 180.0F * (float)Math.PI) * MathHelper.cos(this.rotationPitch / 180.0F * (float)Math.PI));
this.motionZ = (double)(MathHelper.cos(this.rotationYaw / 180.0F * (float)Math.PI) * MathHelper.cos(this.rotationPitch / 180.0F * (float)Math.PI));
this.motionY = (double)(-MathHelper.sin(this.rotationPitch / 180.0F * (float)Math.PI));
this.setThrowableHeading(this.motionX, this.motionY, this.motionZ, par3 * 1.5F, 1.0F);
}

protected void entityInit()
{
this.dataWatcher.addObject(16, Byte.valueOf((byte)0));
}

/**
* Similar to setArrowHeading, it's point the throwable entity to a x, y, z direction.
*/
public void setThrowableHeading(double par1, double par3, double par5, float par7, float par8)
{
float f2 = MathHelper.sqrt_double(par1 * par1 + par3 * par3 + par5 * par5);
par1 /= (double)f2;
par3 /= (double)f2;
par5 /= (double)f2;
par1 += this.rand.nextGaussian() * (double)(this.rand.nextBoolean() ? -1 : 1) * 0.007499999832361937D * (double)par8;
par3 += this.rand.nextGaussian() * (double)(this.rand.nextBoolean() ? -1 : 1) * 0.007499999832361937D * (double)par8;
par5 += this.rand.nextGaussian() * (double)(this.rand.nextBoolean() ? -1 : 1) * 0.007499999832361937D * (double)par8;
par1 *= (double)par7;
par3 *= (double)par7;
par5 *= (double)par7;
this.motionX = par1;
this.motionY = par3;
this.motionZ = par5;
float f3 = MathHelper.sqrt_double(par1 * par1 + par5 * par5);
this.prevRotationYaw = this.rotationYaw = (float)(Math.atan2(par1, par5) * 180.0D / Math.PI);
this.prevRotationPitch = this.rotationPitch = (float)(Math.atan2(par3, (double)f3) * 180.0D / Math.PI);
this.ticksInGround = 0;
}

@SideOnly(Side.CLIENT)

/**
* Sets the position and rotation. Only difference from the other one is no bounding on the rotation. Args: posX,
* posY, posZ, yaw, pitch
*/
public void setPositionAndRotation2(double par1, double par3, double par5, float par7, float par8, int par9)
{
this.setPosition(par1, par3, par5);
this.setRotation(par7, par8);
}

@SideOnly(Side.CLIENT)

/**
* Sets the velocity to the args. Args: x, y, z
*/
public void setVelocity(double par1, double par3, double par5)
{
this.motionX = par1;
this.motionY = par3;
this.motionZ = par5;

if (this.prevRotationPitch == 0.0F && this.prevRotationYaw == 0.0F)
{
float f = MathHelper.sqrt_double(par1 * par1 + par5 * par5);
this.prevRotationYaw = this.rotationYaw = (float)(Math.atan2(par1, par5) * 180.0D / Math.PI);
this.prevRotationPitch = this.rotationPitch = (float)(Math.atan2(par3, (double)f) * 180.0D / Math.PI);
this.prevRotationPitch = this.rotationPitch;
this.prevRotationYaw = this.rotationYaw;
this.setLocationAndAngles(this.posX, this.posY, this.posZ, this.rotationYaw, this.rotationPitch);
this.ticksInGround = 0;
}
}

/**
* Called to update the entity's position/logic.
*/
public void onUpdate()
{
super.onUpdate();

if (this.prevRotationPitch == 0.0F && this.prevRotationYaw == 0.0F)
{
float f = MathHelper.sqrt_double(this.motionX * this.motionX + this.motionZ * this.motionZ);
this.prevRotationYaw = this.rotationYaw = (float)(Math.atan2(this.motionX, this.motionZ) * 180.0D / Math.PI);
this.prevRotationPitch = this.rotationPitch = (float)(Math.atan2(this.motionY, (double)f) * 180.0D / Math.PI);
}

int i = this.worldObj.getBlockId(this.xTile, this.yTile, this.zTile);

if (i > 0)
{
Block.blocksList[i].setBlockBoundsBasedOnState(this.worldObj, this.xTile, this.yTile, this.zTile);
AxisAlignedBB axisalignedbb = Block.blocksList[i].getCollisionBoundingBoxFromPool(this.worldObj, this.xTile, this.yTile, this.zTile);

if (axisalignedbb != null && axisalignedbb.isVecInside(this.worldObj.getWorldVec3Pool().getVecFromPool(this.posX, this.posY, this.posZ)))
{
this.inGround = true;
}
}

if (this.xTile != 0 & this.inGround == false && xyzLightBlocks.size() > 0) {
setXYZLightBlocks(true); // the block was destroyed
}

if (this.arrowShake > 0)
{
--this.arrowShake;
}

if (this.inGround)
{
int j = this.worldObj.getBlockId(this.xTile, this.yTile, this.zTile);
int k = this.worldObj.getBlockMetadata(this.xTile, this.yTile, this.zTile);

if (j == this.inTile && k == this.inData)
{
++this.ticksInGround;
if (!worldObj.isRemote) System.out.println(String.format("Seconds: %s   Ticks: %s", Calendar.getInstance().getTime(), this.ticksInGround));
if (this.ticksInGround >= 500 && !worldObj.isRemote)
{
setXYZLightBlocks(true);
this.setDead();
}
}
else
{
this.inGround = false;
this.motionX *= (double)(this.rand.nextFloat() * 0.2F);
this.motionY *= (double)(this.rand.nextFloat() * 0.2F);
this.motionZ *= (double)(this.rand.nextFloat() * 0.2F);
this.ticksInGround = 0;
this.ticksInAir = 0;
}
}
else
{
++this.ticksInAir;
Vec3 vec3 = this.worldObj.getWorldVec3Pool().getVecFromPool(this.posX, this.posY, this.posZ);
Vec3 vec31 = this.worldObj.getWorldVec3Pool().getVecFromPool(this.posX + this.motionX, this.posY + this.motionY, this.posZ + this.motionZ);
MovingObjectPosition movingobjectposition = this.worldObj.rayTraceBlocks_do_do(vec3, vec31, false, true);
vec3 = this.worldObj.getWorldVec3Pool().getVecFromPool(this.posX, this.posY, this.posZ);
vec31 = this.worldObj.getWorldVec3Pool().getVecFromPool(this.posX + this.motionX, this.posY + this.motionY, this.posZ + this.motionZ);

if (movingobjectposition != null)
{
vec31 = this.worldObj.getWorldVec3Pool().getVecFromPool(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;
int l;
float f1;

for (l = 0; l < list.size(); ++l)
{
Entity entity1 = (Entity)list.get(l);

if (entity1.canBeCollidedWith() && (entity1 != this.shootingEntity || this.ticksInAir >= 5))
{
f1 = 0.3F;
AxisAlignedBB axisalignedbb1 = entity1.boundingBox.expand((double)f1, (double)f1, (double)f1);
MovingObjectPosition movingobjectposition1 = axisalignedbb1.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 && movingobjectposition.entityHit != null && movingobjectposition.entityHit instanceof EntityPlayer)
{
EntityPlayer entityplayer = (EntityPlayer)movingobjectposition.entityHit;

if (entityplayer.capabilities.disableDamage || this.shootingEntity instanceof EntityPlayer && !((EntityPlayer)this.shootingEntity).func_96122_a(entityplayer))
{
movingobjectposition = null;
}
}

float f2;
float f3;

if (movingobjectposition != null)
{
if (movingobjectposition.entityHit != null)
{
f2 = MathHelper.sqrt_double(this.motionX * this.motionX + this.motionY * this.motionY + this.motionZ * this.motionZ);
int i1 = MathHelper.ceiling_double_int((double)f2 * this.damage);

if (this.getIsCritical())
{
i1 += this.rand.nextInt(i1 / 2 + 2);
}

DamageSource damagesource = null;

if (this.shootingEntity == null)
{
damagesource = Items.causeArrowDamage(this, this);
}
else
{
damagesource = Items.causeArrowDamage(this, this.shootingEntity);
}

if (this.isBurning() && !(movingobjectposition.entityHit instanceof EntityEnderman))
{
movingobjectposition.entityHit.setFire(5);
}

if (movingobjectposition.entityHit.attackEntityFrom(damagesource, (float)i1))
{
if (movingobjectposition.entityHit instanceof EntityLivingBase)
{
EntityLivingBase entitylivingbase = (EntityLivingBase)movingobjectposition.entityHit;

if (!this.worldObj.isRemote)
{
entitylivingbase.setArrowCountInEntity(entitylivingbase.getArrowCountInEntity() + 1);
}

if (this.knockbackStrength > 0)
{
f3 = MathHelper.sqrt_double(this.motionX * this.motionX + this.motionZ * this.motionZ);

if (f3 > 0.0F)
{
movingobjectposition.entityHit.addVelocity(this.motionX * (double)this.knockbackStrength * 0.6000000238418579D / (double)f3, 0.1D, this.motionZ * (double)this.knockbackStrength * 0.6000000238418579D / (double)f3);
}
}

if (this.shootingEntity != null)
{
EnchantmentThorns.func_92096_a(this.shootingEntity, entitylivingbase, this.rand);
}

if (this.shootingEntity != null && movingobjectposition.entityHit != this.shootingEntity && movingobjectposition.entityHit instanceof EntityPlayer && this.shootingEntity instanceof EntityPlayerMP)
{
((EntityPlayerMP)this.shootingEntity).playerNetServerHandler.sendPacketToPlayer(new Packet70GameEvent(6, 0));
}
}

this.playSound("random.bowhit", 1.0F, 1.2F / (this.rand.nextFloat() * 0.2F + 0.9F));

if (!(movingobjectposition.entityHit instanceof EntityEnderman))
{
this.setDead();
}
}
else
{
this.motionX *= -0.10000000149011612D;
this.motionY *= -0.10000000149011612D;
this.motionZ *= -0.10000000149011612D;
this.rotationYaw += 180.0F;
this.prevRotationYaw += 180.0F;
this.ticksInAir = 0;
}
}
else
{
this.xTile = movingobjectposition.blockX;
this.yTile = movingobjectposition.blockY;
this.zTile = movingobjectposition.blockZ;
this.inTile = this.worldObj.getBlockId(this.xTile, this.yTile, this.zTile);
this.inData = this.worldObj.getBlockMetadata(this.xTile, this.yTile, this.zTile);
this.motionX = (double)((float)(movingobjectposition.hitVec.xCoord - this.posX));
this.motionY = (double)((float)(movingobjectposition.hitVec.yCoord - this.posY));
this.motionZ = (double)((float)(movingobjectposition.hitVec.zCoord - this.posZ));
f2 = MathHelper.sqrt_double(this.motionX * this.motionX + this.motionY * this.motionY + this.motionZ * this.motionZ);
this.posX -= this.motionX / (double)f2 * 0.05000000074505806D;
this.posY -= this.motionY / (double)f2 * 0.05000000074505806D;
this.posZ -= this.motionZ / (double)f2 * 0.05000000074505806D;
this.playSound("random.bowhit", 1.0F, 1.2F / (this.rand.nextFloat() * 0.2F + 0.9F));
this.inGround = true;
this.arrowShake = 7;
this.setIsCritical(false);

xyzLightBlocks = Methods.getAirSides(worldObj, this.posX, this.posY, this.posZ);
setXYZLightBlocks(false);

if (this.inTile != 0)
{
Block.blocksList[this.inTile].onEntityCollidedWithBlock(this.worldObj, this.xTile, this.yTile, this.zTile, this);
}
}
}

if (this.getIsCritical())
{
for (l = 0; l < 4; ++l)
{
this.worldObj.spawnParticle("crit", this.posX + this.motionX * (double)l / 4.0D, this.posY + this.motionY * (double)l / 4.0D, this.posZ + this.motionZ * (double)l / 4.0D, -this.motionX, -this.motionY + 0.2D, -this.motionZ);
}
}

this.posX += this.motionX;
this.posY += this.motionY;
this.posZ += this.motionZ;
f2 = MathHelper.sqrt_double(this.motionX * this.motionX + this.motionZ * this.motionZ);
this.rotationYaw = (float)(Math.atan2(this.motionX, this.motionZ) * 180.0D / Math.PI);

for (this.rotationPitch = (float)(Math.atan2(this.motionY, (double)f2) * 180.0D / Math.PI); 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 f4 = 0.99F;
f1 = 0.05F;

if (this.isInWater())
{
for (int j1 = 0; j1 < 4; ++j1)
{
f3 = 0.25F;
this.worldObj.spawnParticle("bubble", this.posX - this.motionX * (double)f3, this.posY - this.motionY * (double)f3, this.posZ - this.motionZ * (double)f3, this.motionX, this.motionY, this.motionZ);
}

f4 = 0.8F;
}

this.motionX *= (double)f4;
this.motionY *= (double)f4;
this.motionZ *= (double)f4;
this.motionY -= (double)f1;
this.setPosition(this.posX, this.posY, this.posZ);
this.doBlockCollisions();
}
}

/**
* (abstract) Protected helper method to write subclass entity data to NBT.
*/
public void writeEntityToNBT(NBTTagCompound par1NBTTagCompound)
{
XYZpoint temp;
par1NBTTagCompound.setShort("xTile", (short)this.xTile);
par1NBTTagCompound.setShort("yTile", (short)this.yTile);
par1NBTTagCompound.setShort("zTile", (short) this.zTile);
par1NBTTagCompound.setByte("inTile", (byte)this.inTile);
par1NBTTagCompound.setByte("inData", (byte)this.inData);
par1NBTTagCompound.setByte("shake", (byte)this.arrowShake);
par1NBTTagCompound.setByte("inGround", (byte)(this.inGround ? 1 : 0));
par1NBTTagCompound.setByte("pickup", (byte) this.canBePickedUp);
par1NBTTagCompound.setDouble("damage", this.damage);
par1NBTTagCompound.setInteger("ticksInGround", this.ticksInGround);

for (int t=0; t < 6; t++) {
temp = new XYZpoint(0,0,0);
if (t < xyzLightBlocks.size())
temp = xyzLightBlocks.get(t);

par1NBTTagCompound.setInteger("x" + String.valueOf(t), temp.posX);
par1NBTTagCompound.setInteger("y" + String.valueOf(t), temp.posY);
par1NBTTagCompound.setInteger("z" + String.valueOf(t), temp.posZ);
}
}

/**
* (abstract) Protected helper method to read subclass entity data from NBT.
*/
public void readEntityFromNBT(NBTTagCompound par1NBTTagCompound)
{
XYZpoint temp;
this.xTile = par1NBTTagCompound.getShort("xTile");
this.yTile = par1NBTTagCompound.getShort("yTile");
this.zTile = par1NBTTagCompound.getShort("zTile");
this.inTile = par1NBTTagCompound.getByte("inTile") & 255;
this.inData = par1NBTTagCompound.getByte("inData") & 255;
this.arrowShake = par1NBTTagCompound.getByte("shake") & 255;
this.inGround = par1NBTTagCompound.getByte("inGround") == 1;
this.ticksInGround = par1NBTTagCompound.getInteger("ticksInGround");
this.damage = par1NBTTagCompound.getDouble("damage");
this.canBePickedUp = par1NBTTagCompound.getByte("pickup");

xyzLightBlocks = new ArrayList<XYZpoint>();
for (int t=0; t < 6; t++) {
temp = new XYZpoint();
temp.posX = par1NBTTagCompound.getInteger("x" + String.valueOf(t));
temp.posY = par1NBTTagCompound.getInteger("y" + String.valueOf(t));
temp.posZ = par1NBTTagCompound.getInteger("z" + String.valueOf(t));
xyzLightBlocks.add(temp);
}
}

private void setXYZLightBlocks(boolean clear) {
if (worldObj.isRemote) return;
XYZpoint temp;

int compareID;
int setID;

if (clear) {
compareID = Blocks.blockLight.blockID;
setID = 0;
} else {
compareID = 0;
setID = Blocks.blockLight.blockID;
}

for (int t = 0; t<6; t++) {
if (t < xyzLightBlocks.size()) {
temp = xyzLightBlocks.get(t);
if (worldObj.getBlockId(temp.posX, temp.posY,temp.posZ) == compareID) {
worldObj.setBlock(temp.posX, temp.posY,temp.posZ, setID);
}
}
}

if (clear) {
xyzLightBlocks = new ArrayList<XYZpoint>();
}
}

/**
* Called by a player entity when they collide with an entity
*/
public void onCollideWithPlayer(EntityPlayer par1EntityPlayer)
{
if (!this.worldObj.isRemote && this.inGround && this.arrowShake <= 0)
{
boolean flag = this.canBePickedUp == 1 || this.canBePickedUp == 2 && par1EntityPlayer.capabilities.isCreativeMode;

if (this.canBePickedUp == 1 && !par1EntityPlayer.inventory.addItemStackToInventory(new ItemStack(Items.glowingArrow, 1)))
{
flag = false;
}

if (flag)
{
this.playSound("random.pop", 0.2F, ((this.rand.nextFloat() - this.rand.nextFloat()) * 0.7F + 1.0F) * 2.0F);
par1EntityPlayer.onItemPickup(this, 1);
setXYZLightBlocks(true);
this.setDead();
}
}
}

/**
* returns if this entity triggers Block.onEntityWalking on the blocks they walk on. used for spiders and wolves to
* prevent them from trampling crops
*/
protected boolean canTriggerWalking()
{
return false;
}

@SideOnly(Side.CLIENT)
public float getShadowSize()
{
return 0.0F;
}

public void setDamage(double par1)
{
this.damage = par1;
}

public double getDamage()
{
return this.damage;
}

/**
* Sets the amount of knockback the arrow applies when it hits a mob.
*/
public void setKnockbackStrength(int par1)
{
this.knockbackStrength = par1;
}

/**
* If returns false, the item will not inflict any damage against entities.
*/
public boolean canAttackWithItem()
{
return false;
}

/**
* Whether the arrow has a stream of critical hit particles flying behind it.
*/
public void setIsCritical(boolean par1)
{
byte b0 = this.dataWatcher.getWatchableObjectByte(16);

if (par1)
{
this.dataWatcher.updateObject(16, Byte.valueOf((byte)(b0 | 1)));
}
else
{
this.dataWatcher.updateObject(16, Byte.valueOf((byte)(b0 & -2)));
}
}

/**
* Whether the arrow has a stream of critical hit particles flying behind it.
*/
public boolean getIsCritical()
{
byte b0 = this.dataWatcher.getWatchableObjectByte(16);
return (b0 & 1) != 0;
}


}

package lostworld.items;

import lostworld.lib.References;
import net.minecraft.client.renderer.texture.IconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.Icon;
import net.minecraft.world.World;

/**
 * Created with IntelliJ IDEA.
 * User: Slash
 * Date: 1/3/14
 * Time: 3:39 PM
 */
public class itemGlowingArrow extends Item {
public itemGlowingArrow(int par1) {
super(par1);
setUnlocalizedName("glowingArrow");
setCreativeTab(CreativeTabs.tabCombat);
}

/**
* Called whenever this item is equipped and the right mouse button is pressed. Args: itemStack, world, entityPlayer
*
* @param par1ItemStack
* @param par2World
* @param par3EntityPlayer
*/
@Override
public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer) {
return super.onItemRightClick(par1ItemStack, par2World, par3EntityPlayer);
}

@Override
public void registerIcons(IconRegister par1IconRegister) {
this.itemIcon = par1IconRegister.registerIcon(References.MODID + ":" + getUnlocalizedName().substring(getUnlocalizedName().indexOf(".") + 1));
}

@Override
public Icon getIconFromDamage(int par1) {
return this.itemIcon;
}


/**
* Return the correct icon for rendering based on the supplied ItemStack and render pass.
* <p/>
* Defers to {@link #getIconFromDamageForRenderPass(int, int)}
*
* @param stack to render for
* @param pass  the multi-render pass
* @return the icon
*/
@Override
public Icon getIcon(ItemStack stack, int pass) {
return this.itemIcon;
}
}

package lostworld.items;

import lostworld.entities.EntityGlowingArrow;
import lostworld.lib.References;
import net.minecraft.client.renderer.texture.IconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.enchantment.Enchantment;
import net.minecraft.enchantment.EnchantmentHelper;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.EnumAction;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.Icon;
import net.minecraft.world.World;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.event.entity.player.ArrowLooseEvent;
import net.minecraftforge.event.entity.player.ArrowNockEvent;

/**
 * Created with IntelliJ IDEA.
 * User: Slash
 * Date: 1/3/14
 * Time: 4:29 PM
 */
public class itemGlowingBow extends Item {
private Icon[] icons = new Icon[4];

public itemGlowingBow(int par1)
{
super(par1);
this.maxStackSize = 1;
this.setMaxDamage(3200);//How many times you can shoot arrows
this.setCreativeTab(CreativeTabs.tabCombat);
setUnlocalizedName("glowingBow");
}

//The pulling back texture of the bow, you can change this to whatever you want, for example 8 textures or something
@Override
public Icon getIcon(ItemStack stack, int renderPass, EntityPlayer player, ItemStack usingItem, int useRemaining)
{
if (usingItem != null && usingItem.getItem().itemID == Items.glowingBow.itemID)
{
int k = usingItem.getMaxItemUseDuration() - useRemaining;
if (k >= 18) return icons[3];
if (k >  13) return icons[2];
if (k >   0) return icons[1];
}
return icons[0];
}

@Override
public Icon getIconFromDamage(int par1) {
return this.itemIcon;
}

@Override
public void registerIcons(IconRegister par1IconRegister) {
this.icons[0] = par1IconRegister.registerIcon(References.MODID + ":" + getUnlocalizedName().substring(getUnlocalizedName().indexOf(".") + 1) + "_standby");
for (int t=0; t<3; t++) {
this.icons[t+1] = par1IconRegister.registerIcon(References.MODID + ":" + getUnlocalizedName().substring(getUnlocalizedName().indexOf(".") + 1) + "_pulling_" + String.valueOf(t));
}
this.itemIcon = icons[0];
}

public void onPlayerStoppedUsing(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer, int par4)
{
int var6 = this.getMaxItemUseDuration(par1ItemStack) - par4;

ArrowLooseEvent event = new ArrowLooseEvent(par3EntityPlayer, par1ItemStack, var6);
MinecraftForge.EVENT_BUS.post(event);
if (event.isCanceled())
{
return;
}
var6 = event.charge;

boolean var5 = par3EntityPlayer.capabilities.isCreativeMode || EnchantmentHelper.getEnchantmentLevel(Enchantment.infinity.effectId, par1ItemStack) > 0;

if (var5 || par3EntityPlayer.inventory.hasItem(Items.glowingArrow.itemID))
{
float var7 = (float)var6 / 20.0F;
var7 = (var7 * var7 + var7 * 2.0F) / 3.0F;

if ((double)var7 < 0.1D)
{
return;
}

if (var7 > 1.0F)
{
var7 = 1.0F;
}

//Want multiple arrows? add another line like this:
//EntityArrow var81 = new EntityArrow(par2World, par3EntityPlayer, var7 * 2.0F);
EntityGlowingArrow entityArrow = new EntityGlowingArrow(par2World, par3EntityPlayer, var7 * 2.0F);
//EntityArrow entityArrow = new EntityArrow(par2World, par3EntityPlayer, var7 * 2.0F);

if (var7 == 1.0F)
{
//entityArrow.setIsCritical(true);
}

//Enchantements:
int var9 = EnchantmentHelper.getEnchantmentLevel(Enchantment.power.effectId, par1ItemStack);

if (var9 > 0)
{
entityArrow.setDamage(entityArrow.getDamage() + (double)var9 * 0.5D + 0.5D);
}

int var10 = EnchantmentHelper.getEnchantmentLevel(Enchantment.punch.effectId, par1ItemStack);

if (var10 > 0)
{
entityArrow.setKnockbackStrength(var10);
}

if (EnchantmentHelper.getEnchantmentLevel(Enchantment.flame.effectId, par1ItemStack) > 0)
{
entityArrow.setFire(100);
}

//Damages the item with 1
par1ItemStack.damageItem(1, par3EntityPlayer);
par2World.playSoundAtEntity(par3EntityPlayer, "random.bow", 1.0F, 1.0F / (itemRand.nextFloat() * 0.4F + 1.2F) + var7 * 0.5F);

if (var5)
{
entityArrow.canBePickedUp = 2;
}
else
{
par3EntityPlayer.inventory.consumeInventoryItem(Items.glowingArrow.itemID);
}

if (!par2World.isRemote)
{
//For multiple arrows:
//par2World.spawnEntityInWorld(var81);
par2World.spawnEntityInWorld(entityArrow);
}
}
}

@Override
public int getMaxItemUseDuration(ItemStack par1ItemStack)
{
return 72000;
}

public EnumAction getItemUseAction(ItemStack par1ItemStack)
{
return EnumAction.bow;
}

public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
{
ArrowNockEvent event = new ArrowNockEvent(par3EntityPlayer, par1ItemStack);
MinecraftForge.EVENT_BUS.post(event);
if (event.isCanceled())
{
return event.result;
}

if (par3EntityPlayer.capabilities.isCreativeMode || par3EntityPlayer.inventory.hasItem(Items.glowingArrow.itemID))
{
par3EntityPlayer.setItemInUse(par1ItemStack, this.getMaxItemUseDuration(par1ItemStack));
}

return par1ItemStack;
}

public int getItemEnchantability()
{
return 0;
}

}

registerEntity(References.entityGlowingArrow,EntityGlowingArrow.class,"GlowingArrow", 64*10, 1, true);


public void registerEntity(int id, Class<? extends Entity> entityClass, String entityName, int trackingRange, int updateFrequency, boolean sendVelocityPackets) {

EntityRegistry.registerModEntity(entityClass,entityName,id,this,trackingRange,updateFrequency,sendVelocityPackets);
EntityList.IDtoClassMapping.put(id, entityClass);

}

package lostworld.lib;

/**
 * Created with IntelliJ IDEA.
 * User: Slash
 * Date: 10/21/13
 * Time: 8:53 AM
 */
public class XYZpoint {
public int posX = 0;
public int posY = 0;
public int posZ = 0;
public double fX = 0;
public double fY = 0;
public double fZ = 0;

public XYZpoint() {
posX = posY = posZ = 0;
fX = fY = fZ = 0.0f;
}
public XYZpoint(double x, double y, double z) {
posX = (int)x;
posY = (int)y;
posZ = (int)z;
fX = x;
fY = y;
fZ = z;
}
}

package lostworld.renders;

import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import lostworld.entities.EntityGlowingArrow;
import lostworld.lib.Resources;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.client.renderer.entity.Render;
import net.minecraft.entity.Entity;
import net.minecraft.util.MathHelper;
import net.minecraft.util.ResourceLocation;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL12;

@SideOnly(Side.CLIENT)
public class RenderGlowingArrow extends Render
{
public void renderArrow(EntityGlowingArrow par1EntityArrow, double par2, double par4, double par6, float par8, float par9)
    {
        this.func_110777_b(par1EntityArrow);
GL11.glPushMatrix();
        GL11.glTranslatef((float)par2, (float)par4, (float)par6);
        GL11.glRotatef(par1EntityArrow.prevRotationYaw + (par1EntityArrow.rotationYaw - par1EntityArrow.prevRotationYaw) * par9 - 90.0F, 0.0F, 1.0F, 0.0F);
        GL11.glRotatef(par1EntityArrow.prevRotationPitch + (par1EntityArrow.rotationPitch - par1EntityArrow.prevRotationPitch) * par9, 0.0F, 0.0F, 1.0F);
        Tessellator tessellator = Tessellator.instance;
        byte b0 = 0;
        float f2 = 0.0F;
        float f3 = 0.5F;
        float f4 = (float)(0 + b0 * 10) / 32.0F;
        float f5 = (float)(5 + b0 * 10) / 32.0F;
        float f6 = 0.0F;
        float f7 = 0.15625F;
        float f8 = (float)(5 + b0 * 10) / 32.0F;
        float f9 = (float)(10 + b0 * 10) / 32.0F;
        float f10 = 0.05625F;
        GL11.glEnable(GL12.GL_RESCALE_NORMAL);
        float f11 = (float)par1EntityArrow.arrowShake - par9;

        if (f11 > 0.0F)
        {
            float f12 = -MathHelper.sin(f11 * 3.0F) * f11;
            GL11.glRotatef(f12, 0.0F, 0.0F, 1.0F);
        }

        GL11.glRotatef(45.0F, 1.0F, 0.0F, 0.0F);
        GL11.glScalef(f10, f10, f10);
        GL11.glTranslatef(-4.0F, 0.0F, 0.0F);
        GL11.glNormal3f(f10, 0.0F, 0.0F);
        tessellator.startDrawingQuads();
        tessellator.addVertexWithUV(-7.0D, -2.0D, -2.0D, (double)f6, (double)f8);
        tessellator.addVertexWithUV(-7.0D, -2.0D, 2.0D, (double)f7, (double)f8);
        tessellator.addVertexWithUV(-7.0D, 2.0D, 2.0D, (double)f7, (double)f9);
        tessellator.addVertexWithUV(-7.0D, 2.0D, -2.0D, (double)f6, (double)f9);
        tessellator.draw();
        GL11.glNormal3f(-f10, 0.0F, 0.0F);
        tessellator.startDrawingQuads();
        tessellator.addVertexWithUV(-7.0D, 2.0D, -2.0D, (double)f6, (double)f8);
        tessellator.addVertexWithUV(-7.0D, 2.0D, 2.0D, (double)f7, (double)f8);
        tessellator.addVertexWithUV(-7.0D, -2.0D, 2.0D, (double)f7, (double)f9);
        tessellator.addVertexWithUV(-7.0D, -2.0D, -2.0D, (double)f6, (double)f9);
        tessellator.draw();

        for (int i = 0; i < 4; ++i)
        {
            GL11.glRotatef(90.0F, 1.0F, 0.0F, 0.0F);
            GL11.glNormal3f(0.0F, 0.0F, f10);
            tessellator.startDrawingQuads();
            tessellator.addVertexWithUV(-8.0D, -2.0D, 0.0D, (double)f2, (double)f4);
            tessellator.addVertexWithUV(8.0D, -2.0D, 0.0D, (double)f3, (double)f4);
            tessellator.addVertexWithUV(8.0D, 2.0D, 0.0D, (double)f3, (double)f5);
            tessellator.addVertexWithUV(-8.0D, 2.0D, 0.0D, (double)f2, (double)f5);
            tessellator.draw();
        }

        GL11.glDisable(GL12.GL_RESCALE_NORMAL);
        GL11.glPopMatrix();
    }

@Override
    protected ResourceLocation func_110775_a(Entity par1Entity)
    {
        return Resources.ENTITY_ARROW;
    }

    /**
     * Actually renders the given argument. This is a synthetic bridge method, always casting down its argument and then
     * handing it off to a worker function which does the actual work. In all probabilty, the class Render is generic
     * (Render<T extends Entity) and this method has signature public void doRender(T entity, double d, double d1,
     * double d2, float f, float f1). But JAD is pre 1.5 so doesn't do that.
     */
    @Override
public void doRender(Entity par1Entity, double par2, double par4, double par6, float par8, float par9)
    {
        this.renderArrow((EntityGlowingArrow)par1Entity, par2, par4, par6, par8, par9);
    }
}

protected void bindPlayerInventory(IInventory inventoryPlayer) {
// adds second group of slots (player's inventory)
for (int y = 0; y < 3; y++) {
for (int x = 0; x < 9; x++) {
addSlotToContainer(new Slot(inventoryPlayer, x + y * 9 + 9, firstPlayerInvSlotX + x * slotSquareSize, firstPlayerInvSlotY + y * slotSquareSize));
}
}

// adds first group of slots (Player Hands)
for (int i = 0; i < 9; i++) {
addSlotToContainer(new Slot(inventoryPlayer, i, firstPlayerSlotX + i * slotSquareSize, firstPlayerSlotY));
}
}