5. Passer le rayTrace en ServerSide

Passer le rayTrace en ServerSide

  • Correcteurs

    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.

    0
  • Administrateurs

    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);
        }
    }
    0
  • Correcteurs

    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

    0
  • Administrateurs

    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

    0
  • Correcteurs

    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)
    0
  • Administrateurs

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

    0
  • Correcteurs

    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

    0
1.7.10 2079
Log in to reply