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 ["SAFE ZONE _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;

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

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

    // Remote execution block for each client
    {
        private _player = _x;
        private _playerSide = side _player;

        if (_playerSide != _side) then {
            {
                [_x, 0] remoteExec ["setMarkerAlpha", _player];
            } forEach _markers;
        } else {
            {
                [_x, 1] remoteExec ["setMarkerAlpha", _player];
            } forEach _markers;
        };
    } forEach allPlayers;
};

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

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

[_safezoneTrigger, _side] spawn
{
    params ["_safezoneTrigger", "_side"];

    private _old_safezone = [];

    while {true} do
    {
        private _entitiesInSafezone = (allUnits + vehicles) select {(_x inArea _safezoneTrigger)};
        private _new_safezone = _entitiesInSafezone select {!(_x in _old_safezone)};
        private _left_safezone = _old_safezone select {!(_x inArea _safezoneTrigger)};
        _old_safezone = _entitiesInSafezone;

        // Debugging: Log the entities in the safezone
        diag_log format ["Entities in safezone: %1", _entitiesInSafezone];
        diag_log format ["New entities in safezone: %1", _new_safezone];
        diag_log format ["Entities left safezone: %1", _left_safezone];

        // Handle units/vehicles entering the safezone
        {
            private _entity = _x;
            private _vehicle = vehicle _entity;
            private _entitySide = side _entity;


            // If the entity is a vehicle itself, adjust accordingly
            if (_entity isKindOf "LandVehicle" || _entity isKindOf "Air" || _entity isKindOf "Ship") then {
                _vehicle = _entity;
                _entitySide = side _vehicle;
            };

            // Debugging: Log the entity and its side
            diag_log format ["Entity entering: %1, Side: %2", _entity, _entitySide];

            if (_entitySide == _side) then
            {
                // Apply 10-second delay before protection
                [_entity, _vehicle] spawn {
                    params ["_entity", "_vehicle"];
                    _delay = _entity getVariable ["NUP_safezoneDelay", true];


                        if (_delay==true) then
                        {
                            sleep 10;

                            if (_entity == player) then
                            {
                                _entity commandChat "Safezone Protection Initializing in 10 seconds.";
                            };

                            if (_entity == player) then
                            {
                                _entity commandChat "Safezone Protection: Activated.";
                            };
                            [_entity, false] remoteExec ["allowDamage", _entity];
                            if (!isNull _vehicle) then
                            {
                                [_vehicle, false] remoteExec ["allowDamage", _vehicle];
                            };
                        }
                        else
                        {
                            if (_entity == player) then
                            {
                                _entity commandChat "Safezone Protection: Activated.";
                            };
                            [_entity, false] remoteExec ["allowDamage", _entity];
                            if (!isNull _vehicle) then
                            {
                                [_vehicle, false] remoteExec ["allowDamage", _vehicle];
                            };
                        };

                };
            }
            else
            {
                if (_entity == player) then { _entity commandChat "You've entered an enemy safezone."; };
                if (_entity isKindOf "man") then {_entity call BIS_fnc_neutralizeUnit;};
                if (count (crew _vehicle) > 0) then
                {
                    _vehicle call BIS_fnc_neutralizeUnit;
                };
            };
        } forEach _new_safezone;

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

            // Debugging: Log the entity and its vehicle status
            diag_log format ["Entity leaving: %1, Vehicle: %2", _entity, _vehicle];

            [_entity, true] remoteExec ["allowDamage", _entity];
            if (_entity isKindOf "LandVehicle" || _entity isKindOf "helicopter"|| _entity isKindOf "plane" || _entity isKindOf "Ship") then {
                [_vehicle, true] remoteExec ["allowDamage", _vehicle];
            };

            if (_entity == player) then { _entity commandChat "Safezone Protection: Deactivated."; };
        } forEach _left_safezone;

        sleep 1;
    };
};

//Adjust terrain height for safezone
 /*   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

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