Jump to content
Search the Forums BEFORE making a new post.
Currently supported: All versions

[1.8] Custom arrow not render when it must but !Wtf bug ? <WorkArrounded>

perromercenary00

By perromercenary00
in Modder Support

 Share

Recommended Posts

perromercenary00 Dragon Slayer

perromercenary00

Posted
Posted

good nigths

i have create a custome bow and a pair of custome arrows

now the thing is that when the bow shoots mi custom arrows has no texture,

but doing some test i discover thah when i shoot the arrow in the onItemRightClick() the arrow have his texture.

 

normaly in the bow code you shoot the arrow in the onPlayerStoppedUsing() method if i do this the arrow has no texture

 

but if  iput the code to shoot the arrow in onItemRightClick() method  it shoots and the textures work

 

and there is no trouble with vainilla arrow 

 

this is the code from the bow it shoot 3 tipes of arrow based in the state of the nbttag "tipomunicion"

int tipomunicion = getInttag(arco, "tipomunicion");

 

0 is no arrow

1 is vainilla arrow

2 is mercenaryArrow

3 is mercenary Explosive arrow

 

lineas  108

208

 

package mercenarymod.items.arcos;


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

import mercenarymod.Mercenary;
import mercenarymod.items.MercenaryModItems;
import mercenarymod.items.render.renderFlechaMercenaria;
import mercenarymod.utilidades.chat;
import mercenarymod.utilidades.nbtMercenaria;
import net.minecraft.client.resources.model.ModelResourceLocation;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.enchantment.Enchantment;
import net.minecraft.enchantment.EnchantmentHelper;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.projectile.EntityArrow;
import net.minecraft.init.Items;
import net.minecraft.item.EnumAction;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.stats.StatList;
import net.minecraft.util.BlockPos;
import net.minecraft.world.World;
import net.minecraftforge.fml.common.registry.GameRegistry;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;

public class arcoMercenarioDeMadera extends Item
{


//#########################################################################3    
    public arcoMercenarioDeMadera()
    {
    	String name = "arcoMercenarioDeMadera";
    	setUnlocalizedName(Mercenary.MODID + "_" + name);
    	GameRegistry.registerItem(this, name);
    	setCreativeTab(Mercenary.herramientas);
        this.maxStackSize = 1;
        this.setMaxDamage(384);
        
    }
//####################################################################################3	    
@Override
public ModelResourceLocation getModel(ItemStack arco, EntityPlayer playerIn, int useRemaining){

ModelResourceLocation modelresourcelocation = new ModelResourceLocation("modmercenario:arcos/arcodemadera/arcoMercenarioDeMadera", "inventory") ;

int tick;
tick=(1000-useRemaining);
if (tick>999){tick=0;}

int tipomunicion = getInttag(arco, "tipomunicion");


switch(tipomunicion){	

default:{
if (tick > 0 & tick < 8   ){modelresourcelocation = new ModelResourceLocation("modmercenario:arcos/arcodemadera/arcoMercenarioDeMadera_A00", "inventory");}
if (tick > 7 & tick < 16  ){modelresourcelocation = new ModelResourceLocation("modmercenario:arcos/arcodemadera/arcoMercenarioDeMadera_A01", "inventory") ;}
if (tick > 15 & tick < 30 ){modelresourcelocation = new ModelResourceLocation("modmercenario:arcos/arcodemadera/arcoMercenarioDeMadera_A02", "inventory") ;}
if (tick > 29             ){modelresourcelocation = new ModelResourceLocation("modmercenario:arcos/arcodemadera/arcoMercenarioDeMadera_A03", "inventory") ;}
}break;

case 1:{
if (tick > 0 & tick < 8   ){modelresourcelocation = new ModelResourceLocation("modmercenario:arcos/arcodemadera/arcoMercenarioDeMadera_A00", "inventory");}
if (tick > 7 & tick < 16  ){modelresourcelocation = new ModelResourceLocation("modmercenario:arcos/arcodemadera/arcoMercenarioDeMadera_A01_vainilla", "inventory") ;}
if (tick > 15 & tick < 30 ){modelresourcelocation = new ModelResourceLocation("modmercenario:arcos/arcodemadera/arcoMercenarioDeMadera_A02_vainilla", "inventory") ;}
if (tick > 29             ){modelresourcelocation = new ModelResourceLocation("modmercenario:arcos/arcodemadera/arcoMercenarioDeMadera_A03_vainilla", "inventory") ;}
}break;

case 2:{
if (tick > 0 & tick < 8   ){modelresourcelocation = new ModelResourceLocation("modmercenario:arcos/arcodemadera/arcoMercenarioDeMadera_A00", "inventory");}
if (tick > 7 & tick < 16  ){modelresourcelocation = new ModelResourceLocation("modmercenario:arcos/arcodemadera/arcoMercenarioDeMadera_A01_mercenaria", "inventory") ;}
if (tick > 15 & tick < 30 ){modelresourcelocation = new ModelResourceLocation("modmercenario:arcos/arcodemadera/arcoMercenarioDeMadera_A02_mercenaria", "inventory") ;}
if (tick > 29             ){modelresourcelocation = new ModelResourceLocation("modmercenario:arcos/arcodemadera/arcoMercenarioDeMadera_A03_mercenaria", "inventory") ;}
}break;

case 3:{
if (tick > 0 & tick < 8   ){modelresourcelocation = new ModelResourceLocation("modmercenario:arcos/arcodemadera/arcoMercenarioDeMadera_A00", "inventory");}
if (tick > 7 & tick < 16  ){modelresourcelocation = new ModelResourceLocation("modmercenario:arcos/arcodemadera/arcoMercenarioDeMadera_A01_mercenariaExplosiva", "inventory") ;}
if (tick > 15 & tick < 30 ){modelresourcelocation = new ModelResourceLocation("modmercenario:arcos/arcodemadera/arcoMercenarioDeMadera_A02_mercenariaExplosiva", "inventory") ;}
if (tick > 29             ){modelresourcelocation = new ModelResourceLocation("modmercenario:arcos/arcodemadera/arcoMercenarioDeMadera_A03_mercenariaExplosiva", "inventory") ;}
}break;







}

   	return modelresourcelocation;
   	
}
//####################################################################################3
@Override
public ItemStack onItemRightClick(ItemStack arco, World worldIn, EntityPlayer playerIn)
{
 playerIn.setItemInUse(arco, this.getMaxItemUseDuration(arco));

         //####################	
         //	HERE this arrow has texture 
         //####################
         // 
 if (!worldIn.isRemote){

mercenarymod.items.arcos.flechaMercenaria_entity 
	flechaM = new 
	mercenarymod.items.arcos.flechaMercenaria_entity(worldIn,playerIn,1);

worldIn.spawnEntityInWorld(flechaM);

 }




return arco; 
}
// ######################################################################################3
public String getUnlocalizedName(ItemStack stack) {

//		return "escopetaWinchester1200";

	switch (stack.getMetadata()) {
	default:
		return "arcoMercenarioDeMadera";
	case 1:
	case 2:
	case 3:
		return "arcoMercenarioDeMadera";
	case 4:
	case 5:
	case 6:
		return "arcoMercenarioDeMadera";
	case 7:
	case 8:
	case 9:
		return "arcoMercenarioDeMadera";
	}

}

// ############################################################################################3
@SideOnly(Side.CLIENT)
public void getSubItems(Item itemIn, CreativeTabs tab, List subItems) {

	subItems.add(new ItemStack(itemIn, 1, 1));
	//subItems.add(new ItemStack(itemIn, 1, 4));

}


//####################################################################################3
@Override
public boolean onEntitySwing(EntityLivingBase entityLiving, ItemStack arco)
{


 World worldIn = entityLiving.getEntityWorld();

 if (!worldIn.isRemote){

EntityPlayer playerIn = (EntityPlayer) entityLiving; 

mercenarymod.items.arcos.flechaMercenaria_entity 
	flechaM = new 
	mercenarymod.items.arcos.flechaMercenaria_entity(worldIn,playerIn,1);
	 worldIn.spawnEntityInWorld(flechaM);

 }


 return false;
}
//####################################################################################3
@Override
public void onUsingTick(ItemStack arco, EntityPlayer playerIn, int count)
{

 int tick;
 tick=1000-count;
 int ciclo=8;

 if (tick == 1)
 {
	boolean shoot = getBooleantag(arco, "shoot");

	if (!shoot)
	{
		playerIn.stopUsingItem();
	}



 }




}	 
//#################################################################################################3
public void disparo(EntityPlayer playerIn,World worldIn,ItemStack arco, float fuerza){
    //chat.chatm(playerIn, "disparo");


}//fin del methodo	

//#################################################################################################3
@Override
public void onPlayerStoppedUsing(ItemStack arco, World worldIn, EntityPlayer playerIn, int timeLeft)
{
	int tick;
    if (timeLeft>970){tick=30-(timeLeft-970);}
    else {tick=30;}

    float f=((tick/30F)*2.0F);

    if (!worldIn.isRemote){
    	
    	
    	
    	ArrayList<Integer> flechasCantidad = new ArrayList<Integer>();
    	flechasCantidad.clear();
    	
    	boolean habilitado=true;
    	boolean shoot = getBooleantag(arco, "shoot");
    	
    	
    	int municiondisponible=0;
    	int tipomunicion = getInttag(arco, "tipomunicion");

    	int tipomunicionmax = getInttag(arco, "tipomunicionmax");
    	int tipomunicionmin = getInttag(arco, "tipomunicionmin");
    	
    	boolean w00=true;
    	int cont=0;

    	Item flecha=null;
    	Item flecha1=Items.arrow;
    	Item flecha2=MercenaryModItems.flechaMercenaria;
    	Item flecha3=MercenaryModItems.flechaMercenariaExplosiva;
    	
    	switch(tipomunicion)
		{
		case 1: flecha=flecha1;break;
		case 2: flecha=flecha2;break;
		case 3: flecha=flecha3;break;
		}	    	
    		    	
    	
    	boolean fl1 = playerIn.inventory.hasItem(flecha1);
    	
    	boolean fl2 = playerIn.inventory.hasItem(flecha2);
    	
    	boolean fl3 = playerIn.inventory.hasItem(flecha3);
    	
    	if ( fl1 | fl2 | fl3  )
    	{}
    	else
    	{
    		tipomunicion=0;
    		setInttag(arco, "tipomunicion", tipomunicion );
    	}	
   

    	//mandar a disparar
    	if ( habilitado & !shoot ){
    		setBooleantag(arco, "shoot", true);
    		habilitado=false;
    	}
    	



    	//##############################
    	//
    	//HERE is the code to shoot the arrow
    	//##############################
    	//shoot   this arrows has no texture 
    	//disparo
    	if ( habilitado & shoot & (tick > 2) ){
    	
    		 int spell0 = EnchantmentHelper.getEnchantmentLevel(Enchantment.power.effectId, arco);
    		 int spell1 = EnchantmentHelper.getEnchantmentLevel(Enchantment.punch.effectId, arco);	 
    		 int spell2 = EnchantmentHelper.getEnchantmentLevel(Enchantment.flame.effectId, arco);
   		
    		
    	if (flecha != null)
    	{	
    		

    		
    		 
    	switch(tipomunicion){
    		// flecha vainilla
    	case 1: {
    		EntityArrow entityarrow = new EntityArrow(worldIn, playerIn, f );
    		
    	   if (spell0 > 0){entityarrow.setDamage(entityarrow.getDamage() + (double)spell0 * 0.5D + 0.5D);}
    	   if (spell1 > 0){entityarrow.setKnockbackStrength(spell1);}
    	   if (spell2 > 0){entityarrow.setFire(100);}
    	   worldIn.spawnEntityInWorld(entityarrow);
    		     	};break;
    		     	
     	
    	case 2: {
    		mercenarymod.items.arcos.flechaMercenaria_entity 
	    	flechaM = new 
	    	mercenarymod.items.arcos.flechaMercenaria_entity(worldIn,playerIn,f);
	    	   if (spell0 > 0){flechaM.setDamage(flechaM.getDamage() + (double)spell0 * 0.5D + 0.5D);}
	    	   if (spell1 > 0){flechaM.setKnockbackStrength(spell1);}
	    	   if (spell2 > 0){flechaM.setFire(100);}
			worldIn.spawnEntityInWorld(flechaM);
			    };break;
    		
    		
    	case 3: {
	    	mercenarymod.items.arcos.flechaMercenariaExplosiva_entity 
	    	flechaX = new 
	    	mercenarymod.items.arcos.flechaMercenariaExplosiva_entity(worldIn,playerIn,f);
	    	   if (spell0 > 0){flechaX.setDamage(flechaX.getDamage() + (double)spell0 * 0.5D + 0.5D);}
	    	   if (spell1 > 0){flechaX.setKnockbackStrength(spell1);}
	    	   if (spell2 > 0){flechaX.setFire(100);}
			worldIn.spawnEntityInWorld(flechaX);
    	        };break;
    		
    	}
    	playerIn.inventory.consumeInventoryItem(flecha);
    	}
    	
    	arco.damageItem(1, playerIn);//dañar con el uso
    	setBooleantag(arco, "shoot", false);
    	worldIn.playSoundAtEntity(playerIn, "random.bow", 1.0F, 1.0F / (itemRand.nextFloat() * 0.4F + 1.2F) + 0.5F);
    	
    	}//fin de disparar

    
    }//fin de (!worldIn.isRemote)

    	
}	 
//#################################################################################################3	    
@Override
public ItemStack onItemUseFinish(ItemStack stack, World worldIn, EntityPlayer playerIn)
{
      return stack;
}
//#################################################################################################3
public int getMaxItemUseDuration(ItemStack stack)
{
     return 1000;
}
//#################################################################################################3
@Override
public EnumAction getItemUseAction(ItemStack stack)
{ 	 
     return EnumAction.BOW;
}
//#########################################################################3 
	public static ArrayList<Integer> cuantosHayCuantosCaben(EntityPlayer playerIn, Item cosa) 
	{
	ArrayList<Integer> salida = new ArrayList<Integer>();
	ArrayList<Integer> vacio = new ArrayList<Integer>();
	ArrayList<Integer> conteos = new ArrayList<Integer>();
	conteos.clear();

	vacio.clear();
	vacio.add(0);

	salida.clear();
	salida.add(0);
	int cantidad=0;

	int invSize = (playerIn.inventory.getSizeInventory()) - 4;
	ItemStack invStack = null;
	Item       invItem = null;

		for (int invSlot = 0 ; invSlot < invSize ; invSlot++)
		{
			invStack=playerIn.inventory.getStackInSlot(invSlot);

			if (invStack != null)
			{
				invItem=invStack.getItem();

				if (invItem.equals(cosa))
				{
				salida.add(invSlot);
				cantidad += (invStack.stackSize);
				}

			}
			else 
			{
				vacio.add(invSlot);	
			}

		}

	salida.set(0, cantidad);
	vacio.set(0, ( vacio.size() - 1) );

	int maxStaacksize = cosa.getItemStackLimit();
	int cantidadUbicable= ((( salida.size() - 1) * maxStaacksize) - cantidad) + ( maxStaacksize * (vacio.get(0)) )  ;

	//chat.chatda(playerIn, "cantidadUbicable="+cantidadUbicable );
	//chat.chatda(playerIn, "vacios="+(vacio.get(0)) );

	conteos.add(cantidad);
	conteos.add(cantidadUbicable);

	return conteos;
	}
// ########################################################################3
public void onCreated(ItemStack arco, World worldIn,
		EntityPlayer playerIn) {
	intialize(arco, playerIn);
}

// #########################################################################3
public static void intialize(ItemStack arco, EntityPlayer playerIn) {

	// System.out.println("#\n#\n#\n Incializacion");

	int mm = 0; int tp = 0;
	switch (arco.getMetadata()) 
	{
		default:mm = 0;break;
		case 1: case 2:	case 3: mm = 1; tp = 1;break;
		case 4:	case 5: case 6:	mm = 1; tp = 2;break;
		case 7:	case 8:	case 9:	mm = 1; tp = 3;break;
	}

	int m = 0;
	switch (arco.getMetadata()) 
	{
		default: m = 0;	break;
		case 1: case 4:	case 7:	m = 0;break;
		case 2:	case 5:	case 8:	m = mm / 2;	break;
		case 3:	case 6:	case 9:	m = mm;break;
	}

	setInttag(arco, "texturajson", 0);
	setInttag(arco, "municion", m);
	setInttag(arco, "municionmaxima", mm);
	setInttag(arco, "municiondisponible", 0);
	setInttag(arco, "ciclosMaximos", 0);
	setInttag(arco, "tipomunicion", 1);
	setInttag(arco, "tipomunicionmax", 3);
	setInttag(arco, "tipomunicionmin", 1);

	setInttag(arco, "tipocargador", tp);
	setInttag(arco, "tipocargadormax", 0);

	setInttag(arco, "tipocargadorcambio", 0);

	setInttag(arco, "tipodisparo", 0);
	setInttag(arco, "tipodisparomax", 0);

	setBooleantag(arco, "reload", false);
	setBooleantag(arco, "shoot", false);
	setBooleantag(arco, "unload", false);
	setBooleantag(arco, "cargar", false);
	setBooleantag(arco, "descargar", false);
	setFloattag(arco, "strength", 0.0F);
	setBooleantag(arco, "enable", true);
	setBooleantag(arco, "inicializado", true);

}


// #########################################################################3


public static float getFloattag(ItemStack item, String tag) {

	NBTTagCompound etiquetas = item.getTagCompound();
	if (etiquetas == null) {
		etiquetas = new NBTTagCompound();
		item.setTagCompound(etiquetas);
		return 999.9F;
	}

	float ex = etiquetas.getFloat(tag);
	return ex;

}

// #########################################################################3

public static void setFloattag(ItemStack item, String tag, float value) {

	NBTTagCompound etiquetas = item.getTagCompound();
	if (etiquetas == null) {
		etiquetas = new NBTTagCompound();
	}

	etiquetas.setFloat(tag, value);
	item.setTagCompound(etiquetas);

}

// #########################################################################3

public static int getInttag(ItemStack item, String tag) {

	NBTTagCompound etiquetas = item.getTagCompound();
	if (etiquetas == null) {
		etiquetas = new NBTTagCompound();
		item.setTagCompound(etiquetas);
		return 9999;
	}

	int ex = etiquetas.getInteger(tag);
	return ex;

}

// #########################################################################3

public static void setInttag(ItemStack item, String tag, int value) {

	NBTTagCompound etiquetas = item.getTagCompound();
	if (etiquetas == null) {
		etiquetas = new NBTTagCompound();
	}

	etiquetas.setInteger(tag, value);
	item.setTagCompound(etiquetas);

}

// #########################################################################3

public static Boolean getBooleantag(ItemStack item, String tag) {

	NBTTagCompound etiquetas = item.getTagCompound();
	if (etiquetas == null) {
		etiquetas = new NBTTagCompound();
		item.setTagCompound(etiquetas);
		return false;
	}

	boolean ex = etiquetas.getBoolean(tag);

	return ex;

}

// #########################################################################3

public static void setBooleantag(ItemStack item, String tag, boolean value) {

	NBTTagCompound etiquetas = item.getTagCompound();
	if (etiquetas == null) {
		etiquetas = item.getTagCompound();
	}

	etiquetas.setBoolean(tag, value);
	item.setTagCompound(etiquetas);

}

// #########################################################################3

public int getItemEnchantability() {
	return 1;
}


//#########################################################################3	
@SideOnly(Side.CLIENT)
public void addInformation(ItemStack arco, EntityPlayer playerIn, List list, boolean aBoolean)
{


	int municion =getInttag(arco, "municion");		
	if((municion>9998)||(municion<0)){  
	intialize(arco, playerIn);       }


	String lore="municion="+municion;	
	String lore0="";
	String lore1="ControlClick to change arrow type";


	switch(getInttag(arco, "tipomunicion")){
	default: lore0="tipo de flechas=No hay flechas";break;
	case 1: lore0="tipo de flechas=flechas de madera";break;
	case 2: lore0="tipo de flechas=flechas de carbono";break;
	case 3: lore0="tipo de flechas=flechas de carbono explosivas";break;
	                                       }


	if(lore != "")
   {
      list.add(lore);
      list.add(lore0);
      list.add(lore1);
   }
}    
//#########################################################################3    
}
[!code]




ClientProxy.java
[code]
        @Override
        public void init() {
        	
        	System.out.println("########\n\n\n ClientProxy init()");
        	
        	mercenarymod.MercenaryModTexturas.init();
        	mercenarymod.MercenaryModTexturasBlockes.init();

        	RenderingRegistry.registerEntityRenderingHandler(mercenarymod.items.prueba.proyectilPapa_entity.class ,
        	new mercenarymod.items.prueba.renderPapa(Minecraft.getMinecraft().getRenderManager(), MercenaryModItems.papa,
        	Minecraft.getMinecraft().getRenderItem() ) );

     
        	RenderingRegistry.registerEntityRenderingHandler(mercenarymod.items.arcos.flechaPrueba.class ,
        	new mercenarymod.items.arcos.renderFlechaPrueba(Minecraft.getMinecraft().getRenderManager() ) );
        	
        	
        	RenderingRegistry.registerEntityRenderingHandler(mercenarymod.items.arcos.flechaMercenaria_entity.class ,
        	new mercenarymod.items.arcos.flechaMercenaria_render(Minecraft.getMinecraft().getRenderManager() ) );
        	
        	     RenderingRegistry.registerEntityRenderingHandler(mercenarymod.items.arcos.flechaMercenariaExplosiva_entity.class ,
            new mercenarymod.items.arcos.flechaMercenariaExplosiva_render(Minecraft.getMinecraft().getRenderManager() ) );
        	
        	
        }

 

 

flechaMercenaria_entity.java

package mercenarymod.items.arcos;

import java.util.List;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.block.state.IBlockState;
import net.minecraft.enchantment.EnchantmentHelper;
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.init.Items;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.network.play.server.S2BPacketChangeGameState;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.util.BlockPos;
import net.minecraft.util.DamageSource;
import net.minecraft.util.EnumParticleTypes;
import net.minecraft.util.MathHelper;
import net.minecraft.util.MovingObjectPosition;
import net.minecraft.util.ResourceLocation;
import net.minecraft.util.Vec3;
import net.minecraft.world.World;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;

public class flechaMercenaria_entity extends Entity implements IProjectile
{
    private int xTile = -1;
    private int yTile = -1;
    private int zTile = -1;
    private Block 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 static final String __OBFID = "CL_00001715";

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

    public flechaMercenaria_entity(World worldIn, double x, double y, double z)
    {
        super(worldIn);
        this.renderDistanceWeight = 10.0D;
        this.setSize(0.5F, 0.5F);
        this.setPosition(x, y, z);
    }

    public flechaMercenaria_entity(World worldIn, EntityLivingBase shooter, EntityLivingBase p_i1755_3_, float p_i1755_4_, float p_i1755_5_)
    {
        super(worldIn);
        this.renderDistanceWeight = 10.0D;
        this.shootingEntity = shooter;

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

        this.posY = shooter.posY + (double)shooter.getEyeHeight() - 0.10000000149011612D;
        double d0 = p_i1755_3_.posX - shooter.posX;
        double d1 = p_i1755_3_.getEntityBoundingBox().minY + (double)(p_i1755_3_.height / 3.0F) - this.posY;
        double d2 = p_i1755_3_.posZ - shooter.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(shooter.posX + d4, this.posY, shooter.posZ + d5, f2, f3);
            float f4 = (float)(d3 * 0.20000000298023224D);
            this.setThrowableHeading(d0, d1 + (double)f4, d2, p_i1755_4_, p_i1755_5_);
        }
    }

    public flechaMercenaria_entity(World worldIn, EntityLivingBase shooter, float p_i1756_3_)
    {
        super(worldIn);
        this.renderDistanceWeight = 10.0D;
        this.shootingEntity = shooter;

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

        this.setSize(0.5F, 0.5F);
        this.setLocationAndAngles(shooter.posX, shooter.posY + (double)shooter.getEyeHeight(), shooter.posZ, shooter.rotationYaw, shooter.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.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, p_i1756_3_ * 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.
     *  
     * @param inaccuracy Higher means more error.
     */
    public void setThrowableHeading(double x, double y, double z, float velocity, float inaccuracy)
    {
        float f2 = MathHelper.sqrt_double(x * x + y * y + z * z);
        x /= (double)f2;
        y /= (double)f2;
        z /= (double)f2;
        x += this.rand.nextGaussian() * (double)(this.rand.nextBoolean() ? -1 : 1) * 0.007499999832361937D * (double)inaccuracy;
        y += this.rand.nextGaussian() * (double)(this.rand.nextBoolean() ? -1 : 1) * 0.007499999832361937D * (double)inaccuracy;
        z += this.rand.nextGaussian() * (double)(this.rand.nextBoolean() ? -1 : 1) * 0.007499999832361937D * (double)inaccuracy;
        x *= (double)velocity;
        y *= (double)velocity;
        z *= (double)velocity;
        this.motionX = x;
        this.motionY = y;
        this.motionZ = z;
        float f3 = MathHelper.sqrt_double(x * x + z * z);
        this.prevRotationYaw = this.rotationYaw = (float)(Math.atan2(x, z) * 180.0D / Math.PI);
        this.prevRotationPitch = this.rotationPitch = (float)(Math.atan2(y, (double)f3) * 180.0D / Math.PI);
        this.ticksInGround = 0;
    }

    @SideOnly(Side.CLIENT)
    public void func_180426_a(double p_180426_1_, double p_180426_3_, double p_180426_5_, float p_180426_7_, float p_180426_8_, int p_180426_9_, boolean p_180426_10_)
    {
        this.setPosition(p_180426_1_, p_180426_3_, p_180426_5_);
        this.setRotation(p_180426_7_, p_180426_8_);
    }

    /**
     * Sets the velocity to the args. Args: x, y, z
     */
    @SideOnly(Side.CLIENT)
    public void setVelocity(double x, double y, double z)
    {
        this.motionX = x;
        this.motionY = y;
        this.motionZ = z;

        if (this.prevRotationPitch == 0.0F && this.prevRotationYaw == 0.0F)
        {
            float f = MathHelper.sqrt_double(x * x + z * z);
            this.prevRotationYaw = this.rotationYaw = (float)(Math.atan2(x, z) * 180.0D / Math.PI);
            this.prevRotationPitch = this.rotationPitch = (float)(Math.atan2(y, (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);
        }

        BlockPos blockpos = new BlockPos(this.xTile, this.yTile, this.zTile);
        IBlockState iblockstate = this.worldObj.getBlockState(blockpos);
        Block block = iblockstate.getBlock();

        if (block.getMaterial() != Material.air)
        {
            block.setBlockBoundsBasedOnState(this.worldObj, blockpos);
            AxisAlignedBB axisalignedbb = block.getCollisionBoundingBox(this.worldObj, blockpos, iblockstate);

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

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

        if (this.inGround)
        {
            int j = block.getMetaFromState(iblockstate);

            if (block == this.inTile && j == 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 vec31 = new Vec3(this.posX, this.posY, this.posZ);
            Vec3 vec3 = new Vec3(this.posX + this.motionX, this.posY + this.motionY, this.posZ + this.motionZ);
            MovingObjectPosition movingobjectposition = this.worldObj.rayTraceBlocks(vec31, vec3, false, true, false);
            vec31 = new Vec3(this.posX, this.posY, this.posZ);
            vec3 = new Vec3(this.posX + this.motionX, this.posY + this.motionY, this.posZ + this.motionZ);

            if (movingobjectposition != null)
            {
                vec3 = new Vec3(movingobjectposition.hitVec.xCoord, movingobjectposition.hitVec.yCoord, movingobjectposition.hitVec.zCoord);
            }

            Entity entity = null;
            List list = this.worldObj.getEntitiesWithinAABBExcludingEntity(this, this.getEntityBoundingBox().addCoord(this.motionX, this.motionY, this.motionZ).expand(1.0D, 1.0D, 1.0D));
            double d0 = 0.0D;
            int i;
            float f1;

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

                if (entity1.canBeCollidedWith() && (entity1 != this.shootingEntity || this.ticksInAir >= 5))
                {
                    f1 = 0.3F;
                    AxisAlignedBB axisalignedbb1 = entity1.getEntityBoundingBox().expand((double)f1, (double)f1, (double)f1);
                    MovingObjectPosition movingobjectposition1 = axisalignedbb1.calculateIntercept(vec31, vec3);

                    if (movingobjectposition1 != null)
                    {
                        double d1 = vec31.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;
            float f4;

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

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

                    DamageSource damagesource;

                    if (this.shootingEntity == null)
                    {
                        damagesource = DamageSource.causeThrownDamage(this, this);
                    }
                    else
                    {
                        damagesource = DamageSource.causeThrownDamage(this, this.shootingEntity);
                    }

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

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

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

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

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

                            if (this.shootingEntity instanceof EntityLivingBase)
                            {
                                EnchantmentHelper.func_151384_a(entitylivingbase, this.shootingEntity);
                                EnchantmentHelper.func_151385_b((EntityLivingBase)this.shootingEntity, entitylivingbase);
                            }

                            if (this.shootingEntity != null && movingobjectposition.entityHit != this.shootingEntity && movingobjectposition.entityHit instanceof EntityPlayer && this.shootingEntity instanceof EntityPlayerMP)
                            {
                                ((EntityPlayerMP)this.shootingEntity).playerNetServerHandler.sendPacket(new S2BPacketChangeGameState(6, 0.0F));
                            }
                        }

                        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
                {
                    BlockPos blockpos1 = movingobjectposition.getBlockPos();
                    this.xTile = blockpos1.getX();
                    this.yTile = blockpos1.getY();
                    this.zTile = blockpos1.getZ();
                    iblockstate = this.worldObj.getBlockState(blockpos1);
                    this.inTile = iblockstate.getBlock();
                    this.inData = this.inTile.getMetaFromState(iblockstate);
                    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));
                    f3 = MathHelper.sqrt_double(this.motionX * this.motionX + this.motionY * this.motionY + this.motionZ * this.motionZ);
                    this.posX -= this.motionX / (double)f3 * 0.05000000074505806D;
                    this.posY -= this.motionY / (double)f3 * 0.05000000074505806D;
                    this.posZ -= this.motionZ / (double)f3 * 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.getMaterial() != Material.air)
                    {
                        this.inTile.onEntityCollidedWithBlock(this.worldObj, blockpos1, iblockstate, this);
                    }
                }
            }

            if (this.getIsCritical())
            {
                for (i = 0; i < 4; ++i)
                {
                    this.worldObj.spawnParticle(EnumParticleTypes.CRIT, this.posX + this.motionX * (double)i / 4.0D, this.posY + this.motionY * (double)i / 4.0D, this.posZ + this.motionZ * (double)i / 4.0D, -this.motionX, -this.motionY + 0.2D, -this.motionZ, new int[0]);
                }
            }

            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;
            f3 = 0.99F;
            f1 = 0.05F;

            if (this.isInWater())
            {
                for (int l = 0; l < 4; ++l)
                {
                    f4 = 0.25F;
                    this.worldObj.spawnParticle(EnumParticleTypes.WATER_BUBBLE, this.posX - this.motionX * (double)f4, this.posY - this.motionY * (double)f4, this.posZ - this.motionZ * (double)f4, this.motionX, this.motionY, this.motionZ, new int[0]);
                }

                f3 = 0.6F;
            }

            if (this.isWet())
            {
                this.extinguish();
            }

            this.motionX *= (double)f3;
            this.motionY *= (double)f3;
            this.motionZ *= (double)f3;
            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 tagCompound)
    {
        tagCompound.setShort("xTile", (short)this.xTile);
        tagCompound.setShort("yTile", (short)this.yTile);
        tagCompound.setShort("zTile", (short)this.zTile);
        tagCompound.setShort("life", (short)this.ticksInGround);
        ResourceLocation resourcelocation = (ResourceLocation)Block.blockRegistry.getNameForObject(this.inTile);
        tagCompound.setString("inTile", resourcelocation == null ? "" : resourcelocation.toString());
        tagCompound.setByte("inData", (byte)this.inData);
        tagCompound.setByte("shake", (byte)this.arrowShake);
        tagCompound.setByte("inGround", (byte)(this.inGround ? 1 : 0));
        tagCompound.setByte("pickup", (byte)this.canBePickedUp);
        tagCompound.setDouble("damage", this.damage);
    }

    /**
     * (abstract) Protected helper method to read subclass entity data from NBT.
     */
    public void readEntityFromNBT(NBTTagCompound tagCompund)
    {
        this.xTile = tagCompund.getShort("xTile");
        this.yTile = tagCompund.getShort("yTile");
        this.zTile = tagCompund.getShort("zTile");
        this.ticksInGround = tagCompund.getShort("life");

        if (tagCompund.hasKey("inTile", )
        {
            this.inTile = Block.getBlockFromName(tagCompund.getString("inTile"));
        }
        else
        {
            this.inTile = Block.getBlockById(tagCompund.getByte("inTile") & 255);
        }

        this.inData = tagCompund.getByte("inData") & 255;
        this.arrowShake = tagCompund.getByte("shake") & 255;
        this.inGround = tagCompund.getByte("inGround") == 1;

        if (tagCompund.hasKey("damage", 99))
        {
            this.damage = tagCompund.getDouble("damage");
        }

        if (tagCompund.hasKey("pickup", 99))
        {
            this.canBePickedUp = tagCompund.getByte("pickup");
        }
        else if (tagCompund.hasKey("player", 99))
        {
            this.canBePickedUp = tagCompund.getBoolean("player") ? 1 : 0;
        }
    }

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

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

            if (flag)
            {
                this.playSound("random.pop", 0.2F, ((this.rand.nextFloat() - this.rand.nextFloat()) * 0.7F + 1.0F) * 2.0F);
                entityIn.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;
    }

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

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

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

    /**
     * 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 p_70243_1_)
    {
        byte b0 = this.dataWatcher.getWatchableObjectByte(16);

        if (p_70243_1_)
        {
            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;
    }

}

 

 

 

flechaMercenaria_render.java

package mercenarymod.items.arcos;

import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.client.renderer.WorldRenderer;
import net.minecraft.client.renderer.entity.Render;
import net.minecraft.client.renderer.entity.RenderManager;
import net.minecraft.entity.Entity;
import mercenarymod.items.arcos.flechaMercenaria_entity;
import net.minecraft.util.MathHelper;
import net.minecraft.util.ResourceLocation;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;

import org.lwjgl.opengl.GL11;

@SideOnly(Side.CLIENT)
public class flechaMercenaria_render extends Render
{
    private static final ResourceLocation arrowTextures = new ResourceLocation("modmercenario:textures/entity/mercenaryArrow.png");
    //private static final String __OBFID = "CL_00000978";

    public flechaMercenaria_render(RenderManager p_i46193_1_)
    {
        super(p_i46193_1_);
    }

    public void doRender(flechaMercenaria_entity p_180551_1_, double p_180551_2_, double p_180551_4_, double p_180551_6_, float p_180551_8_, float p_180551_9_)
    {
        this.bindEntityTexture(p_180551_1_);
        GlStateManager.color(1.0F, 1.0F, 1.0F, 1.0F);
        GlStateManager.pushMatrix();
        GlStateManager.translate((float)p_180551_2_, (float)p_180551_4_, (float)p_180551_6_);
        GlStateManager.rotate(p_180551_1_.prevRotationYaw + (p_180551_1_.rotationYaw - p_180551_1_.prevRotationYaw) * p_180551_9_ - 90.0F, 0.0F, 1.0F, 0.0F);
        GlStateManager.rotate(p_180551_1_.prevRotationPitch + (p_180551_1_.rotationPitch - p_180551_1_.prevRotationPitch) * p_180551_9_, 0.0F, 0.0F, 1.0F);
        Tessellator tessellator = Tessellator.getInstance();
        WorldRenderer worldrenderer = tessellator.getWorldRenderer();
        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;
        GlStateManager.enableRescaleNormal();
        float f11 = (float)p_180551_1_.arrowShake - p_180551_9_;

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

        GlStateManager.rotate(45.0F, 1.0F, 0.0F, 0.0F);
        GlStateManager.scale(f10, f10, f10);
        GlStateManager.translate(-4.0F, 0.0F, 0.0F);
        GL11.glNormal3f(f10, 0.0F, 0.0F);
        worldrenderer.startDrawingQuads();
        worldrenderer.addVertexWithUV(-7.0D, -2.0D, -2.0D, (double)f6, (double)f8);
        worldrenderer.addVertexWithUV(-7.0D, -2.0D, 2.0D, (double)f7, (double)f8);
        worldrenderer.addVertexWithUV(-7.0D, 2.0D, 2.0D, (double)f7, (double)f9);
        worldrenderer.addVertexWithUV(-7.0D, 2.0D, -2.0D, (double)f6, (double)f9);
        tessellator.draw();
        GL11.glNormal3f(-f10, 0.0F, 0.0F);
        worldrenderer.startDrawingQuads();
        worldrenderer.addVertexWithUV(-7.0D, 2.0D, -2.0D, (double)f6, (double)f8);
        worldrenderer.addVertexWithUV(-7.0D, 2.0D, 2.0D, (double)f7, (double)f8);
        worldrenderer.addVertexWithUV(-7.0D, -2.0D, 2.0D, (double)f7, (double)f9);
        worldrenderer.addVertexWithUV(-7.0D, -2.0D, -2.0D, (double)f6, (double)f9);
        tessellator.draw();

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

        GlStateManager.disableRescaleNormal();
        GlStateManager.popMatrix();
        super.doRender(p_180551_1_, p_180551_2_, p_180551_4_, p_180551_6_, p_180551_8_, p_180551_9_);
    }

    protected ResourceLocation getEntityTexture(flechaMercenaria_entity p_180550_1_)
    {
        return arrowTextures;
    }

    /**
     * Returns the location of an entity's texture. Doesn't seem to be called unless you call Render.bindEntityTexture.
     */
    protected ResourceLocation getEntityTexture(Entity entity)
    {
        return this.getEntityTexture((flechaMercenaria_entity)entity);
    }

    /**
     * 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 func_76986_a(T entity, double d, double d1,
     * double d2, float f, float f1). But JAD is pre 1.5 so doe
     */
    public void doRender(Entity entity, double x, double y, double z, float p_76986_8_, float partialTicks)
    {
        this.doRender((flechaMercenaria_entity)entity, x, y, z, p_76986_8_, partialTicks);
    }
}

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.
Note: Your post will require moderator approval before it will be visible.

Guest
Unfortunately, your content contains terms that we do not allow. Please edit your content to remove the highlighted words below.
Reply to this topic...

×   Pasted as rich text.   Restore formatting

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

×
 Share
Go to topic listing

Announcements



×
×
  • Create New...

Important Information

By using this site, you agree to our Terms of Use.

  I accept