tips til generisk statemachine framework.

Der findes mange former for statemaskiner, og man kan lave dem på mange måder.

Man kan lave det som en 2D array af funktions pointere, hvor den ene dimension er state og den anden event. Hvis en event i en state altid giver samme state kan man lade dette fremgå af array'et.

Man kan også lade state være en funktions pointer der bliver kaldt med den næste event, funktionen kan så returnere den næste state/funktion.

Men til små statemaskiner foretrækker jeg at håndkode en switch(state)/switch(event) funktion. Det finder jeg mest overskueligt.

Så for at hjælpe dig videre må vi nok vide lidt mere om hvad dine statmaskiner skal.

de skal bruges til at holde styr på spillogikken i et quest system til et spil

nu ved jeg ikke lige hvor vanvittigt dit quest-system spil er, men til små-tilstandsmaskiner vil jeg nok også gå efter switch/case ala:
#include <conio.h>

enum States
{
    state1,
    state2,
    state3,
    state4,
};

void UpdateState(States &state)
{
    switch(state)
    {
        case state1:
            state = state2;
            break;
        case state2:
            state = state3;
            break;
        case state3:
            state = state4;
            break;
        case state4:
            state = state1;
            break;
        default:
            break;
    }
}

int _tmain(int argc, _TCHAR* argv[])
{
    States s = state1;
    for(int i=0; i<10; i++)
    {
        UpdateState(s);
    }
    printf("state = %d\n", s);
    getch();
    return 0;
}

sovsekoder:
Det skal være en del mere generisk fordi det er mere end blot en sekvens. Det skal osse primært arbejde med strenge fordi det skal kunne implementeres i nogle scripts.

hvad mener du præcis med generisk. Vil du opbygge din statemachine løbende under program-kørsel?

i ovenstående er det meningen at de enkelte states implementeres i case-delen:
case state1:
  if(playerGoesNorth == true)
    state = state 4;
    return;
  else
  {
    if(playerChoosesNewWeapon)
    {
      state = ChooseWeapon();
    }
  }
  state = state2

  break;

...dvs du ved hvordan din statemachine ser ud når du starter dit spil, og implementerer de enkelte states som de nu skal være...

hvis din statemachine skal opbygges i et script af en art kuune man måske lave en statemachine-engine i denne stil:
StateMachine sm;
sm.CreateState("st_start");
sm.CreateState("st_newGame");
sm.CreateState("st_exit");

sm.CreateEvent("ev_start");
sm.CreateEvent("ev_moveNorth");
sm.CreateEvent("ev_moveSouth");
sm.CreateEvent("ev_quitGame");

//
Transition trans;
trans = sm.CreateTransition("st_start", "st_newGame");
trans.AddTriggerEvent("ev_start", true);

trans = sm.CreateTransition("st_newGame", "st_exit");
trans.AddTriggerEvent("ev_moveSouth", true);
trans.AddTriggerEvent("ev_quitGame", true);

...
sm.SetEvent("ev_start", true);
sm.GetState();
sm.DescreteStep();
....

med en StateMachine klasse der indeholder tilstandsmaskinen.
CreateState opretter en tilstand

CreateEvent opretter et event, der senere bruges til at afgøre om man skal gå fra een tilstand til en anden..

CreateTransition opretter en overgange fra een tilstand til en anden.

Transition er en klasse der repræsenterer en overgang.

Transition.AddTriggerEvent tilføjer en betingelse der skal opfyldes for at man går fra een state til en anden.

derudover skal der være noget til at sætte værdierne (true/false) på de forskellige events. (StateMachine.SetEvent / GetState) - og tilsidst noget der får StateMachine til at udføre et deskret skridt, dvs. opdatering af nuværende tilstand

..så i koden i forrige indlæg har jeg prøvet atlave en statemachine der :
går fra state:st_start til state:st_newGame hvis eventen ev_start er sat
går fra st_newGame til st_exit hvis enten ev_moveSouth eller ev_quitGame er sat

det kræver så at man har styr på sine events i det program der bruger frameworket.

er det noget i den stil, du skal bruge?

ja det er noget i den stil...