[1.7.x]Extended Entity Properties/Dimension/Particules/Rotation d'un Item

[mindany2]

Le plus dûr n’est pas de généré une structure, ni de faire une dimension je pense
C’est de faire en sorte que la dimension est vide avec une structure qui apparaît à ton spawn

[Superloup10]

C’est même relativement facile à faire.
Prenons une structure de 5^3.
La bordure de la structure étant le 5ème bloc en x, y et z.
Il suffit de dire que tous les blocs en dehors de cette zone sont des blocs d’air, et de dire, que le bas de la structure spawn en dessous du joueur.

C’est moi, qui vais m’occuper de cette dimension-structure dans Energy Transformer (J’aime le challenge).

[mindany2]

“C’est moi, qui va s’occuper de cette dimension-structure dans Energy Transformer (J’aime le challenge).”
Ok ^^ j’ai un projet personnel qui va utilisé le même principe (structure dans le vide), je vais essayé d’utiliser ça

Ah au faite je vais pouvoir vous aidez vers juillet pour Energy Transformer ^^ (enfin si j’arrive à vous aidez)

[mindany2]

Après avoir vérifié le temps entre chaque post (doute entre 24 et 48h :P) :
J’ai réussi à créer ma dimension vide en revanche mon problème est de faire spawn la structure en dessous du spawn du joueur qui doit être identique à chaque endroit de l’overworld (en gros que le portail soit fait en 1900 1000 ou en 0 0 revient au même)

J’ai fait quelque recherche dans les codes mais je n’ai rien trouvé de spécial mise à part peut-être :

public ChunkCoordinates getEntrancePortalLocation()
{
return new ChunkCoordinates(100, 50, 0);
}

mais il n’est d’aucune aide pour ce problème il me semble
Auriez vous une idée :huh:

Merci d’avance

[Superloup10]

C’est le joueur qui spawn en (100, 50, 0) ou la structure? Pour la structure, j’ai réussi à la faire spawné constamment en (0, 4, 0).

[mindany2]

Bah les deux en faite
Enfin après les coordonnés peut importe le temps que le joueur spawn bien au dessus de la structure ^^___Salut,
J’ai un autre problème qui concerne la façon dont on active le fly j’aimerais faire un système de la même façon (donc en faisant un “double saut” mais j’ai du mal à comprendre le système qui active le fly dans la class EntityPlayerSP on voit

boolean flag = this.movementInput.jump;
if (this.capabilities.allowFlying && !flag && this.movementInput.jump)
{
if (this.flyToggleTimer == 0)
{
this.flyToggleTimer = 7;
}
else
{
this.capabilities.isFlying = !this.capabilities.isFlying;
this.sendPlayerAbilities();
this.flyToggleTimer = 0;
}
}

flag est normalement contraire de “this.movementInput.jump” et pourtant c’est une condition “et” (si on peut dire ça comme ça)
De plus j’ai utilisé ce code mais ça n’a pas marché un simple saut l’active
Merci d’avance

Edit : Oups >.<’ j’ai mal configurer mon profil… Le forum m’affichait l’heure en GTM +0 donc je pensais que ça faisait les 24 heures … Désolé

[robin4002]

J’ai fusionné les deux messages.

Tu l’as mit ou ton code ?
Car celui de mojang se trouve dans la fonction onUpdate du joueur, donc une fonction déclenché à chaque tick. Entre les deux morceaux de code que tu as donnés, il y a d’autres codes qui joue sur le timer, ça doit être ça.
La condition flag est obtenu plus tôt dans le temps, en fait elle sert à éviter que mettre le fly si le joueur reste appuyer sur la touche.

[mindany2]

Merci d’avoir fusionné mes messages et encore désolé ^^’
J’ai mis le bout de code dans un LivingUpdateEvent
Ok, en revanche comment puis-je garder le même principe en ne pouvant pas vraiment “éloigner” le flag :s ?
Les codes entre les deux morceaux que j’ai envoyé concernent le sprint donc je ne pense pas que l’info est dedans

[robin4002]

Envoie tout ton code actuel. Tu cherche à faire quoi exactement ?

[mindany2]

Ok

@SubscribeEvent
public void onLivingUpdate(LivingUpdateEvent event)
{
Minecraft mc = Minecraft.getMinecraft();
if(event.entity instanceof EntityPlayer){
EntityPlayer player = (EntityPlayer) event.entityLiving;

boolean flag = mc.thePlayer.movementInput.jump;
if(!flag&&mc.thePlayer.movementInput.jump){
final IEntitySelector livingFilter = new SonicEntityFilter();
List entityTagetList = player.worldObj.selectEntitiesWithinAABB(Entity.class, player.boundingBox.expand(64.0D, 64.0D, 64.0D), livingFilter);
for(int i = 0; i < entityTagetList.size(); i++)
{
Entity entityTarget = (Entity)entityTagetList.get(i);
if(entityTarget != player && entityTarget instanceof EntityLivingBase)
{
EntityLivingBase entityLivingTarget = (EntityLivingBase)entityTarget;
Vec3 vec3 = player.getLook(1.0F).normalize();
Vec3 vec31 = entityLivingTarget.worldObj.getWorldVec3Pool().getVecFromPool(entityLivingTarget.posX - player.posX, entityLivingTarget.boundingBox.minY + (double)(entityLivingTarget.height / 2.0F) - (player.posY + (double)player.getEyeHeight()), entityLivingTarget.posZ - player.posZ);
double d0 = vec31.lengthVector();
vec31 = vec31.normalize();
double d1 = vec3.dotProduct(vec31);
if(d1 > 1.0D - 0.025D / d0 && player.canEntityBeSeen(entityLivingTarget))
{
player.setPositionAndUpdate(entityLivingTarget.posX, entityLivingTarget.posY, entityLivingTarget.posZ);
player.attackTargetEntityWithCurrentItem(entityLivingTarget);
}
}
}
}
}
}

Bon ben là les codes “parlent” d’eux même je cherche à faire en sorte que lorsqu’on appuie deux fois sur espace cela tp le joueur à l’entité et l’attaque ^^

[robin4002]

private final Map <entityplayer, integer="">timeSinceLastJump = new HashMap();
@SubscribeEvent
public void onJump(LivingJumpEvent event)
{
if(event.entityLiving instanceof EntityPlayer)
{
EntityPlayer player = (EntityPlayer)event.entityLiving;
if(timeSinceLastJump.containsKey(player))
{
if(timeSinceLastJump.get(player) < 30)
{
System.out.println("deux jump à la suite");
}
}
timeSinceLastJump.put(player, 0);
}
}

@SubscribeEvent
public void onLivingUpdate(LivingUpdateEvent event)
{
if(event.entity instanceof EntityPlayer)
{
EntityPlayer player = (EntityPlayer)event.entityLiving;
if(timeSinceLastJump.containsKey(player))
{
timeSinceLastJump.put(player, timeSinceLastJump.get(player) + 1);
System.out.println(timeSinceLastJump.get(player));
}
}
}

J’ai testé, c’est fonctionnel.</entityplayer,>

[mindany2]

Pour ma part le message à parait à un simple saut pourtant , d’après ce que j’ai compris du code si la touche est maintenu cela marche quand même non ?

Edit : Mise à jour du post afin de ne pas avoir à lire tout les messages

[robin4002]

En effet, je viens de retesté, je devais être fatigué quand j’ai dis que ça fonctionnait x)

Du-coup j’ai tout refait, ça m’a l’air bon parcontre c’est que en client :

@SideOnly(Side.CLIENT)
boolean jumpLast = false;
@SideOnly(Side.CLIENT)
int timer;

@SideOnly(Side.CLIENT)
@SubscribeEvent
public void onTickPlayer(TickEvent.PlayerTickEvent event)
{
if(event.player.getCommandSenderName() == Minecraft.getMinecraft().thePlayer.getCommandSenderName())
{
EntityPlayerSP player = Minecraft.getMinecraft().thePlayer;
if(player.movementInput.jump)
{
if(!jumpLast)
{
jumpLast = true;
}
else if(timer > 2)
{
jumpLast = false;
System.out.println("second jump");
}
timer = 0;
}
if(jumpLast)
{
timer ++;
if(timer > 20)
{
jumpLast = false;
timer = 0;
}
}
}
}

Ah, aussi, j’utilise un event de fml, donc il faut enregistrer la classe avec FMLCommonHandler.instance().bus().register(new TaClasse());

[mindany2]

C’est pas grave vu tout ce que tu fais sur ce site ._.
Merci beaucoup ça marche parfaitement bien ^^

Edit : Encore un “petit” problème >.<’ (je suis actuellement en train de chercher comment l’arranger)
J’ai voulu faire spawn des particules et j’aimerais que les particules soit “stable” comme le bloc barrier en snapshot

[robin4002]

Pour l’image en jeu : https://github.com/FFMT/nanotech_mod/blob/master/common/fr/mcnanotech/kevin_68/nanotechmod/main/event/RenderEvent.java#L45-L64
Par contre là c’est sur tout le jeu, il faudrait adapter le code pour mettre seulement sur une partie de l’écran.

Pour les particules, aucune idée.

[mindany2]

Ok merci, ça m’a permis en même temps de comprendre comment marchais le placement x, y avec Tessellator ^^
Encore un petit problème avec les overlays : J’aimerais utilisé une police spécial pour afficher des chiffres, actuellement j’utilise

FMLClientHandler.instance().getClient().fontRenderer.drawStringWithShadow(player.getEntityData().getInteger("numb"), 5, 15, 0xffffff);
``` mais il ne propose pas le changement de police donc y a t'il une fonction qui le propose où je vais devoir essayé de marcher par image :s ?

[robin4002]

Heu non je ne crois pas qu’il y ait de fonction pour changer la police

[mindany2]

Aie :s
Je vais essayé de passer par des images alors ._.
Pendant ce temps je continue à m’attaquer à plus dur et j’ai du mal >.<’
J’essaye de créer un(e) EntityItem plus grand(e) enfin une nouvelle entité basé sur son principe (Récupérable par le joueur, temps de récupération/dispawn, tourne sur elle même), j’ai commencé à épuré son code

public class EntityItem2 extends EntityItem
{
private static final Logger logger = LogManager.getLogger();
/**
* The age of this EntityItem (used to animate it up and down as well as expire it)
*/
public int age;
public int delayBeforeCanPickup;
/**
* The health of this EntityItem. (For example, damage for tools)
*/
private String field_145801_f;
private String field_145802_g;
/**
* The EntityItem's random initial float height.
*/
public float hoverStart;
private static final String __OBFID = "CL_00001669";

/**
* The maximum age of this EntityItem. The item is expired once this is reached.
*/
public int lifespan = 6000;

public EntityItem2(World par1World, double par2, double par4, double par6)
{
super(par1World);
this.hoverStart = (float)(Math.random() * Math.PI * 2.0D);
this.setSize(0.25F, 0.25F);
this.yOffset = this.height / 2.0F;
this.setPosition(par2, par4, par6);
this.rotationYaw = (float)(Math.random() * 360.0D);
this.motionX = (double)((float)(Math.random() * 0.20000000298023224D - 0.10000000149011612D));
this.motionY = 0.20000000298023224D;
this.motionZ = (double)((float)(Math.random() * 0.20000000298023224D - 0.10000000149011612D));
}

public EntityItem2(World par1World, double par2, double par4, double par6, ItemStack par8ItemStack)
{
this(par1World, par2, par4, par6);
this.setEntityItemStack(par8ItemStack);
this.lifespan = (par8ItemStack.getItem() == null ? 6000 : par8ItemStack.getItem().getEntityLifespan(par8ItemStack, par1World));
}

/**
* 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 EntityItem2(World par1World)
{
super(par1World);
this.hoverStart = (float)(Math.random() * Math.PI * 2.0D);
this.setSize(0.25F, 0.25F);
this.yOffset = this.height / 2.0F;
}

protected void entityInit()
{
this.getDataWatcher().addObjectByDataType(10, 5);
}

/**
* Called to update the entity's position/logic.
*/
public void onUpdate()
{
if (this.getEntityItem() == null)
{
this.setDead();
}
else
{
super.onUpdate();

if (this.delayBeforeCanPickup > 0)
{
–this.delayBeforeCanPickup;
}

this.prevPosX = this.posX;
this.prevPosY = this.posY;
this.prevPosZ = this.posZ;
this.motionY -= 0.03999999910593033D;
this.noClip = this.func_145771_j(this.posX, (this.boundingBox.minY + this.boundingBox.maxY) / 2.0D, this.posZ);
this.moveEntity(this.motionX, this.motionY, this.motionZ);
boolean flag = (int)this.prevPosX != (int)this.posX || (int)this.prevPosY != (int)this.posY || (int)this.prevPosZ != (int)this.posZ;

if (flag || this.ticksExisted % 25 == 0)
{
if (this.worldObj.getBlock(MathHelper.floor_double(this.posX), MathHelper.floor_double(this.posY), MathHelper.floor_double(this.posZ)).getMaterial() == Material.lava)
{
this.motionY = 0.20000000298023224D;
this.motionX = (double)((this.rand.nextFloat() - this.rand.nextFloat()) * 0.2F);
this.motionZ = (double)((this.rand.nextFloat() - this.rand.nextFloat()) * 0.2F);
this.playSound("random.fizz", 0.4F, 2.0F + this.rand.nextFloat() * 0.4F);
}
}

float f = 0.98F;

if (this.onGround)
{
f = this.worldObj.getBlock(MathHelper.floor_double(this.posX), MathHelper.floor_double(this.boundingBox.minY) - 1, MathHelper.floor_double(this.posZ)).slipperiness * 0.98F;
}

this.motionX *= (double)f;
this.motionY *= 0.9800000190734863D;
this.motionZ *= (double)f;

if (this.onGround)
{
this.motionY *= -0.5D;
}

++this.age;

ItemStack item = getDataWatcher().getWatchableObjectItemStack(10);

if (!this.worldObj.isRemote && this.age >= lifespan)
{
this.setDead();
}

if (item != null && item.stackSize <= 0)
{
this.setDead();
}
}
}

/**
* Looks for other itemstacks nearby and tries to stack them together
*/
private void searchForOtherItemsNearby()
{
return;
}

/**
* Tries to merge this item with the item passed as the parameter. Returns true if successful. Either this item or
* the other item will be removed from the world.
*/
public boolean combineItems(EntityItem par1EntityItem){
return false;
}

/**
* sets the age of the item so that it'll despawn one minute after it has been dropped (instead of five). Used when
* items are dropped from players in creative mode
*/
public void setAgeToCreativeDespawnTime()
{
this.age = 4800;
}

/**
* Returns if this entity is in water and will end up adding the waters velocity to the entity
*/
public boolean handleWaterMovement()
{
return this.worldObj.handleMaterialAcceleration(this.boundingBox, Material.water, this);
}

/**
* Will deal the specified amount of damage to the entity if the entity isn't immune to fire damage. Args:
* amountDamage
*/
protected void dealFireDamage(int par1)
{
this.attackEntityFrom(DamageSource.inFire, (float)par1);
}

/**
* Called when the entity is attacked.
*/
public boolean attackEntityFrom(DamageSource par1DamageSource, float par2)
{
this.setBeenAttacked();
return false;
}

/**
* (abstract) Protected helper method to write subclass entity data to NBT.
*/
public void writeEntityToNBT(NBTTagCompound par1NBTTagCompound)
{
par1NBTTagCompound.setShort("Age", (short)this.age);
par1NBTTagCompound.setInteger("Lifespan", lifespan);

if (this.func_145800_j() != null)
{
par1NBTTagCompound.setString("Thrower", this.field_145801_f);
}

if (this.func_145798_i() != null)
{
par1NBTTagCompound.setString("Owner", this.field_145802_g);
}

if (this.getEntityItem() != null)
{
par1NBTTagCompound.setTag("Item", this.getEntityItem().writeToNBT(new NBTTagCompound()));
}
}

/**
* (abstract) Protected helper method to read subclass entity data from NBT.
*/
public void readEntityFromNBT(NBTTagCompound par1NBTTagCompound)
{
this.age = par1NBTTagCompound.getShort("Age");

if (par1NBTTagCompound.hasKey("Owner"))
{
this.field_145802_g = par1NBTTagCompound.getString("Owner");
}

if (par1NBTTagCompound.hasKey("Thrower"))
{
this.field_145801_f = par1NBTTagCompound.getString("Thrower");
}

NBTTagCompound nbttagcompound1 = par1NBTTagCompound.getCompoundTag("Item");
this.setEntityItemStack(ItemStack.loadItemStackFromNBT(nbttagcompound1));

ItemStack item = getDataWatcher().getWatchableObjectItemStack(10);

if (item == null || item.stackSize <= 0)
{
this.setDead();
}

if (par1NBTTagCompound.hasKey("Lifespan"))
{
lifespan = par1NBTTagCompound.getInteger("Lifespan");
}
}

/**
* Called by a player entity when they collide with an entity
*/
public void onCollideWithPlayer(EntityPlayer par1EntityPlayer)
{
if (!this.worldObj.isRemote)
{
if (this.delayBeforeCanPickup > 0)
{
return;
}

EntityItemPickupEvent event = new EntityItemPickupEvent(par1EntityPlayer, this);

if (MinecraftForge.EVENT_BUS.post(event))
{
return;
}

ItemStack itemstack = this.getEntityItem();
int i = itemstack.stackSize;

if (this.delayBeforeCanPickup <= 0 && (this.field_145802_g == null || lifespan - this.age <= 200 || this.field_145802_g.equals(par1EntityPlayer.getCommandSenderName())) && (event.getResult() == Result.ALLOW || i <= 0 || true))
{

FMLCommonHandler.instance().firePlayerItemPickupEvent(par1EntityPlayer, this);

this.worldObj.playSoundAtEntity(par1EntityPlayer, "random.pop", 0.2F, ((this.rand.nextFloat() - this.rand.nextFloat()) * 0.7F + 1.0F) * 2.0F);
itemstack.stackSize = 0;
int ring = par1EntityPlayer.getEntityData().getInteger("ring");
par1EntityPlayer.getEntityData().setInteger("ring",ring+itemstack.stackSize);

if (itemstack.stackSize <= 0)
{
this.setDead();
}
}
}
}

public void travelToDimension(int par1)
{
super.travelToDimension(par1);
}

/**
* Returns the ItemStack corresponding to the Entity (Note: if no item exists, will log an error but still return an
* ItemStack containing Block.stone)
*/
public ItemStack getEntityItem()
{
ItemStack itemstack = this.getDataWatcher().getWatchableObjectItemStack(10);

if (itemstack == null)
{
if (this.worldObj != null)
{
logger.error("Item entity " + this.getEntityId() + " has no item?!");
}

return new ItemStack(Items.stick);
}
else
{
return itemstack;
}
}

/**
* Sets the ItemStack for this entity
*/
public void setEntityItemStack(ItemStack par1ItemStack)
{
this.getDataWatcher().updateObject(10, par1ItemStack);
this.getDataWatcher().setObjectWatched(10);
}

public String func_145798_i()
{
return this.field_145802_g;
}

public void func_145797_a(String p_145797_1_)
{
this.field_145802_g = p_145797_1_;
}

public String func_145800_j()
{
return this.field_145801_f;
}

public void func_145799_b(String p_145799_1_)
{
this.field_145801_f = p_145799_1_;
}
}

Le problème c’est que pour l’agrandir, il faut un render, je l’ai aussi un peu épuré :

@SideOnly(Side.CLIENT)
public class RenderItem2 extends Render
{
private static final ResourceLocation RES_ITEM_GLINT = new ResourceLocation("textures/misc/enchanted_item_glint.png");
/**
* The RNG used in RenderItem (for bobbing itemstacks on the ground)
*/
private Random random = new Random();
public boolean renderWithColor = true;
/**
* Defines the zLevel of rendering of item on GUI.
*/
public float zLevel;
public static boolean renderInFrame;
private static final String __OBFID = "CL_00001003";

public RenderItem2()
{
this.shadowSize = 0.15F;
this.shadowOpaque = 0.75F;
}

/**
* 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,="" d1,<br="">* double d2, float f, float f1). But JAD is pre 1.5 so doesn't do that.
*/
public void doRender(EntityItem2 par1EntityItem2, double par2, double par4, double par6, float par8, float par9)
{
ItemStack itemstack = par1EntityItem2.getEntityItem();

if (itemstack.getItem() != null)
{
System.out.println("Ce code est lu ?");
this.bindEntityTexture(par1EntityItem2);
this.random.setSeed(187L);
GL11.glPushMatrix();
float f2 = shouldBob() ? MathHelper.sin(((float)par1EntityItem2.age + par9) / 10.0F + par1EntityItem2.hoverStart) * 0.1F + 0.1F : 0F;
float f3 = (((float)par1EntityItem2.age + par9) / 20.0F + par1EntityItem2.hoverStart) * (180F / (float)Math.PI);
byte b0 = 1;

if (par1EntityItem2.getEntityItem().stackSize > 1)
{
b0 = 2;
}

b0 = getMiniBlockCount(itemstack, b0);
GL11.glTranslatef((float)par2, (float)par4 + f2, (float)par6);
GL11.glEnable(GL12.GL_RESCALE_NORMAL);
float f7;
float f6;
int k;

if (ForgeHooksClient.renderEntityItem(par1EntityItem2, itemstack, f2, f3, random, renderManager.renderEngine, field_147909_c, b0))
{
;
}
else // Code Style break here to prevent the patch from editing this line
{
float f5;

if (/*itemstack.getItemSpriteNumber() == 1 &&*/ itemstack.getItem().requiresMultipleRenderPasses())
{
if (renderInFrame)
{
GL11.glScalef(0.5128205F, 0.5128205F, 0.5128205F);
GL11.glTranslatef(0.0F, -0.05F, 0.0F);
}
else
{
GL11.glScalef(5.5F, 5.5F, 5.5F);
}

for (int j = 0; j <= itemstack.getItem().getRenderPasses(itemstack.getItemDamage()); ++j)
{
this.random.setSeed(187L);
IIcon iicon1 = itemstack.getItem().getIcon(itemstack, j);

if (this.renderWithColor)
{
k = itemstack.getItem().getColorFromItemStack(itemstack, j);
f5 = (float)(k >> 16 & 255) / 255.0F;
f6 = (float)(k >> 8 & 255) / 255.0F;
f7 = (float)(k & 255) / 255.0F;
GL11.glColor4f(f5, f6, f7, 1.0F);
this.renderDroppedItem(par1EntityItem2, iicon1, b0, par9, f5, f6, f7, j);
}
else
{
this.renderDroppedItem(par1EntityItem2, iicon1, b0, par9, 1.0F, 1.0F, 1.0F, j);
}
}
}
else
{
if (itemstack != null && itemstack.getItem() instanceof ItemCloth)
{
GL11.glAlphaFunc(GL11.GL_GREATER, 0.1F);
GL11.glEnable(GL11.GL_BLEND);
OpenGlHelper.glBlendFunc(770, 771, 1, 0);
}

if (renderInFrame)
{
GL11.glScalef(0.5128205F, 0.5128205F, 0.5128205F);
GL11.glTranslatef(0.0F, -0.05F, 0.0F);
}
else
{
GL11.glScalef(0.5F, 0.5F, 0.5F);
}

IIcon iicon = itemstack.getIconIndex();

if (this.renderWithColor)
{
int i = itemstack.getItem().getColorFromItemStack(itemstack, 0);
float f4 = (float)(i >> 16 & 255) / 255.0F;
f5 = (float)(i >> 8 & 255) / 255.0F;
f6 = (float)(i & 255) / 255.0F;
this.renderDroppedItem(par1EntityItem2, iicon, b0, par9, f4, f5, f6);
}
else
{
this.renderDroppedItem(par1EntityItem2, iicon, b0, par9, 1.0F, 1.0F, 1.0F);
}

if (itemstack != null && itemstack.getItem() instanceof ItemCloth)
{
GL11.glDisable(GL11.GL_BLEND);
}
}
}

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

/**
* Returns the location of an entity's texture. Doesn't seem to be called unless you call Render.bindEntityTexture.
*/
protected ResourceLocation getEntityTexture(EntityItem2 par1EntityItem2)
{
return this.renderManager.renderEngine.getResourceLocation(par1EntityItem2.getEntityItem().getItemSpriteNumber());
}

/**
* Renders a dropped item
*/
private void renderDroppedItem(EntityItem2 par1EntityItem2, IIcon par2Icon, int par3, float par4, float par5, float par6, float par7)
{
this.renderDroppedItem(par1EntityItem2, par2Icon, par3, par4, par5, par6, par7, 0);
}

// JAVADOC METHOD $ renderDroppedItem
private void renderDroppedItem(EntityItem2 par1EntityItem2, IIcon par2Icon, int par3, float par4, float par5, float par6, float par7, int pass)
{
Tessellator tessellator = Tessellator.instance;

if (par2Icon == null)
{
TextureManager texturemanager = Minecraft.getMinecraft().getTextureManager();
ResourceLocation resourcelocation = texturemanager.getResourceLocation(par1EntityItem2.getEntityItem().getItemSpriteNumber());
par2Icon = ((TextureMap)texturemanager.getTexture(resourcelocation)).getAtlasSprite("missingno");
}

float f14 = ((IIcon)par2Icon).getMinU();
float f15 = ((IIcon)par2Icon).getMaxU();
float f4 = ((IIcon)par2Icon).getMinV();
float f5 = ((IIcon)par2Icon).getMaxV();
float f6 = 1.0F;
float f7 = 0.5F;
float f8 = 0.25F;
float f10;

if (this.renderManager.options.fancyGraphics)
{
GL11.glPushMatrix();

if (renderInFrame)
{
GL11.glRotatef(180.0F, 0.0F, 1.0F, 0.0F);
}
else
{
GL11.glRotatef((((float)par1EntityItem2.age + par4) / 20.0F + par1EntityItem2.hoverStart) * (180F / (float)Math.PI), 0.0F, 1.0F, 0.0F);
}

float f9 = 0.0625F;
f10 = 0.021875F;
ItemStack itemstack = par1EntityItem2.getEntityItem();
int j = itemstack.stackSize;
byte b0;

if (j < 2)
{
b0 = 1;
}
else if (j < 16)
{
b0 = 2;
}
else if (j < 32)
{
b0 = 3;
}
else
{
b0 = 4;
}

b0 = getMiniItemCount(itemstack, b0);

GL11.glTranslatef(-f7, -f8, -((f9 + f10) * (float)b0 / 2.0F));

for (int k = 0; k < b0; ++k)
{
// Makes items offset when in 3D, like when in 2D, looks much better. Considered a vanilla bug...
if (k > 0 && shouldSpreadItems())
{
float x = (random.nextFloat() * 2.0F - 1.0F) * 0.3F / 0.5F;
float y = (random.nextFloat() * 2.0F - 1.0F) * 0.3F / 0.5F;
float z = (random.nextFloat() * 2.0F - 1.0F) * 0.3F / 0.5F;
GL11.glTranslatef(x, y, f9 + f10);
}
else
{
GL11.glTranslatef(0f, 0f, f9 + f10);
}

if (itemstack.getItemSpriteNumber() == 0)
{
this.bindTexture(TextureMap.locationBlocksTexture);
}
else
{
this.bindTexture(TextureMap.locationItemsTexture);
}

GL11.glColor4f(par5, par6, par7, 1.0F);
ItemRenderer.renderItemIn2D(tessellator, f15, f4, f14, f5, ((IIcon)par2Icon).getIconWidth(), ((IIcon)par2Icon).getIconHeight(), f9);

if (itemstack.hasEffect(pass))
{
GL11.glDepthFunc(GL11.GL_EQUAL);
GL11.glDisable(GL11.GL_LIGHTING);
this.renderManager.renderEngine.bindTexture(RES_ITEM_GLINT);
GL11.glEnable(GL11.GL_BLEND);
GL11.glBlendFunc(GL11.GL_SRC_COLOR, GL11.GL_ONE);
float f11 = 0.76F;
GL11.glColor4f(0.5F * f11, 0.25F * f11, 0.8F * f11, 1.0F);
GL11.glMatrixMode(GL11.GL_TEXTURE);
GL11.glPushMatrix();
float f12 = 0.125F;
GL11.glScalef(f12, f12, f12);
float f13 = (float)(Minecraft.getSystemTime() % 3000L) / 3000.0F * 8.0F;
GL11.glTranslatef(f13, 0.0F, 0.0F);
GL11.glRotatef(-50.0F, 0.0F, 0.0F, 1.0F);
ItemRenderer.renderItemIn2D(tessellator, 0.0F, 0.0F, 1.0F, 1.0F, 255, 255, f9);
GL11.glPopMatrix();
GL11.glPushMatrix();
GL11.glScalef(f12, f12, f12);
f13 = (float)(Minecraft.getSystemTime() % 4873L) / 4873.0F * 8.0F;
GL11.glTranslatef(-f13, 0.0F, 0.0F);
GL11.glRotatef(10.0F, 0.0F, 0.0F, 1.0F);
ItemRenderer.renderItemIn2D(tessellator, 0.0F, 0.0F, 1.0F, 1.0F, 255, 255, f9);
GL11.glPopMatrix();
GL11.glMatrixMode(GL11.GL_MODELVIEW);
GL11.glDisable(GL11.GL_BLEND);
GL11.glEnable(GL11.GL_LIGHTING);
GL11.glDepthFunc(GL11.GL_LEQUAL);
}
}

GL11.glPopMatrix();
}
else
{
for (int l = 0; l < par3; ++l)
{
GL11.glPushMatrix();

if (l > 0)
{
f10 = (this.random.nextFloat() * 2.0F - 1.0F) * 0.3F;
float f17 = (this.random.nextFloat() * 2.0F - 1.0F) * 0.3F;
float f16 = (this.random.nextFloat() * 2.0F - 1.0F) * 0.3F;
GL11.glTranslatef(f10, f17, f16);
}

if (!renderInFrame)
{
GL11.glRotatef(180.0F - this.renderManager.playerViewY, 0.0F, 1.0F, 0.0F);
}

GL11.glColor4f(par5, par6, par7, 1.0F);
tessellator.startDrawingQuads();
tessellator.setNormal(0.0F, 1.0F, 0.0F);
tessellator.addVertexWithUV((double)(0.0F - f7), (double)(0.0F - f8), 0.0D, (double)f14, (double)f5);
tessellator.addVertexWithUV((double)(f6 - f7), (double)(0.0F - f8), 0.0D, (double)f15, (double)f5);
tessellator.addVertexWithUV((double)(f6 - f7), (double)(1.0F - f8), 0.0D, (double)f15, (double)f4);
tessellator.addVertexWithUV((double)(0.0F - f7), (double)(1.0F - f8), 0.0D, (double)f14, (double)f4);
tessellator.draw();
GL11.glPopMatrix();
}
}
}

/**
* Render the item's icon or block into the GUI, including the glint effect.
*/

public void renderEffect(TextureManager manager, int x, int y)
{
GL11.glDepthFunc(GL11.GL_EQUAL);
GL11.glDisable(GL11.GL_LIGHTING);
GL11.glDepthMask(false);
manager.bindTexture(RES_ITEM_GLINT);
GL11.glEnable(GL11.GL_ALPHA_TEST);
GL11.glEnable(GL11.GL_BLEND);
GL11.glColor4f(0.5F, 0.25F, 0.8F, 1.0F);
this.renderGlint(x * 431278612 + y * 32178161, x - 2, y - 2, 20, 20);
GL11.glDepthMask(true);
GL11.glDisable(GL11.GL_BLEND);
GL11.glDisable(GL11.GL_ALPHA_TEST);
GL11.glEnable(GL11.GL_LIGHTING);
GL11.glDepthFunc(GL11.GL_LEQUAL);
}

private void renderGlint(int par1, int par2, int par3, int par4, int par5)
{
for (int j1 = 0; j1 < 2; ++j1)
{
OpenGlHelper.glBlendFunc(772, 1, 0, 0);
float f = 0.00390625F;
float f1 = 0.00390625F;
float f2 = (float)(Minecraft.getSystemTime() % (long)(3000 + j1 * 1873)) / (3000.0F + (float)(j1 * 1873)) * 256.0F;
float f3 = 0.0F;
Tessellator tessellator = Tessellator.instance;
float f4 = 4.0F;

if (j1 == 1)
{
f4 = -1.0F;
}

tessellator.startDrawingQuads();
tessellator.addVertexWithUV((double)(par2 + 0), (double)(par3 + par5), (double)this.zLevel, (double)((f2 + (float)par5 * f4) * f), (double)((f3 + (float)par5) * f1));
tessellator.addVertexWithUV((double)(par2 + par4), (double)(par3 + par5), (double)this.zLevel, (double)((f2 + (float)par4 + (float)par5 * f4) * f), (double)((f3 + (float)par5) * f1));
tessellator.addVertexWithUV((double)(par2 + par4), (double)(par3 + 0), (double)this.zLevel, (double)((f2 + (float)par4) * f), (double)((f3 + 0.0F) * f1));
tessellator.addVertexWithUV((double)(par2 + 0), (double)(par3 + 0), (double)this.zLevel, (double)((f2 + 0.0F) * f), (double)((f3 + 0.0F) * f1));
tessellator.draw();
}
}

/**
* Adds a quad to the tesselator at the specified position with the set width and height and color. Args:
* tessellator, x, y, width, height, color
*/
private void renderQuad(Tessellator par1Tessellator, int par2, int par3, int par4, int par5, int par6)
{
par1Tessellator.startDrawingQuads();
par1Tessellator.setColorOpaque_I(par6);
par1Tessellator.addVertex((double)(par2 + 0), (double)(par3 + 0), 0.0D);
par1Tessellator.addVertex((double)(par2 + 0), (double)(par3 + par5), 0.0D);
par1Tessellator.addVertex((double)(par2 + par4), (double)(par3 + par5), 0.0D);
par1Tessellator.addVertex((double)(par2 + par4), (double)(par3 + 0), 0.0D);
par1Tessellator.draw();
}

public void renderIcon(int par1, int par2, IIcon par3Icon, int par4, int par5)
{
Tessellator tessellator = Tessellator.instance;
tessellator.startDrawingQuads();
tessellator.addVertexWithUV((double)(par1 + 0), (double)(par2 + par5), (double)this.zLevel, (double)par3Icon.getMinU(), (double)par3Icon.getMaxV());
tessellator.addVertexWithUV((double)(par1 + par4), (double)(par2 + par5), (double)this.zLevel, (double)par3Icon.getMaxU(), (double)par3Icon.getMaxV());
tessellator.addVertexWithUV((double)(par1 + par4), (double)(par2 + 0), (double)this.zLevel, (double)par3Icon.getMaxU(), (double)par3Icon.getMinV());
tessellator.addVertexWithUV((double)(par1 + 0), (double)(par2 + 0), (double)this.zLevel, (double)par3Icon.getMinU(), (double)par3Icon.getMinV());
tessellator.draw();
}

/**
* Returns the location of an entity's texture. Doesn't seem to be called unless you call Render.bindEntityTexture.
*/
protected ResourceLocation getEntityTexture(Entity par1Entity)
{
return this.getEntityTexture((EntityItem2)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 Render is generic
* (Render <t extends="" entity)="" and="" this="" method="" has="" signature="" public="" void="" dorender(t="" entity,="" double="" d,="" d1,<br="">* 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.doRender((EntityItem2)par1Entity, par2, par4, par6, par8, par9);
}

/*==================================== FORGE START ===========================================*/

/**
* Items should spread out when rendered in 3d?
* @return
*/
public boolean shouldSpreadItems()
{
return true;
}

/**
* Items should have a bob effect
* @return
*/
public boolean shouldBob()
{
return true;
}

public byte getMiniBlockCount(ItemStack stack, byte original)
{
return original;
}

/**
* Allows for a subclass to override how many rendered items appear in a
* "mini item 3d stack"
* @param stack The item stack
* @param original The default amount vanilla would use
* @return
*/
public byte getMiniItemCount(ItemStack stack, byte original)
{
return original;
}
/*==================================== FORGE END =============================================*/
}

En ayant mis dans mon ClientProxy

RenderingRegistry.registerEntityRenderingHandler(EntityItem2.class, new RenderItem2());

Pourtant le render n’est pas lu, savez pourquoi ?</t></t>

[robin4002]

ça n’ira pas comme ça car quand tu drop un item ça spawnera une EntityItem normal.
Depuis le IItemRenderer tu peux changer le rendu de le l’entity item, il faut que tu passe par ça.

[mindany2]

J’avais fait un autre système qui faisait spawn les items
Je vais me renseigner pour IItemRenderer si c’est plus simple, sachant que je n’utilise pas de model spécial, lequel dois-je mettre ?