3353 lines
161 KiB
C#
3353 lines
161 KiB
C#
using System;
|
||
using System.Collections;
|
||
using System.Collections.Generic;
|
||
using System.Linq;
|
||
using System.Text;
|
||
using Facepunch;
|
||
using Newtonsoft.Json;
|
||
using Newtonsoft.Json.Linq;
|
||
using Oxide.Core;
|
||
using Oxide.Core.Plugins;
|
||
using Oxide.Game.Rust;
|
||
using Oxide.Game.Rust.Cui;
|
||
using UnityEngine;
|
||
|
||
namespace Oxide.Plugins
|
||
{
|
||
[Info("Remover Tool", "Reneb/Fuji/Arainrr", "4.3.24", ResourceId = 651)]
|
||
[Description("Building and entity removal tool")]
|
||
public class RemoverTool : RustPlugin
|
||
{
|
||
#region Fields
|
||
|
||
[PluginReference] private readonly Plugin Friends, ServerRewards, Clans, Economics, ImageLibrary, BuildingOwners;
|
||
private const string PERMISSION_ALL = "removertool.all";
|
||
private const string PERMISSION_ADMIN = "removertool.admin";
|
||
private const string PERMISSION_NORMAL = "removertool.normal";
|
||
private const string PERMISSION_TARGET = "removertool.target";
|
||
private const string PERMISSION_EXTERNAL = "removertool.external";
|
||
private const string PERMISSION_OVERRIDE = "removertool.override";
|
||
private const string PERMISSION_STRUCTURE = "removertool.structure";
|
||
private const string PREFAB_ITEM_DROP = "assets/prefabs/misc/item drop/item_drop.prefab";
|
||
|
||
private const int LAYER_ALL = 1 << 0 | 1 << 8 | 1 << 21;
|
||
private const int LAYER_TARGET = ~(1 << 2 | 1 << 3 | 1 << 4 | 1 << 10 | 1 << 18 | 1 << 28 | 1 << 29);
|
||
|
||
private static RemoverTool rt;
|
||
private static BUTTON removeButton;
|
||
private static RemoveMode removeMode;
|
||
private bool removeOverride;
|
||
private Coroutine removeAllCoroutine;
|
||
private Coroutine removeStructureCoroutine;
|
||
private Coroutine removeExternalCoroutine;
|
||
private Coroutine removePlayerEntityCoroutine;
|
||
|
||
private Hash<uint, float> entitySpawnedTimes;
|
||
private Hash<ulong, float> lastBlockedPlayers;
|
||
private Hash<uint, float> lastAttackedBuildings;
|
||
private readonly Hash<ulong, float> cooldownTimes = new Hash<ulong, float>();
|
||
|
||
//Reduce boxing
|
||
private static readonly object True = true, False = false, Null = null;
|
||
|
||
private enum RemoveMode
|
||
{
|
||
None,
|
||
NoHeld,
|
||
MeleeHit,
|
||
SpecificTool
|
||
}
|
||
|
||
private enum RemoveType
|
||
{
|
||
None,
|
||
All,
|
||
Admin,
|
||
Normal,
|
||
External,
|
||
Structure
|
||
}
|
||
|
||
private enum RemovePlayerEntityType
|
||
{
|
||
All,
|
||
Cupboard,
|
||
Building,
|
||
}
|
||
|
||
#endregion Fields
|
||
|
||
#region Oxide Hooks
|
||
|
||
private void Init()
|
||
{
|
||
rt = this;
|
||
LoadDefaultMessages();
|
||
permission.RegisterPermission(PERMISSION_ALL, this);
|
||
permission.RegisterPermission(PERMISSION_ADMIN, this);
|
||
permission.RegisterPermission(PERMISSION_NORMAL, this);
|
||
permission.RegisterPermission(PERMISSION_TARGET, this);
|
||
permission.RegisterPermission(PERMISSION_OVERRIDE, this);
|
||
permission.RegisterPermission(PERMISSION_EXTERNAL, this);
|
||
permission.RegisterPermission(PERMISSION_STRUCTURE, this);
|
||
foreach (var perm in configData.permS.Keys)
|
||
{
|
||
if (!permission.PermissionExists(perm, this))
|
||
permission.RegisterPermission(perm, this);
|
||
}
|
||
cmd.AddChatCommand(configData.chatS.command, this, nameof(CmdRemove));
|
||
Unsubscribe(nameof(OnEntityDeath));
|
||
Unsubscribe(nameof(OnHammerHit));
|
||
Unsubscribe(nameof(OnEntitySpawned));
|
||
Unsubscribe(nameof(OnEntityKill));
|
||
Unsubscribe(nameof(OnPlayerAttack));
|
||
Unsubscribe(nameof(OnActiveItemChanged));
|
||
}
|
||
|
||
private void OnServerInitialized()
|
||
{
|
||
Initialize();
|
||
UpdateConfig();
|
||
removeMode = RemoveMode.None;
|
||
if (configData.removerModeS.noHeldMode) removeMode = RemoveMode.NoHeld;
|
||
if (configData.removerModeS.meleeHitMode) removeMode = RemoveMode.MeleeHit;
|
||
if (configData.removerModeS.specificToolMode) removeMode = RemoveMode.SpecificTool;
|
||
if (removeMode == RemoveMode.MeleeHit)
|
||
{
|
||
BaseMelee beseMelee;
|
||
ItemDefinition itemDefinition;
|
||
if (string.IsNullOrEmpty(configData.removerModeS.meleeHitItemShortname) ||
|
||
(itemDefinition = ItemManager.FindItemDefinition(configData.removerModeS.meleeHitItemShortname)) == null ||
|
||
(beseMelee = itemDefinition.GetComponent<ItemModEntity>()?.entityPrefab.Get()?.GetComponent<BaseMelee>()) == null)
|
||
{
|
||
PrintError($"{configData.removerModeS.meleeHitItemShortname} is not an item shortname for a melee tool");
|
||
removeMode = RemoveMode.None;
|
||
}
|
||
else
|
||
{
|
||
Subscribe(beseMelee is Hammer ? nameof(OnHammerHit) : nameof(OnPlayerAttack));
|
||
}
|
||
}
|
||
|
||
if (configData.raidS.enabled)
|
||
{
|
||
lastBlockedPlayers = new Hash<ulong, float>();
|
||
lastAttackedBuildings = new Hash<uint, float>();
|
||
Subscribe(nameof(OnEntityDeath));
|
||
}
|
||
if (configData.globalS.entityTimeLimit)
|
||
{
|
||
entitySpawnedTimes = new Hash<uint, float>();
|
||
Subscribe(nameof(OnEntitySpawned));
|
||
Subscribe(nameof(OnEntityKill));
|
||
}
|
||
|
||
if (removeMode == RemoveMode.MeleeHit && configData.removerModeS.meleeHitEnableInHand ||
|
||
removeMode == RemoveMode.SpecificTool && configData.removerModeS.specificToolEnableInHand)
|
||
{
|
||
Subscribe(nameof(OnActiveItemChanged));
|
||
}
|
||
|
||
if (!Enum.TryParse(configData.globalS.removeButton, true, out removeButton))
|
||
{
|
||
PrintError($"{configData.globalS.removeButton} is an invalid button. The remove button has been changed to 'FIRE_PRIMARY'.");
|
||
removeButton = BUTTON.FIRE_PRIMARY;
|
||
configData.globalS.removeButton = removeButton.ToString();
|
||
SaveConfig();
|
||
}
|
||
if (ImageLibrary != null)
|
||
{
|
||
foreach (var image in configData.imageUrls)
|
||
{
|
||
AddImageToLibrary(image.Value, image.Key);
|
||
}
|
||
if (configData.removerModeS.showCrosshair)
|
||
{
|
||
AddImageToLibrary(configData.removerModeS.crosshairImageUrl, UINAME_CROSSHAIR);
|
||
}
|
||
}
|
||
}
|
||
|
||
private void Unload()
|
||
{
|
||
if (removeAllCoroutine != null) ServerMgr.Instance.StopCoroutine(removeAllCoroutine);
|
||
if (removeStructureCoroutine != null) ServerMgr.Instance.StopCoroutine(removeStructureCoroutine);
|
||
if (removeExternalCoroutine != null) ServerMgr.Instance.StopCoroutine(removeExternalCoroutine);
|
||
if (removePlayerEntityCoroutine != null) ServerMgr.Instance.StopCoroutine(removePlayerEntityCoroutine);
|
||
foreach (var player in BasePlayer.activePlayerList)
|
||
{
|
||
DestroyAllUI(player);
|
||
player.GetComponent<ToolRemover>()?.DisableTool();
|
||
}
|
||
rt = null;
|
||
configData = null;
|
||
}
|
||
|
||
private void OnEntityDeath(BuildingBlock buildingBlock, HitInfo info)
|
||
{
|
||
if (buildingBlock == null || info == null) return;
|
||
var attacker = info.InitiatorPlayer;
|
||
if (attacker != null && attacker.userID.IsSteamId() && HasAccess(attacker, buildingBlock)) return;
|
||
BlockRemove(buildingBlock);
|
||
}
|
||
|
||
private void OnEntitySpawned(BaseEntity entity)
|
||
{
|
||
if (entity == null || entity.net == null) return;
|
||
if (!CanEntityBeSaved(entity)) return;
|
||
entitySpawnedTimes[entity.net.ID] = Time.realtimeSinceStartup;
|
||
}
|
||
|
||
private void OnEntityKill(BaseEntity entity)
|
||
{
|
||
if (entity == null || entity.net == null) return;
|
||
entitySpawnedTimes.Remove(entity.net.ID);
|
||
}
|
||
|
||
private object OnPlayerAttack(BasePlayer player, HitInfo info) => OnHammerHit(player, info);
|
||
|
||
private object OnHammerHit(BasePlayer player, HitInfo info)
|
||
{
|
||
if (player == null || info.HitEntity == null) return Null;
|
||
var toolRemover = player.GetComponent<ToolRemover>();
|
||
if (toolRemover == null) return Null;
|
||
if (!IsMeleeTool(player)) return Null;
|
||
toolRemover.hitEntity = info.HitEntity;
|
||
return False;
|
||
}
|
||
|
||
private void OnActiveItemChanged(BasePlayer player, Item oldItem, Item newItem)
|
||
{
|
||
if (newItem == null) return;
|
||
if (player == null || !player.userID.IsSteamId()) return;
|
||
if (IsToolRemover(player)) return;
|
||
if (removeMode == RemoveMode.MeleeHit && IsMeleeTool(newItem))
|
||
{
|
||
ToggleRemove(player, RemoveType.Normal);
|
||
return;
|
||
}
|
||
if (removeMode == RemoveMode.SpecificTool && IsSpecificTool(newItem))
|
||
{
|
||
ToggleRemove(player, RemoveType.Normal);
|
||
return;
|
||
}
|
||
}
|
||
|
||
#endregion Oxide Hooks
|
||
|
||
#region Initializing
|
||
|
||
private readonly Dictionary<string, string> shorPrefabNameToDeployable = new Dictionary<string, string>();
|
||
private readonly Dictionary<string, string> prefabNameToStructure = new Dictionary<string, string>();
|
||
private readonly Dictionary<string, int> itemShortNameToItemID = new Dictionary<string, int>();
|
||
private readonly HashSet<Construction> constructions = new HashSet<Construction>();
|
||
|
||
private void Initialize()
|
||
{
|
||
foreach (var itemDefinition in ItemManager.GetItemDefinitions())
|
||
{
|
||
if (!itemShortNameToItemID.ContainsKey(itemDefinition.shortname))
|
||
itemShortNameToItemID.Add(itemDefinition.shortname, itemDefinition.itemid);
|
||
var deployablePrefab = itemDefinition.GetComponent<ItemModDeployable>()?.entityPrefab?.resourcePath;
|
||
if (string.IsNullOrEmpty(deployablePrefab)) continue;
|
||
var shortPrefabName = GameManager.server.FindPrefab(deployablePrefab)?.GetComponent<BaseEntity>()?.ShortPrefabName;
|
||
if (!string.IsNullOrEmpty(shortPrefabName) && !shorPrefabNameToDeployable.ContainsKey(shortPrefabName))
|
||
shorPrefabNameToDeployable.Add(shortPrefabName, itemDefinition.shortname);
|
||
}
|
||
foreach (var entry in PrefabAttribute.server.prefabs)
|
||
{
|
||
var construction = entry.Value.Find<Construction>().FirstOrDefault();
|
||
if (construction != null && construction.deployable == null && !string.IsNullOrEmpty(construction.info.name.english))
|
||
{
|
||
constructions.Add(construction);
|
||
if (!prefabNameToStructure.ContainsKey(construction.fullName))
|
||
prefabNameToStructure.Add(construction.fullName, construction.info.name.english);
|
||
}
|
||
}
|
||
}
|
||
|
||
#endregion Initializing
|
||
|
||
#region Methods
|
||
|
||
private static string GetRemoveTypeName(RemoveType removeType) => configData.removeTypeS[removeType].displayName;
|
||
|
||
private static void DropItemContainer(ItemContainer itemContainer, Vector3 position, Quaternion rotation) => itemContainer?.Drop(PREFAB_ITEM_DROP, position, rotation);
|
||
|
||
private static bool IsExternalWall(StabilityEntity stabilityEntity) => stabilityEntity.ShortPrefabName.Contains("external");
|
||
|
||
private static bool IsRemovableEntity(BaseEntity entity) => rt.shorPrefabNameToDeployable.ContainsKey(entity.ShortPrefabName) || rt.prefabNameToStructure.ContainsKey(entity.PrefabName) || configData.removeS.entityS.ContainsKey(entity.ShortPrefabName);
|
||
|
||
private static bool CanEntityBeDisplayed(BaseEntity entity, BasePlayer player)
|
||
{
|
||
if (entity == null) return false;
|
||
var stash = entity as StashContainer;
|
||
return stash == null || !stash.IsHidden() || stash.PlayerInRange(player);
|
||
}
|
||
|
||
private static bool CanEntityBeSaved(BaseEntity entity)
|
||
{
|
||
if (entity is BuildingBlock) return true;
|
||
ConfigData.RemoveSettings.EntityS entityS;
|
||
return configData.removeS.entityS.TryGetValue(entity.ShortPrefabName, out entityS) && entityS.enabled;
|
||
}
|
||
|
||
private static bool HasEntityEnabled(BaseEntity entity)
|
||
{
|
||
bool valid;
|
||
var buildingBlock = entity as BuildingBlock;
|
||
if (buildingBlock != null && configData.removeS.validConstruction.TryGetValue(buildingBlock.grade, out valid) && valid) return true;
|
||
ConfigData.RemoveSettings.EntityS entityS;
|
||
return configData.removeS.entityS.TryGetValue(entity.ShortPrefabName, out entityS) && entityS.enabled;
|
||
}
|
||
|
||
private static string GetEntityName(BaseEntity entity)
|
||
{
|
||
string entityName;
|
||
if (rt.shorPrefabNameToDeployable.TryGetValue(entity.ShortPrefabName, out entityName)) return entityName;
|
||
if (rt.prefabNameToStructure.TryGetValue(entity.PrefabName, out entityName)) return entityName;
|
||
if (configData.removeS.entityS.ContainsKey(entity.ShortPrefabName)) return entity.ShortPrefabName;
|
||
return string.Empty;
|
||
}
|
||
|
||
private static string GetEntityImage(string name)
|
||
{
|
||
if (configData.imageUrls.ContainsKey(name))
|
||
return GetImageFromLibrary(name);
|
||
if (rt.itemShortNameToItemID.ContainsKey(name))
|
||
return GetImageFromLibrary(name);
|
||
return string.Empty;
|
||
}
|
||
|
||
private static string GetItemImage(string shortname)
|
||
{
|
||
switch (shortname.ToLower())
|
||
{
|
||
case "economics": return GetImageFromLibrary("Economics");
|
||
case "serverrewards": return GetImageFromLibrary("ServerRewards");
|
||
}
|
||
return GetEntityImage(shortname);
|
||
}
|
||
|
||
private static string GetDisplayName(string name)
|
||
{
|
||
var shortPrefabName = rt.shorPrefabNameToDeployable.FirstOrDefault(x => x.Value == name).Key;
|
||
if (string.IsNullOrEmpty(shortPrefabName)) shortPrefabName = name;
|
||
|
||
ConfigData.RemoveSettings.EntityS entityS;
|
||
if (configData.removeS.entityS.TryGetValue(shortPrefabName, out entityS)) return entityS.displayName;
|
||
ConfigData.RemoveSettings.BuildingBlocksS buildingBlockS;
|
||
if (configData.removeS.buildingBlockS.TryGetValue(name, out buildingBlockS)) return buildingBlockS.displayName;
|
||
if (configData.displayNames.TryGetValue(name, out shortPrefabName)) return shortPrefabName;
|
||
var itemDefinition = ItemManager.FindItemDefinition(name);
|
||
if (itemDefinition != null)
|
||
{
|
||
configData.displayNames.Add(name, itemDefinition.displayName.english);
|
||
name = itemDefinition.displayName.english;
|
||
}
|
||
else configData.displayNames.Add(name, name);
|
||
rt.SaveConfig();
|
||
return name;
|
||
}
|
||
|
||
private static ConfigData.PermSettings GetPermissionS(BasePlayer player)
|
||
{
|
||
int priority = 0;
|
||
ConfigData.PermSettings permissionS = null;
|
||
foreach (var entry in configData.permS)
|
||
{
|
||
if (entry.Value.priority >= priority && rt.permission.UserHasPermission(player.UserIDString, entry.Key))
|
||
{
|
||
priority = entry.Value.priority;
|
||
permissionS = entry.Value;
|
||
}
|
||
}
|
||
return permissionS ?? new ConfigData.PermSettings();
|
||
}
|
||
|
||
private static Vector2 GetAnchor(string anchor)
|
||
{
|
||
var array = anchor.Split(' ');
|
||
return new Vector2(float.Parse(array[0]), float.Parse(array[1]));
|
||
}
|
||
|
||
private static bool AddImageToLibrary(string url, string shortname, ulong skin = 0) => (bool)rt.ImageLibrary.Call("AddImage", url, shortname.ToLower(), skin);
|
||
|
||
private static string GetImageFromLibrary(string shortname, ulong skin = 0, bool returnUrl = false) => string.IsNullOrEmpty(shortname) ? string.Empty : (string)rt.ImageLibrary.Call("GetImage", shortname.ToLower(), skin, returnUrl);
|
||
|
||
#endregion Methods
|
||
|
||
#region UI
|
||
|
||
private class UI
|
||
{
|
||
public static CuiElementContainer CreateElementContainer(string parent, string panelName, string backgroundColor, string anchorMin, string anchorMax, string offsetMin = "", string offsetMax = "", bool cursor = false)
|
||
{
|
||
return new CuiElementContainer()
|
||
{
|
||
{
|
||
new CuiPanel
|
||
{
|
||
Image = { Color = backgroundColor },
|
||
RectTransform = { AnchorMin = anchorMin, AnchorMax = anchorMax ,OffsetMin = offsetMin,OffsetMax = offsetMax},
|
||
CursorEnabled = cursor
|
||
}, parent, panelName
|
||
}
|
||
};
|
||
}
|
||
|
||
public static void CreatePanel(ref CuiElementContainer container, string panelName, string backgroundColor, string anchorMin, string anchorMax, bool cursor = false)
|
||
{
|
||
container.Add(new CuiPanel
|
||
{
|
||
Image = { Color = backgroundColor },
|
||
RectTransform = { AnchorMin = anchorMin, AnchorMax = anchorMax },
|
||
CursorEnabled = cursor
|
||
}, panelName, CuiHelper.GetGuid());
|
||
}
|
||
|
||
public static void CreateLabel(ref CuiElementContainer container, string panelName, string textColor, string text, int fontSize, string anchorMin, string anchorMax, TextAnchor align = TextAnchor.MiddleCenter, float fadeIn = 0f)
|
||
{
|
||
container.Add(new CuiLabel
|
||
{
|
||
Text = { Color = textColor, FontSize = fontSize, Align = align, Text = text, FadeIn = fadeIn },
|
||
RectTransform = { AnchorMin = anchorMin, AnchorMax = anchorMax }
|
||
}, panelName, CuiHelper.GetGuid());
|
||
}
|
||
|
||
public static void CreateImage(ref CuiElementContainer container, string panelName, string image, string anchorMin, string anchorMax, string color = "1 1 1 1")
|
||
{
|
||
container.Add(new CuiElement
|
||
{
|
||
Name = CuiHelper.GetGuid(),
|
||
Parent = panelName,
|
||
Components =
|
||
{
|
||
new CuiRawImageComponent { Sprite = "assets/content/textures/generic/fulltransparent.tga", Color = color, Png = image},
|
||
new CuiRectTransformComponent { AnchorMin = anchorMin, AnchorMax = anchorMax }
|
||
}
|
||
});
|
||
}
|
||
}
|
||
|
||
private const string UINAME_MAIN = "RemoverToolUI_Main";
|
||
private const string UINAME_TIMELEFT = "RemoverToolUI_TimeLeft";
|
||
private const string UINAME_ENTITY = "RemoverToolUI_Entity";
|
||
private const string UINAME_PRICE = "RemoverToolUI_Price";
|
||
private const string UINAME_REFUND = "RemoverToolUI_Refund";
|
||
private const string UINAME_AUTH = "RemoverToolUI_Auth";
|
||
private const string UINAME_CROSSHAIR = "RemoverToolUI_Crosshair";
|
||
|
||
private static void CreateCrosshairUI(BasePlayer player)
|
||
{
|
||
if (rt.ImageLibrary == null) return;
|
||
var image = GetImageFromLibrary(UINAME_CROSSHAIR);
|
||
if (string.IsNullOrEmpty(image)) return;
|
||
var container = UI.CreateElementContainer("Hud", UINAME_CROSSHAIR, "0 0 0 0", configData.removerModeS.crosshairAnchorMin, configData.removerModeS.crosshairAnchorMax, configData.removerModeS.crosshairOffsetMin, configData.removerModeS.crosshairOffsetMax);
|
||
UI.CreateImage(ref container, UINAME_CROSSHAIR, image, "0 0", "1 1", configData.removerModeS.crosshairColor);
|
||
CuiHelper.DestroyUi(player, UINAME_CROSSHAIR);
|
||
CuiHelper.AddUi(player, container);
|
||
}
|
||
|
||
private static void CreateToolUI(BasePlayer player, RemoveType removeType)
|
||
{
|
||
var container = UI.CreateElementContainer("Hud", UINAME_MAIN, configData.uiS.removerToolBackgroundColor, configData.uiS.removerToolAnchorMin, configData.uiS.removerToolAnchorMax, configData.uiS.removerToolOffsetMin, configData.uiS.removerToolOffsetMax);
|
||
UI.CreatePanel(ref container, UINAME_MAIN, configData.uiS.removeBackgroundColor, configData.uiS.removeAnchorMin, configData.uiS.removeAnchorMax);
|
||
UI.CreateLabel(ref container, UINAME_MAIN, configData.uiS.removeTextColor, rt.Lang("RemoverToolType", player.UserIDString, GetRemoveTypeName(removeType)), configData.uiS.removeTextSize, configData.uiS.removeTextAnchorMin, configData.uiS.removeTextAnchorMax, TextAnchor.MiddleLeft);
|
||
CuiHelper.DestroyUi(player, UINAME_MAIN);
|
||
CuiHelper.AddUi(player, container);
|
||
}
|
||
|
||
private static void UpdateTimeLeftUI(BasePlayer player, RemoveType removeType, int timeLeft, int currentRemoved, int maxRemovable)
|
||
{
|
||
var container = UI.CreateElementContainer(UINAME_MAIN, UINAME_TIMELEFT, configData.uiS.timeLeftBackgroundColor, configData.uiS.timeLeftAnchorMin, configData.uiS.timeLeftAnchorMax);
|
||
UI.CreateLabel(ref container, UINAME_TIMELEFT, configData.uiS.timeLeftTextColor, rt.Lang("TimeLeft", player.UserIDString, timeLeft, removeType == RemoveType.Normal || removeType == RemoveType.Admin ? maxRemovable == 0 ? $"{currentRemoved} / {rt.Lang("Unlimit", player.UserIDString)}" : $"{currentRemoved} / {maxRemovable}" : currentRemoved.ToString()), configData.uiS.timeLeftTextSize, configData.uiS.timeLeftTextAnchorMin, configData.uiS.timeLeftTextAnchorMax, TextAnchor.MiddleLeft);
|
||
CuiHelper.DestroyUi(player, UINAME_TIMELEFT);
|
||
CuiHelper.AddUi(player, container);
|
||
}
|
||
|
||
private static void UpdateEntityUI(BasePlayer player, BaseEntity targetEntity)
|
||
{
|
||
CuiHelper.DestroyUi(player, UINAME_ENTITY);
|
||
if (!CanEntityBeDisplayed(targetEntity, player)) return;
|
||
var container = UI.CreateElementContainer(UINAME_MAIN, UINAME_ENTITY, configData.uiS.entityBackgroundColor, configData.uiS.entityAnchorMin, configData.uiS.entityAnchorMax);
|
||
string name;
|
||
var entityName = GetEntityName(targetEntity);
|
||
if (string.IsNullOrEmpty(entityName))
|
||
{
|
||
var target = targetEntity as BasePlayer;
|
||
name = target != null ? $"{target.displayName} ({GetDisplayName(target.ShortPrefabName)})" : targetEntity.ShortPrefabName;
|
||
}
|
||
else name = GetDisplayName(entityName);
|
||
UI.CreateLabel(ref container, UINAME_ENTITY, configData.uiS.entityTextColor, name, configData.uiS.entityTextSize, configData.uiS.entityTextAnchorMin, configData.uiS.entityTextAnchorMax, TextAnchor.MiddleLeft);
|
||
if (configData.uiS.entityImageEnabled && !string.IsNullOrEmpty(entityName) && rt.ImageLibrary != null)
|
||
{
|
||
var image = GetEntityImage(entityName);
|
||
if (!string.IsNullOrEmpty(image))
|
||
UI.CreateImage(ref container, UINAME_ENTITY, image, configData.uiS.entityImageAnchorMin, configData.uiS.entityImageAnchorMax);
|
||
}
|
||
CuiHelper.AddUi(player, container);
|
||
}
|
||
|
||
private static void UpdatePricesUI(BasePlayer player, bool usePrice, BaseEntity targetEntity)
|
||
{
|
||
CuiHelper.DestroyUi(player, UINAME_PRICE);
|
||
if (!CanEntityBeDisplayed(targetEntity, player) || !HasEntityEnabled(targetEntity)) return;
|
||
Dictionary<string, int> price = null;
|
||
if (usePrice) price = rt.GetPrice(targetEntity);
|
||
var container = UI.CreateElementContainer(UINAME_MAIN, UINAME_PRICE, configData.uiS.priceBackgroundColor, configData.uiS.priceAnchorMin, configData.uiS.priceAnchorMax);
|
||
UI.CreateLabel(ref container, UINAME_PRICE, configData.uiS.priceTextColor, rt.Lang("Price", player.UserIDString), configData.uiS.priceTextSize, configData.uiS.priceTextAnchorMin, configData.uiS.priceTextAnchorMax, TextAnchor.MiddleLeft);
|
||
if (price == null || price.Count == 0) UI.CreateLabel(ref container, UINAME_PRICE, configData.uiS.price2TextColor, rt.Lang("Free", player.UserIDString), configData.uiS.price2TextSize, configData.uiS.price2TextAnchorMin, configData.uiS.price2TextAnchorMax, TextAnchor.MiddleLeft);
|
||
else
|
||
{
|
||
var anchorMin = configData.uiS.Price2TextAnchorMin;
|
||
var anchorMax = configData.uiS.Price2TextAnchorMax;
|
||
float x = (anchorMax.y - anchorMin.y) / price.Count;
|
||
int textSize = configData.uiS.price2TextSize - price.Count;
|
||
int i = 0;
|
||
foreach (var p in price)
|
||
{
|
||
UI.CreateLabel(ref container, UINAME_PRICE, configData.uiS.price2TextColor, $"{GetDisplayName(p.Key)} x{p.Value}", textSize, $"{anchorMin.x} {anchorMin.y + i * x}", $"{anchorMax.x} {anchorMin.y + (i + 1) * x}", TextAnchor.MiddleLeft);
|
||
if (configData.uiS.imageEnabled && rt.ImageLibrary != null)
|
||
{
|
||
var image = GetItemImage(p.Key);
|
||
if (!string.IsNullOrEmpty(image))
|
||
UI.CreateImage(ref container, UINAME_PRICE, image, $"{anchorMax.x - configData.uiS.rightDistance - x * configData.uiS.imageScale} {anchorMin.y + i * x}", $"{anchorMax.x - configData.uiS.rightDistance} {anchorMin.y + (i + 1) * x}");
|
||
}
|
||
i++;
|
||
}
|
||
}
|
||
CuiHelper.AddUi(player, container);
|
||
}
|
||
|
||
private static void UpdateRefundUI(BasePlayer player, bool useRefund, BaseEntity targetEntity)
|
||
{
|
||
CuiHelper.DestroyUi(player, UINAME_REFUND);
|
||
if (!CanEntityBeDisplayed(targetEntity, player) || !HasEntityEnabled(targetEntity)) return;
|
||
Dictionary<string, int> refund = null;
|
||
if (useRefund) refund = rt.GetRefund(targetEntity);
|
||
var container = UI.CreateElementContainer(UINAME_MAIN, UINAME_REFUND, configData.uiS.refundBackgroundColor, configData.uiS.refundAnchorMin, configData.uiS.refundAnchorMax);
|
||
UI.CreateLabel(ref container, UINAME_REFUND, configData.uiS.refundTextColor, rt.Lang("Refund", player.UserIDString), configData.uiS.refundTextSize, configData.uiS.refundTextAnchorMin, configData.uiS.refundTextAnchorMax, TextAnchor.MiddleLeft);
|
||
|
||
if (refund == null || refund.Count == 0) UI.CreateLabel(ref container, UINAME_REFUND, configData.uiS.refund2TextColor, rt.Lang("Nothing", player.UserIDString), configData.uiS.refund2TextSize, configData.uiS.refund2TextAnchorMin, configData.uiS.refund2TextAnchorMax, TextAnchor.MiddleLeft);
|
||
else
|
||
{
|
||
var anchorMin = configData.uiS.Refund2TextAnchorMin;
|
||
var anchorMax = configData.uiS.Refund2TextAnchorMax;
|
||
float x = (anchorMax.y - anchorMin.y) / refund.Count;
|
||
int textSize = configData.uiS.refund2TextSize - refund.Count;
|
||
int i = 0;
|
||
foreach (var p in refund)
|
||
{
|
||
UI.CreateLabel(ref container, UINAME_REFUND, configData.uiS.refund2TextColor, $"{GetDisplayName(p.Key)} x{p.Value}", textSize, $"{anchorMin.x} {anchorMin.y + i * x}", $"{anchorMax.x} {anchorMin.y + (i + 1) * x}", TextAnchor.MiddleLeft);
|
||
if (configData.uiS.imageEnabled && rt.ImageLibrary != null)
|
||
{
|
||
var image = GetItemImage(p.Key);
|
||
if (!string.IsNullOrEmpty(image))
|
||
UI.CreateImage(ref container, UINAME_REFUND, image, $"{anchorMax.x - configData.uiS.rightDistance - x * configData.uiS.imageScale} {anchorMin.y + i * x}", $"{anchorMax.x - configData.uiS.rightDistance} {anchorMin.y + (i + 1) * x}");
|
||
}
|
||
i++;
|
||
}
|
||
}
|
||
CuiHelper.AddUi(player, container);
|
||
}
|
||
|
||
private static void UpdateAuthorizationUI(BasePlayer player, RemoveType removeType, BaseEntity targetEntity, bool shouldPay)
|
||
{
|
||
CuiHelper.DestroyUi(player, UINAME_AUTH);
|
||
if (!CanEntityBeDisplayed(targetEntity, player)) return;
|
||
string reason;
|
||
string color = rt.CanRemoveEntity(player, removeType, targetEntity, shouldPay, out reason) ? configData.uiS.allowedBackgroundColor : configData.uiS.refusedBackgroundColor;
|
||
var container = UI.CreateElementContainer(UINAME_MAIN, UINAME_AUTH, color, configData.uiS.authorizationsAnchorMin, configData.uiS.authorizationsAnchorMax);
|
||
UI.CreateLabel(ref container, UINAME_AUTH, configData.uiS.authorizationsTextColor, reason, configData.uiS.authorizationsTextSize, configData.uiS.authorizationsTextAnchorMin, configData.uiS.authorizationsTextAnchorMax, TextAnchor.MiddleLeft);
|
||
CuiHelper.AddUi(player, container);
|
||
}
|
||
|
||
private static void DestroyAllUI(BasePlayer player)
|
||
{
|
||
CuiHelper.DestroyUi(player, UINAME_CROSSHAIR);
|
||
CuiHelper.DestroyUi(player, UINAME_MAIN);
|
||
}
|
||
|
||
#endregion UI
|
||
|
||
#region ToolRemover Component
|
||
|
||
#region Tool Helpers
|
||
|
||
private static bool IsSpecificTool(BasePlayer player)
|
||
{
|
||
var heldItem = player.GetActiveItem();
|
||
return IsSpecificTool(heldItem);
|
||
}
|
||
|
||
private static bool IsSpecificTool(Item heldItem)
|
||
{
|
||
if (heldItem != null && heldItem.info.shortname == configData.removerModeS.specificToolShortname)
|
||
{
|
||
if (configData.removerModeS.specificToolSkin < 0) return true;
|
||
return heldItem.skin == (ulong)configData.removerModeS.specificToolSkin;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
private static bool IsMeleeTool(BasePlayer player)
|
||
{
|
||
var heldItem = player.GetActiveItem();
|
||
return IsMeleeTool(heldItem);
|
||
}
|
||
|
||
private static bool IsMeleeTool(Item heldItem)
|
||
{
|
||
if (heldItem != null && heldItem.info.shortname == configData.removerModeS.meleeHitItemShortname)
|
||
{
|
||
if (configData.removerModeS.meleeHitModeSkin < 0) return true;
|
||
return heldItem.skin == (ulong)configData.removerModeS.meleeHitModeSkin;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
#endregion Tool Helpers
|
||
|
||
private class ToolRemover : FacepunchBehaviour
|
||
{
|
||
public BasePlayer player;
|
||
public RemoveType removeType;
|
||
public bool canOverride;
|
||
public BaseEntity hitEntity;
|
||
public int currentRemoved;
|
||
|
||
private int timeLeft;
|
||
private float distance;
|
||
private float lastRemove;
|
||
private float removeInterval;
|
||
private bool pay;
|
||
private bool refund;
|
||
private int maxRemovable;
|
||
private RaycastHit raycastHit;
|
||
private BaseEntity targetEntity;
|
||
private uint currentItemID;
|
||
private int removeTime;
|
||
private bool resetTime;
|
||
private Item lastHeldItem;
|
||
|
||
private bool checkHeldItem;
|
||
|
||
private void Awake()
|
||
{
|
||
player = GetComponent<BasePlayer>();
|
||
currentItemID = player.svActiveItemID;
|
||
checkHeldItem = removeMode == RemoveMode.MeleeHit && configData.removerModeS.meleeHitDisableInHand ||
|
||
removeMode == RemoveMode.SpecificTool && configData.removerModeS.specificToolDisableInHand;
|
||
if (checkHeldItem)
|
||
{
|
||
lastHeldItem = player.GetActiveItem();
|
||
}
|
||
if (removeMode == RemoveMode.NoHeld)
|
||
{
|
||
UnEquip();
|
||
}
|
||
}
|
||
|
||
public void Init(RemoveType type, int time, int max, float dis, float interval, bool p, bool r, bool reset, bool c)
|
||
{
|
||
canOverride = c;
|
||
removeTime = timeLeft = time;
|
||
removeType = type;
|
||
distance = dis;
|
||
resetTime = reset;
|
||
removeInterval = Mathf.Max(0.2f, interval);
|
||
if (removeType == RemoveType.Normal)
|
||
{
|
||
maxRemovable = max;
|
||
pay = p && configData.removeS.priceEnabled;
|
||
refund = r && configData.removeS.refundEnabled;
|
||
}
|
||
else
|
||
{
|
||
maxRemovable = currentRemoved = 0;
|
||
pay = refund = false;
|
||
}
|
||
DestroyAllUI(player);
|
||
if (removeMode == RemoveMode.NoHeld && configData.removerModeS.showCrosshair)
|
||
{
|
||
CreateCrosshairUI(player);
|
||
}
|
||
|
||
if (configData.uiS.enabled)
|
||
{
|
||
CreateToolUI(player, removeType);
|
||
}
|
||
CancelInvoke(RemoveUpdate);
|
||
InvokeRepeating(RemoveUpdate, 0f, 1f);
|
||
}
|
||
|
||
private void RemoveUpdate()
|
||
{
|
||
if (configData.uiS.enabled)
|
||
{
|
||
GetTargetEntity();
|
||
UpdateTimeLeftUI(player, removeType, timeLeft, currentRemoved, maxRemovable);
|
||
UpdateEntityUI(player, targetEntity);
|
||
if (removeType == RemoveType.Normal)
|
||
{
|
||
if (configData.uiS.authorizationEnabled) UpdateAuthorizationUI(player, removeType, targetEntity, pay);
|
||
if (configData.uiS.priceEnabled) UpdatePricesUI(player, pay, targetEntity);
|
||
if (configData.uiS.refundEnabled) UpdateRefundUI(player, refund, targetEntity);
|
||
}
|
||
}
|
||
|
||
if (timeLeft-- <= 0)
|
||
{
|
||
DisableTool();
|
||
}
|
||
}
|
||
|
||
private void GetTargetEntity()
|
||
{
|
||
bool flag = Physics.Raycast(player.eyes.HeadRay(), out raycastHit, distance, LAYER_TARGET);
|
||
targetEntity = flag ? raycastHit.GetEntity() : null;
|
||
}
|
||
|
||
private void FixedUpdate()
|
||
{
|
||
if (player == null || !player.IsConnected || !player.CanInteract())
|
||
{
|
||
DisableTool();
|
||
return;
|
||
}
|
||
if (player.svActiveItemID != currentItemID)
|
||
{
|
||
if (checkHeldItem)
|
||
{
|
||
var heldItem = player.GetActiveItem();
|
||
if (removeMode == RemoveMode.MeleeHit && IsMeleeTool(lastHeldItem) && !IsMeleeTool(heldItem) ||
|
||
removeMode == RemoveMode.SpecificTool && IsSpecificTool(lastHeldItem) && !IsSpecificTool(heldItem))
|
||
{
|
||
DisableTool();
|
||
return;
|
||
}
|
||
lastHeldItem = heldItem;
|
||
}
|
||
if (removeMode == RemoveMode.NoHeld)
|
||
{
|
||
if (player.svActiveItemID != 0)
|
||
{
|
||
if (configData.removerModeS.noHeldDisableInHand)
|
||
{
|
||
DisableTool();
|
||
return;
|
||
}
|
||
UnEquip();
|
||
}
|
||
}
|
||
currentItemID = player.svActiveItemID;
|
||
}
|
||
if (Time.realtimeSinceStartup - lastRemove >= removeInterval)
|
||
{
|
||
if (removeMode == RemoveMode.MeleeHit)
|
||
{
|
||
if (hitEntity == null) return;
|
||
targetEntity = hitEntity;
|
||
hitEntity = null;
|
||
}
|
||
else
|
||
{
|
||
if (!player.serverInput.IsDown(removeButton)) return;
|
||
if (removeMode == RemoveMode.SpecificTool && !IsSpecificTool(player)) return;
|
||
GetTargetEntity();
|
||
}
|
||
if (rt.TryRemove(player, targetEntity, removeType, pay, refund))
|
||
{
|
||
if (resetTime) timeLeft = removeTime;
|
||
if (removeType == RemoveType.Normal || removeType == RemoveType.Admin)
|
||
currentRemoved++;
|
||
if (configData.globalS.startCooldownOnRemoved && removeType == RemoveType.Normal)
|
||
{
|
||
rt.cooldownTimes[player.userID] = Time.realtimeSinceStartup;
|
||
}
|
||
}
|
||
lastRemove = Time.realtimeSinceStartup;
|
||
}
|
||
if (removeType == RemoveType.Normal && maxRemovable > 0 && currentRemoved >= maxRemovable)
|
||
{
|
||
rt.Print(player, rt.Lang("EntityLimit", player.UserIDString, maxRemovable));
|
||
DisableTool(false);
|
||
};
|
||
}
|
||
|
||
private void UnEquip()
|
||
{
|
||
//player.lastReceivedTick.activeItem = 0;
|
||
var activeItem = player.GetActiveItem();
|
||
if (activeItem?.GetHeldEntity() is HeldEntity)
|
||
{
|
||
var slot = activeItem.position;
|
||
activeItem.SetParent(null);
|
||
player.Invoke(() =>
|
||
{
|
||
if (activeItem == null || !activeItem.IsValid()) return;
|
||
if (player.inventory.containerBelt.GetSlot(slot) == null)
|
||
{
|
||
activeItem.position = slot;
|
||
activeItem.SetParent(player.inventory.containerBelt);
|
||
}
|
||
else player.GiveItem(activeItem);
|
||
}, 0.2f);
|
||
}
|
||
}
|
||
|
||
public void DisableTool(bool showMessage = true)
|
||
{
|
||
if (showMessage)
|
||
{
|
||
if (rt != null && player != null && player.IsConnected)
|
||
{
|
||
rt.Print(player, rt.Lang("ToolDisabled", player.UserIDString));
|
||
}
|
||
}
|
||
DestroyImmediate(this);
|
||
}
|
||
|
||
private void OnDestroy()
|
||
{
|
||
DestroyAllUI(player);
|
||
if (rt != null && removeType == RemoveType.Normal)
|
||
{
|
||
if (configData != null && !configData.globalS.startCooldownOnRemoved)
|
||
{
|
||
rt.cooldownTimes[player.userID] = Time.realtimeSinceStartup;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
#endregion ToolRemover Component
|
||
|
||
#region Pay
|
||
|
||
private readonly List<Item> collect = new List<Item>();
|
||
|
||
private bool Pay(BasePlayer player, BaseEntity targetEntity)
|
||
{
|
||
var price = GetPrice(targetEntity);
|
||
if (price == null) return true;
|
||
try
|
||
{
|
||
foreach (var entry in price)
|
||
{
|
||
if (entry.Value <= 0) continue;
|
||
int itemID;
|
||
if (itemShortNameToItemID.TryGetValue(entry.Key, out itemID))
|
||
{
|
||
collect.Clear();
|
||
player.inventory.Take(collect, itemID, entry.Value);
|
||
player.Command("note.inv", itemID, -entry.Value);
|
||
}
|
||
else if (!CheckOrPay(entry.Key, entry.Value, player.userID))
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
PrintError($"{player} couldn't pay to remove entity. Error Message: {e.Message}");
|
||
return false;
|
||
}
|
||
finally
|
||
{
|
||
foreach (Item item in collect) item.Remove();
|
||
}
|
||
return true;
|
||
}
|
||
|
||
private Dictionary<string, int> GetPrice(BaseEntity targetEntity)
|
||
{
|
||
var buildingBlock = targetEntity as BuildingBlock;
|
||
if (buildingBlock != null)
|
||
{
|
||
var entityName = prefabNameToStructure[buildingBlock.PrefabName];
|
||
ConfigData.RemoveSettings.BuildingBlocksS buildingBlockS;
|
||
if (configData.removeS.buildingBlockS.TryGetValue(entityName, out buildingBlockS))
|
||
{
|
||
ConfigData.RemoveSettings.BuildingBlocksS.BuildingGradeS buildingGradeS;
|
||
if (buildingBlockS.buildingGradeS.TryGetValue(buildingBlock.grade, out buildingGradeS))
|
||
{
|
||
if (buildingGradeS.priceDic != null)
|
||
{
|
||
return buildingGradeS.priceDic;
|
||
}
|
||
if (buildingGradeS.pricePercentage > 0f)
|
||
{
|
||
var currentGrade = buildingBlock.currentGrade;
|
||
if (currentGrade != null)
|
||
{
|
||
var price = new Dictionary<string, int>();
|
||
foreach (var itemAmount in currentGrade.costToBuild)
|
||
{
|
||
var amount = Mathf.RoundToInt(itemAmount.amount * buildingGradeS.pricePercentage / 100);
|
||
if (amount <= 0) continue;
|
||
price.Add(itemAmount.itemDef.shortname, amount);
|
||
}
|
||
|
||
return price;
|
||
}
|
||
}
|
||
else if (buildingGradeS.pricePercentage < 0f)
|
||
{
|
||
var currentGrade = buildingBlock.currentGrade;
|
||
if (currentGrade != null)
|
||
{
|
||
return currentGrade.costToBuild.ToDictionary(x => x.itemDef.shortname, y => Mathf.RoundToInt(y.amount));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ConfigData.RemoveSettings.EntityS entityS;
|
||
if (configData.removeS.entityS.TryGetValue(targetEntity.ShortPrefabName, out entityS))
|
||
{
|
||
return entityS.price;
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
private bool CanPay(BasePlayer player, BaseEntity targetEntity)
|
||
{
|
||
var price = GetPrice(targetEntity);
|
||
if (price.Count <= 0) return true;
|
||
foreach (var p in price)
|
||
{
|
||
if (p.Value <= 0) continue;
|
||
int itemID;
|
||
if (itemShortNameToItemID.TryGetValue(p.Key, out itemID))
|
||
{
|
||
int c = player.inventory.GetAmount(itemID);
|
||
if (c < p.Value) return false;
|
||
}
|
||
else if (!CheckOrPay(p.Key, p.Value, player.userID, true)) return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
private bool CheckOrPay(string key, int price, ulong playerID, bool check = false)
|
||
{
|
||
if (price <= 0) return true;
|
||
switch (key.ToLower())
|
||
{
|
||
case "economics":
|
||
if (Economics == null) return false;
|
||
if (check)
|
||
{
|
||
var b = Economics.Call("Balance", playerID);
|
||
if (b == null) return false;
|
||
if ((double)b < price) return false;
|
||
}
|
||
else
|
||
{
|
||
var w = Economics.Call("Withdraw", playerID, (double)price);
|
||
if (w == null || !(bool)w) return false;
|
||
}
|
||
return true;
|
||
|
||
case "serverrewards":
|
||
if (ServerRewards == null) return false;
|
||
if (check)
|
||
{
|
||
var c = ServerRewards.Call("CheckPoints", playerID);
|
||
if (c == null) return false;
|
||
if ((int)c < price) return false;
|
||
}
|
||
else
|
||
{
|
||
var t = ServerRewards.Call("TakePoints", playerID, price);
|
||
if (t == null || !(bool)t) return false;
|
||
}
|
||
return true;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
#endregion Pay
|
||
|
||
#region Refund
|
||
|
||
private void GiveRefund(BasePlayer player, BaseEntity targetEntity)
|
||
{
|
||
var refund = GetRefund(targetEntity);
|
||
if (refund == null) return;
|
||
foreach (var entry in refund)
|
||
{
|
||
if (entry.Value <= 0) continue;
|
||
int itemID; string shortname;
|
||
shorPrefabNameToDeployable.TryGetValue(targetEntity.ShortPrefabName, out shortname);
|
||
if (itemShortNameToItemID.TryGetValue(entry.Key, out itemID))
|
||
{
|
||
var item = ItemManager.CreateByItemID(itemID, entry.Value, entry.Key == shortname ? targetEntity.skinID : 0);
|
||
player.GiveItem(item);
|
||
}
|
||
else
|
||
{
|
||
switch (entry.Key.ToLower())
|
||
{
|
||
case "economics":
|
||
if (Economics == null) continue;
|
||
Economics.Call("Deposit", player.userID, (double)entry.Value);
|
||
continue;
|
||
|
||
case "serverrewards":
|
||
if (ServerRewards == null) continue;
|
||
ServerRewards.Call("AddPoints", player.userID, entry.Value);
|
||
continue;
|
||
default:
|
||
PrintError($"{player} didn't receive refund because {entry.Key} doesn't seem to be a valid item name");
|
||
continue;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
private Dictionary<string, int> GetRefund(BaseEntity targetEntity)
|
||
{
|
||
var buildingBlock = targetEntity.GetComponent<BuildingBlock>();
|
||
if (buildingBlock != null)
|
||
{
|
||
var entityName = prefabNameToStructure[buildingBlock.PrefabName];
|
||
ConfigData.RemoveSettings.BuildingBlocksS buildingBlockS;
|
||
if (configData.removeS.buildingBlockS.TryGetValue(entityName, out buildingBlockS))
|
||
{
|
||
ConfigData.RemoveSettings.BuildingBlocksS.BuildingGradeS buildingGradeS;
|
||
if (buildingBlockS.buildingGradeS.TryGetValue(buildingBlock.grade, out buildingGradeS))
|
||
{
|
||
if (buildingGradeS.refundDic != null)
|
||
{
|
||
return buildingGradeS.refundDic;
|
||
}
|
||
if (buildingGradeS.refundPercentage > 0f)
|
||
{
|
||
var currentGrade = buildingBlock.currentGrade;
|
||
if (currentGrade != null)
|
||
{
|
||
var refund = new Dictionary<string, int>();
|
||
foreach (var itemAmount in currentGrade.costToBuild)
|
||
{
|
||
var amount = Mathf.RoundToInt(itemAmount.amount * buildingGradeS.refundPercentage / 100);
|
||
if (amount <= 0) continue;
|
||
refund.Add(itemAmount.itemDef.shortname, amount);
|
||
}
|
||
return refund;
|
||
}
|
||
}
|
||
else if (buildingGradeS.refundPercentage < 0f)
|
||
{
|
||
var currentGrade = buildingBlock.currentGrade;
|
||
if (currentGrade != null)
|
||
{
|
||
return currentGrade.costToBuild.ToDictionary(x => x.itemDef.shortname, y => Mathf.RoundToInt(y.amount));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ConfigData.RemoveSettings.EntityS entityS;
|
||
if (configData.removeS.entityS.TryGetValue(targetEntity.ShortPrefabName, out entityS))
|
||
{
|
||
if (configData.removeS.refundSlot)
|
||
{
|
||
var slots = GetSlots(targetEntity);
|
||
if (slots.Any())
|
||
{
|
||
var refund = new Dictionary<string, int>(entityS.refund);
|
||
foreach (var slotName in slots)
|
||
{
|
||
if (!refund.ContainsKey(slotName)) refund.Add(slotName, 0);
|
||
refund[slotName]++;
|
||
}
|
||
return refund;
|
||
}
|
||
}
|
||
return entityS.refund;
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
private IEnumerable<string> GetSlots(BaseEntity targetEntity)
|
||
{
|
||
foreach (BaseEntity.Slot slot in Enum.GetValues(typeof(BaseEntity.Slot)))
|
||
{
|
||
if (targetEntity.HasSlot(slot))
|
||
{
|
||
var entity = targetEntity.GetSlot(slot);
|
||
if (entity != null)
|
||
{
|
||
string slotName;
|
||
if (shorPrefabNameToDeployable.TryGetValue(entity.ShortPrefabName, out slotName))
|
||
{
|
||
yield return slotName;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
#endregion Refund
|
||
|
||
#region RaidBlocker
|
||
|
||
private void BlockRemove(BuildingBlock buildingBlock)
|
||
{
|
||
if (configData.raidS.blockBuildingID)
|
||
{
|
||
var buildingID = buildingBlock.buildingID;
|
||
lastAttackedBuildings[buildingID] = Time.realtimeSinceStartup;
|
||
}
|
||
if (configData.raidS.blockPlayers)
|
||
{
|
||
var players = Pool.GetList<BasePlayer>();
|
||
Vis.Entities(buildingBlock.transform.position, configData.raidS.blockRadius, players, Rust.Layers.Mask.Player_Server);
|
||
foreach (var player in players)
|
||
{
|
||
if (player.userID.IsSteamId())
|
||
lastBlockedPlayers[player.userID] = Time.realtimeSinceStartup;
|
||
}
|
||
Pool.FreeList(ref players);
|
||
}
|
||
}
|
||
|
||
private bool IsRaidBlocked(BasePlayer player, BaseEntity targetEntity, out float timeLeft)
|
||
{
|
||
if (configData.raidS.blockBuildingID)
|
||
{
|
||
var buildingBlock = targetEntity as BuildingBlock;
|
||
if (buildingBlock != null)
|
||
{
|
||
float blockTime;
|
||
if (lastAttackedBuildings.TryGetValue(buildingBlock.buildingID, out blockTime))
|
||
{
|
||
timeLeft = configData.raidS.blockTime - (Time.realtimeSinceStartup - blockTime);
|
||
if (timeLeft > 0) return true;
|
||
}
|
||
}
|
||
}
|
||
if (configData.raidS.blockPlayers)
|
||
{
|
||
float blockTime;
|
||
if (lastBlockedPlayers.TryGetValue(player.userID, out blockTime))
|
||
{
|
||
timeLeft = configData.raidS.blockTime - (Time.realtimeSinceStartup - blockTime);
|
||
if (timeLeft > 0) return true;
|
||
}
|
||
}
|
||
timeLeft = 0;
|
||
return false;
|
||
}
|
||
|
||
#endregion RaidBlocker
|
||
|
||
#region TryRemove
|
||
|
||
private bool TryRemove(BasePlayer player, BaseEntity targetEntity, RemoveType removeType, bool shouldPay, bool shouldRefund)
|
||
{
|
||
if (!CanEntityBeDisplayed(targetEntity, player))
|
||
{
|
||
Print(player, Lang("NotFoundOrFar", player.UserIDString));
|
||
return false;
|
||
}
|
||
if (removeType == RemoveType.Admin)
|
||
{
|
||
var target = targetEntity as BasePlayer;
|
||
if (target != null)
|
||
{
|
||
if (target.userID.IsSteamId() && target.IsConnected)
|
||
{
|
||
target.Kick("From RemoverTool Plugin");
|
||
return true;
|
||
}
|
||
}
|
||
DoRemove(targetEntity, configData.removeTypeS[RemoveType.Admin].gibs ? BaseNetworkable.DestroyMode.Gib : BaseNetworkable.DestroyMode.None);
|
||
return true;
|
||
}
|
||
|
||
string reason;
|
||
if (!CanRemoveEntity(player, removeType, targetEntity, shouldPay, out reason))
|
||
{
|
||
Print(player, reason);
|
||
return false;
|
||
}
|
||
switch (removeType)
|
||
{
|
||
case RemoveType.All:
|
||
{
|
||
if (removeAllCoroutine != null)
|
||
{
|
||
Print(player, Lang("AlreadyRemoveAll", player.UserIDString));
|
||
return false;
|
||
}
|
||
removeAllCoroutine = ServerMgr.Instance.StartCoroutine(RemoveAll(targetEntity, player));
|
||
Print(player, Lang("StartRemoveAll", player.UserIDString));
|
||
return true;
|
||
}
|
||
case RemoveType.External:
|
||
{
|
||
var stabilityEntity = targetEntity as StabilityEntity;
|
||
if (stabilityEntity == null || !IsExternalWall(stabilityEntity))
|
||
{
|
||
Print(player, Lang("NotExternalWall", player.UserIDString));
|
||
return false;
|
||
}
|
||
if (removeExternalCoroutine != null)
|
||
{
|
||
Print(player, Lang("AlreadyRemoveExternal", player.UserIDString));
|
||
return false;
|
||
}
|
||
removeExternalCoroutine = ServerMgr.Instance.StartCoroutine(RemoveExternal(stabilityEntity, player));
|
||
Print(player, Lang("StartRemoveExternal", player.UserIDString));
|
||
return true;
|
||
}
|
||
case RemoveType.Structure:
|
||
{
|
||
var decayEntity = targetEntity as DecayEntity;
|
||
if (decayEntity == null)
|
||
{
|
||
Print(player, Lang("NotStructure", player.UserIDString));
|
||
return false;
|
||
}
|
||
if (removeStructureCoroutine != null)
|
||
{
|
||
Print(player, Lang("AlreadyRemoveStructure", player.UserIDString));
|
||
return false;
|
||
}
|
||
removeStructureCoroutine = ServerMgr.Instance.StartCoroutine(RemoveStructure(decayEntity, player));
|
||
Print(player, Lang("StartRemoveStructure", player.UserIDString));
|
||
return true;
|
||
}
|
||
}
|
||
|
||
var storageContainer = targetEntity as StorageContainer;
|
||
if (storageContainer != null && storageContainer.inventory?.itemList?.Count > 0)
|
||
{
|
||
if (configData.containerS.dropContainerStorage || configData.containerS.dropItemsStorage)
|
||
{
|
||
if (Interface.CallHook("OnDropContainerEntity", storageContainer) == null)
|
||
{
|
||
if (configData.containerS.dropContainerStorage)
|
||
{
|
||
DropItemContainer(storageContainer.inventory, storageContainer.GetDropPosition(),
|
||
storageContainer.transform.rotation);
|
||
}
|
||
else if (configData.containerS.dropItemsStorage)
|
||
{
|
||
storageContainer.DropItems();
|
||
//DropUtil.DropItems(storageContainer.inventory, storageContainer.GetDropPosition());
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
var containerIoEntity = targetEntity as ContainerIOEntity;
|
||
if (containerIoEntity != null && containerIoEntity.inventory?.itemList?.Count > 0)
|
||
{
|
||
if (configData.containerS.dropContainerIoEntity || configData.containerS.dropItemsIoEntity)
|
||
{
|
||
if (Interface.CallHook("OnDropContainerEntity", containerIoEntity) == null)
|
||
{
|
||
if (configData.containerS.dropContainerIoEntity)
|
||
{
|
||
DropItemContainer(containerIoEntity.inventory, containerIoEntity.GetDropPosition(), containerIoEntity.transform.rotation);
|
||
}
|
||
else if (configData.containerS.dropItemsIoEntity)
|
||
{
|
||
containerIoEntity.DropItems();
|
||
//DropUtil.DropItems(containerIoEntity.inventory, containerIoEntity.GetDropPosition());
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (shouldPay)
|
||
{
|
||
bool flag = Pay(player, targetEntity);
|
||
if (!flag)
|
||
{
|
||
Print(player, Lang("CantPay", player.UserIDString));
|
||
return false;
|
||
}
|
||
}
|
||
if (shouldRefund) GiveRefund(player, targetEntity);
|
||
DoNormalRemove(player, targetEntity, configData.removeTypeS[RemoveType.Normal].gibs);
|
||
return true;
|
||
}
|
||
|
||
private bool CanRemoveEntity(BasePlayer player, RemoveType removeType, BaseEntity targetEntity, bool shouldPay, out string reason)
|
||
{
|
||
if (targetEntity.IsDestroyed || !IsRemovableEntity(targetEntity) ||
|
||
(removeType == RemoveType.Normal && ((targetEntity as BaseCombatEntity)?.IsDead() ?? false)))
|
||
{
|
||
reason = Lang("InvalidEntity", player.UserIDString);
|
||
return false;
|
||
}
|
||
if (removeType != RemoveType.Normal)
|
||
{
|
||
reason = string.Empty;
|
||
return true;
|
||
}
|
||
if (!HasEntityEnabled(targetEntity))
|
||
{
|
||
reason = Lang("EntityDisabled", player.UserIDString);
|
||
return false;
|
||
}
|
||
var result = Interface.CallHook("canRemove", player, targetEntity);
|
||
if (result != null)
|
||
{
|
||
reason = result is string ? (string)result : Lang("BeBlocked", player.UserIDString);
|
||
return false;
|
||
}
|
||
if (!configData.damagedEntityS.enabled && IsDamagedEntity(targetEntity))
|
||
{
|
||
reason = Lang("DamagedEntity", player.UserIDString);
|
||
return false;
|
||
}
|
||
float timeLeft;
|
||
if (configData.raidS.enabled && IsRaidBlocked(player, targetEntity, out timeLeft))
|
||
{
|
||
reason = Lang("RaidBlocked", player.UserIDString, Math.Ceiling(timeLeft));
|
||
return false;
|
||
}
|
||
if (configData.globalS.entityTimeLimit && IsEntityTimeLimit(targetEntity))
|
||
{
|
||
reason = Lang("EntityTimeLimit", player.UserIDString, configData.globalS.limitTime);
|
||
return false;
|
||
}
|
||
if (shouldPay && !CanPay(player, targetEntity))
|
||
{
|
||
reason = Lang("NotEnoughCost", player.UserIDString);
|
||
return false;
|
||
}
|
||
if (!configData.containerS.removeNotEmptyStorage && targetEntity is StorageContainer)
|
||
{
|
||
if (((StorageContainer)targetEntity).inventory?.itemList?.Count > 0)
|
||
{
|
||
reason = Lang("StorageNotEmpty", player.UserIDString);
|
||
return false;
|
||
}
|
||
}
|
||
if (!configData.containerS.removeNotEmptyIoEntity && targetEntity is ContainerIOEntity)
|
||
{
|
||
if (((ContainerIOEntity)targetEntity).inventory?.itemList?.Count > 0)
|
||
{
|
||
reason = Lang("StorageNotEmpty", player.UserIDString);
|
||
return false;
|
||
}
|
||
}
|
||
if (!HasAccess(player, targetEntity))
|
||
{
|
||
reason = Lang("NotRemoveAccess", player.UserIDString);
|
||
return false;
|
||
}
|
||
if (configData.globalS.checkStash && HasStashUnderFoundation(targetEntity as BuildingBlock))//Prevent not access players from knowing that there has a stash
|
||
{
|
||
reason = Lang("HasStash", player.UserIDString);
|
||
return false;
|
||
}
|
||
reason = Lang("CanRemove", player.UserIDString);
|
||
return true;
|
||
}
|
||
|
||
private bool HasAccess(BasePlayer player, BaseEntity targetEntity)
|
||
{
|
||
//var excludeTwigs = configData.globalS.excludeTwigs && (targetEntity as BuildingBlock)?.grade == BuildingGrade.Enum.Twigs;
|
||
if (configData.globalS.useEntityOwners)
|
||
{
|
||
if (AreFriends(targetEntity.OwnerID, player.userID))
|
||
{
|
||
if (!configData.globalS.useToolCupboards)
|
||
{
|
||
return true;
|
||
}
|
||
|
||
if (HasTotalAccess(player, targetEntity))
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
if (configData.globalS.useToolCupboards)
|
||
{
|
||
if (HasTotalAccess(player, targetEntity))
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
if (configData.globalS.useBuildingOwners && BuildingOwners != null)
|
||
{
|
||
var buildingBlock = targetEntity as BuildingBlock;
|
||
if (buildingBlock != null)
|
||
{
|
||
var result = BuildingOwners?.Call("FindBlockData", buildingBlock) as string;
|
||
if (result != null)
|
||
{
|
||
ulong ownerID = ulong.Parse(result);
|
||
if (AreFriends(ownerID, player.userID))
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
private static bool HasTotalAccess(BasePlayer player, BaseEntity targetEntity)
|
||
{
|
||
if (player.IsBuildingBlocked(targetEntity.WorldSpaceBounds()))
|
||
{
|
||
return false;
|
||
}
|
||
if (configData.globalS.useBuildingLocks && !CanOpenAllLocks(player, targetEntity))
|
||
{
|
||
//reason = Lang("Can'tOpenAllLocks", player.UserIDString);
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
private static bool CanOpenAllLocks(BasePlayer player, BaseEntity targetEntity)
|
||
{
|
||
var decayEntities = Pool.GetList<DecayEntity>();
|
||
var building = targetEntity.GetBuildingPrivilege()?.GetBuilding() ?? (targetEntity as DecayEntity)?.GetBuilding();
|
||
if (building != null)
|
||
{
|
||
decayEntities.AddRange(building.decayEntities);
|
||
}
|
||
/*else//An entity placed outside
|
||
{
|
||
Vis.Entities(targetEntity.transform.position, 9f, decayEntities, Layers.Mask.Construction | Layers.Mask.Deployed);
|
||
}*/
|
||
foreach (var decayEntity in decayEntities)
|
||
{
|
||
if ((decayEntity is Door || decayEntity is BoxStorage) && decayEntity.OwnerID.IsSteamId())
|
||
{
|
||
var lockEntity = decayEntity.GetSlot(BaseEntity.Slot.Lock) as BaseLock;
|
||
if (lockEntity != null && !OnTryToOpen(player, lockEntity))
|
||
{
|
||
Pool.FreeList(ref decayEntities);
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
Pool.FreeList(ref decayEntities);
|
||
return true;
|
||
}
|
||
|
||
private static bool OnTryToOpen(BasePlayer player, BaseLock baseLock)
|
||
{
|
||
var codeLock = baseLock as CodeLock;
|
||
if (codeLock != null)
|
||
{
|
||
var obj = Interface.CallHook("CanUseLockedEntity", player, codeLock);
|
||
if (obj is bool)
|
||
{
|
||
return (bool)obj;
|
||
}
|
||
if (!codeLock.IsLocked())
|
||
{
|
||
return true;
|
||
}
|
||
if (codeLock.whitelistPlayers.Contains(player.userID) || codeLock.guestPlayers.Contains(player.userID))
|
||
{
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
var keyLock = baseLock as KeyLock;
|
||
if (keyLock != null)
|
||
{
|
||
return keyLock.OnTryToOpen(player);
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
private static bool HasStashUnderFoundation(BuildingBlock buildingBlock)
|
||
{
|
||
if (buildingBlock == null) return false;
|
||
if (buildingBlock.ShortPrefabName.Contains("foundation"))
|
||
{
|
||
return GamePhysics.CheckOBB<StashContainer>(buildingBlock.WorldSpaceBounds());
|
||
//var stashes = Pool.GetList<StashContainer>();
|
||
//Vis.Entities(buildingBlock.CenterPoint(), 2.5f, stashes, Rust.Layers.Mask.Default);
|
||
//bool flag = stashes.Count > 0;
|
||
//Pool.FreeList(ref stashes);
|
||
//return flag;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
private static bool IsDamagedEntity(BaseEntity entity)
|
||
{
|
||
if (configData.damagedEntityS.excludeBuildingBlocks && (entity is BuildingBlock || entity is SimpleBuildingBlock)) return false;
|
||
var baseCombatEntity = entity as BaseCombatEntity;
|
||
if (baseCombatEntity == null || !baseCombatEntity.repair.enabled) return false;
|
||
if (!(entity is BuildingBlock) && (baseCombatEntity.repair.itemTarget == null || baseCombatEntity.repair.itemTarget.Blueprint == null))//Quarry
|
||
return false;
|
||
if (baseCombatEntity.Health() / baseCombatEntity.MaxHealth() * 100f >= configData.damagedEntityS.percentage) return false;
|
||
return true;
|
||
}
|
||
|
||
private static bool IsEntityTimeLimit(BaseEntity entity)
|
||
{
|
||
if (entity.net == null) return true;
|
||
float spawnedTime;
|
||
if (rt.entitySpawnedTimes.TryGetValue(entity.net.ID, out spawnedTime))
|
||
return Time.realtimeSinceStartup - spawnedTime > configData.globalS.limitTime;
|
||
return true;
|
||
}
|
||
|
||
#region AreFriends
|
||
|
||
private bool AreFriends(ulong playerID, ulong friendID)
|
||
{
|
||
if (!playerID.IsSteamId()) return false;
|
||
if (playerID == friendID) return true;
|
||
if (configData.globalS.useTeams && SameTeam(playerID, friendID)) return true;
|
||
if (configData.globalS.useFriends && HasFriend(playerID, friendID)) return true;
|
||
if (configData.globalS.useClans && SameClan(playerID, friendID)) return true;
|
||
return false;
|
||
}
|
||
|
||
private static bool SameTeam(ulong playerID, ulong friendID)
|
||
{
|
||
if (!RelationshipManager.TeamsEnabled()) return false;
|
||
var playerTeam = RelationshipManager.Instance.FindPlayersTeam(playerID);
|
||
if (playerTeam == null) return false;
|
||
var friendTeam = RelationshipManager.Instance.FindPlayersTeam(friendID);
|
||
if (friendTeam == null) return false;
|
||
return playerTeam == friendTeam;
|
||
}
|
||
|
||
private bool HasFriend(ulong playerID, ulong friendID)
|
||
{
|
||
if (Friends == null) return false;
|
||
return (bool)Friends.Call("HasFriend", playerID, friendID);
|
||
}
|
||
|
||
private bool SameClan(ulong playerID, ulong friendID)
|
||
{
|
||
if (Clans == null) return false;
|
||
//Clans
|
||
var isMember = Clans.Call("IsClanMember", playerID.ToString(), friendID.ToString());
|
||
if (isMember != null) return (bool)isMember;
|
||
//Rust:IO Clans
|
||
var playerClan = Clans.Call("GetClanOf", playerID);
|
||
if (playerClan == null) return false;
|
||
var friendClan = Clans.Call("GetClanOf", friendID);
|
||
if (friendClan == null) return false;
|
||
return (string)playerClan == (string)friendClan;
|
||
}
|
||
|
||
#endregion AreFriends
|
||
|
||
#endregion TryRemove
|
||
|
||
#region RemoveEntity
|
||
|
||
private IEnumerator RemoveAll(BaseEntity sourceEntity, BasePlayer player)
|
||
{
|
||
var removeList = Pool.Get<HashSet<BaseEntity>>();
|
||
yield return GetNearbyEntities(sourceEntity, removeList, LAYER_ALL);
|
||
yield return ProcessContainer(removeList);
|
||
yield return DelayRemove(removeList, player, RemoveType.All);
|
||
Pool.Free(ref removeList);
|
||
removeAllCoroutine = null;
|
||
}
|
||
|
||
private IEnumerator RemoveExternal(StabilityEntity sourceEntity, BasePlayer player)
|
||
{
|
||
var removeList = Pool.Get<HashSet<StabilityEntity>>();
|
||
yield return GetNearbyEntities(sourceEntity, removeList, Rust.Layers.Mask.Construction, IsExternalWall);
|
||
yield return DelayRemove(removeList, player, RemoveType.External);
|
||
Pool.Free(ref removeList);
|
||
removeExternalCoroutine = null;
|
||
}
|
||
|
||
private IEnumerator RemoveStructure(DecayEntity sourceEntity, BasePlayer player)
|
||
{
|
||
var removeList = Pool.Get<HashSet<BaseEntity>>();
|
||
yield return ProcessBuilding(sourceEntity, removeList);
|
||
yield return DelayRemove(removeList, player, RemoveType.Structure);
|
||
Pool.Free(ref removeList);
|
||
removeStructureCoroutine = null;
|
||
}
|
||
|
||
private IEnumerator RemovePlayerEntity(ConsoleSystem.Arg arg, ulong targetID, RemovePlayerEntityType removePlayerEntityType)
|
||
{
|
||
int current = 0;
|
||
var removeList = Pool.Get<HashSet<BaseEntity>>();
|
||
switch (removePlayerEntityType)
|
||
{
|
||
case RemovePlayerEntityType.All:
|
||
case RemovePlayerEntityType.Building:
|
||
bool onlyBuilding = removePlayerEntityType == RemovePlayerEntityType.Building;
|
||
foreach (var serverEntity in BaseNetworkable.serverEntities)
|
||
{
|
||
if (++current % 500 == 0) yield return CoroutineEx.waitForEndOfFrame;
|
||
var entity = serverEntity as BaseEntity;
|
||
if (entity == null || entity.OwnerID != targetID) continue;
|
||
if (!onlyBuilding || entity is BuildingBlock)
|
||
{
|
||
removeList.Add(entity);
|
||
}
|
||
}
|
||
foreach (var player in BasePlayer.allPlayerList)
|
||
{
|
||
if (player.userID == targetID)
|
||
{
|
||
if (player.IsConnected) player.Kick("From RemoverTool Plugin");
|
||
removeList.Add(player);
|
||
break;
|
||
}
|
||
}
|
||
break;
|
||
|
||
case RemovePlayerEntityType.Cupboard:
|
||
foreach (var serverEntity in BaseNetworkable.serverEntities)
|
||
{
|
||
if (++current % 500 == 0) yield return CoroutineEx.waitForEndOfFrame;
|
||
var entity = serverEntity as BuildingPrivlidge;
|
||
if (entity == null || entity.OwnerID != targetID) continue;
|
||
yield return ProcessBuilding(entity, removeList);
|
||
}
|
||
break;
|
||
}
|
||
int removed = removeList.Count(x => x != null && !x.IsDestroyed);
|
||
yield return DelayRemove(removeList);
|
||
Pool.Free(ref removeList);
|
||
Print(arg, $"You have successfully removed {removed} entities of player {targetID}.");
|
||
removePlayerEntityCoroutine = null;
|
||
}
|
||
|
||
private IEnumerator DelayRemove(IEnumerable<BaseEntity> entities, BasePlayer player = null, RemoveType removeType = RemoveType.None)
|
||
{
|
||
int removed = 0;
|
||
var destroyMode = removeType == RemoveType.None ? BaseNetworkable.DestroyMode.None : configData.removeTypeS[removeType].gibs ? BaseNetworkable.DestroyMode.Gib : BaseNetworkable.DestroyMode.None;
|
||
foreach (var entity in entities)
|
||
{
|
||
if (DoRemove(entity, destroyMode) && ++removed % configData.globalS.removePerFrame == 0)
|
||
yield return CoroutineEx.waitForEndOfFrame;
|
||
}
|
||
if (removeType == RemoveType.None) yield break;
|
||
var toolRemover = player?.GetComponent<ToolRemover>();
|
||
switch (removeType)
|
||
{
|
||
case RemoveType.All:
|
||
if (toolRemover != null && toolRemover.removeType == removeType) toolRemover.currentRemoved += removed;
|
||
if (player != null) Print(player, Lang("CompletedRemoveAll", player.UserIDString, removed));
|
||
yield break;
|
||
|
||
case RemoveType.Structure:
|
||
if (toolRemover != null && toolRemover.removeType == removeType) toolRemover.currentRemoved += removed;
|
||
if (player != null) Print(player, Lang("CompletedRemoveStructure", player.UserIDString, removed));
|
||
yield break;
|
||
|
||
case RemoveType.External:
|
||
if (toolRemover != null && toolRemover.removeType == removeType) toolRemover.currentRemoved += removed;
|
||
if (player != null) Print(player, Lang("CompletedRemoveExternal", player.UserIDString, removed));
|
||
yield break;
|
||
}
|
||
}
|
||
|
||
#region RemoveEntity Helpers
|
||
|
||
private static IEnumerator GetNearbyEntities<T>(T sourceEntity, HashSet<T> removeList, int layers, Func<T, bool> filter = null) where T : BaseEntity
|
||
{
|
||
int current = 0;
|
||
var checkFrom = Pool.Get<Queue<Vector3>>();
|
||
var nearbyEntities = Pool.GetList<T>();
|
||
checkFrom.Enqueue(sourceEntity.transform.position);
|
||
while (checkFrom.Count > 0)
|
||
{
|
||
nearbyEntities.Clear();
|
||
var position = checkFrom.Dequeue();
|
||
Vis.Entities(position, 3f, nearbyEntities, layers);
|
||
for (var i = 0; i < nearbyEntities.Count; i++)
|
||
{
|
||
var entity = nearbyEntities[i];
|
||
if (filter != null && !filter(entity)) continue;
|
||
if (!removeList.Add(entity)) continue;
|
||
checkFrom.Enqueue(entity.transform.position);
|
||
}
|
||
if (++current % configData.globalS.removePerFrame == 0) yield return CoroutineEx.waitForEndOfFrame;
|
||
}
|
||
Pool.Free(ref checkFrom);
|
||
Pool.FreeList(ref nearbyEntities);
|
||
}
|
||
|
||
private static IEnumerator ProcessContainer(HashSet<BaseEntity> removeList)
|
||
{
|
||
foreach (var entity in removeList)
|
||
{
|
||
var storageContainer = entity as StorageContainer;
|
||
if (storageContainer != null && storageContainer.inventory?.itemList?.Count > 0)
|
||
{
|
||
if (configData.globalS.noItemContainerDrop) storageContainer.inventory.Clear();
|
||
else DropItemContainer(storageContainer.inventory, storageContainer.GetDropPosition(), storageContainer.transform.rotation);
|
||
continue;
|
||
}
|
||
var containerIoEntity = entity as ContainerIOEntity;
|
||
if (containerIoEntity != null && containerIoEntity.inventory?.itemList?.Count > 0)
|
||
{
|
||
if (configData.globalS.noItemContainerDrop) containerIoEntity.inventory.Clear();
|
||
else DropItemContainer(containerIoEntity.inventory, containerIoEntity.GetDropPosition(), containerIoEntity.transform.rotation);
|
||
}
|
||
}
|
||
if (configData.globalS.noItemContainerDrop) ItemManager.DoRemoves();
|
||
yield break;
|
||
}
|
||
|
||
private static IEnumerator ProcessBuilding(DecayEntity sourceEntity, HashSet<BaseEntity> removeList)
|
||
{
|
||
var building = sourceEntity.GetBuilding();
|
||
if (building != null)
|
||
{
|
||
foreach (var entity in building.decayEntities)
|
||
{
|
||
if (!removeList.Add(entity)) continue;
|
||
var storageContainer = entity as StorageContainer;
|
||
if (storageContainer != null && storageContainer.inventory?.itemList?.Count > 0)
|
||
{
|
||
if (configData.globalS.noItemContainerDrop) storageContainer.inventory.Clear();
|
||
else DropItemContainer(storageContainer.inventory, storageContainer.GetDropPosition(), storageContainer.transform.rotation);
|
||
}
|
||
}
|
||
}
|
||
else removeList.Add(sourceEntity);
|
||
if (configData.globalS.noItemContainerDrop) ItemManager.DoRemoves();
|
||
yield break;
|
||
}
|
||
|
||
private static bool DoRemove(BaseEntity entity, BaseNetworkable.DestroyMode destroyMode)
|
||
{
|
||
if (entity != null && !entity.IsDestroyed)
|
||
{
|
||
entity.Kill(destroyMode);
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
private static void DoNormalRemove(BasePlayer player, BaseEntity entity, bool gibs = true)
|
||
{
|
||
if (entity != null && !entity.IsDestroyed)
|
||
{
|
||
Interface.CallHook("OnNormalRemovedEntity", player, entity);
|
||
entity.Kill(gibs ? BaseNetworkable.DestroyMode.Gib : BaseNetworkable.DestroyMode.None);
|
||
}
|
||
}
|
||
|
||
#endregion RemoveEntity Helpers
|
||
|
||
#endregion RemoveEntity
|
||
|
||
#region API
|
||
|
||
private bool IsToolRemover(BasePlayer player) => player?.GetComponent<ToolRemover>() != null;
|
||
|
||
private string GetPlayerRemoveType(BasePlayer player) => player?.GetComponent<ToolRemover>()?.removeType.ToString();
|
||
|
||
#endregion API
|
||
|
||
#region Commands
|
||
|
||
private void CmdRemove(BasePlayer player, string command, string[] args)
|
||
{
|
||
if (args == null || args.Length == 0)
|
||
{
|
||
var sourceRemover = player.GetComponent<ToolRemover>();
|
||
if (sourceRemover != null)
|
||
{
|
||
sourceRemover.DisableTool();
|
||
return;
|
||
}
|
||
}
|
||
if (removeOverride && !permission.UserHasPermission(player.UserIDString, PERMISSION_OVERRIDE))
|
||
{
|
||
Print(player, Lang("CurrentlyDisabled", player.UserIDString));
|
||
return;
|
||
}
|
||
RemoveType removeType = RemoveType.Normal;
|
||
int time = configData.removeTypeS[removeType].defaultTime;
|
||
if (args != null && args.Length > 0)
|
||
{
|
||
switch (args[0].ToLower())
|
||
{
|
||
case "n":
|
||
case "normal":
|
||
break;
|
||
|
||
case "a":
|
||
case "admin":
|
||
removeType = RemoveType.Admin;
|
||
time = configData.removeTypeS[removeType].defaultTime;
|
||
if (!permission.UserHasPermission(player.UserIDString, PERMISSION_ADMIN))
|
||
{
|
||
Print(player, Lang("NotAllowed", player.UserIDString, PERMISSION_ADMIN));
|
||
return;
|
||
}
|
||
break;
|
||
|
||
case "all":
|
||
removeType = RemoveType.All;
|
||
time = configData.removeTypeS[removeType].defaultTime;
|
||
if (!permission.UserHasPermission(player.UserIDString, PERMISSION_ALL))
|
||
{
|
||
Print(player, Lang("NotAllowed", player.UserIDString, PERMISSION_ALL));
|
||
return;
|
||
}
|
||
break;
|
||
|
||
case "s":
|
||
case "structure":
|
||
removeType = RemoveType.Structure;
|
||
time = configData.removeTypeS[removeType].defaultTime;
|
||
if (!permission.UserHasPermission(player.UserIDString, PERMISSION_STRUCTURE))
|
||
{
|
||
Print(player, Lang("NotAllowed", player.UserIDString, PERMISSION_STRUCTURE));
|
||
return;
|
||
}
|
||
break;
|
||
|
||
case "e":
|
||
case "external":
|
||
removeType = RemoveType.External;
|
||
time = configData.removeTypeS[removeType].defaultTime;
|
||
if (!permission.UserHasPermission(player.UserIDString, PERMISSION_EXTERNAL))
|
||
{
|
||
Print(player, Lang("NotAllowed", player.UserIDString, PERMISSION_EXTERNAL));
|
||
return;
|
||
}
|
||
break;
|
||
|
||
case "h":
|
||
case "help":
|
||
StringBuilder stringBuilder = new StringBuilder();
|
||
stringBuilder.AppendLine(Lang("Syntax", player.UserIDString, configData.chatS.command, GetRemoveTypeName(RemoveType.Normal)));
|
||
stringBuilder.AppendLine(Lang("Syntax1", player.UserIDString, configData.chatS.command, GetRemoveTypeName(RemoveType.Admin)));
|
||
stringBuilder.AppendLine(Lang("Syntax2", player.UserIDString, configData.chatS.command, GetRemoveTypeName(RemoveType.All)));
|
||
stringBuilder.AppendLine(Lang("Syntax3", player.UserIDString, configData.chatS.command, GetRemoveTypeName(RemoveType.Structure)));
|
||
stringBuilder.AppendLine(Lang("Syntax4", player.UserIDString, configData.chatS.command, GetRemoveTypeName(RemoveType.External)));
|
||
Print(player, stringBuilder.ToString());
|
||
return;
|
||
|
||
default:
|
||
if (int.TryParse(args[0], out time)) break;
|
||
Print(player, Lang("SyntaxError", player.UserIDString, configData.chatS.command));
|
||
return;
|
||
}
|
||
}
|
||
if (args != null && args.Length > 1) int.TryParse(args[1], out time);
|
||
ToggleRemove(player, removeType, time);
|
||
}
|
||
|
||
private bool ToggleRemove(BasePlayer player, RemoveType removeType, int time = 0)
|
||
{
|
||
if (removeType == RemoveType.Normal && !permission.UserHasPermission(player.UserIDString, PERMISSION_NORMAL))
|
||
{
|
||
Print(player, Lang("NotAllowed", player.UserIDString, PERMISSION_NORMAL));
|
||
return false;
|
||
}
|
||
|
||
int maxRemovable = 0;
|
||
bool pay = false, refund = false;
|
||
var removeTypeS = configData.removeTypeS[removeType];
|
||
float distance = removeTypeS.distance;
|
||
int maxTime = removeTypeS.maxTime;
|
||
bool resetTime = removeTypeS.resetTime;
|
||
float interval = configData.globalS.removeInterval;
|
||
if (removeType == RemoveType.Normal)
|
||
{
|
||
var permissionS = GetPermissionS(player);
|
||
var cooldown = permissionS.cooldown;
|
||
if (cooldown > 0 && !(configData.globalS.cooldownExclude && player.IsAdmin))
|
||
{
|
||
float lastUse;
|
||
if (cooldownTimes.TryGetValue(player.userID, out lastUse))
|
||
{
|
||
var timeLeft = cooldown - (Time.realtimeSinceStartup - lastUse);
|
||
if (timeLeft > 0)
|
||
{
|
||
Print(player, Lang("Cooldown", player.UserIDString, Math.Ceiling(timeLeft)));
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
if (removeMode == RemoveMode.MeleeHit && configData.removerModeS.meleeHitRequires)
|
||
{
|
||
if (!IsMeleeTool(player))
|
||
{
|
||
Print(player, Lang("MeleeToolNotHeld", player.UserIDString));
|
||
return false;
|
||
}
|
||
}
|
||
if (removeMode == RemoveMode.SpecificTool && configData.removerModeS.specificToolRequires)
|
||
{
|
||
if (!IsSpecificTool(player))
|
||
{
|
||
Print(player, Lang("SpecificToolNotHeld", player.UserIDString));
|
||
return false;
|
||
}
|
||
}
|
||
|
||
interval = permissionS.removeInterval;
|
||
resetTime = permissionS.resetTime;
|
||
maxTime = permissionS.maxTime;
|
||
maxRemovable = permissionS.maxRemovable;
|
||
if (configData.globalS.maxRemovableExclude && player.IsAdmin) maxRemovable = 0;
|
||
distance = permissionS.distance;
|
||
pay = permissionS.pay;
|
||
refund = permissionS.refund;
|
||
}
|
||
if (time == 0) time = configData.removeTypeS[removeType].defaultTime;
|
||
if (time > maxTime) time = maxTime;
|
||
var toolRemover = player.GetComponent<ToolRemover>();
|
||
if (toolRemover == null)
|
||
{
|
||
toolRemover = player.gameObject.AddComponent<ToolRemover>();
|
||
}
|
||
else if (toolRemover.removeType == RemoveType.Normal)
|
||
{
|
||
if (!configData.globalS.startCooldownOnRemoved)
|
||
{
|
||
cooldownTimes[player.userID] = Time.realtimeSinceStartup;
|
||
}
|
||
}
|
||
toolRemover.Init(removeType, time, maxRemovable, distance, interval, pay, refund, resetTime, true);
|
||
Print(player, Lang("ToolEnabled", player.UserIDString, time, maxRemovable == 0 ? Lang("Unlimit", player.UserIDString) : maxRemovable.ToString(), GetRemoveTypeName(removeType)));
|
||
return true;
|
||
}
|
||
|
||
[ConsoleCommand("remove.toggle")]
|
||
private void CCmdRemoveToggle(ConsoleSystem.Arg arg)
|
||
{
|
||
var player = arg.Player();
|
||
if (player == null)
|
||
{
|
||
Print(arg, "Syntax error!!! Please type the commands in the F1 console");
|
||
return;
|
||
}
|
||
CmdRemove(player, string.Empty, arg.Args);
|
||
}
|
||
|
||
[ConsoleCommand("remove.target")]
|
||
private void CCmdRemoveTarget(ConsoleSystem.Arg arg)
|
||
{
|
||
if (arg.Args == null || arg.Args.Length <= 1)
|
||
{
|
||
StringBuilder stringBuilder = new StringBuilder();
|
||
stringBuilder.AppendLine("Syntax error of target command");
|
||
stringBuilder.AppendLine("remove.target <disable | d> <player (name or id)> - Disable remover tool for player");
|
||
stringBuilder.AppendLine("remove.target <normal | n> <player (name or id)> [time (seconds)] [max removable objects (integer)] - Enable remover tool for player (Normal)");
|
||
stringBuilder.AppendLine("remove.target <admin | a> <player (name or id)> [time (seconds)] - Enable remover tool for player (Admin)");
|
||
stringBuilder.AppendLine("remove.target <all> <player (name or id)> [time (seconds)] - Enable remover tool for player (All)");
|
||
stringBuilder.AppendLine("remove.target <structure | s> <player (name or id)> [time (seconds)] - Enable remover tool for player (Structure)");
|
||
stringBuilder.AppendLine("remove.target <external | e> <player (name or id)> [time (seconds)] - Enable remover tool for player (External)");
|
||
Print(arg, stringBuilder.ToString());
|
||
return;
|
||
}
|
||
var player = arg.Player();
|
||
if (player != null && !permission.UserHasPermission(player.UserIDString, PERMISSION_TARGET))
|
||
{
|
||
Print(arg, Lang("NotAllowed", player.UserIDString, PERMISSION_TARGET));
|
||
return;
|
||
}
|
||
var target = RustCore.FindPlayer(arg.Args[1]);
|
||
if (target == null || !target.IsConnected)
|
||
{
|
||
Print(arg, target == null ? $"'{arg.Args[0]}' cannot be found." : $"'{target}' is offline.");
|
||
return;
|
||
}
|
||
RemoveType removeType = RemoveType.Normal;
|
||
switch (arg.Args[0].ToLower())
|
||
{
|
||
case "n":
|
||
case "normal":
|
||
break;
|
||
|
||
case "a":
|
||
case "admin":
|
||
removeType = RemoveType.Admin;
|
||
break;
|
||
|
||
case "all":
|
||
removeType = RemoveType.All;
|
||
break;
|
||
|
||
case "s":
|
||
case "structure":
|
||
removeType = RemoveType.Structure;
|
||
break;
|
||
|
||
case "e":
|
||
case "external":
|
||
removeType = RemoveType.External;
|
||
break;
|
||
|
||
case "d":
|
||
case "disable":
|
||
var toolRemover = target.GetComponent<ToolRemover>();
|
||
if (toolRemover != null)
|
||
{
|
||
toolRemover.DisableTool();
|
||
Print(arg, $"{target}'s remover tool is disabled");
|
||
}
|
||
else Print(arg, $"{target} did not enable the remover tool");
|
||
return;
|
||
|
||
default:
|
||
StringBuilder stringBuilder = new StringBuilder();
|
||
stringBuilder.AppendLine("Syntax error of target command");
|
||
stringBuilder.AppendLine("remove.target <disable | d> <player (name or id)> - Disable remover tool for player");
|
||
stringBuilder.AppendLine("remove.target <normal | n> <player (name or id)> [time (seconds)] [max removable objects (integer)] - Enable remover tool for player (Normal)");
|
||
stringBuilder.AppendLine("remove.target <admin | a> <player (name or id)> [time (seconds)] - Enable remover tool for player (Admin)");
|
||
stringBuilder.AppendLine("remove.target <all> <player (name or id)> [time (seconds)] - Enable remover tool for player (All)");
|
||
stringBuilder.AppendLine("remove.target <structure | s> <player (name or id)> [time (seconds)] - Enable remover tool for player (Structure)");
|
||
stringBuilder.AppendLine("remove.target <external | e> <player (name or id)> [time (seconds)] - Enable remover tool for player (External)");
|
||
Print(arg, stringBuilder.ToString());
|
||
return;
|
||
}
|
||
int maxRemovable = 0;
|
||
int time = configData.removeTypeS[removeType].defaultTime;
|
||
if (arg.Args.Length > 2) int.TryParse(arg.Args[2], out time);
|
||
if (arg.Args.Length > 3 && removeType == RemoveType.Normal) int.TryParse(arg.Args[3], out maxRemovable);
|
||
var targetRemover = target.GetComponent<ToolRemover>();
|
||
if (targetRemover == null) targetRemover = target.gameObject.AddComponent<ToolRemover>();
|
||
var permissionS = configData.permS[PERMISSION_NORMAL];
|
||
targetRemover.Init(removeType, time, maxRemovable, configData.removeTypeS[removeType].distance, permissionS.removeInterval, permissionS.pay, permissionS.refund, permissionS.resetTime, false);
|
||
Print(arg, Lang("TargetEnabled", player?.UserIDString, target, time, maxRemovable, GetRemoveTypeName(removeType)));
|
||
}
|
||
|
||
[ConsoleCommand("remove.building")]
|
||
private void CCmdConstruction(ConsoleSystem.Arg arg)
|
||
{
|
||
if (arg.Args == null || arg.Args.Length <= 1 || !arg.IsAdmin)
|
||
{
|
||
Print(arg, $"Syntax error, Please type 'remove.building <price / refund / priceP / refundP> <percentage>', e.g.'remove.building price 60'");
|
||
return;
|
||
}
|
||
float value;
|
||
switch (arg.Args[0].ToLower())
|
||
{
|
||
case "price":
|
||
if (!float.TryParse(arg.Args[1], out value)) value = 50f;
|
||
foreach (var construction in constructions)
|
||
{
|
||
ConfigData.RemoveSettings.BuildingBlocksS buildingBlocksS;
|
||
if (configData.removeS.buildingBlockS.TryGetValue(construction.info.name.english, out buildingBlocksS))
|
||
{
|
||
foreach (var entry in buildingBlocksS.buildingGradeS)
|
||
{
|
||
var grade = construction.grades[(int)entry.Key];
|
||
entry.Value.price = grade.costToBuild.ToDictionary(x => x.itemDef.shortname, y => value <= 0 ? 0 : Mathf.RoundToInt(y.amount * value / 100));
|
||
}
|
||
}
|
||
}
|
||
Print(arg, $"Successfully modified all building prices to {value}% of the initial cost.");
|
||
SaveConfig();
|
||
return;
|
||
|
||
case "refund":
|
||
if (!float.TryParse(arg.Args[1], out value)) value = 40f;
|
||
foreach (var construction in constructions)
|
||
{
|
||
ConfigData.RemoveSettings.BuildingBlocksS buildingBlocksS;
|
||
if (configData.removeS.buildingBlockS.TryGetValue(construction.info.name.english, out buildingBlocksS))
|
||
{
|
||
foreach (var entry in buildingBlocksS.buildingGradeS)
|
||
{
|
||
var grade = construction.grades[(int)entry.Key];
|
||
entry.Value.refund = grade.costToBuild.ToDictionary(x => x.itemDef.shortname, y => value <= 0 ? 0 : Mathf.RoundToInt(y.amount * value / 100));
|
||
}
|
||
}
|
||
}
|
||
Print(arg, $"Successfully modified all building refunds to {value}% of the initial cost.");
|
||
SaveConfig();
|
||
return;
|
||
|
||
case "pricep":
|
||
if (!float.TryParse(arg.Args[1], out value)) value = 40f;
|
||
foreach (var buildingBlockS in configData.removeS.buildingBlockS.Values)
|
||
{
|
||
foreach (var data in buildingBlockS.buildingGradeS.Values)
|
||
data.price = value <= 0 ? 0 : value;
|
||
}
|
||
|
||
Print(arg, $"Successfully modified all building prices to {value}% of the initial cost.");
|
||
SaveConfig();
|
||
return;
|
||
|
||
case "refundp":
|
||
if (!float.TryParse(arg.Args[1], out value)) value = 50f;
|
||
foreach (var buildingBlockS in configData.removeS.buildingBlockS.Values)
|
||
{
|
||
foreach (var data in buildingBlockS.buildingGradeS.Values)
|
||
data.refund = value <= 0 ? 0 : value;
|
||
}
|
||
|
||
Print(arg, $"Successfully modified all building refunds to {value}% of the initial cost.");
|
||
SaveConfig();
|
||
return;
|
||
|
||
default:
|
||
Print(arg, $"Syntax error, Please type 'remove.building <price / refund / priceP / refundP> <percentage>', e.g.'remove.building price 60'");
|
||
return;
|
||
}
|
||
}
|
||
|
||
[ConsoleCommand("remove.allow")]
|
||
private void CCmdRemoveAllow(ConsoleSystem.Arg arg)
|
||
{
|
||
if (arg.Args == null || arg.Args.Length == 0)
|
||
{
|
||
Print(arg, "Syntax error, Please type 'remove.allow <true | false>'");
|
||
return;
|
||
}
|
||
var player = arg.Player();
|
||
if (player != null && !permission.UserHasPermission(player.UserIDString, PERMISSION_OVERRIDE))
|
||
{
|
||
Print(arg, Lang("NotAllowed", player.UserIDString, PERMISSION_OVERRIDE));
|
||
return;
|
||
}
|
||
switch (arg.Args[0].ToLower())
|
||
{
|
||
case "true":
|
||
case "1":
|
||
removeOverride = false;
|
||
Print(arg, "Remove is now allowed depending on your settings.");
|
||
return;
|
||
|
||
case "false":
|
||
case "0":
|
||
removeOverride = true;
|
||
Print(arg, "Remove is now restricted for all players (exept admins)");
|
||
foreach (var p in BasePlayer.activePlayerList)
|
||
{
|
||
var toolRemover = p.GetComponent<ToolRemover>();
|
||
if (toolRemover == null) continue;
|
||
if (toolRemover.removeType == RemoveType.Normal && toolRemover.canOverride)
|
||
{
|
||
Print(toolRemover.player, "The remover tool has been disabled by the admin");
|
||
toolRemover.DisableTool(false);
|
||
}
|
||
}
|
||
return;
|
||
|
||
default:
|
||
Print(arg, "This is not a valid argument");
|
||
return;
|
||
}
|
||
}
|
||
|
||
[ConsoleCommand("remove.playerentity")]
|
||
private void CCmdRemoveEntity(ConsoleSystem.Arg arg)
|
||
{
|
||
if (arg.Args == null || arg.Args.Length <= 1 || !arg.IsAdmin)
|
||
{
|
||
StringBuilder stringBuilder = new StringBuilder();
|
||
stringBuilder.AppendLine("Syntax error of remove.playerentity command");
|
||
stringBuilder.AppendLine("remove.playerentity <all | a> <player id> - Remove all entities of the player");
|
||
stringBuilder.AppendLine("remove.playerentity <building | b> <player id> - Remove all buildings of the player");
|
||
stringBuilder.AppendLine("remove.playerentity <cupboard | c> <player id> - Remove buildings of the player owned cupboard");
|
||
Print(arg, stringBuilder.ToString());
|
||
return;
|
||
}
|
||
if (removePlayerEntityCoroutine != null)
|
||
{
|
||
Print(arg, "There is already a RemovePlayerEntity running, please wait.");
|
||
return;
|
||
}
|
||
ulong targetID;
|
||
if (!ulong.TryParse(arg.Args[1], out targetID) || !targetID.IsSteamId())
|
||
{
|
||
Print(arg, "Please enter the player's steamID.");
|
||
return;
|
||
}
|
||
RemovePlayerEntityType removePlayerEntityType;
|
||
switch (arg.Args[0].ToLower())
|
||
{
|
||
case "a":
|
||
case "all":
|
||
removePlayerEntityType = RemovePlayerEntityType.All;
|
||
break;
|
||
|
||
case "b":
|
||
case "building":
|
||
removePlayerEntityType = RemovePlayerEntityType.Building;
|
||
break;
|
||
|
||
case "c":
|
||
case "cupboard":
|
||
removePlayerEntityType = RemovePlayerEntityType.Cupboard;
|
||
break;
|
||
|
||
default:
|
||
Print(arg, "This is not a valid argument");
|
||
return;
|
||
}
|
||
removePlayerEntityCoroutine = ServerMgr.Instance.StartCoroutine(RemovePlayerEntity(arg, targetID, removePlayerEntityType));
|
||
Print(arg, "Start running RemovePlayerEntity, please wait.");
|
||
}
|
||
|
||
#endregion Commands
|
||
|
||
#region ConfigurationFile
|
||
|
||
private void UpdateConfig()
|
||
{
|
||
var buildingGrades = new[] { BuildingGrade.Enum.Twigs, BuildingGrade.Enum.Wood, BuildingGrade.Enum.Stone, BuildingGrade.Enum.Metal, BuildingGrade.Enum.TopTier };
|
||
foreach (var value in buildingGrades)
|
||
{
|
||
if (!configData.removeS.validConstruction.ContainsKey(value))
|
||
{
|
||
configData.removeS.validConstruction.Add(value, true);
|
||
}
|
||
}
|
||
|
||
var newBuildingBlocksS = new Dictionary<string, ConfigData.RemoveSettings.BuildingBlocksS>();
|
||
foreach (var construction in constructions)
|
||
{
|
||
ConfigData.RemoveSettings.BuildingBlocksS buildingBlocksS;
|
||
if (!configData.removeS.buildingBlockS.TryGetValue(construction.info.name.english, out buildingBlocksS))
|
||
{
|
||
var buildingGrade = new Dictionary<BuildingGrade.Enum, ConfigData.RemoveSettings.BuildingBlocksS.BuildingGradeS>();
|
||
foreach (var value in buildingGrades)
|
||
{
|
||
var grade = construction.grades[(int)value];
|
||
buildingGrade.Add(value, new ConfigData.RemoveSettings.BuildingBlocksS.BuildingGradeS { refund = grade.costToBuild.ToDictionary(x => x.itemDef.shortname, y => Mathf.RoundToInt(y.amount * 0.4f)), price = grade.costToBuild.ToDictionary(x => x.itemDef.shortname, y => Mathf.RoundToInt(y.amount * 0.6f)) });
|
||
}
|
||
buildingBlocksS = new ConfigData.RemoveSettings.BuildingBlocksS { displayName = construction.info.name.english, buildingGradeS = buildingGrade };
|
||
}
|
||
newBuildingBlocksS.Add(construction.info.name.english, buildingBlocksS);
|
||
}
|
||
configData.removeS.buildingBlockS = newBuildingBlocksS;
|
||
|
||
foreach (var entry in shorPrefabNameToDeployable)
|
||
{
|
||
ConfigData.RemoveSettings.EntityS entityS;
|
||
if (!configData.removeS.entityS.TryGetValue(entry.Key, out entityS))
|
||
{
|
||
var itemDefinition = ItemManager.FindItemDefinition(entry.Value);
|
||
entityS = new ConfigData.RemoveSettings.EntityS
|
||
{
|
||
enabled = itemDefinition.category != ItemCategory.Food,
|
||
displayName = itemDefinition.displayName.english,
|
||
refund = new Dictionary<string, int> { [entry.Value] = 1 },
|
||
price = new Dictionary<string, int>()
|
||
};
|
||
configData.removeS.entityS.Add(entry.Key, entityS);
|
||
}
|
||
}
|
||
SaveConfig();
|
||
}
|
||
|
||
private static ConfigData configData;
|
||
|
||
private class ConfigData
|
||
{
|
||
[JsonProperty(PropertyName = "Settings")]
|
||
public GlobalSettings globalS = new GlobalSettings();
|
||
|
||
public class GlobalSettings
|
||
{
|
||
[JsonProperty(PropertyName = "Use Teams")]
|
||
public bool useTeams = false;
|
||
|
||
[JsonProperty(PropertyName = "Use Clans")]
|
||
public bool useClans = true;
|
||
|
||
[JsonProperty(PropertyName = "Use Friends")]
|
||
public bool useFriends = true;
|
||
|
||
[JsonProperty(PropertyName = "Use Entity Owners")]
|
||
public bool useEntityOwners = true;
|
||
|
||
[JsonProperty(PropertyName = "Use Building Locks")]
|
||
public bool useBuildingLocks = false;
|
||
|
||
[JsonProperty(PropertyName = "Use Tool Cupboards (Strongly unrecommended)")]
|
||
public bool useToolCupboards = false;
|
||
|
||
[JsonProperty(PropertyName = "Use Building Owners (You will need BuildingOwners plugin)")]
|
||
public bool useBuildingOwners = false;
|
||
|
||
//[JsonProperty(PropertyName = "Exclude Twigs (Used for \"Use Tool Cupboards\" and \"Use Entity Owners\")")]
|
||
//public bool excludeTwigs;
|
||
|
||
[JsonProperty(PropertyName = "Remove Button")]
|
||
public string removeButton = BUTTON.FIRE_PRIMARY.ToString();
|
||
|
||
[JsonProperty(PropertyName = "Remove Interval (Min = 0.2)")]
|
||
public float removeInterval = 0.5f;
|
||
|
||
[JsonProperty(PropertyName = "Only start cooldown when an entity is removed")]
|
||
public bool startCooldownOnRemoved;
|
||
|
||
[JsonProperty(PropertyName = "RemoveType - All/Structure - Remove per frame")]
|
||
public int removePerFrame = 15;
|
||
|
||
[JsonProperty(PropertyName = "RemoveType - All/Structure - No item container dropped")]
|
||
public bool noItemContainerDrop = true;
|
||
|
||
[JsonProperty(PropertyName = "RemoveType - Normal - Max Removable Objects - Exclude admins")]
|
||
public bool maxRemovableExclude = true;
|
||
|
||
[JsonProperty(PropertyName = "RemoveType - Normal - Cooldown - Exclude admins")]
|
||
public bool cooldownExclude = true;
|
||
|
||
[JsonProperty(PropertyName = "RemoveType - Normal - Check stash under the foundation")]
|
||
public bool checkStash = false;
|
||
|
||
[JsonProperty(PropertyName = "RemoveType - Normal - Entity Spawned Time Limit - Enabled")]
|
||
public bool entityTimeLimit = false;
|
||
|
||
[JsonProperty(PropertyName = "RemoveType - Normal - Entity Spawned Time Limit - Cannot be removed when entity spawned time more than it")]
|
||
public float limitTime = 300f;
|
||
}
|
||
|
||
[JsonProperty(PropertyName = "Container Settings")]
|
||
public ContainerSettings containerS = new ContainerSettings();
|
||
|
||
public class ContainerSettings
|
||
{
|
||
[JsonProperty(PropertyName = "Storage Container - Enable remove of not empty storages")]
|
||
public bool removeNotEmptyStorage = true;
|
||
|
||
[JsonProperty(PropertyName = "Storage Container - Drop items from container")]
|
||
public bool dropItemsStorage = false;
|
||
|
||
[JsonProperty(PropertyName = "Storage Container - Drop a item container from container")]
|
||
public bool dropContainerStorage = true;
|
||
|
||
[JsonProperty(PropertyName = "IOEntity Container - Enable remove of not empty storages")]
|
||
public bool removeNotEmptyIoEntity = true;
|
||
|
||
[JsonProperty(PropertyName = "IOEntity Container - Drop items from container")]
|
||
public bool dropItemsIoEntity = false;
|
||
|
||
[JsonProperty(PropertyName = "IOEntity Container - Drop a item container from container")]
|
||
public bool dropContainerIoEntity = true;
|
||
}
|
||
|
||
[JsonProperty(PropertyName = "Remove Damaged Entities")]
|
||
public DamagedEntitySettings damagedEntityS = new DamagedEntitySettings();
|
||
|
||
public class DamagedEntitySettings
|
||
{
|
||
[JsonProperty(PropertyName = "Enabled")]
|
||
public bool enabled = false;
|
||
|
||
[JsonProperty(PropertyName = "Exclude Building Blocks")]
|
||
public bool excludeBuildingBlocks = true;
|
||
|
||
[JsonProperty(PropertyName = "Percentage (Can be removed when (health / max health * 100) is not less than it)")]
|
||
public float percentage = 90f;
|
||
}
|
||
|
||
[JsonProperty(PropertyName = "Chat Settings")]
|
||
public ChatSettings chatS = new ChatSettings();
|
||
|
||
public class ChatSettings
|
||
{
|
||
[JsonProperty(PropertyName = "Chat Command")]
|
||
public string command = "remove";
|
||
|
||
[JsonProperty(PropertyName = "Chat Prefix")]
|
||
public string prefix = "<color=#00FFFF>[RemoverTool]</color>: ";
|
||
|
||
[JsonProperty(PropertyName = "Chat SteamID Icon")]
|
||
public ulong steamIDIcon = 0;
|
||
}
|
||
|
||
[JsonProperty(PropertyName = "Permission Settings (Just for normal type)")]
|
||
public Dictionary<string, PermSettings> permS = new Dictionary<string, PermSettings>
|
||
{
|
||
[PERMISSION_NORMAL] = new PermSettings { priority = 0, distance = 3, cooldown = 60, maxTime = 300, maxRemovable = 50, removeInterval = 0.8f, pay = true, refund = true, resetTime = false }
|
||
};
|
||
|
||
public class PermSettings
|
||
{
|
||
[JsonProperty(PropertyName = "Priority")]
|
||
public int priority;
|
||
|
||
[JsonProperty(PropertyName = "Distance")]
|
||
public float distance;
|
||
|
||
[JsonProperty(PropertyName = "Cooldown")]
|
||
public float cooldown;
|
||
|
||
[JsonProperty(PropertyName = "Max Time")]
|
||
public int maxTime;
|
||
|
||
[JsonProperty(PropertyName = "Remove Interval (Min = 0.2)")]
|
||
public float removeInterval;
|
||
|
||
[JsonProperty(PropertyName = "Max Removable Objects (0 = Unlimit)")]
|
||
public int maxRemovable;
|
||
|
||
[JsonProperty(PropertyName = "Pay")]
|
||
public bool pay;
|
||
|
||
[JsonProperty(PropertyName = "Refund")]
|
||
public bool refund;
|
||
|
||
[JsonProperty(PropertyName = "Reset the time after removing an entity")]
|
||
public bool resetTime;
|
||
}
|
||
|
||
[JsonProperty(PropertyName = "Remove Type Settings")]
|
||
public Dictionary<RemoveType, RemoveTypeSettings> removeTypeS = new Dictionary<RemoveType, RemoveTypeSettings>
|
||
{
|
||
[RemoveType.Normal] = new RemoveTypeSettings { displayName = RemoveType.Normal.ToString(), distance = 3, gibs = true, defaultTime = 60, maxTime = 300, resetTime = false },
|
||
[RemoveType.Structure] = new RemoveTypeSettings { displayName = RemoveType.Structure.ToString(), distance = 100, gibs = false, defaultTime = 300, maxTime = 600, resetTime = true },
|
||
[RemoveType.All] = new RemoveTypeSettings { displayName = RemoveType.All.ToString(), distance = 50, gibs = false, defaultTime = 300, maxTime = 600, resetTime = true },
|
||
[RemoveType.Admin] = new RemoveTypeSettings { displayName = RemoveType.Admin.ToString(), distance = 20, gibs = true, defaultTime = 300, maxTime = 600, resetTime = true },
|
||
[RemoveType.External] = new RemoveTypeSettings { displayName = RemoveType.External.ToString(), distance = 20, gibs = true, defaultTime = 300, maxTime = 600, resetTime = true }
|
||
};
|
||
|
||
public class RemoveTypeSettings
|
||
{
|
||
[JsonProperty(PropertyName = "Display Name")]
|
||
public string displayName;
|
||
|
||
[JsonProperty(PropertyName = "Distance")]
|
||
public float distance;
|
||
|
||
[JsonProperty(PropertyName = "Default Time")]
|
||
public int defaultTime;
|
||
|
||
[JsonProperty(PropertyName = "Max Time")]
|
||
public int maxTime;
|
||
|
||
[JsonProperty(PropertyName = "Gibs")]
|
||
public bool gibs;
|
||
|
||
[JsonProperty(PropertyName = "Reset the time after removing an entity")]
|
||
public bool resetTime;
|
||
}
|
||
|
||
[JsonProperty(PropertyName = "Remove Mode Settings (Only one model works)")]
|
||
public RemoverModeSettings removerModeS = new RemoverModeSettings();
|
||
|
||
public class RemoverModeSettings
|
||
{
|
||
[JsonProperty(PropertyName = "No Held Item Mode")]
|
||
public bool noHeldMode = true;
|
||
|
||
[JsonProperty(PropertyName = "No Held Item Mode - Disable remover tool when you have any item in hand")]
|
||
public bool noHeldDisableInHand = true;
|
||
|
||
[JsonProperty(PropertyName = "No Held Item Mode - Show Crosshair")]
|
||
public bool showCrosshair = true;
|
||
|
||
[JsonProperty(PropertyName = "No Held Item Mode - Crosshair Image Url")]
|
||
public string crosshairImageUrl = "https://i.imgur.com/SqLCJaQ.png";
|
||
|
||
[JsonProperty(PropertyName = "No Held Item Mode - Crosshair Box - Min Anchor (in Rust Window)")]
|
||
public string crosshairAnchorMin = "0.5 0.5";
|
||
|
||
[JsonProperty(PropertyName = "No Held Item Mode - Crosshair Box - Max Anchor (in Rust Window)")]
|
||
public string crosshairAnchorMax = "0.5 0.5";
|
||
|
||
[JsonProperty(PropertyName = "No Held Item Mode - Crosshair Box - Min Offset (in Rust Window)")]
|
||
public string crosshairOffsetMin = "-15 -15";
|
||
|
||
[JsonProperty(PropertyName = "No Held Item Mode - Crosshair Box - Max Offset (in Rust Window)")]
|
||
public string crosshairOffsetMax = "15 15";
|
||
|
||
[JsonProperty(PropertyName = "No Held Item Mode - Crosshair Box - Image Color")]
|
||
public string crosshairColor = "1 0 0 1";
|
||
|
||
[JsonProperty(PropertyName = "Melee Tool Hit Mode")]
|
||
public bool meleeHitMode = false;
|
||
|
||
[JsonProperty(PropertyName = "Melee Tool Hit Mode - Item shortname")]
|
||
public string meleeHitItemShortname = "hammer";
|
||
|
||
[JsonProperty(PropertyName = "Melee Tool Hit Mode - Item skin (-1 = All skins)")]
|
||
public long meleeHitModeSkin = -1;
|
||
|
||
[JsonProperty(PropertyName = "Melee Tool Hit Mode - Auto enable remover tool when you hold a melee tool")]
|
||
public bool meleeHitEnableInHand = false;
|
||
|
||
[JsonProperty(PropertyName = "Melee Tool Hit Mode - Requires a melee tool in your hand when remover tool is enabled")]
|
||
public bool meleeHitRequires = false;
|
||
|
||
[JsonProperty(PropertyName = "Melee Tool Hit Mode - Disable remover tool when you are not holding a melee tool")]
|
||
public bool meleeHitDisableInHand = false;
|
||
|
||
[JsonProperty(PropertyName = "Specific Tool Mode")]
|
||
public bool specificToolMode = false;
|
||
|
||
[JsonProperty(PropertyName = "Specific Tool Mode - Item shortname")]
|
||
public string specificToolShortname = "hammer";
|
||
|
||
[JsonProperty(PropertyName = "Specific Tool Mode - Item skin (-1 = All skins)")]
|
||
public long specificToolSkin = -1;
|
||
|
||
[JsonProperty(PropertyName = "Specific Tool Mode - Auto enable remover tool when you hold a specific tool")]
|
||
public bool specificToolEnableInHand = false;
|
||
|
||
[JsonProperty(PropertyName = "Specific Tool Mode - Requires a specific tool in your hand when remover tool is enabled")]
|
||
public bool specificToolRequires = false;
|
||
|
||
[JsonProperty(PropertyName = "Specific Tool Mode - Disable remover tool when you are not holding a specific tool")]
|
||
public bool specificToolDisableInHand = false;
|
||
}
|
||
|
||
[JsonProperty(PropertyName = "Raid Blocker Settings")]
|
||
public RaidBlockerSettings raidS = new RaidBlockerSettings();
|
||
|
||
public class RaidBlockerSettings
|
||
{
|
||
[JsonProperty(PropertyName = "Enabled")]
|
||
public bool enabled = false;
|
||
|
||
[JsonProperty(PropertyName = "Block Time")]
|
||
public float blockTime = 300;
|
||
|
||
[JsonProperty(PropertyName = "By Buildings")]
|
||
public bool blockBuildingID = true;
|
||
|
||
[JsonProperty(PropertyName = "By Surrounding Players")]
|
||
public bool blockPlayers = true;
|
||
|
||
[JsonProperty(PropertyName = "By Surrounding Players - Radius")]
|
||
public float blockRadius = 120;
|
||
}
|
||
|
||
[JsonProperty(PropertyName = "Image Urls (Used to UI image)")]
|
||
public Dictionary<string, string> imageUrls = new Dictionary<string, string>
|
||
{
|
||
["Economics"] = "https://i.imgur.com/znPwdcv.png",
|
||
["ServerRewards"] = "https://i.imgur.com/04rJsV3.png"
|
||
};
|
||
|
||
[JsonProperty(PropertyName = "Display Names Of Other Things")]
|
||
public Dictionary<string, string> displayNames = new Dictionary<string, string>();
|
||
|
||
[JsonProperty(PropertyName = "GUI")]
|
||
public UiSettings uiS = new UiSettings();
|
||
|
||
public class UiSettings
|
||
{
|
||
[JsonProperty(PropertyName = "Enabled")]
|
||
public bool enabled = true;
|
||
|
||
[JsonProperty(PropertyName = "Main Box - Min Anchor (in Rust Window)")]
|
||
public string removerToolAnchorMin = "0 1";
|
||
|
||
[JsonProperty(PropertyName = "Main Box - Max Anchor (in Rust Window)")]
|
||
public string removerToolAnchorMax = "0 1";
|
||
|
||
[JsonProperty(PropertyName = "Main Box - Min Offset (in Rust Window)")]
|
||
public string removerToolOffsetMin = "30 -330";
|
||
|
||
[JsonProperty(PropertyName = "Main Box - Max Offset (in Rust Window)")]
|
||
public string removerToolOffsetMax = "470 -40";
|
||
|
||
[JsonProperty(PropertyName = "Main Box - Background Color")]
|
||
public string removerToolBackgroundColor = "0 0 0 0";
|
||
|
||
[JsonProperty(PropertyName = "Remove Title - Box - Min Anchor (in Main Box)")]
|
||
public string removeAnchorMin = "0 0.84";
|
||
|
||
[JsonProperty(PropertyName = "Remove Title - Box - Max Anchor (in Main Box)")]
|
||
public string removeAnchorMax = "0.996 1";
|
||
|
||
[JsonProperty(PropertyName = "Remove Title - Box - Background Color")]
|
||
public string removeBackgroundColor = "0.31 0.88 0.71 1";
|
||
|
||
[JsonProperty(PropertyName = "Remove Title - Text - Min Anchor (in Main Box)")]
|
||
public string removeTextAnchorMin = "0.05 0.84";
|
||
|
||
[JsonProperty(PropertyName = "Remove Title - Text - Max Anchor (in Main Box)")]
|
||
public string removeTextAnchorMax = "0.6 1";
|
||
|
||
[JsonProperty(PropertyName = "Remove Title - Text - Text Color")]
|
||
public string removeTextColor = "1 0.1 0.1 1";
|
||
|
||
[JsonProperty(PropertyName = "Remove Title - Text - Text Size")]
|
||
public int removeTextSize = 18;
|
||
|
||
[JsonProperty(PropertyName = "Timeleft - Box - Min Anchor (in Main Box)")]
|
||
public string timeLeftAnchorMin = "0.6 0.84";
|
||
|
||
[JsonProperty(PropertyName = "Timeleft - Box - Max Anchor (in Main Box)")]
|
||
public string timeLeftAnchorMax = "1 1";
|
||
|
||
[JsonProperty(PropertyName = "Timeleft - Box - Background Color")]
|
||
public string timeLeftBackgroundColor = "0 0 0 0";
|
||
|
||
[JsonProperty(PropertyName = "Timeleft - Text - Min Anchor (in Timeleft Box)")]
|
||
public string timeLeftTextAnchorMin = "0 0";
|
||
|
||
[JsonProperty(PropertyName = "Timeleft - Text - Max Anchor (in Timeleft Box)")]
|
||
public string timeLeftTextAnchorMax = "0.9 1";
|
||
|
||
[JsonProperty(PropertyName = "Timeleft - Text - Text Color")]
|
||
public string timeLeftTextColor = "0 0 0 0.9";
|
||
|
||
[JsonProperty(PropertyName = "Timeleft - Text - Text Size")]
|
||
public int timeLeftTextSize = 15;
|
||
|
||
[JsonProperty(PropertyName = "Entity - Box - Min Anchor (in Main Box)")]
|
||
public string entityAnchorMin = "0 0.68";
|
||
|
||
[JsonProperty(PropertyName = "Entity - Box - Max Anchor (in Main Box)")]
|
||
public string entityAnchorMax = "1 0.84";
|
||
|
||
[JsonProperty(PropertyName = "Entity - Box - Background Color")]
|
||
public string entityBackgroundColor = "0.82 0.58 0.30 1";
|
||
|
||
[JsonProperty(PropertyName = "Entity - Text - Min Anchor (in Entity Box)")]
|
||
public string entityTextAnchorMin = "0.05 0";
|
||
|
||
[JsonProperty(PropertyName = "Entity - Text - Max Anchor (in Entity Box)")]
|
||
public string entityTextAnchorMax = "1 1";
|
||
|
||
[JsonProperty(PropertyName = "Entity - Text - Text Color")]
|
||
public string entityTextColor = "1 1 1 1";
|
||
|
||
[JsonProperty(PropertyName = "Entity - Text - Text Size")]
|
||
public int entityTextSize = 16;
|
||
|
||
[JsonProperty(PropertyName = "Entity - Image - Enabled")]
|
||
public bool entityImageEnabled = true;
|
||
|
||
[JsonProperty(PropertyName = "Entity - Image - Min Anchor (in Entity Box)")]
|
||
public string entityImageAnchorMin = "0.795 0.01";
|
||
|
||
[JsonProperty(PropertyName = "Entity - Image - Max Anchor (in Entity Box)")]
|
||
public string entityImageAnchorMax = "0.9 0.99";
|
||
|
||
[JsonProperty(PropertyName = "Authorization Check Enabled")]
|
||
public bool authorizationEnabled = true;
|
||
|
||
[JsonProperty(PropertyName = "Authorization Check - Box - Min Anchor (in Main Box)")]
|
||
public string authorizationsAnchorMin = "0 0.6";
|
||
|
||
[JsonProperty(PropertyName = "Authorization Check - Box - Max Anchor (in Main Box)")]
|
||
public string authorizationsAnchorMax = "1 0.68";
|
||
|
||
[JsonProperty(PropertyName = "Authorization Check - Box - Allowed Background Color")]
|
||
public string allowedBackgroundColor = "0.22 0.78 0.27 1";
|
||
|
||
[JsonProperty(PropertyName = "Authorization Check - Box - Refused Background Color")]
|
||
public string refusedBackgroundColor = "0.78 0.22 0.27 1";
|
||
|
||
[JsonProperty(PropertyName = "Authorization Check - Text - Min Anchor (in Authorization Check Box)")]
|
||
public string authorizationsTextAnchorMin = "0.05 0";
|
||
|
||
[JsonProperty(PropertyName = "Authorization Check - Text - Max Anchor (in Authorization Check Box)")]
|
||
public string authorizationsTextAnchorMax = "1 1";
|
||
|
||
[JsonProperty(PropertyName = "Authorization Check - Text - Text Color")]
|
||
public string authorizationsTextColor = "1 1 1 0.9";
|
||
|
||
[JsonProperty(PropertyName = "Authorization Check Box - Text - Text Size")]
|
||
public int authorizationsTextSize = 14;
|
||
|
||
[JsonProperty(PropertyName = "Price & Refund - Image Enabled")]
|
||
public bool imageEnabled = true;
|
||
|
||
[JsonProperty(PropertyName = "Price & Refund - Image Scale")]
|
||
public float imageScale = 0.18f;
|
||
|
||
[JsonProperty(PropertyName = "Price & Refund - Distance of image from right border")]
|
||
public float rightDistance = 0.05f;
|
||
|
||
[JsonProperty(PropertyName = "Price Enabled")]
|
||
public bool priceEnabled = true;
|
||
|
||
[JsonProperty(PropertyName = "Price - Box - Min Anchor (in Main Box)")]
|
||
public string priceAnchorMin = "0 0.3";
|
||
|
||
[JsonProperty(PropertyName = "Price - Box - Max Anchor (in Main Box)")]
|
||
public string priceAnchorMax = "1 0.6";
|
||
|
||
[JsonProperty(PropertyName = "Price - Box - Background Color")]
|
||
public string priceBackgroundColor = "0 0 0 0.8";
|
||
|
||
[JsonProperty(PropertyName = "Price - Text - Min Anchor (in Price Box)")]
|
||
public string priceTextAnchorMin = "0.05 0";
|
||
|
||
[JsonProperty(PropertyName = "Price - Text - Max Anchor (in Price Box)")]
|
||
public string priceTextAnchorMax = "0.25 1";
|
||
|
||
[JsonProperty(PropertyName = "Price - Text - Text Color")]
|
||
public string priceTextColor = "1 1 1 0.9";
|
||
|
||
[JsonProperty(PropertyName = "Price - Text - Text Size")]
|
||
public int priceTextSize = 18;
|
||
|
||
[JsonProperty(PropertyName = "Price - Text2 - Min Anchor (in Price Box)")]
|
||
public string price2TextAnchorMin = "0.3 0";
|
||
|
||
[JsonProperty(PropertyName = "Price - Text2 - Max Anchor (in Price Box)")]
|
||
public string price2TextAnchorMax = "1 1";
|
||
|
||
[JsonProperty(PropertyName = "Price - Text2 - Text Color")]
|
||
public string price2TextColor = "1 1 1 0.9";
|
||
|
||
[JsonProperty(PropertyName = "Price - Text2 - Text Size")]
|
||
public int price2TextSize = 16;
|
||
|
||
[JsonProperty(PropertyName = "Refund Enabled")]
|
||
public bool refundEnabled = true;
|
||
|
||
[JsonProperty(PropertyName = "Refund - Box - Min Anchor (in Main Box)")]
|
||
public string refundAnchorMin = "0 0";
|
||
|
||
[JsonProperty(PropertyName = "Refund - Box - Max Anchor (in Main Box)")]
|
||
public string refundAnchorMax = "1 0.3";
|
||
|
||
[JsonProperty(PropertyName = "Refund - Box - Background Color")]
|
||
public string refundBackgroundColor = "0 0 0 0.8";
|
||
|
||
[JsonProperty(PropertyName = "Refund - Text - Min Anchor (in Refund Box)")]
|
||
public string refundTextAnchorMin = "0.05 0";
|
||
|
||
[JsonProperty(PropertyName = "Refund - Text - Max Anchor (in Refund Box)")]
|
||
public string refundTextAnchorMax = "0.25 1";
|
||
|
||
[JsonProperty(PropertyName = "Refund - Text - Text Color")]
|
||
public string refundTextColor = "1 1 1 0.9";
|
||
|
||
[JsonProperty(PropertyName = "Refund - Text - Text Size")]
|
||
public int refundTextSize = 18;
|
||
|
||
[JsonProperty(PropertyName = "Refund - Text2 - Min Anchor (in Refund Box)")]
|
||
public string refund2TextAnchorMin = "0.3 0";
|
||
|
||
[JsonProperty(PropertyName = "Refund - Text2 - Max Anchor (in Refund Box)")]
|
||
public string refund2TextAnchorMax = "1 1";
|
||
|
||
[JsonProperty(PropertyName = "Refund - Text2 - Text Color")]
|
||
public string refund2TextColor = "1 1 1 0.9";
|
||
|
||
[JsonProperty(PropertyName = "Refund - Text2 - Text Size")]
|
||
public int refund2TextSize = 16;
|
||
|
||
[JsonIgnore]
|
||
public Vector2 Price2TextAnchorMin, Price2TextAnchorMax, Refund2TextAnchorMin, Refund2TextAnchorMax;
|
||
}
|
||
|
||
[JsonProperty(PropertyName = "Remove Info (Refund & Price)")]
|
||
public RemoveSettings removeS = new RemoveSettings();
|
||
|
||
public class RemoveSettings
|
||
{
|
||
[JsonProperty(PropertyName = "Price Enabled")]
|
||
public bool priceEnabled = true;
|
||
|
||
[JsonProperty(PropertyName = "Refund Enabled")]
|
||
public bool refundEnabled = true;
|
||
|
||
[JsonProperty(PropertyName = "Refund Items In Entity Slot")]
|
||
public bool refundSlot = true;
|
||
|
||
[JsonProperty(PropertyName = "Allowed Building Grade")]
|
||
public Dictionary<BuildingGrade.Enum, bool> validConstruction = new Dictionary<BuildingGrade.Enum, bool>();
|
||
|
||
[JsonProperty(PropertyName = "Building Blocks Settings")]
|
||
public Dictionary<string, BuildingBlocksS> buildingBlockS = new Dictionary<string, BuildingBlocksS>();
|
||
|
||
public class BuildingBlocksS
|
||
{
|
||
[JsonProperty(PropertyName = "Display Name")]
|
||
public string displayName;
|
||
|
||
[JsonProperty(PropertyName = "Building Grade")]
|
||
public Dictionary<BuildingGrade.Enum, BuildingGradeS> buildingGradeS = new Dictionary<BuildingGrade.Enum, BuildingGradeS>();
|
||
|
||
public class BuildingGradeS
|
||
{
|
||
[JsonProperty(PropertyName = "Price")]
|
||
public object price;
|
||
|
||
[JsonProperty(PropertyName = "Refund")]
|
||
public object refund;
|
||
|
||
[JsonIgnore] public float pricePercentage = -1, refundPercentage = -1;
|
||
[JsonIgnore] public Dictionary<string, int> priceDic, refundDic;
|
||
}
|
||
}
|
||
|
||
[JsonProperty(PropertyName = "Other Entity Settings")]
|
||
public Dictionary<string, EntityS> entityS = new Dictionary<string, EntityS>();
|
||
|
||
public class EntityS
|
||
{
|
||
[JsonProperty(PropertyName = "Remove Allowed")]
|
||
public bool enabled = false;
|
||
|
||
[JsonProperty(PropertyName = "Display Name")]
|
||
public string displayName = string.Empty;
|
||
|
||
[JsonProperty(PropertyName = "Price")]
|
||
public Dictionary<string, int> price = new Dictionary<string, int>();
|
||
|
||
[JsonProperty(PropertyName = "Refund")]
|
||
public Dictionary<string, int> refund = new Dictionary<string, int>();
|
||
}
|
||
}
|
||
|
||
[JsonProperty(PropertyName = "Version")]
|
||
public VersionNumber version;
|
||
}
|
||
|
||
protected override void LoadConfig()
|
||
{
|
||
base.LoadConfig();
|
||
try
|
||
{
|
||
PreprocessOldConfig();
|
||
configData = Config.ReadObject<ConfigData>();
|
||
if (configData == null)
|
||
{
|
||
LoadDefaultConfig();
|
||
}
|
||
else
|
||
{
|
||
UpdateConfigValues();
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
PrintError($"The configuration file is corrupted. \n{ex}");
|
||
LoadDefaultConfig();
|
||
}
|
||
SaveConfig();
|
||
PreprocessConfigValues();
|
||
}
|
||
|
||
protected override void LoadDefaultConfig()
|
||
{
|
||
PrintWarning("Creating a new configuration file");
|
||
configData = new ConfigData();
|
||
configData.version = Version;
|
||
}
|
||
|
||
protected override void SaveConfig() => Config.WriteObject(configData);
|
||
|
||
private void PreprocessConfigValues()
|
||
{
|
||
configData.uiS.Price2TextAnchorMin = GetAnchor(configData.uiS.price2TextAnchorMin);
|
||
configData.uiS.Price2TextAnchorMax = GetAnchor(configData.uiS.price2TextAnchorMax);
|
||
configData.uiS.Refund2TextAnchorMin = GetAnchor(configData.uiS.refund2TextAnchorMin);
|
||
configData.uiS.Refund2TextAnchorMax = GetAnchor(configData.uiS.refund2TextAnchorMax);
|
||
|
||
foreach (var entry in configData.removeS.buildingBlockS)
|
||
{
|
||
foreach (var gradeEntry in entry.Value.buildingGradeS)
|
||
{
|
||
var price = gradeEntry.Value.price;
|
||
float pricePercentage;
|
||
if (float.TryParse(price.ToString(), out pricePercentage))
|
||
{
|
||
gradeEntry.Value.pricePercentage = pricePercentage;
|
||
}
|
||
else
|
||
{
|
||
var priceDic = price as Dictionary<string, int>;
|
||
if (priceDic != null)
|
||
{
|
||
gradeEntry.Value.priceDic = priceDic;
|
||
}
|
||
else
|
||
{
|
||
try { gradeEntry.Value.priceDic = JsonConvert.DeserializeObject<Dictionary<string, int>>(price.ToString()); }
|
||
catch (Exception e)
|
||
{
|
||
gradeEntry.Value.priceDic = null;
|
||
PrintError($"Wrong price format for '{gradeEntry.Key}' of '{entry.Key}' in 'Building Blocks Settings'. Error Message: {e.Message}");
|
||
}
|
||
}
|
||
}
|
||
|
||
var refund = gradeEntry.Value.refund;
|
||
float refundPercentage;
|
||
if (float.TryParse(refund.ToString(), out refundPercentage))
|
||
{
|
||
gradeEntry.Value.refundPercentage = refundPercentage;
|
||
}
|
||
else
|
||
{
|
||
var refundDic = refund as Dictionary<string, int>;
|
||
if (refundDic != null)
|
||
{
|
||
gradeEntry.Value.refundDic = refundDic;
|
||
}
|
||
else
|
||
{
|
||
try { gradeEntry.Value.refundDic = JsonConvert.DeserializeObject<Dictionary<string, int>>(refund.ToString()); }
|
||
catch (Exception e)
|
||
{
|
||
gradeEntry.Value.refundDic = null;
|
||
PrintError($"Wrong refund format for '{gradeEntry.Key}' of '{entry.Key}' in 'Building Blocks Settings'. Error Message: {e.Message}");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
private void UpdateConfigValues()
|
||
{
|
||
if (configData.version < Version)
|
||
{
|
||
if (configData.version <= default(VersionNumber))
|
||
{
|
||
string prefix, prefixColor;
|
||
if (GetConfigValue(out prefix, "Chat Settings", "Chat Prefix") && GetConfigValue(out prefixColor, "Chat Settings", "Chat Prefix Color"))
|
||
{
|
||
configData.chatS.prefix = $"<color={prefixColor}>{prefix}</color>: ";
|
||
}
|
||
|
||
if (configData.uiS.removerToolAnchorMin == "0.1 0.55")
|
||
{
|
||
configData.uiS.removerToolAnchorMin = "0.04 0.55";
|
||
}
|
||
|
||
if (configData.uiS.removerToolAnchorMax == "0.4 0.95")
|
||
{
|
||
configData.uiS.removerToolAnchorMax = "0.37 0.95";
|
||
}
|
||
}
|
||
|
||
if (configData.version <= new VersionNumber(4, 3, 18))
|
||
{
|
||
configData.removerModeS.crosshairAnchorMin = "0.5 0.5";
|
||
configData.removerModeS.crosshairAnchorMax = "0.5 0.5";
|
||
configData.uiS.removerToolAnchorMin = "0 1";
|
||
configData.uiS.removerToolAnchorMax = "0 1";
|
||
}
|
||
|
||
if (configData.version <= new VersionNumber(4, 3, 21))
|
||
{
|
||
if (configData.removerModeS.crosshairAnchorMin == "0.5 0")
|
||
{
|
||
configData.removerModeS.crosshairAnchorMin = "0.5 0.5";
|
||
}
|
||
if (configData.removerModeS.crosshairAnchorMax == "0.5 0")
|
||
{
|
||
configData.removerModeS.crosshairAnchorMax = "0.5 0.5";
|
||
}
|
||
}
|
||
|
||
if (configData.version <= new VersionNumber(4, 3, 22))
|
||
{
|
||
bool enabled;
|
||
if (GetConfigValue(out enabled, "Remove Mode Settings (Only one model works)", "Hammer Hit Mode"))
|
||
{
|
||
configData.removerModeS.meleeHitMode = true;
|
||
configData.removerModeS.meleeHitItemShortname = "hammer";
|
||
}
|
||
if (GetConfigValue(out enabled, "Remove Mode Settings (Only one model works)", "Hammer Hit Mode - Requires a hammer in your hand when remover tool is enabled"))
|
||
{
|
||
configData.removerModeS.meleeHitRequires = true;
|
||
}
|
||
if (GetConfigValue(out enabled, "Remove Mode Settings (Only one model works)", "Hammer Hit Mode - Disable remover tool when you are not holding a hammer"))
|
||
{
|
||
configData.removerModeS.meleeHitDisableInHand = true;
|
||
}
|
||
}
|
||
|
||
if (configData.version <= new VersionNumber(4, 3, 23))
|
||
{
|
||
string value;
|
||
if (GetConfigValue(out value, "GUI", "Authorization Check - Box - Allowed Background"))
|
||
{
|
||
configData.uiS.allowedBackgroundColor = value == "0 1 0 0.8" ? "0.22 0.78 0.27 1" : value;
|
||
}
|
||
if (GetConfigValue(out value, "GUI", "Authorization Check - Box - Refused Background"))
|
||
{
|
||
configData.uiS.refusedBackgroundColor = value == "1 0 0 0.8" ? "0.78 0.22 0.27 1" : value;
|
||
}
|
||
if (configData.uiS.removeBackgroundColor == "0.42 0.88 0.88 1")
|
||
configData.uiS.removeBackgroundColor = "0.31 0.88 0.71 1";
|
||
if (configData.uiS.entityBackgroundColor == "0 0 0 0.8")
|
||
configData.uiS.entityBackgroundColor = "0.82 0.58 0.30 1";
|
||
}
|
||
configData.version = Version;
|
||
}
|
||
}
|
||
|
||
private bool GetConfigValue<T>(out T value, params string[] path)
|
||
{
|
||
var configValue = Config.Get(path);
|
||
if (configValue != null)
|
||
{
|
||
if (configValue is T)
|
||
{
|
||
value = (T)configValue;
|
||
return true;
|
||
}
|
||
try
|
||
{
|
||
value = Config.ConvertValue<T>(configValue);
|
||
return true;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
PrintError($"GetConfigValue ERROR: path: {string.Join("\\", path)}\n{ex}");
|
||
}
|
||
}
|
||
|
||
value = default(T);
|
||
return false;
|
||
}
|
||
|
||
private void SetConfigValue(params object[] pathAndTrailingValue)
|
||
{
|
||
Config.Set(pathAndTrailingValue);
|
||
}
|
||
|
||
#region Preprocess Old Config
|
||
|
||
private void PreprocessOldConfig()
|
||
{
|
||
var jObject = Config.ReadObject<JObject>();
|
||
if (jObject == null) return;
|
||
//Interface.Oxide.DataFileSystem.WriteObject(Name + "_old", jObject);
|
||
VersionNumber oldVersion;
|
||
if (GetConfigVersionPre(jObject, out oldVersion))
|
||
{
|
||
if (oldVersion < Version)
|
||
{
|
||
//Fixed typos
|
||
if (oldVersion <= new VersionNumber(4, 3, 23))
|
||
{
|
||
foreach (RemoveType value in Enum.GetValues(typeof(RemoveType)))
|
||
{
|
||
if (value == RemoveType.None) continue;
|
||
bool enabled;
|
||
if (GetConfigValuePre(jObject, out enabled, "Remove Type Settings", value.ToString(), "Reset the time after removing a entity"))
|
||
{
|
||
SetConfigValuePre(jObject, enabled, "Remove Type Settings", value.ToString(), "Reset the time after removing an entity");
|
||
}
|
||
}
|
||
Dictionary<string, object> values;
|
||
if (GetConfigValuePre(jObject, out values, "Permission Settings (Just for normal type)"))
|
||
{
|
||
foreach (var entry in values)
|
||
{
|
||
object value;
|
||
if (GetConfigValuePre(jObject, out value, "Permission Settings (Just for normal type)", entry.Key, "Reset the time after removing a entity"))
|
||
{
|
||
SetConfigValuePre(jObject, value, "Permission Settings (Just for normal type)", entry.Key, "Reset the time after removing an entity");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
Config.WriteObject(jObject);
|
||
//Interface.Oxide.DataFileSystem.WriteObject(Name + "_new", jObject);
|
||
}
|
||
}
|
||
}
|
||
|
||
private bool GetConfigValuePre<T>(JObject config, out T value, params string[] path)
|
||
{
|
||
if (path.Length < 1)
|
||
{
|
||
throw new ArgumentException("path is empty");
|
||
}
|
||
|
||
try
|
||
{
|
||
JToken jToken;
|
||
if (!config.TryGetValue(path[0], out jToken))
|
||
{
|
||
value = default(T);
|
||
return false;
|
||
}
|
||
|
||
for (int i = 1; i < path.Length; i++)
|
||
{
|
||
var jObject = jToken.ToObject<JObject>();
|
||
if (jObject == null || !jObject.TryGetValue(path[i], out jToken))
|
||
{
|
||
value = default(T);
|
||
return false;
|
||
}
|
||
}
|
||
value = jToken.ToObject<T>();
|
||
return true;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
PrintError($"GetConfigValuePre ERROR: path: {string.Join("\\", path)}\n{ex}");
|
||
}
|
||
value = default(T);
|
||
return false;
|
||
}
|
||
|
||
private void SetConfigValuePre(JObject config, object value, params string[] path)
|
||
{
|
||
if (path.Length < 1)
|
||
{
|
||
throw new ArgumentException("path is empty");
|
||
}
|
||
|
||
try
|
||
{
|
||
JToken jToken;
|
||
if (!config.TryGetValue(path[0], out jToken))
|
||
{
|
||
if (path.Length == 1)
|
||
{
|
||
jToken = JToken.FromObject(value);
|
||
config.Add(path[0], jToken);
|
||
return;
|
||
}
|
||
jToken = new JObject();
|
||
config.Add(path[0], jToken);
|
||
}
|
||
|
||
for (int i = 1; i < path.Length - 1; i++)
|
||
{
|
||
var jObject = jToken as JObject;
|
||
if (jObject == null || !jObject.TryGetValue(path[i], out jToken))
|
||
{
|
||
jToken = new JObject();
|
||
jObject?.Add(path[i], jToken);
|
||
//config.Add(path[i], jToken);
|
||
}
|
||
}
|
||
(jToken as JObject)?.Add(path[path.Length - 1], JToken.FromObject(value));
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
PrintError($"SetConfigValuePre ERROR: value: {value} path: {string.Join("\\", path)}\n{ex}");
|
||
}
|
||
}
|
||
|
||
private bool GetConfigVersionPre(JObject config, out VersionNumber version)
|
||
{
|
||
try
|
||
{
|
||
JToken jToken;
|
||
if (config.TryGetValue("Version", out jToken))
|
||
{
|
||
version = jToken.ToObject<VersionNumber>();
|
||
return true;
|
||
}
|
||
}
|
||
catch
|
||
{
|
||
// ignored
|
||
}
|
||
version = default(VersionNumber);
|
||
return false;
|
||
}
|
||
|
||
#endregion Preprocess Old Config
|
||
|
||
#endregion ConfigurationFile
|
||
|
||
#region LanguageFile
|
||
|
||
private void Print(BasePlayer player, string message)
|
||
{
|
||
Player.Message(player, message, configData.chatS.prefix, configData.chatS.steamIDIcon);
|
||
}
|
||
|
||
private void Print(ConsoleSystem.Arg arg, string message)
|
||
{
|
||
//SendReply(arg, message);
|
||
var player = arg.Player();
|
||
if (player == null) Puts(message);
|
||
else PrintToConsole(player, message);
|
||
}
|
||
|
||
private string Lang(string key, string id = null, params object[] args) => string.Format(lang.GetMessage(key, this, id), args);
|
||
|
||
protected override void LoadDefaultMessages()
|
||
{
|
||
lang.RegisterMessages(new Dictionary<string, string>
|
||
{
|
||
["NotAllowed"] = "You don't have '{0}' permission to use this command.",
|
||
["TargetDisabled"] = "{0}'s Remover Tool has been disabled.",
|
||
["TargetEnabled"] = "{0} is now using Remover Tool; Enabled for {1} seconds (Max Removable Objects: {2}, Remove Type: {3}).",
|
||
["ToolDisabled"] = "Remover Tool has been disabled.",
|
||
["ToolEnabled"] = "Remover Tool enabled for {0} seconds (Max Removable Objects: {1}, Remove Type: {2}).",
|
||
["Cooldown"] = "You need to wait {0} seconds before using Remover Tool again.",
|
||
["CurrentlyDisabled"] = "Remover Tool is currently disabled.",
|
||
["EntityLimit"] = "Entity limit reached, you have removed {0} entities, Remover Tool was automatically disabled.",
|
||
["MeleeToolNotHeld"] = "You need to be holding a melee tool in order to use the Remover Tool.",
|
||
["SpecificToolNotHeld"] = "You need to be holding a specific tool in order to use the Remover Tool.",
|
||
|
||
["StartRemoveAll"] = "Start running RemoveAll, please wait.",
|
||
["StartRemoveStructure"] = "Start running RemoveStructure, please wait.",
|
||
["StartRemoveExternal"] = "Start running RemoveExternal, please wait.",
|
||
["AlreadyRemoveAll"] = "There is already a RemoveAll running, please wait.",
|
||
["AlreadyRemoveStructure"] = "There is already a RemoveStructure running, please wait.",
|
||
["AlreadyRemoveExternal"] = "There is already a RemoveExternal running, please wait.",
|
||
["CompletedRemoveAll"] = "You've successfully removed {0} entities using RemoveAll.",
|
||
["CompletedRemoveStructure"] = "You've successfully removed {0} entities using RemoveStructure.",
|
||
["CompletedRemoveExternal"] = "You've successfully removed {0} entities using RemoveExternal.",
|
||
|
||
["CanRemove"] = "You can remove this entity.",
|
||
["NotEnoughCost"] = "Can't remove: You don't have enough resources.",
|
||
["EntityDisabled"] = "Can't remove: Server has disabled the entity from being removed.",
|
||
["DamagedEntity"] = "Can't remove: Server has disabled damaged objects from being removed.",
|
||
["BeBlocked"] = "Can't remove: An external plugin blocked the usage.",
|
||
["InvalidEntity"] = "Can't remove: No valid entity targeted.",
|
||
["NotFoundOrFar"] = "Can't remove: The entity is not found or too far away.",
|
||
["StorageNotEmpty"] = "Can't remove: The entity storage is not empty.",
|
||
["RaidBlocked"] = "Can't remove: Raid blocked for {0} seconds.",
|
||
["NotRemoveAccess"] = "Can't remove: You don't have any rights to remove this.",
|
||
["NotStructure"] = "Can't remove: The entity is not a structure.",
|
||
["NotExternalWall"] = "Can't remove: The entity is not an external wall.",
|
||
["HasStash"] = "Can't remove: There are stashes under the foundation.",
|
||
["EntityTimeLimit"] = "Can't remove: The entity was built more than {0} seconds ago.",
|
||
//["Can'tOpenAllLocks"] = "Can't remove: There is a lock in the building that you cannot open.",
|
||
["CantPay"] = "Can't remove: Paying system crashed! Contact an administrator with the time and date to help him understand what happened.",
|
||
|
||
["Refund"] = "Refund:",
|
||
["Nothing"] = "Nothing",
|
||
["Price"] = "Price:",
|
||
["Free"] = "Free",
|
||
["TimeLeft"] = "Timeleft: {0}s\nRemoved: {1}",
|
||
["RemoverToolType"] = "Remover Tool ({0})",
|
||
["Unlimit"] = "∞",
|
||
|
||
["SyntaxError"] = "Syntax error, please type '<color=#ce422b>/{0} <help | h></color>' to view help",
|
||
["Syntax"] = "<color=#ce422b>/{0} [time (seconds)]</color> - Enable RemoverTool ({1})",
|
||
["Syntax1"] = "<color=#ce422b>/{0} <admin | a> [time (seconds)]</color> - Enable RemoverTool ({1})",
|
||
["Syntax2"] = "<color=#ce422b>/{0} <all> [time (seconds)]</color> - Enable RemoverTool ({1})",
|
||
["Syntax3"] = "<color=#ce422b>/{0} <structure | s> [time (seconds)]</color> - Enable RemoverTool ({1})",
|
||
["Syntax4"] = "<color=#ce422b>/{0} <external | e> [time (seconds)]</color> - Enable RemoverTool ({1})",
|
||
}, this);
|
||
|
||
lang.RegisterMessages(new Dictionary<string, string>
|
||
{
|
||
["NotAllowed"] = "您没有 '{0}' 权限来使用该命令",
|
||
["TargetDisabled"] = "'{0}' 的拆除工具已禁用",
|
||
["TargetEnabled"] = "'{0}' 的拆除工具已启用 {1} 秒 (可拆除数: {2}, 拆除模式: {3}).",
|
||
["ToolDisabled"] = "您的拆除工具已禁用",
|
||
["ToolEnabled"] = "您的拆除工具已启用 {0} 秒 (可拆除数: {1}, 拆除模式: {2}).",
|
||
["Cooldown"] = "您需要等待 {0} 秒才可以再次使用拆除工具",
|
||
["CurrentlyDisabled"] = "服务器当前已禁用了拆除工具",
|
||
["EntityLimit"] = "您已经拆除了 '{0}' 个实体，拆除工具已自动禁用",
|
||
["MeleeToolNotHeld"] = "您必须拿着近战工具才可以使用拆除工具",
|
||
["SpecificToolNotHeld"] = "您必须拿着指定工具才可以使用拆除工具",
|
||
|
||
["StartRemoveAll"] = "开始运行 '所有拆除'，请您等待",
|
||
["StartRemoveStructure"] = "开始运行 '建筑拆除'，请您等待",
|
||
["StartRemoveExternal"] = "开始运行 '外墙拆除'，请您等待",
|
||
["AlreadyRemoveAll"] = "已经有一个 '所有拆除' 正在运行，请您等待",
|
||
["AlreadyRemoveStructure"] = "已经有一个 '建筑拆除' 正在运行，请您等待",
|
||
["AlreadyRemoveExternal"] = "已经有一个 '外墙拆除' 正在运行，请您等待",
|
||
["CompletedRemoveAll"] = "您使用 '所有拆除' 成功拆除了 {0} 个实体",
|
||
["CompletedRemoveStructure"] = "您使用 '建筑拆除' 成功拆除了 {0} 个实体",
|
||
["CompletedRemoveExternal"] = "您使用 '外墙拆除' 成功拆除了 {0} 个实体",
|
||
|
||
["CanRemove"] = "您可以拆除该实体",
|
||
["NotEnoughCost"] = "无法拆除该实体: 拆除所需资源不足",
|
||
["EntityDisabled"] = "无法拆除该实体: 服务器已禁用拆除这种实体",
|
||
["DamagedEntity"] = "无法拆除该实体: 服务器已禁用拆除已损坏的实体",
|
||
["BeBlocked"] = "无法拆除该实体: 其他插件阻止您拆除该实体",
|
||
["InvalidEntity"] = "无法拆除该实体: 无效的实体",
|
||
["NotFoundOrFar"] = "无法拆除该实体: 没有找到实体或者距离太远",
|
||
["StorageNotEmpty"] = "无法拆除该实体: 该实体内含有物品",
|
||
["RaidBlocked"] = "无法拆除该实体: 拆除工具被突袭阻止了 {0} 秒",
|
||
["NotRemoveAccess"] = "无法拆除该实体: 您无权拆除该实体",
|
||
["NotStructure"] = "无法拆除该实体: 该实体不是建筑物",
|
||
["NotExternalWall"] = "无法拆除该实体: 该实体不是外高墙",
|
||
["HasStash"] = "无法拆除该实体: 地基下藏有小藏匿",
|
||
["EntityTimeLimit"] = "无法拆除该实体: 该实体的存活时间大于 {0} 秒",
|
||
//["Can'tOpenAllLocks"] = "无法拆除该实体: 该建筑中有您无法打开的锁",
|
||
["CantPay"] = "无法拆除该实体: 支付失败，请联系管理员，告诉他详情",
|
||
|
||
["Refund"] = "退还:",
|
||
["Nothing"] = "没有",
|
||
["Price"] = "价格:",
|
||
["Free"] = "免费",
|
||
["TimeLeft"] = "剩余时间: {0}s\n已拆除数: {1} ",
|
||
["RemoverToolType"] = "拆除工具 ({0})",
|
||
["Unlimit"] = "∞",
|
||
|
||
["SyntaxError"] = "语法错误，输入 '<color=#ce422b>/{0} <help | h></color>' 查看帮助",
|
||
["Syntax"] = "<color=#ce422b>/{0} [time (seconds)]</color> - 启用拆除工具 ({1})",
|
||
["Syntax1"] = "<color=#ce422b>/{0} <admin | a> [time (seconds)]</color> - 启用拆除工具 ({1})",
|
||
["Syntax2"] = "<color=#ce422b>/{0} <all> [time (seconds)]</color> - 启用拆除工具 ({1})",
|
||
["Syntax3"] = "<color=#ce422b>/{0} <structure | s> [time (seconds)]</color> - 启用拆除工具 ({1})",
|
||
["Syntax4"] = "<color=#ce422b>/{0} <external | e> [time (seconds)]</color> - 启用拆除工具 ({1})",
|
||
}, this, "zh-CN");
|
||
lang.RegisterMessages(new Dictionary<string, string>
|
||
{
|
||
["NotAllowed"] = "У вас нет разрешения '{0}' чтобы использовать эту команду.",
|
||
["TargetDisabled"] = "{0}'s Remover Tool отключен.",
|
||
["TargetEnabled"] = "{0} теперь использует Remover Tool; Включено на {1} секунд (Макс. объектов для удаления: {2}, Тип удаления: {3}).",
|
||
["ToolDisabled"] = "Remover Tool отключен.",
|
||
["ToolEnabled"] = "Remover Tool включен на {0} секунд (Макс. объектов для удаления: {1}, Тип удаления: {2}).",
|
||
["Cooldown"] = "Необходимо подождать {0} секунд, прежде чем использовать Remover Tool снова.",
|
||
["CurrentlyDisabled"] = "Remover Tool в данный момент отключен.",
|
||
["EntityLimit"] = "Достигнут предел, удалено {0} объектов, Remover Tool автоматически отключен.",
|
||
["MeleeToolNotHeld"] = "Вы должны держать Инструмент ближнего боя, чтобы использовать инструмент для удаления.",
|
||
["SpecificToolNotHeld"] = "Вы должны держать Инструмент определенный, чтобы использовать инструмент для удаления.",
|
||
|
||
["StartRemoveAll"] = "Запускается RemoveAll, пожалуйста, подождите.",
|
||
["StartRemoveStructure"] = "Запускается RemoveStructure, пожалуйста, подождите.",
|
||
["StartRemoveExternal"] = "Запускается RemoveExternal, пожалуйста, подождите.",
|
||
["AlreadyRemoveAll"] = "RemoveAll уже выполняется, пожалуйста, подождите.",
|
||
["AlreadyRemoveStructure"] = "RemoveStructure уже выполняется, пожалуйста, подождите.",
|
||
["AlreadyRemoveExternal"] = "RemoveExternal уже выполняется, пожалуйста, подождите.",
|
||
["CompletedRemoveAll"] = "Вы успешно удалили {0} объектов используя RemoveAll.",
|
||
["CompletedRemoveStructure"] = "Вы успешно удалили {0} объектов используя RemoveStructure.",
|
||
["CompletedRemoveExternal"] = "Вы успешно удалили {0} объектов используя RemoveExternal.",
|
||
|
||
["CanRemove"] = "Вы можете удалить этот объект.",
|
||
["NotEnoughCost"] = "Нельзя удалить: У вас не достаточно ресурсов.",
|
||
["EntityDisabled"] = "Нельзя удалить: Сервер отключил возможность удаления этого объекта.",
|
||
["DamagedEntity"] = "Нельзя удалить: Сервер отключил возможность удалять повреждённые объекты.",
|
||
["BeBlocked"] = "Нельзя удалить: Внешний plugin блокирует использование.",
|
||
["InvalidEntity"] = "Нельзя удалить: Неверный объект.",
|
||
["NotFoundOrFar"] = "Нельзя удалить: Объект не найден, либо слишком далеко.",
|
||
["StorageNotEmpty"] = "Нельзя удалить: Хранилище объекта не пусто.",
|
||
["RaidBlocked"] = "Нельзя удалить: Рэйд-блок {0} секунд.",
|
||
["NotRemoveAccess"] = "Нельзя удалить: У вас нет прав удалять это.",
|
||
["NotStructure"] = "Нельзя удалить: Объект не конструкция.",
|
||
["NotExternalWall"] = "Нельзя удалить: Объект не внешняя стена.",
|
||
["HasStash"] = "Нельзя удалить: Обнаружены тайники под фундаментом.",
|
||
["EntityTimeLimit"] = "Нельзя удалить: Объект был построен более {0} секунд назад.",
|
||
//["Can'tOpenAllLocks"] = "Нельзя удалить: в здании есть замок, который вы не можете открыть",
|
||
["CantPay"] = "Нельзя удалить: Система оплаты дала сбой! Свяжитесь с админом указав дату и время, чтобы помочь ему понять что случилось.",
|
||
|
||
["Refund"] = "Возврат:",
|
||
["Nothing"] = "Ничего",
|
||
["Price"] = "Цена:",
|
||
["Free"] = "Бесплатно",
|
||
["TimeLeft"] = "Осталось времени: {0}s\nУдалено: {1}",
|
||
["RemoverToolType"] = "Remover Tool ({0})",
|
||
["Unlimit"] = "∞",
|
||
|
||
["SyntaxError"] = "Синтаксическая ошибка! Пожалуйста, введите '<color=#ce422b>/{0} <help | h></color>' для отображения помощи",
|
||
["Syntax"] = "<color=#ce422b>/{0} [время (секунд)]</color> - Включить RemoverTool ({1})",
|
||
["Syntax1"] = "<color=#ce422b>/{0} <admin | a> [время (секунд)]</color> - Включить RemoverTool ({1})",
|
||
["Syntax2"] = "<color=#ce422b>/{0} <all> [время (секунд)]</color> - Включить RemoverTool ({1})",
|
||
["Syntax3"] = "<color=#ce422b>/{0} <structure | s> [время (секунд)]</color> - Включить RemoverTool ({1})",
|
||
["Syntax4"] = "<color=#ce422b>/{0} <external | e> [время (секунд)]</color> - Включить RemoverTool ({1})",
|
||
}, this, "ru");
|
||
}
|
||
|
||
#endregion LanguageFile
|
||
}
|
||
} |