C#:
// Все права принадлежат дискорд сообществу https://discord.gg/VgNHPpNrz6
/* LICENSE
* Copyright (C) 2022-2024 evict
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.*/
#region > Singleton
namespace Oxide.Plugins {
using System;
using System.IO;
using Oxide.Core;
using Oxide.Core.Plugins;
using Oxide.Core.Configuration;
using Oxide.Core.Libraries.Covalence;
using UnityEngine;
using System.Collections.Generic;
using System.Linq;
using Network;
[Info("Imperium", "chucklenugget/evict", "2.2.9")]
[Description("Land Claims for Rust")]
public partial class Imperium : RustPlugin {
//Optional Dependencies
[PluginReference]
private Plugin BetterChat, Clans, RaidableBases, NPCSpawn;
private List<HookDeferral> HookDeferralRegistry = new List<HookDeferral>();
public class HookDeferral {
public string hookName;
public Plugin plugin;
public HookDeferral(string HookName, Plugin Plugin) {
hookName = HookName;
plugin = Plugin;
}
}
//Hook Deferrals
[PluginReference]
private Plugin NpcSpawn, AirEvent;
private void InitDeferList() {
//RegisterHookDeferral("OnEntityTakeDamage", NpcSpawn);
//RegisterHookDeferral("OnEntityTakeDamage", AirEvent);
}
private static Imperium Instance;
private bool Ready;
public static string dataDirectory = $"file://{Interface.Oxide.DataDirectory}{Path.DirectorySeparatorChar}ImperiumImages{Path.DirectorySeparatorChar}";
private DynamicConfigFile AreasFile;
private DynamicConfigFile FactionsFile;
private DynamicConfigFile PinsFile;
private DynamicConfigFile WarsFile;
private GameObject GO;
private ImperiumOptions Options;
private Timer UpkeepCollectionTimer;
private AreaManager Areas;
private FactionManager Factions;
private HudManager Hud;
private PinManager Pins;
private UserManager Users;
private WarManager Wars;
private ZoneManager Zones;
private RecruitManager Recruits;
private void Init() {
AreasFile = GetDataFile("areas");
FactionsFile = GetDataFile("factions");
PinsFile = GetDataFile("pins");
WarsFile = GetDataFile("wars");
}
private void RegisterHookDeferral(string hook, Plugin plugin) {
if (plugin == null) return;
HookDeferralRegistry.Add(new HookDeferral(hook, plugin));
}
private object GetExternalHookResult(string hook, params object[] args) {
if (HookDeferralRegistry.Count == 0) return null;
List<HookDeferral> filtered = HookDeferralRegistry.FindAll(r => r.hookName == hook && r.plugin != null);
if (filtered.Count == 0) return null;
object result = null;
foreach (HookDeferral def in filtered) {
if (def.plugin == null) continue;
result = def.plugin.Call(hook, args);
if (result != null) return result;
}
return null;
}
private void Loaded() {
InitLang();
InitDeferList();
Permission.RegisterAll(this);
try {
Options = Config.ReadObject<ImperiumOptions>();
}
catch (Exception ex) {
PrintError($"Error while loading configuration: {ex.ToString()}");
}
Puts("Area claims are " + (Options.Claims.Enabled ? "enabled" : "disabled"));
Puts("Taxation is " + (Options.Taxes.Enabled ? "enabled" : "disabled"));
Puts("Badlands are " + (Options.Badlands.Enabled ? "enabled" : "disabled"));
Puts("Map pins are " + (Options.Map.PinsEnabled ? "enabled" : "disabled"));
Puts("War is " + (Options.War.Enabled ? "enabled" : "disabled"));
Puts("Decay reduction is " + (Options.Decay.Enabled ? "enabled" : "disabled"));
Puts("Claim upkeep is " + (Options.Upkeep.Enabled ? "enabled" : "disabled"));
Puts("Zones are " + (Options.Zones.Enabled ? "enabled" : "disabled"));
if (Options.Upgrading.Enabled) {
PrintWarning("Land upgrading is not available in this Imperium version yet! Disabling it");
Options.Upgrading.Enabled = false;
}
if (Options.Recruiting.Enabled) {
PrintWarning("Recruiting is not available in this Imperium version yet! Disabling it");
//Options.Recruiting.Enabled = false;
}
if (BetterChat != null) {
Puts("Using " + BetterChat.Name + " by " + BetterChat.Author);
Interface.CallHook("API_RegisterThirdPartyTitle", this, new Func<IPlayer, string>(BetterChat_FormattedFactionTag));
}
Instance = this;
//Puts("Recruiting is " + (Options.Recruiting.Enabled ? "enabled" : "disabled"));
// If the map has already been initialized, we can set up now; otherwise,
// we need to wait until the savefile has been loaded.if (TerrainMeta.Size.x > 0) Setup();
}
private void OnServerInitialized(bool initial) {
if (initial) Setup();
}
private void Setup() {
GO = new GameObject();
Areas = new AreaManager();
Factions = new FactionManager();
Hud = new HudManager();
Pins = new PinManager();
Users = new UserManager();
Wars = new WarManager();
Zones = new ZoneManager();
Recruits = new RecruitManager();
Factions.Init(TryLoad<FactionInfo>(FactionsFile));
Areas.Init(TryLoad<AreaInfo>(AreasFile));
Pins.Init(TryLoad<PinInfo>(PinsFile));
Users.Init();
Wars.Init(TryLoad<WarInfo>(WarsFile));
Zones.Init();
Hud.Init();
Hud.GenerateMapOverlayImage();
if (Options.Factions.OverrideInGameTeamSystem) {
RelationshipManager.maxTeamSize = 128;
RelationshipManager.maxTeamSize_Internal = 128;
}
if (Instance.Options.Factions.UseClansPlugin) {
Factions.SyncAllWithClans();
}
if (Options.Upkeep.Enabled) UpkeepCollectionTimer = timer.Every(Options.Upkeep.CheckIntervalMinutes * 60, Upkeep.CollectForAllFactions);
PrintToChat($"{Title} v{Version} initialized.");
Ready = true;
}
private void Unload() {
SaveData();
Hud.Destroy();
Zones.Destroy();
Users.Destroy();
Wars.Destroy();
Pins.Destroy();
Areas.Destroy();
Factions.Destroy();
if (UpkeepCollectionTimer != null && !UpkeepCollectionTimer.Destroyed) UpkeepCollectionTimer.Destroy();
if (GO != null) UnityEngine.Object.Destroy(GO);
Instance = null;
}
private void OnServerSave() {
timer.Once(Core.Random.Range(10, 30), SaveData);
}
private void SaveData() {
AreasFile.WriteObject(Areas.Serialize());
FactionsFile.WriteObject(Factions.Serialize());
PinsFile.WriteObject(Pins.Serialize());
WarsFile.WriteObject(Wars.Serialize());
}
private DynamicConfigFile GetDataFile(string name) {
return Interface.Oxide.DataFileSystem.GetFile(Name + Path.DirectorySeparatorChar + name);
}
private IEnumerable<T> TryLoad<T>(DynamicConfigFile file) {
List<T> items;
try {
items = file.ReadObject<List<T>>();
}
catch (Exception ex) {
PrintWarning($"Error reading data from {file.Filename}: ${ex.ToString()}");
items = new List<T>();
}
return items;
}
private void Log(string message, params object[] args) {
LogToFile("log", String.Format(message, args), this, true);
}
private bool EnsureUserCanChangeFactionClaims(User user, Faction faction) {
if (faction == null || !faction.HasLeader(user)) {
user.SendChatMessage(nameof(Messages.NotLeaderOfFaction));
return false;
}
if (faction.MemberCount < Options.Claims.MinFactionMembers) {
user.SendChatMessage(nameof(Messages.FactionTooSmallToOwnLand), Options.Claims.MinFactionMembers);
return false;
}
return true;
}
private bool EnsureFactionCanClaimArea(User user, Faction faction, Area area) {
if (area.Type == AreaType.Badlands) {
user.SendChatMessage(nameof(Messages.AreaIsBadlands), area.Id);
return false;
}
if (faction.MemberCount < Instance.Options.Claims.MinFactionMembers) {
user.SendChatMessage(nameof(Messages.FactionTooSmallToOwnLand), Instance.Options.Claims.MinFactionMembers);
return false;
}
Area[] claimedAreas = Areas.GetAllClaimedByFaction(faction);
if (Instance.Options.Claims.RequireContiguousClaims && !area.IsClaimed && claimedAreas.Length > 0) {
int contiguousClaims = Areas.GetNumberOfContiguousClaimedAreas(area, faction);
if (contiguousClaims == 0) {
user.SendChatMessage(nameof(Messages.AreaNotContiguous), area.Id, faction.Id);
return false;
}
}
int? maxClaims = Instance.Options.Claims.MaxClaims;
if (maxClaims != null && claimedAreas.Length >= maxClaims) {
user.SendChatMessage(nameof(Messages.FactionOwnsTooMuchLand), faction.Id, maxClaims);
return false;
}
return true;
}
private bool EnsureCupboardCanBeUsedForClaim(User user, BuildingPrivlidge cupboard) {
if (cupboard == null) {
user.SendChatMessage(nameof(Messages.SelectingCupboardFailedInvalidTarget));
return false;
}
if (!cupboard.IsAuthed(user.Player)) {
user.SendChatMessage(nameof(Messages.SelectingCupboardFailedNotAuthorized));
return false;
}
return true;
}
private bool EnsureLockerCanBeUsedForArmory(User user, Locker locker, Area area) {
if (area == null || area.FactionId != user.Faction.Id) {
user.SendChatMessage(nameof(Messages.AreaNotOwnedByYourFaction));
return false;
}
return true;
}
private bool EnsureUserAndFactionCanEngageInDiplomacy(User user, Faction faction) {
if (faction == null) {
user.SendChatMessage(nameof(Messages.NotMemberOfFaction));
return false;
}
if (faction.MemberCount < Options.Claims.MinFactionMembers) {
user.SendChatMessage(nameof(Messages.FactionTooSmallToOwnLand));
return false;
}
if (Areas.GetAllClaimedByFaction(faction).Length == 0) {
user.SendChatMessage(nameof(Messages.FactionDoesNotOwnLand));
return false;
}
return true;
}
private bool EnforceCommandCooldown(User user, string command, int cooldownSeconds) {
int secondsRemaining = user.GetSecondsLeftOnCooldown(command);
if (secondsRemaining > 0) {
user.SendChatMessage(nameof(Messages.CommandIsOnCooldown), secondsRemaining);
return false;
}
user.SetCooldownExpiration(command, DateTime.UtcNow.AddSeconds(cooldownSeconds));
return true;
}
private bool TryCollectFromStacks(ItemDefinition itemDef, IEnumerable<Item> stacks, int amount) {
if (stacks.Sum(item => item.amount) < amount) return false;
int amountRemaining = amount;
var dirtyContainers = new HashSet<ItemContainer>();
foreach (Item stack in stacks) {
var amountToTake = Math.Min(stack.amount, amountRemaining);
stack.amount -= amountToTake;
amountRemaining -= amountToTake;
dirtyContainers.Add(stack.GetRootContainer());
if (stack.amount == 0) stack.RemoveFromContainer();
if (amountRemaining == 0) break;
}
foreach (ItemContainer container in dirtyContainers) container.MarkDirty();
return true;
}
}
}
namespace Oxide.Plugins {
using Oxide.Core.Plugins;
using Oxide.Core.Libraries.Covalence;
public partial class Imperium {
private string BetterChat_FormattedFactionTag(IPlayer player) {
if (Clans) return null;
Faction faction = Factions.GetByMember(player.Id);
if (faction == null) return string.Empty;
FactionColorPicker colorPicker = new FactionColorPicker();
return "[" + colorPicker.GetHexColorForFaction(faction.Id) + "][" + faction.Id + "][/#]";
}
}
}
#endregion
#region > Console To Chat
namespace Oxide.Plugins {
public partial class Imperium {
[ConsoleCommand("imperium.panel.close")]
private void ccmdImperiumPanelClose(ConsoleSystem.Arg arg) {
BasePlayer player = arg.Connection.player as BasePlayer;
if (player == null) return;
User user = player.GetComponent<User>();
if (user == null) return;
user.Panel.Close();
}
}
}
namespace Oxide.Plugins {
using UnityEngine;
public partial class Imperium {
[ConsoleCommand("imperium.panel.opentab")]
private void ccmdImperiumPanelOpenTab(ConsoleSystem.Arg arg) {
BasePlayer player = arg.Connection.player as BasePlayer;
if (player == null) return;
User user = player.GetComponent<User>();
if (user == null) return;
user.Panel.OpenTab(arg.Args[0]);
}
}
}
namespace Oxide.Plugins {
using UnityEngine;
public partial class Imperium {
[ConsoleCommand("imperium.panel.opencmd")]
private void ccmdImperiumPanelOpenCmd(ConsoleSystem.Arg arg) {
BasePlayer player = arg.Connection.player as BasePlayer;
if (player == null) return;
User user = player.GetComponent<User>();
if (user == null) return;
user.Panel.OpenCommand(arg.Args[0]);
}
}
}
namespace Oxide.Plugins {
using UnityEngine;
using System;
using System.Text.RegularExpressions;
public partial class Imperium {
[ConsoleCommand("imperium.panel.run")]
private void ccmdImperiumPanelRun(ConsoleSystem.Arg arg) {
BasePlayer player = arg.Connection.player as BasePlayer;
if (player == null) return;
User user = player.GetComponent<User>();
if (user == null) return;
string chatCommand = user.Panel.GetFullConsoleCommand();
Regex.Replace(chatCommand, @"[\""]", "\\\"", RegexOptions.None);
player.SendConsoleCommand("chat.say " + chatCommand);
if (Convert.ToBoolean(arg.Args[0])) {
user.Panel.Close();
}
else {
user.Panel.ClearCurrentCommand();
user.Panel.Refresh();
}
}
}
}
namespace Oxide.Plugins {
using System;
using UnityEngine;
public partial class Imperium {
[ConsoleCommand("imperium.panel.setarg")]
private void ccmdImperiumPanelSetArg(ConsoleSystem.Arg arg) {
BasePlayer player = arg.Connection.player as BasePlayer;
if (!player) return;
User user = player.GetComponent<User>();
if (!user) return;
if (arg.Args.Length < 3) return;
string fullArg = "";
for (int i = 2; i < arg.Args.Length; i++) {
fullArg = fullArg + arg.Args[i];
if (i != arg.Args.Length - 1) fullArg = fullArg + " ";
}
user.Panel.SetArg(Convert.ToInt32(arg.Args[0]), fullArg, Convert.ToBoolean(arg.Args[1]));
}
}
}
#endregion
#region > Chat Commands
#region commons
namespace Oxide.Plugins {
public partial class Imperium {
[ChatCommand("cancel")]
private void OnCancelCommand(BasePlayer player, string command, string[] args) {
User user = Users.Get(player);
if (user.CurrentInteraction == null) {
user.SendChatMessage(nameof(Messages.NoInteractionInProgress));
return;
}
user.SendChatMessage(nameof(Messages.InteractionCanceled));
user.CancelInteraction();
}
}
}
namespace Oxide.Plugins {
using System.Text;
public partial class Imperium {
[ChatCommand("help")]
private void OnHelpCommand(BasePlayer player, string command, string[] args) {
User user = Users.Get(player);
if (user == null) return;
var sb = new StringBuilder();
sb.AppendLine($"<size=18>Welcome to {ConVar.Server.hostname}!</size>");
sb.AppendLine($"Powered by {Name} v{Version} by <color=#ffd479>chucklenugget</color> and <color=#ffd479>evict</color>");
sb.AppendLine("Do <color=#ffd479>/i</color> to open Imperium UI.You can also do <color=#ffd479>bind i chat.say /i</color> in F1 console to easily toggle Imperium UI");
sb.AppendLine();
sb.Append("The following commands are available.To learn more about each command, do <color=#ffd479>/command help</color>.");
sb.AppendLine("For example, to learn more about how to claim land, do <color=#ffd479>/claim help</color>.");
sb.AppendLine();
sb.AppendLine("<color=#ffd479>/faction</color> Create or join a faction");
sb.AppendLine("<color=#ffd479>/claim</color> Claim areas of land");
if (Options.Taxes.Enabled) sb.AppendLine("<color=#ffd479>/tax</color> Manage taxation of your land");
if (Options.Map.PinsEnabled) sb.AppendLine("<color=#ffd479>/pin</color> Add pins (points of interest) to the map");
if (Options.War.Enabled) sb.AppendLine("<color=#ffd479>/war</color> See active wars, declare war, or offer peace");
if (Options.Badlands.Enabled) {
if (user.HasPermission(Permission.AdminBadlands)) sb.AppendLine("<color=#ffd479>/badlands</color> Find or change badlands areas");
else sb.AppendLine("<color=#ffd479>/badlands</color> Find badlands (PVP) areas");
}
user.SendChatMessage(sb);
}
}
}
#endregion
#region /imperium
namespace Oxide.Plugins {
public partial class Imperium {
[ChatCommand("i")]
private void OnImperiumCommand(BasePlayer player, string command, string[] args) {
User user = Users.Get(player);
user.Panel.Toggle();
}
}
}
#endregion
#region /pvp
namespace Oxide.Plugins {
public partial class Imperium {
[ChatCommand("pvp")]
private void OnPvpCommand(BasePlayer player, string command, string[] args) {
User user = Users.Get(player);
if (!Options.Pvp.EnablePvpCommand) {
user.SendChatMessage(nameof(Messages.PvpModeDisabled));
return;
}
if (!EnforceCommandCooldown(user, "pvp", Options.Pvp.CommandCooldownSeconds)) return;
if (user.IsInPvpMode) {
user.IsInPvpMode = false;
user.SendChatMessage(nameof(Messages.ExitedPvpMode));
Util.RunEffect(user.transform.position, "assets/prefabs/missions/effects/mission_objective_complete.prefab");
}
else {
user.IsInPvpMode = true;
user.SendChatMessage(nameof(Messages.EnteredPvpMode));
Util.RunEffect(user.transform.position, "assets/prefabs/missions/effects/mission_objective_complete.prefab");
}
user.Hud.Refresh();
}
}
}
#endregion
#region /badlands
namespace Oxide.Plugins {
using System.Linq;
public partial class Imperium {
[ChatCommand("badlands")]
private void OnBadlandsCommand(BasePlayer player, string command, string[] args) {
User user = Users.Get(player);
if (user == null) return;
if (!Options.Badlands.Enabled) {
user.SendChatMessage(nameof(Messages.BadlandsDisabled));
return;
}
if (args.Length == 0) {
var areas = Areas.GetAllByType(AreaType.Badlands).Select(a => a.Id);
user.SendChatMessage(nameof(Messages.BadlandsList), Util.Format(areas), Options.Taxes.BadlandsGatherBonus);
return;
}
if (!user.HasPermission(Permission.AdminBadlands)) {
user.SendChatMessage(nameof(Messages.NoPermission));
return;
}
var areaIds = args.Skip(1).Select(arg => Util.NormalizeAreaId(arg)).ToArray();
switch (args[0].ToLower()) {
case "add" : if (args.Length < 2) user.SendChatMessage(nameof(Messages.Usage), "/badlands add [XY XY XY...]");
else OnAddBadlandsCommand(user, areaIds);
break;
case "remove" : if (args.Length < 2) user.SendChatMessage(nameof(Messages.Usage), "/badlands remove [XY XY XY...]");
else OnRemoveBadlandsCommand(user, areaIds);
break;
case "set" : if (args.Length < 2) user.SendChatMessage(nameof(Messages.Usage), "/badlands set [XY XY XY...]");
else OnSetBadlandsCommand(user, areaIds);
break;
case "clear" : if (args.Length != 1) user.SendChatMessage(nameof(Messages.Usage), "/badlands clear");
else OnSetBadlandsCommand(user, new string[0]);
break;
default : OnBadlandsHelpCommand(user);
break;
}
}
}
}
namespace Oxide.Plugins {
using System.Collections.Generic;
using System.Linq;
public partial class Imperium {
private void OnAddBadlandsCommand(User user, string[] args) {
var areas = new List<Area>();
foreach (string arg in args) {
Area area = Areas.Get(Util.NormalizeAreaId(arg));
if (area == null) {
user.SendChatMessage(nameof(Messages.UnknownArea), arg);
return;
}
if (area.Type != AreaType.Wilderness) {
user.SendChatMessage(nameof(Messages.AreaNotWilderness), area.Id);
return;
}
areas.Add(area);
}
Areas.AddBadlands(areas);
Util.RunEffect(user.transform.position, "assets/prefabs/missions/effects/mission_objective_complete.prefab");
user.SendChatMessage(nameof(Messages.BadlandsSet), Util.Format(Areas.GetAllByType(AreaType.Badlands)));
Log($"{Util.Format(user)} added {Util.Format(areas)} to badlands");
}
}
}
namespace Oxide.Plugins {
using System.Text;
public partial class Imperium {
private User user;
private void OnBadlandsHelpCommand(User user) {
var sb = new StringBuilder();
sb.AppendLine("Available commands:");
sb.AppendLine(" <color=#ffd479>/badlands add XY [XY XY...]</color>: Add area(s) to the badlands");
sb.AppendLine(" <color=#ffd479>/badlands remove XY [XY XY...]</color>: Remove area(s) from the badlands");
sb.AppendLine(" <color=#ffd479>/badlands set XY [XY XY...]</color>: Set the badlands to a list of areas");
sb.AppendLine(" <color=#ffd479>/badlands clear</color>: Remove all areas from the badlands");
sb.AppendLine(" <color=#ffd479>/badlands help</color>: Prints this message");
user.SendChatMessage(sb);
}
}
}
namespace Oxide.Plugins {
using System.Collections.Generic;
using System.Linq;
public partial class Imperium {
private void OnRemoveBadlandsCommand(User user, string[] args) {
var areas = new List<Area>();
foreach (string arg in args) {
Area area = Areas.Get(Util.NormalizeAreaId(arg));
if (area == null) {
user.SendChatMessage(nameof(Messages.UnknownArea), arg);
return;
}
if (area.Type != AreaType.Badlands) {
user.SendChatMessage(nameof(Messages.AreaNotBadlands), area.Id);
return;
}
areas.Add(area);
}
Areas.Unclaim(areas);
Util.RunEffect(user.transform.position, "assets/prefabs/missions/effects/mission_objective_complete.prefab");
user.SendChatMessage(nameof(Messages.BadlandsSet), Util.Format(Areas.GetAllByType(AreaType.Badlands)));
Log($"{Util.Format(user)} removed {Util.Format(areas)} from badlands");
}
}
}
namespace Oxide.Plugins {
using System.Collections.Generic;
using System.Linq;
public partial class Imperium {
private void OnSetBadlandsCommand(User user, string[] args) {
var areas = new List<Area>();
foreach (string arg in args) {
Area area = Areas.Get(Util.NormalizeAreaId(arg));
if (area == null) {
user.SendChatMessage(nameof(Messages.UnknownArea), arg);
return;
}
if (area.Type != AreaType.Wilderness) {
user.SendChatMessage(nameof(Messages.AreaNotWilderness), area.Id);
return;
}
areas.Add(area);
}
Areas.Unclaim(Areas.GetAllByType(AreaType.Badlands));
Areas.AddBadlands(areas);
Util.RunEffect(user.transform.position, "assets/prefabs/missions/effects/mission_objective_complete.prefab");
user.SendChatMessage(nameof(Messages.BadlandsSet), Util.Format(Areas.GetAllByType(AreaType.Badlands)));
Log($"{Util.Format(user)} set badlands to {Util.Format(areas)}");
}
}
}
#endregion
#region /claim
namespace Oxide.Plugins {
using System.Linq;
public partial class Imperium {
[ChatCommand("claim")]
private void OnClaimCommand(BasePlayer player, string command, string[] args) {
User user = Users.Get(player);
if (user == null) return;
if (!Options.Claims.Enabled) {
user.SendChatMessage(nameof(Messages.AreaClaimsDisabled));
return;
}
if (args.Length == 0) {
OnClaimAddCommand(user);
return;
}
var restArguments = args.Skip(1).ToArray();
switch (args[0].ToLower()) {
case "add" : OnClaimAddCommand(user);
break;
case "remove" : OnClaimRemoveCommand(user);
break;
case "hq" : OnClaimHeadquartersCommand(user);
break;
case "rename" : OnClaimRenameCommand(user, restArguments);
break;
case "give" : OnClaimGiveCommand(user, restArguments);
break;
case "cost" : OnClaimCostCommand(user, restArguments);
break;
case "upkeep" : OnClaimUpkeepCommand(user);
break;
case "show" : OnClaimShowCommand(user, restArguments);
break;
case "list" : OnClaimListCommand(user, restArguments);
break;
case "assign" : OnClaimAssignCommand(user, restArguments);
break;
case "delete" : OnClaimDeleteCommand(user, restArguments);
break;
case "info" : case "upgrade" : default : OnClaimHelpCommand(user);
break;
}
}
}
}
namespace Oxide.Plugins {
public partial class Imperium {
private void OnClaimAddCommand(User user) {
Faction faction = Factions.GetByMember(user);
if (!EnsureUserCanChangeFactionClaims(user, faction)) return;
user.SendChatMessage(nameof(Messages.SelectClaimCupboardToAdd));
user.BeginInteraction(new AddingClaimInteraction(faction));
}
}
}
namespace Oxide.Plugins {
public partial class Imperium {
private void OnClaimAssignCommand(User user, string[] args) {
if (!user.HasPermission(Permission.AdminClaims)) {
user.SendChatMessage(nameof(Messages.NoPermission));
return;
}
if (args.Length == 0) {
user.SendChatMessage(nameof(Messages.Usage), "/claim assign FACTION");
return;
}
string factionId = Util.NormalizeFactionId(args[0]);
Faction faction = Factions.Get(factionId);
if (faction == null) {
user.SendChatMessage(nameof(Messages.FactionDoesNotExist), factionId);
return;
}
user.SendChatMessage(nameof(Messages.SelectClaimCupboardToAssign));
user.BeginInteraction(new AssigningClaimInteraction(faction));
}
}
}
namespace Oxide.Plugins {
public partial class Imperium {
private void OnClaimCostCommand(User user, string[] args) {
Faction faction = Factions.GetByMember(user);
if (faction == null) {
user.SendChatMessage(nameof(Messages.NotMemberOfFaction));
return;
}
if (faction.MemberCount < Options.Claims.MinFactionMembers) {
user.SendChatMessage(nameof(Messages.FactionTooSmallToOwnLand), Options.Claims.MinFactionMembers);
return;
}
if (args.Length > 1) {
user.SendChatMessage(nameof(Messages.Usage), "/claim cost [XY]");
return;
}
Area area;
if (args.Length == 0) area = user.CurrentArea;
else area = Areas.Get(Util.NormalizeAreaId(args[0]));
if (area == null) {
user.SendChatMessage(nameof(Messages.Usage), "/claim cost [XY]");
return;
}
if (area.Type == AreaType.Badlands) {
user.SendChatMessage(nameof(Messages.AreaIsBadlands), area.Id);
return;
}
else if (area.Type != AreaType.Wilderness) {
user.SendChatMessage(nameof(Messages.CannotClaimAreaAlreadyClaimed), area.Id, area.FactionId);
return;
}
int cost = area.GetClaimCost(faction);
user.SendChatMessage(nameof(Messages.ClaimCost), area.Id, faction.Id, cost);
}
}
}
namespace Oxide.Plugins {
using System.Collections.Generic;
public partial class Imperium {
private void OnClaimDeleteCommand(User user, string[] args) {
if (args.Length == 0) {
user.SendChatMessage(nameof(Messages.Usage), "/claim delete XY [XY XY...]");
return;
}
if (!user.HasPermission(Permission.AdminClaims)) {
user.SendChatMessage(nameof(Messages.NoPermission));
return;
}
var areas = new List<Area>();
foreach (string arg in args) {
Area area = Areas.Get(Util.NormalizeAreaId(arg));
if (area.Type == AreaType.Badlands) {
user.SendChatMessage(nameof(Messages.AreaIsBadlands), area.Id);
return;
}
if (area.Type == AreaType.Wilderness) {
user.SendChatMessage(nameof(Messages.AreaIsWilderness), area.Id);
return;
}
areas.Add(area);
}
foreach (Area area in areas) {
PrintToChat(Messages.AreaClaimDeletedAnnouncement, area.FactionId, area.Id);
Log($"{Util.Format(user)} deleted {area.FactionId}'s claim on {area.Id}");
}
Areas.Unclaim(areas);
}
}
}
namespace Oxide.Plugins {
public partial class Imperium {
private void OnClaimGiveCommand(User user, string[] args) {
if (args.Length == 0) {
user.SendChatMessage(nameof(Messages.Usage), "/claim give FACTION");
return;
}
Faction sourceFaction = Factions.GetByMember(user);
if (!EnsureUserCanChangeFactionClaims(user, sourceFaction)) return;
string factionId = Util.NormalizeFactionId(args[0]);
Faction targetFaction = Factions.Get(factionId);
if (targetFaction == null) {
user.SendChatMessage(nameof(Messages.FactionDoesNotExist), factionId);
return;
}
user.SendChatMessage(nameof(Messages.SelectClaimCupboardToTransfer));
user.BeginInteraction(new TransferringClaimInteraction(sourceFaction, targetFaction));
}
}
}
namespace Oxide.Plugins {
public partial class Imperium {
private void OnClaimHeadquartersCommand(User user) {
Faction faction = Factions.GetByMember(user);
if (!EnsureUserCanChangeFactionClaims(user, faction)) return;
user.SendChatMessage(nameof(Messages.SelectClaimCupboardForHeadquarters));
user.BeginInteraction(new SelectingHeadquartersInteraction(faction));
}
}
}
namespace Oxide.Plugins {
using System.Text;
public partial class Imperium {
private void OnClaimHelpCommand(User user) {
var sb = new StringBuilder();
sb.AppendLine("Available commands:");
sb.AppendLine(" <color=#ffd479>/claim</color>: Add a claim for your faction");
sb.AppendLine(" <color=#ffd479>/claim hq</color>: Select your faction's headquarters");
sb.AppendLine(" <color=#ffd479>/claim remove</color>: Remove a claim for your faction (no undo!)");
sb.AppendLine(" <color=#ffd479>/claim give FACTION</color>: Give a claimed area to another faction (no undo!)");
sb.AppendLine(" <color=#ffd479>/claim rename XY \"NAME\"</color>: Rename an area claimed by your faction");
sb.AppendLine(" <color=#ffd479>/claim show XY</color>: Show who owns an area");
sb.AppendLine(" <color=#ffd479>/claim list FACTION</color>: List all areas claimed for a faction");
sb.AppendLine(" <color=#ffd479>/claim cost [XY]</color>: Show the cost for your faction to claim an area");
if (!Options.Upkeep.Enabled) sb.AppendLine(" <color=#ffd479>/claim upkeep</color>: Show information about upkeep costs for your faction");
sb.AppendLine(" <color=#ffd479>/claim help</color>: Prints this message");
if (user.HasPermission(Permission.AdminClaims)) {
sb.AppendLine("Admin commands:");
sb.AppendLine(" <color=#ffd479>/claim assign FACTION</color>: Use the hammer to assign a claim to another faction");
sb.AppendLine(" <color=#ffd479>/claim delete XY [XY XY XY...]</color>: Remove the claim on the specified areas (no undo!)");
}
user.SendChatMessage(sb);
}
}
}
namespace Oxide.Plugins {
using System;
using System.Linq;
using System.Text;
public partial class Imperium {
private void OnClaimListCommand(User user, string[] args) {
if (args.Length != 1) {
user.SendChatMessage(nameof(Messages.Usage), "/claim list FACTION");
return;
}
string factionId = Util.NormalizeFactionId(args[0]);
Faction faction = Factions.Get(factionId);
if (faction == null) {
user.SendChatMessage(nameof(Messages.FactionDoesNotExist), factionId);
return;
}
Area[] areas = Areas.GetAllClaimedByFaction(faction);
Area headquarters = areas.FirstOrDefault(a => a.Type == AreaType.Headquarters);
var sb = new StringBuilder();
if (areas.Length == 0) {
sb.AppendFormat(String.Format("<color=#ffd479>[{0}]</color> has no land holdings.", factionId));
}
else {
float percentageOfMap = (areas.Length / (float)Areas.Count) * 100;
sb.AppendLine(String.Format("<color=#ffd479>[{0}] owns {1} tiles ({2:F2}% of the known world)</color>", faction.Id, areas.Length, percentageOfMap));
sb.AppendLine(String.Format("Headquarters: {0}", (headquarters == null) ? "Unknown" : headquarters.Id));
sb.AppendLine(String.Format("Areas claimed: {0}", Util.Format(areas)));
}
user.SendChatMessage(sb);
}
}
}
namespace Oxide.Plugins {
public partial class Imperium {
private void OnClaimRemoveCommand(User user) {
Faction faction = Factions.GetByMember(user);
if (!EnsureUserCanChangeFactionClaims(user, faction)) return;
user.SendChatMessage(nameof(Messages.SelectClaimCupboardToRemove));
user.BeginInteraction(new RemovingClaimInteraction(faction));
}
}
}
namespace Oxide.Plugins {
using System;
public partial class Imperium {
private void OnClaimRenameCommand(User user, string[] args) {
Faction faction = Factions.GetByMember(user);
if (!EnsureUserCanChangeFactionClaims(user, faction)) return;
if (args.Length != 2) {
user.SendChatMessage(nameof(Messages.Usage), "/claim rename XY \"NAME\"");
return;
}
var areaId = Util.NormalizeAreaId(args[0]);
var name = Util.NormalizeAreaName(args[1]);
if (name == null || name.Length < Options.Claims.MinAreaNameLength || name.Length > Options.Claims.MaxAreaNameLength) {
user.SendChatMessage(nameof(Messages.InvalidAreaName), Options.Claims.MinAreaNameLength, Options.Claims.MaxAreaNameLength);
return;
}
Area area = Areas.Get(areaId);
if (area == null) {
user.SendChatMessage(nameof(Messages.UnknownArea), areaId);
return;
}
if (area.FactionId != faction.Id) {
user.SendChatMessage(nameof(Messages.AreaNotOwnedByYourFaction), area.Id);
return;
}
Util.RunEffect(user.transform.position, "assets/prefabs/missions/effects/mission_objective_complete.prefab");
user.SendChatMessage(nameof(Messages.AreaRenamed), area.Id, name);
Log($"{Util.Format(user)} renamed {area.Id} to {name}");
area.Name = name;
}
}
}
namespace Oxide.Plugins {
public partial class Imperium {
private void OnClaimShowCommand(User user, string[] args) {
if (args.Length != 1) {
user.SendChatMessage(nameof(Messages.Usage), "/claim show XY");
return;
}
Area area = Areas.Get(Util.NormalizeAreaId(args[0]));
switch (area.Type) {
case AreaType.Badlands : user.SendChatMessage(nameof(Messages.AreaIsBadlands), area.Id);
return;
case AreaType.Claimed : user.SendChatMessage(nameof(Messages.AreaIsClaimed), area.Id, area.FactionId);
return;
case AreaType.Headquarters : user.SendChatMessage(nameof(Messages.AreaIsHeadquarters), area.Id, area.FactionId);
return;
default : user.SendChatMessage(nameof(Messages.AreaIsWilderness), area.Id);
return;
}
}
}
}
namespace Oxide.Plugins {
using System;
public partial class Imperium {
private void OnClaimUpkeepCommand(User user) {
if (!Options.Upkeep.Enabled) {
user.SendChatMessage(nameof(Messages.UpkeepDisabled));
return;
}
Faction faction = Factions.GetByMember(user);
if (faction == null) {
user.SendChatMessage(nameof(Messages.NotMemberOfFaction));
return;
}
if (faction.MemberCount < Options.Claims.MinFactionMembers) {
user.SendChatMessage(nameof(Messages.FactionTooSmallToOwnLand), Options.Claims.MinFactionMembers);
return;
}
Area[] areas = Areas.GetAllClaimedByFaction(faction);
if (areas.Length == 0) {
user.SendChatMessage(nameof(Messages.NoAreasClaimed));
return;
}
int upkeep = faction.GetUpkeepPerPeriod();
var nextPaymentHours = (int)faction.NextUpkeepPaymentTime.Subtract(DateTime.UtcNow).TotalHours;
if (nextPaymentHours > 0) user.SendChatMessage(nameof(Messages.UpkeepCost), upkeep, areas.Length, faction.Id, nextPaymentHours);
else user.SendChatMessage(nameof(Messages.UpkeepCostOverdue), upkeep, areas.Length, faction.Id, nextPaymentHours);
}
}
}
#endregion
#region /faction
namespace Oxide.Plugins {
using System.Linq;
public partial class Imperium {
[ChatCommand("faction")]
private void OnFactionCommand(BasePlayer player, string command, string[] args) {
User user = Users.Get(player);
if (user == null) return;
if (args.Length == 0) {
OnFactionShowCommand(user);
return;
}
var restArguments = args.Skip(1).ToArray();
switch (args[0].ToLower()) {
case "create" : OnFactionCreateCommand(user, restArguments);
break;
case "join" : OnFactionJoinCommand(user, restArguments);
break;
case "leave" : OnFactionLeaveCommand(user, restArguments);
break;
case "invite" : OnFactionInviteCommand(user, restArguments);
break;
case "kick" : OnFactionKickCommand(user, restArguments);
break;
case "promote" : OnFactionPromoteCommand(user, restArguments);
break;
case "demote" : OnFactionDemoteCommand(user, restArguments);
break;
case "disband" : OnFactionDisbandCommand(user, restArguments);
break;
case "badlands" : OnFactionBadlandsCommand(user, restArguments);
break;
case "help" : default : OnFactionHelpCommand(user);
break;
}
}
}
}
namespace Oxide.Plugins {
using System;
public partial class Imperium {
[ChatCommand("f")]
private void OnFactionChatCommand(BasePlayer player, string command, string[] args) {
User user = Users.Get(player);
if (user == null) return;
string message = String.Join(" ", args).Trim();
if (message.Length == 0) {
user.SendChatMessage(nameof(Messages.Usage), "/f MESSAGE...");
return;
}
Faction faction = Factions.GetByMember(user);
if (faction == null) {
user.SendChatMessage(nameof(Messages.NotMemberOfFaction));
return;
}
faction.SendChatMessage(nameof(Messages.FactionChatMessage), user.UserName, message);
Puts("[FACTION] {0} - {1}: {2}", faction.Id, user.UserName, message);
}
}
}
namespace Oxide.Plugins {
public partial class Imperium {
private void OnFactionCreateCommand(User user, string[] args) {
if (Instance.Options.Factions.UseClansPlugin) {
user.SendChatMessage(nameof(Messages.CannotManageFactionUseClansInstead));
return;
}
if (!user.HasPermission(Permission.ManageFactions)) {
user.SendChatMessage(nameof(Messages.NoPermission));
return;
}
if (user.Faction != null) {
user.SendChatMessage(nameof(Messages.AlreadyMemberOfFaction));
return;
}
if (args.Length != 1) {
user.SendChatMessage(nameof(Messages.Usage), "/faction create NAME");
return;
}
string id = Util.RemoveSpecialCharacters(args[0].Replace(" ", ""));
if (id.Length < Options.Factions.MinFactionNameLength || id.Length > Options.Factions.MaxFactionNameLength) {
user.SendChatMessage(nameof(Messages.InvalidFactionName), Options.Factions.MinFactionNameLength, Options.Factions.MaxFactionNameLength);
return;
}
if (Factions.Exists(id)) {
user.SendChatMessage(nameof(Messages.FactionAlreadyExists), id);
return;
}
PrintToChat(Messages.FactionCreatedAnnouncement, id);
Log($"{Util.Format(user)} created faction {id}");
Util.RunEffect(user.transform.position, "assets/prefabs/missions/effects/mission_victory.prefab");
Faction faction = Factions.Create(id, user);
user.SetF
// ... [Code preview truncated due to length. Full source in attached file] ...