Navigation

    • Register
    • Login
    • Search
    • Recent
    • Tags
    • Popular
    • Users
    • Groups

    SOLVED Portal custom : direction du block de la structure

    1.7.x
    1.7.10
    5
    11
    2624
    Loading More Posts
    • Oldest to Newest
    • Newest to Oldest
    • Most Votes
    Reply
    • Reply as topic
    Log in to reply
    This topic has been deleted. Only users with topic management privileges can see it.
    • Axaurus
      Axaurus last edited by

      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

      1 Reply Last reply Reply Quote 0
      • EmotionFox
        EmotionFox last edited by

        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.

        1 Reply Last reply Reply Quote 0
        • robin4002
          robin4002 Administrateurs Rédacteurs Moddeurs confirmés last edited by

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

          1 Reply Last reply Reply Quote 0
          • Diangle
            Diangle last edited by

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

            1 Reply Last reply Reply Quote 0
            • Axaurus
              Axaurus last edited by

              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

              1 Reply Last reply Reply Quote 0
              • SCAREX
                SCAREX last edited by

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

                1 Reply Last reply Reply Quote 0
                • Diangle
                  Diangle last edited by

                  Tu peux nous faire voir ton code ?

                  1 Reply Last reply Reply Quote 0
                  • robin4002
                    robin4002 Administrateurs Rédacteurs Moddeurs confirmés last edited by

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

                    1 Reply Last reply Reply Quote 0
                    • Axaurus
                      Axaurus last edited by

                      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.

                      1 Reply Last reply Reply Quote 0
                      • Diangle
                        Diangle last edited by

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

                        1 Reply Last reply Reply Quote 0
                        • Axaurus
                          Axaurus last edited by

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

                          1 Reply Last reply Reply Quote 0
                          • 1 / 1
                          • First post
                            Last post
                          Design by Woryk
                          Contact / Mentions Légales / Faire un don

                          MINECRAFT FORGE FRANCE © 2018

                          Powered by NodeBB