C#:
// Все права принадлежат дискорд сообществу https://discord.gg/VgNHPpNrz6
using UnityEngine;
using CompanionServer.Handlers;
using Newtonsoft.Json;
using Oxide.Core.Libraries.Covalence;
using System.Collections.Generic;
using Oxide.Core.Plugins;
namespace Oxide.Plugins
{
[Info("TC Map Markers", "1AK1", "1.1.2")]
[Description("Shows custom map markers for all cupboards on the server.")]
internal class TcMapMarkers : CovalencePlugin
{
[PluginReference] private Plugin Friends, Clans;
#region Vars
private int count;
private const string permUse = "tcmapmarkers.use";
public List<MapMarkerGenericRadius> TCMarkers = new List<MapMarkerGenericRadius>();
#endregion Vars
#region Config
private ConfigData configData;
private class ConfigData
{
[JsonProperty(PropertyName = "Map Marker Options")]
public MapMarkerOptions MapMarker { get; set; }
[JsonProperty(PropertyName = "Owned Markers Options")]
public OwnedMarkersOptions OwnedMarkers { get; set; }
[JsonProperty(PropertyName = "Other Markers Options")]
public OtherMarkersOptions OtherMarkers { get; set; }
[JsonProperty(PropertyName = "Teams Markers Options")]
public TeamsMarkersOptions TeamsMarkers { get; set; }
[JsonProperty(PropertyName = "Friends Markers Options")]
public FriendsMarkersOptions FriendsMarkers { get; set; }
[JsonProperty(PropertyName = "Clans Markers Options")]
public ClansMarkersOptions ClansMarkers { get; set; }
public class MapMarkerOptions
{
[JsonProperty(PropertyName = "Prefab Path")]
public string PREFAB_MARKER { get; set; }
[JsonProperty(PropertyName = "Show to all? (true/false)")]
public bool visibleToAll { get; set; }
[JsonProperty(PropertyName = "Enable Teams? (true/false)")]
public bool TeamsUse { get; set; }
[JsonProperty(PropertyName = "Enable Friends? (true/false)")]
public bool FriendsUse { get; set; }
[JsonProperty(PropertyName = "Enable Clans? (true/false)")]
public bool ClansUse { get; set; }
}
public class OwnedMarkersOptions
{
[JsonProperty(PropertyName = "Color1 (hex)")]
public string OwnedColor1 { get; set; }
[JsonProperty(PropertyName = "Color2 (hex)")]
public string OwnedColor2 { get; set; }
[JsonProperty(PropertyName = "Alpha")]
public float OwnedAlpha { get; set; }
[JsonProperty(PropertyName = "Radius")]
public float OwnedRadius { get; set; }
}
public class OtherMarkersOptions
{
[JsonProperty(PropertyName = "Color1 (hex)")]
public string OtherColor1 { get; set; }
[JsonProperty(PropertyName = "Color2 (hex)")]
public string OtherColor2 { get; set; }
[JsonProperty(PropertyName = "Alpha")]
public float OtherAlpha { get; set; }
[JsonProperty(PropertyName = "Radius")]
public float OtherRadius { get; set; }
}
public class TeamsMarkersOptions
{
[JsonProperty(PropertyName = "Color1 (hex)")]
public string TeamsColor1 { get; set; }
[JsonProperty(PropertyName = "Color2 (hex)")]
public string TeamsColor2 { get; set; }
[JsonProperty(PropertyName = "Alpha")]
public float TeamsAlpha { get; set; }
[JsonProperty(PropertyName = "Radius")]
public float TeamsRadius { get; set; }
}
public class FriendsMarkersOptions
{
[JsonProperty(PropertyName = "Color1 (hex)")]
public string FriendsColor1 { get; set; }
[JsonProperty(PropertyName = "Color2 (hex)")]
public string FriendsColor2 { get; set; }
[JsonProperty(PropertyName = "Alpha")]
public float FriendsAlpha { get; set; }
[JsonProperty(PropertyName = "Radius")]
public float FriendsRadius { get; set; }
}
public class ClansMarkersOptions
{
[JsonProperty(PropertyName = "Color1 (hex)")]
public string ClansColor1 { get; set; }
[JsonProperty(PropertyName = "Color2 (hex)")]
public string ClansColor2 { get; set; }
[JsonProperty(PropertyName = "Alpha")]
public float ClansAlpha { get; set; }
[JsonProperty(PropertyName = "Radius")]
public float ClansRadius { get; set; }
}
}
protected override void LoadConfig()
{
base.LoadConfig();
configData = Config.ReadObject<ConfigData>();
Config.WriteObject(configData, true);
}
protected override void LoadDefaultConfig() => configData = GetBaseConfig();
private ConfigData GetBaseConfig()
{
return new ConfigData
{
MapMarker = new ConfigData.MapMarkerOptions
{
PREFAB_MARKER = "assets/prefabs/tools/map/genericradiusmarker.prefab",
visibleToAll = true,
FriendsUse = true
},
OwnedMarkers = new ConfigData.OwnedMarkersOptions
{
OwnedColor1 = "#00FF00",
OwnedColor2 = "#00FF00",
OwnedAlpha = 1f,
OwnedRadius = 0.08f
},
OtherMarkers = new ConfigData.OtherMarkersOptions
{
OtherColor1 = "#FF0000",
OtherColor2 = "#FF0000",
OtherAlpha = 1f,
OtherRadius = 0.08f
},
TeamsMarkers = new ConfigData.TeamsMarkersOptions
{
TeamsColor1 = "#0000FF",
TeamsColor2 = "#0000FF",
TeamsAlpha = 1f,
TeamsRadius = 0.08f
},
FriendsMarkers = new ConfigData.FriendsMarkersOptions
{
FriendsColor1 = "#0000FF",
FriendsColor2 = "#0000FF",
FriendsAlpha = 1f,
FriendsRadius = 0.08f
},
ClansMarkers = new ConfigData.ClansMarkersOptions
{
ClansColor1 = "#0000FF",
ClansColor2 = "#0000FF",
ClansAlpha = 1f,
ClansRadius = 0.08f
}
};
}
protected override void SaveConfig() => Config.WriteObject(configData, true);
#endregion Config
#region Localization
protected override void LoadDefaultMessages()
{
lang.RegisterMessages(new Dictionary<string, string>
{
["NotAllowed"] = "You are not allowed to use the '{0}' command",
["PlayersOnly"] = "Command '{0}' can only be used by players",
["UsageTcMap"] = "Usage {0} <clear|update|showtoall|>",
["MarkersRemoved"] = "All map markers has been removed",
["MarkersSpawned"] = "Spawned {0} map markers",
["MarkersVisibleAdmin"] = "Map marker are now visible to ADMINS only",
["MarkersVisibleAll"] = "Map marker are now visible to ALL"
}, this);
}
#endregion Localization
#region Oxide Hooks
private void Init()
{
AddCovalenceCommand("tcmap", "CommandTCMap");
permission.RegisterPermission(permUse, this);
}
private void OnServerInitialized(bool initial)
{
LoadMapMarkers();
}
private void Unload()
{
RemoveMapMarkers();
}
private void OnPlayerConnected(BasePlayer player)
{
if (player.IsReceivingSnapshot)
{
timer.Once(1f, () => OnPlayerConnected(player));
return;
}
foreach (var marker in TCMarkers)
{
if(marker != null)
{
marker.SendUpdate();
}
}
}
object CanNetworkTo(MapMarkerGenericRadius marker, BasePlayer player)
{
if (!TCMarkers.Contains(marker)) return null;
if (!configData.MapMarker.visibleToAll && !player.IPlayer.HasPermission(permUse)) return false;
switch (marker.name)
{
case "owner":
if (marker.OwnerID == player.userID) return null;
else return false;
case "team":
if(configData.MapMarker.TeamsUse && player.Team != null && player.Team.members.Contains(marker.OwnerID)) return null;
else return false;
case "friend":
if(configData.MapMarker.FriendsUse && Friends != null && Friends.IsLoaded && Friends.Call<bool>("AreFriends", player.userID, marker.OwnerID)) return null;
else return false;
case "clan":
if (configData.MapMarker.ClansUse && Clans != null && Clans.IsLoaded && Clans.Call<bool>("IsClanMember", player.UserIDString, marker.OwnerID.ToString())) return null;
else return false;
default:
return null;
}
}
private void OnEntityBuilt(Planner plan, GameObject go)
{
var cupboard = go.GetComponent<BuildingPrivlidge>();
if (cupboard == null)
{
return;
}
CreateMapMarker(cupboard, "other", configData.OtherMarkers.OtherColor1, configData.OtherMarkers.OtherColor2, configData.OtherMarkers.OtherAlpha, configData.OtherMarkers.OtherRadius);
if (configData.MapMarker.TeamsUse)
{
CreateMapMarker(cupboard, "team", configData.TeamsMarkers.TeamsColor1, configData.TeamsMarkers.TeamsColor2, configData.TeamsMarkers.TeamsAlpha, configData.TeamsMarkers.TeamsRadius);
}
if (configData.MapMarker.FriendsUse && Friends != null && Friends.IsLoaded)
{
CreateMapMarker(cupboard, "friend", configData.FriendsMarkers.FriendsColor1, configData.FriendsMarkers.FriendsColor2, configData.FriendsMarkers.FriendsAlpha, configData.FriendsMarkers.FriendsRadius);
}
if (configData.MapMarker.ClansUse && Clans != null && Clans.IsLoaded)
{
CreateMapMarker(cupboard, "clan", configData.ClansMarkers.ClansColor1, configData.ClansMarkers.ClansColor2, configData.ClansMarkers.ClansAlpha, configData.ClansMarkers.ClansRadius);
}
CreateMapMarker(cupboard, "owner", configData.OwnedMarkers.OwnedColor1, configData.OwnedMarkers.OwnedColor2, configData.OwnedMarkers.OwnedAlpha, configData.OwnedMarkers.OwnedRadius);
}
private void OnEntityKill(BaseNetworkable entity)
{
if (!(entity is BuildingPrivlidge)) return;
var cupboard = (BuildingPrivlidge)entity;
foreach (var marker in TCMarkers)
{
if(marker == null)
{
return;
}
if (marker.transform.position == cupboard.transform.position)
{
marker.Kill();
marker.SendUpdate();
}
}
}
#endregion Oxide Hooks
#region Core
private void LoadMapMarkers()
{
count = 0;
foreach (var entity in BaseNetworkable.serverEntities)
{
if ((entity is BuildingPrivlidge))
{
var cupboard = (BuildingPrivlidge)entity;
CreateMapMarker(cupboard, "other", configData.OtherMarkers.OtherColor1, configData.OtherMarkers.OtherColor2, configData.OtherMarkers.OtherAlpha, configData.OtherMarkers.OtherRadius);
if (configData.MapMarker.TeamsUse)
{
CreateMapMarker(cupboard, "team", configData.TeamsMarkers.TeamsColor1, configData.TeamsMarkers.TeamsColor2, configData.TeamsMarkers.TeamsAlpha, configData.TeamsMarkers.TeamsRadius);
}
if (configData.MapMarker.FriendsUse && Friends != null && Friends.IsLoaded)
{
CreateMapMarker(cupboard, "friend", configData.FriendsMarkers.FriendsColor1, configData.FriendsMarkers.FriendsColor2, configData.FriendsMarkers.FriendsAlpha, configData.FriendsMarkers.FriendsRadius);
}
if (configData.MapMarker.ClansUse && Clans != null && Clans.IsLoaded)
{
CreateMapMarker(cupboard, "clan", configData.ClansMarkers.ClansColor1, configData.ClansMarkers.ClansColor2, configData.ClansMarkers.ClansAlpha, configData.ClansMarkers.ClansRadius);
}
CreateMapMarker(cupboard, "owner", configData.OwnedMarkers.OwnedColor1, configData.OwnedMarkers.OwnedColor2, configData.OwnedMarkers.OwnedAlpha, configData.OwnedMarkers.OwnedRadius);
count++;
}
}
Puts(Lang("MarkersSpawned", null, count.ToString()));
}
private void RemoveMapMarkers()
{
foreach (var marker in TCMarkers)
{
if (marker != null)
{
marker.Kill();
marker.SendUpdate();
}
}
TCMarkers.Clear();
}
private void CreateMapMarker(BuildingPrivlidge cupboard, string type, string color1, string color2, float alpha, float radius)
{
MapMarkerGenericRadius mapMarker = GameManager.server.CreateEntity(configData.MapMarker.PREFAB_MARKER, cupboard.transform.position) as MapMarkerGenericRadius;
if (mapMarker != null)
{
mapMarker.alpha = alpha;
if (!ColorUtility.TryParseHtmlString(color1, out mapMarker.color1))
{
mapMarker.color1 = Color.black;
PrintError($"Invalid map marker color1: {color1}");
}
if (!ColorUtility.TryParseHtmlString(color2, out mapMarker.color2))
{
mapMarker.color2 = Color.white;
PrintError($"Invalid map marker color2: {color2}");
}
mapMarker.name = type;
mapMarker.radius = radius;
mapMarker.OwnerID = cupboard.OwnerID;
TCMarkers.Add(mapMarker);
mapMarker.Spawn();
mapMarker.SendUpdate();
}
}
#endregion Core
#region Commands
private void CommandTCMap(IPlayer player, string command, string[] args)
{
if (player.IsServer)
{
Message(player, "PlayersOnly", command);
return;
}
if (!player.HasPermission(permUse))
{
Message(player, "NotAllowed", command);
return;
}
if (args == null || args.Length <= 0)
{
Message(player, "UsageTcMap", command);
return;
}
switch (args[0].ToLower())
{
case "help":
Message(player, "UsageTcMap", command);
return;
case "clear":
RemoveMapMarkers();
Message(player, "MarkersRemoved");
return;
case "update":
RemoveMapMarkers();
LoadMapMarkers();
Message(player, "MarkersSpawned", count.ToString());
return;
case "showtoall":
if (configData.MapMarker.visibleToAll)
{
configData.MapMarker.visibleToAll = false;
RemoveMapMarkers();
LoadMapMarkers();
Message(player, "MarkersVisibleAdmin");
}
else
{
configData.MapMarker.visibleToAll = true;
RemoveMapMarkers();
LoadMapMarkers();
Message(player, "MarkersVisibleAll");
}
return;
}
}
#endregion Commands
#region Helpers
private void Message(IPlayer player, string key, params object[] args)
{
if (player.IsConnected)
{
player.Message(Lang(key, player.Id, args));
}
}
private string Lang(string key, string id = null, params object[] args)
{
return string.Format(lang.GetMessage(key, this, id), args);
}
#endregion Helpers
}
}