Come gestire diverse velocità di azione nei giochi RogueLike?

Come gestire diverse velocità di azione nei giochi RogueLike?

Quello che voglio dire è che i giochi a turni possono avere attori che agiscono a "velocità" diverse, a seconda dell'azione e di alcune altre caratteristiche. Gli attori quindi eseguono effettivamente più azioni / svolte rispetto agli altri se hanno una maggiore velocità o meno.

Come determinare quando un attore dovrebbe essere in grado di recitare (girare la programmazione?)?

Sembra che ci siano diversi modi per farlo? Puoi spiegarne alcuni con gli algoritmi?

Nel mio gioco roguelike Tyrant ho usato un sistema di punti azione e velocità.

Fondamentalmente:

• La maggior parte delle azioni aveva un costo in PA di 100
• La maggior parte delle creature ha una velocità di 100

Quindi il ciclo di gioco sarebbe il seguente.

• L'eroe compie un'azione.
• Il tempo trascorso viene calcolato come hero action AP cost * 100 / hero speed
• A tutte le creature vengono assegnati AP pari a creature speed * elapsed time / 100
• Le creature intraprendono azioni e subiscono la sottrazione degli AP fino a quando i loro AP non sono <= 0
• Ripetere

Questo sistema ha funzionato molto bene nel complesso, ad esempio funzioni interessanti:

• Se hai un eroe molto veloce (forse a causa di un bonus alla velocità magica), puoi fare diverse mosse prima che una singola creatura possa muoversi (i suoi AP sarebbero negativi per alcuni turni perché il tempo trascorso sarebbe piccolo)
• È possibile rendere alcune azioni più o meno costose variando il costo dell'AP
• Puoi ritardare le creature sottraendo gli AP o dare loro una spinta improvvisa una tantum aggiungendo AP

Punti d'azione. Dai a ciascuna entità una "velocità" in modo che gli attori più veloci ottengano più punti ogni turno. Fai completare ad ogni azione un determinato numero di punti per il completamento e sottrai quel numero dai punti del giocatore per quel turno quando compie un'azione. Se un'azione prende più punti di quanti il ​​giocatore ha lasciato, segnalo come "parzialmente completato" e lascia che finisca il turno successivo.

Vuoi dire che le azioni hanno più turni (cioè dormire per 50 turni di fila)?

Quello che vorrei fare è mantenere un oggetto, player.currentAction. currentAction potrebbe contenere quanti turni richiederebbe l'azione, qual è la risoluzione dell'azione e un elenco di stati che annullano l'azione (in pericolo, essere attaccato, troppo caldo, ecc.). Ad ogni turno, prima di controllare l'input del giocatore, verificheremmo se il giocatore era attualmente nel mezzo di un'azione, quindi fare qualcosa di simile a ...

if(!player.currentAction.interrupted())
{
 if(player.currentAction.complete() == true)
   {
    player.currentAction.doAction(); //Some actions, like casting a spell, would have something happen here. Others, like sleeping, may or may not, depending on how you coded it.
    player.currentAction = null;
   }
else player.currentAction.decreaseTimer(); //Decrease our timer by one.
}
else 
{
 player.currentAction.interrupt(); //Let the player know he's been interrupted. Bungle the spell, cancel sleep, etc.
 player.currentAction = null;
}

Puoi andare con punti azione ma senza turni di per sé ma con zecche, che sono molto più piccole. Supponiamo che ogni attore abbia una velocità di accumulo del punto di azione (ad es. 2 AP per tick). Inizia un'azione che vale, diciamo, 10 AP. Il gioco avanza di 5 tick in avanti (perché questo è il tempo impiegato dall'attore per pagare il prezzo AP dell'azione).

Quando ci sono diversi attori. Il gioco avanza tick by tick fino a quando qualcuno non ha pagato il prezzo AP nel momento in cui questa azione viene eseguita.

L'approccio è simile a quello di @ mikera, solo che non ci sono AP negativi.

Tempo ad alta risoluzione

Se il pugno fa 400 giri, e calcio fa 1000 turni, posso darti un pugno almeno due volte prima che tu mi dia un calcio, e posso darti un pugno 5 volte quando mi dai un calcio due volte.

Facendo girare molte cose, hai molto controllo su quanto tempo impiegano.