Help with software design of a turn based combat system using SDL2

Question

I have been working on a RPG where the player is free to wander an open world but when a monster is encountered or on keyboard command the game switches to a turn based system. Note this is not like final fantasy like games, I intend for the turn based combat to take place in the same map, there is no scene transition.

I am trying to wrap my head around how to implement the turn based combat system. Right now I have a basic game loop that handles the main world map where the player can move above, pick up items, engage in dialogue with npcs, this looks like this:

while (does_not_quit){
        input();
        logic();
        render()
        }

Within logic() there is a keyboard command that switches the game to turn based mode, turn based meaning the player and npcs' movement and actions are now controlled by aciton points and these refresh once per turn. My question is, mechanically from a software design point of view, what is the best way to implement this turn based system on top of the main game loop?

Currently, what I do is, upon entering turn based mode, I start to check player movement against available action points which are read from a json file for each npc (and player). But how do I generate the effect of turns? For example, when the NPCs move I have to halt all commands from the player and I want each NPC to move separately, one after another and then when its the player's turn again, keyboard commands are restored and the player makes his moves before hitting "end turn". Naively, I have tried using a for loop to cycle through all the npcs+players in a given turn but this doesn't seem right?

I have played around with a few methods but it just doesn't feel right and I feel that there must be some classic design patterns that do this but I haven't been able to find any literature on this.

Can anyone advise?

Answer 1

When your game has different modes it's in, and each mode should have different logic and different UI, then that's often a use-case for the state machine pattern.

So instead of having all your game logic in your one logic()-function, you create a separate logic-function for each state your game can be in.

You might also want to create an enter-function and leave-function for each state which do the logic for initializing and cleaning up the state. In order to keep everything that belongs to one state together, it can be a good idea to keep those three functions for each state together in one source file for each state. Or if your code gets too long for that, you might want to create a separate folder for each state.

Your logic-function would then look something like that:

void logic(void) {
    /* stuff you want to happen in every state */

    case (currentState) {
        STATE_WALK:
            walk_logic();
            break;
        STATE_DIALOG:
            dialog_logic();
            break;
        STATE_COMBAT:
            combat_logic();
            break;
    }
}

Now you can switch states by changing the value of currentState between a bunch of constants. But wait, remember to call the enter and leave functions. To make sure you don't skip them, you might want to create an utility function for that:

void switchState(int newState) {
    // exit the old state
    case (currentState) {
        STATE_WALK:
            walk_leave();
            break;
        STATE_DIALOG:
            dialog_leave();
            break;
        STATE_COMBAT:
            combat_leave();
            break;
    }
    // enter the new state
    case (newState) {
        STATE_WALK:
            walk_enter();
            break;
        STATE_DIALOG:
            dialog_enter();
            break;
        STATE_COMBAT:
            combat_enter();
            break;
    }

    // NOW we can change the state
    currentState = newState;
}

Note that you can also have more than one state-machine in your game. For example, your function combat_logic might in turn be implemented by a state machine itself switching between states like "select unit", "select unit action", "select action target", "execute action", "execute ai" etc. This pattern of state-machines within states of other state-machines is called "Hierarchical State Machines".