Sto cercando di generare in modo casuale una mappa di stanze collegate da porte e sono riuscita a generarne una usando questo codice:

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

Tuttavia, questo non mi permette di scoprire quali porte ha la stanza data. Devo essere in grado di capirlo in modo da poter posizionare le porte nei posti corretti in modo che possano essere utilizzate per annettere le stanze. Questo tipo di "smart map" è possibile con il mio attuale algoritmo o dovrei ricominciare da capo? Quali passi posso prendere per farlo funzionare?

Sto usando Slick2d e Java per questo

Grazie.

Penso che questa domanda sia piuttosto aperta, dal momento che ci sono alcuni pezzi di codice che ti serviranno prima di poter collegare correttamente le stanze e come codificare dipende molto da come le cose hanno senso per te.

Detto questo, posso fare alcuni consigli per aiutarti ad andare nella giusta direzione.

Prima di tutto, se le dimensioni delle stanze sono costanti, consiglierei di creare un sistema di coordinate di livello superiore per le stanze. Qualcosa che assomiglierebbe a questo:

 _____ _____ _____ _____ _____
|     |     |     |     |     |
|-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'idea è che quando fai spazio (0,0) chiedi stanze (-1,0) (0, -1) (1,0) e (0,1) dove si trovano le porte adiacenti. Se hai bisogno di schermate, dovrebbe essere abbastanza facile aggiungere un metodo GetScreenCoords o una matrice di trasformazione se ti piacciono.

Successivamente vorrai essere in grado di interrogare l'elenco delle stanze. Passare attraverso tutte le stanze della tua lista (fino a 5000!) Solo per trovare le stanze vicine diventerà costoso. Per un modo rapido per mettere in moto le cose, ti consiglio di usare HashMap<coord, Room> roomsinvece un . In questo modo quando crei spazio (0,0) chiedi camere vicine esistenti che chiedi semplicemente rooms.get((1,0))ecc. E aggiungi la tua camera appena generata a (0,0) che faresti rooms.put((0,0), newroom) Se questo diventa troppo lento, potrebbe vale la pena guardare gli elenchi ordinati. Forse un elenco ordinato (x) di elenchi ordinati (y).

Infine, dovrai aggiungere un modo per ottenere la posizione della porta dalle stanze vicine. Un nuovo metodo come int GetSouthDoor()dovrebbe fare il trucco.

Sono sicuro che ci sarà molto più lavoro per te per codificare una soluzione completa. Spero che questo ti aiuti a iniziare.

Due cose:

1) Nel tuo commento, dici di volere qualcosa come il Vincolo di Isacco. Quel gioco ha le porte nel mezzo di ogni pezzo, garantendo che si allineino. Se segui l'esempio, allora si tratta solo di decidere con quale tipo di porta collegarli (aperto, bloccato, bowall, ecc.).

2) Il codice sembra iniziare in una posizione e generare proceduralmente nuove tessere in una direzione. Nella sua dichiarazione switch, tuttavia, non sei la contabilità per la direzione si sta venendo da . Se continui con quell'algoritmo, considera di tenere traccia anche dell'ultimo posizionamento, in modo che i riquadri non si sovrascrivano l'un l'altro.

Usa un algoritmo di generazione del labirinto

Usa una forma modificata dell'algoritmo di Prim per creare un labirinto di base di circa 20 stanze. Scegli due stanze da iniziare e finire, assicurandoti che la fine sia sempre raggiungibile. Bloccare le porte casuali con diversi tipi di porte e aggiungere casualmente porte in cui due stanze adiacenti non sono collegate (con bassa probabilità)