Im essayant de générer au hasard une carte des pièces connectées par des portes, et j'ai réussi à en générer une en utilisant ce code:

public void generate(GameContainer gc) {
        rooms = new ArrayList<Room>();
        startingRoom = new Room(0);
        startingRoom.setPosition(viewport.getCenterX(), viewport.getCenterY());
        lastRoom = startingRoom;
        rooms.add(startingRoom);
        int roomsize = 25;

        for (int i = 0; i <= (1000 + Math.random() * 4000); i++) {
            Room room = new Room(i + 1);
            int direction = (int) (Math.random() * (4));

            switch (direction) {
                case 0:
                    room.setPosition(lastRoom.x, lastRoom.y - roomsize);
                    break;
                case 1:
                    room.setPosition(lastRoom.x, lastRoom.y + roomsize);
                    break;
                case 2:
                    room.setPosition(lastRoom.x + roomsize, lastRoom.y);
                    break;
                case 3:
                    room.setPosition(lastRoom.x - roomsize, lastRoom.y);
                    break;
                default:
                    room.setPosition(lastRoom.x, lastRoom.y - roomsize);
                    break;
            }
            rooms.add(room);
            lastRoom = room;
        }
    } 

Cependant, cela ne me permet pas de savoir quelles portes a la chambre donnée. Je dois être en mesure de comprendre cela afin de pouvoir placer les portes aux bons endroits afin qu'elles puissent être utilisées pour attacher des pièces. Ce type de "carte intelligente" est-il possible avec mon algorithme actuel, ou dois-je recommencer? Quelles mesures puis-je prendre pour que cela fonctionne?

J'utilise Slick2d et Java pour cela

Merci.

Je pense que cette question est assez ouverte, car il y a quelques morceaux de code dont vous aurez besoin avant de pouvoir lier les salles correctement et la façon dont vous codez cela dépend beaucoup de la façon dont les choses ont du sens pour vous.

Cela dit, je peux faire quelques recommandations pour vous aider à aller dans la bonne direction.

Tout d'abord, si la taille des pièces est constante, je recommanderais de créer un système de coordonnées de niveau supérieur pour les pièces. Quelque chose qui ressemblerait à ceci:

 _____ _____ _____ _____ _____
|     |     |     |     |     |
|-2,-1|-1,-1| 0,-1| 1,-1| 2,-1|
|_____|_____|_____|_____|_____|
|     |     |     |     |     |
|-2,0 |-1,0 | 0,0 | 1,0 | 2,0 |
|_____|_____|_____|_____|_____|
|     |     |     |     |     |
|-2,1 |-1,1 | 0,1 | 1,1 | 2,1 |
|_____|_____|_____|_____|_____|

L'idée étant que lorsque vous faites de la place (0,0), vous demandez aux pièces (-1,0) (0, -1) (1,0) et (0,1) où se trouvent les portes adjacentes. Si vous avez besoin de coordonnées d'écran, il devrait être assez facile d'ajouter une méthode GetScreenCoords ou une matrice de transformation si vous y êtes.

Ensuite, vous voudrez pouvoir interroger la liste des chambres. Parcourir toutes les chambres de votre liste (jusqu'à 5000!) Juste pour trouver les chambres voisines coûtera cher. Pour un moyen rapide de faire fonctionner les choses, je recommanderais d'utiliser un à la HashMap<coord, Room> roomsplace. De cette façon, lorsque vous créez une pièce (0,0), vous demandez des pièces voisines existantes, vous demandez simplement rooms.get((1,0))etc., et pour ajouter votre pièce nouvellement générée à (0,0), vous le feriez. rooms.put((0,0), newroom) Si cela devient trop lent, cela pourrait vaut la peine de regarder des listes triées. Peut-être une liste triée (x) de listes triées (y).

Enfin, vous devrez ajouter un moyen d'obtenir la position de la porte des pièces voisines. Une nouvelle méthode comme celle-ci int GetSouthDoor()devrait faire l'affaire.

Je suis sûr qu'il vous faudra encore beaucoup de travail pour coder une solution complète. J'espère que cela vous aidera à démarrer.

Deux choses:

1) Dans votre commentaire, vous dites que vous voulez quelque chose comme la Reliure d'Isaac. Ce jeu a des portes au milieu de chaque pièce, garantissant qu'elles s'alignent. Si vous emboitez le pas, il ne s'agit que de décider du type de porte avec laquelle les connecter (ouverte, verrouillée, bowall, etc.).

2) Votre code semble commencer à un endroit et générer de nouvelles tuiles procédurales dans une seule direction. Dans votre déclaration de commutation, cependant, vous n'êtes pas représentant la direction que vous venez de . Si vous continuez avec cet algorithme, pensez également à garder une trace du dernier emplacement, afin que les tuiles ne se remplacent pas.

Utilisez un algorithme de génération de labyrinthe

Utilisez une forme modifiée de l'algorithme de Prim pour créer un labyrinthe de base de 20 pièces environ. Choisissez deux salles comme salles de début et de fin, en vous assurant que la fin est toujours accessible. Bloquer les portes aléatoires avec différents types de portes et ajouter au hasard des portes où deux pièces adjacentes ne sont pas connectées (avec une faible probabilité)