juego shoot-em-up de Android. Patrones de enemigos robustos para el comportamiento grupal complejo

Question

Estoy trabajando en un juego de shoot-em-up arcade para Android similar a Ikaruga. El problema que estoy enfrentando es que está resultando bastante difícil crear robustos patrones de movimiento y disparo para los enemigos. Por el momento, he creado dos clases abstractas EnemyShip y FlightPath de las que derivan cada patrón de enemigo y movimiento diferente, respectivamente. Cuando se crea el Mundial se instancia un LevelManager que almacena información de nivel en forma de:

waveInfos.add(new WaveInfo(3, 3f)); // new WaveInfo(NumberOfGroups, spawn interval) 
enemyGroups.add(new EnemyGroup(8, EnemyGroup.TYPE_SCOUT_SHIP, EnemyGroup.F_PATH_INVADERS)); 
enemyGroups.add(new EnemyGroup(1, EnemyGroup.TYPE_QUAD_SPHERE, EnemyGroup.F_PATH_QUAD_SPHERE_L, World.BLACK)); 
enemyGroups.add(new EnemyGroup(8, EnemyGroup.TYPE_SCOUT_SHIP, EnemyGroup.F_PATH_INVADERS)); 
// new EnemyGroup(NumberOfEnemies, EnemyType, FlightPathType) 
// new EnemyGroup(NumberOfEnemies, EnemyType, FlightPathType, ShipColour) 

waveInfos.add(new WaveInfo(2, 0.33f)); 
enemyGroups.add(new EnemyGroup(1, EnemyGroup.TYPE_QUAD_SPHERE, EnemyGroup.F_PATH_QUAD_SPHERE_L, World.WHITE)); 
enemyGroups.add(new EnemyGroup(1, EnemyGroup.TYPE_QUAD_SPHERE, EnemyGroup.F_PATH_QUAD_SPHERE_R, World.WHITE)); 

totalWaves = waveInfos.size(); 

Los niveles están divididos en olas de grupos de enemigos y en este momento la clase EnemyGroup toma creación de instancias de atención, la adición de la ruta de vuelo especificada al enemigo recién creado y pasar a ese enemigo a ArrayList en LevelManager para su almacenamiento hasta que se genere en el mundo en el momento necesario.

Una vez creado, el componente FlightPath asume el control y comienza a dar instrucciones basadas en su propio tiempo de estado y dado que cada FlightPath tiene un campo de referencia para su propietario EnemyShip puede acceder a las funciones del barco y a los miembros que controla.

La clase EnemyShip tiene algunas funciones para facilitar la instrucción, como moveTo (float x, float y, duración del flotador) y shoot() pero incluso con éstas las derivaciones de FlightPath son difíciles de hacer especialmente cuando quiero enemigos diferentes en el mismo grupo tiene trayectorias ligeramente diferentes y llegadas en el tiempo ligeramente diferentes.

creé unos campos en la trayectoria de vuelo para realizar un seguimiento de los fotogramas clave:

public int currentKeyFrame = 0; 
public int totalKeyFrames; 
public KeyFrame[] keyFrames; // Stores duration of instruction to be done, the spreadTime, totalFrameTime and enemyIntervalTime 
public int shipNumber; // Stores which ship out of group this FlightPath is attached to 
public int totalShips; // Stores total number of ships in this EnemyShip's group 
public float stateTime = 0; 

KeyFrame.spreadTime es mi intento de controlar el tiempo entre el primer enemigo en el grupo para comenzar a mover/tiro y el último.

KeyFrame.totalFrameTime = KeyFrame.duration + KeyFrame.spreadTime

KeyFrame.enemyIntervalTime = KeyFrame.spreadTime/Número de enemigos en este grupo

Si bien esta configuración funciona muy bien para el movimiento lineal muy simple, se siente bastante engorroso.

Gracias por leer esto ahora. Mi pregunta es cómo implementar un control de patrones más racionalizado que permita un movimiento complejo sin hordas de declaraciones de if() para verificar qué hacen otros enemigos en el grupo y cosas por el estilo.

Espero haber proporcionado suficiente información para que entiendas cómo se manejan los enemigos. Proporcionaré cualquier código fuente a cualquier persona interesada. Gracias de antemano por cualquier luz que pueda arrojar sobre el tema.

Marios Kalogerou

EDIT: He encontrado una página que describe mucho el tipo de sistema que sería perfecto para lo que quiero, pero estoy seguro de cómo implementar correctamente con respecto a grupo global fotogramas clave

http://www.yaldex.com/games-programming/0672323699_ch12lev1sec3.html

Answer 1

FlightPath no debe controlar ningún objeto. Es un camino, no un administrador. Sin embargo, debería ser capaz de dar coordenadas dado cualquier fotograma clave o tiempo. Por ejemplo: flightPath.getX(1200) -> ¿Dónde debería estar en la coordenada X a 1200 ms?

Cada EnemyShip debe mantener una posesión de una instancia de FlightPath. EnemyShip comprueba dónde debería estar en la ruta cada fotograma.

EnemyGroup controla el desove de cada EnemyShip. Si tienes 8 EnemyShips en un EnemyGroup, todos poseen el mismo tipo de FlightPath, entonces puedes imaginar que EnemyGroup engendraría cada nave a 500ms de distancia para crear la ola.

Finalmente, traduce todas las coordenadas EnemyShip relativas a la coordenada mundo/pantalla, que tradicionalmente se mueve lentamente en la dirección vertical.

Answer 2

hay enfoques diferentes:

1. puede agregar intervalos aleatorios antes disparar, y establecer tiempos de llegada ligeramente aleatorios. Me gusta currentEnemyArrivalTime += (X - rand(2*X)).

2. Puede controlar el movimiento del grupo de enemigos. Cada enemigo en el grupo intenta mantener su posición relativa al centro del grupo.

3. Para patrones realmente complejos, es mejor desarrollar un motor de scripting simple. Puede ser muy simple (como una matriz de coeficientes para spline), o algo más complejo. Creo que, en tales juegos, el comportamiento lo realizan los guiones.