From 9ec51a5e19cb72d1b6ecc4dec4035c4dc7eb8b4d Mon Sep 17 00:00:00 2001 From: IndigoFox Date: Tue, 30 Jan 2024 15:05:02 -0800 Subject: [PATCH] big refactor to isolate functionality. adds milsim_fnc_log. --- functions/CfgFunctions.hpp | 23 +- .../reinsert/client/fn_addAceSelfActions.sqf | 67 +++++ .../client/fn_addCheckQueueSelfAction.sqf | 28 ++ functions/reinsert/client/fn_initClient.sqf | 53 ++++ .../reinsert/client/fn_requestShowQueue.sqf | 3 + functions/reinsert/fn_getBaseName.sqf | 8 + functions/reinsert/fn_getNearestBase.sqf | 10 + functions/reinsert/server/fn_addToQueue.sqf | 56 ++++ .../reinsert/server/fn_globalShowQueue.sqf | 70 +++++ functions/reinsert/server/fn_initServer.sqf | 50 +++ .../reinsert/server/fn_removeFromQueue.sqf | 57 ++++ .../fn_returnReinsertQueueNotification.sqf | 109 +++++++ .../reinsert/server/fn_validateQueue.sqf | 57 ++++ functions/respawn/fn_getNearestBase.sqf | 15 - functions/respawn/fn_init.sqf | 284 ------------------ .../fn_showReinsertQueueNotification.sqf | 56 ---- functions/settings/fn_addCBASettings.sqf | 75 ++++- functions/util/fn_addPlayerInfoToArray.sqf | 11 + functions/util/fn_getPlayerLogString.sqf | 33 +- functions/util/fn_log.sqf | 24 ++ 20 files changed, 714 insertions(+), 375 deletions(-) create mode 100644 functions/reinsert/client/fn_addAceSelfActions.sqf create mode 100644 functions/reinsert/client/fn_addCheckQueueSelfAction.sqf create mode 100644 functions/reinsert/client/fn_initClient.sqf create mode 100644 functions/reinsert/client/fn_requestShowQueue.sqf create mode 100644 functions/reinsert/fn_getBaseName.sqf create mode 100644 functions/reinsert/fn_getNearestBase.sqf create mode 100644 functions/reinsert/server/fn_addToQueue.sqf create mode 100644 functions/reinsert/server/fn_globalShowQueue.sqf create mode 100644 functions/reinsert/server/fn_initServer.sqf create mode 100644 functions/reinsert/server/fn_removeFromQueue.sqf create mode 100644 functions/reinsert/server/fn_returnReinsertQueueNotification.sqf create mode 100644 functions/reinsert/server/fn_validateQueue.sqf delete mode 100644 functions/respawn/fn_getNearestBase.sqf delete mode 100644 functions/respawn/fn_init.sqf delete mode 100644 functions/respawn/fn_showReinsertQueueNotification.sqf create mode 100644 functions/util/fn_addPlayerInfoToArray.sqf create mode 100644 functions/util/fn_log.sqf diff --git a/functions/CfgFunctions.hpp b/functions/CfgFunctions.hpp index e5f54d5..7951b16 100644 --- a/functions/CfgFunctions.hpp +++ b/functions/CfgFunctions.hpp @@ -73,14 +73,31 @@ class milsim class util { class getPlayerLogString {}; + class addPlayerInfoToArray {}; + class log {}; }; }; class milsim_respawn { class functions { - file = "functions\respawn"; - class init { postInit = 1; }; - class showReinsertQueueNotification {}; + file = "functions\reinsert"; + class getBaseName {}; class getNearestBase {}; }; + class server { + file = "functions\reinsert\server"; + class initServer { postInit = 1; }; + class addToQueue {}; + class globalShowQueue {}; + class removeFromQueue {}; + class returnReinsertQueueNotification {}; + class validateQueue {}; + }; + class client { + file = "functions\reinsert\client"; + class initClient { postInit = 1; }; + class addAceSelfActions {}; + class addCheckQueueSelfAction {}; + class requestShowQueue {}; + }; }; \ No newline at end of file diff --git a/functions/reinsert/client/fn_addAceSelfActions.sqf b/functions/reinsert/client/fn_addAceSelfActions.sqf new file mode 100644 index 0000000..fe4091a --- /dev/null +++ b/functions/reinsert/client/fn_addAceSelfActions.sqf @@ -0,0 +1,67 @@ +params ["_type"]; // string of the object's classname +if (!(_type isKindOf "CAManBase")) exitWith {}; + +if ( + (localNamespace getVariable ["milsim_respawn_fileForReinsertClassesAdded", []]) + find _type != -1 +) exitWith {}; + +private _fileForReinsertAction = [ + "milsim_respawn_fileReinsertRequest", + "File Re-insert Request", + "\A3\ui_f\data\igui\cfg\simpleTasks\types\takeoff_ca.paa", + { // statement + params ["_target", "_player", "_params"]; + // find nearest base or location + private _base = [_player] call milsim_respawn_fnc_getNearestBase; + private _baseName = [_base] call milsim_respawn_fnc_getBaseName; + // send event to server + ["milsim_respawn_fileReinsertRequest", [_player, _base]] call CBA_fnc_serverEvent; + // notify player their request was filed + [["Re-insert Request Filed"], [format["Location: %1", _baseName]]] call CBA_fnc_notify; + }, + { // condition + params ["_target", "_player", "_params"]; + // find nearest base or location + private _base = [_player] call milsim_respawn_fnc_getNearestBase; + private _baseDistance = _player distance _base; + + private _maxRangeToReady = missionNamespace getVariable ["milsim_respawn_setting_reinsertion_maxRangeToReady", 400]; + private _existingQueue = missionNamespace getVariable ["milsim_respawn_reinsertionQueue", []]; + + // check if module is enabled, player is near a base, and player is not already in the queue + // (serverTime - milsim_respawn_missionStartServerTime) > 60*5 && // only allow after 15 minutes + missionNamespace getVariable ["milsim_respawn_setting_reinsertion_enabled", true] && + (_baseDistance < _maxRangeToReady) && + not (_player in (_existingQueue apply {_x#0})) + } +] call ace_interact_menu_fnc_createAction; +[_type, 1, ["ACE_SelfActions"], _fileForReinsertAction, true] call ace_interact_menu_fnc_addActionToClass; + +private _removeFileForReinsertAction = [ + "milsim_respawn_removeReinsertRequest", + "Remove Re-insert Request", + "\A3\ui_f\data\igui\cfg\simpleTasks\types\land_ca.paa", + { // statement + params ["_target", "_player", "_params"]; + // send event to server + ["milsim_respawn_removeReinsertRequest", [_player]] call CBA_fnc_serverEvent; + // notify player their request was rescinded + "Re-insert Request Rescinded" call CBA_fnc_notify; + }, + { // condition + params ["_target", "_player", "_params"]; + private _existingQueue = missionNamespace getVariable ["milsim_respawn_reinsertionQueue", []]; + + // check if module is enabled, player is in the queue + // (serverTime - milsim_respawn_missionStartServerTime) > 60*5 && // only allow after 15 minutes + missionNamespace getVariable ["milsim_respawn_setting_reinsertion_enabled", true] && + (_player in (_existingQueue apply {_x#0})) + } +] call ace_interact_menu_fnc_createAction; +[_type, 1, ["ACE_SelfActions"], _removeFileForReinsertAction, true] call ace_interact_menu_fnc_addActionToClass; + +private _classesActionsAddedTo = (localNamespace getVariable ["milsim_respawn_fileForReinsertClassesAdded", []]); +_classesActionsAddedTo pushBackUnique _type; +localNamespace setVariable ["milsim_respawn_fileForReinsertClassesAdded", _classesActionsAddedTo]; + diff --git a/functions/reinsert/client/fn_addCheckQueueSelfAction.sqf b/functions/reinsert/client/fn_addCheckQueueSelfAction.sqf new file mode 100644 index 0000000..87f0746 --- /dev/null +++ b/functions/reinsert/client/fn_addCheckQueueSelfAction.sqf @@ -0,0 +1,28 @@ +params ["_type"]; // string of the object's classname +if (!(_type isKindOf "CAManBase")) exitWith {}; + +if ( + (localNamespace getVariable ["milsim_respawn_checkReinsertQueueClassesAdded", []]) + find _type != -1 +) exitWith {}; + +private _checkReinsertQueueAction = [ + "milsim_respawn_checkReinsertQueue", + "[PILOT] Check Re-insert Queue", + "\A3\ui_f\data\igui\cfg\simpleTasks\types\land_ca.paa", + { + params ["_target", "_player", "_params"]; + // request notification from the server + call milsim_respawn_fnc_requestShowQueue; + // reset last check time + localNamespace setVariable ["milsim_respawn_lastReinsertQueueCheck", diag_tickTime]; + }, + { + missionNamespace getVariable ["milsim_respawn_setting_reinsertion_enabled", true] + } // always allow +] call ace_interact_menu_fnc_createAction; +[_type, 1, ["ACE_SelfActions"], _checkReinsertQueueAction, true] call ace_interact_menu_fnc_addActionToClass; + +private _classesActionsAddedTo = (localNamespace getVariable ["milsim_respawn_checkReinsertQueueClassesAdded", []]); +_classesActionsAddedTo pushBackUnique _type; +localNamespace setVariable ["milsim_respawn_checkReinsertQueueClassesAdded", _classesActionsAddedTo]; \ No newline at end of file diff --git a/functions/reinsert/client/fn_initClient.sqf b/functions/reinsert/client/fn_initClient.sqf new file mode 100644 index 0000000..8a96f23 --- /dev/null +++ b/functions/reinsert/client/fn_initClient.sqf @@ -0,0 +1,53 @@ +if (!hasInterface) exitWith {}; + +// ACE SELF-INTERACTIONS FOR FILING AND RESCINDING REINSERT REQUESTS NEAR BASE - ALL PLAYERS +localNamespace setVariable ["milsim_respawn_fileForReinsertClassesAdded", []]; +// add actions to current class +[typeOf player] call milsim_respawn_fnc_addAceSelfActions; +// add actions to future classes +["ace_interact_menu_newControllableObject", { + _this call milsim_respawn_fnc_addAceSelfActions; +}] call CBA_fnc_addEventHandler; + +///////////////////////////////////////////////////// +// PILOTS ONLY +// ACE SELF-INTERACTIONS FOR CHECKING REINSERT QUEUE - ONLY FOR PILOTS +if ((typeOf player) in ["B_Helipilot_F", "B_helicrew_F"]) then { + localNamespace setVariable ["milsim_respawn_checkReinsertQueueClassesAdded", []]; + localNamespace setVariable ["milsim_respawn_lastReinsertQueueCheck", diag_tickTime]; + + // add actions to current class + [typeOf player] call milsim_respawn_fnc_addCheckQueueSelfAction; + // add actions to future classes + ["ace_interact_menu_newControllableObject", { + _this call milsim_respawn_fnc_addCheckQueueSelfAction; + }] call CBA_fnc_addEventHandler; +}; +///////////////////////////////////////////////////// + + +// ADD TIMER FOR PILOTS - IF REINSERT LIST NOT CHECKED FOR 20 MINUTES, SHOW NOTIFICATION AUTOMATICALLY +if ((typeOf player) in ["B_Helipilot_F", "B_helicrew_F"]) then { + [{ + // if module not enabled and pilot forced check not enabled, exit + if (not ( + missionNamespace getVariable ["milsim_respawn_setting_reinsertion_enabled", true] && + missionNamespace getVariable ["milsim_respawn_setting_reinsertion_pilotForcedCheckEnabled", true] + )) exitWith {}; + + // if last check was less than X minutes ago, skip + private _lastCheck = localNamespace getVariable ["milsim_respawn_lastReinsertQueueCheck", diag_tickTime]; + private _requiredCheckInterval = missionNamespace getVariable ["milsim_respawn_setting_reinsertion_pilotForcedCheckInterval", 60*20]; + if ( + diag_tickTime - _lastCheck < + _requiredCheckInterval + ) exitWith {}; // if last check was less than X minutes ago, skip + + // last check was greater than X minutes ago + // reset last check time + localNamespace setVariable ["milsim_respawn_lastReinsertQueueCheck", diag_tickTime]; + // request notification from the server + call milsim_respawn_fnc_requestShowQueue; + }, 30] call CBA_fnc_addPerFrameHandler; +}; +///////////////////////////////////////////////////// \ No newline at end of file diff --git a/functions/reinsert/client/fn_requestShowQueue.sqf b/functions/reinsert/client/fn_requestShowQueue.sqf new file mode 100644 index 0000000..11a8d03 --- /dev/null +++ b/functions/reinsert/client/fn_requestShowQueue.sqf @@ -0,0 +1,3 @@ +if (!hasInterface) exitWith {}; + +[] remoteExec ["milsim_respawn_fnc_returnReinsertQueueNotification", 2]; \ No newline at end of file diff --git a/functions/reinsert/fn_getBaseName.sqf b/functions/reinsert/fn_getBaseName.sqf new file mode 100644 index 0000000..ab2cbf8 --- /dev/null +++ b/functions/reinsert/fn_getBaseName.sqf @@ -0,0 +1,8 @@ +params [["_base", objNull, [objNull]]]; +if (_base == objNull) exitWith {""}; + +// get base name +private _baseName = _base getVariable ["name", ""]; +if (_baseName == "") then {_baseName = format["near %1", text (nearestLocation [_base, ["NameCity", "NameLocal"]])]}; + +_baseName; \ No newline at end of file diff --git a/functions/reinsert/fn_getNearestBase.sqf b/functions/reinsert/fn_getNearestBase.sqf new file mode 100644 index 0000000..3d955ba --- /dev/null +++ b/functions/reinsert/fn_getNearestBase.sqf @@ -0,0 +1,10 @@ +params [["_player", objNull, [objNull]]]; +if (isNull _player) exitWith {objNull}; + +private _bases = missionNamespace getVariable ["milsim_respawn_bases", []]; +if (count _bases == 0) exitWith {objNull}; + +// get nearest base (Module_Respawn_F) +private _closestBase = [_bases, _player] call BIS_fnc_nearestPosition; +if (isNull _closestBase) exitWith {objNull}; +_closestBase; \ No newline at end of file diff --git a/functions/reinsert/server/fn_addToQueue.sqf b/functions/reinsert/server/fn_addToQueue.sqf new file mode 100644 index 0000000..24f63ad --- /dev/null +++ b/functions/reinsert/server/fn_addToQueue.sqf @@ -0,0 +1,56 @@ +params [ + ["_player", objNull, [objNull]], + ["_base", objNull, [objNull]], + ["_timeFiled", diag_tickTime, [25]] +]; + +if (!isServer) exitWith { + [ + "respawn_reinsertion", + "ATTEMPTED RUN ON CLIENT", + [ + ["player", _player], + ["base", _base] + ] + ] call milsim_fnc_log; +}; +if ( + isNull _player || + isNull _base +) exitWith { + [ + "respawn_reinsertion", + "NULL PARAMETERS", + [ + ["player", _player], + ["base", _base] + ] + ] call milsim_fnc_log; +}; + + +private _maxRangeToReady = missionNamespace getVariable ["milsim_respawn_setting_reinsertion_maxRangeToReady", 400]; +// nearest base here is the same as the base sent +private _nearestBase = _base; + +milsim_respawn_reinsertionQueue pushBackUnique [ + _player, _base, _timeFiled +]; +// broadcast new list to all machines +publicVariable "milsim_respawn_reinsertionQueue"; + +// log to rpt +private _logParams = [ + ["filedAtBase", [_base] call milsim_respawn_fnc_getBaseName], + ["filedAtBaseDistance", _player distance _base], + ["closestBase", [_nearestBase] call milsim_respawn_fnc_getBaseName], + ["closestBaseDistance", _player distance _nearestBase], + ["maxDistanceSetting", _maxRangeToReady], + ["inQueueDuration", diag_tickTime - _timeFiled] +]; +_logParams = [_player, _logParams] call milsim_fnc_addPlayerInfoToArray; +[ + "respawn_reinsertion", + "PLAYER FILED REQUEST", + _logParams +] call milsim_fnc_log; \ No newline at end of file diff --git a/functions/reinsert/server/fn_globalShowQueue.sqf b/functions/reinsert/server/fn_globalShowQueue.sqf new file mode 100644 index 0000000..566a780 --- /dev/null +++ b/functions/reinsert/server/fn_globalShowQueue.sqf @@ -0,0 +1,70 @@ +if (!isServer) exitWith {}; + +// if at least 1 player in the queue has been waiting longer than the configured timeout, notify all players +private _timeout = missionNamespace getVariable ["milsim_respawn_setting_reinsertion_max_wait", 60*20]; // default 20 minutes +private _timeoutPlayers = milsim_respawn_reinsertionQueue select { + _x params ["_player", "_base", "_timeFiled"]; + alive (_player) && + (diag_tickTime - (_timeFiled)) > _timeout +}; +if (count _timeoutPlayers > 0) then { + // GLOBAL CBA NOTIFY + private _playerLines = [["Players are still waiting for Re-insert!", 1.2, [1, 0.64, 0, 1]]]; + private _maxRangeToReady = missionNamespace getVariable ["milsim_respawn_setting_reinsertion_maxRangeToReady", 400]; + + // get base objects from queue + private _basesWithPeople = (missionNamespace getVariable ["milsim_respawn_reinsertionQueue", []]) apply {_x#1}; + // get unique base objects + private _basesWithPeople = _basesWithPeople arrayIntersect _basesWithPeople; + + { + private _thisBase = _x; + + // Add line for base name + _playerLines pushBack ([[_thisBase] call milsim_respawn_fnc_getBaseName, 1, [0,1,0,1]]); + + // Get players under this base + private _thisBasePlayers = _timeoutPlayers select {_x#1 isEqualTo _thisBase}; + // sort _timeoutPlayers by time in queue, descending + _thisBasePlayers = [_thisBasePlayers, [], { + _x params ["_player", "_base", "_timeFiled"]; + _timeFiled; + }, "DESCEND"] call BIS_fnc_sortBy; + + + { // for each player under this base, add a line + _x params ["_player", "_base", "_timeFiled"]; + // get the closest base to the player + private _nearestBase = [_player] call milsim_respawn_fnc_getNearestBase; + + // add player to array of players under bases + _playerLines pushBack ([format [ + "%1: %2 [%3]", + groupID (group (_player)), + name (_player), + [diag_tickTime - (_timeFiled), "MM:SS"] call BIS_fnc_secondsToString + ], 0.8, [0.8, 0.8, 0.8, 1]]); + + // log to rpt + private _logParams = [ + ["filedAtBase", [_base] call milsim_respawn_fnc_getBaseName], + ["filedAtBaseDistance", _player distance _base], + ["closestBase", [_nearestBase] call milsim_respawn_fnc_getBaseName], + ["closestBaseDistance", _player distance _nearestBase], + ["maxDistanceSetting", _maxRangeToReady], + ["inQueueDuration", diag_tickTime - _timeFiled] + ]; + _logParams = [_player, _logParams] call milsim_fnc_addPlayerInfoToArray; + [ + "respawn_reinsertion", + "PLAYER WAITING OVER TIMEOUT", + _logParams + ] call milsim_fnc_log; + } forEach _thisBasePlayers; + } forEach _basesWithPeople; + + // SEND NOTIFY + _playerLines remoteExec ["CBA_fnc_notify", [0, -2] select isDedicated]; + // RESET NOTIFICATION TIMER + milsim_respawn_reinsertionOverTimeoutLastNotificationTime = diag_tickTime; +}; \ No newline at end of file diff --git a/functions/reinsert/server/fn_initServer.sqf b/functions/reinsert/server/fn_initServer.sqf new file mode 100644 index 0000000..a93a91a --- /dev/null +++ b/functions/reinsert/server/fn_initServer.sqf @@ -0,0 +1,50 @@ +// if a player files for reinsert using self-interaction +// they're added to the queue along with their nearest base location and the time they filed +// if a player's time in the queue exceeds the configured timeout, a message will be posted every 5 minutes on a cycle based around +// the player's time in the queue stating how long they have been waiting, their name, and their group's name + +if (!isServer) exitWith {}; + +// array of all respawn modules in the mission, used as 'base' locations for reinsertion +milsim_respawn_bases = allMissionObjects "ModuleRespawnPosition_F"; +publicVariable "milsim_respawn_bases"; + +// register queue +milsim_respawn_reinsertionQueue = []; +publicVariable "milsim_respawn_reinsertionQueue"; + + +// server mission start time +milsim_respawn_missionStartServerTime = serverTime; + +// FILE REQUEST CBA HANDLER +["milsim_respawn_fileReinsertRequest", { + params ["_player", "_base"]; + [_player, _base] call milsim_respawn_fnc_addToQueue; +}] call CBA_fnc_addEventHandler; + +// REMOVE REQUEST CBA HANDLER +["milsim_respawn_removeReinsertRequest", { + params ["_player"]; + [_player] call milsim_respawn_fnc_removeFromQueue; +}] call CBA_fnc_addEventHandler; + + +// automated wait threshold timer +milsim_respawn_reinsertionOverTimeoutLastNotificationTime = 0; + +[{ // every 60 seconds + + // validate queue + call milsim_respawn_fnc_validateQueue; + + // check if last overTimeout notification was sent more than X minutes ago + if ( + diag_tickTime - milsim_respawn_reinsertionOverTimeoutLastNotificationTime > 60*5 + ) then { + // show global queue notification with any players that are over timeout + call milsim_respawn_fnc_globalShowQueue; + }; + +}, 60] call CBA_fnc_addPerFrameHandler; + diff --git a/functions/reinsert/server/fn_removeFromQueue.sqf b/functions/reinsert/server/fn_removeFromQueue.sqf new file mode 100644 index 0000000..f230c63 --- /dev/null +++ b/functions/reinsert/server/fn_removeFromQueue.sqf @@ -0,0 +1,57 @@ +params [["_player", objNull, [objNull]]]; + +if (!isServer) exitWith { + [ + "respawn_reinsertion", + "ATTEMPTED RUN ON CLIENT", + [ + ["player", _player] + ] + ] call milsim_fnc_log; +}; +if (isNull _player) exitWith { + [ + "respawn_reinsertion", + "NULL PARAMETERS", + [ + ["player", _player] + ] + ] call milsim_fnc_log; +}; + +// get entries for this player from queue +private _unitArrs = milsim_respawn_reinsertionQueue select {_x#0 isEqualTo _player}; +// if player not in queue, skip +if (count _unitArrs isEqualTo 0) exitWith {}; + +private _maxRangeToReady = missionNamespace getVariable ["milsim_respawn_setting_reinsertion_maxRangeToReady", 400]; + +// remove player from queue +milsim_respawn_reinsertionQueue = milsim_respawn_reinsertionQueue - _unitArrs; +// broadcast new list to all machines +publicVariable "milsim_respawn_reinsertionQueue"; + +// sort _unitArrs by time in queue, descending, to get longest wait (if for some reason there's a duplicate) +[_unitArrs, [], { + _x#2 +}, "DESCEND"] call BIS_fnc_sortBy; + +// get first entry (longest wait) +(_unitArrs#0) params ["_player", "_base", "_timeFiled"]; // _unitArr = [unit, base, timeInQueue] +// get the closest base to the player +private _nearestBase = [_player] call milsim_respawn_fnc_getNearestBase; +// log to rpt +private _logParams = [ + ["filedAtBase", [_base] call milsim_respawn_fnc_getBaseName], + ["filedAtBaseDistance", _player distance _base], + ["closestBase", [_nearestBase] call milsim_respawn_fnc_getBaseName], + ["closestBaseDistance", _player distance _nearestBase], + ["maxDistanceSetting", _maxRangeToReady], + ["inQueueDuration", diag_tickTime - _timeFiled] +]; +_logParams = [_player, _logParams] call milsim_fnc_addPlayerInfoToArray; +[ + "respawn_reinsertion", + "PLAYER RESCINDED REQUEST", + _logParams +] call milsim_fnc_log; \ No newline at end of file diff --git a/functions/reinsert/server/fn_returnReinsertQueueNotification.sqf b/functions/reinsert/server/fn_returnReinsertQueueNotification.sqf new file mode 100644 index 0000000..e7eaf0a --- /dev/null +++ b/functions/reinsert/server/fn_returnReinsertQueueNotification.sqf @@ -0,0 +1,109 @@ +/* + Function: milsim_respawn_fnc_showReinsertQueueNotification + + Description: + Designed to be remoteExecuted on the server. Will show a CBA notification on the remoteExecutedOwner's screen with the current reinsertion queue and log this occurrence in the server RPT. + + Author: IndigoFox +*/ + +if (not isRemoteExecuted) exitWith { + diag_log text format ["[milsim] (respawn_reinsertion) SHOW QUEUE NOT REMOTE EXECUTED"]; +}; +if (not isServer) exitWith { + diag_log text format ["[milsim] (respawn_reinsertion) SHOW QUEUE NOT RUN ON SERVER"]; +}; + +private _users = allUsers apply {getUserInfo _x} select {count _x > 0}; +private _userIndex = _users findIf {_x#1 isEqualTo remoteExecutedOwner}; +if (_userIndex isEqualTo -1) exitWith { + diag_log text format ["[milsim] (respawn_reinsertion) SHOW QUEUE USER NOT FOUND"]; +}; +private _userObject = _users select _userIndex select 10; +if (isNull _userObject) exitWith { + diag_log text format ["[milsim] (respawn_reinsertion) SHOW QUEUE USER OBJECT NOT FOUND"]; +}; + +// log to rpt +private _logParams = [_userObject, []] call milsim_fnc_addPlayerInfoToArray; +[ + "respawn_reinsertion", + "SHOW QUEUE REQUESTED", + _logParams +] call milsim_fnc_log; + +private _queue = missionNamespace getVariable ["milsim_respawn_reinsertionQueue", []]; +// get base objects from queue +private _basesWithPeople = (missionNamespace getVariable ["milsim_respawn_reinsertionQueue", []]) apply {_x#1}; +// get unique base objects +private _basesWithPeople = _basesWithPeople arrayIntersect _basesWithPeople; + +// text array to use in notification +private _par = [["Players Awaiting Reinsert", 1.2, [1,0.64,0,1]]]; + +if (count _basesWithPeople isEqualTo 0) then { + _par pushBack ["[QUEUE EMPTY]", 1, [1,1,1,1]]; +}; + +// forEach _basesWithPeople +{ + private _thisBase = _x; + private _baseName = [_thisBase] call milsim_respawn_fnc_getBaseName; + + // generate player lines for this base + private _playerLines = _queue select { + _x#1 isEqualTo _thisBase + } apply { + _x params ["_player", "_base", "_timeFiled"]; + [ + format [ + "%1: %2 [%3]", + groupId (group _player), + name _player, + [diag_tickTime - _timeFiled, "MM:SS"] call BIS_fnc_secondsToString + ], + 0.8, + [1,1,1,1] + ]; + }; + + // determine suffix for player count based on count + private _playerCountText = ""; + switch (count _playerLines) do { + case 0: { + _playerCountText = "No players"; + }; + case 1: { + _playerCountText = "1 player"; + }; + default { + _playerCountText = format ["%1 players", count _playerLines]; + }; + }; + + // add base name and player count to notification lines + _par pushBack [ + format ["Location: %1 (%2)", + _baseName, + _playerCountText + ], + 1, + [0,1,0,1] + ]; + + // sort by text (first piece of text is group name) + _playerLines = [ + _playerLines, + [], + {_x#0} + ] call BIS_fnc_sortBy; + + // add to notification lines + { + _par pushBack _x; + } forEach _playerLines; +} forEach _basesWithPeople; + +_par remoteExec ["CBA_fnc_notify", remoteExecutedOwner]; + +true; \ No newline at end of file diff --git a/functions/reinsert/server/fn_validateQueue.sqf b/functions/reinsert/server/fn_validateQueue.sqf new file mode 100644 index 0000000..cce9bac --- /dev/null +++ b/functions/reinsert/server/fn_validateQueue.sqf @@ -0,0 +1,57 @@ +// revalidate any players in the queue +// compare their distance to the nearest base, and remove them if they're too far away (or dead) +private _stillValid = []; +private _maxRangeToReady = missionNamespace getVariable ["milsim_respawn_setting_reinsertion_maxRangeToReady", 400]; +{ + _x params ["_player", "_base", "_timeFiled"]; // _unitArr = [unit, baseName, timeInQueue] + + private _distanceToOriginalBase = _player distance _base; + // get the closest base to the player + private _nearestBase = [_player] call milsim_respawn_fnc_getNearestBase; + private _isCloseEnoughToAnyBase = (_player distance _nearestBase) < _maxRangeToReady; + + if (not _isCloseEnoughToAnyBase || not (alive _player)) then { + // don't include player in updated queue + // log to rpt + private _logParams = [ + ["filedAtBase", [_base] call milsim_respawn_fnc_getBaseName], + ["filedAtBaseDistance", _player distance _base], + ["closestBase", [_nearestBase] call milsim_respawn_fnc_getBaseName], + ["closestBaseDistance", _player distance _nearestBase], + ["maxDistanceSetting", _maxRangeToReady], + ["inQueueDuration", diag_tickTime - _timeFiled] + ]; + _logParams = [_player, _logParams] call milsim_fnc_addPlayerInfoToArray; + [ + "respawn_reinsertion", + "PLAYER DEQUEUED AUTOMATICALLY", + _logParams + ] call milsim_fnc_log; + // continue loop + continue + }; + + // include player in updated queue, and update their location to nearest base + _stillValid pushBackUnique [_player, _nearestBase, _timeFiled]; + // if player's base has changed, log to rpt + if (_base != _nearestBase) then { + private _logParams = [ + ["filedAtBase", [_base] call milsim_respawn_fnc_getBaseName], + ["filedAtBaseDistance", _player distance _base], + ["closestBase", [_nearestBase] call milsim_respawn_fnc_getBaseName], + ["closestBaseDistance", _player distance _nearestBase], + ["maxDistanceSetting", _maxRangeToReady], + ["inQueueDuration", diag_tickTime - _timeFiled] + ]; + _logParams = [_player, _logParams] call milsim_fnc_addPlayerInfoToArray; + [ + "respawn_reinsertion", + "PLAYER BASE WAS UPDATED", + _logParams + ] call milsim_fnc_log; + }; +} forEach milsim_respawn_reinsertionQueue; + +// broadcast new list to all machines +milsim_respawn_reinsertionQueue = _stillValid; +publicVariable "milsim_respawn_reinsertionQueue"; \ No newline at end of file diff --git a/functions/respawn/fn_getNearestBase.sqf b/functions/respawn/fn_getNearestBase.sqf deleted file mode 100644 index c9039aa..0000000 --- a/functions/respawn/fn_getNearestBase.sqf +++ /dev/null @@ -1,15 +0,0 @@ -params [["_player", objNull, [objNull]]]; -if (isNull _player) exitWith {[99999, ""]}; - -private _bases = missionNamespace getVariable ["milsim_respawn_bases", []]; -if (count _bases == 0) exitWith {[99999, ""]}; - -// get nearest base (Module_Respawn_F) -private _closestBase = [_bases, _player] call BIS_fnc_nearestPosition; -// get distance -private _nearestDistance = _closestBase distance _player; -// get base name -private _baseName = _closestBase getVariable ["name", ""]; -if (_baseName == "") then {_baseName = format["near %1", text (nearestLocation [_closestBase, ""])]}; - -[_nearestDistance, _baseName]; \ No newline at end of file diff --git a/functions/respawn/fn_init.sqf b/functions/respawn/fn_init.sqf deleted file mode 100644 index 56a6836..0000000 --- a/functions/respawn/fn_init.sqf +++ /dev/null @@ -1,284 +0,0 @@ - -// if a player files for reinsert using self-interaction -// they're added to the queue along with their nearest base location and the time they filed -// if a player's time in the queue exceeds the configured timeout, a message will be posted every 5 minutes on a cycle based around -// the player's time in the queue stating how long they have been waiting, their name, and their group's name - -// execute for all -if (isNil "milsim_respawn_setting_reinsertion_maxRangeToReady") then { - // configured in CBA settings - milsim_respawn_setting_reinsertion_maxRangeToReady = 400; // distance in meters from a base at which players can ready up for pickup. players removed from the queue if they move further away than this distance -}; -milsim_respawn_bases = allMissionObjects "ModuleRespawnPosition_F"; // array of all respawn modules in the mission - - -// on the server, initialize the queue and register the CBA event handler by which players can ready up -if (isServer) then { - // register queue - milsim_respawn_reinsertionQueue = []; - publicVariable "milsim_respawn_reinsertionQueue"; - - milsim_respawn_reinsertionOverTimeoutLastNotificationTime = 0; - - // register event handlers - ["milsim_respawn_fileReinsertRequest", { - params ["_unit", "_closestBaseName"]; - milsim_respawn_reinsertionQueue pushBackUnique [ - _unit, _closestBaseName, diag_tickTime - ]; - diag_log text format [ - "[milsim] (respawn_reinsertion) PLAYER FILED REQUEST :: filedAtBase=""%1"" %2", - _closestBaseName, - [_unit] call milsim_fnc_getPlayerLogString - ]; - publicVariable "milsim_respawn_reinsertionQueue"; - }] call CBA_fnc_addEventHandler; - ["milsim_respawn_removeReinsertRequest", { - params ["_unit"]; - private _unitArrs = milsim_respawn_reinsertionQueue select {_x#0 isEqualTo _unit}; - if (count _unitArrs isEqualTo 0) exitWith {}; - - milsim_respawn_reinsertionQueue = milsim_respawn_reinsertionQueue - _unitArrs; - // sort _unitArrs by time in queue, descending - [_unitArrs, [], { - _x#2 - }, "DESCEND"] call BIS_fnc_sortBy; - (_unitArrs#0) params ["_unit", "_baseName", "_timeFiled"]; // _unitArr = [unit, baseName, timeInQueue] - private _timeInQueue = diag_tickTime - (_timeFiled); - diag_log text format ["[milsim] (respawn_reinsertion) PLAYER RESCINDED REQUEST :: filedAtBase=""%1"" inQueueDuration=""%2s"" %3", - _baseName, - _timeInQueue, - [_unit] call milsim_fnc_getPlayerLogString - ]; - publicVariable "milsim_respawn_reinsertionQueue"; - }] call CBA_fnc_addEventHandler; - - - - [{ - // every 60 seconds, revalidate any players in the queue - // compare their distance to the nearest base, and remove them if they're too far away (or dead) - private _stillValid = []; - private _maxRangeToReady = missionNamespace getVariable ["milsim_respawn_setting_reinsertion_maxRangeToReady", 400]; - { - _x params ["_player", "_baseName", "_timeFiled"]; // _unitArr = [unit, baseName, timeInQueue] - - - private _nearBase = _nearestDistance < _maxRangeToReady; - - if (_nearBase && alive _player) then { - _stillValid pushBackUnique _x; - } else { - diag_log text format [ - "[milsim] (respawn_reinsertion) PLAYER DEQUEUED AUTOMATICALLY :: filedAtBase=""%1"" nearestBaseDistance=""%2m"" maxDistanceSetting=""%3m"" inQueueDuration=""%4s"" %5", - _baseName, - _nearestDistance, - _maxRangeToReady, - diag_tickTime - _timeFiled, - [_player] call milsim_fnc_getPlayerLogString - ]; - }; - } forEach milsim_respawn_reinsertionQueue; - - // broadcast new list to all machines - milsim_respawn_reinsertionQueue = _stillValid; - publicVariable "milsim_respawn_reinsertionQueue"; - - - // if at least 1 player in the queue has been waiting longer than the configured timeout, - // show a notification to all players if the last notification was more than 5 minutes ago - private _needNotification = - diag_tickTime - milsim_respawn_reinsertionOverTimeoutLastNotificationTime > 60*5; // if last notification was more than 5 minutes ago - if (_needNotification) then { - private _timeout = missionNamespace getVariable ["milsim_respawn_setting_reinsertion_timeout", 60*20]; // default 20 minutes - private _timeoutPlayers = milsim_respawn_reinsertionQueue select { - alive (_x#0) && - (diag_tickTime - (_x#2)) > _timeout - }; - if (count _timeoutPlayers > 0) then { - // sort _timeoutPlayers by time in queue, descending - _timeoutPlayers = [_timeoutPlayers, [], { - _x#2 - }, "DESCEND"] call BIS_fnc_sortBy; - - // GLOBAL CBA NOTIFY - private _playerLines = [["Players are still waiting for Re-insert!"]]; - { - _playerLines pushBack ([format [ - "%1: %2 [%3]", - groupID (group (_x#0)), - name (_x#0), - [diag_tickTime - (_x#2), "MM:SS"] call BIS_fnc_secondsToString - ], 0.8, [0.8, 0.8, 0.8, 1]]); - } forEach _timeoutPlayers; - _playerLines remoteExec ["CBA_fnc_notify", [0, -2] select isDedicated]; - - // RESET NOTIFICATION TIMER - milsim_respawn_reinsertionOverTimeoutLastNotificationTime = diag_tickTime; - - // LOG TO RPT - { - diag_log text format [ - "[milsim] (respawn_reinsertion) PLAYER WAITING OVER TIMEOUT :: timeout=""%1s"" inQueueDuration=""%2s"" %3", - _timeout, - diag_tickTime - (_x#2), - [_x#0] call milsim_fnc_getPlayerLogString - ]; - } forEach _timeoutPlayers; - }; - }; - }, 60] call CBA_fnc_addPerFrameHandler; -}; - - -// if a player, register the ACE self-interaction to ready up -if (hasInterface) then { - - // ACE SELF-INTERACTIONS FOR FILING AND RESCINDING REINSERT REQUESTS NEAR BASE - ALL PLAYERS - localNamespace setVariable ["milsim_respawn_fileForReinsertClassesAdded", []]; - - private _addReinsertRequestSelfActions = { - params ["_type"]; // string of the object's classname - if (!(_type isKindOf "CAManBase")) exitWith {}; - - if ( - (localNamespace getVariable ["milsim_respawn_fileForReinsertClassesAdded", []]) - find _type != -1 - ) exitWith {}; - - private _fileForReinsertAction = [ - "milsim_respawn_fileReinsertRequest", - "File Re-insert Request", - "\A3\ui_f\data\igui\cfg\simpleTasks\types\takeoff_ca.paa", - { - params ["_target", "_player", "_params"]; - // find nearest base or location - ([_player] call milsim_respawn_fnc_getNearestBase) params [ - "_baseDistance", "_baseName" - ]; - // send event to server - ["milsim_respawn_fileReinsertRequest", [_player, _baseName]] call CBA_fnc_serverEvent; - // notify player their request was filed - [["Re-insert Request Filed"], [format["Location: %1", _baseName]]] call CBA_fnc_notify; - }, - { - params ["_target", "_player", "_params"]; - // find nearest base or location - ([_player] call milsim_respawn_fnc_getNearestBase) params [ - "_baseDistance", "_baseName" - ]; - - private _maxRangeToReady = missionNamespace getVariable ["milsim_respawn_setting_reinsertion_maxRangeToReady", 400]; - private _existingQueue = missionNamespace getVariable ["milsim_respawn_reinsertionQueue", []]; - - // check if module is enabled, player is near a base, and player is not already in the queue - missionNamespace getVariable ["milsim_respawn_setting_reinsertion_enabled", true] && - (_baseDistance < _maxRangeToReady) && - not (_player in (_existingQueue apply {_x#0})) - } - ] call ace_interact_menu_fnc_createAction; - [_type, 1, ["ACE_SelfActions"], _fileForReinsertAction, true] call ace_interact_menu_fnc_addActionToClass; - - private _removeFileForReinsertAction = [ - "milsim_respawn_removeReinsertRequest", - "Remove Re-insert Request", - "\A3\ui_f\data\igui\cfg\simpleTasks\types\land_ca.paa", - { - params ["_target", "_player", "_params"]; - // send event to server - ["milsim_respawn_removeReinsertRequest", [_player]] call CBA_fnc_serverEvent; - // notify player their request was rescinded - "Re-insert Request Rescinded" call CBA_fnc_notify; - }, - { - params ["_target", "_player", "_params"]; - - private _existingQueue = missionNamespace getVariable ["milsim_respawn_reinsertionQueue", []]; - - // check if module is enabled, player is in the queue - missionNamespace getVariable ["milsim_respawn_setting_reinsertion_enabled", true] && - (_player in (_existingQueue apply {_x#0})) - } - ] call ace_interact_menu_fnc_createAction; - [_type, 1, ["ACE_SelfActions"], _removeFileForReinsertAction, true] call ace_interact_menu_fnc_addActionToClass; - - private _classesActionsAddedTo = (localNamespace getVariable ["milsim_respawn_fileForReinsertClassesAdded", []]); - _classesActionsAddedTo pushBackUnique _type; - localNamespace setVariable ["milsim_respawn_fileForReinsertClassesAdded", _classesActionsAddedTo]; - }; - - [typeOf player] call _addReinsertRequestSelfActions; - - ["ace_interact_menu_newControllableObject", { - _thisArgs params ["_fnc"]; - _this call _fnc; - }, [_addReinsertRequestSelfActions]] call CBA_fnc_addEventHandlerArgs; - - - ///////////////////////////////////////////////////// - // PILOTS ONLY - // ACE SELF-INTERACTIONS FOR CHECKING REINSERT QUEUE - ONLY FOR PILOTS - localNamespace setVariable ["milsim_respawn_checkReinsertQueueClassesAdded", []]; - localNamespace setVariable ["milsim_respawn_lastReinsertQueueCheck", diag_tickTime]; - - private _addCheckReinsertQueueSelfAction = { - params ["_type"]; // string of the object's classname - if (!(_type isKindOf "CAManBase")) exitWith {}; - if (!(_type in ["B_Helipilot_F", "B_helicrew_F"])) exitWith {}; - - if ( - (localNamespace getVariable ["milsim_respawn_checkReinsertQueueClassesAdded", []]) - find _type != -1 - ) exitWith {}; - - private _checkReinsertQueueAction = [ - "milsim_respawn_checkReinsertQueue", - "[PILOT] Check Re-insert Queue", - "\A3\ui_f\data\igui\cfg\simpleTasks\types\land_ca.paa", - { - params ["_target", "_player", "_params"]; - // reset last check time - localNamespace setVariable ["milsim_respawn_lastReinsertQueueCheck", diag_tickTime]; - - call milsim_respawn_fnc_showReinsertQueueNotification; - }, - { - missionNamespace getVariable ["milsim_respawn_setting_reinsertion_enabled", true] - } // always allow - ] call ace_interact_menu_fnc_createAction; - [_type, 1, ["ACE_SelfActions"], _checkReinsertQueueAction, true] call ace_interact_menu_fnc_addActionToClass; - - private _classesActionsAddedTo = (localNamespace getVariable ["milsim_respawn_checkReinsertQueueClassesAdded", []]); - _classesActionsAddedTo pushBackUnique _type; - localNamespace setVariable ["milsim_respawn_checkReinsertQueueClassesAdded", _classesActionsAddedTo]; - }; - - [typeOf player] call _addCheckReinsertQueueSelfAction; - - ["ace_interact_menu_newControllableObject", { - _thisArgs params ["_fnc"]; - _this call _fnc; - }, [_addCheckReinsertQueueSelfAction]] call CBA_fnc_addEventHandlerArgs; - - - // ADD TIMER FOR PILOTS - IF REINSERT LIST NOT CHECKED FOR 20 MINUTES, SHOW NOTIFICATION AUTOMATICALLY - if ((typeOf player) in ["B_Helipilot_F", "B_helicrew_F"]) then { - [{ - if (not ( - missionNamespace getVariable ["milsim_respawn_setting_reinsertion_enabled", true] && - missionNamespace getVariable ["milsim_respawn_setting_reinsertion_pilotForcedCheckEnabled", true] - )) exitWith {}; - private _lastCheck = localNamespace getVariable ["milsim_respawn_lastReinsertQueueCheck", diag_tickTime]; - if ( - diag_tickTime - _lastCheck < - missionNamespace getVariable ["milsim_respawn_setting_reinsertion_pilotForcedCheckInterval", 60*20] - ) exitWith {}; // if last check was less than X minutes ago, skip - - // if last check was greater than 20 minutes ago, we'll prompt the notification now and reset the timer - localNamespace setVariable ["milsim_respawn_lastReinsertQueueCheck", diag_tickTime]; - - call milsim_respawn_fnc_showReinsertQueueNotification; - }, 30] call CBA_fnc_addPerFrameHandler; - }; - ///////////////////////////////////////////////////// -}; diff --git a/functions/respawn/fn_showReinsertQueueNotification.sqf b/functions/respawn/fn_showReinsertQueueNotification.sqf deleted file mode 100644 index 4c626a2..0000000 --- a/functions/respawn/fn_showReinsertQueueNotification.sqf +++ /dev/null @@ -1,56 +0,0 @@ -private _par = [["Players Awaiting Reinsert", 1.2, [1,0.64,0,1]]]; -private _baseNames = (missionNamespace getVariable ["milsim_respawn_reinsertionQueue", []]) apply {_x#1}; -{ - private _baseName = _x; - private _peopleAtThisBase = (missionNamespace getVariable ["milsim_respawn_reinsertionQueue", []]) select { - _x#1 isEqualTo _baseName - } apply { - private _timeInQueue = diag_tickTime - (_x#2); - [ - format [ - "%1: %2 [%3]", - groupId (group (_x#0)), - name (_x#0), - [_timeInQueue, "MM:SS"] call BIS_fnc_secondsToString - ], - 0.7, - [1,1,1,1] - ]; - }; - - _peopleAtThisBase = [ - _peopleAtThisBase, - [], - {_x#0} - ] call BIS_fnc_sortBy; - - private _playerCountText = ""; - switch (count _peopleAtThisBase) do { - case 0: { - _playerCountText = "No players"; - }; - case 1: { - _playerCountText = "1 player"; - }; - default { - _playerCountText = format ["%1 players", count _peopleAtThisBase]; - }; - }; - - _par pushBack [ - format ["Location: %1 (%2)", - _baseName, - _playerCountText - ], - 1, - [0,1,0,1] - ]; - - { - _par pushBack _x; - } forEach _peopleAtThisBase; -} forEach _baseNames; - -_par call CBA_fnc_notify; - -true; \ No newline at end of file diff --git a/functions/settings/fn_addCBASettings.sqf b/functions/settings/fn_addCBASettings.sqf index c541b2b..fc786f5 100644 --- a/functions/settings/fn_addCBASettings.sqf +++ b/functions/settings/fn_addCBASettings.sqf @@ -136,7 +136,17 @@ true, // global setting { params ["_value"]; - diag_log format["[milsim] (respawn_reinsertion) enabled set to %1", _value]; + [ + "respawn_reinsertion", + "SETTING CHANGED", + [ + [ + "setting", + "milsim_respawn_setting_reinsertion_enabled" + ], + ["newValue", _value] + ] + ] call milsim_fnc_log; } ] call CBA_fnc_addSetting; @@ -149,7 +159,17 @@ true, // global setting { params ["_value"]; - diag_log format["[milsim] (respawn_reinsertion) maxRangeToReady set to %1", _value]; + [ + "respawn_reinsertion", + "SETTING CHANGED", + [ + [ + "setting", + "milsim_respawn_setting_reinsertion_maxRangeToReady" + ], + ["newValue", _value] + ] + ] call milsim_fnc_log; } ] call CBA_fnc_addSetting; @@ -162,34 +182,63 @@ true, // global setting { params ["_value"]; - diag_log format["[milsim] (respawn_reinsertion) pilotForcedCheckEnabled set to %1", _value]; + [ + "respawn_reinsertion", + "SETTING CHANGED", + [ + [ + "setting", + "milsim_respawn_setting_reinsertion_pilotForcedCheckEnabled" + ], + ["newValue", _value] + ] + ] call milsim_fnc_log; } ] call CBA_fnc_addSetting; [ "milsim_respawn_setting_reinsertion_pilotForcedCheckInterval", // variable - "SLIDER", // type - ["Pilot Check Interval", "Pilots will be force shown the queue if they haven't checked it in X seconds"], // title + "TIME", // type + ["Pilot Forced Check Interval", "Pilots will be force shown the queue if they haven't checked it in X seconds"], // title ["17th Battalion", "Re-insert Queue"], // category - [60*10, 60*30, 60*20, 0, false], // [_min, _max, _default, _trailingDecimals, _isPercentage + [60*5, 60*30, 60*10], // [_min, _max, _default] true, { params ["_value"]; - diag_log format["[milsim] (respawn_reinsertion) pilotForcedCheckInterval set to %1", _value]; - + [ + "respawn_reinsertion", + "SETTING CHANGED", + [ + [ + "setting", + "milsim_respawn_setting_reinsertion_pilotForcedCheckInterval" + ], + ["newValue", _value] + ] + ] call milsim_fnc_log; } ] call CBA_fnc_addSetting; [ - "milsim_respawn_setting_reinsertion_timeout", // variable - "SLIDER", // type - ["Request Timeout", "How long should at least one person be waiting before prompting a global notification."], // title + "milsim_respawn_setting_reinsertion_max_wait", // variable + "TIME", // type + ["Max Wait Threshold", "How long should at least one person be waiting before prompting a global notification."], // title ["17th Battalion", "Re-insert Queue"], // category - [60*10, 60*30, 60*20, 0, false], // [_min, _max, _default, _trailingDecimals, _isPercentage + [60*5, 60*30, 60*20], // [_min, _max, _default] true, { params ["_value"]; - diag_log format["[milsim] (respawn_reinsertion) timeout set to %1", _value]; + [ + "respawn_reinsertion", + "SETTING CHANGED", + [ + [ + "setting", + "milsim_respawn_setting_reinsertion_max_wait" + ], + ["newValue", _value] + ] + ] call milsim_fnc_log; } ] call CBA_fnc_addSetting; diff --git a/functions/util/fn_addPlayerInfoToArray.sqf b/functions/util/fn_addPlayerInfoToArray.sqf new file mode 100644 index 0000000..b5e45c5 --- /dev/null +++ b/functions/util/fn_addPlayerInfoToArray.sqf @@ -0,0 +1,11 @@ +params [["_playerObj", objNull], ["_arrayToModify", [], [[]]]]; + +{ + _arrayToModify = [_arrayToModify, _x#0, _x#1] call BIS_fnc_setToPairs; +} forEach [ + ["playerName", name _playerObj], + ["playerUID", getPlayerUID _playerObj], + ["playerGroup", groupId (group _playerObj)] +]; + +_arrayToModify; \ No newline at end of file diff --git a/functions/util/fn_getPlayerLogString.sqf b/functions/util/fn_getPlayerLogString.sqf index d3f5ae0..3b194eb 100644 --- a/functions/util/fn_getPlayerLogString.sqf +++ b/functions/util/fn_getPlayerLogString.sqf @@ -8,10 +8,35 @@ Parameters: 0: _playerObj - The player object to get the string for. + 1: _returnArray - If true, returns a key/value array of the player's name, UID and group name. */ -params [["_playerObj", objNull]]; -if (isNull _playerObj) exitWith { - "playerName=""ERROR"" playerUID=""ERROR"" playerGroup=""ERROR""" +params [["_playerObj", objNull], ["_returnArray", false, [false, true]]]; + +switch (_returnArray) do { + case false: { + if (isNull _playerObj) exitWith { + "playerName=""ERROR"" playerUID=""ERROR"" playerGroup=""ERROR""" + }; + if (true) exitWith { + format["playerName=""%1"" playerUID=""%2"" playerGroup=""%3""", name _playerObj, getPlayerUID _playerObj, groupId (group _playerObj)]; + }; + }; + case true: { + if (isNull _playerObj) exitWith { + [ + ["playerName", "ERROR"], + ["playerUID", "ERROR"], + ["playerGroup", "ERROR"] + ] + }; + if (true) exitWith { + [ + ["playerName", name _playerObj], + ["playerUID", getPlayerUID _playerObj], + ["playerGroup", groupId (group _playerObj)] + ] + }; + }; }; -format["playerName=""%1"" playerUID=""%2"" playerGroup=""%3""", name _playerObj, getPlayerUID _playerObj, groupId (group _playerObj)]; \ No newline at end of file + diff --git a/functions/util/fn_log.sqf b/functions/util/fn_log.sqf new file mode 100644 index 0000000..5b780b4 --- /dev/null +++ b/functions/util/fn_log.sqf @@ -0,0 +1,24 @@ +/* + Function: milsim_fnc_log + + Description: + Used to log messages to the server RPT file. + + Parameters: + 0: STRING - component name. + 1: STRING - message to log. + 2: ARRAY - Key value pairs of data to log. +*/ + +params [ + ["_component", "", [""]], + ["_message", "", [""]], + ["_data", [], [[]]] +]; + +private _hash = createHashMapFromArray _data; + +private _json = [_hash] call CBA_fnc_encodeJSON; +_log = format ["[milsim] (%1) (%2) (%3) :: %4", _component, _fnc_scriptNameParent, _message, _json]; + +diag_log text _log; \ No newline at end of file