forge/arma/server/addons/task/functions/objects/fnc_DestroyTaskBaseClass.sqf

#include "..\script_component.hpp"

/*
 * Object-style destroy task class.
 */

#pragma hemtt ignore_variables ["_self"]
GVAR(DestroyTaskBaseClass) = +GVAR(TaskInstanceBaseClass);
GVAR(DestroyTaskBaseClass) merge [createHashMapFromArray [
    ["#type", "DestroyTaskBaseClass"],
    ["#create", compileFinal {
        params [
            ["_taskID", "", [""]],
            ["_entities", createHashMap, [createHashMap]],
            ["_taskParams", createHashMap, [createHashMap]]
        ];

        _self call ["initializeBaseState", [_taskID, "destroy", _entities, _taskParams]];

        private _targets = +(_entities getOrDefault ["targets", []]);
        private _requiredDestroyed = _taskParams getOrDefault ["limitSuccess", -1];
        if (_requiredDestroyed < 0) then { _requiredDestroyed = count _targets; };

        _self set ["targets", _targets];
        _self set ["requiredDestroyed", _requiredDestroyed];
        _self set ["timeLimit", _taskParams getOrDefault ["timeLimit", 0]];
        _self set ["useTaskStore", _taskParams getOrDefault ["useTaskStore", false]];

        _self call ["registerInstance", []];
    }],
    ["#delete", compileFinal {
        _self call ["unregisterInstance", []];
    }],
    ["refreshEntitiesFromStore", compileFinal {
        private _taskID = _self getOrDefault ["taskID", ""];
        if (_taskID isEqualTo "" || { !(_self getOrDefault ["useTaskStore", false]) }) exitWith { false };

        private _targets = GVAR(TaskStore) call ["getTaskEntities", ["targets", _taskID]];
        _self set ["targets", _targets];
        true
    }],
    ["trackParticipants", compileFinal {
        private _taskID = _self getOrDefault ["taskID", ""];
        if (_taskID isEqualTo "" || { !(_self getOrDefault ["useTaskStore", false]) }) exitWith { false };

        GVAR(TaskStore) call ["trackParticipants", [_taskID, _self getOrDefault ["targets", []], "", 300]];
        true
    }],
    ["waitForRequiredEntities", compileFinal {
        if (_self getOrDefault ["useTaskStore", false]) then {
            waitUntil {
                sleep 1;
                _self call ["refreshEntitiesFromStore", []];
                _self call ["trackParticipants", []];
                !(_self call ["isTaskStoreOpen", []]) || { count (_self getOrDefault ["targets", []]) > 0 }
            };
        } else {
            waitUntil {
                sleep 1;
                count (_self getOrDefault ["targets", []]) > 0
            };
        };

        if !(_self call ["isTaskStoreOpen", []]) exitWith { false };

        private _targets = _self getOrDefault ["targets", []];
        private _taskParams = _self getOrDefault ["taskParams", createHashMap];
        private _requiredDestroyed = _taskParams getOrDefault ["limitSuccess", -1];
        if (_requiredDestroyed < 0) then { _requiredDestroyed = count _targets; };

        _self set ["requiredDestroyed", _requiredDestroyed];
        true
    }],
    ["waitForAssignment", compileFinal {
        private _taskID = _self getOrDefault ["taskID", ""];

        if (_taskID isEqualTo "" || { !(_self getOrDefault ["useTaskStore", false]) }) exitWith { true };

        waitUntil {
            sleep 1;
            !(_self call ["isTaskStoreOpen", []]) || { GVAR(TaskStore) call ["isTaskAccepted", [_taskID]] }
        };

        _self call ["isTaskStoreOpen", []]
    }],
    ["countDestroyedTargets", compileFinal {
        private _targets = _self getOrDefault ["targets", []];
        { !alive _x } count _targets
    }],
    ["tick", compileFinal {
        private _startedAt = _self getOrDefault ["startedAt", -1];
        private _timeLimit = _self getOrDefault ["timeLimit", 0];
        private _destroyed = _self call ["countDestroyedTargets", []];
        private _requiredDestroyed = _self getOrDefault ["requiredDestroyed", 0];
        private _timeExpired = false;

        if (_timeLimit > 0 && { _startedAt >= 0 }) then {
            _timeExpired = (serverTime - _startedAt) >= _timeLimit;
        };

        createHashMapFromArray [
            ["destroyed", _destroyed],
            ["requiredDestroyed", _requiredDestroyed],
            ["timeExpired", _timeExpired],
            ["shouldFail", _timeExpired && { _destroyed < _requiredDestroyed }],
            ["shouldSucceed", _destroyed >= _requiredDestroyed]
        ]
    }],
    ["handleFailureOutcome", compileFinal {
        private _taskID = _self getOrDefault ["taskID", ""];
        private _rewardData = _self getOrDefault ["rewardData", createHashMap];
        private _ratingFail = _rewardData getOrDefault ["ratingFail", 0];
        private _endFail = (_self getOrDefault ["taskParams", createHashMap]) getOrDefault ["endFail", false];

        if (_self getOrDefault ["useTaskStore", false]) then {
            [_taskID, "FAILED"] call BFUNC(taskSetState);
            GVAR(TaskStore) call ["setTaskStatus", [_taskID, "failed"]];

            sleep 1;

            GVAR(TaskStore) call ["applyRatingOutcome", [_taskID, _ratingFail]];
            GVAR(TaskStore) call ["notifyParticipants", [_taskID, "warning", "Tasks", format ["Task failed: %1 reputation", _ratingFail]]];
            GVAR(TaskStore) call ["clearTask", [_taskID]];
        };

        if (_endFail) then { "EveryoneLost" call BFUNC(endMissionServer); };
        true
    }],
    ["handleSuccessOutcome", compileFinal {
        private _taskID = _self getOrDefault ["taskID", ""];
        private _rewardData = _self getOrDefault ["rewardData", createHashMap];
        private _ratingSuccess = _rewardData getOrDefault ["ratingSuccess", 0];
        private _funds = _rewardData getOrDefault ["funds", 0];
        private _endSuccess = (_self getOrDefault ["taskParams", createHashMap]) getOrDefault ["endSuccess", false];

        if (_self getOrDefault ["useTaskStore", false]) then {
            [_taskID, "SUCCEEDED"] call BFUNC(taskSetState);
            GVAR(TaskStore) call ["setTaskStatus", [_taskID, "succeeded"]];
            [_taskID, _rewardData] call FUNC(handleTaskRewards);

            sleep 1;

            GVAR(TaskStore) call ["applyRatingOutcome", [_taskID, _ratingSuccess]];
            GVAR(TaskStore) call ["notifyParticipants", [_taskID, "success", "Tasks", format ["Task completed: %1 reputation, $%2 funds", _ratingSuccess, [_funds] call EFUNC(common,formatNumber)]]];
            GVAR(TaskStore) call ["clearTask", [_taskID]];
        };

        if (_endSuccess) then { "EveryoneWon" call BFUNC(endMissionServer); };
        true
    }],
    ["runLoop", compileFinal {
        if !(_self call ["waitForRequiredEntities", []]) exitWith {
            _self call ["markAborted", ["Task reached terminal status before required entities registered."]];
            _self call ["cleanup", []];
            false
        };
        if !(_self call ["waitForAssignment", []]) exitWith {
            _self call ["markAborted", ["Task reached terminal status before assignment."]];
            _self call ["cleanup", []];
            false
        };
        _self call ["markActive", []];

        while { _self call ["isTaskLoopActive", []] } do {
            _self call ["trackParticipants", []];
            private _snapshot = _self call ["tick", []];

            if (_snapshot getOrDefault ["shouldFail", false]) exitWith {
                _self call ["markFailed", ["Destroy fail conditions met.", _snapshot]];
            };

            if (_snapshot getOrDefault ["shouldSucceed", false]) exitWith {
                _self call ["markSucceeded", [_snapshot]];
            };

            sleep 1;
        };

        private _finalStatus = _self call ["getStatus", []];
        if (_finalStatus isEqualTo "failed") then {
            _self call ["handleFailureOutcome", []];
        };

        if (_finalStatus isEqualTo "succeeded") then {
            _self call ["handleSuccessOutcome", []];
        };

        _self call ["cleanup", []];
        true
    }]
], true];