¿Cómo se hace la evasión local de RTS?

Actualmente, estoy simulando las fuerzas de impacto de la física para evitar las unidades localmente, pero este método a veces empuja a las unidades fuera de la formación y tiene efectos muy indeseables cuando las unidades se agrupan.

Para juegos RTS como Starcraft 2, ¿cómo se hace la evasión local? ¿Se simula la física o un controlador omniciente decide dónde debe estar todo? Sé que esta pregunta puede ser un poco amplia, por lo que pregunto específicamente cómo lograr los comportamientos locales de evitación de Starcraft 2; aunque cualquier cosa que funcione será muy apreciada.

No busco ningún código, solo recursos útiles o explicaciones de cómo Starcraft 2 (o juegos similares) maneja la evasión local.

Actualmente, tengo implementada la detección de colisión (con el vector de penetración), las fuerzas de colisión y el movimiento por velocidad. Cada unidad se compara con otra para una colisión: si chocan, los objetos se compensan inmediatamente por el vector de penetración y luego se aplica la fuerza de colisión. Luego, otro bucle mueve los objetos por sus velocidades y aplica resistencia a las velocidades. El desplazamiento mitiga el problema de las fuerzas de colisión excesivas aplicadas en unidades agrupadas, pero las unidades a veces aún disparan.

La solución que busco debe cumplir los siguientes requisitos (como en Starcraft 2):

• Los objetos no deben superponerse; o al menos las superposiciones deben resolverse finalmente.
• Los objetos no se alejan más de lo necesario para que 2 unidades puedan pararse y moverse una al lado de la otra en una formación.
• No debería haber ningún comportamiento extraño cuando los objetos se agrupan hacia el mismo destino.
• Puede soportar unidades de diferentes tamaños, e incluso diferentes formas convexas.

En lo que he estado pensando hasta ahora es en lugar de detectar colisiones, detectar colisiones futuras para que la superposición nunca ocurra. Luego aplique la restricción, asegurándose de que las velocidades de las 2 unidades no hagan que se superpongan. Todavía estoy jugando con el algoritmo para restringir el movimiento más allá de la superposición.

Parece que lo que está buscando es el algoritmo de prevención de colisión recíproca óptima . El artículo anterior también merece una lectura. Aunque el artículo puede estar un poco involucrado, la teoría detrás del algoritmo es bastante sencilla:

Suponga que ya tiene una simulación (juego) con agentes (unidades) que tienen algún tipo de volumen límite a su alrededor. Es probable que este volumen límite sea lo que ya está utilizando para realizar la detección y respuesta de colisión. Para cada agente, defina una velocidad preferida v_pque pueda o no basarse en la meta del agente.

Ahora, para realizar la simulación:

1. Para cada agente, suponiendo que sea estacionario, calcule todas las velocidades que podrían hacer que colisionen en cualquier momento en el futuro con cualquiera de los otros agentes en movimiento. Esto se puede representar en el "espacio de velocidad" como un conjunto de semiplanos que se cruzan (también conocido como obstáculo de velocidad ).
2. Determine el punto en este espacio más cercano a v_p, esta es la nueva velocidad de la unidad.

Si todos los agentes están ejecutando el mismo algoritmo, elegirán velocidades que se complementen entre sí y evitarán otros agentes. En algunas situaciones, puede causar oscilaciones como esa cosa incómoda que ocurre cuando camina directamente hacia alguien en el pasillo y ambos intentan apartarse en la misma dirección, pero los documentos cubren cómo evitar eso.

Para calcular las dos etapas del algoritmo anterior, puede usar las sumas de Minkowski para determinar cuál es el obstáculo de velocidad, y luego usar un modelo de programación lineal (como el Algoritmo Simplex ) para determinar el punto más cercano al v_pque evita el obstáculo de velocidad. Además, el código para evitar colisiones está disponible para su lectura y se ha transferido a C # para usarse en motores de juegos como Unity. Esta técnica se ha utilizado al menos en Warhammer 40,000: Space Marine y quizás en otros juegos .

No sé cómo funcionan sus unidades, pero supongo que son como una máquina de estado:

Estados posibles

• Corriendo a (x, y, z)
• Atacar (enemigo_id)
• Recopilación de recursos (ressource_id)

Si prestas atención a cómo Starcraft aborda este problema, encontrarás que:

1. Si hay espacio para moverse en una dirección, el personaje se mueve en esa dirección.
2. Si no hay espacio, la unidad en el camino se moverá para hacer espacio
3. Si la unidad que necesita moverse para hacer espacio ya tiene un comando, mantendrá el comando, pero lo modificará ligeramente para eventualmente hacer lugar.

Aquí escenario 1:

¿Tengo espacio para ir allí? Si ? Entonces vete

Escenario 2:

¿Tengo espacio para ir allí? No ? Oye, ¿puedes hacerme un espacio? Me estás bloqueando. Ya tengo una orden para moverme hacia adelante, pero lo acomodaré.

Entonces, qué necesitará implementar:

• Las unidades deben ser conscientes de su entorno.
• Las unidades deben tener una forma de comunicarse entre sí
• Debe implementar una forma de seguir ejecutando un comando mientras acomoda otra unidad

Una forma de hacerlo es hacer que las unidades formen auto formaciones y hacer que intenten permanecer en una posición relativa al centro de la formación . Luego, en lugar de mover cada unidad individualmente, mueva el centro de la formación.

Aquí hay una forma básica de hacerlo usando una formación de caja y resortes simples para mantener las unidades en sus posiciones apropiadas:

// Defines a phalanx (box) formation
class Formation
    // Center of the box in the world
    Position center;
    // Width in # of units
    int width;
    // Height in # of units
    int height;
    // Space between units
    float scale;
    // How much force units will apply to stay near
    // their assigned spot.
    float springforce;

    // Return a position of a unit at the given row and column
    // Todo: add a rotation to this formation so it can rotate when moving.
    Position GetUnitPhalanxPosition(int row, int column)
        return new Position(center.X + column * scale - width * scale /2, 
                            center.Y + row * scale    - height* scale / 2);

// Represents a simple point object with a velocity and position;
// it belongs to a formation.
class Unit
    Position pos;
    Velocity vel;
    Formation formation;
    // What's our assigned spot in the formation?
    int row;
    int column;

    void Update(float dt)
        // Get the desired target position in the formation
        Position target = formation.GetUnitPhalanxPosition(row, column);
        // Apply a spring force toward the position (todo: you might want to damp this)
        vel += (target - position) * dt * formation.springforce;
        // Move along the velocity vector.
        pos += vel * dt;

Sé que algunas personas fruncen el ceño ante la descarga de enlaces, sin embargo, encontré que un enfoque basado en el campo potencial de múltiples agentes para bots de juego de estrategia en tiempo real (ISBN 978-91-7295-160-0) es un documento muy esclarecedor, y obviamente transmite mucho más de lo que podría explicar. El documento explora el uso de campos de potencial artificial (un concepto que se origina en la robótica), para facilitar la prevención de colisiones locales dentro de un contexto de desarrollo de juegos.