FSM/vscode/FSM_OOP/baseFSM/FSM.c

/**
 * @file FSM.c
 * @author 天神 (dalaoshi@stu.xjtu.edu.cn)
 * @brief 
 * @version 2.1
 * @date 2024-05-07
 * 
 * @copyright 天神创意无限公司 2024
 * 
 */

#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <string.h>

#include "FSM_private.h"
#include "FSM_protected.h"
#include "FSM_public.h"


/* -------------------------------------------------------------------------- */
/*                                private函数                                 */
/* -------------------------------------------------------------------------- */
/**
 * @brief 设置下一个状态，里面的子状态机暂时没用到
 * 
 * @param pFSM 状态机变量的基类指针
 */
static inline void setNextState(FSM* pFSM){
    int curState = pFSM->privateVars->curState;

    pFSM->signals.lastTriggeredSignal = Idle_Signal;
    pFSM->privateVars->nextState = pFSM->privateVars->fcns.selectNextState[curState](pFSM->data, &pFSM->signals);
    pFSM->privateVars->index = pFSM->privateVars->curState * pFSM->privateVars->numState + pFSM->privateVars->nextState;

}

/**
 * @brief 
 * @deprecated 去掉了所有和预装载器相关的内容
 * @param pFSM 
 */
static inline void preload(FSM* pFSM){
    if(pFSM->privateVars->preloader.isReady){
        memcpy(pFSM->data, pFSM->privateVars->preloader.shadowData, pFSM->privateVars->preloader.size);
        pFSM->privateVars->preloader.isReady = 0;
    }    
}

/* -------------------------------------------------------------------------- */
/*                                  protected                                 */
/* -------------------------------------------------------------------------- */

/**
 * @brief 运行状态机，状态机框架的核心函数
 * @details 共分为三部首先判断是否有状态机切换，
 * @param pFSM 状态机基类指针
 */
void stepBaseFSM(FSM *pFSM)
{
    pFSM->pureVtbl.loadExternalData(pFSM->data);
    // preload(pFSM);
    setNextState(pFSM);
    pFSM->pureVtbl.resetSignals(&pFSM->signals, pFSM->data);
    
    FSMHandler *fcns = &pFSM->privateVars->fcns;
    int curState = pFSM->privateVars->curState;
    void *data = pFSM->data;
    FSM **childFSMTable = pFSM->privateVars->childFSMTable;
    int index = pFSM->privateVars->index;
    int nextState = pFSM->privateVars->nextState;
    
    if(nextState && curState != nextState){  // 状态切换
        // 退子状态机
        if(hasChildFSM(pFSM, curState)){
            FSM *cFSM = getChildFSM(pFSM, curState);
            exitFSM(cFSM);
        }
        // 退状态机
        doExit(pFSM);

        // 转移函数
        doTransition(pFSM, index);       // 有特定的状态转移函数
        doGeneralTransition(pFSM);      // 通用状态转移函数 

        // 进状态机
        doEnter(pFSM, nextState);

        // 进子状态机，必须从默认状态开始
        if(hasChildFSM(pFSM, nextState)){
            FSM *cFSM = getChildFSM(pFSM, nextState);
            Step(cFSM);
        }
        setCurState(pFSM, nextState);
    }
    else    // 状态机没动
    {
        if(!hasChildFSM(pFSM, curState)){
            doDuring(pFSM);
        }
        else{
            FSM *cFSM = getChildFSM(pFSM, curState);
            Step(cFSM);
        }
    }
}




/* -------------------------------------------------------------------------- */
/*                                public 函数                                 */
/* -------------------------------------------------------------------------- */
void _stepFSM(FSM *pFSM){
    pFSM->publicFcns.step(pFSM);
}

int getFSMCurState(FSM *pFSM){
    return pFSM->privateVars->curState;
}
int getFSMNextState(FSM *pFSM){
    return pFSM->privateVars->nextState;
}




void registerChildFSM(FSM *parent, FSM *child, int state){
    parent->privateVars->childFSMTable[state] = child;
}



const void *_getData(FSM* pFSM){
    return (const void *)pFSM->data;
}

void _setSignal(FSM *pFSM, Uint16 signalFlag){
    pFSM->signals.all |= (1 << signalFlag);
}

/**
 * @brief 
 * @deprecated 弃用
 * @param pFSM 
 * @return void* 
 */
void *_preloadIn(FSM *pFSM){
    return pFSM->privateVars->preloader.shadowData;
}

/**
 * @brief 
 * @deprecated 弃用
 * @param pFSM 
 */
void _preloaderGetReady(FSM *pFSM){
    if(pFSM->privateVars->preloader.isReady){
        pFSM->privateVars->preloader.isOverflow = 1;
    }
    pFSM->privateVars->preloader.isReady = 1;
}

/**
 * @brief 
 * @deprecated 弃用
 * @param pFSM 
 * @return int 
 */
int _getPreloaderOverFlag(FSM *pFSM){
    return pFSM->privateVars->preloader.isOverflow;
}

/**
 * @brief 
 * @deprecated 弃用
 * @param pFSM 
 */
void _clearPreloaderOverFlag(FSM *pFSM){
    pFSM->privateVars->preloader.isOverflow = 0;
}




/* -------------------------------------------------------------------------- */
/*                   构造函数，分两段，先新建再赋值                            */
/* -------------------------------------------------------------------------- */
FSM*  newBaseFSM(int numState){
    typedef void (*StateFuncPtr)(void *); 
    typedef void (*ChildFSMStepFuncPtr)(FSM **); 
    typedef int (*TransitionFuncPtr)(void *, int *);
    typedef int (*SelectNextStateFcnPtr)(void *, FSMSignals *);

    FSM *pFSM = calloc(1, sizeof(FSM));
    pFSM->privateVars = newFMSPrivateVars(numState);

    FSMPureVtbl pureVtbl = {
        .setupHandler = NULL,
        .initData = NULL,
        .loadExternalData = NULL,
        .initDataLoader = NULL,
        .initSignals = NULL,
        .resetSignals = NULL,
    };
    pFSM->pureVtbl = pureVtbl;

    pFSM->publicFcns.step = stepBaseFSM;

    return pFSM;
}


void constructFSM(FSM* pFSM){
    assert(pFSM->pureVtbl.setupHandler);
    assert(pFSM->pureVtbl.initData);
    assert(pFSM->pureVtbl.initDataLoader);



    pFSM->pureVtbl.setupHandler(&pFSM->privateVars->fcns);
    pFSM->pureVtbl.initData(pFSM);
    pFSM->pureVtbl.initDataLoader(pFSM);

    /* ---------------------------------- 检查状态表 --------------------------------- */
    for (int i = 1; i < pFSM->privateVars->numState; i++) // 跳过Idle状态，Idle状态只能跳转到默认状态
    {
        if(!pFSM->privateVars->fcns.selectNextState[i]){
            FSM_LOG("每个状态都要有一个状态选择函数!\n");
            assert(0); // 强制退出
        }
    }
}