SOLVED Portal custom : direction du block de la structure

1.7.x
Log in to reply
  • 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

    0
  • 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.

    0
  • robin4002
    Administrateurs Rédacteurs Moddeurs confirmés

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

    0
  • Diangle

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

    0
  • 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

    0
  • SCAREX

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

    0
  • Diangle

    Tu peux nous faire voir ton code ?

    0
  • robin4002
    Administrateurs Rédacteurs Moddeurs confirmés

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

    0
  • 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.

    0
  • Diangle

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

    0
  • Axaurus

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

    0