C#:
// Все права принадлежат дискорд сообществу https://discord.gg/VgNHPpNrz6
using Oxide.Core;
using System;
using System.Collections.Generic;
using System.Text;
using Rust;
using Oxide.Core.Plugins;
using Oxide.Core.Libraries.Covalence;
using UnityEngine;
using Newtonsoft.Json;
namespace Oxide.Plugins
{
[Info("WipeProtection", "FastBurst", "2.1.3")]
[Description("Blocks raiding after wipe for so many hours")]
class WipeProtection : RustPlugin
{
[PluginReference] Plugin HeliSupport;
private List<BasePlayer> cooldown = new List<BasePlayer>();
private float wipeprotecctime;
private bool refund, broadcastend, msgadmin;
private const string permUse = "wipeprotection.use";
private static WipeProtection Instance { get; set; }
private StoredData storedData;
private Dictionary<string, string> raidtools = new Dictionary<string, string>
{
{"ammo.rocket.fire", "rocket_fire" },
{"ammo.rocket.hv", "rocket_hv" },
{"ammo.rocket.basic", "rocket_basic" },
{"explosive.timed", "explosive.timed.deployed" },
{"surveycharge", "survey_charge.deployed" },
{"explosive.satchel", "explosive.satchel.deployed" },
{"grenade.beancan", "grenade.beancan.deployed" },
{"grenade.f1", "grenade.f1.deployed" },
{"ammo.grenadelauncher.he", "40mm_grenade_he"},
{"ammo.rifle", "riflebullet" },
{"ammo.rifle.explosive", "riflebullet_explosive" },
{"ammo.rifle.incendiary", "riflebullet_fire" },
{"ammo.pistol", "pistolbullet" },
{"ammo.pistol.fire", "pistolbullet_fire" },
{"ammo.shotgun", "shotgunbullet" },
{"ammo.shotgun.fire", "shotgunbullet_fire" },
{"ammo.shotgun.slug", "shotgunslug" }
};
#region Hooks
private void Unload() => SaveFile();
private void Init()
{
permission.RegisterPermission(permUse, this);
lang.RegisterMessages(Messages, this);
Instance = this;
storedData = Interface.Oxide.DataFileSystem.ReadObject<StoredData>(this.Name);
CheckTime();
}
private void CheckTime()
{
timer.Every(30f, () => {
if (!storedData.wipeprotection)
return;
if (DateTime.Now >= Convert.ToDateTime(storedData.RaidStartTime))
{
if (configData.Settings.broadcastend)
SendChatMessage("raidprotection_ended");
storedData.wipeprotection = false;
SaveFile();
return;
}
});
}
private void OnNewSave(string filename)
{
DateTime now = DateTime.Now;
DateTime rs = now.AddHours(configData.Settings.wipeprotecctime);
storedData.wipeprotection = true;
storedData.lastwipe = SaveRestore.SaveCreatedTime.ToString();
storedData.RaidStartTime = rs.ToString();
SaveFile();
PrintWarning(msg("console_auto"), now, rs);
}
private void OnPlayerConnected(BasePlayer player)
{
if (!player.IsAdmin || !configData.Settings.msgadmin || !storedData.wipeprotection)
return;
string remaining = Convert.ToDateTime(storedData.RaidStartTime).Subtract(DateTime.Now).ToShortString();
SendReply(player, msg("adminmsg"), "<color=orange>[WipeProtection]</color>", storedData.RaidStartTime, remaining);
}
private object OnEntityTakeDamage(BaseCombatEntity entity, HitInfo hitinfo)
{
if (hitinfo == null || entity == null || entity.OwnerID == hitinfo?.InitiatorPlayer?.userID || entity?.OwnerID == 0 || hitinfo?.WeaponPrefab?.ShortPrefabName == null)
return null;
if (!(entity is BuildingBlock || entity is Door || entity.PrefabName.Contains("deployable")))
return null;
BasePlayer attacker = hitinfo.InitiatorPlayer;
string name = null;
if (hitinfo?.WeaponPrefab?.ShortPrefabName == "rocket_fire"
|| hitinfo?.WeaponPrefab?.ShortPrefabName == "rocket_fire"
|| hitinfo?.WeaponPrefab?.ShortPrefabName == "rocket_hv"
|| hitinfo?.WeaponPrefab?.ShortPrefabName == "rocket_basic"
|| hitinfo?.WeaponPrefab?.ShortPrefabName == "explosive.timed.deployed"
|| hitinfo?.WeaponPrefab?.ShortPrefabName == "survey_charge.deployed"
|| hitinfo?.WeaponPrefab?.ShortPrefabName == "explosive.satchel.deployed"
|| hitinfo?.WeaponPrefab?.ShortPrefabName == "grenade.beancan.deployed"
|| hitinfo?.WeaponPrefab?.ShortPrefabName == "grenade.f1.deployed"
|| hitinfo?.WeaponPrefab?.ShortPrefabName == "40mm_grenade_he")
{
name = hitinfo?.WeaponPrefab?.ShortPrefabName;
}
else
{
name = hitinfo?.ProjectilePrefab?.name.ToString();
}
if (cooldown.Contains(attacker))
{
RemoveCD(attacker);
if (WipeProtected())
{
hitinfo.damageTypes = new DamageTypeList();
hitinfo.DoHitEffects = false;
hitinfo.HitMaterial = 0;
return true;
}
return null;
}
cooldown.Add(attacker);
RemoveCD(attacker);
if (WipeProtected())
{
//Puts(name.ToString());
hitinfo.damageTypes = new DamageTypeList();
hitinfo.DoHitEffects = false;
hitinfo.HitMaterial = 0;
msgPlayer(attacker, entity);
Refund(attacker, name, entity);
return true;
}
return null;
}
#endregion
#region Functions
private void RemoveCD(BasePlayer player)
{
if (player == null)
return;
timer.In(0.1f, () => {
if (cooldown.Contains(player)) cooldown.Remove(player);
});
}
bool WipeProtected()
{
if (!storedData.wipeprotection)
return false;
if (DateTime.Now < (Convert.ToDateTime(storedData.RaidStartTime)))
return true;
return false;
}
private void msgPlayer(BasePlayer player, BaseEntity entity)
{
if (WipeProtected())
{
SendReply(player, msg("wipe_blocked"));
return;
}
}
private void Refund(BasePlayer player, string name, BaseEntity ent)
{
if (configData.Settings.Refunds.RefundAmmo)
{
foreach (var entry in raidtools)
{
if (name == entry.Value)
{
Item item = ItemManager.CreateByName(entry.Key, 1);
player.GiveItem(item);
if (configData.Settings.Refunds.NotifyRefund)
SendReply(player, msg("refunded"), item.info.displayName.english);
}
}
}
else
{
if (configData.Settings.Refunds.NotifyRefundNo)
SendReply(player, msg("refundedNot"));
}
}
private void SaveFile() => Interface.Oxide.DataFileSystem.WriteObject(this.Name, storedData);
#endregion
#region Commands
[ConsoleCommand("wp")]
private void wipeCmd(ConsoleSystem.Arg arg)
{
if (arg.Connection != null)
return;
var player = arg.Player();
if (arg.Args == null || arg.Args.Length == 0)
{
Puts("Wipe Protection by:: FastBurst");
Puts("wp start - Manually start wipe protection");
Puts("wp stop - Manually stop wipe protection");
return;
}
if (arg.IsAdmin == true)
{
switch (arg.Args[0].ToLower())
{
case "start":
DateTime now = DateTime.Now;
DateTime rs = now.AddHours(configData.Settings.wipeprotecctime);
storedData.wipeprotection = true;
storedData.lastwipe = SaveRestore.SaveCreatedTime.ToString();
storedData.RaidStartTime = rs.ToString();
SaveFile();
Puts(msg("console_manual"), now, rs);
return;
case "stop":
storedData.wipeprotection = false;
SaveFile();
Puts(msg("console_stopped"));
return;
default:
break;
}
}
else
{
if (permission.UserHasPermission(player.UserIDString, permUse) == false)
{
SendReply(arg, msg("permission"));
return;
}
}
}
[ChatCommand("wp")]
private void wipeCmd2(BasePlayer player, string command, string[] args)
{
if (permission.UserHasPermission(player.UserIDString, permUse) == false)
{
SendReply(player, msg("permission"));
return;
}
if (args.Length == 0)
{
var helpmsg = new StringBuilder();
helpmsg.Append("<size=22><color=green>Wipe Protection</color></size> by: FastBurst\n");
helpmsg.Append("<color=orange>/wp start</color> - Manually start wipe protection\n");
helpmsg.Append("<color=orange>/wp stop</color> - Manually stop wipe protection\n");
SendReply(player, helpmsg.ToString().TrimEnd());
return;
}
switch (args[0].ToLower())
{
case "start":
DateTime now = DateTime.Now;
DateTime rs = now.AddHours(configData.Settings.wipeprotecctime);
storedData.wipeprotection = true;
storedData.lastwipe = SaveRestore.SaveCreatedTime.ToString();
storedData.RaidStartTime = rs.ToString();
SaveFile();
SendReply(player, msg("console_manual"), now, rs);
return;
case "stop":
storedData.wipeprotection = false;
SaveFile();
SendReply(player, msg("console_stopped"));
return;
default:
player.ChatMessage("Invalid syntax!");
break;
}
}
#endregion
#region Config
private static ConfigData configData;
private class ConfigData
{
[JsonProperty(PropertyName = "Settings")]
public SettingOptions Settings { get; set; }
public class SettingOptions
{
[JsonProperty(PropertyName = "Broadcast to chat when raid block has ended")]
public bool broadcastend { get; set; }
[JsonProperty(PropertyName = "Message admins on connection with info on when the raid block is ending")]
public bool msgadmin { get; set; }
[JsonProperty(PropertyName = "Wipe protection time (hours)")]
public float wipeprotecctime { get; set; }
[JsonProperty(PropertyName = "Refunding Options")]
public RefundSettings Refunds { get; set; }
public class RefundSettings
{
[JsonProperty(PropertyName = "Allow Refunding of Explosives & Rockets")]
public bool RefundAmmo { get; set; }
[JsonProperty(PropertyName = "Enable notifican on refunding of ammo types")]
public bool NotifyRefund { get; set; }
[JsonProperty(PropertyName = "Enable notifican on denial of refunding of ammo types")]
public bool NotifyRefundNo { get; set; }
}
}
public Oxide.Core.VersionNumber Version { get; set; }
}
protected override void LoadConfig()
{
base.LoadConfig();
configData = Config.ReadObject<ConfigData>();
if (configData.Version < Version)
UpdateConfigValues();
Config.WriteObject(configData, true);
}
protected override void LoadDefaultConfig() => configData = GetBaseConfig();
private ConfigData GetBaseConfig()
{
return new ConfigData
{
Settings = new ConfigData.SettingOptions
{
broadcastend = true,
msgadmin = true,
wipeprotecctime = 24f,
Refunds = new ConfigData.SettingOptions.RefundSettings
{
RefundAmmo = true,
NotifyRefund = true,
NotifyRefundNo = true
}
},
Version = Version
};
}
protected override void SaveConfig() => Config.WriteObject(configData, true);
private void UpdateConfigValues()
{
PrintWarning("Config update detected! Updating config values...");
ConfigData baseConfig = GetBaseConfig();
if (configData.Version < new Core.VersionNumber(2, 0, 0))
configData = baseConfig;
if (configData.Version < new Core.VersionNumber(2, 0, 3))
configData.Settings.Refunds = baseConfig.Settings.Refunds;
configData.Version = Version;
PrintWarning("Config update completed!");
}
private T GetConfig<T>(string name, T defaultValue)
{
if (Config[name] == null) return defaultValue;
return (T)Convert.ChangeType(Config[name], typeof(T));
}
#endregion
#region DataFile
private class StoredData
{
public bool wipeprotection;
public string lastwipe;
public string RaidStartTime;
public StoredData()
{
}
}
#endregion
#region Lang
private static void SendChatMessage(string key, params object[] args)
{
for (int i = 0; i < BasePlayer.activePlayerList.Count; i++)
{
BasePlayer player = BasePlayer.activePlayerList[i];
player.ChatMessage(args != null ? string.Format(msg(key, player.UserIDString), args) : msg(key, player.UserIDString));
}
}
private static string msg(string key, string playerId = null) => Instance.lang.GetMessage(key, Instance, playerId);
private Dictionary<string, string> Messages = new Dictionary<string, string>
{
["adminmsg"] = "Wipe protection ending at <color=orange>{0} ({1})</color>",
["console_manual"] = "Manually setting {0} as wipe time and {1} as time after which raiding is possible",
["console_auto"] = "Detected wipe, setting {0} as wipe time and {1} as time after which raiding is possible",
["console_stopped"] = "Everything is now raidable",
["raidprotection_ended"] = "<size=20>Wipe protection is now over.</size>",
["dataFileWiped"] = "Data file successfully wiped",
["permission"] = "<color=#ff0000>You don't have permission to use that!</color>",
["refunded"] = "Your '{0}' was refunded.",
["refundedNot"] = "Your Ammo or Explosives are <color=red>not being refunded</color> and has been lost due to trying to raid before the time allowed.",
["wipe_blocked"] = "This entity cannot be destroyed because all raiding is currently blocked."
};
#endregion
}
}