Problème GUI

SCAREX

Tu t’es trompé dans les ID : java.lang.ClassCastException: eryah.usefulthings.tileentity.TileEntityCrusher cannot be cast to eryah.usefulthings.tileentity.TileEntityPlateCrafter tu essaie de cast une tileEntity à une autre.

Eryah

Je ne pense pas. Enfin le crash report le dit mais je ne voit pas ou
Le GUICrusher a comme ID 0, le Platecrafter 1, et mon GUIHandler cast Platecrafter pour le Platecrafter etc

 package eryah.usefulthings;
 
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.util.BlockPos;
import net.minecraft.world.World;
import net.minecraftforge.fml.common.network.IGuiHandler;
import eryah.usefulthings.container.ContainerCrusher;
import eryah.usefulthings.container.ContainerPlateCrafter;
import eryah.usefulthings.gui.GuiCrusher;
import eryah.usefulthings.gui.GuiPlateCrafter;
import eryah.usefulthings.tileentity.TileEntityCrusher;
import eryah.usefulthings.tileentity.TileEntityPlateCrafter;
 
public class GuiHandler implements IGuiHandler {
 
@Override
public Object getServerGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) {
 
switch (ID) {
case 0:
return new ContainerCrusher(((TileEntityCrusher)world.getTileEntity(new BlockPos(x, y, z))), player.inventory);
case 1:
return new ContainerPlateCrafter(((TileEntityPlateCrafter)world.getTileEntity(new BlockPos(x, y, z))), player.inventory);
}
return null;
}
 
@Override
public Object getClientGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) {
 
switch (ID) {
case 0:
return new GuiCrusher(((TileEntityCrusher)world.getTileEntity(new BlockPos(x, y, z))), player.inventory);
case 1:
return new GuiPlateCrafter(((TileEntityPlateCrafter)world.getTileEntity(new BlockPos(x, y, z))), player.inventory);
}
 
return null;
}
 
}

SCAREX

Envoi l’appel de la fonction player.openGui

Eryah

Crusher

 public boolean onBlockActivated(World worldIn, BlockPos pos, IBlockState state, EntityPlayer playerIn, EnumFacing side, float hitX, float hitY, float hitZ)
{
    playerIn.openGui(UsefulthingsMod.instance, 0, worldIn, pos.getX(), pos.getY(), pos.getZ());
return true;
}

PlateCrafter

 public boolean onBlockActivated(World worldIn, BlockPos pos, IBlockState state, EntityPlayer playerIn, EnumFacing side, float hitX, float hitY, float hitZ)
{
    playerIn.openGui(UsefulthingsMod.instance, 1, worldIn, pos.getX(), pos.getY(), pos.getZ());
return true;
}

SCAREX

Envoi la classe entière du block.

Eryah

Crusher

 package eryah.usefulthings.blocks;
 
import java.util.Random;
 
import net.minecraft.block.Block;
import net.minecraft.block.BlockContainer;
import net.minecraft.block.material.Material;
import net.minecraft.block.properties.IProperty;
import net.minecraft.block.properties.PropertyDirection;
import net.minecraft.block.state.BlockState;
import net.minecraft.block.state.IBlockState;
import net.minecraft.client.Minecraft;
import net.minecraft.client.resources.model.ModelResourceLocation;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Blocks;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.InventoryHelper;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.EnumParticleTypes;
import net.minecraft.util.MathHelper;
import net.minecraft.world.World;
import net.minecraftforge.fml.common.network.internal.FMLNetworkHandler;
import net.minecraftforge.fml.common.registry.GameRegistry;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
import eryah.usefulthings.Reference;
import eryah.usefulthings.UsefulthingsMod;
import eryah.usefulthings.tileentity.TileEntityCrusher;
 
public class Crusher extends BlockContainer
{
    public static final PropertyDirection FACING = PropertyDirection.create("facing", EnumFacing.Plane.HORIZONTAL);
    private static boolean isBurning;
    private static boolean keepInventory;
    private static final String __OBFID = "CL_00000248";
    public static Block crusher;
 
    protected Crusher(Material mat, boolean isBurning)
    {
        super(Material.rock);
        this.setDefaultState(this.blockState.getBaseState().withProperty(FACING, EnumFacing.NORTH));
        this.isBurning = isBurning;
    }
 
public static void init()
{
crusher = new Crusher(Material.rock, isBurning).setUnlocalizedName("crusher").setCreativeTab(UsefulthingsMod.UTTab);
}
 
public static void register()
{
GameRegistry.registerBlock(crusher, crusher.getUnlocalizedName().substring(5));
}
 
public static void registerRenders()
{
registerRender(crusher);
}
 
public static void registerRender(Block block)
{
Item item = Item.getItemFromBlock(block);
Minecraft.getMinecraft().getRenderItem().getItemModelMesher().register(item, 0, new ModelResourceLocation(Reference.MOD_ID + ":" + item.getUnlocalizedName().substring(5), "inventory"));
}
 
    /**
     * Get the Item that this Block should drop when harvested.
     *  
     * @param fortune the level of the Fortune enchantment on the player's tool
     */
 
    public void onBlockAdded(World worldIn, BlockPos pos, IBlockState state)
    {
        this.setDefaultFacing(worldIn, pos, state);
    }
 
    private void setDefaultFacing(World worldIn, BlockPos pos, IBlockState state)
    {
        if (!worldIn.isRemote)
        {
            Block block = worldIn.getBlockState(pos.north()).getBlock();
            Block block1 = worldIn.getBlockState(pos.south()).getBlock();
            Block block2 = worldIn.getBlockState(pos.west()).getBlock();
            Block block3 = worldIn.getBlockState(pos.east()).getBlock();
            EnumFacing enumfacing = (EnumFacing)state.getValue(FACING);
 
            if (enumfacing == EnumFacing.NORTH && block.isFullBlock() && !block1.isFullBlock())
            {
                enumfacing = EnumFacing.SOUTH;
            }
            else if (enumfacing == EnumFacing.SOUTH && block1.isFullBlock() && !block.isFullBlock())
            {
                enumfacing = EnumFacing.NORTH;
            }
            else if (enumfacing == EnumFacing.WEST && block2.isFullBlock() && !block3.isFullBlock())
            {
                enumfacing = EnumFacing.EAST;
            }
            else if (enumfacing == EnumFacing.EAST && block3.isFullBlock() && !block2.isFullBlock())
            {
                enumfacing = EnumFacing.WEST;
            }
 
            worldIn.setBlockState(pos, state.withProperty(FACING, enumfacing), 2);
        }
    }
 
    @SideOnly(Side.CLIENT)
    public void randomDisplayTick(World worldIn, BlockPos pos, IBlockState state, Random rand)
    {
        if (this.isBurning)
        {
            EnumFacing enumfacing = (EnumFacing)state.getValue(FACING);
            double d0 = (double)pos.getX() + 0.5D;
            double d1 = (double)pos.getY() + rand.nextDouble() * 6.0D / 16.0D;
            double d2 = (double)pos.getZ() + 0.5D;
            double d3 = 0.52D;
            double d4 = rand.nextDouble() * 0.6D - 0.3D;
 
            switch (Crusher.SwitchEnumFacing.FACING_LOOKUP[enumfacing.ordinal()])
            {
                case 1:
                    worldIn.spawnParticle(EnumParticleTypes.SMOKE_NORMAL, d0 - d3, d1, d2 + d4, 0.0D, 0.0D, 0.0D, new int[0]);
                    worldIn.spawnParticle(EnumParticleTypes.FLAME, d0 - d3, d1, d2 + d4, 0.0D, 0.0D, 0.0D, new int[0]);
                    break;
                case 2:
                    worldIn.spawnParticle(EnumParticleTypes.SMOKE_NORMAL, d0 + d3, d1, d2 + d4, 0.0D, 0.0D, 0.0D, new int[0]);
                    worldIn.spawnParticle(EnumParticleTypes.FLAME, d0 + d3, d1, d2 + d4, 0.0D, 0.0D, 0.0D, new int[0]);
                    break;
                case 3:
                    worldIn.spawnParticle(EnumParticleTypes.SMOKE_NORMAL, d0 + d4, d1, d2 - d3, 0.0D, 0.0D, 0.0D, new int[0]);
                    worldIn.spawnParticle(EnumParticleTypes.FLAME, d0 + d4, d1, d2 - d3, 0.0D, 0.0D, 0.0D, new int[0]);
                    break;
                case 4:
                    worldIn.spawnParticle(EnumParticleTypes.SMOKE_NORMAL, d0 + d4, d1, d2 + d3, 0.0D, 0.0D, 0.0D, new int[0]);
                    worldIn.spawnParticle(EnumParticleTypes.FLAME, d0 + d4, d1, d2 + d3, 0.0D, 0.0D, 0.0D, new int[0]);
            }
        }
    }
 
    @Override
    public boolean onBlockActivated(World worldIn, BlockPos pos, IBlockState state, EntityPlayer playerIn, EnumFacing side, float hitX, float hitY, float hitZ)
{
    playerIn.openGui(UsefulthingsMod.instance, 0, worldIn, pos.getX(), pos.getY(), pos.getZ());
return true;
}
 
    public static void setState(boolean active, World worldIn, BlockPos pos)
    {
        IBlockState iblockstate = worldIn.getBlockState(pos);
        TileEntity tileentity = worldIn.getTileEntity(pos);
        keepInventory = true;
 
        if (active)
        {
            worldIn.setBlockState(pos, LitCrusher.lit_crusher.getDefaultState().withProperty(FACING, iblockstate.getValue(FACING)), 3);
            worldIn.setBlockState(pos, LitCrusher.lit_crusher.getDefaultState().withProperty(FACING, iblockstate.getValue(FACING)), 3);
        }
        else
        {
            worldIn.setBlockState(pos, Crusher.crusher.getDefaultState().withProperty(FACING, iblockstate.getValue(FACING)), 3);
            worldIn.setBlockState(pos, Crusher.crusher.getDefaultState().withProperty(FACING, iblockstate.getValue(FACING)), 3);
        }
 
        keepInventory = false;
 
        if (tileentity != null)
        {
            tileentity.validate();
            worldIn.setTileEntity(pos, tileentity);
        }
    }
 
    /**
     * Returns a new instance of a block's tile entity class. Called on placing the block.
     */
    public TileEntity createNewTileEntity(World worldIn, int meta)
    {
        return new TileEntityCrusher();
    }
 
    public IBlockState onBlockPlaced(World worldIn, BlockPos pos, EnumFacing facing, float hitX, float hitY, float hitZ, int meta, EntityLivingBase placer)
    {
        return this.getDefaultState().withProperty(FACING, placer.getHorizontalFacing().getOpposite());
    }
 
    public void onBlockPlacedBy(World worldIn, BlockPos pos, IBlockState state, EntityLivingBase placer, ItemStack stack)
    {
        worldIn.setBlockState(pos, state.withProperty(FACING, placer.getHorizontalFacing().getOpposite()), 2);
 
        if (stack.hasDisplayName())
        {
            TileEntity tileentity = worldIn.getTileEntity(pos);
 
            if (tileentity instanceof TileEntityCrusher)
            {
                ((TileEntityCrusher)tileentity).setCustomInventoryName(stack.getDisplayName());
            }
        }
    }
 
    public void breakBlock(World worldIn, BlockPos pos, IBlockState state)
    {
        if (!keepInventory)
        {
            TileEntity tileentity = worldIn.getTileEntity(pos);
 
            if (tileentity instanceof TileEntityCrusher)
            {
                InventoryHelper.dropInventoryItems(worldIn, pos, (TileEntityCrusher)tileentity);
                worldIn.updateComparatorOutputLevel(pos, this);
            }
        }
 
        super.breakBlock(worldIn, pos, state);
    }
 
    public boolean hasComparatorInputOverride()
    {
        return true;
    }
 
    public int getComparatorInputOverride(World worldIn, BlockPos pos)
    {
        return Container.calcRedstone(worldIn.getTileEntity(pos));
    }
 
    @SideOnly(Side.CLIENT)
    public Item getItem(World worldIn, BlockPos pos)
    {
        return Item.getItemFromBlock(Crusher.crusher);
    }
 
    /**
     * The type of render function that is called for this block
     */
 
    /**
     * Possibly modify the given BlockState before rendering it on an Entity (Minecarts, Endermen, …)
     */
    @SideOnly(Side.CLIENT)
    public IBlockState getStateForEntityRender(IBlockState state)
    {
        return this.getDefaultState().withProperty(FACING, EnumFacing.SOUTH);
    }
 
    /**
     * Convert the given metadata into a BlockState for this Block
     */
    public IBlockState getStateFromMeta(int meta)
    {
        EnumFacing enumfacing = EnumFacing.getFront(meta);
 
        if (enumfacing.getAxis() == EnumFacing.Axis.Y)
        {
            enumfacing = EnumFacing.NORTH;
        }
 
        return this.getDefaultState().withProperty(FACING, enumfacing);
    }
 
    /**
     * Convert the BlockState into the correct metadata value
     */
    public int getMetaFromState(IBlockState state)
    {
        return ((EnumFacing)state.getValue(FACING)).getIndex();
    }
 
    protected BlockState createBlockState()
    {
        return new BlockState(this, new IProperty[] {FACING});
    }
 
    @SideOnly(Side.CLIENT)
 
    static final class SwitchEnumFacing
        {
            static final int[] FACING_LOOKUP = new int[EnumFacing.values().length];
            private static final String __OBFID = "CL_00002111";
 
            static
            {
                try
                {
                    FACING_LOOKUP[EnumFacing.WEST.ordinal()] = 1;
                }
                catch (NoSuchFieldError var4)
                {
                    ;
                }
 
                try
                {
                    FACING_LOOKUP[EnumFacing.EAST.ordinal()] = 2;
                }
                catch (NoSuchFieldError var3)
                {
                    ;
                }
 
                try
                {
                    FACING_LOOKUP[EnumFacing.NORTH.ordinal()] = 3;
                }
                catch (NoSuchFieldError var2)
                {
                    ;
                }
 
                try
                {
                    FACING_LOOKUP[EnumFacing.SOUTH.ordinal()] = 4;
                }
                catch (NoSuchFieldError var1)
                {
                    ;
                }
            }
        }
 
    public boolean isOpaqueCube()
    {
        return false;
    }
 
    public boolean renderAsNormalBlock()
    {
        return false;
    }
 
    public int getRenderType()
    {
        return -1;
    }
}

PlateCrafter

 package eryah.usefulthings.blocks;
 
import java.util.Random;
 
import net.minecraft.block.Block;
import net.minecraft.block.BlockContainer;
import net.minecraft.block.material.Material;
import net.minecraft.block.properties.IProperty;
import net.minecraft.block.properties.PropertyDirection;
import net.minecraft.block.state.BlockState;
import net.minecraft.block.state.IBlockState;
import net.minecraft.client.Minecraft;
import net.minecraft.client.resources.model.ModelResourceLocation;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Blocks;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.InventoryHelper;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.EnumParticleTypes;
import net.minecraft.util.MathHelper;
import net.minecraft.world.World;
import net.minecraftforge.fml.common.network.internal.FMLNetworkHandler;
import net.minecraftforge.fml.common.registry.GameRegistry;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
import eryah.usefulthings.Reference;
import eryah.usefulthings.UsefulthingsMod;
import eryah.usefulthings.tileentity.TileEntityPlateCrafter;
import eryah.usefulthings.tileentity.TileEntityPlateCrafter;
 
public class PlateCrafter extends BlockContainer
{
    public static final PropertyDirection FACING = PropertyDirection.create("facing", EnumFacing.Plane.HORIZONTAL);
    private static boolean isBurning;
    private static boolean keepInventory;
    private static final String __OBFID = "CL_00000248";
    public static Block platecrafter;
 
    protected PlateCrafter(Material mat, boolean isBurning)
    {
        super(Material.rock);
        this.setDefaultState(this.blockState.getBaseState().withProperty(FACING, EnumFacing.NORTH));
        this.isBurning = isBurning;
    }
 
public static void init()
{
platecrafter = new PlateCrafter(Material.rock, isBurning).setUnlocalizedName("platecrafter").setCreativeTab(UsefulthingsMod.UTTab);
}
 
public static void register()
{
GameRegistry.registerBlock(platecrafter, platecrafter.getUnlocalizedName().substring(5));
}
 
public static void registerRenders()
{
registerRender(platecrafter);
}
 
public static void registerRender(Block block)
{
Item item = Item.getItemFromBlock(block);
Minecraft.getMinecraft().getRenderItem().getItemModelMesher().register(item, 0, new ModelResourceLocation(Reference.MOD_ID + ":" + item.getUnlocalizedName().substring(5), "inventory"));
}
 
    /**
     * Get the Item that this Block should drop when harvested.
     *  
     * @param fortune the level of the Fortune enchantment on the player's tool
     */
 
    public void onBlockAdded(World worldIn, BlockPos pos, IBlockState state)
    {
        this.setDefaultFacing(worldIn, pos, state);
    }
 
    private void setDefaultFacing(World worldIn, BlockPos pos, IBlockState state)
    {
        if (!worldIn.isRemote)
        {
            Block block = worldIn.getBlockState(pos.north()).getBlock();
            Block block1 = worldIn.getBlockState(pos.south()).getBlock();
            Block block2 = worldIn.getBlockState(pos.west()).getBlock();
            Block block3 = worldIn.getBlockState(pos.east()).getBlock();
            EnumFacing enumfacing = (EnumFacing)state.getValue(FACING);
 
            if (enumfacing == EnumFacing.NORTH && block.isFullBlock() && !block1.isFullBlock())
            {
                enumfacing = EnumFacing.SOUTH;
            }
            else if (enumfacing == EnumFacing.SOUTH && block1.isFullBlock() && !block.isFullBlock())
            {
                enumfacing = EnumFacing.NORTH;
            }
            else if (enumfacing == EnumFacing.WEST && block2.isFullBlock() && !block3.isFullBlock())
            {
                enumfacing = EnumFacing.EAST;
            }
            else if (enumfacing == EnumFacing.EAST && block3.isFullBlock() && !block2.isFullBlock())
            {
                enumfacing = EnumFacing.WEST;
            }
 
            worldIn.setBlockState(pos, state.withProperty(FACING, enumfacing), 2);
        }
    }
 
    @SideOnly(Side.CLIENT)
    public void randomDisplayTick(World worldIn, BlockPos pos, IBlockState state, Random rand)
    {
        if (this.isBurning)
        {
            EnumFacing enumfacing = (EnumFacing)state.getValue(FACING);
            double d0 = (double)pos.getX() + 0.5D;
            double d1 = (double)pos.getY() + rand.nextDouble() * 6.0D / 16.0D;
            double d2 = (double)pos.getZ() + 0.5D;
            double d3 = 0.52D;
            double d4 = rand.nextDouble() * 0.6D - 0.3D;
 
            switch (PlateCrafter.SwitchEnumFacing.FACING_LOOKUP[enumfacing.ordinal()])
            {
                case 1:
                    worldIn.spawnParticle(EnumParticleTypes.SMOKE_NORMAL, d0 - d3, d1, d2 + d4, 0.0D, 0.0D, 0.0D, new int[0]);
                    worldIn.spawnParticle(EnumParticleTypes.FLAME, d0 - d3, d1, d2 + d4, 0.0D, 0.0D, 0.0D, new int[0]);
                    break;
                case 2:
                    worldIn.spawnParticle(EnumParticleTypes.SMOKE_NORMAL, d0 + d3, d1, d2 + d4, 0.0D, 0.0D, 0.0D, new int[0]);
                    worldIn.spawnParticle(EnumParticleTypes.FLAME, d0 + d3, d1, d2 + d4, 0.0D, 0.0D, 0.0D, new int[0]);
                    break;
                case 3:
                    worldIn.spawnParticle(EnumParticleTypes.SMOKE_NORMAL, d0 + d4, d1, d2 - d3, 0.0D, 0.0D, 0.0D, new int[0]);
                    worldIn.spawnParticle(EnumParticleTypes.FLAME, d0 + d4, d1, d2 - d3, 0.0D, 0.0D, 0.0D, new int[0]);
                    break;
                case 4:
                    worldIn.spawnParticle(EnumParticleTypes.SMOKE_NORMAL, d0 + d4, d1, d2 + d3, 0.0D, 0.0D, 0.0D, new int[0]);
                    worldIn.spawnParticle(EnumParticleTypes.FLAME, d0 + d4, d1, d2 + d3, 0.0D, 0.0D, 0.0D, new int[0]);
            }
        }
    }
 
    @Override
    public boolean onBlockActivated(World worldIn, BlockPos pos, IBlockState state, EntityPlayer playerIn, EnumFacing side, float hitX, float hitY, float hitZ)
{
    playerIn.openGui(UsefulthingsMod.instance, 1, worldIn, pos.getX(), pos.getY(), pos.getZ());
return true;
}
 
    /**
     * Returns a new instance of a block's tile entity class. Called on placing the block.
     */
    public TileEntity createNewTileEntity(World worldIn, int meta)
    {
        return new TileEntityPlateCrafter();
    }
 
    public IBlockState onBlockPlaced(World worldIn, BlockPos pos, EnumFacing facing, float hitX, float hitY, float hitZ, int meta, EntityLivingBase placer)
    {
        return this.getDefaultState().withProperty(FACING, placer.getHorizontalFacing().getOpposite());
    }
 
    public void onBlockPlacedBy(World worldIn, BlockPos pos, IBlockState state, EntityLivingBase placer, ItemStack stack)
    {
        worldIn.setBlockState(pos, state.withProperty(FACING, placer.getHorizontalFacing().getOpposite()), 2);
 
        if (stack.hasDisplayName())
        {
            TileEntity tileentity = worldIn.getTileEntity(pos);
 
            if (tileentity instanceof TileEntityPlateCrafter)
            {
                ((TileEntityPlateCrafter)tileentity).setCustomInventoryName(stack.getDisplayName());
            }
        }
    }
 
    public void breakBlock(World worldIn, BlockPos pos, IBlockState state)
    {
        if (!keepInventory)
        {
            TileEntity tileentity = worldIn.getTileEntity(pos);
 
            if (tileentity instanceof TileEntityPlateCrafter)
            {
                InventoryHelper.dropInventoryItems(worldIn, pos, (TileEntityPlateCrafter)tileentity);
                worldIn.updateComparatorOutputLevel(pos, this);
            }
        }
 
        super.breakBlock(worldIn, pos, state);
    }
 
    public boolean hasComparatorInputOverride()
    {
        return true;
    }
 
    public int getComparatorInputOverride(World worldIn, BlockPos pos)
    {
        return Container.calcRedstone(worldIn.getTileEntity(pos));
    }
 
    @SideOnly(Side.CLIENT)
    public Item getItem(World worldIn, BlockPos pos)
    {
        return Item.getItemFromBlock(PlateCrafter.platecrafter);
    }
 
    /**
     * The type of render function that is called for this block
     */
 
    /**
     * Possibly modify the given BlockState before rendering it on an Entity (Minecarts, Endermen, …)
     */
    @SideOnly(Side.CLIENT)
    public IBlockState getStateForEntityRender(IBlockState state)
    {
        return this.getDefaultState().withProperty(FACING, EnumFacing.SOUTH);
    }
 
    /**
     * Convert the given metadata into a BlockState for this Block
     */
    public IBlockState getStateFromMeta(int meta)
    {
        EnumFacing enumfacing = EnumFacing.getFront(meta);
 
        if (enumfacing.getAxis() == EnumFacing.Axis.Y)
        {
            enumfacing = EnumFacing.NORTH;
        }
 
        return this.getDefaultState().withProperty(FACING, enumfacing);
    }
 
    /**
     * Convert the BlockState into the correct metadata value
     */
    public int getMetaFromState(IBlockState state)
    {
        return ((EnumFacing)state.getValue(FACING)).getIndex();
    }
 
    protected BlockState createBlockState()
    {
        return new BlockState(this, new IProperty[] {FACING});
    }
 
    @SideOnly(Side.CLIENT)
 
    static final class SwitchEnumFacing
        {
            static final int[] FACING_LOOKUP = new int[EnumFacing.values().length];
            private static final String __OBFID = "CL_00002111";
 
            static
            {
                try
                {
                    FACING_LOOKUP[EnumFacing.WEST.ordinal()] = 1;
                }
                catch (NoSuchFieldError var4)
                {
                    ;
                }
 
                try
                {
                    FACING_LOOKUP[EnumFacing.EAST.ordinal()] = 2;
                }
                catch (NoSuchFieldError var3)
                {
                    ;
                }
 
                try
                {
                    FACING_LOOKUP[EnumFacing.NORTH.ordinal()] = 3;
                }
                catch (NoSuchFieldError var2)
                {
                    ;
                }
 
                try
                {
                    FACING_LOOKUP[EnumFacing.SOUTH.ordinal()] = 4;
                }
                catch (NoSuchFieldError var1)
                {
                    ;
                }
            }
        }
 
    public boolean isOpaqueCube()
    {
        return false;
    }
 
    public boolean renderAsNormalBlock()
    {
        return false;
    }
 
    public int getRenderType()
    {
        return -1;
    }
}

SCAREX

Essaie de casser ton block et de le reposer, car normalement c’est pas possible.

Eryah

Ah oui ça fonctionne.
Je pense qu’il y a eu un problème de synchronisation ou quelque chose comme cela qui fait que le bloc pense qu’il doit toujours ouvrir le GUI 1
Je vais pouvoir, enfin mettre ce topic en résolu
Espèrons a ne jamais devoir le remettre en non-resolu
Dire que la 1ere phrase du topic était : Un topic qui je pens,e sera court…
Eh bien c’est mon plus long topic

	package eryah.usefulthings;

	import net.minecraft.entity.player.EntityPlayer;
	import net.minecraft.util.BlockPos;
	import net.minecraft.world.World;
	import net.minecraftforge.fml.common.network.IGuiHandler;
	import eryah.usefulthings.container.ContainerCrusher;
	import eryah.usefulthings.container.ContainerPlateCrafter;
	import eryah.usefulthings.gui.GuiCrusher;
	import eryah.usefulthings.gui.GuiPlateCrafter;
	import eryah.usefulthings.tileentity.TileEntityCrusher;
	import eryah.usefulthings.tileentity.TileEntityPlateCrafter;

	public class GuiHandler implements IGuiHandler {

	@Override
	public Object getServerGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) {

	switch (ID) {
	case 0:
	return new ContainerCrusher(((TileEntityCrusher)world.getTileEntity(new BlockPos(x, y, z))), player.inventory);
	case 1:
	return new ContainerPlateCrafter(((TileEntityPlateCrafter)world.getTileEntity(new BlockPos(x, y, z))), player.inventory);
	}
	return null;
	}

	@Override
	public Object getClientGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) {

	switch (ID) {
	case 0:
	return new GuiCrusher(((TileEntityCrusher)world.getTileEntity(new BlockPos(x, y, z))), player.inventory);
	case 1:
	return new GuiPlateCrafter(((TileEntityPlateCrafter)world.getTileEntity(new BlockPos(x, y, z))), player.inventory);
	}

	return null;
	}

	}

	public boolean onBlockActivated(World worldIn, BlockPos pos, IBlockState state, EntityPlayer playerIn, EnumFacing side, float hitX, float hitY, float hitZ)
	{
	playerIn.openGui(UsefulthingsMod.instance, 0, worldIn, pos.getX(), pos.getY(), pos.getZ());
	return true;
	}

	package eryah.usefulthings.blocks;

	import java.util.Random;

	import net.minecraft.block.Block;
	import net.minecraft.block.BlockContainer;
	import net.minecraft.block.material.Material;
	import net.minecraft.block.properties.IProperty;
	import net.minecraft.block.properties.PropertyDirection;
	import net.minecraft.block.state.BlockState;
	import net.minecraft.block.state.IBlockState;
	import net.minecraft.client.Minecraft;
	import net.minecraft.client.resources.model.ModelResourceLocation;
	import net.minecraft.entity.EntityLivingBase;
	import net.minecraft.entity.player.EntityPlayer;
	import net.minecraft.init.Blocks;
	import net.minecraft.inventory.Container;
	import net.minecraft.inventory.InventoryHelper;
	import net.minecraft.item.Item;
	import net.minecraft.item.ItemStack;
	import net.minecraft.tileentity.TileEntity;
	import net.minecraft.util.BlockPos;
	import net.minecraft.util.EnumFacing;
	import net.minecraft.util.EnumParticleTypes;
	import net.minecraft.util.MathHelper;
	import net.minecraft.world.World;
	import net.minecraftforge.fml.common.network.internal.FMLNetworkHandler;
	import net.minecraftforge.fml.common.registry.GameRegistry;
	import net.minecraftforge.fml.relauncher.Side;
	import net.minecraftforge.fml.relauncher.SideOnly;
	import eryah.usefulthings.Reference;
	import eryah.usefulthings.UsefulthingsMod;
	import eryah.usefulthings.tileentity.TileEntityCrusher;

	public class Crusher extends BlockContainer
	{
	public static final PropertyDirection FACING = PropertyDirection.create("facing", EnumFacing.Plane.HORIZONTAL);
	private static boolean isBurning;
	private static boolean keepInventory;
	private static final String __OBFID = "CL_00000248";
	public static Block crusher;

	protected Crusher(Material mat, boolean isBurning)
	{
	super(Material.rock);
	this.setDefaultState(this.blockState.getBaseState().withProperty(FACING, EnumFacing.NORTH));
	this.isBurning = isBurning;
	}

	public static void init()
	{
	crusher = new Crusher(Material.rock, isBurning).setUnlocalizedName("crusher").setCreativeTab(UsefulthingsMod.UTTab);
	}

	public static void register()
	{
	GameRegistry.registerBlock(crusher, crusher.getUnlocalizedName().substring(5));
	}

	public static void registerRenders()
	{
	registerRender(crusher);
	}

	public static void registerRender(Block block)
	{
	Item item = Item.getItemFromBlock(block);
	Minecraft.getMinecraft().getRenderItem().getItemModelMesher().register(item, 0, new ModelResourceLocation(Reference.MOD_ID + ":" + item.getUnlocalizedName().substring(5), "inventory"));
	}

	/**
	* Get the Item that this Block should drop when harvested.
	*
	* @param fortune the level of the Fortune enchantment on the player's tool
	*/

	public void onBlockAdded(World worldIn, BlockPos pos, IBlockState state)
	{
	this.setDefaultFacing(worldIn, pos, state);
	}

	private void setDefaultFacing(World worldIn, BlockPos pos, IBlockState state)
	{
	if (!worldIn.isRemote)
	{
	Block block = worldIn.getBlockState(pos.north()).getBlock();
	Block block1 = worldIn.getBlockState(pos.south()).getBlock();
	Block block2 = worldIn.getBlockState(pos.west()).getBlock();
	Block block3 = worldIn.getBlockState(pos.east()).getBlock();
	EnumFacing enumfacing = (EnumFacing)state.getValue(FACING);

	if (enumfacing == EnumFacing.NORTH && block.isFullBlock() && !block1.isFullBlock())
	{
	enumfacing = EnumFacing.SOUTH;
	}
	else if (enumfacing == EnumFacing.SOUTH && block1.isFullBlock() && !block.isFullBlock())
	{
	enumfacing = EnumFacing.NORTH;
	}
	else if (enumfacing == EnumFacing.WEST && block2.isFullBlock() && !block3.isFullBlock())
	{
	enumfacing = EnumFacing.EAST;
	}
	else if (enumfacing == EnumFacing.EAST && block3.isFullBlock() && !block2.isFullBlock())
	{
	enumfacing = EnumFacing.WEST;
	}

	worldIn.setBlockState(pos, state.withProperty(FACING, enumfacing), 2);
	}
	}

	@SideOnly(Side.CLIENT)
	public void randomDisplayTick(World worldIn, BlockPos pos, IBlockState state, Random rand)
	{
	if (this.isBurning)
	{
	EnumFacing enumfacing = (EnumFacing)state.getValue(FACING);
	double d0 = (double)pos.getX() + 0.5D;
	double d1 = (double)pos.getY() + rand.nextDouble() * 6.0D / 16.0D;
	double d2 = (double)pos.getZ() + 0.5D;
	double d3 = 0.52D;
	double d4 = rand.nextDouble() * 0.6D - 0.3D;

	switch (Crusher.SwitchEnumFacing.FACING_LOOKUP[enumfacing.ordinal()])
	{
	case 1:
	worldIn.spawnParticle(EnumParticleTypes.SMOKE_NORMAL, d0 - d3, d1, d2 + d4, 0.0D, 0.0D, 0.0D, new int[0]);
	worldIn.spawnParticle(EnumParticleTypes.FLAME, d0 - d3, d1, d2 + d4, 0.0D, 0.0D, 0.0D, new int[0]);
	break;
	case 2:
	worldIn.spawnParticle(EnumParticleTypes.SMOKE_NORMAL, d0 + d3, d1, d2 + d4, 0.0D, 0.0D, 0.0D, new int[0]);
	worldIn.spawnParticle(EnumParticleTypes.FLAME, d0 + d3, d1, d2 + d4, 0.0D, 0.0D, 0.0D, new int[0]);
	break;
	case 3:
	worldIn.spawnParticle(EnumParticleTypes.SMOKE_NORMAL, d0 + d4, d1, d2 - d3, 0.0D, 0.0D, 0.0D, new int[0]);
	worldIn.spawnParticle(EnumParticleTypes.FLAME, d0 + d4, d1, d2 - d3, 0.0D, 0.0D, 0.0D, new int[0]);
	break;
	case 4:
	worldIn.spawnParticle(EnumParticleTypes.SMOKE_NORMAL, d0 + d4, d1, d2 + d3, 0.0D, 0.0D, 0.0D, new int[0]);
	worldIn.spawnParticle(EnumParticleTypes.FLAME, d0 + d4, d1, d2 + d3, 0.0D, 0.0D, 0.0D, new int[0]);
	}
	}
	}

	@Override
	public boolean onBlockActivated(World worldIn, BlockPos pos, IBlockState state, EntityPlayer playerIn, EnumFacing side, float hitX, float hitY, float hitZ)
	{
	playerIn.openGui(UsefulthingsMod.instance, 0, worldIn, pos.getX(), pos.getY(), pos.getZ());
	return true;
	}

	public static void setState(boolean active, World worldIn, BlockPos pos)
	{
	IBlockState iblockstate = worldIn.getBlockState(pos);
	TileEntity tileentity = worldIn.getTileEntity(pos);
	keepInventory = true;

	if (active)
	{
	worldIn.setBlockState(pos, LitCrusher.lit_crusher.getDefaultState().withProperty(FACING, iblockstate.getValue(FACING)), 3);
	worldIn.setBlockState(pos, LitCrusher.lit_crusher.getDefaultState().withProperty(FACING, iblockstate.getValue(FACING)), 3);
	}
	else
	{
	worldIn.setBlockState(pos, Crusher.crusher.getDefaultState().withProperty(FACING, iblockstate.getValue(FACING)), 3);
	worldIn.setBlockState(pos, Crusher.crusher.getDefaultState().withProperty(FACING, iblockstate.getValue(FACING)), 3);
	}

	keepInventory = false;

	if (tileentity != null)
	{
	tileentity.validate();
	worldIn.setTileEntity(pos, tileentity);
	}
	}

	/**
	* Returns a new instance of a block's tile entity class. Called on placing the block.
	*/
	public TileEntity createNewTileEntity(World worldIn, int meta)
	{
	return new TileEntityCrusher();
	}

	public IBlockState onBlockPlaced(World worldIn, BlockPos pos, EnumFacing facing, float hitX, float hitY, float hitZ, int meta, EntityLivingBase placer)
	{
	return this.getDefaultState().withProperty(FACING, placer.getHorizontalFacing().getOpposite());
	}

	public void onBlockPlacedBy(World worldIn, BlockPos pos, IBlockState state, EntityLivingBase placer, ItemStack stack)
	{
	worldIn.setBlockState(pos, state.withProperty(FACING, placer.getHorizontalFacing().getOpposite()), 2);

	if (stack.hasDisplayName())
	{
	TileEntity tileentity = worldIn.getTileEntity(pos);

	if (tileentity instanceof TileEntityCrusher)
	{
	((TileEntityCrusher)tileentity).setCustomInventoryName(stack.getDisplayName());
	}
	}
	}

	public void breakBlock(World worldIn, BlockPos pos, IBlockState state)
	{
	if (!keepInventory)
	{
	TileEntity tileentity = worldIn.getTileEntity(pos);

	if (tileentity instanceof TileEntityCrusher)
	{
	InventoryHelper.dropInventoryItems(worldIn, pos, (TileEntityCrusher)tileentity);
	worldIn.updateComparatorOutputLevel(pos, this);
	}
	}

	super.breakBlock(worldIn, pos, state);
	}

	public boolean hasComparatorInputOverride()
	{
	return true;
	}

	public int getComparatorInputOverride(World worldIn, BlockPos pos)
	{
	return Container.calcRedstone(worldIn.getTileEntity(pos));
	}

	@SideOnly(Side.CLIENT)
	public Item getItem(World worldIn, BlockPos pos)
	{
	return Item.getItemFromBlock(Crusher.crusher);
	}

	/**
	* The type of render function that is called for this block
	*/

	/**
	* Possibly modify the given BlockState before rendering it on an Entity (Minecarts, Endermen, …)
	*/
	@SideOnly(Side.CLIENT)
	public IBlockState getStateForEntityRender(IBlockState state)
	{
	return this.getDefaultState().withProperty(FACING, EnumFacing.SOUTH);
	}

	/**
	* Convert the given metadata into a BlockState for this Block
	*/
	public IBlockState getStateFromMeta(int meta)
	{
	EnumFacing enumfacing = EnumFacing.getFront(meta);

	if (enumfacing.getAxis() == EnumFacing.Axis.Y)
	{
	enumfacing = EnumFacing.NORTH;
	}

	return this.getDefaultState().withProperty(FACING, enumfacing);
	}

	/**
	* Convert the BlockState into the correct metadata value
	*/
	public int getMetaFromState(IBlockState state)
	{
	return ((EnumFacing)state.getValue(FACING)).getIndex();
	}

	protected BlockState createBlockState()
	{
	return new BlockState(this, new IProperty[] {FACING});
	}

	@SideOnly(Side.CLIENT)

	static final class SwitchEnumFacing
	{
	static final int[] FACING_LOOKUP = new int[EnumFacing.values().length];
	private static final String __OBFID = "CL_00002111";

	static
	{
	try
	{
	FACING_LOOKUP[EnumFacing.WEST.ordinal()] = 1;
	}
	catch (NoSuchFieldError var4)
	{
	;
	}

	try
	{
	FACING_LOOKUP[EnumFacing.EAST.ordinal()] = 2;
	}
	catch (NoSuchFieldError var3)
	{
	;
	}

	try
	{
	FACING_LOOKUP[EnumFacing.NORTH.ordinal()] = 3;
	}
	catch (NoSuchFieldError var2)
	{
	;
	}

	try
	{
	FACING_LOOKUP[EnumFacing.SOUTH.ordinal()] = 4;
	}
	catch (NoSuchFieldError var1)
	{
	;
	}
	}
	}

	public boolean isOpaqueCube()
	{
	return false;
	}

	public boolean renderAsNormalBlock()
	{
	return false;
	}

	public int getRenderType()
	{
	return -1;
	}
	}

Résolu Problème GUI