Security scan — TugMe

Read-only view of the uploaded .cs file. Ai has detected at risk method calls. A security warning is not an automatic malware verdict — review the code yourself before trusting it.
⚠ 4 flagged lines in TugMe.cs (highlighted below).
Line 944: Directory.CreateDirectory
Line 945: File.WriteAllText
Line 968: Directory.CreateDirectory
Line 2249: Directory.CreateDirectory
TugMe.cs · scanned 4 hours ago Download
/*▄▄▄    ███▄ ▄███▓  ▄████  ▄▄▄██▀▀▀▓█████▄▄▄█████▓
▓█████▄ ▓██▒▀█▀ ██▒ ██▒ ▀█▒   ▒██   ▓█   ▀▓  ██▒ ▓▒
▒██▒ ▄██▓██    ▓██░▒██░▄▄▄░   ░██   ▒███  ▒ ▓██░ ▒░
▒██░█▀  ▒██    ▒██ ░▓█  ██▓▓██▄██▓  ▒▓█  ▄░ ▓██▓ ░ 
░▓█  ▀█▓▒██▒   ░██▒░▒▓███▀▒ ▓███▒   ░▒████▒ ▒██▒ ░ 
░▒▓███▀▒░ ▒░   ░  ░ ░▒   ▒  ▒▓▒▒░   ░░ ▒░ ░ ▒ ░░   
▒░▒   ░ ░  ░      ░  ░   ░  ▒ ░▒░    ░ ░  ░   ░    
 ░    ░ ░      ░   ░ ░   ░  ░ ░ ░      ░    ░      
 ░             ░         ░  ░   ░      ░  ░
Perms:
TugMe.Spawn
TugMe.Remove
TugMe.Event
TugMe.Buy
TugMe.AutoNav
TugMe.Place
TugMe.Find
TugMe.Button
TugMe.Announce
TugMe.Tome
TugMe.Rotate
TugMe.VendorMap
TugMe.Torpedo
TugMe.Mine
TugMe.Latch
TugMe.Tomeanywhere

Chat Commands:
/tughelp
/tugmount
/tugcopy
/tugpaste
/tugplant
/tugcannon
/tugtow
/tugcam
/tugtoken
/tugboat
/tugevent
/tugtome
/tugremove
/tugfind
/autonav
 
Console Commands:
starttugevent

Controls Standing On Tug:
Rotate = Reload+HammerHit
Use = Croutch+HammerHit
Place = Hold Fire Button

Controls Driving Tug:
Fire Torpedo = Reload Key
Drop Mine  = Croutch Key
*/

using Facepunch;
using Facepunch.Utility;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Oxide.Core;
using Oxide.Core.Plugins;
using Oxide.Game.Rust.Cui;
using ProtoBuf.Nexus;
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using UnityEngine;
using UnityEngine.SceneManagement;
namespace Oxide.Plugins
{
    [Info("TugMe", "bmgjet", "1.5.5")]
    [Description("Mod TugBoat")]
    class TugMe : RustPlugin
    {
        bool AdminDebug = false;

        //External Plugins
        [PluginReference]
        private readonly Plugin ServerRewards, Economics, Kits, NpcSpawn;
        private static TugMe _plugin; //Self Reference

        //Variables
        private Dictionary<BaseNetworkable, Vector3> TugDealers = new Dictionary<BaseNetworkable, Vector3>(); //Store Tug sellers
        private List<BaseNetworkable> EventBoats = new List<BaseNetworkable>(); //Current event tugboats
        private List<ulong> ActiveNPCs = new List<ulong>(); //List of active NPCs on server from this plugin
        private List<ulong> PlayingEffect = new List<ulong>(); //List of Tugboats playing Effect
        private HashSet<ulong> Shooting = new HashSet<ulong>(); //Set for cooldown of shooting
        private List<BaseNetworkable> TugMapMarkers = new List<BaseNetworkable>(); //List Of tugs mapmarkers
        private List<BaseNetworkable> mapmarkersList = new List<BaseNetworkable>(); //List of map markers
        private List<BaseNetworkable> VenderMapMarkers = new List<BaseNetworkable>(); //List Of vendor mapmarkers
        private List<BaseNetworkable> WaterSystem = new List<BaseNetworkable>();
        private Dictionary<ulong, ulong> UidMapping = new Dictionary<ulong, ulong>();
        private Dictionary<ulong, float> DamageTimer = new Dictionary<ulong, float>();
        private Dictionary<ulong, TowHook> Towed = new Dictionary<ulong, TowHook>();
        private HashSet<ulong> Connected = new HashSet<ulong>();
        private Dictionary<ulong, CollisionBuffer> _collisionTrackers = new Dictionary<ulong, CollisionBuffer>();
        private List<ulong> SinkingTugs = new List<ulong>();
        private Color one;
        private Color two;
        private HashSet<int> AllowedItems = new HashSet<int>();
        private string BuyCUICache = string.Empty;
        private bool CUICached = false;
        private const string Gibs = "assets/content/vehicles/scrap heli carrier/effects/debris_effect.prefab";
        private const string C4_explosion = "assets/prefabs/tools/c4/effects/c4_explosion.prefab";
        private const string Oilfire = "assets/bundled/prefabs/oilfireballsmall.prefab";
        private const string Mapmakerprefab = "assets/prefabs/tools/map/genericradiusmarker.prefab";
        private const string Tugboatprefab = "assets/content/vehicles/boats/tugboat/tugboat.prefab";
        private const string Lockprefab = "assets/prefabs/locks/keypad/lock.code.prefab";
        private const string Woodboxprefab = "assets/prefabs/deployable/large wood storage/box.wooden.large.prefab";
        private const string Doorprefab = "assets/prefabs/building/door.hinged/door.hinged.wood.prefab";
        private const string Autoturretprefab = "assets/prefabs/npc/autoturret/autoturret_deployed.prefab";
        private const string Samsiteprefab = "assets/prefabs/npc/sam_site_turret/sam_site_turret_deployed.prefab";
        private const string Guntrapprefab = "assets/prefabs/deployable/single shot trap/guntrap.deployed.prefab";
        private static readonly ItemDefinition SaltWaterDef = ItemManager.FindItemDefinition("water.salt");
        private static readonly ItemDefinition CleanWaterDef = ItemManager.FindItemDefinition("water");
        // Cache LayerMask to avoid repeated calculations
        private static readonly int PhysicsLayerMask = LayerMask.GetMask("Construction", "Default", "Deployed", "Resource", "Terrain", "Water", "World");
        private static readonly HashSet<string> BlockedPrefabPatterns = new HashSet<string> { "modding", "props", "structures", "building core", "iceberg", "tugboat", "barge_base", "cargo", "dock", "level0", "structure_bottom", "hull" };
        private class CollisionBuffer { public float LastResetTime; public int HitCount; }
        public class TugProtoData { public string OwnerID; public string TugData; public List<SignDataJson> SignData; }
        public class SignDataJson { public ulong NetId; public int Frame; public string SignData; }
        #region DataFile
        private StoredData storedData;
        private class StoredData
        {
            public List<ulong> AutoNav = new List<ulong>(); //Users who have enabled auto nav
            public List<ulong> RunningTugs = new List<ulong>(); //networkID and OwnerID
            public Dictionary<ulong, ulong> OwnedTugs = new Dictionary<ulong, ulong>(); //networkID and OwnerID
            public Dictionary<ulong, ulong> LastMiniDriver = new Dictionary<ulong, ulong>(); //networkID and OwnerID
            public List<ulong> EventTugs = new List<ulong>(); //Users who have enabled auto nav
        }
        #endregion

        #region CustomVendors
        //Setting for custom placed tugboat vendors
        public class CustomVendorPos : IEquatable<CustomVendorPos>
        {
            public Vector3 Position;
            public Vector3 Rotation;
            public Vector3 SpawnPoint;
            public CustomVendorPos init(Vector3 p, Vector3 r, Vector3 s)
            {
                Position = p;
                Rotation = r;
                SpawnPoint = s;
                return this;
            }

            public bool Equals(CustomVendorPos other)
            {
                if (other == null) { return false; }
                return Position == other.Position && Rotation == other.Rotation && SpawnPoint == other.SpawnPoint;
            }

            public override bool Equals(object obj) => Equals(obj as CustomVendorPos);
            public override int GetHashCode() => Position.GetHashCode() ^ Rotation.GetHashCode() ^ SpawnPoint.GetHashCode();
        }
        #endregion

        #region VendorsConfig
        //Setting for vendor positions
        public class VendorPos : IEquatable<VendorPos>
        {
            public string PrefabPath;
            public Vector3 OffsetPosition;
            public Vector3 OffsetRotation;
            public Vector3 OffsetSpawnPoint;
            public VendorPos init(string m, Vector3 p, Vector3 r, Vector3 s)
            {
                PrefabPath = m;
                OffsetPosition = p;
                OffsetRotation = r;
                OffsetSpawnPoint = s;
                return this;
            }

            public bool Equals(VendorPos other)
            {
                if (other == null) { return false; }
                return PrefabPath == other.PrefabPath && OffsetPosition == other.OffsetPosition && OffsetRotation == other.OffsetRotation && OffsetSpawnPoint == other.OffsetSpawnPoint;
            }

            public override bool Equals(object obj) => Equals(obj as VendorPos);
            public override int GetHashCode() => (PrefabPath?.GetHashCode() ?? 0) ^ OffsetPosition.GetHashCode() ^ OffsetRotation.GetHashCode() ^ OffsetSpawnPoint.GetHashCode();
        }
        #endregion

        #region TurretPositions
        //Setting for Turret Positions/Rotations
        public class TurretPos
        {
            public Vector3 Position;
            public Vector3 Rotation;
            public TurretPos init(Vector3 p, Vector3 r)
            {
                Position = p;
                Rotation = r;
                return this;
            }
        }
        #endregion

        #region BetterNPC Config Layout
        public class NpcBelt
        {
            [JsonProperty("ShortName")] public string ShortName { get; set; }
            [JsonProperty("Amount")] public int Amount { get; set; }
            [JsonProperty("SkinID (0 - default)")] public ulong SkinID { get; set; }
            [JsonProperty("Mods")] public List<string> Mods { get; set; }
            [JsonProperty("Ammo")] public string Ammo { get; set; }
        }

        public class NpcWear
        {
            [JsonProperty("ShortName")] public string ShortName { get; set; }
            [JsonProperty("SkinID (0 - default)")] public ulong SkinID { get; set; }
        }
        #endregion

        #region ResourcesData
        //Setting for Turret Positions/Rotations
        public class ResourcesData
        {
            public string Shortname;
            public int Amount;
            public ulong SkinID;
            public string Name;
            public ResourcesData init(string s, int a, ulong i, string n)
            {
                Shortname = s;
                Name = n;
                Amount = a;
                SkinID = i;
                return this;
            }
        }
        #endregion

        #region Language
        protected override void LoadDefaultMessages()
        {
            lang.RegisterMessages(new Dictionary<string, string>
            {
            {"Help", "Tugboat Help Info:"},
            {"Buy1", "You Can Buy Tug Boats @ "},
            {"H1", "Harbors "},
            {"FV", "Fishing Villages "},
            {"FT", "Ferry Terminals"},
            {"M1", "You can enable AutoNav with command /autonav"},
            {"M2", "It will take over driving if you dismount while full throttle."},
            {"M3", "You can spawn tug boat with command /tugboat"},
            {"M4", "You can remove tugs with command /tugremove ID"},
            {"M5", "You can place some things even while they show red"},
            {"M6", "You can mark owned tugs on the map with command /tugfind"},
            {"M8", "There is a button while driving a tug that will let you toggle autonav"},
            {"M9", "Cannot spawn because you're <color=orange>building blocked!</color>"},
            {"M0", "Cannot spawn because you're <color=orange>below sea level</color>"},
            {"E1", "<color=red>Trying to spawn outside of terrain!</color>"},
            {"E2", "<color=red>You're trying to spawn it too far away!</color>"},
            {"E3", "Spawning this close will <color=red>KILL YOU!</color>"},
            {"E4", "<color=orange>Not enough open ocean area to spawn.</color>"},
            {"E5", "<color=orange>To close to a blocked prefab.</color>"},
            {"E6", "<color=orange>Tugboat already present within {0}m</color>"},
            {"E7", "<color=red>To close to a player</color>"},
            {"E8", "Spawned Tug Boat"},
            {"E9", "<color=orange>At Spawn Limit ({0})</color>"},
            {"E0", "Spawning Event @ {0}"},
            {"A0", "Killed TugID: {0} @ {1}"},
            {"A1", "You Don't Own This Tug Boat."},
            {"A2", "Not A Tug Boat"},
            {"A3", "Enter ID of tug to remove /tugremove ID"},
            {"A4", "TugID: {0} @ {1}"},
            {"A5", "You don't have TugMe.Remove Permission."},
            {"A6", "Found {0} tug boats."},
            {"A7", "You don't have TugMe.Find Permission."},
            {"A8", "Enabling AutoNav"},
            {"A9", "Disabling AutoNav"},
            {"B0", "You Don't Have AutoNav Permission"},
            {"B1", "AutoNav Requires The Engine To Be Running"},
            {"B2", "AutoNav Enabled"},
            {"B3", "AutoNav Disabled"},
            {"B4", "You need more resources:\n{0}"},
            {"B5", "ServerRewards not installed"},
            {"B6", "You can not afford to buy this"},
            {"B7", "Economics not installed"},
            {"B8", "Currency Type Not supported on this server"},
            {"B9", "Paid {0} for tug boat"},
            {"C0", "Buy Tug Boat\n"},
            {"C1", "Spawn New Tug Boat"},
            {"C2", "To close to {0}({1})"},
            {"C3", "You don't have TugMe.Buy Permission"},
            {"C4", "At Spawn Limit ({0})"},
            {"C5", "Bought Tug Boat."},
            {"C6", "Tug Event Started Near Grid {0}"},
            {"C7", "Teleported Tug: {0} To {1}"},
            {"C8", "You can teleport your tug to you with /tugtome"},
            {"C9", "You can rotate some deployables, hit with hammer + reload key"},
            {"D1", "Enter ID of tug to teleport /tugtome ID"},
            {"D2", "You don't have TugMe.Tome Permission."},
            {"D3", "Out of torpedos!"},
            {"D4", "Torpedo fired!"},
            {"D5", "Out of inner tubes for water mine!"},
            {"D6", "Out of C4 for water mine!"},
            {"D7", "Water mine dropped!"},
            {"D8", "Minicopter latched!"},
            {"D9", "Minicopter unlatched!"},
            {"F0", "You can shoot torpedos key (R), Ammo taken from inventory"},
            {"F1", "You can drop mines with (ctrl), InnerTube + C4 taken from inventory"},
            {"F2", "Minicopter will latch onto tugboats"},
            {"F3", "Tug auth required to latch/unLatch!"},
            {"G0", "Invalid Args /tugcam name"},
            {"G1", "Not Authed On This Tug"},
            {"G2", "Set Camera ID {0}"},
            {"G3", "Set the ID of CCTV with /tugcam ID"},
            {"G4", "At placement limit for this entity ({0}/{1})"},
            {"G6","Doors On Running Tugboats Take Damage In Safe Zones!" },
            {"G7","Planter boxes fill straight from water purifier, Place plants with /tugplant" },
            {"G8","You must be holding a seed or clone." },
            {"G9","That item is not a seed or clone." },
            {"I0","You are not looking at a planter box." },
            {"I1","You must look directly at a planter box." },
            {"I2","This planter box is already full." },
            {"I3","You don't have any seeds or clones left." },
            {"I4","Planted <color=#a0ff7f>{planted}</color> seed(s)." },
            {"I5","Could not plant seeds." },
            {"I6","You are not looking at a cannon." },
            {"I7","You must look directly at a cannon." },
            {"I8","You must look directly at a anchor." },
            {"I9","Boat Hook Attached!"},
            {"J0","Boat Hook Detached!"},
            {"K0","Tug Not Found."},
            }, this);
        }

        private string message(BasePlayer player, string key, params object[] args)
        {
            if (player == null) { return string.Format(lang.GetMessage(key, this), args); }
            return string.Format(lang.GetMessage(key, this, player.UserIDString), args);
        }
        #endregion

        #region Configuration
        private Configuration config;

        private class Configuration
        {
            [JsonProperty("[Server] Block Native Tugboat Spawns")]
            public bool BlockNative = false;

            [JsonProperty("[Server] Move Blocked Tugboats To GC Instead Of Kill")]
            public bool BlockMove = false;

            [JsonProperty("[Server] Allow Native Spawned Tugs Already Authed On (For Option Block Native Tugboat Spawns)")]
            public bool NativeAllowAlreadyAuthed = false;

            [JsonProperty("[Server] Enable PVE Support")]
            public bool PVESupport = false;

            [JsonProperty("[Server] Near Tug Radius")]
            public int NearTug = 85;

            [JsonProperty("[Chat] Message Icon (SteamID)")]
            public string AnnouncementIcon = "76561199381312678";

            [JsonProperty("[Chat] Message Name")]
            public string TugName = "<color=orange>TugBoat</color>";

            [JsonProperty("[MAP] Draw On Map TugBoats")]
            public bool MapFunction = false;

            [JsonProperty("[MAP] Refresh Rate")]
            public int MapRefresh = 60;

            [JsonProperty("[PirateTug] Number Of Tug Boats")]
            public int EventTug = 1;

            [JsonProperty("[PirateTug] Min Server FPS To Allow Events")]
            public int MinFPS = 20;

            [JsonProperty("[PirateTug] Apply Code Lock To Pirate Loot Box")]
            public bool ApplyCodeLock = true;

            [JsonProperty("[PirateTug] Prevent Pirate Tugboat From Sinking")]
            public bool PirateSink = false;

            [JsonProperty("[PirateTug] When No Sink Trigger Fire After (Sec)")]
            public int PirateSinkFire = 180;

            [JsonProperty("[PirateTug] Try Prevent Beaching With Repel Force")]
            public bool NavPushBack = true;

            [JsonProperty("[PirateTug] Enable Event Oxide Hooks")]
            public bool EventHooks = false;

            [JsonProperty("[PirateTug] End Event Timeout (sec)")]
            public int EventTimeout = 1800;

            [JsonProperty("[PirateTug] Refresh Tickrate (sec)")]
            public int EventTick = 300;

            [JsonProperty("[PirateTug] Announce Event Starts")]
            public bool SpawnAnnounce = true;

            [JsonProperty("[PirateTug] Announce To Player Chat")]
            public bool SpawnAnnounceChat = false;

            [JsonProperty("[PirateTug] Announce Style")]
            public int AnnounceStyle = 1;

            [JsonProperty("[PirateTug] Mark Events On Map")]
            public bool MarkEvents = false;

            [JsonProperty("[PirateTug] Marker Alpha")]
            public float MarkerAlpha = 0.2f;

            [JsonProperty("[PirateTug] Marker Radius")]
            public float MarkerRadius = 0.5f;

            [JsonProperty("[PirateTug] Marker Color 1")]
            public string MarkerC1 = "#0098FF";

            [JsonProperty("[PirateTug] Marker Color 2")]
            public string MarkerC2 = "#FF0000";

            [JsonProperty("[PirateTug] Speed Multiplyer (Use Less Then 1 To Make NPC Tugs Slower)")]
            public float EventSpeed = 0.8f;

            [JsonProperty("[PirateTug] Over-ride Buoyant Sleep When No Near By Players (Will Increase Server Load)")]
            public bool DisableBuoyantSleep = true;

            [JsonProperty("[PirateTug] Loot Prefab (Used as loot profile)")]
            public string LootPrefab = "assets/prefabs/npc/patrol helicopter/heli_crate.prefab";

            [JsonProperty("[PirateTug] Loot Multiplyer")]
            public int LootMulti = 2;

            [JsonProperty("[PirateTug] Pirate Tugboat Health (-1 = default)")]
            public float PirateBoatHealth = -1;

            [JsonProperty("[PirateTug] Door Health")]
            public int DoorHealth = 35;

            [JsonProperty("[PirateTug] Door SkinID")]
            public ulong DoorSkinID = 0;

            [JsonProperty("[PirateTug] Start Fires After Loot Box Break (seconds)")]
            public int FireDelay = 30;

            [JsonProperty("[PirateTug] Add Extra Fire")]
            public bool ExtraFire = false;

            [JsonProperty("[PirateTug] Use Alternative NPC Type (Stops Better NPC from removing them)")]
            public bool AlternativeNPC = false;

            [JsonProperty("[PirateTug] Use Better NPC for Bots")]
            public bool UseBetterNPC = false;

            [JsonProperty("[PirateTug] NPCs Health")]
            public int NPCHealth = 350;

            [JsonProperty("[PirateTug] NPCs AimScaler")]
            public int NPCAimScaler = 1;

            [JsonProperty("[PirateTug] NPCs DamageScaler")]
            public int NPCDamageScaler = 1;

            [JsonProperty("[PirateTug] NPCs Attack Range Multiplyer")]
            public int NPCAttackRange = 3;

            [JsonProperty("[PirateTug] NPCs Name Prefix (Added to start of pirates name)")]
            public string NPCPrefix = "";

            [JsonProperty("[PirateTug] NPCs Gun")]
            public string NPCGun = "rifle.semiauto";

            [JsonProperty("[PirateTug] NPCs Gun Attachment")]
            public string NPCGunAttachment = "weapon.mod.flashlight";

            [JsonProperty("[PirateTug] NPCs Attire")]
            public string NPCAttire = "hazmatsuit.diver";

            [JsonProperty("[PirateTug] Use Kits Plugin For NPCs Attire(Change NPCs Attire to kits name)")]
            public bool UseKitsPlugin = false;

            [JsonProperty("[PirateTug] NPC Spawn Positions")]
            public Vector3[] NPCSpawnPoints = new Vector3[] { new Vector3(2, 2.8f, -8), new Vector3(-2, 2.8f, -8), new Vector3(0, 6, 2.5f), new Vector3(0, 2.1f, 9), new Vector3(0, 8.7f, 2), new Vector3(0, 2.1f, 3.5f), };

            [JsonProperty("[PirateTug] AutoTurret Gun")]
            public string AutoTurretGun = "pistol.eoka";

            [JsonProperty("[PirateTug] AutoTurret Ammo Amount")]
            public int AutoTurretAmmo = 100;

            [JsonProperty("[PirateTug] AutoTurret Health")]
            public int AutoTurretHealth = 100;

            [JsonProperty("[PirateTug] AutoTurret Spawn Positions")]
            public TurretPos[] NPCAutoTurretPoints = new TurretPos[]
            {
                new TurretPos().init(new Vector3(0,2,-1.49f), new Vector3(0,180,0)),
                new TurretPos().init(new Vector3(1.47f,7.2f,-1.1f), new Vector3(0,56,0)),
                new TurretPos().init(new Vector3(-1.47f,7.2f,-1.1f), new Vector3(0,304,0)),
                new TurretPos().init(new Vector3(0,4.5f,5.3f), new Vector3(0,0,0)),
                new TurretPos().init(new Vector3(0,3f,11f), new Vector3(0,0,0)),
                new TurretPos().init(new Vector3(0,4.5f,-4.8f), new Vector3(0,180,0)),
            };

            [JsonProperty("[PirateTug] Samsite Spawn Positions")]
            public TurretPos[] NPCSamsitePoints = new TurretPos[]
            {
                new TurretPos().init(new Vector3(-0.57f,10.7f,2.1f), new Vector3(0,0,0)),
            };

            [JsonProperty("[PirateTug] Samsite Ammo")]
            public int SamsiteAmmo = 25;

            [JsonProperty("[PirateTug] Samsite Health")]
            public int SamsiteHealth = 500;

            [JsonProperty("[PirateTug] Guntrap Spawn Positions")]
            public TurretPos[] NPCGuntrapPoints = new TurretPos[]
            {
                new TurretPos().init(new Vector3(1.6f,5.8f,3f), new Vector3(0,180,0)),
                new TurretPos().init(new Vector3(-1.6f,5.8f,3f), new Vector3(0,180,0)),
                new TurretPos().init(new Vector3(2f,2f,-4.7f), new Vector3(0,270,0)),
                new TurretPos().init(new Vector3(-2f,2f,-4.7f), new Vector3(0,90,0)),
            };

            [JsonProperty("[PirateTug] Guntrap Ammo")]
            public int GuntrapAmmo = 25;

            [JsonProperty("[PirateTug] Guntrap Health")]
            public int GuntrapHealth = 150;

            [JsonProperty("[Boat Setting] TugboatFunctions TickRate (Lower = less delay between ticks)")]
            public byte TugboatTick = 6;

            [JsonProperty("[Boat Setting] Block Tugboats From Deepsea")]
            public bool BlockTugDeepsea = false;

            [JsonProperty("[Boat Setting] Only Apply Settings To Player Bought/Spawned Tug Boats")]
            public bool LimitPlayerSpawned = false;

            [JsonProperty("[Boat Setting] Lock Minicopters To Tugboats On Driver Dismount")]
            public bool TugBoatHeliLock = false;

            [JsonProperty("[Boat Setting] Move Locked Helis To Back Of Tugboat")]
            public bool MoveBackHeli = false;

            [JsonProperty("[Boat Setting] Disable Decay On Locked Helis")]
            public bool LockNoDecay = false;

            [JsonProperty("[Boat Setting] Unlock Helis On Plugin Unload")]
            public bool UnlockUnload = false;

            [JsonProperty("[Boat Setting] Minicopter Unlock Delay")]
            public int HeliUnLock = 8;

            [JsonProperty("[Boat Setting] Minicopter Lock Requires Tug Auth")]
            public bool LatchAuth = true;

            [JsonProperty("[Boat Setting] Allow Latched Minicopters Into DeepSea")]
            public bool AllowLatchedDeep = true;

            [JsonProperty("[Boat Setting] AutoFlip Back The Right Way Up")]
            public bool AutoFlipper = false;

            [JsonProperty("[Boat Setting] Add Tow Winch")]
            public bool TowWinch = false;

            [JsonProperty("[Boat Setting] Tow At Half Tick Speed")]
            public bool TowHalfTick = false;

            [JsonProperty("[Boat Setting] Tow Connection Radius")]
            public float HookRadius = 2f;

            [JsonProperty("[Boat Setting] Tow Connection Max Height")]
            public float HookMaxHeight = 1.5f;

            [JsonProperty("[Boat Setting] Tow Connection Max Angle")]
            public float HookMaxAngle = 8f;

            [JsonProperty("[Boat Setting] Tow Connection Max Collisions")]
            public int HookMaxCollision = 40;

            [JsonProperty("[Boat Setting] Tow Connection Collision Cooldown")]
            public float HookRefresh = 1.0f;

            [JsonProperty("[Boat Setting] Tug Water Mines Mode (Pressing Duck (ctrl) to drop mines using InnerTube+C4 from players inventory)")]
            public bool Tugboatmines = false;

            [JsonProperty("[Boat Setting] Mines Health (They decay fast when in deep water)")]
            public int TugboatminesHealth = 500;

            [JsonProperty("[Boat Setting] Water Mines Cool Down (Sec per drop)")]
            public float TugboatminesCD = 2f;

            [JsonProperty("[Boat Setting] Tug Torpedo Mode (Pressing Reload (R) to fire torpedo from players inventory)")]
            public bool Tugboattorpedo = false;

            [JsonProperty("[Boat Setting] Torpedo Cool Down (Sec per shoot)")]
            public float TugboattorpedoCD = 3f;

            [JsonProperty("[Boat Setting] Disable Tugboat Driver Check")]
            public bool DisableDriverCheck = true;

            [JsonProperty("[Boat Setting] No Fuel Requirement")]
            public bool DisableFuelRequirement = false;

            [JsonProperty("[Boat Setting] Spawn With Fuel (-1 = default)")]
            public int FuelAmount = -1;

            [JsonProperty("[Boat Setting] Enable Global Broadcast")]
            public bool SpawnGlobal = true;

            [JsonProperty("[Boat Setting] Fuel Per Sec (-1 = default)")]
            public float FuelPerSec = -1;

            [JsonProperty("[Boat Setting] Engine Thrust (-1 = default)")]
            public float engineThrust = -1;

            [JsonProperty("[Boat Setting] Tugboat Health (-1 = default)")]
            public float BoatHealth = -1;

            [JsonProperty("[Boat Setting] Damage Doors On Tugboats Idling In Safe Zones (Damage Per 5min)(0 = disabled)")]
            public int SafeZoneDamage = 0;

            [JsonProperty("[AutoNav] Add AutoNav Button")]
            public bool AutoNavButton = false;

            [JsonProperty("[AutoNav] Node Distance To Switch Target")]
            public int NodeDistance = 80;

            [JsonProperty("[AutoNav] ButtonCUI")]
            public string ButtonCUIJson = @"[{""name"":""AutoNavButton"",""parent"":""Overlay"",""destroyUi"":""AutoNavButton"",""components"":[{""type"":""UnityEngine.UI.RawImage"",""color"":""1 1 1 1""},{""type"":""RectTransform"",""anchormin"":""0.92 0"",""anchormax"":""0.986 0.02"",""offsetmin"":""0 0"",""offsetmax"":""0 0""}]},{""name"":""Button"",""parent"":""AutoNavButton"",""components"":[{""type"":""UnityEngine.UI.Button"",""command"":""CMDAutoNav"",""color"":""0.26 0.39 0.53 1""},{""type"":""RectTransform"",""anchormin"":""0.0 0.0"",""anchormax"":""1 1""}]},{""parent"":""Button"",""components"":[{""type"":""UnityEngine.UI.Text"",""text"":""AutoNav"",""fontSize"":12,""align"":""MiddleCenter"",""color"":""0.905 0.882 0.807 1""},{""type"":""RectTransform""}]}]";

            [JsonProperty("[AutoNav] Enable AutoNav On Dismount")]
            public bool AllowAutoNav = false;

            [JsonProperty("[AutoNav] AutoNav Take Over Delay")]
            public int AutoNavDelay = 8;

            [JsonProperty("[AutoNav] AutoNav TickRate")]
            public int AutoNavTick = 2;

            [JsonProperty("[AutoNav] Remove Water Junkpiles On Collision (AutoNav Only)")]
            public bool JunkPileKill = true;

            [JsonProperty("[AutoNav] Water Junkpiles Scan Distance")]
            public float JunkPileScan = 12;

            [JsonProperty("[Spawners] Buy Window CUI")]
            public string BuyCUIJson = @"[{""name"":""BuyTugPannel"",""parent"":""Overlay"",""destroyUi"":""BuyTugPannel"",""components"":[{""type"":""UnityEngine.UI.Image"",""color"":""0.179 0.179 0.179 0.9""},{""type"":""RectTransform"",""anchormin"":""0 0"",""anchormax"":""1 1"",""offsetmin"":""380 220"",""offsetmax"":""-380 -220""},{""type"":""NeedsCursor""}]},{""name"":""BuyTextMsg"",""parent"":""BuyTugPannel"",""components"":[{""type"":""UnityEngine.UI.Text"",""text"":""{BUYTEXT}"",""fontSize"":40,""align"":""MiddleCenter"",""color"":""1 1 1 1""},{""type"":""UnityEngine.UI.Outline"",""color"":""0 0 0 1"",""distance"":""1 1""},{""type"":""RectTransform"",""anchormin"":""0 0"",""anchormax"":""1 1"",""offsetmin"":""0 -120"",""offsetmax"":""0 180""}]},{""name"":""YesButton"",""parent"":""BuyTugPannel"",""components"":[{""type"":""UnityEngine.UI.Button"",""command"":""BuyTugBoat"",""color"":""1 1 1 1""},{""type"":""RectTransform"",""anchormin"":""0.5 0.5"",""anchormax"":""0.5 0.5"",""offsetmin"":""-243 -127"",""offsetmax"":""-1 -100""}]},{""parent"":""YesButton"",""components"":[{""type"":""UnityEngine.UI.Text"",""text"":""Yes"",""fontSize"":15,""align"":""MiddleCenter"",""color"":""0 0 0 1""},{""type"":""RectTransform""}]},{""name"":""NoButton"",""parent"":""BuyTugPannel"",""components"":[{""type"":""UnityEngine.UI.Button"",""command"":""CloseTug"",""color"":""1 1 1 1""},{""type"":""RectTransform"",""anchormin"":""0.5 0.5"",""anchormax"":""0.5 0.5"",""offsetmin"":""1 -127"",""offsetmax"":""243 -100""}]},{""parent"":""NoButton"",""components"":[{""type"":""UnityEngine.UI.Text"",""text"":""No"",""fontSize"":15,""align"":""MiddleCenter"",""color"":""0 0 0 1""},{""type"":""RectTransform""}]}]";

            [JsonProperty("[Spawners] Max Alive Tugs Per Player")]
            public int MaxPerPlayer = 5;

            [JsonProperty("[Spawners] Adds NPC Spawners At Harbors")]
            public bool EnableTugSpawners = true;

            [JsonProperty("[Spawners] Adds NPCs Spawners At Fishing Villages")]
            public bool EnableTugSpawners2 = true;

            [JsonProperty("[Spawners] Adds NPC Spawner At Ferry Terminal")]
            public bool EnableTugSpawners3 = true;

            [JsonProperty("[Spawners] Mark NPC Spawner On Map")]
            public bool MarkVendorsOnMap = true;

            [JsonProperty("[Spawners] Map Marker Label")]
            public string VendorsOnMap = "TUGBOAT VENDOR";

            [JsonProperty("[Spawners] NPC Spawners Attire")]
            public string NPCVendorAttire = "hazmatsuit.diver";

            [JsonProperty("[Spawners] Use Kits Plugin For NPCs Spawners Attire(Change NPC Spawners Attire to kits name)")]
            public bool UseKitsPluginVendor = false;

            [JsonProperty("[Spawners] Spawn Block Radius")]
            public float SpawnBlockRadius = 20;

            [JsonProperty("[Spawners] Spawn Cost Type (serverrewards,economics,resources,free)")]
            public string Costtype = "free";

            [JsonProperty("[Spawners] Spawn Cost For (serverrewards,economics)")]
            public float Spawncost = 2000;

            [JsonProperty("[Spawners] Currency Symbol For (serverrewards,economics)")]
            public string CurrencySymbol = "$";

            [JsonProperty("[Spawners] Spawn Cost When Using Resources V2")]
            public ResourcesData[] SpawnCostResources = new ResourcesData[] { new ResourcesData().init("scrap", 1300, 0, ""), new ResourcesData().init("metal.refined", 1300, 0, ""), };

            [JsonProperty("[Spawners] Vendor Positions (Offset from Center Of Monument)")]
            public VendorPos[] VendorPositions = new VendorPos[]
            {
                new VendorPos().init("assets/bundled/prefabs/autospawn/monument/harbor/ferry_terminal_1.prefab", new Vector3(3.896f, 0.217f, 43.764f), new Vector3(0, 80, 0), new Vector3(3, 0, 56)),
                new VendorPos().init("assets/bundled/prefabs/autospawn/monument/harbor/harbor_1.prefab", new Vector3(-65.4f, 4.3f, 24.8f), new Vector3(0, 180, 0), new Vector3(-74.5f, 0f, 35f)),
                new VendorPos().init("assets/bundled/prefabs/autospawn/monument/harbor/harbor_2.prefab", new Vector3(40.25f, 4.0f, 109f), new Vector3(0, 0, 0), new Vector3(50, 0, 120)),
                new VendorPos().init("assets/bundled/prefabs/autospawn/monument/fishing_village/fishing_village_a.prefab", new Vector3(0.48f, 2, 21.33f), new Vector3(0, 270, 0), new Vector3(-7, 0, 32.5f)),
                new VendorPos().init("assets/bundled/prefabs/autospawn/monument/fishing_village/fishing_village_b.prefab", new Vector3(-8.73f, 0.68f, 30.68f), new Vector3(0, 270, 0), new Vector3(-19, 0, 41.5f)),
                new VendorPos().init("assets/bundled/prefabs/autospawn/monument/fishing_village/fishing_village_c.prefab", new Vector3(-1.47f, 2.1f, 22.62f), new Vector3(0, 270, 0), new Vector3(-14, 0, 31.5f)),
            };

            [JsonProperty("[Spawners] Custom Vendor Positions (Position On The Map)")]
            public CustomVendorPos[] CustomPositions = new CustomVendorPos[] { new CustomVendorPos().init(new Vector3(0, 0, 0), new Vector3(0, 0, 0), new Vector3(0, 0, 0)), };

            [JsonProperty("[Building] Allow Override Of Placement Check (White Listed Items Only)")]
            public bool OverrideAllow = false;

            [JsonProperty("[Building] Placement Distance Checking")]
            public float DistanceCheck = 1.35f;

            [JsonProperty("[Building] Power Electrical When Engine Running")]
            public bool PowerFromEngine = false;

            [JsonProperty("[Building] Run Sprinkler/Electrice Water Purifier system")]
            public bool WaterSystem = true;

            [JsonProperty("[Building] Water System Tick Rate")]
            public int WaterSystemTick = 3;

            [JsonProperty("[Building] Boat Auth = Trap Auth (needed for gun and flame traps)")]
            public bool AuthFromBoat = true;

            [JsonProperty("[Building] Boat Auth = Samsite Auth")]
            public bool SamAuthFromBoat = true;

            [JsonProperty("[Building] Max Samsite Per Tug (-1 = no limit)")]
            public int MaxSam = -1;

            [JsonProperty("[Building] Max AutoTurret Per Tug (-1 = no limit)")]
            public int MaxAT = -1;

            [JsonProperty("[Building] White List Shortnames")]
            public string[] ItemOverride = new string[]
            {
                "autoturret",
                "samsite" ,
                "water.catcher.small" ,
                "barricade.concrete" ,
                "composter" ,
                "sign.pole.banner.large",
                "small.oil.refinery" ,
                "trap.landmine",
                "trap.bear" ,
                "searchlight" ,
                "guntrap",
                "flameturret",
                "planter.small",
                "woodcross",
                "rustige_egg_a",
                "rustige_egg_b",
                "rustige_egg_c",
                "rustige_egg_d",
                "rustige_egg_e",
                "rustige_egg_f",
                "electric.flasherlight",
                "electric.furnace",
                "electric.sprinkler",
                "smallcandles",
                "strobelight",
                "discofloor",
                "fogmachine",
                "cursedcauldron",
                "coffin.storage",
                "largecandles",
                "snowmachine",
                "spookyspeaker",
                "boombox",
                "electric.heater",
                "electric.sirenlight",
                "electric.simplelight",
                "target.reactive",
                "industrial.wall.light.green",
                "industrial.wall.light.red",
                "industrial.wall.light",
                "planter.large",
                "scarecrow",
                "mailbox",
                "wall.graveyard.fence",
                "fireplace.stone",
                "powered.water.purifier",
                "ceilinglight",
                "cctv.camera",
                "ptz.cctv.camera",
                "hitchtroughcombo",
                "cannon",
            };

            [JsonProperty("[Building] Rotation Amount (Per Hammer Hit)")]
            public int ItemAngle = 8;

            [JsonProperty("[Building] Allow Rotation On")]
            public string[] ItemRotation = new string[]
            {
                "autoturret_deployed",
                "barricade.concrete" ,
                "composter" ,
                "sign.pole.banner.large",
                "refinery_small_deployed" ,
                "searchlight.deployed" ,
                "guntrap.deployed",
                "flameturret.deployed",
                "snowmachine",
                "largecandleset",
                "fogmachine",
                "coffinstorage",
                "gravestone.wood.deployed",
                "boombox.deployed",
                "electricfurnace.deployed",
                "rustigeegg_b.deployed",
                "smallcandleset",
                "electrical.heater",
                "spookyspeaker",
                "strobelight",
                "electric.flasherlight.deployed",
                "reactivetarget_deployed",
                "planter.small.deployed",
                "electric.sirenlight.deployed",
                "cursedcauldron.deployed",
                "discofloor.deployed",
                "planter.large.deployed",
                "industrial.wall.lamp.deployed",
                "industrial.wall.lamp.red.deployed",
                "industrial.wall.lamp.green.deployed",
                "simplelight",
                "graveyardfence",
                "mailbox.deployed",
                "scarecrow.deployed",
                "fireplace.deployed",
                "poweredwaterpurifier.deployed",
                "hitchtrough.deployed",
                "cctv_deployed",
                "cannon.deployed"
            };

            public string ToJson() => JsonConvert.SerializeObject(this);

            public Dictionary<string, object> ToDictionary() => JsonConvert.DeserializeObject<Dictionary<string, object>>(ToJson());
        }

        protected override void LoadDefaultConfig() { config = new Configuration(); }

        protected override void LoadConfig()
        {
            base.LoadConfig();
            try
            {
                config = Config.ReadObject<Configuration>();
                if (config == null) { throw new JsonException(); }

                if (!config.ToDictionary().Keys.SequenceEqual(Config.ToDictionary(x => x.Key, x => x.Value).Keys))
                {
                    PrintWarning("Configuration appears to be outdated; updating and saving");
                    SaveConfig();
                }
            }
            catch
            {
                PrintWarning($"Configuration file {Name}.json is invalid; using defaults");
                LoadDefaultConfig();
            }
        }

        protected override void SaveConfig()
        {
            PrintWarning($"Configuration changes saved to {Name}.json");
            Config.WriteObject(config, true);
        }
        #endregion Configuration

        #region Commands
        [ChatCommand("tughelp")]
        private void tughelp(BasePlayer player) //Help chat command
        {
            MessageIcon(player, "Help");
            if (permission.UserHasPermission(player.UserIDString, "TugMe.Buy"))
            {
                string buymsg = message(player, "Buy1");
                if (config.EnableTugSpawners) { buymsg += message(player, "H1"); }
                if (config.EnableTugSpawners2) { buymsg += message(player, "FV"); }
                if (config.EnableTugSpawners3) { buymsg += message(player, "FT"); }
                rust.SendChatMessage(player, config.TugName, buymsg, config.AnnouncementIcon);
            }
            if (config.AllowAutoNav && permission.UserHasPermission(player.UserIDString, "TugMe.AutoNav"))
            {
                MessageIcon(player, "M1");
                MessageIcon(player, "M2");
            }
            if (permission.UserHasPermission(player.UserIDString, "TugMe.Spawn")) { MessageIcon(player, "M3"); }
            if (permission.UserHasPermission(player.UserIDString, "TugMe.Remove")) { MessageIcon(player, "M4"); }
            if (permission.UserHasPermission(player.UserIDString, "TugMe.Place")) { MessageIcon(player, "M5"); }
            if (permission.UserHasPermission(player.UserIDString, "TugMe.Find")) { MessageIcon(player, "M6"); }
            if (permission.UserHasPermission(player.UserIDString, "TugMe.Button")) { MessageIcon(player, "M8"); }
            if (permission.UserHasPermission(player.UserIDString, "TugMe.Tome")) { MessageIcon(player, "C8"); }
            if (permission.UserHasPermission(player.UserIDString, "TugMe.Rotate")) { MessageIcon(player, "C9"); }
            if (permission.UserHasPermission(player.UserIDString, "TugMe.Torpedo")) { MessageIcon(player, "F0"); }
            if (permission.UserHasPermission(player.UserIDString, "TugMe.Mine")) { MessageIcon(player, "F1"); }
            if (permission.UserHasPermission(player.UserIDString, "TugMe.Latch")) { MessageIcon(player, "F2"); }
            MessageIcon(player, "G3");
            MessageIcon(player, "G7");
        }

        [ChatCommand("tugmount")]
        private void TugMount(BasePlayer player, string command, string[] args)
        {
            Tugboat tugboat = player.GetParentEntity() as Tugboat;
            if (tugboat != null)
            {
                if (tugboat.OwnerID == player.userID)
                {
                    var mountPoint = tugboat.GetMountPoint(0);
                    if (mountPoint?.mountable != null) { mountPoint.mountable.MountPlayer(player); }
                }
            }
        }

        [ChatCommand("tugcopy")]
        private void TugCopy(BasePlayer player, string command, string[] args)
        {
            if (!player.IsAdmin)
            {
                return;
            }
            if (args.Length != 1)
            {
                player.ChatMessage("Enter A Name To Save As /tugcopy name");
                return;
            }
            string safeName = Sanitize(args[0]);
            if (string.IsNullOrEmpty(safeName))
            {
                player.ChatMessage("Invalid name.");
                return;
            }
            Tugboat tugboat = player.GetParentEntity() as Tugboat;
            if (tugboat != null)
            {
                if (!Directory.Exists("tugmetugs")) { Directory.CreateDirectory("tugmetugs"); }
                File.WriteAllText(Path.Combine("tugmetugs", safeName + ".json"), CopyTugBoat(tugboat));
                player.ChatMessage("Tug Copied");
            }
        }

        [ChatCommand("tugpaste")]
        private void TugPaste(BasePlayer player, string command, string[] args)
        {
            if (!player.IsAdmin)
            {
                return;
            }
            if (args.Length != 1)
            {
                player.ChatMessage("Enter A Name Paste /tugpaste name");
                return;
            }
            string safeName = Sanitize(args[0]);
            if (string.IsNullOrEmpty(safeName))
            {
                player.ChatMessage("Invalid name.");
                return;
            }
            if (!Directory.Exists("tugmetugs")) { Directory.CreateDirectory("tugmetugs"); }
            string path = Path.Combine("tugmetugs", safeName + ".json");
            if (!File.Exists(path))
            {
                player.ChatMessage("File Not Found");
                return;
            }
            ProcessTugMeTugsJson(player.eyes.position + (player.eyes.BodyForward() * 16), player.eyes.rotation, File.ReadAllText(path));
            player.ChatMessage("Pasted Tugboat");
        }

        [ChatCommand("tugplant")]
        private void TugPlant(BasePlayer player, string command, string[] args)
        {
            if (player == null)
                return;

            // Must be on a tugboat
            Tugboat tug = player.GetParentEntity() as Tugboat;
            if (tug == null)
                return;

            if (!tug.IsAuthedForBuilding(player))
            {
                player.ChatMessage(message(player, "G1"));
                return;
            }

            // Must be holding valid item
            Item active = player.GetActiveItem();
            if (active == null)
            {
                player.ChatMessage(message(player, "G8"));
                return;
            }

            ItemDefinition def = active.info;
            if (def == null || (!def.shortname.Contains("seed") && !def.shortname.Contains("clone")))
            {
                player.ChatMessage(message(player, "G9"));
                return;
            }

            // Get planter box the player is looking at
            RaycastHit hit;
            if (!Physics.Raycast(player.eyes.HeadRay(), out hit, 4f))
            {
                player.ChatMessage(message(player, "I0"));
                return;
            }

            PlanterBox planter = hit.GetEntity() as PlanterBox;
            if (planter == null)
            {
                player.ChatMessage(message(player, "I1"));
                return;
            }

            // Determine max slots by prefab
            int maxSlots = 9;
            int usedSlots = planter.children != null ? planter.children.Count : 0;
            int emptySlots = Mathf.Max(0, maxSlots - usedSlots);

            if (emptySlots <= 0)
            {
                player.ChatMessage(message(player, "I2"));
                return;
            }

            // Check player has enough seeds FIRST
            if (active.amount < emptySlots)
            {
                emptySlots = active.amount; // Limit to what player has
            }

            if (emptySlots <= 0)
            {
                player.ChatMessage(message(player, "I3"));
                return;
            }

            // Plant seeds
            int planted = fillPlanter(emptySlots, planter, def);

            // Remove only the amount that was actually planted
            if (planted > 0)
            {
                active.UseItem(planted);
                player.ChatMessage(message(player, "I4", planted));
            }
            else
            {
                player.ChatMessage(message(player, "I5"));
            }
        }

        [ChatCommand("tugcannon")]
        private void TugCannon(BasePlayer player, string command, string[] args)
        {
            if (player == null)
                return;

            // Must be on a tugboat
            Tugboat tug = player.GetParentEntity() as Tugboat;
            if (tug == null)
                return;

            if (!tug.IsAuthedForBuilding(player))
            {
                player.ChatMessage(message(player, "G1"));
                return;
            }

            // Get cannon the player is looking at
            RaycastHit hit;
            if (!Physics.Raycast(player.eyes.HeadRay(), out hit, 4f))
            {
                player.ChatMessage(message(player, "I6"));
                return;
            }
            Cannon cannon = hit.GetEntity() as Cannon;
            if (cannon == null)
            {
                player.ChatMessage(message(player, "I7"));
                return;
            }
            cannon.MountPlayer(player);
        }

        [ChatCommand("tugtow")]
        private void TugTow(BasePlayer player, string command, string[] args)
        {
            if (player == null)
                return;

            Tugboat tug = null;
            if (player.isMounted)
            {
                tug = player.GetMountedVehicle() as Tugboat;
            }
            else
            {
                tug = player.GetParentEntity() as Tugboat;
            }
            if (tug == null)
                return;

            if (!tug.IsAuthedForBuilding(player))
            {
                player.ChatMessage(message(player, "G1"));
                return;
            }

            Anchor anchor = null;
            foreach (var child in tug.children)
            {
                if (child is Anchor)
                {
                    anchor = child as Anchor;
                    break;
                }
            }
            if (anchor == null)
            {
                player.ChatMessage(message(player, "I8"));
                return;
            }
            ToggleTow(anchor, tug, player);
        }

        [ChatCommand("tugcam")]
        private void TugCam(BasePlayer player, string command, string[] args)
        {
            if (args.Length != 1)
            {
                player.ChatMessage(message(player, "G0"));
                return;
            }
            string camname = Sanitize(args[0]);
            if (player != null && player?.GetParentEntity() is Tugboat)
            {
                Tugboat tug = player.GetParentEntity() as Tugboat;
                if (tug == null) { return; }
                if (!tug.IsAuthedForBuilding(player)) { player.ChatMessage(message(player, "G1")); return; }
                int index = 0;
                foreach (var child in tug.children)
                {
                    if (child is CCTV_RC)
                    {
                        CCTV_RC cam = child as CCTV_RC;
                        if (cam != null)
                        {
                            cam.UpdateIdentifier(camname + index++);
                            player.ChatMessage(message(player, "G2", cam.GetIdentifier()));
                        }
                    }
                }
            }
        }

        [ChatCommand("tugtoken")]
        private void Spawntugtoken(BasePlayer player, string command, string[] args) //Spawn command
        {
            if (player != null && player.IsAdmin)
            {
                int amount = 1;
                if (args.Length == 1) { int.TryParse(args[0], out amount); }
                Item i = ItemManager.CreateByName("paper", amount, 2513472788);
                player.GiveItem(i);
            }
        }

        [ChatCommand("tugboat")]
        private void SpawnTugBoat(BasePlayer player, string command, string[] args) //Spawn command
        {
            if (player != null && permission.UserHasPermission(player.UserIDString, "TugMe.Spawn"))
            {
                BasePlayer p = null;
                if (player.IsAdmin && args.Length == 1)
                {
                    ulong id;
                    if (ulong.TryParse(args[0], out id))
                    {
                        p = BasePlayer.FindByID(id);
                        if (p != null) { player = p; }
                    }
                }
                Vector3 position = GetPosition(player);
                if (position == Vector3.zero) return;
                if (SpawnManager(player)) //Check not over spawn limit
                {
                    Tugboat boat = GameManager.server.CreateEntity(Tugboatprefab, position, player.transform.rotation, true) as Tugboat;
                    if (boat == null)
                    {
                        MessageIcon(player, "K0");
                        if (p) { MessageIcon(p, "K0"); }
                        return;
                    }
                    MessageIcon(player, "E8");
                    if (p) { MessageIcon(p, "E8"); }
                    boat.OwnerID = player.userID;
                    boat.Spawn();
                    storedData.OwnedTugs[boat.net.ID.Value] = player.userID;
                    return;
                }
                MessageIcon(player, "E9", config.MaxPerPlayer.ToString());
                if (p) { MessageIcon(p, "E9", config.MaxPerPlayer.ToString()); }
            }
        }

        [ChatCommand("tugevent")]
        private void TugBoatEvent(BasePlayer player) //Spawn event nearest cargo node to player
        {
            if (player != null && permission.UserHasPermission(player.UserIDString, "TugMe.Event"))
            {
                player.Invoke(() =>
                {
                    if (player.IsBuildingBlocked())
                    {
                        MessageIcon(player, "M9");
                        return;
                    }
                    if (player.transform.position.y < -5) //Prevent spawning in train tunnels, caves ect
                    {
                        MessageIcon(player, "M0");
                        return;
                    }
                    Vector3 vector = TerrainMeta.Path.OceanPatrolFar[GetClosestNodeToUs(player.transform.position)];
                    Tugboat TB = NewTugBoat(vector, Quaternion.Euler(new Vector3(0, 0, 0)), 1234);
                    if (TB == null) { return; }
                    MessageIcon(player, "E0", vector.ToString());
                    if (config.DisableBuoyantSleep)
                    {
                        var TugBuoyancy = TB.GetComponent<Buoyancy>();
                        if (TugBuoyancy != null)
                        {
                            TugBuoyancy.CancelInvoke("CheckSleepState");
                            TugBuoyancy.Invoke(new Action(TugBuoyancy.Wake), 0f); //Force Awake
                        }
                    }
                    timer.Once(2, () => { if (TB != null) { SetupEvent(TB); } });
                }, 0.1f);
            }
        }

        [ChatCommand("tugtome")]
        private void TugToMe(BasePlayer player, string command, string[] args)
        {
            if (player != null && permission.UserHasPermission(player.UserIDString, "TugMe.Tome"))
            {
                if (args.Length == 1)
                {
                    ulong ID;
                    if (ulong.TryParse(args[0], out ID))
                    {
                        if (ID < 1000) { ID = ListOwnedTugs(player, (int)ID); }
                        if (storedData.OwnedTugs.ContainsKey(ID))
                        {
                            if (storedData.OwnedTugs[ID] == player.userID || player.IsAdmin)
                            {
                                TeleportTug(ID, player);
                            }
                            else { MessageIcon(player, "A1"); }
                        }
                        else { MessageIcon(player, "A2"); }
                    }
                    return;
                }
                MessageIcon(player, "D1");
                ListOwnedTugs(player);
                return;
            }
            MessageIcon(player, "D2");
        }

        [ChatCommand("tugremove")]
        private void TugRemove(BasePlayer player, string command, string[] args)
        {
            if (permission.UserHasPermission(player.UserIDString, "TugMe.Remove"))
            {
                if (args.Length == 1)
                {
                    ulong ID;
                    if (ulong.TryParse(args[0], out ID))
                    {
                        if (ID < 1000) { ID = ListOwnedTugs(player, (int)ID); }
                        if (storedData.OwnedTugs.ContainsKey(ID))
                        {
                            if (storedData.OwnedTugs[ID] == player.userID)
                            {
                                BaseNetworkable bn = BaseNetworkable.serverEntities.Find(new NetworkableId(ID));
                                if (bn == null)
                                {
                                    MessageIcon(player, "A2");
                                    storedData.OwnedTugs.Remove(ID);
                                    return;
                                }
                                Vector3 pos = bn.transform.position;
                                bn.Kill();
                                MessageIcon(player, "A0", ID, PositionToGridCoord(pos));
                            }
                            else { MessageIcon(player, "A1"); }
                        }
                        else { MessageIcon(player, "A2"); }
                    }
                    return;
                }
                MessageIcon(player, "A3");
                ListOwnedTugs(player);
                return;
            }
            MessageIcon(player, "A5");
        }

        [ChatCommand("tugfind")]
        private void TugFind(BasePlayer player) //Mark tugboats owned on map
        {
            if (permission.UserHasPermission(player.UserIDString, "TugMe.Find"))
            {
                MessageIcon(player, "A6", UpdatePlayersTugIcon(player, true).ToString());
                return;
            }
            MessageIcon(player, "A7");
        }

        [ChatCommand("autonav")]
        private void TugBoatAutoNav(BasePlayer player) //Toggle auto nav mode on/off
        {
            if (permission.UserHasPermission(player.UserIDString, "TugMe.AutoNav"))
            {
                if (!storedData.AutoNav.Contains(player.userID))
                {
                    MessageIcon(player, "A8");
                    storedData.AutoNav.Add(player.userID);
                    return;
                }
                MessageIcon(player, "A9");
                storedData.AutoNav.Remove(player.userID);
                return;
            }
            MessageIcon(player, "B0");
        }

        [ConsoleCommand("starttugevent")]
        private void ConsoleTugEvent(ConsoleSystem.Arg arg) //Create tug event at position from console/other plugin
        {
            if ((arg.IsAdmin || arg.IsRcon) && arg.Args?.Length >= 3) //Check there are 3 or more args
            {
                float x; float y; float z;
                if (float.TryParse(arg.Args[0], System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out x) && float.TryParse(arg.Args[1], System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out y) && float.TryParse(arg.Args[2], System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out z)) //Try convert to vector3
                {
                    Vector3 pos = new Vector3(x, y, z);
                    Tugboat TB = NewTugBoat(pos, Quaternion.Euler(new Vector3(0, 0, 0)), 1234);
                    if (TB == null)
                    {
                        Puts("Failed to spawn TugEvent @ " + pos);
                        return;
                    }
                    Puts("TugEvent @ " + pos);
                    if (config.DisableBuoyantSleep)
                    {
                        var TugBuoyancy = TB.GetComponent<Buoyancy>();
                        if (TugBuoyancy != null)
                        {
                            TugBuoyancy.CancelInvoke("CheckSleepState");
                            TugBuoyancy.Invoke(new Action(TugBuoyancy.Wake), 0f); //Force Awake
                        }
                    }
                    timer.Once(2, () => { if (TB != null) { SetupEvent(TB); } });
                }
            }
        }

        //CUI Close button
        [ConsoleCommand("CloseTug")] private void CloseCUI(ConsoleSystem.Arg arg) { if (arg.Player() != null) { CuiHelper.DestroyUi(arg.Player(), "BuyTugPannel"); } }
        //CUI Buy button
        [ConsoleCommand("BuyTugBoat")]
        private void BuyCUI(ConsoleSystem.Arg arg)
        {
            var player = arg?.Player();
            if (player == null)
                return;

            // Close UI
            CuiHelper.DestroyUi(player, "BuyTugPannel");

            // Validate nearest NPC to prevent console exploit
            BaseNetworkable closest = null;
            float closestDist = float.MaxValue;
            foreach (var npc in TugDealers.Keys)
            {
                if (npc == null)
                    continue;

                float dist = Vector3.Distance(npc.transform.position, player.transform.position);
                if (dist > 5f)
                    continue;

                if (dist < closestDist)
                {
                    closestDist = dist;
                    closest = npc;
                }
            }

            if (closest != null)
            {
                //Same checks as the conversation start since this console command can be run without the UI
                if (!permission.UserHasPermission(player.UserIDString, "TugMe.Buy")) { MessageIcon(player, "C3"); return; }
                if (!SpawnManager(player)) { MessageIcon(player, "C4", config.MaxPerPlayer.ToString()); return; }
                List<Tugboat> nearby = Pool.Get<List<Tugboat>>();
                Vis.Entities<Tugboat>(closest.transform.position, config.SpawnBlockRadius, nearby);
                bool blocked = nearby.Count > 0;
                Pool.FreeUnmanaged(ref nearby);
                if (blocked) { MessageIcon(player, "E6", config.SpawnBlockRadius.ToString()); return; }
                // Player is close enough — charge & spawn tug
                if (TryChargePlayer(player))
                {
                    var tug = _plugin.NewTugBoat(_plugin.TugDealers[closest], closest.transform.rotation, player.userID);
                    if (tug != null)
                    {
                        storedData.OwnedTugs[tug.net.ID.Value] = player.userID;
                    }
                }
            }
        }
        //CUI AutoNav button
        [ConsoleCommand("CMDAutoNav")]
        private void AutoNavCUI(ConsoleSystem.Arg arg)
        {
            if (arg.Player() != null)
            {
                BasePlayer player = arg.Player();
                BaseMountable baseMountable = player.GetParentEntity() as BaseMountable;
                if (baseMountable == null) { return; }
                Tugboat tugboat = baseMountable.GetParentEntity() as Tugboat;
                if (tugboat != null && tugboat.GetDriver() == player)
                {
                    if (!tugboat.HasFlag(Tugboat.Flags.On))
                    {
                        MessageIcon(player, "B1");
                        return;
                    }
                    AutoNavigation an = tugboat.gameObject.GetComponent<AutoNavigation>();
                    if (an == null) //Add auto nav if missing
                    {
                        an = tugboat.gameObject.AddComponent<AutoNavigation>();
                        an.captin = player;
                        MessageIcon(player, "B2");
                    }
                    else { an.RemoveMe(); }
                }
            }
        }
        #endregion

        #region TruePVEHook
        object CanEntityTakeDamage(BaseCombatEntity entity, HitInfo hitinfo)
        {
            if (config.PVESupport)
            {
                if (entity != null && entity?.net != null)
                {
                    //Allow Players To Damage Pirate Tugs And Pirate NPCs
                    if (EventBoats.Contains(entity) || ActiveNPCs.Contains(entity.net.ID.Value))
                    {
                        return true;
                    }
                    //Allow Players To Damage Things On Pirate Tugs
                    if (EventBoats.Contains(entity?.GetParentEntity()))
                    {
                        return true;
                    }
                    //Allow Player On Player Damage When One On Pirate Tugboat
                    BasePlayer player = entity.ToPlayer();
                    if (player != null && hitinfo != null && hitinfo?.Initiator?.ToPlayer() != null)
                    {
                        Tugboat tugboat = player?.GetParentEntity() as Tugboat;
                        Tugboat tugboat2 = hitinfo?.Initiator?.ToPlayer()?.GetParentEntity() as Tugboat;
                        if (tugboat != null && tugboat2 != null)
                        {
                            if (EventBoats.Contains(tugboat) || EventBoats.Contains(tugboat2))
                            {
                                return true;
                            }
                        }
                    }
                }
            }
            return null;
        }

        object CanEntityBeTargeted(BasePlayer player, BaseEntity turret)
        {
            if (config.PVESupport) { if (EventBoats.Contains(turret?.GetParentEntity()) && !player.IsNpc) { return true; } }
            return null;
        }
        object CanEntityTrapTrigger(BaseTrap trap, BasePlayer player)
        {
            if (config.PVESupport) { if (EventBoats.Contains(trap?.GetParentEntity()) && !player.IsNpc) { return true; } }
            return null;
        }
        #endregion

        #region Hooks

        private void Init()
        {
            Unsubscribe(nameof(OnEntitySpawned));
            Unsubscribe(nameof(OnSamSiteTarget));
            Unsubscribe(nameof(OnHammerHit));
            Unsubscribe(nameof(OnEntityKill));
            storedData = Interface.Oxide.DataFileSystem.ReadObject<StoredData>("TugMe");
            _plugin = this; //Set self reference
            //Permissions
            permission.RegisterPermission("TugMe.Spawn", this);
            permission.RegisterPermission("TugMe.Remove", this);
            permission.RegisterPermission("TugMe.Event", this);
            permission.RegisterPermission("TugMe.Buy", this);
            permission.RegisterPermission("TugMe.AutoNav", this);
            permission.RegisterPermission("TugMe.Place", this);
            permission.RegisterPermission("TugMe.Find", this);
            permission.RegisterPermission("TugMe.Button", this);
            permission.RegisterPermission("TugMe.Announce", this);
            permission.RegisterPermission("TugMe.Tome", this);
            permission.RegisterPermission("TugMe.Rotate", this);
            permission.RegisterPermission("TugMe.VendorMap", this);
            permission.RegisterPermission("TugMe.Torpedo", this);
            permission.RegisterPermission("TugMe.Mine", this);
            permission.RegisterPermission("TugMe.Latch", this);
            permission.RegisterPermission("TugMe.Tomeanywhere", this);
            ColorUtility.TryParseHtmlString(config.MarkerC1, out one);
            ColorUtility.TryParseHtmlString(config.MarkerC2, out two);
        }

        private void OnServerInitialized()
        {
            Subscribe(nameof(OnEntitySpawned));
            Subscribe(nameof(OnEntityKill));
            if (config.SamAuthFromBoat) { Subscribe(nameof(OnSamSiteTarget)); }
            if (config.ItemAngle != 0) { Subscribe(nameof(OnHammerHit)); }
            timer.Once(2, () =>
            { //Some reason some servers dont have ServerMgr.Instance ready when hook called so wait 2 sec)
                ServerMgr.Instance.StartCoroutine(TugMeStartUp());
            });
        }

        private void Unload()
        {
            foreach (var t in TugDealers.Keys) { if (t != null && !t.IsDestroyed) { t.Kill(); } } //Remove Tug NPCs
            foreach (var p in BasePlayer.activePlayerList)
            {
                if (p == null) { continue; }
                CuiHelper.DestroyUi(p, "AutoNavButton");
                CuiHelper.DestroyUi(p, "BuyTugPannel");
            }
            MarkerDisplayingDelete();
            foreach (var t in EventBoats) { if (t != null && !t.IsDestroyed) { t.Kill(); } }
            foreach (var n in ActiveNPCs)
            {
                ScientistNPC npc = BaseNetworkable.serverEntities.Find(new NetworkableId(n)) as ScientistNPC;
                if (npc != null && !npc.IsDestroyed) { npc.Kill(); }
            }
            foreach (var vm in VenderMapMarkers) { if (vm != null && !vm.IsDestroyed) { vm.Kill(); } }
            foreach (var vm in TugMapMarkers) { if (vm != null && !vm.IsDestroyed) { vm.Kill(); } }
            foreach (var ent in BaseNetworkable.serverEntities)
            {
                if (ent == null) { continue; }
                if (ent is Tugboat)
                {
                    TugboatFunction tug = ent.gameObject.GetComponent<TugboatFunction>();
                    if (tug != null) { tug.RemoveMe(); }
                }
                if (config.TugBoatHeliLock && ent is BaseHelicopter)
                {
                    MiniLatch ml = ent.gameObject.GetComponent<MiniLatch>();
                    if (ml != null) { ml.RemoveMe(); }
                }
                if (config.TowWinch && ent is Tugboat)
                {
                    TowHook th = ent.gameObject.GetComponent<TowHook>();
                    if (th != null) { th.attached = false; th.RemoveMe(); }
                }
            }
            for (int i = storedData.RunningTugs.Count - 1; i >= 0; i--)
            {
                BaseNetworkable b = BaseNetworkable.serverEntities.Find(new NetworkableId(storedData.RunningTugs[i]));
                if (b == null)
                {
                    storedData.RunningTugs.RemoveAt(i);
                    continue;
                }
                AutoNavigation an = b.gameObject.GetComponent<AutoNavigation>();
                if (an != null) { an.RemoveMe(); }
                var Ioents = Facepunch.Pool.Get<List<IOEntity>>();
                foreach (var ent in b.children)
                {
                    if (ent is IOEntity)
                    {
                        Ioents.Add(ent as IOEntity);
                    }
                }
                Tugboat_TogglePower(Ioents, false, storedData.RunningTugs[i]);
                Facepunch.Pool.FreeUnmanaged(ref Ioents);
            }
            storedData.EventTugs.Clear();//Should all be removed if code made it this far.
            SaveData(); //Save Datafile
            _plugin = null;
        }

        void OnEntityMounted(BaseMountable entity, BasePlayer player)
        {
            if (entity?.prefabID == 1955582400)// "tugboatdriver") //Mounted tugboat driver seat
            {
                Tugboat tugboat = entity?.GetParentEntity() as Tugboat;
                if (tugboat == null) { return; }
                AutoNavigation an = tugboat.gameObject.GetComponent<AutoNavigation>();
                if (an != null) { an.captin = player; }
                if (config.AutoNavButton && permission.UserHasPermission(player.UserIDString, "TugMe.Button")) { CuiHelper.AddUi(player, config.ButtonCUIJson); }
                return;
            }
            //Keep track of last mini driver
            if (config.TugBoatHeliLock && (entity?.prefabID == 3742994540 /* == "miniheliseat"*/ || entity?.prefabID == 70742988))// == "attackhelidriver"))
            {

                try //try catch since will throw error on nexus transferes
                {
                    BaseVehicle bv = player?.GetParentEntity() as BaseVehicle;
                    if (bv == null) { return; }
                    if (storedData.LastMiniDriver.ContainsKey(bv.net.ID.Value)) { storedData.LastMiniDriver[bv.net.ID.Value] = player.userID; }
                    else { storedData.LastMiniDriver.Add(bv.net.ID.Value, player.userID); }
                    MiniLatch ml = entity?.VehicleParent()?.gameObject?.GetComponent<MiniLatch>();
                    if (ml != null) { ml.UnLatch(config.HeliUnLock); }
                }
                catch { }
                return;
            }
            if (config.Tugboatmines && entity?.prefabID == 1252195950)//"innertube.deployed") //Mounted Mine
            {
                foreach (var c4 in entity.children) { if (c4 != null && c4 is TimedExplosive) { entity?.DismountAllPlayers(); return; } }
            }
        }

        void CanDismountEntity(BasePlayer player, BaseMountable entity)
        {
            if (entity?.prefabID == 1955582400)// "tugboatdriver") //Dismounted tugboat driver seat
            {
                if (config.AutoNavButton) { CuiHelper.DestroyUi(player, "AutoNavButton"); }
                if (config.AllowAutoNav && storedData.AutoNav.Contains(player.userID) && permission.UserHasPermission(player.UserIDString, "TugMe.AutoNav"))
                {
                    Tugboat tugboat = player?.GetParentEntity() as Tugboat;
                    if (tugboat != null && tugboat.HasFlag(Tugboat.Flags.On)) //Check if engine on
                    {
                        AutoNavigation an = tugboat.gameObject.GetComponent<AutoNavigation>();
                        if (an == null) //Add auto nav if missing
                        {
                            an = tugboat.gameObject.AddComponent<AutoNavigation>();
                            an.captin = player;
                            MessageIcon(player, "B2");
                        }
                    }
                }
            }
            //Keep track of last mini driver
            if (config.TugBoatHeliLock && (entity?.prefabID == 3742994540 || entity?.prefabID == 70742988) && player == entity?.VehicleParent()?.GetDriver())
            {
                BaseVehicle bv = entity?.VehicleParent();
                if (bv == null) { return; }
                if (storedData.LastMiniDriver.ContainsKey(bv.net.ID.Value)) { storedData.LastMiniDriver[bv.net.ID.Value] = bv.GetDriver().userID; }
                else { storedData.LastMiniDriver.Add(bv.net.ID.Value, bv.GetDriver().userID); }
            }
        }

        //Sam Site Control check boat auth
        object OnSamSiteTarget(SamSite samSite, BaseCombatEntity target)
        {
            if (samSite.staticRespawn) { return null; }
            var mountPoints = (target as BaseVehicle)?.mountPoints;
            var tugboat = samSite?.GetParentEntity() as Tugboat;
            if (mountPoints != null && tugboat != null) //Checks players mounted
            {
                foreach (var mountPoint in mountPoints)
                {
                    var player = mountPoint.mountable.GetMounted();
                    if ((object)player != null && tugboat.IsAuthedForBuilding(player)) { return true; }
                }
            }
            else if (tugboat != null) //Checks players standing in scrappy
            {
                foreach (var child in target.children)
                {
                    var player = child as BasePlayer;
                    if ((object)player != null)
                    {
                        if (tugboat.IsAuthedForBuilding(player)) { return true; }
                    }
                }
            }
            return null;
        }

        private void OnServerSave() { SaveData(); }

        //Catch Hammer hitting to enable rotate mode
        object OnHammerHit(BasePlayer ownerPlayer, HitInfo info)
        {
            BasePlayer player = info?.Initiator as BasePlayer;
            if (player == null || !(player.GetParentEntity() is Tugboat tb)) { return null; }
            //Check has reload down and permission
            if (player.serverInput.IsDown(BUTTON.RELOAD) && permission.UserHasPermission(player.UserIDString, "TugMe.Rotate"))
            {
                if (EventBoats.Contains(tb)) { return null; } //Check isnt event tug
                if (AdminDebug) { Puts(info?.HitEntity?.ShortPrefabName); }
                if (tb.IsAuthedForBuilding(player) && config.ItemRotation.Contains(info?.HitEntity?.ShortPrefabName) && info.HitEntity?.GetParentEntity() == tb)
                {
                    info.HitEntity.transform.localRotation *= Quaternion.Euler(0, config.ItemAngle, 0);
                    info.HitEntity.SendNetworkUpdateImmediate();
                    return true;
                }
            }
            if (info.HitEntity is Anchor anchor)
            {
                if (tb.IsAuthedForBuilding(player) && player.serverInput.IsDown(BUTTON.DUCK))
                {
                    ToggleTow(anchor, tb, player);
                    return true;
                }
            }
            if (info.HitEntity is Cannon cannon)
            {
                if (tb.IsAuthedForBuilding(player) && player.serverInput.IsDown(BUTTON.DUCK))
                {
                    cannon.MountPlayer(player);
                    return true;
                }
            }
            return null;
        }

        private object CanBeTargeted(BaseCombatEntity baseCombatEntity, GunTrap gunTrap)
        {
            if (gunTrap?.GetParentEntity() is Tugboat) { return false; }
            return null;
        }

        private object CanBeTargeted(BasePlayer basePlayer, FlameTurret flameTurret)
        {
            if (flameTurret?.GetParentEntity() is Tugboat) { return false; }
            return null;
        }

        private object CanTeleportDeepSea(Tugboat tugboat)
        {
            if (config.BlockTugDeepsea)
            {
                return new ValueTuple<bool, Translate.Phrase>(false, null);
            }
            if (config.AllowLatchedDeep)
            {
                foreach (var ent in tugboat.children)
                {
                    if (ent is Minicopter)
                    {
                        return new ValueTuple<bool, Translate.Phrase>(true, null);
                    }
                }
            }
            return null;
        }

        private void OnDeepSeaTeleport(TriggerDeepSeaPortal portal, Tugboat entity) //Moves the attached boat behind tug at same time.
        {
            var th = entity.gameObject.GetComponent<TowHook>();
            if (th != null)
            {
                if (portal.Portal.PortalMode == DeepSeaPortal.PortalModeEnum.Entrance)
                {
                    timer.Once(1, () => { if (th != null && th.boat != null) { PointEntity<DeepSeaManager>.ServerInstance.MoveToDeepSea(th.boat); } });
                    return;
                }
                timer.Once(1, () => { if (th != null && th.boat != null) { PointEntity<DeepSeaManager>.ServerInstance.MoveToMainIsland(th.boat); } });
            }
        }

        //Unhook from tugboat on mass collision spam (Prevents making lag machines)
        private object OnPlayerBoatCollide(PlayerBoat playerBoat)
        {
            ulong boatId = playerBoat.net.ID.Value;
            if (!Connected.Contains(boatId)) { return null; } //Hashset should be faster
            if (!_collisionTrackers.TryGetValue(boatId, out var tracker))
            {
                tracker = new CollisionBuffer { LastResetTime = Time.realtimeSinceStartup };
                _collisionTrackers[boatId] = tracker;
            }
            else
            {
                float currentTime = Time.realtimeSinceStartup;
                float elapsed = currentTime - tracker.LastResetTime;
                if (elapsed > config.HookRefresh)
                {
                    tracker.HitCount = 0;
                    tracker.LastResetTime = currentTime;
                }
            }
            tracker.HitCount++;
            if (tracker.HitCount >= config.HookMaxCollision)
            {
                _collisionTrackers.Remove(boatId);
                if (Towed.TryGetValue(boatId, out TowHook th))
                {
                    th.RemoveMe();
                    return true;
                }
            }
            return null;
        }

        void OnEntityKill(Tugboat entity)
        {
            if (entity?.net == null) { return; }
            ulong id = entity.net.ID.Value;
            storedData.OwnedTugs.Remove(id);
            storedData.RunningTugs.Remove(id);
            SinkingTugs.Remove(id);
            DamageTimer.Remove(id);
            Shooting.Remove(id);
            var th = entity.GetComponent<TowHook>();
            if (th != null) { th.attached = false; th.RemoveMe(); }
        }

        void OnEntityKill(PlayerBoat entity)
        {
            if (entity?.net == null) { return; }
            _collisionTrackers.Remove(entity.net.ID.Value);
            if (Towed.TryGetValue(entity.net.ID.Value, out TowHook th)) { th.attached = false; th.RemoveMe(); }
        }

        void OnEntityKill(BaseHelicopter entity)
        {
            if (entity?.net == null) { return; }
            ulong id = entity.net.ID.Value;
            storedData.LastMiniDriver.Remove(id);

            var ml = entity.GetComponent<MiniLatch>();
            if (ml?.mini?.rigidBody != null)
            {
                try { ml.mini.rigidBody.ResetInertiaTensor(); }
                catch { /* intentionally silent — Unity edge case */ }
            }
        }

        void OnEntityKill(StorageContainer entity)
        {
            var boat = entity.GetComponent<TugboatRef>()?.Boat;
            if (boat == null) { return; }
            if (config.EventHooks)
            {
                var players = Pool.Get<List<BasePlayer>>();
                try
                {
                    var children = boat.children;
                    int count = children.Count;
                    for (int i = 0; i < count; i++)
                    {
                        if (children[i] is BasePlayer player && player.UserIDString.IsSteamId()) { players.Add(player); }
                    }
                    Interface.Oxide.CallHook("EventTugLooted", boat, players);
                }
                finally
                {
                    Pool.FreeUnmanaged(ref players);
                }
            }

            // Delay start fire only if still valid
            timer.Once(config.FireDelay, () =>
            {
                BoatFire(boat);
            });
        }

        void OnEntityKill(WaterInflatable entity)
        {
            if (entity == null || entity.children == null || entity.children.Count == 0) { return; }
            var children = entity.children;
            for (int i = children.Count - 1; i >= 0; i--)
            {
                if (children[i] is not TimedExplosive te) { continue; }
                te.SetParent(null);
                te.transform.position = entity.transform.position + Vector3.up * 2f;
                var tugs = Pool.Get<List<Tugboat>>();
                try
                {
                    Vis.Entities(entity.transform.position, 4f, tugs, Rust.Layers.Mask.Default);
                    if (tugs.Count > 0)
                    {
                        tugs[0].Hurt(10000f); // Apply direct heavy damage once
                    }
                }
                finally
                {
                    Pool.FreeUnmanaged(ref tugs);
                }
                te.Explode();
            }
        }

        private void OnEntityDeath(BaseCombatEntity entity, HitInfo info)
        {
            if (!(entity is Tugboat tug) || tug?.net == null)
                return;

            if (!EventBoats.Contains(tug))
                return;

            try
            {
                // cache id
                ulong id = tug.net.ID.Value;
                var nav = tug.GetComponent<AutoNavigation>();
                if (nav != null) nav.RemoveMe();

                var func = tug.GetComponent<TugboatFunction>();
                if (func != null) func.RemoveMe();

                // stop motion
                tug.gasPedal = 0f;
                Transform tf = tug.transform;
                if (tf != null)
                {
                    Vector3 pos = tf.position;
                    Quaternion rot = tf.rotation;

                    // precomputed vector avoid new every call
                    Vector3 offset = new Vector3(0f, 6.5f, 4f);
                    Vector3 effectPos = pos + rot * offset;

                    Effect.server.Run(C4_explosion, effectPos, Vector3.up, null, true);
                    Effect.server.Run(Gibs, effectPos, Vector3.up, null, true);
                }

                var children = tug.children;
                for (int i = children.Count - 1; i >= 0; i--)
                {
                    BaseEntity child = children[i];
                    if (child == null || child.IsDestroyed)
                        continue;

                    switch (child)
                    {
                        case ScientistNPC _:
                            ActiveNPCs.Remove(child.net.ID.Value);
                            child.Kill();
                            break;

                        case AutoTurret _:
                        case SamSite _:
                            child.Kill();
                            break;
                    }
                }

                if (config.EventHooks)
                    Interface.Oxide.CallHook("EventTugStopped", tug);

                EventBoats.Remove(tug);
                storedData.EventTugs.Remove(id);
                if (_plugin.config.PirateSink) { tug.SetFlagLocal(BaseEntity.Flags.Broken, false); tug.Invoke(() => { if (tug == null) { return; } tug.SetFlagLocal(BaseEntity.Flags.Broken, false); tug.Invoke(() => { if (tug != null) { BoatFire(tug); } }, config.PirateSinkFire); }, 5f); }
            }
            catch
            {
                // swallow but remain safe (Oxide expected)
            }
        }

        //Vendor control
        private object OnNpcConversationStart(NPCTalking __instance, BasePlayer ply)
        {
            if (_plugin.TugDealers.ContainsKey(__instance))
            {
                List<Tugboat> list = Pool.Get<List<Tugboat>>();
                Vis.Entities<Tugboat>(__instance.transform.position, _plugin.config.SpawnBlockRadius, list);
                bool TugBlocked = false;
                if (list.Count > 0) { TugBlocked = true; }
                if (!_plugin.permission.UserHasPermission(ply.UserIDString, "TugMe.Buy"))
                {
                    _plugin.MessageIcon(ply, "C3");
                    Pool.FreeUnmanaged(ref list);
                    return true;
                }
                if (TugBlocked)
                {
                    _plugin.MessageIcon(ply, "E6", _plugin.config.SpawnBlockRadius.ToString());
                    Pool.FreeUnmanaged(ref list);
                    return true;
                }
                if (!_plugin.SpawnManager(ply))
                {
                    _plugin.MessageIcon(ply, "C4", _plugin.config.MaxPerPlayer.ToString());
                    Pool.FreeUnmanaged(ref list);
                    return true;
                }
                _plugin.RustUI(ply); //Create CUI
                Pool.FreeUnmanaged(ref list);
                return true;
            }
            return null;
        }

        private void OnNewSave()
        {
            storedData.EventTugs.Clear();
            storedData.OwnedTugs.Clear();
            storedData.AutoNav.Clear();
            storedData.LastMiniDriver.Clear();
            storedData.RunningTugs.Clear();
            SaveData();
        }

        object CanNetworkTo(VendingMachineMapMarker marker, BasePlayer player)
        {
            if (marker.OwnerID != player.userID && TugMapMarkers.Contains(marker)) { return false; }
            return null;
        }

        private void OnEntitySpawned(BaseHelicopter baseEntity)
        {
            NextFrame(() =>
            {
                LatchFunction(baseEntity, null);
            });
        }

        private void OnEntitySpawned(Tugboat baseEntity)
        {
            NextFrame(() =>
            {
                if (baseEntity != null)
                {
                    SetupTugSettings(baseEntity);
                }
            });
        }

        #endregion

        #region Methods
        //Sends chat message with custom name and icon
        public void MessageIcon(BasePlayer player, string txt, params object[] args) { rust.SendChatMessage(player, config.TugName, message(player, txt, args), config.AnnouncementIcon); }

        public IEnumerator TugMeStartUp()
        {
            AllowedItems = Tugboat_AllowedItems();
            bool dupes = false;
            CustomVendorPos[] c = config.CustomPositions.Distinct().ToArray();
            if (c.Length != config.CustomPositions.Length)
            {
                config.CustomPositions = c;
                dupes = true;
            }
            VendorPos[] v = config.VendorPositions.Distinct().ToArray();
            if (v.Length != config.VendorPositions.Length)
            {
                config.VendorPositions = v;
                dupes = true;
            }
            if (dupes)
            {
                PrintWarning("Configuration appears to have duplicates; fixed and saving");
                SaveConfig();
            }
            yield return CoroutineEx.waitForEndOfFrame;
            if (config.EnableTugSpawners || config.EnableTugSpawners2 || config.EnableTugSpawners3)
            { //Create NPC Tug boat spawners
                CreateNPCs();
                Puts("Spawned " + TugDealers.Count + " Tugboat Dealers.");
            }
            yield return CoroutineEx.waitForEndOfFrame;
            //Clear up if server missed Unload hook (Crash or dirty shutdown)
            if (storedData.EventTugs != null && storedData.EventTugs.Count > 0)
            {
                int dirty = 0;
                foreach (var tugid in storedData.EventTugs)
                {
                    BaseNetworkable bn = BaseNetworkable.serverEntities.Find(new NetworkableId(tugid));
                    if (bn != null && !bn.IsDestroyed) { bn.Kill(); dirty++; }
                }
                if (dirty > 0) { Puts("Detected Dirty Server Shut Down, Removed " + dirty + " Orphaned Entitys!"); }
                storedData.EventTugs.Clear();
            }
            yield return CoroutineEx.waitForEndOfFrame;
            //Reapply mod to exsisting tugboats
            int tugs = 0;
            int minis = 0;
            foreach (var t in new List<BaseNetworkable>(BaseNetworkable.serverEntities.entityList.Get().Values))
            {
                if (t == null) { continue; }
                if (t is BaseHelicopter) { minis++; LatchFunction(t, null); continue; }
                if (t is Tugboat)
                {
                    if ((t as Tugboat).OwnerID == 1234)
                    {
                        Puts("Killing Old Event Tug");
                        t.Kill();
                    }
                    else
                    {
                        tugs++;
                        if (t != null)
                        {
                            SetupTugSettings(t as Tugboat);
                            //Reapply heli latching
                            for (int i = t.children.Count - 1; i >= 0; i--)
                            {
                                if (t.children[i] is Minicopter || t.children[i] is AttackHelicopter) { LatchFunction(t.children[i], t as Tugboat); }
                            }
                        }
                    }
                    continue;
                }
                if ((t is FlameTurret || t is GunTrap) && (t as BaseEntity).HasFlag(BaseEntity.Flags.Reserved5)) { (t as BaseEntity).SetFlagLocal(BaseEntity.Flags.Reserved5, false); } //Reset Traps
            }
            Puts("Modded " + tugs + " Tugboats.");
            timer.Once(10, () => { EventTick(); });
            timer.Every(config.EventTick, () => { EventTick(); });
            if (config.MapFunction) { timer.Every(config.MapRefresh, () => { MapTick(); }); }
            if (config.MarkEvents) { timer.Every(config.MapRefresh, () => { DrawMapfunction(); }); }
            if (config.WaterSystem) { timer.Every(config.WaterSystemTick, () => { AddWater(); }); }
        }

        public void SaveData() { Interface.Oxide.DataFileSystem.WriteObject("TugMe", storedData); } //Save Datafile

        public string Sanitize(string String) { return new string(String.Where(char.IsLetterOrDigit).ToArray()); }

        public string PositionToGridCoord(Vector3 position)
        {
            Vector2 vector = new Vector2(TerrainMeta.NormalizeX(position.x), TerrainMeta.NormalizeZ(position.z));
            float num = TerrainMeta.Size.x / 1024f;
            int num2 = 7;
            Vector2 vector2 = vector * num * num2;
            float num3 = Mathf.Floor(vector2.x) + 1f;
            float num4 = Mathf.Floor(num * (float)num2 - vector2.y);
            string text = string.Empty;
            float num5 = num3 / 26f;
            float num6 = num3 % 26f;
            if (num6 < 0) { num6 = 1; } //Limit to no less than A grid
            if (num4 < 0) { num4 = 0; } //Limit to no less then 0 Grid
            else if (num6 == 0f) { num6 = 26f; }
            if (num5 > 1f) { text += Convert.ToChar(64 + (int)num5); }
            text += Convert.ToChar(64 + (int)num6);
            return $"{text}{num4}";
        }

        private ulong ListOwnedTugs(BasePlayer player, int index = -1)
        {
            List<ulong> list = new List<ulong>();
            int i = 0;
            foreach (KeyValuePair<ulong, ulong> kvp in storedData.OwnedTugs)
            {
                if (kvp.Value == player.userID)
                {
                    BaseNetworkable bn = BaseNetworkable.serverEntities.Find(new NetworkableId(kvp.Key));
                    if (bn != null && !bn.IsDestroyed)
                    {
                        MessageIcon(player, "A4", +i++ + " Or " + kvp.Key.ToString(), PositionToGridCoord(bn.transform.position));
                        list.Add(kvp.Key);
                    }
                }
            }
            if (index == -1 || index > list.Count - 1) { return 0; }
            return list[index];
        }

        public void RepositionEntities(TransferRequest Request, Vector3 offset, Quaternion rot)
        {
            ProtoBuf.Entity entity = Request.entities[0];
            Vector3 pos = entity.baseEntity.pos;
            Quaternion rotation = Quaternion.Euler(entity.baseEntity.rot);
            Quaternion rhs = rot * Quaternion.Inverse(rotation);
            Vector3 b = offset - pos;
            foreach (ProtoBuf.Entity entity2 in Request.entities)
            {
                if (entity2.baseEntity != null && (entity2.parent == null || !entity2.parent.uid.IsValid))
                {
                    entity2.baseEntity.pos += b;
                    entity2.baseEntity.rot = (Quaternion.Euler(entity2.baseEntity.rot) * rhs).eulerAngles;
                }
            }
        }

        private List<SignDataJson> GetSignData(List<BaseNetworkable> networkables)
        {
            List<SignDataJson> signData = new List<SignDataJson>();
            foreach (var bn in networkables)
            {
                try
                {
                    if (bn is Signage)
                    {
                        int i = 0;
                        foreach (uint uid in (bn as Signage).textureIDs)
                        {
                            if (uid == 0) { continue; } //Blank image
                            byte[] Image = FileStorage.server.Get(uid, FileStorage.Type.png, bn.net.ID);
                            SignDataJson signDataJson = new SignDataJson();
                            signDataJson.NetId = bn.net.ID.Value;
                            signDataJson.Frame = i++;
                            signDataJson.SignData = Convert.ToBase64String(Compression.Compress(Image));
                            signData.Add(signDataJson);
                        }
                    }
                    else if (bn is PhotoFrame)
                    {
                        if ((bn as PhotoFrame)._overlayTextureCrc == 0) { continue; } //Blank image
                        byte[] Image = FileStorage.server.Get((bn as PhotoFrame)._overlayTextureCrc, FileStorage.Type.png, bn.net.ID);
                        SignDataJson signDataJson = new SignDataJson();
                        signDataJson.NetId = bn.net.ID.Value;
                        signDataJson.Frame = 0;
                        signDataJson.SignData = Convert.ToBase64String(Compression.Compress(Image));
                        signData.Add(signDataJson);
                    }
                }
                catch { Puts("GetSignData Fault"); }
            }
            return signData;
        }

        public byte[] SerializeToBytes(Request instance)
        {
            byte[] array;
            using (var bufferStream = new BufferStream().Initialize())
            {
                Request.Serialize(bufferStream, instance);
                ArraySegment<byte> buffer = bufferStream.GetBuffer();
                array = buffer.ToArray();
            }
            return array;
        }

        private string CopyTugBoat(Tugboat tugboat)
        {
            if (!Directory.Exists("tugmetugs")) { Directory.CreateDirectory("tugmetugs"); }
            Request request = null;
            List<BaseNetworkable> networkables = null;
            List<BasePlayer> players = null;
            List<ulong> playerIds = null;
            tugboat.DismountAllPlayers();
            NexusServer.BuildTransferRequest(tugboat, "", "", "", out request, out networkables, out players, out playerIds);
            for (int i = request.transfer.entities.Count - 1; i >= 0; i--) { if (request.transfer.entities[i].basePlayer != null) { request.transfer.entities.RemoveAt(i); } }
            TugProtoData tugProtoData = new TugProtoData();
            tugProtoData.OwnerID = tugboat.OwnerID.ToString();
            tugProtoData.TugData = Convert.ToBase64String(Compression.Compress(SerializeToBytes(request)));
            tugProtoData.SignData = GetSignData(networkables);
            return JsonConvert.SerializeObject(tugProtoData);
        }

        private bool ProcessTugMeTugsJson(Vector3 positon, Quaternion rotation, string data)
        {
            TugProtoData tugProtoData = JsonConvert.DeserializeObject<TugProtoData>(data);
            if (tugProtoData == null)
            {
                Puts("DeserializeObject Fault");
                return false;
            }
            Request Request = Request.Deserialize(Compression.Uncompress(Convert.FromBase64String(tugProtoData.TugData))); //Convert byte array into Transfere data
            if (Request != null)
            {
                //Remap UIDs
                UidMapping.Clear();
                Request.InspectUids(new UidInspector<ulong>(UpdateWithNewUid));
                RepositionEntities(Request.transfer, positon, rotation);
                SpawnEntities(Request.transfer, tugProtoData.SignData); //Spawn entitys
            }
            return true;
        }

        private void SpawnEntities(TransferRequest Request, List<SignDataJson> Signs)
        {
            Tugboat tug = null;
            Rust.Application.isLoadingSave = true; //Stops auto init on entitys being created
            try
            {
                Dictionary<BaseEntity, ProtoBuf.Entity> EntityToSpawn = new Dictionary<BaseEntity, ProtoBuf.Entity>();
                List<BaseEntity> images = new List<BaseEntity>();
                foreach (ProtoBuf.Entity entity in Request.entities)
                {
                    //Create entitys
                    BaseEntity baseEntity = GameManager.server.CreateEntity(StringPool.Get(entity.baseNetworkable.prefabID), entity.baseEntity.pos, Quaternion.Euler(entity.baseEntity.rot), true);
                    if (baseEntity != null)
                    {
                        baseEntity.InitLoad(entity.baseNetworkable.uid);
                        EntityToSpawn.Add(baseEntity, entity);
                    }
                }
                foreach (KeyValuePair<BaseEntity, ProtoBuf.Entity> keyValuePair in EntityToSpawn)
                {
                    //Spawn and load data
                    BaseEntity key = keyValuePair.Key;
                    if (!(key == null))
                    {

                        key.Spawn();
                        //Remove old sign crc's
                        if (key is PhotoFrame)
                        {
                            keyValuePair.Value.photoFrame.overlayImageCrc = 0;
                            images.Add(key);
                        }
                        else if (key is Signage)
                        {
                            for (int i = keyValuePair.Value.sign.imageIds.Count - 1; i >= 0; i--) { keyValuePair.Value.sign.imageIds[i] = 0; }
                            images.Add(key);
                        }
                        else if (key is Tugboat)
                        {
                            tug = key as Tugboat;
                        }
                        key.Load(new BaseNetworkable.LoadInfo
                        {
                            fromDisk = true,
                            fromTransfer = true,
                            msg = keyValuePair.Value
                        });
                        if (key.prefabID == 1955582400) { key.transform.rotation = new Quaternion(0, 0, 0, 0); }
                    }
                }
                //Fix Signs
                foreach (BaseEntity be in images)
                {
                    if (UidMapping.ContainsValue(be.net.ID.Value))
                    {
                        var NewUID = UidMapping.FirstOrDefault(x => x.Value == be.net.ID.Value).Key;
                        if (be is Signage)
                        {
                            int i = 0;
                            foreach (uint frame in (be as Signage).textureIDs) { ReadImage(NewUID, i++, be, Signs); }
                        }
                        else { ReadImage(NewUID, 0, be, Signs); }
                    }
                }
                foreach (KeyValuePair<BaseEntity, ProtoBuf.Entity> keyValuePair2 in EntityToSpawn)
                {
                    //Update data
                    BaseEntity key2 = keyValuePair2.Key;
                    if (!(key2 == null))
                    {
                        key2.UpdateNetworkGroup();
                        key2.PostServerLoad();
                    }
                }
            }
            catch (Exception ex) { Puts("SpawnEntities Fault: " + ex.Message); }
            Rust.Application.isLoadingSave = false; //Return to normal
            timer.Once(1, () =>
            {
                if (tug != null)
                {
                    SetupTugSettings(tug);
                    //Reapply heli latching
                    for (int i = tug.children.Count - 1; i >= 0; i--)
                    {
                        if (tug.children[i] is Minicopter || tug.children[i] is AttackHelicopter)
                        {
                            if (!storedData.LastMiniDriver.ContainsKey(tug.children[i].net.ID.Value))
                            {
                                storedData.LastMiniDriver.Add(tug.children[i].net.ID.Value, tug.OwnerID);
                            }
                            LatchFunction(tug.children[i], tug);
                            break; //Can only latch 1 heli
                        }
                    }
                }
            });
        }

        private void ReadImage(ulong uid, int frame, BaseEntity be, List<SignDataJson> Signs)
        {
            uint crc = 0;
            if (Signs == null || Signs.Count == 0) { return; }
            foreach (var sd in Signs)
            {
                if (sd.NetId == uid && frame == sd.Frame)
                {
                    Puts("Loaded Image " + String.Format("{0:0.##}", (double)(sd.SignData.Length / 1024f)) + " Kb");
                    crc = FileStorage.server.Store(Compression.Uncompress(Convert.FromBase64String(sd.SignData)), FileStorage.Type.png, be.net.ID);
                    if (be is Signage) { (be as Signage).textureIDs[frame] = crc; }
                    else if (be is PhotoFrame) { (be as PhotoFrame)._overlayTextureCrc = crc; }
                }
            }
        }

        private void UpdateWithNewUid(UidType type, ref ulong prevUid)
        {
            if (type == UidType.Clear) { prevUid = 0uL; }
            else if (prevUid != 0L)
            {
                if (!UidMapping.TryGetValue(prevUid, out ulong value))
                {
                    value = Network.Net.sv.TakeUID();
                    UidMapping.Add(prevUid, value);
                }
                prevUid = value;
            }
        }

        private void TeleportTug(ulong ID, BasePlayer player)
        {
            BaseNetworkable bn = BaseNetworkable.serverEntities.Find(new NetworkableId(ID));
            if (bn == null)
            {
                MessageIcon(player, "A2");
                storedData.OwnedTugs.Remove(ID);
                return;
            }
            Vector3 vector = GetPosition(player);
            if (vector == Vector3.zero) { return; }
            bn.transform.position = vector;
            bn.SendNetworkUpdateImmediate();
            MessageIcon(player, "C7", ID, PositionToGridCoord(bn.transform.position));
        }

        private Vector3 GetPosition(BasePlayer player)
        {
            if (player == null) return Vector3.zero;
            if (player.IsBuildingBlocked())
            {
                MessageIcon(player, "M9");
                return Vector3.zero;
            }
            if (player.transform.position.y < -5) //Prevent spawning in train tunnels, caves ect
            {
                MessageIcon(player, "M0");
                return Vector3.zero;
            }
            Vector3 position;
            RaycastHit hit;
            if (!Physics.Raycast(player.eyes.HeadRay(), out hit, Mathf.Infinity, PhysicsLayerMask))
            {
                MessageIcon(player, "E1");
                return Vector3.zero;
            }
            if (permission.UserHasPermission(player.UserIDString, "TugMe.Tomeanywhere"))
            {
                return hit.point + new Vector3(0, 4, 0);
            }
            if (hit.distance > 35) //Limit max spawn range
            {
                MessageIcon(player, "E2");
                return Vector3.zero;
            }
            else if (hit.distance < 12) //Limit min spawn range to stop player glitching inside it
            {
                MessageIcon(player, "E3");
                return Vector3.zero;
            }
            position = hit.point;
            position.y = 0.1f; //Force to water level
            bool buildingblocked = false;
            List<BuildingPrivlidge> bb = Pool.Get<List<BuildingPrivlidge>>();
            Vis.Entities<BuildingPrivlidge>(position, _plugin.config.SpawnBlockRadius, bb);
            foreach (BuildingPrivlidge bp in bb)
            {
                if (!bp.IsAuthed(player))
                {
                    buildingblocked = true;
                    break;
                }
            }
            Pool.FreeUnmanaged(ref bb);
            if (buildingblocked)
            {
                MessageIcon(player, "M9");
                return Vector3.zero;
            }
            //Check 8 points around radius are all in water
            for (int i = 0; i < 8; i++)
            {
                float num5 = (float)i / (float)8 * 360f;
                Vector3 p = new Vector3(Mathf.Sin(num5 * 0.0174532924f) * 11f, 0, Mathf.Cos(num5 * 0.0174532924f) * 11f) + position;
                if (TerrainMeta.HeightMap.GetHeight(p) > 0)
                {
                    MessageIcon(player, "E4");
                    return Vector3.zero;
                }
            }
            //Check for prefab collision, Prevent spawn inside things
            if (CheckColliders(position, 12))
            {
                MessageIcon(player, "E5");
                return Vector3.zero;
            }
            //Check no close by tugs already
            List<Tugboat> list = Pool.Get<List<Tugboat>>(); //Pooling to save list memory
            Vis.Entities<Tugboat>(position, _plugin.config.SpawnBlockRadius, list);
            if (list.Count != 0)
            {
                MessageIcon(player, "E6", _plugin.config.SpawnBlockRadius.ToString());
                Pool.FreeUnmanaged(ref list); //Free pooling
                return Vector3.zero;
            }
            Pool.FreeUnmanaged(ref list); //Free pooling
            //Check not spawning ontop of a player
            List<BasePlayer> list2 = Pool.Get<List<BasePlayer>>();
            Vis.Entities<BasePlayer>(position, 12, list2);
            if (list2.Count != 0)
            {
                MessageIcon(player, "E7");
                Pool.FreeUnmanaged(ref list2);
                return Vector3.zero;
            }
            Pool.FreeUnmanaged(ref list2);
            return position;
        }

        private void MarkerDisplayingDelete()
        {
            foreach (var m in mapmarkersList)
            {
                if (m != null && !m.IsDestroyed)
                {
                    (m as MapMarkerGenericRadius).Kill();
                    (m as MapMarkerGenericRadius).SendUpdate();
                }
            }
            mapmarkersList.Clear();
        }

        private void DrawMapfunction()
        {
            MarkerDisplayingDelete();
            if (EventBoats.Count == 0) { return; }
            foreach (var tug in EventBoats)
            {
                Tugboat eventTug = tug as Tugboat;
                if (eventTug == null || eventTug.IsDestroyed) { continue; }
                MapMarkerGenericRadius MapMarkerCustom = GameManager.server.CreateEntity(Mapmakerprefab) as MapMarkerGenericRadius;
                if (MapMarkerCustom == null) { continue; }
                MapMarkerCustom.alpha = config.MarkerAlpha;
                MapMarkerCustom.radius = config.MarkerRadius;
                MapMarkerCustom.color1 = one;
                MapMarkerCustom.color2 = two;
                MapMarkerCustom.SetParent(eventTug, false, true);
                if (MapMarkerCustom.transform.position != Vector3.zero) { mapmarkersList.Add(MapMarkerCustom); }
                else { UnityEngine.Object.Destroy(MapMarkerCustom.gameObject); } //Never spawned so clean up
            }
            foreach (var m in mapmarkersList)
            {
                m.Spawn();
                MapMarker.serverMapMarkers.Remove((m as MapMarkerGenericRadius));
                (m as MapMarkerGenericRadius).SendUpdate();
            }
        }

        private void UpdateVenderTugIcon()
        {
            foreach (var kvp in TugDealers)
            {
                VendingMachineMapMarker vendingMarkerIcon = GameManager.server.CreateEntity(StringPool.Get(3459945130), kvp.Key.transform.position) as VendingMachineMapMarker;
                if (vendingMarkerIcon == null) { continue; }
                vendingMarkerIcon.markerShopName = config.VendorsOnMap;
                vendingMarkerIcon.enabled = false;
                vendingMarkerIcon.Spawn();
                VenderMapMarkers.Add(vendingMarkerIcon);
            }
        }

        private int UpdatePlayersTugIcon(BasePlayer player, bool forcerefresh = false)
        {
            if (player == null || player.IsNpc || player.IsSleeping() || !player.IsAlive()) { return 0; }
            int Found = 0;
            TugMapMarkers.RemoveAll(m => m == null || m.IsDestroyed); //Markers die with their tug
            foreach (KeyValuePair<ulong, ulong> kvp in storedData.OwnedTugs)
            {
                if (kvp.Value == player.userID)
                {
                    BaseNetworkable bn = BaseNetworkable.serverEntities.Find(new NetworkableId(kvp.Key));
                    if (bn != null && !bn.IsDestroyed && bn is Tugboat)
                    {
                        Found++;
                        VendingMachineMapMarker vm = null;
                        string shopName = "TUGBOAT[" + kvp.Key + "]";
                        foreach (var mm in TugMapMarkers)
                        {
                            VendingMachineMapMarker marker = mm as VendingMachineMapMarker;
                            if (marker != null && marker.markerShopName == shopName)
                            {
                                vm = marker;
                                break;
                            }
                        }
                        if (vm == null)
                        {
                            VendingMachineMapMarker vendingMarkerIcon = GameManager.server.CreateEntity(StringPool.Get(3459945130), bn.transform.position) as VendingMachineMapMarker;
                            if (vendingMarkerIcon == null) { continue; }
                            vendingMarkerIcon.markerShopName = shopName;
                            vendingMarkerIcon.enabled = false;
                            vendingMarkerIcon.OwnerID = player.userID;
                            vendingMarkerIcon.Spawn();
                            vendingMarkerIcon.SetParent(bn as Tugboat, true, true);
                            TugMapMarkers.Add(vendingMarkerIcon);
                        }
                    }
                }
            }
            return Found; //Return number found
        }

        private void ToggleTow(Anchor anchor, Tugboat tug, BasePlayer player)
        {
            if (!anchor.IsBusy() && anchor.parentEntity.Get(true) == tug)
            {
                if (!anchor.Lowered)
                {
                    anchor.SetFlagLocal(BaseEntity.Flags.Busy, true, false);
                    anchor.SetFlagLocal(BaseEntity.Flags.Reserved12, true, false);
                    anchor.CancelInvoke(new Action(anchor.OnFullyLowered));
                    anchor.Invoke(new Action(anchor.OnFullyLowered), anchor.LowerDuration);
                    timer.Once(anchor.LowerDuration, () => { FullyLowered(tug, anchor, player); });
                }
                else
                {
                    anchor.SetFlagLocal(BaseEntity.Flags.Busy, true, false);
                    anchor.SetFlagLocal(BaseEntity.Flags.Reserved13, true, false);
                    anchor.CancelInvoke(new Action(anchor.OnFullyRaised));
                    anchor.Invoke(new Action(anchor.OnFullyRaised), anchor.RaiseDuration);
                    timer.Once(anchor.RaiseDuration, () => { FullyRaised(tug); });
                }
            }
        }

        private void FullyLowered(Tugboat tugboat, Anchor anchor, BasePlayer player)
        {
            if (tugboat == null || anchor == null) { return; } //Destroyed while the anchor was moving
            //Do a scan for boats
            Vector3 TowHook = tugboat.transform.position + tugboat.transform.forward * -13;
            List<PlayerBoat> list = Pool.Get<List<PlayerBoat>>();
            Vis.Entities<PlayerBoat>(TowHook, config.HookRadius, list);
            bool NoConnection = true;
            if (list.Count > 0)
            {
                PlayerBoat playerBoat = null;
                foreach (PlayerBoat pb in list) { if (pb != null && pb != tugboat) { playerBoat = pb; break; } } //Dont hook onto self
                if (playerBoat != null && player != null && playerBoat.IsPlayerAuthed(player, true))
                {
                    //Attach componant
                    TowHook th = tugboat.gameObject.GetComponent<TowHook>();
                    if (th == null)
                    {
                        th = tugboat.gameObject.AddComponent<TowHook>();
                        th.tug = tugboat;
                        th.boat = playerBoat;
                        th.captin = player.userID;
                        th.anchor = anchor;
                        th.InitializeOffset();
                        NoConnection = false;
                        player.ChatMessage(message(player, "I9"));
                    }
                }
            }
            Pool.FreeUnmanaged(ref list);
            if (NoConnection) { NextFrame(() => { ToggleTow(anchor, tugboat, player); }); }
        }

        private void FullyRaised(Tugboat tugboat)
        {
            TowHook th = tugboat.gameObject.GetComponent<TowHook>();
            if (th != null) { th.attached = false; th.RemoveMe(); }
        }

        private bool HaveResources(BasePlayer player)
        {
            Dictionary<string, int> Needed = new Dictionary<string, int>();
            //Check has needed meterials
            foreach (var component in config.SpawnCostResources)
            {
                string name = component.Shortname;
                if (component.SkinID != 0)
                {
                    int found = 0;
                    List<Item> items = Pool.Get<List<Item>>();
                    player.inventory.GetAllItems(items);
                    foreach (Item i in items) { if (i.skin == component.SkinID) { found += i.amount; } }
                    Pool.FreeUnmanaged(ref items);
                    if (found < component.Amount)
                    {
                        if (!Needed.ContainsKey(component.Name)) { Needed.Add(component.Name, 0); }
                        Needed[component.Name] += component.Amount;
                    }
                }
                else
                {
                    if (player.inventory.GetAmount(ItemManager.FindItemDefinition(component.Shortname).itemid) < component.Amount)
                    {
                        if (!Needed.ContainsKey(name)) { Needed.Add(name, 0); }
                        Needed[name] += component.Amount;
                    }
                }
            }
            //Has everything needed so remove from player and allow
            if (Needed.Count == 0)
            {
                foreach (var item in config.SpawnCostResources)
                {
                    if (item.SkinID == 0) { Take(player, ItemManager.FindItemDefinition(item.Shortname).itemid, item.Amount); }
                    else
                    {
                        int take = 0;
                        List<Item> list = Pool.Get<List<Item>>();
                        player.inventory.GetAllItems(list);
                        foreach (Item i in list)
                        {
                            if (i.skin == item.SkinID)
                            {
                                if (i.amount + take == item.Amount)
                                {
                                    take += i.amount;
                                    i.Remove();
                                    i.MarkDirty();
                                }
                                else if (i.amount + take < item.Amount)
                                {
                                    take += i.amount;
                                    i.Remove();
                                    i.MarkDirty();
                                }
                                else if (i.amount + take > item.Amount)
                                {
                                    int amountremove = (item.Amount - take);
                                    i.amount -= amountremove;
                                    take += amountremove;
                                    i.MarkDirty();
                                }
                                if (take == item.Amount) { break; }
                            }
                        }
                        Pool.FreeUnmanaged(ref list);
                    }
                }
                MessageIcon(player, "C5");
                return true;
            }
            else
            {
                string text = "";
                foreach (var item in Needed) { text += $" * {item.Key} x{item.Value}\n"; }
                rust.SendChatMessage(player, config.TugName, message(player, "B4", text), config.AnnouncementIcon);
                return false;
            }
        }

        //Check type of tugboat buying and use external plugin if set
        private bool TryChargePlayer(BasePlayer player)
        {
            if (player == null)
                return false;

            object result = null;
            if (config.Costtype == "serverrewards")
            {
                if (ServerRewards == null)
                {
                    MessageIcon(player, "B5");
                    return false;
                }
                result = ServerRewards.Call("CheckPoints", player.UserIDString);
                if (result is int && (int)result < (int)config.Spawncost)
                {
                    MessageIcon(player, "B6");
                    return false;
                }
                result = ServerRewards.Call("TakePoints", player.UserIDString, (int)config.Spawncost);
            }
            else if (config.Costtype == "economics")
            {
                if (Economics == null)
                {
                    MessageIcon(player, "B7");
                    return false;
                }
                result = Economics.Call("Withdraw", player.UserIDString, (double)config.Spawncost);
            }
            else if (config.Costtype == "resources") { return HaveResources(player); }
            else if (config.Costtype == "free")
            {
                MessageIcon(player, "E8");
                return true;
            }
            else
            {
                MessageIcon(player, "B8");
                return false;
            }
            if (result == null || (result is bool && (bool)result == false))
            {
                MessageIcon(player, "B6");
                return false;
            }
            MessageIcon(player, "B9", config.CurrencySymbol + config.Spawncost.ToString());
            return true;
        }

        //Create CUI window to buy tug
        private void RustUI(BasePlayer player)
        {
            if (CUICached)
            {
                CuiHelper.AddUi(player, BuyCUICache);
                return;
            }
            //Create CUI buy message
            string buytext = message(player, "C0");
            switch (config.Costtype)
            {
                case "serverrewards":
                    buytext += config.CurrencySymbol + config.Spawncost;
                    break;
                case "economics":
                    buytext += config.CurrencySymbol + config.Spawncost;
                    break;
                case "resources":
                    foreach (var item in config.SpawnCostResources)
                    {
                        if (item.Name == "") { buytext += item.Shortname + "(" + item.Amount + ")\n"; }
                        else { buytext += item.Name + "(" + item.Amount + ")\n"; }
                    }
                    break;
                default:
                    buytext = message(player, "C1");
                    break;
            }
            //Create CUI
            BuyCUICache = config.BuyCUIJson.Replace("{BUYTEXT}", buytext); //Keep the template in the config intact
            CUICached = true;
            CuiHelper.AddUi(player, BuyCUICache);
        }

        private void LatchFunction(BaseNetworkable bv, Tugboat tb)
        {
            if (config.TugBoatHeliLock && bv != null)
            {
                MiniLatch latch = bv.gameObject.GetComponent<MiniLatch>();
                if (latch == null)
                {
                    latch = bv.gameObject.AddComponent<MiniLatch>();
                }
                if (latch != null && tb != null)
                {
                    latch.boat = tb;
                    latch.Latched = true;
                    latch.landed = true;
                    latch.mini = bv as BaseVehicle;
                    latch.Lock();
                }
            }
        }

        private bool CheckColliders(Vector3 position, float distance)
        {
            foreach (Collider col in Physics.OverlapSphere(position, distance, PhysicsLayerMask))
            {
                string thisobject = col.gameObject.ToString();
                // Check if any blocked pattern exists in the string
                foreach (var pattern in BlockedPrefabPatterns)
                {
                    if (thisobject.Contains(pattern)) { return true; }
                }
            }
            return false;
        }

        //Find closest cargoship path point
        public int GetClosestNodeToUs(Vector3 position)
        {
            int result = 0;
            float numSq = float.PositiveInfinity;
            var pathPoints = TerrainMeta.Path.OceanPatrolFar;
            int count = pathPoints.Count;

            for (int i = 0; i < count; i++)
            {
                Vector3 b = pathPoints[i];
                float num2 = (position - b).sqrMagnitude;
                if (num2 < numSq)
                {
                    result = i;
                    numSq = num2;
                }
            }
            return result;
        }

        //Check and maintain spawned owner list.
        private bool SpawnManager(BasePlayer player)
        {
            int OwnedTugs = 0;
            for (int i = storedData.OwnedTugs.Count - 1; i >= 0; i--)
            {
                KeyValuePair<ulong, ulong> KVP = storedData.OwnedTugs.ElementAt(i);
                BaseNetworkable BN = BaseNetworkable.serverEntities.Find(new NetworkableId(KVP.Key));
                if (BN != null && !BN.IsDestroyed && BN is Tugboat)
                {
                    if (player.userID == KVP.Value) { OwnedTugs++; }
                    continue;
                }
                storedData.OwnedTugs.Remove(KVP.Key);
            }
            if (OwnedTugs >= config.MaxPerPlayer)
            {
                return false;
            }
            return true;
        }

        private void MapTick()
        {
            foreach (BasePlayer player in BasePlayer.activePlayerList)
            {
                if (permission.UserHasPermission(player.UserIDString, "TugMe.Find")) { UpdatePlayersTugIcon(player); }
            }
        }

        private void EventTick()
        {
            //Clean Boat List
            if (EventBoats.Count > 0)
            {
                for (int i = EventBoats.Count - 1; i >= 0; i--)
                {
                    Tugboat eventBoat = EventBoats[i] as Tugboat;
                    if (eventBoat == null || eventBoat.IsDestroyed || eventBoat.IsDead()) { EventBoats.RemoveAt(i); }
                }
            }
            //Check if needs spawn
            if (EventBoats.Count >= config.EventTug) { return; }
            //Dont run when low FPS
            if (Performance.report.frameRate < config.MinFPS)
            {
                Puts("Warning SERVER Running Below " + config.MinFPS + "FPS, Pirate Event Canceled.");
                return;
            }
            //Dont run when no players online (Save server cpu)
            if (BasePlayer.activePlayerList.Count == 0) { return; }
            Vector3 SpawnPos = TerrainMeta.Path.OceanPatrolFar.GetRandom();
            if (!PlayersNearby(SpawnPos, 50))
            {
                Tugboat TB = NewTugBoat(SpawnPos, Quaternion.Euler(new Vector3(0, 0, 0)), 1234);
                if (TB == null) { return; }
                if (config.DisableBuoyantSleep)
                {
                    var TugBuoyancy = TB.GetComponent<Buoyancy>();
                    if (TugBuoyancy != null)
                    {
                        TugBuoyancy.CancelInvoke("CheckSleepState");
                        TugBuoyancy.Invoke(new Action(TugBuoyancy.Wake), 0f); //Force Awake
                    }
                }
                TB.Invoke(() => { if (TB != null) { SetupEvent(TB); } }, 2);
            }
        }

        public void ShowToast(BasePlayer player, GameTip.Styles style, string message, bool overlay = false, params string[] arguments)
        {
            player.SendConsoleCommand("gametip.showtoast_translated", new object[]
            {
                (int)style,
                message,
                message,
                overlay,
                arguments
            });
            return;
        }

        //Create fire on the boat
        private void BoatFire(Tugboat boat)
        {
            if (boat == null) { return; }
            try
            {
                //Trigger boat death loop
                timer.Once(80, () => { if (boat != null) { TryDie(boat); } });
                AutoNavigation an = boat.gameObject.GetComponent<AutoNavigation>();
                if (an != null) { an.RemoveMe(); }
                boat.gasPedal = 0; //Stop throttle
                Effect.server.Run(C4_explosion, boat.transform.position + boat.transform.rotation * new Vector3(0, 6.5f, 4), Vector3.up, null, true);
                Effect.server.Run(Gibs, boat.transform.position + boat.transform.rotation * new Vector3(0, 6.5f, 4), Vector3.up, null, true);
                CreateFire(300, new Vector3(0, 6f, 4.5f), 5, boat);
                CreateFire(300, new Vector3(0, 2.1f, 3.8f), 60, boat);
                CreateFire(300, new Vector3(0, 2.1f, -1f), 70, boat);
                CreateFire(300, new Vector3(0, 2.1f, -5f), 80, boat);
                if (config.ExtraFire)
                {
                    CreateFire(300, new Vector3(-2.3f, 5.67f, 1.5f), 80, boat);
                    CreateFire(300, new Vector3(-2.66f, 2f, -7.3f), 80, boat);
                    CreateFire(300, new Vector3(2.7f, 2f, -6.8f), 80, boat);
                    CreateFire(300, new Vector3(1.5f, 4.5f, -3.6f), 80, boat);
                    CreateFire(300, new Vector3(0.1f, 7.2f, -0.8f), 80, boat);
                    CreateFire(300, new Vector3(0.2f, 8.6f, 2.3f), 80, boat);
                    CreateFire(300, new Vector3(0f, 2f, 9f), 80, boat);
                }
            }
            catch { }
        }

        //Delayed kill function
        private void TryDie(Tugboat tugboat)
        {
            if (tugboat == null || tugboat.IsDestroyed) { return; }
            if (PlayersNearby(tugboat.transform.position))
            {
                timer.Once(60, () => { TryDie(tugboat); });
                return;
            }
            tugboat.DismountAllPlayers();
            //Kill NPCs and loot
            for (int i = tugboat.children.Count - 1; i >= 0; i--)
            {
                try
                {
                    if (tugboat.children[i] != null && tugboat.children[i] is ScientistNPC && !tugboat.children[i].IsDestroyed)
                    {
                        ActiveNPCs.Remove((tugboat.children[i] as ScientistNPC).net.ID.Value);
                        tugboat.children[i].Kill();
                    }
                }
                catch { }
            }
            if (config.EventHooks) { Interface.Oxide.CallHook("EventTugStopped", tugboat); }
            //Remove data
            try { EventBoats.Remove(tugboat); } catch { }
            try { storedData.EventTugs.Remove(tugboat.net.ID.Value); } catch { }
            //Update save file
            SaveData();
            tugboat.Kill();
        }

        public bool PlayersNearby(Vector3 position, int ExtraDistance = 0)
        {
            return BaseNetworkable.HasCloseConnections(position, config.NearTug + ExtraDistance); //Return result
        }

        private void SetupEvent(Tugboat tugboat)
        {
            tugboat.EnableSaving(false);
            //Force to face next node in path
            int targetNodeIndex = GetClosestNodeToUs(tugboat.transform.position) - 1;
            if (targetNodeIndex < 0) { targetNodeIndex = TerrainMeta.Path.OceanPatrolFar.Count - 1; }
            tugboat.transform.LookAt(TerrainMeta.Path.OceanPatrolFar[targetNodeIndex]);
            //Slightly slow down so players can catch.
            tugboat.engineThrust = tugboat.engineThrust * config.EventSpeed;
            //Give unlimited fuel
            tugboat.fuelPerSec = 0f;
            if (config.PirateBoatHealth != -1) { tugboat.InitializeHealth(config.PirateBoatHealth, config.PirateBoatHealth); }
            //Setup unlimited fuel
            EntityFuelSystem entityFuelSystem = tugboat.GetFuelSystem() as EntityFuelSystem;
            if (entityFuelSystem == null)
            {
                Puts("Null Fuel System On Event Tugboat");
            }
            else
            {
                StorageContainer fuelContainer = entityFuelSystem.GetFuelContainer();
                if (fuelContainer != null)
                {
                    fuelContainer.inventory.AddItem(fuelContainer.allowedItem, 1);
                    fuelContainer.SetFlagLocal(BaseEntity.Flags.Locked, true);
                }
            }
            //Create Suiside timer
            timer.Once(config.EventTimeout, () => { TryDie(tugboat); });
            //Spawn NPCs
            var TugNPCs = CreateNPCScientist(tugboat);
            //Create AutoTurrets
            CreateAutoTurrets(tugboat, TugNPCs);
            //Create Samsites
            CreateSamTurrets(tugboat);
            //Create GunTraps
            CreateGunTraps(tugboat);
            //Spawn Doors
            CreateDoors(tugboat, new Vector3(0, 2, -5.3f), new Vector3(0, 90, 0));
            CreateDoors(tugboat, new Vector3(-2, 5.75f, 1.4f), new Vector3(0, 0, 0));
            CreateDoors(tugboat, new Vector3(2, 5.75f, 1.4f), new Vector3(0, 180, 0));
            NextFrame(() =>
            {
                if (tugboat == null) { return; }
                //Spawn Loot
                StorageContainer loot = CreateStoragefunction(new Vector3(0, 2, 0), tugboat);
                if (loot != null)
                {
                    for (int i = 0; i <= config.LootMulti; i++)
                    {
                        StorageContainer baseEntity = GameManager.server.CreateEntity(config.LootPrefab) as StorageContainer;
                        if (baseEntity != null && loot != null)
                        {
                            baseEntity.SendMessage("SetWasDropped", SendMessageOptions.DontRequireReceiver);
                            baseEntity.Spawn();
                            baseEntity.EnableSaving(false);
                            // Iterate directly over itemList without creating ToList() allocation
                            foreach (Item item in baseEntity.inventory.itemList.ToList())
                            {
                                if (item != null) { item.MoveToContainer(loot.inventory); }
                            }
                            NextFrame(() => { if (baseEntity != null && !baseEntity.IsDestroyed) { baseEntity.Kill(); } });
                        }
                    }
                    loot.gameObject.AddComponent<TugboatRef>().Boat = tugboat;
                }
                EventBoats.Add(tugboat);
                storedData.EventTugs.Add(tugboat.net.ID.Value);
                if (config.EventHooks)
                {
                    Interface.Oxide.CallHook("EventTugStarted", tugboat);
                }
                SaveData();
                tugboat.SetFlagLocal(Tugboat.Flags.On, true);
                tugboat.gasPedal = 1;
                AutoNavigation AN = tugboat.gameObject.AddComponent<AutoNavigation>();
                if (config.DisableBuoyantSleep)
                {
                    var TugBuoyancy = tugboat.GetComponent<Buoyancy>();
                    if (TugBuoyancy != null)
                    {
                        TugBuoyancy.CancelInvoke("CheckSleepState");
                        TugBuoyancy.Invoke(new Action(TugBuoyancy.Wake), 0f); //Force Awake
                    }
                }
                if (config.SpawnAnnounce || config.SpawnAnnounceChat)
                {
                    timer.Once(5, () =>
                    {
                        foreach (BasePlayer player in BasePlayer.activePlayerList)
                        {
                            if (!player.IsSleeping() && permission.UserHasPermission(player.UserIDString, "TugMe.Announce"))
                            {
                                if (config.SpawnAnnounceChat) { MessageIcon(player, message(player, "C6", PositionToGridCoord(tugboat.transform.position))); }
                                if (config.SpawnAnnounce)
                                {
                                    ShowToast(player, GameTip.Styles.Red_Normal, message(player, "C6", PositionToGridCoord(tugboat.transform.position)), false, Array.Empty<string>());
                                }
                            }
                        }
                    });
                }
            });
        }

        //Create a woodbox for the loot
        private StorageContainer CreateStoragefunction(Vector3 offset, Tugboat parent)
        {
            StorageContainer itembox = GameManager.server.CreateEntity(Woodboxprefab) as StorageContainer;
            if (itembox == null) { return null; }
            itembox.Spawn();
            itembox.EnableSaving(false);
            itembox.SetParent(parent, true, false);
            itembox.skinID = 931816387;
            itembox.transform.localPosition = offset;
            itembox.transform.localRotation = Quaternion.Euler(0, 0, 0);
            itembox.inventory.capacity = 30;
            if (config.ApplyCodeLock)
            {
                CodeLock alock = GameManager.server.CreateEntity(Lockprefab) as CodeLock;
                if (alock != null)
                {
                    alock.Spawn();
                    alock.EnableSaving(false);
                    alock.OwnerID = 0;
                    //Unique code per box so one code doesn't unlock every pirate loot box on the server
                    alock.code = UnityEngine.Random.Range(1111, 9999).ToString();
                    alock.SetParent(itembox, itembox.GetSlotAnchorName(BaseEntity.Slot.Lock));
                    itembox.SetSlot(BaseEntity.Slot.Lock, alock);
                    alock.SetFlagLocal(BaseEntity.Flags.Locked, true);
                }
            }
            itembox.SendNetworkUpdateImmediate();
            return itembox;
        }

        //Create doors on event tug
        private void CreateDoors(Tugboat boat, Vector3 position, Vector3 rotation)
        {
            StabilityEntity door = GameManager.server.CreateEntity(Doorprefab, boat.transform.position + boat.transform.rotation * position, boat.transform.rotation * Quaternion.Euler(rotation)) as StabilityEntity;
            if (door == null) { return; }
            door.Spawn();
            door.EnableSaving(false);
            door.SetParent(boat, true, false);
            door.InitializeHealth(config.DoorHealth, config.DoorHealth);
            door.SetFlagLocal(BaseEntity.Flags.Locked, true);
            (door as Door).canTakeLock = false;
            door.grounded = true;
            door.skinID = config.DoorSkinID;
            door.SendNetworkUpdateImmediate();
        }

        //Create gun for event npc
        private void CreateGun(ScientistNPC npc, string ItemName, string Attachment)
        {
            try //Try catch since some times half way though NPC might die and its quicker then adding null check each line
            {
                if (string.IsNullOrEmpty(ItemName)) { return; }
                Item item = ItemManager.CreateByName(ItemName, 1, 0);
                if (item == null) { return; }
                BaseEntity be = item.GetHeldEntity();
                BaseEntity we = item.GetWorldEntity();
                if (be != null) { be.isSpawned = false; }
                if (we != null) { we.isSpawned = false; }
                timer.Once(3f, () =>
                {
                    if (be != null) { be.isSpawned = true; }
                    if (we != null) { we.isSpawned = true; }
                });
                if (!item.MoveToContainer(npc.inventory.containerBelt, -1, false)) { item.Remove(); return; }
                if (be != null && be is BaseProjectile)
                {
                    if (!string.IsNullOrEmpty(Attachment))
                    {
                        Item moditem = ItemManager.CreateByName(Attachment, 1, 0);
                        if (moditem != null && item.contents != null)
                        {
                            BaseEntity bemi = moditem.GetHeldEntity();
                            BaseEntity wemi = moditem.GetWorldEntity();
                            if (bemi != null) { bemi.isSpawned = false; }
                            if (wemi != null) { wemi.isSpawned = false; }
                            timer.Once(3f, () =>
                            {
                                if (bemi != null) { bemi.isSpawned = true; }
                                if (wemi != null) { wemi.isSpawned = true; }
                            });
                            if (!moditem.MoveToContainer(item.contents)) { item.contents.Insert(moditem); }
                        }
                    }
                    timer.Once(5f, () => { if (npc != null && item != null) { npc.UpdateActiveItem(item.uid); } });
                }
            }
            catch { }
        }

        private void DestroyNonConvex(BaseEntity ent)
        {
            foreach (var mesh in ent.GetComponentsInChildren<MeshCollider>())
            {
                UnityEngine.Object.DestroyImmediate(mesh);
            }
        }

        private void AttachToTug(BaseEntity ent, BaseEntity parent, bool canpickup = false)
        {
            if (ent == null || parent == null) { return; }
            DestroyNonConvex(ent);
            ent.Spawn();
            ent.EnableSaving(false);
            ent.SetParent(parent, true, false);
            if (ent as BaseCombatEntity != null) { (ent as BaseCombatEntity).pickup.enabled = canpickup; }
            ent.SendNetworkUpdateImmediate();
        }

        //Create event turrets
        private void CreateAutoTurrets(Tugboat tugboat, Dictionary<ScientistNPC, Vector3> npcs)
        {
            var turretPoints = _plugin.config.NPCAutoTurretPoints;
            var tugTransform = tugboat.transform;
            var basePos = tugTransform.position;
            var baseRot = tugTransform.rotation;

            // Cache NPC IDs once
            List<ulong> authorizedIds = Pool.Get<List<ulong>>();
            if (npcs != null)
            {
                foreach (var npc in npcs.Keys)
                    authorizedIds.Add(npc.userID);
            }

            foreach (TurretPos pos in turretPoints)
            {
                AutoTurret turret = GameManager.server.CreateEntity(
                    Autoturretprefab,
                    basePos + baseRot * pos.Position,
                    baseRot * Quaternion.Euler(pos.Rotation)
                ) as AutoTurret;

                if (turret == null)
                    continue;

                AttachToTug(turret, tugboat);

                if (turret.AttachedWeapon == null)
                {
                    Item item = ItemManager.CreateByName(config.AutoTurretGun, 1);
                    if (item == null || !item.MoveToContainer(turret.inventory, 0, false))
                        item?.Remove();
                    else
                        turret.UpdateAttachedWeapon();
                }

                turret.InitializeHealth(config.AutoTurretHealth, config.AutoTurretHealth);
                FillAmmoTurret(turret);

                var authList = turret.authorizedPlayers;
                for (int i = 0; i < authorizedIds.Count; i++)
                    authList.Add(authorizedIds[i]);

                if (!turret.IsPowered())
                {
                    turret.InitiateStartup();
                    turret.authDirty = true;
                }
            }
            Pool.FreeUnmanaged(ref authorizedIds);
        }

        //Create event sams
        private void CreateSamTurrets(Tugboat tugboat)
        {
            foreach (TurretPos position in _plugin.config.NPCSamsitePoints)
            {
                SamSite sam = GameManager.server.CreateEntity(Samsiteprefab, tugboat.transform.position + tugboat.transform.rotation * position.Position, tugboat.transform.rotation * Quaternion.Euler(position.Rotation)) as SamSite;
                if (sam == null) { continue; }
                AttachToTug(sam, tugboat);
                sam.SetFlagLocal(BaseEntity.Flags.Locked, true);
                sam.InitializeHealth(config.SamsiteHealth, config.SamsiteHealth);
                NextFrame(() =>
                {
                    if (sam == null) { return; }
                    if (sam.ammoType == null) { sam.ammoType = ItemManager.FindItemDefinition("ammo.rocket.sam"); }
                    var ammo = sam.inventory.GetSlot(0);
                    if (ammo == null) { sam.inventory.AddItem(sam.ammoType, config.SamsiteAmmo); }
                });
            }
        }

        //Create event guntraps
        private void CreateGunTraps(Tugboat tugboat)
        {
            foreach (TurretPos position in _plugin.config.NPCGuntrapPoints)
            {
                GunTrap guntrap = GameManager.server.CreateEntity(Guntrapprefab, tugboat.transform.position + tugboat.transform.rotation * position.Position, tugboat.transform.rotation * Quaternion.Euler(position.Rotation)) as GunTrap;
                if (guntrap == null) { continue; }
                AttachToTug(guntrap, tugboat);
                guntrap.SetFlagLocal(BaseEntity.Flags.Locked, true);
                guntrap.InitializeHealth(config.GuntrapHealth, config.GuntrapHealth);
                NextFrame(() =>
                {
                    if (guntrap == null) { return; }
                    if (guntrap.ammoType == null) { guntrap.ammoType = ItemManager.FindItemDefinition("ammo.handmade.shell"); }
                    var ammo = guntrap.inventory.GetSlot(0);
                    if (ammo == null) { guntrap.inventory.AddItem(guntrap.ammoType, config.GuntrapAmmo); }
                });
            }
        }

        //Create event NPC
        private Dictionary<ScientistNPC, Vector3> CreateNPCScientist(Tugboat baseEntity)
        {
            if (baseEntity == null) { return null; }
            try
            {
                Dictionary<ScientistNPC, Vector3> NPCList = new Dictionary<ScientistNPC, Vector3>();
                if (config.UseBetterNPC && NpcSpawn != null)
                {
                    HashSet<string> states = new HashSet<string> { "IdleState", "CombatStationaryState" };
                    var WearItems = new List<NpcWear> { new NpcWear { ShortName = config.NPCAttire, SkinID = 0 } };
                    var BeltItems = new List<NpcBelt>
                {
                                new NpcBelt { ShortName = config.NPCGun, Amount = 1, SkinID = 0, Mods = new List<string> { "weapon.mod.holosight", "weapon.mod.flashlight" }, Ammo = string.Empty },
                                new NpcBelt { ShortName = "syringe.medical", Amount = 10, SkinID = 0, Mods = new List<string>(), Ammo = string.Empty },
                };
                    JObject objectConfig = new JObject
                    {
                        ["Name"] = config.NPCPrefix + RandomUsernames.Get((ulong)UnityEngine.Random.Range(0, 10000000)),
                        ["WearItems"] = new JArray { WearItems.Select(x => new JObject { ["ShortName"] = x.ShortName, ["SkinID"] = x.SkinID }) },
                        ["BeltItems"] = new JArray { BeltItems.Select(x => new JObject { ["ShortName"] = x.ShortName, ["Amount"] = x.Amount, ["SkinID"] = x.SkinID, ["Mods"] = new JArray { x.Mods }, ["Ammo"] = x.Ammo }) },
                        ["Kit"] = config.UseKitsPlugin ? config.NPCAttire : "",
                        ["Health"] = config.NPCHealth,
                        ["RoamRange"] = 0,
                        ["ChaseRange"] = 0,
                        ["SenseRange"] = 100,
                        ["ListenRange"] = 50,
                        ["AttackRangeMultiplier"] = config.NPCAttackRange,
                        ["CheckVisionCone"] = 1,
                        ["VisionCone"] = 1,
                        ["HostileTargetsOnly"] = false,
                        ["DamageScale"] = config.NPCDamageScaler,
                        ["TurretDamageScale"] = 1f,
                        ["AimConeScale"] = 1,
                        ["DisableRadio"] = true,
                        ["CanRunAwayWater"] = false,
                        ["CanSleep"] = false,
                        ["SleepDistance"] = 0,
                        ["Speed"] = 3,
                        ["AreaMask"] = 1,
                        ["AgentTypeID"] = -1372625422,
                        ["HomePosition"] = string.Empty,
                        ["MemoryDuration"] = 60,
                        ["States"] = new JArray { states }
                    };
                    foreach (Vector3 position in _plugin.config.NPCSpawnPoints)
                    {
                        ScientistNPC npc = (ScientistNPC)NpcSpawn.Call("SpawnNpc", baseEntity.transform.position, objectConfig);
                        if (npc != null)
                        {
                            ActiveNPCs.Add(npc.net.ID.Value);
                            NPCList.Add(npc, position);
                            timer.Once(1, () =>
                            {
                                if (npc != null)
                                {
                                    NpcSpawn.Call("SetParentEntity", npc, baseEntity, baseEntity.transform.InverseTransformPoint(position));
                                    npc.SetParent(baseEntity);
                                    npc.transform.localPosition = position;
                                    npc.SendNetworkUpdateImmediate();
                                }
                            });
                        }
                    }
                    return NPCList;
                }

                var prefabName = StringPool.Get(config.AlternativeNPC ? 3763080634 : 1536035819);
                foreach (Vector3 position in _plugin.config.NPCSpawnPoints)
                {
                    try
                    {
                        var go = Instantiate.GameObject(GameManager.server.FindPrefab(prefabName));
                        go.SetActive(false);
                        go.name = prefabName;
                        go.transform.position = new Vector3(0, 3, 0);
                        ScientistNPC npc = go.GetComponent<ScientistNPC>();
                        SceneManager.MoveGameObjectToScene(go, Rust.Server.EntityScene);
                        npc.userID = (ulong)UnityEngine.Random.Range(0, 10000000);
                        npc.UserIDString = npc.userID.ToString();
                        npc.displayName = config.NPCPrefix + RandomUsernames.Get(npc.userID);
                        ScientistBrain brain = npc.GetComponent<ScientistBrain>();
                        if (brain != null) { brain.SenseRange = 100; brain.CheckVisionCone = false; brain.CheckLOS = false; }
                        go.SetActive(true);
                        npc.Spawn();
                        if (npc == null) { continue; }
                        ActiveNPCs.Add(npc.net.ID.Value);
                        NPCList.Add(npc, position);
                        npc.EnableSaving(false);
                        npc.isSpawned = false;
                        npc.InitializeHealth(config.NPCHealth, config.NPCHealth);
                        npc.aimConeScale *= config.NPCAimScaler;
                        npc.damageScale *= config.NPCDamageScaler;
                        npc.transform.position = baseEntity.transform.position;
                        BaseNavigator baseNavigator = npc.GetComponent<BaseNavigator>();
                        if (baseNavigator != null) { baseNavigator.CanUseNavMesh = false; }
                        timer.Once(Core.Random.Range(3, 4), () =>
                        {
                            if (baseEntity != null) { baseEntity.gasPedal = 1; }
                            if (npc != null)
                            {
                                npc.inventory.Strip();
                                if (config.UseKitsPlugin)
                                {
                                    if (Kits == null) { Puts("Kits Plugin Not Loaded!"); }
                                    else
                                    {
                                        timer.Once(5, () =>
                                        {
                                            if (npc != null && npc.net != null && npc.net.group != null && npc?.inventory?.containerWear != null)
                                            {
                                                object success = Kits?.Call("GiveKit", npc, config.NPCAttire);
                                                if (success == null || !(success is bool)) { Puts("Failed to give NPC Kit"); }
                                                timer.Once(5, () =>
                                                {
                                                    if (npc == null) { return; }
                                                    Item projectileItem = null;
                                                    // Iterate a copy since medical tools are moved out of the belt in the loop
                                                    foreach (var item in npc.inventory.containerBelt.itemList.ToArray())
                                                    {
                                                        if (item.GetHeldEntity() is BaseProjectile)
                                                        {
                                                            projectileItem = item;
                                                            break;
                                                        }
                                                        if (item.GetHeldEntity() is MedicalTool)
                                                        {
                                                            item.MoveToContainer(npc.inventory.containerMain);
                                                        }
                                                    }
                                                    // Only search for melee if no projectile found
                                                    if (projectileItem == null)
                                                    {
                                                        foreach (var item in npc.inventory.containerBelt.itemList)
                                                        {
                                                            if (item.GetHeldEntity() is BaseMelee)
                                                            {
                                                                projectileItem = item;
                                                                break;
                                                            }
                                                        }
                                                    }
                                                    if (projectileItem != null)
                                                    {
                                                        npc.UpdateActiveItem(projectileItem.uid);
                                                        npc.inventory.UpdatedVisibleHolsteredItems();
                                                        timer.Once(1f, () => { npc.AttemptReload(); });
                                                    }
                                                    npc.SendNetworkUpdateImmediate();
                                                    npc.inventory.ServerUpdate(0f);
                                                });
                                            }
                                        });
                                    }
                                }
                                else
                                {
                                    Item item = ItemManager.CreateByName(config.NPCAttire, 1, 0);
                                    timer.Once(4, () => //Wait 4 secs for super shit slow servers to have the NPC ready.
                                    {
                                        if (item != null && npc != null && npc.net != null && npc.net.group != null && npc?.inventory?.containerWear != null)
                                        {
                                            npc.inventory.containerWear.onItemAddedRemoved = null;
                                            npc.inventory.containerWear.Insert(item);
                                            CreateGun(npc, config.NPCGun, config.NPCGunAttachment);
                                            npc?.SendNetworkUpdateImmediate();
                                            npc.inventory.ServerUpdate(0f);
                                            item.MarkDirty();
                                        }
                                        else
                                        {
                                            timer.Once(10, () => //Wait 14 secs Final try to kit
                                            {
                                                if (item != null && npc != null && npc.net != null && npc.net.group != null && npc?.inventory?.containerWear != null)
                                                {
                                                    npc.inventory.containerWear.onItemAddedRemoved = null;
                                                    npc.inventory.containerWear.Insert(item);
                                                    CreateGun(npc, config.NPCGun, config.NPCGunAttachment);
                                                    npc?.SendNetworkUpdateImmediate();
                                                    npc.inventory.ServerUpdate(0f);
                                                    item.MarkDirty();
                                                }
                                            });
                                        }
                                    });
                                }
                                npc.SetParent(baseEntity);
                                npc.transform.localPosition = position;
                                npc.isSpawned = true;
                                npc.Brain.AttackRangeMultiplier = config.NPCAttackRange;
                                npc.Invoke(() =>
                                {
                                    if (npc?.net?.ID != null)
                                    {
                                        ActiveNPCs.Remove(npc.net.ID.Value);
                                        if (!npc.IsDestroyed) { npc.Kill(); }
                                    }


                                }, config.EventTimeout + 120);
                            }
                        });
                    }
                    catch { Puts("Failed To Spawn NPC @ " + position); }
                }
                //Check NPCs parented
                timer.Once(60, () =>
                {
                    if (baseEntity != null && NPCList.Count > 0)
                    {
                        foreach (var reparent in NPCList)
                        {
                            if (reparent.Key != null)
                            {
                                if (!reparent.Key.HasParent())
                                {
                                    reparent.Key.SetParent(baseEntity);
                                    reparent.Key.transform.localPosition = reparent.Value;
                                    reparent.Key.SendNetworkUpdateImmediate();
                                }
                            }
                        }
                    }
                });
                return NPCList;
            }
            catch { return null; }
        }

        //Spawn NPCs to buy tug from
        private void CreateNPCs()
        {
            foreach (MonumentInfo info in TerrainMeta.Path.Monuments)
            {
                foreach (VendorPos vp in config.VendorPositions)
                {
                    //Check config block outs
                    if (info.name.Contains("harbor_") && !config.EnableTugSpawners) { break; }
                    if (info.name.Contains("fishing_village") && !config.EnableTugSpawners2) { break; }
                    if (info.name.Contains("ferry_terminal") && !config.EnableTugSpawners3) { break; }
                    //Get positions from config file
                    if (vp.PrefabPath == info.name) { TugDealers.Add(NewTugger(info.transform.position + info.transform.rotation * vp.OffsetPosition, info.transform.rotation * Quaternion.Euler(vp.OffsetRotation)), info.transform.position + info.transform.rotation * vp.OffsetSpawnPoint); }
                }
            }
            //Custom Vendors
            foreach (var t in config.CustomPositions)
            {
                if (t.Position.x == 0 && t.Position.y == 0) { continue; } //Ignore the example
                TugDealers.Add(NewTugger(t.Position, Quaternion.Euler(t.Rotation)), t.SpawnPoint);
            }
            if (config.MarkVendorsOnMap) { UpdateVenderTugIcon(); }
        }

        private void FillAmmoTurret(AutoTurret turret)
        {
            if (turret == null) { return; }
            var attachedWeapon = turret.GetAttachedWeapon();
            if (attachedWeapon == null)
            {
                turret.Invoke(() => FillAmmoTurret(turret), 0.2f);
                return;
            }
            turret.inventory.AddItem(attachedWeapon.primaryMagazine.ammoType, config.AutoTurretAmmo, 0uL);
            attachedWeapon.primaryMagazine.contents = attachedWeapon.primaryMagazine.capacity;
            attachedWeapon.SendNetworkUpdate(BasePlayer.NetworkQueue.Update);
            turret.Invoke(turret.UpdateTotalAmmo, 0.25f);
            turret.dropFloats = false;
            turret.dropsLoot = false;
            turret.inventory.SetFlag(ItemContainer.Flag.NoItemInput, true);
        }

        private void CreateFire(float lifetime, Vector3 FireOffset, float FireDelay, BaseEntity parant)
        {
            timer.Once(FireDelay, () =>
            {
                if (parant == null || parant.IsDestroyed) { return; }
                Effect.server.Run(C4_explosion, parant.transform.position + parant.transform.rotation * FireOffset, Vector3.up, null, true);
                Effect.server.Run(Gibs, parant.transform.position + parant.transform.rotation * FireOffset, Vector3.up, null, true);
                FireBall fireBallSPAWN = GameManager.server.CreateEntity(Oilfire, parant.transform.position) as FireBall;
                if (fireBallSPAWN == null) { return; }
                fireBallSPAWN.Spawn();
                fireBallSPAWN.EnableSaving(false);
                fireBallSPAWN.SetParent(parant, true, true);
                fireBallSPAWN.transform.localPosition = FireOffset;
                fireBallSPAWN.GetComponent<Rigidbody>().isKinematic = false;
                fireBallSPAWN.CancelInvoke(fireBallSPAWN.Extinguish);
                fireBallSPAWN.Invoke(fireBallSPAWN.Extinguish, lifetime);
            });
        }

        private bool WeaponsCoolDown(Tugboat tug, float cooldown)
        {
            if (Shooting.Contains(tug.net.ID.Value)) { return true; }
            Shooting.Add(tug.net.ID.Value);
            timer.Once(cooldown, () => { if (tug != null) { Shooting.Remove(tug.net.ID.Value); } });
            return false;
        }

        private void Take(BasePlayer player, int itemid, int amount)
        {
            var collect = Pool.Get<List<Item>>();
            player.inventory.Take(collect, itemid, amount); // Take only calls RemoveFromContainer
            foreach (Item item in collect)
            {
                item.Remove();
            }
            Pool.FreeUnmanaged(ref collect);
        }

        private int fillPlanter(int amount, PlanterBox planterBox, ItemDefinition itemDefinition)
        {
            int planted = 0;

            if (planterBox.links == null)
                return 0;

            string deployPrefab = itemDefinition.GetComponent<ItemModDeployable>()?.entityPrefab?.resourcePath;

            if (string.IsNullOrEmpty(deployPrefab))
                return 0;

            var tempItem = ItemManager.Create(itemDefinition, amount);

            foreach (EntityLink socketBase in planterBox.links)
            {
                if (planted >= amount)
                    break;

                Socket_Base socket = socketBase.socket;
                if (socket == null || !socket.female || planterBox.IsOccupied(socket.socketName))
                    continue;

                // Check if the socket is physically free
                Vector3 worldPos = planterBox.transform.TransformPoint(socket.worldPosition);
                if (!freeSlot(worldPos))
                    continue;

                GrowableEntity growable = GameManager.server.CreateEntity(deployPrefab, worldPos, Quaternion.identity) as GrowableEntity;
                if (growable == null)
                    continue;

                // Transfer skin
                Item growItem = growable.GetItem();
                if (growItem != null && tempItem.skin != 0)
                    growItem.skin = tempItem.skin;

                // Transfer instance data (for clones)
                var data = tempItem.instanceData;

                growable.SetParent(planterBox, true);
                growable.Spawn();

                if (data != null)
                    growable.ReceiveInstanceData(data);

                growable.transform.localPosition = socket.worldPosition;

                tempItem.UseItem(1);
                planted++;

                Effect.server.Run("assets/prefabs/plants/plantseed.effect.prefab", worldPos);
            }

            if (tempItem.amount > 0) { tempItem.Remove(); } //Dont leave the template item lying around
            planterBox.SendNetworkUpdateImmediate();
            planterBox.SendChildrenNetworkUpdateImmediate();

            return planted;
        }


        public bool freeSlot(Vector3 position)
        {
            List<GrowableEntity> found = Pool.Get<List<GrowableEntity>>();
            Vis.Entities(position, 0.1f, found);

            bool free = found.Count == 0;
            Pool.FreeUnmanaged(ref found);
            return free;
        }

        //FireTorpedo
        private void Tugboat_TorpedoMod(BasePlayer player, Tugboat tug)
        {
            if (tug == null || player == null || !tug.IsDriver(player) || !permission.UserHasPermission(player.UserIDString, "TugMe.Torpedo") || WeaponsCoolDown(tug, config.TugboattorpedoCD)) { return; }
            int torpedoid = ItemManager.FindItemDefinition("submarine.torpedo.straight").itemid;
            if (player.inventory.GetAmount(torpedoid) != 0)
            {
                BaseEntity baseEntity = GameManager.server.CreateEntity("assets/prefabs/ammo/torpedo/torpedostraight.prefab", tug.transform.position + (tug.transform.forward * 12.75f) + tug.transform.up * 1f, default(Quaternion), true);
                if (baseEntity == null) { return; }
                ServerProjectile projectile = baseEntity.GetComponent<ServerProjectile>();
                if (projectile == null) { baseEntity.Kill(); return; }
                Vector3 vector = projectile.initialVelocity + tug.transform.forward * projectile.speed;
                Take(player, torpedoid, 1);
                projectile.InitializeVelocity(vector);
                if (player.IsValid())
                {
                    baseEntity.creatorEntity = player;
                    baseEntity.OwnerID = player.userID;
                }
                baseEntity.Spawn();
                MessageIcon(player, "D4");
                return;
            }
            MessageIcon(player, "D3");
        }

        //Drop Water Mine
        private void Tugboat_WaterMineMod(BasePlayer player, Tugboat tug)
        {
            if (tug == null || player == null || !tug.IsDriver(player) || !permission.UserHasPermission(player.UserIDString, "TugMe.Mine") || WeaponsCoolDown(tug, config.TugboatminesCD)) { return; }
            int InnerTube = ItemManager.FindItemDefinition("innertube").itemid;
            int C4 = ItemManager.FindItemDefinition("explosive.timed").itemid;
            if (player.inventory.GetAmount(InnerTube) == 0)
            {
                MessageIcon(player, "D5");
                return;
            }
            if (player.inventory.GetAmount(C4) == 0)
            {
                MessageIcon(player, "D6");
                return;
            }
            BaseCombatEntity innertube = GameManager.server.CreateEntity("assets/prefabs/misc/summer_dlc/inner_tube/innertube.deployed.prefab", tug.transform.position + (tug.transform.forward * -12.75f) + tug.transform.up * 1f) as BaseCombatEntity;
            RFTimedExplosive explosive = GameManager.server.CreateEntity("assets/prefabs/tools/c4/explosive.timed.deployed.prefab", tug.transform.position + (tug.transform.forward * -12.75f) + tug.transform.up * 1f) as RFTimedExplosive;
            if (innertube == null || explosive == null)
            {
                innertube?.Kill();
                explosive?.Kill();
                return;
            }
            innertube.Spawn();
            explosive.Spawn();
            Take(player, InnerTube, 1);
            Take(player, C4, 1);
            explosive.SetParent(innertube, true, true);
            innertube.pickup.enabled = false;
            innertube.InitializeHealth(config.TugboatminesHealth, config.TugboatminesHealth);
            explosive.SetMotionEnabled(false);
            explosive.SetCollisionEnabled(false);
            explosive.SetFrequency(UnityEngine.Random.Range(1111, 9999)); //Set to given frequency
            explosive.ArmRF(); //trigger Arm SFX and conditions
            explosive.CancelInvoke(new Action(explosive.Explode)); //Block auto exploding
            explosive.SetFlagLocal(BaseEntity.Flags.On, false);
            if (player.IsValid())
            {
                explosive.creatorEntity = player;
                explosive.OwnerID = player.userID;
            }
            NextFrame(() => { innertube.SetFlagLocal(BaseEntity.Flags.On, false); });
            MessageIcon(player, "D7");
            return;
        }

        //Override placement limitation
        private void Tugboat_PlacementMod(BasePlayer player, Tugboat tug, Item held, BaseEntity parent, Vector3 pos)
        {
            if (!permission.UserHasPermission(player.UserIDString, "TugMe.Place"))
                return;

            var itemDef = held?.info;
            if (itemDef == null)
                return;

            int itemId = itemDef.itemid;
            bool isSam = itemId == -1009359066;
            bool isAT = itemId == -2139580305;
            if ((config.MaxSam != -1 && isSam) || (config.MaxAT != -1 && isAT))
            {
                int countSam = 0;
                int countAT = 0;
                var children = parent.children;
                int c = children?.Count ?? 0;
                for (int i = 0; i < c; i++)
                {
                    var child = children[i];
                    if (child == null)
                        continue;


                    switch (child)
                    {
                        case SamSite _:
                            countSam++;
                            break;

                        case AutoTurret _:
                            countAT++;
                            break;
                    }
                }

                if (isSam && config.MaxSam != -1 && countSam >= config.MaxSam)
                {
                    MessageIcon(player, "G4", countSam, config.MaxSam);
                    return;
                }

                if (isAT && config.MaxAT != -1 && countAT >= config.MaxAT)
                {
                    MessageIcon(player, "G4", countAT, config.MaxAT);
                    return;
                }
            }

            float maxDistSqr = config.DistanceCheck * config.DistanceCheck;
            {
                var children = parent.children;
                int c = children?.Count ?? 0;
                for (int i = 0; i < c; i++)
                {
                    var child = children[i];
                    if (child == null || child is BasePlayer)
                        continue;

                    float distSqr = (child.transform.position - pos).sqrMagnitude;
                    if (distSqr <= maxDistSqr)
                    {
                        MessageIcon(player, "C2", child.ShortPrefabName, Mathf.Sqrt(distSqr).ToString("0.0"));
                        return;
                    }
                }
            }

            var mod = itemDef.GetComponent<ItemModDeployable>();
            if (mod == null)
                return;

            BaseEntity ent = GameManager.server.CreateEntity(mod.entityPrefab.resourcePath, pos, parent.transform.rotation, true);
            if (ent == null)
                return;

            ent.transform.position = pos;

            DestroyNonConvex(ent);
            ent.Spawn();

            ent.SetParent(parent, worldPositionStays: true, sendImmediate: false);
            ent.OwnerID = player.userID;

            if (!(ent is Drone))
            {
                var rb = ent.GetComponent<Rigidbody>();
                if (rb != null)
                    rb.isKinematic = true;
            }

            Take(player, itemId, 1);

            ulong parentId = player.GetParentEntity()?.net?.ID.Value ?? 0;
            if (parentId != 0 && storedData.RunningTugs.Contains(parentId))
            {
                IOEntity iOEntity = null;
                if (ent is ElectricOven electric)
                {
                    if (electric.spawnedIo.TryGet(true, out IOEntity ovenent)) { iOEntity = ovenent; }
                }
                else if (ent is IOEntity iO)
                {
                    iOEntity = iO;
                }
                if (iOEntity != null)
                {
                    var list = Facepunch.Pool.Get<List<IOEntity>>();
                    list.Add(iOEntity);
                    Tugboat_TogglePower(list, true, tug.net.ID.Value);
                    Facepunch.Pool.FreeUnmanaged(ref list);
                }
            }
        }

        private void HandlePlayerInput(BasePlayer player, Tugboat tugboat)
        {
            var input = player.serverInput;

            if (input == null) return;

            if (input.IsDown(BUTTON.RELOAD))
            {
                _plugin.Tugboat_TorpedoMod(player, tugboat);
                return;
            }

            if (input.IsDown(BUTTON.DUCK))
            {
                _plugin.Tugboat_WaterMineMod(player, tugboat);
                return;
            }

            if (!input.IsDown(BUTTON.FIRE_PRIMARY) || !_plugin.config.OverrideAllow)
                return;

            TryHandleOverridePlacement(player, tugboat);
        }

        private void TryHandleOverridePlacement(BasePlayer player, Tugboat tugboat)
        {
            var heldItem = player?.GetActiveItem();
            if (heldItem == null || heldItem.info == null || !_plugin.AllowedItems.Contains(heldItem.info.itemid))
                return;
            if (AdminDebug) { Puts(heldItem.info.shortname); }

            var heldEntity = heldItem.GetHeldEntity();
            if (heldEntity == null || heldEntity is BaseProjectile or BaseMelee || !player.CanBuild())
                return;

            if (!Physics.Raycast(player.eyes.HeadRay(), out var hit, 3f))
                return;

            var entity = hit.GetEntity();
            if (entity == null || hit.distance is < 1.2f or > 4f || entity.prefabID != 268742921)
                return;

            var itemId = heldItem.info.itemid;
            var pos = hit.point;

            // Placement logic constraints
            if (itemId == 1142993169 && hit.point.y < player.eyes.position.y) // Ceiling Light
                return;
            if (hit.point.y > player.eyes.position.y && itemId != 634478325 && itemId != 140006625 && itemId != -1009359066)
                return;

            // Y-position adjustments
            pos.y = Mathf.Min(pos.y, tugboat.transform.position.y + 8.621f);
            if (itemId == -1009359066 && (hit.point.y - entity.transform.position.y) > 10f)
                pos.y += 2.2f;

            _plugin.Tugboat_PlacementMod(player, tugboat, heldItem, entity, pos);
        }

        private void HandleIOPower(Tugboat tugboat, List<IOEntity> ioEntities)
        {
            if (!_plugin.config.PowerFromEngine)
                return;

            var id = tugboat.net.ID.Value;
            var running = _plugin.storedData.RunningTugs;

            bool isOn = tugboat.HasFlag(Tugboat.Flags.On);
            bool isRunning = running.Contains(id);

            if (isOn && !isRunning)
            {
                _plugin.Tugboat_TogglePower(ioEntities, true, id);
                running.Add(id);
            }
            else if (!isOn && isRunning)
            {
                _plugin.Tugboat_TogglePower(ioEntities, false, id);
                running.Remove(id);
            }
        }

        private void HandleTrapControl(Tugboat tugboat, List<BaseEntity> traps, List<BasePlayer> players)
        {
            foreach (var trap in traps)
            {
                if (trap.HasFlag(BaseEntity.Flags.Reserved5))
                    continue;

                // Set active (cached)
                trap.SetFlagLocal(BaseEntity.Flags.Reserved5, true);
                trap.Invoke(() => trap.SetFlagLocal(BaseEntity.Flags.Reserved5, false), 0.65f);

                Vector3 trapCheckPos = trap.transform.position + trap.transform.forward * 3f;

                foreach (var player in players)
                {
                    if (player == null || player.IsSleeping() || player.IsDead() || tugboat.IsAuthedForBuilding(player))
                        continue;

                    if (Vector3.Distance(player.transform.position, trapCheckPos) > 2.1f)
                        continue;

                    switch (trap)
                    {
                        case GunTrap gun when gun.UseAmmo():
                            Effect.server.Run(gun.gun_fire_effect.resourcePath, gun,
                                StringPool.Get(gun.muzzlePos.gameObject.name),
                                Vector3.zero, Vector3.zero);
                            for (int i = 0; i < gun.numPellets; i++)
                                gun.FireBullet();
                            break;

                        case FlameTurret flame when !flame.IsTriggered() && flame.HasFuel():
                            flame.SetTriggered(true);
                            Effect.server.Run(flame.triggeredEffect.resourcePath, flame.transform.position, Vector3.up);
                            flame.DoFlame(0.5f);
                            flame.SendNetworkUpdateImmediate();
                            flame.Invoke(() => flame.SetTriggered(false), 5f);
                            break;
                    }
                }
            }
        }

        private void HandleSafeZoneDamage(Tugboat tugboat, List<Door> doors, List<BasePlayer> players)
        {
            var id = tugboat.net.ID.Value;
            if (!_plugin.DamageTimer.TryGetValue(id, out var nextTime))
                _plugin.DamageTimer[id] = 0;

            if (_plugin.DamageTimer[id] > UnityEngine.Time.realtimeSinceStartup)
                return;

            _plugin.DamageTimer[id] = UnityEngine.Time.realtimeSinceStartup + 300f;

            bool inSafeZone = TriggerSafeZone.allSafeZones.Any(zone => Vector3.Distance(zone.transform.position, tugboat.transform.position) < 60f);
            if (!inSafeZone || !tugboat.HasFlag(Tugboat.Flags.On))
                return;

            foreach (Door door in doors.OfType<Door>())
            {
                door.health -= _plugin.config.SafeZoneDamage;
                door.SendNetworkUpdate();
                if (door.health <= 0)
                    door.Kill();
            }

            if (players?.Count > 0)
                _plugin.Tugboat_SafeZoneMessage(tugboat, players);
        }

        //Apply custom tugboat settings
        private void SetupTugSettings(Tugboat tugboat)
        {
            if (config.BlockNative && tugboat.OwnerID == 0)
            {
                if (config.NativeAllowAlreadyAuthed)
                {
                    foreach (BaseEntity child in tugboat.children)
                    {
                        VehiclePrivilege vehiclePrivilege = child as VehiclePrivilege;
                        if (vehiclePrivilege != null && !vehiclePrivilege.AnyAuthed())
                        {
                            try { tugboat.Kill(); } catch { } // Kill Native
                            return;
                        }
                    }
                }
                else
                {
                    if (config.BlockMove)
                    {
                        try
                        {
                            tugboat.transform.position = new Vector3(0, -11, 0);
                            tugboat.rigidBody.Sleep();
                            tugboat.rigidBody.isKinematic = true;
                            tugboat.rigidBody.detectCollisions = false;
                            tugboat.rigidBody.constraints = RigidbodyConstraints.FreezeAll;
                            for (int i = tugboat.children.Count - 1; i >= 0; i--)
                            {
                                if (tugboat.children[i] != null && !tugboat.children[i].IsDestroyed)
                                {
                                    tugboat.children[i].Kill();
                                }
                            }
                        }
                        catch { }
                        tugboat.SendNetworkUpdateImmediate();
                        return; //Its been parked out of the way, dont mod it
                    }
                    else
                    {
                        try { tugboat.Kill(); return; } catch { } // Kill Native
                    }
                }
            }
            if (config.LimitPlayerSpawned && tugboat.OwnerID == 0) { return; }
            if (tugboat.gameObject.GetComponent<TugboatFunction>() == null) { tugboat.gameObject.AddComponent<TugboatFunction>(); }
            if (storedData.AutoNav.Contains(tugboat.net.ID.Value) && tugboat.gameObject.GetComponent<AutoNavigation>() == null)
            { tugboat.gameObject.AddComponent<AutoNavigation>(); }
            EntityFuelSystem entityFuelSystem = tugboat.GetFuelSystem() as EntityFuelSystem;
            StorageContainer fuelContainer = null;
            if (entityFuelSystem == null)
            {
                Puts("Null Fuel System");
            }
            else
            {
                fuelContainer = entityFuelSystem.GetFuelContainer();
            }
            if (config.FuelAmount > 0)
            { //Give Spawn Fuel
                if (fuelContainer != null && fuelContainer.inventory.itemList.Count == 0)
                {
                    fuelContainer.inventory.AddItem(fuelContainer.allowedItem, config.FuelAmount);
                }
            }
            if (config.DisableFuelRequirement)
            {
                tugboat.fuelPerSec = 0f;
                if (fuelContainer != null)
                {
                    fuelContainer.inventory.AddItem(fuelContainer.allowedItem, 1);
                    fuelContainer.SetFlagLocal(BaseEntity.Flags.Locked, true);
                }
            }
            else if (config.FuelPerSec >= 0) { tugboat.fuelPerSec = config.FuelPerSec; }
            if (config.engineThrust != -1) { tugboat.engineThrust = config.engineThrust; }
            if (config.BoatHealth != -1) { tugboat.InitializeHealth(config.BoatHealth, config.BoatHealth); }
            tugboat.globalBroadcast = config.SpawnGlobal;
            if (config.PowerFromEngine)
            {
                if (storedData.RunningTugs.Contains(tugboat.net.ID.Value))
                {
                    var Ioents = Facepunch.Pool.Get<List<IOEntity>>();
                    foreach (var ent in tugboat.children)
                    {
                        if (ent is ElectricOven)
                        {
                            if ((ent as ElectricOven).spawnedIo.TryGet(true, out IOEntity ovenent)) { Ioents.Add(ovenent); }
                        }
                        if (ent is IOEntity)
                        {
                            Ioents.Add(ent as IOEntity);
                        }
                    }
                    Tugboat_TogglePower(Ioents, true, tugboat.net.ID.Value);
                    Facepunch.Pool.FreeUnmanaged(ref Ioents);
                }
            }
            if (config.TowWinch)
            {
                foreach (var be in tugboat.children) //Check if already has Anchor if it does then its a plugin reload
                {
                    if (be is Anchor oldanchor)
                    {
                        if (oldanchor.Lowered) //Its already down so it must of been connected
                        {
                            TowHook th = tugboat.gameObject.GetComponent<TowHook>();
                            if (th == null)
                            {
                                Vector3 TowHook = tugboat.transform.position + tugboat.transform.forward * -13;
                                List<PlayerBoat> list = Pool.Get<List<PlayerBoat>>();
                                Vis.Entities<PlayerBoat>(TowHook, config.HookRadius + 2f, list); //Allow for 2f drift
                                if (list.Count > 0)
                                {
                                    th = tugboat.gameObject.AddComponent<TowHook>();
                                    th.tug = tugboat;
                                    th.boat = list[0];
                                    th.captin = tugboat.OwnerID;
                                    th.anchor = oldanchor;
                                    th.InitializeOffset();
                                }
                                else
                                {
                                    oldanchor.SetFlagLocal(BaseEntity.Flags.Busy, true, false);
                                    oldanchor.SetFlagLocal(BaseEntity.Flags.Reserved13, true, false);
                                    oldanchor.CancelInvoke(new Action(oldanchor.OnFullyRaised));
                                    oldanchor.Invoke(new Action(oldanchor.OnFullyRaised), oldanchor.RaiseDuration);
                                }
                            }
                        }
                        return;
                    }
                }
                timer.Once(5, () =>
                {
                    if (tugboat?.net != null && !storedData.EventTugs.Contains(tugboat.net.ID.Value))
                    {
                        Anchor anchor = null;
                        anchor = GameManager.server.CreateEntity("assets/prefabs/deployable/boatbuilding/anchor/anchor.deployed.prefab", tugboat.transform.position + tugboat.transform.rotation * new Vector3(0, 2.343f, -9.368f), tugboat.transform.rotation * Quaternion.Euler(270, 180, 0), true) as Anchor;
                        if (anchor == null) { return; }
                        anchor.Spawn();
                        anchor.SetParent(tugboat, true, true);
                        anchor.decay = null;
                        anchor.canBeDemolished = false;
                        anchor.pickup.enabled = false;
                        DestroyNonConvex(anchor);
                    }
                });
            }
        }

        private NPCTalking NewTugger(Vector3 position, Quaternion rotation)
        {
            List<NPCTalking> list = Pool.Get<List<NPCTalking>>(); //Pooling to save list memory
            Vis.Entities<NPCTalking>(position, 3, list); //Limit layers to players only and collide to ignore vanished players.
            foreach (NPCTalking t in list) { if (t != null && !t.IsDestroyed) { t.Kill(); } }
            Pool.FreeUnmanaged(ref list); //Free pooling
            NPCTalking player = GameManager.server.CreateEntity("assets/prefabs/npc/bandit/shopkeepers/missionprovider_test.prefab", position, rotation, true) as NPCTalking;
            if (player == null) { return null; }
            player.Spawn();
            player.inventory.Strip();
            player.EnableSaving(false);
            if (config.UseKitsPluginVendor)
            {
                if (Kits == null)
                {
                    Puts("Kits Plugin Not Loaded!");
                    return player;
                }
                else
                {
                    timer.Once(3, () =>
                    {
                        object success = Kits?.Call("GiveKit", player, config.NPCVendorAttire);
                        if (success == null || !(success is bool)) { Puts("Failed to give NPC Kit"); }
                        else
                        {
                            timer.Once(3, () =>
                            {
                                List<Item> list = Pool.Get<List<Item>>();
                                player.inventory.GetAllItems(list);
                                foreach (Item i in list) { i.condition = 999999999999; }
                                Pool.FreeUnmanaged(ref list);
                            });
                        }
                    });
                }
            }
            else
            {
                Item item = ItemManager.CreateByName(config.NPCVendorAttire, 1, 0);
                if (item != null)
                {
                    item.condition = 99999999999999;
                    timer.Once(4, () =>
                    {
                        {
                            if (item != null)
                            {
                                player.inventory.containerWear.Insert(item);
                                player.SendNetworkUpdateImmediate();
                            }
                        }
                    });
                }
            }
            return player;
        }

        private Tugboat NewTugBoat(Vector3 position, Quaternion rotation, ulong OwnerID)
        {
            position.y = 0.1f; //Stops splashing if cargo node below water
            BaseEntity boat = GameManager.server.CreateEntity(Tugboatprefab, position, rotation, true);
            if (boat == null) { return null; }
            boat.OwnerID = OwnerID;
            boat.Spawn();
            return boat as Tugboat;
        }

        void AddWater()
        {
            if (WaterSystem == null || WaterSystem.Count == 0)
                return;

            WaterSystem.RemoveAll(x => x == null || x.IsDestroyed);
            foreach (var bn in WaterSystem)
            {
                var purifier = bn as WaterPurifier;
                if (purifier == null)
                    continue;

                if (!purifier.IsPowered())
                {
                    continue;
                }

                // Add salt water quickly (no need to re-find item definition)
                purifier.inventory.AddItem(SaltWaterDef, 20);

                var parent = purifier.GetParentEntity();
                if (parent == null || parent.children == null)
                    continue;

                // Pre-fetch water slot once
                var storage = purifier.purifiedWaterStorage;
                if (storage == null)
                    continue;

                Item slot0 = storage.inventory.GetSlot(0);
                int available = slot0?.amount ?? 0;

                if (available < 3)
                    continue;

                foreach (var child in parent.children)
                {
                    if (!(child is PlanterBox box))
                        continue;

                    // Double check water each planter use (one take per planter)
                    if (available < 3)
                        break;

                    // Take 3 clean water
                    var collect = Pool.Get<List<Item>>();
                    try
                    {
                        storage.inventory.Take(collect, CleanWaterDef.itemid, 3);
                        foreach (var item in collect)
                            item.Remove();
                    }
                    finally
                    {
                        Pool.FreeUnmanaged(ref collect);
                    }

                    available -= 3;

                    // Apply water to soil
                    float toAdd = Mathf.Min(box.availableWaterCapacity, 3);
                    box.soilSaturation += (int)toAdd;

                    // Update growables
                    var kids = box.children;
                    if (kids == null)
                        continue;

                    for (int i = 0; i < kids.Count; i++)
                    {
                        if (kids[i] is GrowableEntity grow)
                            grow.QueueForQualityUpdate();
                    }
                }
            }
        }

        //Manually give or remove power from IO entity
        private void Tugboat_TogglePower(List<IOEntity> baseEntities, bool on, ulong tugid)
        {
            if (on) { if (!storedData.RunningTugs.Contains(tugid)) { storedData.RunningTugs.Add(tugid); } }
            else { storedData.RunningTugs.Remove(tugid); }
            foreach (var be in baseEntities)
            {
                IOEntity io = be;
                if (io != null)
                {
                    if (!on)
                    {
                        io.SetFlagLocal(BaseEntity.Flags.On, false);
                        io.UpdateHasPower(0, 1);
                        io.SendNetworkUpdateImmediate();
                        if (be is AutoTurret) { (be as AutoTurret).InitiateShutdown(); }
                        else if (io is SamSite) { io.SetFlagLocal(BaseEntity.Flags.Reserved8, false); }
                        else if (config.WaterSystem && be is PoweredWaterPurifier) { WaterSystem.Remove(be as PoweredWaterPurifier); }
                        continue;
                    }
                    io.SetFlagLocal(BaseEntity.Flags.On, true);
                    io.UpdateHasPower(100, 1);
                    io.SendNetworkUpdateImmediate();
                    if (be is AutoTurret) { (be as AutoTurret).InitiateStartup(); (be as AutoTurret).authDirty = true; }
                    else if (io is SamSite) { io.SetFlagLocal(BaseEntity.Flags.Reserved8, true); }
                    else if (config.WaterSystem && be is PoweredWaterPurifier && !WaterSystem.Contains(be)) { WaterSystem.Add(be as PoweredWaterPurifier); }
                }
            }
        }

        private HashSet<int> Tugboat_AllowedItems()
        {
            HashSet<int> list = new HashSet<int>();
            foreach (string item in config.ItemOverride)
            {
                ItemDefinition itemdef = ItemManager.FindItemDefinition(item);
                if (itemdef != null) { list.Add(itemdef.itemid); }
            }
            return list;
        }

        private void Tugboat_SafeZoneMessage(Tugboat tug, List<BasePlayer> players) { foreach (var p in players) { ShowToast(p.ToPlayer(), GameTip.Styles.Red_Normal, message(p.ToPlayer(), "G6"), false); } }
        #endregion

        #region Behaviour
        //Look up for event tugboats for kill hook.
        public class TugboatRef : MonoBehaviour
        {
            public Tugboat Boat;
        }

        //Control latching mini to tugboat
        public class MiniLatch : MonoBehaviour
        {
            public BaseVehicle mini;
            public Tugboat boat;

            public bool Latched;
            public bool landed;

            private ulong LastDriverId =>
                _plugin.storedData.LastMiniDriver.TryGetValue(mini.net.ID.Value, out var id)
                    ? id
                    : 0;

            private BasePlayer LastDriver =>
                LastDriverId == 0 ? null : BasePlayer.FindByID(LastDriverId);

            void Awake()
            {
                mini = GetComponent<BaseVehicle>();
            }

            public void UnLatch(float delay)
            {
                landed = false;

                _plugin.timer.Once(delay, () =>
                {
                    if (mini == null || !mini.HasDriver() || !Latched)
                        return;

                    if (LastDriverId == 0 || !_plugin.permission.UserHasPermission(mini.GetDriver().UserIDString, "TugMe.Latch"))
                        return;

                    var player = LastDriver;

                    if (_plugin.config.LatchAuth)
                    {
                        if (IsAuthed(LastDriverId))
                        {
                            Unlock();
                            if (player != null) _plugin.MessageIcon(player, "D9");
                        }
                        else if (player != null)
                        {
                            _plugin.MessageIcon(player, "F3");
                        }

                        return;
                    }

                    Unlock();
                    if (player != null) _plugin.MessageIcon(player, "D9");
                });
            }

            private void Unlock()
            {
                mini.SetParent(null, true, true);

                var offsetY = _plugin.config.MoveBackHeli ? 3f : 0.5f;
                mini.transform.position += new Vector3(0, offsetY, 0);
                mini.rigidBody.SetActive(true);
                if (_plugin.config.LockNoDecay)
                {
                    var heli = mini as PlayerHelicopter;
                    if (heli != null)
                    {
                        mini.InvokeRandomized(
                            new Action(heli.DecayTick),
                            UnityEngine.Random.Range(30f, 60f),
                            60f,
                            6f
                        );
                    }
                }

                Latched = false;
            }

            public void Lock()
            {
                var q = mini.transform.rotation;
                var boatRot = boat.transform.rotation;
                q.x = boatRot.x;
                q.z = boatRot.z;
                mini.rigidBody.SetActive(false);
                if (_plugin.config.MoveBackHeli)
                {
                    q.y = boatRot.y;
                    mini.transform.rotation = q;
                    mini.SetParent(boat, false, false);
                    mini.transform.position = boat.transform.position + (boat.transform.up * 3) + (boat.transform.forward * -12);
                    mini.transform.LookAt(boat.transform.position, Vector3.up);
                }
                else
                {
                    mini.transform.rotation = q;
                    mini.SetParent(boat, true, true);
                }
                if (_plugin.config.LockNoDecay)
                {
                    var heli = mini as PlayerHelicopter;
                    if (heli != null)
                        mini.CancelInvoke(heli.DecayTick);
                }

                mini.SendNetworkUpdateImmediate();
                Latched = true;
            }

            private bool IsAuthed(ulong playerId)
            {
                if (boat?.children == null) { return true; }
                foreach (var child in boat.children)
                {
                    if (child is VehiclePrivilege vp) { return vp.IsAuthed(playerId); }
                }
                return true;
            }

            void OnCollisionStay(Collision collision)
            {
                if (collision == null || Latched || landed)
                    return;

                var tb = collision.gameObject?.ToBaseEntity() as Tugboat;
                if (tb == null || mini.HasDriver())
                    return;

                if (LastDriverId == 0 || !_plugin.permission.UserHasPermission(LastDriverId.ToString(), "TugMe.Latch"))
                    return;

                boat = tb;
                var player = LastDriver;
                landed = true;

                if (_plugin.config.LatchAuth)
                {
                    if (IsAuthed(LastDriverId))
                    {
                        Lock();
                        if (player != null) _plugin.MessageIcon(player, "D8");
                    }
                    else if (player != null)
                    {
                        _plugin.MessageIcon(player, "F3");
                    }

                    return;
                }

                Lock();
                if (player != null) _plugin.MessageIcon(player, "D8");
            }

            public void RemoveMe()
            {
                if (Latched && _plugin.config.UnlockUnload)
                    Unlock();

                Destroy(this);
            }
        }

        //Control towing
        public class TowHook : MonoBehaviour
        {
            public ulong captin;
            public PlayerBoat boat;
            public Tugboat tug;
            public Anchor anchor;
            public bool InTransfereZone;
            public bool attached = false;
            private Vector3 localOffset;
            private Quaternion localRotation;
            bool tick = false;
            byte delay = 0;

            public void RemoveMe()
            {
                if (InTransfereZone && attached) { return; }
                attached = false;
                if (boat != null && boat.net != null)
                {
                    _plugin.Towed.Remove(boat.net.ID.Value);
                    _plugin.Connected.Remove(boat.net.ID.Value);
                }
                BasePlayer player = BasePlayer.Find(captin.ToString());
                if (player != null) { player.ChatMessage(_plugin.message(player, "J0")); }
                if (anchor != null)
                {
                    anchor.SetFlagLocal(BaseEntity.Flags.Busy, true, false);
                    anchor.SetFlagLocal(BaseEntity.Flags.Reserved13, true, false);
                    anchor.CancelInvoke(new Action(anchor.OnFullyRaised));
                    anchor.Invoke(new Action(anchor.OnFullyRaised), anchor.RaiseDuration);
                }
                Destroy(this);
            }

            public void InitializeOffset()
            {
                if (tug == null || boat == null) return;
                if (!_plugin.Towed.ContainsKey(boat.net.ID.Value))
                {
                    _plugin.Towed.Add(boat.net.ID.Value, this);
                    _plugin.Connected.Add(boat.net.ID.Value);
                }
                float minTowDistance = 99;
                foreach (var bbb in boat.BoatBuildingBlocks.Cached)
                {
                    var d = Vector3.Distance(bbb.transform.position, tug.transform.position);
                    if (d < minTowDistance)
                    {
                        minTowDistance = d;
                        if (minTowDistance < 13) { break; }
                    }
                }
                Vector3 directionToBoat = (boat.transform.position - tug.transform.position).normalized;
                Vector3 bufferedWorldPos = boat.transform.position;
                if (minTowDistance <= 12.9f) { bufferedWorldPos = boat.transform.position + (directionToBoat * 0.75f); }
                localOffset = tug.transform.InverseTransformPoint(bufferedWorldPos);
                localRotation = Quaternion.Inverse(tug.transform.rotation) * boat.transform.rotation;
                attached = true;
            }

            private void FixedUpdate()
            {
                if (!attached || tug == null || boat == null) return;
                if (_plugin.config.TowHalfTick)
                {
                    tick = !tick;
                    if (!tick) return;
                }

                if (delay <= 0)
                {
                    delay = 128;
                    InTransfereZone = DeepSeaManager.IsInsidePortal(tug, DeepSeaPortal.PortalModeEnum.Entrance) ||
                                      DeepSeaManager.IsInsidePortal(tug, DeepSeaPortal.PortalModeEnum.Exit) ||
                                      DeepSeaManager.IsInsidePortal(boat, DeepSeaPortal.PortalModeEnum.Entrance) ||
                                      DeepSeaManager.IsInsidePortal(boat, DeepSeaPortal.PortalModeEnum.Exit);
                }
                delay--;

                // Cache transforms
                var tugT = tug.transform;
                var boatT = boat.transform;
                Vector3 targetWorldPos = tugT.TransformPoint(localOffset);
                Vector3 newPos = Vector3.Lerp(boatT.position, new Vector3(targetWorldPos.x, boatT.position.y, targetWorldPos.z), Time.fixedDeltaTime * 10f);
                if (newPos.y > _plugin.config.HookMaxHeight)
                {
                    RemoveMe();
                    return;
                }
                boat.rigidBody.MovePosition(newPos);
                Quaternion targetRot = tugT.rotation * localRotation;
                Quaternion slerpedRot = Quaternion.Slerp(boatT.rotation, targetRot, Time.fixedDeltaTime * 5f);
                boat.rigidBody.MoveRotation(slerpedRot);
                if (Vector3.Angle(boatT.up, Vector3.up) > _plugin.config.HookMaxAngle)
                {
                    RemoveMe();
                    return;
                }
            }
        }

        //Control tugboat to follow cargopath
        public class AutoNavigation : MonoBehaviour
        {
            private Tugboat boat;
            public BasePlayer captin = null;
            private float delay = 0;
            private int targetNodeIndex = -1;
            private bool HalfTick = false;

            void Awake()
            {
                boat = GetComponent<Tugboat>();
                if (boat == null) { Destroy(this); return; } //No player so remove
                delay = UnityEngine.Time.time + _plugin.config.AutoNavDelay; //start delay
                if (DeepSeaManager.IsInsideDeepSea(boat.transform.position)) { Destroy(this); } //Dont allow in deepsea
            }

            public void RemoveMe() => Destroy(this); //Remove componant function

            void FixedUpdate()
            {
                try
                {
                    if (delay > UnityEngine.Time.time) { return; } //Cancel since not waited long enough
                    if (boat == null || boat.IsDestroyed || boat.IsBroken()) { Destroy(this); return; }
                    delay = UnityEngine.Time.time + _plugin.config.AutoNavTick; //Set up next adjustment
                    if (TerrainMeta.Path.OceanPatrolFar == null || TerrainMeta.Path.OceanPatrolFar.Count == 0 || targetNodeIndex == -2) { return; } //Do nothing
                    else if (targetNodeIndex == -1) { targetNodeIndex = _plugin.GetClosestNodeToUs(base.transform.position); } //Get a node

                    // Cache boat transform for reuse
                    Transform boatTransform = boat.transform;
                    Vector3 boatPos = boatTransform.position;

                    if (_plugin.config.JunkPileKill) //Kill junkpiles if colliding with them
                    {
                        // Cache scan radius to avoid repeated config access
                        float scanRadius = _plugin.config.JunkPileScan;

                        //Junkpile
                        List<JunkPileWater> list = Pool.Get<List<JunkPileWater>>(); //Pooling to save list memory
                        Vis.Entities<JunkPileWater>(boatPos + boatTransform.forward * 12f, scanRadius, list);
                        {
                            foreach (JunkPileWater pile in list)
                            {
                                pile.SpawnGroupsEmpty();
                                pile.Kill();
                            }
                        }
                        Pool.FreeUnmanaged(ref list); //Free pooling
                        List<DiveSiteBuoy> list2 = Pool.Get<List<DiveSiteBuoy>>();
                        Vis.Entities<DiveSiteBuoy>(boatPos, scanRadius, list2);
                        foreach (DiveSiteBuoy divesite in list2) { divesite.Kill(); }
                        Pool.FreeUnmanaged(ref list2); //Free pooling
                    }

                    // Cache EventBoats check result
                    bool isEventBoat = _plugin.EventBoats.Contains(boat);

                    if (!HalfTick && isEventBoat) //Event boat force throttle on.
                    {
                        HalfTick = true;
                        boat.SetFlagLocal(Tugboat.Flags.On, true);
                        if (_plugin.config.NavPushBack)
                        {
                            // Pre-calculate all height check positions
                            Vector3 forwardPos = boatPos + boatTransform.forward * 30f;
                            Vector3 rightPos = boatPos + boatTransform.right * 25f;
                            Vector3 leftPos = boatPos + boatTransform.right * -25f;

                            //Check Infront
                            if (TerrainMeta.HeightMap.GetHeight(forwardPos) > -3f) { boat.rigidBody.AddForce(boatTransform.forward * -8000000f, ForceMode.Force); }
                            //Check Right Side
                            if (TerrainMeta.HeightMap.GetHeight(rightPos) > -3f) { boat.rigidBody.AddForce(boatTransform.right * -8000000f, ForceMode.Force); }
                            //Check Left Side
                            if (TerrainMeta.HeightMap.GetHeight(leftPos) > -3f) { boat.rigidBody.AddForce(boatTransform.right * 8000000f, ForceMode.Force); }
                        }
                        if (captin == null)
                        {
                            bool throttle = false;
                            //Check for NPCs
                            List<ScientistNPC> list = Pool.Get<List<ScientistNPC>>();
                            Vis.Entities<ScientistNPC>(boatPos, 15f, list);
                            foreach (ScientistNPC npc in list) //Check vis list
                            {
                                if (_plugin.ActiveNPCs.Contains(npc.net.ID.Value))
                                {
                                    throttle = true;
                                    break;
                                }
                            }
                            Pool.FreeUnmanaged(ref list);
                            if (throttle) { boat.gasPedal = 1; }
                            else { boat.gasPedal = 0; }
                        }
                    }
                    else
                    {
                        HalfTick = false;
                    }

                    Vector3 vector = TerrainMeta.Path.OceanPatrolFar[targetNodeIndex]; //Get position from cargopath
                    float clampedX = vector.x;
                    if (clampedX > 3990f) { clampedX = 3990f; }
                    else if (clampedX < -3990f) { clampedX = -3990f; }
                    float clampedZ = vector.z;
                    if (clampedZ > 3990f) clampedZ = 3990f;
                    else if (clampedZ < -3990f) clampedZ = -3990f;
                    Vector3 clampedVector = new Vector3(clampedX, vector.y, clampedZ);
                    Vector3 normalized = (clampedVector - boatPos).normalized; //Get direction
                    boat.steering = Vector3.Dot(boatTransform.right, normalized) * -1f; //Adjust to that direction
                    float nodeDistanceSq = _plugin.config.NodeDistance * _plugin.config.NodeDistance;
                    if ((boatPos - clampedVector).sqrMagnitude < nodeDistanceSq) //Goto next node
                    {
                        targetNodeIndex--;
                        if (targetNodeIndex <= 0) { targetNodeIndex = TerrainMeta.Path.OceanPatrolFar.Count - 1; }
                    }
                }
                catch { Destroy(this); }
            }
            void OnDestroy() { try { if (captin != null && !captin.IsSleeping() && captin.IsAlive()) { _plugin.MessageIcon(captin, "B3"); } } catch { } }
        }

        //Control tugboat to follow cargopath
        public class TugboatFunction : MonoBehaviour
        {
            private Tugboat __instance;
            byte delaytick = 8;
            void Awake()
            {
                __instance = GetComponent<Tugboat>();
                if (__instance == null || __instance.IsBroken()) { Destroy(this); }
            }

            void OnDestroy() { }

            void FixedUpdate()
            {
                // --- Slow down update rate ---
                if (__instance == null) { return; }
                if (delaytick > 0)
                {
                    delaytick--;
                    return;
                }
                delaytick = _plugin.config.TugboatTick;

                // --- DRIVER BYPASS ---
                if (_plugin.config.DisableDriverCheck || __instance.OwnerID == 1234)
                {
                    __instance.lastHadDriverTime = Time.time;
                }

                // --- AUTO FLIP ---
                if (_plugin.config.AutoFlipper && __instance.IsFlipped())
                {
                    var up = __instance.transform.up;
                    __instance.transform.up = -up;
                    __instance.SendNetworkUpdateImmediate();
                }

                var players = Pool.Get<List<BasePlayer>>();
                var io = Pool.Get<List<IOEntity>>();
                var traps = Pool.Get<List<BaseEntity>>();
                var doors = Pool.Get<List<Door>>();

                try
                {
                    // --- BROKEN STATE HANDLING ---
                    if (__instance.IsBroken())
                    {
                        ulong id = __instance.net.ID.Value;
                        if (!_plugin.SinkingTugs.Contains(id))
                        {
                            var children2 = __instance.children;
                            for (int i = children2.Count - 1; i >= 0; i--)
                            {
                                var c = children2[i];
                                if (c is AutoTurret at && at != null)
                                {
                                    at.SetFlagLocal(BaseEntity.Flags.On, false);
                                    at.SetFlagLocal(BaseEntity.Flags.Reserved8, false);
                                    at.UpdateHasPower(0, 1);
                                    at.InitiateShutdown();
                                    at.SetTarget(null);
                                    at.SendNetworkUpdateImmediate();
                                }
                            }
                        }
                        _plugin.SinkingTugs.Add(id);
                        __instance.GetComponent<AutoNavigation>()?.RemoveMe();
                        RemoveMe();
                        return;
                    }

                    // --- SCAN CHILDREN (fast, no AddRange) ---
                    var children = __instance.children;
                    int count = children.Count;

                    for (int i = 0; i < count; i++)
                    {
                        var child = children[i];
                        if (child == null || child.IsDestroyed || child is ScientistNPC)
                            continue;

                        switch (child)
                        {
                            case Door d:
                                doors.Add(d);
                                break;

                            case GunTrap or FlameTurret:
                                traps.Add(child);
                                break;

                            case IOEntity ioEnt:
                                io.Add(ioEnt);
                                break;

                            case BasePlayer p when p.userID.IsSteamId():
                                _plugin.HandlePlayerInput(p, __instance);
                                players.Add(p);
                                break;

                            case BaseVehicleMountPoint mountPoint:
                                BasePlayer player = mountPoint._mounted;
                                if (player != null)
                                {
                                    _plugin.HandlePlayerInput(player, __instance);
                                    if (!players.Contains(player)) { players.Add(player); }
                                }
                                break;

                            case ElectricOven oven:
                                if (oven.spawnedIo.TryGet(true, out IOEntity ovenIO))
                                    io.Add(ovenIO);
                                break;
                        }
                    }

                    // --- HANDLE IO ---
                    if (io.Count > 0)
                        _plugin.HandleIOPower(__instance, io);

                    // --- TRAPS ---
                    if (_plugin.config.AuthFromBoat && traps.Count > 0 && players.Count > 0)
                        _plugin.HandleTrapControl(__instance, traps, players);

                    // --- SAFE ZONE DAMAGE ---
                    if (_plugin.config.SafeZoneDamage > 0 && __instance.OwnerID != 1234)
                        _plugin.HandleSafeZoneDamage(__instance, doors, players);
                }
                catch
                {
                    // swallow but don’t break FixedUpdate
                }
                finally
                {
                    Pool.FreeUnmanaged(ref players);
                    Pool.FreeUnmanaged(ref io);
                    Pool.FreeUnmanaged(ref traps);
                    Pool.FreeUnmanaged(ref doors);
                }
            }

            public void RemoveMe() => Destroy(this); //Remove componant function
        }
        #endregion
    }
}