SOLVED Portal custom : direction du block de la structure

Axaurus

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

EmotionFox

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.

robin4002

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

Diangle

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

Axaurus

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

SCAREX

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

Diangle

Tu peux nous faire voir ton code ?

robin4002

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

Axaurus

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.

Diangle

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

Axaurus

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