Problème sur le rendu d'une Entity Boat.



  • Hey salut à tous,

    Aujourd'hui je vous explique mon problème en rapport d'un problème de texture d'un nouveau bateau en 1.10.2.

    Mon bateau à bien été enregistré, il est reconnu par le jeux ainsi que ces fonctions. Hors, quand je le vois, il ressemble à un rectangle blanc. Je pense que j'ai un problème de Render mais je ne sais pas ou.

    Je vous partage mon code :

    :::

    package fr.sunmod.neutronstars.entity;
    import java.util.List;
    import javax.annotation.Nullable;
    import com.google.common.collect.Lists;
    import fr.sunmod.neutronstars.items.ItemList;
    import net.minecraft.block.BlockLiquid;
    import net.minecraft.block.BlockPlanks;
    import net.minecraft.block.material.Material;
    import net.minecraft.block.state.IBlockState;
    import net.minecraft.entity.Entity;
    import net.minecraft.entity.EntityLivingBase;
    import net.minecraft.entity.passive.EntityAnimal;
    import net.minecraft.entity.passive.EntityWaterMob;
    import net.minecraft.entity.player.EntityPlayer;
    import net.minecraft.init.Blocks;
    import net.minecraft.init.Items;
    import net.minecraft.item.Item;
    import net.minecraft.item.ItemStack;
    import net.minecraft.nbt.NBTTagCompound;
    import net.minecraft.network.datasync.DataParameter;
    import net.minecraft.network.datasync.DataSerializers;
    import net.minecraft.network.datasync.EntityDataManager;
    import net.minecraft.network.play.client.CPacketSteerBoat;
    import net.minecraft.util.DamageSource;
    import net.minecraft.util.EntityDamageSourceIndirect;
    import net.minecraft.util.EntitySelectors;
    import net.minecraft.util.EnumFacing;
    import net.minecraft.util.EnumHand;
    import net.minecraft.util.math.AxisAlignedBB;
    import net.minecraft.util.math.BlockPos;
    import net.minecraft.util.math.MathHelper;
    import net.minecraft.util.math.Vec3d;
    import net.minecraft.world.IBlockAccess;
    import net.minecraft.world.World;
    import net.minecraftforge.fml.relauncher.Side;
    import net.minecraftforge.fml.relauncher.SideOnly;
    public class SunBoat extends Entity
    {
        private static final DataParameter <integer>TIME_SINCE_HIT = EntityDataManager.<integer>createKey(SunBoat.class, DataSerializers.VARINT);
        private static final DataParameter <integer>FORWARD_DIRECTION = EntityDataManager.<integer>createKey(SunBoat.class, DataSerializers.VARINT);
        private static final DataParameter <float>DAMAGE_TAKEN = EntityDataManager.<float>createKey(SunBoat.class, DataSerializers.FLOAT);
        private static final DataParameter <integer>BOAT_TYPE = EntityDataManager.<integer>createKey(SunBoat.class, DataSerializers.VARINT);
        private static final DataParameter<boolean>[] DATA_ID_PADDLE = new DataParameter[] {EntityDataManager.createKey(SunBoat.class, DataSerializers.BOOLEAN), EntityDataManager.createKey(SunBoat.class, DataSerializers.BOOLEAN)};
        private final float[] paddlePositions;
        /** How much of current speed to retain. Value zero to one. */
        private float momentum;
        private float outOfControlTicks;
        private float deltaRotation;
        private int lerpSteps;
        private double boatPitch;
        private double lerpY;
        private double lerpZ;
        private double boatYaw;
        private double lerpXRot;
        private boolean leftInputDown;
        private boolean rightInputDown;
        private boolean forwardInputDown;
        private boolean backInputDown;
        private double waterLevel;
        /**
         * How much the boat should glide given the slippery blocks it's currently gliding over.
         * Halved every tick.
         */
        private float boatGlide;
        private SunBoat.Status status;
        private SunBoat.Status previousStatus;
        private double lastYd;
        public SunBoat(World worldIn)
        {
            super(worldIn);
            this.paddlePositions = new float[2];
            this.preventEntitySpawning = true;
            this.setSize(1.375F, 0.5625F);
        }
        public SunBoat(World worldIn, double x, double y, double z)
        {
            this(worldIn);
            this.setPosition(x, y, z);
            this.motionX = 0.0D;
            this.motionY = 0.0D;
            this.motionZ = 0.0D;
            this.prevPosX = x;
            this.prevPosY = y;
            this.prevPosZ = z;
        }
        /**
         * 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.dataManager.register(TIME_SINCE_HIT, Integer.valueOf(0));
            this.dataManager.register(FORWARD_DIRECTION, Integer.valueOf(1));
            this.dataManager.register(DAMAGE_TAKEN, Float.valueOf(0.0F));
            this.dataManager.register(BOAT_TYPE, Integer.valueOf(SunBoat.Type.OAK.ordinal()));
            for (DataParameter <boolean>dataparameter : DATA_ID_PADDLE)
            {
                this.dataManager.register(dataparameter, Boolean.valueOf(false));
            }
        }
        /**
         * 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.
         */
        @Nullable
        public AxisAlignedBB getCollisionBox(Entity entityIn)
        {
            return entityIn.getEntityBoundingBox();
        }
        /**
         * Returns the collision bounding box for this entity
         */
        @Nullable
        public AxisAlignedBB getCollisionBoundingBox()
        {
            return this.getEntityBoundingBox();
        }
        /**
         * Returns true if this entity should push and be pushed by other entities when colliding.
         */
        public boolean canBePushed()
        {
            return true;
        }
        /**
         * Returns the Y offset from the entity's position for any entity riding this one.
         */
        public double getMountedYOffset()
        {
            return -0.1D;
        }
        /**
         * Called when the entity is attacked.
         */
        public boolean attackEntityFrom(DamageSource source, float amount)
        {
            if (this.isEntityInvulnerable(source))
            {
                return false;
            }
            else if (!this.worldObj.isRemote && !this.isDead)
            {
                if (source instanceof EntityDamageSourceIndirect && source.getEntity() != null && this.isPassenger(source.getEntity()))
                {
                    return false;
                }
                else
                {
                    this.setForwardDirection(-this.getForwardDirection());
                    this.setTimeSinceHit(10);
                    this.setDamageTaken(this.getDamageTaken() + amount * 10.0F);
                    this.setBeenAttacked();
                    boolean flag = source.getEntity() instanceof EntityPlayer && ((EntityPlayer)source.getEntity()).capabilities.isCreativeMode;
                    if (flag || this.getDamageTaken() > 40.0F)
                    {
                        if (!flag && this.worldObj.getGameRules().getBoolean("doEntityDrops"))
                        {
                            this.dropItemWithOffset(this.getItemBoat(), 1, 0.0F);
                        }
                        this.setDead();
                    }
                    return true;
                }
            }
            else
            {
                return true;
            }
        }
        /**
         * Applies a velocity to the entities, to push them away from eachother.
         */
        public void applyEntityCollision(Entity entityIn)
        {
            if (entityIn instanceof SunBoat)
            {
                if (entityIn.getEntityBoundingBox().minY < this.getEntityBoundingBox().maxY)
                {
                    super.applyEntityCollision(entityIn);
                }
            }
            else if (entityIn.getEntityBoundingBox().minY <= this.getEntityBoundingBox().minY)
            {
                super.applyEntityCollision(entityIn);
            }
        }
        public Item getItemBoat()
        {
            return ItemList.sunBoat;
        }
        /**
         * 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 !this.isDead;
        }
        /**
         * Set the position and rotation values directly without any clamping.
         */
        @SideOnly(Side.CLIENT)
        public void setPositionAndRotationDirect(double x, double y, double z, float yaw, float pitch, int posRotationIncrements, boolean teleport)
        {
            this.boatPitch = x;
            this.lerpY = y;
            this.lerpZ = z;
            this.boatYaw = (double)yaw;
            this.lerpXRot = (double)pitch;
            this.lerpSteps = 10;
        }
        /**
         * Gets the horizontal facing direction of this Entity, adjusted to take specially-treated entity types into
         * account.
         */
        public EnumFacing getAdjustedHorizontalFacing()
        {
            return this.getHorizontalFacing().rotateY();
        }
        /**
         * Called to update the entity's position/logic.
         */
        public void onUpdate()
        {
            this.previousStatus = this.status;
            this.status = this.getBoatStatus();
            if (this.status != SunBoat.Status.UNDER_WATER && this.status != SunBoat.Status.UNDER_FLOWING_WATER)
            {
                this.outOfControlTicks = 0.0F;
            }
            else
            {
                ++this.outOfControlTicks;
            }
            if (!this.worldObj.isRemote && this.outOfControlTicks >= 60.0F)
            {
                this.removePassengers();
            }
            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;
            super.onUpdate();
            this.tickLerp();
            if (this.canPassengerSteer())
            {
                if (this.getPassengers().size() == 0 || !(this.getPassengers().get(0) instanceof EntityPlayer))
                {
                    this.setPaddleState(false, false);
                }
                this.updateMotion();
                if (this.worldObj.isRemote)
                {
                    this.controlBoat();
                    this.worldObj.sendPacketToServer(new CPacketSteerBoat(this.getPaddleState(0), this.getPaddleState(1)));
                }
                this.moveEntity(this.motionX, this.motionY, this.motionZ);
            }
            else
            {
                this.motionX = 0.0D;
                this.motionY = 0.0D;
                this.motionZ = 0.0D;
            }
            for (int i = 0; i <= 1; ++i)
            {
                if (this.getPaddleState(i))
                {
                    this.paddlePositions* = (float)((double)this.paddlePositions* + 0.01D);
                }
                else
                {
                    this.paddlePositions* = 0.0F;
                }
            }
            this.doBlockCollisions();
            List <entity>list = this.worldObj.getEntitiesInAABBexcluding(this, this.getEntityBoundingBox().expand(0.20000000298023224D, -0.009999999776482582D, 0.20000000298023224D), EntitySelectors.<entity>getTeamCollisionPredicate(this));
            if (!list.isEmpty())
            {
                boolean flag = !this.worldObj.isRemote && !(this.getControllingPassenger() instanceof EntityPlayer);
                for (int j = 0; j < list.size(); ++j)
                {
                    Entity entity = (Entity)list.get(j);
                    if (!entity.isPassenger(this))
                    {
                        if (flag && this.getPassengers().size() < 2 && !entity.isRiding() && entity.width < this.width && entity instanceof EntityLivingBase && !(entity instanceof EntityWaterMob) && !(entity instanceof EntityPlayer))
                        {
                            entity.startRiding(this);
                        }
                        else
                        {
                            this.applyEntityCollision(entity);
                        }
                    }
                }
            }
        }
        private void tickLerp()
        {
            if (this.lerpSteps > 0 && !this.canPassengerSteer())
            {
                double d0 = this.posX + (this.boatPitch - this.posX) / (double)this.lerpSteps;
                double d1 = this.posY + (this.lerpY - this.posY) / (double)this.lerpSteps;
                double d2 = this.posZ + (this.lerpZ - this.posZ) / (double)this.lerpSteps;
                double d3 = MathHelper.wrapDegrees(this.boatYaw - (double)this.rotationYaw);
                this.rotationYaw = (float)((double)this.rotationYaw + d3 / (double)this.lerpSteps);
                this.rotationPitch = (float)((double)this.rotationPitch + (this.lerpXRot - (double)this.rotationPitch) / (double)this.lerpSteps);
                –this.lerpSteps;
                this.setPosition(d0, d1, d2);
                this.setRotation(this.rotationYaw, this.rotationPitch);
            }
        }
        public void setPaddleState(boolean p_184445_1_, boolean p_184445_2_)
        {
            this.dataManager.set(DATA_ID_PADDLE[0], Boolean.valueOf(p_184445_1_));
            this.dataManager.set(DATA_ID_PADDLE[1], Boolean.valueOf(p_184445_2_));
        }
        @SideOnly(Side.CLIENT)
        public float getRowingTime(int p_184448_1_, float limbSwing)
        {
            return this.getPaddleState(p_184448_1_) ? (float)MathHelper.denormalizeClamp((double)this.paddlePositions[p_184448_1_] - 0.01D, (double)this.paddlePositions[p_184448_1_], (double)limbSwing) : 0.0F;
        }
        /**
         * Determines whether the boat is in water, gliding on land, or in air
         */
        private SunBoat.Status getBoatStatus()
        {
            SunBoat.Status SunBoat$status = this.getUnderwaterStatus();
            if (SunBoat$status != null)
            {
                this.waterLevel = this.getEntityBoundingBox().maxY;
                return SunBoat$status;
            }
            else if (this.checkInWater())
            {
                return SunBoat.Status.IN_WATER;
            }
            else
            {
                float f = this.getBoatGlide();
                if (f > 0.0F)
                {
                    this.boatGlide = f;
                    return SunBoat.Status.ON_LAND;
                }
                else
                {
                    return SunBoat.Status.IN_AIR;
                }
            }
        }
        public float getWaterLevelAbove()
        {
            AxisAlignedBB axisalignedbb = this.getEntityBoundingBox();
            int i = MathHelper.floor_double(axisalignedbb.minX);
            int j = MathHelper.ceiling_double_int(axisalignedbb.maxX);
            int k = MathHelper.floor_double(axisalignedbb.maxY);
            int l = MathHelper.ceiling_double_int(axisalignedbb.maxY - this.lastYd);
            int i1 = MathHelper.floor_double(axisalignedbb.minZ);
            int j1 = MathHelper.ceiling_double_int(axisalignedbb.maxZ);
            BlockPos.PooledMutableBlockPos blockpos$pooledmutableblockpos = BlockPos.PooledMutableBlockPos.retain();
            try
            {
                label78:
                for (int k1 = k; k1 < l; ++k1)
                {
                    float f = 0.0F;
                    int l1 = i;
                    while (true)
                    {
                        if (l1 >= j)
                        {
                            if (f < 1.0F)
                            {
                                float f2 = (float)blockpos$pooledmutableblockpos.getY() + f;
                                return f2;
                            }
                            break;
                        }
                        for (int i2 = i1; i2 < j1; ++i2)
                        {
                            blockpos$pooledmutableblockpos.setPos(l1, k1, i2);
                            IBlockState iblockstate = this.worldObj.getBlockState(blockpos$pooledmutableblockpos);
                            if (iblockstate.getMaterial() == Material.WATER)
                            {
                                f = Math.max(f, getBlockLiquidHeight(iblockstate, this.worldObj, blockpos$pooledmutableblockpos));
                            }
                            if (f >= 1.0F)
                            {
                                continue label78;
                            }
                        }
                        ++l1;
                    }
                }
                float f1 = (float)(l + 1);
                return f1;
            }
            finally
            {
                blockpos$pooledmutableblockpos.release();
            }
        }
        /**
         * Decides how much the boat should be gliding on the land (based on any slippery blocks)
         */
        public float getBoatGlide()
        {
            AxisAlignedBB axisalignedbb = this.getEntityBoundingBox();
            AxisAlignedBB axisalignedbb1 = new AxisAlignedBB(axisalignedbb.minX, axisalignedbb.minY - 0.001D, axisalignedbb.minZ, axisalignedbb.maxX, axisalignedbb.minY, axisalignedbb.maxZ);
            int i = MathHelper.floor_double(axisalignedbb1.minX) - 1;
            int j = MathHelper.ceiling_double_int(axisalignedbb1.maxX) + 1;
            int k = MathHelper.floor_double(axisalignedbb1.minY) - 1;
            int l = MathHelper.ceiling_double_int(axisalignedbb1.maxY) + 1;
            int i1 = MathHelper.floor_double(axisalignedbb1.minZ) - 1;
            int j1 = MathHelper.ceiling_double_int(axisalignedbb1.maxZ) + 1;
            List <axisalignedbb>list = Lists.<axisalignedbb>newArrayList();
            float f = 0.0F;
            int k1 = 0;
            BlockPos.PooledMutableBlockPos blockpos$pooledmutableblockpos = BlockPos.PooledMutableBlockPos.retain();
            try
            {
                for (int l1 = i; l1 < j; ++l1)
                {
                    for (int i2 = i1; i2 < j1; ++i2)
                    {
                        int j2 = (l1 != i && l1 != j - 1 ? 0 : 1) + (i2 != i1 && i2 != j1 - 1 ? 0 : 1);
                        if (j2 != 2)
                        {
                            for (int k2 = k; k2 < l; ++k2)
                            {
                                if (j2 <= 0 || k2 != k && k2 != l - 1)
                                {
                                    blockpos$pooledmutableblockpos.setPos(l1, k2, i2);
                                    IBlockState iblockstate = this.worldObj.getBlockState(blockpos$pooledmutableblockpos);
                                    iblockstate.addCollisionBoxToList(this.worldObj, blockpos$pooledmutableblockpos, axisalignedbb1, list, this);
                                    if (!list.isEmpty())
                                    {
                                        f += iblockstate.getBlock().slipperiness;
                                        ++k1;
                                    }
                                    list.clear();
                                }
                            }
                        }
                    }
                }
            }
            finally
            {
                blockpos$pooledmutableblockpos.release();
            }
            return f / (float)k1;
        }
        private boolean checkInWater()
        {
            AxisAlignedBB axisalignedbb = this.getEntityBoundingBox();
            int i = MathHelper.floor_double(axisalignedbb.minX);
            int j = MathHelper.ceiling_double_int(axisalignedbb.maxX);
            int k = MathHelper.floor_double(axisalignedbb.minY);
            int l = MathHelper.ceiling_double_int(axisalignedbb.minY + 0.001D);
            int i1 = MathHelper.floor_double(axisalignedbb.minZ);
            int j1 = MathHelper.ceiling_double_int(axisalignedbb.maxZ);
            boolean flag = false;
            this.waterLevel = Double.MIN_VALUE;
            BlockPos.PooledMutableBlockPos blockpos$pooledmutableblockpos = BlockPos.PooledMutableBlockPos.retain();
            try
            {
                for (int k1 = i; k1 < j; ++k1)
                {
                    for (int l1 = k; l1 < l; ++l1)
                    {
                        for (int i2 = i1; i2 < j1; ++i2)
                        {
                            blockpos$pooledmutableblockpos.setPos(k1, l1, i2);
                            IBlockState iblockstate = this.worldObj.getBlockState(blockpos$pooledmutableblockpos);
                            if (iblockstate.getMaterial() == Material.WATER)
                            {
                                float f = getLiquidHeight(iblockstate, this.worldObj, blockpos$pooledmutableblockpos);
                                this.waterLevel = Math.max((double)f, this.waterLevel);
                                flag |= axisalignedbb.minY < (double)f;
                            }
                        }
                    }
                }
            }
            finally
            {
                blockpos$pooledmutableblockpos.release();
            }
            return flag;
        }
        /**
         * Decides whether the boat is currently underwater.
         */
        @Nullable
        private SunBoat.Status getUnderwaterStatus()
        {
            AxisAlignedBB axisalignedbb = this.getEntityBoundingBox();
            double d0 = axisalignedbb.maxY + 0.001D;
            int i = MathHelper.floor_double(axisalignedbb.minX);
            int j = MathHelper.ceiling_double_int(axisalignedbb.maxX);
            int k = MathHelper.floor_double(axisalignedbb.maxY);
            int l = MathHelper.ceiling_double_int(d0);
            int i1 = MathHelper.floor_double(axisalignedbb.minZ);
            int j1 = MathHelper.ceiling_double_int(axisalignedbb.maxZ);
            boolean flag = false;
            BlockPos.PooledMutableBlockPos blockpos$pooledmutableblockpos = BlockPos.PooledMutableBlockPos.retain();
            try
            {
                for (int k1 = i; k1 < j; ++k1)
                {
                    for (int l1 = k; l1 < l; ++l1)
                    {
                        for (int i2 = i1; i2 < j1; ++i2)
                        {
                            blockpos$pooledmutableblockpos.setPos(k1, l1, i2);
                            IBlockState iblockstate = this.worldObj.getBlockState(blockpos$pooledmutableblockpos);
                            if (iblockstate.getMaterial() == Material.WATER && d0 < (double)getLiquidHeight(iblockstate, this.worldObj, blockpos$pooledmutableblockpos))
                            {
                                if (((Integer)iblockstate.getValue(BlockLiquid.LEVEL)).intValue() != 0)
                                {
                                    SunBoat.Status SunBoat$status = SunBoat.Status.UNDER_FLOWING_WATER;
                                    return SunBoat$status;
                                }
                                flag = true;
                            }
                        }
                    }
                }
            }
            finally
            {
                blockpos$pooledmutableblockpos.release();
            }
            return flag ? SunBoat.Status.UNDER_WATER : null;
        }
        public static float getBlockLiquidHeight(IBlockState p_184456_0_, IBlockAccess p_184456_1_, BlockPos p_184456_2_)
        {
            int i = ((Integer)p_184456_0_.getValue(BlockLiquid.LEVEL)).intValue();
            return (i & 7) == 0 && p_184456_1_.getBlockState(p_184456_2_.up()).getMaterial() == Material.WATER ? 1.0F : 1.0F - BlockLiquid.getLiquidHeightPercent(i);
        }
        public static float getLiquidHeight(IBlockState p_184452_0_, IBlockAccess p_184452_1_, BlockPos p_184452_2_)
        {
            return (float)p_184452_2_.getY() + getBlockLiquidHeight(p_184452_0_, p_184452_1_, p_184452_2_);
        }
        /**
         * Update the boat's speed, based on momentum.
         */
        private void updateMotion()
        {
            double d0 = -0.03999999910593033D;
            double d1 = this.func_189652_ae() ? 0.0D : -0.03999999910593033D;
            double d2 = 0.0D;
            this.momentum = 0.05F;
            if (this.previousStatus == SunBoat.Status.IN_AIR && this.status != SunBoat.Status.IN_AIR && this.status != SunBoat.Status.ON_LAND)
            {
                this.waterLevel = this.getEntityBoundingBox().minY + (double)this.height;
                this.setPosition(this.posX, (double)(this.getWaterLevelAbove() - this.height) + 0.101D, this.posZ);
                this.motionY = 0.0D;
                this.lastYd = 0.0D;
                this.status = SunBoat.Status.IN_WATER;
            }
            else
            {
                if (this.status == SunBoat.Status.IN_WATER)
                {
                    d2 = (this.waterLevel - this.getEntityBoundingBox().minY) / (double)this.height;
                    this.momentum = 0.9F;
                }
                else if (this.status == SunBoat.Status.UNDER_FLOWING_WATER)
                {
                    d1 = -7.0E-4D;
                    this.momentum = 0.9F;
                }
                else if (this.status == SunBoat.Status.UNDER_WATER)
                {
                    d2 = 0.009999999776482582D;
                    this.momentum = 0.45F;
                }
                else if (this.status == SunBoat.Status.IN_AIR)
                {
                    this.momentum = 0.9F;
                }
                else if (this.status == SunBoat.Status.ON_LAND)
                {
                    this.momentum = this.boatGlide;
                    if (this.getControllingPassenger() instanceof EntityPlayer)
                    {
                        this.boatGlide /= 2.0F;
                    }
                }
                this.motionX *= (double)this.momentum;
                this.motionZ *= (double)this.momentum;
                this.deltaRotation *= this.momentum;
                this.motionY += d1;
                if (d2 > 0.0D)
                {
                    double d3 = 0.65D;
                    this.motionY += d2 * 0.06153846016296973D;
                    double d4 = 0.75D;
                    this.motionY *= 0.75D;
                }
            }
        }
        private void controlBoat()
        {
            if (this.isBeingRidden())
            {
                float f = 0.0F;
                if (this.leftInputDown)
                {
                    this.deltaRotation += -1.0F;
                }
                if (this.rightInputDown)
                {
                    ++this.deltaRotation;
                }
                if (this.rightInputDown != this.leftInputDown && !this.forwardInputDown && !this.backInputDown)
                {
                    f += 0.005F;
                }
                this.rotationYaw += this.deltaRotation;
                if (this.forwardInputDown)
                {
                    f += 0.04F;
                }
                if (this.backInputDown)
                {
                    f -= 0.005F;
                }
                this.motionX += (double)(MathHelper.sin(-this.rotationYaw * 0.017453292F) * f);
                this.motionZ += (double)(MathHelper.cos(this.rotationYaw * 0.017453292F) * f);
                this.setPaddleState(this.rightInputDown || this.forwardInputDown, this.leftInputDown || this.forwardInputDown);
            }
        }
        public void updatePassenger(Entity passenger)
        {
            if (this.isPassenger(passenger))
            {
                float f = 0.0F;
                float f1 = (float)((this.isDead ? 0.009999999776482582D : this.getMountedYOffset()) + passenger.getYOffset());
                if (this.getPassengers().size() > 1)
                {
                    int i = this.getPassengers().indexOf(passenger);
                    if (i == 0)
                    {
                        f = 0.2F;
                    }
                    else
                    {
                        f = -0.6F;
                    }
                    if (passenger instanceof EntityAnimal)
                    {
                        f = (float)((double)f + 0.2D);
                    }
                }
                Vec3d vec3d = (new Vec3d((double)f, 0.0D, 0.0D)).rotateYaw(-this.rotationYaw * 0.017453292F - ((float)Math.PI / 2F));
                passenger.setPosition(this.posX + vec3d.xCoord, this.posY + (double)f1, this.posZ + vec3d.zCoord);
                passenger.rotationYaw += this.deltaRotation;
                passenger.setRotationYawHead(passenger.getRotationYawHead() + this.deltaRotation);
                this.applyYawToEntity(passenger);
                if (passenger instanceof EntityAnimal && this.getPassengers().size() > 1)
                {
                    int j = passenger.getEntityId() % 2 == 0 ? 90 : 270;
                    passenger.setRenderYawOffset(((EntityAnimal)passenger).renderYawOffset + (float)j);
                    passenger.setRotationYawHead(passenger.getRotationYawHead() + (float)j);
                }
            }
        }
        /**
         * Applies this boat's yaw to the given entity. Used to update the orientation of its passenger.
         */
        protected void applyYawToEntity(Entity entityToUpdate)
        {
            entityToUpdate.setRenderYawOffset(this.rotationYaw);
            float f = MathHelper.wrapDegrees(entityToUpdate.rotationYaw - this.rotationYaw);
            float f1 = MathHelper.clamp_float(f, -105.0F, 105.0F);
            entityToUpdate.prevRotationYaw += f1 - f;
            entityToUpdate.rotationYaw += f1 - f;
            entityToUpdate.setRotationYawHead(entityToUpdate.rotationYaw);
        }
        /**
         * Applies this entity's orientation (pitch/yaw) to another entity. Used to update passenger orientation.
         */
        @SideOnly(Side.CLIENT)
        public void applyOrientationToEntity(Entity entityToUpdate)
        {
            this.applyYawToEntity(entityToUpdate);
        }
        /**
         * (abstract) Protected helper method to write subclass entity data to NBT.
         */
        protected void writeEntityToNBT(NBTTagCompound compound)
        {
            compound.setString("Type", this.getBoatType().getName());
        }
        /**
         * (abstract) Protected helper method to read subclass entity data from NBT.
         */
        protected void readEntityFromNBT(NBTTagCompound compound)
        {
            if (compound.hasKey("Type", 8))
            {
                this.setBoatType(SunBoat.Type.getTypeFromString(compound.getString("Type")));
            }
        }
        public boolean processInitialInteract(EntityPlayer player, @Nullable ItemStack stack, EnumHand hand)
        {
            if (!this.worldObj.isRemote && !player.isSneaking() && this.outOfControlTicks < 60.0F)
            {
                player.startRiding(this);
            }
            return true;
        }
        protected void updateFallState(double y, boolean onGroundIn, IBlockState state, BlockPos pos)
        {
            this.lastYd = this.motionY;
            if (!this.isRiding())
            {
                if (onGroundIn)
                {
                    if (this.fallDistance > 3.0F)
                    {
                        if (this.status != SunBoat.Status.ON_LAND)
                        {
                            this.fallDistance = 0.0F;
                            return;
                        }
                        this.fall(this.fallDistance, 1.0F);
                        if (!this.worldObj.isRemote && !this.isDead)
                        {
                            this.setDead();
                            if (this.worldObj.getGameRules().getBoolean("doEntityDrops"))
                            {
                                for (int i = 0; i < 3; ++i)
                                {
                                    this.entityDropItem(new ItemStack(Item.getItemFromBlock(Blocks.PLANKS), 1, this.getBoatType().getMetadata()), 0.0F);
                                }
                                for (int j = 0; j < 2; ++j)
                                {
                                    this.dropItemWithOffset(Items.STICK, 1, 0.0F);
                                }
                            }
                        }
                    }
                    this.fallDistance = 0.0F;
                }
                else if (this.worldObj.getBlockState((new BlockPos(this)).down()).getMaterial() != Material.WATER && y < 0.0D)
                {
                    this.fallDistance = (float)((double)this.fallDistance - y);
                }
            }
        }
        public boolean getPaddleState(int p_184457_1_)
        {
            return ((Boolean)this.dataManager.get(DATA_ID_PADDLE[p_184457_1_])).booleanValue() && this.getControllingPassenger() != null;
        }
        /**
         * Sets the damage taken from the last hit.
         */
        public void setDamageTaken(float damageTaken)
        {
            this.dataManager.set(DAMAGE_TAKEN, Float.valueOf(damageTaken));
        }
        /**
         * Gets the damage taken from the last hit.
         */
        public float getDamageTaken()
        {
            return ((Float)this.dataManager.get(DAMAGE_TAKEN)).floatValue();
        }
        /**
         * Sets the time to count down from since the last time entity was hit.
         */
        public void setTimeSinceHit(int timeSinceHit)
        {
            this.dataManager.set(TIME_SINCE_HIT, Integer.valueOf(timeSinceHit));
        }
        /**
         * Gets the time since the last hit.
         */
        public int getTimeSinceHit()
        {
            return ((Integer)this.dataManager.get(TIME_SINCE_HIT)).intValue();
        }
        /**
         * Sets the forward direction of the entity.
         */
        public void setForwardDirection(int forwardDirection)
        {
            this.dataManager.set(FORWARD_DIRECTION, Integer.valueOf(forwardDirection));
        }
        /**
         * Gets the forward direction of the entity.
         */
        public int getForwardDirection()
        {
            return ((Integer)this.dataManager.get(FORWARD_DIRECTION)).intValue();
        }
        public void setBoatType(SunBoat.Type boatType)
        {
            this.dataManager.set(BOAT_TYPE, Integer.valueOf(boatType.ordinal()));
        }
        public SunBoat.Type getBoatType()
        {
            return SunBoat.Type.byId(((Integer)this.dataManager.get(BOAT_TYPE)).intValue());
        }
        protected boolean canFitPassenger(Entity passenger)
        {
            return this.getPassengers().size() < 2;
        }
        /**
         * For vehicles, the first passenger is generally considered the controller and "drives" the vehicle. For example,
         * Pigs, Horses, and Boats are generally "steered" by the controlling passenger.
         */
        @Nullable
        public Entity getControllingPassenger()
        {
            List <entity>list = this.getPassengers();
            return list.isEmpty() ? null : (Entity)list.get(0);
        }
        @SideOnly(Side.CLIENT)
        public void updateInputs(boolean p_184442_1_, boolean p_184442_2_, boolean p_184442_3_, boolean p_184442_4_)
        {
            this.leftInputDown = p_184442_1_;
            this.rightInputDown = p_184442_2_;
            this.forwardInputDown = p_184442_3_;
            this.backInputDown = p_184442_4_;
        }
        public static enum Status
        {
            IN_WATER,
            UNDER_WATER,
            UNDER_FLOWING_WATER,
            ON_LAND,
            IN_AIR;
        }
        public static enum Type
        {
            OAK(BlockPlanks.EnumType.OAK.getMetadata(), "oak");
            private final String name;
            private final int metadata;
            private Type(int metadataIn, String nameIn)
            {
                this.name = nameIn;
                this.metadata = metadataIn;
            }
            public String getName()
            {
                return this.name;
            }
            public int getMetadata()
            {
                return this.metadata;
            }
            public String toString()
            {
                return this.name;
            }
            /**
             * Get a boat type by it's enum ordinal
             */
            public static SunBoat.Type byId(int id)
            {
                if (id < 0 || id >= values().length)
                {
                    id = 0;
                }
                return values()[id];
            }
            public static SunBoat.Type getTypeFromString(String nameIn)
            {
                for (int i = 0; i < values().length; ++i)
                {
                    if (values()*.getName().equals(nameIn))
                    {
                        return values()*;
                    }
                }
                return values()[0];
            }
        }
    }
    

    :::

    :::

    package fr.sunmod.neutronstars.model;
    import fr.sunmod.neutronstars.entity.SunBoat;
    import net.minecraft.client.model.IMultipassModel;
    import net.minecraft.client.model.ModelBase;
    import net.minecraft.client.model.ModelRenderer;
    import net.minecraft.client.renderer.GLAllocation;
    import net.minecraft.client.renderer.GlStateManager;
    import net.minecraft.entity.Entity;
    import net.minecraft.util.math.MathHelper;
    import net.minecraftforge.fml.relauncher.Side;
    import net.minecraftforge.fml.relauncher.SideOnly;
    @SideOnly(Side.CLIENT)
    public class ModelSunBoat extends ModelBase implements IMultipassModel
    {
        public ModelRenderer[] boatSides = new ModelRenderer[5];
        public ModelRenderer[] paddles = new ModelRenderer[2];
        /** Part of the model rendered to make it seem like there's no water in the boat */
        public ModelRenderer noWater;
        private final int patchList = GLAllocation.generateDisplayLists(1);
        public ModelSunBoat()
        {
            this.boatSides[0] = (new ModelRenderer(this, 0, 0)).setTextureSize(128, 64);
            this.boatSides[1] = (new ModelRenderer(this, 0, 19)).setTextureSize(128, 64);
            this.boatSides[2] = (new ModelRenderer(this, 0, 27)).setTextureSize(128, 64);
            this.boatSides[3] = (new ModelRenderer(this, 0, 35)).setTextureSize(128, 64);
            this.boatSides[4] = (new ModelRenderer(this, 0, 43)).setTextureSize(128, 64);
            int i = 32;
            int j = 6;
            int k = 20;
            int l = 4;
            int i1 = 28;
            this.boatSides[0].addBox(-14.0F, -9.0F, -3.0F, 28, 16, 3, 0.0F);
            this.boatSides[0].setRotationPoint(0.0F, 3.0F, 1.0F);
            this.boatSides[1].addBox(-13.0F, -7.0F, -1.0F, 18, 6, 2, 0.0F);
            this.boatSides[1].setRotationPoint(-15.0F, 4.0F, 4.0F);
            this.boatSides[2].addBox(-8.0F, -7.0F, -1.0F, 16, 6, 2, 0.0F);
            this.boatSides[2].setRotationPoint(15.0F, 4.0F, 0.0F);
            this.boatSides[3].addBox(-14.0F, -7.0F, -1.0F, 28, 6, 2, 0.0F);
            this.boatSides[3].setRotationPoint(0.0F, 4.0F, -9.0F);
            this.boatSides[4].addBox(-14.0F, -7.0F, -1.0F, 28, 6, 2, 0.0F);
            this.boatSides[4].setRotationPoint(0.0F, 4.0F, 9.0F);
            this.boatSides[0].rotateAngleX = ((float)Math.PI / 2F);
            this.boatSides[1].rotateAngleY = ((float)Math.PI * 3F / 2F);
            this.boatSides[2].rotateAngleY = ((float)Math.PI / 2F);
            this.boatSides[3].rotateAngleY = (float)Math.PI;
            this.paddles[0] = this.makePaddle(true);
            this.paddles[0].setRotationPoint(3.0F, -5.0F, 9.0F);
            this.paddles[1] = this.makePaddle(false);
            this.paddles[1].setRotationPoint(3.0F, -5.0F, -9.0F);
            this.paddles[1].rotateAngleY = (float)Math.PI;
            this.paddles[0].rotateAngleZ = 0.19634955F;
            this.paddles[1].rotateAngleZ = 0.19634955F;
            this.noWater = (new ModelRenderer(this, 0, 0)).setTextureSize(128, 64);
            this.noWater.addBox(-14.0F, -9.0F, -3.0F, 28, 16, 3, 0.0F);
            this.noWater.setRotationPoint(0.0F, -3.0F, 1.0F);
            this.noWater.rotateAngleX = ((float)Math.PI / 2F);
        }
        /**
         * Sets the models various rotation angles then renders the model.
         */
        public void render(Entity entityIn, float limbSwing, float limbSwingAmount, float ageInTicks, float netHeadYaw, float headPitch, float scale)
        {
            GlStateManager.rotate(90.0F, 0.0F, 1.0F, 0.0F);
            SunBoat SunBoat = (SunBoat)entityIn;
            this.setRotationAngles(limbSwing, limbSwingAmount, ageInTicks, netHeadYaw, headPitch, scale, entityIn);
            for (int i = 0; i < 5; ++i)
            {
                this.boatSides*.render(scale);
            }
            this.renderPaddle(SunBoat, 0, scale, limbSwing);
            this.renderPaddle(SunBoat, 1, scale, limbSwing);
        }
        public void renderMultipass(Entity p_187054_1_, float p_187054_2_, float p_187054_3_, float p_187054_4_, float p_187054_5_, float p_187054_6_, float scale)
        {
            GlStateManager.rotate(90.0F, 0.0F, 1.0F, 0.0F);
            GlStateManager.colorMask(false, false, false, false);
            this.noWater.render(scale);
            GlStateManager.colorMask(true, true, true, true);
        }
        /**
         * Sets the model's various rotation angles. For bipeds, par1 and par2 are used for animating the movement of arms
         * and legs, where par1 represents the time(so that arms and legs swing back and forth) and par2 represents how
         * "far" arms and legs can swing at most.
         */
        public void setRotationAngles(float limbSwing, float limbSwingAmount, float ageInTicks, float netHeadYaw, float headPitch, float scaleFactor, Entity entityIn)
        {
        }
        ModelRenderer makePaddle(boolean p_187056_1_)
        {
            ModelRenderer modelrenderer = (new ModelRenderer(this, 62, p_187056_1_ ? 0 : 20)).setTextureSize(128, 64);
            int i = 20;
            int j = 7;
            int k = 6;
            float f = -5.0F;
            modelrenderer.addBox(-1.0F, 0.0F, -5.0F, 2, 2, 18);
            modelrenderer.addBox(p_187056_1_ ? -1.001F : 0.001F, -3.0F, 8.0F, 1, 6, 7);
            return modelrenderer;
        }
        void renderPaddle(SunBoat boat, int paddle, float scale, float limbSwing)
        {
            float f = 40.0F;
            float f1 = boat.getRowingTime(paddle, limbSwing) * 40.0F;
            ModelRenderer modelrenderer = this.paddles[paddle];
            modelrenderer.rotateAngleX = (float)MathHelper.denormalizeClamp(-1.0471975803375244D, -0.2617993950843811D, (double)((MathHelper.sin(-f1) + 1.0F) / 2.0F));
            modelrenderer.rotateAngleY = (float)MathHelper.denormalizeClamp(-(Math.PI / 4D), (Math.PI / 4D), (double)((MathHelper.sin(-f1 + 1.0F) + 1.0F) / 2.0F));
            if (paddle == 1)
            {
                modelrenderer.rotateAngleY = (float)Math.PI - modelrenderer.rotateAngleY;
            }
            modelrenderer.render(scale);
        }
    }
    

    :::

    :::

    package fr.sunmod.neutronstars.renders;
    import fr.sunmod.neutronstars.entity.SunBoat;
    import fr.sunmod.neutronstars.infos.Infos;
    import fr.sunmod.neutronstars.model.ModelSunBoat;
    import net.minecraft.client.model.IMultipassModel;
    import net.minecraft.client.model.ModelBase;
    import net.minecraft.client.model.ModelBoat;
    import net.minecraft.client.renderer.GlStateManager;
    import net.minecraft.client.renderer.entity.Render;
    import net.minecraft.client.renderer.entity.RenderManager;
    import net.minecraft.util.ResourceLocation;
    import net.minecraft.util.math.MathHelper;
    import net.minecraftforge.fml.relauncher.Side;
    import net.minecraftforge.fml.relauncher.SideOnly;
    @SideOnly(Side.CLIENT)
    public class RenderSunBoat extends Render <sunboat>{
        private static final ResourceLocation BOAT_TEXTURES = new ResourceLocation(Infos.MOD+":textures/entity/boat/boat_sun.png");
        /** instance of ModelBoat for renderming */
        protected ModelBase modelBoat = new ModelSunBoat();
        public RenderSunBoat(RenderManager renderManagerIn)
        {
            super(renderManagerIn);
            this.shadowSize = 0.5F;
        }
        /**
         * Renders the desired [{@code]({@code) T} type Entity.
         */
        public void doRender(SunBoat entity, double x, double y, double z, float entityYaw, float partialTicks)
        {
            GlStateManager.pushMatrix();
            this.setupTranslation(x, y, z);
            this.setupRotation(entity, entityYaw, partialTicks);
            this.bindEntityTexture(entity);
            if (this.renderOutlines)
            {
                GlStateManager.enableColorMaterial();
                GlStateManager.enableOutlineMode(this.getTeamColor(entity));
            }
            this.modelBoat.render(entity, partialTicks, 0.0F, -0.1F, 0.0F, 0.0F, 0.0625F);
            if (this.renderOutlines)
            {
                GlStateManager.disableOutlineMode();
                GlStateManager.disableColorMaterial();
            }
            GlStateManager.popMatrix();
            super.doRender(entity, x, y, z, entityYaw, partialTicks);
        }
        public void setupRotation(SunBoat p_188311_1_, float p_188311_2_, float p_188311_3_)
        {
            GlStateManager.rotate(180.0F - p_188311_2_, 0.0F, 1.0F, 0.0F);
            float f = (float)p_188311_1_.getTimeSinceHit() - p_188311_3_;
            float f1 = p_188311_1_.getDamageTaken() - p_188311_3_;
            if (f1 < 0.0F)
            {
                f1 = 0.0F;
            }
            if (f > 0.0F)
            {
                GlStateManager.rotate(MathHelper.sin(f) * f * f1 / 10.0F * (float)p_188311_1_.getForwardDirection(), 1.0F, 0.0F, 0.0F);
            }
            GlStateManager.scale(-1.0F, -1.0F, 1.0F);
        }
        public void setupTranslation(double p_188309_1_, double p_188309_3_, double p_188309_5_)
        {
            GlStateManager.translate((float)p_188309_1_, (float)p_188309_3_ + 0.375F, (float)p_188309_5_);
        }
        /**
         * Returns the location of an entity's texture. Doesn't seem to be called unless you call Render.bindEntityTexture.
         */
        protected ResourceLocation getEntityTexture(SunBoat entity)
        {
            return BOAT_TEXTURES;
        }
        public boolean isMultipass()
        {
            return true;
        }
        public void renderMultipass(SunBoat p_188300_1_, double p_188300_2_, double p_188300_4_, double p_188300_6_, float p_188300_8_, float p_188300_9_)
        {
            GlStateManager.pushMatrix();
            this.setupTranslation(p_188300_2_, p_188300_4_, p_188300_6_);
            this.setupRotation(p_188300_1_, p_188300_8_, p_188300_9_);
            this.bindEntityTexture(p_188300_1_);
            ((IMultipassModel)this.modelBoat).renderMultipass(p_188300_1_, p_188300_9_, 0.0F, -0.1F, 0.0F, 0.0F, 0.0625F);
            GlStateManager.popMatrix();
        }
    }
    

    :::

    :::

    package fr.sunmod.neutronstars.entity;
    import fr.sunmod.neutronstars.SunMod;
    import net.minecraftforge.fml.common.registry.EntityRegistry;
    import net.minecraftforge.fml.common.registry.EntityRegistry.EntityRegistration;
    public class EntityList {
    
     public EntityList() {
      int id = 500;
      EntityRegistry.registerModEntity(SunBoat.class, "boat_sun", id++, SunMod.sunMod, 250, 10, true);
     }
    }
    

    :::

    :::

    package fr.sunmod.neutronstars.infos;
    import fr.sunmod.neutronstars.blocks.BlockList;
    import fr.sunmod.neutronstars.blocks.SunBlock;
    import fr.sunmod.neutronstars.entity.SunBoat;
    import fr.sunmod.neutronstars.items.ItemList;
    import fr.sunmod.neutronstars.items.SunAxe;
    import fr.sunmod.neutronstars.items.SunBoatItem;
    import fr.sunmod.neutronstars.items.SunBoots;
    import fr.sunmod.neutronstars.items.SunChestPlate;
    import fr.sunmod.neutronstars.items.SunFragment;
    import fr.sunmod.neutronstars.items.SunHelmet;
    import fr.sunmod.neutronstars.items.SunHoe;
    import fr.sunmod.neutronstars.items.SunLeggings;
    import fr.sunmod.neutronstars.items.SunPepite;
    import fr.sunmod.neutronstars.items.SunPickaxe;
    import fr.sunmod.neutronstars.items.SunShovel;
    import fr.sunmod.neutronstars.items.SunSword;
    import fr.sunmod.neutronstars.renders.RenderSunBoat;
    import net.minecraft.client.renderer.entity.Render;
    import net.minecraft.client.renderer.entity.RenderManager;
    import net.minecraft.entity.Entity;
    import net.minecraft.util.ResourceLocation;
    import net.minecraftforge.fml.client.registry.IRenderFactory;
    import net.minecraftforge.fml.client.registry.RenderingRegistry;
    public class ClientProxy extends ServerProxy{
    
     @Override
     public void registerRenders() {
      //*** BLOCKS ***//
      ((SunBlock)BlockList.sunBlock).registerRender();
    
      //*** ITEMS ***//
      ((SunFragment)ItemList.sunFragment).registerRender();
      ((SunSword)ItemList.sunSword).registerRender();
      ((SunPickaxe)ItemList.sunPickaxe).registerRender();
      ((SunAxe)ItemList.sunAxe).registerRender();
      ((SunShovel)ItemList.sunShovel).registerRender();
      ((SunHoe)ItemList.sunHoe).registerRender();
      ((SunHelmet)ItemList.sunhelmet).registerRender();
      ((SunChestPlate)ItemList.sunChestplate).registerRender();
      ((SunLeggings)ItemList.sunLeggings).registerRender();
      ((SunBoots)ItemList.sunBoots).registerRender();
      ((SunPepite)ItemList.sunPepite).registerRender();
      ((SunBoatItem)ItemList.sunBoat).registerRender();
     }
    
     @Override
     public void entityRegister(){
      //*** ENTITY ***///
      registerEntityRenderer(SunBoat.class, RenderSunBoat.class);
     }
    
     private static <e extends="" entity="">void registerEntityRenderer(Class <e>entityClass, Class renderClass){
        RenderingRegistry.registerEntityRenderingHandler(entityClass, new EntityRenderFactory(renderClass));
     }
    
      private static class EntityRenderFactory <e extends="" entity="">implements IRenderFactory <e>{
         private Class> renderClass;
    
         private EntityRenderFactory(Class> renderClass)
         {
           this.renderClass = renderClass;
         }
    
         public Render <e>createRenderFor(RenderManager manager)
         {
           Render <e>renderer = null;
           try
           {
             renderer = (Render)this.renderClass.getConstructor(new Class[] { RenderManager.class }).newInstance(new Object[] { manager });
           }
           catch (Exception e)
           {
             e.printStackTrace();
           }
           return renderer;
         }
       }
    }
    

    :::

    J'espère avoir tout fourni. N'hésitez pas à demander, s'il le faut. Et si vous souhaitez directement m'aider sur mon code, demandez-moi sur Skype : sergentnarutyt (Pseudo : Neutron_Stars)

    Merci à ceux qui m'aiderons.

    Cordialement,
    Neutron_Stars.

    PS : Si vous ne vous y connaissez pas en java s'abstenir, je n'ai pas envie de revoir les choses du style que le problème vient du "super.methode( )", juste parcequ'il faut utiliser "this.methode()". Ceux qui savent développer comprendrons la bêtise d'une personne qui m'a sortit ça et qui développe depuis 2 ans. ^^</e></e></e></e></e></e></sunboat></entity></axisalignedbb></axisalignedbb></entity></entity></boolean></boolean></integer></integer></float></float></integer></integer></integer></integer>


  • Administrateurs

    Salut,
    La fonction entityRegister de ton proxy est-elle appelé dans la classe principale ?



  • Oui bien sur :

    :::

    package fr.sunmod.neutronstars;
    import fr.sunmod.neutronstars.blocks.BlockList;
    import fr.sunmod.neutronstars.craft.RegisteryCraft;
    import fr.sunmod.neutronstars.entity.EntityList;
    import fr.sunmod.neutronstars.events.EventList;
    import fr.sunmod.neutronstars.infos.Infos;
    import fr.sunmod.neutronstars.infos.ServerProxy;
    import fr.sunmod.neutronstars.items.ItemList;
    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 = Infos.MOD, version = Infos.VERSION, name = Infos.NAME)
    public class SunMod {
     @SidedProxy(clientSide = Infos.CLIENT, serverSide = Infos.CLIENT)
     public static ServerProxy serverProxy;
    
     @Mod.Instance(Infos.MOD)
     public static SunMod sunMod;
    
     @EventHandler
        public void preInit(FMLPreInitializationEvent event){
      new BlockList();
      new ItemList();
      new EventList();
      new RegisteryCraft();
      new EntityList();
        }
    
     @EventHandler
        public void init(FMLInitializationEvent event){
      serverProxy.registerRenders();
      serverProxy.entityRegister();
        }
    
     @EventHandler
        public void postInit(FMLPostInitializationEvent event){
    
        }
    }
    

    :::

    EDIT :

    J'ai remarqué une erreur lors du la copie du code "@SidedProxy(clientSide = Infos.CLIENT, serverSide = Infos.CLIENT)", j'ai remplacé serverSide = Infos.SERVER mais rien, le rendu n'est toujours pas fait 😕



  • Bonsoir, le rendu des entités doit être enregistré depuis la méthode pré-init et non init comme tu l'as fait. 🙂



  • @'Reden':

    Bonsoir, le rendu des entités doit être enregistré depuis la méthode pré-init et non init comme tu l'as fait. 🙂

    Bonsoir, sur le coup ta proposition ma paru farfelu mais j'ai tout de même essayé et franchement, un gros GG et merci à toi, tu m'as donné la solution qui à ruiné toute ma journée d'hier. xD

    J'aurais du penser à le faire avant mais je ne l'avais pas fait en pensant que ça ne changerais rien mais tu m'as prouvé le contraire. Merci à toi encore. ^^



  • De rien, pour t'expliquer je pense que cela est dû aux RenderFactory qui sont chargés depuis le pre-init (pour la compatibilité et l'override par d'autres mods ?).



  • La je ne pourrais pas te dire 🙂

    J'ai un autre problème sur le spawn du bateau.

    J'ai réutilisé la methode du bateau classique mais je suppose qu'il y a une erreur sur world.spawnEntityInWorld(entity) ;

    :::

    package fr.sunmod.neutronstars.items;
    import java.util.List;
    import fr.sunmod.neutronstars.CreativeTab.SunTabCreative;
    import fr.sunmod.neutronstars.entity.SunBoat;
    import fr.sunmod.neutronstars.infos.Infos;
    import fr.sunmod.neutronstars.renders.RenderSunBoat;
    import net.minecraft.block.Block;
    import net.minecraft.client.Minecraft;
    import net.minecraft.client.renderer.block.model.ModelResourceLocation;
    import net.minecraft.creativetab.CreativeTabs;
    import net.minecraft.entity.Entity;
    import net.minecraft.entity.EntityLiving;
    import net.minecraft.entity.IEntityLivingData;
    import net.minecraft.entity.effect.EntityLightningBolt;
    import net.minecraft.entity.item.EntityBoat;
    import net.minecraft.entity.player.EntityPlayer;
    import net.minecraft.init.Blocks;
    import net.minecraft.item.Item;
    import net.minecraft.item.ItemStack;
    import net.minecraft.nbt.NBTTagCompound;
    import net.minecraft.stats.StatList;
    import net.minecraft.util.ActionResult;
    import net.minecraft.util.EnumActionResult;
    import net.minecraft.util.EnumHand;
    import net.minecraft.util.math.AxisAlignedBB;
    import net.minecraft.util.math.BlockPos;
    import net.minecraft.util.math.MathHelper;
    import net.minecraft.util.math.RayTraceResult;
    import net.minecraft.util.math.Vec3d;
    import net.minecraft.world.World;
    import net.minecraft.world.chunk.storage.AnvilChunkLoader;
    import net.minecraftforge.fml.common.registry.GameRegistry;
    public class SunBoatItem extends Item{
     public SunBoatItem(){
      super.maxStackSize = 1;
         super.setCreativeTab(SunTabCreative.creativeTabsItems);
         super.setUnlocalizedName("sun_boat");
         GameRegistry.registerItem(this, this.getUnlocalizedName().substring(5));
     }
    
     @Override
     public ActionResult <itemstack>onItemRightClick(ItemStack itemStackIn, World worldIn, EntityPlayer playerIn, EnumHand hand)
        {
            float f = 1.0F;
            float f1 = playerIn.prevRotationPitch + (playerIn.rotationPitch - playerIn.prevRotationPitch) * 1.0F;
            float f2 = playerIn.prevRotationYaw + (playerIn.rotationYaw - playerIn.prevRotationYaw) * 1.0F;
            double d0 = playerIn.prevPosX + (playerIn.posX - playerIn.prevPosX) * 1.0D;
            double d1 = playerIn.prevPosY + (playerIn.posY - playerIn.prevPosY) * 1.0D + (double)playerIn.getEyeHeight();
            double d2 = playerIn.prevPosZ + (playerIn.posZ - playerIn.prevPosZ) * 1.0D;
            Vec3d vec3d = new Vec3d(d0, d1, d2);
            float f3 = MathHelper.cos(-f2 * 0.017453292F - (float)Math.PI);
            float f4 = MathHelper.sin(-f2 * 0.017453292F - (float)Math.PI);
            float f5 = -MathHelper.cos(-f1 * 0.017453292F);
            float f6 = MathHelper.sin(-f1 * 0.017453292F);
            float f7 = f4 * f5;
            float f8 = f3 * f5;
            double d3 = 5.0D;
            Vec3d vec3d1 = vec3d.addVector((double)f7 * 5.0D, (double)f6 * 5.0D, (double)f8 * 5.0D);
            RayTraceResult raytraceresult = worldIn.rayTraceBlocks(vec3d, vec3d1, true);
            if (raytraceresult == null)
            {
                return new ActionResult(EnumActionResult.PASS, itemStackIn);
            }
            else
            {
                Vec3d vec3d2 = playerIn.getLook(1.0F);
                boolean flag = false;
                List <entity>list = worldIn.getEntitiesWithinAABBExcludingEntity(playerIn, playerIn.getEntityBoundingBox().addCoord(vec3d2.xCoord * 5.0D, vec3d2.yCoord * 5.0D, vec3d2.zCoord * 5.0D).expandXyz(1.0D));
                for (int i = 0; i < list.size(); ++i)
                {
                    Entity entity = (Entity)list.get(i);
                    if (entity.canBeCollidedWith())
                    {
                        AxisAlignedBB axisalignedbb = entity.getEntityBoundingBox().expandXyz((double)entity.getCollisionBorderSize());
                        if (axisalignedbb.isVecInside(vec3d))
                        {
                            flag = true;
                        }
                    }
                }
                if (flag)
                {
                    return new ActionResult(EnumActionResult.PASS, itemStackIn);
                }
                else if (raytraceresult.typeOfHit != RayTraceResult.Type.BLOCK)
                {
                    return new ActionResult(EnumActionResult.PASS, itemStackIn);
                }
                else
                {
                    Block block = worldIn.getBlockState(raytraceresult.getBlockPos()).getBlock();
                    boolean flag1 = block == Blocks.WATER || block == Blocks.FLOWING_WATER;
                    SunBoat entityboat = new SunBoat(worldIn,raytraceresult.hitVec.xCoord, flag1 ? raytraceresult.hitVec.yCoord - 0.12D : raytraceresult.hitVec.yCoord, raytraceresult.hitVec.zCoord);
                    entityboat.rotationYaw = playerIn.rotationYaw;
    
                    if (!worldIn.getCollisionBoxes(entityboat, entityboat.getEntityBoundingBox().expandXyz(-0.1D)).isEmpty())
                    {
                        return new ActionResult(EnumActionResult.FAIL, itemStackIn);
                    }
                    else
                    {
                        if (!worldIn.isRemote)
                        {
                         worldIn.spawnEntityInWorld(entityboat);
                        }
                        if (!playerIn.capabilities.isCreativeMode)
                        {
                            –itemStackIn.stackSize;
                        }
    
                        return new ActionResult(EnumActionResult.SUCCESS, itemStackIn);
                    }
                }
            }
        }
    
     public void registerRender(){
      Minecraft.getMinecraft().getRenderItem().getItemModelMesher().register(this, 0, new ModelResourceLocation(Infos.MOD+":"+this.getUnlocalizedName().substring(5), "inventory"));
     }
    }
    

    :::

    Je te remercierai une fois de plus si tu as la solution :)</entity></itemstack>


  • Administrateurs

    Quelle est l'erreur ?



  • @'robin4002':

    Quelle est l'erreur ?

    Bah quand je fais click droit avec l'item, mon bateau ne spawn/apparait pas 😕


  • Administrateurs

    Ajoutes des print à différent endroit de la fonction puis regardes la console pour comprendre où ça bloque.



  • worldIn.spawnEntityInWorld(entityboat);

    ça "bloque ici", je l'avais fait hier ^^

    Il ne me fait pas crash mais ça considere comme spawn mais je n'ai rien, à croire que pour forge ceci n'est pas bon ;/

    Par contre quand je fais /summon monmod:boat_sun ça fonctionne


  • Administrateurs

    Rien dans les logs ?
    Étrange comme problème ça.



  • Non rien 😕

    Ces boat vont me sortir par les yeux ^^



  • C'est bon j'ai résolu mon problème, vu que le /summon fonctionné sur mon bateau j'ai recuperer le code et remplacer la methode ^^

    :::

    
    [size=small**NBTTagCompound**] **[size=smallnbttagcompound]** [size=small=] **[size=smallnew]** [size=smallNBTTagCompound][size=small()][size=small;]
    
    [size=smallnbttagcompound][size=small.][size=smallsetString][size=small(][size=small"id"][size=small,] **[size=smallInfos]**[size=small.]***[size=smallMOD]***[size=small+][size=small".boat_sun"][size=small)][size=small;]
    
    **[size=smallEntity]** **[size=smallentity]** [size=small=] **[size=smallAnvilChunkLoader]**[size=small.]*[size=smallreadWorldEntityPos]*[size=small(][size=smallnbttagcompound][size=small,] [size=smallworldIn][size=small,] [size=smallraytraceresult][size=small.][size=smallhitVec][size=small.][size=smallxCoord][size=small,] [size=smallflag1] [size=small?] [size=smallraytraceresult][size=small.][size=smallhitVec][size=small.][size=smallyCoord] [size=small-] [size=small0.12D] [size=small:] [size=smallraytraceresult][size=small.][size=smallhitVec][size=small.][size=smallyCoord][size=small,] [size=smallraytraceresult][size=small.][size=smallhitVec][size=small.][size=smallzCoord][size=small,] **[size=smalltrue]**[size=small)][size=small;]
    

    :::

    Le sujet peut-être déplacer en résolu, merci pour votre aide. 😛


Log in to reply