/*//
*///    File : fn_hostileInit.sqf
/*//    Version : 1.4
*///    Author : Dmitry Yuri
/*//    Description : Finds all triggers that are defined as hostile spawn points and sets up the spawning loop.
*///    Usage :
/*//
*///

/*
    _targets <array> <groups> list of groups that can be targeted by spawned squads
    _locations <array> <sting> prefix for spawn locations, prefix for spawn locations near objects with building positions
    _classes <array> <string> list of unit classnames // Or array of arrays of strings. array of strings is chosen at random and group is spawned in the order of the array. _size flag is ignored in this mode.
    _size <array> <int> number of units + random number to spawn
    _side <side> the side the units will be spawned as. this will override the side of the group, You could have a blufor group spawn as side EAST (redfor)
    _skill <float> number between 0 and 1, This will be the skill of the spawned units.
    _maxNumber <int> maximum number of units on the map. Includes players. If this number is reached, no more units will spawn
    _condition <code> the condition that is evaluated before any hostile groups are spawned. If the condition is false the units will not spawn. If the condition becomes true again the spawning will then continue.
    _delay <float> the time in seconds that we will wait before spawning another group
    _minDist <float> If any human player is found within this radius around the spawn area then the units will not spawn. // Can be overRidden on a case by case basis by executing the following code on the trigger in question. -  myTrigger setVariable ["zeu_hostile_minDist",300];
    _maxDist <float> If there are no targets found within this radius around the spawn area we will not spawn the units. -  myTrigger setVariable ["zeu_hostile_maxDist",1600];
    _exitCondition <code> code that if true will exit the loop and stop the spawning of any more units.
    _spawnCode <code> code that will be executed when a new group is spawned. Passed vars are [hostile group,target group]. code is called.
    _stalk <any> default: true. If bool units will stalk. If string then units will be sent to the marker with that name. If object units will be sent to the position of that object.
*/

// We only want the server running this
if !(isServer) exitWith {};

// Debug thing
if (isNil "DM_Debug") then {DM_Debug = false;};

params [["_targets",[grpNull]],["_locations",["hostile_spawn_","hostile_town_"]],["_classes",["I_C_Soldier_Para_2_F","I_C_Soldier_Para_7_F"]],["_size",[2,2]],["_side",independent],["_skill",0.2],["_maxNumber",150],["_condition",{true}],["_delay",40],["_minDist",300],["_maxDist",1600],["_exitCondition",{false}],["_spawnCode",{true}],["_stalk",true]];

private _spawnAreas = [];
private _spawnTowns = [];


// Radius used when finding building positions around triggers when attempting to spawn units in buildings
private _radius = 60;

_locations params ["_sa","_st"];

// populate our possible spawn location arrays.
for "_i" from 1 to 1000 do {
    _area = format["%1%2", _sa, _i];
    if !(isNil _area) then {
        _spawnAreas append [(call compile _area)];
    };
    _town = format["%1%2", _st, _i];
    if !(isNil _town) then {
        _obj = (call compile _town);
        _spawnTowns append [_obj];
        _obj setVariable ["zeu_hostile_isTown",true];
    };
    if ((isNil _area) && (isNil _town)) exitWith {};
};

while {true} do {
    private _time = 5;
    // if the exit condition is true then exit the loop.
    if (call _exitCondition) exitWith {if (dm_debug) then {systemChat "_exitCondition called. hostileInit exiting.";};};
    // if the condition returns true then continue. Else go round the loop again.
    if (call _condition) then {

        // Do we need to spawn any more enemies?
        if ((count allUnits) < _maxNumber) then {
            private _location = objNull;
            // find our spawn location

            // refine our list of groups by only selecting ones that have units in them
            private _groups = (_targets select {!(isNull _x) && {(count units _x) > 0}});

            // if we have no target groups then exit and run the loop again.
            if !((count _groups) > 0) exitWith {_time = 10;};

            // only select spawn areas that are valid.
            private _enabled_arr = ((_spawnAreas + _spawnTowns) select {_x getVariable ["valid_Hostile_Spawn", true]});

            // select all the objects that are within a cirtain distance from any squad.
            private _withinDist_arr = (_enabled_arr select { _loc = _x; (({((leader _x) distance _loc) < (_loc getVariable ["zeu_hostile_maxDist",_maxDist])} count _groups) > 0)});

            // if there are no viable locations then exit this scope and go round the loop again.
            if (count _withinDist_arr == 0) exitWith {_time = 10; if (dm_debug) then {systemChat "No nearby locations found";};};

            // Refine that list to only show the areas that have no human players within _minDist
            private _valid_arr = (_withinDist_arr select { _loc = _x; (({(_x distance _loc) > (_loc getVariable ["zeu_hostile_minDist",_minDist])} count allPlayers) == (count allPlayers))});

            // if there are no viable locations then exit this scope and go round the loop again.
            if (count _valid_arr == 0) exitWith {_time = 10; if (dm_debug) then {systemChat "No valid locations with no players nearby found";};};

            // define _location with a randomly selected a valid zone
            private _location = selectRandom _valid_arr;

            // if _location is null then exit this scope and go round the loop again.
            if (isNull _location) exitWith {
                _time = 10;
                if (dm_debug) then {systemChat "_location is undefined";};
            };

            // Find the nearest target group to the location
            private _groupDist = _groups apply {(leader _x) distance _location};
            private _distMin = selectMin _groupDist;
            private _groupIndex = _groupDist find _distMin;
            private _target = _groups # _groupIndex;

            // compile our list of units to spawn depending on our input classes structure
            private _units = if ((typeName (_classes # 0)) == "STRING") then {
                _size params ["_count","_extra"];
                private _out = [];
                for "_i" from 1 to (_count + round (random _extra)) do {
                    private _class = (selectRandom _classes);
                    _out append [_class];
                };
                _out;
            } else {
                selectRandom _classes;
            };

            // if the location is a town then we want to try and spawn these guys in a building, otherwise just spawn them ontop of the location.
            private _hostileGroup = (createGroup _side);
            if (_location getVariable ["zeu_hostile_isTown",false]) then {
                private _positions = [_location,_radius] call zeu_fnc_findBuildingPos;
                if ((count _positions) > 0) then {
                    {
                        private _pos = (selectRandom _positions);
                        private _unit = _hostileGroup createUnit [_x, _pos, [], 0, "NONE"];
                        _unit setPosATL _pos;
                    } forEach _units;
                } else {
                    private _position = (getPos _location);
                    {
                        private _pos = _position;
                        private _unit = _hostileGroup createUnit [_x, _pos, [], 0, "NONE"];
                    } forEach _units;
                };
            } else {
                private _position = (getPos _location);
                {
                    private _pos = _position;
                    private _unit = _hostileGroup createUnit [_x, _pos, [], 0, "NONE"];
                } forEach _units;
            };

            // Make the AI a bit more aggressive.
            {
                private _unit = _x;
                _unit disableAI "COVER";
                //_unit disableAI "AIMINGERROR";
                _unit disableAI "FSM";
                _unit disableAI "AUTOCOMBAT";

                _unit setSkill _skill;
                {
                    _unit setSkill _x;
                } forEach [["aimingAccuracy", 0.37],["aimingShake", 0.4],["aimingSpeed", 0.6],["spotDistance", 0.6],["spotTime", 0.7],["courage", 0.9],["reloadSpeed", _skill],["commanding", 0.9]];
            } forEach (units _hostileGroup);

            // Make the hostile group stalk one of the target groups
            switch (typeName _stalk) do {
                case "BOOL" : { [_hostileGroup, _target, 25, 10, {false}, 1] spawn bis_fnc_stalk; };
                case "OBJECT" : { _hostileGroup move (getPos _stalk); };
                case "STRING" : { _hostileGroup move (getMarkerPos _stalk); };
                default { [_hostileGroup, _target, 40, 12, {false},station] spawn bis_fnc_stalk;
            };

            // call the _spawnCode
            [_hostileGroup,_target] call _spawnCode;

            // set the sleep time to the full delay ammount;
            _time = _delay;
        } else {
            if (DM_Debug) then {systemChat format["%1 allUnits. Cap of %2 Reached.", count allUnits, _maxNumber];};
        };
    } else {
        if (DM_Debug) then {systemChat "Condition not met."};
    };

    // short delay before we run the loop again
    sleep _time;
};