SOLVED Portal custom : direction du block de la structure


  • Salut
    Tout d’abord, j’ai déjà créer un sujet qui a le même rapport que celui-ci, mais comme ce n’est pas vaiment un problème et que ça n’a rien à voir avec le tp, je ne savais pas si il fallait répondre au sujet mentionné ci-dessus ou créer un autre sujet. Dans le doute, j’en créer un autre (celui que vous lisez)

    (Pour ceux qui n’aurait pas lu le sujet ci-dessus, j’ai créer une dimension custom avec un nouveau portal, qui a la même forme que celui du nether.)

    La structure du portal est en citrouille et marche très bien. L’“allumage” aussi. Ce que j’aimerais savoir, c’est si c’est possible (et si oui, comment) de faire que si la citrouille est orientée dans une certaine direction, le portail s’allume quand on utilise l’activateur. Dans le cas contraire, le portal de n’allumera pas. J’ai fais plusieurs recherches, mais rien trouvé.

    Merci d’avance


  • Voilà pour toi, “EAST” est remplaçable par n’importe quel direction :

    Blocks.pumpkin.getDefaultState().withProperty(BlockPumpkin.FACING, EnumFacing.EAST);
    

    Édit désolé j’ai crue que c’était un post en 1.8 en espérant que ça t’aidera tout de même.

  • Administrateurs Rédacteurs Moddeurs confirmés

    Regarde le metadata de la citrouille, il est différent en fonction de la direction.


  • Tu fait juste une condition dans l’activateur pour voir si la metadata de la citrouille est la bonne.


  • Salut
    Dans les conditions, j’ai tester d’ajouter :

    ​.getBlockById(1)
    

    et

    ​.getHarvestLevel(1)
    

    après le

    ​Blocks.pumpkin
    

    Il n’y a aucune erreur dans Éclipse, mais quand je teste, peut importe le sens de la citrouille, le portal s’allume.

    J’ai également tester

    ​        boolean direction = ForgeDirection.EAST != null;
    

    et, dans la condition,

    ​&& direction
    

    mais pareil


  • Si tu es en 1.7, regarde les metadatas, si tu es en 1.8, il faut regarder les blockStates


  • Tu peux nous faire voir ton code ?

  • Administrateurs Rédacteurs Moddeurs confirmés

    world.getBlockMetadata(x, y, z) == 0
    ou 1, ou 2, ou 3 en fonction de la direction voulu.


  • Salut
    Merci pour la fonction, je l’ai tester mais sans succès : on peut toujours allumer le portal quelque soit la direction des citrouilles
    Voilà la class :

    ​package This_is_Halloween.Block;
    
    import java.util.Random;
    
    import cpw.mods.fml.relauncher.Side;
    import cpw.mods.fml.relauncher.SideOnly;
    import This_is_Halloween.CreateBlocks;
    import This_is_Halloween.This_is_Halloween;
    import This_is_Halloween.NOM.TeleporterNOM;
    import net.minecraft.block.Block;
    import net.minecraft.block.BlockPortal;
    import net.minecraft.block.material.Material;
    import net.minecraft.creativetab.CreativeTabs;
    import net.minecraft.entity.Entity;
    import net.minecraft.entity.player.EntityPlayerMP;
    import net.minecraft.init.Blocks;
    import net.minecraft.item.ItemStack;
    import net.minecraft.server.MinecraftServer;
    import net.minecraft.util.AxisAlignedBB;
    import net.minecraft.util.MovingObjectPosition;
    import net.minecraft.world.IBlockAccess;
    import net.minecraft.world.World;
    import net.minecraftforge.common.util.ForgeDirection;
    
    public class BlockPortalNOM extends BlockPortal{
        public BlockPortalNOM(Material material)
        {
            super();
        }
    
        @Override
        public void setBlockBoundsBasedOnState(IBlockAccess blockaccess, int x, int y, int z)
        {
            float f;
            float f1;
    
            if(!blockaccess.getBlock(x - 1, y, z).equals(this) && !blockaccess.getBlock(x + 1, y, z).equals(this))
            {
                f = 0.125F;
                f1 = 0.5F;
                this.setBlockBounds(0.5F - f, 0.0F, 0.5F - f1, 0.5F + f, 1.0F, 0.5F + f1);
            }
            else
            {
                f = 0.5F;
                f1 = 0.125F;
                this.setBlockBounds(0.5F - f, 0.0F, 0.5F - f1, 0.5F + f, 1.0F, 0.5F + f1);
            }
        }
    
        @Override
        public AxisAlignedBB getCollisionBoundingBoxFromPool(World world, int x, int y, int z)
        {
            return null;
        }
    
        @Override
        public void setBlockBoundsForItemRender()
        {
            float f1 = 0.125F;
            this.setBlockBounds(0, 0.0F, 0.5F - f1, 1F, 1.0F, 0.5F + f1);
        }
    
        @Override
        public boolean func_150000_e(World par1World, int par2, int par3, int par4)
        {
            byte b0 = 0;
            byte b1 = 0;
    
            if (par1World.getBlock(par2 - 1, par3, par4) == Blocks.pumpkin || par1World.getBlock(par2 + 1, par3, par4) == Blocks.pumpkin)
                if (par1World.getBlockMetadata(par2 - 1, par3, par4) == 1 || par1World.getBlockMetadata(par2 + 1, par3, par4) == 1)
                {
                    b0 = 1;
                }
    
            if (par1World.getBlock(par2, par3, par4 - 1) == Blocks.pumpkin || par1World.getBlock(par2, par3, par4 + 1) == Blocks.pumpkin)
                if (par1World.getBlockMetadata(par2, par3, par4 - 1) == 1 || par1World.getBlockMetadata(par2, par3, par4 + 1) == 1)
            {
                b1 = 1;
            }
    
            if (b0 == b1)
            {
                return false;
            }
            else
            {
                if (par1World.isAirBlock(par2 - b0, par3, par4 - b1))
                {
                    par2 -= b0;
                    par4 -= b1;
                }
    
                int l;
                int i1;
    
                for (l = -1; l <= 2; ++l)
                {
                    for (i1 = -1; i1 <= 3; ++i1)
                    {
                        boolean flag = l == -1 || l == 2 || i1 == -1 || i1 == 3;
    
                        if (l != -1 && l != 2 || i1 != -1 && i1 != 3)
                        {
                            Block j1 = par1World.getBlock(par2 + b0 * l, par3 + i1, par4 + b1 * l);
                            boolean isAirBlock = par1World.isAirBlock(par2 + b0 * l, par3 + i1, par4 + b1 * l);
    
                            if (flag)
                            {
                                if (j1 != Blocks.pumpkin)
                                {
                                    return false;
                                }
                            }
                            else if (!isAirBlock && j1 != Blocks.lava)
                            {
                                return true;
                            }
                        }
                    }
                }
    
                for (l = 0; l < 2; ++l)
                {
                    for (i1 = 0; i1 < 3; ++i1)
                    {
                        par1World.setBlock(par2 + b0 * l, par3 + i1, par4 + b1 * l, CreateBlocks.PortalNOMBlock, 0, 2);
                    }
                }
    
                return true;
            }
        }
        @Override
        public void onNeighborBlockChange(World par1World, int par2, int par3, int par4, Block par5)
        {
            byte b0 = 0;
            byte b1 = 1;
    
            if (par1World.getBlock(par2 - 1, par3, par4) == this || par1World.getBlock(par2 + 1, par3, par4) == this)
            {
                b0 = 1;
                b1 = 0;
            }
    
            int i1;
    
            for (i1 = par3; par1World.getBlock(par2, i1 - 1, par4) == this; –i1)
            {
                ;
            }
    
            if (par1World.getBlock(par2, i1 - 1, par4) != Blocks.pumpkin)
            {
                par1World.setBlockToAir(par2, par3, par4);
            }
            else
            {
                int j1;
    
                for (j1 = 1; j1 < 4 && par1World.getBlock(par2, i1 + j1, par4) == this; ++j1)
                {
                    ;
                }
    
                if (j1 == 3 && par1World.getBlock(par2, i1 + j1, par4) == Blocks.pumpkin)
                    if (j1 == 3 && par1World.getBlockMetadata(par2, i1 + j1, par4) == 1)
                {
                    boolean flag = par1World.getBlock(par2 - 1, par3, par4) == this || par1World.getBlock(par2 + 1, par3, par4) == this;
                    boolean flag1 = par1World.getBlock(par2, par3, par4 - 1) == this || par1World.getBlock(par2, par3, par4 + 1) == this;
    
                    if (flag && flag1)
                    {
                        par1World.setBlockToAir(par2, par3, par4);
                    }
                    else
                    {
                        if ((par1World.getBlock(par2 + b0, par3, par4 + b1) != Blocks.pumpkin || par1World.getBlock(par2 - b0, par3, par4 - b1) != this) && (par1World.getBlock(par2 - b0, par3, par4 - b1) != Blocks.pumpkin || par1World.getBlock(par2 + b0, par3, par4 + b1) != this))
                        {
                            par1World.setBlockToAir(par2, par3, par4);
                        }
                    }
                }
                else
                {
                    par1World.setBlockToAir(par2, par3, par4);
                }
            }
        }
    
        @Override
        public boolean isOpaqueCube()
        {
            return false;
        }
    
        @Override
        public boolean renderAsNormalBlock()
        {
            return false;
        }
    
        @Override
        public int quantityDropped(Random random)
        {
            return 0;
        }
    
        @Override
        public void onEntityCollidedWithBlock(World world, int x, int y, int z, Entity entity)
        {
            if((entity.ridingEntity == null) && (entity.riddenByEntity == null))
            {
                if(entity.dimension != This_is_Halloween.dimensionID)
                {
                    if(entity instanceof EntityPlayerMP)
                    {
                        EntityPlayerMP player = (EntityPlayerMP)entity;
                        if(player.timeUntilPortal > 0)
                        {
                            player.timeUntilPortal = 10;
                        }
                        else
                        {
                            player.timeUntilPortal = 10;
                            player.mcServer.getConfigurationManager().transferPlayerToDimension(player, This_is_Halloween.dimensionID, new TeleporterNOM(player.mcServer.worldServerForDimension(This_is_Halloween.dimensionID)));
                        }
                    }
                }
                else
                {
                    if(entity instanceof EntityPlayerMP)
                    {
                        EntityPlayerMP player = (EntityPlayerMP)entity;
                        if(player.timeUntilPortal > 0)
                        {
                            player.timeUntilPortal = 10;
                        }
                        else
                        {
                            player.timeUntilPortal = 10;
                            player.mcServer.getConfigurationManager().transferPlayerToDimension(player, 0, new TeleporterNOM(player.mcServer.worldServerForDimension(0)));
                        }
                    }
                }
            }
        }
    
        @SideOnly(Side.CLIENT)
        @Override
        public int getRenderBlockPass()
        {
            return 1;
        }
    
        @SideOnly(Side.CLIENT)
        @Override
        public ItemStack getPickBlock(MovingObjectPosition target, World world, int x, int y, int z)
        {
            return null;
        }
    
        @Override
        public void breakBlock(World world, int x, int y, int z, Block block, int metadata)
        {
            super.breakBlock(world, x, y, z, block, metadata);
            if(world.getBlock(x, y + 1, z).equals(this))
            {
                world.setBlockToAir(x, y + 1, z);
            }
            if(world.getBlock(x, y - 1, z).equals(this))
            {
                world.setBlockToAir(x, y - 1, z);
            }
            if(world.getBlock(x + 1, y, z).equals(this))
            {
                world.setBlockToAir(x + 1, y, z);
            }
            if(world.getBlock(x - 1, y, z).equals(this))
            {
                world.setBlockToAir(x - 1, y, z);
            }
            if(world.getBlock(x, y, z + 1).equals(this))
            {
                world.setBlockToAir(x, y, z + 1);
            }
            if(world.getBlock(x, y, z - 1).equals(this))
            {
                world.setBlockToAir(x, y, z - 1);
            }
        }
    }
    

    La fonction est aux lignes 71, 77 et 167.


  • tu utilises un activateur, donc fait ça dans l’activateur ^^


  • ça marche beaucoup mieux
    Le portal s’allume comme je veux, merci beaucoup