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.
}

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;
        }