diff --git a/functions/CfgFunctions.hpp b/functions/CfgFunctions.hpp index 9f3f211..cd622c8 100644 --- a/functions/CfgFunctions.hpp +++ b/functions/CfgFunctions.hpp @@ -73,13 +73,31 @@ class milsim class util { class getPlayerLogString {}; + class addPlayerInfoToArray {}; + class log {}; }; }; -class milsim_respawn { +class milsim_reinsert { 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..7734e1b --- /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_reinsert_fileForReinsertClassesAdded", []]) + find _type != -1 +) exitWith {}; + +private _fileForReinsertAction = [ + "milsim_reinsert_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_reinsert_fnc_getNearestBase; + private _baseName = [_base] call milsim_reinsert_fnc_getBaseName; + // send event to server + ["milsim_reinsert_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_reinsert_fnc_getNearestBase; + private _baseDistance = _player distance _base; + + private _maxRangeToReady = missionNamespace getVariable ["milsim_reinsert_setting_reinsertion_maxRangeToReady", 400]; + private _existingQueue = missionNamespace getVariable ["milsim_reinsert_reinsertionQueue", []]; + + // check if module is enabled, player is near a base, and player is not already in the queue + // (serverTime - milsim_reinsert_missionStartServerTime) > 60*5 && // only allow after 15 minutes + missionNamespace getVariable ["milsim_reinsert_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_reinsert_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_reinsert_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_reinsert_reinsertionQueue", []]; + + // check if module is enabled, player is in the queue + // (serverTime - milsim_reinsert_missionStartServerTime) > 60*5 && // only allow after 15 minutes + missionNamespace getVariable ["milsim_reinsert_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_reinsert_fileForReinsertClassesAdded", []]); +_classesActionsAddedTo pushBackUnique _type; +localNamespace setVariable ["milsim_reinsert_fileForReinsertClassesAdded", _classesActionsAddedTo]; + diff --git a/functions/reinsert/client/fn_addCheckQueueSelfAction.sqf b/functions/reinsert/client/fn_addCheckQueueSelfAction.sqf new file mode 100644 index 0000000..5897b53 --- /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_reinsert_checkReinsertQueueClassesAdded", []]) + find _type != -1 +) exitWith {}; + +private _checkReinsertQueueAction = [ + "milsim_reinsert_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_reinsert_fnc_requestShowQueue; + // reset last check time + localNamespace setVariable ["milsim_reinsert_lastReinsertQueueCheck", diag_tickTime]; + }, + { + missionNamespace getVariable ["milsim_reinsert_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_reinsert_checkReinsertQueueClassesAdded", []]); +_classesActionsAddedTo pushBackUnique _type; +localNamespace setVariable ["milsim_reinsert_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..cdee922 --- /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_reinsert_fileForReinsertClassesAdded", []]; +// add actions to current class +[typeOf player] call milsim_reinsert_fnc_addAceSelfActions; +// add actions to future classes +["ace_interact_menu_newControllableObject", { + _this call milsim_reinsert_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_reinsert_checkReinsertQueueClassesAdded", []]; + localNamespace setVariable ["milsim_reinsert_lastReinsertQueueCheck", diag_tickTime]; + + // add actions to current class + [typeOf player] call milsim_reinsert_fnc_addCheckQueueSelfAction; + // add actions to future classes + ["ace_interact_menu_newControllableObject", { + _this call milsim_reinsert_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_reinsert_setting_reinsertion_enabled", true] && + missionNamespace getVariable ["milsim_reinsert_setting_reinsertion_pilotForcedCheckEnabled", true] + )) exitWith {}; + + // if last check was less than X minutes ago, skip + private _lastCheck = localNamespace getVariable ["milsim_reinsert_lastReinsertQueueCheck", diag_tickTime]; + private _requiredCheckInterval = missionNamespace getVariable ["milsim_reinsert_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_reinsert_lastReinsertQueueCheck", diag_tickTime]; + // request notification from the server + call milsim_reinsert_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..1afed4e --- /dev/null +++ b/functions/reinsert/client/fn_requestShowQueue.sqf @@ -0,0 +1,3 @@ +if (!hasInterface) exitWith {}; + +[] remoteExec ["milsim_reinsert_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..049cc04 --- /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_reinsert_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..ce662d1 --- /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_reinsert_setting_reinsertion_maxRangeToReady", 400]; +// nearest base here is the same as the base sent +private _nearestBase = _base; + +milsim_reinsert_reinsertionQueue pushBackUnique [ + _player, _base, _timeFiled +]; +// broadcast new list to all machines +publicVariable "milsim_reinsert_reinsertionQueue"; + +// log to rpt +private _logParams = [ + ["filedAtBase", [_base] call milsim_reinsert_fnc_getBaseName], + ["filedAtBaseDistance", _player distance _base], + ["closestBase", [_nearestBase] call milsim_reinsert_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..a85462e --- /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_reinsert_setting_reinsertion_max_wait", 60*20]; // default 20 minutes +private _timeoutPlayers = milsim_reinsert_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_reinsert_setting_reinsertion_maxRangeToReady", 400]; + + // get base objects from queue + private _basesWithPeople = (missionNamespace getVariable ["milsim_reinsert_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_reinsert_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_reinsert_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_reinsert_fnc_getBaseName], + ["filedAtBaseDistance", _player distance _base], + ["closestBase", [_nearestBase] call milsim_reinsert_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_reinsert_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..9dd329f --- /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_reinsert_bases = allMissionObjects "ModuleRespawnPosition_F"; +publicVariable "milsim_reinsert_bases"; + +// register queue +milsim_reinsert_reinsertionQueue = []; +publicVariable "milsim_reinsert_reinsertionQueue"; + + +// server mission start time +milsim_reinsert_missionStartServerTime = serverTime; + +// FILE REQUEST CBA HANDLER +["milsim_reinsert_fileReinsertRequest", { + params ["_player", "_base"]; + [_player, _base] call milsim_reinsert_fnc_addToQueue; +}] call CBA_fnc_addEventHandler; + +// REMOVE REQUEST CBA HANDLER +["milsim_reinsert_removeReinsertRequest", { + params ["_player"]; + [_player] call milsim_reinsert_fnc_removeFromQueue; +}] call CBA_fnc_addEventHandler; + + +// automated wait threshold timer +milsim_reinsert_reinsertionOverTimeoutLastNotificationTime = 0; + +[{ // every 60 seconds + + // validate queue + call milsim_reinsert_fnc_validateQueue; + + // check if last overTimeout notification was sent more than X minutes ago + if ( + diag_tickTime - milsim_reinsert_reinsertionOverTimeoutLastNotificationTime > 60*5 + ) then { + // show global queue notification with any players that are over timeout + call milsim_reinsert_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..0e24679 --- /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_reinsert_reinsertionQueue select {_x#0 isEqualTo _player}; +// if player not in queue, skip +if (count _unitArrs isEqualTo 0) exitWith {}; + +private _maxRangeToReady = missionNamespace getVariable ["milsim_reinsert_setting_reinsertion_maxRangeToReady", 400]; + +// remove player from queue +milsim_reinsert_reinsertionQueue = milsim_reinsert_reinsertionQueue - _unitArrs; +// broadcast new list to all machines +publicVariable "milsim_reinsert_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_reinsert_fnc_getNearestBase; +// log to rpt +private _logParams = [ + ["filedAtBase", [_base] call milsim_reinsert_fnc_getBaseName], + ["filedAtBaseDistance", _player distance _base], + ["closestBase", [_nearestBase] call milsim_reinsert_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..d114ad2 --- /dev/null +++ b/functions/reinsert/server/fn_returnReinsertQueueNotification.sqf @@ -0,0 +1,109 @@ +/* + Function: milsim_reinsert_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_reinsert_reinsertionQueue", []]; +// get base objects from queue +private _basesWithPeople = (missionNamespace getVariable ["milsim_reinsert_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_reinsert_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..9c59209 --- /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_reinsert_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_reinsert_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_reinsert_fnc_getBaseName], + ["filedAtBaseDistance", _player distance _base], + ["closestBase", [_nearestBase] call milsim_reinsert_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_reinsert_fnc_getBaseName], + ["filedAtBaseDistance", _player distance _base], + ["closestBase", [_nearestBase] call milsim_reinsert_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_reinsert_reinsertionQueue; + +// broadcast new list to all machines +milsim_reinsert_reinsertionQueue = _stillValid; +publicVariable "milsim_reinsert_reinsertionQueue"; \ 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 76e8c09..0000000 --- a/functions/respawn/fn_init.sqf +++ /dev/null @@ -1,281 +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", "_time"]; - milsim_respawn_reinsertionQueue pushBackUnique [_unit, _closestBaseName, _time]; - diag_log text format [ - "[milsim] (respawn_reinsertion) ADDED name=%1 playerUID=%2 group=%3 filedAtBase=%4", - name _unit, - getPlayerUID _unit, - groupId (group _unit), - _closestBaseName - ]; - 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) REMOVED BY REQUEST name=%1 playerUID=%2 group=%3 filedAtBase=%4 inQueue=%5s", - name _unit, - getPlayerUID _unit, - groupId (group _unit), - _baseName, - _timeInQueue - ]; - 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 = []; - { - _x params ["_player", "_baseName", "_timeFiled"]; // _unitArr = [unit, baseName, timeInQueue] - private _nearestDistance = 99999; - { - private _baseLocation = _x; - private _distanceFromBase = _player distance _baseLocation; - if (_distanceFromBase < _nearestDistance) then { - _nearestDistance = _distanceFromBase; - }; - } forEach milsim_respawn_bases; - - private _nearBase = _nearestDistance < milsim_respawn_setting_reinsertion_maxRangeToReady; - - if (_nearBase && alive _player) then { - _stillValid pushBackUnique _x; - } else { - diag_log text format [ - "[milsim] (respawn_reinsertion) REMOVED AUTOMATICALLY name=%1 playerUID=%2 group=%3 filedAtBase=%4 nearestBaseDistance=%5m inQueue=%6s", - name _player, - getPlayerUID _player, - groupId (group _player), - _baseName, - _nearestDistance, - diag_tickTime - _timeFiled - ]; - }; - } 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; - private _playerLines = [["Players are still waiting for Re-insert!"]]; - { - private _timeInQueue = diag_tickTime - (_x#2); - private _groupId = groupID (group (_x#0)); - _playerLines pushBack ([format [ - "%1: %2 [%3]", - _groupId, - name (_x#0), - [_timeInQueue, "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]; - - milsim_respawn_reinsertionOverTimeoutLastNotificationTime = diag_tickTime; - - diag_log text format [ - "[milsim] (respawn_reinsertion) PLAYERS WAITING LONGER THAN %1s: %2", - _timeout, - _timeoutPlayers apply { - format[ - "%1: %2 [%3]", - groupId (group (_x#0)), - name (_x#0), - diag_tickTime - (_x#2) - ] - } - ]; - - }; - }; - }, 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"]; - private _closestBase = [milsim_respawn_bases, _player] call BIS_fnc_nearestPosition; - private _closestBaseName = _closestBase getVariable ["name", ""]; - if (_closestBaseName == "") then {_closestBaseName = format["near %1", text (nearestLocation [_closestBase, ""])]}; - ["milsim_respawn_fileReinsertRequest", [_player, _closestBaseName, diag_tickTime]] call CBA_fnc_serverEvent; - [["Re-insert Request Filed"], [format["Pickup at %1", _closestBaseName]]] call CBA_fnc_notify; - }, - { - params ["_target", "_player", "_params"]; - private _closestBase = [milsim_respawn_bases, _player] call BIS_fnc_nearestPosition; - - missionNamespace getVariable ["milsim_respawn_setting_reinsertion_enabled", true] && - (_player distance _closestBase < milsim_respawn_setting_reinsertion_maxRangeToReady) && - not (_player in ((missionNamespace getVariable ["milsim_respawn_reinsertionQueue", []]) 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"]; - ["milsim_respawn_removeReinsertRequest", [_player]] call CBA_fnc_serverEvent; - "Re-insert Request Rescinded" call CBA_fnc_notify; - }, - { - params ["_target", "_player", "_params"]; - - missionNamespace getVariable ["milsim_respawn_setting_reinsertion_enabled", true] && - (_player in ((missionNamespace getVariable ["milsim_respawn_reinsertionQueue", []]) 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..2f22ebf 100644 --- a/functions/settings/fn_addCBASettings.sqf +++ b/functions/settings/fn_addCBASettings.sqf @@ -128,7 +128,7 @@ //--------------------- // Respawn Settings [ - "milsim_respawn_setting_reinsertion_enabled", // variable + "milsim_reinsert_setting_reinsertion_enabled", // variable "CHECKBOX", // type ["Enabled", "Whether or not players can file for reinsert and pilots can check the reinsert queue"], // title ["17th Battalion", "Re-insert Queue"], // category @@ -136,12 +136,22 @@ true, // global setting { params ["_value"]; - diag_log format["[milsim] (respawn_reinsertion) enabled set to %1", _value]; + [ + "respawn_reinsertion", + "SETTING CHANGED", + [ + [ + "setting", + "milsim_reinsert_setting_reinsertion_enabled" + ], + ["newValue", _value] + ] + ] call milsim_fnc_log; } ] call CBA_fnc_addSetting; [ - "milsim_respawn_setting_reinsertion_maxRangeToReady", // variable + "milsim_reinsert_setting_reinsertion_maxRangeToReady", // variable "SLIDER", // type ["Max Request Filing Range", "Maximum distance from a respawn point a player can be to ready up"], // title ["17th Battalion", "Re-insert Queue"], // category @@ -149,12 +159,22 @@ true, // global setting { params ["_value"]; - diag_log format["[milsim] (respawn_reinsertion) maxRangeToReady set to %1", _value]; + [ + "respawn_reinsertion", + "SETTING CHANGED", + [ + [ + "setting", + "milsim_reinsert_setting_reinsertion_maxRangeToReady" + ], + ["newValue", _value] + ] + ] call milsim_fnc_log; } ] call CBA_fnc_addSetting; [ - "milsim_respawn_setting_reinsertion_pilotForcedCheckEnabled", // variable + "milsim_reinsert_setting_reinsertion_pilotForcedCheckEnabled", // variable "CHECKBOX", // type ["Enabled", "Whether or not pilots are forced to view the contents of the reinsertion queue per interval"], // title ["17th Battalion", "Re-insert Queue"], // category @@ -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_reinsert_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 + "milsim_reinsert_setting_reinsertion_pilotForcedCheckInterval", // variable + "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_reinsert_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_reinsert_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_reinsert_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