C#:
// Все права принадлежат дискорд сообществу https://discord.gg/VgNHPpNrz6
/*
* <----- End-User License Agreement ----->
* Copyright © 2024 Iftebinjan
* Devoloper: Iftebinjan (Contact: https://discord.gg/HFaGs8YwsH)
*
* You may not copy, modify, merge, publish, distribute, sublicense, or sell copies of This Software without the Developer’s consent
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.*/
using Oxide.Core.Plugins;
using Newtonsoft.Json;
using Oxide.Game.Rust.Cui;
using UnityEngine;
using Newtonsoft.Json.Linq;
using Oxide.Core;
using System.Collections.Generic;
using System.Linq;
using Network;
using System;
using Oxide.Core.Libraries.Covalence;
using System.Globalization;
using System.IO;
using Oxide.Core.Configuration;
using Steamworks.ServerList;
using Rust;
using ProtoBuf;
using ConVar;
using Oxide.Core.Libraries;
using CompanionServer.Handlers;
using System.Runtime;
using Facepunch;
using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;
using System.Reflection;
using System.Collections;
using Oxide.Game.Rust.Libraries;
using Facepunch.Math;
using Rust.Ai.Gen2;
//
namespace Oxide.Plugins {
[Info("SimplePVE", "Ifte", "1.2.7")]
[Description("An easy simple PVE plugin for your server to modify or change PVE rules.")]
public class SimplePVE : RustPlugin {
/*------------------------------------
*
* SimplePVE by Ifte
* Support: https://discord.gg/cCWadjcapr
* Fiverr: https://www.fiverr.com/s/e2pkYY
* Eror404 not found
*
------------------------------------*/
/*------------------------------------
*
* UPDATES
* --------------
* 1.2.0 - Latest with NewUI, Added new schedule system with weekdays support.Added config for Commands to execute when pvp purge starts and ends(Only from schedules)
* 1.2.1 - Fixed ZombieHorde plugin, Fixed Tugboat vehicle damage, Added support for Backpack(Backpack no longer be pickup or open by other players)
* 1.2.2 - Added new configuration, all rules configurations moved to Oxide/Data/SimplePVE/, Config values changed, Fixed DropBox & Mail not opening(More entitys option in the config)
* 1.2.3 - Updated for latest force wipe, Added New Status UI for PVE status Zone Status Schedule Stats, New Configuration added, Fixed a bug where backpack cant be pickup after death by entity, Fixed few Zone Bugs, More bug added.* 1.2.4 - Updated for New Forced Update, Added support for FClan, Added support for codelock raid, Fixed Shark not damageing players
* 1.2.5 - Fixed Status UI, Fixed APIs Not Calling, Working APIs(IsServerPVE, GetPVPStartTimeRemaining, GetPVPEndTimeRemaining, AddToExcludeZone, RemoveFromExcludeZone, IsStatusEnabled_API),
* 1.2.6 - Update for recent force wipe, Fixed for new wolf ai and wolf damage
* 1.2.8 - Updated config file(Config will auto update from the next update), Changes to StatusUI(Now it requires SimpleStatus plugin as dependency), Code cleanup for maxium performance, Fixed Torpedo damaging Tugboat, Added Support for Toastify & Notify
*
* BUGS
* ---------
* Updates coming in
* wallpaper damageable? wait till oxide hook
*
------------------------------------*/
#region Varriables
[PluginReference]
Plugin ZoneManager, ImageLibrary, Clans, Friends, RaidableBases, Convoy, HeliSignals, AbandonedBases, FClan, SimpleStatus, Toastify, Notify;
private static SimplePVE ins;
private Configuration config;
private ScheduleSave savedSch;
private bool update = true;
private bool PVPRun = false;
private bool ChangedConfig = false;
private bool DiscordMessageSent = false;
private Dictionary<ulong, PVPDelay> pvp_delays = new Dictionary<ulong, PVPDelay>();
enum PVERules {
GRules, PRules, NRules, ERules, LRules, ZRules
}
private class PVPDelay {
public string ZoneID;
public Timer DelayTimer;
}
//permissions
private const string PvEAdminPerms = "simplepve.admin";
private const string PvEAdminLootPerms = "simplepve.adminloot";
private const string PvEAdminDamagePerms = "simplepve.admindamage";
#endregion
#region Configs
private class Configuration {
[JsonProperty(PropertyName = "PVE Enabled")]
public bool pveEnabledConfig {
get;
set;
}
[JsonProperty(PropertyName = "Notifications")]
public DisplayNotify displayNotify {
get;
set;
}
[JsonProperty(PropertyName = "Loot Protection Excluded Entitys", ObjectCreationHandling = ObjectCreationHandling.Replace)]
public List<string> excludedEntitys {
get;
set;
}
[JsonProperty(PropertyName = "Schedules Setting")]
public Sche sche {
get;
set;
}
[JsonProperty(PropertyName = "PVP Delay Setting")]
public PVPDelayNotify delaySetting {
get;
set;
}
[JsonProperty(PropertyName = "Discord Setting")]
public DiscordSetting discordSetting {
get;
set;
}
[JsonProperty(PropertyName = "Commands when PVP Purge Starts")]
public List<string> commandsExefrompvpstart {
get;
set;
}
[JsonProperty(PropertyName = "Commands when PVP Purge Ends")]
public List<string> commandsExefrompvpends {
get;
set;
}
[JsonProperty(PropertyName = "Exclude Zone IDs From Rules")]
public List<string> excludedZoneIDs {
get;
set;
}
[JsonProperty(PropertyName = "Status UI")]
public StatusUI statusUI {
get;
set;
}
[JsonProperty(PropertyName = "Config Version (Don't Edit This)")]
public VersionNumber Version {
get;
set;
}
}
private class PVPDelayNotify {
[JsonProperty("PVP delay time in seconds(If enabled from ZoneRules)")]
public int pvpdelaytime {
get;
set;
}
[JsonProperty("Show PVP Delay Message")]
public bool pvpDelayMsgEnabled {
get;
set;
}
[JsonProperty("PVP Delay Message")]
public string pvpDelayMessage {
get;
set;
}
}
private class DisplayNotify {
[JsonProperty("Prefix")]
public string prefix {
get;
set;
}
[JsonProperty("Chat Avatar")]
public ulong chatAvatar {
get;
set;
}
[JsonProperty("Show PVE Icon Overlay")]
public bool showPvEOverlay {
get;
set;
}
[JsonProperty("Show PVE Warning Messages")]
public bool showDamageM {
get;
set;
}
[JsonProperty("PVE Warning Type(Chat/UI/Both(Chat & UI)/Toastify/Notify)")]
public string showDamageMType {
get;
set;
}
[JsonProperty("PVE Warning Chat Message")]
public string showDamageMTypeMessage {
get;
set;
}
[JsonProperty("PVE Warning Custom UI Message(Toastify/Notify)")]
public string showMsgCustomUI {
get;
set;
}
[JsonProperty("PVE Warning UI Settings")]
public WarningUI warningUI {
get;
set;
}
public class WarningUI {
[JsonProperty("Anchor Min")]
public string WarningAMin {
get;
set;
}
[JsonProperty("Anchor Max")]
public string WarningAMax {
get;
set;
}
[JsonProperty("Warning Image URL")]
public string WarningImgUrl {
get;
set;
}
}
[JsonProperty("Show Loot Protection Messages")]
public bool LPMessagesOn {
get;
set;
}
[JsonProperty("Loot Protection Type(Chat/UI/Both(Chat & UI)/Toastify/Notify)")]
public string LPType {
get;
set;
}
[JsonProperty("Loot Protection Chat Message")]
public string LPChatMessage {
get;
set;
}
[JsonProperty("Loot Protection Custom UI Message(Toastify/Notify)")]
public string LPChatMessageUI {
get;
set;
}
[JsonProperty("Loot Protection UI Settings")]
public LPUISetting lPUISetting {
get;
set;
}
public class LPUISetting {
[JsonProperty("Anchor Min")]
public string WarningAMin {
get;
set;
}
[JsonProperty("Anchor Max")]
public string WarningAMax {
get;
set;
}
[JsonProperty("Warning Loot UI Image URL")]
public string WarningImgUrl {
get;
set;
}
}
[JsonProperty("PVE/PVP Icon UI Settings")]
public PEPUISetting pUISetting {
get;
set;
}
public class PEPUISetting {
[JsonProperty("Anchor Min")]
public string pepAMin {
get;
set;
}
[JsonProperty("Anchor Max")]
public string pepAMax {
get;
set;
}
[JsonProperty("Offset Min")]
public string pepOMin {
get;
set;
}
[JsonProperty("Offset Max")]
public string pepOMax {
get;
set;
}
}
}
private class Sche {
[JsonProperty("UTC Time Difference")]
public int utcTimeDif {
get;
set;
}
[JsonProperty("Enable Weekly Schedule Only")]
public bool enableweeklysch {
get;
set;
}
[JsonProperty("PVP On Notify Message")]
public string pvpOnMessage {
get;
set;
}
[JsonProperty("PVE On Notify Message")]
public string pveOnMessage {
get;
set;
}
[JsonProperty("PVP Purge Start Before Message")]
public string pvppurgeStartMsg {
get;
set;
}
[JsonProperty("PVP Purge Ending Before Message")]
public string pvppurgeEndingMsg {
get;
set;
}
}
private class DiscordSetting {
[JsonProperty("Enable Discord Notification")]
public bool enableDiscordNotify {
get;
set;
}
[JsonProperty("Discord Webhook URL")]
public string discordWebhookURL {
get;
set;
}
[JsonProperty("Enable Message Before PVP Time Start")]
public bool messageBeforeStart {
get;
set;
}
[JsonProperty("Before PVP Time Start Minutes")]
public int messageBeforeStartMinutes {
get;
set;
}
[JsonProperty("PVP Message Embed Color(Hexa)")]
public string pvpmessageEmbed {
get;
set;
}
[JsonProperty("Before PVP Time Start Message Content")]
public string[] pvpTimeMessage {
get;
set;
}
[JsonProperty("Enable Message Before PVE Time Start")]
public bool messageBeforeStartPVE {
get;
set;
}
[JsonProperty("Before PVE Time Start Minutes")]
public int messageBeforeStartMinutesPVE {
get;
set;
}
[JsonProperty("PVE Message Embed Color")]
public string pvemessageEmbed {
get;
set;
}
[JsonProperty("Before PVE Time Start Message Content")]
public string[] pveTimeMessage {
get;
set;
}
}
private class StatusUI {
[JsonProperty(PropertyName = "Enable Status")]
public bool status {
get;
set;
}
[JsonProperty(PropertyName = "Interval Time In Seconds")]
public int interval {
get;
set;
}
[JsonProperty(PropertyName = "PVE/PVP Status")]
public PVPorPVEStatus peStatus {
get;
set;
}
/*[JsonProperty(PropertyName = "Zone Status")]
public ZoneStatus zoneStatus { get; set; }*/
[JsonProperty(PropertyName = "Purge Schedule Status")]
public PurgeStatus purgeStatus {
get;
set;
}
}
private class PVPorPVEStatus {
[JsonProperty(PropertyName = "Status Enable")]
public bool status {
get;
set;
}
[JsonProperty(PropertyName = "PVE Status")]
public Setting PVEStatus {
get;
set;
}
[JsonProperty(PropertyName = "PVP Status")]
public Setting PVPStatus {
get;
set;
}
}
private class ZoneStatus {
[JsonProperty(PropertyName = "Status Enable")]
public bool status {
get;
set;
}
[JsonProperty(PropertyName = "In PVP Area Status")]
public Setting pvparea {
get;
set;
}
}
private class PurgeStatus {
[JsonProperty(PropertyName = "Status Enable")]
public bool status {
get;
set;
}
[JsonProperty(PropertyName = "Purge PVP Status")]
public Setting purgepvpStatus {
get;
set;
}
[JsonProperty(PropertyName = "Purge PVE Status")]
public Setting purgepveStatus {
get;
set;
}
}
private class Setting {
[JsonProperty(PropertyName = "Enable Status")]
public bool status {
get;
set;
}
[JsonProperty(PropertyName = "Text List")]
public string[] strings {
get;
set;
}
[JsonProperty(PropertyName = "Text Color")]
public string textColor {
get;
set;
}
[JsonProperty(PropertyName = "Icon Image Url")]
public string icon {
get;
set;
}
[JsonProperty(PropertyName = "Icon Image Color")]
public string iconColor {
get;
set;
}
[JsonProperty(PropertyName = "Status Color")]
public string statusColor {
get;
set;
}
}
private Configuration CreateConfig() {
return new Configuration {
pveEnabledConfig = true, displayNotify = new DisplayNotify {
showDamageM = true, prefix = "<color=#00ffff>[SimplePVE]</color>: ", chatAvatar = 0, showDamageMType = "Both(Chat & UI)", showDamageMTypeMessage = "PVE enabled on this server, blocking damage.", showMsgCustomUI = "PVE enabled on this server, blocking damage.", warningUI = new DisplayNotify.WarningUI {
WarningAMin = "0.786 0.722", WarningAMax = "0.99 0.815", WarningImgUrl = "https://i.postimg.cc/0jZNDr9x/Add-a-subheading-2.png"
}
, showPvEOverlay = true, LPMessagesOn = true, LPType = "Both(Chat & UI)", LPChatMessage = "This entity is protected!", LPChatMessageUI = "This entity is protected!", lPUISetting = new DisplayNotify.LPUISetting {
WarningAMin = "0.786 0.722", WarningAMax = "0.99 0.815", WarningImgUrl = "https://i.postimg.cc/SxSsS67s/Add-a-subheading-1.png"
}
, pUISetting = new DisplayNotify.PEPUISetting {
pepAMin = "0.5 0", pepAMax = "0.5 0", pepOMin = "190 30", pepOMax = "250 60"
}
}
, statusUI = new StatusUI() {
status = true, interval = 10, peStatus = new PVPorPVEStatus() {
status = true, PVEStatus = new Setting() {
status = true, strings = new string[] {
"PVE ENABLED", "RAID IS DISABLED", "PVP IS DISABLED",
}
, textColor = "#FFFFFF", icon = "https://i.postimg.cc/4ymwFnSC/quality.png", iconColor = "#A4FE0A", statusColor = "#718D48"
}
, PVPStatus = new Setting() {
status = true, strings = new string[] {
"PVP ENABLED", "RAID IS ENABLED", "PVE IS DISABLED", "PVP IS ENABLED",
}
, textColor = "#FFFFFF", icon = "https://i.postimg.cc/50YVChxW/human-skull-with-crossed-bones-silhouette.png", iconColor = "#FFFFFF", statusColor = "#B22222"
}
}
,
/*zoneStatus = new ZoneStatus()
{
status = true,
pvparea = new Setting()
{
status = true,
strings = new string[]
{
"YOU'RE IN THE PVP ZONE"
},
textColor = "#FFFFFF",
icon = "https://i.postimg.cc/qRGxrMBR/fighting-game.png",
iconColor = "#FFFFFF",
statusColor = "#A30000"
}
},*/
purgeStatus = new PurgeStatus() {
status = true, purgepvpStatus = new Setting() {
status = true, strings = new string[] {
"PVP ENABLEING IN {TIMER}", "RAID ENABLEING IN {TIMER}", "PVP PURGING IN {TIMER}"
}
, textColor = "#FFFFFF", icon = "https://i.postimg.cc/0j2n3rzp/time.png", iconColor = "#FFFFFF", statusColor = "#A30000"
}
, purgepveStatus = new Setting() {
status = true, strings = new string[] {
"PVE ENABLING IN {TIMER}", "RAID DISABLEING IN {TIMER}", "PVE PURGING IN {TIMER}"
}
, textColor = "#FFFFFF", icon = "https://i.postimg.cc/rydRF7cc/time.png", iconColor = "#FFFFFF", statusColor = "#718D48"
}
}
}
, excludedEntitys = new List<string>() {
"mailbox.deployed", "dropbox.deployed"
}
, sche = new Sche {
utcTimeDif = 360, enableweeklysch = true, pvpOnMessage = "<#990000>PVP enabled on the server.Now you can raid others bases and fight!</color>", pveOnMessage = "<#008000>PVE enabled.Raid and fight is now prohibited!</color>", pvppurgeStartMsg = "PVP time is approaching! {TIMELEFT} minutes left.", pvppurgeEndingMsg = "PVP time is ending! {TIMELEFT} minutes left.",
}
, delaySetting = new PVPDelayNotify {
pvpdelaytime = 10, pvpDelayMsgEnabled = true, pvpDelayMessage = "You will be removed from PVP state in <color=#DC143C>{delay}</color> seconds.",
}
, discordSetting = new DiscordSetting {
enableDiscordNotify = false, discordWebhookURL = string.Empty, messageBeforeStart = false, messageBeforeStartMinutes = 30, pvpmessageEmbed = "#990000", pvpTimeMessage = new string[] {
"🔔 **Attention Rust Survivors!**", "", "PVP purge approaching!", "In {Minutes} Minutes🕒", "", "Prepare yourselves for intense battles! ⚔️",
}
, messageBeforeStartPVE = false, messageBeforeStartMinutesPVE = 30, pvemessageEmbed = "#32CD32", pveTimeMessage = new string[] {
"🔔 **Attention Rust Survivors!**", "", "PVP purge ending soon!", "In {Minutes} Minutes🕒", "", "Make your final moves wisely!", "Collect your victories and gear up for the next day!"
}
}
, commandsExefrompvpstart = new List<string> {
}
, commandsExefrompvpends = new List<string> {
}
, excludedZoneIDs = new List<string> {
"999", "6969"
}
, Version = Version,
}
;
}
protected override void LoadConfig() {
base.LoadConfig();
config = Config.ReadObject<Configuration>();
if (config.Version < Version) {
// Backup old configuration
Puts("Config version updated.Backing up old config for safe...");
BackupOldConfig();
config.Version = Version;
Config.WriteObject(config, true);
}
}
protected override void LoadDefaultConfig() {
config = CreateConfig();
}
protected override void SaveConfig() {
Config.WriteObject(config, true);
}
private void BackupOldConfig() {
string backupFileName = $"{Name}_config_backup_ver{config.Version.ToString()}_{Time:yyyy-MM-dd_HH-mm-ss}.json";
string backupFilePath = Path.Combine(Interface.Oxide.ConfigDirectory, backupFileName);
Config.WriteObject(config, false, backupFilePath);
}
#endregion
#region Localization
protected override void LoadDefaultMessages() {
lang.RegisterMessages(new Dictionary<string, string> {
["TEST"]
= "Attention! A test message",
}
, this, "en");
}
#endregion
#region Data files
private RulesData rulesData;
private void LoadRulesData() {
rulesData = Interface.Oxide.DataFileSystem.ReadObject<RulesData>($"{Name}/RulesData");
// If rulesData is null or empty, populate it with default rules
if (rulesData == null || rulesData.IsRulesDataEmpty(rulesData)) {
rulesData = RulesData.CreateDefaultRules();
SaveRulesData();
}
}
private void SaveRulesData() {
Interface.Oxide.DataFileSystem.WriteObject($"{Name}/RulesData", rulesData);
}
private class RulesData {
[JsonProperty(PropertyName = "General Rules")]
public GRules gRules {
get;
set;
}
public class GRules {
[JsonProperty("Allow Friendly Fire")]
public bool aFriendlyFire {
get;
set;
}
[JsonProperty("Allow Suicide")]
public bool allowSuicide {
get;
set;
}
[JsonProperty("Kill Sleepers")]
public bool killSleepers {
get;
set;
}
[JsonProperty("Player Radiation Damage")]
public bool pRadiation {
get;
set;
}
[JsonProperty("Allow Codelock Raid")]
public bool aCodelockRaid {
get;
set;
}
}
[JsonProperty(PropertyName = "Player Rules")]
public PlayerRules playerRules {
get;
set;
}
public class PlayerRules {
[JsonProperty("Player Can Hurt Players")]
public bool pCanHurtp {
get;
set;
}
[JsonProperty("Player Can Hurt Animals")]
public bool pCanHurta {
get;
set;
}
[JsonProperty("Player Can Hurt NPC")]
public bool pCanHurtn {
get;
set;
}
[JsonProperty("Player Can Damage(Helicopters, Vehicles)")]
public bool pCanDamEntitys {
get;
set;
}
[JsonProperty("Player Can Damage Other Player Buildings")]
public bool pCanDamOtherpBuildings {
get;
set;
}
[JsonProperty("Player Can Damage Own Buildings")]
public bool pCanDamageOwnBuildings {
get;
set;
}
[JsonProperty("Player Can Damage Own Teammates Building")]
public bool pCanDamOwnTeamamtesBuilding {
get;
set;
}
[JsonProperty("Player Can Damage Other Player Twigs")]
public bool PallowTwigDamage {
get;
set;
}
}
[JsonProperty(PropertyName = "Npc Rules")]
public NpcRules npcRules {
get;
set;
}
public class NpcRules {
[JsonProperty("Npc Can Hurt Players")]
public bool NpcHurtP {
get;
set;
}
[JsonProperty("Animal Can Hurt Players")]
public bool AnimalCanHurtP {
get;
set;
}
[JsonProperty("Patrol Heli Can Hurt Player")]
public bool PatrolHurtP {
get;
set;
}
[JsonProperty("Patrol Heli Can Hurt Buildings")]
public bool PatrolHurtB {
get;
set;
}
[JsonProperty("Player SamSite Ignore Players")]
public bool PSamigP {
get;
set;
}
[JsonProperty("Npc SamSite Ignore Players")]
public bool NSamigP {
get;
set;
}
[JsonProperty("Bradley Can Hurt Players")]
public bool bradleyHurtP {
get;
set;
}
}
[JsonProperty(PropertyName = "Entity Rules")]
public EntityRules entityRules {
get;
set;
}
public class EntityRules {
[JsonProperty("Walls Entitys Can Hurt Players(Example: High External Wall)")]
public bool WallHurtP {
get;
set;
}
[JsonProperty("Barricade Entitys Can Hurt Players(Example: Wooden Barricade)")]
public bool BarrHurtP {
get;
set;
}
[JsonProperty("MLRS Rocket Can Damage Players or Buildings")]
public bool MlrsHurtPB {
get;
set;
}
[JsonProperty("Vehicle Entitys Can Hurt Players(Example: Cars, Mini, ScrapHeli)")]
public bool VehicleHurtP {
get;
set;
}
[JsonProperty("Disable Traps(BearTrap, LandMine, GunTrap, FlameTurret, AutoTurret)")]
public bool trapD {
get;
set;
}
[JsonProperty("Enable Vehicle Collsion Damage")]
public bool enableVehicleCollsionD {
get;
set;
}
}
[JsonProperty(PropertyName = "Loot Rules")]
public LootRules lootRules {
get;
set;
}
public class LootRules {
[JsonProperty("Use Loot Protection")]
public bool useLP {
get;
set;
}
[JsonProperty("Admin Can Loot All")]
public bool adminCanLootAll {
get;
set;
}
[JsonProperty("Teams Can Access Loot")]
public bool teamsAccessLoot {
get;
set;
}
[JsonProperty("Player can loot other player in PVP Zones")]
public bool pclpvpzones {
get;
set;
}
[JsonProperty("Anyone can open Player called SupplyDrops")]
public bool anyoneOpenSupplyDrop {
get;
set;
}
}
[JsonProperty(PropertyName = "Zone Rules")]
public ZoneRules zoneRules {
get;
set;
}
public class ZoneRules {
[JsonProperty("Use ZoneManager")]
public bool zoneManager {
get;
set;
}
[JsonProperty("Disable PVE Rules In Zones")]
public bool disableRulesZone {
get;
set;
}
[JsonProperty("Enable PVP Delay from ZoneManager")]
public bool enablePVPDelay {
get;
set;
}
}
public static RulesData CreateDefaultRules() {
return new RulesData {
zoneRules = new ZoneRules {
zoneManager = true, disableRulesZone = true, enablePVPDelay = true,
}
, gRules = new GRules {
aFriendlyFire = true, allowSuicide = true, killSleepers = false, pRadiation = true, aCodelockRaid = false,
}
, playerRules = new PlayerRules {
pCanHurtp = false, pCanHurta = true, pCanHurtn = true, pCanDamEntitys = true, pCanDamOtherpBuildings = false, pCanDamageOwnBuildings = true, pCanDamOwnTeamamtesBuilding = true, PallowTwigDamage = true,
}
, npcRules = new NpcRules {
NpcHurtP = true, AnimalCanHurtP = true, PatrolHurtP = true, PatrolHurtB = true, PSamigP = true, NSamigP = true, bradleyHurtP = true
}
, entityRules = new EntityRules {
WallHurtP = true, BarrHurtP = true, MlrsHurtPB = false, VehicleHurtP = false, trapD = true, enableVehicleCollsionD = true,
}
, lootRules = new LootRules {
useLP = true, adminCanLootAll = true, teamsAccessLoot = true, pclpvpzones = false, anyoneOpenSupplyDrop = false
}
,
}
;
}
public bool IsRulesDataEmpty(RulesData data) {
return data.gRules == null && data.playerRules == null && data.npcRules == null && data.entityRules == null && data.lootRules == null && data.zoneRules == null;
}
}
#endregion
#region Commands Pack
[Command("simplepve")]
private void CommandEnable(IPlayer p, string cmd, string[] args) {
if (!p.HasPermission(PvEAdminPerms)) {
p.Message("You don't have permission to use this command.");
return;
}
if (args.Length == 0) {
p.Message("Usage: /simplepve <on|off>");
return;
}
bool enablePVE = false;
switch (args[0].ToLower()) {
case "on" : enablePVE = true;
break;
case "off" : enablePVE = false;
break;
default : p.Message("Invalid argument.Usage: /simplepve <on|off>");
return;
}
if (config.pveEnabledConfig == enablePVE) {
p.Message($"SimplePVE is already {(enablePVE ? "enabled" : "disabled")}.");
return;
}
config.pveEnabledConfig = enablePVE;
SaveConfig();
string message = config.pveEnabledConfig ? "SimplePVE enabled" : "SimplePVE disabled";
p.Message(message);
if (config.pveEnabledConfig) {
Subscribe();
}
else {
NotSubscribe();
}
foreach (var player in BasePlayer.activePlayerList) {
RemovePVPPanel(player);
RemovePVEPanel(player);
if (config.pveEnabledConfig) {
ShowPVEUI(player);
}
else {
ShowPVPUi(player);
}
}
}
[Command("rsp")]
private void ReloadPlugin(IPlayer player, string cmd, string[] args) {
if (!player.HasPermission(PvEAdminPerms)) {
player.Message("You don't have permission to use this command.");
return;
}
player.Command("oxide.reload SimplePVE");
player.Message("SimplePVE reloaded.");
}
[ChatCommand("sprules")]
private void SimplePVEGui(BasePlayer player, string cmd, string[] args) {
if (!permission.UserHasPermission(player.UserIDString, PvEAdminPerms)) {
player.ChatMessage("You don't have permission to use this command.");
return;
}
SimplePVEMainGui(player);
PVERulesUI(player, PVERules.GRules);
}
[ChatCommand("notcommand")]
private void SimplePVEGuiClose(BasePlayer player, string cmd, string[] args) {
//StatusUI(player);
Puts("command activated");
player.ChatMessage("ewe ");
}
[ConsoleCommand("spvecui")]
private void SPVECUICMD(ConsoleSystem.Arg args) {
var player = args?.Player();
string command = args.Args[0];
switch (command) {
case "pverules" : PVERulesUI(player, PVERules.GRules);
break;
case "pveschedules" : var time = DateTime.Now;
PVESchedules(player);
break;
case "grules" : PVERulesUI(player, PVERules.GRules);
break;
case "prules" : PVERulesUI(player, PVERules.PRules);
break;
case "nrules" : PVERulesUI(player, PVERules.NRules);
break;
case "erules" : PVERulesUI(player, PVERules.ERules);
break;
case "lrules" : PVERulesUI(player, PVERules.LRules);
break;
case "zrules" : PVERulesUI(player, PVERules.ZRules);
break;
case "closeall" : CuiHelper.DestroyUi(player, "SimplePVECUI");
/*if (ChangedConfig == true)
{
Server.Command($"o.reload {Name}");
ChangedConfig = false;
} */
break;
}
}
[ConsoleCommand("grulesSetting")]
private void GrulesCcmd(ConsoleSystem.Arg args) {
var player = args?.Player();
string propertyName = args.Args[0];
SetProperty(propertyName);
PVERulesUI(player, PVERules.GRules);
}
[ConsoleCommand("prulesSetting")]
private void PrulesCcmd(ConsoleSystem.Arg args) {
var player = args?.Player();
string propertyName = args.Args[0];
SetProperty(propertyName);
PVERulesUI(player, PVERules.PRules);
}
[ConsoleCommand("nrulesSetting")]
private void NrulesCcmd(ConsoleSystem.Arg args) {
var player = args?.Player();
string propertyName = args.Args[0];
SetProperty(propertyName);
PVERulesUI(player, PVERules.NRules);
}
[ConsoleCommand("erulesSetting")]
private void ErulesCcmd(ConsoleSystem.Arg args) {
var player = args?.Player();
string propertyName = args.Args[0];
SetProperty(propertyName);
PVERulesUI(player, PVERules.ERules);
}
[ConsoleCommand("lrulesSetting")]
private void LrulesCcmd(ConsoleSystem.Arg args) {
var player = args?.Player();
string propertyName = args.Args[0];
SetProperty(propertyName);
PVERulesUI(player, PVERules.LRules);
}
[ConsoleCommand("zrulesSetting")]
private void ZrulesCcmd(ConsoleSystem.Arg args) {
var player = args?.Player();
string propertyName = args.Args[0];
SetProperty(propertyName);
PVERulesUI(player, PVERules.ZRules);
}
private void SetProperty(string propertyName) {
if (config == null) return;
PropertyInfo gRulesProperty = typeof(RulesData.GRules).GetProperty(propertyName);
PropertyInfo pRulesProperty = typeof(RulesData.PlayerRules).GetProperty(propertyName);
PropertyInfo nRulesProperty = typeof(RulesData.NpcRules).GetProperty(propertyName);
PropertyInfo eRulesProperty = typeof(RulesData.EntityRules).GetProperty(propertyName);
PropertyInfo lRulesProperty = typeof(RulesData.LootRules).GetProperty(propertyName);
PropertyInfo zRulesProperty = typeof(RulesData.ZoneRules).GetProperty(propertyName);
ChangedConfig = true;
if (gRulesProperty != null) {
bool currentValue = (bool)gRulesProperty.GetValue(rulesData.gRules);
bool newValue = !currentValue;
gRulesProperty.SetValue(rulesData.gRules, newValue);
}
else if (pRulesProperty != null) {
bool currentValue = (bool)pRulesProperty.GetValue(rulesData.playerRules);
bool newValue = !currentValue;
pRulesProperty.SetValue(rulesData.playerRules, newValue);
}
else if (nRulesProperty != null) {
bool currentValue = (bool)nRulesProperty.GetValue(rulesData.npcRules);
bool newValue = !currentValue;
nRulesProperty.SetValue(rulesData.npcRules, newValue);
}
else if (eRulesProperty != null) {
bool currentValue = (bool)eRulesProperty.GetValue(rulesData.entityRules);
bool newValue = !currentValue;
eRulesProperty.SetValue(rulesData.entityRules, newValue);
}
else if (lRulesProperty != null) {
bool currentValue = (bool)lRulesProperty.GetValue(rulesData.lootRules);
bool newValue = !currentValue;
lRulesProperty.SetValue(rulesData.lootRules, newValue);
}
else if (zRulesProperty != null) {
bool currentValue = (bool)zRulesProperty.GetValue(rulesData.zoneRules);
bool newValue = !currentValue;
zRulesProperty.SetValue(rulesData.zoneRules, newValue);
}
}
#endregion
#region Plugin Loads
void Init() {
Puts("Cleaning up...");
Puts("Initializing rules.....");
//permission
permission.RegisterPermission(PvEAdminPerms, this);
permission.RegisterPermission(PvEAdminLootPerms, this);
permission.RegisterPermission(PvEAdminDamagePerms, this);
//Commands
AddCovalenceCommand("simplepve", "CommandEnable");
AddCovalenceCommand("rsp", "ReloadPlugin");
NotSubscribe();
}
private void OnServerInitialized() {
ins = this;
if (config.pveEnabledConfig) {
Subscribe();
}
else {
NotSubscribe();
}
foreach (var player in BasePlayer.activePlayerList) {
OnPlayerConnected(player);
}
InitializeStatus();
//Images load from ImageLibrary
LoadImages();
CheckStatusPlugin();
timer.In(1f, OnServerInitializedLate);
}
private void OnServerInitializedLate() {
//Start Schedules
ServerMgr.Instance.StartCoroutine(Schedules());
}
private void Loaded() {
LoadSchTime();
LoadRulesData();
}
private void OnServerSave() {
SaveRulesData();
SaveSchTime();
}
private void Unload() {
SaveRulesData();
SaveSchTime();
NotSubscribe();
foreach (var player in BasePlayer.activePlayerList) {
RemovePVEPanel(player);
RemovePVPPanel(player);
RemoveUIWarning(player);
RemoveWarningLoot(player);
CuiHelper.DestroyUi(player, "SimplePVECUI");
if (config.statusUI.status && SimpleStatus) {
SetStatus(player.UserIDString, StatusKey, 0);
}
}
update = false;
ChangedConfig = false;
DiscordMessageSent = false;
}
private void Subscribe() {
Subscribe(nameof(OnEntitySpawned));
Subscribe(nameof(OnEntityTakeDamage));
if (rulesData.lootRules.useLP) {
Subscribe(nameof(CanLootEntity));
Subscribe(nameof(CanLootPlayer));
Subscribe(nameof(CanAdministerVending));
Subscribe(nameof(OnOvenToggle));
Subscribe(nameof(CanBuild));
Subscribe(nameof(OnRackedWeaponMount));
Subscribe(nameof(OnRackedWeaponSwap));
Subscribe(nameof(OnRackedWeaponTake));
Subscribe(nameof(OnRackedWeaponUnload));
Subscribe(nameof(OnRackedWeaponLoad));
//new
Subscribe(nameof(OnItemDropped));
Subscribe(nameof(OnLootEntity));
}
if (rulesData.entityRules.trapD) {
Subscribe(nameof(OnTrapTrigger));
Subscribe(nameof(CanBeTargeted));
}
if (rulesData.npcRules.NSamigP || rulesData.npcRules.PSamigP) {
Subscribe(nameof(OnSamSiteTarget));
}
}
private void NotSubscribe() {
Unsubscribe(nameof(OnEntityTakeDamage));
Unsubscribe(nameof(CanLootEntity));
Unsubscribe(nameof(CanLootPlayer));
Unsubscribe(nameof(CanAdministerVending));
Unsubscribe(nameof(OnOvenToggle));
Unsubscribe(nameof(OnTrapTrigger));
Unsubscribe(nameof(CanBeTargeted));
Unsubscribe(nameof(OnSamSiteTarget));
Unsubscribe(nameof(OnEntitySpawned));
Unsubscribe(nameof(CanBuild));
//Racked
Unsubscribe(nameof(OnRackedWeaponMount));
Unsubscribe(nameof(OnRackedWeaponSwap));
Unsubscribe(nameof(OnRackedWeaponTake));
Unsubscribe(nameof(OnRackedWeaponUnload));
Unsubscribe(nameof(OnRackedWeaponLoad));
//new
Unsubscribe(nameof(OnItemDropped));
Unsubscribe(nameof(OnLootEntity));
}
private void CheckStatusPlugin() {
if (config.statusUI.status && !SimpleStatus) {
PrintWarning("Please install SimpleSt
// ... [Code preview truncated due to length. Full source in attached file] ...