Come faccio a spostare gli oggetti lungo un percorso?

Sto cercando di ottenere qualcosa di simile all'immagine qui sotto. Come puoi vedere, c'è un'autostrada e al suo interno ci saranno alcuni oggetti in movimento (millisecondi). Immagino che il comportamento della strada sia come una conduttura. Quando l'autostrada carica un oggetto, questo appare all'inizio e si sposta attraverso l'autostrada fino a quando non arriva nell'altro estremo dell'autostrada.

Il mio problema principale è, come posso spostare diversi oggetti solo all'interno dell'autostrada?

cattura dello schermo da bloons td4 livello 1

— oscar.fimbres
fonte

Risposte:

Dipende: come vuoi che si muovano?

L'opzione innaturale

Definire un percorso predefinito con una serie di vertici e fare in modo che i palloncini seguano rigorosamente il percorso.

Un'opzione più naturale

Fai gonfiare i palloncini e implementa il percorso della folla seguendo il comportamento , che li farà seguire il percorso (e non allontanarsi troppo da esso) evitando collisioni tra loro. Entrambe queste pagine contengono esempi di applet Java.

L'autore di quelle pagine osserva che non può distribuire il codice sorgente degli esempi, tuttavia OpenSteer offre implementazioni C ++ di quegli algoritmi.

(Non sono a conoscenza di librerie boids C # o tutorial decenti - il meglio che ho fatto è solo seguire esempi di codice)

— doppelgreener
fonte

+1 per una buona risposta. Penso che seguire semplicemente un percorso sia l'unica cosa necessaria per simulare il comportamento rappresentato. I comportamenti di guida torneranno utili quando il percorso si allargherà improvvisamente o appariranno degli ostacoli in cui le "boids" si metteranno in coda.

— Bummzack,

Penso che la prima opzione sarebbe più semplice. È possibile che tu mi mostri un esempio?

— oscar.fimbres

@ oscar.fimbres: dovrebbe essere abbastanza semplice. Basta creare un elenco di coordinate waypoint (ad es. Un array), prendere la prima coordinata come target e spostare il proprio agente in quella direzione. Una volta che l'agente raggiunge il waypoint, prendere quello successivo come target. Se l'agente si muove a velocità costante, puoi anche mappare facilmente qualsiasi superamento al bersaglio successivo.

— Bummzack,

Sì, posso immaginare .. Sto controllando il sito: enchantedage.com/node/78 Anche se, riesco a spostare il mio sprite in quel percorso

— oscar.fimbres

IMO, boids è eccessivo per un problema così semplice. Il movimento in qualsiasi momento è essenzialmente 1D e non è soggetto nemmeno alla direzione di inversione. È probabile che qualsiasi comportamento dello sterzo sia estremamente semplice e non garantisca realmente quel tipo di sistema. Inoltre, i palloncini non agiscono come un gregge, agiscono in modo autonomo e non mostrano alcun reale tentativo di mantenere il "gregge" - sono semplicemente bloccati su una strada e vanno tutti nella stessa direzione. Questa è una coincidenza, non un comportamento esplicitamente programmato. Trattarli come un gregge non ha davvero senso anche nel contesto della guida. Segui tutti?

— Patrick B

È necessario un elenco di punti e un elenco di palloncini

class Path 
{
   List<Vector2> Points;
   float[] Lengths;
   Vector2[] Directions;

   void Build()
   {
       Lengths = new float[Points.Count-1];
       Directions = new float[Points.Count-1];
       for (int i=0; i<Points.Count-1;i++)
       {
            Directions[i] = Points[i+1] - Points[i];
            Lengths[i] = Directions[i].Length();
            Directions[i].Normalize();
       }  
   }
}

class Balloon
{
     Vector2 Position;
     float StagePos;
     int StageIndex;
     Path Path;
     float Speed;

     void Update(float Seconds)
     {
         if (StageIndex!=Path.Points.Count-1)
         {
             StagePos += Speed * Seconds;
             while (StagePos>Path.Lengths[StageIndex])
             {
                 StagePos -= Path.Lengths[StageIndex]; 
                 StageIndex++;              
                 if (StageIndex == Path.Points.Count-1) 
                 {
                     Position = Path.Points[StageIndex];
                     return;
                 }
             }
             Position = Path.Points[StageIndex] + Directions[StageIndex] * StagePos;
         }
     }    
}

— Blau
fonte

Se hai una strada fatta di tessere con un singolo percorso ("pipeline" come la chiamavi), allora non hai bisogno di boids, evitamento, AI o qualcosa di veramente speciale. Basta che ogni palloncino si muova nella direzione naturale della piastrella stradale. Ad esempio, data una tessera iniziale con una sola tessera non sabbia da toccare, puoi capire quale direzione muoverti - è la direzione che non è "qui, non dove ero io, e non sabbia". Poiché la tua strada ha solo due possibili direzioni di flusso, una volta stabilite la direzione iniziale e la piastrella, l'algoritmo risolverà il problema.

I palloncini sembreranno seguirsi semplicemente perché non c'è nessun altro posto dove andare. Se si muovono tutti a velocità costante, non sono possibili collisioni. Anche se non si muovono a velocità costante, il "non qui, non dove ero e non la sabbia" può essere "e assicurarsi che ci sia abbastanza spazio per me".

Potresti generalizzare un po 'e usare l'immagine della piastrella come metodo di estrazione della direzione. Ad esempio, una striscia di strada a forma di L significa "se vai a sud, quindi svolta a est" o "se stai andando a ovest, svolta a nord".

Questo sistema si interrompe quando si prende una decisione, vale a dire più di un singolo percorso che può essere preso, ma dallo screenshot e dalla descrizione del problema, questo non sembra essere un problema. Se è un requisito per la tua applicazione, allora sicuramente investi in un approccio più incentrato sull'intelligenza artificiale.

— PatrickB
fonte