Merge pull request 'misc-improvements' (#23) from misc-improvements into develop

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

CHANGELOG.md

@@ -4,6 +4,51 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project badly attempts [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.2] - 2024-02-01
+
+### Added
+
+- Custom logging function to allow for external scripts to parse framework messages
+- Transport request system for respawned players
+- CBA settings for transport request enable/disable and timeout durations
+- Added zeus mortar resupply boxes
+- Added battalion layout definition file for use in FBCB2 system
+
+### Changed
+
+- Update fixed wing asset class type
+- Update contents of zeus resupply boxes
+- Update player inventory check functions
+- Update FBCB2 callsign and radio frequency pages
+
+## [3.1.3] - 2024-01-10
+
+### Changed
+- Merge triage-status-draw3d to fix draw overlay for medics
+
+## [3.1.2] - 2024-01-04
+
+### Added
+- Add forgotten code file file for medical overlay
+
+### Changed
+- Merge update-flag-exclusions branch to fix issues with vehicles not applying flag
+
+## [3.1.1] - 2024-01-04
+
+### Changed
+- Spelling Fixes
+- Update class binding for vehicle flag interaction
+
+## [3.1.0] - 2023-12-17
+
+### Added
+
+- Vehicles now have an ace interaction to allow the mounting of flags onto them for identification. Contributed by IndigoFox
+- Added inventory validation checks
+- Added empty group removal code due to ownership issues on entity transfers
+- Added medical card visibility to medics for triage purposes
+
 ## [3.0.2] - 2023-10-14
 
 ### Changed

README.md

@@ -1,21 +1,27 @@
 # Installation Instructions
 
-Once your mission has been created and saved in the Arma 3 Eden Editor, download the latest mission template zip and copy its contents to the folder where your mission file lives.
+The only file which should be pre-existing in your mission folder is `mission.sqm`, once freshly saved from Arma 3's EDEN Editor.
 
-The only file which should be pre-existing in your mission folder is `mission.sqm`
+Download the latest mission template zip from the [latest release](https://17th-gs.iceberg-gaming.com:5443/hizumi/MissionTemplate/releases/latest) and copy its contents to the folder where your mission file lives.
 
 Once copied, the final structure should appear similar to the following:
 ```markdown
-├── functions/
+├── aaFrameworkUtils/
+├── defines/
+├── framework/
 ├── images/
 ├── scripts/
 ├── sounds/
+├── textures/
+├── CHANGELOG.md
 ├── description.ext
+├── mission_settings.hpp
 ├── mission.jpg
 ├── mission.sqm
-├── mission_settings.hpp
 ```
 
+If you're building a mission for use in an op, please delete "aaFrameworkUtils" and "framework\x". These are for the purposes of development and add bloat to the mission download when players connect to your mission.
+
 After the requisite configuration file edits have been made, your mission is ready to be packed into a pbo for deployment.
 
 # Files
@@ -52,3 +58,60 @@ This directory is for organizational purposes for any custom scripts you wish to
 
 This directory is for organizational purposes for any custom scripts you wish to use in your mission.
 > **Note:** Using custom sounds require adding the proper CfgSounds codeblock into mission_settings.hpp
+
+## textures/
+
+This directory is for organizational purposes for textures files used by mission scripts.
+
+## DEV NOTES
+
+All modules are broken apart as such in /framework. Client and server inits are managed in /framework/init.
+
+Pay attention to framework/script_mod.hpp prior to deployment of releases, as the debug settings within will determine what is logged during prod missions.
+
+CfgFunctions is sensitive to the folder/script_component.hpp of each module.
+
+### `defines` Directory
+
+This directory contains a number of hpp files used to define constants throughout the framework. These should ONLY be edited by or with the supervision of a developer to reflect format battalion-wide changes.
+
+- `ApprovedAssets.hpp`: Contains subclasses for approved aerial assets with their assigned callsigns. Used primarily in `fbcb2_assets`.
+- `BattalionInfo.hpp`: Used for representing Battalion structure, element callsigns, and radio frequency assignments. Used primarily in `fbcb2_main`.
+- `DisallowedEquipment.hpp`: Contains flagged item classnames by category that players may not use, or may use only in specific roles. Used to monitor and enforce equipment restrictions.
+- `SignalColors.hpp`: Contains smoke/flare/chemlight colors and what they represent in the field. Used primarily in `fbcb2_main` for the Signal Colors diary record.
+- `SupplyCrates.hpp`: Contains the types, contents, and metadata for all supply crate types in the `resupply` module.
+- `VehicleFlags.hpp`: Defines system information, flag categories, and flag options used to populate ACE3 interaction menus for vehicles. Used by the `vehicleFlags` module.
+
+
+### Modules List
+
+*Within `framework`:*
+
+- `ambience`:
+  - Adds ambient flak capabilities.
+- `client`:
+  - Contains core client-side event handlers and actions that don't fit into other modules.
+- `common`:
+  - Contains common functions and variables used by multiple modules.
+- `fbcb2_main`:
+  - Contains the main FBCB2 functionality and initialization code. Populates the briefing/diary with mission information.
+- `fbcb2_assets`:
+  - A subcomponent of `fbcb2_main`. Used to gather, display, and manage diary records as intel for assets near known bases.
+- `init`:
+  - Contains core initialization functions. Both server and client inits across all modules are managed here.
+- `mapcopy`:
+  - Gives players the ability to copy each other's maps.
+- `performance`:
+  - Contains functionality for monitoring and logging performance data.
+- `reinsert`:
+  - Provides a reinsertion queue system for players and pilots to maximize efficiency of the reinsertion process.
+- `resupply`:
+  - Provides a Zeus module and standalone function to spawn pre-equipped supply crates onto the battlefield.
+  - Supply crate definitions are stored in `defines/SupplyCrates.hpp`.
+  - Optionally, allows players to spawn supply crates from arsenal boxes.
+- `triageIcons`:
+  - For those with medical permissions (`ace_medical`), provides a configurable 3D icon over unconscious units indicating their current ACE Triage Card status.
+- `vehicleFlags`:
+  - Provides an ACE3 interaction menu that allows players to attach and remove flags from vehicles.
+  - Flags are defined in `defines/VehicleFlags.hpp`.
+

aaFrameworkUtils/getSupplyCratesFromCfg.sqf

@@ -0,0 +1,35 @@
+private _supplyCratesCfg = call milsim_resupply_fnc_getSupplyCratesCfg; 
+ 
+private _properties = []; 
+{ 
+	_properties append ((configProperties [_x]) apply {configName _x}); 
+} forEach (_supplyCratesCfg call BIS_fnc_returnChildren);
+
+_properties = _properties arrayIntersect _properties;
+
+private _cfgVals = [];
+{
+	private _cfg = _x;
+	private _cfgName = configName _x;
+	_vals = createHashMap;
+
+	{
+		_vals set [_x, (_cfg >> _x) call BIS_fnc_getCfgData];
+	} forEach _properties;
+
+	{
+		private _arr = _vals get _x;
+		private _newArr = [];
+		{
+			_x params ["_class", "_count"];
+			private _cfg = _class call CBA_fnc_getItemConfig;
+			private _name = [_cfg] call BIS_fnc_displayName;
+			_newArr pushBack [_class, _name, _count];
+		} forEach _arr;
+		_vals set [_x, _newArr];
+	} forEach ["backpacks", "weapons", "items", "magazines"];
+
+	_cfgVals pushBack [_cfgName, _vals];
+} forEach (_supplyCratesCfg call BIS_fnc_returnChildren);
+
+text ([createHashMapFromArray _cfgVals] call CBA_fnc_encodeJSON);

aaFrameworkUtils/parseSupplyCratesJSONToCSV.py

@@ -0,0 +1,37 @@
+import sys
+import json
+import csv
+
+
+def parseSupplyCratesJSONToCSV(jsonFile, csvFile):
+    with open(jsonFile, 'r') as file:
+        supply_boxes = json.load(file)
+
+    headers = ["box_config_name", "box_friendly_name", "box_class", "box_tooltip", "category", "item_class", "item_name", "quantity"]
+    all_rows = []
+    for supply_box_name in supply_boxes.keys():
+        supply_box_data = supply_boxes[supply_box_name]
+
+        display_name = supply_box_data['displayName']
+        tooltip = supply_box_data['tooltip']
+        box_class = supply_box_data['boxClass']
+        for category in ["items", "backpacks", "weapons", "magazines"]:
+            for item in supply_box_data[category]:
+                item_class = item[0]
+                item_name = item[1]
+                item_quantity = item[2]
+                row = [supply_box_name, display_name, box_class, tooltip, category, item_class, item_name, item_quantity]
+                all_rows.append(row)
+
+
+    with open(csvFile, 'w', newline='', encoding='utf-8') as file:
+        writer = csv.writer(file)
+        writer.writerow(headers)
+        writer.writerows(all_rows)
+
+if __name__ == "__main__":
+    jsonFile = sys.argv[1]
+    csvFile = sys.argv[2]
+    parseSupplyCratesJSONToCSV(jsonFile, csvFile)
+    print(f"Done! {csvFile} created.")
+        

aaFrameworkUtils/test.csv

@@ -0,0 +1,84 @@
+box_config_name,box_friendly_name,box_class,box_tooltip,category,item_class,item_name,quantity
+CrewServedWeapons,CSW Crate,Box_NATO_Equip_F,A crate containing backpacks that assemble into static weapons.,backpacks,RHS_M2_Gun_Bag,M2 Gun Bag,2
+CrewServedWeapons,CSW Crate,Box_NATO_Equip_F,A crate containing backpacks that assemble into static weapons.,backpacks,RHS_M2_Tripod_Bag,M2 Tripod Bag,2
+CrewServedWeapons,CSW Crate,Box_NATO_Equip_F,A crate containing backpacks that assemble into static weapons.,backpacks,RHS_M2_MiniTripod_Bag,M3 Minitripod Bag,2
+CrewServedWeapons,CSW Crate,Box_NATO_Equip_F,A crate containing backpacks that assemble into static weapons.,backpacks,rhs_Tow_Gun_Bag,TOW Gun Bag,2
+CrewServedWeapons,CSW Crate,Box_NATO_Equip_F,A crate containing backpacks that assemble into static weapons.,backpacks,rhs_TOW_Tripod_Bag,TOW Tripod Bag,2
+CrewServedWeapons,CSW Crate,Box_NATO_Equip_F,A crate containing backpacks that assemble into static weapons.,backpacks,UK3CB_Static_M240_Elcan_Gun_Bag,M240 w/Elcan Gun Bag,2
+CrewServedWeapons,CSW Crate,Box_NATO_Equip_F,A crate containing backpacks that assemble into static weapons.,backpacks,UK3CB_B_Static_M240_Elcan_Tripod_Low_Bag_US_D,M240 w/Elcan Tripod Bag (Low),2
+CrewServedWeapons,CSW Crate,Box_NATO_Equip_F,A crate containing backpacks that assemble into static weapons.,backpacks,RHS_Mk19_Gun_Bag,Mk19 Gun Bag,2
+CrewServedWeapons,CSW Crate,Box_NATO_Equip_F,A crate containing backpacks that assemble into static weapons.,backpacks,RHS_Mk19_Tripod_Bag,Mk19 Tripod Bag,2
+MortarMk6Resupply,Mortar MK6 Supply Crate,Box_NATO_WpsSpecial_F,A crate containing Mk6 mortar resupply (tubes) and tools.,items,ACE_artilleryTable,Artillery Rangetable,2
+MortarMk6Resupply,Mortar MK6 Supply Crate,Box_NATO_WpsSpecial_F,A crate containing Mk6 mortar resupply (tubes) and tools.,items,ACE_RangeTable_82mm,82mm Rangetable,2
+MortarMk6Resupply,Mortar MK6 Supply Crate,Box_NATO_WpsSpecial_F,A crate containing Mk6 mortar resupply (tubes) and tools.,items,ACE_microDAGR,MicroDAGR GPS,2
+MortarMk6Resupply,Mortar MK6 Supply Crate,Box_NATO_WpsSpecial_F,A crate containing Mk6 mortar resupply (tubes) and tools.,items,ACE_MapTools,Map Tools,2
+MortarMk6Resupply,Mortar MK6 Supply Crate,Box_NATO_WpsSpecial_F,A crate containing Mk6 mortar resupply (tubes) and tools.,backpacks,B_Mortar_01_support_F,Folded Mk6 Mortar Bipod [NATO],3
+MortarMk6Resupply,Mortar MK6 Supply Crate,Box_NATO_WpsSpecial_F,A crate containing Mk6 mortar resupply (tubes) and tools.,backpacks,B_Mortar_01_weapon_F,Folded Mk6 Mortar Tube [NATO],6
+MortarMk6Resupply,Mortar MK6 Supply Crate,Box_NATO_WpsSpecial_F,A crate containing Mk6 mortar resupply (tubes) and tools.,backpacks,UK3CB_LSM_B_B_CARRYALL_RADIO_TIG_STRIPE_01,Carryall Backpack RT1523g (Tiger Stripe 01),1
+MortarMk6Resupply,Mortar MK6 Supply Crate,Box_NATO_WpsSpecial_F,A crate containing Mk6 mortar resupply (tubes) and tools.,weapons,ACE_Vector,Vector 21 Nite,2
+MortarMk6Resupply,Mortar MK6 Supply Crate,Box_NATO_WpsSpecial_F,A crate containing Mk6 mortar resupply (tubes) and tools.,magazines,acex_intelitems_notepad,Notepad,2
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,weapons,rhs_weap_M136,M136 (HEAT),4
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,weapons,rhs_weap_M136_hp,M136 (HP),4
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,weapons,rhs_weap_m72a7,M72A7,2
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,magazines,1Rnd_SmokePurple_Grenade_shell,Smoke Round (Purple),12
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,magazines,1Rnd_SmokeBlue_Grenade_shell,Smoke Round (Blue),24
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,magazines,1Rnd_SmokeOrange_Grenade_shell,Smoke Round (Orange),12
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,magazines,rhs_mag_M441_HE,M441 HE Grenade Round,25
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,magazines,rhs_mag_M433_HEDP,M433 HEDP Grenade Round,15
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,magazines,ACE_40mm_Flare_ir,M992 Illumination Flare (IR),12
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,magazines,rhsusf_200Rnd_556x45_mixed_soft_pouch_coyote,200rnd M249 Softpack M855A1 (Mixed),25
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,magazines,rhsusf_20Rnd_762x51_m993_Mag,20rnd M14 M993 AP,25
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,magazines,SmokeShell,M83 Smoke Grenade (White),12
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,magazines,rhs_mag_m67,M67 Fragmentation Grenade,12
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,magazines,1Rnd_Smoke_Grenade_shell,Smoke Round (White),24
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,magazines,1Rnd_SmokeRed_Grenade_shell,Smoke Round (Red),24
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,magazines,1Rnd_SmokeGreen_Grenade_shell,Smoke Round (Green),24
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,magazines,1Rnd_SmokeYellow_Grenade_shell,Smoke Round (Yellow),12
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,magazines,Tier1_30Rnd_556x45_M856A1_EMag,30rnd EMAG M856A1 (Tracer),25
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,magazines,Tier1_30Rnd_556x45_Mk318Mod0_EMag,30rnd EMAG Mk318 Mod 0,75
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,magazines,ACE_30Rnd_65_Creedmor_mag,6.5 mm Creedmor 30Rnd Sand Mag,25
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,magazines,SMA_30Rnd_762x35_BLK_EPR,30 Round .300 Blackout EPR,25
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,magazines,Tier1_30Rnd_762x35_300BLK_SMK_PMAG,30rnd PMAG .300 Custom Combat TAC-TX,25
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,magazines,SMA_30Rnd_68x43_SPC_FMJ,SPC FMJ 6.8x43 30rnd Mag,25
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,magazines,SMA_30Rnd_68x43_SPC_FMJ_Tracer,SPC FMJ 6.8x43 30rnd Tracer Mag,25
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,magazines,SMA_20Rnd_762x51mm_M80A1_EPR,M80A1 EPR 762x51mm 20rnd Mag,25
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,magazines,SMA_20Rnd_762x51mm_M80A1_EPR_Tracer,M80A1 EPR 762x51mm 20rnd Tracer Mag,25
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,magazines,SMA_20Rnd_762x51mm_Mk316_Mod_0_Special_Long_Range,Mk316 Mod 0 762x51mm SBLR 20rnd Mag,25
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,magazines,SMA_20Rnd_762x51mm_Mk316_Mod_0_Special_Long_Range_Tracer,Mk316 Mod 0 762x51mm SBLR 20rnd Tracer Mag,25
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,magazines,Tier1_250Rnd_762x51_Belt_M993_AP,250rnd Ammo Belt M993 AP,15
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,magazines,ACE_20Rnd_762x51_Mag_Tracer,7.62 mm 20Rnd Mag (Tracer),25
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,magazines,ACE_20Rnd_762x51_M993_AP_Mag,7.62 mm 20Rnd Mag (M993 AP),25
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,magazines,rhsusf_20Rnd_762x51_SR25_m993_Mag,20rnd SR-25 M993 AP,25
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,magazines,Tier1_20Rnd_762x51_M993_SR25_Mag,20rnd SR-25/M110 M993 AP,25
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,magazines,Tier1_20Rnd_65x48_Creedmoor_SR25_Mag,20rnd SR-25/M110 6.5mm Creedmoor,25
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,magazines,rhssaf_30rnd_556x45_EPR_G36,30rnd G36 M855A1,25
+AmmoSquad,Squad Ammo,Box_Syndicate_Ammo_F,A crate containing general ammunition and equipment for an infantry squad.,magazines,DemoCharge_Remote_Mag,M112 Demolition Block,16
+AmmoHeavy,Heavy Ammo,Box_NATO_Wps_F,"A crate containing mixed ammo for rifles, ARs, MAT, and HAT.",magazines,MRAWS_HEAT_F,MAAWS HEAT 75 Round,35
+AmmoHeavy,Heavy Ammo,Box_NATO_Wps_F,"A crate containing mixed ammo for rifles, ARs, MAT, and HAT.",magazines,MRAWS_HE_F,MAAWS HE 44 Round,15
+AmmoHeavy,Heavy Ammo,Box_NATO_Wps_F,"A crate containing mixed ammo for rifles, ARs, MAT, and HAT.",magazines,Tier1_250Rnd_762x51_Belt_M993_AP,250rnd Ammo Belt M993 AP,50
+AmmoHeavy,Heavy Ammo,Box_NATO_Wps_F,"A crate containing mixed ammo for rifles, ARs, MAT, and HAT.",magazines,Tier1_30Rnd_556x45_M856A1_EMag,30rnd EMAG M856A1 (Tracer),25
+AmmoHeavy,Heavy Ammo,Box_NATO_Wps_F,"A crate containing mixed ammo for rifles, ARs, MAT, and HAT.",magazines,Tier1_30Rnd_556x45_Mk318Mod0_EMag,30rnd EMAG Mk318 Mod 0,50
+AmmoHeavy,Heavy Ammo,Box_NATO_Wps_F,"A crate containing mixed ammo for rifles, ARs, MAT, and HAT.",magazines,Titan_AA,Titan AA Missile,10
+AmmoHeavy,Heavy Ammo,Box_NATO_Wps_F,"A crate containing mixed ammo for rifles, ARs, MAT, and HAT.",magazines,Titan_AT,Titan AT Missile,10
+AmmoHeavy,Heavy Ammo,Box_NATO_Wps_F,"A crate containing mixed ammo for rifles, ARs, MAT, and HAT.",magazines,200Rnd_65x39_cased_Box_Tracer_Red,6.5mm 200Rnd Belt Tracer (Red),50
+Launchers,Launcher Crate,Box_NATO_WpsLaunch_F,A crate containing missile launchers and ammunition.,weapons,launch_B_Titan_short_F,Titan MPRL Compact (Sand),2
+Launchers,Launcher Crate,Box_NATO_WpsLaunch_F,A crate containing missile launchers and ammunition.,weapons,launch_NLAW_F,NLAW,2
+Launchers,Launcher Crate,Box_NATO_WpsLaunch_F,A crate containing missile launchers and ammunition.,weapons,rhs_weap_fim92,FIM-92F,2
+Launchers,Launcher Crate,Box_NATO_WpsLaunch_F,A crate containing missile launchers and ammunition.,magazines,Titan_AA,Titan AA Missile,6
+Launchers,Launcher Crate,Box_NATO_WpsLaunch_F,A crate containing missile launchers and ammunition.,magazines,Titan_AT,Titan AT Missile,6
+Mortar60mmCommandoResupply,Mortar 60mm Commando Supply Crate,Box_NATO_WpsSpecial_F,A crate containing COMMANDO 60mm mortar shells and some STANAGs.,magazines,twc_2inch_he_1rnd,60mm COMMANDO 1Rnd HE,70
+Mortar60mmCommandoResupply,Mortar 60mm Commando Supply Crate,Box_NATO_WpsSpecial_F,A crate containing COMMANDO 60mm mortar shells and some STANAGs.,magazines,twc_2inch_smoke_1rnd,60mm COMMANDO 1Rnd Smoke,15
+Mortar60mmCommandoResupply,Mortar 60mm Commando Supply Crate,Box_NATO_WpsSpecial_F,A crate containing COMMANDO 60mm mortar shells and some STANAGs.,magazines,twc_2inch_illum_1rnd,60mm COMMANDO 1Rnd Illum,15
+Mortar60mmCommandoResupply,Mortar 60mm Commando Supply Crate,Box_NATO_WpsSpecial_F,A crate containing COMMANDO 60mm mortar shells and some STANAGs.,magazines,Tier1_30Rnd_556x45_Mk318Mod0_EMag,30rnd EMAG Mk318 Mod 0,20
+MedicalSupplies,Medical Crate,ACE_medicalSupplyCrate_advanced,A crate containing medical supplies.,items,ACE_packingBandage,Bandage (Packing),100
+MedicalSupplies,Medical Crate,ACE_medicalSupplyCrate_advanced,A crate containing medical supplies.,items,ACE_elasticBandage,Bandage (Elastic),100
+MedicalSupplies,Medical Crate,ACE_medicalSupplyCrate_advanced,A crate containing medical supplies.,items,ACE_tourniquet,Tourniquet (CAT),48
+MedicalSupplies,Medical Crate,ACE_medicalSupplyCrate_advanced,A crate containing medical supplies.,items,ACE_splint,Splint,48
+MedicalSupplies,Medical Crate,ACE_medicalSupplyCrate_advanced,A crate containing medical supplies.,items,ACE_morphine,Morphine Autoinjector,50
+MedicalSupplies,Medical Crate,ACE_medicalSupplyCrate_advanced,A crate containing medical supplies.,items,ACE_epinephrine,Epinephrine Autoinjector,50
+MedicalSupplies,Medical Crate,ACE_medicalSupplyCrate_advanced,A crate containing medical supplies.,items,ACE_bloodIV,Blood IV (1000ml),75
+MedicalSupplies,Medical Crate,ACE_medicalSupplyCrate_advanced,A crate containing medical supplies.,items,ACE_bloodIV_500,Blood IV (500ml),50
+MedicalSupplies,Medical Crate,ACE_medicalSupplyCrate_advanced,A crate containing medical supplies.,items,ACE_bloodIV_250,Blood IV (250ml),25
+MedicalSupplies,Medical Crate,ACE_medicalSupplyCrate_advanced,A crate containing medical supplies.,items,ACE_quikclot,Bandage (QuikClot),75
+MedicalSupplies,Medical Crate,ACE_medicalSupplyCrate_advanced,A crate containing medical supplies.,items,ACE_personalAidKit,Personal Aid Kit,5
+MedicalSupplies,Medical Crate,ACE_medicalSupplyCrate_advanced,A crate containing medical supplies.,items,ACE_surgicalKit,Surgical Kit,5

defines/ApprovedAssets.hpp

@@ -0,0 +1,22 @@
+// Lists approved fixed-wing and rotary vehicle types that mission makers can use in their missions.
+
+class ApprovedAssets {
+	// Fixed-wing aircraft
+	class USAF_A10 {callsign = "Ares";};
+	class RHSGREF_A29B_HIDF {callsign = "Odyssey";};
+	class USAF_C130J {callsign = "Hercules";};
+	// Rotary aircraft
+	class RHS_MELB_MH6M {callsign = "Apollo";};
+	class RHS_MELB_AH6M {callsign = "Artemis";};
+	class RHS_MELB_H6M {callsign = "Icarus";};
+	class RHS_CH_47F {callsign = "Achilles";};
+	class ej_MH60MDAP4 {callsign = "Hades";};
+	class RHS_UH60M {callsign = "Griffin";};
+	class RHS_UH60M_MEV2 {callsign = "Dustoff";};
+	class B_T_VTOL_01_INFANTRY_F {callsign = "Pegasus";};
+	class B_T_VTOL_01_ARMED_F {callsign = "Spartan";};
+	class RHS_AH64D {callsign = "Orion";};
+	class RHS_AH1Z {callsign = "Athena";};
+	class RHS_UH1Y {callsign = "Homer";};
+	class rhsusf_CH53E_USMC {callsign = "Atlas";};
+};

defines/BattalionInfo.hpp

@@ -0,0 +1,253 @@
+// BattalionInfo.hpp
+// Defines the structure of the Battalion, allowing properties to be easily changed and updated
+// This file is included in description.ext
+
+
+// Define the callsigns for the Battalion
+#define COMMAND_CALLSIGN SPARTAN
+#define RRC_CALLSIGN TIGER
+#define MEDIC_CALLSIGN LIFELINE
+#define ALPHA_CALLSIGN BLACKJACK
+#define ECHO_CALLSIGN FIREBRAND
+#define WPN_CALLSIGN BLACKFOOT
+
+// Define the frequencies for the Battalion
+#define FREQ_BATTALION 45
+#define FREQ_BATTALION_MEDICAL_INTERCOM 91.1
+#define FREQ_ALL_MEDICAL_SR 121.5
+
+#define FREQ_ALPHA_COMPANY 40
+
+#define FREQ_PLATOON1_SR 100
+#define FREQ_PLATOON1_LR 41
+#define FREQ_PLATOON1_RTO 101
+
+#define FREQ_PLATOON2_SR 200
+#define FREQ_PLATOON2_LR 42
+#define FREQ_PLATOON2_RTO 201
+
+#define FREQ_ECHO_FLIGHT_INTERCOM 30
+#define FREQ_ECHO_FLIGHT_CAS 35
+#define FREQ_ECHO_FLIGHT_LOGISTICS 35.1
+
+#define FREQ_ECHO_GROUND 80
+#define FREQ_ECHO_GROUND_LOGISTICS 81
+#define FREQ_ECHO_ARTY 82
+#define FREQ_ECHO_ARTY_INTERCOM 155
+
+#define FREQ_CONVOY 50
+
+// Define the text colors to appear in diary entries
+#define LVL1_TEXT_COLOR "#7c887e"
+#define LVL2_TEXT_COLOR "#bab79f"
+#define LVL3_TEXT_COLOR "#91967f"
+#define LVL4_TEXT_COLOR "#d3d2cd"
+
+
+// All elements and subclasses should have the following properties:
+// callsign: the callsign of the element
+// textColor: the color of the text for the element
+// frequencies: an array of frequencies for the element in the format:
+// 		{roleWithinElement, {primarySR, additionalSR}, {primaryLR, additionalLR}}
+
+// Battalion-level elements under Command should have the following additional properties:
+// shortDescription: a short description of the element's place in the Battalion
+
+
+// System macros
+#define CALLSIGN_ELEMENT(callsign,element) callsign##element
+
+
+
+class BattalionInfo {
+	class Command {
+		callsign = COMMAND_CALLSIGN;
+		shortDescription = "Battalion Command";
+		textColor = LVL1_TEXT_COLOR;
+		// frequencies are in format:
+		// {roleWithinElement, {primarySR, additionalSR}, {primaryLR, additionalLR}}
+		frequencies[] = {
+			{"Contact", {}, {FREQ_BATTALION}},
+			{"Actual", {}, {FREQ_BATTALION}},
+			{"Romeo", {}, {FREQ_BATTALION, FREQ_ECHO_FLIGHT_CAS}}
+		};
+
+
+		class RRC { // WIP
+			callsign = RRC_CALLSIGN;
+			shortDescription = "RRC";
+			textColor = LVL2_TEXT_COLOR;
+			frequencies[] = {
+				{"Contact", {}, {FREQ_BATTALION}},
+				{"Actual", {}, {FREQ_BATTALION, FREQ_ECHO_FLIGHT_CAS}}
+			};
+		};
+
+		class BattalionMedical { // WIP
+			callsign = MEDIC_CALLSIGN;
+			shortDescription = "Battalion Medical";
+			textColor = LVL2_TEXT_COLOR;
+			frequencies[] = {
+				{"Contact", {FREQ_ALL_MEDICAL_SR}, {FREQ_BATTALION}},
+				{"Actual", {FREQ_BATTALION_MEDICAL_INTERCOM, FREQ_ALL_MEDICAL_SR}, {FREQ_BATTALION, FREQ_ECHO_FLIGHT_LOGISTICS}},
+				{"General", {FREQ_BATTALION_MEDICAL_INTERCOM, FREQ_ALL_MEDICAL_SR}, {}}
+			};
+		};
+
+		class WeaponsSquad { // WIP
+			callsign = WPN_CALLSIGN;
+			shortDescription = "Special Weapons Squad";
+			textColor = LVL2_TEXT_COLOR;
+			frequencies[] = {
+				{"Contact", {}, {FREQ_BATTALION}}
+			};
+		};
+
+			
+		class AlphaCompany {
+			callsign = ALPHA_CALLSIGN;
+			shortDescription = "Alpha Company";
+			textColor = LVL2_TEXT_COLOR;
+			frequencies[] = {
+				{"Contact", {}, {FREQ_ALPHA_COMPANY, FREQ_BATTALION}}
+			};
+
+			class Platoon1 {
+				callsign = CALLSIGN_ELEMENT(ALPHA_CALLSIGN, 1-6);
+				textColor = LVL3_TEXT_COLOR;
+				frequencies[] = {
+					{"Actual", {FREQ_PLATOON1_SR, FREQ_PLATOON1_RTO}, {FREQ_PLATOON1_LR, FREQ_ALPHA_COMPANY}},
+					{"Romeo", {}, {FREQ_BATTALION, FREQ_ECHO_FLIGHT_CAS, FREQ_ECHO_FLIGHT_LOGISTICS}}
+				};
+				class Squad1 {
+					callsign = CALLSIGN_ELEMENT(ALPHA_CALLSIGN, 1-1);
+					textColor = LVL4_TEXT_COLOR;
+					frequencies[] = {
+						{"Actual", {110, FREQ_PLATOON1_SR}, {FREQ_PLATOON1_LR}},
+						{"Alpha Team", {111, 110}, {}},
+						{"Bravo Team", {112, 110}, {}},
+						{"Medic", {110, FREQ_ALL_MEDICAL_SR}, {}}
+					};
+				};
+				class Squad2 {
+					callsign = CALLSIGN_ELEMENT(ALPHA_CALLSIGN, 1-2);
+					textColor = LVL4_TEXT_COLOR;
+					frequencies[] = {
+						{"Actual", {120, FREQ_PLATOON1_SR}, {FREQ_PLATOON1_LR}},
+						{"Alpha Team", {121, 120}, {}},
+						{"Bravo Team", {122, 120}, {}},
+						{"Medic", {120, FREQ_ALL_MEDICAL_SR}, {}}
+					};
+				};
+				class Squad3 {
+					callsign = CALLSIGN_ELEMENT(ALPHA_CALLSIGN, 1-3);
+					textColor = LVL4_TEXT_COLOR;
+					frequencies[] = {
+						{"Actual", {130, FREQ_PLATOON1_SR}, {FREQ_PLATOON1_LR}},
+						{"Alpha Team", {131, 130}, {}},
+						{"Bravo Team", {132, 130}, {}},
+						{"Medic", {130, FREQ_ALL_MEDICAL_SR}, {}}
+					};
+				};
+			};
+
+			class Platoon2 {
+				callsign = CALLSIGN_ELEMENT(ALPHA_CALLSIGN, 2-6);
+				textColor = LVL3_TEXT_COLOR;
+				frequencies[] = {
+					{"Actual", {FREQ_PLATOON2_SR, FREQ_PLATOON2_RTO}, {FREQ_PLATOON2_LR, FREQ_ALPHA_COMPANY}}
+				};
+				class Squad1 {
+					callsign = CALLSIGN_ELEMENT(ALPHA_CALLSIGN, 2-1);
+					textColor = LVL4_TEXT_COLOR;
+					frequencies[] = {
+						{"Actual", {210, FREQ_PLATOON2_SR}, {FREQ_PLATOON2_LR}},
+						{"Alpha Team", {211, 210}, {}},
+						{"Bravo Team", {212, 210}, {}},
+						{"Medic", {210, FREQ_ALL_MEDICAL_SR}, {}}
+					};
+				};
+				class Squad2 {
+					callsign = CALLSIGN_ELEMENT(ALPHA_CALLSIGN, 2-2);
+					textColor = LVL4_TEXT_COLOR;
+					frequencies[] = {
+						{"Actual", {220, FREQ_PLATOON2_SR}, {FREQ_PLATOON2_LR}},
+						{"Alpha Team", {221, 220}, {}},
+						{"Bravo Team", {222, 220}, {}},
+						{"Medic", {220, FREQ_ALL_MEDICAL_SR}, {}}
+					};
+				};
+				class Squad3 {
+					callsign = CALLSIGN_ELEMENT(ALPHA_CALLSIGN, 2-3);
+					textColor = LVL4_TEXT_COLOR;
+					frequencies[] = {
+						{"Actual", {230, FREQ_PLATOON2_SR}, {FREQ_PLATOON2_LR}},
+						{"Alpha Team", {231, 230}, {}},
+						{"Bravo Team", {232, 230}, {}},
+						{"Medic", {230, FREQ_ALL_MEDICAL_SR}, {}}
+					};
+				};
+			};
+		};
+
+		class EchoCompany {
+			callsign = ECHO_CALLSIGN;
+			shortDescription = "Echo Company";
+			textColor = LVL2_TEXT_COLOR;
+			frequencies[] = {
+				{"Contact", {}, {FREQ_BATTALION}},
+				{"Actual", {}, {FREQ_BATTALION}}
+			};
+
+			class Flight {
+				callsign = CALLSIGN_ELEMENT(ECHO_CALLSIGN, FLIGHT);
+				textColor = LVL3_TEXT_COLOR;
+				frequencies[] = {
+					{"Contact", {}, {FREQ_BATTALION}},
+					{"Actual", {}, {FREQ_ECHO_FLIGHT_INTERCOM, FREQ_BATTALION}},
+					{"CAS Support", {}, {FREQ_ECHO_FLIGHT_INTERCOM, FREQ_ECHO_FLIGHT_CAS}},
+					{"Logistics", {}, {FREQ_ECHO_FLIGHT_INTERCOM, FREQ_ECHO_FLIGHT_LOGISTICS}}
+				};
+			};
+
+			class Ground {
+				callsign = CALLSIGN_ELEMENT(ECHO_CALLSIGN, GROUND);
+				textColor = LVL3_TEXT_COLOR;
+				frequencies[] = {
+					{"Contact", {}, {FREQ_BATTALION}},
+					{"Actual", {}, {FREQ_ECHO_GROUND, FREQ_BATTALION}}
+				};
+
+				class Logistics {
+					callsign = CALLSIGN_ELEMENT(ECHO_CALLSIGN, LOGISTICS);
+					textColor = LVL4_TEXT_COLOR;
+					frequencies[] = {
+						{"Contact", {}, {FREQ_ECHO_GROUND}},
+						{"Actual", {}, {FREQ_ECHO_GROUND_LOGISTICS, FREQ_ECHO_GROUND}},
+						{"General", {}, {FREQ_ECHO_GROUND_LOGISTICS}},
+						{"Convoy", {}, {FREQ_CONVOY}}
+					};
+				};
+
+				class Armor {
+					callsign = CALLSIGN_ELEMENT(ECHO_CALLSIGN, ARMOR);
+					textColor = LVL4_TEXT_COLOR;
+					frequencies[] = {
+						{"Contact", {}, {FREQ_ECHO_GROUND, FREQ_ECHO_FLIGHT_CAS}},
+						{"Actual", {}, {FREQ_ECHO_GROUND}},
+						{"General", {}, {FREQ_ECHO_GROUND}},
+						{"Convoy", {}, {FREQ_CONVOY}}
+					};
+				};
+
+				class Artillery {
+					callsign = CALLSIGN_ELEMENT(ECHO_CALLSIGN, ARTILLERY);
+					textColor = LVL4_TEXT_COLOR;
+					frequencies[] = {
+						{"General", {FREQ_ECHO_ARTY_INTERCOM}, {FREQ_ECHO_GROUND, FREQ_ECHO_ARTY}}
+					};
+				};
+			};
+		};
+	};
+};

defines/DisallowedEquipment.hpp

@@ -0,0 +1,223 @@
+// To access these from SQF:
+// to get an array of STRING with each subclass name:
+// (missionConfigFile >> "DisallowedEquipment") call BIS_fnc_getCfgSubClasses
+// To access a specific class' properties:
+// (missionConfigFile >> "DisallowedEquipment" >> "blacklisted" >> "label") call BIS_fnc_getCfgData;
+// (missionConfigFile >> "DisallowedEquipment" >> "blacklisted" >> "description") call BIS_fnc_getCfgData;
+// (missionConfigFile >> "DisallowedEquipment" >> "blacklisted" >> "items") call BIS_fnc_getCfgDataArray;
+
+class DisallowedEquipment {
+	class blacklisted {
+		label = "BLACKLISTED WEAPON OR ITEM";
+		description = "Items that NO member is allowed to use.";
+		items[] = {
+			"17BN_ANPVS14", // NVG AN/PVS-14
+			"ej_PVS15D", // NVG AN/PVS-15
+			"ej_VPS15", // NVG AN/PVS-15
+			"LMG_Mk200_black_F", //Mk200 Series
+			"LMG_Mk200_F", //Mk200 Series
+			"rhs_weap_g36c", // G36 Series
+			"rhs_weap_g36kv_ag36", // G36 Series
+			"rhs_weap_g36kv", // G36 Series
+			"rhs_weap_m14_d", // M14 Series
+			"rhs_weap_m14_fiberglass", // M14 Series
+			"rhs_weap_m14_rail_d", // M14 Series
+			"rhs_weap_m14_rail_fiberglass", // M14 Series
+			"rhs_weap_m14_rail_wd", // M14 Series
+			"rhs_weap_m14_rail", // M14 Series
+			"rhs_weap_m14_ris_d", // M14 Series
+			"rhs_weap_m14_ris_fiberglass", // M14 Series
+			"rhs_weap_m14_ris_wd", // M14 Series
+			"rhs_weap_m14_ris", // M14 Series
+			"rhs_weap_m14_socom_rail", // M14 Series
+			"rhs_weap_m14_socom", // M14 Series
+			"rhs_weap_m14_wd", // M14 Series
+			"rhs_weap_m14_weap_m14ebrri", // M14 Series
+			"rhs_weap_m14", // M14 Series
+			"rhs_weap_m16a4_carryhandle_M203", // M16 Series
+			"rhs_weap_m16a4_carryhandle", // M16 Series
+			"rhs_weap_m16a4_imod_M203", // M16 Series
+			"rhs_weap_m16a4_imod", // M16 Series
+			"rhs_weap_m16a4", // M16 Series
+			"rhs_weap_m27iar_grip", // M27 Series
+			"rhs_weap_m27iar", // M27 Series
+			"rhsusf_ANPVS_14", // NVG AN/PVS-14
+			"rhsusf_ANPVS_15", // NVG AN/PVS-15
+			"SMA_ACRREM", //Remington ACR 556+6.5
+			"SMA_ACRREMAFG", //Remington ACR 556+6.5
+			"SMA_ACRREMAFGblk", //Remington ACR 556+6.5
+			"SMA_ACRREMAFGCQB",  //Remington ACR 556+6.5
+			"SMA_ACRREMAFGCQBblk", //Remington ACR 556+6.5
+			"SMA_ACRREMblk", //Remington ACR 556+6.5
+			"SMA_ACRREMCQBGL", //Remington ACR 556+6.5
+			"SMA_ACRREMGL_B", //Remington ACR 556+6.5
+			"SMA_ACRREMGL", //Remington ACR 556+6.5
+			"SMA_ACRREMMOE", //Remington ACR 556+6.5
+			"SMA_ACRREMMOEblk", //Remington ACR 556+6.5
+			"SMA_ACRREMMOECQB", //Remington ACR 556+6.5
+			"SMA_ACRREMMOECQBblk", //Remington ACR 556+6.5
+			"srifle_DMR_06_camo_F", // M14 Series
+			"srifle_DMR_06_hunter_F", // M14 Series
+			"srifle_DMR_06_olive_F", // M14 Series
+			"srifle_EBR_F", // Mk14 Series
+			"Tier1_SIG_CMX_115_Virtus_300BLK_Black", // MCX 300 Blackout
+			"Tier1_SIG_CMX_115_Virtus_300BLK_Desert", // MCX 300 Blackout
+			"Tier1_SIG_CMX_115_Virtus_300BLK_FDE", // MCX 300 Blackout
+			"Tier1_SIG_CMX_115_Virtus_300BLK", // MCX 300 Blackout
+			"UK3CB_AG36_MLIC", // G36 Series
+			"UK3CB_AG36_TAC_K", // G36 Series
+			"UK3CB_AG36A1", // G36 Series
+			"UK3CB_AG36E1", // G36 Series
+			"UK3CB_AG36V", // G36 Series
+			"UK3CB_FNFAL_FOREGRIP", // FN_FAL Series
+			"UK3CB_FNFAL_FULL_RAILS", // FN_FAL Series
+			"UK3CB_FNFAL_FULL", // FN_FAL Series
+			"UK3CB_FNFAL_OSW_GL", // FN_FAL Series
+			"UK3CB_FNFAL_OSW", // FN_FAL Series
+			"UK3CB_FNFAL_PARA_RAILS", // FN_FAL Series
+			"UK3CB_FNFAL_PARA", // FN_FAL Series
+			"UK3CB_FNFAL_STG58", // FN_FAL Series
+			"UK3CB_G36_KSK_K", // G36 Series
+			"UK3CB_G36_KSK", // G36 Series
+			"UK3CB_G36_LSW", // G36 Series
+			"UK3CB_G36_MLIC_C", // G36 Series
+			"UK3CB_G36_MLIC_K", // G36 Series
+			"UK3CB_G36_MLIC", // G36 Series
+			"UK3CB_G36_TAC_C", // G36 Series
+			"UK3CB_G36_TAC", // G36 Series
+			"UK3CB_G36A1_C", // G36 Series
+			"UK3CB_G36A1_K", // G36 Series
+			"UK3CB_G36A1", // G36 Series
+			"UK3CB_G36E1_C", // G36 Series
+			"UK3CB_G36E1_K", // G36 Series
+			"UK3CB_G36E1", // G36 Series
+			"UK3CB_G36V_C", // G36 Series
+			"UK3CB_G36V_K", // G36 Series
+			"UK3CB_G36V", // G36 Series
+			"UK3CB_M14_Railed", // M14 Series
+			"UK3CB_M14", // M14 Series
+			"UK3CB_M14DMR_BLK", // M14 Series
+			"UK3CB_M14DMR_Railed_BLK", // M14 Series
+			"UK3CB_M14DMR_Railed", // M14 Series
+			"UK3CB_M14DMR", // M14 Series
+			"UK3CB_M16_Carbine", // M16 Series
+			"UK3CB_M16A1_LSW", // M16 Series
+			"UK3CB_M16A1", // M16 Series
+			"UK3CB_M16A2_UGL", // M16 Series
+			"UK3CB_M16A2", // M16 Series
+			"UK3CB_M16A3", // M16 Series
+			"USP_PVS_14", // NVG AN/PVS-14
+			"USP_PVS_15" // NVG AN/PVS-15
+		};
+	};
+
+	class restrictedItems {
+		label = "RESTRICTED ITEM";
+		description = "Items that are allowed for specific USE Case (RRC / Marksman / etc.)";
+		items[] = {
+			"A3_GPNVG18_BLK_TI", // Thermal Quad
+			"A3_GPNVG18_REC_BLK_TI", // Thermal Quad
+			"A3_GPNVG18_REC_TI", // Thermal Quad
+			"A3_GPNVG18_TI", // Thermal Quad
+			"A3_GPNVG18b_BLK_TI", // Thermal Quad
+			"A3_GPNVG18b_REC_BLK_TI", // Thermal Quad
+			"A3_GPNVG18b_REC_TI", // Thermal Quad
+			"A3_GPNVG18b_TI", // Thermal Quad
+			"ACE_optic_LRPS_2D", //Nightforce Series Optic
+			"ACE_optic_LRPS_PIP", //Nightforce Series Optic
+			"NVGogglesB_blk_F", // ENVG
+			"NVGogglesB_grn_F", // ENVG
+			"NVGogglesB_gry_F", // ENVG
+			"optic_lrps_ghex_F", //Nightforce Series Optic
+			"optic_lrps_tna_F", //Nightforce Series Optic
+			"optic_lrps", //Nightforce Series Optic
+			"optic_Nightstalker", // Thermal Optic
+			"optic_tws_mg", // Thermal Optic
+			"optic_tws", // Thermal Optic
+			"rhsusf_acc_anpas13gv1", // Thermal Optic
+			"rhsusf_acc_anpvs27", // Thermal Optic
+			"Tier1_ANPVS10_Tan", // Thermal Optic
+			"Tier1_ATACR18_ADM_Black_Vanilla", //Nightforce Series Optic
+			"Tier1_ATACR18_ADM_Black", //Nightforce Series Optic
+			"Tier1_ATACR18_ADM_Desert_Vanilla", //Nightforce Series Optic
+			"Tier1_ATACR18_ADM_Desert", //Nightforce Series Optic
+			"Tier1_ATACR18_ADM_T1_Black_Vanilla", //Nightforce Series Optic
+			"Tier1_ATACR18_ADM_T1_Black", //Nightforce Series Optic
+			"Tier1_ATACR18_ADM_T1_Desert_Vanilla", //Nightforce Series Optic
+			"Tier1_ATACR18_ADM_T1_Desert", //Nightforce Series Optic
+			"Tier1_ATACR18_Geissele_Black_Vanilla", //Nightforce Series Optic
+			"Tier1_ATACR18_Geissele_Black", //Nightforce Series Optic
+			"Tier1_ATACR18_Geissele_Desert_Vanilla", //Nightforce Series Optic
+			"Tier1_ATACR18_Geissele_Desert", //Nightforce Series Optic
+			"Tier1_ATACR18_Geissele_Docter_Black_Vanilla", //Nightforce Series Optic
+			"Tier1_ATACR18_Geissele_Docter_Black", //Nightforce Series Optic
+			"Tier1_ATACR18_Geissele_Docter_Desert_Vanilla", //Nightforce Series Optic
+			"Tier1_ATACR18_Geissele_Docter_Desert" //Nightforce Series Optic
+		};
+	};
+
+	class tabbedItems { // Items that are allowed for individuals with Ranger Tab
+		label = "TABBED WEAPON";
+		description = "Items that are allowed for individuals with Ranger Tab.";
+		items[] = {
+			"arifle_MX_black_F", // MX Series
+			"arifle_MX_F", // MX Series
+			"arifle_MX_GL_black_F", // MX 3GL Series
+			"arifle_MX_GL_F", // MX 3GL Series
+			"arifle_MX_GL_khk_F", // MX 3GL Series
+			"arifle_MX_khk_F", // MX Series
+			"arifle_MX_SW_black_F", // MX LSW Series
+			"arifle_MX_SW_F", // MX LSW Series
+			"arifle_MX_SW_khk_F", // MX LSW Series
+			"arifle_MXC_black_F", // MXC Series
+			"arifle_MXC_F", // MXC Series
+			"arifle_MXC_khk_F", // MXC Series
+			"arifle_MXM_black_F", // MXM Series
+			"arifle_MXM_F", // MXM Series
+			"arifle_MXM_khk_F", // MXM Series
+			"arifle_SPAR_03_blk_F", // HK417 Series
+			"arifle_SPAR_03_khk_F", // HK417 Series
+			"arifle_SPAR_03_snd_F", // HK417 Series
+			"rhs_weap_SCARH_CQC", // Scar H Series
+			"rhs_weap_SCARH_FDE_CQC", // Scar H Series
+			"rhs_weap_SCARH_FDE_LB", // Scar H Series
+			"rhs_weap_SCARH_FDE_STD", // Scar H Series
+			"rhs_weap_SCARH_LB", // Scar H Series
+			"rhs_weap_SCARH_STD", // Scar H Series
+			"rhs_weap_SCARH_USA_CQC", // Scar H Series
+			"rhs_weap_SCARH_USA_LB", // Scar H Series
+			"rhs_weap_SCARH_USA_STD", // Scar H Series
+			"SMA_HK417_16in", // HK417 Series
+			"SMA_HK417", // HK417 Series
+			"SMA_HK417vfg", // HK417 Series
+			"SMA_Mk17_16_black", // Scar H Series
+			"SMA_Mk17_16_green", // Scar H Series
+			"SMA_Mk17_16", // Scar H Series
+			"SMA_Mk17_black", // Scar H Series
+			"SMA_Mk17_EGML_black", // Scar H Series
+			"SMA_Mk17_EGML_green", // Scar H Series
+			"SMA_Mk17_EGML", // Scar H Series
+			"SMA_Mk17_green", // Scar H Series
+			"SMA_Mk17", // Scar H Series
+			"Tier1_MK48_Mod0_Desert", // Mk48 Series
+			"Tier1_MK48_Mod0_Para_Desert", // Mk48 Series
+			"Tier1_MK48_Mod0_Para", // Mk48 Series
+			"Tier1_MK48_Mod0", // Mk48 Series
+			"Tier1_MK48_Mod1_Desert", // Mk48 Series
+			"Tier1_MK48_Mod1", // Mk48 Series
+			"Tier1_SR25_ec_tan", // SR-25 Series
+			"Tier1_SR25_ec", // SR-25 Series
+			"Tier1_SR25_tan", // SR-25 Series
+			"Tier1_SR25" // SR-25 Series
+		};
+	};
+
+	class memeItems {
+		label = "MEME ITEM";
+		description = "Items that serve no purpose other than to MEME.";
+		items[] = {
+			"ACE_Banana",
+			"UK3CB_Cocaine_Brick"
+		};
+	};
+};

defines/SignalColors.hpp

@@ -0,0 +1,44 @@
+class SignalColors {
+	class White {
+		name = "White";
+		hexCode = "#FFFFFF";
+		usage = "Concealment, Light";
+		itemExamples[] = {"SmokeShell", "1Rnd_Smoke_Grenade_shell", "ACE_Chemlight_White"};
+	};
+	class Green {
+		name = "Green";
+		hexCode = "#00FF00";
+		usage = "Friendly Forces";
+		itemExamples[] = {"SmokeShellGreen", "1Rnd_SmokeGreen_Grenade_shell", "Chemlight_green"};
+	};
+	class Blue {
+		name = "Blue";
+		hexCode = "#0000FF";
+		usage = "LZ Marking";
+		itemExamples[] = {"SmokeShellBlue", "1Rnd_SmokeBlue_Grenade_shell", "Chemlight_blue"};
+	};
+	class Red {
+		name = "Red";
+		hexCode = "#FF0000";
+		usage = "Enemy Location";
+		itemExamples[] = {"SmokeShellRed", "1Rnd_SmokeRed_Grenade_shell", "Chemlight_red"};
+	};
+	class Orange {
+		name = "Orange";
+		hexCode = "#FFA500";
+		usage = "Resupply Marker";
+		itemExamples[] = {"SmokeShellOrange", "1Rnd_SmokeOrange_Grenade_shell", "ACE_Chemlight_Orange"};
+	};
+	class Yellow {
+		name = "Yellow";
+		hexCode = "#FFFF00";
+		usage = "Medical Emergency";
+		itemExamples[] = {"SmokeShellYellow", "1Rnd_SmokeYellow_Grenade_shell", "Chemlight_yellow"};
+	};
+	class Purple {
+		name = "Purple";
+		hexCode = "#800080";
+		usage = "Broken Arrow - 100m radius";
+		itemExamples[] = {"SmokeShellPurple", "1Rnd_SmokePurple_Grenade_shell"};
+	};
+};

defines/SupplyCrates.hpp

@@ -0,0 +1,180 @@
+class SupplyCrates {
+	class AmmoSquad {
+		boxClass = "Box_Syndicate_Ammo_F";
+		displayName = "Squad Ammo Crate";
+		tooltip = "A crate containing general ammunition and equipment for an infantry squad.";
+		icon = "\A3\ui_f\data\map\vehicleicons\iconCrateAmmo_ca.paa";
+
+		backpacks[] = {};
+		weapons[] = {
+			{"rhs_weap_M136",4},
+			{"rhs_weap_M136_hp",4},
+			{"rhs_weap_m72a7",2}
+		};
+		magazines[] = {
+			{"1Rnd_SmokePurple_Grenade_shell",12},
+			{"1Rnd_SmokeBlue_Grenade_shell",24},
+			{"1Rnd_SmokeOrange_Grenade_shell",12},
+			{"rhs_mag_M441_HE",25},
+			{"rhs_mag_M433_HEDP",15},
+			{"ACE_40mm_Flare_ir",12},
+			{"rhsusf_200Rnd_556x45_mixed_soft_pouch_coyote",25},
+			{"rhsusf_20Rnd_762x51_m993_Mag",25},
+			{"SmokeShell",12},
+			{"rhs_mag_m67",12},
+			{"1Rnd_Smoke_Grenade_shell",24},
+			{"1Rnd_SmokeRed_Grenade_shell",24},
+			{"1Rnd_SmokeGreen_Grenade_shell",24},
+			{"1Rnd_SmokeYellow_Grenade_shell",12},
+			{"Tier1_30Rnd_556x45_M856A1_EMag",25},
+			{"Tier1_30Rnd_556x45_Mk318Mod0_EMag",75},
+			{"ACE_30Rnd_65_Creedmor_mag",25},
+			{"SMA_30Rnd_762x35_BLK_EPR",25},
+			{"Tier1_30Rnd_762x35_300BLK_SMK_PMAG",25},
+			{"SMA_30Rnd_68x43_SPC_FMJ",25},
+			{"SMA_30Rnd_68x43_SPC_FMJ_Tracer",25},
+			{"SMA_20Rnd_762x51mm_M80A1_EPR",25},
+			{"SMA_20Rnd_762x51mm_M80A1_EPR_Tracer",25},
+			{"SMA_20Rnd_762x51mm_Mk316_Mod_0_Special_Long_Range",25},
+			{"SMA_20Rnd_762x51mm_Mk316_Mod_0_Special_Long_Range_Tracer",25},
+			{"Tier1_250Rnd_762x51_Belt_M993_AP",15},
+			{"ACE_20Rnd_762x51_Mag_Tracer",25},
+			{"ACE_20Rnd_762x51_M993_AP_Mag",25},
+			{"rhsusf_20Rnd_762x51_SR25_m993_Mag",25},
+			{"Tier1_20Rnd_762x51_M993_SR25_Mag",25},
+			{"Tier1_20Rnd_65x48_Creedmoor_SR25_Mag",25},
+			{"rhssaf_30rnd_556x45_EPR_G36", 25},
+			{"DemoCharge_Remote_Mag",16}
+		};
+		items[] = {};
+	};
+
+	class AmmoHeavy {
+		boxClass = "Box_NATO_Wps_F";
+		displayName = "Heavy Ammo Crate";
+		tooltip = "A crate containing mixed ammo for rifles, ARs, MAT, and HAT.";
+		icon = "\A3\ui_f\data\map\vehicleicons\iconCrateWpns_ca.paa";
+
+		backpacks[] = {};
+		weapons[] = {};
+		magazines[] = {
+			{"MRAWS_HEAT_F",35},
+			{"MRAWS_HE_F",15},
+			{"Tier1_250Rnd_762x51_Belt_M993_AP",50},
+			{"Tier1_30Rnd_556x45_M856A1_EMag",25},
+			{"Tier1_30Rnd_556x45_Mk318Mod0_EMag",50},
+			{"Titan_AA",10},
+			{"Titan_AT",10},
+			{"200Rnd_65x39_cased_Box_Tracer_Red",50}
+		};
+		items[] = {};
+	};
+
+	class MedicalSupplies {
+		boxClass = "ACE_medicalSupplyCrate_advanced";
+		displayName = "Medical Crate";
+		tooltip = "A crate containing medical supplies.";
+		icon = "\A3\ui_f\data\map\vehicleicons\pictureHeal_ca.paa";
+
+		backpacks[] = {};
+		weapons[] = {};
+		magazines[] = {};
+		items[] = {
+			{"ACE_packingBandage",100},
+			{"ACE_elasticBandage",100},
+			{"ACE_tourniquet",48},
+			{"ACE_splint",48},
+			{"ACE_morphine",50},
+			{"ACE_epinephrine",50},
+			{"ACE_bloodIV",75},
+			{"ACE_bloodIV_500",50},
+			{"ACE_bloodIV_250",25},
+			{"ACE_quikclot",75},
+			{"ACE_personalAidKit", 5},
+			{"ACE_surgicalKit", 5}
+		};
+	};
+
+	class Launchers {
+		boxClass = "Box_NATO_WpsLaunch_F";
+		displayName = "Launcher Crate";
+		tooltip = "A crate containing missile launchers and ammunition.";
+		icon = "\A3\ui_f\data\map\vehicleicons\iconCrateLong_ca.paa";
+
+		backpacks[] = {};
+		weapons[] = {
+			{"launch_B_Titan_short_F",2},
+			{"launch_NLAW_F",2},
+			{"rhs_weap_fim92",2}
+		};
+		magazines[] = {
+			{"Titan_AA",6},
+			{"Titan_AT",6}
+		};
+		items[] = {};
+	};
+
+	class CrewServedWeapons {
+		boxClass = "Box_NATO_Equip_F";
+		displayName = "CSW Crate";
+		tooltip = "A crate containing backpacks that assemble into static weapons.";
+		icon = "\A3\ui_f\data\igui\cfg\simpleTasks\types\defend_ca.paa";
+
+		backpacks[] = {
+			{"RHS_M2_Gun_Bag",2},
+			{"RHS_M2_Tripod_Bag",2},
+			{"RHS_M2_MiniTripod_Bag",2},
+			{"rhs_Tow_Gun_Bag",2},
+			{"rhs_TOW_Tripod_Bag",2},
+			{"UK3CB_Static_M240_Elcan_Gun_Bag",2},
+			{"UK3CB_B_Static_M240_Elcan_Tripod_Low_Bag_US_D",2},
+			{"RHS_Mk19_Gun_Bag",2},
+			{"RHS_Mk19_Tripod_Bag",2}
+		};
+		weapons[] = {};
+		magazines[] = {};
+		items[] = {};
+	};
+
+	class MortarMk6Resupply {
+		boxClass = "Box_NATO_WpsSpecial_F";
+		displayName = "Mortar MK6 Supply Crate";
+		tooltip = "A crate containing Mk6 mortar resupply (tubes) and tools.";
+		icon = "\A3\ui_f\data\map\vehicleicons\iconStaticMortar_ca.paa";
+
+		backpacks[] = {
+			{"B_Mortar_01_support_F",3},
+			{"B_Mortar_01_weapon_F",6},
+			{"UK3CB_LSM_B_B_CARRYALL_RADIO_TIG_STRIPE_01",1}
+		};
+		weapons[] = {
+			{"ACE_Vector",2}
+		};
+		magazines[] = {
+			{"acex_intelitems_notepad",2}
+		};
+		items[] = {
+			{"ACE_artilleryTable",2},
+			{"ACE_RangeTable_82mm",2},
+			{"ACE_microDAGR",2},
+			{"ACE_MapTools",2}
+		};
+	};
+
+	class Mortar60mmCommandoResupply {
+		boxClass = "Box_NATO_WpsSpecial_F";
+		displayName = "Mortar 60mm Commando Supply Crate";
+		tooltip = "A crate containing COMMANDO 60mm mortar shells and some STANAGs.";
+		icon = "\A3\ui_f\data\igui\cfg\simpleTasks\types\scout_ca.paa";
+		
+		backpacks[] = {};
+		weapons[] = {};
+		magazines[] = {
+			{"twc_2inch_he_1rnd",70},
+			{"twc_2inch_smoke_1rnd",15},
+			{"twc_2inch_illum_1rnd",15},
+			{"Tier1_30Rnd_556x45_Mk318Mod0_EMag",20}
+		};
+		items[] = {};
+	};
+};

defines/VehicleFlags.hpp

@@ -0,0 +1,164 @@
+class VehicleFlags {
+
+	texturePBOName = "textures";
+	baseClassesToApplyActionsFor[] = {
+		"LandVehicle",
+		"Helicopter"
+	};
+
+	class ExcludedVehicles {
+		classesWithoutFlagProxies[] = {
+			"TF373_SOAR_MH47G_Base", // MH-47G Chinook
+			"RHS_MELB_base", // MELB AH-6M/MH-6M/H-6M Little Bird
+			"USAF_C17", // C17 Globemaster III
+			"USAF_C130J", // C130J Super Hercules
+			"USAF_AC130U", // AC130 Spooky II
+			"ej_UH60M_base", // UH-60M Black Hawk + DAP variants
+			"rhsusf_fmtv_base" // M1083A1P2 variants + SOV SOCOM variants
+		};
+	};
+
+	class FlagCategories {
+		class ChevronNumbers {
+			actionID = "flag_chevron_numbers";
+			actionTitle = "Chevron Numbers";
+
+			class Chevron1 {
+				actionID = "flag_chevron_id1";
+				actionTitle = "Flag 1";
+				texture = "textures\flag_number\flag_id_1_co.paa";
+			};
+			class Chevron2 {
+				actionID = "flag_chevron_id2";
+				actionTitle = "Flag 2";
+				texture = "textures\flag_number\flag_id_2_co.paa";
+			};
+			class Chevron3 {
+				actionID = "flag_chevron_id3";
+				actionTitle = "Flag 3";
+				texture = "textures\flag_number\flag_id_3_co.paa";
+			};
+			class Chevron4 {
+				actionID = "flag_chevron_id4";
+				actionTitle = "Flag 4";
+				texture = "textures\flag_number\flag_id_4_co.paa";
+			};
+			class Chevron5 {
+				actionID = "flag_chevron_id5";
+				actionTitle = "Flag 5";
+				texture = "textures\flag_number\flag_id_5_co.paa";
+			};
+			class Chevron6 {
+				actionID = "flag_chevron_id6";
+				actionTitle = "Flag 6";
+				texture = "textures\flag_number\flag_id_6_co.paa";
+			};
+			class Chevron7 {
+				actionID = "flag_chevron_id7";
+				actionTitle = "Flag 7";
+				texture = "textures\flag_number\flag_id_7_co.paa";
+			};
+			class Chevron8 {
+				actionID = "flag_chevron_id8";
+				actionTitle = "Flag 8";
+				texture = "textures\flag_number\flag_id_8_co.paa";
+			};
+			class Chevron9 {
+				actionID = "flag_chevron_id9";
+				actionTitle = "Flag 9";
+				texture = "textures\flag_number\flag_id_9_co.paa";
+			};
+			class Chevron10 {
+				actionID = "flag_chevron_id10";
+				actionTitle = "Flag 10";
+				texture = "textures\flag_number\flag_id_10_co.paa";
+			};
+			class ChevronHQ {
+				actionID = "flag_chevron_hq";
+				actionTitle = "Flag HQ";
+				texture = "textures\flag_number\flag_id_hq_co.paa";
+			};
+		};
+
+		class SimpleShapes {
+			actionID = "flag_simpleshape";
+			actionTitle = "Simple Shapes";
+
+			class GreenOctagon {
+				actionID = "flag_simpleshape_greenoctagon";
+				actionTitle = "Green Octagon";
+				texture = "textures\simple_shape\flag_simpleshape_greenoctagon_co.paa";
+			};
+			class BlueCircle {
+				actionID = "flag_simpleshape_bluecircle";
+				actionTitle = "Blue Circle";
+				texture = "textures\simple_shape\flag_simpleshape_bluecircle_co.paa";
+			};
+			class OrangeSquare {
+				actionID = "flag_simpleshape_orangesquare";
+				actionTitle = "Orange Square";
+				texture = "textures\simple_shape\flag_simpleshape_orangesquare_co.paa";
+			};
+			class PinkTriangle {
+				actionID = "flag_simpleshape_pinktriangle";
+				actionTitle = "Pink Triangle";
+				texture = "textures\simple_shape\flag_simpleshape_pinktriangle_co.paa";
+			};
+			class RedPentagon {
+				actionID = "flag_simpleshape_redpentagon";
+				actionTitle = "Red Pentagon";
+				texture = "textures\simple_shape\flag_simpleshape_redpentagon_co.paa";
+			};
+		};
+
+		class Miscellaneous {
+			actionID = "flag_misc";
+			actionTitle = "Miscellaneous";
+			class BattalionEmblem {
+				actionID = "flag_17th_emblem";
+				actionTitle = "17th Emblem";
+				texture = "textures\flags_misc\flag_17th_emblem_co.paa";
+			};
+			class RedCross {
+				actionID = "flag_redcross";
+				actionTitle = "Red Cross";
+				texture = "textures\flags_misc\flag_redcross_co.paa";
+			};
+		};
+
+		class BuiltIn {
+			actionID = "flag_builtin";
+			actionTitle = "Built-In";
+			class BlueFlag {
+				actionID = "flag_builtin_blue";
+				actionTitle = "Blue Flag";
+				texture = "\A3\Data_F\Flags\flag_blue_CO.paa";
+			};
+			class GreenFlag {
+				actionID = "flag_builtin_green";
+				actionTitle = "Green Flag";
+				texture = "\A3\Data_F\Flags\flag_green_CO.paa";
+			};
+			class RedFlag {
+				actionID = "flag_builtin_red";
+				actionTitle = "Red Flag";
+				texture = "\A3\Data_F\Flags\flag_red_CO.paa";
+			};
+			class WhiteFlag {
+				actionID = "flag_builtin_white";
+				actionTitle = "White Flag";
+				texture = "\A3\Data_F\Flags\flag_white_CO.paa";
+			};
+			class NATOFlag {
+				actionID = "flag_builtin_nato";
+				actionTitle = "NATO Flag";
+				texture = "\A3\Data_F\Flags\flag_NATO_CO.paa";
+			};
+			class UNFlag {
+				actionID = "flag_builtin_un";
+				actionTitle = "UN Flag";
+				texture = "\A3\Data_F\Flags\Flag_uno_CO.paa";
+			};
+		};
+	};
+};

description.ext

@@ -1,4 +1,4 @@
-//-------------------------------------------DESCRIPTION.EXT-----------------------------------------------------------------
+//-------------------------------------------DESCRIPTION.EXT-----------------------------------------------------------------
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 
@@ -17,6 +17,13 @@
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 #include "mission_settings.hpp"
+#include "framework\script_mod.hpp"
+#include "defines\ApprovedAssets.hpp"
+#include "defines\BattalionInfo.hpp"
+#include "defines\DisallowedEquipment.hpp"
+#include "defines\SupplyCrates.hpp"
+#include "defines\VehicleFlags.hpp"
+#include "defines\SignalColors.hpp"
 
 //-------------------------------------------MISSION INFO--------------------------------------------------------------------
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -87,10 +94,9 @@ class Params
 };
 
 
-class cfgFunctions 
+// CfgFunctions
-{
+#include "framework\CfgFunctions.hpp"
-	#include "functions\CfgFunctions.hpp"
+
-};
 
 
 class CfgDebriefingSections {

framework/CfgFunctions.hpp

@@ -0,0 +1,180 @@
+#include "script_mod.hpp"
+
+class CfgFunctions {
+
+	class DOUBLES(PREFIX,init) {
+		class functions {
+			file = "framework\init\functions";
+			class initServer { postInit = 1;};
+			class initClient { postInit = 1;};
+			class setDefaults { postInit = 1; };
+			class addAARChatHandler { postInit = 1; };
+			class addRespawnChatHandler { postInit = 1; };
+		};
+	};
+	
+	class PREFIX {	
+		class ambience {
+			file = "framework\ambience";
+			class flakInitVehicle {};
+			class flakEH {};
+		};
+	};
+
+	class DOUBLES(PREFIX,client) {
+		class functions {
+			file = "framework\client\functions";
+			class bindEmptyGroupGarbageCleanup { postInit = 1; };
+			class bindEventHandlers { postInit = 1; };
+			class bindVehicleActions { postInit = 1; };
+			class addZenModules {postInit = 1;};
+		};
+	};
+
+	class DOUBLES(PREFIX,common) {
+		class functions {
+			file = "framework\common\functions";
+			class addCBASettings { preInit = 1; };
+			class logMissionInfo {};
+			class addPlayerInfoToArray {};
+			class createOrUpdateDiaryRecord {};
+			class getApprovedAssetsCfg {};
+			class getBattalionCfg {};
+			class getNameOfBase {};
+			class getNearestBase {};
+			class log {};
+			class checkPlayerInventory {};
+			class logSettingChanged {};
+			class padString {};
+			class recurseSubclasses {};
+		};
+	};
+
+	class DOUBLES(PREFIX,fbcb2_assets) {
+		class functions {
+			file = "framework\fbcb2_assets\functions";
+			class addCBASettings {preInit=1;};
+			class initServer {};
+			class initClient {};
+			class getCallsignFromClassname {};
+			class getCurrentAssetsByBase {};
+			class getInventory {};
+			class getMagsForWeapon {};
+			class getStartingAndCurrentAssets {};
+			class getStartingAssetsByBase {};
+			class getVehicleData {};
+			class getWeaponry {};
+			class hintAllApprovedAssets {};
+			class isAssetInRangeOfBase {};
+			class removeAssetDiaryRecords {};
+			class removeMarkersOnMap {};
+			class showMarkersOnMap {};
+			class updateAssetDiary {};
+			class updateAssetsByBase {};
+		};
+	};
+
+	class DOUBLES(PREFIX,fbcb2_main) {
+		class functions {
+			file = "framework\fbcb2_main\functions";
+			class initClient {};
+			class addEnvironmentRecord {};
+			class addFrequenciesRecord {};
+			class addSignalColorsRecord {};
+		};
+		class util {
+			file = "framework\fbcb2_main\util";
+			class formatRadioElementForDiary {};
+			class generateElementFrequencyRecordText {};
+		};
+	};
+
+	class DOUBLES(PREFIX,mapcopy) {
+		class functions {
+			file = "framework\mapcopy\functions";
+			class addCBASettings {preInit=1;};
+			class initClient {};
+			class getMapMarkers {};
+			class loadMapMarkers {};
+			class mapMarkerToString {};
+			class stringToMapMarker {};
+		};
+	};
+
+	class DOUBLES(PREFIX,performance) {
+		class functions {
+			file = "framework\performance\functions";
+			class addCBASettings {preInit=1;};
+			class addDNI_PlayerFPS { postInit = 1; };
+
+			// PFHs managed in addCBASettings onChange code
+			class addClientStatsPFH {};
+			class calculateClientStats {};
+			class addServerStatsPFH {};
+			class calculateServerStats {};
+		};
+	};
+
+	class DOUBLES(PREFIX,reinsert) {
+		class functions {
+			file = "framework\reinsert\functions";
+			class addCBASettings {preInit=1;};
+		};
+		class server {
+			file = "framework\reinsert\server";
+			class initServer {};
+			class addToQueue {};
+			class globalShowQueue {};
+			class removeFromQueue {};
+			class returnReinsertQueueNotification {};
+			class validateQueue {};
+		};
+		class client {
+			file = "framework\reinsert\client";
+			class initClient {};
+			class addAceSelfActions {};
+			class addCheckQueueSelfAction {};
+			class requestShowQueue {};
+		};
+	};
+
+	class DOUBLES(PREFIX,resupply) {
+		class functions {
+			file = "framework\resupply\functions";
+			class addCBASettings {preInit=1;};
+			class initClient {};
+			class createBox {};
+			class getSupplyCratesCfg {};
+			class addArsenalObjectSpawnBoxActions {};
+		};
+	};
+
+	class DOUBLES(PREFIX,triageIcons) {
+		class functions {
+			file = "framework\triageIcons\functions";
+			class addCBASettings {preInit=1;};
+			class initClient {};
+			class addDrawIconsPFH {};
+			class addGetEntitiesPFH {};
+			class updateColors {};
+		};
+	};
+
+	class DOUBLES(PREFIX,vehicleFlags) {
+		class functions {
+			file = "framework\vehicleFlags\functions";
+			class initClient {};
+			class getActionsFlagCategories {};
+			class getVehicleFlagsCfg {};
+			class isClassExcluded {};
+		};
+	};
+
+	class DOUBLES(PREFIX,zeus) {
+		class functions {
+			file = "framework\zeus\functions";
+			class initClient {};
+			class addZenModules {};
+		};
+	};
+};

framework/client/functions/fn_addZenModules.sqf

@@ -0,0 +1,41 @@
+#include "..\script_component.hpp"
+
+if ( !hasInterface ) exitWith {};
+
+[
+	QUOTE(MODULE_CATEGORY_NAME),
+	"Grounds Cleanup", 
+	{
+		params [["_pos", [0,0,0], [[]], 3], ["_target", objNull, [objNull]]];
+		
+		_pos = [_pos#0, _pos#1, 0];
+		
+		[
+			"Cleanup Area",
+			[
+				[ "SLIDER:RADIUS", "Radius (meters)", [50, 500, 100, 0, _pos, [0.8, 0.2, 0.2, 1.0]], true ]
+			],
+			{
+				
+				params ["_dialog", "_args"];
+				
+				_dialog params ["_radius"];
+				_args params ["_pos", "_target"];
+						
+				_objects = _pos nearObjects ["GroundWeaponHolder", _radius];
+				{
+					deleteVehicle _x;
+				} forEach _objects
+
+			},
+			{},
+			[_pos, _target]
+		] call zen_dialog_fnc_create;
+
+	}
+] call zen_custom_modules_fnc_register;
+
+
+diag_log text "[MILSIM] (client) zeus modules added";
+
+nil;

framework/client/functions/fn_bindEmptyGroupGarbageCleanup.sqf

@@ -0,0 +1,43 @@
+#include "..\script_component.hpp"
+
+[
+	LEVEL_INFO,
+	QUOTE(COMPONENT),
+	"Initializing empty group deletion PFH",
+	[]
+] call EFUNC(common,log);
+
+_emptyGroupPFH = [
+	{ 
+		{
+			if (local _x) then {
+				if ((count units _x) == 0) then {
+					deleteGroup _x;
+				};
+			};
+		} forEach allGroups;
+	},
+	300,
+	[],
+	{ 
+		[
+			LEVEL_INFO,
+			QUOTE(COMPONENT),
+			"Empty group deletion PFH loaded",
+			[]
+		] call EFUNC(common,log);
+	},
+	{ 	[
+			LEVEL_INFO,
+			QUOTE(COMPONENT),
+			"Empty group deletion PFH unloaded",
+			[]
+		] call EFUNC(common,log);
+	},
+	{ true },
+	{ false },
+	[]
+] call CBA_fnc_createPerFrameHandlerObject;
+
+
+

framework/client/functions/fn_bindEventHandlers.sqf

@@ -1,11 +1,18 @@
+#include "..\script_component.hpp"
+
 if ( !hasInterface ) exitWith {};
 
 player addEventHandler["Respawn", 
 	{
 		params ["_unit", "_corpse"];
-		_killer = _corpse getVariable ["ace_medical_causeOfDeath", "#scripted"];
+		private _killer = _corpse getVariable ["ace_medical_causeOfDeath", "#scripted"];
 		if (_killer == "respawn_button") then {
-			format["[MILSIM] (client) %1 was unconscious then clicked the respawn button", name _unit] remoteExec["diag_log", 0];
+			[
+				LEVEL_INFO,
+				QUOTE(COMPONENT),
+				"RESPAWNED WHILE UNCONSCIOUS",
+				[_unit] call EFUNC(common,addPlayerInfoToArray)
+			] remoteExec [QEFUNC(common,log), 2];
 		//	format["%1 was unconscious then clicked the respawn button", name _unit] remoteExec["systemChat", 0];
 		};
 	}
@@ -38,6 +45,14 @@ addMissionEventHandler ["HandleChatMessage",
 ];
 
 
+["ace_arsenal_displayClosed", {
+	[player] remoteExec [QEFUNC(common,checkPlayerInventory), 2];
+}] call CBA_fnc_addEventHandler;
+
+[missionNamespace, "arsenalClosed", {
+	[player] remoteExec [QEFUNC(common,checkPlayerInventory), 2];
+}] call BIS_fnc_addScriptedEventHandler;
+
 diag_log text "[MILSIM] (client) event handlers bound";
 
 nil;

framework/client/functions/fn_bindVehicleActions.sqf

@@ -56,7 +56,7 @@ _patchTire =
 			"Patching"
 		] call ace_common_fnc_progressBar
 	},
-	{ ( alive _target ) && ( [_player, "ToolKit"] call ace_common_fnc_hasItem ) && ( getDammage _target > 0.2 ) && ( _target getVariable["milsim_ace_repair_wheel_canPatch", true] ) }
+	{ ( alive _target ) && ( [_player, "ToolKit"] call ace_common_fnc_hasItem ) && ( damage _target > 0.2 ) && ( _target getVariable["milsim_ace_repair_wheel_canPatch", true] ) }
 ] call ace_interact_menu_fnc_createAction; 
 
 ["ACE_Wheel", 0, ["ACE_MainActions"], _patchTire, true] call ace_interact_menu_fnc_addActionToClass;

framework/client/script_component.hpp

@@ -0,0 +1,3 @@
+#define COMPONENT client
+#define COMPONENT_BEAUTIFIED Client
+#include "../script_mod.hpp"

framework/common/functions/fn_addCBASettings.sqf

@@ -0,0 +1,27 @@
+#include "..\script_component.hpp"
+
+//---------------------
+//	Side Chat
+//---------------------
+
+[
+	QGVARMAIN(sideChat),
+	"CHECKBOX",
+	"Side Chat Text Enabled",
+	[QUOTE(SETTINGS_GROUP_NAME), QUOTE(COMPONENT_BEAUTIFIED)],
+	false, // default value
+	true, // requires restart
+	{
+		params ["_value"];
+		[
+			QGVARMAIN(sideChat),
+			_value
+		] call EFUNC(common,logSettingChanged);
+	}
+] call CBA_fnc_addSetting;
+
+[QGVARMAIN(sideChat), false] call CBA_settings_fnc_set;
+
+diag_log text "[MILSIM] (settings) Custom CBA settings initialized";
+
+nil;

framework/common/functions/fn_addPlayerInfoToArray.sqf

@@ -0,0 +1,16 @@
+#include "..\script_component.hpp"
+
+params [["_playerObj", objNull, [nil, objNull]], ["_arrayToModify", [], [[]]]];
+
+if (isNull _playerObj) exitWith {_arrayToModify};
+
+{
+	_arrayToModify = [_arrayToModify, _x#0, _x#1] call BIS_fnc_setToPairs;
+} forEach [
+	["playerName", name _playerObj],
+	["playerUID", getPlayerUID _playerObj],
+	["playerGroup", groupId (group _playerObj)],
+	["playerNetID", _playerObj call BIS_fnc_netId]
+];
+
+_arrayToModify;

framework/common/functions/fn_checkPlayerInventory.sqf

@@ -0,0 +1,150 @@
+/*
+	Function: milsim_common_fnc_checkPlayerInventory
+
+	Description:
+		Checks a player's inventory for non-compliant items and logs results to all machines.
+
+	Author: Hizumi, EagleTrooper, IndigoFox
+
+	Parameters:
+		0: _player - <OBJECT> - Player to check inventory of.
+
+	Returns:
+		<ARRAY> - Array of strings to be logged.
+
+*/
+#include "..\script_component.hpp"
+
+params [
+	["_player", objNull, [objNull]]
+];
+
+if (!isPlayer _player) exitWith {
+	[
+		LEVEL_ERROR,
+		QUOTE(COMPONENT),
+		"PARAM PLAYER IS NOT A PLAYER",
+		[["player", _player]]
+	] call EFUNC(common,log);
+};
+
+// testing
+// test_old = compile preprocessFileLineNumbers "testold.sqf"; 
+// test_new = compile preprocessFileLineNumbers "testnew.sqf";
+// player addItem "A3_GPNVG18_BLK_TI";
+// player addWeapon "SMA_HK417_16in";
+// player addItem "ej_VPS15";
+// player addItem "ACE_Banana";
+
+// INSTANTIATE VARS
+private _foundItemsKeyValue = [];
+private _allFoundItemsSoFar = [];
+
+// GET PLAYER ITEMS
+private _playerItems = [
+	_player, // Unit
+	true, // Include weapons, attachments, loaded magazines
+	true, // Include items in backpack
+	true, // Include items in vest
+	true, // Include items in uniform
+	true, // Include assigned items
+	true // Include not loaded magazines
+] call CBA_fnc_uniqueUnitItems;
+
+_playerItems pushBack (headgear _player);
+_playerItems pushBack (uniform _player);
+
+
+[
+	LEVEL_DEBUG,
+	QUOTE(COMPONENT),
+	"CHECKING PLAYER INVENTORY",
+	[_player] call EFUNC(common,addPlayerInfoToArray)
+] call EFUNC(common,log);
+
+////////////////////////////////////////
+// HARDCODED DISALLOWED ITEMS - see functions/definitions/DisallowedEquipment.hpp
+
+// Get parent class
+private _disallowedEquipmentCfg = (missionConfigFile >> "DisallowedEquipment");
+
+// Get all subclasses
+private _definitionCfgs = (_disallowedEquipmentCfg call BIS_fnc_getCfgSubClasses) apply {
+	(_disallowedEquipmentCfg >> _x)
+};
+
+// diag_log text format["DEFINITION CFGS: %1", _definitionCfgs];
+// Check all items
+{ // forEach _subclassesCfgs
+	private _definitionCfg = _x;
+	private _definitionLabel = (_definitionCfg >> "label") call BIS_fnc_getCfgData;
+	private _definitionItems = (_definitionCfg >> "items") call BIS_fnc_getCfgDataArray;
+	// diag_log text format["DEF ITEMS: %1", _definitionItems];
+	{ // forEach _playerItems
+		private _playerItem = _x;
+		// diag_log text format["PLAYER ITEM: %1", _playerItem];
+		if (_playerItem in _definitionItems && not (_playerItem in _allFoundItemsSoFar)) then {
+			// add under def label
+			[_foundItemsKeyValue, _definitionLabel, _playerItem] call BIS_fnc_addToPairs;
+			// add to all found items
+			_allFoundItemsSoFar pushBackUnique _playerItem;
+		};
+	} forEach _playerItems;
+} forEach _definitionCfgs;
+
+////////////////////////////////////////
+// UNLISTED THERMAL - Any item with thermal capabilities that is not already in the list
+
+// Identify thermal items in the player list
+private _thermalItems = _playerItems select {
+	private _playerItem = _x;
+	private _modes = getArray(configfile >> "CfgWeapons" >> _playerItem >> "visionMode");
+	private _subModes = [configfile >> "CfgWeapons" >> _playerItem >> "ItemInfo" >> "OpticsModes", 1] call BIS_fnc_returnChildren;
+	{
+		_modes append getArray( _x >> "visionMode" );
+	} forEach _subModes;
+	if ((count _modes) isNotEqualTo 0) then {
+		// if the item has thermal capabilities and is not in the list anywhere else, include it
+		"ti" in (_modes apply { toLower _x }) && not (_playerItem in _allFoundItemsSoFar);
+	} else {
+		false;
+	};
+};
+
+{
+	[_foundItemsKeyValue, "UNLISTED THERMAL", _x] call BIS_fnc_addToPairs;
+} forEach _thermalItems;
+
+
+// Only log compliance message if no non-compliant items were found
+if (count _allFoundItemsSoFar isEqualTo 0) exitWith {
+	[
+		LEVEL_INFO,
+		QUOTE(COMPONENT),
+		"PLAYER INVENTORY IS COMPLIANT",
+		[_player] call EFUNC(common,addPlayerInfoToArray)
+	] call EFUNC(common,log);
+};
+
+// Log all non-compliant items
+{
+	_x params ["_categoryLabel", "_items"];
+	if (typeName _items isEqualTo "STRING") then {
+		_items = [_items];
+	};
+	{
+		private _itemClassName = _x;
+		private _itemConfig = _itemClassName call CBA_fnc_getItemConfig;
+		// Log to RPT
+		[
+			LEVEL_WARNING,
+			QUOTE(COMPONENT),
+			"NON-COMPLIANT ITEM",
+			[_player, [
+				["category", _categoryLabel],
+				["className", _itemClassName],
+				["displayName", [_itemConfig] call BIS_fnc_displayName]
+			]] call EFUNC(common,addPlayerInfoToArray)
+		] call EFUNC(common,log);
+	} forEach _items;
+} forEach _foundItemsKeyValue;

framework/common/functions/fn_createOrUpdateDiaryRecord.sqf

@@ -0,0 +1,58 @@
+#include "../script_component.hpp"
+
+if (!hasInterface) exitWith {};
+
+params [
+	["_subjectID", "", [""]],
+	["_recordTitle", "", [""]],
+	["_recordText", "", [""]],
+	["_recordIcon", "", [""]]
+];
+
+// Check if all parameters are provided
+if (
+	count _subjectID isEqualTo 0 ||
+	count _recordTitle isEqualTo 0 ||
+	count _recordText isEqualTo 0
+) exitWith {
+	[LEVEL_ERROR, QUOTE(COMPONENT), "Not all parameters provided"] call EFUNC(common,log);
+};
+
+// Check if already created
+private _subjectRecords = GVAR(diaryRecords) getOrDefault [_subjectID, createHashMap, true];
+private _existingRecord = _subjectRecords getOrDefault [_recordTitle, diaryRecordNull, true];
+
+if (!isNull _existingRecord) then {
+	player setDiaryRecordText [[_subjectID, _existingRecord], [_recordTitle, _recordText, _recordIcon]];
+	
+	[
+		LEVEL_DEBUG,
+		QUOTE(COMPONENT),
+		format ["Updated diary record: %1", _recordTitle],
+		[
+			["subjectID", _subjectID],
+			["recordTitle", _recordTitle]
+		]
+	] call EFUNC(common,log);
+} else {
+	private _new = player createDiaryRecord [
+		_subjectID, 
+		[
+			_recordTitle, 
+			_recordText,
+			_recordIcon
+		]
+	];
+	_subjectRecords set [_recordTitle, _new];
+	GVAR(diaryRecords) set [_subjectID, _subjectRecords];
+
+	[
+		LEVEL_DEBUG,
+		QUOTE(COMPONENT),
+		format ["Created diary record: %1", _recordTitle],
+		[
+			["subjectID", _subjectID],
+			["recordTitle", _recordTitle]
+		]
+	] call EFUNC(common,log);
+};

framework/common/functions/fn_getApprovedAssetsCfg.sqf

@@ -0,0 +1,15 @@
+#include "../script_component.hpp"
+
+private _approvedAssetsCfg = (missionConfigFile >> "ApprovedAssets");
+
+if (!IS_CONFIG(_approvedAssetsCfg) || {!isClass _approvedAssetsCfg}) exitWith {
+	[
+		LEVEL_ERROR,
+		QUOTE(COMPONENT),
+		"ERROR: Approved assets config not found. Check that the config is present and correctly named in the mission config file. See defines/ApprovedAssets.hpp and framework/util/functions/getApprovedAssetsCfg.sqf.",
+		[]
+	] call EFUNC(common,log);
+	configNull;
+};
+
+_approvedAssetsCfg;

framework/common/functions/fn_getBattalionCfg.sqf

@@ -0,0 +1,15 @@
+#include "../script_component.hpp"
+
+private _battalionInfoCfg = (missionConfigFile >> "BattalionInfo");
+
+if (!IS_CONFIG(_battalionInfoCfg) || {!isClass _battalionInfoCfg}) exitWith {
+	[
+		LEVEL_ERROR,
+		QUOTE(COMPONENT),
+		"ERROR: Battalion config not found. Check that the battalion config is present and correctly named in the mission config file. See defines/BattalionInfo.hpp and framework/util/functions/getBattalionCfg.sqf.",
+		[]
+	] call EFUNC(common,log);
+	configNull;
+};
+
+_battalionInfoCfg;

framework/common/functions/fn_getNameOfBase.sqf

@@ -0,0 +1,19 @@
+#include "..\script_component.hpp"
+
+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"]])
+// 	]
+// };
+
+if (_baseName == "") then {
+	_baseName = _base call BIS_fnc_locationDescription;
+};
+
+_baseName;

framework/common/functions/fn_getNearestBase.sqf

@@ -0,0 +1,12 @@
+#include "..\script_component.hpp"
+
+params [["_object", objNull, [objNull]]];
+if (isNull _object) exitWith {objNull};
+
+private _bases = missionNamespace getVariable ["milsim_baseObjects", []];
+if (count _bases == 0) exitWith {objNull};
+
+// get nearest base (Module_Respawn_F)
+private _closestBase = [_bases, _object] call BIS_fnc_nearestPosition;
+if (isNull _closestBase) exitWith {objNull};
+_closestBase;

framework/common/functions/fn_log.sqf

@@ -0,0 +1,33 @@
+/* 
+	Function: milsim_common_fnc_log
+
+	Description:
+		Used to log messages to the server RPT file.
+
+	Parameters:
+		0: NUMBER - log level.
+		1: STRING - component name.
+		2: STRING - message to log.
+		3: ARRAY - key value pairs of data to log.
+*/
+#include "..\script_component.hpp"
+
+params [
+	["_logLevel", 1, [-1,0,1,2,3]], // script_mod.hpp
+	["_component", "", [""]],
+	["_message", "", [""]],
+	["_data", [], [[]]]
+];
+
+if (_logLevel < DEBUG_MODE) exitWith {};
+
+private _hash = createHashMapFromArray _data;
+
+// Replace square brackets with round brackets to avoid parsing issues.
+_message regexReplace ['(\[)', "("];
+_message regexReplace ['(\])', ")"];
+
+private _json = [_hash] call CBA_fnc_encodeJSON;
+_log = format ["[%1] [%2] [%3] [%4] :: %5", QUOTE(PREFIX), _component, _fnc_scriptNameParent, _message, _json];
+
+diag_log text _log;

framework/common/functions/fn_logMissionInfo.sqf

@@ -0,0 +1,26 @@
+#include "..\script_component.hpp"
+
+[
+	LEVEL_INFO,
+	QUOTE(COMPONENT),
+	"MISSION INFO",
+	[
+		["serverName", serverName],
+		["worldName", worldName],
+		["missionSeries", getMissionConfigValue ["missionSeries", ""]],
+		["missionName", missionName],
+		["briefingName", briefingName],
+		["overviewText", getMissionConfigValue ["overviewText", ""]],
+		["onLoadName", getMissionConfigValue ["onLoadName", ""]],
+		["onLoadMission", getMissionConfigValue ["onLoadMission", ""]],
+		["missionAuthor", getMissionConfigValue ["author", ""]],
+		["unitSlots", createHashMapFromArray [
+			["EAST", playableSlotsNumber EAST], // 0 is EAST side
+			["WEST", playableSlotsNumber WEST], // 1 is WEST side
+			["RESISTANCE", playableSlotsNumber RESISTANCE], // 2 is RESISTANCE side
+			["CIVILIAN", playableSlotsNumber CIVILIAN], // 3 is CIVILIAN side
+			["SIDEUNKNOWN", 0], // 4 is SIDEUNKNOWN side
+			["LOGIC", playableSlotsNumber sideLogic] // 5 is LOGIC side
+		]]
+	]
+] call FUNC(log);

framework/common/functions/fn_logSettingChanged.sqf

@@ -0,0 +1,16 @@
+#include "..\script_component.hpp"
+
+params [
+	["_settingName", "", [""]],
+	"_newValue"
+];
+
+[
+	LEVEL_INFO,
+	QUOTE(COMPONENT),
+	"SETTING CHANGED",
+	[
+		["setting", _settingName],
+		["newValue", _value]
+	]
+] call EFUNC(common,log);

framework/common/functions/fn_padString.sqf

@@ -0,0 +1,22 @@
+#include "..\script_component.hpp"
+
+params [
+	["_text", "", [""]],
+	["_padSide", "left", ["left", "right"]],
+	["_padChar", " ", [" "]],
+	["_padLength", 4, [4]]
+];
+
+// pad a string with a character to a certain length
+if (_padSide == "left") then {
+	for "_i" from 1 to _padLength - count _text do {
+		_text = _padChar + _text;
+	};
+};
+if (_padSide == "right") then {
+	for "_i" from 1 to _padLength - count _text do {
+		_text = _text + _padChar;
+	};
+};
+
+_text

framework/common/functions/fn_recurseSubclasses.sqf

@@ -0,0 +1,27 @@
+#include "..\script_component.hpp"
+
+params [
+	["_cfg", configNull, [configNull]],
+	["_code", {}, [{}]]
+];
+
+if (isNull _cfg) exitWith {["Provided config is null!"] call BIS_fnc_error};
+
+
+private _recurseFnc = {
+	params ["_cfg", "_code", ["_recurseCounter", 0]];
+	[_cfg, _recurseCounter] call _code;
+	// get children and recurse
+	private _childCfgs = _cfg call BIS_fnc_returnChildren;
+	if (count _childCfgs isEqualTo 0) exitWith {false};
+
+	{
+		[_x, _code, _recurseCounter + 1] call _recurseFnc;
+	} forEach _childCfgs;
+	false;
+};
+
+private _continue = true;
+while {_continue} do {
+	_continue = [_cfg, _code] call _recurseFnc;
+};

framework/common/script_component.hpp

@@ -0,0 +1,3 @@
+#define COMPONENT common
+#define COMPONENT_BEAUTIFIED Common
+#include "../script_mod.hpp"

framework/fbcb2_assets/functions/fn_addCBASettings.sqf

@@ -0,0 +1,27 @@
+#include "..\script_component.hpp"
+
+//---------------------
+// Asset Diary and Markers Settings
+
+[
+	QGVAR(setting_detectionRangeFromBase), // variable
+	"SLIDER", // type
+	["Detection Range From Base", "The range from a base that assets will be detected"], // title
+	[QUOTE(SETTINGS_GROUP_NAME), QUOTE(COMPONENT_BEAUTIFIED)], // category
+	[0, 1000, 750, 0, false], // [_min, _max, _default, _trailingDecimals, _isPercentage]
+	true, // global setting
+	{
+		params ["_value"];
+		[
+			QGVAR(setting_detectionRangeFromBase),
+			_value
+		] call EFUNC(common,logSettingChanged);
+	}
+] call CBA_fnc_addSetting;
+
+[
+	LEVEL_INFO,
+	QUOTE(COMPONENT),
+	"CREATED SETTINGS",
+	[]
+] call EFUNC(common,log);

framework/fbcb2_assets/functions/fn_getCallsignFromClassname.sqf

@@ -0,0 +1,15 @@
+#include "..\script_component.hpp"
+
+params [
+	["_className", "", [""]]
+];
+
+// Get the approved assets config
+private _approvedAssetsCfg = call EFUNC(common,getApprovedAssetsCfg);
+if (isNull _approvedAssetsCfg) exitWith {""};
+
+// Get the asset definition
+private _assetDef = (_approvedAssetsCfg >> _className);
+if (isClass _assetDef) exitWith {getText(_assetDef >> "callsign")};
+
+"";

framework/fbcb2_assets/functions/fn_getCurrentAssetsByBase.sqf

@@ -0,0 +1,6 @@
+#include "../script_component.hpp"
+
+// return each base with its assets
+GVARMAIN(baseObjects) apply {
+	[_x, _x getVariable [QGVAR(assetsAtThisBase), []]]
+};

framework/fbcb2_assets/functions/fn_getInventory.sqf

@@ -0,0 +1,123 @@
+params ["_vic"];
+
+
+_vicDispName = configOf _vic call BIS_fnc_displayName;
+private _thisArr = [];
+
+// _thisArr pushBack getItemCargo _vic;
+// _thisArr pushBack getBackpackCargo _vic;
+// _thisArr pushBack getMagazineCargo _vic;
+// _thisArr pushBack getWeaponCargo _vic;
+
+private _ItemCargo = [];
+private _MagazineCargo = [];
+private _WeaponCargo = [];
+private _BackpackCargo = [];
+
+{
+	private _config = _x call CBA_fnc_getItemConfig;
+	_ItemCargo pushBack [
+		getText (_config >> "displayName"),
+		getText (_config >> "picture")
+	];
+} forEach ItemCargo _vic;
+{
+	private _config = _x call CBA_fnc_getItemConfig;
+	_MagazineCargo pushBack [
+		getText (_config >> "displayName"),
+		getText (_config >> "picture")
+	];
+} forEach MagazineCargo _vic;
+{
+	// private _config = _x call CBA_fnc_getObjectConfig;
+	_WeaponCargo pushBack [
+		getText (configFile >> "CfgWeapons" >> _x >> "displayName"),
+		getText (configFile >> "CfgWeapons" >> _x >> "picture")
+	];
+} forEach WeaponCargo _vic;
+{
+	private _config = _x call CBA_fnc_getObjectConfig;
+	_BackpackCargo pushBack [
+		getText (_config >> "displayName"),
+		getText (_config >> "picture")
+	];
+} forEach BackpackCargo _vic;
+
+private _sortedItemCargo = ([_ItemCargo call BIS_fnc_consolidateArray, [], {_x # 0 # 0}] call BIS_fnc_sortBy) select {!(_x # 0 # 0 isEqualTo "")};
+private _sortedMagazineCargo = ([_MagazineCargo call BIS_fnc_consolidateArray, [], {_x # 0 # 0}] call BIS_fnc_sortBy) select {!(_x # 0 # 0 isEqualTo "")};
+private _sortedWeaponCargo = ([_WeaponCargo call BIS_fnc_consolidateArray, [], {_x # 0 # 0}] call BIS_fnc_sortBy) select {!(_x # 0 # 0 isEqualTo "")};
+private _sortedBackpackCargo = ([_BackpackCargo call BIS_fnc_consolidateArray, [], {_x # 0 # 0}] call BIS_fnc_sortBy) select {!(_x # 0 # 0 isEqualTo "")};
+
+// "debug_console" callExtension(str _sortedItemCargo + "~0100");
+// "debug_console" callExtension(str _sortedMagazineCargo + "~0100");
+// "debug_console" callExtension(str _sortedWeaponCargo + "~0100");
+// "debug_console" callExtension(str _sortedBackpackCargo + "~0100");
+
+if (count _sortedItemCargo > 0) then {
+	_thisArr pushBack format["<font color='#ffffff' size='12' face='PuristaMedium'>Items:</font>"];
+	private _itemCargoOut = [];
+	{
+		private _name = _x # 0 # 0;
+		private _pic = _x # 0 # 1;
+		private _count = _x # 1;
+		if (_pic == "") then {
+			_itemCargoOut pushBack format["<font color='#ffffff' size='12' face='EtelkaMonospacePro'><execute expression='systemChat ""%3"";'>%3 x%2</execute></font>", _pic, _count, _name];
+		} else {
+			_itemCargoOut pushBack format["<img height='30' image='%1'/><font color='#ffffff' size='10' face='EtelkaMonospacePro'><execute expression='systemChat ""%3"";'>x%2</execute></font>", _pic, _count, _name];
+		};
+		if ((_forEachIndex + 1) mod 6 == 0) then {_itemCargoOut pushBack "<br/>"};
+	} forEach _sortedItemCargo;
+	_thisArr pushBack (_itemCargoOut joinString "");
+};
+if (count _sortedMagazineCargo > 0) then {
+	_thisArr pushBack format["<font color='#ffffff' size='12' face='PuristaMedium'>Magazines:</font>"];
+	private _magCargoOut = [];
+	{
+		private _name = _x # 0 # 0;
+		private _pic = _x # 0 # 1;
+		private _count = _x # 1;
+		if (_pic == "") then {
+			_magCargoOut pushBack format["<font color='#ffffff' size='12' face='EtelkaMonospacePro'><execute expression='systemChat ""%3"";'>%3 x%2</execute></font>", _pic, _count, _name];
+		} else {
+			_magCargoOut pushBack format["<img height='30' image='%1'/><font color='#ffffff' size='10' face='EtelkaMonospacePro'><execute expression='systemChat ""%3"";'>x%2</execute></font>", _pic, _count, _name];
+		};
+		if ((_forEachIndex + 1) mod 6 == 0) then {_magCargoOut pushBack "<br/>"};
+	} forEach _sortedMagazineCargo;
+	_thisArr pushBack (_magCargoOut joinString "");
+};
+if (count _sortedWeaponCargo > 0) then {
+	_thisArr pushBack format["<font color='#ffffff' size='12' face='PuristaMedium'>Weapons:</font>"];
+	private _weaponCargoOut = [];
+	{
+		private _name = _x # 0 # 0;
+		private _pic = _x # 0 # 1;
+		private _count = _x # 1;
+		if (_pic == "") then {
+			_weaponCargoOut pushBack format["<font color='#ffffff' size='12' face='EtelkaMonospacePro'><execute expression='systemChat ""%3"";'>%3 x%2</execute></font>", _pic, _count, _name];
+		} else {
+			_weaponCargoOut pushBack format["<img height='50' image='%1'/><font color='#ffffff' size='10' face='EtelkaMonospacePro'><execute expression='systemChat ""%3"";'>x%2</execute></font>", _pic, _count, _name];
+		};
+		if ((_forEachIndex + 1) mod 3 == 0) then {_weaponCargoOut pushBack "<br/>"};
+	} forEach _sortedWeaponCargo;
+	_thisArr pushBack (_weaponCargoOut joinString "");
+};
+if (count _sortedBackpackCargo > 0) then {
+	_thisArr pushBack format["<font color='#ffffff' size='12' face='PuristaMedium'>Backpacks:</font>"];
+	private _backpackCargoOut = [];
+	{
+		private _name = _x # 0 # 0;
+		private _pic = _x # 0 # 1;
+		private _count = _x # 1;
+		if (_pic == "") then {
+			_backpackCargoOut pushBack format["<font color='#ffffff' size='12' face='EtelkaMonospacePro'><execute expression='systemChat ""%3"";'>%3 x%2</execute></font>", _pic, _count, _name];
+		} else {
+			_backpackCargoOut pushBack format["<img height='50' image='%1'/><font color='#ffffff' size='10' face='EtelkaMonospacePro'><execute expression='systemChat ""%3"";'>x%2</execute></font>", _pic, _count, _name];
+		};
+		if ((_forEachIndex + 1) mod 4 == 0) then {_backpackCargoOut pushBack "<br/>"};
+	} forEach _sortedBackpackCargo;
+	_thisArr pushBack (_backpackCargoOut joinString "");
+	// "debug_console" callExtension(str _backpackCargoOut + "~0100");
+};
+
+// "debug_console" callExtension(str _thisArr + "~1100");
+_thisArr;

framework/fbcb2_assets/functions/fn_getMagsForWeapon.sqf

@@ -0,0 +1,80 @@
+params ["_vic", "_path", "_wep", "_magsHere", "_pylons"];
+
+if (_path isEqualTo []) then {_path = [-1]};
+// "debug_console" callExtension (_wep + "#0100");
+if (_wep in [
+	"rhs_weap_MASTERSAFE",
+	"rhs_weap_fcs_ammo",
+	"rhs_weap_laserDesignator_AI",
+	"rhs_weap_fcs_ah64",
+	"rhs_weap_DummyLauncher",
+	"rhs_weap_fcs_nolrf_ammo",
+	"rhsusf_weap_duke",
+	"TruckHorn",
+	"TruckHorn2",
+	"TruckHorn3"
+]) exitWith {[[]]};
+
+private _thisArr = [];
+_wepConfig = (configFile >> "CfgWeapons" >> _wep);
+_wepDisp = [(_wepConfig >> "displayName"), "STRING", "Weapon"] call CBA_fnc_getConfigEntry;
+if (_wep == "rhs_weap_smokegen") then {_wepDisp = "Smoke Generator"};
+if (_wepDisp isEqualTo "") exitWith {[[]]};
+
+// "debug_console" callExtension (_wepDisp + "#0100");
+_magsToCheck = (_vic magazinesTurret _path);
+
+
+// See if the first default magazine in the config of this weapon is meant to be used on a pylon. If so, process differently
+// _mag1pylonWeapon = "";
+// _magsConfigArr = [(_wepConfig >> "magazines"), "ARRAY", []] call CBA_fnc_getConfigEntry;
+// if (_magsConfigArr isEqualTo []) then {
+// 	_mag1pylonWeapon = "";
+// } else {
+// 	_mag1Name = _magsConfigArr # 0;
+// 	_mag1pylonWeapon = [(configFile >> "CfgMagazines" >> _mag1Name >> "pylonWeapon"), "STRING", ""] call CBA_fnc_getConfigEntry;
+// };
+
+_pylonMagNames = _pylons apply {_x # 3};
+
+_compatMagsRef = [_wepConfig, true] call CBA_fnc_compatibleMagazines;
+_magsFound = _compatMagsRef select {_magsToCheck find _x  != -1};
+
+private _magsArr = [];
+
+if (!((_magsFound # 0) in _pylonMagNames)) then {
+	// Not a pylon weapon, so check mags in turret storage
+	_thisArr pushBack format["        <font color='#87ffbb' face='PuristaSemiBold'>%1</font>", _wepDisp];
+	{
+	_thisMag = _x;
+		_magAmmo = _vic magazineTurretAmmo [_x, _path];
+		_magCount = (_magsHere select {_x # 0 == _thisMag} apply {_x # 1}) # 0;
+
+		private _magConfig = (configFile >> "CfgMagazines" >> _thisMag);
+		private _magName = [(_magConfig >> "displayName"), "STRING", "Magazine"] call CBA_fnc_getConfigEntry;
+		if (_magName isEqualTo "") then {_magName = "Magazine"};
+
+
+
+		_magsArr pushBack format[
+			"            + <font color='#4de4ff' size='12' face='PuristaMedium'><font color='#ffffff'>%1</font> <font color='#c2c2c2'>|</font> %2 <font color='#c2c2c2'>rounds</font> <font color='#c2c2c2'>|</font> %3 <font color='#c2c2c2'>mags</font></font>",
+			_magName,
+			_magAmmo,
+			_magCount
+		];
+	} forEach _magsFound;
+} else {
+	// This is a pylon weapon, so make a unique entry and directly check ammo on pylon
+	_thisArr pushBack format["        <font color='#87ffbb' face='PuristaSemiBold'>%1</font> <font face='PuristaMedium'>[Pylon]</font>", _wepDisp];
+};
+
+_thisArr pushBack _magsArr;
+// "debug_console" callExtension (str _magsArr + "#0100");
+_thisArr;
+// _thisArr;
+// "debug_console" callExtension (format[
+// 	"    %1 | %2 rounds | %3 mags#0110",
+// 	getText(configFile >> "CfgMagazines" >> _thisMag >> "displayName"),
+// 	_magAmmo,
+// 	_magCount
+// ]);

framework/fbcb2_assets/functions/fn_getStartingAndCurrentAssets.sqf

@@ -0,0 +1,17 @@
+#include "..\script_component.hpp"
+
+// get all starting assets at each base and combine to array
+private _startingAssetsByBase = call FUNC(getStartingAssetsByBase);
+private _startingAssets = [];
+{
+	_startingAssets append (_x#1);
+} forEach _startingAssetsByBase;
+
+// get all current assets at each base and combine to array
+private _assetsByBase = call FUNC(getCurrentAssetsByBase);
+private _assets = [];
+{
+	_assets append (_x#1);
+} forEach _assetsByBase;
+
+[_startingAssets, _assets];

framework/fbcb2_assets/functions/fn_getStartingAssetsByBase.sqf

@@ -0,0 +1,6 @@
+#include "../script_component.hpp"
+
+// return each base with its assets
+GVARMAIN(baseObjects) apply {
+	[_x, _x getVariable [QGVAR(assetsStartedAtThisBase), []]]
+};

framework/fbcb2_assets/functions/fn_getVehicleData.sqf

@@ -0,0 +1,166 @@
+params ["_vic"];
+
+private _title = [];
+private _image = [];
+private _info = [];
+private _capacity = [];
+
+// Excluded 2024-02-01
+// private _weapons = [];
+// private _pylonWeapons = [];
+// private _inventory = [];
+
+
+private _vicConfig = configOf _vic;
+private _class = configName _vicConfig;
+private _objType = (_vic call BIS_fnc_objectType) select 1;
+private _dispName = getText(_vicConfig >> 'displayName');
+
+// "debug_console" callExtension (format["VehicleName = %1", _dispName] + "#0110");
+
+private _cat = getText(_vicConfig >> 'category');
+private _fac = getText(_vicConfig >> 'faction');
+private _side = [getNumber(_vicConfig >> 'side')] call BIS_fnc_sideName;
+private _canFloat = (_vicConfig >> "canFloat") call BIS_fnc_getCfgDataBool;
+
+private _totalSeats = [_class, true] call BIS_fnc_crewCount; // Number of total seats: crew + non-FFV cargo/passengers + FFV cargo/passengers
+private _crewSeats = [_class, false] call BIS_fnc_crewCount; // Number of crew seats only
+private _driverSeats = fullcrew [_vic, "driver", true];
+private _gunnerSeats = fullCrew [_vic, "gunner", true];
+private _commanderSeats = fullCrew [_vic, "commander", true];
+// _cargoSeats = fullCrew [_vic, "cargo", true];
+private _cargoSeats = _totalSeats - _crewSeats; // Number of total cargo/passenger seats: non-FFV + FFV
+private _turretSeatsRaw = fullCrew [_vic, "turret", true];
+private _turretSeats = _turretSeatsRaw select {(_x # 4) isEqualTo false};
+private _ffvSeats = _turretSeatsRaw select {(_x # 4) isEqualTo true};
+
+private _pylons = getAllPylonsInfo _vic;
+
+///////////////////////////////////////////////
+// WRITE TITLE
+///////////////////////////////////////////////
+_title pushBack format["%1", _dispName];
+
+///////////////////////////////////////////////
+// WRITE IMAGE
+///////////////////////////////////////////////
+// Editor preview image
+_image pushBack format["<img width='200' image='%1'/>", getText(_vicConfig >> 'editorPreview')];
+_image pushBack linebreak;
+// Thumbnail image
+// _image pushBack format["<img width='128' height='64' image='%1'/>", getText(_vicConfig >> 'picture')];
+// _image pushBack linebreak;
+
+///////////////////////////////////////////////
+// WRITE INFO
+///////////////////////////////////////////////
+_info pushBack format["<font size='14' color='#e1701a' face='PuristaBold'>INFO</font>"];
+_info pushBack format["<font face='PuristaMedium'>  Classname: %1", _class];
+_info pushBack format["  Side: %1", _side];
+_info pushBack format["  Category: %1", _objType];
+_info pushBack format["  Faction: %1", _fac];
+_info pushBack format["  Can Float: %1", _canFloat];
+
+///////////////////////////////////////////////
+// WRITE CAPACITY
+///////////////////////////////////////////////
+_capacity pushBack format["<font size='14' color='#e1701a' face='PuristaBold'>CAPACITY: %1</font>", _totalSeats];
+_capacity pushBack format["<font face='PuristaMedium'>  Driver Seats: %1", count _driverSeats];
+_capacity pushBack format["  Gunner Seats: %1", count _gunnerSeats];
+_capacity pushBack format["  Commander Seats: %1", count _commanderSeats];
+_capacity pushBack format["  Turret Seats: %1", count _turretSeats];
+_capacity pushBack format["  Cargo Seats: %1", _cargoSeats];
+_capacity pushBack format["  FFV Seats: %1</font>", count _ffvSeats];
+
+///////////////////////////////////////////////
+// GATHER WEAPONS AVAILABLE TO SEATS AND TURRETS
+// EXCLUDED 2024-02-01
+///////////////////////////////////////////////
+// _weapons pushBack format["<font size='14' color='#e1701a' face='PuristaBold'>WEAPONS</font>"];
+// // DRIVER
+// [_driverSeats apply {_x # 3}, "DRIVER/PILOT", _weapons] call milsim_fbcb2_assets_fnc_getWeaponry;
+
+// //GUNNER
+// [_gunnerSeats apply {_x # 3}, "GUNNER/COPILOT", _weapons] call milsim_fbcb2_assets_fnc_getWeaponry;
+
+// // COMMANDER
+// // "debug_console" callExtension ("COMMANDER" + "#1100");
+// [_commanderSeats apply {_x # 3}, "COMMANDER", _weapons] call milsim_fbcb2_assets_fnc_getWeaponry;
+
+// // TURRETS
+// [_turretSeats apply {_x # 3}, "TURRET", _weapons] call milsim_fbcb2_assets_fnc_getWeaponry;
+
+///////////////////////////////////////////////
+// GATHER PYLON WEAPONS WITH AMMO
+// EXCLUDED 2024-02-01
+///////////////////////////////////////////////
+
+// _pilotWeps = [];
+// _otherWeps = [];
+
+// _parsePylonWeapons = {
+// 	params ["_input"];
+// 	_input params ["_index", "_name", "_turretPath", "_magazine","_ammoCount","_id"];
+// 	// "debug_console" callExtension (str _turretPath + "~0000");
+
+// 	_magName = getText(configFile >> "CfgMagazines" >> _magazine >> "displayName");
+// 	if (_magName isEqualTo "") exitWith {};
+
+// 	if (_turretPath isEqualTo [-1]) then {
+// 		_pilotWeps pushBack format[
+// 			"        <font color='#87ffbb' face='PuristaSemiBold'>%1</font> <font face='PuristaMedium'><font color='#c2c2c2'>|</font> <font color='#4de4ff'>%2</font> <font color='#c2c2c2'>rounds</font></font>",
+// 			_magName,
+// 			_ammoCount
+// 		];
+// 	} else {
+// 		_otherWeps pushBack format[
+// 			"        <font color='#87ffbb' face='PuristaSemiBold'>%1</font> <font face='PuristaMedium'><font color='#c2c2c2'>|</font> <font color='#4de4ff'>%2</font> <font color='#c2c2c2'>rounds</font></font>",
+// 			_magName,
+// 			_ammoCount
+// 		];
+// 	};
+// };
+
+///////////////////////////////////////////////
+// WRITE PYLON WEAPONS
+///////////////////////////////////////////////
+
+// if (count _pylons > 0) then {
+// 	_pylonWeapons pushBack format["<font size='14' color='#e1701a' face='PuristaBold'>PYLON WEAPONS</font>"];
+// 	{
+// 		[_x] call _parsePylonWeapons;
+// 	} forEach _pylons;
+// 	_pylonWeapons pushBack format["    <font color='#f6dcbf' face='PuristaSemiBold'>PILOT</font>"];
+// 	{
+// 		_pylonWeapons pushBack _x;
+// 	} forEach _pilotWeps;
+// 	_pylonWeapons pushBack format["    <font color='#f6dcbf' face='PuristaSemiBold'>GUNNER</font>"];
+// 	{
+// 		_pylonWeapons pushBack _x;
+// 	} forEach _otherWeps;
+// };
+
+///////////////////////////////////////////////
+// GATHER INVENTORY
+// EXCLUDED 2024-02-01
+///////////////////////////////////////////////
+// _invLines = [_vic] call milsim_fbcb2_assets_fnc_getInventory;
+// if (count _invLines > 0) then {
+// 	_inventory pushBack format["<font size='14' color='#e1701a' face='PuristaBold'>INVENTORY</font>"];
+// 	_inventory append _invLines;
+// };
+
+
+///////////////////////////////////////////////
+// CLOSE AND RETURN
+///////////////////////////////////////////////
+
+[_vicConfig, _dispName, [
+	_title joinString "<br/>",
+	_image joinString "<br/>",
+	_info joinString "<br/>",
+	_capacity joinString "<br/>"
+	// _weapons joinString "<br/>",
+	// _pylonWeapons joinString "<br/>",
+	// _inventory joinString "<br/>"
+]];

framework/fbcb2_assets/functions/fn_getWeaponry.sqf

@@ -0,0 +1,55 @@
+params ["_turretPaths", "_seatCategory", "_outArr"];
+{
+	_path = _x;
+	if (_path isEqualTo []) then {_path = [-1]};
+	_weps = _vic weaponsTurret _path;
+	private _thisArr = [];
+	if (count _weps isNotEqualTo 0) then {
+		_magsHere = _vic magazinesTurret _path call BIS_fnc_consolidateArray;
+
+		private _wepMags = [];
+		{
+			private _wepDet = [_vic, _path, _x, _magsHere, _pylons] call milsim_fbcb2_assets_fnc_getMagsForWeapon;
+			if (!(_wepDet isEqualTo [[]])) then {
+				_wepMags pushBack _wepDet;
+			};
+		} forEach _weps;
+
+		if (count _wepMags > 0) then {
+		// "debug_console" callExtension (format["_wepMags Driver = %1", [_wepMags] call CBA_fnc_encodeJSON] + "#1100");
+		{
+			_thisArr pushBack _x # 0;
+			if (count _x > 1) then {
+			{
+				_thisArr pushBack _x;
+			} forEach (_x # 1);
+			}
+		} forEach _wepMags;
+		};
+	};// else {
+		// "debug_console" callExtension (format["Running Mags Only."] + "#1100");
+		// "debug_console" callExtension (format["Vic: %1",_vic] + "#1100");
+		// "debug_console" callExtension (format["Path: %1", _path] + "#1100");
+	// 	_mags = ([_vic, _path] call _getMags);
+
+	// 	if (count _mags > 0) then {
+	// 		{
+	// 			_thisArr pushBack _x;
+	// 		} forEach _mags;
+	// 	};
+	// };
+
+	if (count _thisArr > 0) then {
+		private _turretConfig = [_vic, _x] call BIS_fnc_turretConfig;
+		private _turretDisplayName = [_turretConfig] call BIS_fnc_displayName;
+		if (_turretDisplayName != "") then {
+			_outArr pushBack format["    <font color='#f6dcbf' face='PuristaSemiBold'>%1 (""%2"")</font>", _seatCategory, _turretDisplayName];
+		} else {
+			_outArr pushBack format["    <font color='#f6dcbf' face='PuristaSemiBold'>%1</font>", _seatCategory];
+		};
+
+		{
+			_outArr pushBack _x;
+		} forEach _thisArr;
+	}
+} forEach _turretPaths;

framework/fbcb2_assets/functions/fn_hintAllApprovedAssets.sqf

@@ -0,0 +1,94 @@
+#include "..\script_component.hpp"
+
+// get vehicles the mission started with at base locations
+(call FUNC(getStartingAndCurrentAssets)) params [
+	"_startingAssets",
+	"_currentAssets"
+];
+
+// get distinct classnames to group by
+private _distinctStartingAssetsClassNames = [];
+{
+	_x params ["_netId", "_cfg"];
+	private _className = configName _cfg;
+	_distinctStartingAssetsClassNames pushBackUnique _className;
+} forEach _startingAssets;
+
+// get the approved assets config to identify callsigns
+private _approvedAssetsCfg = call EFUNC(common,getApprovedAssetsCfg);
+if (isNull _approvedAssetsCfg) exitWith {
+	[
+		LEVEL_ERROR,
+		QUOTE(COMPONENT),
+		"No approved assets defined.",
+		[]
+	] call EFUNC(common,log);
+	[
+		"ERROR: No approved assets defined. See defines/ApprovedAssets.hpp"
+	] call BIS_fnc_error;
+};
+
+_text = parseText "<t size='4'>MESSAGE</t>";
+_text = composeText [_text, lineBreak ];
+
+_text = composeText [_text, parseText "<t align='left' size='2'>Asset</t><t align='right' size='2'>Available</t>", lineBreak ];
+ 
+{
+	private _className = _x;
+	// only approved assets
+	if (!isClass (_approvedAssetsCfg >> _className)) then {continue};
+
+	private _callsign = [_className] call FUNC(getCallsignFromClassname);
+
+	private _startingAssetsOfThisType = _startingAssets select {
+		// select all starting assets of this type
+		_x params ["_netId", "_cfg"];
+		_className isEqualTo (configName _cfg);
+	};
+	private _currentAssetsOfThisType = _currentAssets select {
+		_x params ["_netId", "_cfg"];
+		private _object = _netId call BIS_fnc_objectFromNetId;
+		// objNull if deleted, then check classname and if alive
+		!isNull _object && {
+			_className isEqualTo (typeOf _object) &&
+			alive _object
+		};
+	};
+
+	(_startingAssetsOfThisType#0) params [
+		"_assetNetId",
+		"_assetCfg"
+	];
+
+	_assigned = count _startingAssetsOfThisType;
+	_available =  count _currentAssetsOfThisType;
+	// count (getMarkerPos "respawn_west"  nearEntities [ _asset, 2000] );  
+	
+	
+	_image = getText(_assetCfg >> "picture");
+
+	_name = getText(_assetCfg >> "displayName") select [0, 22];
+	private _data = format[
+		"<img size='1' align='left' image='%1'/><t size='1' align='left'>  %2</t><t size='1' align='right'>%3   [ %4 ]</t>",
+		_image,
+		_name,
+		_available,
+		_assigned
+	];
+
+	// private _data = format[
+	// 	"<img size='1' align='left' image='%1'/>
+	// 	<t size='1' align='left'>  %2</t>
+	// 	<t size='1' align='middle'>%3</t>
+	// 	<t size='1' align='right'>%4</t>",
+	// 	_image,
+	// 	_name,
+	// 	_assigned,
+	// 	_available
+	// ];
+	_text = composeText[ _text,  parseText _data, lineBreak ];  
+   
+  
+} foreach _distinctStartingAssetsClassNames;
+ 
+hint _text;

framework/fbcb2_assets/functions/fn_initClient.sqf

@@ -0,0 +1,28 @@
+#include "..\script_component.hpp"
+
+if (!hasInterface) exitWith {};
+
+call FUNC(updateAssetDiary);
+
+// once the server has published that assets have been gathered and distributed to bases (respawn modules),
+// we can update the asset diary on our end using that data
+[QGVAR(assetsGathered), {
+	[
+		LEVEL_DEBUG,
+		QUOTE(COMPONENT),
+		"Received gathered base asset data from server",
+		[]
+	] call EFUNC(common,log);
+
+	// update the asset diary with the data we've received
+	FUNC(updateAssetDiary);
+}] call CBA_fnc_addEventHandlerArgs;
+
+[
+	LEVEL_DEBUG,
+	QUOTE(COMPONENT),
+	"initClient complete",
+	[]
+] call EFUNC(common,log);
+
+localNamespace setVariable [QGVAR(complete), true];

framework/fbcb2_assets/functions/fn_initServer.sqf

@@ -0,0 +1,29 @@
+#include "..\script_component.hpp"
+
+if (!isServer) exitWith {};
+
+// init asset stores at bases
+[true] call FUNC(updateAssetsByBase);
+
+// starting 5 minutes after postInit, update asset stores every 5 minutes
+[{
+	[
+		{[false] call FUNC(updateAssetsByBase);},
+		60*5
+	] call CBA_fnc_addPerFrameHandler;
+}, 60*5] call CBA_fnc_waitAndExecute;
+
+
+// add end mission EH
+addMissionEventHandler ["MPEnded", {
+	// log the "current" asset counts to RPT
+	[false, true] call FUNC(updateAssetsByBase);
+}];
+
+
+[
+	LEVEL_DEBUG,
+	QUOTE(COMPONENT),
+	"postInit complete",
+	[]
+] call EFUNC(common,log);

framework/fbcb2_assets/functions/fn_isAssetInRangeOfBase.sqf

@@ -0,0 +1,8 @@
+#include "..\script_component.hpp"
+
+params [["_asset", objNull, [objNull]]];
+
+private _closestBase = [_asset] call EFUNC(common,getNearestBase);
+if (isNull _closestBase) exitWith {false};
+
+(_asset distance2D _closestBase) <= GVAR(setting_detectionRangeFromBase)

framework/fbcb2_assets/functions/fn_removeAssetDiaryRecords.sqf

@@ -0,0 +1,18 @@
+#include "..\script_component.hpp"
+
+if (!hasInterface) exitWith {};
+
+{
+	private _diarySubject = _x;
+	private _records = player allDiaryRecords _diarySubject;
+	if (count _records isEqualTo 0) then {continue};
+
+	{
+		private _diaryRecord = _x select -1;
+		player removeDiaryRecord [_diarySubject, _diaryRecord];
+	} forEach _records;
+} forEach [
+	EGVAR(fbcb2_main,subjectAssetsFixedWingID),
+	EGVAR(fbcb2_main,subjectAssetsRotaryID),
+	EGVAR(fbcb2_main,subjectAssetsGroundID)
+];

framework/fbcb2_assets/functions/fn_removeMarkersOnMap.sqf

@@ -0,0 +1,24 @@
+#include "..\script_component.hpp"
+
+private _baseMarkerStore = localNamespace getVariable [
+	QGVAR(baseMarkerStore),
+	[]
+];
+private _assetMarkerStore = localNamespace getVariable [
+	QGVAR(assetMarkerStore),
+	[]
+];
+
+// delete markers
+{
+	deleteMarkerLocal (_x#1);
+} forEach (_baseMarkerStore + _assetMarkerStore);
+
+localNamespace setVariable [
+	QGVAR(baseMarkerStore),
+	[]
+];
+localNamespace setVariable [
+	QGVAR(assetMarkerStore),
+	[]
+];

framework/fbcb2_assets/functions/fn_showMarkersOnMap.sqf

@@ -0,0 +1,111 @@
+#include "..\script_component.hpp"
+
+params [
+	["_className", "", [""]],
+	["_markerType", "hd_dot", [""]],
+	["_markerColor", "", [""]],
+	["_assetObjects", [], []]
+];
+
+if (count _className isEqualTo 0) exitWith {
+	["No class name provided!"] call BIS_fnc_error;
+};
+if (count _markerColor isEqualTo 0) exitWith {
+	["No marker color provided!"] call BIS_fnc_error;
+};
+if (count _assetObjects isEqualTo 0) exitWith {
+	["No vehicles to draw markers for!"] call BIS_fnc_error;
+};
+
+private _baseMarkerStoreVar = QGVAR(baseMarkerStore);
+private _assetMarkerStoreVar = QGVAR(assetMarkerStore);
+
+private _baseMarkerStore = localNamespace getVariable [
+	_baseMarkerStoreVar,
+	[]
+];
+private _assetMarkerStore = localNamespace getVariable [
+	_assetMarkerStoreVar,
+	[]
+];
+
+///////////////////////////////////////////////////////////////////////////////
+// Create base markers if not already present
+if (not (count _baseMarkerStore > 0)) then {
+	{ // milsim_baseObjects is accessed directly, so are valid objects
+		private _base = _x;
+
+		// create a circle marker with range as the detection range of assets
+		_newMarker = createMarkerLocal [
+			format["%1_%2", QGVAR(baseCircleMarker), _forEachIndex + 1],
+			getPosASL _base
+		];
+		_newMarker setMarkerTypeLocal "mil_dot";
+		_newMarker setMarkerColorLocal "ColorGreen";
+		_newMarker setMarkerShapeLocal "ELLIPSE";
+		_newMarker setMarkerSizeLocal [
+			GVAR(setting_detectionRangeFromBase),
+			GVAR(setting_detectionRangeFromBase)
+		];
+		_newMarker setMarkerAlphaLocal 0.5;
+		_newMarker setMarkerTextLocal str(_forEachIndex + 1);
+
+		_baseMarkerStore pushBack [
+			_base,
+			_newMarker
+		];
+
+		// create a flag marker at base position
+		_newMarker = createMarkerLocal [
+			format["%1_%2", QGVAR(baseFlagMarker), _forEachIndex + 1],
+			getPosASL _base
+		];
+		_newMarker setMarkerTypeLocal "mil_flag";
+		_newMarker setMarkerColorLocal "ColorGreen";
+		_newMarker setMarkerSizeLocal [0.7, 0.7];
+		_newMarker setMarkerTextLocal ([_base] call EFUNC(common,getNameOfBase));
+
+		_baseMarkerStore pushBack [
+			_base,
+			_newMarker
+		];
+	} forEach GVARMAIN(baseObjects);
+
+	localNamespace setVariable [_baseMarkerStoreVar, _baseMarkerStore];
+};
+
+
+private _start = (count _assetMarkerStore) + 1;
+{ // _assetObjects is a serialized parameter, so we pass the netIds (strings)
+	private _assetNetIdStr = _x;
+	private _asset = _assetNetIdStr call BIS_fnc_objectFromNetId;
+	// if asset was removed since last update
+	if (isNull _asset) then {continue};
+	// check if a marker is already placed for this asset
+	if (
+		(_assetMarkerStore findIf { _x select 0 isEqualTo _asset })
+		> -1
+	) then {continue};
+
+	// check if the asset is within base detection range
+	if (not ([_asset] call FUNC(isAssetInRangeOfBase))) then {continue};
+
+	// create a marker for the asset
+	private _newMarker = createMarkerLocal [
+		format["%1_%2", QGVAR(assetMarker), _start],
+		getPosASL _asset
+	];
+	_newMarker setMarkerAlphaLocal 1;
+	_newMarker setMarkerTypeLocal _markerType;
+	_newMarker setMarkerColorLocal _markerColor;
+	// _newMarker setMarkerTextLocal ([configOf _asset] call BIS_fnc_displayName);
+
+	_assetMarkerStore pushBack [
+		_asset,
+		_newMarker
+	];
+	_start = _start + 1;
+} forEach _assetObjects;
+
+// update store var
+localNamespace setVariable [_assetMarkerStoreVar, _assetMarkerStore];

framework/fbcb2_assets/functions/fn_updateAssetDiary.sqf

@@ -0,0 +1,261 @@
+#include "..\script_component.hpp"
+
+if (!hasInterface) exitWith {};
+
+// create diary records
+
+// remove any existing asset map markers
+call FUNC(removeMarkersOnMap);
+
+// remove existing asset records
+call FUNC(removeAssetDiaryRecords);
+
+(call FUNC(getStartingAndCurrentAssets)) params [
+	"_startingAssets",
+	"_currentAssets"
+];
+
+// get distinct vehicle class names
+private _distinctVehiclesClassNames = [];
+{
+	_x params ["_netId", "_cfg"];
+	private _className = configName _cfg;
+	_distinctVehiclesClassNames pushBackUnique _className;
+} forEach _startingAssets;
+
+
+// for random color cycling
+private _colorSelectionIndex = 0;
+private _randomColors = [
+	["ColorRed", "#FF0000", "Red"],
+	["ColorGreen", "#00FF00", "Green"],
+	["ColorBlue", "#0000FF", "Blue"],
+	["ColorYellow", "#FFFF00", "Yellow"],
+	["ColorWhite", "#FFFFFF", "White"]
+];
+
+// ForEach unique vehicle class name, we'll find the first and gather its info
+{
+	private _className = _x;
+	private _vehicleCallsign = toUpper (
+		[_className] call FUNC(getCallsignFromClassname)
+	);
+
+	// Get all starting assets of this type
+	private _startingAssetsOfThisType = _startingAssets select {
+		_x params ["_netId", "_cfg"];
+		_className isEqualTo (configName _cfg);
+	};
+	// Get all current assets of this type
+	private _currentAssetsOfThisType = _currentAssets select {
+		_x params ["_netId", "_cfg"];
+		private _object = _netId call BIS_fnc_objectFromNetId;
+		// objNull if deleted, then check classname and if alive
+		!isNull _object && {_className isEqualTo (typeOf _object) && alive _object};
+	};
+	// This should never happen, but...
+	if (count _startingAssetsOfThisType isEqualTo 0) then {continue};
+
+	// Try to find a not null vehicle that can be processed
+	private _exampleVehicleToProcess = objNull;
+	private _assetCfg = configNull;
+
+	private _exampleVehicleToProcessIndex = _startingAssetsOfThisType findIf {
+		_x params ["_netId", "_cfg"];
+		!isNull (_netId call BIS_fnc_objectFromNetId);
+	};
+	// If found, get the data
+	if (_exampleVehicleToProcessIndex > -1) then {
+		private _exampleData = _startingAssetsOfThisType select _exampleVehicleToProcessIndex;
+		_assetNetId = _exampleData#0;
+		_assetCfg = _exampleData#1;
+		_exampleVehicleToProcess = _assetNetId call BIS_fnc_objectFromNetId;
+	} else {
+		// otherwise, we only have the config to work with
+		private _exampleData = _startingAssetsOfThisType#0;
+		_assetCfg = _exampleData#1;
+	};
+
+	private _parentClassNames = [_assetCfg, true] call BIS_fnc_returnParents;
+	
+	
+
+	// Process the vehicle for extended info
+	// Exclusion list for display names
+	if (
+		[_assetCfg] call BIS_fnc_displayName
+		in ["Helicopter"]
+	) then {continue};
+	
+	// Get the vehicle data
+	private _processed = [configNull, "", []];
+	if (!isNull _exampleVehicleToProcess) then {
+		_processed = [_exampleVehicleToProcess] call FUNC(getVehicleData);
+	};
+	_processed params ["_processedVehicleCfg", "_displayName", "_diaryTextSections"];
+	_diaryTextSections params [
+		["_title", "", [""]],
+		["_image", "", [""]],
+		["_info", "", [""]],
+		["_capacity", "", [""]]
+		// ["_weapons", "", [""]],
+		// ["_pylonWeapons", "", [""]],
+		// ["_inventory", "", [""]]
+	];
+
+	// Get what we can from the vehicle cfg
+
+	// Create the diary record
+	private _recordText = [];
+	// Add the title and image
+	if (count _title isEqualTo 0) then {
+		_title = format["%1", [_assetCfg] call BIS_fnc_displayName];
+	};
+	_recordText pushBack format[
+		"<font size='24' shadow='1' color='#e1701a' face='PuristaBold'>%1</font>",
+		_title
+	];
+	if (count _image isEqualTo 0) then {
+		_image = format["<img width='200' image='%1'/>", getText(_assetCfg >> 'editorPreview')];
+	};
+	_recordText pushBack _image;
+	_recordText pushBack "<br/>";
+	_recordText pushBack format[
+		"CALLSIGN: %1",
+		_vehicleCallsign
+	];
+	_recordText pushBack format[
+		"COUNT STARTED: %1",
+		count _startingAssetsOfThisType
+	];
+	_recordText pushBack format[
+		"COUNT ACTIVE: %1",
+		count _currentAssetsOfThisType
+	];
+
+	// Here, we'll create a link to show markers on the map for all vehicles of this kind
+	// get 'picture' for record
+	private _icon = getText(_assetCfg >> "picture");
+	// determine marker type
+	private _markerType = "mil_dot";
+	switch (true) do {
+		case ("Helicopter" in _parentClassNames): {
+			_markerType = "loc_heli";
+		};
+		case ("Air" in _parentClassNames): {
+			_markerType = "loc_plane";
+		};
+		case ("Ship" in _parentClassNames): {
+			_markerType = "loc_boat";
+		};
+		case ("Car" in _parentClassNames): {
+			_markerType = "loc_car";
+		};
+		default {
+			_markerType = "loc_truck";
+		};
+	};
+
+	private "_randomColor";
+	if (_colorSelectionIndex < count _randomColors) then {
+			_randomColor = _randomColors select _colorSelectionIndex;
+			INC(_colorSelectionIndex);
+	} else {
+		_colorSelectionIndex = 0;
+		_randomColor = _randomColors select _colorSelectionIndex;
+	};
+
+	// Link to show markers
+	private _showMarkersText = format[
+		"<execute expression='[""%1"",""%2"",""%3"",%4] call %5'>SHOW MARKERS for vehicles at base</execute> (in %6)",
+		_className,
+		_markerType,
+		_randomColor#0,
+		(_currentAssetsOfThisType apply {
+			_x params ["_netId", "_cfg"];
+			_netId;
+		}),
+		QFUNC(showMarkersOnMap),
+		format["<font color='%1'>%2</font>", _randomColor#1, _randomColor#2]
+	];
+	_recordText pushBack _showMarkersText;
+
+	// Link to hide markers
+	_recordText pushBack format[
+		"<execute expression=""call %1"">REMOVE ALL MARKERS showing asset positions</execute>",
+		QFUNC(removeMarkersOnMap)
+	];
+
+	// Link to update asset diary entries
+	_recordText pushBack format[
+		"<execute expression=""call %1"">UPDATE ENTRIES for all assets</execute>",
+		QFUNC(updateAssetDiary)
+	];
+
+	// link to display hint with all assets
+	_recordText pushBack format[
+		"<execute expression=""call %1"">SHOW APPROVED ASSET COUNTS via hint</execute>",
+		QFUNC(hintAllApprovedAssets)
+	];
+
+	_recordText pushBack format[
+		"<font size='10' color='#777777'>%1</font>",
+		"Notes:<br/>
+			- Markers are only displayed on your local machine.<br/>
+			- The REMOVE ALL option will remove all assets' markers from the map.<br/>
+			- UPDATE ENTRIES will update the asset diary with the latest information.<br/>
+			- Markers will only be displayed for assets that are within a certain distance of a base."
+	];
+
+
+
+	// Add info and capacity sections - exclude if no living examples were found
+	if (count _info > 0) then {
+		_recordText pushBack _info;
+	};
+	if (count _capacity > 0) then {
+		_recordText pushBack _capacity;
+	};
+
+
+	private _subjectID = "";
+	switch (true) do {
+		case ("Helicopter" in _parentClassNames): {
+			_subjectID = EGVAR(fbcb2_main,subjectAssetsRotaryID);
+		};
+		case ("Air" in _parentClassNames): {
+			_subjectID = EGVAR(fbcb2_main,subjectAssetsFixedWingID);
+		};
+		default {
+			_subjectID = EGVAR(fbcb2_main,subjectAssetsGroundID);
+		};
+	};
+
+	[
+		_subjectID,
+		format[
+			"[%1/%2] %3",
+			count _currentAssetsOfThisType,
+			count _startingAssetsOfThisType,
+			(_assetCfg) call BIS_fnc_displayName
+		],
+		_recordText joinString "<br/>",
+		_icon
+	] call EFUNC(common,createOrUpdateDiaryRecord);
+
+// "\A3\ui_f\data\igui\cfg\simpleTasks\types\car_ca.paa"
+} forEach _distinctVehiclesClassNames;
+
+// log to RPT
+[
+	LEVEL_INFO,
+	QUOTE(COMPONENT),
+	"UPDATED ASSET DIARY",
+	[
+		["startingAssetCount", count _startingAssets],
+		["startingAssetCountDistinct", count _distinctVehiclesClassNames],
+		["currentassetCount", count _currentAssets]
+	]
+] call EFUNC(common,log);
+
+true;

framework/fbcb2_assets/functions/fn_updateAssetsByBase.sqf

@@ -0,0 +1,141 @@
+#include "..\script_component.hpp"
+
+params [
+	["_isInit", false, [false]],
+	["_logCurrentAssets", false, [false]]
+];
+
+if (!isServer) exitWith {};
+
+GVARMAIN(baseObjects) = allMissionObjects "ModuleRespawnPosition_F";
+
+// Get all approved assets on map, find the closest base
+// Then determine if it's within range
+// If it is, add it to the base's assets list
+// This is to ensure bases with overlapping detection range don't have duplicate assets
+private _allVehicles = vehicles;
+private _allSaved = [];
+
+private _assetsStartedAtThisBaseVar = QGVAR(assetsStartedAtThisBase);
+private _assetsAtThisBaseVar = QGVAR(assetsAtThisBase);
+
+private _approvedAssetsCfg = call EFUNC(common,getApprovedAssetsCfg);
+if (isNull _approvedAssetsCfg) exitWith {};
+
+private _currentBaseAssetsGathered = GVARMAIN(baseObjects) apply {[_x, []]};;
+
+{
+	private _className = configName _x;
+	private _callsign = getText(_x >> "callsign");
+	private _found = _allVehicles select { typeOf _x == _className };
+	{
+		private _asset = _x;
+
+		// ignore assets beyond the range of bases
+		if (not ([_asset] call FUNC(isAssetInRangeOfBase))) then {continue};
+
+
+		// add to base's assets list
+		private _closestBase = [_asset] call EFUNC(common,getNearestBase);
+		private _closestBaseCurrentAssets = (_currentBaseAssetsGathered select { _x select 0 isEqualTo _closestBase })#0#1;
+		_closestBaseCurrentAssets pushBackUnique  [
+			_asset call BIS_fnc_netId,
+			configOf _asset
+		];
+	} forEach _found;
+} forEach (_approvedAssetsCfg call BIS_fnc_returnChildren);
+
+// Add all ground vehicles (LandVehicle)
+{
+	private _asset = _x;
+
+	// ignore assets beyond the range of bases
+	if (not ([_asset] call FUNC(isAssetInRangeOfBase))) then {continue};
+
+	// add to base's assets list
+	private _closestBase = [_asset] call EFUNC(common,getNearestBase);
+	private _closestBaseCurrentAssets = (_currentBaseAssetsGathered select { _x select 0 isEqualTo _closestBase })#0#1;
+	_closestBaseCurrentAssets pushBackUnique  [
+		_asset call BIS_fnc_netId,
+		configOf _asset
+	];
+} forEach (_allVehicles select { _x isKindOf "LandVehicle" });
+
+////////////////////////////////////////////////////////////////////////
+// publish updated base variables
+////////////////////////////////////////////////////////////////////////
+{
+	private _base = _x;
+
+	private _thisBaseCurrentAssets = (_currentBaseAssetsGathered select { _x select 0 isEqualTo _base })#0#1;
+	_base setVariable [_assetsAtThisBaseVar, _thisBaseCurrentAssets, true];
+
+	if (_isInit) then {
+		_base setVariable [_assetsStartedAtThisBaseVar, _thisBaseCurrentAssets, true];
+	};
+} forEach GVARMAIN(baseObjects);
+
+// send a CBA event to let other scripts know that assets have been gathered
+[{[QGVAR(assetsGathered)] call CBA_fnc_globalEvent;}, 2] call CBA_fnc_waitAndExecute;
+
+////////////////////////////////////////////////////////////////////////
+// log starting assets if init
+// log current assets if requested (for end of mission counts)
+////////////////////////////////////////////////////////////////////////
+if !(_isInit || _logCurrentAssets) exitWith {};
+
+{
+	private _base = _x;
+
+	// get current assets
+	private _baseAssets = (_currentBaseAssetsGathered select { _x select 0 isEqualTo _base })#0#1;
+
+	// prepare key value for logging
+	private _baseAssetsHashesPrep = _baseAssets apply {
+		_x params ["_netId", "_cfg"];
+		[
+			["callsign", [configName _cfg] call FUNC(getCallsignFromClassname)],
+			["className", configName _cfg],
+			["displayName", [_cfg] call BIS_fnc_displayName]
+		];
+	};
+
+	_baseAssetsHashesPrep = _baseAssetsHashesPrep call BIS_fnc_consolidateArray;
+
+	private _baseAssetsHashes = [];
+	{
+		private _out = createHashMapFromArray (_x#0);
+		_out set ["count", _x#1];
+		_baseAssetsHashes pushBack _out;
+	} forEach _baseAssetsHashesPrep;
+
+	// if logging current assets
+	if (_logCurrentAssets) then {
+		{
+			[
+				LEVEL_INFO,
+				QUOTE(COMPONENT),
+				"CURRENT ASSETS",
+				[
+					["baseName", [[_base] call EFUNC(common,getNameOfBase)]],
+					["asset", _x]
+				]
+			] call EFUNC(common,log);
+		} forEach _baseAssetsHashes;
+	};
+
+	// if init, log starting assets
+	if (_isInit) then {		
+		{
+			[
+				LEVEL_INFO,
+				QUOTE(COMPONENT),
+				"STARTING ASSETS",
+				[
+					["baseName", [[_base] call EFUNC(common,getNameOfBase)]],
+					["asset", _x]
+				]
+			] call EFUNC(common,log);
+		} forEach _baseAssetsHashes;
+	};
+} forEach GVARMAIN(baseObjects);

framework/fbcb2_assets/script_component.hpp

@@ -0,0 +1,3 @@
+#define COMPONENT fbcb2_assets
+#define COMPONENT_BEAUTIFIED FBCB2 - Assets
+#include "../script_mod.hpp"

framework/fbcb2_main/functions/fn_addEnvironmentRecord.sqf

@@ -0,0 +1,112 @@
+#include "..\script_component.hpp"
+
+private _recordTitle = "ENVIRONMENTAL CONDITIONS";
+
+private _text = [
+	format[
+		"<font size='%1' color='%2' face='%3'>%4</font>",
+		GVAR(recordTitleSize),
+		GVAR(recordTitleColor),
+		GVAR(recordTitleFont),
+		_recordTitle
+	]
+];
+
+private _sunriseColor = "#4A86E8";
+private _sunsetColor = "#6AA84F";
+private _whiteColor = "#FFFFFF";
+
+private _sunTimes = date call BIS_fnc_sunriseSunsetTime;
+private _nearestBase = [player] call EFUNC(common,getNearestBase);
+
+if (isNull _nearestBase) exitWith {
+	[
+		LEVEL_WARNING,
+		QUOTE(COMPONENT),
+		"WARNING: No bases found nearby to report weather!",
+		[player, [
+			["position", getPos player]
+		]] call EFUNC(common,addPlayerInfoToArray)
+	] call EFUNC(common,log);
+	["WARNING: No bases found nearby to report weather!"] call BIS_fnc_error;
+};
+
+_text pushBack format[
+	"<font size='%1'>Current conditions at nearest weather station: %2</font><br/>",
+	GVAR(recordTextBodySize),
+	[_nearestBase] call EFUNC(common,getNameOfBase)
+];
+
+private _weatherData = [];
+
+if (isClass (configFile >> "CfgPatches" >> "ace_weather")) then {
+	// get ace_weather data
+	private _barometricPressure = ((getPosASL _nearestBase)#2) call ace_weather_fnc_calculateBarometricPressure;
+	private _relHumidity = missionNamespace getVariable ["ace_weather_currentHumidity", 0.5];
+	private _temperature = ((getPosASL _nearestBase)#2) call ace_weather_fnc_calculateTemperatureAtHeight;
+	private _dewPoint = [_temperature, _relHumidity] call ace_weather_fnc_calculateDewPoint;
+	private _windSpeed = [getPosASL _nearestBase, false, false, false] call ace_weather_fnc_calculateWindSpeed;
+	private _windChill = [_temperature, _windSpeed] call ace_weather_fnc_calculateWindChill;
+	private _heatIndex = [_temperature, _relHumidity] call ace_weather_fnc_calculateHeatIndex;
+
+	toFixed 2;
+	private _aceData = [
+		["Temperature", format["%1°C / %2°F", _temperature, _temperature * (9/5) + 32]],
+		["Wind Chill", format["%1°C / %2°F", _windChill, _windChill * (9/5) + 32]],
+		["Heat Index", format["%1°C / %2°F", _heatIndex, _heatIndex * (9/5) + 32]],
+		["Dew Point", format["%1°C / %2°F", _dewPoint, _dewPoint * (9/5) + 32]],
+		["Wind Speed", format["%1mph / %2kph / %3kts", _windSpeed * 2.237, _windSpeed * 3.6, _windSpeed * 1.944]],
+		["Wind Direction", ""],
+		["Barometric Pressure", format["%1 hPA", _barometricPressure]],
+		["Relative Humidity", format["%1%2", _relHumidity * 100, "%"]],
+		["Fog Cover", ""],
+		["Rain", ""],
+		["Overcast", ""]
+	];
+	toFixed -1;
+
+	{
+		_x params ["_name", "_value"];
+		[_weatherData, _name, _value] call BIS_fnc_setToPairs;
+	} forEach _aceData;
+};
+
+// always add built-in weather
+toFixed 2;
+private _vanillaData = [
+	["Temperature", format["%1°C", (ambientTemperature)#0]],
+	["Fog Cover", format["%1%2", fog * 100, "%"]],
+	["Overcast", format["%1%2", overcast * 100, "%"]],
+	["Rain", format["%1%2", rain * 100, "%"]],
+	["Wind Speed", format["%1m/s", windStr]],
+	["Wind Direction", format["%1°", windDir]]
+];
+toFixed -1;
+
+_vanillaData pushBack ["Sunrise", ([_sunTimes select 0, "HH:MM"] call BIS_fnc_timeToString)];
+_vanillaData pushBack ["Sunset", ([_sunTimes select 1, "HH:MM"] call BIS_fnc_timeToString)];
+
+// override or set keys for vanilla data into weather data
+{
+	_x params ["_name", "_value"];
+	[_weatherData, _name, _value] call BIS_fnc_setToPairs;
+} forEach _vanillaData;
+
+// write lines
+{
+	_x params ["_name", "_value"];
+	_text pushBack format[
+		"<font size='%1' face='EtelkaMonospacePro'>%2%3</font>",
+		GVAR(recordTextBodySize)-4,
+		[_name, "right", " ", 23] call EFUNC(common,padString),
+		_value
+	];
+} forEach _weatherData;
+
+_text = _text joinString "<br/>";
+
+[
+	GVAR(subjectIntelID),
+	_recordTitle,
+	_text
+] call EFUNC(common,createOrUpdateDiaryRecord);

framework/fbcb2_main/functions/fn_addFrequenciesRecord.sqf

@@ -0,0 +1,77 @@
+// updated 2024-02-01 by IndigoFox
+// now reads from the battalion config structure to generate the diary entries
+
+#include "../script_component.hpp"
+
+////////////////////////////////////////
+// Get info from missionConfigFile
+////////////////////////////////////////
+private _battalionInfoCfg = call EFUNC(common,getBattalionCfg);
+if (isNull _battalionInfoCfg) exitWith {
+	[
+		LEVEL_ERROR,
+		QUOTE(COMPONENT),
+		"Null Battalion Config",
+		[]
+	] call EFUNC(common,log);
+	["Null Battalion Config"] call BIS_fnc_error;
+};
+
+private _battalionElementCfgs = [_battalionInfoCfg >> "Command"] call BIS_fnc_returnChildren;
+if (count _battalionElementCfgs == 0) exitWith {
+	[
+		LEVEL_ERROR,
+		QUOTE(COMPONENT),
+		"ERROR: No battalion elements found. Check that the battalion config is correctly structured. See defines/BattalionInfo.hpp and framework/util/functions/getBattalionCfg.sqf.",
+		[]
+	] call EFUNC(common,log);
+	["ERROR: No battalion elements found. Check that the battalion config is correctly structured. See defines/BattalionInfo.hpp and framework/util/functions/getBattalionCfg.sqf."] call BIS_fnc_error;
+};
+
+////////////////////////////////////////
+// Define formatting constants
+////////////////////////////////////////
+private _ELEMENT_NAME_SIZE = 10;
+private _ELEMENT_NAME_FONT = "EtelkaMonospaceProBold";
+private _ELEMENT_FREQ_SIZE = 9;
+private _ELEMENT_FREQ_FONT = "EtelkaMonospacePro";
+private _FREQ_INDENT_CONSTANT = 6;
+private _FREQ_PAD_LENGTH = 17;
+private _FREQ_TEXT_COLOR = "#CCCCCC";
+// Note: Element colors are defined in the battalion config
+
+////////////////////////////////////////
+// ADD DIARY ENTRIES
+////////////////////////////////////////
+
+// First is all the battalion-level elements beneath command
+// To have the records listed in the order they appear in the battalion config, we need to reverse the array
+// Since each entry is added to the top of the list, this will result in the entries being added in the correct order
+reverse _battalionElementCfgs;
+
+{
+	[
+		LEVEL_TRACE,
+		QUOTE(COMPONENT),
+		format["Processing battalion element %1", configName _x],
+		[]
+	] call EFUNC(common,log);
+	// recursively generate diary text for all child elements of battalion-level elements
+	private _diaryTitleText = [_x, true] call FUNC(generateElementFrequencyRecordText);
+	[
+		GVAR(subjectFrequenciesID),
+		_diaryTitleText#0,
+		_diaryTitleText#1
+	] call EFUNC(common,createOrUpdateDiaryRecord);
+} forEach _battalionElementCfgs;
+
+// add the battalion command to the top of the list
+// don't process child elements
+private _diaryTitleText = [_battalionInfoCfg >> "Command", false] call FUNC(generateElementFrequencyRecordText);
+[
+	GVAR(subjectFrequenciesID),
+	_diaryTitleText#0,
+	_diaryTitleText#1
+] call EFUNC(common,createOrUpdateDiaryRecord);
+
+true;

framework/fbcb2_main/functions/fn_addSignalColorsRecord.sqf

@@ -0,0 +1,59 @@
+#include "../script_component.hpp"
+
+private _recordTitle = "SIGNAL COLORS";
+
+private _text = [
+	// Title
+	format[
+		"<font size='%1' color='%2' face='%3'>%4</font>",
+		GVAR(recordTitleSize),
+		GVAR(recordTitleColor),
+		GVAR(recordTitleFont),
+		_recordTitle
+	]
+];
+
+private _signalColorDefs = (missionConfigFile >> "SignalColors") call BIS_fnc_returnChildren;
+
+{
+	private _cfg = _x;
+	private _color = getText(_cfg >> "hexCode");
+	private _name = getText(_cfg >> "name");
+	private _usage = getText(_cfg >> "usage");
+	private _itemExamples = getArray(_cfg >> "itemExamples");
+
+	private _thisText = [];
+
+	_thisText pushBack format[
+		"<font size='%1'><font color='%2'>%3</font> - %4</font>",
+		GVAR(recordTextHeaderSize),
+		_color,
+		_name,
+		_usage
+	];
+
+	private _imagesLine = [];
+
+	{
+		private _itemClassname = _x;
+		private _itemCfg = [_itemClassname] call CBA_fnc_getItemConfig;
+		private _itemName = getText(_itemCfg >> "displayName");
+		private _itemImage = getText(_itemCfg >> "picture");
+		_imagesLine pushBack format[
+			"<img height='32' src='%1' title='%2'/>",
+			_itemImage,
+			_itemName
+		];
+	} forEach _itemExamples;
+
+	_thisText pushBack (_imagesLine joinString " ");
+	_text pushBack (_thisText joinString "<br/>");
+} forEach _signalColorDefs;
+
+_text = _text joinString "<br/><br/>";
+
+[
+	GVAR(subjectIntelID),
+	_recordTitle,
+	_text
+] call EFUNC(common,createOrUpdateDiaryRecord);

framework/fbcb2_main/functions/fn_initClient.sqf

@@ -0,0 +1,48 @@
+#include "../script_component.hpp"
+
+if ( !hasInterface ) exitWith {};
+
+GVAR(recordTitleColor) = "#ff6666";
+GVAR(recordTitleFont) = "PuristaMedium";
+GVAR(recordTitleSize) = 20;
+
+GVAR(recordTextHeaderSize) = 16;
+GVAR(recordTextBodySize) = 14;
+
+GVAR(subjectStatusID) = "FBCB2_Status";
+GVAR(subjectIntelID) = "FBCB2_Intel";
+GVAR(subjectMessagesID) = "FBCB2_Messages";
+GVAR(subjectFrequenciesID) = "FBCB2_Frequencies";
+GVAR(subjectAssetsFixedWingID) = "FBCB2_Assets_FixedWing";
+GVAR(subjectAssetsRotaryID) = "FBCB2_Assets_Rotary";
+GVAR(subjectAssetsGroundID) = "FBCB2_Assets_Ground";
+
+player createDiarySubject[GVAR(subjectStatusID), "FBCB2 Status"];
+player createDiarySubject[GVAR(subjectMessagesID), "FBCB2 Messages"];
+player createDiarySubject[GVAR(subjectIntelID), "FBCB2 Intel"];
+player createDiarySubject[GVAR(subjectFrequenciesID), "FBCB2 Frequencies"];
+player createDiarySubject[GVAR(subjectAssetsFixedWingID), "FBCB2 Planes"];
+player createDiarySubject[GVAR(subjectAssetsRotaryID), "FBCB2 Helicopters"];
+player createDiarySubject[GVAR(subjectAssetsGroundID), "FBCB2 Ground"];
+
+// run main inits
+[] call FUNC(addFrequenciesRecord);
+[] call FUNC(addSignalColorsRecord);
+[] call FUNC(addEnvironmentRecord);
+
+// starting 5 minutes after postInit, update weather diary record every 5 minutes
+[{
+	[
+		{call FUNC(addEnvironmentRecord);},
+		60*5
+	] call CBA_fnc_addPerFrameHandler;
+}, 60*5] call CBA_fnc_waitAndExecute;
+
+[
+	LEVEL_DEBUG,
+	QUOTE(COMPONENT),
+	"initClient complete",
+	[]
+] call EFUNC(common,log);
+
+localNamespace setVariable [QGVAR(complete), true];

framework/fbcb2_main/script_component.hpp

@@ -0,0 +1,3 @@
+#define COMPONENT fbcb2_main
+#define COMPONENT_BEAUTIFIED FBCB2 - Main
+#include "../script_mod.hpp"

framework/fbcb2_main/util/fn_formatRadioElementForDiary.sqf

@@ -0,0 +1,75 @@
+// called from milsim_fnc_processFBCB2RadioFrequencies
+#include "../script_component.hpp"
+
+params ["_cfg", ["_indentCount", 1, [5]]];
+
+//////////////////////////////////////////////////////
+// Define leading space/hyphenation for element name
+//////////////////////////////////////////////////////
+private _leadingSpace = [
+	format["<font size='%1' face='%2'>| ", _ELEMENT_NAME_SIZE, _ELEMENT_NAME_FONT]
+];
+for "_i" from 1 to _indentCount do {
+	_leadingSpace pushBack "-";
+};
+_leadingSpace pushBack " | </font>";
+
+/////////////////////////////////////////////////////////
+// Create the header line for the provided config entry
+/////////////////////////////////////////////////////////
+private _lines = [
+	format[
+		"<font color='%1'>%2%3</font>",
+		getText(_cfg >> "textColor"),
+		_leadingSpace joinString "",
+		getText (_cfg >> "callsign")
+	]
+];
+
+////////////////////////////////////////////////////////////
+// Create the frequency lines for the provided config entry
+////////////////////////////////////////////////////////////
+
+// Generate leading space
+private _freqLeadingSpace = [
+	format["<font size='%1' face='%2'>| ", _ELEMENT_NAME_SIZE, _ELEMENT_NAME_FONT]
+];
+for "_i" from 1 to _FREQ_INDENT_CONSTANT do {
+	_freqLeadingSpace pushBack " ";
+};
+_freqLeadingSpace pushBack "</font>";
+_freqLeadingSpace = _freqLeadingSpace joinString "";
+
+// Process config values for frequencies
+{
+	_x params ["_role", "_sr", "_lr"];
+
+
+	private ["_srStr", "_lrStr"];
+	if (count _sr > 0) then {
+		_srStr = format["%1", _sr joinString " / "];
+	} else {
+		_srStr = "----";
+	};
+	if (count _lr > 0) then {
+		_lrStr = format["%1", _lr joinString " / "];
+	} else {
+		_lrStr = "----";
+	};
+
+	// Add formatted line to the array
+	_lines pushBack format[
+		"%1<font size='%2' face='%3' color='%4'>- %5%6%7</font>",
+		_freqLeadingSpace,
+		_ELEMENT_FREQ_SIZE,
+		_ELEMENT_FREQ_FONT,
+		_FREQ_TEXT_COLOR,
+		[_role, "right", " ", _FREQ_PAD_LENGTH] call EFUNC(common,padString),
+		[_srStr, "right", " ", _FREQ_PAD_LENGTH] call EFUNC(common,padString),
+		_lrStr
+	];
+} forEach (getArray (_cfg >> "frequencies"));
+// diag_log text (_lines joinString endl);
+
+// Return the formatted lines in ARRAY format
+_lines;

framework/fbcb2_main/util/fn_generateElementFrequencyRecordText.sqf

@@ -0,0 +1,104 @@
+// called from milsim_fnc_processFBCB2RadioFrequencies ONLY
+// this function is called recursively to process all child elements of a battalion element in missionConfigFile
+
+#include "../script_component.hpp"
+
+params [
+	["_elementCfg", configNull, [configNull]],
+	["_shouldProcessChildCfgs", true]
+];
+
+if (isNull _elementCfg) exitWith {
+	["_elementCfg parameter is NULL"] call BIS_fnc_error;
+};
+
+// change reference variable for clarity
+private _battalionElement = _elementCfg;
+
+// Generate title from callsign and shortDescription
+private _recordTitle = format[
+	"%1 (%2)",
+	getText(_battalionElement >> "callsign"),
+	getText(_battalionElement >> "shortDescription")
+];
+// systemChat _recordTitle;
+
+
+//////////////////////////////////////////////////////////
+// Generate frequency table header line's leading space
+//////////////////////////////////////////////////////////
+private _freqLeadingSpace = [
+	format["<font size='%1' face='%2'>| ", _ELEMENT_NAME_SIZE, _ELEMENT_NAME_FONT]
+];
+for "_i" from 1 to _FREQ_INDENT_CONSTANT do {
+	_freqLeadingSpace pushBack " ";
+};
+_freqLeadingSpace pushBack "</font>";
+_freqLeadingSpace = _freqLeadingSpace joinString "";
+
+//////////////////////////////////////////////////////////
+// Generate header line and frequency table header line
+//////////////////////////////////////////////////////////
+
+private _headers = [
+	format[
+		"<font size='%1' color='%2' face='%3'>%4</font>",
+		GVAR(recordTitleSize),
+		GVAR(recordTitleColor),
+		GVAR(recordTitleFont),
+		_recordTitle
+	],
+	format[
+		"%1<font size='%2' face='%3' color='%4'>- %5%6%7</font>",
+		_freqLeadingSpace,
+		_ELEMENT_FREQ_SIZE,
+		_ELEMENT_FREQ_FONT,
+		_FREQ_TEXT_COLOR,
+		["ROLE", "right", " ", _FREQ_PAD_LENGTH] call EFUNC(common,padString),
+		["SR", "right", " ", _FREQ_PAD_LENGTH] call EFUNC(common,padString),
+		"LR"
+	]
+];
+
+
+//////////////////////////////////////////////////////////
+// Generate the list of element headers and frequencies
+//////////////////////////////////////////////////////////
+private _allText = [];
+
+// get all child elements recursively and format them
+if (_shouldProcessChildCfgs) then {
+	[
+		LEVEL_TRACE,
+		QUOTE(COMPONENT),
+		"Processing child elements for battalion element %1",
+		[]
+	] call EFUNC(common,log);
+
+	[_battalionElement, {
+		params ["_cfg", "_recurseCounter"];
+		// add config
+		private _lines = [_cfg, _recurseCounter+1] call FUNC(formatRadioElementForDiary);
+		// private _lines = [_cfg, _indentCount] call t;
+		_allText pushBack (_lines joinString "<br/>");
+	}] call EFUNC(common,recurseSubclasses);
+} else {
+	[
+		LEVEL_TRACE,
+		QUOTE(COMPONENT),
+		"Skipping processing of child elements for battalion element %1",
+		[]
+	] call EFUNC(common,log);
+
+	// or if the param was false, just add the battalion element
+	private _lines = [_battalionElement, 1] call FUNC(formatRadioElementForDiary);
+	// private _lines = [_cfg, _indentCount] call t;
+	_allText pushBack (_lines joinString "<br/>");
+};
+
+// add headers, add all other lines and format them as monospace
+_allText = format[
+	"%1<br/><br/><font face='EtelkaMonospaceProBold'>%2</font>", _headers joinString "<br/>", _allText joinString "<br/><br/>"];
+
+// return the title and all text
+[_recordTitle, _allText];

framework/init/functions/fn_addAARChatHandler.sqf

@@ -0,0 +1,18 @@
+#include "..\script_component.hpp"
+
+[
+	"saveaar", 
+	{
+		[] remoteExec["ocap_fnc_exportData", 2];
+	},
+	"admin"
+] call CBA_fnc_registerChatCommand;
+
+[
+	LEVEL_INFO,
+	QUOTE(COMPONENT),
+	"OCAP chat handler registered",
+	[player] call EFUNC(common,addPlayerInfoToArray)
+] call EFUNC(common,log);
+
+nil;

framework/init/functions/fn_addRespawnChatHandler.sqf

@@ -0,0 +1,31 @@
+#include "..\script_component.hpp"
+
+[
+	"respawn", 
+	{
+		_clientID = _thisArgs select 0;
+		player setDamage 1;
+
+		// log to server RPT
+		[
+			LEVEL_INFO,
+			QUOTE(COMPONENT),
+			"CHAT COMMAND RESPAWN",
+			[player] call EFUNC(common,addPlayerInfoToArray)
+		] remoteExec [QEFUNC(common,log), 2];
+
+		// systemChat to all remote machines
+		format["%1 claims they were glitched and respawned (%2)", name player, netID player] remoteExec["systemChat", -_clientID];
+	},
+	"all",
+	[clientOwner]
+] call CBA_fnc_registerChatCommand;
+
+[
+	LEVEL_INFO,
+	QUOTE(COMPONENT),
+	"respawn chat handler registered",
+	[player] call EFUNC(common,addPlayerInfoToArray)
+] call EFUNC(common,log);
+
+nil;

framework/init/functions/fn_initClient.sqf

@@ -0,0 +1,45 @@
+#include "..\script_component.hpp"
+
+if ( !hasInterface ) exitWith {};
+
+["milsim_logText", {
+	params [["_strArray", [""], [[]]]];
+	{
+		diag_log text _x;
+	} forEach _strArray;
+}] call CBA_fnc_addEventHandler;
+
+// make sure the server has finished init
+waitUntil {!isNil QGVARMAIN(complete)};
+
+["InitializePlayer", [player, true]] call BIS_fnc_dynamicGroups;
+
+// Initialize a holder for managing local diary records
+// store records in format:
+// [subject, [
+//		[title, diaryRecord]
+// ]]
+EGVAR(common,diaryRecords) = createHashMap;
+
+
+// initialize other modules
+call EFUNC(mapcopy,initClient);
+call EFUNC(reinsert,initClient);
+call EFUNC(resupply,initClient);
+call EFUNC(triageIcons,initClient);
+call EFUNC(vehicleFlags,initClient);
+call EFUNC(zeus,initClient);
+call EFUNC(fbcb2_main,initClient);
+call EFUNC(fbcb2_assets,initClient);
+
+
+[
+	LEVEL_DEBUG,
+	QUOTE(COMPONENT),
+	"initClient complete",
+	[]
+] call EFUNC(common,log);
+
+localNamespace setVariable [QGVAR(complete), true];
+
+nil;

framework/init/functions/fn_initServer.sqf

@@ -0,0 +1,42 @@
+#include "..\script_component.hpp"
+
+if (!isServer) exitWith {};
+
+// array of all respawn modules in the mission representing "bases"
+GVARMAIN(baseObjects) = allMissionObjects "ModuleRespawnPosition_F";
+publicVariable QGVARMAIN(baseObjects);
+
+// Initializes the Dynamic Groups framework and groups
+["Initialize", [true]] call BIS_fnc_dynamicGroups;
+
+if (isDedicated) then {
+	["milsim_logText", {
+		params [["_strArray", [""], [[]]]];
+		{
+			diag_log text _x;
+		} forEach _strArray;
+	}] call CBA_fnc_addEventHandler;
+};
+
+
+// initialize other modules
+call EFUNC(common,logMissionInfo);
+call EFUNC(fbcb2_assets,initServer);
+call EFUNC(reinsert,initServer);
+
+// declare init complete to other modules
+missionNamespace setVariable [QGVARMAIN(complete), true, true];
+
+[
+	LEVEL_INFO,
+	QUOTE(COMPONENT),
+	format["%1: version %2", QGVARMAIN(complete), QUOTE(VERSION_STR)],
+	[["version", QUOTE(VERSION_STR)]]
+] call EFUNC(common,log);
+
+[
+	LEVEL_DEBUG,
+	QUOTE(COMPONENT),
+	"postInit complete",
+	[]
+] call EFUNC(common,log);

framework/init/functions/fn_setDefaults.sqf

@@ -0,0 +1,34 @@
+#include "..\script_component.hpp"
+
+enableSaving[false, false];
+
+enableRadio false;
+enableSentences false;
+
+missionNamespace setVariable ["ACE_maxWeightDrag", 2400]; 
+missionNamespace setVariable ["ACE_maxWeightCarry", 1800]; 
+
+if(isClass(configfile >> "CfgPatches" >> "rhs_main")) then {
+    rhs_vehicleRadioChatter = 0;
+};
+
+waitUntil {time > 0};
+
+enableEnvironment[false, true];
+
+[
+	LEVEL_INFO,
+	QUOTE(COMPONENT),
+	"Defaults set",
+	[
+		["enableSaving", [false, false]],
+		["enableRadio", false],
+		["enableSentences", false],
+		["ACE_maxWeightDrag", 2400],
+		["ACE_maxWeightCarry", 1800],
+		["rhs_vehicleRadioChatter", 0],
+		["enableEnvironment", [false, true]]
+	]
+] call EFUNC(common,log);
+
+nil;

framework/init/script_component.hpp

@@ -0,0 +1,3 @@
+#define COMPONENT init
+#define COMPONENT_BEAUTIFIED Init
+#include "../script_mod.hpp"

framework/mapcopy/functions/fn_addCBASettings.sqf

@@ -0,0 +1,24 @@
+#include "..\script_component.hpp"
+
+[
+	QGVAR(setting_enable),
+	"CHECKBOX",
+	"Allow Map Copying",
+	[QUOTE(SETTINGS_GROUP_NAME), QUOTE(COMPONENT_BEAUTIFIED)],
+	true, // default value
+	true, // is global
+	{
+		params ["_value"];
+		[
+			QGVAR(setting_enable),
+			_value
+		] call EFUNC(common,logSettingChanged);
+	}
+] call CBA_fnc_addSetting;
+
+[
+	LEVEL_INFO,
+	QUOTE(COMPONENT),
+	"CREATED SETTINGS",
+	[]
+] call EFUNC(common,log);

framework/mapcopy/functions/fn_getMapMarkers.sqf

@@ -0,0 +1,15 @@
+#include "..\script_component.hpp"
+// serializes markers on local machine and returns them as array
+
+_markerData = [];
+
+{
+	_marker = toArray _x;
+	_marker resize 15;
+	if ( toString _marker == "_USER_DEFINED #" ) then {
+		_marker = _x call FUNC(mapMarkerToString);
+		_markerData pushBack _marker;
+	};
+} forEach allMapMarkers;
+
+_markerData;

framework/mapcopy/functions/fn_initClient.sqf

@@ -0,0 +1,57 @@
+#include "..\script_component.hpp"
+
+////////////////////////////////////////////////////////////////////
+// Create action to copy map markers on all inheritors of CAManBase
+////////////////////////////////////////////////////////////////////
+private _mapCopyAction =
+[
+	QGVAR(actionID),
+	"Copy Map",
+	"\a3\ui_f\data\igui\cfg\actions\talk_ca.paa",
+	{
+		params ["_target", "_player", "_params"];
+		format["Copying map markers from %1", name _target] call CBA_fnc_notify;
+		[QGVAR(mapCopyRequest), _this, _target] call CBA_fnc_targetEvent;
+	},
+	{
+		params ["_target", "_player", "_params"];
+		[QGVAR(setting_enable)] call CBA_settings_fnc_get && {
+			('ItemMap' in (assignedItems _player)) &&
+			('ItemMap' in (assignedItems _target)) &&
+			([_player, _target, []] call ace_common_fnc_canInteractWith)
+		};
+	}
+] call ace_interact_menu_fnc_createAction;
+["CAManBase", 0, ["ACE_MainActions"], _mapCopyAction, true] call ace_interact_menu_fnc_addActionToClass;
+
+////////////////////////////////////////////////////////////////////
+// Create CBA event to receive requests
+////////////////////////////////////////////////////////////////////
+[QGVAR(mapCopyRequest), {
+	params ["_me", "_requester", "_params"];
+	format["Your map is being copied by %1", name _requester] call CBA_fnc_notify;
+	private _myMarkers = _this call FUNC(getMapMarkers);
+	[QGVAR(mapCopyResponse), [_me, _myMarkers], _requester] call CBA_fnc_targetEvent;
+}] call CBA_fnc_addEventHandler;
+
+////////////////////////////////////////////////////////////////////
+// Create CBA event to receive responses
+////////////////////////////////////////////////////////////////////
+[QGVAR(mapCopyResponse), {
+	params [["_responder", objNull, [objNull]], ["_markerList", [], [[]]]];
+	if ('ItemMap' in (assignedItems player)) then {
+		[_markerList] call FUNC(loadMapMarkers);
+		format["Copied %1 markers from %2", count _markerList, name _responder] call CBA_fnc_notify;
+	} else {
+		format["You need a map to copy onto!"] call CBA_fnc_notify;
+	};
+}] call CBA_fnc_addEventHandler;
+
+[
+	LEVEL_DEBUG,
+	QUOTE(COMPONENT),
+	"initClient complete",
+	[]
+] call EFUNC(common,log);
+
+localNamespace setVariable [QGVAR(complete), true];

framework/mapcopy/functions/fn_loadMapMarkers.sqf

@@ -0,0 +1,8 @@
+#include "..\script_component.hpp"
+// accepts an array of serialized markers and adds them to local map
+
+params [["_markerList", [], [[]]]];
+
+{
+	_x call FUNC(stringToMapMarker);
+} foreach _markerList;

framework/mapcopy/script_component.hpp

@@ -0,0 +1,3 @@
+#define COMPONENT mapcopy
+#define COMPONENT_BEAUTIFIED Map Copy
+#include "../script_mod.hpp"

framework/performance/functions/fn_addCBASettings.sqf

@@ -0,0 +1,105 @@
+#include "..\script_component.hpp"
+
+//---------------------
+//	Server CPS
+//---------------------
+
+[
+	QGVAR(server_cps_enable),
+	"CHECKBOX",
+	"Server CPS Metrics Enabled",
+	[QUOTE(SETTINGS_GROUP_NAME), QUOTE(COMPONENT_BEAUTIFIED)],
+	true,
+	true,
+	{
+		params ["_value"];
+		[
+			QGVAR(cps_enable),
+			_value
+		] call EFUNC(common,logSettingChanged);
+	}
+] call CBA_fnc_addSetting;
+
+[QGVAR(cps_enable), true] call CBA_settings_fnc_set;
+
+[
+	QGVAR(server_cps_interval),
+	"TIME",
+	"Server CPS Metrics Interval",
+	[QUOTE(SETTINGS_GROUP_NAME), QUOTE(COMPONENT_BEAUTIFIED)],
+	[60,300,120],
+	true,
+	{
+		if (!isServer) exitWith {};
+		
+		params ["_value"];
+
+		[
+			QGVAR(cps_interval),
+			_value
+		] call EFUNC(common,logSettingChanged);
+		
+		_cpsPFH = missionNamespace getVariable [QGVAR(server_cps_handler), ObjNull];
+		if (!isNull _cpsPFH) then {
+			_cpsPFH call CBA_fnc_deletePerFrameHandlerObject;
+		};
+
+		[] call FUNC(addServerStatsPFH);
+	}
+] call CBA_fnc_addSetting;
+
+
+//---------------------
+//	Client CPS
+//---------------------
+
+[
+	QGVAR(client_cps_enable),
+	"CHECKBOX",
+	"Client CPS Metrics Enabled",
+	[QUOTE(SETTINGS_GROUP_NAME), QUOTE(COMPONENT_BEAUTIFIED)],
+	true,
+	true,
+	{
+		params ["_value"];
+		[
+			QGVAR(client_cps_enable),
+			_value
+		] call EFUNC(common,logSettingChanged);
+	}
+] call CBA_fnc_addSetting;
+
+[QGVAR(client_cps_enable), true] call CBA_settings_fnc_set;
+
+[
+	QGVAR(client_cps_interval),
+	"TIME",
+	"Client CPS Metrics Interval",
+	[QUOTE(SETTINGS_GROUP_NAME), QUOTE(COMPONENT_BEAUTIFIED)],
+	[60,300,120],
+	true,
+	{
+		if (!hasInterface) exitWith {};
+		
+		params ["_value"];
+
+		[
+			QGVAR(client_cps_interval),
+			_value
+		] call EFUNC(common,logSettingChanged);
+
+		_cpsPFH = player getVariable [QGVAR(client_cps_handler), ObjNull];
+		if (!isNull _cpsPFH) then {
+			_cpsPFH call CBA_fnc_deletePerFrameHandlerObject;
+		};
+
+		[] call FUNC(addClientStatsPFH);
+	}
+] call CBA_fnc_addSetting;
+
+[
+	LEVEL_INFO,
+	QUOTE(COMPONENT),
+	"CREATED SETTINGS",
+	[]
+] call EFUNC(common,log);

framework/performance/functions/fn_addClientStatsPFH.sqf

@@ -0,0 +1,38 @@
+#include "..\script_component.hpp"
+
+if (!hasInterface) exitWith {};
+
+[
+	LEVEL_INFO,
+	QUOTE(COMPONENT),
+	"Initializing client stats PFH",
+	[]
+] call EFUNC(common,log);
+
+_cpsPFH = [
+	{ 
+		[] call FUNC(calculateClientStats);
+	},
+	QGVAR(client_cps_interval) call CBA_settings_fnc_get,
+	[],
+	{ 
+		[
+			LEVEL_INFO,
+			QUOTE(COMPONENT),
+			"Client PFH loaded",
+			[["pfhInterval", QGVAR(client_cps_interval) call CBA_settings_fnc_get]]
+		] call EFUNC(common,log);
+	},
+	{ 	[
+			LEVEL_INFO,
+			QUOTE(COMPONENT),
+			"Client PFH unloaded",
+			[]
+		] call EFUNC(common,log);
+	},
+	{ QGVAR(client_cps_enable) call CBA_settings_fnc_get },
+	{ false },
+	[]
+] call CBA_fnc_createPerFrameHandlerObject;
+
+player setVariable [QGVAR(client_cps_handler), _cpsPFH];

framework/performance/functions/fn_addDNI_PlayerFPS.sqf

@@ -1,3 +1,5 @@
+#include "..\script_component.hpp"
+
 if ( !hasInterface ) exitWith {};
 
 diag_log text "[MILSIM] (DNI) writing variable loop";

framework/performance/functions/fn_addServerStatsPFH.sqf

@@ -1,28 +1,48 @@
+#include "..\script_component.hpp"
+
 if (!isServer) exitWith {};
 
-missionNamespace setVariable["milsim_raw_cps", 0];
+missionNamespace setVariable[QGVAR(raw_cps), 0];
-missionNamespace setVariable["milsim_cps", 0];
+missionNamespace setVariable[QGVAR(cps), 0];
 
-publicVariable "milsim_raw_cps";
+publicVariable QGVAR(raw_cps);
-publicVariable "milsim_cps";
+publicVariable QGVAR(cps);
 
-diag_log text format ["[MILSIM] (server) initializing Server Stats PFH"];
+[
+	LEVEL_INFO,
+	QUOTE(COMPONENT),
+	"Initializing server stats PFH",
+	[]
+] call EFUNC(common,log);
 
 _serverCpsPFH = [
 	{ 
-		[] call milsim_fnc_calculateServerStats;
+		[] call FUNC(calculateServerStats);
 	},
-	"milsim_server_cps_interval" call CBA_settings_fnc_get,
+	QGVAR(server_cps_interval) call CBA_settings_fnc_get,
 	[],
-	{ diag_log text format ["[MILSIM] (server) Server PFH loaded with interval %1 seconds", "milsim_server_cps_interval" call CBA_settings_fnc_get ] },
+	{ 
-	{ diag_log text format ["[MILSIM] (server) Server PFH unloaded"] },
+		[
-	{ "milsim_server_cps_enable" call CBA_settings_fnc_get },
+			LEVEL_INFO,
+			QUOTE(COMPONENT),
+			"Server PFH loaded",
+			[["pfhInterval", QGVAR(server_cps_interval) call CBA_settings_fnc_get]]
+		] call EFUNC(common,log);
+	},
+	{ 	[
+			LEVEL_INFO,
+			QUOTE(COMPONENT),
+			"Server PFH unloaded",
+			[]
+		] call EFUNC(common,log);
+	},
+	{ QGVAR(server_cps_enable) call CBA_settings_fnc_get },
 	{ false },
 	[]
 ] call CBA_fnc_createPerFrameHandlerObject;
 
 
-missionNamespace setVariable ["milsim_server_cps_handler", _serverCpsPFH];
+missionNamespace setVariable [QGVAR(server_cps_handler), _serverCpsPFH];
 
 _playerCpsPFH = [
 	{ 

framework/performance/functions/fn_calculateClientStats.sqf

@@ -1,3 +1,5 @@
+#include "..\script_component.hpp"
+
 [] spawn {
 	// warning: while loop without suspension executes multiple times per frame
 	private _counter = 0;
@@ -8,8 +10,8 @@
 		_counter = _counter + 1;
 	};
 	// in an empty mission, the _counter may go well over 2000 times per frame!
-	diag_log text format ["[MILSIM] (client) Average Execution: %1 times per frame", _counter / (diag_frameNo - _frameNo)];
+	private _rawCPS = _counter / (diag_frameNo - _frameNo);
-	player setVariable ["milsim_player_raw_cps", _counter / (diag_frameNo - _frameNo), true];
+	player setVariable [QGVAR(player_raw_cps), _rawCPS, true];
 
 	// with suspension
 	private _counter = 0;
@@ -21,9 +23,23 @@
 		uiSleep 0.001; // waits at least 1 frame
 	};
 	// _counter says one per frame, as expected
-	diag_log text format ["[MILSIM] (client) Average Execution: %1 times per frame", _counter / (diag_frameNo - _frameNo)];
+	private _playerCPS = _counter / (diag_frameNo - _frameNo);
-	player setVariable ["milsim_player_cps", _counter / (diag_frameNo - _frameNo), true];
+	player setVariable [QGVAR(player_cps), _playerCPS, true];
 
+	// log to RPT
+	[
+		
+		{_this call EFUNC(common,log);},
+		[
+			LEVEL_INFO,
+			QUOTE(COMPONENT),
+			format ["Average Execution: %1 times per frame", _playerCPS],
+			[
+				["playerRawCPS", _rawCPS],
+				["playerCPS", _playerCPS]
+			]
+		]
+	] call CBA_fnc_directCall;
 };
 
 nil;

framework/performance/functions/fn_calculateServerStats.sqf

@@ -0,0 +1,54 @@
+#include "..\script_component.hpp"
+
+[] spawn {
+	// warning: while loop without suspension executes multiple times per frame
+	private _counter = 0;
+	private _endTime = diag_tickTime + 5;
+	private _frameNo = diag_frameNo;
+	while { diag_tickTime < _endTime } do
+	{
+		_counter = _counter + 1;
+	};
+
+	private _rawCPS = _counter / (diag_frameNo - _frameNo);
+	missionNamespace setVariable [QGVAR(server_raw_cps), _rawCPS];
+	publicVariable QGVAR(server_raw_cps);
+
+	// with suspension
+	private _counter = 0;
+	private _endTime = diag_tickTime + 5;
+	private _frameNo = diag_frameNo;
+	while { diag_tickTime < _endTime } do
+	{
+		_counter = _counter + 1;
+		uiSleep 0.001; // waits at least 1 frame
+	};
+
+	private _serverCPS = _counter / (diag_frameNo - _frameNo);
+	missionNamespace setVariable [QGVAR(server_cps), _counter / (diag_frameNo - _frameNo)];
+	publicVariable QGVAR(server_cps);
+
+	// log to RPT
+	[
+		
+		{_this call EFUNC(common,log);},
+		[
+			LEVEL_INFO,
+			QUOTE(COMPONENT),
+			format ["Average Server Execution: %1 times per frame", _serverCPS],
+			[
+				["serverRawCPS", _rawCPS],
+				["serverCPS", _serverCPS]
+			]
+		]
+	] call CBA_fnc_directCall;
+
+	[QGVARMAIN(serverEfficiency), [
+		[
+			["float", QGVARMAIN(raw_cps), missionNamespace getVariable [QGVAR(server_raw_cps), -1]],
+			["float", QGVARMAIN(cps), missionNamespace getVariable [QGVAR(server_cps), -1]]
+		]
+	]] call CBA_fnc_localEvent;
+};
+
+nil;

framework/performance/script_component.hpp

@@ -0,0 +1,3 @@
+#define COMPONENT performance
+#define COMPONENT_BEAUTIFIED Performance Monitoring
+#include "../script_mod.hpp"

framework/reinsert/client/fn_addAceSelfActions.sqf

@@ -0,0 +1,65 @@
+#include "..\script_component.hpp"
+
+params [
+	["_types", [], [[]]], // classnames to assign these action to
+	["_useInheritance", false, [false]]
+]; 
+
+{ // forEach _types
+	private _classToAddActionsTo = _x;
+
+	private _fileForReinsertAction = [
+		QGVAR(fileReinsertRequestAction),
+		"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 EFUNC(common,getNearestBase);
+			private _baseName = [_base] call EFUNC(common,getNameOfBase);
+			// send event to server
+			[QGVAR(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 EFUNC(common,getNearestBase);
+			private _baseDistance = _player distance _base;
+
+			private _maxRangeToReady = [QGVAR(setting_maxRangeToReady)] call CBA_settings_fnc_get;
+			private _existingQueue = missionNamespace getVariable [QGVAR(reinsertionQueue), []];
+
+			// check if module is enabled, player is near a base, and player is not already in the queue
+			// (serverTime - GVAR(missionStartServerTime)) > 60*5 && // only allow after 15 minutes
+			[QGVAR(setting_enabled)] call CBA_settings_fnc_get &&
+			(_baseDistance < _maxRangeToReady) &&
+			not (_player in (_existingQueue apply {_x#0}))
+		}
+	] call ace_interact_menu_fnc_createAction;
+	[_classToAddActionsTo, 1, ["ACE_SelfActions"], _fileForReinsertAction, _useInheritance] call ace_interact_menu_fnc_addActionToClass;
+
+	private _removeFileForReinsertAction = [
+		QGVAR(removeReinsertRequestAction),
+		"Remove Re-insert Request",
+		"\A3\ui_f\data\igui\cfg\simpleTasks\types\land_ca.paa",
+		{ // statement
+			params ["_target", "_player", "_params"];
+			// send event to server
+			[QGVAR(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 [QGVAR(reinsertionQueue), []];
+
+			// check if module is enabled, player is in the queue
+			// (serverTime - GVAR(missionStartServerTime)) > 60*5 && // only allow after 15 minutes
+			[QGVAR(setting_enabled)] call CBA_settings_fnc_get &&
+			(_player in (_existingQueue apply {_x#0}))
+		}
+	] call ace_interact_menu_fnc_createAction;
+	[_classToAddActionsTo, 1, ["ACE_SelfActions"], _removeFileForReinsertAction, _useInheritance] call ace_interact_menu_fnc_addActionToClass;
+} forEach _types;

framework/reinsert/client/fn_addCheckQueueSelfAction.sqf

@@ -0,0 +1,28 @@
+#include "..\script_component.hpp"
+
+params [
+	["_types", [], [[]]], // classnames to assign these action to
+	["_useInheritance", false, [false]]
+];
+
+{ // forEach _types
+	private _classToAddActionsTo = _x;
+
+	private _checkReinsertQueueAction = [
+		QGVAR(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 FUNC(requestShowQueue);
+			// reset last check time
+			localNamespace setVariable [QGVAR(lastReinsertQueueCheck), diag_tickTime];
+		},
+		{
+			GVAR(setting_enabled);
+		} // condition
+	] call ace_interact_menu_fnc_createAction;
+	[_classToAddActionsTo, 1, ["ACE_SelfActions"], _checkReinsertQueueAction, _useInheritance] call ace_interact_menu_fnc_addActionToClass;
+
+} forEach _types;

framework/reinsert/client/fn_initClient.sqf

@@ -0,0 +1,54 @@
+#include "..\script_component.hpp"
+
+if (!hasInterface) exitWith {};
+
+// ACE SELF-INTERACTIONS FOR FILING AND RESCINDING REINSERT REQUESTS NEAR BASE - ALL PLAYERS
+localNamespace setVariable [QGVAR(fileForReinsertClassesAdded), []];
+// add actions to current class
+[["CAManBase"], true] call FUNC(addAceSelfActions);
+
+/////////////////////////////////////////////////////
+// PILOTS ONLY
+// ACE SELF-INTERACTIONS FOR CHECKING REINSERT QUEUE - ONLY FOR PILOTS
+localNamespace setVariable [QGVAR(checkReinsertQueueClassesAdded), []];
+localNamespace setVariable [QGVAR(lastReinsertQueueCheck), diag_tickTime];
+
+// add actions to pilot classes, and don't apply to child classes
+[["B_Helipilot_F", "B_helicrew_F"], false] call FUNC(addCheckQueueSelfAction);
+/////////////////////////////////////////////////////
+
+
+// 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 (
+			[QGVAR(setting_enabled)] call CBA_settings_fnc_get and
+			[QGVAR(setting_pilotForcedCheckEnabled)] call CBA_settings_fnc_get
+		)) exitWith {};
+
+		// if last check was less than X minutes ago, skip
+		private _lastCheck = localNamespace getVariable [QGVAR(lastReinsertQueueCheck), diag_tickTime];
+		private _requiredCheckInterval = [QGVAR(setting_pilotForcedCheckInterval)] call CBA_settings_fnc_get;
+		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 [QGVAR(lastReinsertQueueCheck), diag_tickTime];
+		// request notification from the server
+		call FUNC(requestShowQueue);
+	}, 30] call CBA_fnc_addPerFrameHandler;
+};
+/////////////////////////////////////////////////////
+
+[
+	LEVEL_DEBUG,
+	QUOTE(COMPONENT),
+	"initClient complete",
+	[]
+] call EFUNC(common,log);
+
+localNamespace setVariable [QGVAR(complete), true];

framework/reinsert/client/fn_requestShowQueue.sqf

@@ -0,0 +1,5 @@
+#include "..\script_component.hpp"
+
+if (!hasInterface) exitWith {};
+
+[] remoteExec [QFUNC(returnReinsertQueueNotification), 2];

framework/reinsert/functions/fn_addCBASettings.sqf

@@ -0,0 +1,83 @@
+#include "..\script_component.hpp"
+
+//---------------------
+// Respawn Settings
+[
+	QGVAR(setting_enabled), // variable
+	"CHECKBOX", // type
+	["Enabled", "Whether or not players can file for reinsert and pilots can check the reinsert queue"], // title
+	[QUOTE(SETTINGS_GROUP_NAME), QUOTE(COMPONENT_BEAUTIFIED)], // category
+	true, // default value
+	true, // global setting
+	{
+		params ["_value"];
+		[
+			QGVAR(setting_enabled),
+			_value
+		] call EFUNC(common,logSettingChanged);
+	}
+] call CBA_fnc_addSetting;
+
+[
+	QGVAR(setting_maxRangeToReady), // variable
+	"SLIDER", // type
+	["Max Request Filing Range", "Maximum distance from a respawn point a player can be to ready up"], // title
+	[QUOTE(SETTINGS_GROUP_NAME), QUOTE(COMPONENT_BEAUTIFIED)], // category
+	[0, 1000, 400, 0, false], // [_min, _max, _default, _trailingDecimals, _isPercentage]
+	true, // global setting
+	{
+		params ["_value"];
+		[
+			QGVAR(setting_maxRangeToReady),
+			_value
+		] call EFUNC(common,logSettingChanged);
+	}
+] call CBA_fnc_addSetting;
+
+[
+	QGVAR(setting_maxWait), // variable
+	"TIME", // type
+	["Max Wait Before Global Notify", "How long should at least one person be waiting before prompting a global notification."], // title
+	[QUOTE(SETTINGS_GROUP_NAME), QUOTE(COMPONENT_BEAUTIFIED)], // category
+	[60*5, 60*30, 60*20], // [_min, _max, _default]
+	true,
+	{
+		params ["_value"];
+		[
+			QGVAR(setting_maxWait),
+			_value
+		] call EFUNC(common,logSettingChanged);
+	}
+] call CBA_fnc_addSetting;
+
+[
+	QGVAR(setting_pilotForcedCheckEnabled), // variable
+	"CHECKBOX", // type
+	["Force Queue Checks for Pilots", "Whether or not pilots are forced to view the contents of the reinsertion queue per interval"], // title
+	[QUOTE(SETTINGS_GROUP_NAME), QUOTE(COMPONENT_BEAUTIFIED)], // category
+	false, // default value
+	true, // global setting
+	{
+		params ["_value"];
+		[
+			QGVAR(setting_pilotForcedCheckEnabled),
+			_value
+		] call EFUNC(common,logSettingChanged);
+	}
+] call CBA_fnc_addSetting;
+
+[
+	QGVAR(setting_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
+	[QUOTE(SETTINGS_GROUP_NAME), QUOTE(COMPONENT_BEAUTIFIED)], // category
+	[60*5, 60*30, 60*10], // [_min, _max, _default]
+	true,
+	{
+		params ["_value"];
+		[
+			QGVAR(setting_pilotForcedCheckInterval),
+			_value
+		] call EFUNC(common,logSettingChanged);
+	}
+] call CBA_fnc_addSetting;

framework/reinsert/script_component.hpp

@@ -0,0 +1,3 @@
+#define COMPONENT reinsert
+#define COMPONENT_BEAUTIFIED Reinsertion
+#include "../script_mod.hpp"

framework/reinsert/server/fn_addToQueue.sqf

@@ -0,0 +1,61 @@
+#include "..\script_component.hpp"
+
+params [
+	["_player", objNull, [objNull]],
+	["_base", objNull, [objNull]],
+	["_timeFiled", diag_tickTime, [25]]
+];
+
+if (!isServer) exitWith {
+	[
+		LEVEL_ERROR,
+		QUOTE(COMPONENT),
+		"ATTEMPTED RUN ON CLIENT",
+		[
+			["player", _player],
+			["base", _base]
+		]
+	] call EFUNC(common,log);
+	["ATTEMPTED RUN ON CLIENT"] call BIS_fnc_error;
+};
+if (
+	isNull _player ||
+	isNull _base
+) exitWith {
+	[
+		LEVEL_ERROR,
+		QUOTE(COMPONENT),
+		"NULL PARAMETERS",
+		[
+			["player", _player],
+			["base", _base]
+		]
+	] call EFUNC(common,log);
+	["NULL PARAMETERS"] call BIS_fnc_error;
+};
+
+
+private _maxRangeToReady = missionNamespace getVariable [QGVAR(setting_maxRangeToReady), 400];
+// nearest base here is the same as the base sent
+private _nearestBase = _base;
+
+GVAR(reinsertionQueue) pushBackUnique [
+	_player, _base, _timeFiled
+];
+// broadcast new list to all machines
+publicVariable QGVAR(reinsertionQueue);
+
+// log to rpt
+[
+	LEVEL_INFO,
+	QUOTE(COMPONENT),
+	"PLAYER FILED REQUEST",
+	[_player, [
+		["filedAtBase", [_base] call EFUNC(common,getNameOfBase)],
+		["filedAtBaseDistance", _player distance _base],
+		["closestBase", [_nearestBase] call EFUNC(common,getNameOfBase)],
+		["closestBaseDistance", _player distance _nearestBase],
+		["maxDistanceSetting", _maxRangeToReady],
+		["inQueueDuration", diag_tickTime - _timeFiled]
+	]] call EFUNC(common,addPlayerInfoToArray)
+] call EFUNC(common,log);

framework/reinsert/server/fn_globalShowQueue.sqf

@@ -0,0 +1,71 @@
+#include "..\script_component.hpp"
+
+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 [QGVAR(setting_maxWait), 60*20]; // default 20 minutes
+private _timeoutPlayers = GVAR(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 [QGVAR(setting_maxRangeToReady), 400];
+
+	// get base objects from queue
+	private _basesWithPeople = (missionNamespace getVariable [QGVAR(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 EFUNC(common,getNameOfBase), 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 EFUNC(common,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
+			[
+				LEVEL_WARNING,
+				QUOTE(COMPONENT),
+				"PLAYER WAITING OVER TIMEOUT",
+				[_player, [
+					["filedAtBase", [_base] call EFUNC(common,getNameOfBase)],
+					["filedAtBaseDistance", _player distance _base],
+					["closestBase", [_nearestBase] call EFUNC(common,getNameOfBase)],
+					["closestBaseDistance", _player distance _nearestBase],
+					["maxDistanceSetting", _maxRangeToReady],
+					["inQueueDuration", diag_tickTime - _timeFiled]
+				]] call EFUNC(common,addPlayerInfoToArray)
+			] call EFUNC(common,log);
+		} forEach _thisBasePlayers;
+	} forEach _basesWithPeople;
+
+	// SEND NOTIFY
+	_playerLines remoteExec ["CBA_fnc_notify", [0, -2] select isDedicated];
+	// RESET NOTIFICATION TIMER
+	GVAR(overTimeoutLastNotificationTime) = diag_tickTime;
+};

framework/reinsert/server/fn_initServer.sqf

@@ -0,0 +1,53 @@
+// 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
+
+#include "..\script_component.hpp"
+
+if (!isServer) exitWith {};
+
+// register queue
+GVAR(reinsertionQueue) = [];
+publicVariable QGVAR(reinsertionQueue);
+
+// server mission start time
+GVAR(missionStartServerTime) = serverTime;
+
+// FILE REQUEST CBA HANDLER
+[QGVAR(fileReinsertRequest), {
+	params ["_player", "_base"];
+	[_player, _base] call FUNC(addToQueue);
+}] call CBA_fnc_addEventHandler;
+
+// REMOVE REQUEST CBA HANDLER
+[QGVAR(removeReinsertRequest), {
+	params ["_player"];
+	[_player] call FUNC(removeFromQueue);
+}] call CBA_fnc_addEventHandler;
+
+
+// automated wait threshold timer
+GVAR(overTimeoutLastNotificationTime) = 0;
+
+[{ // every 60 seconds
+
+	// validate queue
+	call FUNC(validateQueue);
+
+	// check if last overTimeout notification was sent more than X minutes ago
+	if (
+		diag_tickTime - GVAR(overTimeoutLastNotificationTime) > 60*5
+	) then {
+		// show global queue notification with any players that are over timeout
+		call FUNC(globalShowQueue);
+	};
+
+}, 60] call CBA_fnc_addPerFrameHandler;
+
+[
+	LEVEL_DEBUG,
+	QUOTE(COMPONENT),
+	"postInit complete",
+	[]
+] call EFUNC(common,log);

framework/reinsert/server/fn_removeFromQueue.sqf

@@ -0,0 +1,60 @@
+#include "..\script_component.hpp"
+
+params [["_player", objNull, [objNull]]];
+
+if (!isServer) exitWith {
+	[
+		LEVEL_ERROR,
+		QUOTE(COMPONENT),
+		"ATTEMPTED RUN ON CLIENT",
+		[
+			["player", _player]
+		]
+	] call EFUNC(common,log);
+};
+if (isNull _player) exitWith {
+	[
+		LEVEL_ERROR,
+		QUOTE(COMPONENT),
+		"NULL PARAMETERS",
+		[
+			["player", _player]
+		]
+	] call EFUNC(common,log);
+};
+
+// get entries for this player from queue
+private _unitArrs = GVAR(reinsertionQueue) select {_x#0 isEqualTo _player};
+// if player not in queue, skip
+if (count _unitArrs isEqualTo 0) exitWith {};
+
+private _maxRangeToReady = missionNamespace getVariable [QGVAR(setting_maxRangeToReady), 400];
+
+// remove player from queue
+GVAR(reinsertionQueue) = GVAR(reinsertionQueue) - _unitArrs;
+// broadcast new list to all machines
+publicVariable QGVAR(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 EFUNC(common,getNearestBase);
+// log to rpt
+[
+	LEVEL_INFO,
+	QUOTE(COMPONENT),
+	"PLAYER RESCINDED REQUEST",
+	[_player, [
+		["filedAtBase", [_base] call EFUNC(common,getNameOfBase)],
+		["filedAtBaseDistance", _player distance _base],
+		["closestBase", [_nearestBase] call EFUNC(common,getNameOfBase)],
+		["closestBaseDistance", _player distance _nearestBase],
+		["maxDistanceSetting", _maxRangeToReady],
+		["inQueueDuration", diag_tickTime - _timeFiled]
+	]] call EFUNC(common,addPlayerInfoToArray)
+] call EFUNC(common,log);

framework/reinsert/server/fn_returnReinsertQueueNotification.sqf

@@ -0,0 +1,111 @@
+/*
+	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
+*/
+
+#include "..\script_component.hpp"
+
+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
+[
+	LEVEL_INFO,
+	QUOTE(COMPONENT),
+	"SHOW QUEUE REQUESTED",
+	[_userObject] call EFUNC(common,addPlayerInfoToArray)
+] call EFUNC(common,log);
+
+private _queue = missionNamespace getVariable [QGVAR(reinsertionQueue), []];
+// get base objects from queue
+private _basesWithPeople = (missionNamespace getVariable [QGVAR(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 EFUNC(common,getNameOfBase);
+	
+	// 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;

framework/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)
+#include "..\script_component.hpp"
+
+private _stillValid = [];
+private _maxRangeToReady = missionNamespace getVariable [QGVAR(setting_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 EFUNC(common,getNearestBase);
+	private _isCloseEnoughToAnyBase = (_player distance _nearestBase) < _maxRangeToReady;
+
+	if (not _isCloseEnoughToAnyBase || not (alive _player)) then {
+		// don't include player in updated queue
+		// log to rpt
+		[
+			LEVEL_INFO,
+			QUOTE(COMPONENT),
+			"PLAYER DEQUEUED AUTOMATICALLY",
+			[_player, [
+				["filedAtBase", [_base] call EFUNC(common,getNameOfBase)],
+				["filedAtBaseDistance", _player distance _base],
+				["closestBase", [_nearestBase] call EFUNC(common,getNameOfBase)],
+				["closestBaseDistance", _player distance _nearestBase],
+				["maxDistanceSetting", _maxRangeToReady],
+				["inQueueDuration", diag_tickTime - _timeFiled]
+			]] call EFUNC(common,addPlayerInfoToArray)
+		] call EFUNC(common,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 {
+		[
+			LEVEL_INFO,
+			QUOTE(COMPONENT),
+			"PLAYER BASE WAS UPDATED",
+			[_player, [
+				["filedAtBase", [_base] call EFUNC(common,getNameOfBase)],
+				["filedAtBaseDistance", _player distance _base],
+				["closestBase", [_nearestBase] call EFUNC(common,getNameOfBase)],
+				["closestBaseDistance", _player distance _nearestBase],
+				["maxDistanceSetting", _maxRangeToReady],
+				["inQueueDuration", diag_tickTime - _timeFiled]
+			]] call EFUNC(common,addPlayerInfoToArray)
+		] call EFUNC(common,log);
+	};
+} forEach GVAR(reinsertionQueue);
+
+// broadcast new list to all machines
+GVAR(reinsertionQueue) = _stillValid;
+publicVariable QGVAR(reinsertionQueue);

framework/resupply/functions/fn_addArsenalObjectSpawnBoxActions.sqf

@@ -0,0 +1,63 @@
+#include "..\script_component.hpp"
+
+// adds a scroll wheel action to all arsenal boxes to spawn different supply crate types
+
+private _arsenalBoxClassName = "Land_PaperBox_open_full_F";
+
+// get all instances of the arsenal item
+private _arsenalBoxes = (allMissionObjects _arsenalBoxClassName) select {
+	// only select the ones that already have user actions attached
+	count (actionIDs _x) > 0;
+};
+
+private _supplyCratesCfg = call FUNC(getSupplyCratesCfg);
+private _supplyCrateTypesCfgs = _supplyCratesCfg call BIS_fnc_returnChildren;
+
+{
+	// add scroll wheel action to spawn different supply box types
+	private _arsenalBox = _x;
+
+	// always remove old actions if they exist
+	private _actionIDs = _arsenalBox getVariable [QGVAR(supplyCrateActionIDs), []];
+	{
+		_arsenalBox removeAction _x;
+	} forEach _actionIDs;
+	_arsenalBox setVariable [QGVAR(supplyCrateActionIDs), []];
+
+
+	// if setting disabled, skip adding actions
+	if (not (
+		[QGVAR(setting_allowSupplyBoxScrollWheelSpawning)] call CBA_settings_fnc_get
+	)) then {continue};
+
+	
+	{ // add an action for each supply crate type
+		private _cfg = _x;
+		private _supplyCrateDisplayName = (_cfg >> "displayName") call BIS_fnc_getCfgData;
+
+		// add action to spawn supply crate
+		private _actionID = _arsenalBox addAction [format ["<t color='#ffffff'>Spawn %1</t>", _supplyCrateDisplayName], {
+			params ["_target", "_caller", "_actionId", "_arguments"];
+			_arguments params ["_supplyCrateCfg"];
+			[
+				objNull,
+				configName _supplyCrateCfg,
+				getPos _target
+			] call FUNC(createBox);
+
+			// log action use in server RPT
+			private _supplyCrateDisplayName = (_supplyCrateCfg >> "displayName") call BIS_fnc_getCfgData;
+			[
+				LEVEL_INFO,
+				QUOTE(COMPONENT),
+				"Supply crate spawned",
+				[player, [
+					["supplyCrateDisplayName", _supplyCrateDisplayName],
+					["supplyCrateCfgName", configName _supplyCrateCfg],
+					["position", getPos _target]
+				]] call EFUNC(common,addPlayerInfoToArray)
+			] remoteExec [QEFUNC(common,log), 2];
+		}, [_cfg], 0, false, true, "", ""];
+		(_arsenalBox getVariable [QGVAR(supplyCrateActionIDs), []]) pushBack _actionID;
+	} forEach _supplyCrateTypesCfgs;
+} forEach _arsenalBoxes;

framework/resupply/functions/fn_addCBASettings.sqf

@@ -0,0 +1,29 @@
+#include "..\script_component.hpp"
+
+[
+	QGVAR(setting_allowSupplyBoxScrollWheelSpawning), // variable
+	"CHECKBOX", // type
+	["Allow Spawning Boxes from Arsenal Box", "If true, adds scroll wheel options to arsenal boxes to spawn supply boxes"], // title
+	[QUOTE(SETTINGS_GROUP_NAME), QUOTE(COMPONENT_BEAUTIFIED)], // category
+	false, // default value
+	true, // global setting
+	{
+		params ["_value"];
+		[
+			QGVAR(setting_allowSupplyBoxScrollWheelSpawning),
+			_value
+		] call EFUNC(common,logSettingChanged);
+
+		if (_value && hasInterface && time > 0) then {
+			[] call FUNC(addArsenalObjectSpawnBoxActions);
+		};
+	},
+	true // requires mission restart
+] call CBA_fnc_addSetting;
+
+[
+	LEVEL_INFO,
+	QUOTE(COMPONENT),
+	"CREATED SETTINGS",
+	[]
+] call EFUNC(common,log);

framework/resupply/functions/fn_createBox.sqf

@@ -0,0 +1,168 @@
+/*
+ * Author: Hizumi & IndigoFox
+ *
+ * Create Mortar resupply box for the 17th Battalion. Primarily called from milsim_fnc_addZenModules
+ *
+ * Arguments:
+ * 0: Vehicle - <OBJECT>
+ * 1: Type - <STRING>
+ * 2: Position - <ARRAY>
+ *
+ * Return Value:
+ * Function executed <BOOL>
+ *
+ * Example:
+ * [box, "AmmoSquad"] call milsim_fnc_createBox; 			// create mortar ammo box via init line of editor object
+ * [objNull, "AmmoHeavy", pos] call milsim_fnc_createBox;		// create mortar ammo box via zeus module
+ *
+ * Public: Yes
+ *
+ * Note: For gathering:
+	formatText ["%1", [
+		["containerClassname", typeOf cursorObject],
+		["backpack", (backpackCargo cursorObject) call BIS_fnc_consolidateArray],
+		["item", (itemCargo cursorObject) call BIS_fnc_consolidateArray],
+		["magazine", (magazineCargo cursorObject) call BIS_fnc_consolidateArray],
+		["magazineAmmo", magazinesAmmoCargo cursorObject],
+		["weapon", (weaponCargo cursorObject) call BIS_fnc_consolidateArray]
+	]];
+ */
+ 
+#include "..\script_component.hpp"
+
+params [
+	["_box", objNull, [objNull]],
+	["_type", "", [""]],
+	["_pos", [0,0,0], [[]], 3]
+];
+
+// get defs class
+private _supplyCratesCfg = call FUNC(getSupplyCratesCfg);
+if (!isClass _supplyCratesCfg) exitWith {
+	["Resupply Boxes: Failed to load crate definitions, possibly a bad edit?"] call BIS_fnc_error;
+	objNull;
+};
+
+// get the subclass names
+private _boxTypesAvailable = _supplyCratesCfg call BIS_fnc_getCfgSubClasses;
+
+// if no type is provided, show the available types
+if (_type isEqualTo "") exitWith {
+	[
+		"%1 | %2 %3",
+		"Resupply Boxes: [_boxObject, _type, _pos] call milsim_fnc_createBox",
+		"No type provided. Please use one of the following types for _type:",
+		_boxTypesAvailable joinString ", "
+	] call BIS_fnc_error;
+	objNull;
+};
+
+
+//////////////////////////////////////////////////////////////////////////
+// get the box definition class
+//////////////////////////////////////////////////////////////////////////
+private _boxDef = (_supplyCratesCfg >> _type);
+// validate it exists
+if (!isClass _boxDef) exitWith {
+	[
+		"%1 | %2 %3",
+		"Resupply Boxes: [_boxObject, _type, _pos] call milsim_fnc_createBox",
+		"Invalid type provided. Please use one of the following types for _type:",
+		_boxTypesAvailable joinString ", "
+	] call BIS_fnc_error;
+	objNull;
+};
+
+//////////////////////////////////////////////////////////////////////////
+// Create box if one wasn't provided in parameters
+//////////////////////////////////////////////////////////////////////////
+if (isNull _box) then {
+	private _neededBoxType = getText(_boxDef >> "boxClass");
+	if (_neededBoxType isEqualTo "") exitWith {
+		[
+			"Resupply Boxes: Failed to create box. No boxClass defined in the box definition."
+		] call BIS_fnc_error;
+		objNull;
+	};
+	_box = _neededBoxType createVehicle _pos;
+};
+
+
+//////////////////////////////////////////////////////////////////////////
+// Clear box
+//////////////////////////////////////////////////////////////////////////
+clearBackpackCargoGlobal _box;
+clearItemCargoGlobal _box;
+clearMagazineCargoGlobal _box;
+clearWeaponCargoGlobal _box;
+
+//////////////////////////////////////////////////////////////////////////
+// Get [item, quantity] arrays from definition
+//////////////////////////////////////////////////////////////////////////
+private _backpacks = ([_boxDef >> "backpacks"] call BIS_fnc_getCfgDataArray);
+if (isNil "_backpacks") exitWith {
+	[
+		"Resupply Boxes: Failed to create box. No backpacks defined in the box definition."
+	] call BIS_fnc_error;
+	objNull;
+};
+
+private _weapons = ([_boxDef >> "weapons"] call BIS_fnc_getCfgDataArray);
+if (isNil "_weapons") exitWith {
+	[
+		"Resupply Boxes: Failed to create box. No weapons defined in the box definition."
+	] call BIS_fnc_error;
+	objNull;
+};
+
+private _magazines = ([_boxDef >> "magazines"] call BIS_fnc_getCfgDataArray);
+if (isNil "_magazines") exitWith {
+	[
+		"Resupply Boxes: Failed to create box. No magazines defined in the box definition."
+	] call BIS_fnc_error;
+	objNull;
+};
+
+private _items = ([_boxDef >> "items"] call BIS_fnc_getCfgDataArray);
+if (isNil "_items") exitWith {
+	[
+		"Resupply Boxes: Failed to create box. No items defined in the box definition."
+	] call BIS_fnc_error;
+	objNull;
+};
+
+//////////////////////////////////////////////////////////////////////////
+// Add stuff to box
+//////////////////////////////////////////////////////////////////////////
+{
+	_x params ["_class", "_qty"];
+	_box addBackpackCargoGlobal [_class, _qty]
+} foreach _backpacks;
+
+{
+	_x params ["_class", "_qty"];
+	_box addItemCargoGlobal [_class, _qty]
+} foreach _items;
+
+{
+	_x params ["_class", "_qty"];
+	_box addMagazineCargoGlobal [_class, _qty]
+} foreach _magazines;
+
+{
+	_x params ["_class", "_qty"];
+	_box addWeaponCargoGlobal [_class, _qty]
+} foreach _weapons;
+
+
+//////////////////////////////////////////////////////////////////////////
+// Adjust ACE settings
+//////////////////////////////////////////////////////////////////////////
+// set box size
+[_box,1] call ace_cargo_fnc_setSize;
+
+// ignore weight restrictions for carry/drag
+_box setVariable ["ace_ignoreWeightCarry", true, true];
+
+// Return the box
+_box;

framework/resupply/functions/fn_getSupplyCratesCfg.sqf

@@ -0,0 +1,2 @@
+#include "..\script_component.hpp"
+(missionConfigFile >> "SupplyCrates");

framework/resupply/functions/fn_initClient.sqf

@@ -0,0 +1,14 @@
+#include "..\script_component.hpp"
+
+if (!hasInterface) exitWith {};
+
+call FUNC(addArsenalObjectSpawnBoxActions);
+
+[
+	LEVEL_DEBUG,
+	QUOTE(COMPONENT),
+	"initClient complete",
+	[]
+] call EFUNC(common,log);
+
+localNamespace setVariable [QGVAR(complete), true];

framework/resupply/script_component.hpp

@@ -0,0 +1,3 @@
+#define COMPONENT resupply
+#define COMPONENT_BEAUTIFIED Resupply
+#include "../script_mod.hpp"

framework/script_macros.hpp

@@ -0,0 +1,11 @@
+// all text before cba include
+#define SETTINGS_GROUP_NAME 17th Battalion
+#define MODULE_CATEGORY_NAME 17th Battalion
+
+#define LEVEL_TRACE -1
+#define LEVEL_DEBUG 0
+#define LEVEL_INFO 1
+#define LEVEL_WARNING 2
+#define LEVEL_ERROR 3
+
+#include "\x\cba\addons\main\script_macros_mission.hpp"