[1.7.10]Faire un block réactif a la RedStone !



  • Dans ce tutoriel je vais vous montrer comment réaliser un bloc sensible a la redstone .😉

    Sommaire

    [1.7.10]Faire un block réactif a la RedStone ?

    Bonjour, dans ce tutoriel en 1.7.10 nous allons découvrir comment faire un bloc lampe ou block qui réagit a la Redstone !! Comme exemple, la lampe de redstone dans minecraft vanilla. Et un bonus qui plaira a plus d'un 🙂

    Pré-requis

    Pour cette recette vous n'aurez besoin que d'un seul ingrédient, ce tutoriel :

    Le Code

    Dans votre classe ou vos blocks sont listés (classe principale le plus souvent) :

    Les BlockLampTuto et BlockLampTutoActive sont les noms que j'ai donné aux deux blocks qui serviront pour la lampe, il est IMPÉRATIF d'en créer deux vous pouvez leur donner le nom que VOUS voulez 😉

    public static Block vosSupersBlocks, BlockLampTuto, BlockLampTutoActive;
    

    Comme vous l'aurez sans doute deviné(ou pas), Le "BlockLampTutoActive" remplacera le "BlockLampTuto" quand un signal de redstone touchera "BlockLampTuto" et lorsque que ce signal disparaitra, "BlockLampTutoActive" aussi, il sera de nouveau remplacé par "BlockLampTuto", quel beau cycle 😄 .
    Ensuite initialisez le dans votre fonction init(){

    BlockLampTuto= new  BlockLampInfo(false).setBlockName("BlockLampTuto").setCreativeTab(^CreativeTab que vous voudrez^).setBlockTextureName(^Votre modid +":votretexturedublocnon-actif"^).setStepSound(Block.soundTypeGlass);
    BlockLampTutoActive = new  BlockLampInfo(true).setBlockName("BlockLampTutoActive").setCreativeTab(^CreativeTab que vous voudrez^).setBlockTextureName(^Votre modid +":votretexturedublocactif"^).setStepSound(Block.soundTypeGlass);
    

    J'ai uniquement mis le setCreativeTab pour le non actif (BlockLampTuto) car l'actif (BlockLampTutoActive) ne servirai a rien dans une creativeTab et rajouterai un bloc dans cette creativeTab pour rien 🙂 .

    Dans ce code, le (false) mets une ERREUR c'est tout a fait normal , ne paniquez on y viens. Le setStepSound sert a determiner quelle type de son le block produira t-il quand on le cassera, ou lorsqu'on le posera etc... je vous laisse jeter un coup d'oeil dans le Block. pour trouver votre bonheur 😉 .

    On les enregistre :

    GameRegistry.registerBlock(BlockLampTuto, BlockLampTuto.getUnlocalizedName().substring(5));
    GameRegistry.registerBlock(BlockLampTutoActive, BlockLampTutoActive.getUnlocalizedName().substring(5));
    

    La Classe du Bloc :

    On commence par faire un extends Block

    public class BlockLampInfo extends Block
    {
    
    }
    

    On importe le net.minecraft.block

    Ensuite on ajoute le constructeur (si vous êtes perdu dans ce que je dis, vous avez deux possibilités: relire le tutoriel pré-requis de Robin4002 ou apprendre le java, je vous laisse décider 😉 )

        protected BlockLampInfo(Material p_i45394_1_)
        {
            super(p_i45394_1_);
            // TODO Auto-generated constructor stub
        }
    

    On passe le "protected" en le renomant "public" et pour mieux s'y retrouver, on renome le "p_i45394_1_" en material et aussi j'enlève le "TODO Auto-generated...", il est inutile

        public BlockLampInfo(Material material)
        {
            super(material);
        }
    

    Maintenant IMPORTEZ votre classe "BlockLampInfo" dans votre classe principale ou dans votre classe ou sont initialisés vos blocks.

    Et là, une erreur en moins pour une erreur en plus ! Pas de bol la valeur (false) et (true) dans la classe de vos blocks sont"booléennes" mais on n'a pas mis de valeurs "booléennes" dans notre classe du bloc on y est :

    Je ne vais pas détailler TOUT le code car c'est trop long et inutile surtout mais si vous voulez savoir qu'est-ce qu'est tout cela allez apprendre le minimum du java.

    On rajoute ça au dessus du constructeur

        private final boolean isActive;
        private static final String __OBFID = "CL_00000297";
    
    

    La valeur booléenne "isActive" va servir a savoir si le blocLampTuto doit s'allumer ou pas.

    Ensuite on modifie un tout petit peu le constructeur en le remplaçant par ça :

        public BlockLampInfo(boolean p_i45421_1_)
            {
                super(Material.glass);
                this.isActive = p_i45421_1_;
                
                if (p_i45421_1_)
                {
                    setLightLevel(1.0F);
                }
           }
    

    Pour les petits malins qui auraient mis dans la classe init(je vais désormais appeler la classe ou sont tous vos blocks la classe init se sera plus simple), le "Material.", il faut le mettre dans la classe du bloc. Et le setLightLevel servira a faire : de la lumière !

    Il faut ajouter ces trois fonctions maintenant :

        public void onBlockAdded(World world, int x, int y, int z) {
            if (!world.isRemote)
            {
                if (this.isActive && !world.isBlockIndirectlyGettingPowered(x, y, z)) {
            
                    world.scheduleBlockUpdate(x, y, z, this, 4);
                }
                else if (!this.isActive && world.isBlockIndirectlyGettingPowered(x, y, z)) {
           
                     world.setBlock(x, y, z, ^La classe init.le nom de votre bloc ACTIF^, 0, 2);
              } 
          }
       }
        public void onNeighborBlockChange(World world, int x, int y, int z, Block block) {
        if (!world.isRemote)
         {
          if (this.isActive && !world.  isBlockIndirectlyGettingPowered(x, y, z)) {
            
            world.scheduleBlockUpdate(x, y, z, this, 4);
         }
           else if (!this.isActive && world.isBlockIndirectlyGettingPowered(x, y, z)) {
            
            world.setBlock(x, y, z, ^La classe init.le nom de votre bloc ACTIF^, 0, 2);
          } 
        }
      }
        public void updateTick(World world, int x, int y, int z, Random p_149674_5_) {
            if (!world.isRemote && this.isActive && !world.isBlockIndirectlyGettingPowered(x, y, z))
                 {
                    world.setBlock(x, y, z, ^La classe init.le nom de votre bloc NON-ACTIF^, 0, 2);
                 }
        }
    

    Il y a beaucoup d'erreur mais elle se résolvent facilement en remplacant seulement les " ^La classe init.le nom de votre bloc ACTIF^" et le "^La classe init.le nom de votre bloc NON-ACTIF^"

    Attention

    Il ne faut pas mélanger le ACTIF du non-ACTIF dans la classe du bloc cela pourrait créer des erreurs.

    Et pour finir quelques fonctions obligatoires pratiques :

        public Item getItemDropped(int p_149650_1_, Random rand, int p_149650_3_) { return Item.getItemFromBlock(^La classe init.le nom de votre bloc NON-ACTIF^); }
    
        @SideOnly(Side.CLIENT)
        public Item getItem(World world, int x, int y, int z) { return Item.getItemFromBlock(^La classe init.le nom de votre bloc NON-ACTIF^); }
    
        protected ItemStack createStackedBlock(int meta) { return new ItemStack(^La classe init.le nom de votre bloc NON-ACTIF^); }
    

    Ces fonctions servent a que lorsque qu'on récupère notre bloc en créatif ou en survie, on récupère bien le NON-ACTIF et non l'ACTIF.
    Si besoin, n'oubliez pas les IMPORTS !

    Le Résultat

    2019-08-11_20.07.45.png

    On a bien une lampe qui éclaire lorsqu'elle est alimentée en redstone et qui n’éclaire pas sinon.
    N'oubliez pas qu'il faut bien deux textures différentes, une pour la lampe allumée et une autre pour le contraire.
    Personnellement j'ai fais un design 'lampe en émeraude'.

    Bonus

    Pour utiliser le bloc d'une autre manière que d'une lampe il suffit de modifier cette partie du code et de la remplacer par ce que vous souhaitez :

        public void onBlockAdded(World world, int x, int y, int z) {
            if (!world.isRemote)
            {
                if (this.isActive && !world.isBlockIndirectlyGettingPowered(x, y, z)) {
            
                    world.scheduleBlockUpdate(x, y, z, this, 4);
                }
                else if (!this.isActive && world.isBlockIndirectlyGettingPowered(x, y, z)) {
           
                     world.setBlock(x, y, z, ^La classe init.le nom de votre bloc ACTIF^, 0, 2); //ICI
              } 
          }
       }
        public void onNeighborBlockChange(World world, int x, int y, int z, Block block) {
        if (!world.isRemote)
         {
          if (this.isActive && !world.  isBlockIndirectlyGettingPowered(x, y, z)) {
            
            world.scheduleBlockUpdate(x, y, z, this, 4);
         }
           else if (!this.isActive && world.isBlockIndirectlyGettingPowered(x, y, z)) {
            
            world.setBlock(x, y, z, ^La classe init.le nom de votre bloc ACTIF^, 0, 2)//ICI AUSSI
          } 
        }
      }
        public void updateTick(World world, int x, int y, int z, Random p_149674_5_) {
            if (!world.isRemote && this.isActive && !world.isBlockIndirectlyGettingPowered(x, y, z))
                 {
                    world.setBlock(x, y, z, ^La classe init.le nom de votre bloc NON-ACTIF^, 0, 2); //ET ICI
                 }
        }
    

    Par exemple :

        public void onBlockAdded(World world, int x, int y, int z) {
            if (!world.isRemote)
            {
                if (this.isActive && !world.isBlockIndirectlyGettingPowered(x, y, z)) {
            
                    world.scheduleBlockUpdate(x, y, z, this, 4);
                }
                else if (!this.isActive && world.isBlockIndirectlyGettingPowered(x, y, z)) {
                      EntityEnderman enderman = new EntityEnderman(world);
                      enderman.setPosition(x, y, z);                                      //LA
                      world.spawnEntityInWorld(enderman);
                     world.setBlock(x, y, z, ^La classe init.le nom de votre bloc ACTIF^, 0, 2); 
              } 
          }
       }
        public void onNeighborBlockChange(World world, int x, int y, int z, Block block) {
        if (!world.isRemote)
         {
          if (this.isActive && !world.  isBlockIndirectlyGettingPowered(x, y, z)) {
            
            world.scheduleBlockUpdate(x, y, z, this, 4);
         }
           else if (!this.isActive && world.isBlockIndirectlyGettingPowered(x, y, z)) {
                       EntityEnderman enderman = new EntityEnderman(world);
                       enderman.setPosition(x, y, z);                                       //ICI LA
                       world.spawnEntityInWorld(enderman);
            world.setBlock(x, y, z, ^La classe init.le nom de votre bloc ACTIF^, 0, 2)
          } 
        }
      }
        public void updateTick(World world, int x, int y, int z, Random p_149674_5_) {
            if (!world.isRemote && this.isActive && !world.isBlockIndirectlyGettingPowered(x, y, z))
                 {
                EntityPig piggy = new EntityPig(world);
                piggy.setPosition(x, y, z);                                                     //ET AUSSI LA    
                world.spawnEntityInWorld(piggy);
                    world.setBlock(x, y, z, ^La classe init.le nom de votre bloc NON-ACTIF^, 0, 2); 
                 }
        }
    

    Maintenant, lorsque la lampe est alimentée en redstone, elle fait spawner un enderman ,et quand le signal de redstone disparait, un cochon. Maintenant votre seule limite sera votre imagination (et java,un peu) 😉

    Crédits

    Creative Commons

    Rédaction : applygamer

    Ce tutoriel de Minecraft Forge France est mis à disposition selon les termes de la licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International


Log in to reply