GTA LCS Function Commands Implementation

enum eScriptCommand
{
    COMMAND_RETURN                  = 81,
    COMMAND_RETURN_TRUE             = 197,
    COMMAND_RETURN_FALSE,
    COMMAND_CALL                    = 1454,
    COMMAND_CALLNOT,
    COMMAND_RETURN_IF_TRUE          = 1477, // never used
    COMMAND_RETURN_FALSE_IF_TRUE            // never used
};

class CTheScripts
{
public:
    static unsigned char* ScriptSpace;
};

extern int ScriptParams[32];

class CRunningScript
{
public:
    union ReturnPC
    {
        struct {
            unsigned int m_countersPC : 22;
            unsigned int m_bNotFlag : 1;
            unsigned int m_bIsFunction : 1;
            unsigned int m_outParamsOffset : 8;
        };
        unsigned int m_PC;
    };

    CRunningScript* m_next;
    CRunningScript* m_prev;
    int m_processId;
    char __pad_C[4];
    char m_name[8];                 // On CRunningScript::Init, sprintf(m_name, "id%02i", m_processId)
    unsigned int m_PC;
    ReturnPC m_returnStack[16];
    short m_returnStackPosition;
    char __align_5E[2];
    int m_aLocalVariables[106];
    int m_baseLocalVariableIndex;
    bool m_bIsActiveScript;
    bool m_bCompareFlag;
    bool m_bUseMissionCleanUp;
    bool m_bClearMessagesOnWait;
    unsigned int m_wakeTime;
    unsigned short m_andOr;
    bool m_bNotFlag;
    bool m_bDeatharrestState;
    bool m_bHasDeatharrestExecuted;
    bool m_bIsMissionScript;
    char __align_21A[2];

    void UpdatePC(int address);
    void UpdateCompareFlag(bool state);

    int CollectParameters(unsigned int* pPC, int count, int* list);
    void StoreParameters(unsigned int* pPC, short count);
    void ReturnFromGosubOrFunction();

    int ProcessCommands0To99(int index);
    int ProcessCommands100To199(int index);
    int ProcessCommands1400To1499(int index);
};

int CRunningScript::ProcessCommands0To99(int index)
{
    switch(index)
    {
    case COMMAND_RETURN:
        ReturnFromGosubOrFunction();
    }

    return 0;
}

int CRunningScript::ProcessCommands100To199(int index)
{
    switch(index)
    {
    case COMMAND_RETURN_TRUE:
        UpdateCompareFlag(true);
        ReturnFromGosubOrFunction();

        break;
    case COMMAND_RETURN_FALSE:
        UpdateCompareFlag(false);
        ReturnFromGosubOrFunction();
    }

    return 0;
}

int CRunningScript::ProcessCommands1400To1499(int index)
{
    switch(index)
    {
    case COMMAND_CALL:
    case COMMAND_CALLNOT:
        {
            m_returnStack[m_returnStackPosition].m_PC = m_PC;
            m_returnStack[m_returnStackPosition].m_bNotFlag = index == COMMAND_CALLNOT;
            m_returnStack[m_returnStackPosition].m_bIsFunction = true;
            m_returnStackPosition++;

            int numInputParams = (char)CTheScripts::ScriptSpace[m_PC];
            int baseLocalVariableIndex = m_baseLocalVariableIndex + (char)CTheScripts::ScriptSpace[m_PC + 2];

            unsigned int paramsPC = m_PC + 3;
            m_PC = paramsPC;

            CollectParameters(&m_PC, 1, ScriptParams);

            if(numInputParams > 0)
            {
                CollectParameters(&m_PC, numInputParams, &m_aLocalVariables[baseLocalVariableIndex]);
            }

            m_baseLocalVariableIndex = baseLocalVariableIndex;
            m_returnStack[m_returnStackPosition - 1].m_outParamsOffset = m_PC - paramsPC;

            UpdatePC(ScriptParams[0]);
        }

        break;
    case COMMAND_RETURN_IF_TRUE:
        if(m_bCompareFlag)
        {
            ReturnFromGosubOrFunction();
        }

        break;
    case COMMAND_RETURN_FALSE_IF_TRUE:
        if(m_bCompareFlag)
        {
            UpdateCompareFlag(false);
            ReturnFromGosubOrFunction();
        }
    }

    return 0;
}

void CRunningScript::ReturnFromGosubOrFunction()
{
    m_returnStackPosition--;

    if(!m_returnStack[m_returnStackPosition].m_bIsFunction)
    {
        m_PC = m_returnStack[m_returnStackPosition].m_PC;

        return;
    }

    if(m_returnStack[m_returnStackPosition].m_bNotFlag)
    {
        m_bNotFlag = !m_bNotFlag;
    }

    unsigned int PC = m_returnStack[m_returnStackPosition].m_countersPC;

    int* storedLocalVariables = &m_aLocalVariables[m_baseLocalVariableIndex + (char)CTheScripts::ScriptSpace[PC]];
    short numOutputParams = (char)CTheScripts::ScriptSpace[PC + 1];

    for(int i = 0; i < numOutputParams; i++)
    {
        ScriptParams[i] = storedLocalVariables[i];
    }

    m_PC = PC + 3 + m_returnStack[m_returnStackPosition].m_outParamsOffset;
    m_baseLocalVariableIndex -= (char)CTheScripts::ScriptSpace[PC + 2];

    StoreParameters(&m_PC, numOutputParams);
}