07d5422091
- Updated fnc_extCall.sqf to suppress logging for specific functions. - Added object model prototypes for task instances in prototypes/taskObjectPrototypes.sqf. - Enhanced README.md to document the new object model and its purpose. - Modified XEH_postInit.sqf to improve event handling for defuse tasks. - Updated various task functions (fnc_attack, fnc_defend, fnc_defuse, fnc_delivery, fnc_destroy, fnc_heartBeat, fnc_hostage, fnc_hvt) to include task acceptance checks. - Improved fnc_makeHostage and fnc_makeIED to ensure proper task registration and state management. - Introduced new methods in task object prototypes for better state management and task flow control.
657 lines
26 KiB
Plaintext
657 lines
26 KiB
Plaintext
#include "..\script_component.hpp"
|
|
|
|
/*
|
|
* Author: IDSolutions
|
|
* Initializes the task store for task entity tracking, participant
|
|
* contribution tracking, and task outcome application.
|
|
*
|
|
* Task metadata is extension-backed but intentionally transient. The
|
|
* task backend is reset when this store is created so task/catalog/status
|
|
* state starts clean for each server or mission lifecycle.
|
|
*
|
|
* Arguments:
|
|
* None
|
|
*
|
|
* Return Value:
|
|
* Task store object [HASHMAP OBJECT]
|
|
*
|
|
* Example:
|
|
* call forge_server_task_fnc_initTaskStore
|
|
*
|
|
* Public: No
|
|
*/
|
|
|
|
#pragma hemtt ignore_variables ["_self"]
|
|
GVAR(TaskStore) = createHashMapObject [[
|
|
["#type", "TaskStore"],
|
|
["#create", compileFinal {
|
|
_self set ["participantRegistry", createHashMap];
|
|
_self set ["taskEntityRegistries", createHashMapFromArray [
|
|
["cargo", createHashMap],
|
|
["hostages", createHashMap],
|
|
["hvts", createHashMap],
|
|
["ieds", createHashMap],
|
|
["entities", createHashMap],
|
|
["shooters", createHashMap],
|
|
["targets", createHashMap]
|
|
]];
|
|
|
|
// Task extension state is mission-scoped and intentionally reset on
|
|
// startup rather than being treated as durable account data.
|
|
["task:reset", []] call EFUNC(extension,extCall) params ["_result", "_isSuccess"];
|
|
if (
|
|
!_isSuccess
|
|
|| { !(_result isEqualType "") }
|
|
|| { (_result find "Error:") == 0 }
|
|
) then {
|
|
["WARNING", "Failed to reset task backend state during task store initialization."] call EFUNC(common,log);
|
|
};
|
|
}],
|
|
["callTaskStateEnvelope", compileFinal {
|
|
params [["_function", "", [""]], ["_arguments", [], [[]]]];
|
|
|
|
private _envelope = createHashMapFromArray [
|
|
["success", false],
|
|
["error", ""]
|
|
];
|
|
|
|
if (_function isEqualTo "") exitWith { _envelope };
|
|
|
|
[_function, _arguments] call EFUNC(extension,extCall) params ["_result", "_isSuccess"];
|
|
if !_isSuccess exitWith {
|
|
_envelope set ["error", format ["Task backend call '%1' failed.", _function]];
|
|
_envelope
|
|
};
|
|
if !(_result isEqualType "") exitWith {
|
|
_envelope set ["error", format ["Task backend call '%1' returned an invalid response.", _function]];
|
|
_envelope
|
|
};
|
|
if ((_result find "Error:") == 0) exitWith {
|
|
["ERROR", format ["Task extension call '%1' failed: %2", _function, _result]] call EFUNC(common,log);
|
|
_envelope set ["error", _result select [7]];
|
|
_envelope
|
|
};
|
|
|
|
_envelope set ["success", true];
|
|
if (_result isNotEqualTo "") then {
|
|
_envelope set ["data", fromJSON _result];
|
|
};
|
|
|
|
_envelope
|
|
}],
|
|
["callTaskState", compileFinal {
|
|
params [["_function", "", [""]], ["_arguments", [], [[]]], ["_fallback", nil]];
|
|
|
|
private _envelope = _self call ["callTaskStateEnvelope", [_function, _arguments]];
|
|
if !(_envelope getOrDefault ["success", false]) exitWith { _fallback };
|
|
|
|
_envelope getOrDefault ["data", _fallback]
|
|
}],
|
|
["bindTaskOwnership", compileFinal {
|
|
params [["_taskID", "", [""]], ["_requesterUid", "", [""]]];
|
|
|
|
private _result = createHashMapFromArray [
|
|
["success", false],
|
|
["requesterUid", _requesterUid],
|
|
["orgID", "default"],
|
|
["message", ""]
|
|
];
|
|
|
|
if (_taskID isEqualTo "") exitWith {
|
|
_result set ["message", "Missing task ID."];
|
|
_result
|
|
};
|
|
|
|
private _orgID = "default";
|
|
|
|
if (_requesterUid isNotEqualTo "") then {
|
|
private _actor = EGVAR(actor,ActorStore) call ["load", [_requesterUid]];
|
|
|
|
if (_actor isEqualTo createHashMap) exitWith {
|
|
_result set ["message", format ["Failed to load actor for %1.", _requesterUid]];
|
|
_result
|
|
};
|
|
|
|
_orgID = EGVAR(actor,ActorStore) call ["getOrganization", [_requesterUid]];
|
|
};
|
|
|
|
private _context = createHashMapFromArray [
|
|
["requesterUid", _requesterUid],
|
|
["orgId", _orgID]
|
|
];
|
|
private _envelope = _self call [
|
|
"callTaskStateEnvelope",
|
|
[
|
|
"task:ownership:bind",
|
|
[_taskID, toJSON _context]
|
|
]
|
|
];
|
|
if !(_envelope getOrDefault ["success", false]) exitWith {
|
|
_result set ["message", _envelope getOrDefault ["error", "Failed to bind task ownership."]];
|
|
_result
|
|
};
|
|
|
|
private _bindResult = _envelope getOrDefault ["data", createHashMap];
|
|
_result set ["success", true];
|
|
_result set ["message", _bindResult getOrDefault [
|
|
"message",
|
|
["No requester UID provided. Bound task to default organization.", "Task ownership updated."] select (_requesterUid isNotEqualTo "")
|
|
]];
|
|
_result set ["orgID", _bindResult getOrDefault ["orgId", _orgID]];
|
|
_result
|
|
}],
|
|
["releaseTaskOwnership", compileFinal {
|
|
params [["_taskID", "", [""]]];
|
|
|
|
if (_taskID isEqualTo "") exitWith { false };
|
|
|
|
private _envelope = _self call ["callTaskStateEnvelope", ["task:ownership:release", [_taskID]]];
|
|
_envelope getOrDefault ["success", false]
|
|
}],
|
|
["registerTaskCatalogEntry", compileFinal {
|
|
params [["_taskID", "", [""]], ["_entry", createHashMap, [createHashMap]]];
|
|
|
|
if (_taskID isEqualTo "" || { _entry isEqualTo createHashMap }) exitWith { false };
|
|
|
|
private _envelope = _self call [
|
|
"callTaskStateEnvelope",
|
|
[
|
|
"task:catalog:upsert",
|
|
[_taskID, toJSON _entry]
|
|
]
|
|
];
|
|
_envelope getOrDefault ["success", false]
|
|
}],
|
|
["getActiveTaskCatalog", compileFinal {
|
|
private _entries = _self call ["callTaskState", ["task:catalog:active", [], []]];
|
|
if !(_entries isEqualType []) exitWith { [] };
|
|
|
|
_entries
|
|
}],
|
|
["hasTaskCatalogEntry", compileFinal {
|
|
params [["_taskID", "", [""]]];
|
|
|
|
if (_taskID isEqualTo "") exitWith { false };
|
|
|
|
private _entry = _self call ["callTaskState", ["task:catalog:get", [_taskID], objNull]];
|
|
_entry isEqualType createHashMap
|
|
}],
|
|
["getTaskCatalogEntry", compileFinal {
|
|
params [["_taskID", "", [""]]];
|
|
|
|
if (_taskID isEqualTo "") exitWith { createHashMap };
|
|
|
|
private _entry = _self call ["callTaskState", ["task:catalog:get", [_taskID], createHashMap]];
|
|
if !(_entry isEqualType createHashMap) exitWith { createHashMap };
|
|
|
|
_entry
|
|
}],
|
|
["isTaskAccepted", compileFinal {
|
|
params [["_taskID", "", [""]]];
|
|
|
|
if (_taskID isEqualTo "") exitWith { false };
|
|
|
|
private _entry = _self call ["getTaskCatalogEntry", [_taskID]];
|
|
if (_entry isEqualTo createHashMap) exitWith { false };
|
|
|
|
(_entry getOrDefault ["accepted", false]) || { (_entry getOrDefault ["requesterUid", ""]) isNotEqualTo "" }
|
|
}],
|
|
["acceptTask", compileFinal {
|
|
params [["_taskID", "", [""]], ["_requesterUid", "", [""]]];
|
|
|
|
private _result = createHashMapFromArray [
|
|
["success", false],
|
|
["message", "Unable to accept task."],
|
|
["entry", createHashMap]
|
|
];
|
|
|
|
if (_taskID isEqualTo "" || { _requesterUid isEqualTo "" }) exitWith {
|
|
_result set ["message", "Missing task ID or requester UID."];
|
|
_result
|
|
};
|
|
|
|
private _actor = EGVAR(actor,ActorStore) call ["load", [_requesterUid]];
|
|
if (_actor isEqualTo createHashMap) exitWith {
|
|
_result set ["message", format ["Failed to load actor for %1.", _requesterUid]];
|
|
_result
|
|
};
|
|
|
|
private _orgID = EGVAR(actor,ActorStore) call ["getOrganization", [_requesterUid]];
|
|
|
|
private _context = createHashMapFromArray [
|
|
["requesterUid", _requesterUid],
|
|
["orgId", _orgID]
|
|
];
|
|
private _envelope = _self call [
|
|
"callTaskStateEnvelope",
|
|
[
|
|
"task:ownership:accept",
|
|
[_taskID, toJSON _context]
|
|
]
|
|
];
|
|
if !(_envelope getOrDefault ["success", false]) exitWith {
|
|
_result set ["message", _envelope getOrDefault ["error", "Unable to accept task."]];
|
|
_result
|
|
};
|
|
|
|
private _acceptResult = _envelope getOrDefault ["data", createHashMap];
|
|
private _entry = _acceptResult getOrDefault ["entry", createHashMap];
|
|
if !(_entry isEqualType createHashMap) then {
|
|
_entry = createHashMap;
|
|
};
|
|
|
|
_result set ["success", true];
|
|
_result set ["message", _acceptResult getOrDefault ["message", "Task accepted."]];
|
|
_result set ["entry", _entry];
|
|
_result
|
|
}],
|
|
["setTaskStatus", compileFinal {
|
|
params [["_taskID", "", [""]], ["_status", "", [""]]];
|
|
|
|
if (_taskID isEqualTo "" || { _status isEqualTo "" }) exitWith { false };
|
|
|
|
[(_self call ["callTaskState", ["task:status:set", [_taskID, _status], false]])] params [["_statusResult", false, [false]]];
|
|
|
|
_statusResult
|
|
}],
|
|
["getTaskStatus", compileFinal {
|
|
params [["_taskID", "", [""]]];
|
|
|
|
if (_taskID isEqualTo "") exitWith { "" };
|
|
|
|
private _status = _self call ["callTaskState", ["task:status:get", [_taskID], ""]];
|
|
if !(_status isEqualType "") exitWith { "" };
|
|
|
|
_status
|
|
}],
|
|
["clearTaskStatus", compileFinal {
|
|
params [["_taskID", "", [""]]];
|
|
|
|
if (_taskID isEqualTo "") exitWith { false };
|
|
|
|
[(_self call ["callTaskState", ["task:status:clear", [_taskID], false]])] params [["_statusResult", false, [false]]];
|
|
|
|
_statusResult
|
|
}],
|
|
["registerTaskEntity", compileFinal {
|
|
params [["_registryKey", "", [""]], ["_taskID", "", [""]], ["_entity", objNull, [objNull]]];
|
|
|
|
if (_registryKey isEqualTo "" || { _taskID isEqualTo "" } || { isNull _entity }) exitWith { false };
|
|
|
|
private _taskEntityRegistries = _self getOrDefault ["taskEntityRegistries", createHashMap];
|
|
private _registry = +(_taskEntityRegistries getOrDefault [_registryKey, createHashMap]);
|
|
private _entities = +(_registry getOrDefault [_taskID, []]);
|
|
_entities pushBackUnique _entity;
|
|
_registry set [_taskID, _entities];
|
|
_taskEntityRegistries set [_registryKey, _registry];
|
|
_self set ["taskEntityRegistries", _taskEntityRegistries];
|
|
|
|
true
|
|
}],
|
|
["getTaskEntities", compileFinal {
|
|
params [["_registryKey", "", [""]], ["_taskID", "", [""]]];
|
|
|
|
if (_registryKey isEqualTo "" || { _taskID isEqualTo "" }) exitWith { [] };
|
|
|
|
private _taskEntityRegistries = _self getOrDefault ["taskEntityRegistries", createHashMap];
|
|
private _registry = _taskEntityRegistries getOrDefault [_registryKey, createHashMap];
|
|
|
|
+(_registry getOrDefault [_taskID, []])
|
|
}],
|
|
["findTaskEntityOwner", compileFinal {
|
|
params [["_registryKey", "", [""]], ["_entity", objNull, [objNull]]];
|
|
|
|
if (_registryKey isEqualTo "" || { isNull _entity }) exitWith { "" };
|
|
|
|
private _taskEntityRegistries = _self getOrDefault ["taskEntityRegistries", createHashMap];
|
|
private _registry = _taskEntityRegistries getOrDefault [_registryKey, createHashMap];
|
|
private _resolvedTaskID = "";
|
|
|
|
{
|
|
private _taskID = _x;
|
|
private _entities = _y;
|
|
|
|
if (_entity in _entities) exitWith {
|
|
_resolvedTaskID = _taskID;
|
|
};
|
|
|
|
private _matchingEntity = _entities select {
|
|
!isNull _x
|
|
&& { (typeOf _x) isEqualTo (typeOf _entity) }
|
|
&& { _x distance _entity < 1 }
|
|
};
|
|
if (_matchingEntity isNotEqualTo []) exitWith {
|
|
_resolvedTaskID = _taskID;
|
|
};
|
|
} forEach _registry;
|
|
|
|
_resolvedTaskID
|
|
}],
|
|
["clearTaskEntities", compileFinal {
|
|
params [["_taskID", "", [""]]];
|
|
|
|
if (_taskID isEqualTo "") exitWith { false };
|
|
|
|
private _taskEntityRegistries = _self getOrDefault ["taskEntityRegistries", createHashMap];
|
|
|
|
{
|
|
private _registry = +_y;
|
|
_registry deleteAt _taskID;
|
|
_taskEntityRegistries set [_x, _registry];
|
|
} forEach _taskEntityRegistries;
|
|
|
|
_self set ["taskEntityRegistries", _taskEntityRegistries];
|
|
true
|
|
}],
|
|
["trackParticipants", compileFinal {
|
|
params [["_taskID", "", [""]], ["_entities", [], [[]]], ["_marker", "", [""]], ["_radius", 300, [0]]];
|
|
|
|
if (_taskID isEqualTo "") exitWith { createHashMap };
|
|
|
|
private _participantRegistry = _self getOrDefault ["participantRegistry", createHashMap];
|
|
private _participantSnapshots = +(_participantRegistry getOrDefault [_taskID, createHashMap]);
|
|
private _activePlayers = allPlayers select {
|
|
alive _x
|
|
&& { side group _x isEqualTo west }
|
|
};
|
|
|
|
if (_marker isNotEqualTo "" && { markerShape _marker in ["RECTANGLE", "ELLIPSE"] }) then {
|
|
{
|
|
private _uid = getPlayerUID _x;
|
|
if (_uid isNotEqualTo "" && { _x inArea _marker }) then {
|
|
if !(_uid in _participantSnapshots) then {
|
|
_participantSnapshots set [_uid, createHashMapFromArray [
|
|
["startRating", rating _x]
|
|
]];
|
|
};
|
|
};
|
|
} forEach _activePlayers;
|
|
};
|
|
|
|
if (_radius > 0 && { _entities isNotEqualTo [] }) then {
|
|
{
|
|
private _entity = _x;
|
|
if (isNull _entity) then { continue; };
|
|
|
|
{
|
|
private _uid = getPlayerUID _x;
|
|
if (_uid isNotEqualTo "" && { (_x distance2D _entity) <= _radius }) then {
|
|
if !(_uid in _participantSnapshots) then {
|
|
_participantSnapshots set [_uid, createHashMapFromArray [
|
|
["startRating", rating _x]
|
|
]];
|
|
};
|
|
};
|
|
} forEach _activePlayers;
|
|
} forEach _entities;
|
|
};
|
|
|
|
_participantRegistry set [_taskID, _participantSnapshots];
|
|
_self set ["participantRegistry", _participantRegistry];
|
|
|
|
_participantSnapshots
|
|
}],
|
|
["resolveRewardContext", compileFinal {
|
|
params [["_taskID", "", [""]]];
|
|
|
|
private _result = createHashMapFromArray [
|
|
["requesterUid", ""],
|
|
["orgID", ""],
|
|
["memberUids", []]
|
|
];
|
|
|
|
if (_taskID isEqualTo "") exitWith { _result };
|
|
|
|
private _rewardState = _self call ["callTaskState", ["task:ownership:reward_context", [_taskID], createHashMap]];
|
|
if (_rewardState isEqualTo createHashMap) exitWith { _result };
|
|
|
|
private _requesterUid = _rewardState getOrDefault ["requesterUid", ""];
|
|
private _resolvedOrgID = _rewardState getOrDefault ["orgId", ""];
|
|
if (_resolvedOrgID isEqualTo "") exitWith { _result };
|
|
|
|
private _org = EGVAR(org,OrgStore) call ["loadById", [_resolvedOrgID]];
|
|
private _memberUids = [];
|
|
if (_org isNotEqualTo createHashMap) then {
|
|
private _members = _org getOrDefault ["members", createHashMap];
|
|
if (_members isEqualType createHashMap) then {
|
|
_memberUids = keys _members;
|
|
};
|
|
if (_requesterUid isNotEqualTo "" && { !(_requesterUid in _memberUids) }) then {
|
|
_memberUids pushBack _requesterUid;
|
|
};
|
|
};
|
|
|
|
_result set ["requesterUid", _requesterUid];
|
|
_result set ["orgID", _resolvedOrgID];
|
|
_result set ["memberUids", _memberUids];
|
|
_result
|
|
}],
|
|
["incrementDefuseCount", compileFinal {
|
|
params [["_taskID", "", [""]]];
|
|
|
|
if (_taskID isEqualTo "") exitWith { 0 };
|
|
|
|
["task:defuse:increment", [_taskID]] call EFUNC(extension,extCall) params ["_result", "_isSuccess"];
|
|
|
|
if !_isSuccess exitWith { 0 };
|
|
if !(_result isEqualType "") exitWith { 0 };
|
|
if ((_result find "Error:") == 0) exitWith {
|
|
["ERROR", format ["Task extension call 'task:defuse:increment' failed: %1", _result]] call EFUNC(common,log);
|
|
0
|
|
};
|
|
|
|
parseNumber _result
|
|
}],
|
|
["getDefuseCount", compileFinal {
|
|
params [["_taskID", "", [""]]];
|
|
|
|
if (_taskID isEqualTo "") exitWith { 0 };
|
|
|
|
["task:defuse:get", [_taskID]] call EFUNC(extension,extCall) params ["_result", "_isSuccess"];
|
|
if !_isSuccess exitWith { 0 };
|
|
if !(_result isEqualType "") exitWith { 0 };
|
|
if ((_result find "Error:") == 0) exitWith {
|
|
["ERROR", format ["Task extension call 'task:defuse:get' failed: %1", _result]] call EFUNC(common,log);
|
|
0
|
|
};
|
|
|
|
parseNumber _result
|
|
}],
|
|
["notifyParticipants", compileFinal {
|
|
params [
|
|
["_taskID", "", [""]],
|
|
["_type", "info", [""]],
|
|
["_title", "Tasks", [""]],
|
|
["_message", "", [""]]
|
|
];
|
|
|
|
if (_taskID isEqualTo "" || { _message isEqualTo "" }) exitWith { false };
|
|
|
|
private _participantRegistry = _self getOrDefault ["participantRegistry", createHashMap];
|
|
private _participantSnapshots = +(_participantRegistry getOrDefault [_taskID, createHashMap]);
|
|
if (_participantSnapshots isEqualTo createHashMap) exitWith { false };
|
|
|
|
{
|
|
private _player = [_x] call EFUNC(common,getPlayer);
|
|
if (isNull _player) then { continue; };
|
|
[CRPC(notifications,recieveNotification), [_type, _title, _message], _player] call CFUNC(targetEvent);
|
|
} forEach (keys _participantSnapshots);
|
|
|
|
true
|
|
}],
|
|
["clearTask", compileFinal {
|
|
params [["_taskID", "", [""]]];
|
|
|
|
if (_taskID isEqualTo "") exitWith { false };
|
|
|
|
if !(isNil QGVAR(MissionManager)) then {
|
|
GVAR(MissionManager) call ["completeMission", [_taskID]];
|
|
};
|
|
|
|
private _participantRegistry = _self getOrDefault ["participantRegistry", createHashMap];
|
|
_participantRegistry deleteAt _taskID;
|
|
_self set ["participantRegistry", _participantRegistry];
|
|
_self call ["callTaskState", ["task:clear", [_taskID], false]];
|
|
_self call ["clearTaskEntities", [_taskID]];
|
|
true
|
|
}],
|
|
["applyRatingOutcome", compileFinal {
|
|
params [["_taskID", "", [""]], ["_delta", 0, [0]]];
|
|
|
|
private _result = createHashMapFromArray [
|
|
["participantUids", []],
|
|
["orgIds", []],
|
|
["contributions", createHashMap],
|
|
["success", true],
|
|
["mutationFailures", []],
|
|
["persistenceFailures", []],
|
|
["message", ""]
|
|
];
|
|
|
|
if (_taskID isEqualTo "" || { _delta isEqualTo 0 }) exitWith { _result };
|
|
|
|
private _participantRegistry = _self getOrDefault ["participantRegistry", createHashMap];
|
|
private _participantSnapshots = +(_participantRegistry getOrDefault [_taskID, createHashMap]);
|
|
if (_participantSnapshots isEqualTo createHashMap) exitWith { _result };
|
|
|
|
private _rewardContext = _self call ["resolveRewardContext", [_taskID]];
|
|
private _participantUids = keys _participantSnapshots;
|
|
if (_participantUids isEqualTo [] && { _delta > 0 }) then {
|
|
private _requesterUid = _rewardContext getOrDefault ["requesterUid", ""];
|
|
if (_requesterUid isNotEqualTo "") then {
|
|
private _requesterPlayer = [_requesterUid] call EFUNC(common,getPlayer);
|
|
if (!isNull _requesterPlayer) then {
|
|
_participantUids pushBack _requesterUid;
|
|
_participantSnapshots set [_requesterUid, createHashMapFromArray [
|
|
["startRating", rating _requesterPlayer]
|
|
]];
|
|
_participantRegistry set [_taskID, _participantSnapshots];
|
|
_self set ["participantRegistry", _participantRegistry];
|
|
["WARNING", format ["Task %1 had no tracked participants at payout time; falling back to requester %2 for personal earnings.", _taskID, _requesterUid]] call EFUNC(common,log);
|
|
};
|
|
};
|
|
};
|
|
if (_participantUids isEqualTo []) exitWith { _result };
|
|
|
|
private _orgIds = [];
|
|
private _contributions = createHashMap;
|
|
private _totalContribution = 0;
|
|
private _mutationFailures = [];
|
|
private _persistenceFailures = [];
|
|
|
|
if (_delta > 0) then {
|
|
{
|
|
private _uid = _x;
|
|
private _player = [_uid] call EFUNC(common,getPlayer);
|
|
if (isNull _player) then { continue; };
|
|
|
|
_contributions set [_uid, 1];
|
|
_totalContribution = _totalContribution + 1;
|
|
} forEach _participantUids;
|
|
};
|
|
|
|
if (_totalContribution <= 0) exitWith {
|
|
_self call ["clearTask", [_taskID]];
|
|
_result
|
|
};
|
|
|
|
{
|
|
private _uid = _x;
|
|
private _orgID = EGVAR(actor,ActorStore) call ["getOrganization", [_uid, ""]];
|
|
if (_orgID isNotEqualTo "") then {
|
|
_orgIds pushBackUnique _orgID;
|
|
};
|
|
|
|
if (_delta > 0) then {
|
|
private _contribution = _contributions getOrDefault [_uid, 0];
|
|
if (_contribution <= 0) then { continue; };
|
|
|
|
private _account = EGVAR(bank,BankStore) call ["get", [_uid, ""]];
|
|
if (_account isEqualTo createHashMap) then {
|
|
_account = EGVAR(bank,BankStore) call ["init", [_uid]];
|
|
};
|
|
|
|
if (_account isNotEqualTo createHashMap) then {
|
|
private _earnings = _account getOrDefault ["earnings", 0];
|
|
private _earningsDelta = round ((_delta * _contribution) / _totalContribution);
|
|
if (_earningsDelta <= 0) then { continue; };
|
|
|
|
private _patch = EGVAR(bank,BankStore) call [
|
|
"mset",
|
|
[
|
|
_uid,
|
|
createHashMapFromArray [["earnings", (_earnings + _earningsDelta)]],
|
|
false
|
|
]
|
|
];
|
|
if !(_patch isEqualType createHashMap) then { continue; };
|
|
if (_patch isEqualTo createHashMap) then { continue; };
|
|
|
|
EGVAR(bank,BankMessenger) call ["sendAccountSync", [_uid, _patch]];
|
|
if ((EGVAR(bank,BankStore) call ["save", [_uid]]) isEqualTo createHashMap) then {
|
|
_persistenceFailures pushBackUnique format ["bank:%1", _uid];
|
|
["ERROR", format ["Task %1 updated bank earnings for %2, but durable save failed.", _taskID, _uid]] call EFUNC(common,log);
|
|
};
|
|
};
|
|
};
|
|
} forEach _participantUids;
|
|
|
|
private _ownerOrgID = _rewardContext getOrDefault ["orgID", ""];
|
|
if (_ownerOrgID isNotEqualTo "") then {
|
|
private _org = EGVAR(org,OrgStore) call ["loadById", [_ownerOrgID]];
|
|
|
|
if (_org isNotEqualTo createHashMap) then {
|
|
private _reputation = _org getOrDefault ["reputation", 0];
|
|
private _nextReputation = round (_reputation + _delta);
|
|
_org set ["reputation", _nextReputation];
|
|
private _updatedOrg = EGVAR(org,OrgStore) call [
|
|
"callHotOrg",
|
|
[
|
|
"org:hot:override",
|
|
[_ownerOrgID, toJSON _org]
|
|
]
|
|
];
|
|
|
|
if (_updatedOrg isNotEqualTo createHashMap) then {
|
|
private _patch = createHashMapFromArray [["reputation", _nextReputation]];
|
|
private _memberUids = _rewardContext getOrDefault ["memberUids", []];
|
|
{
|
|
private _player = [_x] call EFUNC(common,getPlayer);
|
|
if (isNull _player) then { continue; };
|
|
[CRPC(org,responseSyncOrg), [_patch], _player] call CFUNC(targetEvent);
|
|
} forEach _memberUids;
|
|
|
|
_orgIds = [_ownerOrgID];
|
|
if ((EGVAR(org,OrgStore) call ["saveById", [_ownerOrgID]]) isEqualTo createHashMap) then {
|
|
_persistenceFailures pushBackUnique format ["organization:%1", _ownerOrgID];
|
|
["ERROR", format ["Task %1 updated reputation for organization %2, but durable save failed.", _taskID, _ownerOrgID]] call EFUNC(common,log);
|
|
};
|
|
} else {
|
|
["ERROR", format ["Failed to update organization %1 reputation for task %2.", _ownerOrgID, _taskID]] call EFUNC(common,log);
|
|
_mutationFailures pushBackUnique format ["organization:%1", _ownerOrgID];
|
|
};
|
|
};
|
|
};
|
|
|
|
_result set ["participantUids", _participantUids];
|
|
_result set ["orgIds", _orgIds];
|
|
_result set ["contributions", _contributions];
|
|
_result set ["success", (_mutationFailures isEqualTo []) && { _persistenceFailures isEqualTo [] }];
|
|
_result set ["mutationFailures", _mutationFailures];
|
|
_result set ["persistenceFailures", _persistenceFailures];
|
|
if (_mutationFailures isNotEqualTo [] || { _persistenceFailures isNotEqualTo [] }) then {
|
|
private _messageParts = [];
|
|
if (_mutationFailures isNotEqualTo []) then {
|
|
_messageParts pushBack format ["mutation failures: %1", _mutationFailures joinString ", "];
|
|
};
|
|
if (_persistenceFailures isNotEqualTo []) then {
|
|
_messageParts pushBack format ["persistence failures: %1", _persistenceFailures joinString ", "];
|
|
};
|
|
_result set ["message", _messageParts joinString "; "];
|
|
};
|
|
_result
|
|
}]
|
|
]];
|
|
|
|
GVAR(TaskStore)
|