Add garrison zeus modules

addons/common/XEH_PREP.hpp

@@ -46,6 +46,7 @@ PREP(fixCollision);
 PREP(fixFloating);
 PREP(fixLoweredRifleAnimation);
 PREP(fixPosition);
+PREP(garrison);
 PREP(getAllDefinedSetVariables);
 PREP(getDeathAnim);
 PREP(getDefaultAnim);
@@ -165,6 +166,7 @@ PREP(toBitmask);
 PREP(toHex);
 PREP(toNumber);
 PREP(unhideUnit);
+PREP(unGarrison);
 PREP(uniqueElements);
 PREP(unloadPerson);
 PREP(unloadPersonLocal);

addons/common/XEH_postInit.sqf

@@ -123,6 +123,17 @@ if (isServer) then {
 [QGVAR(switchMove), {(_this select 0) switchMove (_this select 1)}] call CBA_fnc_addEventHandler;
 [QGVAR(setVectorDirAndUp), {(_this select 0) setVectorDirAndUp (_this select 1)}] call CBA_fnc_addEventHandler;
 [QGVAR(setVanillaHitPointDamage), {(_this select 0) setHitPointDamage (_this select 1)}] call CBA_fnc_addEventHandler;
+[QGVAR(doMove), {(_this select 0) doMove (_this select 1)}] call CBA_fnc_addEventHandler;
+[QGVAR(doFollow), {(_this select 0) doMove (_this select 1)}] call CBA_fnc_addEventHandler;
+
+[QGVAR(disableAI), {
+    params [["_units", [], [[]]], "_section"];
+    {_x disableAI _section} foreach (_units select {local _x});
+}] call CBA_fnc_addEventHandler;
+[QGVAR(enableAI), {
+    params [["_units", [], [[]]], "_section"];
+    {_x enableAI _section} foreach (_units select {local _x});
+}] call CBA_fnc_addEventHandler;
 
 // Request framework
 [QGVAR(requestCallback), FUNC(requestCallback)] call CBA_fnc_addEventHandler;

addons/common/functions/fnc_garrison.sqf

@@ -0,0 +1,173 @@
+/*
+ * Author: alganthe
+ * Garrison function used to garrison AI inside buildings.
+ *
+ * Arguments:
+ * 0: The building(s) nearest this position are used <POSITION>
+ * 1: Limit the building search to those type of building <ARRAY>
+ * 2: Units that will be garrisoned <ARRAY>
+ * 3: Radius to fill building(s) <SCALAR> default: 50
+ * 4: 0: even filling, 1: building by building, 2: random filling <SCALAR> default: 0
+ * 5: True to fill building(s) from top to bottom <BOOL> default: false
+
+ * Return Value:
+ * Array of units not garrisoned
+ *
+ * Public: Yes
+ *
+ * Example:
+ * [position, nil, [unit1, unit2, unit3, unitN], 200, 1, false] call ace_common_fnc_garrison
+*/
+#include "script_component.hpp"
+
+params [["_startingPos",[0,0,0], [[]], 3], ["_buildingTypes", ["Building"], [[]]], ["_unitsArray", [], [[]]], ["_fillingRadius", 50, [0]], ["_fillingType", 0, [0]], ["_topDownFilling", false, [true]]];
+
+_unitsArray = _unitsArray select {alive _x && {!isPlayer _x}};
+
+if (_startingPos isEqualTo [0,0,0]) exitWith {
+    [LSTRING(GarrisonInvalidPosition)] call EFUNC(common,displayTextStructured);
+};
+
+if (count _unitsArray == 0 || {isNull (_unitsArray select 0)}) exitWith {
+    [LSTRING(GarrisonNoUnits)] call EFUNC(common,displayTextStructured);
+};
+
+private _buildings = [];
+
+if (_fillingRadius < 50) then {
+    _buildings = nearestObjects [_startingPos, _buildingTypes, 50];
+} else {
+    _buildings = nearestObjects [_startingPos, _buildingTypes, _fillingRadius];
+    _buildings = _buildings call BIS_fnc_arrayShuffle;
+};
+
+if (count _buildings == 0) exitWith {
+    [LSTRING(GarrisonNoBuilding)] call EFUNC(common,displayTextStructured);
+};
+
+private _buildingsIndexes = [];
+
+if (_topDownFilling) then {
+    {
+        private _buildingPos = _x buildingPos -1;
+
+        // Those reverse are necessary, as dumb as it is there's no better way to sort those subarrays in sqf
+        {
+            reverse _x;
+        } foreach _buildingPos;
+
+        _buildingPos sort false;
+
+        {
+            reverse _x;
+        } foreach _buildingPos;
+
+        _buildingsIndexes pushback _buildingPos;
+    } foreach _buildings;
+} else {
+    {
+        _buildingsIndexes pushback (_x buildingPos -1);
+    } foreach _buildings;
+};
+
+// Remove buildings without positions
+{
+    _buildingsIndexes deleteAt (_buildingsIndexes find _x);
+} foreach (_buildingsIndexes select {count _x == 0});
+
+// Warn the user that there's not enough positions to place all units
+private _count = 0;
+{_count = _count + count _x} foreach _buildingsIndexes;
+private _leftOverAICount = (count _unitsArray) - _count;
+if (_leftOverAICount > 0) then {
+    [LSTRING(GarrisonNotEnoughPos)] call EFUNC(common,displayTextStructured);
+};
+
+private _placedUnits = [];
+
+// Do the placement
+switch (_fillingType) do {
+    case 0: {
+        while {count _unitsArray > 0} do {
+            if (count _buildingsIndexes == 0) exitWith {};
+
+            private _building = _buildingsIndexes select 0;
+
+            if (_building isEqualTo []) then {
+                _buildingsIndexes deleteAt 0;
+            } else {
+                private _pos = _building select 0;
+
+                private _nearestUnits = (_pos nearEntities ["CAManBase", 1]);
+                if (count _nearestUnits  > 0 && {count (_nearestUnits select {getPos _x select 2 == _pos select 2}) > 0}) then {
+                    _buildingsIndexes set [0,  _building - [_pos]];
+
+                } else {
+                    private _unit = _unitsArray select 0;
+                    _unit setPos _pos;
+                    _placedUnits pushBack _unit;
+                    _unitsArray deleteAt (_unitsArray find _unit);
+                    _building deleteAt 0;
+                    _buildingsIndexes deleteAt 0;
+                    _buildingsIndexes pushbackUnique _building;
+                };
+            };
+        };
+    };
+
+    case 1: {
+        while {count _unitsArray > 0} do {
+            if (count _buildingsIndexes == 0) exitWith {};
+
+            private _building = _buildingsIndexes select 0;
+
+            if (_building isEqualTo []) then {
+                _buildingsIndexes deleteAt 0;
+            } else {
+                private _pos = _building select 0;
+
+                private _nearestUnits = (_pos nearEntities ["CAManBase", 1]);
+                if (count _nearestUnits  > 0 && {count (_nearestUnits select {getPos _x select 2 == _pos select 2}) > 0}) then {
+                    _buildingsIndexes set [0, _building - [_pos]];
+
+                } else {
+                    private _unit = _unitsArray select 0;
+                    _unit setPos _pos;
+                    _placedUnits pushBack _unit;
+                    _unitsArray deleteAt (_unitsArray find _unit);
+                    _buildingsIndexes set [0, _building - [_pos]];
+                };
+            };
+        };
+    };
+
+    case 2: {
+        while {count _unitsArray > 0} do {
+            if (count _buildingsIndexes == 0) exitWith {};
+
+            private _building = selectRandom _buildingsIndexes;
+
+            if (_building isEqualTo []) then {
+                _buildingsIndexes deleteAt (_buildingsIndexes find _building);
+            } else {
+                private _pos = selectRandom _building;
+
+                private _nearestUnits = (_pos nearEntities ["CAManBase", 1]);
+                if (count _nearestUnits  > 0 && {count (_nearestUnits select {getPos _x select 2 == _pos select 2}) > 0}) then {
+                    _buildingsIndexes set [(_buildingsIndexes find _building), _building - [_pos]];
+
+                } else {
+                    private _unit = _unitsArray select 0;
+                    _unit setPos _pos;
+                    _unitsArray deleteAt (_unitsArray find _unit);
+                    _placedUnits pushBack _unit;
+                    _buildingsIndexes set [(_buildingsIndexes find _building), _building - [_pos]];
+                };
+            };
+        };
+    };
+};
+
+[QGVAR(disableAI), [_placedUnits, "AUTOCOMBAT"], _placedUnits] call CBA_fnc_targetEvent;
+[QGVAR(disableAI), [_placedUnits, "PATH"], _placedUnits] call CBA_fnc_targetEvent;
+_unitsArray

addons/common/functions/fnc_unGarrison.sqf

@@ -0,0 +1,45 @@
+/*
+ * Author: alganthe
+ * Used to un-garrison units garrisoned with ace_common_fnc_garrison
+ *
+ * Arguments:
+ * 0: Array of units to un-garrison <ARRAY>
+ *
+ * Return Value:
+ * Nothing
+ *
+ * Public: Yes
+ *
+*/
+#include "script_component.hpp"
+
+params [["_unitsArray", [], [[]]]];
+
+{
+    if !(isPlayer _x) then {
+        if (local _x) then {
+            _x enableAI "AUTOCOMBAT";
+            _x enableAI "PATH";
+        } else {
+            [QGVAR(enableAI), [_placedUnits, "AUTOCOMBAT"], _placedUnits] call CBA_fnc_targetEvent;
+            [QGVAR(enableAI), [_placedUnits, "PATH"], _placedUnits] call CBA_fnc_targetEvent;
+        };
+
+        private _leader = leader _x;
+        if (_leader != _x) then {
+            doStop _x;
+            if (local _leader) then {
+                _x doFollow _leader;
+            } else {
+                [QGVAR(doFollow), [_x, _leader], _leader] call CBA_fnc_targetEvent;
+            };
+
+        } else {
+            if (local _x) then {
+                _x doMove ((nearestBuilding (getPos _x)) buildingExit 0);
+            } else {
+                [QGVAR(doMove), [_x, ((nearestBuilding (getPos _x)) buildingExit 0)], _x] call CBA_fnc_targetEvent;
+            };
+        };
+    };
+} foreach _unitsArray;

addons/common/stringtable.xml

@@ -874,5 +874,21 @@
             <Russian>Нет места для выгрузки</Russian>
             <Japanese>降ろすための空間がありません</Japanese>
         </Key>
+        <Key ID="STR_ACE_Common_GarrisonInvalidPosition">
+            <English>Invalid position provided.</English>
+            <French>Position invalide fourni</French>
+        </Key>
+        <Key ID="STR_ACE_Common_GarrisonNoUnits">
+            <English>No units provided.</English>
+            <French>Aucune unité fourni</French>
+        </Key>
+        <Key ID="STR_ACE_Common_GarrisonNotEnoughPos">
+            <English>There isn't enough positions to place all units.</English>
+            <French>Il n'y a pas assez de positions pour placer toutes les unités</French>
+        </Key>
+        <Key ID="STR_ACE_Common_GarrisonNoBuilding">
+            <English>No building found.</English>
+            <French>Aucun bâtiment trouvé</French>
+        </Key>
     </Package>
 </Project>

addons/zeus/CfgVehicles.hpp

@@ -174,4 +174,16 @@ class CfgVehicles {
         function = QFUNC(moduleUnconscious);
         icon = QPATHTOF(UI\Icon_Module_Zeus_Unconscious_ca.paa);
     };
+    class GVAR(moduleGarrison): GVAR(moduleBase) {
+        curatorCanAttach = 1;
+        displayName = CSTRING(ModuleGarrison_DisplayName);
+        curatorInfoType = QGVAR(RscGarrison);
+        icon = QPATHTOF(UI\Icon_Module_Zeus_Garrison_ca.paa);
+    };
+    class GVAR(moduleUnGarrison): GVAR(moduleBase) {
+        curatorCanAttach = 1;
+        displayName = CSTRING(ModuleUnGarrison_DisplayName);
+        function = QFUNC(moduleUnGarrison);
+        icon = QPATHTOF(UI\Icon_Module_Zeus_UnGarrison_ca.paa);
+    };
 };

addons/zeus/XEH_PREP.hpp

@@ -8,6 +8,7 @@ PREP(handleZeusUnitAssigned);
 PREP(moduleAddSpareTrack);
 PREP(moduleAddSpareWheel);
 PREP(moduleCaptive);
+PREP(moduleGarrison);
 PREP(moduleGlobalSetSkill);
 PREP(moduleGroupSide);
 PREP(moduleSearchNearby);
@@ -17,11 +18,13 @@ PREP(moduleSetMedicalFacility);
 PREP(moduleSurrender);
 PREP(moduleTeleportPlayers);
 PREP(moduleUnconscious);
+PREP(moduleUnGarrison);
 PREP(moduleZeusSettings);
 PREP(ui_attributeCargo);
 //PREP(ui_attributePosition);
 PREP(ui_attributeRadius);
 PREP(ui_defendArea);
+PREP(ui_garrison);
 PREP(ui_globalSetSkill);
 PREP(ui_groupSide);
 PREP(ui_patrolArea);

addons/zeus/config.cpp

@@ -10,7 +10,9 @@ class CfgPatches {
             QGVAR(modulePatrolArea),
             QGVAR(moduleSearchArea),
             QGVAR(moduleSearchNearby),
-            QGVAR(moduleTeleportPlayers)
+            QGVAR(moduleTeleportPlayers),
+            QGVAR(moduleGarrison),
+            QGVAR(moduleUnGarrison)
         };
         weapons[] = {};
         requiredVersion = REQUIRED_VERSION;

addons/zeus/functions/fnc_moduleGarrison.sqf

@@ -0,0 +1,57 @@
+/*
+ * Author: alganthe
+ * Module calling the garrison function
+ *
+ * Arguments:
+ * 0: The module logic <OBJECT>
+ * 1: Position of the module <POSITION>
+ * 2: Radius of the task <NUMBER>
+ * 3: Filling mode of the garrison function <NUMBER>
+ * 4: Enable or not top down filling <BOOLEAN>
+ *
+ * Return Value:
+ * None
+*/
+
+#include "script_component.hpp"
+
+params ["_logic", "_pos", "_radius" ,"_mode" , "_topDownMode"];
+
+private _unit = (attachedTo _logic);
+private _building = nearestBuilding (getPosASL _unit);
+
+// Handles errors
+scopeName "Main";
+private _fnc_errorAndClose = {
+    params ["_msg"];
+    deleteVehicle _logic;
+    [_msg] call EFUNC(common,displayTextStructured);
+    breakOut "Main";
+};
+
+switch (false) do {
+    case !(isNull _unit): {
+        [LSTRING(NothingSelected)] call _fnc_errorAndClose;
+    };
+    case (_unit isKindOf "CAManBase"): {
+        [LSTRING(OnlyInfantry)] call _fnc_errorAndClose;
+    };
+    case (alive _unit): {
+        [LSTRING(OnlyAlive)] call _fnc_errorAndClose;
+    };
+    case (_unit distance _building < 500): {
+        [LSTRING(BuildingTooFar)] call _fnc_errorAndClose;
+    };
+};
+
+private _units = units _unit;
+// Make sure all units are disembarked.
+{
+    if (vehicle _x != _x) then {
+        moveOut _x;
+    };
+} forEach _units;
+
+[_pos, ["Building"], _units, _radius, _mode, _topDownMode] call EFUNC(common,garrison);
+
+deleteVehicle _logic;