Apprendre


Vous êtes
nouveau sur
Oniromancie?

Visite guidée
du site


Découvrir
RPG Maker

RM 95
RM 2000/2003
RM XP
RM VX/VX Ace
RM MV/MZ

Apprendre
RPG Maker

Tutoriels
Guides
Making-of

Dans le
Forum

Section Entraide

Interviews: Ephy / Tutos: Godot : Premier Contact -Partie (...) / Tutos: Godot : Premier Contact -Partie (...) / Making-of: Ma première game jam classée / Jeux: Oracle of Tao / Chat

Bienvenue
visiteur !




publicité RPG Maker!

Statistiques

Liste des
membres


Contact

Mentions légales

96 connectés actuellement

11018160 visiteurs
depuis l'ouverture

9 visiteurs
aujourd'hui



Barre de séparation

Partenaires

Indiexpo

Akademiya RPG Maker

Hellsoft

Planète Glutko

Alex d'Or

Offgame

ConsoleFun

Le Studio du Chat Vert

RPG Maker - La Communauté

Tous nos partenaires

Devenir
partenaire



Formule de Donjon (de Base)

Par Z (voir sa galerie)
(Autre)
Ajouté le 01/07/2012 à 23:39:42

❤ 0


L'image est affichée ici


Description de l'auteur

Je ne connais pas les techniques pour générer des donjons mais en voilà une de base que j'ai fais. Elle peut générer des donjons de toutes sortent d'après ce qu'on y paramètre et elle est facilement modifiable selon les goûts.

La forme du code en générale:

Portion de code : Tout sélectionner

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
 
#La map est définie par une table de valeur à deux dimensions [][]
#On commence par précisé quelques valeurs, grandeur du donjon, etc.
#Ce sont les options du donjon donc on peut y mettre un peu n'importe quoi.
#Je vais utiliser les mêmes que dans l'image.
 
int Width      = 60        #Largeur du donjon.
int Height     = 20        #Hauteur du donjon.
int minHalls   = 120       #Le nombre minimal de couloirs.
int maxHalls   = 160       #Le nombre maximal de couloirs.
int minLenght  = 1         #La longeur minimal d'un couloir.
int maxLenght  = 10        #La longeur maximal d'un couloir.
Tuile [Width][Height] Donjon; #Votre table de valeur contenent l'information de
#votre donjon. Cherchez Array c++/ruby/c# ou autre chose sur google si vous 
#ne connaissez pas.
 
###############################################################################
 
#À partir d'ici c'est le code pour générer le donjon.
#En premier il y a le nombres de couloirs dans le donjon.
int HallNumber = (rand()% (maxHalls - minHalls)) + minHalls;
int startX     = rand()% Width;     #Position X où commence le premier couloir.
int startY     = rand()% Height;    #Position Y où commence le premier couloir.
 
#Quelques variables crées et définies à 0, qui sont utilisées plus loin.
int HallLenght = 0;
int Direction  = 0;
int X          = 0;
int Y          = 0;
int K          = 0;
 
#Cette boucle va être appliqué le nombre de fois qu'il y a de couloirs et c'est
#tout, ensuite on affiche la map comme on veut.
for (int i = 0; i < HallNumber; i++)
{
  #Longeur du couloir présant.
  HallLenght = (rand()% (maxLenght - minLenght)) + minLenght;
  #La direction du couloir est choisie au hasard entre 0, 1, 2, 3.
  Direction  = rand()% 4;
  #À chaque début de boucle il est important de remètre X, Y et K à 0.
  K          = 0; #C'est le nombre de cases utilisés pour le couloir présant.
  X          = 0; #Variable utilisée pour la direction plus loin.
  Y          = 0; #Variable utilisée pour la direction plus loin.
 
  #La direction est donné comme ça, j'ai choisi cette méthode pour ainsi
  #écrire le même code peut-importe la direction..
  if (Direction == 0)
    X = 1;
  else if (Direction == 1)
    X = -1;
  else if (Direction == 2)
    Y = 1;
  else if (Direction == 3)
    Y = -1;
    
  #Boucle pour creer le couloir présant à partir de la longeur dite plus haut.
  for (int k = 0; k < HallLenght; k++) 
  {
    #Si la position de départ du couloir + la direction(-1, +1, X/Y) * le point
    #où on en est rendu dans la création du couloir (première case, deuxieme, etc)
    #dépasse les limites du terrain par n'importe quel bord, alors on fait rien
    #sinon, à cette position là, on change la texture de la case pour du plancher.
    if (startX + (X * k) = Width - 1 || startY + (Y * k) = Height - 1);
    else
    {
       Donjon[startX + (X * k)][startY + (Y * k)].Sort = "Plancher";
       #Puis ce qu'on a réussi à créer une case on rajoute 1 à la variable K
       #Qui dit de combien de cases le couloir est de long avec les contraintes
       #d'un peu plus haut.
       K++;
    }
  }
  
  #On est toujours dans la boucle principale de chaque couloir.
  #Mais maintenent que ce couloir est terminé on additionne la direction
  #et le nombre de case qui le constitu à la valeur où il commençait.
  #Comme ça le prochain couloir va commencer où celui-ci terminait.
  startX = startX + (X * K);
  startY = startY + (Y * K);
  
  #Les mêmes étapes seront répétés pour tout les couloirs et c'est tout.
}



Biensûr ce code ne fonctionne pas, je l'ai généraliser un peu pour qu'il soit comprenable, l'originale est une fonction en c++:

Portion de code : Tout sélectionner

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
std::vector GenerateDonjon2D(std::vector Index, int Width, int Height, int minHalls, int maxHalls, int minLenght, int maxLenght)
        {
                int HallNumber = (rand()% (maxHalls - minHalls)) + minHalls;
                int startX     = rand()% Width;
                int startY     = rand()% Height;
                int HallLenght = 0;
                int Direction  = 0;
                int X          = 0;
                int Y          = 0;
                int K          = 0;
 
                for (int i = 0; i < HallNumber; i++)
                {
                        HallLenght = (rand()% (maxLenght - minLenght)) + minLenght;
                        Direction  = rand()% 4;
                        K          = 0;
                        X          = 0;
                        Y          = 0;
 
                        if (Direction == 0)
                                X = 1;
                        else if (Direction == 1)
                                X = -1;
                        else if (Direction == 2)
                                Y = 1;
                        else if (Direction == 3)
                                Y = -1;
 
                        for (int k = 0; k < HallLenght; k++)
                        {
                                if (startX + (X * k) = Width - 1 || startY + (Y * k) = Height - 1);
                                else
                                {
                                    Index[startX + (X * k)][startY + (Y * k)].Sort = " ";
                                        K++;
                                }
                        }
 
                        startX = startX + (X * K);
                        startY = startY + (Y * K);
                }
 
                return Index;
        }



La condition a la ligne 63 (dans le premier) et 32 (dans le deuxième) ne veux pas s'afficher au complet, mais je pense que vous comprenez le principe des limites du terrain. :)






Tata Monos - posté le 02/07/2012 à 06:58:41 (28 messages postés)

❤ 0

Compte Non utilisé

Il faudrait que je test à adapter ça sur mmf même si il existe une extension. Tu aurais plutôt du ouvrir un topic dans général pour qu'on puisse en parler mieux je pense. Cela peut je pense intéresser pas mal de monde.


Tampaxor - posté le 02/07/2012 à 22:51:09 (10274 messages postés)

❤ 0

Bah, ça peut toujours servir de phase de test et une fois que ça marche bien, go forum et tout ça ^^

GG en tout cas, ça fait partie des scripts intéressants.

Chaîne Youtube | Twitter | Facebook | Blog | Fruity Loops, nouvelles bases | Fruity Loops, les VST | SoC | Flickr


Z - posté le 03/07/2012 à 02:58:24 (1417 messages postés)

❤ 0

Oui, j'ai aussi un autre script sympa de PathFinding que j'ai fais pour les persos dans mon truc Isométrique avec détection d'obstacles, etc. Mais je sais pas trop si c'est une ''bonne'' façon où une façon à évité, mais le code est très visuel et simple. :sourit

Suite à de nombreux abus, le post en invités a été désactivé. Veuillez vous inscrire si vous souhaitez participer à la conversation.

Haut de page

Merci de ne pas reproduire le contenu de ce site sans autorisation.
Contacter l'équipe - Mentions légales

Plan du site

Communauté: Accueil | Forum | Chat | Commentaires | News | Flash-news | Screen de la semaine | Sorties | Tests | Gaming-Live | Interviews | Galerie | OST | Blogs | Recherche
Apprendre: Visite guidée | RPG Maker 95 | RPG Maker 2003 | RPG Maker XP | RPG Maker VX | RPG Maker MV | Tutoriels | Guides | Making-of
Télécharger: Programmes | Scripts | Ressources | Packs de ressources | Midis | Eléments séparés | Sprites
Jeux: Au hasard | Notre sélection | Sélection des membres | Tous les jeux | Jeux complets | Le cimetière | RPG Maker 95 | RPG Maker 2000 | RPG Maker 2003 | RPG Maker XP | RPG Maker VX | RPG Maker VX Ace | RPG Maker MV | Autres | Proposer
Ressources RPG Maker 2000/2003: Chipsets | Charsets | Panoramas | Backdrops | Facesets | Battle anims | Battle charsets | Monstres | Systems | Templates
Ressources RPG Maker XP: Tilesets | Autotiles | Characters | Battlers | Window skins | Icônes | Transitions | Fogs | Templates
Ressources RPG Maker VX: Tilesets | Charsets | Facesets | Systèmes
Ressources RPG Maker MV: Tilesets | Characters | Faces | Systèmes | Title | Battlebacks | Animations | SV/Ennemis
Archives: Palmarès | L'Annuaire | Livre d'or | Le Wiki | Divers