Gui coté serveur

[robin4002]

Ajoutes des System.out.println( ) pour déboguer ton code.

[Jodge]

Forcé de constaté que parfois, (souvent dans mon cas) l’erreur est tellement grosse qu’elle me saute au yeux… 
J’ai initialisé mon tag au nom de “aT” dans JWeapons, et “aC” dans mon énum ^^’
J’ai donc revue ma fonction d’initialisation pour qu’elle prène le nom définis dans mon énum pour éviter les problèmes de ce genre.

J’ai aussi vue qu’il manquais dans ma fonction onUptade la condition “if(!worldIn.isRemote)” pour éviter d’agir a la fois coté client et serveur.

De plus, chose que je n’avais pas capté sur le coup, ma fonction d’initialisation ne réinitialise pas mes précédent tag, du coup les tests effectuer depuis mon ancien objet générer bugguer forcément.

En revanche, mon bug est bien réel.

Voici un extrait du log :
(lecture deux ligne par deux ligne sous la forme suivante :
#1# : nom du tag, valeur initial, valeur recu
### nom du tag, nouvelle valeur, modification effectuer
Si la nouvelle valeur n’es pas celle égale a reçu, alors le boolean devrai être à false, ce qui signifie que le tag n’existe pas)

:::
[21:30:18] [Server thread/INFO] [STDOUT]: [fr.Jodge.jodgeLibrary.common.JFunction:write:1091]: ###
[21:30:18] [Server thread/INFO] [STDOUT]: [fr.Jodge.jodgeLibrary.common.JFunction:write:1091]: #1# : rC 0 1
[21:30:18] [Server thread/INFO] [STDOUT]: [fr.Jodge.jodgeLibrary.common.JFunction:write:1091]: ### : rC 1 true
[21:30:18] [Server thread/INFO] [STDOUT]: [fr.Jodge.jodgeLibrary.common.JFunction:write:1091]: ###
[21:30:18] [Server thread/INFO] [STDOUT]: [fr.Jodge.jodgeLibrary.common.JFunction:write:1091]: #1# : aT 0 1
[21:30:18] [Server thread/INFO] [STDOUT]: [fr.Jodge.jodgeLibrary.common.JFunction:write:1091]: ### : aT 0 true
[21:30:18] [Server thread/INFO] [STDOUT]: [fr.Jodge.jodgeLibrary.common.JFunction:write:1091]: #1# : aT 0 0
[21:30:18] [Server thread/INFO] [STDOUT]: [fr.Jodge.jodgeLibrary.common.JFunction:write:1091]: ### : aT 0 true
[21:30:18] [Server thread/INFO] [STDOUT]: [fr.Jodge.jodgeLibrary.common.JFunction:write:1091]: #1# : rPC 0 1
[21:30:18] [Server thread/INFO] [STDOUT]: [fr.Jodge.jodgeLibrary.common.JFunction:write:1091]: ### : rPC 0 true
[21:30:18] [Server thread/INFO] [STDOUT]: [fr.Jodge.jodgeLibrary.common.JFunction:write:1091]: #1# : aT 0 1
[21:30:18] [Server thread/INFO] [STDOUT]: [fr.Jodge.jodgeLibrary.common.JFunction:write:1091]: ### : aT 0 true
[21:30:18] [Server thread/INFO] [STDOUT]: [fr.Jodge.jodgeLibrary.common.JFunction:write:1091]: #1# : aT 0 0
[21:30:18] [Server thread/INFO] [STDOUT]: [fr.Jodge.jodgeLibrary.common.JFunction:write:1091]: ### : aT 0 true
[21:30:18] [Server thread/INFO] [STDOUT]: [fr.Jodge.jodgeLibrary.common.JFunction:write:1091]: #1# : rPC 0 1
[21:30:18] [Server thread/INFO] [STDOUT]: [fr.Jodge.jodgeLibrary.common.JFunction:write:1091]: ### : rPC 0 true
:::

Les 4 premier lignes sont séparer des autres, pour cause, elle sont dans la fonction “onPlayerStoppedUsing”.
On peu voir ici que la modification a correctement lieu.

Le premier problème a lieu au niveau de la ligne 6. Sur la ligne 5 on peu voir que la valeur reçus (le 3eme argument) est 1.
Or la valeur n’est pas mis a jour (pour rapel, elle passe par la même fonction que la premier). Ces deux ligne corresponde a l’incrémentation de base de ma boucle.

la 7 et 8 eme ligne sont la pour s’assurer que les valeur retourne a 0, car il y a eu une modification de right clic (les 4 premier ligne)

la ligne 9 et 10 sont la pour justement empêcher que ma variable ne soit ré-initialisé a chaque tour de boucle (en revanche son incrémentation continue).

nous avons donc 3 fonctions qui bug ici.
Si nous regardons les fonctions de plus près, on se rend compte qu’elle ont lieu dans ce sens :
Incrémentation (fonctionnelle)
Incrémentation (buguer)
Changement de valeur (buguer)
Changement de valeur (buguer)

Le boolean étant a true depuis que j’ai correctement renommé mon tag, il n’y a aucune raison pour que cela ne fonctionne pas

J’ai rien compris ces tag à la con, mais ça m’as l’air un poil buguer quand on y fait trop appelle ^^'X)

[robin4002]

Renvoies ton code actuel vu que tu as fait des modifications depuis.

[Jodge]

Désoler pour la réponse un poil tardive, j’ai eu quelque problème IRL (vive les travaux d’urgence T-T).

enfin bref, après avoir galérer avec GitHub en vain (allez savoir pourquoi le bouton importer un fichier/projet, qui est pourtant le plus basique de mon point de vue n’existe pas sur le site, ou alors est super bien planqué…)

Du coup, comme ça m’as un peu gonfler, je vais me contenter des bonne vielle balise java pour le moment…

Main (@mod) :

package fr.Jodge.jodgeLibrary.common;

import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.fml.common.Mod;
import net.minecraftforge.fml.common.Mod.EventHandler;
import net.minecraftforge.fml.common.Mod.Instance;

import net.minecraftforge.fml.common.SidedProxy;

import net.minecraftforge.fml.common.event.FMLInitializationEvent;
import net.minecraftforge.fml.common.event.FMLPostInitializationEvent;
import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;

@Mod(modid=Main.MODID, name=Main.MODNAME, version=Main.MODVER) //Tell forge "Oh hey, there's a new mod here to load."
public class Main
{
   public static final String MODID = "jodgelibrary";
   public static final String MODNAME = "Jodge Library";
   public static final String MODVER = "A0.1.5";

   public static final boolean DEBUG = true;

@Instance(MODID)
public static Main instance;

@SidedProxy(clientSide = "fr.Jodge.jodgeLibrary.client.ClientProxy", serverSide = "fr.Jodge.jodgeLibrary.common.CommonProxy")
public static CommonProxy proxy;

@EventHandler
public void preInit(FMLPreInitializationEvent event)
{

}

@EventHandler
public void init(FMLInitializationEvent event)
{
proxy.registerRender();
if(event.getSide().isClient())
{
MinecraftForge.EVENT_BUS.register(new JScreen());
}
}

@EventHandler
public void postInit(FMLPostInitializationEvent event)
{

}

}

JScreen :

​package fr.Jodge.jodgeLibrary.common;

import java.awt.Color;

import org.lwjgl.opengl.GL11;

import fr.Jodge.jodgeLibrary.common.JFunction.nbtVar;
import fr.Jodge.jodgeLibrary.common.toolSet.JWeapons;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.FontRenderer;
import net.minecraft.client.gui.Gui;
import net.minecraft.client.gui.ScaledResolution;
import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.client.renderer.RenderHelper;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.client.renderer.WorldRenderer;
import net.minecraft.client.renderer.entity.RenderItem;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.ContainerPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.Slot;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.profiler.Profiler;
import net.minecraft.util.EnumChatFormatting;
import net.minecraft.util.ResourceLocation;
import net.minecraftforge.client.event.RenderGameOverlayEvent;
import net.minecraftforge.client.event.RenderGameOverlayEvent.ElementType;
import net.minecraftforge.fml.common.eventhandler.EventPriority;
import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;

public class JScreen extends Gui
{
private static EntityPlayer player;
private static Item item;

private static int WIDTH = 16;
private static int HEIGHT = 16;
private static int NBSLOT = 9;

private static Minecraft MC = Minecraft.getMinecraft();;

    ResourceLocation TIMERTEXTURE = new ResourceLocation(Main.MODID + ":textures/gui/timerCombo.png");

    @SideOnly(Side.CLIENT)
@SubscribeEvent(priority = EventPriority.NORMAL)
public void onRenderHotbar(RenderGameOverlayEvent.Post event) 
{
   if(event.isCancelable() || event.type != ElementType.HOTBAR) // to active whit hotbar
   {      
    return;
   }

   // VARIABLE    
if(player == null || player != MC.thePlayer) // first time, and when player change cause of other mod ?
{
player = MC.thePlayer; // To get Player
}

int limMax = player.openContainer.getInventory().size();

for (int i = limMax - NBSLOT; i < limMax; ++i)
{
Slot slot = (Slot)player.openContainer.inventorySlots.get(i);
   ItemStack itemStack = slot.getStack(); 

if(itemStack != null)
{
item = itemStack.getItem();

    ScaledResolution sr = new ScaledResolution(MC, MC.displayWidth, MC.displayHeight);;

       int y = sr.getScaledHeight() - HEIGHT - 3;
       int x = 0;

// FUNCTION

       if(item instanceof JWeapons)
       {
    // ################################################
    GlStateManager.pushMatrix(); 
       //GlStateManager.disableLighting();
       //GlStateManager.disableDepth();
       //GlStateManager.disableTexture2D();
       //GlStateManager.disableAlpha();
       //GlStateManager.disableBlend();
       GL11.glColor4f(0.8F, 0.8F, 0.8F, 1.0F); // Cyan, Magenta, Jaune, 
    // ################################################

       x = getXforSlot(i, limMax);
       if(x != 0)
       {
           int actualTimer = nbtVar.readNbtVarInt(itemStack, nbtVar.ActualCombo);
           int comboTimer = ((JWeapons)item).comboTimer * 20;
        double width = (((comboTimer - Math.min(comboTimer, actualTimer)) * WIDTH) / comboTimer);

           if(actualTimer != 0)
        {
       Minecraft.getMinecraft().renderEngine.bindTexture(TIMERTEXTURE);
       JFunction.drawTexturedModalRect(x, y, 1.0F, 0, 0, (int)width, HEIGHT);
        }
       }

    // ################################################
       //GlStateManager.enableBlend();
       //GlStateManager.enableAlpha();
       //GlStateManager.enableTexture2D();
       //GlStateManager.enableDepth();
       //GlStateManager.enableLighting();
       GlStateManager.popMatrix();
    // ################################################

       } // end of item instanceof JWeapons

}// end of itemStack != null

}// end of for

} // RenderGameOverlayEvent(post)

int getXforSlot(int slot, int nbSlot)
{
    ScaledResolution sr = new ScaledResolution(MC, MC.displayWidth, MC.displayHeight);;
int x = (sr.getScaledWidth() / 2) - WIDTH/2;
int pos = nbSlot - slot;

if (pos > 0 && pos <= NBSLOT)
{
return x - (WIDTH + 4) * (pos - 5);
}
else
{
return 0;
}
}

}

/* for (int i = limMin; i < limMax; ++i)
{
Slot slot = (Slot)inventoryPlayer.inventorySlots.get(i);
    ItemStack itemstack = slot.getStack(); 
itemRender = mc.getRenderItem();

    if(itemstack != null)
    {
        Item item = itemstack.getItem();
        Minecraft mc = Minecraft.getMinecraft();
        if(item instanceof JWeapons)
        {

            double actualTimer = ((JWeapons)item).actualTimer;
            double comboTimer = ((JWeapons)item).comboTimer * 20;

            Minecraft.getMinecraft().renderEngine.bindTexture(timerTexture);
            JFunction.drawTexturedModalRect(x, y, itemRender.zLevel + 1.0F, 0, 0, 16, 16);

        } // end of item instanceof JWeapons
    } // end of itemStack != null
} // end of for*/

JFunction (j’ai enlever toute les fonction qui ne sont pas utiles pour alléger) :

​package fr.Jodge.jodgeLibrary.common;

import java.util.Locale;

import fr.Jodge.jodgeLibrary.common.toolSet.JWeapons;

import net.minecraft.block.Block;
import net.minecraft.block.BlockCrops;

import net.minecraft.block.BlockBush;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.client.renderer.WorldRenderer;

import net.minecraft.enchantment.EnchantmentHelper;

import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.SharedMonsterAttributes;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.EntityPlayerMP;

import net.minecraft.init.Blocks;

import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;

import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.network.play.server.S12PacketEntityVelocity;

import net.minecraft.stats.AchievementList;
import net.minecraft.stats.StatList;

import net.minecraft.util.BlockPos;
import net.minecraft.util.DamageSource;
import net.minecraft.util.MathHelper;

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 JFunction 
{
[…]
   public static enum nbtVar
   {
    RightCombo("rC"),
    RightPreviousCombo("rPC"),
    LeftCombo("lC"),
    LeftPreviousCombo("lPC"),
    ActualCombo("aT");

    private String name = "";

    nbtVar(String name)
    {
    this.name = name;
    }

    public String toString()
    {
    return name;
    }

       public static boolean writeNbtVar(ItemStack stack, nbtVar var, int value)
       {
        JFunction.write("#1# : " + var + " " + nbtVar.readNbtVarInt(stack, var) + " " + value);

        boolean isWrite = false;
        if (stack.hasTagCompound())
        {
               NBTTagCompound itemData = stack.getTagCompound();

            String varName = var.toString();

            if(itemData.hasKey(varName))
            {
            stack.getTagCompound().setInteger(varName, value);
               isWrite = true;
            }
        }
        JFunction.write("### : " + var + " " + nbtVar.readNbtVarInt(stack, var) + " " + isWrite);

        return isWrite;

       }

       public static boolean incNbtVarInt(ItemStack stack, nbtVar var)
       {
        int i = readNbtVarInt(stack, var);

        return writeNbtVar(stack, var, i + 1);
       }

       public static boolean decNbtVarInt(ItemStack stack, nbtVar var)
       {
        int i = readNbtVarInt(stack, var);
        return writeNbtVar(stack, var, i - 1);
       }

public static int readNbtVarInt(ItemStack stack, nbtVar var)
{
if (stack.hasTagCompound())
{
NBTTagCompound itemData = stack.getTagCompound();

String varName = var.toString();

if (itemData.hasKey(varName))
{
return stack.getTagCompound().getInteger(varName);
}
}
return 0;
}

   }
[…]
   @SideOnly(Side.CLIENT)
public static void drawTexturedModalRect(int x, int y, float z, int textureX, int textureY, int width, int height)
{
drawTexturedModalRect(x, y, z, textureX, textureY, width, height, 0.00390625F, 0.00390625F);
}

   @SideOnly(Side.CLIENT)
public static void drawTexturedModalRect(int x, int y, float z, int textureX, int textureY, int width, int height, float f, float f1)
{
Tessellator tessellator = Tessellator.getInstance();
       WorldRenderer worldrenderer = tessellator.getWorldRenderer();

       worldrenderer.startDrawingQuads();
       worldrenderer.addVertexWithUV(x + 0, y + height, z, (textureX + 0) * f, (textureY + height) * f1);
       worldrenderer.addVertexWithUV(x + width, y + height, z, (textureX + width) * f, (textureY + height) * f1);
       worldrenderer.addVertexWithUV(x + width, y + 0, z, (textureX + width) * f, (textureY + 0) * f1);
       worldrenderer.addVertexWithUV(x + 0, y + 0, z, (textureX + 0) * f, (textureY + 0) * f1);
tessellator.draw();
}
[…]
public static void write (String text)
{
System.out.println(text);
}

Si il manque d’autre fichier, je peu les rajouter si besoin, j’essaye juste d’éviter de mettre tout les fichiers pour que ceux qui comme toi accepte de perdre un peu de leurs temps pour aider les autres n’en perde justement pas trop à s’y retrouver dans les fichiers X)

[robin4002]

public static int readNbtVarInt(ItemStack stack, nbtVar var)
{
if (stack.hasTagCompound())
{
NBTTagCompound itemData = stack.getTagCompound();

if(var == nbtVar.RightCombo)
{
String varName = nbtVar.RightCombo.toString();

if(itemData.hasKey(varName))
{
return stack.getTagCompound().getInteger(varName);
}
}
}
return 0;
}

Pourquoi tu as une condition if(var == nbtVar.RightCombo) ici ?

[Jodge]

Autant pour moi, ce n’est pas toute à fait la bonne version du code (grâce ou a cause de Github, j’ai du récupérer une ancienne sauvegarde du code, parce que j’avais accidentellement tous effacé)

La bonne version de la fonction est :

public static int readNbtVarInt(ItemStack stack, nbtVar var)
{
if (stack.hasTagCompound())
{
NBTTagCompound itemData = stack.getTagCompound();

String varName = var.toString();

if (itemData.hasKey(varName))
{
return stack.getTagCompound().getInteger(varName);
}
}
return 0;
}

Truc plutôt étrange, mon problème d’écriture c’est réglé lorsque j’ai ré-écrit le code manquant a cause de Github. Je suppose que j’ai enlever l’erreur en ré-écrivant le code ^^’ (note que l’erreur ne pouvais pas venir de read, car la fonction n’étais pas utilisé dans le write, sauf pour l’affichage. L’affichage étais donc peu être buguer, mais la valeur n’étais jamais atteinte, puisque l’objet n’étais jamais ré-initialisé, et que je n’utilisai pas encore les nouvelles fonction dans ma classe JScreen au moment du test)

Du coup j’ai un problème qui persiste.
Pour faire un timer, j’écrit tous les tic, dans un tag, et cela entraîne une ré-initialisation constante de l’objet (et donc de l’animation).
il n’y a pas une manière différente de faire timer (moins gourmand en ressources, qui dure X tick pour chaque instance de l’objet, et qui se réinitialise dès que la condition change uniquement pour cette objet ?

Voila ma classe a l’heure actuel :

public void onUpdate(ItemStack stack, World worldIn, Entity entityIn, int itemSlot, boolean isSelected)
{
if(stack.getTagCompound() == null)
       {
        stack.setTagCompound(new NBTTagCompound());

        stack.getTagCompound().setInteger("rC", 0); // Right Combo
        stack.getTagCompound().setInteger("rPC",0); // Right Previous Combo
        stack.getTagCompound().setInteger("lC", 0); // Left Combo
        stack.getTagCompound().setInteger("lPC", 0); // Left Previous Combo
        stack.getTagCompound().setInteger("aT",0); // actualTimer
       }

if ((nbtVar.readNbtVarInt(stack, nbtVar.RightCombo) != 0) || (nbtVar.readNbtVarInt(stack, nbtVar.LeftCombo) != 0))
{
nbtVar.incNbtVarInt(stack, nbtVar.ActualCombo);
if (nbtVar.readNbtVarInt(stack, nbtVar.ActualCombo) >= this.comboTimer)
{
nbtVar.writeNbtVar(stack, nbtVar.RightCombo, 0);
nbtVar.writeNbtVar(stack, nbtVar.LeftCombo, 0);
nbtVar.writeNbtVar(stack, nbtVar.ActualCombo, 0);
}
else if ( nbtVar.readNbtVarInt(stack, nbtVar.RightCombo) != nbtVar.readNbtVarInt(stack, nbtVar.RightPreviousCombo) ||
nbtVar.readNbtVarInt(stack, nbtVar.LeftCombo) != nbtVar.readNbtVarInt(stack, nbtVar.LeftPreviousCombo))
{
nbtVar.writeNbtVar(stack, nbtVar.ActualCombo, 0);
}
if (nbtVar.readNbtVarInt(stack, nbtVar.RightCombo) != nbtVar.readNbtVarInt(stack, nbtVar.RightPreviousCombo))
{
nbtVar.writeNbtVar(stack, nbtVar.RightPreviousCombo, nbtVar.readNbtVarInt(stack, nbtVar.RightCombo));
}
if (nbtVar.readNbtVarInt(stack, nbtVar.LeftCombo) != nbtVar.readNbtVarInt(stack, nbtVar.LeftPreviousCombo))
{
nbtVar.writeNbtVar(stack, nbtVar.LeftPreviousCombo, nbtVar.readNbtVarInt(stack, nbtVar.LeftCombo));
}
}
}

[robin4002]

Tu l’utilises pour quoi ce timer ?

[Jodge]

J’utilise le tag “ActualTimer” qui est incrémenter de 1 chaque tick tan que l’un des deux tags (“RightClic” ou LeftClic") est différent de 0.

Lorsque mon tag “ActualTimer” est supérieur à ma Variable “comboTimer” (variable ce coup ci attention) alors tous mes tag sont ré-initialisé a 0 (et donc le timer ce désactive).

Si, au cour de l’un des itérations de mon Timer (d’ou la nécessité de l’effectuer chaque tic), un des deux tags “RightClic” ou LeftClic" est modifier (chose que je vérifie grâce aux tags “RightPreviousClic” et “LeftPreviousClic”), alors je ré-initialise mon tag “ActualTimer” le timer continue alors, mais le tag reprend la valeur 0.

Je ne sais pas si j’ai été assez clair ^^’

[robin4002]

Je ne vois pas d’autres façons de faire
Ce que tu peux par contre faire c’est actualisé ton time toutes les secondes au lieu de tous les ticks.

[Jodge]

Comment cas ? onUptade est appeler tout les ticks, comment je peu définir pour que ce ne soit que toute les minutes ?

[robin4002]

Ajoute dans ta classe deux variables :
private static final long start = System.currentTimeMillis() / 1000;
private static int seconds = 0
Ensuite dans ta fonction update :

if(seconds != (int)(System.currentTimeMillis() / 1000 - start))
{
// ton action ici, elle ne sera que faite toutes les secondes
seconds = (int)(System.currentTimeMillis() / 1000 - start);
}

C’est le moyen le plus propre pour faire ça.

[Jodge]

Je vien de relire mon code, et effectuer l’incrémentation chaque seconde n’es pas possible a cause de l’affichage (trop de latence).
Par contre, j’avoue avoir totalement oublier la classe System, et je dois pouvoir me baser sur le temps du syteme et faire le calcul à chaque fois plutôt que de me baser sur un tag qu’il faut re écrire à chaque fois. Je vais m’y pencher dessus ^^

EDIT :

​ public void onUpdate(ItemStack stack, World worldIn, Entity entityIn, int itemSlot, boolean isSelected)
{
if(stack.getTagCompound() == null)
        {
        stack.setTagCompound(new NBTTagCompound());

        stack.getTagCompound().setInteger("rC", 0); // Right Combo
        stack.getTagCompound().setInteger("rPC",0); // Right Previous Combo
        stack.getTagCompound().setInteger("lC", 0); // Left Combo
        stack.getTagCompound().setInteger("lPC", 0); // Left Previous Combo
        stack.getTagCompound().setInteger("aT",timer); // actualTimer
        }

if ((nbtVar.readNbtVarInt(stack, nbtVar.RightCombo) != 0) || (nbtVar.readNbtVarInt(stack, nbtVar.LeftCombo) != 0))
{

timer++;
if (timer < 0)
{
timer = 0;
}

int seconds = timer  - nbtVar.readNbtVarInt(stack, nbtVar.ActualCombo);

if(seconds >= this.comboTimer)
{
JFunction.write("### ### : " + seconds + " >= " + this.comboTimer + " ?");

nbtVar.writeNbtVar(stack, nbtVar.RightCombo, 0);
nbtVar.writeNbtVar(stack, nbtVar.LeftCombo, 0);
nbtVar.writeNbtVar(stack, nbtVar.ActualCombo, timer);
}
else if ( nbtVar.readNbtVarInt(stack, nbtVar.RightCombo) != nbtVar.readNbtVarInt(stack, nbtVar.RightPreviousCombo) || 
nbtVar.readNbtVarInt(stack, nbtVar.LeftCombo) != nbtVar.readNbtVarInt(stack, nbtVar.LeftPreviousCombo))
{
nbtVar.writeNbtVar(stack, nbtVar.ActualCombo, timer);
}
if (nbtVar.readNbtVarInt(stack, nbtVar.RightCombo) != nbtVar.readNbtVarInt(stack, nbtVar.RightPreviousCombo))
{
nbtVar.writeNbtVar(stack, nbtVar.RightPreviousCombo, nbtVar.readNbtVarInt(stack, nbtVar.RightCombo));
}
if (nbtVar.readNbtVarInt(stack, nbtVar.LeftCombo) != nbtVar.readNbtVarInt(stack, nbtVar.LeftPreviousCombo))
{
nbtVar.writeNbtVar(stack, nbtVar.LeftPreviousCombo, nbtVar.readNbtVarInt(stack, nbtVar.LeftCombo));
}
}
}

Grace à cette méthode, l’objet n’est pas ré-initialisé à chaque fois. Le seul problème viens de si le joueur joue plus de 2,147,483,647 tick non stop (à raison de 20 tick par seconde, sachant qu’il y a 86400 seconde dans une journée sa fait 17,280,000 de tick par jour, soit à peu près 124 jours non stop.)
Reste a voir si sa ne risque pas de poser de problème niveau serveurs (multi-activation).

[Jodge]

Le problème n’est malheureusement pas terminer X)

Le problème de serveurs semble avoir totalement disparut de par l’utilisation de nbtTags.

En revanche, un nouveau problème apparaît ^^’
Comme vous pouvez le voir sur le GIF animé (ou pas), l’affichage à lieu sur tout nouveaux objet, immédiatement et se fige. De plus, il y a un décalage des objets qui s’effectues lors du premier clic. Si j’effectue plusieurs clic, le problème est résolu tan que je reste sur cette objet. Dès que je change, c’est la même.

:::
Désoler pour vos yeux X)

:::

Voila les code concerner :
Classe JScreen (Classe d’affichage, qui est sans doute celle qui bug)
Classe JWeapons (Classe de base d’une armes)
JScythe (Classe étendu utilisé dans l’exemple)

Étrangement, si on observe le code, l’affichage est censé avoir lieu selon la valeurs du nbtTag, qui, par défaut, est initialisé a 0 (donc pas d’affichage). Chaque valeurs est ensuite correcte, sauf la premier fois…

help !

[robin4002]

Je vais récupérer les sources dans la soiré ou demain et je vais regarder ça.