Mauvaise Direction



  • Bonjour,

    Je Rencontre un Problème avec un bloc techne Qui Doit s’orienter dans la Direction du joueur.

    #Problème Détaillée(Problème Détaillée)

    J'ai voulu faire un bloc techne qui se tourne dans la direction du joueur mais le probleme c'est que le bloc se met dans la direction inverse. Je ne pensse pas m'être tromper de Face dans Techne j'ai pris la Face "F" pour l'avant.

    Voici un Screen :

    http://www.noelshack.com/2016-07-1455637259-2016-02-16-16-39-54.png

    Mes Codes:

    Bloc

    public class AutelFanta extends Block 
    {
    
    public AutelFanta(int i, Material material) 
    {
    super(material);
    this.setHarvestLevel("pickaxe", 3);
    this.setHardness(20.0F);
    this.setResistance(100.0F);
    this.setLightLevel(1.0F);
    this.setStepSound(soundTypeMetal);
    this.setBlockName("AutelFanta");
    this.setBlockTextureName(LaFrenchCraftMOD.MODID + ":AutelFanta");
    }
    
    @Override
       public TileEntity createTileEntity(World world, int metadata)
       {
           return new TileEntityAutelFanta();
       }
    
       @Override
       public boolean hasTileEntity(int metadata)
       {
           return true;
       }
    
       public boolean isOpaqueCube()
       {
           return false;
       }
    
       public boolean renderAsNormalBlock()
       {
           return false;
       }
    
       @SideOnly(Side.CLIENT)
       public int getRenderType()
       {
           return ProxyClient.tesrRenderId;
       }
       public void setBlockBoundsBasedOnState(IBlockAccess world, int x, int y, int z)
       {
           this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 2.3F, 1.0F);
       }
    
       public void onBlockPlacedBy(World world, int x, int y, int z, EntityLivingBase living, ItemStack stack)
       {
           if(stack.getItemDamage() == 0)
           {
               TileEntity tile = world.getTileEntity(x, y, z);
               if(tile instanceof TileEntityAutelFanta)
               {
                   int direction = MathHelper.floor_double((double)(living.rotationYaw * 4.0F / 360.0F) + 2.5D) & 3;
                   ((TileEntityAutelFanta)tile).setDirection((byte)direction);
               }
           }
       }
    
       @Override
           public boolean rotateBlock(World world, int x, int y, int z, ForgeDirection axis)
            {
               if((axis == ForgeDirection.UP || axis == ForgeDirection.DOWN) && !world.isRemote && world.getBlockMetadata(x, y, z) == 0)
                {
                    TileEntity tile = world.getTileEntity(x, y, z);
                    if(tile instanceof TileEntityAutelFanta)
                    {
                    TileEntityAutelFanta tileTuto = (TileEntityAutelFanta)tile;
    
                       byte direction = tileTuto.getDirection();
                      direction++;
                      if(direction > 3)
                        {
    
                           direction = 0;
                        }
    
                       tileTuto.setDirection(direction);
                        return true;
                    }
                }
                return false;
            }
    
           public ForgeDirection[] getValidRotations(World world, int x, int y, int z)
           {
              return world.getBlockMetadata(x, y, z) == 0 ? new ForgeDirection[] {ForgeDirection.UP, ForgeDirection.DOWN} : ForgeDirection.VALID_DIRECTIONS;
           }
    
    }
    
    

    #Tile Entity du bloc & Special Renderer(Tile Entity du bloc & Special Renderer)

    public class TileEntityAutelFanta extends TileEntity
    {
     private byte direction;
    
          @Override
          public void readFromNBT(NBTTagCompound compound)
          {
              super.readFromNBT(compound);
    
             this.direction = compound.getByte("Direction");
          }
    
          @Override
          public void writeToNBT(NBTTagCompound compound)
          {
              super.writeToNBT(compound);
    
             compound.setByte("Direction", this.direction);
          }
    
         public byte getDirection()
          {
    
             return direction;
          }
    
         public void setDirection(byte direction)
          {
    
             this.direction = direction;
             this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord);
          }
    
         public Packet getDescriptionPacket()
          {
             NBTTagCompound nbttagcompound = new NBTTagCompound();
             this.writeToNBT(nbttagcompound);
             return new S35PacketUpdateTileEntity(this.xCoord, this.yCoord, this.zCoord, 0, nbttagcompound);
         }
    
       public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity pkt)
         {
             this.readFromNBT(pkt.func_148857_g());
             this.worldObj.markBlockRangeForRenderUpdate(this.xCoord, this.yCoord, this.zCoord, this.xCoord, this.yCoord, this.zCoord);
          }
    }
    
    
    public class TileEntityAutelFantaSpecialRenderer extends TileEntitySpecialRenderer 
    {
    
       public static AutelFantaOffModel model = new AutelFantaOffModel();
       public static ResourceLocation texture = new ResourceLocation(LaFrenchCraftMOD.MODID, "textures/models/blocks/AutelFantaOffModel.png");
    
     @Override
       public void renderTileEntityAt(TileEntity tile, double x, double y, double z, float partialRenderTick) // la fonction qui était la de base
       {
           this.renderTileEntityAutelFantaAt((TileEntityAutelFanta)tile, x, y, z, partialRenderTick); // j'appelle ma fonction renderTileEntityTutorielAt en castant TileEntityTutoriel à l'argument tile
       }
    
       private void renderTileEntityAutelFantaAt(TileEntityAutelFanta tile, double x, double y, double z, float partialRenderTick) // ma propre fonction
       {
        GL11.glPushMatrix(); // ouvre une matrix
            GL11.glTranslated(x + 0.5D, y + 1.5D, z + 0.5D); // déplace le bloc sur les coordonnés et le centre
            GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F); // met droit le bloc (par défaut il est à  l'envers)
            GL11.glRotatef(90F * tile.getDirection(), 0.0F, 1.0F, 0.0F);
            this.bindTexture(texture); // affiche la texture
            model.renderAll(); // rend le modèle
            GL11.glPopMatrix(); // ferme la matrix
       }
    
    }
    
    


  • GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F); // met droit le bloc (par défaut il est à l'envers), si le bloc est à l'envers au lieu d'être droit, retire cette ligne.



  • @'AymericRed':

    GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F); // met droit le bloc (par défaut il est à  l'envers), si le bloc est à l'envers au lieu d'être droit, retire cette ligne.

    Non cette ligne mais le bloc a l'endroit en le mettant sur le sol Je sais pas si c'est clair ^^ mais sans cette ligne le bloc est dans les air la tête a l'envert ^^



  • Ah okay ^^

    Je m'y connaît pas trop en openGl mais le "90F * tile.getDirection()", si t'enlève le 90F ?



  • @'AymericRed':

    Ah okay ^^

    Je m'y connaît pas trop en openGl mais le "90F * tile.getDirection()", si t'enlève le 90F ?

    Le 90F * tile.getDirection() fais parti du bonus du tuto de robin sur créé un bloc techne et se qui est bizarre c'est que j'ai créer d'autre bloc avec le même code et aucun problème



  • C'est donc le modèle qui doit être dans le mauvais sens, si quelqu'un connaît la fonction pour rotate horizontalement ?



  • Horizontalement ? C'est à dire ?
    Pour tourner vers le joueur c'est l'axe Y



  • @'AymericRed':

    C'est donc le modèle qui doit être dans le mauvais sens, si quelqu'un connaît la fonction pour rotate horizontalement ?

    Bas la face de devant c'est bien le F dans techne ?



  • Aucune idée, de toute façon avec Techne il faut toujours corriger deriière, au pire tu rajoutes juste un GL11.glRotatef(90F, 0F, 1F, 0F) avant



  • Fais ce qu'à dit scarex, et oui c'est bien F la face de devant.


  • Administrateurs

    S'il est dans le sens inverse tu as juste à faire un :
    GL11.glRotatef(180F, 0.0F, 1.0F, 0.0F);
    avant la fonction render.



  • Merci sa marche niquel ^^