Visualizzazione dell'intervallo sulla griglia esagonale

10

Ecco la situazione

Ho una tavola esagonale, e un'unità su di essa, con velocità o valore di movimento 4. Il terreno di frontiera ha un costo diverso. Quando clicco sull'unità, il gioco dovrebbe mostrarmi un raggio di movimento.

La mia soluzione era quella di controllare ogni esagono nel raggio di 4, con A * pathfinding, e se il costo del percorso era inferiore a 4, allora questo esagono era nel raggio. Finalmente il gioco mi mostra bene il raggio di quell'unità.

La mia domanda è: esiste un'altra soluzione per cercare un intervallo su griglie esadecimali o griglia quadrata, perché anche se sono davvero orgoglioso di quello che ho fatto nella mia soluzione, penso che sia un po 'esagerato? :))

Cosa mi fa fare questa domanda? Ho notato che quando la velocità dell'unità è 4 o 6 o addirittura 8, il tempo necessario per il raggio di calcolo del mio computer era davvero buono, ma quando la velocità era 10 e più ho notato che dovevo aspettare qualche secondo per calcolare Beh, nei giochi reali preferisco non vedere qualcosa del genere e il mio percorso A * è piuttosto ottimizzato, quindi sto pensando che la mia soluzione sia sbagliata.

Grazie per eventuali risposte

— user23673
fonte

1

Concordo con Byte56 che un primo algoritmo di ricerca ampia è una buona soluzione. Questo non vuol dire che non dovresti cercare di essere creativo, ma per quanto riguarda gli algoritmi ben noti è un buon metodo che si applica bene.

— theJollySin,

11

Hai ragione che A * è un po 'eccessivo, ma non di molto. Non dovresti vedere ritardi come te. Un * è davvero solo un algoritmo di Dijikstra modificato . Dal momento che non stai usando una posizione finale (dato che la tua posizione finale è "il più lontano possibile"), non è necessario usare A * con l'aggiunta euristica. Basta usare Dijikstra o una semplice prima ricerca di ampiezza sarà sufficiente.

Ad esempio, Dikikstra si espanderà uniformemente in tutte le direzioni:

inserisci qui la descrizione dell'immagine

(Una semplice prima ricerca sarà simile a questa)

Tieni traccia dei costi per raggiungere ciascun nodo. Una volta che un nodo ha il costo di viaggio massimo, non elaborare ulteriormente i nodi collegati. (Simile a dove i nodi si imbattono nel muro sottostante).

Se riscontri problemi di prestazioni a soli 10 nodi in uscita, ti consigliamo di vedere come accedi ai nodi. Un'ampia prima ricerca dovrebbe essere in grado di navigare tra centinaia di nodi senza un notevole ritardo (certamente non pochi secondi). Considera di archiviare una versione semplice del tuo mondo in un formato grafico, per un rapido spostamento.

— MichaelHouse
fonte

riesci a trovare la distanza tra due nodi usando BFS e tenendo conto di ostacoli / pesi diversi?

— Luca B.

Il costo dello spostamento tra i nodi dovrebbe essere pre-calcolato per la maggior parte. Il costo non viene calcolato utilizzando BFS, BFS è un algoritmo per attraversare i nodi. Il modo in cui si determina il costo per viaggiare da un nodo all'altro è indipendente dal modo in cui si attraversano i nodi.

— MichaelHouse

Grazie, ora vedo perché il mio pensiero era sbagliato, la chiave di ciò era questa affermazione "Dal momento che non stai usando una posizione finale (poiché la tua posizione finale è solo" per quanto puoi andare ")". Nella mia soluzione i aveva una posizione finale, era l'unità. Ho appena risolto il problema da una direzione errata. Prima ho determinato il confine, e poi da lì sono tornato alla mia unità, in quel modo probabilmente ho passato molte volte attraverso gli stessi nodi. quando la mia velocità aumenta, anche il numero di calcoli aumenta molto. Il modo in cui mi mostri, visiterò sempre il nodo una volta. Ho appena avuto un punto di vista sbagliato, davvero grazie, questo semplifica molto.

— user23673

4

Amit Patel ha fornito un'eccellente risorsa per ottenere intervalli sul suo sito . Nell'articolo usa il seguente algoritmo per raccogliere tessere esadecimali in un intervallo:

for each -N ≤ Δx ≤ N:
    for each max(-N, -Δx-N) ≤ Δy ≤ min(N, -Δx+N):
        Δz = -Δx-Δy
        results.append(H.add(Cube(Δx, Δy, Δz)))

Questo crea limiti allineati con la griglia esadecimale:

inserisci qui la descrizione dell'immagine

Questo troverà tutti gli esagoni entro una certa distanza dall'esagono centrale, se vuoi considerare gli ostacoli, usa l'ampiezza prima ricerca dall'altra mia risposta.

— MichaelHouse
fonte

1

Nel caso qualcuno ne abbia bisogno, ecco l'implementazione C # dell'algoritmo di Patel:

IEnumerable<Hex> GetRange(Hex center, int range)
    {
        var inRange = new List<Hex>();
        for (int q = -range; q <= range; q++)
        {
            int r1 = Math.Max(-range, -q - range);
            int r2 = Math.Min(range, -q + range);
            for (int r = r1; r <= r2; r++)
            {
                inRange.Add(center.Add(new Hex(q, r, -q - r)));
            }
        }

        return inRange;
    }

— Allan Haugsted
fonte