internal HideHoldOutLivePlayer(PlayerInfos player)
{
this.player = player;
steamId = Convert.ToUInt64(player.account_id);
Character = this;
Object = player.Transfo.gameObject;
}
private void SendEditList(PlayerInfos player)
{
SendReply(player, GetMsg("edit1"));
SendReply(player, GetMsg("edit2"));
SendReply(player, GetMsg("edit3"));
SendReply(player, GetMsg("edit4"));
SendReply(player, GetMsg("edit5"));
SendReply(player, GetMsg("edit6"));
SendReply(player, GetMsg("edit7"));
SendReply(player, GetMsg("edit8"));
}
private void Client_PlayerAdded(PlayerInfos player)
{
if (_refreshPlayers < DateTime.UtcNow)
{
Dispatcher.InvokeAsync(delegate
{
Players.RefreshView();
});
_refreshPlayers = DateTime.UtcNow.AddMilliseconds(_refreshPlayersDelay);
}
}
private void InitializePlayer(PlayerInfos player)
{
if (!permission.UserHasPermission(player.account_id, "proximityalert.use"))
{
return;
}
if (player.PManager.GetComponent <ProximityPlayer>())
{
DestroyPlayer(player);
}
GetPlayer(player);
}
private void ChatUserGroup(PlayerInfos player, string command, string[] args)
{
if (!PermissionsLoaded(player))
{
return;
}
if (!IsAdmin(player))
{
return;
}
if (args.Length < 3)
{
Reply(Lang("CommandUsageUserGroup", player.account_id), player);
return;
}
var mode = args[0];
var name = args[1];
var group = args[2];
var target = FindPlayer(name);
if (target == null && !permission.UserIdValid(name))
{
Reply(Lang("UserNotFound", player.account_id, name), player);
return;
}
var userId = name;
if (target != null)
{
userId = target.account_id;
name = target.Nickname;
permission.UpdateNickname(userId, name);
}
if (!permission.GroupExists(group))
{
Reply(Lang("GroupNotFound", player.account_id, name), player);
return;
}
if (mode.Equals("add"))
{
permission.AddUserGroup(userId, group);
Reply(Lang("UserAddedToGroup", player.account_id, name, group), player);
}
else if (mode.Equals("remove"))
{
permission.RemoveUserGroup(userId, group);
Reply(Lang("UserRemovedFromGroup", player.account_id, name, group), player);
}
}
public void Load()
{
if (File.Exists(Application.persistentDataPath + "playerSaveFile.dat"))
{
BinaryFormatter bf = new BinaryFormatter();
FileStream file = File.Open(Application.persistentDataPath + "playerSaveFile.dat", FileMode.Open);
PlayerInfos data = (PlayerInfos)bf.Deserialize(file);
file.Close();
temp = data.temp;
}
}
private void Game_PlayerUpdated(PlayerInfos player)
{
if (player.Name.Contains("["))
{
int distance = _bot.Game.DistanceTo(player.PosX, player.PosY);
if (!player.IsAfk && IsEnabled)
{
_bot.LogMessage(player.Name + " is at " + distance + " cells from you and is not AFK, disconnecting.");
_bot.Logout(false);
}
}
}
/// <summary>
/// Handles the specified chat command
/// </summary>
/// <param name="player"></param>
/// <param name="command"></param>
/// <param name="args"></param>
internal bool HandleChatCommand(PlayerInfos player, string command, string[] args)
{
ChatCommand cmd;
if (!chatCommands.TryGetValue(command.ToLowerInvariant(), out cmd))
{
return(false);
}
cmd.Plugin.CallHook(cmd.CallbackName, player, command, args);
return(true);
}
public void Save()
{
BinaryFormatter bf = new BinaryFormatter();
FileStream file = File.Open(Application.persistentDataPath + "playerSaveFile.dat", FileMode.Open);
PlayerInfos playerData = new PlayerInfos();
playerData.temp = temp;
bf.Serialize(file, playerData);
file.Close();
}
private void OnPlayerDisconnected(PlayerInfos player)
{
// Call covalence hook
var iplayer = covalence.PlayerManager.GetPlayer(player.account_id);
Interface.CallHook("OnUserDisconnected", iplayer, null);
// Let covalence know
covalence.PlayerManager.NotifyPlayerDisconnect(player);
Debug.Log($"{player.account_id}/{player.Nickname} quit");
}
private void CanGiveKit(PlayerInfos player, string kitname)
{
if (!player.isADMIN)
{
if (!pd.playerData.ContainsKey(player.account_id))
{
pd.playerData.Add(player.account_id, new Dictionary <string, PlayerData>());
}
var kit = kits.Kits[kitname];
var playerData = pd.playerData[player.account_id];
if (!playerData.ContainsKey(kitname))
{
playerData.Add(kitname, new PlayerData());
}
bool cd = false;
bool use = false;
if (!string.IsNullOrEmpty(kit.Permission))
{
if (!permission.UserHasPermission(player.account_id, kit.Permission))
{
SendReply(player, GetMsg("noPermK"));
return;
}
}
if (kit.Cooldown > 0)
{
if (playerData[kitname].Cooldown > GrabCurrentTime() && playerData[kitname].Cooldown != 0)
{
SendReply(player, string.Format(GetMsg("cdTime"), (int)(GrabCurrentTime() - playerData[kitname].Cooldown) / 60));
return;
}
cd = true;
}
if (kit.MaxUse > 0)
{
if (playerData[kitname].Used >= kit.MaxUse)
{
SendReply(player, string.Format(GetMsg("maxUsed"), kit.Name));
return;
}
use = true;
}
if (cd)
{
playerData[kitname].Cooldown = GrabCurrentTime() + kit.Cooldown;
}
if (use)
{
playerData[kitname].Used++;
}
}
GiveKit(player, kitname);
}
private void GiveKit(PlayerInfos player, string kitname)
{
foreach (var item in kits.Kits[kitname].Items)
{
int ID = int.Parse(item.ItemID);
int Amount = int.Parse(item.Amount);
if (ID != 0)
{
nc.NetView.RPC("NET_ADMIN_ReceiveItem", player.NetPlayer, new object[] { ID, Amount });
}
}
SendReply(player, string.Format(GetMsg("giveKit"), kits.Kits[kitname].Name));
}
private void ReplaceCorpseInventory(PlayerInfos player, List <ItemDef> Items)
{
var corpses = UnityEngine.Object.FindObjectsOfType <Ragdoll_SYNC>();
foreach (var c in corpses)
{
if (c.LOOT_Container.CONTEXT_name.Contains(player.Nickname + "'s Body"))
{
c.LOOT_Container.CONTEXT_name = player.Nickname + "'s Old Body";
c.LOOT_Container.CONTENT_str = CreateInventory(Items);
}
}
}
private void GivePlayerInventory(PlayerInfos player, List <ItemDef> items)
{
foreach (var item in items)
{
int ID = int.Parse(item.ItemID);
int Amount = int.Parse(item.Amount);
if (ID != 0)
{
nc.NetView.RPC("NET_ADMIN_ReceiveItem", player.NetPlayer, new object[] { ID, Amount });
}
}
playerInv.Remove(player.account_id);
}
private bool HasPerm(PlayerInfos player)
{
if (player.isADMIN)
{
return(true);
}
if (permission.UserHasPermission(player.account_id.ToString(), "kits.admin"))
{
return(true);
}
SendReply(player, lang.GetMessage("title", this, player.account_id.ToString()) + lang.GetMessage("noPerms", this, player.account_id.ToString()));
return(false);
}
public void Instantiate(PlayerInfos infos, float z_offset)
{
controls = infos.GetControls();
if (infos.GetBoatId() == GameTime.BLUE_BOAT_ID)
{
boat = GameTime.GetBlueBoat();
}
else
{
boat = GameTime.GetRedBoat();
}
this.gameObject.transform.position = boat.gameObject.transform.position + new Vector3(0, 5, z_offset);
infos.GetModelInfos().SetModelToModelParameters(this.gameObject);
}
private bool RestoreInventory(PlayerInfos player)
{
if (igData.Inventorys.ContainsKey(player.account_id))
{
Puts("restoring :" + player.Nickname);
if (igData.Inventorys[player.account_id].RestoreOnce)
{
igData.Inventorys[player.account_id].RestoreOnce = false;
}
player.inventory = igData.Inventorys[player.account_id].Inventory;
return(true);
}
return(false);
}
internal void SetColor(Color color)
{
PlayerInfos infos = (PlayerInfos)connectionToClient.authenticationData;
if (infos == null)
{
infos = new PlayerInfos();
connectionToClient.authenticationData = infos;
}
((PlayerInfos)connectionToClient.authenticationData).PlayerColor = color;
PlayerColor = color;
_renderer.color = color;
}
private void cmdKick(PlayerInfos player, string command, string[] args)
{
if (HasPerm(player))
{
if (args == null || args.Length == 0)
{
SendReply(player, lang.GetMessage("kickSyn", this, player.account_id));
return;
}
if (args.Length >= 1)
{
KickPlayer(args[0]);
}
}
}
public void InstantiateMenu(PlayerInfos infos)
{
controls = new PlayerControls('V', "VoidAxis", "VoidAxis", "VoidKey", "VoidKey", PlayerControls.VIDE);
if (infos.GetBoatId() == GameTime.BLUE_BOAT_ID)
{
boat = GameTime.GetBlueBoat();
}
else
{
boat = GameTime.GetRedBoat();
}
infos.GetModelInfos().SetModelToModelParameters(this.gameObject);
SetIsInteracting(true);
transform.localScale = new Vector3(3, 3, 3);
gameObject.GetComponent <Rigidbody>().isKinematic = true;
}
/// <summary>
/// Method called when the server sends a message that another player disconnected
/// </summary>
/// <param name="parts"></param>
private void PlayerDisconnectResolve(string[] parts)
{
PlayerColor disconnectedPlayer = Enum.Parse <PlayerColor>(parts[1]);
PlayerInfos.Remove(disconnectedPlayer);
if (_playerOrder != null)
{
_playerOrder.Remove(disconnectedPlayer);
}
if (_orderManager != null)
{
_orderManager.Properties.Remove(disconnectedPlayer);
PlacesChanged?.Invoke(this, EventArgs.Empty);
}
PlayerDisconnected?.Invoke(this, disconnectedPlayer);
}
public void Save()
{
BinaryFormatter formatter = new BinaryFormatter();
FileStream filestream = File.Create(Application.persistentDataPath + "/savefile.dat");
PlayerInfos saver = new PlayerInfos();
//--------------------------Data-----------------------------//
saver.CompleteLevelNum = GlobalData.CompleteLevelNum;
saver.MuteSFX = GlobalData.MuteSFX;
//--------------------------Data-----------------------------//
formatter.Serialize(filestream, saver);
filestream.Close();
}
private bool SaveInventory(PlayerInfos player)
{
Puts("saving :" + player.Nickname);
if (string.IsNullOrEmpty(player.inventory))
{
return(false);
}
if (!igData.Inventorys.ContainsKey(player.account_id))
{
igData.Inventorys.Add(player.account_id, new PlayerData {
Inventory = player.inventory
});
}
igData.Inventorys[player.account_id].Inventory = player.inventory;
return(true);
}
public void Load()
{
if (File.Exists(Application.persistentDataPath + "/savefile.dat"))
{
BinaryFormatter formatter = new BinaryFormatter();
FileStream filestream = File.Open(Application.persistentDataPath + "/savefile.dat", FileMode.Open);
PlayerInfos loader = (PlayerInfos)formatter.Deserialize(filestream);
filestream.Close();
//--------------------------Data-----------------------------//
GlobalData.CompleteLevelNum = loader.CompleteLevelNum;
GlobalData.MuteSFX = loader.MuteSFX;
//--------------------------Data----------------------------//
}
}
private void ChatPlugins(PlayerInfos player, string command, string[] args)
{
if (!PermissionsLoaded(player))
{
return;
}
if (!IsAdmin(player))
{
return;
}
var loadedPlugins = pluginManager.GetPlugins().Where(pl => !pl.IsCorePlugin).ToArray();
var loadedPluginNames = new HashSet <string>(loadedPlugins.Select(pl => pl.Name));
var unloadedPluginErrors = new Dictionary <string, string>();
foreach (var loader in Interface.Oxide.GetPluginLoaders())
{
foreach (var name in loader.ScanDirectory(Interface.Oxide.PluginDirectory).Except(loadedPluginNames))
{
string msg;
unloadedPluginErrors[name] = (loader.PluginErrors.TryGetValue(name, out msg)) ? msg : "Unloaded";
}
}
var totalPluginCount = loadedPlugins.Length + unloadedPluginErrors.Count;
if (totalPluginCount < 1)
{
Reply(Lang("NoPluginsFound", player.account_id), player);
return;
}
var output = $"Listing {loadedPlugins.Length + unloadedPluginErrors.Count} plugins:";
var number = 1;
foreach (var plugin in loadedPlugins)
{
output += $"\n {number++:00} \"{plugin.Title}\" ({plugin.Version}) by {plugin.Author} ({plugin.TotalHookTime:0.00}s)";
}
foreach (var pluginName in unloadedPluginErrors.Keys)
{
output += $"\n {number++:00} {pluginName} - {unloadedPluginErrors[pluginName]}";
}
Reply(output, player);
}
private void Game_PlayerAdded(PlayerInfos player)
{
if (player.Name.Contains("["))
{
int distance = _bot.Game.DistanceTo(player.PosX, player.PosY);
string message = player.Name + " appears on the map at " + distance + " cells from you";
if (player.IsAfk)
{
message += ", but is AFK";
}
else if (IsEnabled)
{
_bot.Logout(false);
message += ", disconnecting";
}
_bot.LogMessage(message + ".");
}
}
private void cmdProx(PlayerInfos player, string command, string[] args)
{
if (!permission.UserHasPermission(player.account_id, "proximityalert.use"))
{
return;
}
if (GetPlayer(player).Activated)
{
GetPlayer(player).Activated = false;
SendReply(player, lang.GetMessage("deactive", this, player.account_id));
return;
}
else
{
GetPlayer(player).Activated = true;
SendReply(player, lang.GetMessage("active", this, player.account_id));
}
}
private void KickPlayer(string name)
{
if (uLink.Network.isServer)
{
PlayerInfos playerInfo = sm.FindPlayer(name);
if (!playerInfo.isDefined || !playerInfo.connected)
{
if (PlayerIPs.ContainsKey(name))
{
playerInfo = sm.FindPlayer(PlayerIPs[name]);
}
}
if (playerInfo.isDefined && playerInfo.connected)
{
nc.chatManager.Send_msg(string.Format(lang.GetMessage("kicked", this), playerInfo.Nickname));
uLink.Network.CloseConnection(playerInfo.NetPlayer, true);
}
}
}
public void SetSlot(int slot_id)
{
infos = new PlayerInfos(CharaMenuHandler.GetNextAvailableControl(null), slot_id);
this.slot_id = slot_id;
if (slot_id == 2)
{
playerObject = Instantiate(GameTime.GetRedModel(), transform.position, transform.rotation);
playerObject.GetComponent <Player>().InstantiateMenu(infos);
infos.GetModelInfos().SetModelToModelParameters(playerObject);
}
else if (slot_id == 3)
{
playerObject = Instantiate(GameTime.GetBlueModel(), transform.position, transform.rotation);
playerObject.GetComponent <Player>().InstantiateMenu(infos);
infos.GetModelInfos().SetModelToModelParameters(playerObject);
}
CharaMenuHandler.AddCharaSelect(this);
display.Display(infos.GetControls());
}
public void InstantiateCeleb(PlayerInfos infos, bool front, float x_offset)
{
GetMAnimator();
controls = infos.GetControls();
if (front)
{
boat = WinnerTime.GetFront();
this.HasWon(x_offset >= 0 ? 1 : 0);
}
else
{
boat = WinnerTime.GetBack();
this.HasLost(x_offset >= 0 ? 1 : 0);
}
this.gameObject.transform.position = boat.gameObject.transform.position + new Vector3(x_offset, 0, 0);
infos.GetModelInfos().SetModelToModelParameters(this.gameObject);
SetIsInteracting(true);
transform.localScale = new Vector3(3, 3, 3);
gameObject.GetComponent <Rigidbody>().isKinematic = true;
}
void OnPlayerConnected(PlayerInfos player)
{
if (igData.IsActivated)
{
if (igData.Inventorys.ContainsKey(player.account_id))
{
if (igData.Inventorys[player.account_id].RestoreOnce)
{
if (!player.connected)
{
timer.Once(3, () => { OnPlayerConnected(player); return; });
}
else
{
RestoreInventory(player);
}
}
}
}
}
private void OnPlayerConnected(PlayerInfos player)
{
Debug.Log($"{player.account_id}/{player.Nickname} joined");
// Let covalence know
covalence.PlayerManager.NotifyPlayerConnect(player);
// Do permission stuff
if (permission.IsLoaded)
{
var id = player.account_id;
permission.UpdateNickname(id, player.Nickname);
// Add player to default group
if (!permission.UserHasGroup(id, DefaultGroups[0])) permission.AddUserGroup(id, DefaultGroups[0]);
// Add player to admin group if admin
if (player.isADMIN && !permission.UserHasGroup(id, DefaultGroups[2])) permission.AddUserGroup(id, DefaultGroups[2]);
}
// Call covalence hook
Interface.Call("OnUserConnected", covalence.PlayerManager.GetPlayer(player.account_id));
}
private void ChatVersion(PlayerInfos player)
{
Reply($"Oxide {OxideMod.Version} for {Title} {NetworkController.NetManager_.get_GAME_VERSION}", player);
}
/// <summary>
/// Returns if specified player is admin
/// </summary>
/// <param name="player"></param>
/// <returns></returns>
private bool IsAdmin(PlayerInfos player)
{
if (player == null || player.isADMIN) return true;
Reply(Lang("YouAreNotAdmin", player.account_id), player);
return false;
}
private void ChatGroup(PlayerInfos player, string command, string[] args)
{
if (!PermissionsLoaded(player)) return;
if (!IsAdmin(player)) return;
if (args.Length < 2)
{
Reply(Lang("CommandUsageGroup", player.account_id), player);
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))
{
Reply(Lang("GroupAlreadyExists", player.account_id, name), player);
return;
}
permission.CreateGroup(name, title, rank);
Reply(Lang("GroupCreated", player.account_id, name), player);
}
else if (mode.Equals("remove"))
{
if (!permission.GroupExists(name))
{
Reply(Lang("GroupNotFound", player.account_id, name), player);
return;
}
permission.RemoveGroup(name);
Reply(Lang("GroupDeleted", player.account_id, name), player);
}
else if (mode.Equals("set"))
{
if (!permission.GroupExists(name))
{
Reply(Lang("GroupNotFound", player.account_id, name), player);
return;
}
permission.SetGroupTitle(name, title);
permission.SetGroupRank(name, rank);
Reply(Lang("GroupChanged", player.account_id, name), player);
}
else if (mode.Equals("parent"))
{
if (!permission.GroupExists(name))
{
Reply(Lang("GroupNotFound", player.account_id, name), player);
return;
}
var parent = args[2];
if (!string.IsNullOrEmpty(parent) && !permission.GroupExists(parent))
{
Reply(Lang("GroupParentNotFound", player.account_id, parent), player);
return;
}
if (permission.SetGroupParent(name, parent))
Reply(Lang("GroupParentChanged", player.account_id, name, parent), player);
else
Reply(Lang("GroupParentNotChanged", player.account_id, name), player);
}
}
/// <summary>
/// Replies to the player with the specified message
/// </summary>
/// <param name="message"></param>
/// <param name="player"></param>
/// <param name="args"></param>
private static void Reply(string message, PlayerInfos player = null, params object[] args)
{
if (player == null)
{
Interface.Oxide.LogInfo(message, args);
return;
}
ChatNetView.RPC("NET_Receive_msg", player.NetPlayer, "\n" + string.Format(message, args), chat_msg_type.standard, player.account_id);
}
private void ChatPlugins(PlayerInfos player, string command, string[] args)
{
if (!PermissionsLoaded(player)) return;
if (!IsAdmin(player)) return;
var loadedPlugins = pluginManager.GetPlugins().Where(pl => !pl.IsCorePlugin).ToArray();
var loadedPluginNames = new HashSet<string>(loadedPlugins.Select(pl => pl.Name));
var unloadedPluginErrors = new Dictionary<string, string>();
foreach (var loader in Interface.Oxide.GetPluginLoaders())
{
foreach (var name in loader.ScanDirectory(Interface.Oxide.PluginDirectory).Except(loadedPluginNames))
{
string msg;
unloadedPluginErrors[name] = (loader.PluginErrors.TryGetValue(name, out msg)) ? msg : "Unloaded";
}
}
var totalPluginCount = loadedPlugins.Length + unloadedPluginErrors.Count;
if (totalPluginCount < 1)
{
Reply(Lang("NoPluginsFound", player.account_id), player);
return;
}
var output = $"Listing {loadedPlugins.Length + unloadedPluginErrors.Count} plugins:";
var number = 1;
foreach (var plugin in loadedPlugins)
output += $"\n {number++:00} \"{plugin.Title}\" ({plugin.Version}) by {plugin.Author} ({plugin.TotalHookTime:0.00}s)";
foreach (var pluginName in unloadedPluginErrors.Keys)
output += $"\n {number++:00} {pluginName} - {unloadedPluginErrors[pluginName]}";
Reply(output, player);
}
private void ChatShow(PlayerInfos player, string command, string[] args)
{
if (!PermissionsLoaded(player)) return;
if (!IsAdmin(player)) return;
if (args.Length < 1)
{
Reply(Lang("CommandUsageShow", player.account_id), player);
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());
Reply(result, player);
}
else if (mode.Equals("user"))
{
if (string.IsNullOrEmpty(name))
{
Reply(Lang("CommandUsageShow", player.account_id), player);
return;
}
var target = FindPlayer(name);
if (target == null && !permission.UserIdValid(name))
{
Reply(Lang("UserNotFound", player.account_id), player);
return;
}
var userId = name;
if (target != null)
{
userId = target.account_id;
name = target.Nickname;
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));
Reply(result, player);
}
else if (mode.Equals("group"))
{
if (string.IsNullOrEmpty(name))
{
Reply(Lang("CommandUsageShow", player.account_id), player);
return;
}
if (!permission.GroupExists(name) && !string.IsNullOrEmpty(name))
{
Reply(Lang("GroupNotFound", player.account_id, name), player);
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);
}
Reply(result, player);
}
else if (mode.Equals("groups"))
{
Reply(Lang("ShowGroups", player.account_id, "\n" + string.Join(", ", permission.GetGroups())), player);
}
}
/// <summary>
/// Checks if the permission system has loaded, shows an error if it failed to load
/// </summary>
/// <returns></returns>
private bool PermissionsLoaded(PlayerInfos player)
{
if (permission.IsLoaded) return true;
Reply(Lang("PermissionsNotLoaded", permission.LastException.Message), player);
return false;
}
private void ChatUnload(PlayerInfos player, string command, string[] args)
{
if (!PermissionsLoaded(player)) return;
if (!IsAdmin(player)) return;
if (args.Length < 1)
{
Reply(Lang("CommandUsageUnload", player.account_id), player);
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)
{
Reply(Lang("PluginNotLoaded", player.account_id, name), player);
continue;
}
Interface.Oxide.UnloadPlugin(name);
Reply(Lang("PluginUnloaded", player.account_id, plugin.Title, plugin.Version, plugin.Author), player);
}
}
private void Client_PlayerUpdated(PlayerInfos player)
{
if (_refreshPlayers < DateTime.UtcNow)
{
Dispatcher.InvokeAsync(delegate
{
Players.RefreshView();
});
_refreshPlayers = DateTime.UtcNow.AddMilliseconds(_refreshPlayersDelay);
}
}
private void ChatRevoke(PlayerInfos player, string command, string[] args)
{
if (!PermissionsLoaded(player)) return;
if (!IsAdmin(player)) return;
if (args.Length < 3)
{
Reply(Lang("CommandUsageRevoke", player.account_id), player);
return;
}
var mode = args[0];
var name = args[1];
var perm = args[2];
if (!permission.PermissionExists(perm))
{
Reply(Lang("PermissionNotFound", player.account_id, perm), player);
return;
}
if (mode.Equals("group"))
{
if (!permission.GroupExists(name))
{
Reply(Lang("GroupNotFound", player.account_id, name), player);
return;
}
permission.RevokeGroupPermission(name, perm);
Reply(Lang("GroupPermissionRevoked", player.account_id, name, perm), player);
}
else if (mode.Equals("user"))
{
var target = FindPlayer(name);
if (target == null && !permission.UserIdValid(name))
{
Reply(Lang("UserNotFound", player.account_id, name), player);
return;
}
var userId = name;
if (target != null)
{
userId = target.account_id;
name = target.Nickname;
permission.UpdateNickname(userId, name);
}
permission.RevokeUserPermission(userId, perm);
Reply(Lang("UserPermissionRevoked", player.account_id, $"{name} ({userId})", perm), player);
}
}
internal void NotifyPlayerDisconnect(PlayerInfos player) => livePlayers.Remove(player.account_id);
/// <summary>
/// Handles the specified chat command
/// </summary>
/// <param name="player"></param>
/// <param name="command"></param>
/// <param name="args"></param>
internal bool HandleChatCommand(PlayerInfos player, string command, string[] args)
{
ChatCommand cmd;
if (!chatCommands.TryGetValue(command.ToLowerInvariant(), out cmd)) return false;
cmd.Plugin.CallHook(cmd.CallbackName, player, command, args);
return true;
}
private void OnPlayerDisconnected(PlayerInfos player)
{
Debug.Log($"{player.account_id}/{player.Nickname} quit");
// Call covalence hook
Interface.Call("OnUserDisconnected", covalence.PlayerManager.GetPlayer(player.account_id), "Unknown");
// Let covalence know
covalence.PlayerManager.NotifyPlayerDisconnect(player);
}
private void OnPlayerRespawned(PlayerInfos player)
{
// Call covalence hook
Interface.Call("OnUserRespawned", covalence.PlayerManager.GetPlayer(player.account_id));
}
internal void NotifyPlayerConnect(PlayerInfos player)
{
NotifyPlayerJoin(Convert.ToUInt64(player.account_id), player.Nickname);
livePlayers[player.account_id] = new HideHoldOutLivePlayer(player);
}
private void OnUpdatePlayer(string[] data)
{
string[] updateData = data[1].Split('|');
bool isNewPlayer = false;
PlayerInfos player;
DateTime expiration = DateTime.UtcNow.AddSeconds(20);
if (Players.ContainsKey(updateData[0]))
{
player = Players[updateData[0]];
player.Expiration = expiration;
}
else
{
isNewPlayer = true;
player = new PlayerInfos(expiration);
player.Name = updateData[0];
}
player.Updated = DateTime.UtcNow;
player.PosX = Convert.ToInt32(updateData[1]);
player.PosY = Convert.ToInt32(updateData[2]);
player.Direction = updateData[3][0];
player.Skin = updateData[3].Substring(1);
player.IsAfk = updateData[4][0] != '0';
player.IsInBattle = updateData[4][1] != '0';
player.PokemonPetId = Convert.ToInt32(updateData[4].Substring(2));
player.IsPokemonPetShiny = updateData[5][0] != '0';
player.IsMember = updateData[5][1] != '0';
player.IsOnground = updateData[5][2] != '0';
player.GuildId = Convert.ToInt32(updateData[5].Substring(3));
player.PetForm = Convert.ToInt32(updateData[6]); // ???
Players[player.Name] = player;
if (isNewPlayer)
{
PlayerAdded?.Invoke(player);
}
else
{
PlayerUpdated?.Invoke(player);
}
}
private void ChatUserGroup(PlayerInfos player, string command, string[] args)
{
if (!PermissionsLoaded(player)) return;
if (!IsAdmin(player)) return;
if (args.Length < 3)
{
Reply(Lang("CommandUsageUserGroup", player.account_id), player);
return;
}
var mode = args[0];
var name = args[1];
var group = args[2];
var target = FindPlayer(name);
if (target == null && !permission.UserIdValid(name))
{
Reply(Lang("UserNotFound", player.account_id, name), player);
return;
}
var userId = name;
if (target != null)
{
userId = target.account_id;
name = target.Nickname;
permission.UpdateNickname(userId, name);
}
if (!permission.GroupExists(group))
{
Reply(Lang("GroupNotFound", player.account_id, name), player);
return;
}
if (mode.Equals("add"))
{
permission.AddUserGroup(userId, group);
Reply(Lang("UserAddedToGroup", player.account_id, name, group), player);
}
else if (mode.Equals("remove"))
{
permission.RemoveUserGroup(userId, group);
Reply(Lang("UserRemovedFromGroup", player.account_id, name, group), player);
}
}
private void ChatLoad(PlayerInfos player, string command, string[] args)
{
if (!PermissionsLoaded(player)) return;
if (!IsAdmin(player)) return;
if (args.Length < 1)
{
Reply(Lang("CommandUsageLoad", player.account_id), player);
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, player);
}
}
