Crée une structure massif



  • Bonjour je cherche à créer une structure de très grand taille.
    Problème le code ne semble pas apprécier une génération aillent sur deux chunks .
    En core moins sur 3 et plus !

    Ma structure et de dimension 50x50 bloc !
    Je n'ai pas encore abordé la hauteur dans mon problème !
    Avant de générée les éléments de ma structure, je veux niveler la zone où elle sera générée !
    Mais ça c'est déjà trop dur!
    Voici mon code ;

    package com.example.examplemod.gen.structs;
    
    import java.util.Random;
    
    import com.example.examplemod.gen.structs.*;
    import com.example.examplemod.gen.structs.components.BlockLogAsset;
    import com.example.examplemod.gen.structs.components.BlockStairsAsset;
    import com.example.examplemod.gen.structs.components.blockAsset;
    import com.example.examplemod.gen.structs.components.blockButtonAsset;
    import com.example.examplemod.gen.structs.components.blockDoorAsset;
    import com.example.examplemod.gen.structs.components.blockLadderAsset;
    
    import net.minecraft.block.*;
    import net.minecraft.init.Blocks;
    import net.minecraft.world.World;
    import net.minecraft.world.gen.feature.WorldGenerator;
    
    //Fracture
    public class StructureGenerator extends WorldGenerator
    {
        @Override
        public boolean generate(World world, Random random, int x, int y, int z)
        {
    
            // world.setBlock(x, y , z , Blocks.grass);
            // if(world.isAirBlock(x, y + 1, z))
            {
                int _xInd, _zInd, _yInd;
                for(_yInd = 0; _yInd < 10; _yInd++)
                {
                    for(_xInd = 0; _xInd < 50; _xInd++) // 74
                    {
                        for(_zInd = 0; _zInd < 50; _zInd++)
                        {
    
                            world.setBlock(x + _xInd, y + _yInd, z + _zInd, Blocks.air);
                        }
                    }
                }
                for(_xInd = 0; _xInd < 50; _xInd++)
                {
                    for(_zInd = 0; _zInd < 50; _zInd++)
                    {
                        world.setBlock(x + _xInd, y, z + _zInd, Blocks.grass);
                        if(world.getBlock(x + _xInd, y - 1, z + _zInd) == Blocks.air)
                        {
                            world.setBlock(x + _xInd, y - 1, z + _zInd, Blocks.dirt);
                        }
                    }
                }
            }
            return true;
        }
    }
    

    Pour info le jeux crach pas il reste bloquée sur la génération mais ne fait plus rien a ce niveaux (je tourne toujour à 30 fps).

    Mes élément de structure son prête et tester mais non utiliser !

    Je me suis peut être trompez de class pour générée des structure !


  • Administrateurs

    Salut,
    50x50 ce n'est pas sensé causer de problème.
    Vérifies pour commencer que ton est bien appelé.



  • Bonjour.

    Non latéralement il n'y à pas d'erreur de code.

    Si je réduit la taille a 5 ou 8 le code fonctionnement appart que lord de la génération lord du chargement des Chunk les chiffre du "Chunk update" sont complètement fou.
    Sur une taille de 50 le jeux ne semble plus capable de Chargez les nouvelle zone généré.
    Est il ne sauvegarde plus mas position dans le jeux.

    Je cherche une solution pour fragmentez mas génération!
    Il y a t'il une façon de sauvegardez de nouvelle donnez efficacement dans le jeux 
    Car j'ai également cherchez mas on dirais que je vais devoir faire mas propre classe.



  • Bonjour, je me demande si tu n'aurais pas fait une erreur avant que ce code soit appelé, montres ce qui appelle cette fonction.



  • Bonjour depuis mon dernier post j'ai fait de recherche et bidouillez mon code du coup je n'ai plus vraiment le code d'origine.
    J'ai notamment modifiez la méthode d'appel de génération et du coup je me suis posez plusieurs question.

    Pour l'appel de la fonction [font=monospacegener][font=monospaceate] du precedent poste je devais avoir :

    private void generateSurface(World world, Random random, int x, int z)
    {
    // TODO Auto-generated method stub
    int x1 = x + random.nextInt(16);
    int y1 = random.nextInt(64);
    int z1 = z + random.nextInt(16);
    (new StructureGenerator()).generate(world, random, x1, y1, z1);
    
    }
    

    Pour replacez le contexte j'ai suivie le tutoriel du site qui décompose une classe qui appel la fonction generate qui permet de séparée la génération par dimention
    Si je fait un appel trop élevez de la fonction de génération ce la ne peut t'il pas surchargez le programme de génération des chunk de minecrafte.
    Dans ce cas je voudrais savoir comment pour séparée efficacement mes différent génération et en produire qu'une par chunk sa alléger énormément le programme.



  • "Si je fait un appel trop élevez de la fonction de génération ce la ne peut t'il pas surchargez le programme de génération des chunk de minecrafte."
    MES YEUX SAIGNENT  😢 
    RIP Minecraft

    Normalement non ca ne pose pas problème et puis je pense que cela vien plutôt de la classe de ta structure



  • @'SpyMan':

    "Si je fait un appel trop élevez de la fonction de génération ce la ne peut t'il pas surchargez le programme de génération des chunk de minecrafte."
    MES YEUX SAIGNENT  😢 
    RIP Minecraft

    Normalement non ca ne pose pas problème et puis je pense que cela vien plutôt de la classe de ta structure

    Ben j'ai déjà postez la class de génération que j'ai mis en place pour le moment je ne fait que nivelez le terrien ou plut je test une génération de grand taille !

    Donc sa ne peut pas venir de la génération de la structure puisque que je ne l'utilise pas ! Comme détaillez dans le preniez post :

    Ma structure et de dimension 50x50 bloc !
    Je n'ai pas encore abordé la hauteur dans mon problème !
    Avant de générée les éléments de ma structure, je veux niveler la zone où elle sera générée !
    Mais ça c'est déjà trop dur!

    Désolée mai beaucoup de mots que j'utilise ne sont pas pris en compte par le correcteur orthographe alors désolée si je suis nul je fais de mon mieux !



  • "Si je fait un appel trop élevez de la fonction de génération ce la ne peut t'il pas surchargez le programme de génération des chunk de minecrafte.
    Dans ce cas je voudrais savoir comment pour séparée efficacement mes différent génération et en produire qu'une par chunk sa alléger énormément le programme."
    (la citation charge à l'infini donc ait pas pu l'utiliser)

    J'ai pas trop compris, mais ce que je vois, c'est que ta structure va être générée un trèèèèsssss grand nombre de fois à la suite, vu que tu n'as mis aucun if(random.nextInt(chance de génération)).



  • Bonsoir 
    (R.I.P la langue Français)  :s

    J'ai fait quel que test utiliser les fonction de génération comme je le fais est comme d'écrit dans les tutoriel de minecraftforgefrance pour des structure massif et une grave erreur!

    J'ai compris les bug que mon programme provoque et ce n'est pas très simple .
    Dans la première Class "MainWorldGenerator" implémenter de la Class  IWorldGenerator
    Voici la méthode qui permet la génération de mas structure

    @Override
    public void generate(Random random, int chunkX, int chunkZ, World world, IChunkProvider chunkGenerator,
    IChunkProvider chunkProvider)
    {
    switch(world.provider.dimensionId)
    {
    
    case -1:
    generateNether(world, random, chunkX * 16, chunkZ * 16);
    break;
    case 0:
    generateSurface(world, random, chunkX * 16, chunkZ * 16);
    break;
    case 1:
    generateEnd(world, random, chunkX * 16, chunkZ * 16);
    break;
    }
    }
    

    Ce qui est le code exacte du tutoriel ils faut bien observez les variables suivante :
     chunkX ,chunkZ ,chunkProvider ,chunkGenerator
    Se sont toute des valeur qui nous indique que notre génération vas se faire par chunk
    Or les structure que je tente de générée sont de taille 5050 et un chunk 1616

    En chargent mas structure je force minecraft a chargez plusieurs chunck en même temps 
    Avec le code génération que j'utilisais sa forçais minecraft a chargez d'autre chunck qui cherchais à générée la structure !

    La conséquence c'est que minecraft cherche à générée tous les zone du jeux ce qui est impossible !
    D’Où la nécessiter des chunk.

    J'ai imposer une condition spéciale pour la génération de ma structure pour évitez le chargement infinie des chunck .
    Mais si on prend en compte que la simple génération de mas structure fais charger 4164 chunck ,
    est que mon PC peine a le faire cette solution ne me parais pas viable.

    J'ai besoin d'une meilleur option de génération car ce n'est sans doute pas comme ça que minecraft procédé !

    Ouille quelle post ! 😢



  • Ce la fait plusieurs semaine que j'ai posez sur ce forum mon problème de génération de structure.

    J'ai attendue que des réponse pertinente survienne pris le temps de réévaluée mon problème et je me suis rendus compte après avoir fouillez le code qu'il existais des fonction don je ne comprenais pas l'utilité. 
    Minecraft utilise ces fonction pour des génération de structure comme les forteresses du Nether ou encore les mines abandonnée qui pour moi son des structures massif !

    Voici la méthode au quelle je fait référence :

    package net.minecraft.world.gen;
    public class ChunkProviderGenerate implements IChunkProvider
    
    // Traduction de la Java doc :
    // Remplit le chunk avec des minerais etc etc
    public void populate(IChunkProvider p_73153_1_, int p_73153_2_, int p_73153_3_)
    
    

    Puis qu'il s'agit de fonction fessant partie du code fournie par Forge ,je me contente de d'indiquez le package la class et la fonction avec une traduction
    tezzfze 
    Je souhaite m'intéressée à l'objet retournez sous l' interface IChunkProvider.

    Que l'on retrouve dans ma class MainWorldGenerator.
    Qui et aux centre de mon programme de génération !

    Durand le tutoriel l'or de la séparation de génération les objet de cette interface sont ignorée par le tutoriel et ne sont pas reconduit par les nouvelle méthode de génération !

       @Override
       public void generate(Random random, int chunkX, int chunkZ, World world, IChunkProvider chunkGenerator,
               IChunkProvider chunkProvider)
       {
           switch(world.provider.dimensionId)
           {
    
           case -1:
               generateNether(world, random, chunkX * 16, chunkZ * 16);
               break;
           case 0:
               generateSurface(world, random, chunkX * 16, chunkZ * 16);
               break;
           case 1:
               generateEnd(world, random, chunkX * 16, chunkZ * 16);
               break;
           }
       }
    

    Il y a deux objet je souhaite les comprendre et voir si il y a une solution !



  • Pour ceux qui souhaite voir la méthode aux quelle je fait référence sur le site la voici mais elle fais une centaine de ligne !

    /**
        * Populates chunk with ores etc etc
        */
       public void populate(IChunkProvider p_73153_1_, int p_73153_2_, int p_73153_3_)
       {
           BlockFalling.fallInstantly = true;
           int k = p_73153_2_ * 16;
           int l = p_73153_3_ * 16;
           BiomeGenBase biomegenbase = this.worldObj.getBiomeGenForCoords(k + 16, l + 16);
           this.rand.setSeed(this.worldObj.getSeed());
           long i1 = this.rand.nextLong() / 2L * 2L + 1L;
           long j1 = this.rand.nextLong() / 2L * 2L + 1L;
           this.rand.setSeed((long)p_73153_2_ * i1 + (long)p_73153_3_ * j1 ^ this.worldObj.getSeed());
           boolean flag = false;
    
           MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Pre(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag));
    
           if (this.mapFeaturesEnabled)
           {
               this.mineshaftGenerator.generateStructuresInChunk(this.worldObj, this.rand, p_73153_2_, p_73153_3_);
               flag = this.villageGenerator.generateStructuresInChunk(this.worldObj, this.rand, p_73153_2_, p_73153_3_);
               this.strongholdGenerator.generateStructuresInChunk(this.worldObj, this.rand, p_73153_2_, p_73153_3_);
               this.scatteredFeatureGenerator.generateStructuresInChunk(this.worldObj, this.rand, p_73153_2_, p_73153_3_);
           }
    
           int k1;
           int l1;
           int i2;
    
           if (biomegenbase != BiomeGenBase.desert && biomegenbase != BiomeGenBase.desertHills && !flag && this.rand.nextInt(4) == 0
               && TerrainGen.populate(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag, LAKE))
           {
               k1 = k + this.rand.nextInt(16) + 8;
               l1 = this.rand.nextInt(256);
               i2 = l + this.rand.nextInt(16) + 8;
               (new WorldGenLakes(Blocks.water)).generate(this.worldObj, this.rand, k1, l1, i2);
           }
    
           if (TerrainGen.populate(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag, LAVA) && !flag && this.rand.nextInt(8) == 0)
           {
               k1 = k + this.rand.nextInt(16) + 8;
               l1 = this.rand.nextInt(this.rand.nextInt(248) + 8);
               i2 = l + this.rand.nextInt(16) + 8;
    
               if (l1 < 63 || this.rand.nextInt(10) == 0)
               {
                   (new WorldGenLakes(Blocks.lava)).generate(this.worldObj, this.rand, k1, l1, i2);
               }
           }
    
           boolean doGen = TerrainGen.populate(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag, DUNGEON);
           for (k1 = 0; doGen && k1 < 8; ++k1)
           {
               l1 = k + this.rand.nextInt(16) + 8;
               i2 = this.rand.nextInt(256);
               int j2 = l + this.rand.nextInt(16) + 8;
               (new WorldGenDungeons()).generate(this.worldObj, this.rand, l1, i2, j2);
           }
    
           biomegenbase.decorate(this.worldObj, this.rand, k, l);
           if (TerrainGen.populate(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag, ANIMALS))
           {
           SpawnerAnimals.performWorldGenSpawning(this.worldObj, biomegenbase, k + 8, l + 8, 16, 16, this.rand);
           }
           k += 8;
           l += 8;
    
           doGen = TerrainGen.populate(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag, ICE);
           for (k1 = 0; doGen && k1 < 16; ++k1)
           {
               for (l1 = 0; l1 < 16; ++l1)
               {
                   i2 = this.worldObj.getPrecipitationHeight(k + k1, l + l1);
    
                   if (this.worldObj.isBlockFreezable(k1 + k, i2 - 1, l1 + l))
                   {
                       this.worldObj.setBlock(k1 + k, i2 - 1, l1 + l, Blocks.ice, 0, 2);
                   }
    
                   if (this.worldObj.func_147478_e(k1 + k, i2, l1 + l, true))
                   {
                       this.worldObj.setBlock(k1 + k, i2, l1 + l, Blocks.snow_layer, 0, 2);
                   }
               }
           }
    
           MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Post(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag));
    
           BlockFalling.fallInstantly = false;
       }
    

  • Administrateurs

    Logiquement avec l'event PopulateChunkEvent.Pre ou PopulateChunkEvent.Post tu devrais pouvoir faire la même chose que les générateurs pour les villages, les mines, etc …



  • Oui mais si j'utilise un simple copiez coller des algorithme en plus de faire n’importe-quoi !
    En plus je ne comprendrais pas la Logic du code !

    Surtout qui en plus par rapport à la méthode vanille il y a 1 objet IChunkProvider en plus.
    Donc la même logic ne peut donc pas forcément fonctionner puisque l'implémentation de mas génération n'est pas du même type que celle de la vanille

    P.S Des fois je voudrais postez une image mais il faux l'importez d'un autre site.
    Vous avez des référence à me conseiller .


  • Administrateurs

    imgur, sinon tu as les pièces jointes du forum.



  • perso j'ai testé ta class structurgenerator et ça marche chez moi (enfin ça se met sur plusieurs chunck)



  • @'sventus':

    perso j'ai testé ta class structurgenerator et ça marche chez moi  (enfin ça se met sur plusieurs chunck)

    Bon Comme je l'ai déjà expliquez le code fonction mais difficilement.
    Chez moi on se retrouve à attendre à la bordure des chunck que minecraft génère les chunck!
    Lors de la génération il y a des bug de MAJ de lumière sur les block! On peut voir que ces bugs sont en rapport avec le chargement des chunck!

    Je fournie les image en pièce jointe!  WizardIceTeaMcFCSM.zip

    WizardIceTeaMcFCSM01

    Vous y voyez le dessous de mas structure!

    WizardIceTeaMcFCSM02

    L'ombre de ma structure!

    WizardIceTeaMcFCSM03

    La on vois ma structure de cotée Je rappel se sont que des test pour le moment génération!
    Pour rappelle il y a des bug d’éclairage ou on vois carrément que c'est le jour et la nuit c'est bug ci se règle avec une MAJ des block .
    Je ne parle jamais de ces bug ci mais des lumières qui rance perce ma structure et déforme sont ombre

    WizardIceTeaMcFCSM04

    Sur l'image citez ci dessus et dessous je mesure l'écart entre certaine anomalie et on vois qu'il font bien la taille des chunck

    WizardIceTeaMcFCSM05

    L'explication et simple les zone éclairez on été générée avent ma structure quand ma structure c'est générée par dessus il n'a MAJ la luminosité que dans les chunck ou sa génération à étée lancée et ceux qui ce sont générée en même temps.

    Voilà ce que je voulais dire par fonctionne MAL . :@

    Je ne veut plus m'expliquez encore sur les que je rencontre !Surtout que ce n'est n'y intéressent n’y constructif de le répétez !!

    Alors pitez plus de "ça marche chez moi "



  • et tu penses pas que ça peut venir tout simplement d'éclipse qui à trop de mal à générer la structure et du génère les bugs, sur un serveur, il n'y aura pas forcément ces bugs


  • Administrateurs

    Eclipse ne fait rien tourner du tout …
    C'est ton processeur qui fait tourner minecraft. Donc si sur un serveur ça fonctionne mieux, c'est parce que le cpu du serveur est plus performant.

    Et corriger un problème d'optimisation en utilisant une machine plus perf, ce n'est pas un vrai correctif.

    Ce qu'il faudrait faire c'est diviser la structure en plusieurs morceaux de 16x16 et générer morceau par morceau sur chaque chunk.



  • Tu as aussi moyen de demander manuellement une update de la luminosité dans chaque chunk (voire plus d'une si il le faut) après avoir généré toute la structure via la fonction de la classe World (je sais plus son nom par contre).



  • Diviser la structure en plusieurs morceaux de 16x16 et générer morceau par morceau sur chaque chunk.

    Est la chose la plus sensé à faire mais je n'ai pas trouvez comment.

    Ils fraudais crée une zone mémoire qui contiendrais le plans de ma structure, mais je ne vois pas comment créée cette zone car il faudrait la sauvegardez dans un fichez 
    Problème je ne sait pas si minecraft peut proposer de fonction de sauvegarde de donner supplémentaire.

    A défaut de trouvez des formas de donnée propre à minecraft. Je devrais donc constituez les miens !
    Si quel qu'un peut m'indiquez la zone de minecraft ou les fonction de sauvegarde ? Que je puise reprendre la même logic .

    Si vous trouvez une autre solution que de crée une zone tampon avent génération cela m’intéresse !

    Pour finir je pence qu’après ce serra la fin de ce sujet .
    Car basiquement sur ce point c'est de la programmation classic.
    Je serais plongez dans mon livre de code pour trouvez comment sauvegardez des donnez .
    Et je serais sur openclassroom pour trouvez des solution de bibliothèque java.

    D'avance je remercie tous ceux qui mon aidez sur ce projet qui et plus dure que je ne le pensais !
                         Mais je n’abondons rien ! Je verrais si je peut vous tenir de l’agencement de mon projet .

    Une MAJ de la lumière sa parais difficile puisque c'est la lumière du jour qui passa aux travers de mes bock !