Custom Arrows bouncing of targets

[BreezedFreak]

Hello Guys,

So I just created a custom Bow and Arrow and When I shoot with the Bow the Arrow sometimes just bounces of the Target or sometimes doesn't event hit the Target because its bouncing off before

For better explantation here a little video :

 

www.youtube.com/embed/RARorY3rzqM?rel=0

Sorry I dunno how to insert a video if its possible

 

 

Here the Code from my Bow:

package items;

import Entities.EntityBetterArrow1;
import net.minecraft.enchantment.Enchantment;
import net.minecraft.enchantment.EnchantmentHelper;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.item.ItemBow;
import net.minecraft.item.ItemStack;
import net.minecraft.world.World;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.event.entity.player.ArrowLooseEvent;


public class UpgradeBow extends ItemBow{
    private int MaxUseDuration = 1000;
    public static int oldLevel;
    public static int Level = 0;


    public UpgradeBow(int par1) {
        super(par1);
    }

    public static void addOne(){
        oldLevel = Level;
        Level++;
    }


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

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

        j = event.charge;


        boolean flag = par3EntityPlayer.capabilities.isCreativeMode || EnchantmentHelper.getEnchantmentLevel(Enchantment.infinity.effectId, par1ItemStack) > 0 && par3EntityPlayer.inventory.hasItem(Item.arrow.itemID);

        if (flag || par3EntityPlayer.inventory.hasItem(Item.arrow.itemID)) {
            float f = (float) j / 20.0F;
            f = (f * f + f * 2.0F) / 3.0F;

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

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

            EntityBetterArrow1 entityarrow = new EntityBetterArrow1(par2World, par3EntityPlayer, f * 2.0F);

            if (f == 1.0F) {
                entityarrow.setIsCritical(true);
            }
            /*

            int k = EnchantmentHelper.getEnchantmentLevel(Enchantment.power.effectId, par1ItemStack);

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

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

            if (l > 0) {
                entityarrow.setKnockbackStrength(l);
            }


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

            par1ItemStack.damageItem(1, par3EntityPlayer);
            */

            entityarrow.setExplosionRadius(4.0F);
            entityarrow.setDamage((entityarrow.getDamage() / 3) + (Level * 0.3));
            par2World.playSoundAtEntity(par3EntityPlayer, "random.bow", 1.0F, 1.0F / (itemRand.nextFloat() * 0.4F + 1.2F) + f * 0.5F);
            par3EntityPlayer.addChatMessage("DAMAGE :" + entityarrow.getDamage());
            par1ItemStack.setItemDamage(par1ItemStack.getMaxDamage() - Level);


            if (flag) {
                entityarrow.canBePickedUp = 2;
            } else {
                par3EntityPlayer.inventory.consumeInventoryItem(Item.arrow.itemID);
            }


                par2World.spawnEntityInWorld(entityarrow);

        }
    }

}

 

 

And here the Code from the Arrow:

 

Arrow Class:

package Entities;

 

import cpw.mods.fml.relauncher.Side;

import cpw.mods.fml.relauncher.SideOnly;

 

import java.util.List;

 

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.entity.projectile.EntityThrowable;

import net.minecraft.item.Item;

import net.minecraft.item.ItemStack;

import net.minecraft.nbt.NBTTagCompound;

import net.minecraft.network.packet.Packet70GameEvent;

import net.minecraft.util.AxisAlignedBB;

import net.minecraft.util.DamageSource;

import net.minecraft.util.MathHelper;

import net.minecraft.util.MovingObjectPosition;

import net.minecraft.util.Vec3;

import net.minecraft.world.World;

 

public class EntityBetterArrow1 extends EntityThrowable implements IProjectile {

    private int xTile = -1;

    private int yTile = -1;

    private int zTile = -1;

    private int inTile;

    private int inData;

    private boolean inGround;

 

    /**

    * 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;

    private float ExplosionRadius = 2.0F;

 

    public EntityBetterArrow1(World par1World) {

        super(par1World);

        this.renderDistanceWeight = 10.0D;

        this.setSize(0.5F, 0.5F);

    }

 

    public EntityBetterArrow1(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 EntityBetterArrow1(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 EntityBetterArrow1(World par1World, EntityLivingBase par2EntityLivingBase, float par3) {

        super(par1World);

        this.renderDistanceWeight = 10.0D;

        this.shootingEntity = par2EntityLivingBase;

 

        if (par2EntityLivingBase instanceof EntityPlayer) {

            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.setBlockBoundsBasedOnState(this.worldObj, this.xTile, this.yTile, this.zTile);

            AxisAlignedBB axisalignedbb = Block.blocksList.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.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 (this.ticksInGround == 1200) {

                    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).canAttackPlayer(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 = main.main.causeBetterArrow1Damage(this, this);

                    } else {

                        damagesource = main.main.causeBetterArrow1Damage(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);

 

                    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) {

        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);

    }

 

    /**

    * (abstract) Protected helper method to read subclass entity data from NBT.

    */

    public void readEntityFromNBT(NBTTagCompound par1NBTTagCompound) {

        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;

 

        if (par1NBTTagCompound.hasKey("damage")) {

            this.damage = par1NBTTagCompound.getDouble("damage");

        }

 

        if (par1NBTTagCompound.hasKey("pickup")) {

            this.canBePickedUp = par1NBTTagCompound.getByte("pickup");

        } else if (par1NBTTagCompound.hasKey("player")) {

            this.canBePickedUp = par1NBTTagCompound.getBoolean("player") ? 1 : 0;

        }

    }

 

    /**

    * 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(Item.arrow, 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);

                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;

    }

    @Override

    public void onImpact(MovingObjectPosition par1MovingObjectPosition){

 

        if (this.inGround) {

 

 

        } else if (par1MovingObjectPosition.entityHit instanceof EntityPlayer) {

        } else {

            /*

            this.worldObj.createExplosion(this, this.posX, this.posY, this.posZ, this.ExplosionRadius, true);

            this.setDead();

            */

        }

    }

    public void setExplosionRadius(float par1){

        this.ExplosionRadius = par1;

    }

}

 

RenderClass:

package Renders;

 

import Entities.EntityBetterArrow1;

import cpw.mods.fml.relauncher.Side;

import cpw.mods.fml.relauncher.SideOnly;

import net.minecraft.client.Minecraft;

import net.minecraft.client.renderer.Tessellator;

import net.minecraft.client.renderer.entity.Render;

import net.minecraft.entity.Entity;

import net.minecraft.entity.projectile.EntityArrow;

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 RenderBetterArrow1 extends Render {

    private static final ResourceLocation arrowTextures = new ResourceLocation("textures/entity/arrow.png");

 

    public void renderArrow(EntityBetterArrow1 par1EntityArrow, double par2, double par4, double par6, float par8, float par9) {

        this.bindEntityTexture(new EntityArrow(Minecraft.getMinecraft().theWorld));

        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();

    }

 

    protected ResourceLocation getArrowTextures(net.minecraft.entity.projectile.EntityArrow par1EntityArrow) {

        return arrowTextures;

    }

 

    /**

    * Returns the location of an entity's texture. Doesn't seem to be called unless you call Renders.bindEntityTexture.

    */

    protected ResourceLocation getEntityTexture(Entity par1Entity) {

        return this.getArrowTextures((net.minecraft.entity.projectile.EntityArrow) par1Entity);

    }

 

    /**

    * 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 Renders is generic

    * (Renders<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.

    */

    public void doRender(Entity par1Entity, double par2, double par4, double par6, float par8, float par9) {

        this.renderArrow((EntityBetterArrow1) par1Entity, par2, par4, par6, par8, par9);

    }

}

 

 

 

[coolAlias]

Probably the biggest part of your problem is you've copied all of the arrow code into an EntityThrowable; you now have class variables such as "inGround", to name only one, that are duplicates of those in EntityThrowable. While this isn't a problem in itself, you are calling super.onUpdate(), meaning that the EntityThrowable is calculating trajectory, whether it's in the ground, collided with entities, etc, and then you do so again using your own variables. Not only is this wasteful to run the same calculations twice, I'm sure you can see how it could cause all sorts of problems, as your arrow is essentially updating twice each tick.

 

Yet for some reason you don't call super on the read and write from NBT methods, when you most certainly should. Anyway, to say the least, I think a major recode is in order.

[BreezedFreak]

So I guess it wouldn't help if I just delete super.onUpdate() right ?well I guess ill need to redo something there

[BreezedFreak]

I just noticed something It seems like its not the problem of the Arrow because even If I let my bow shoot normal Arrows the Bug is happening and also I noticed that the Bow Class gets called twice because I just added a simple chat message and the message is getting called twice...