• Salut,
    Je reviens avec mon vélo pour le finaliser.
    Actuellement, quand je le pose, il spawn environ 1/4 de block au dessus de sol puis tombe et s’enfonce dans le sol à hauteur d’un block.
    J’aimerais votre aide pour le modifier afin qu’il reste sur le sol, que le joueur soit correctement placé lorsqu’il monte dessus et qu’il puisse le controler.
    Ce sont les codes du bateau, je voudrais également changer le hitbox.
    Voici l’entité:
    :::

    package com.namilowarus.phase.bike;
    
    import java.util.List;
    
    import com.namilowarus.phase.PhaseMod;
    import cpw.mods.fml.relauncher.Side;
    import cpw.mods.fml.relauncher.SideOnly;
    import net.minecraft.block.Block;
    import net.minecraft.block.material.Material;
    import net.minecraft.entity.Entity;
    import net.minecraft.entity.EntityLivingBase;
    import net.minecraft.entity.player.EntityPlayer;
    import net.minecraft.init.Blocks;
    import net.minecraft.init.Items;
    import net.minecraft.item.Item;
    import net.minecraft.nbt.NBTTagCompound;
    import net.minecraft.util.AxisAlignedBB;
    import net.minecraft.util.DamageSource;
    import net.minecraft.util.MathHelper;
    import net.minecraft.world.World;
    
    public class EntityBike extends Entity{
    
    /** true if no player in boat */
    private boolean isBoatEmpty;
    private double speedMultiplier;
    private int boatPosRotationIncrements;
    private double boatX;
    private double boatY;
    private double boatZ;
    private double boatYaw;
    private double boatPitch;
    @SideOnly(Side.CLIENT)
    private double velocityX;
    @SideOnly(Side.CLIENT)
    private double velocityY;
    @SideOnly(Side.CLIENT)
    private double velocityZ;
    private static final String __OBFID = "CL_00001667";
    
    public EntityBike(World p_i1704_1_)
    {
    super(p_i1704_1_);
    this.isBoatEmpty = true;
    this.speedMultiplier = 0.07D;
    this.preventEntitySpawning = true;
    this.setSize(1.5F, 0.6F);
    this.yOffset = this.height * 1.5F;
    }
    
    /**
    * 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;
    }
    
    protected void entityInit()
    {
    this.dataWatcher.addObject(17, new Integer(0));
    this.dataWatcher.addObject(18, new Integer(1));
    this.dataWatcher.addObject(19, new Float(0.0F));
    }
    
    public EntityBike setboundingBox() {
    return this;
    }
    
    /**
    * Returns a boundingBox used to collide the entity with other entities and blocks. This enables the entity to be
    * pushable on contact, like boats or minecarts.
    */
    @Override
    public AxisAlignedBB getCollisionBox(Entity p_70114_1_)
    {
    return p_70114_1_.boundingBox;
    }
    
    /**
    * returns the bounding box for this entity
    */
    @Override
    public AxisAlignedBB getBoundingBox()
    {
    return this.boundingBox;
    }
    
    /**
    * Returns true if this entity should push and be pushed by other entities when colliding.
    */
    public boolean canBePushed()
    {
    return true;
    }
    
    public EntityBike(World p_i1705_1_, double p_i1705_2_, double p_i1705_4_, double p_i1705_6_)
    {
    this(p_i1705_1_);
    this.setPosition(p_i1705_2_, p_i1705_4_ + (double)this.yOffset, p_i1705_6_);
    this.motionX = 0.0D;
    this.motionY = 0.0D;
    this.motionZ = 0.0D;
    this.prevPosX = p_i1705_2_;
    this.prevPosY = p_i1705_4_;
    this.prevPosZ = p_i1705_6_;
    }
    /**
    * Called when the entity is attacked.
    */
    public boolean attackEntityFrom(DamageSource p_70097_1_, float p_70097_2_)
    {
    if (this.isEntityInvulnerable())
    {
    return false;
    }
    else if (!this.worldObj.isRemote && !this.isDead)
    {
    this.setForwardDirection(-this.getForwardDirection());
    this.setTimeSinceHit(10);
    this.setDamageTaken(this.getDamageTaken() + p_70097_2_ * 10.0F);
    this.setBeenAttacked();
    boolean flag = p_70097_1_.getEntity() instanceof EntityPlayer && ((EntityPlayer)p_70097_1_.getEntity()).capabilities.isCreativeMode;
    
    if (flag || this.getDamageTaken() > 40.0F)
    {
    if (this.riddenByEntity != null)
    {
    this.riddenByEntity.mountEntity(this);
    }
    
    if (!flag)
    {
    this.func_145778_a(PhaseMod.itemBike, 1, 0.0F);
    }
    
    this.setDead();
    }
    
    return true;
    }
    else
    {
    return true;
    }
    }
    
    /**
    * Setups the entity to do the hurt animation. Only used by packets in multiplayer.
    */
    @SideOnly(Side.CLIENT)
    public void performHurtAnimation()
    {
    this.setForwardDirection(-this.getForwardDirection());
    this.setTimeSinceHit(10);
    this.setDamageTaken(this.getDamageTaken() * 11.0F);
    }
    
    /**
    * Returns true if other Entities should be prevented from moving through this Entity.
    */
    public boolean canBeCollidedWith()
    {
    return true;
    }
    
    /**
    * Sets the position and rotation. Only difference from the other one is no bounding on the rotation. Args: posX,
    * posY, posZ, yaw, pitch
    */
    @SideOnly(Side.CLIENT)
    public void setPositionAndRotation2(double p_70056_1_, double p_70056_3_, double p_70056_5_, float p_70056_7_, float p_70056_8_, int p_70056_9_)
    {
    if (this.isBoatEmpty)
    {
    this.boatPosRotationIncrements = p_70056_9_ + 5;
    }
    else
    {
    double d3 = p_70056_1_ - this.posX;
    double d4 = p_70056_3_ - this.posY;
    double d5 = p_70056_5_ - this.posZ;
    double d6 = d3 * d3 + d4 * d4 + d5 * d5;
    
    if (d6 <= 1.0D)
    {
    return;
    }
    
    this.boatPosRotationIncrements = 3;
    }
    
    this.boatX = p_70056_1_;
    this.boatY = p_70056_3_;
    this.boatZ = p_70056_5_;
    this.boatYaw = (double)p_70056_7_;
    this.boatPitch = (double)p_70056_8_;
    this.motionX = this.velocityX;
    this.motionY = this.velocityY;
    this.motionZ = this.velocityZ;
    }
    
    /**
    * Sets the velocity to the args. Args: x, y, z
    */
    @SideOnly(Side.CLIENT)
    public void setVelocity(double p_70016_1_, double p_70016_3_, double p_70016_5_)
    {
    this.velocityX = this.motionX = p_70016_1_;
    this.velocityY = this.motionY = p_70016_3_;
    this.velocityZ = this.motionZ = p_70016_5_;
    }
    
    /**
    * Called to update the entity's position/logic.
    */
    public void onUpdate()
    {
    super.onUpdate();
    
    if (this.getTimeSinceHit() > 0)
    {
    this.setTimeSinceHit(this.getTimeSinceHit() - 1);
    }
    
    if (this.getDamageTaken() > 0.0F)
    {
    this.setDamageTaken(this.getDamageTaken() - 1.0F);
    }
    
    this.prevPosX = this.posX;
    this.prevPosY = this.posY;
    this.prevPosZ = this.posZ;
    byte b0 = 5;
    double d0 = 0.0D;
    
    for (int i = 0; i < b0; ++i)
    {
    double d1 = this.boundingBox.minY + (this.boundingBox.maxY - this.boundingBox.minY) * (double)(i + 0) / (double)b0 - 0.125D;
    double d3 = this.boundingBox.minY + (this.boundingBox.maxY - this.boundingBox.minY) * (double)(i + 1) / (double)b0 - 0.125D;
    AxisAlignedBB axisalignedbb = AxisAlignedBB.getBoundingBox(this.boundingBox.minX, d1, this.boundingBox.minZ, this.boundingBox.maxX, d3, this.boundingBox.maxZ);
    }
    
    double d10 = Math.sqrt(this.motionX * this.motionX + this.motionZ * this.motionZ);
    double d2;
    double d4;
    int j;
    
    if (d10 > 0.26249999999999996D)
    {
    d2 = Math.cos((double)this.rotationYaw * Math.PI / 180.0D);
    d4 = Math.sin((double)this.rotationYaw * Math.PI / 180.0D);
    
    for (j = 0; (double)j < 1.0D + d10 * 60.0D; ++j)
    {
    double d5 = (double)(this.rand.nextFloat() * 2.0F - 1.0F);
    double d6 = (double)(this.rand.nextInt(2) * 2 - 1) * 0.7D;
    double d8;
    double d9;
    
    if (this.rand.nextBoolean())
    {
    d8 = this.posX - d2 * d5 * 0.8D + d4 * d6;
    d9 = this.posZ - d4 * d5 * 0.8D - d2 * d6;
    this.worldObj.spawnParticle("splash", d8, this.posY - 0.125D, d9, this.motionX, this.motionY, this.motionZ);
    }
    else
    {
    d8 = this.posX + d2 + d4 * d5 * 0.7D;
    d9 = this.posZ + d4 - d2 * d5 * 0.7D;
    this.worldObj.spawnParticle("splash", d8, this.posY - 0.125D, d9, this.motionX, this.motionY, this.motionZ);
    }
    }
    }
    
    double d11;
    double d12;
    
    if (this.worldObj.isRemote && this.isBoatEmpty)
    {
    if (this.boatPosRotationIncrements > 0)
    {
    d2 = this.posX + (this.boatX - this.posX) / (double)this.boatPosRotationIncrements;
    d4 = this.posY + (this.boatY - this.posY) / (double)this.boatPosRotationIncrements;
    d11 = this.posZ + (this.boatZ - this.posZ) / (double)this.boatPosRotationIncrements;
    d12 = MathHelper.wrapAngleTo180_double(this.boatYaw - (double)this.rotationYaw);
    this.rotationYaw = (float)((double)this.rotationYaw + d12 / (double)this.boatPosRotationIncrements);
    this.rotationPitch = (float)((double)this.rotationPitch + (this.boatPitch - (double)this.rotationPitch) / (double)this.boatPosRotationIncrements);
    –this.boatPosRotationIncrements;
    this.setPosition(d2, d4, d11);
    this.setRotation(this.rotationYaw, this.rotationPitch);
    }
    else
    {
    d2 = this.posX + this.motionX;
    d4 = this.posY + this.motionY;
    d11 = this.posZ + this.motionZ;
    this.setPosition(d2, d4, d11);
    
    if (this.onGround)
    {
    this.motionX *= 0.5D;
    this.motionY *= 0.5D;
    this.motionZ *= 0.5D;
    }
    
    this.motionX *= 0.9900000095367432D;
    this.motionY *= 0.949999988079071D;
    this.motionZ *= 0.9900000095367432D;
    }
    }
    else
    {
    if (d0 < 1.0D)
    {
    d2 = d0 * 2.0D - 1.0D;
    this.motionY += 0.03999999910593033D * d2;
    }
    else
    {
    if (this.motionY < 0.0D)
    {
    this.motionY /= 2.0D;
    }
    
    this.motionY += 0.007000000216066837D;
    }
    
    if (this.riddenByEntity != null && this.riddenByEntity instanceof EntityLivingBase)
    {
    EntityLivingBase entitylivingbase = (EntityLivingBase)this.riddenByEntity;
    float f = this.riddenByEntity.rotationYaw + -entitylivingbase.moveStrafing * 90.0F;
    this.motionX += -Math.sin((double)(f * (float)Math.PI / 180.0F)) * this.speedMultiplier * (double)entitylivingbase.moveForward * 0.05000000074505806D;
    this.motionZ += Math.cos((double)(f * (float)Math.PI / 180.0F)) * this.speedMultiplier * (double)entitylivingbase.moveForward * 0.05000000074505806D;
    }
    
    d2 = Math.sqrt(this.motionX * this.motionX + this.motionZ * this.motionZ);
    
    if (d2 > 0.35D)
    {
    d4 = 0.35D / d2;
    this.motionX *= d4;
    this.motionZ *= d4;
    d2 = 0.35D;
    }
    
    if (d2 > d10 && this.speedMultiplier < 0.35D)
    {
    this.speedMultiplier += (0.35D - this.speedMultiplier) / 35.0D;
    
    if (this.speedMultiplier > 0.35D)
    {
    this.speedMultiplier = 0.35D;
    }
    }
    else
    {
    this.speedMultiplier -= (this.speedMultiplier - 0.07D) / 35.0D;
    
    if (this.speedMultiplier < 0.07D)
    {
    this.speedMultiplier = 0.07D;
    }
    }
    
    int l;
    
    for (l = 0; l < 4; ++l)
    {
    int i1 = MathHelper.floor_double(this.posX + ((double)(l % 2) - 0.5D) * 0.8D);
    j = MathHelper.floor_double(this.posZ + ((double)(l / 2) - 0.5D) * 0.8D);
    
    for (int j1 = 0; j1 < 2; ++j1)
    {
    int k = MathHelper.floor_double(this.posY) + j1;
    Block block = this.worldObj.getBlock(i1, k, j);
    
    if (block == Blocks.snow_layer)
    {
    this.worldObj.setBlockToAir(i1, k, j);
    this.isCollidedHorizontally = false;
    }
    else if (block == Blocks.waterlily)
    {
    this.worldObj.func_147480_a(i1, k, j, true);
    this.isCollidedHorizontally = false;
    }
    }
    }
    
    if (this.onGround)
    {
    this.motionX *= 0.5D;
    this.motionY *= 0.5D;
    this.motionZ *= 0.5D;
    }
    
    this.moveEntity(this.motionX, this.motionY, this.motionZ);
    
    if (this.isCollidedHorizontally && d10 > 0.2D)
    {
    if (!this.worldObj.isRemote && !this.isDead)
    {
    this.setDead();
    
    this.func_145778_a(PhaseMod.itemBike, 1, 0.0F);
    }
    }
    else
    {
    this.motionX *= 0.9900000095367432D;
    this.motionY *= 0.949999988079071D;
    this.motionZ *= 0.9900000095367432D;
    }
    
    this.rotationPitch = 0.0F;
    d4 = (double)this.rotationYaw;
    d11 = this.prevPosX - this.posX;
    d12 = this.prevPosZ - this.posZ;
    
    if (d11 * d11 + d12 * d12 > 0.001D)
    {
    d4 = (double)((float)(Math.atan2(d12, d11) * 180.0D / Math.PI));
    }
    
    double d7 = MathHelper.wrapAngleTo180_double(d4 - (double)this.rotationYaw);
    
    if (d7 > 20.0D)
    {
    d7 = 20.0D;
    }
    
    if (d7 < -20.0D)
    {
    d7 = -20.0D;
    }
    
    this.rotationYaw = (float)((double)this.rotationYaw + d7);
    this.setRotation(this.rotationYaw, this.rotationPitch);
    
    if (!this.worldObj.isRemote)
    {
    List list = this.worldObj.getEntitiesWithinAABBExcludingEntity(this, this.boundingBox.expand(0.20000000298023224D, 0.0D, 0.20000000298023224D));
    
    if (list != null && !list.isEmpty())
    {
    for (int k1 = 0; k1 < list.size(); ++k1)
    {
    Entity entity = (Entity)list.get(k1);
    
    if (entity != this.riddenByEntity && entity.canBePushed() && entity instanceof EntityBike)
    {
    entity.applyEntityCollision(this);
    }
    }
    }
    
    if (this.riddenByEntity != null && this.riddenByEntity.isDead)
    {
    this.riddenByEntity = null;
    }
    }
    }
    }
    
    public void updateRiderPosition()
    {
    if (this.riddenByEntity != null)
    {
    double d0 = Math.cos((double)this.rotationYaw * Math.PI / 180.0D) * 0.4D;
    double d1 = Math.sin((double)this.rotationYaw * Math.PI / 180.0D) * 0.4D;
    this.riddenByEntity.setPosition(this.posX + d0, this.posY + this.getMountedYOffset() + this.riddenByEntity.getYOffset(), this.posZ + d1);
    }
    }
    
    /**
    * (abstract) Protected helper method to write subclass entity data to NBT.
    */
    protected void writeEntityToNBT(NBTTagCompound p_70014_1_) {}
    
    /**
    * (abstract) Protected helper method to read subclass entity data from NBT.
    */
    protected void readEntityFromNBT(NBTTagCompound p_70037_1_) {}
    
    @SideOnly(Side.CLIENT)
    public float getShadowSize()
    {
    return 0.0F;
    }
    
    /**
    * First layer of player interaction
    */
    public boolean interactFirst(EntityPlayer p_130002_1_)
    {
    if (this.riddenByEntity != null && this.riddenByEntity instanceof EntityPlayer && this.riddenByEntity != p_130002_1_)
    {
    return true;
    }
    else
    {
    if (!this.worldObj.isRemote)
    {
    p_130002_1_.mountEntity(this);
    }
    
    return true;
    }
    }
    
    /**
    * Takes in the distance the entity has fallen this tick and whether its on the ground to update the fall distance
    * and deal fall damage if landing on the ground. Args: distanceFallenThisTick, onGround
    */
    protected void updateFallState(double p_70064_1_, boolean p_70064_3_)
    {
    int i = MathHelper.floor_double(this.posX);
    int j = MathHelper.floor_double(this.posY);
    int k = MathHelper.floor_double(this.posZ);
    
    if (p_70064_3_)
    {
    if (this.fallDistance > 3.0F)
    {
    this.fall(this.fallDistance);
    
    if (!this.worldObj.isRemote && !this.isDead)
    {
    this.setDead();
    this.func_145778_a(PhaseMod.itemBike, 1, 0.0F);
    }
    
    this.fallDistance = 0.0F;
    }
    }
    else if (this.worldObj.getBlock(i, j - 1, k).getMaterial() != Material.water && p_70064_1_ < 0.0D)
    {
    this.fallDistance = (float)((double)this.fallDistance - p_70064_1_);
    }
    }
    
    /**
    * Sets the damage taken from the last hit.
    */
    public void setDamageTaken(float p_70266_1_)
    {
    this.dataWatcher.updateObject(19, Float.valueOf(p_70266_1_));
    }
    
    /**
    * Gets the damage taken from the last hit.
    */
    public float getDamageTaken()
    {
    return this.dataWatcher.getWatchableObjectFloat(19);
    }
    
    /**
    * Sets the time to count down from since the last time entity was hit.
    */
    public void setTimeSinceHit(int p_70265_1_)
    {
    this.dataWatcher.updateObject(17, Integer.valueOf(p_70265_1_));
    }
    
    /**
    * Gets the time since the last hit.
    */
    public int getTimeSinceHit()
    {
    return this.dataWatcher.getWatchableObjectInt(17);
    }
    
    /**
    * Sets the forward direction of the entity.
    */
    public void setForwardDirection(int p_70269_1_)
    {
    this.dataWatcher.updateObject(18, Integer.valueOf(p_70269_1_));
    }
    
    /**
    * Gets the forward direction of the entity.
    */
    public int getForwardDirection()
    {
    return this.dataWatcher.getWatchableObjectInt(18);
    }
    
    /**
    * true if no player in boat
    */
    @SideOnly(Side.CLIENT)
    public void setIsBoatEmpty(boolean p_70270_1_)
    {
    this.isBoatEmpty = p_70270_1_;
    }
    
    }
    
    

    :::


  • Conseil : quand tu fais un copié-collé, penses à supprimer tout ce dont tu n’as pas besoin et à refaire le code comme tu veux en changeant le nom des paramètres par exemple (car à ce que je vois, ton vélo fait des particules d’eau, non ?)

    Je pense que le problème vient de là : (je suis pas sûr car le code est pas très compréhensible)

    
    if (this.worldObj.isRemote && this.isBoatEmpty)
    {
    if (this.boatPosRotationIncrements > 0)
    {
    d2 = this.posX + (this.boatX - this.posX) / (double)this.boatPosRotationIncrements;
    d4 = this.posY + (this.boatY - this.posY) / (double)this.boatPosRotationIncrements;
    d11 = this.posZ + (this.boatZ - this.posZ) / (double)this.boatPosRotationIncrements;
    d12 = MathHelper.wrapAngleTo180_double(this.boatYaw - (double)this.rotationYaw);
    this.rotationYaw = (float)((double)this.rotationYaw + d12 / (double)this.boatPosRotationIncrements);
    this.rotationPitch = (float)((double)this.rotationPitch + (this.boatPitch - (double)this.rotationPitch) / (double)this.boatPosRotationIncrements);
    –this.boatPosRotationIncrements;
    this.setPosition(d2, d4, d11);
    this.setRotation(this.rotationYaw, this.rotationPitch);
    }
    else
    {
    d2 = this.posX + this.motionX;
    d4 = this.posY + this.motionY;
    d11 = this.posZ + this.motionZ;
    this.setPosition(d2, d4, d11);
    
    if (this.onGround)
    {
    this.motionX *= 0.5D;
    this.motionY *= 0.5D;
    this.motionZ *= 0.5D;
    }
    
    this.motionX *= 0.9900000095367432D;
    this.motionY *= 0.949999988079071D;
    this.motionZ *= 0.9900000095367432D;
    }
    }
    

  • Yop,

    Pourquoi ne pas créé une entité genre cheval avec 1pv qui drop l’item œuf vélo quand tu le tue?(tu change sa texture par un vélo) ce serait plus simple ca reste juste une idée


  • @‘VirusZ’:

    Yop,

    Pourquoi ne pas créé une entité genre cheval avec 1pv qui drop l’item œuf vélo quand tu le tue?(tu change sa texture par un vélo) ce serait plus simple ca reste juste une idée

    le bateau utilise un item pour invoquer l’entité.
    les oeufs ont une texture défini donc il ne peut pas la changer simplement comme un item


  • @‘pulganr’:

    @‘VirusZ’:

    Yop,

    Pourquoi ne pas créé une entité genre cheval avec 1pv qui drop l’item œuf vélo quand tu le tue?(tu change sa texture par un vélo) ce serait plus simple ca reste juste une idée

    le bateau utilise un item pour invoquer l’entité.
    les oeufs ont une texture défini donc il ne peut pas la changer simplement comme un item

    tu recrée un item œuf avec un texture différente


  • @‘VirusZ’:

    @‘pulganr’:

    @‘VirusZ’:

    Yop,

    Pourquoi ne pas créé une entité genre cheval avec 1pv qui drop l’item œuf vélo quand tu le tue?(tu change sa texture par un vélo) ce serait plus simple ca reste juste une idée

    le bateau utilise un item pour invoquer l’entité.
    les oeufs ont une texture défini donc il ne peut pas la changer simplement comme un item

    tu recrée un item œuf avec un texture différente

    ouai possible.

    sinon moi je me souviens que mes entité s’enfoncer dans le sol selon l’extend que j’avais mis, mais bon la, pas trop le choix.

    trouve toi un petit mod open source avec des vehicule pour voir


  • problème de collision essaye avec this.setSize(1.0F, 1.0F); voir si il continue de rentrer dans le sol
    ou avec boudingBox je me souvient plus


  • @‘VirusZ’:

    problème de collision essaye avec this.setSize(1.0F, 1.0F); voir si il continue de rentrer dans le sol
    ou avec boudingBox je me souvient plus

    Les boundingBox c’est pour les block

  • Administrateurs Rédacteurs Moddeurs confirmés

    Les entités ont aussi une boundingBox box …