Sto realizzando una Tower Defense e per questo ho bisogno di un buon algoritmo di tracciamento.
Ho pensato a Dijkstra ma ne ho bisogno che può essere dinamico; deve essere in grado di aggiornarsi quando un bordo viene rimosso o aggiunto senza un ricalcolo completo.
Sto codificando in C # se aiuta.
Risposte:
In genere vorrai usare A *, a meno che non ci sia qualcosa di molto diverso che stai cercando.
Avevo bisogno di risolvere un problema simile: l'individuazione di percorsi su una grande griglia simile a un labirinto con "costi" e barriere in costante cambiamento.
Il fatto è che nel gioco di difesa della torre il numero di entità che devono risolvere il percorso per loro è di solito molto più grande del numero di nodi nel grafico. Un * non lo è l'algoritmo più appropriato per gestirlo, perché dovrai risolverlo di nuovo ogni volta che qualcosa viene cambiato. Bene, è appropriato se devi trovare solo un percorso, ma nel mio caso avevo bisogno di essere in grado di gestire entità che possono apparire in posizioni diverse e ognuna ha il suo percorso.
L' algoritmo di Floyd-Warshall è molto più appropriato, anche se nel mio caso ho scritto un algoritmo personalizzato che ogni volta che un nodo cambia, ricalcola il costo di quel nodo da tutti i suoi vicini, e quindi se i vicini sono stati cambiati viene invocato ricorsivamente su di loro.
Quindi all'inizio del gioco, accendo questo algoritmo su tutti i miei nodi "obiettivo". Quindi, ogni volta che cambia un singolo nodo (ad esempio, diventa non passabile), lo accendo solo su quel nodo e la modifica viene propagata a tutti i nodi che saranno interessati e quindi interrotta. Quindi non è necessario il ricalcolo globale e l'algoritmo è completamente indipendente dal numero di entità che richiedono l'individuazione del percorso.
Il mio algoritmo era sostanzialmente qualcosa di simile (pseudo-codice):
update_node method in Node class:
$old <- $my_score
find $neighbor node among all neighbors such that
$neighbor.score + distance_to($neighbor) is minimal
$my_score <- $neighbor.score + distance_to($neighbor)
$next_node <- $neighbor
if ($my_score != $old)
for each $neighbor
$neighbor.update_node()Con il punteggio iniziale a seconda che il nodo sia un obiettivo o una sorta di barriera.
L'algoritmo di rotta che ho usato sul mio TD era all'indietro rispetto al normale percorso A * a causa del numero di entità che avevo nel gioco. Invece di passare dall'obiettivo ai cattivi, ho indirizzato dall'obiettivo a ogni quadrato vuoto sul tabellone.
Questo non richiede molto tempo, continui a iterare la scheda fino a quando non hai trovato i tuoi "costi" e fornisce un buon feedback per i percorsi bloccati (se li stai facendo). L'uso dell'algoritmo di Floyd è veloce e compatibile con la cache rispetto ad A * in quanto non esegue ricerche dipendenti dai dati, si sta semplicemente caricando e operando sui dati nei flussi.
Inizia con la tua scheda impostata su un costo infinito, quindi imposta la casella obiettivo su costo zero, quindi esegui l'iterazione sulla scheda controllando se una cella vicina costa meno del costo corrente più il costo del viaggio. Il costo del viaggio è dove hai messo la tua euristica (nel mio caso, il costo del viaggio in diagonale era infinito, ma il costo del viaggio attraverso una torre era alto, quindi gli era permesso di mangiare attraverso le torri, ma a meno che non avessero scelta)
Una volta ottenuta la griglia dei costi, è possibile creare rapidamente una griglia "flusso" da quella testando il gradiente di costo più ripido sulle celle. Questo funziona davvero bene per enormi quantità di cattivi perché nessuno di loro deve mai trovare il percorso, seguono solo le indicazioni virtuali.
Un altro vantaggio è che in questo modo devi solo eseguire questo compito ogni volta che aggiusti gli ostacoli (o nel mio gioco, quando un brivido si nutre attraverso una delle tue torri). Non ogni volta che un creep / mob entra nel campo (che con migliaia di mob e decine al secondo sarebbe stato piuttosto un mal di testa).
Il pathfinding è veloce e su qualcosa delle dimensioni di un normale gioco di difesa della torre, non avrai problemi a eseguire un passaggio A * o Dijkstra completo ogni volta che qualcosa cambia. Stiamo parlando bene sotto un millisecondo per un aggiornamento completo. Qualsiasi tipo di tracciamento adattivo finisce in modo orribilmente complicato. Fallo nel modo più semplice, a meno che tu non stia realizzando la più grande griglia di difesa della torre al mondo.
Come funziona A * pathfinding? potrebbe essere un buon punto di partenza :-)
Questo potrebbe essere eccessivo per la tua soluzione, ma pensa al routing all'indietro anziché in avanti.
In una partita TD, i nemici generalmente cercano di raggiungere un obiettivo specifico. Rotta all'indietro da quell'obiettivo al primo nemico, quindi memorizza nella cache quel percorso. Nella generazione del percorso per i nemici successivi, usa il primo percorso come punto di partenza e così via. Se hai più punti di accesso nemici o più obiettivi, puoi iniziare da una serie di percorsi pre-memorizzati nella cache.
Il pathpoint di waypoint sarebbe probabilmente il migliore per un gioco td, perché generalmente basato sul livello che l'IA segue un percorso diretto. Fondamentalmente si impostano i nodi o i waypoint quindi si ha il punto "ai" verso il waypoiny e si cammina verso di esso, una volta che si avvicina abbastanza da farlo andare al waypoint successivo, affrontarlo e spostarsi verso di esso.
Da quando qualcuno lo ha chiesto, ti rivolgi ad ambienti che cambiano in modo dinamico ricalcolando il percorso ogni volta che il giocatore posiziona o rimuove una torre e nel frattempo memorizzi quel percorso in memoria. L'ambiente non cambia su ogni frame.
Nota che alcuni giochi TD hanno un percorso prestabilito e non ti consentono di posizionare torri su di esso, quindi risolvono il pathfinding in modo semplice: codificando un percorso e non lasciandolo bloccare :)
Una soluzione semplice è imbrogliare.
Progetta la mappa in anticipo per assicurarti che non ci siano vicoli ciechi. Quindi in ogni incrocio, aggiungi un grilletto che induca il personaggio a scegliere una rotta (esempio: gira sempre a sinistra, gira sempre a destra o a caso).