Pasted

#include "TriggerCore.h"
 
 
 
TriggerCore::TriggerCore(EUDStarcraft* sc, char* data, unsigned int length) {
    this->data = data;
    this->length = length;
    this->sc = sc;
 
    this->sc->PlayersTriggerList[0].first = nullptr;
    this->sc->PlayersTriggerList[1].first = nullptr;
    this->sc->PlayersTriggerList[2].first = nullptr;
    this->sc->PlayersTriggerList[3].first = nullptr;
    this->sc->PlayersTriggerList[4].first = nullptr;
    this->sc->PlayersTriggerList[5].first = nullptr;
    this->sc->PlayersTriggerList[6].first = nullptr;
    this->sc->PlayersTriggerList[7].first = nullptr;
 
}
 
#define NODE_NEEDED EnabledFor(t, player) || EnabledFor(t, Players::AllPlayers) || EnabledFor(t, Players::Force1 + playerForces[player])
 
void createNodeIfNeeded(TriggerNode* nodes, unsigned int* freeNodeIndex, Trigger* t, unsigned int player, unsigned char* playerForces, TriggerList* PlayersTriggerList) {
    if (NODE_NEEDED) {
        TriggerList* lst = &(PlayersTriggerList[player]);
        TriggerNode* node = &(nodes[*freeNodeIndex]);
        *freeNodeIndex = (*freeNodeIndex) + 1;
        node->prev = nullptr;
        node->next = nullptr;
        memcpy(&(node->data), t->data, sizeof(TriggerData));
        if (lst->first == nullptr) { // First
            lst->first = node;
        } else { // Has prev
            node->prev = lst->last;
            node->prev->next = node;
        }
        lst->last = node;
    }
}
 
bool TriggerCore::construct() {
    char* localData = this->data;
 
    // Construct trigger array
    for (unsigned int i = 0; i < length / sizeof(TriggerData); i++) {
        Trigger* t = new Trigger(localData, i);
        localData += sizeof(TriggerData);
        if (!triggers.append(t)) {
            delete t;
            return false;
        }
    }
 
    // Calculate how many nodes it takes
    totalNodes = 0;
    unsigned char* playerForces = sc->playerForces;
    for (unsigned int i = 0; i < triggers.getSize(); i++) {
        Trigger* t = triggers.get(i);
        for (unsigned int player = 0; player < 8; player++) {
            if (NODE_NEEDED) {
                totalNodes++;
            }
        }
    }
 
    sc->firstNode = nullptr;
    sc->lastNode = nullptr;
 
    if (totalNodes > 0) { // Create nodes
 
        memset(sc->PlayersTriggerList, 0, sizeof(TriggerList) * 8);
        MALLOC_N(newNodes, TriggerNode, totalNodes, { return false; });
        nodes = newNodes;
 
        sc->firstNode = nodes;
        sc->lastNode = nodes + (sizeof(TriggerNode)*totalNodes);
 
        // Create trigger lists
        unsigned int currentNodeIndex = 0;
        for (unsigned int i = 0; i < triggers.getSize(); i++) {
            Trigger* t = triggers.get(i);
            createNodeIfNeeded(nodes, &currentNodeIndex, t, Players::Player1, sc->playerForces, sc->PlayersTriggerList);
            createNodeIfNeeded(nodes, &currentNodeIndex, t, Players::Player2, sc->playerForces, sc->PlayersTriggerList);
            createNodeIfNeeded(nodes, &currentNodeIndex, t, Players::Player3, sc->playerForces, sc->PlayersTriggerList);
            createNodeIfNeeded(nodes, &currentNodeIndex, t, Players::Player4, sc->playerForces, sc->PlayersTriggerList);
            createNodeIfNeeded(nodes, &currentNodeIndex, t, Players::Player5, sc->playerForces, sc->PlayersTriggerList);
            createNodeIfNeeded(nodes, &currentNodeIndex, t, Players::Player6, sc->playerForces, sc->PlayersTriggerList);
            createNodeIfNeeded(nodes, &currentNodeIndex, t, Players::Player7, sc->playerForces, sc->PlayersTriggerList);
            createNodeIfNeeded(nodes, &currentNodeIndex, t, Players::Player8, sc->playerForces, sc->PlayersTriggerList);
        }
    }
    return true;
}
 
inline bool TriggerCore::isNativeTrigger(TriggerNode* node) {
    return node >= nodes && node < nodes + ((sizeof(TriggerNode)*totalNodes));
}
 
TriggerCore::~TriggerCore() {
    for (unsigned int i = 0; i < triggers.getSize(); i++) {
        Trigger* trig = triggers.get(i);
        delete trig;
    }
    FREE_NOT_NULL(nodes);
    FREE_NOT_NULL(data);
}
 
TriggerCore * TriggerCore::get(char * file, EUDStarcraft* sc) {
    bool error = false;
    FILE* f;
    if (!fopen_s(&f, file, "rb")) {
        ReadBuffer rb(f, &error);
        fclose(f);
        if (error) {
            return nullptr;
        }
        unsigned int length = rb.getDataSize();
        char* data = (char*) rb.readArray(length, &error);
        if (error) {
            return nullptr;
        }
        TriggerCore* tc = new TriggerCore(sc, data, length);
        if (!tc->construct()) {
            delete tc;
            return nullptr;
        }
        return tc;
    }
    return nullptr;
}
 
void TriggerCore::run() {
 
    sc->load();
 
    bool _segFault = false;
    bool* segFault = &_segFault;
 
    FILE* f;
    if (fopen_s(&f, "..\\EUDEmulator\\exec.txt", "wb")) {
        return;
    }
 
    // Execute triggers in loops
    while(true) {
 
        TriggerNode* prev = nullptr;
 
        for (unsigned int playerTriggerIndex = 0; playerTriggerIndex < 8; playerTriggerIndex++) {
            sc->currentPlayerIndexForTriggers = playerTriggerIndex;
            if (sc->executePlayerLoop[playerTriggerIndex]) {
                TriggerList* triggers = &(sc->PlayersTriggerList[playerTriggerIndex]);
                TriggerNode* node = triggers->first;
 
                unsigned int triggersExecutedCounter = 0;
 
                while (node != nullptr) {
 
                    bool outputCurrentTrigger = false;
                    int triggerIndex = -1;
                    int triggerFlags = -1;
                    WriteBuffer conditionBuffer;
                    WriteBuffer actionBuffer;
 
                    if (!sc->isAllocated((unsigned int) node, sizeof(TriggerNode))) {
                        *segFault = true;
#ifdef TRIG_PRINT
                        OutputDebugStringA("\r\n\r\n =================== End of execution because of segfault of node =================== \r\n\r\n");
#endif
                    }
 
                    if (!(*segFault)) { // Node is valid
                        // Update current trigger
                        sc->currentTriggerNode = node;
                        triggersExecutedCounter++;
 
                        TriggerData* trigger = (TriggerData*)(&node->data);
                        triggerIndex = trigger->flags >> 16;
                        triggerFlags = trigger->flags & 0xffff;
 
                        if (Trigger::canBeExecutedNow(sc, trigger, &conditionBuffer, segFault)) { // Can be executed
                            SET_EXECUTE(trigger);
                        }
 
 
                        if (!(*segFault)) { // Conditions didn't cause segfault
                            if (HAS_EXECUTE(trigger)) { // Can be executed
                                outputCurrentTrigger = true;
                                CLEAR_EXECUTE(trigger); // Clear execution flag
                                bool stopTriggersForCurrentPlayer = false;
                                bool stopTriggersForAllPlayers = false;
                                Trigger::executeNow(sc, trigger, &actionBuffer, &stopTriggersForCurrentPlayer, &stopTriggersForAllPlayers, segFault);
 
                                if (!HAS_PRESERVE(trigger)) {
                                    SET_IGNORE_EXECUTION(trigger);
                                }
 
                                if (stopTriggersForCurrentPlayer) {
                                    sc->executePlayerLoop[playerTriggerIndex] = false;
                                }
                                if (stopTriggersForAllPlayers) {
                                    for (unsigned int playerIndex = 0; playerIndex < 8; playerIndex++) {
                                        sc->executePlayerLoop[playerIndex] = false;
                                    }
                                    break;
                                }
                            }
                        }
                    }
                        
#ifdef TRIG_PRINT
                    if (outputCurrentTrigger || (*segFault)) { // Output incomplete trigger causing segfault or any executed trigged
                        bool error = false;
                        conditionBuffer.writeByte(0, &error);
                        actionBuffer.writeByte(0, &error);
                        unsigned char* actData;
                        unsigned char* condData;
                        unsigned int actDataLen;
                        unsigned int condDataLen;
                        conditionBuffer.getWrittenData(&condData, &condDataLen);
                        actionBuffer.getWrittenData(&actData, &actDataLen);
                        char trigID[128];
                        if (isNativeTrigger(node)) {
                            sprintf_s(trigID, "%d (flags: %d), for player %d", triggerIndex, triggerFlags, playerTriggerIndex + 1);
                        } else { // Trigger outside of TRIG section
                            unsigned int offPtr = 0;
                            char* fmt = sc->getTriggerOrigin(node, &offPtr, segFault);
                            sprintf_s(trigID, "%s[%d] 0x%X (flags: %d), for player %d", fmt, offPtr, (unsigned int)node, triggerFlags, playerTriggerIndex + 1);
                        }
 
                        if (!outputCurrentTrigger) {
                            OutputDebugStringA("Following trigger was NOT executed\r\n");
                        }
                        if (*segFault) {
                            OutputDebugStringA("Following trigger caused segfault\r\n");
                        }
                        OutputDebugStringA("///////////////////// Conditions[");
                        OutputDebugStringA(trigID);
                        OutputDebugStringA("] ////////////////////\r\n");
                        OutputDebugStringA((char*)condData);
                        OutputDebugStringA("////////////////////// Actions[");
                        OutputDebugStringA(trigID);
                        OutputDebugStringA("] //////////////////////\r\n");
                        OutputDebugStringA((char*)actData);
                        OutputDebugStringA("///////////////////////////////////////////////////////////////////////////////////\r\n\r\n");
                    }
#endif
                        
                    if (*segFault) { // Break trigger loop for current player
                        break;
                    }
                    prev = node;
                    node = node->next;
                }
            }
            if (*segFault) { // Break trigger loop for all players
                break;
            }
        }
        if (*segFault) { // Stop triggers
            break;
        }
        OutputDebugStringA("\r\n\r\n ================== End of trigger loop =================\r\n\r\n");
        Sleep(500);
    }
 
    if (*segFault) {
        OutputDebugStringA("\r\n\r\n =================== End of execution because of segfault =================== \r\n\r\n");
    }
 
    fclose(f);
}