internal HurtworldLivePlayer(PlayerSession session)
{
this.session = session;
steamId = (ulong)session.SteamId;
Character = this;
Object = session.WorldPlayerEntity;
}
public void Push(PlayerSession session, byte[] data)
{
var converter = EndianBitConverter.Big;
byte[] sendData = new byte[data.Length + 10];
int offset = 0;
converter.CopyBytes(session.NetHandle, sendData, 0);
offset += 8;
converter.CopyBytes((ushort)data.Length, sendData, offset);
offset += 2;
Buffer.BlockCopy(data, 0, sendData, offset, data.Length);
if(_socket != null)
_socket.Send(sendData);
}
/// <summary> /// Gets if the player is banned /// </summary> public bool IsBanned(PlayerSession session) => IsBanned(session.SteamId.m_SteamID);
/// <summary> /// Clears the inventory of the player /// </summary> /// <param name="session"></param> public void ClearInventory(PlayerSession session) => Inventory(session)?.DestroyAll();
/// <summary>
/// Replies to the player with a specific message
/// </summary>
/// <param name="session"></param>
/// <param name="message"></param>
private void ReplyWith(string message, PlayerSession session = null)
{
if (session == null)
{
Interface.Oxide.LogInfo(message);
return;
}
ChatManagerServer.Instance.RPC("RelayChat", session.Player, message);
}
private void CmdRevoke(PlayerSession session, string command, string[] args)
{
if (!PermissionsLoaded(session)) return;
if (!session.IsAdmin) return;
if (args.Length < 3)
{
ReplyWith(GetMessage("CommandUsageRevoke", session.SteamId.ToString()), session);
return;
}
var mode = args[0];
var name = args[1];
var perm = args[2];
if (!permission.PermissionExists(perm))
{
ReplyWith(string.Format(GetMessage("PermissionNotFound", session.SteamId.ToString()), perm), session);
return;
}
if (mode.Equals("group"))
{
if (!permission.GroupExists(name))
{
ReplyWith(string.Format(GetMessage("GroupNotFound", session.SteamId.ToString()), name), session);
return;
}
permission.RevokeGroupPermission(name, perm);
ReplyWith(string.Format(GetMessage("GroupPermissionRevoked", session.SteamId.ToString()), name, perm), session);
}
else if (mode.Equals("user"))
{
var target = FindSession(name);
if (target == null && !permission.UserExists(name))
{
ReplyWith(string.Format(GetMessage("UserNotFound", session.SteamId.ToString()), name), session);
return;
}
var userId = name;
if (target != null)
{
userId = target.SteamId.ToString();
name = target.Name;
permission.UpdateNickname(userId, name);
}
permission.RevokeUserPermission(userId, perm);
ReplyWith(string.Format(GetMessage("UserPermissionRevoked", session.SteamId.ToString()), $"{name} ({userId})", perm), session);
}
}
/// <summary>
/// Replies to the player with the specified message
/// </summary>
/// <param name="message"></param>
/// <param name="session"></param>
/// <param name="args"></param>
private static void Reply(string message, PlayerSession session = null, params object[] args)
{
if (session == null)
{
Interface.Oxide.LogInfo(message, args);
return;
}
ChatManagerServer.Instance.RPC("RelayChat", session.Player, string.Format(message, args));
}
private object GiveItem(IPlayer target, string itemNameOrId, int amount = 1, string container = "main")
{
if (config.ItemBlacklist.Contains(itemNameOrId.ToLower()))
{
return(null);
}
string itemName = itemNameOrId;
#if HURTWORLDITEMV2
PlayerSession session = target.Object as PlayerSession;
PlayerInventory inventory = session.WorldPlayerEntity.GetComponent <PlayerInventory>();
ItemGeneratorAsset generator = FindItem(itemNameOrId);
ItemObject itemObj;
if (generator.IsStackable())
{
itemObj = GlobalItemManager.Instance.CreateItem(generator, amount);
if (!inventory.GiveItemServer(itemObj))
{
GlobalItemManager.SpawnWorldItem(itemObj, inventory);
}
}
else
{
int amountGiven = 0;
while (amountGiven < amount)
{
itemObj = GlobalItemManager.Instance.CreateItem(generator);
if (!inventory.GiveItemServer(itemObj))
{
GlobalItemManager.SpawnWorldItem(itemObj, inventory);
}
amountGiven++;
}
}
#elif HURTWORLD
PlayerSession session = target.Object as PlayerSession;
PlayerInventory inventory = session.WorldPlayerEntity.GetComponent <PlayerInventory>();
GlobalItemManager.Instance.GiveItem(session.Player, FindItem(itemNameOrId), amount);
#elif REIGNOFKINGS
Player player = target.Object as Player;
if (player == null)
{
return(false);
}
Container itemContainer = null;
switch (container.ToLower())
{
case "belt":
itemContainer = player.CurrentCharacter.Entity.GetContainerOfType(CollectionTypes.Hotbar);
break;
case "main":
itemContainer = player.CurrentCharacter.Entity.GetContainerOfType(CollectionTypes.Inventory);
break;
}
InvItemBlueprint blueprint = InvDefinitions.Instance.Blueprints.GetBlueprintForName(itemName, true, true);
if (blueprint == null)
{
return(false);
}
ContainerManagement containerManagement = blueprint.TryGet <ContainerManagement>();
int stackableAmount = containerManagement != null ? containerManagement.StackLimit : 0;
int amountGiven = 0;
while (amountGiven < amount)
{
int amountToGive = Mathf.Min(stackableAmount, amount - amountGiven);
InvGameItemStack itemStack = new InvGameItemStack(blueprint, amountToGive, null);
if (!ItemCollection.AutoMergeAdd(itemContainer.Contents, itemStack))
{
int stackAmount = amountToGive - itemStack.StackAmount;
if (stackAmount != 0)
{
amountGiven += stackAmount;
}
else
{
break;
}
}
else
{
amountGiven += amountToGive;
}
if (itemContainer.Contents.FreeSlotCount == 0)
{
break;
}
}
#elif RUST
Item item = ItemManager.Create(FindItem(itemNameOrId));
if (item == null)
{
return(false);
}
item.amount = amount;
BasePlayer basePlayer = target.Object as BasePlayer;
if (basePlayer == null)
{
return(false);
}
ItemContainer itemContainer = null;
switch (container.ToLower())
{
case "belt":
itemContainer = basePlayer.inventory.containerBelt;
break;
case "main":
itemContainer = basePlayer.inventory.containerMain;
break;
}
if (!basePlayer.inventory.GiveItem(item, itemContainer))
{
item.Remove();
return(false);
}
itemName = item.info.displayName.english;
if (config.ShowPopupNotices)
{
target.Command("note.inv", item.info.itemid, amount);
target.Command("gametip.showgametip", Lang("ItemReceived", target.Id, itemName, amount));
}
#endif
if (config.ShowChatNotices)
{
Message(target, "ItemReceived", itemName, amount);
}
if (config.LogToConsole)
{
Log($"{target.Name} {amount} x {itemName}");
}
return(true);
}
string getUpName(PlayerSession session) => session.WorldPlayerEntity.GetComponent <HurtMonoBehavior>().RPC("UpdateName", uLink.RPCMode.OthersExceptOwnerBuffered).RPCName;
private void ChatGrant(PlayerSession session, string command, string[] args)
{
if (!PermissionsLoaded(session)) return;
if (!IsAdmin(session)) return;
if (args.Length < 3)
{
Reply(Lang("CommandUsageGrant", session.SteamId.ToString()), session);
return;
}
var mode = args[0];
var name = args[1];
var perm = args[2];
if (!permission.PermissionExists(perm))
{
Reply(Lang("PermissionNotFound", session.SteamId.ToString(), perm), session);
return;
}
if (mode.Equals("group"))
{
if (!permission.GroupExists(name))
{
Reply(Lang("GroupNotFound", session.SteamId.ToString(), name), session);
return;
}
permission.GrantGroupPermission(name, perm, null);
Reply(Lang("GroupPermissionGranted", session.SteamId.ToString(), name, perm), session);
}
else if (mode.Equals("user"))
{
var target = FindSession(name);
if (target == null && !permission.UserIdValid(name))
{
Reply(Lang("UserNotFound", session.SteamId.ToString(), name), session);
return;
}
var userId = name;
if (target != null)
{
userId = target.SteamId.ToString();
name = target.Name;
permission.UpdateNickname(userId, name);
}
permission.GrantUserPermission(userId, perm, null);
Reply(Lang("UserPermissionGranted", session.SteamId.ToString(), $"{name} ({userId})", perm), session);
}
}
private void ChatVersion(PlayerSession session)
{
Reply($"Oxide {OxideMod.Version} for {Title} {GameManager.Instance.Version} ({GameManager.PROTOCOL_VERSION})", session);
}
private void OnPlayerInit(PlayerSession session)
{
// Let covalence know
covalence.PlayerManager.NotifyPlayerConnect(session);
// Call covalence hook
Interface.Call("OnUserInit", covalence.PlayerManager.GetPlayer(session.SteamId.ToString()));
}
private void OnPlayerDisconnected(PlayerSession session)
{
// Call covalence hook
Interface.Call("OnUserDisconnected", covalence.PlayerManager.GetPlayer(session.SteamId.ToString()), "Unknown");
// Let covalence know
covalence.PlayerManager.NotifyPlayerDisconnect(session);
}
private object IOnPlayerChat(PlayerSession session, string message)
{
if (message.Trim().Length <= 1) return true;
var str = message.Substring(0, 1);
// Get covalence player
var iplayer = covalence.PlayerManager.GetPlayer(session.SteamId.ToString());
// Is it a chat command?
if (!str.Equals("/"))
return Interface.Call("OnPlayerChat", session, message) ?? Interface.Call("OnUserChat", iplayer, message);
// Is this a covalence command?
if (covalence.CommandSystem.HandleChatMessage(iplayer.ConnectedPlayer, message)) return true;
// Get the command string
var command = message.Substring(1);
// Parse it
string cmd;
string[] args;
ParseChatCommand(command, out cmd, out args);
if (cmd == null) return null;
// Handle it
if (!cmdlib.HandleChatCommand(session, cmd, args))
{
Reply(Lang("UnknownCommand", session.SteamId.ToString(), cmd), session);
return true;
}
Interface.Call("OnChatCommand", session, command);
return true;
}
private object IOnUserApprove(PlayerSession session)
{
session.Name = session.Identity.Name ?? "Unnamed";
var id = session.SteamId.ToString();
var ip = session.Player.ipAddress;
// Call out and see if we should reject
var canLogin = Interface.Call("CanClientLogin", session) ?? Interface.Call("CanUserLogin", session.Name, id, ip);
if (canLogin != null && (!(canLogin is bool) || !(bool)canLogin))
{
// Reject the user with the message
GameManager.Instance.KickPlayer(id, canLogin.ToString());
return true;
}
return Interface.Call("OnUserApprove", session) ?? Interface.Call("OnUserApproved", session.Name, id, ip);
}
/// <summary>
/// Returns if the player is sleeping
/// </summary>
//public bool IsSleeping(string id) => session.Identity.Sleeper != null; // TODO: Session is null OnUserDisconnected?
/// <summary>
/// Returns if the player is sleeping
/// </summary>
//public bool IsSleeping(ulong id) => session.Identity.Sleeper != null; // TODO: Session is null OnUserDisconnected?
/// <summary>
/// Returns if the player is sleeping
/// </summary>
public bool IsSleeping(PlayerSession session) => session.Identity.Sleeper != null; // TODO: Session is null OnUserDisconnected?
void SendClanTag(PlayerSession session, string name)
{
var en = (uLink.RPCMode)uLink.RPCMode.OthersExceptOwnerBuffered;
session.WorldPlayerEntity.GetComponent <HurtMonoBehavior>().RPC("RPCUpdateTag", en, name);
}
/// <summary>
/// Checks if the permission system has loaded, shows an error if it failed to load
/// </summary>
/// <returns></returns>
private bool PermissionsLoaded(PlayerSession session)
{
if (permission.IsLoaded) return true;
ReplyWith(session, "PermissionsNotLoaded", permission.LastException.Message);
return false;
}
void SendUpName(PlayerSession session, string name)
{
session.WorldPlayerEntity.GetComponent <HurtMonoBehavior>().RPC("UpdateName", uLink.RPCMode.OthersExceptOwnerBuffered, name);
}
/// <summary>
/// Replies to the player with a specific message
/// </summary>
/// <param name="session"></param>
/// <param name="key"></param>
/// <param name="args"></param>
private void ReplyWith(PlayerSession session, string key, params object[] args)
{
if (session == null)
{
Interface.Oxide.LogInfo(string.Format(lang.GetMessage(key, this), args));
return;
}
ChatManager.Instance.RPC("RelayChat", session.Player, string.Format(lang.GetMessage(key, this, session.SteamId.ToString()), args));
}
internal void NotifyPlayerConnect(PlayerSession session)
{
NotifyPlayerJoin((ulong)session.SteamId, session.Name);
livePlayers[session.SteamId.ToString()] = new HurtworldLivePlayer(session);
}
internal void NotifyPlayerDisconnect(PlayerSession session) => livePlayers.Remove(session.SteamId.ToString());
private void CmdUserGroup(PlayerSession session, string command, string[] args)
{
if (!PermissionsLoaded(session)) return;
if (!session.IsAdmin) return;
if (args.Length < 3)
{
ReplyWith(GetMessage("CommandUsageUserGroup", session.SteamId.ToString()), session);
return;
}
var mode = args[0];
var name = args[1];
var group = args[2];
var target = FindSession(name);
if (target == null && !permission.UserExists(name))
{
ReplyWith(string.Format(GetMessage("UserNotFound", session.SteamId.ToString()), name), session);
return;
}
var userId = name;
if (target != null)
{
userId = target.SteamId.ToString();
name = target.Name;
permission.UpdateNickname(userId, name);
}
if (!permission.GroupExists(group))
{
ReplyWith(string.Format(GetMessage("GroupNotFound", session.SteamId.ToString()), name), session);
return;
}
if (mode.Equals("add"))
{
permission.AddUserGroup(userId, group);
ReplyWith(string.Format(GetMessage("UserAddedToGroup", session.SteamId.ToString()), name, group), session);
}
else if (mode.Equals("remove"))
{
permission.RemoveUserGroup(userId, group);
ReplyWith(string.Format(GetMessage("UserRemovedFromGroup", session.SteamId.ToString()), name, group), session);
}
}
public void SendChatMessage(PlayerSession session, string name, string message = null)
{
ChatManagerServer.Instance.RPC("RelayChat", session.Player, message != null ? $"{name} {message}" : name);
}
private void CmdShow(PlayerSession session, string command, string[] args)
{
if (!PermissionsLoaded(session)) return;
if (!session.IsAdmin) return;
if (args.Length < 1)
{
ReplyWith(GetMessage("CommandUsageShow", session.SteamId.ToString()), session);
return;
}
var mode = args[0];
var name = args.Length > 1 ? args[1] : string.Empty;
if (mode.Equals("perms"))
{
var result = "Permissions:\n";
result += string.Join(", ", permission.GetPermissions());
ReplyWith(result, session);
}
else if (mode.Equals("user"))
{
var target = FindSession(name);
if (target == null && !permission.UserExists(name))
{
ReplyWith(GetMessage("UserNotFound", session.SteamId.ToString()), session);
return;
}
var userId = name;
if (target != null)
{
userId = target.SteamId.ToString();
name = target.Name;
permission.UpdateNickname(userId, name);
name += $" ({userId})";
}
var result = $"User '{name}' permissions:\n";
result += string.Join(", ", permission.GetUserPermissions(userId));
result += $"\nUser '{name}' groups:\n";
result += string.Join(", ", permission.GetUserGroups(userId));
ReplyWith(result, session);
}
else if (mode.Equals("group"))
{
if (!permission.GroupExists(name))
{
ReplyWith(string.Format(GetMessage("GroupNotFound", session.SteamId.ToString()), name), session);
return;
}
var result = $"Group '{name}' users:\n";
result += string.Join(", ", permission.GetUsersInGroup(name));
result += $"\nGroup '{name}' permissions:\n";
result += string.Join(", ", permission.GetGroupPermissions(name));
var parent = permission.GetGroupParent(name);
while (permission.GroupExists(parent))
{
result = $"\nParent group '{parent}' permissions:\n";
result += string.Join(", ", permission.GetGroupPermissions(parent));
parent = permission.GetGroupParent(parent);
}
ReplyWith(result, session);
}
else if (mode.Equals("groups"))
{
ReplyWith(string.Format(GetMessage("ShowGroups", session.SteamId.ToString()), "\n" + string.Join(", ", permission.GetGroups())), session);
}
}
/// <summary>
/// Checks if the permission system has loaded, shows an error if it failed to load
/// </summary>
/// <returns></returns>
private bool PermissionsLoaded(PlayerSession session)
{
if (permission.IsLoaded) return true;
ReplyWith(string.Format(GetMessage("PermissionsNotLoaded", permission.LastException.Message)), session);
return false;
}
/// <summary> /// Gets the inventory of the player /// </summary> /// <param name="session"></param> /// <returns></returns> public PlayerInventory Inventory(PlayerSession session) => session.WorldPlayerEntity.GetComponent <PlayerInventory>();
private object IOnUserApprove(PlayerSession session)
{
// Call out and see if we should reject
var canlogin = Interface.CallHook("CanClientLogin", session);
if (canlogin != null && (!(canlogin is bool) || !(bool)canlogin))
{
// Reject the user with the message
GameManager.Instance.KickPlayer(session.SteamId.ToString(), canlogin.ToString());
return true;
}
return Interface.CallHook("OnUserApprove", session);
}
/// <summary> /// Returns if the player is admin /// </summary> public bool IsAdmin(PlayerSession session) => session.IsAdmin;
private void OnPlayerDisconnected(PlayerSession session)
{
// Let covalence know
Libraries.Covalence.HurtworldCovalenceProvider.Instance.PlayerManager.NotifyPlayerDisconnect(session);
}
/// <summary> /// Gets if the player is connected /// </summary> public bool IsConnected(PlayerSession session) => session?.Player != null ? session.Player.isConnected : false;
private object IOnPlayerChat(PlayerSession session, string message)
{
if (message.Trim().Length <= 1) return true;
var str = message.Substring(0, 1);
// Is it a chat command?
if (!str.Equals("/") && !str.Equals("!")) return Interface.Oxide.CallHook("OnPlayerChat", session, message);
// Get the arg string
var argstr = message.Substring(1);
// Parse it
string chatcmd;
string[] args;
ParseChatCommand(argstr, out chatcmd, out args);
if (chatcmd == null) return null;
// Handle it
if (!cmdlib.HandleChatCommand(session, chatcmd, args))
{
ReplyWith(string.Format(GetMessage("UnknownChatCommand", session.SteamId.ToString()), chatcmd), session);
return true;
}
return true;
}
internal HurtworldPlayer(PlayerSession session) : this(session.SteamId.m_SteamID, session.Identity.Name)
{
this.session = session;
}
private void CmdPlugins(PlayerSession session, string command, string[] args)
{
if (!PermissionsLoaded(session)) return;
if (!session.IsAdmin) return;
var loaded_plugins = pluginmanager.GetPlugins().Where(pl => !pl.IsCorePlugin).ToArray();
var loaded_plugin_names = new HashSet<string>(loaded_plugins.Select(pl => pl.Name));
var unloaded_plugin_errors = new Dictionary<string, string>();
foreach (var loader in Interface.Oxide.GetPluginLoaders())
{
foreach (var name in loader.ScanDirectory(Interface.Oxide.PluginDirectory).Except(loaded_plugin_names))
{
string msg;
unloaded_plugin_errors[name] = (loader.PluginErrors.TryGetValue(name, out msg)) ? msg : "Unloaded";
}
}
var total_plugin_count = loaded_plugins.Length + unloaded_plugin_errors.Count;
if (total_plugin_count < 1)
{
ReplyWith(GetMessage("NoPluginsFound", session.SteamId.ToString()), session);
return;
}
var output = $"Listing {loaded_plugins.Length + unloaded_plugin_errors.Count} plugins:";
var number = 1;
foreach (var plugin in loaded_plugins)
output += $"\n {number++:00} \"{plugin.Title}\" ({plugin.Version}) by {plugin.Author} ({plugin.TotalHookTime:0.00}s)";
foreach (var plugin_name in unloaded_plugin_errors.Keys)
output += $"\n {number++:00} {plugin_name} - {unloaded_plugin_errors[plugin_name]}";
ReplyWith(output, session);
}
void SendChat(PlayerSession session, string message)
{
hurt.SendChatMessage(session, null, message);
}
private void CmdLoad(PlayerSession session, string command, string[] args)
{
if (!PermissionsLoaded(session)) return;
if (!session.IsAdmin) return;
if (args.Length < 1)
{
ReplyWith(GetMessage("CommandUsageLoad", session.SteamId.ToString()), session);
return;
}
if (args[0].Equals("*"))
{
Interface.Oxide.LoadAllPlugins();
return;
}
foreach (var name in args)
{
if (string.IsNullOrEmpty(name) || !Interface.Oxide.LoadPlugin(name)) continue;
if (!loadingPlugins.ContainsKey(name)) loadingPlugins.Add(name, session);
}
}
void CommandInvis(PlayerSession session, string command, string[] args)
{
if (permission.UserHasPermission(session.SteamId.ToString(), Name.ToLower() + ".admin") || session.IsAdmin)
{
if (args.Length != 1)
{
SendChat(session, prefix + "Syntax: invis 1 OR 0");
return;
}
var inv = session.WorldPlayerEntity.GetComponent <PlayerInventory>();
switch (args[0].ToLower())
{
case "true":
case "on":
case "1":
inv.SetSlot(8, GetItem("InvisiHat", 1));
if (!activ.ContainsKey((ulong)session.SteamId))
{
activ.Add((ulong)session.SteamId, getUpName(session));
}
else
{
SendChat(session, prefix + "Mode already is on");
}
SendUpName(session, " ");
SendClanTag(session, " ");
SendChat(session, prefix + "Mode on");
break;
case "false":
case "off":
case "0":
if (inv.GetSlot(8) != null && inv.GetSlot(8).Generator.name.Contains("InvisiHat"))
{
inv.RemoveItem(8);
}
if (activ.ContainsKey((ulong)session.SteamId))
{
SendUpName(session, activ[(ulong)session.SteamId]);
if (session.Identity.Clan != null)
{
SendClanTag(session, session.Identity.Clan.ClanTag);
}
activ.Remove((ulong)session.SteamId);
}
else
{
SendChat(session, prefix + "Mode already is off");
return;
}
SendChat(session, prefix + "Mode off");
break;
default:
SendChat(session, prefix + "Syntax: invis 1 OR 0");
break;
}
}
else
{
SendChat(session, "No acces");
}
}
private void CmdUnload(PlayerSession session, string command, string[] args)
{
if (!PermissionsLoaded(session)) return;
if (!session.IsAdmin) return;
if (args.Length < 1)
{
ReplyWith(GetMessage("CommandUsageUnload", session.SteamId.ToString()), session);
return;
}
if (args[0].Equals("*"))
{
Interface.Oxide.UnloadAllPlugins();
return;
}
foreach (var name in args)
{
if (string.IsNullOrEmpty(name)) continue;
var plugin = pluginmanager.GetPlugin(name);
if (plugin == null)
{
ReplyWith(string.Format(GetMessage("PluginNotLoaded", session.SteamId.ToString()), name), session);
continue;
}
Interface.Oxide.UnloadPlugin(name);
ReplyWith(string.Format(GetMessage("PluginUnloaded", session.SteamId.ToString()), plugin.Title, plugin.Version, plugin.Author), session);
}
}
/// <summary>
/// Replies to the player with a specific message
/// </summary>
/// <param name="session"></param>
/// <param name="message"></param>
private void ReplyWith(PlayerSession session, string message) => ChatManager.Instance?.RPC("RelayChat", session.Player, message);
private void CmdVersion(PlayerSession session, string command, string[] args)
{
var oxide = OxideMod.Version.ToString();
var game = GameManager.Instance.GetProtocolVersion().ToString();
if (!string.IsNullOrEmpty(oxide) && !string.IsNullOrEmpty(game))
ReplyWith(string.Format(GetMessage("OxideVersion", session.SteamId.ToString()), oxide, game), session);
}
private void ChatVersion(PlayerSession session)
{
Reply($"Oxide {OxideMod.Version} for {Title} {GameManager.Instance?.Version} ({GameManager.Instance?.GetProtocolVersion()})", session);
}
private void CmdGroup(PlayerSession session, string command, string[] args)
{
if (!PermissionsLoaded(session)) return;
if (!session.IsAdmin) return;
if (args.Length < 2)
{
ReplyWith(GetMessage("CommandUsageGroup", session.SteamId.ToString()), session);
return;
}
var mode = args[0];
var name = args[1];
var title = args.Length > 2 ? args[2] : string.Empty;
int rank;
if (args.Length < 4 || !int.TryParse(args[3], out rank))
rank = 0;
if (mode.Equals("add"))
{
if (permission.GroupExists(name))
{
ReplyWith(string.Format(GetMessage("GroupAlreadyExists", session.SteamId.ToString()), name), session);
return;
}
permission.CreateGroup(name, title, rank);
ReplyWith(string.Format(GetMessage("GroupCreated", session.SteamId.ToString()), name), session);
}
else if (mode.Equals("remove"))
{
if (!permission.GroupExists(name))
{
ReplyWith(string.Format(GetMessage("GroupNotFound", session.SteamId.ToString()), name), session);
return;
}
permission.RemoveGroup(name);
ReplyWith(string.Format(GetMessage("GroupDeleted", session.SteamId.ToString()), name), session);
}
else if (mode.Equals("set"))
{
if (!permission.GroupExists(name))
{
ReplyWith(string.Format(GetMessage("GroupNotFound", session.SteamId.ToString()), name), session);
return;
}
permission.SetGroupTitle(name, title);
permission.SetGroupRank(name, rank);
ReplyWith(string.Format(GetMessage("GroupChanged", session.SteamId.ToString()), name), session);
}
else if (mode.Equals("parent"))
{
if (!permission.GroupExists(name))
{
ReplyWith(string.Format(GetMessage("GroupNotFound", session.SteamId.ToString()), name), session);
return;
}
var parent = args[2];
if (!string.IsNullOrEmpty(parent) && !permission.GroupExists(parent))
{
ReplyWith(string.Format(GetMessage("GroupParentNotFound", session.SteamId.ToString()), parent), session);
return;
}
if (permission.SetGroupParent(name, parent))
ReplyWith(string.Format(GetMessage("GroupParentChanged", session.SteamId.ToString()), name, parent), session);
else
ReplyWith(string.Format(GetMessage("GroupParentNotChanged", session.SteamId.ToString()), name), session);
}
}
/// <summary>
/// Handles the specified chat command
/// </summary>
/// <param name="session"></param>
/// <param name="command"></param>
/// <param name="args"></param>
internal bool HandleChatCommand(PlayerSession session, string command, string[] args)
{
ChatCommand cmd;
if (!chatCommands.TryGetValue(command.ToLowerInvariant(), out cmd)) return false;
cmd.Plugin.CallHook(cmd.CallbackName, session, command, args);
return true;
}
/// <summary>
/// Returns if specified player is admin
/// </summary>
/// <param name="session"></param>
/// <returns></returns>
private bool IsAdmin(PlayerSession session)
{
if (session == null || session.IsAdmin) return true;
Reply(Lang("YouAreNotAdmin", session.SteamId.ToString()), session);
return false;
}
