fn_initSafezone.sqf

//NUP\NUP_flagCapture\functions\NUP_fnc_initSafezone.sqf


if !(isServer) exitWith {};

// Check if sidesArray already exists and initialize if not
if (isNil "sidesArray") then {
    sidesArray = [East, West, Civilian, Independent];
};

// Ensure there are sides in the array before proceeding
if !(count sidesArray > 0) exitWith {};

params
[
    ["_logic", objNull, [objNull]],
    ["_markerSize", [250, 140], [[]], 2]
];

// Randomly select a side
_side = sidesArray call BIS_fnc_selectRandom;
diag_log format ["_side: %1", _side];

_flagSide = "Flag_White_F";
_szMarkerColor = "";
_spawnName = "HQ";

// Define flag color based on side
switch (_side) do
{
    case east:
    {
        _flagSide = "Flag_Red_F";
        _szMarkerColor = "ColorOPFOR";
        _spawnName = "OPFOR HQ";
    };
    case west:
    {
        _flagSide = "Flag_Blue_F";
        _szMarkerColor = "ColorBLUFOR";
        _spawnName = "BLUFOR HQ";
    };
    case civilian:
    {
        _flagSide = "Flag_FD_Purple_F";
        _szMarkerColor = "ColorCivilian";
        _spawnName = "CIVFOR HQ";
    };
    case independent:
    {
        _flagSide = "Flag_Green_F";
        _szMarkerColor = "ColorIndependent";
        _spawnName = "INDFOR HQ";
    };
};

// Spawn the flag
_flag = createVehicle [_flagSide, getPosATL _logic, [], 0, "CAN_COLLIDE"];
_flag allowDamage false;

// Function to hide markers for players not on the specified side
private _hideMarkersForSide = {
    params ["_flag", "_side"];

    // Get the position of the flag
    private _flagPos = getPosATL _flag;

    // Define the radius
    private _radius = 100;

    // Collect markers within 70m of the flag
    private _markers = [];
    {
        private _markerPos = getMarkerPos _x;
        if ((_markerPos distance2D _flagPos) <= _radius) then {
            _markers pushBack _x;
        };
    } forEach allMapMarkers;

    // Log markers in the array for debugging
    diag_log format ["Markers in trigger area: %1", _markers];

    // Iterate through all players and hide markers for those not on the specified side
    {
        private _playerSide = side _x;
        if (_playerSide != _side) then {
            {
                _x setMarkerAlpha 0;
            } forEach _markers;
        } else {
            {
                _x setMarkerAlpha 1;
            } forEach _markers;
        };
    } forEach allPlayers;
};

// Call the function to hide markers
[_flag, _side] call _hideMarkersForSide;


// Create respawn marker
_respawnMarker = createMarker [format ["respawn_%1", _side], getPos _logic];
_respawnMarker setMarkerType "b_hq";
_respawnMarker setMarkersize [1, 1];
_respawnMarker setMarkerAlpha 1;
_respawnMarker setMarkerColor _szMarkerColor;
_respawnMarker setMarkerText format ["%1",_spawnName];
_flag setVariable[ "NUP_respawnMarker", _respawnMarker, true ];

// Create safezone marker
_safezoneMarker = createMarker [format ["safezoneMarker_%1", _side], getPos _logic];
_safezoneMarker setMarkerShape "ELLIPSE";
_safezoneMarker setMarkerSize _markerSize;
_safezoneMarker setMarkerDir (getDir _logic);
_safezoneMarker setMarkerBrush "Solid";
_safezoneMarker setMarkerColor _szMarkerColor;
_safezoneMarker setMarkerAlpha 0.85;
_flag setVariable[ "NUP_safezoneMarker", _safezoneMarker, true ];

// Iterate through all players
{
    private _playerSide = side _x; // Get the side of the player

    // Check if the player's side matches the desired side
    if (_playerSide != _side) then {
        // Set opacity to zero for players whose side doesn't match
        _safezoneMarker setMarkerAlpha 0;
        _respawnMarker setMarkerAlpha 0;
    };
} forEach allPlayers;


//Create trigger centered on the safezone marker
_safezoneTrigger = createTrigger ["EmptyDetector", getPos _logic];
_triggerSize = [(_markerSize select 1), (_markerSize select 0),0, false, 20];
_safezoneTrigger setTriggerArea _triggerSize;
_safezoneTrigger setTriggerActivation ["ANY", "PRESENT", true]; // Activate only if a player of the specified side is present
_safezoneDelay = player getVariable ["NUP_safezoneDelay", false];

_trigger = _safezoneTrigger;

// Function to initiate cruise missile strike on any player or vehicle from an opposing side entering the safezone
_initiateCruiseMissileStrike = {
    params ["_unit", "_side"];
    if (!alive _unit) exitWith {}; // Check if the unit is alive

    private _targetPos = getPos _unit; // Get the position of the unit or vehicle

    // Parameters for missile strike
    private _numberOfMissiles = 3; // Number of missiles
    private _timeBetweenMissiles = 0.75; // Time between each missile
    private _spawnSpread = 50; // Spread of missile spawn
    private _spawnHeight = 150; // Height of missile spawn
    private _targetSpread = 1; // Spread of missile target
    private _missileType = "M_NLAW_AT_F"; // Type of missile

    // Loop to spawn missiles
    for [{_i = 0}, {_i < _numberOfMissiles}, {_i = _i + 1}] do {
        // Calculate spawn position with random spread
        private _spawnPosition = [
            (_targetPos select 0) - _spawnSpread + (random (_spawnSpread * 2)),
            (_targetPos select 1) - _spawnSpread + (random (_spawnSpread * 2)),
            _spawnHeight
        ];

        // Calculate target position without random spread
        private _targetPosition = [
        _targetPos select 0,
        _targetPos select 1,
        getTerrainHeightASL _targetPos
        ];

        // Spawn missile
        private _missile = _missileType createVehicle _spawnPosition;

        // Get missile position
        private _missilePosition = getPosASL _missile;

        // Calculate direction to target
        private _direction = [_missilePosition, _targetPosition] call BIS_fnc_vectorFromXToY;

        // Set missile direction
        _missile setVectorDirAndUp [_direction, [0, 1, 0]];

        // Set missile velocity
        _missile setVelocity ([_direction, 1200] call BIS_fnc_vectorMultiply);

        // Wait before spawning next missile
        sleep _timeBetweenMissiles;
    };
};

[_trigger, _side, _initiateCruiseMissileStrike] spawn {
    params ["_trigger", "_side", "_initiateCruiseMissileStrike"];

    private _old_safezone = [];

    while {true} do {
        private _new_safezone = ((allUnits + vehicles) - allDead) select {(_x inArea _trigger) and !(_x in _old_safezone)};
        private _left_safezone = _old_safezone select {!(_x inArea _trigger)};
        _old_safezone = (_old_safezone select {_x inArea _trigger}) + _new_safezone;

        // Handle units/vehicles entering the safezone
{
    private _unit = _x;
    private _vehicle = vehicle _unit;
    private _unitSide = side _unit;
    private _vehicleSide = _vehicle getVariable ["NUP_vehicleSide", sideUnknown];

    if ((_unitSide == _side) || (_vehicleSide == _side) || (_unitSide == sideUnknown) || (_vehicleSide == sideUnknown)) then {
        // Apply invulnerability only to units in their own safezone
        if (_unitSide == _side) then {
            if (local _unit) then {
                if (_unit getVariable ["NUP_safezoneDelay", false]) then {
                    systemChat "Safezone Protection Initializing in 10 seconds.";
                    sleep 10;
                    systemChat "Safezone Protection: Activated.";
                    _unit setVariable ["NUP_safezoneDelay", false];
                } else {
                    systemChat "Safezone Protection: Activated.";
                };
                _unit allowDamage false;
                if (!isNull _vehicle && {_vehicle != _unit}) then {
                    _vehicle allowDamage false;
                };
            } else {
                [_unit, false] remoteExec ["allowDamage", _unit];
                if (!isNull _vehicle && {_vehicle != _unit}) then {
                    [_vehicle, false] remoteExec ["allowDamage", _vehicle];
                };
            };
        } else {
            //[_unit, _side] call _initiateCruiseMissileStrike;


        };
    };

    };
} forEach _new_safezone;

        // Handle units/vehicles leaving the safezone
        {
            private _unit = _x;
            private _vehicle = vehicle _unit;

            if (local _unit) then {
                _unit allowDamage true;
                systemChat "Safezone Protection: Deactivated.";
                _unit setVariable ["NUP_safezoneDelay", true];
                if (!isNull _vehicle && {_vehicle != _unit}) then {
                    _vehicle allowDamage true;
                };
            } else {
                [_unit, true] remoteExec ["allowDamage", _unit];
                if (!isNull _vehicle && {_vehicle != _unit}) then {
                    [_vehicle, true] remoteExec ["allowDamage", _vehicle];
                };
            };
        } forEach _left_safezone;

        sleep 1;
    };
};



// Event handler to set the side of the vehicle to sideUnknown when created
_vehicleInitHandler = {
    params ["_vehicle"];
    _vehicle setVariable ["NUP_vehicleSide", sideUnknown, true];
};

// Monitor new vehicle creations to set the initial side
_addVehicleInitHandler = {
    params ["_vehicle"];
    hintSilent format ["Vehicle created: %1", typeOf _vehicle]; // Debug message

    // Check if the vehicle is alive
    if (alive _vehicle) then {
        [_vehicle] call _vehicleInitHandler;
    };
};

// Apply the initial side setting handler to all vehicles currently present
{
    [_x] call _vehicleInitHandler;
} forEach vehicles;

// Monitor new vehicle creations
_addVehicleHandler = addMissionEventHandler ["EntityCreated", {
    params ["_entity"];
    hintSilent format ["Entity created: %1", typeOf _entity]; // Debug message

    // Check if the entity is a vehicle
    if (_entity isKindOf "AllVehicles") then {
        [_entity] call _addVehicleInitHandler;
    };
}];




 /*   private _triggerPos = getPosWorld _safezoneTrigger;
    private _triggerSize = triggerArea _safezoneTrigger;
    private _height = _triggerPos select 2;
    private _position = getPosWorld _safezoneTrigger;
    private _triggerLength = (_triggerSize) # 0;
    private _triggerWidth = (_triggerSize) # 1;
    private _triggerAngle = (_triggerSize) # 2;

    private _pos = [(_position#0 + cos(_triggerAngle) * _triggerLength + sin(_triggerAngle) * _triggerWidth), (_position#1 - sin(_triggerAngle) * _triggerLength + cos(_triggerAngle) * _triggerWidth)];
    private _positionsAndHeights = [];
    _pos pushBack _height;

    for "_i" from 0 to (_triggerLength * 8) do {
        private _pos2 = _pos;

        for "_j" from 0 to (_triggerWidth * 8) do {
            _positionsAndHeights pushBack _pos2;
            _pos2 = _pos2 vectorAdd [-0.25 * sin(_triggerAngle), -0.25 * cos(_triggerAngle), 0];
        };

        _pos = _pos  vectorAdd [-0.25 * cos(_triggerAngle), 0.25 * sin(_triggerAngle), 0];
    };

    //{_x hideObjectGlobal true} forEach (allMissionObjects "" inAreaArray _x);

    setTerrainHeight[_positionsAndHeights, false];*/

    // Event handler to set the side of the vehicle to sideUnknown when created
    _vehicleInitHandler = {
    params ["_vehicle"];
    _vehicle setVariable ["NUP_vehicleSide", sideUnknown, true];
    };


// Remove selected side from the array
sidesArray = sidesArray - [_side];