Gioco sparatutto su Android. Robusti schemi nemici per comportamento di gruppo complesso

Question

Sto lavorando a un gioco sparatutto arcade per Android simile a Ikaruga. Il problema che sto affrontando è che è abbastanza difficile creare schemi di mosse e scatti per i nemici. Al momento ho creato due classi astratte EnemyShip e FlightPath da cui derivano rispettivamente ciascun nemico e modello di movimento. Quando viene creato il mondo si crea un'istanza di un LevelManager che memorizza informazioni di livello in forma di:

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(); 

I livelli sono divisi in ondate di gruppi di nemici e in questo momento la classe EnemyGroup si occupa di creare un'istanza, aggiungendo gli aerei specificato al nemico appena creato e passando quel nemico alla Lista Array in LevelManager per lo stoccaggio fino a quando non viene generato nel mondo nel momento necessario.

Una volta generato il componant Flightpath prende il sopravvento e inizia a dare istruzioni basate su di essa la propria stateTime e dal momento che ogni Flightpath ha un campo di riferimento al suo proprietario EnemyShip si può accedere alle funzioni della nave e dei membri è di controllo.

La classe EnemyShip ha alcune funzioni per istruzioni semplici come moveTo (float x, float y, float duration) e shoot() ma anche con queste le derivate FlightPath sono difficili da creare specialmente quando voglio nemici diversi stesso gruppo per avere percorsi leggermente diversi e arrivi di tempo leggermente diversi.

ho creato un paio di campi nel Flightpath per tenere traccia dei fotogrammi chiave:

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 è il mio tentativo di controllare il tempo tra il primo nemico in gruppo per iniziare a muoversi/le riprese e l'ultimo.

KeyFrame.totalFrameTime = KeyFrame.duration + KeyFrame.spreadTime

KeyFrame.enemyIntervalTime = KeyFrame.spreadTime/numero di nemici in questo gruppo

Mentre questa configurazione funziona alla grande per molto semplice movimento lineare, ci si sente abbastanza ingombrante.

Grazie per aver letto fino a qui. La mia domanda è come implementare un controllo di pattern più snello che consentirebbe movimenti complessi senza orde di istruzioni if ​​() per verificare quali altri nemici nel gruppo stanno facendo e così via.

Spero di aver fornito informazioni sufficienti per capire come vengono gestiti i nemici. Fornirò qualsiasi codice sorgente a chiunque sia interessato. Grazie in anticipo per qualsiasi luce si può versare sull'argomento.

Marios Kalogerou

EDIT: ho trovato una pagina che descrive molto il tipo di sistema che sarebbe perfetto per quello che voglio, ma io sono sicuro come implementare correttamente per quanto riguarda il gruppo nel complesso i fotogrammi chiave

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

Answer 1

FlightPath non deve controllare alcun oggetto. È un percorso, non un manager. Tuttavia, dovrebbe essere in grado di fornire le coordinate fornite da qualsiasi keyframe o tempo. Ad esempio: flightPath.getX(1200) -> dove dovrei essere nella coordinata X a 1200 ms?

Ogni EnemyShip deve mantenere il possesso di un'istanza di FlightPath. EnemyShip controlla dove dovrebbe essere nel percorso ogni fotogramma.

EnemyGroup controlla quindi lo spawning di ogni EnemyShip. Se hai 8 EnemyShip in un EnemyGroup, tutti possiedono lo stesso tipo di FlightPath, quindi puoi immaginare che EnemyGroup genererà ogni nave a circa 500ms di distanza per creare l'onda.

Infine, si traduce coordina tutte le EnemyShip relativo alla/schermo mondo coordinate, che si muove tradizionalmente lentamente nella direzione verticale.

Answer 2

ci sono diversi approcci:

1. È possibile aggiungere intervalli casuali prima sparare e impostare tempi di arrivo leggermente casuali. Come currentEnemyArrivalTime += (X - rand(2*X)).

2. È possibile controllare il movimento di un gruppo di nemici. Ogni nemico nel gruppo cerca di mantenere la sua posizione rispetto al centro del gruppo.

3. Per davvero modelli complessi possono essere meglio per sviluppare qualche semplice motore di scripting. Può essere molto semplice (come una serie di coefficienti per spline) o qualcosa di più complesso. Credo che in questi giochi il comportamento sia fatto da script.