• S'inscrire
    • Se connecter
    • Recherche
    • Récent
    • Mots-clés
    • Populaire
    • Utilisateurs
    • Groupes

    Résolu Passer le rayTrace en ServerSide

    1.7.x
    1.7.10
    2
    7
    1415
    Charger plus de messages
    • Du plus ancien au plus récent
    • Du plus récent au plus ancien
    • Les plus votés
    Répondre
    • Répondre à l'aide d'un nouveau sujet
    Se connecter pour répondre
    Ce sujet a été supprimé. Seuls les utilisateurs avec les droits d'administration peuvent le voir.
    • Folgansky
      Folgansky Correcteurs dernière édition par

      Pas envie d’un packet pour détecter le mop de mon rayTrace, on m’a dis de creuser pour voir ce qui constituait la fonction pour voir si il ne serait pas possible de le faire exécuter côté serveur également, mais je rencontre des obstacles (de novice possiblement d’ailleurs)

      Voici où j’en suis arrivé:

      package fr.powergame.modpg2.common.items.weapons;
      
      import fr.powergame.modpg2.common.entities.munitions.EntityGrenadeLauncher;
      import net.minecraft.entity.Entity;
      import net.minecraft.entity.player.EntityPlayer;
      import net.minecraft.item.Item;
      import net.minecraft.item.ItemStack;
      import net.minecraft.util.MathHelper;
      import net.minecraft.util.MovingObjectPosition;
      import net.minecraft.util.MovingObjectPosition.MovingObjectType;
      import net.minecraft.util.Vec3;
      import net.minecraft.world.World;
      
      public class ItemAirStrike extends Item
      {
          public World worldObj;
          public double posX;
          public double posY;
          public double posZ;
          public double prevPosX;
          public double prevPosY;
          public double prevPosZ;
          public float rotationPitch;
          public float prevRotationYaw;
          public float prevRotationPitch;
          public float rotationYaw;
      
          public ItemAirStrike()
          {
              this.setMaxStackSize(1);
          }
      
          @Override
          public boolean onItemUse(ItemStack stack, EntityPlayer player, World world, int x, int y, int z, int side, float hitX, float hitY, float hitZ)
          {
                      spawnGrenadeInWorld(world, mov.blockX, mov.blockY + 10D, mov.blockZ);
      
              return true;
          }
      
          @Override
          public ItemStack onItemRightClick(ItemStack stack, World world, EntityPlayer player)
          {
      //        MovingObjectPosition mov = player.rayTrace(50D, 10);
               MovingObjectPosition mov = player.rayTraceServer(50D, 10);
              if(mov != null && mov.typeOfHit == MovingObjectType.BLOCK && !world.isRemote)
              {
                  if(mov.blockX != player.posX)
                      spawnGrenadeInWorld(world, mov.blockX, mov.blockY + 10D, mov.blockZ);
              }
              return stack;
          }
      
          public MovingObjectPosition rayTraceServer(double range, float partialTickTime)
          {
              Vec3 vec3 = this.getPositionServer(partialTickTime);
              Vec3 vec31 = this.getLookServer(partialTickTime);
              Vec3 vec32 = vec3.addVector(vec31.xCoord * range, vec31.yCoord * range, vec31.zCoord * range);
              return this.worldObj.func_147447_a(vec3, vec32, false, false, true);
          }
      
          public Vec3 getLookServer(float p_70676_1_)
          {
              float f1;
              float f2;
              float f3;
              float f4;
      
              if(p_70676_1_ == 1.0F)
              {
                  f1 = MathHelper.cos(-this.rotationYaw * 0.017453292F - (float)Math.PI);
                  f2 = MathHelper.sin(-this.rotationYaw * 0.017453292F - (float)Math.PI);
                  f3 = -MathHelper.cos(-this.rotationPitch * 0.017453292F);
                  f4 = MathHelper.sin(-this.rotationPitch * 0.017453292F);
                  return Vec3.createVectorHelper(f2 * f3, f4, f1 * f3);
              }
              else
              {
                  f1 = this.prevRotationPitch + (this.rotationPitch - this.prevRotationPitch) * p_70676_1_;
                  f2 = this.prevRotationYaw + (this.rotationYaw - this.prevRotationYaw) * p_70676_1_;
                  f3 = MathHelper.cos(-f2 * 0.017453292F - (float)Math.PI);
                  f4 = MathHelper.sin(-f2 * 0.017453292F - (float)Math.PI);
                  float f5 = -MathHelper.cos(-f1 * 0.017453292F);
                  float f6 = MathHelper.sin(-f1 * 0.017453292F);
                  return Vec3.createVectorHelper(f4 * f5, f6, f3 * f5);
              }
          }
      
          public Vec3 getPositionServer(float p_70666_1_)
          {
              if(p_70666_1_ == 1.0F)
              {
                  return Vec3.createVectorHelper(this.posX, this.posY, this.posZ);
              }
              else
              {
                  double d0 = this.prevPosX + (this.posX - this.prevPosX) * p_70666_1_;
                  double d1 = this.prevPosY + (this.posY - this.prevPosY) * p_70666_1_;
                  double d2 = this.prevPosZ + (this.posZ - this.prevPosZ) * p_70666_1_;
                  return Vec3.createVectorHelper(d0, d1, d2);
              }
          }
      
          public void spawnGrenadeInWorld(World worldIn, double x, double y, double z)
          {
              Entity entity;
              entity = new EntityGrenadeLauncher(worldIn, x, y, z);
              worldIn.spawnEntityInWorld(entity);
          }
      }
      

      Quand j’essaie de passer par ma fonction “rayTraceServer” ça me demande de cast la variable player et comme ça me met l’itemstack… Je me dis que j’ai bien merdé dans mon approche x] Maintenant savoir où et comment faire mieux, je m’en remets à vos conseils et pistes.

      1 réponse Dernière réponse Répondre Citer 0
      • robin4002
        robin4002 Moddeurs confirmés Rédacteurs Administrateurs dernière édition par

        En fait comme de base la fonction que tu as reprit était dans la classe EntityPlayer, tous les this. devrait être remplacé par un joueur :

            @Override
            public ItemStack onItemRightClick(ItemStack stack, World world, EntityPlayer player)
            {
        //        MovingObjectPosition mov = player.rayTrace(50D, 10);
                 MovingObjectPosition mov = this.rayTraceServer(player, 50D, 10);
                if(mov != null && mov.typeOfHit == MovingObjectType.BLOCK && !world.isRemote)
                {
                    if(mov.blockX != player.posX)
                        spawnGrenadeInWorld(world, mov.blockX, mov.blockY + 10D, mov.blockZ);
                }
                return stack;
            }
        
            public MovingObjectPosition rayTraceServer(EntityPlayer player, double range, float partialTickTime)
            {
                Vec3 vec3 = this.getPositionServer(player, partialTickTime);
                Vec3 vec31 = this.getLookServer(player, partialTickTime);
                Vec3 vec32 = vec3.addVector(vec31.xCoord * range, vec31.yCoord * range, vec31.zCoord * range);
                return player.worldObj.func_147447_a(vec3, vec32, false, false, true);
            }
        
            public Vec3 getLookServer(EntityPlayer player, float p_70676_1_)
            {
                float f1;
                float f2;
                float f3;
                float f4;
        
                if(p_70676_1_ == 1.0F)
                {
                    f1 = MathHelper.cos(-player.rotationYaw * 0.017453292F - (float)Math.PI);
                    f2 = MathHelper.sin(-player.rotationYaw * 0.017453292F - (float)Math.PI);
                    f3 = -MathHelper.cos(-player.rotationPitch * 0.017453292F);
                    f4 = MathHelper.sin(-player.rotationPitch * 0.017453292F);
                    return Vec3.createVectorHelper(f2 * f3, f4, f1 * f3);
                }
                else
                {
                    f1 = player.prevRotationPitch + (player.rotationPitch - player.prevRotationPitch) * p_70676_1_;
                    f2 = player.prevRotationYaw + (player.rotationYaw - player.prevRotationYaw) * p_70676_1_;
                    f3 = MathHelper.cos(-f2 * 0.017453292F - (float)Math.PI);
                    f4 = MathHelper.sin(-f2 * 0.017453292F - (float)Math.PI);
                    float f5 = -MathHelper.cos(-f1 * 0.017453292F);
                    float f6 = MathHelper.sin(-f1 * 0.017453292F);
                    return Vec3.createVectorHelper(f4 * f5, f6, f3 * f5);
                }
            }
        
            public Vec3 getPositionServer(EntityPlayer player, float p_70666_1_)
            {
                if(p_70666_1_ == 1.0F)
                {
                    return Vec3.createVectorHelper(player.posX, player.posY, player.posZ);
                }
                else
                {
                    double d0 = player.prevPosX + (player.posX - player.prevPosX) * p_70666_1_;
                    double d1 = player.prevPosY + (player.posY - player.prevPosY) * p_70666_1_;
                    double d2 = player.prevPosZ + (player.posZ - player.prevPosZ) * p_70666_1_;
                    return Vec3.createVectorHelper(d0, d1, d2);
                }
            }
        
        1 réponse Dernière réponse Répondre Citer 0
        • Folgansky
          Folgansky Correcteurs dernière édition par

          Ouki, ça semble plutôt bien fonctionner.

          J’ai tilté un moment car l’entité était tout le temps créée au dessus de ma tête. En fait tant que je vise un bloc qui est au niveau de mes pieds ça fait ça, si je vise sur quelque chose de plus haut ou plus bas ça spawn bien de l’autre côté (sous réserve de tester ça sur serveur)

          Un idée d’où ça vient car faire:

          if(mov.blockY != player.posY)
          

          ne change pas grand chose, pour dire rien

          1 réponse Dernière réponse Répondre Citer 0
          • robin4002
            robin4002 Moddeurs confirmés Rédacteurs Administrateurs dernière édition par

            mov.blockY est surement un int et player.posY est un double.
            Donc peut de chance qu’il soit égaux.
            Faudrait arrondir la valeur de player.posY

            1 réponse Dernière réponse Répondre Citer 0
            • Folgansky
              Folgansky Correcteurs dernière édition par

              Ouki, c’est parfait, je passe en résolu, merci pour ce bon gros coup de pouce niveau rayTrace.

              Ps pour les autres: la condition ressemblera à ça:

              if(mov.blockY != (int)player.posY - 1)
              
              1 réponse Dernière réponse Répondre Citer 0
              • robin4002
                robin4002 Moddeurs confirmés Rédacteurs Administrateurs dernière édition par

                MathHelper.floor_double(player.posY)
                aurait été mieux.

                1 réponse Dernière réponse Répondre Citer 0
                • Folgansky
                  Folgansky Correcteurs dernière édition par

                  D’acc je fais comme ça.

                  Petit soucis avec cette condition maintenant x]

                  Quand on vise un point plus haut que le joueur tout est ok, mais quand on vise un point en contre-bas les deux valeurs sont égales (bien qu’on vise un point situé plus bas…)

                  edit1: Une solution est de sauter… Mais ça reste bizarre et pas du tout évident pour un joueur qui ne sait pas.
                  edit2: en bordure de bloc les coordonnées sont enfin différentes, mais pareil que edit1, c’pas évident à comprendre

                  Edit final: tout semble bien fonctionner côté serveur

                  1 réponse Dernière réponse Répondre Citer 0
                  • 1 / 1
                  • Premier message
                    Dernier message
                  Design by Woryk
                  Contact / Mentions Légales

                  MINECRAFT FORGE FRANCE © 2018

                  Powered by NodeBB