View difference between Paste ID: xSiUUq1E and 5SbNj6F5

 diag_log "Towing script line 1 found...";
 #define SA_Find_Surface_ASL_Under_Position(_object,_positionAGL,_returnSurfaceASL,_canFloat) \
 _objectASL = AGLToASL (_object modelToWorldVisual (getCenterOfMass _object)); \
 _surfaceIntersectStartASL = [_positionAGL select 0, _positionAGL select 1, (_objectASL select 2) + 1]; \
 _surfaceIntersectEndASL = [_positionAGL select 0, _positionAGL select 1, (_objectASL select 2) - 5]; \
 _surfaces = lineIntersectsSurfaces [_surfaceIntersectStartASL, _surfaceIntersectEndASL, _object, objNull, true, 5]; \
 _returnSurfaceASL = AGLToASL _positionAGL; \
 { \
     scopeName "surfaceLoop"; \
     if( isNull (_x select 2) ) then { \
         _returnSurfaceASL = _x select 0; \
         breakOut "surfaceLoop"; \
     } else { \
         if!((_x select 2) isKindOf "RopeSegment") then { \
             _objectFileName = str (_x select 2); \
             if((_objectFileName find " t_") == -1 && (_objectFileName find " b_") == -1) then { \
                 _returnSurfaceASL = _x select 0; \
                 breakOut "surfaceLoop"; \
             }; \
         }; \
     }; \
 } forEach _surfaces; \
 if(_canFloat && (_returnSurfaceASL select 2) < 0) then { \
     _returnSurfaceASL set [2,0]; \
 }; \
 diag_log "Towing script started...";
 #define SA_Find_Surface_ASL_Under_Model(_object,_modelOffset,_returnSurfaceASL,_canFloat) \
 SA_Find_Surface_ASL_Under_Position(_object, (_object modelToWorldVisual _modelOffset), _returnSurfaceASL,_canFloat);
 
 #define SA_Find_Surface_AGL_Under_Model(_object,_modelOffset,_returnSurfaceAGL,_canFloat) \
 SA_Find_Surface_ASL_Under_Model(_object,_modelOffset,_returnSurfaceAGL,_canFloat); \
 _returnSurfaceAGL = ASLtoAGL _returnSurfaceAGL;
 
 #define SA_Get_Cargo(_vehicle,_cargo) \
 if( count (ropeAttachedObjects _vehicle) == 0 ) then { \
     _cargo = objNull; \
 } else { \
     _cargo = ((ropeAttachedObjects _vehicle) select 0) getVariable ["SA_Cargo",objNull]; \
 };
 
 SA_Advanced_Towing_Install = {
 
 // Prevent advanced towing from installing twice
-if(!isNil "SA_TOW_INIT") exitWith {};
+if(!isNil "SA_TOW_INIT") exitWith {diag_log "Towing script exited! SA_TOW_INIT already defined"};
 SA_TOW_INIT = true;
 
 diag_log "Advanced Towing Loading...";
 
 SA_Simulate_Towing_Speed = {
 
     params ["_vehicle"];
 
     private ["_runSimulation","_currentCargo","_maxVehicleSpeed","_maxTowedVehicles","_vehicleMass"];
 
     _maxVehicleSpeed = getNumber (configFile >> "CfgVehicles" >> typeOf _vehicle >> "maxSpeed");
     _vehicleMass = 1000 max (getMass _vehicle);
     _maxTowedCargo = missionNamespace getVariable ["SA_MAX_TOWED_CARGO",2];
     _runSimulation = true;
 
     private ["_currentVehicle","_totalCargoMass","_totalCargoCount","_findNextCargo","_towRopes","_ropeLength"];
     private ["_ends","_endsDistance","_currentMaxSpeed","_newMaxSpeed"];
 
     while {_runSimulation} do {
 
         // Calculate total mass and count of cargo being towed (only takes into account
         // cargo that's actively being towed (e.g. there's no slack in the rope)
 
         _currentVehicle = _vehicle;
         _totalCargoMass = 0;
         _totalCargoCount = 0;
         _findNextCargo = true;
         while {_findNextCargo} do {
             _findNextCargo = false;
             SA_Get_Cargo(_currentVehicle,_currentCargo);
             if(!isNull _currentCargo) then {
                 _towRopes = _currentVehicle getVariable ["SA_Tow_Ropes",[]];
                 if(count _towRopes > 0) then {
                     _ropeLength = ropeLength (_towRopes select 0);
                     _ends = ropeEndPosition (_towRopes select 0);
                     _endsDistance = (_ends select 0) distance (_ends select 1);
                     if( _endsDistance >= _ropeLength - 2 ) then {
                         _totalCargoMass = _totalCargoMass + (1000 max (getMass _currentCargo));
                         _totalCargoCount = _totalCargoCount + 1;
                         _currentVehicle = _currentCargo;
                         _findNextCargo = true;
                     };
                 };
             };
         };
 
         _newMaxSpeed = _maxVehicleSpeed / (1 max ((_totalCargoMass /  _vehicleMass) * 2));
         _newMaxSpeed = (_maxVehicleSpeed * 0.75) min _newMaxSpeed;
 
         // Prevent vehicle from moving if trying to move more cargo than pre-defined max
         if(_totalCargoCount > _maxTowedCargo) then {
             _newMaxSpeed = 0;
         };
 
         _currentMaxSpeed = _vehicle getVariable ["SA_Max_Tow_Speed",_maxVehicleSpeed];
 
         if(_currentMaxSpeed != _newMaxSpeed) then {
             _vehicle setVariable ["SA_Max_Tow_Speed",_newMaxSpeed];
         };
 
         sleep 0.1;
 
     };
 };
 
 SA_Simulate_Towing = {
 
     params ["_vehicle","_vehicleHitchModelPos","_cargo","_cargoHitchModelPos","_ropeLength"];
 
     private ["_lastCargoHitchPosition","_lastCargoVectorDir","_cargoLength","_maxDistanceToCargo","_lastMovedCargoPosition","_cargoHitchPoints"];
     private ["_vehicleHitchPosition","_cargoHitchPosition","_newCargoHitchPosition","_cargoVector","_movedCargoVector","_attachedObjects","_currentCargo"];
     private ["_newCargoDir","_lastCargoVectorDir","_newCargoPosition","_doExit","_cargoPosition","_vehiclePosition","_maxVehicleSpeed","_vehicleMass","_cargoMass","_cargoCanFloat"];
     private ["_cargoCorner1AGL","_cargoCorner1ASL","_cargoCorner2AGL","_cargoCorner2ASL","_cargoCorner3AGL","_cargoCorner3ASL","_cargoCorner4AGL","_cargoCorner4ASL","_surfaceNormal1","_surfaceNormal2","_surfaceNormal"];
     private ["_cargoCenterASL","_surfaceHeight","_surfaceHeight2","_maxSurfaceHeight"];
 
     _maxVehicleSpeed = getNumber (configFile >> "CfgVehicles" >> typeOf _vehicle >> "maxSpeed");
     _cargoCanFloat = if( getNumber (configFile >> "CfgVehicles" >> typeOf _cargo >> "canFloat") == 1 ) then { true } else { false };
 
     private ["_cargoCenterOfMassAGL","_cargoModelCenterGroundPosition"];
     SA_Find_Surface_AGL_Under_Model(_cargo,getCenterOfMass _cargo,_cargoCenterOfMassAGL,_cargoCanFloat);
     _cargoModelCenterGroundPosition = _cargo worldToModelVisual _cargoCenterOfMassAGL;
     _cargoModelCenterGroundPosition set [0,0];
     _cargoModelCenterGroundPosition set [1,0];
     _cargoModelCenterGroundPosition set [2, (_cargoModelCenterGroundPosition select 2) - 0.05]; // Adjust height so that it doesn't ride directly on ground
 
     // Calculate cargo model corner points
     private ["_cargoCornerPoints"];
     _cargoCornerPoints = [_cargo] call SA_Get_Corner_Points;
     _corner1 = _cargoCornerPoints select 0;
     _corner2 = _cargoCornerPoints select 1;
     _corner3 = _cargoCornerPoints select 2;
     _corner4 = _cargoCornerPoints select 3;
 
 
     // Try to set cargo owner if the towing client doesn't own the cargo
     if(local _vehicle && !local _cargo) then {
         [[_cargo, clientOwner],"SA_Set_Owner"] call SA_RemoteExecServer;
     };
 
     _vehicleHitchModelPos set [2,0];
     _cargoHitchModelPos set [2,0];
 
     _lastCargoHitchPosition = _cargo modelToWorld _cargoHitchModelPos;
     _lastCargoVectorDir = vectorDir _cargo;
     _lastMovedCargoPosition = getPos _cargo;
 
     _cargoHitchPoints = [_cargo] call SA_Get_Hitch_Points;
     _cargoLength = (_cargoHitchPoints select 0) distance (_cargoHitchPoints select 1);
 
     _vehicleMass = 1 max (getMass _vehicle);
     _cargoMass = getMass _cargo;
     if(_cargoMass == 0) then {
         _cargoMass = _vehicleMass;
     };
 
     _maxDistanceToCargo = _ropeLength;
 
     _doExit = false;
 
     // Start vehicle speed simulation
     [_vehicle] spawn SA_Simulate_Towing_Speed;
 
     while {!_doExit} do {
 
         _vehicleHitchPosition = _vehicle modelToWorld _vehicleHitchModelPos;
         _vehicleHitchPosition set [2,0];
         _cargoHitchPosition = _lastCargoHitchPosition;
         _cargoHitchPosition set [2,0];
 
         _cargoPosition = getPos _cargo;
         _vehiclePosition = getPos _vehicle;
 
         if(_vehicleHitchPosition distance _cargoHitchPosition > _maxDistanceToCargo) then {
 
             // Calculated simulated towing position + direction
             _newCargoHitchPosition = _vehicleHitchPosition vectorAdd ((_vehicleHitchPosition vectorFromTo _cargoHitchPosition) vectorMultiply _ropeLength);
             _cargoVector = _lastCargoVectorDir vectorMultiply _cargoLength;
             _movedCargoVector = _newCargoHitchPosition vectorDiff _lastCargoHitchPosition;
             _newCargoDir = vectorNormalized (_cargoVector vectorAdd _movedCargoVector);
             //if(_isRearCargoHitch) then {
             //  _newCargoDir = _newCargoDir vectorMultiply -1;
             //};
             _lastCargoVectorDir = _newCargoDir;
             _newCargoPosition = _newCargoHitchPosition vectorAdd (_newCargoDir vectorMultiply -(vectorMagnitude (_cargoHitchModelPos)));
 
             SA_Find_Surface_ASL_Under_Position(_cargo,_newCargoPosition,_newCargoPosition,_cargoCanFloat);
 
             // Calculate surface normal (up) (more realistic than surfaceNormal function)
             SA_Find_Surface_ASL_Under_Model(_cargo,_corner1,_cargoCorner1ASL,_cargoCanFloat);
             SA_Find_Surface_ASL_Under_Model(_cargo,_corner2,_cargoCorner2ASL,_cargoCanFloat);
             SA_Find_Surface_ASL_Under_Model(_cargo,_corner3,_cargoCorner3ASL,_cargoCanFloat);
             SA_Find_Surface_ASL_Under_Model(_cargo,_corner4,_cargoCorner4ASL,_cargoCanFloat);
             _surfaceNormal1 = (_cargoCorner1ASL vectorFromTo _cargoCorner3ASL) vectorCrossProduct (_cargoCorner1ASL vectorFromTo _cargoCorner2ASL);
             _surfaceNormal2 = (_cargoCorner4ASL vectorFromTo _cargoCorner2ASL) vectorCrossProduct (_cargoCorner4ASL vectorFromTo _cargoCorner3ASL);
             _surfaceNormal = _surfaceNormal1 vectorAdd _surfaceNormal2;
 
             if(missionNamespace getVariable ["SA_TOW_DEBUG_ENABLED", false]) then {
                 if(isNil "sa_tow_debug_arrow_1") then {
                     sa_tow_debug_arrow_1 = "Sign_Arrow_F" createVehicleLocal [0,0,0];
                     sa_tow_debug_arrow_2 = "Sign_Arrow_F" createVehicleLocal [0,0,0];
                     sa_tow_debug_arrow_3 = "Sign_Arrow_F" createVehicleLocal [0,0,0];
                     sa_tow_debug_arrow_4 = "Sign_Arrow_F" createVehicleLocal [0,0,0];
                 };
                 sa_tow_debug_arrow_1 setPosASL _cargoCorner1ASL;
                 sa_tow_debug_arrow_1 setVectorUp _surfaceNormal;
                 sa_tow_debug_arrow_2 setPosASL _cargoCorner2ASL;
                 sa_tow_debug_arrow_2 setVectorUp _surfaceNormal;
                 sa_tow_debug_arrow_3 setPosASL _cargoCorner3ASL;
                 sa_tow_debug_arrow_3 setVectorUp _surfaceNormal;
                 sa_tow_debug_arrow_4 setPosASL _cargoCorner4ASL;
                 sa_tow_debug_arrow_4 setVectorUp _surfaceNormal;
             };
 
             // Calculate adjusted surface height based on surface normal (prevents vehicle from clipping into ground)
             _cargoCenterASL = AGLtoASL (_cargo modelToWorldVisual [0,0,0]);
             _cargoCenterASL set [2,0];
             _surfaceHeight = ((_cargoCorner1ASL vectorAdd ( _cargoCenterASL vectorMultiply -1)) vectorDotProduct _surfaceNormal1) /  ([0,0,1] vectorDotProduct _surfaceNormal1);
             _surfaceHeight2 = ((_cargoCorner1ASL vectorAdd ( _cargoCenterASL vectorMultiply -1)) vectorDotProduct _surfaceNormal2) /  ([0,0,1] vectorDotProduct _surfaceNormal2);
             _maxSurfaceHeight = (_newCargoPosition select 2) max _surfaceHeight max _surfaceHeight2;
             _newCargoPosition set [2, _maxSurfaceHeight ];
 
             _newCargoPosition = _newCargoPosition vectorAdd ( _cargoModelCenterGroundPosition vectorMultiply -1 );
 
             _cargo setVectorDir _newCargoDir;
             _cargo setVectorUp _surfaceNormal;
             _cargo setPosWorld _newCargoPosition;
 
             _lastCargoHitchPosition = _newCargoHitchPosition;
             _maxDistanceToCargo = _vehicleHitchPosition distance _newCargoHitchPosition;
             _lastMovedCargoPosition = _cargoPosition;
 
             _massAdjustedMaxSpeed = _vehicle getVariable ["SA_Max_Tow_Speed",_maxVehicleSpeed];
             if(speed _vehicle > (_massAdjustedMaxSpeed)+0.1) then {
                 _vehicle setVelocity ((vectorNormalized (velocity _vehicle)) vectorMultiply (_massAdjustedMaxSpeed/3.6));
             };
 
         } else {
 
             if(_lastMovedCargoPosition distance _cargoPosition > 2) then {
                 _lastCargoHitchPosition = _cargo modelToWorld _cargoHitchModelPos;
                 _lastCargoVectorDir = vectorDir _cargo;
             };
 
         };
 
         // If vehicle isn't local to the client, switch client running towing simulation
         if(!local _vehicle) then {
             [_this,"SA_Simulate_Towing",_vehicle] call SA_RemoteExec;
             _doExit = true;
         };
 
         // If the vehicle isn't towing anything, stop the towing simulation
         SA_Get_Cargo(_vehicle,_currentCargo);
         if(isNull _currentCargo) then {
             _doExit = true;
         };
 
         sleep 0.01;
 
     };
 };
 
 SA_Get_Corner_Points = {
     params ["_vehicle"];
     private ["_centerOfMass","_bbr","_p1","_p2","_rearCorner","_rearCorner2","_frontCorner","_frontCorner2"];
     private ["_maxWidth","_widthOffset","_maxLength","_lengthOffset","_widthFactor","_lengthFactor"];
 
     // Correct width and length factor for air
     _widthFactor = 0.75;
     _lengthFactor = 0.75;
     if(_vehicle isKindOf "Air") then {
         _widthFactor = 0.3;
     };
     if(_vehicle isKindOf "Helicopter") then {
         _widthFactor = 0.2;
         _lengthFactor = 0.45;
     };
 
     _centerOfMass = getCenterOfMass _vehicle;
     _bbr = boundingBoxReal _vehicle;
     _p1 = _bbr select 0;
     _p2 = _bbr select 1;
     _maxWidth = abs ((_p2 select 0) - (_p1 select 0));
     _widthOffset = ((_maxWidth / 2) - abs ( _centerOfMass select 0 )) * _widthFactor;
     _maxLength = abs ((_p2 select 1) - (_p1 select 1));
     _lengthOffset = ((_maxLength / 2) - abs (_centerOfMass select 1 )) * _lengthFactor;
     _rearCorner = [(_centerOfMass select 0) + _widthOffset, (_centerOfMass select 1) - _lengthOffset, _centerOfMass select 2];
     _rearCorner2 = [(_centerOfMass select 0) - _widthOffset, (_centerOfMass select 1) - _lengthOffset, _centerOfMass select 2];
     _frontCorner = [(_centerOfMass select 0) + _widthOffset, (_centerOfMass select 1) + _lengthOffset, _centerOfMass select 2];
     _frontCorner2 = [(_centerOfMass select 0) - _widthOffset, (_centerOfMass select 1) + _lengthOffset, _centerOfMass select 2];
 
     if(missionNamespace getVariable ["SA_TOW_DEBUG_ENABLED", false]) then {
         if(isNil "sa_tow_debug_arrow_1") then {
             sa_tow_debug_arrow_1 = "Sign_Arrow_F" createVehicleLocal [0,0,0];
             sa_tow_debug_arrow_2 = "Sign_Arrow_F" createVehicleLocal [0,0,0];
             sa_tow_debug_arrow_3 = "Sign_Arrow_F" createVehicleLocal [0,0,0];
             sa_tow_debug_arrow_4 = "Sign_Arrow_F" createVehicleLocal [0,0,0];
         };
         sa_tow_debug_arrow_1 setPosASL  AGLtoASL (_vehicle modelToWorldVisual _rearCorner);
         sa_tow_debug_arrow_2 setPosASL  AGLtoASL (_vehicle modelToWorldVisual _rearCorner2);
         sa_tow_debug_arrow_3 setPosASL  AGLtoASL (_vehicle modelToWorldVisual _frontCorner);
         sa_tow_debug_arrow_4 setPosASL  AGLtoASL (_vehicle modelToWorldVisual _frontCorner2);
     };
 
     [_rearCorner,_rearCorner2,_frontCorner,_frontCorner2];
 };
 
 SA_Get_Hitch_Points = {
     params ["_vehicle"];
     private ["_cornerPoints","_rearCorner","_rearCorner2","_frontCorner","_frontCorner2","_rearHitchPoint"];
     private ["_frontHitchPoint","_sideLeftPoint","_sideRightPoint"];
     _cornerPoints = [_vehicle] call SA_Get_Corner_Points;
     _rearCorner = _cornerPoints select 0;
     _rearCorner2 = _cornerPoints select 1;
     _frontCorner = _cornerPoints select 2;
     _frontCorner2 = _cornerPoints select 3;
     _rearHitchPoint = ((_rearCorner vectorDiff _rearCorner2) vectorMultiply 0.5) vectorAdd  _rearCorner2;
     _frontHitchPoint = ((_frontCorner vectorDiff _frontCorner2) vectorMultiply 0.5) vectorAdd  _frontCorner2;
     //_sideLeftPoint = ((_frontCorner vectorDiff _rearCorner) vectorMultiply 0.5) vectorAdd  _frontCorner;
     //_sideRightPoint = ((_frontCorner2 vectorDiff _rearCorner2) vectorMultiply 0.5) vectorAdd  _frontCorner2;
     [_frontHitchPoint,_rearHitchPoint];
 };
 
 SA_Attach_Tow_Ropes = {
     params ["_cargo","_player"];
     _vehicle = _player getVariable ["SA_Tow_Ropes_Vehicle", objNull];
     if(!isNull _vehicle) then {
         if(local _vehicle) then {
             private ["_towRopes","_vehicleHitch","_cargoHitch","_objDistance","_ropeLength"];
             _towRopes = _vehicle getVariable ["SA_Tow_Ropes",[]];
             if(count _towRopes == 1) then {
 
                 /*
                 private ["_cargoHitchPoints","_distanceToFrontHitch","_distanceToRearHitch","_isRearCargoHitch"];
                 _cargoHitchPoints = [_cargo] call SA_Get_Hitch_Points;
                 _distanceToFrontHitch = player distance (_cargo modelToWorld (_cargoHitchPoints select 0));
                 _distanceToRearHitch = player distance (_cargo modelToWorld (_cargoHitchPoints select 1));
                 if( _distanceToFrontHitch < _distanceToRearHitch ) then {
                     _cargoHitch = _cargoHitchPoints select 0;
                     _isRearCargoHitch = false;
                 } else {
                     _cargoHitch = _cargoHitchPoints select 1;
                     _isRearCargoHitch = true;
                 };
                 */
 
                 _cargoHitch = ([_cargo] call SA_Get_Hitch_Points) select 0;
 
                 _vehicleHitch = ([_vehicle] call SA_Get_Hitch_Points) select 1;
                 _ropeLength = (ropeLength (_towRopes select 0));
                 _objDistance = ((_vehicle modelToWorld _vehicleHitch) distance (_cargo modelToWorld _cargoHitch));
                 if( _objDistance > _ropeLength ) then {
                     [["The tow ropes are too short. Move vehicle closer.", false],"SA_Hint",_player] call SA_RemoteExec;
                 } else {
                     [_vehicle,_player] call SA_Drop_Tow_Ropes;
                     _helper = "Land_Can_V2_F" createVehicle position _cargo;
                     _helper attachTo [_cargo, _cargoHitch];
                     _helper setVariable ["SA_Cargo",_cargo,true];
                     hideObject _helper;
                     [[_helper],"SA_Hide_Object_Global"] call SA_RemoteExecServer;
                     [_helper, [0,0,0], [0,0,-1]] ropeAttachTo (_towRopes select 0);
                     [_vehicle,_vehicleHitch,_cargo,_cargoHitch,_ropeLength] spawn SA_Simulate_Towing;
                 };
             };
         } else {
             [_this,"SA_Attach_Tow_Ropes",_vehicle,true] call SA_RemoteExec;
         };
     };
 };
 
 SA_Take_Tow_Ropes = {
     params ["_vehicle","_player"];
     if(local _vehicle) then {
         diag_log format ["Take Tow Ropes Called %1", _this];
         private ["_existingTowRopes","_hitchPoint","_rope"];
         _existingTowRopes = _vehicle getVariable ["SA_Tow_Ropes",[]];
         if(count _existingTowRopes == 0) then {
             _hitchPoint = [_vehicle] call SA_Get_Hitch_Points select 1;
             _rope = ropeCreate [_vehicle, _hitchPoint, 10];
             _vehicle setVariable ["SA_Tow_Ropes",[_rope],true];
             _this call SA_Pickup_Tow_Ropes;
         };
     } else {
         [_this,"SA_Take_Tow_Ropes",_vehicle,true] call SA_RemoteExec;
     };
 };
 
 SA_Pickup_Tow_Ropes = {
     params ["_vehicle","_player"];
     if(local _vehicle) then {
         private ["_attachedObj","_helper"];
         {
             _attachedObj = _x;
             {
                 _attachedObj ropeDetach _x;
             } forEach (_vehicle getVariable ["SA_Tow_Ropes",[]]);
             deleteVehicle _attachedObj;
         } forEach ropeAttachedObjects _vehicle;
         _helper = "Land_Can_V2_F" createVehicle position _player;
         {
             [_helper, [0, 0, 0], [0,0,-1]] ropeAttachTo _x;
             _helper attachTo [_player, [-0.1, 0.1, 0.15], "Pelvis"];
         } forEach (_vehicle getVariable ["SA_Tow_Ropes",[]]);
         hideObject _helper;
         [[_helper],"SA_Hide_Object_Global"] call SA_RemoteExecServer;
         _player setVariable ["SA_Tow_Ropes_Vehicle", _vehicle,true];
         _player setVariable ["SA_Tow_Ropes_Pick_Up_Helper", _helper,true];
     } else {
         [_this,"SA_Pickup_Tow_Ropes",_vehicle,true] call SA_RemoteExec;
     };
 };
 
 SA_Drop_Tow_Ropes = {
     params ["_vehicle","_player"];
     if(local _vehicle) then {
         private ["_helper"];
         _helper = (_player getVariable ["SA_Tow_Ropes_Pick_Up_Helper", objNull]);
         if(!isNull _helper) then {
             {
                 _helper ropeDetach _x;
             } forEach (_vehicle getVariable ["SA_Tow_Ropes",[]]);
             detach _helper;
             deleteVehicle _helper;
         };
         _player setVariable ["SA_Tow_Ropes_Vehicle", nil,true];
         _player setVariable ["SA_Tow_Ropes_Pick_Up_Helper", nil,true];
     } else {
         [_this,"SA_Drop_Tow_Ropes",_vehicle,true] call SA_RemoteExec;
     };
 };
 diag_log "Towing script 50% done...";
 SA_Put_Away_Tow_Ropes = {
     params ["_vehicle","_player"];
     if(local _vehicle) then {
         private ["_existingTowRopes","_hitchPoint","_rope"];
         _existingTowRopes = _vehicle getVariable ["SA_Tow_Ropes",[]];
         if(count _existingTowRopes > 0) then {
             _this call SA_Pickup_Tow_Ropes;
             _this call SA_Drop_Tow_Ropes;
             {
                 ropeDestroy _x;
             } forEach _existingTowRopes;
             _vehicle setVariable ["SA_Tow_Ropes",nil,true];
         };
     } else {
         [_this,"SA_Put_Away_Tow_Ropes",_vehicle,true] call SA_RemoteExec;
     };
 };
 
 SA_Attach_Tow_Ropes_Action = {
     private ["_vehicle","_cargo","_canBeTowed"];
     _cargo = cursorTarget;
     _vehicle = player getVariable ["SA_Tow_Ropes_Vehicle", objNull];
     if([_vehicle,_cargo] call SA_Can_Attach_Tow_Ropes) then {
 
         _canBeTowed = true;
 
         if!(missionNamespace getVariable ["SA_TOW_LOCKED_VEHICLES_ENABLED",false]) then {
             if( locked _cargo > 1 ) then {
                 ["Cannot attach tow ropes to locked vehicle",false] call SA_Hint;
                 _canBeTowed = false;
             };
         };
 
         if!(missionNamespace getVariable ["SA_TOW_IN_EXILE_SAFEZONE_ENABLED",false]) then {
             if(!isNil "ExilePlayerInSafezone") then {
                 if( ExilePlayerInSafezone ) then {
                     ["Cannot attach tow ropes in safe zone",false] call SA_Hint;
                     _canBeTowed = false;
                 };
             };
         };
 
         if(_canBeTowed) then {
             [_cargo,player] call SA_Attach_Tow_Ropes;
         };
 
     };
 };
 
 SA_Attach_Tow_Ropes_Action_Check = {
     private ["_vehicle","_cargo"];
     _vehicle = player getVariable ["SA_Tow_Ropes_Vehicle", objNull];
     _cargo = cursorTarget;
     [_vehicle,_cargo] call SA_Can_Attach_Tow_Ropes;
 };
 
 SA_Can_Attach_Tow_Ropes = {
     params ["_vehicle","_cargo"];
     if(!isNull _vehicle && !isNull _cargo) then {
         [_vehicle,_cargo] call SA_Is_Supported_Cargo && vehicle player == player && player distance _cargo < 10 && _vehicle != _cargo;
     } else {
         false;
     };
 };
 
 SA_Take_Tow_Ropes_Action = {
     private ["_vehicle","_canTakeTowRopes"];
     _vehicle = cursorTarget;
     if([_vehicle] call SA_Can_Take_Tow_Ropes) then {
 
         _canTakeTowRopes = true;
 
         if!(missionNamespace getVariable ["SA_TOW_LOCKED_VEHICLES_ENABLED",false]) then {
             if( locked _vehicle > 1 ) then {
                 ["Cannot take tow ropes from locked vehicle",false] call SA_Hint;
                 _canTakeTowRopes = false;
             };
         };
 
         if!(missionNamespace getVariable ["SA_TOW_IN_EXILE_SAFEZONE_ENABLED",false]) then {
             if(!isNil "ExilePlayerInSafezone") then {
                 if( ExilePlayerInSafezone ) then {
                     ["Cannot take tow ropes in safe zone",false] call SA_Hint;
                     _canTakeTowRopes = false;
                 };
             };
         };
 
         if(_canTakeTowRopes) then {
             [_vehicle,player] call SA_Take_Tow_Ropes;
         };
 
     };
 };
 
 SA_Take_Tow_Ropes_Action_Check = {
     [cursorTarget] call SA_Can_Take_Tow_Ropes;
 };
 
 SA_Can_Take_Tow_Ropes = {
     params ["_vehicle"];
     if([_vehicle] call SA_Is_Supported_Vehicle) then {
         private ["_existingVehicle","_existingTowRopes"];
         _existingTowRopes = _vehicle getVariable ["SA_Tow_Ropes",[]];
         _existingVehicle = player getVariable ["SA_Tow_Ropes_Vehicle", objNull];
         vehicle player == player && player distance _vehicle < 10 && (count _existingTowRopes) == 0 && isNull _existingVehicle;
     } else {
         false;
     };
 };
 
 SA_Put_Away_Tow_Ropes_Action = {
     private ["_vehicle","_canPutAwayTowRopes"];
     _vehicle = cursorTarget;
     if([_vehicle] call SA_Can_Put_Away_Tow_Ropes) then {
 
         _canPutAwayTowRopes = true;
 
         if!(missionNamespace getVariable ["SA_TOW_LOCKED_VEHICLES_ENABLED",false]) then {
             if( locked _vehicle > 1 ) then {
                 ["Cannot put away tow ropes in locked vehicle",false] call SA_Hint;
                 _canPutAwayTowRopes = false;
             };
         };
 
         if!(missionNamespace getVariable ["SA_TOW_IN_EXILE_SAFEZONE_ENABLED",false]) then {
             if(!isNil "ExilePlayerInSafezone") then {
                 if( ExilePlayerInSafezone ) then {
                     ["Cannot put away tow ropes in safe zone",false] call SA_Hint;
                     _canPutAwayTowRopes = false;
                 };
             };
         };
 
         if(_canPutAwayTowRopes) then {
             [_vehicle,player] call SA_Put_Away_Tow_Ropes;
         };
 
     };
 };
 
 SA_Put_Away_Tow_Ropes_Action_Check = {
     [cursorTarget] call SA_Can_Put_Away_Tow_Ropes;
 };
 
 SA_Can_Put_Away_Tow_Ropes = {
     params ["_vehicle"];
     private ["_existingTowRopes"];
     if([_vehicle] call SA_Is_Supported_Vehicle) then {
         _existingTowRopes = _vehicle getVariable ["SA_Tow_Ropes",[]];
         vehicle player == player && player distance _vehicle < 10 && (count _existingTowRopes) > 0;
     } else {
         false;
     };
 };
 
 
 SA_Drop_Tow_Ropes_Action = {
     private ["_vehicle"];
     _vehicle = player getVariable ["SA_Tow_Ropes_Vehicle", objNull];
     if([] call SA_Can_Drop_Tow_Ropes) then {
         [_vehicle, player] call SA_Drop_Tow_Ropes;
     };
 };
 
 SA_Drop_Tow_Ropes_Action_Check = {
     [] call SA_Can_Drop_Tow_Ropes;
 };
 
 SA_Can_Drop_Tow_Ropes = {
     !isNull (player getVariable ["SA_Tow_Ropes_Vehicle", objNull]) && vehicle player == player;
 };
 
 
 
 SA_Pickup_Tow_Ropes_Action = {
     private ["_nearbyTowVehicles","_canPickupTowRopes","_vehicle"];
     _nearbyTowVehicles = missionNamespace getVariable ["SA_Nearby_Tow_Vehicles",[]];
     if([] call SA_Can_Pickup_Tow_Ropes) then {
 
         _vehicle = _nearbyTowVehicles select 0;
         _canPickupTowRopes = true;
 
         if!(missionNamespace getVariable ["SA_TOW_LOCKED_VEHICLES_ENABLED",false]) then {
             if( locked _vehicle > 1 ) then {
                 ["Cannot pick up tow ropes from locked vehicle",false] call SA_Hint;
                 _canPickupTowRopes = false;
             };
         };
 
         if!(missionNamespace getVariable ["SA_TOW_IN_EXILE_SAFEZONE_ENABLED",false]) then {
             if(!isNil "ExilePlayerInSafezone") then {
                 if( ExilePlayerInSafezone ) then {
                     ["Cannot pick up tow ropes in safe zone",false] call SA_Hint;
                     _canPickupTowRopes = false;
                 };
             };
         };
 
         if(_canPickupTowRopes) then {
             [_nearbyTowVehicles select 0, player] call SA_Pickup_Tow_Ropes;
         };
 
     };
 };
 
 SA_Pickup_Tow_Ropes_Action_Check = {
     [] call SA_Can_Pickup_Tow_Ropes;
 };
 
 SA_Can_Pickup_Tow_Ropes = {
     isNull (player getVariable ["SA_Tow_Ropes_Vehicle", objNull]) && count (missionNamespace getVariable ["SA_Nearby_Tow_Vehicles",[]]) > 0 && vehicle player == player;
 };
 
 SA_TOW_SUPPORTED_VEHICLES = [
     "Tank", "Car", "Ship"
 ];
 
 SA_Is_Supported_Vehicle = {
     params ["_vehicle","_isSupported"];
     _isSupported = false;
     if(not isNull _vehicle) then {
         {
             if(_vehicle isKindOf _x) then {
                 _isSupported = true;
             };
         } forEach (missionNamespace getVariable ["SA_TOW_SUPPORTED_VEHICLES_OVERRIDE",SA_TOW_SUPPORTED_VEHICLES]);
     };
     _isSupported;
 };
 
 SA_TOW_RULES = [
     ["Tank","CAN_TOW","Tank"],
     ["Tank","CAN_TOW","Car"],
     ["Tank","CAN_TOW","Ship"],
     ["Tank","CAN_TOW","Air"],
     ["Car","CAN_TOW","Tank"],
     ["Car","CAN_TOW","Car"],
     ["Car","CAN_TOW","Ship"],
     ["Car","CAN_TOW","Air"],
     ["Ship","CAN_TOW","Ship"]
 ];
 
 SA_Is_Supported_Cargo = {
     params ["_vehicle","_cargo"];
     private ["_canTow"];
     _canTow = false;
     if(not isNull _vehicle && not isNull _cargo) then {
         {
             if(_vehicle isKindOf (_x select 0)) then {
                 if(_cargo isKindOf (_x select 2)) then {
                     if( (toUpper (_x select 1)) == "CAN_TOW" ) then {
                         _canTow = true;
                     } else {
                         _canTow = false;
                     };
                 };
             };
         } forEach (missionNamespace getVariable ["SA_TOW_RULES_OVERRIDE",SA_TOW_RULES]);
     };
     _canTow;
 };
 
 SA_Hint = {
     params ["_msg",["_isSuccess",true]];
     if(!isNil "ExileClient_gui_notification_event_addNotification") then {
         if(_isSuccess) then {
             ["Success", [_msg]] call ExileClient_gui_notification_event_addNotification;
         } else {
             ["Whoops", [_msg]] call ExileClient_gui_notification_event_addNotification;
         };
     } else {
         hint _msg;
     };
 };
 
 SA_Hide_Object_Global = {
     params ["_obj"];
     if( _obj isKindOf "Land_Can_V2_F" ) then {
         hideObjectGlobal _obj;
     };
 };
 
 SA_Set_Owner = {
     params ["_obj","_client"];
     _obj setOwner _client;
 };
 
 SA_Add_Player_Tow_Actions = {
 
     player addAction ["Deploy Tow Ropes", {
         [] call SA_Take_Tow_Ropes_Action;
     }, nil, 0, false, true, "", "call SA_Take_Tow_Ropes_Action_Check"];
 
     player addAction ["Put Away Tow Ropes", {
         [] call SA_Put_Away_Tow_Ropes_Action;
     }, nil, 0, false, true, "", "call SA_Put_Away_Tow_Ropes_Action_Check"];
 
     player addAction ["Attach To Tow Ropes", {
         [] call SA_Attach_Tow_Ropes_Action;
     }, nil, 0, false, true, "", "call SA_Attach_Tow_Ropes_Action_Check"];
 
     player addAction ["Drop Tow Ropes", {
         [] call SA_Drop_Tow_Ropes_Action;
     }, nil, 0, false, true, "", "call SA_Drop_Tow_Ropes_Action_Check"];
 
     player addAction ["Pickup Tow Ropes", {
         [] call SA_Pickup_Tow_Ropes_Action;
     }, nil, 0, false, true, "", "call SA_Pickup_Tow_Ropes_Action_Check"];
 
     player addEventHandler ["Respawn", {
         player setVariable ["SA_Tow_Actions_Loaded",false];
     }];
 
 };
 
 SA_Find_Nearby_Tow_Vehicles = {
     private ["_nearVehicles","_nearVehiclesWithTowRopes","_vehicle","_ends","_end1","_end2"];
     _nearVehicles = [];
     {
         _nearVehicles append  (position player nearObjects [_x, 30]);
     } forEach (missionNamespace getVariable ["SA_TOW_SUPPORTED_VEHICLES_OVERRIDE",SA_TOW_SUPPORTED_VEHICLES]);
     _nearVehiclesWithTowRopes = [];
     {
         _vehicle = _x;
         {
             _ends = ropeEndPosition _x;
             if(count _ends == 2) then {
                 _end1 = _ends select 0;
                 _end2 = _ends select 1;
                 if(((position player) distance _end1) < 5 || ((position player) distance _end2) < 5 ) then {
                     _nearVehiclesWithTowRopes pushBack _vehicle;
                 }
             };
         } forEach (_vehicle getVariable ["SA_Tow_Ropes",[]]);
     } forEach _nearVehicles;
     _nearVehiclesWithTowRopes;
 };
 
 if(!isDedicated) then {
     [] spawn {
         while {true} do {
             if(!isNull player && isPlayer player) then {
                 if!( player getVariable ["SA_Tow_Actions_Loaded",false] ) then {
                     [] call SA_Add_Player_Tow_Actions;
                     player setVariable ["SA_Tow_Actions_Loaded",true];
                 };
             };
             missionNamespace setVariable ["SA_Nearby_Tow_Vehicles", (call SA_Find_Nearby_Tow_Vehicles)];
             sleep 2;
         };
     };
 };
 
 SA_RemoteExec = {
     params ["_params","_functionName","_target",["_isCall",false]];
     if(!isNil "ExileClient_system_network_send") then {
         ["AdvancedTowingRemoteExecClient",[_params,_functionName,_target,_isCall]] call ExileClient_system_network_send;
     } else {
         if(_isCall) then {
             _params remoteExecCall [_functionName, _target];
         } else {
             _params remoteExec [_functionName, _target];
         };
     };
 };
 
 SA_RemoteExecServer = {
     params ["_params","_functionName",["_isCall",false]];
     if(!isNil "ExileClient_system_network_send") then {
         ["AdvancedTowingRemoteExecServer",[_params,_functionName,_isCall]] call ExileClient_system_network_send;
     } else {
         if(_isCall) then {
             _params remoteExecCall [_functionName, 2];
         } else {
             _params remoteExec [_functionName, 2];
         };
     };
 };
 
 if(isServer) then {
 
     // Adds support for exile network calls (Only used when running exile) //
 
     SA_SUPPORTED_REMOTEEXECSERVER_FUNCTIONS = ["SA_Set_Owner","SA_Hide_Object_Global"];
 
     ExileServer_AdvancedTowing_network_AdvancedTowingRemoteExecServer = {
         params ["_sessionId", "_messageParameters",["_isCall",false]];
         _messageParameters params ["_params","_functionName"];
         if(_functionName in SA_SUPPORTED_REMOTEEXECSERVER_FUNCTIONS) then {
             if(_isCall) then {
                 _params call (missionNamespace getVariable [_functionName,{}]);
             } else {
                 _params spawn (missionNamespace getVariable [_functionName,{}]);
             };
         };
     };
 
     SA_SUPPORTED_REMOTEEXECCLIENT_FUNCTIONS = ["SA_Simulate_Towing","SA_Attach_Tow_Ropes","SA_Take_Tow_Ropes","SA_Put_Away_Tow_Ropes","SA_Pickup_Tow_Ropes","SA_Drop_Tow_Ropes","SA_Hint"];
 
     ExileServer_AdvancedTowing_network_AdvancedTowingRemoteExecClient = {
         params ["_sessionId", "_messageParameters"];
         _messageParameters params ["_params","_functionName","_target",["_isCall",false]];
         if(_functionName in SA_SUPPORTED_REMOTEEXECCLIENT_FUNCTIONS) then {
             if(_isCall) then {
                 _params remoteExecCall [_functionName, _target];
             } else {
                 _params remoteExec [_functionName, _target];
             };
         };
     };
 
     // Install Advanced Towing on all clients (plus JIP) //
 
     publicVariable "SA_Advanced_Towing_Install";
     remoteExecCall ["SA_Advanced_Towing_Install", -2,true];
 
 };
 
 diag_log "Advanced Towing Loaded";
 
 };
 
 if(isServer) then {
     [] call SA_Advanced_Towing_Install;
 };