Como faço para mover objetos ao longo de um caminho?

Estou tentando obter algo como a imagem abaixo. Como você pode ver, há uma rodovia e, dentro dela, alguns objetos se movem (milissegundos). Eu acho que o comportamento da rua é como um oleoduto. Quando a rodovia carrega um objeto, ela aparece no início e ela se move pela rodovia até chegar ao outro extremo da rodovia.

Meu principal problema é: como posso mover vários objetos apenas dentro da estrada?

Isso depende: como você quer que eles se movam?

A opção não natural

Defina um caminho predefinido com uma série de vértices e faça com que os balões sigam o caminho rigorosamente.

Uma opção mais natural

Faça os balões girarem e implementem o caminho da multidão seguindo o comportamento , o que fará com que eles sigam o caminho (e não fiquem muito longe dele), evitando colisões entre si. Ambas as páginas contêm exemplos de applet Java.

O autor dessas páginas observa que ele não pode distribuir o código fonte dos exemplos, no entanto, o OpenSteer oferece implementações em C ++ desses algoritmos.

(Não conheço nenhuma biblioteca C # boids ou qualquer tutorial decente - o melhor que fiz foi seguir exemplos de código)

Você precisa de uma lista de pontos e uma lista de balões

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

Se você tem uma estrada composta de ladrilhos com um único caminho ("pipeline" como você chamou), não precisa de boids, evasão, IA ou realmente qualquer coisa super especial. Basta fazer com que cada balão se mova na direção natural do ladrilho da estrada. Por exemplo, dado um ladrilho inicial com apenas um ladrilho que não é areia para tocar, você pode descobrir em que direção se mover - é a direção que "não está aqui, não onde eu estava, e não areia". Como sua estrada possui apenas duas direções possíveis de fluxo, uma vez que a direção inicial e o ladrilho sejam estabelecidos, o algoritmo resolverá o problema.

Os balões parecerão seguir um ao outro simplesmente porque não há outro lugar para ir. Se todos eles se moverem a uma velocidade constante, nenhuma colisão será possível. Mesmo que eles não se movam a uma velocidade constante, o "não aqui, não onde eu estava, e não areia" pode ter "e garantir que haja espaço suficiente para mim" anexado.

Você pode generalizar um pouco e usar a imagem do bloco como um método de extrair a direção. Por exemplo, uma faixa de estrada em forma de L significa "se você estiver indo para o sul, depois vire para o leste" ou "se você estiver indo para o oeste, vire para o norte".

Este sistema falha quando você toma decisões, ou seja, mais do que um único caminho que pode ser percorrido, mas a partir da captura de tela e da descrição do problema, isso não parece ser um problema. Se for um requisito para a sua aplicação, invista definitivamente em uma abordagem mais centrada na IA.