Come devo costruire la struttura dei dati per un "labirinto" dinamico e di dimensioni illimitate?

In realtà non sono sicuro che "labirinto" sia il termine corretto. Fondamentalmente gli utenti iniziano in un singolo Roomcon 4 porte (N, S, E e W). Possono andare in qualsiasi direzione e ogni stanza successiva contiene un'altra stanza da 1 a 4 porte che vanno in altre stanze.

Il "labirinto" dovrebbe avere dimensioni illimitate e crescere man mano che si spostano le stanze. C'è un numero limitato di Roomsdisponibili, tuttavia il numero disponibile è dinamico e può cambiare.

Il mio problema è che non sono sicuro della migliore struttura di dati per questo tipo di modello

Ho pensato per la prima volta di usare solo una serie di Roomoggetti [X] [X] , ma preferirei davvero evitarlo poiché la cosa dovrebbe crescere in qualsiasi direzione e dovrebbero essere costruite solo stanze "visitate".

L'altro pensiero era che ogni Roomclasse contenesse 4 Roomproprietà collegate per N, S, E e W, e si collegasse solo alla precedente Room, ma il problema con quello non so come identificare se un utente entra in una stanza che ha una stanza adiacente già "costruita"

Per esempio,

--- --- ----------
| | | |
   Inizia 5 4
| | | |
--- --- --- ---
--- --- ---------- --- ---
| | | | | |
| 1 2 3
| | | | | |
--- --- --- --- ----------

Se l'utente si sposta da Start> 1> 2> 3> 4> 5, allora Room# 5 deve sapere che W contiene la stanza iniziale, S è la stanza # 2 e in questo caso non dovrebbe essere disponibile e N può essere una nuovo Roomo un muro (niente).

Forse ho bisogno di un mix di array e stanze collegate, o forse sto solo guardando questo nel modo sbagliato.

Esiste un modo migliore di costruire la struttura dei dati per questo tipo di "labirinto"? O sono sulla strada giusta con il mio attuale processo di pensiero e mi mancano solo alcune informazioni?

(Se sei interessato, il progetto è un gioco molto simile a Munchkin Quest )

Fornisci le coordinate di ogni stanza (inizio sarebbe (0,0)) e memorizza ogni stanza generata in un dizionario / hashmap per coordinate.

È banale determinare le coordinate adiacenti per ogni stanza, che è possibile utilizzare per verificare se esiste già una stanza. È possibile inserire valori null per rappresentare posizioni in cui è già determinato che non esiste alcuna room. (o se ciò non è possibile, non sono sicuro atm, un dizionario / hasmap separato per le coordinate che non contengono una stanza)

Nella maggior parte dei casi, ciò che stai descrivendo suona come un grafico. Dati alcuni dei tuoi requisiti (l'aspetto crescente) probabilmente sceglierei un elenco di adiacenza come implementazione (l'altra opzione comune sarebbe una matrice di adiacenza ).

Non sono sicuro di quale lingua si sta utilizzando, ma un buon tutorial / spiegazione con dettagli di implementazione per un grafico implementato con una lista di adiacenza in .NET è qui .

Un paio di pensieri sull'implementazione (ho pensato a Carcassonne che ha una serie di altri aspetti stimolanti per la costruzione della matrice - è stata persino una domanda di intervista che mi è stata posta una volta).

Ci sono alcune domande poste a questa struttura:

1. c'è una stanza in X, Y?
2. c'è una stanza [N / S / E / W] della posizione vuota X, Y?

Il problema con semplici elenchi e grafici

La difficoltà con elenchi semplici è che si deve percorrere la struttura per verificare se qualcosa può essere posizionato in una determinata posizione. Il sistema ha bisogno di un modo per accedere a una posizione arbitraria O (1).

Ritenere:

1 2 3 ? 4
5 . . * 6
7 8 9 A B

Per trovare le informazioni sulla possibile posizione '?', Quando al punto 3, si deve camminare tutto intorno per arrivare a 4. La risposta del collegamento con informazioni extra su quanti nodi salta (in modo che 3 sia collegato a 4 con informazioni extra 'salto 1') richiede ancora delle passeggiate quando si trova l'adiacenza di '*' da 6 o A.

Matrici semplici, grandi

C'è un numero limitato di camere disponibili

Se questo non è un numero grande, basta creare un array 2N x 2N e lasciarlo lì. Un array 100 x 100 è "solo" 10.000 puntatori e 50 oggetti. Indice direttamente nell'array.

Questo potrebbe essere ridotto a NxN solo se le attività fuori limite spostassero l'array in modo da essere sempre entro i limiti. Ad esempio, se si dovesse aggiungere una stanza che avrebbe underflow l'array, avere la griglia per spostare ogni elemento di una posizione in modo che non ci fosse più underflow. A questo punto, le dimensioni del mondo per 50 stanze sarebbero 2500 puntatori e 50 oggetti.

Matrici e matrici sparse

Per creare questo in modo più ottimale, guarda in una matrice sparsa in cui la maggior parte degli elementi sono 0 o null. Per due dimensioni, questa è nota come matrice sparsa . Molti linguaggi di programmazione hanno varie librerie per lavorare con questa struttura. Se la libreria si limita a numeri interi, è possibile utilizzare questo numero intero come indice in una matrice fissa di stanze.

Il mio approccio preferito sarebbe quello di avere le stanze come una struttura (puntatori alle stanze adiacenti e coordinate) e avere anche la stanza un puntatore da una tabella di hash che è incisa sulle coordinate. In questa situazione per chiedere quale stanza è [N / S / E / W] da una stanza nulla, si dovrebbe interrogare la tabella hash. Per inciso, questo è il formato "DOK" per la memorizzazione di una matrice sparsa.

Cosa ne pensi di questo..

Dai a ogni cella un collegamento a ciascuno dei suoi vicini. Assegna a ogni cella una sorta di nome (ad esempio "0/0", "-10/0" (Supponi di iniziare da 0,0)). Aggiungi un HashSet con tutti i nomi al suo interno. Mentre provi a spostarti in un'altra cella, controlla che il vicino non sia già presente nell'HashSet.

Inoltre, se si crea un'apertura in un'altra stanza, ciò implica che le stanze esistono? Quindi creeresti un collegamento a una stanza vuota senza collegamenti a nessuna stanza. Probabilmente vorresti anche controllare i vicini delle nuove stanze. Se ne esiste uno e si apre alla tua nuova stanza, aggiungi una porta a quella stanza.

   Empty   
   (0,1)        

---    ---            ----------
|        |            |        |
    0,0       1,0        2,0       Empty
|        |            |        |   (3,0)
---    --- ---------- ---    ---
|        | |        | |        |
|   0,-1      1,-1       2,-1      Empty
|        | |        | |        |   (3,-1)
---    --- ---    --- ----------

   Empty     Empty   
  (0,-2)    (1,-2)

HashSet = {0 | 0, 1 | 0, 2 | 0, 3 | 0, 0 | -1, 1 | -1 ....} 1,0: W = 0,0 / Porta; 1,0: N = 1,1 / Vuoto; E = 2,0 / Porta; S = 1, -1 / Muro

Dovresti anche assicurarti di dare ad ogni nuova stanza almeno una porta non adiacente (ad un'altra stanza) in modo che il labirinto possa crescere in quella direzione.

Quello che stai progettando assomiglia molto a un grafico.

Questi sono spesso rappresentati come un insieme di stati Q , uno stato iniziale q ₀ ∈ Q e alcune transizioni Δ . Quindi, suggerirei di conservarlo in questo modo.

• Un set Q : {s, 1, 2, 3, 5, 6}
• Uno stato iniziale q ₀ : s
• Una mappa delle relazioni di transizione Δ : {s → 1, s → 5, 1 → 2, 2 → 3, 3 → 4, 4 → 5}

Le lingue più ragionevoli hanno sia mappe che set.

Potresti prendere in considerazione un elenco di link a 4 vie ...

Per la prima volta ho pensato di usare solo una matrice [X] [X] di oggetti Room, ma preferirei davvero evitarlo poiché la cosa dovrebbe crescere in qualsiasi direzione e dovrebbero essere costruite solo le stanze "visitate".

Puoi ancora usare un [] [] per quello. La crescita dinamica potrebbe essere lenta, specialmente quando si aggiunge all'inizio, ma forse non è poi così male. Dovresti profilare per verificare. Cercare di manipolare un elenco o una mappa collegati potrebbe effettivamente essere peggio, e su un livello costante piuttosto che occasionale.

Puoi costruire solo stanze visitate implementando una valutazione pigra. Un oggetto può essere in posizione che contiene una stanza e non crea quella stanza fino a quando non room()viene richiamato su di essa. Quindi restituisce lo stesso ogni volta dopo. Non è difficile da fare.

Ho imparato a farlo tramite il libro "Creazione di giochi di avventura sul tuo computer". Se sei disposto a scavare attraverso il codice BASIC (il libro è così vecchio) vai a leggere qui:

http://www.atariarchives.org/adventure/chapter1.php

Per la scorciatoia, ciò che fanno è avere una matrice di stanze, con un elemento in ogni matrice che è un puntatore a un'altra stanza in cui puoi andare, con 0 (vorrei usare -1 in questi giorni) per indicare che non puoi andare in quel modo. Ad esempio, creeresti una struttura di una stanza (o classe o che cosa hai)

room {
 int north_dir;
 int south_dir;
 int west_dir;
 int east_dir;
 // All other variables and code you care about being attached to the rooms here
}

Quindi potresti avere una matrice o una struttura di elenchi collegati o comunque vuoi gestire le tue stanze. Per lo stile di array (o vettori C ++) userei quel codice e le direzioni avrebbero l'indice della stanza a cui si collegano; per un elenco collegato, è possibile utilizzare i puntatori alla stanza successiva.

Come altri hanno già detto, se devi generare dinamicamente nuove stanze quando le persone vi accedono, puoi anche farlo.

Non cercare di risolvere tutti i problemi con una struttura.

Definisci l'oggetto della tua stanza per conservare le cose sulla stanza, non le sue relazioni con le altre stanze. Quindi un array 1D, un elenco, ecc. Possono crescere a piacere.

Una struttura separata può contenere "raggiungibilità" - quali stanze sono accessibili dalla stanza in cui mi trovo. Quindi decidere se la raggiungibilità transitiva deve essere un calcolo rapido o meno. Potresti volere un calcolo della forza bruta e una cache.

Evita l'ottimizzazione precoce. Usa strutture davvero semplici e stupidi algoritmi facilmente comprensibili, quindi ottimizza quelli che vengono utilizzati.