Game Development Stack Exchange is a question and answer site for professional and independent game developers. It only takes a minute to sign up.
Sign up to join this community
How to manage different speed of actions in RogueLike games?
What I mean is that turn based games may have actors acting at different "speed", depending on the action and some other characteristics. The actors then effectively do more actions/turns than others if they have greater speed, or not.
How to determine when an actor should be able to act (turn scheduling?)?
It looks like there is different ways to do it? Can you explain some with algorithms?
In my roguelike game Tyrant I used a system of action points and speed ratings.
Basically:
Then the game loop would go as follows.
hero action AP cost * 100 / hero speedcreature speed * elapsed time / 100This system worked very nicely overall, example nice features:
Action points. Give each entity a "speed" so that faster actors get more points each turn. Make each action take a specific number of points to complete, and subtract that number from the player's points for that turn when he takes an action. If an action takes more points than the player has left, mark it as "partially completed", and let him finish it next turn.
Do you mean having actions take multiple turns (i.e., sleeping for 50 turns straight)?
What I would do is keep an object, player.currentAction. currentAction might contain how many turns the action would require, what the resolution of the action is, and a list of states that cancel the action (in danger, being attacked, too hot, etc). Each turn, before we checked for player input, we would check to see if the player was currently in the middle of an action, then do something like something like...
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;
}
You can go with action points but no turns per se but ticks, which are much smaller. Suppose every actor has action point accumulation speed (e.g. 2 AP per tick). It starts an action worth, say, 10 AP. The game advances 5 ticks forward (because this is how much it takes for the actor to pay action's AP price).
When there are several actors. The game advances tick by tick until somebody has payed AP price at wich point this action is executed.
The approach is similar to @mikera's, only there are no negative APs.
High Resolution Time
If punch takes 400 turns, and kick takes 1000 turns, I can punch you at least twice before you kick me, and I can punch you 5 times by the time you kick me twice.
By making things take lots of turns, you have a lot of control over how long things take.
