Direção anti-parede

Eu estou fazendo um pequeno simulador de direção usando o algoritmo boid de Reynolds. Agora eu quero adicionar um recurso para evitar paredes. Minhas paredes são em 3D e definidas usando dois pontos assim:

   ---------. P2
   |        |
P1 .---------

Meus agentes têm velocidade, posição, etc ...

Você poderia me dizer como evitar meus agentes?

Vector2D ReynoldsSteeringModel::repulsionFromWalls()
{
    Vector2D force;
    vector<Wall *> wallsList = walls();
    Point2D pos = self()->position();
    Vector2D velocity = self()->velocity();

    for (unsigned i=0; i<wallsList.size(); i++)
    {
        //TODO
    }

    return force;
}

Então eu uso todas as forças retornadas pelas minhas funções boid e aplico ao meu agente.

Eu só preciso saber como fazer isso com minhas paredes.

Obrigado pela ajuda.

Deixe que cada parede exerça influência na velocidade.

Tente algo como usar a distância inversa (ou distância ao quadrado inversa) da parede para determinar a magnitude da força que cada parede "exerce" e o normal da parede para determinar a direção da força que a parede "exerce".

Então aqui o boid interage com 4 paredes. Como o produto escalar dos vetores vermelhos (centro da boid-to-wall) é maior que 0 para 3 das 4 paredes, essas paredes não exercerão uma força sobre a boid.

Somente a parede com um vetor azul (produto de ponto negativo) terá força.

A magnitude da força deve ser grande com o boid muito próximo da parede, e a direção da força deve estar na direção da seta preta na parede (apontando diretamente para fora da parede).

Se você usar 1 / (t+1)a magnitude da força, onde testá a distância da parede, a força será realmente forte quando chegar perto de 0, mas desaparecerá quando nada for maior (observe a escala do eixo no diagrama, não é 0 quando t = 5, é 0,2). (O t + 1 é para que você não obtenha uma força / divisão infinita por 0 se o boid entrar na parede).

Se você usar 1/(t^2+1), a força é muito mais nítida perto da parede e cai mais rápido / mais suave.

Experimente e veja o que você gosta.

Se alguém precisar do código, aqui está, sinta-se à vontade para redistribuí-lo. Eu tentei comentar para ser mais compreensível. Baseado na solução de bobobobo .

Vector2D ReynoldsSteeringModel::repulsionFromWalls(vector<Vector2D *> walls)
{
    Vector2D force; // My force will be stored here
    Point2D pos = self()->position(); // Position of the agent

    // For each wall
    for (unsigned j=0; j<walls->size(); j++)
    {
        // Get the center point of the wall
        Real coordX = (walls[j]->p1().x() + walls[j]->p1().y()) / 2.0;
        Real coordY = (walls[j]->p2().x() + walls[j]->p2().y()) / 2.0;
        Point2D center(coordX, coordY);

        // Create a new vector between my agent and the center of the current wall
        Vector2D distance(center, pos);

        // If the wall is visible, calculate the force to apply
        double dotProduct = distance * partsList[j]->normal();
        if (dotProduct < 0)
        {
            force +=  partsList[j]->normal() / (distance.length() * distance.length() + 1);
        }
    }

    // Returned the calculated force
    return force;
}