Cartes de donjon récursives représentées par un tableau 2D élastique

J'ai trouvé une méthode pour générer récursivement des cartes de donjon simples en commençant par une pièce et en y connectant de manière aléatoire de nouvelles pièces adjacentes.

Les cartes sont représentées sous forme de tableaux bidimensionnels où chaque cellule contient une valeur de 0 à 15. 0 ne représente aucune pièce tandis que chaque direction est représentée par nord = 1, est = 2, sud = 4, ouest = 8.

Je voulais commencer avec une seule pièce non ([[0]]), puis étendre le tableau 2d si nécessaire pour s'adapter à la carte générée. La difficulté que je rencontre avec cet arbre comme la récursivité est que si les tableaux doivent être décalés pour ajouter des lignes et des colonnes à gauche et en haut de la carte, je dois ajuster la position actuelle de la fonction, à quelle ligne et colonne elle se trouve . Cela fait en sorte que les branches distinctes ne soient pas au courant des ajustements d'index de tableau des autres branches, seules leurs fonctions enfants le sauront car leur position ajustée leur est transmise en tant qu'arguments de ligne et de colonne.

Y a-t-il un moyen de faire cela? J'ai essayé de stocker des valeurs de décalage de ligne et de colonne en dehors de la récursivité, mais cela n'a pas fonctionné pour une raison quelconque.

Y a-t-il une raison pour laquelle vous devez utiliser un tableau 2D, ou est-ce qu'une table de hachage ou un autre type de carte fonctionnerait? Ensuite, les indices x, y continuent juste dans un espace négatif, mais cela n'a pas d'importance.

Si vous êtes préoccupé par la mémoire ou la vitesse du processeur, 1) Ne le soyez pas, les tables de hachage sont très efficaces dans des choses comme des paires d'entiers denses, 2) vous pouvez créer le niveau dans une table de hachage, puis le post-traiter dans un tableau une fois que vous connaissez la taille finale.

Je fais une chose similaire, en Python. (Ou au moins la partie élastique).

J'ai un dictionnaire de (x, y) tuples mappant sur les cellules. En pseudo code:

map = dictionary( (0,0) : cell at (0,0), (1,0) : cell at (1,0) ... (2, 2) : cell at (2,2)
getCell(x,y):
    return map[(x,y)]
    catch error if out of bounds:
         map[(x,y)] = new cell and return

Une table de hachage serait très bonne pour ce genre de chose.

La solution d'effort minimum consiste à choisir une taille maximale (étendue X et Y) que vous souhaitez que le donjon atteigne, placez votre point de départ au centre de cela et ne permettez pas la croissance en dehors. Pas besoin de changer de vitesse. Cela dépend, bien entendu, de l'étendue fixe.

Vous souhaitez utiliser un graphique au lieu du tableau 2D.

Chaque pièce serait un nœud dans le graphe et sait quelles autres pièces lui sont adjacentes:

Room {
    long x;
    long y;
    List adjacentRooms;
}

De cette façon, vous n'avez pas à définir la taille de votre carte.

Les coordonnées x, y peuvent être utilisées comme clé unique dans une table de hachage pour un accès rapide à chaque pièce. L'ajout d'une nouvelle pièce ne ferait qu'ajouter des entrées aux listes adjacentRooms des pièces voisines.

Le graphique est également idéal pour les algorithmes de recherche de chemin, si vous en avez besoin.