FREE BoatHonk : 1.0.3 1.0.3

using System.Collections.Generic;
using Oxide.Core;
using Oxide.Core.Plugins;
using UnityEngine;

namespace Oxide.Plugins
{
    [Info("BoatHonk", "PwndwithStyleTV", "1.0.3")]
    [Description("Plays different horn sounds for different boats when the driver presses the action key (LMB) and toggles the closest authorized door.")]

    public class BoatHonk : RustPlugin
    {
        private const string PluginName = "boathonk";
        private const string PermissionName = "honk.use";
        private const float DoorOpenRange = 10f; // Adjust the range as needed
        private Dictionary<BaseEntity, float> lastToggleTimes = new Dictionary<BaseEntity, float>();

        private const float GarageDoorCooldown = 4f;
        private const float HingedDoorCooldown = 1f;

        private Dictionary<string, string> boatHornSounds = new Dictionary<string, string>
        {
            { "tugboat", "assets/content/nexus/ferry/effects/nexus-ferry-departure-horn.prefab" },
            { "rowboat", "assets/content/nexus/ferry/effects/nexus-ferry-departure-horn.prefab" },
            { "rhib", "assets/content/nexus/ferry/effects/nexus-ferry-departure-horn.prefab" }
        };

        void Init()
        {
            permission.RegisterPermission($"{PluginName}.{PermissionName}", this);
        }

        void OnPlayerInput(BasePlayer player, InputState input)
        {
            if (player == null || input == null)
                return;

            if (player.isMounted)
            {
                BaseVehicle mountedVehicle = player.GetMountedVehicle() as BaseVehicle;
                if (mountedVehicle != null)
                {
                    // Check if the player is the driver of the vehicle
                    if (IsDriver(player, mountedVehicle) && input.WasJustPressed(BUTTON.FIRE_PRIMARY))
                    {
                        string prefabName = mountedVehicle.ShortPrefabName;
                        if (boatHornSounds.ContainsKey(prefabName))
                        {
                            if (permission.UserHasPermission(player.UserIDString, $"{PluginName}.{PermissionName}"))
                            {
                                Vector3 soundPosition = mountedVehicle.transform.position; // Play sound at the position of the mounted vehicle
                                EmitSound(soundPosition, boatHornSounds[prefabName]);
                                ToggleClosestAuthorizedDoor(player);
                            }
                        }
                    }
                }
            }
        }

        private bool IsDriver(BasePlayer player, BaseVehicle vehicle)
        {
            if (vehicle == null)
                return false;

            var mountable = player.GetMounted();
            if (mountable == null)
                return false;

            // Check if the mount points list is not empty and the player is in the first seat (driver seat)
            return vehicle.mountPoints.Count > 0 && vehicle.mountPoints[0].mountable == mountable;
        }

        private void ToggleClosestAuthorizedDoor(BasePlayer player)
        {
            RaycastHit[] hits = Physics.SphereCastAll(player.transform.position, DoorOpenRange, Vector3.up, DoorOpenRange, LayerMask.GetMask("Construction"));
            BaseEntity closestDoor = null;
            float closestDistance = DoorOpenRange;

            foreach (var hit in hits)
            {
                BaseEntity entity = hit.GetEntity();
                if (entity != null && IsDoor(entity) && IsAuthorized(player, entity))
                {
                    float distance = Vector3.Distance(player.transform.position, entity.transform.position);
                    if (distance < closestDistance)
                    {
                        closestDistance = distance;
                        closestDoor = entity;
                    }
                }
            }

            if (closestDoor != null)
            {
                if (CanToggleDoor(closestDoor))
                {
                    Door door = closestDoor as Door;
                    if (door != null)
                    {
                        door.SetOpen(!door.IsOpen());
                        UpdateLastToggleTime(closestDoor);
                    }
                    else
                    {
                        var garageDoor = closestDoor as AnimatedBuildingBlock;
                        if (garageDoor != null)
                        {
                            using (var setFlags = garageDoor.StartSetFlags(BaseEntity.FlagsUpdateMode.SendNetworkUpdate_Flags))
                            {
                                setFlags.Set(BaseEntity.Flags.Open, !garageDoor.HasFlag(BaseEntity.Flags.Open));
                            }
                            UpdateLastToggleTime(closestDoor);
                        }
                    }
                }
            }
        }

        private bool CanToggleDoor(BaseEntity door)
        {
            float currentTime = Time.time;
            float lastToggleTime;
            if (lastToggleTimes.TryGetValue(door, out lastToggleTime))
            {
                float cooldown = GetDoorCooldown(door);
                if (currentTime - lastToggleTime < cooldown)
                {
                    return false;
                }
            }
            return true;
        }

        private void UpdateLastToggleTime(BaseEntity door)
        {
            lastToggleTimes[door] = Time.time;
        }

        private float GetDoorCooldown(BaseEntity door)
        {
            string prefabName = door.ShortPrefabName;
            if (prefabName.Contains("door.garage") || prefabName.Contains("wall.frame.garagedoor"))
            {
                return GarageDoorCooldown;
            }
            else if (prefabName.Contains("door.hinged") || prefabName.Contains("door.double.hinged") || prefabName.Contains("door.sheet") || prefabName.Contains("door.armored"))
            {
                return HingedDoorCooldown;
            }
            return 0f;
        }

        private bool IsAuthorized(BasePlayer player, BaseEntity entity)
        {
            var buildingPrivilege = entity.GetBuildingPrivilege();
            return buildingPrivilege != null && buildingPrivilege.IsAuthed(player);
        }

        private bool IsDoor(BaseEntity entity)
        {
            return entity.ShortPrefabName.Contains("door.hinged") ||
                   entity.ShortPrefabName.Contains("door.double.hinged") ||
                   entity.ShortPrefabName.Contains("door.garage") ||
                   entity.ShortPrefabName.Contains("door.sheet") ||
                   entity.ShortPrefabName.Contains("door.armored") ||
                   entity.ShortPrefabName.Contains("wall.frame.garagedoor") ||
                   entity.ShortPrefabName.Contains("gates.external.high.wood") ||
                   entity.ShortPrefabName.Contains("gates.external.high.stone");
        }

        private void EmitSound(Vector3 position, string soundPath)
        {
            Effect.server.Run(soundPath, position);
        }
    }
}