Résolu Problème Porte

[AzTick_]

Bonsoir, j’ai un petit soucis avec l’item de ma porte, j’ai essayer de faire une porte comme dans minecraft sauf que l’item me pose quelques soucis, j’ai des erreurs sur ces trois ligne au “withProperty”
à chaque fois :

IBlockState iblockstate = door.getDefaultState().withProperty(BlockGardienDoor.FACING, facing).withProperty(BlockGardienDoor.HINGE, isRightHinge ?BlockGardienDoor.EnumHingePosition.RIGHT : BlockGardienDoor.EnumHingePosition.LEFT).withProperty(BlockGardienDoor.POWERED, Boolean.valueOf(flag2)).withProperty(BlockGardienDoor.OPEN

worldIn.setBlockState(pos, iblockstate.withProperty(BlockGardienDoor.HALF, BlockGardienDoor.EnumDoorHalf.LOWER), 2);

worldIn.setBlockState(blockpos2, iblockstate.withProperty(BlockGardienDoor.HALF, BlockGardienDoor.EnumDoorHalf.UPPER), 2);

Voici la classe de mon item :

package fr.askip.prisonroleplay.item;
 
import fr.askip.prisonroleplay.blocks.BlockGardienDoor;
import net.minecraft.block.Block;
import net.minecraft.block.BlockDoor;
import net.minecraft.block.SoundType;
import net.minecraft.block.state.IBlockState;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.EnumActionResult;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.EnumHand;
import net.minecraft.util.SoundCategory;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
 
public class ItemGardienDoor extends Item {
 
private final Block block;
 
    public ItemGardienDoor(Block block)
    {
        this.block = block;
        this.setCreativeTab(CreativeTabs.REDSTONE);
    }
 
    public EnumActionResult onItemUse(ItemStack stack, EntityPlayer playerIn, World worldIn, BlockPos pos, EnumHand hand, EnumFacing facing, float hitX, float hitY, float hitZ) {
        if (facing != EnumFacing.UP) {
            return EnumActionResult.FAIL;
        } else {
            IBlockState iblockstate = worldIn.getBlockState(pos);
            Block block = iblockstate.getBlock();
 
            if (!block.isReplaceable(worldIn, pos)) {
                pos = pos.offset(facing);
            }
 
            if (playerIn.canPlayerEdit(pos, facing, stack) && this.block.canPlaceBlockAt(worldIn, pos)) {
                EnumFacing enumfacing = EnumFacing.fromAngle((double)playerIn.rotationYaw);
                int i = enumfacing.getFrontOffsetX();
                int j = enumfacing.getFrontOffsetZ();
                boolean flag = i < 0 && hitZ < 0.5F || i > 0 && hitZ > 0.5F || j < 0 && hitX > 0.5F || j > 0 && hitX < 0.5F;
                placeDoor(worldIn, pos, enumfacing, this.block, flag);
                SoundType soundtype = worldIn.getBlockState(pos).getBlock().getSoundType(worldIn.getBlockState(pos), worldIn, pos, playerIn);
                worldIn.playSound(playerIn, pos, soundtype.getPlaceSound(), SoundCategory.BLOCKS, (soundtype.getVolume() + 1.0F) / 2.0F, soundtype.getPitch() * 0.8F);
                –stack.stackSize;
                return EnumActionResult.SUCCESS;
            } else {
                return EnumActionResult.FAIL;
            }
        }
    }
 
    public static void placeDoor(World worldIn, BlockPos pos, EnumFacing facing, Block door, boolean isRightHinge)
    {
        BlockPos blockpos = pos.offset(facing.rotateY());
        BlockPos blockpos1 = pos.offset(facing.rotateYCCW());
        int i = (worldIn.getBlockState(blockpos1).isNormalCube() ? 1 : 0) + (worldIn.getBlockState(blockpos1.up()).isNormalCube() ? 1 : 0);
        int j = (worldIn.getBlockState(blockpos).isNormalCube() ? 1 : 0) + (worldIn.getBlockState(blockpos.up()).isNormalCube() ? 1 : 0);
        boolean flag = worldIn.getBlockState(blockpos1).getBlock() == door || worldIn.getBlockState(blockpos1.up()).getBlock() == door;
        boolean flag1 = worldIn.getBlockState(blockpos).getBlock() == door || worldIn.getBlockState(blockpos.up()).getBlock() == door;
 
        if ((!flag || flag1) && j <= i)
        {
            if (flag1 && !flag || j < i)
            {
                isRightHinge = false;
            }
        }
        else
        {
            isRightHinge = true;
        }
 
        BlockPos blockpos2 = pos.up();
        boolean flag2 = worldIn.isBlockPowered(pos) || worldIn.isBlockPowered(blockpos2);
        IBlockState iblockstate = door.getDefaultState().withProperty(BlockGardienDoor.FACING, facing).withProperty(BlockGardienDoor.HINGE, isRightHinge ? BlockGardienDoor.EnumHingePosition.RIGHT : BlockGardienDoor.EnumHingePosition.LEFT).withProperty(BlockGardienDoor.POWERED, Boolean.valueOf(flag2)).withProperty(BlockGardienDoor.OPEN, Boolean.valueOf(flag2));
        worldIn.setBlockState(pos, iblockstate.withProperty(BlockGardienDoor.HALF, BlockGardienDoor.EnumDoorHalf.LOWER), 2);
        worldIn.setBlockState(blockpos2, iblockstate.withProperty(BlockGardienDoor.HALF, BlockGardienDoor.EnumDoorHalf.UPPER), 2);
        worldIn.notifyNeighborsOfStateChange(pos, door);
        worldIn.notifyNeighborsOfStateChange(blockpos2, door);
    }
 
}
 

La classe de mon bloc :

package fr.askip.prisonroleplay.blocks;
 
import java.util.Random;
 
import javax.annotation.Nullable;
import javax.swing.Icon;
 
import net.minecraft.block.Block;
import net.minecraft.block.BlockDoor;
import net.minecraft.block.BlockHorizontal;
import net.minecraft.block.BlockPlanks;
import net.minecraft.block.material.EnumPushReaction;
import net.minecraft.block.material.MapColor;
import net.minecraft.block.material.Material;
import net.minecraft.block.properties.IProperty;
import net.minecraft.block.properties.PropertyBool;
import net.minecraft.block.properties.PropertyDirection;
import net.minecraft.block.properties.PropertyEnum;
import net.minecraft.block.state.BlockStateContainer;
import net.minecraft.block.state.IBlockState;
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.util.BlockRenderLayer;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.EnumHand;
import net.minecraft.util.IStringSerializable;
import net.minecraft.util.Mirror;
import net.minecraft.util.Rotation;
import net.minecraft.util.math.AxisAlignedBB;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.text.translation.I18n;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
 
public class BlockGardienDoor extends Block {
 
public static final PropertyDirection FACING = BlockHorizontal.FACING;
public static final PropertyBool OPEN = PropertyBool.create("open");
public static final PropertyEnum <blockdoor.enumhingeposition>HINGE = PropertyEnum.<blockdoor.enumhingeposition>create("hinge", BlockDoor.EnumHingePosition.class);
public static final PropertyBool POWERED = PropertyBool.create("powered");
public static final PropertyEnum <blockdoor.enumdoorhalf>HALF = PropertyEnum.<blockdoor.enumdoorhalf>create("half",BlockDoor.EnumDoorHalf.class);
protected static final AxisAlignedBB SOUTH_AABB = new AxisAlignedBB(0.0D, 0.0D, 0.0D, 1.0D, 1.0D, 0.1875D);
protected static final AxisAlignedBB NORTH_AABB = new AxisAlignedBB(0.0D, 0.0D, 0.8125D, 1.0D, 1.0D, 1.0D);
protected static final AxisAlignedBB WEST_AABB = new AxisAlignedBB(0.8125D, 0.0D, 0.0D, 1.0D, 1.0D, 1.0D);
protected static final AxisAlignedBB EAST_AABB = new AxisAlignedBB(0.0D, 0.0D, 0.0D, 0.1875D, 1.0D, 1.0D);
 
protected BlockGardienDoor(Material materialIn)
    {
        super(materialIn);
        this.setDefaultState(this.blockState.getBaseState().withProperty(FACING, EnumFacing.NORTH).withProperty(OPEN, Boolean.valueOf(false)).withProperty(HINGE, BlockDoor.EnumHingePosition.LEFT).withProperty(POWERED, Boolean.valueOf(false)).withProperty(HALF, BlockDoor.EnumDoorHalf.LOWER));
    }
 
public AxisAlignedBB getBoundingBox(IBlockState state, IBlockAccess source, BlockPos pos) {
state = state.getActualState(source, pos);
EnumFacing enumfacing = (EnumFacing) state.getValue(FACING);
boolean flag = !((Boolean) state.getValue(OPEN)).booleanValue();
boolean flag1 = state.getValue(HINGE) == BlockDoor.EnumHingePosition.RIGHT;
 
switch (enumfacing) {
case EAST:
default:
return flag ? EAST_AABB : (flag1 ? NORTH_AABB : SOUTH_AABB);
case SOUTH:
return flag ? SOUTH_AABB : (flag1 ? EAST_AABB : WEST_AABB);
case WEST:
return flag ? WEST_AABB : (flag1 ? SOUTH_AABB : NORTH_AABB);
case NORTH:
return flag ? NORTH_AABB : (flag1 ? WEST_AABB : EAST_AABB);
}
}
 
/**
* Gets the localized name of this block. Used for the statistics page.
*/
public String getLocalizedName() {
return I18n.translateToLocal((this.getUnlocalizedName() + ".name").replaceAll("tile", "item"));
}
 
/**
* Used to determine ambient occlusion and culling when rebuilding chunks
* for render
*/
public boolean isOpaqueCube(IBlockState state) {
return false;
}
 
public boolean isPassable(IBlockAccess worldIn, BlockPos pos) {
return isOpen(combineMetadata(worldIn, pos));
}
 
public boolean isFullCube(IBlockState state) {
return false;
}
 
private int getCloseSound() {
return this.blockMaterial == Material.IRON ? 1011 : 1012;
}
 
private int getOpenSound() {
return this.blockMaterial == Material.IRON ? 1005 : 1006;
}
 
/**
* Get the MapColor for this Block and the given BlockState
*/
public MapColor getMapColor(IBlockState state) {
return state.getBlock() == Blocks.IRON_DOOR ? MapColor.IRON
: (state.getBlock() == Blocks.OAK_DOOR ? BlockPlanks.EnumType.OAK.getMapColor()
: (state.getBlock() == Blocks.SPRUCE_DOOR ? BlockPlanks.EnumType.SPRUCE.getMapColor()
: (state.getBlock() == Blocks.BIRCH_DOOR ? BlockPlanks.EnumType.BIRCH.getMapColor()
: (state.getBlock() == Blocks.JUNGLE_DOOR
? BlockPlanks.EnumType.JUNGLE.getMapColor()
: (state.getBlock() == Blocks.ACACIA_DOOR
? BlockPlanks.EnumType.ACACIA.getMapColor()
: (state.getBlock() == Blocks.DARK_OAK_DOOR
? BlockPlanks.EnumType.DARK_OAK.getMapColor()
: super.getMapColor(state)))))));
}
 
public boolean onBlockActivated(World worldIn, BlockPos pos, IBlockState state, EntityPlayer playerIn,
EnumHand hand, @Nullable ItemStack heldItem, EnumFacing side, float hitX, float hitY, float hitZ) {
if (this.blockMaterial == Material.IRON) {
return false; // Allow items to interact with the door
} else {
BlockPos blockpos = state.getValue(HALF) == BlockDoor.EnumDoorHalf.LOWER ? pos : pos.down();
IBlockState iblockstate = pos.equals(blockpos) ? state : worldIn.getBlockState(blockpos);
 
if (iblockstate.getBlock() != this) {
return false;
} else {
state = iblockstate.cycleProperty(OPEN);
worldIn.setBlockState(blockpos, state, 10);
worldIn.markBlockRangeForRenderUpdate(blockpos, pos);
worldIn.playEvent(playerIn,
((Boolean) state.getValue(OPEN)).booleanValue() ? this.getOpenSound() : this.getCloseSound(),
pos, 0);
return true;
}
}
}
 
public void toggleDoor(World worldIn, BlockPos pos, boolean open) {
IBlockState iblockstate = worldIn.getBlockState(pos);
 
if (iblockstate.getBlock() == this) {
BlockPos blockpos = iblockstate.getValue(HALF) == BlockDoor.EnumDoorHalf.LOWER ? pos : pos.down();
IBlockState iblockstate1 = pos == blockpos ? iblockstate : worldIn.getBlockState(blockpos);
 
if (iblockstate1.getBlock() == this && ((Boolean) iblockstate1.getValue(OPEN)).booleanValue() != open) {
worldIn.setBlockState(blockpos, iblockstate1.withProperty(OPEN, Boolean.valueOf(open)), 10);
worldIn.markBlockRangeForRenderUpdate(blockpos, pos);
worldIn.playEvent((EntityPlayer) null, open ? this.getOpenSound() : this.getCloseSound(), pos, 0);
}
}
}
 
/**
* Called when a neighboring block was changed and marks that this state
* should perform any checks during a neighbor change. Cases may include
* when redstone power is updated, cactus blocks popping off due to a
* neighboring solid block, etc.
*/
public void neighborChanged(IBlockState state, World worldIn, BlockPos pos, Block blockIn) {
if (state.getValue(HALF) == BlockDoor.EnumDoorHalf.UPPER) {
BlockPos blockpos = pos.down();
IBlockState iblockstate = worldIn.getBlockState(blockpos);
 
if (iblockstate.getBlock() != this) {
worldIn.setBlockToAir(pos);
} else if (blockIn != this) {
iblockstate.neighborChanged(worldIn, blockpos, blockIn);
}
} else {
boolean flag1 = false;
BlockPos blockpos1 = pos.up();
IBlockState iblockstate1 = worldIn.getBlockState(blockpos1);
 
if (iblockstate1.getBlock() != this) {
worldIn.setBlockToAir(pos);
flag1 = true;
}
 
if (!worldIn.getBlockState(pos.down()).isSideSolid(worldIn, pos.down(), EnumFacing.UP)) {
worldIn.setBlockToAir(pos);
flag1 = true;
 
if (iblockstate1.getBlock() == this) {
worldIn.setBlockToAir(blockpos1);
}
}
 
if (flag1) {
if (!worldIn.isRemote) {
this.dropBlockAsItem(worldIn, pos, state, 0);
}
} else {
boolean flag = worldIn.isBlockPowered(pos) || worldIn.isBlockPowered(blockpos1);
 
if (blockIn != this && (flag || blockIn.getDefaultState().canProvidePower())
&& flag != ((Boolean) iblockstate1.getValue(POWERED)).booleanValue()) {
worldIn.setBlockState(blockpos1, iblockstate1.withProperty(POWERED, Boolean.valueOf(flag)), 2);
 
if (flag != ((Boolean) state.getValue(OPEN)).booleanValue()) {
worldIn.setBlockState(pos, state.withProperty(OPEN, Boolean.valueOf(flag)), 2);
worldIn.markBlockRangeForRenderUpdate(pos, pos);
worldIn.playEvent((EntityPlayer) null, flag ? this.getOpenSound() : this.getCloseSound(), pos,
0);
}
}
}
}
}
 
/**
* Get the Item that this Block should drop when harvested.
*/
public boolean canPlaceBlockAt(World worldIn, BlockPos pos) {
return pos.getY() >= worldIn.getHeight() - 1 ? false
: worldIn.getBlockState(pos.down()).isSideSolid(worldIn, pos.down(), EnumFacing.UP)
&& super.canPlaceBlockAt(worldIn, pos) && super.canPlaceBlockAt(worldIn, pos.up());
}
 
public EnumPushReaction getMobilityFlag(IBlockState state) {
return EnumPushReaction.DESTROY;
}
 
public static int combineMetadata(IBlockAccess worldIn, BlockPos pos) {
IBlockState iblockstate = worldIn.getBlockState(pos);
int i = iblockstate.getBlock().getMetaFromState(iblockstate);
boolean flag = isTop(i);
IBlockState iblockstate1 = worldIn.getBlockState(pos.down());
int j = iblockstate1.getBlock().getMetaFromState(iblockstate1);
int k = flag ? j : i;
IBlockState iblockstate2 = worldIn.getBlockState(pos.up());
int l = iblockstate2.getBlock().getMetaFromState(iblockstate2);
int i1 = flag ? i : l;
boolean flag1 = (i1 & 1) != 0;
boolean flag2 = (i1 & 2) != 0;
return removeHalfBit(k) | (flag ? 8 : 0) | (flag1 ? 16 : 0) | (flag2 ? 32 : 0);
}
 
public void onBlockHarvested(World worldIn, BlockPos pos, IBlockState state, EntityPlayer player) {
BlockPos blockpos = pos.down();
BlockPos blockpos1 = pos.up();
 
if (player.capabilities.isCreativeMode && state.getValue(HALF) == BlockDoor.EnumDoorHalf.UPPER
&& worldIn.getBlockState(blockpos).getBlock() == this) {
worldIn.setBlockToAir(blockpos);
}
 
if (state.getValue(HALF) == BlockDoor.EnumDoorHalf.LOWER
&& worldIn.getBlockState(blockpos1).getBlock() == this) {
if (player.capabilities.isCreativeMode) {
worldIn.setBlockToAir(pos);
}
 
worldIn.setBlockToAir(blockpos1);
}
}
 
@SideOnly(Side.CLIENT)
public BlockRenderLayer getBlockLayer() {
return BlockRenderLayer.CUTOUT;
}
 
/**
* Get the actual Block state of this Block at the given position. This
* applies properties not visible in the metadata, such as fence
* connections.
*/
public IBlockState getActualState(IBlockState state, IBlockAccess worldIn, BlockPos pos) {
if (state.getValue(HALF) == BlockDoor.EnumDoorHalf.LOWER) {
IBlockState iblockstate = worldIn.getBlockState(pos.up());
 
if (iblockstate.getBlock() == this) {
state = state.withProperty(HINGE, iblockstate.getValue(HINGE)).withProperty(POWERED,
iblockstate.getValue(POWERED));
}
} else {
IBlockState iblockstate1 = worldIn.getBlockState(pos.down());
 
if (iblockstate1.getBlock() == this) {
state = state.withProperty(FACING, iblockstate1.getValue(FACING)).withProperty(OPEN,
iblockstate1.getValue(OPEN));
}
}
 
return state;
}
 
/**
* Returns the blockstate with the given rotation from the passed
* blockstate. If inapplicable, returns the passed blockstate.
*/
public IBlockState withRotation(IBlockState state, Rotation rot) {
return state.getValue(HALF) != BlockDoor.EnumDoorHalf.LOWER ? state
: state.withProperty(FACING, rot.rotate((EnumFacing) state.getValue(FACING)));
}
 
/**
* Returns the blockstate with the given mirror of the passed blockstate. If
* inapplicable, returns the passed blockstate.
*/
public IBlockState withMirror(IBlockState state, Mirror mirrorIn) {
return mirrorIn == Mirror.NONE ? state
: state.withRotation(mirrorIn.toRotation((EnumFacing) state.getValue(FACING))).cycleProperty(HINGE);
}
 
/**
* Convert the given metadata into a BlockState for this Block
*/
public IBlockState getStateFromMeta(int meta) {
return (meta & 8) > 0
? this.getDefaultState().withProperty(HALF, BlockDoor.EnumDoorHalf.UPPER)
.withProperty(HINGE,
(meta & 1) > 0 ? BlockDoor.EnumHingePosition.RIGHT : BlockDoor.EnumHingePosition.LEFT)
.withProperty(POWERED, Boolean.valueOf((meta & 2) > 0))
: this.getDefaultState().withProperty(HALF, BlockDoor.EnumDoorHalf.LOWER)
.withProperty(FACING, EnumFacing.getHorizontal(meta & 3).rotateYCCW())
.withProperty(OPEN, Boolean.valueOf((meta & 4) > 0));
}
 
/**
* Convert the BlockState into the correct metadata value
*/
public int getMetaFromState(IBlockState state) {
int i = 0;
 
if (state.getValue(HALF) == BlockDoor.EnumDoorHalf.UPPER) {
i = i | 8;
 
if (state.getValue(HINGE) == BlockDoor.EnumHingePosition.RIGHT) {
i |= 1;
}
 
if (((Boolean) state.getValue(POWERED)).booleanValue()) {
i |= 2;
}
} else {
i = i | ((EnumFacing) state.getValue(FACING)).rotateY().getHorizontalIndex();
 
if (((Boolean) state.getValue(OPEN)).booleanValue()) {
i |= 4;
}
}
 
return i;
}
 
protected static int removeHalfBit(int meta) {
return meta & 7;
}
 
public static boolean isOpen(IBlockAccess worldIn, BlockPos pos) {
return isOpen(combineMetadata(worldIn, pos));
}
 
public static EnumFacing getFacing(IBlockAccess worldIn, BlockPos pos) {
return getFacing(combineMetadata(worldIn, pos));
}
 
public static EnumFacing getFacing(int combinedMeta) {
return EnumFacing.getHorizontal(combinedMeta & 3).rotateYCCW();
}
 
protected static boolean isOpen(int combinedMeta) {
return (combinedMeta & 4) != 0;
}
 
protected static boolean isTop(int meta) {
return (meta & 8) != 0;
}
 
protected BlockStateContainer createBlockState() {
return new BlockStateContainer(this, new IProperty[] { HALF, FACING, OPEN, HINGE, POWERED });
}
 
public static enum EnumDoorHalf implements IStringSerializable {
UPPER, LOWER;
 
public String toString() {
return this.getName();
}
 
public String getName() {
return this == UPPER ? "upper" : "lower";
}
}
 
public static enum EnumHingePosition implements IStringSerializable {
LEFT, RIGHT;
 
public String toString() {
return this.getName();
}
 
public String getName() {
return this == LEFT ? "left" : "right";
}
}
 
}
 
```</blockdoor.enumdoorhalf></blockdoor.enumdoorhalf></blockdoor.enumhingeposition></blockdoor.enumhingeposition>

[AymericRed]

Salut,
Nous ne sommes pas devins ^^ Peux-tu donner les messages d’erreur que ton IDE donne ?

[AzTick_]

@‘AymericRed’:

Salut,
Nous ne sommes pas devins ^^ Peux-tu donner les messages d’erreur que ton IDE donne ?

Slaut,
Désolé xD voici un screen de l’erreur ^^

http://prntscr.com/iq8x6d

[AymericRed]

Ici java public static final PropertyEnum <blockdoor.enumhingeposition>HINGE = PropertyEnum.<blockdoor.enumhingeposition>create("hinge", BlockDoor.EnumHingePosition.class); et ici ```java
public static final PropertyEnum <blockdoor.enumdoorhalf>HALF = PropertyEnum.<blockdoor.enumdoorhalf>create(“half”,BlockDoor.EnumDoorHalf.class);

[AzTick_]

@‘AymericRed’:

Ici java public static final PropertyEnum <blockdoor.enumhingeposition>HINGE = PropertyEnum.<blockdoor.enumhingeposition>create("hinge", BlockDoor.EnumHingePosition.class); et ici ```java
public static final PropertyEnum <blockdoor.enumdoorhalf>HALF = PropertyEnum.<blockdoor.enumdoorhalf>create(“half”,BlockDoor.EnumDoorHalf.class);

Merci beaucoup, sa fonctionne