Merge pull request 'reinsert-requests' (#14) from reinsert-requests into main

Reviewed-on: https://17th-gs.iceberg-gaming.com:5443/hizumi/MissionTemplate/pulls/14

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 {};
 	};
 };

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];
+

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];

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;
+};
+/////////////////////////////////////////////////////

functions/reinsert/client/fn_requestShowQueue.sqf

@@ -0,0 +1,3 @@
+if (!hasInterface) exitWith {};
+
+[] remoteExec ["milsim_reinsert_fnc_returnReinsertQueueNotification", 2];

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;

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;

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;

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;
+};

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;
+

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;

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;

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";

functions/respawn/fn_init.sqf

@@ -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;
-	};
-	/////////////////////////////////////////////////////
-};

functions/respawn/fn_showReinsertQueueNotification.sqf

@@ -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;

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;
 

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;

functions/util/fn_getPlayerLogString.sqf

@@ -8,10 +8,35 @@
 
 	Parameters:
 		0: _playerObj <OBJECT> - The player object to get the string for.
+		1: _returnArray <BOOL> - 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)];
+

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;