internal void Respawn(RespawningTeamEventArgs ev) { if (ev.NextKnownTeam != Respawning.SpawnableTeamType.ChaosInsurgency) { respawnHappened = true; } }
/// <summary> /// Called when respawning a team. /// </summary> /// <param name="ev"></param> public void OnRespawnTeam(RespawningTeamEventArgs ev) { if (ev.NextKnownTeam == Respawning.SpawnableTeamType.ChaosInsurgency) { Plugin.SpawnManager.OnRespawn(ev); } }
/// <summary> /// Handles spawning Custom Chaos. /// </summary> /// <param name="ev"></param> public void OnRespawn(RespawningTeamEventArgs ev) { foreach (Player ply in RandomCICommanders(ev.Players)) { MakeCICommander(ply, out CICommanderClass comm); } }
public async void OnRespawningTeam(RespawningTeamEventArgs ev) { if (Instance.Config.EventsToLog.RespawningTeam) { await Network.SendAsync(new RemoteCommand("log", "gameEvents", string.Format(ev.NextKnownTeam == SpawnableTeamType.ChaosInsurgency ? Language.ChaosInsurgencyHaveSpawned : Language.NineTailedFoxHaveSpawned, ev.Players.Count))).ConfigureAwait(false); } }
public void OnTeamRespawn(RespawningTeamEventArgs ev) { if (Blackout.active) { ev.NextKnownTeam = Respawning.SpawnableTeamType.ChaosInsurgency; ev.Players.Clear(); } }
public void OnRespawningTeam(RespawningTeamEventArgs ev) { if (GrenadeRun.Instance.GrenadeRound) { ev.NextKnownTeam = SpawnableTeamType.None; ev.Players.Clear(); } }
public void CloseTheBorder(RespawningTeamEventArgs ev) { foreach (var plr in ev.Players) { Timing.RunCoroutine(SpawnAsZeBORDER(plr)); Timing.RunCoroutine(SpawnAtRNG(plr)); } }
public void OnTeamRespawning(RespawningTeamEventArgs ev) { foreach (Npc npc in Npc.List) { NPCTeamRespawnEvent nev = new NPCTeamRespawnEvent(npc, null, ev.NextKnownTeam); npc.FireEvent(nev); } }
public void RunWhenTeamRespawns(RespawningTeamEventArgs ev) { if (Instance.Config.EnableReverseRoleRespawnWaves) { Timing.CallDelayed(0.1f, () => _chaosRespawnHandle = Timing.RunCoroutine(SpawnReverseOfWave(ev.Players, ev.NextKnownTeam == Respawning.SpawnableTeamType.ChaosInsurgency))); } }
public void OnRespawningTeam(RespawningTeamEventArgs ev) { foreach (EPlayer player in EPlayer.List) { if (afk_players.Contains(player)) { ev.Players.Remove(player); } } }
public void OnRespawningTeam(RespawningTeamEventArgs ev) { foreach (Player i in ev.Players.ToList()) { if (afk_players.Contains(i)) { ev.Players.Remove(i); i.ShowHint(AFK.Instance.Config.AFKHintContent, AFK.Instance.Config.AFKHintDuration); } } }
public void OnTeamRespawn(RespawningTeamEventArgs ev) { tcp.SendData(new TeamRespawn { eventName = "TeamRespawn", players = Exiled.API.Features.Player.List.Select(x => { return(PlyToUser(x)); }).ToArray(), team = ev.NextKnownTeam == Respawning.SpawnableTeamType.ChaosInsurgency ? 0 : 1 }); }
public void OnRespawningTeam(RespawningTeamEventArgs ev) { if (ev.NextKnownTeam == Respawning.SpawnableTeamType.ChaosInsurgency) { CheckForEvent("OnRespawningCI", false, true, NumberOfRespawns: ev.MaximumRespawnAmount); } else { CheckForEvent("OnRespawningMTF", false, true, NumberOfRespawns: ev.MaximumRespawnAmount); } CheckForEvent("OnRespawningTeam", false, true, spawnableTeam: ev.NextKnownTeam, NumberOfRespawns: ev.MaximumRespawnAmount); }
internal void OnTeamRespawn(RespawningTeamEventArgs ev) { if (ev.NextKnownTeam.ToString() == "ChaosInsurgency") { ChaosRespawnCount++; LastChaosRespawn = DateTime.Now; } else if (ev.NextKnownTeam.ToString() == "NineTailedFox") { MtfRespawnCount++; LastMtfRespawn = DateTime.Now; } }
public void CassieSpawnMgr(RespawningTeamEventArgs ev) { //Not Working i guess /*if(ev.NextKnownTeam == Respawning.SpawnableTeamType.ChaosInsurgency) * { * features.Cassie.Message("ChaosInsurgency hasentered"); * features.Log.Info("Chaos Insurgency Spawned."); * } * else if (ev.NextKnownTeam == Respawning.SpawnableTeamType.NineTailedFox) * { * features.Log.Info("Mobile Task Force Unit Spawned."); * * }*///Erased because some bugs }
public void OnRespawningTeam(RespawningTeamEventArgs ev) { plugin.TeamRespawnCount++; if (ev.NextKnownTeam != SpawnableTeamType.ChaosInsurgency) { return; } if (!plugin.IsSpawnable) { if (!string.IsNullOrEmpty(config.SpawnManager.ChaosEntryAnnoucement)) { Cassie.GlitchyMessage(config.SpawnManager.ChaosEntryAnnoucement, 0.05f, 0.05f); } return; } ev.IsAllowed = false; bool prioritySpawn = RespawnManager.Singleton._prioritySpawn; if (prioritySpawn) { ev.Players.OrderBy(x => x.ReferenceHub.characterClassManager.DeathTime); } List <Player> sHPlayers = new List <Player>(); for (int i = 0; i < config.SpawnManager.MaxSquad && ev.Players.Count > 0; i++) { Player player = prioritySpawn ? ev.Players.First() : ev.Players[UnityEngine.Random.Range(0, ev.Players.Count)]; sHPlayers.Add(player); ev.Players.Remove(player); } Timing.CallDelayed(0.1f, () => API.SpawnSquad(sHPlayers)); if (config.SpawnManager.MaxSpawns > 0) { plugin.SerpentsRespawnCount++; } plugin.IsSpawnable = false; ev.NextKnownTeam = SpawnableTeamType.None; }
public void OnServerRespawningTeam(RespawningTeamEventArgs ev) { if (!_plugin.Config.ShowRemainingTargetsMessage) { return; } if (ev.NextKnownTeam == SpawnableTeamType.ChaosInsurgency) { return; } _remainingTargetCount += ev.Players.Count; var scpPlayers = Player.List.Where(p => p.Side == Side.Scp); BroadcastMessage(scpPlayers, RemainingTargetMessage.Replace("$count", _remainingTargetCount.ToString())); }
public void OnTeamRespawn(RespawningTeamEventArgs ev) { if (isSpawnable) { if (ev.NextKnownTeam == Respawning.SpawnableTeamType.NineTailedFox) { // Prevent announcement ev.NextKnownTeam = Respawning.SpawnableTeamType.ChaosInsurgency; } List <Player> SHPlayers = new List <Player>(); List <Player> CIPlayers = new List <Player>(ev.Players); ev.Players.Clear(); for (int i = 0; i < SerpentsHand.instance.Config.MaxSquad && CIPlayers.Count > 0; i++) { Player player = CIPlayers[rand.Next(CIPlayers.Count)]; SHPlayers.Add(player); CIPlayers.Remove(player); } Timing.CallDelayed(0.1f, () => { if (!isSpawnable) { SHPlayers.Clear(); } if (isSpawnable) { SpawnSquad(SHPlayers); serpentsRespawnCount++; } }); } else if (ev.NextKnownTeam == Respawning.SpawnableTeamType.ChaosInsurgency) { string ann = SerpentsHand.instance.Config.CiEntryAnnouncement; if (ann != string.Empty) { Cassie.GlitchyMessage(ann, 0.05f, 0.05f); } } teamRespawnCount++; }
public void OnRespawningTeam(RespawningTeamEventArgs ev) { if (ev.NextKnownTeam == SpawnableTeamType.ChaosInsurgency) { AnnouncementSettings settings = SimpleCassie.Instance.Config.ChaosRespawn; Log.Info( $"ChaosRespawn: {settings.Enabled}, roundStartMsg: {settings.Message}, roundStartDelay: {settings.Delay}, roundStartNoise: {settings.MakeNoise}"); Timing.RunCoroutine(Extensions.CassieMessage(settings.Message, false, settings.MakeNoise, settings.Delay)); } else if (ev.NextKnownTeam == SpawnableTeamType.NineTailedFox) { AnnouncementSettings settings = SimpleCassie.Instance.Config.MtfRespawn; Log.Info( $"MtfRespawn: {settings.Enabled}, roundStartMsg: {settings.Message}, roundStartDelay: {settings.Delay}, roundStartNoise: {settings.MakeNoise}"); Timing.RunCoroutine(Extensions.CassieMessage(settings.Message, false, settings.MakeNoise, settings.Delay)); } }
public void OnTeamRespawn(RespawningTeamEventArgs ev) { if (ev.NextKnownTeam == Respawning.SpawnableTeamType.NineTailedFox && rand.Next(1, 101) <= CISpy.instance.Config.SpawnChance && ev.Players.Count >= CISpy.instance.Config.MinimumSquadSize) { List <Player> respawn = new List <Player>(ev.Players); Timing.CallDelayed(0.1f, () => { List <Player> roleList = respawn.Where(x => CISpy.instance.Config.SpyRoles.Contains((int)x.Role)).ToList(); if (roleList.Count > 0) { Player player = roleList[rand.Next(roleList.Count)]; if (player != null) { MakeSpy(player); } } }); } }
internal void RespawningTeam(RespawningTeamEventArgs ev) { if (Plugin.Instance.Config.RespawningTeam == "") { return; } string message = Plugin.Instance.Config.RespawningTeam.Replace("%maxRespawn%", ev.MaximumRespawnAmount.ToString()); message = message.Replace("%team%", ev.NextKnownTeam.ToString()); string players = string.Join(", ", ev.Players); message = message.Replace("%players%", players); if (Plugin.Instance.Config.debug_to_console) { Log.Debug(message: "[ " + Plugin.Instance.Config.server_name + "] " + message); } Plugin.sendWebHook(Plugin.Instance.Config.server_url, message, Plugin.Instance.Config.server_name); }
public static void PreventRespawnEvent(RespawningTeamEventArgs ev) { ev.NextKnownTeam = SpawnableTeamType.None; }
public void OnRespawning(RespawningTeamEventArgs ev) { // Need this, because ev.Players isn't working for methods List <Player> tempPlayers = new List <Player>(); foreach (Player i in ev.Players) { if (i.IsOverwatchEnabled == false) { tempPlayers.Add(i); } } if (ForcedTeam && HasReference) { ForcedTeam = false; ev.NextKnownTeam = chosenTeam.SpawnTypes.FirstOrDefault(); if (MainPlugin.assemblyUIU) { if (Methods.IsUIU()) { Methods.SpawneableUIUToFalse(); } } if (MainPlugin.assemblySerpentHands) { if (Methods.IsSerpentHand()) { Methods.SpawneableSerpentToFalse(); } } } if (MainPlugin.assemblyUIU == true) { if (Methods.IsUIU()) { MainPlugin.Singleton.TmMethods.RemoveTeamReference(); coroutineHandle.Add(Timing.CallDelayed(0.2f, () => { TeamConvert.SetPlayerTeamName(tempPlayers, "uiu"); })); return; } } if (MainPlugin.assemblySerpentHands == true) { if (Methods.IsSerpentHand()) { MainPlugin.Singleton.TmMethods.RemoveTeamReference(); coroutineHandle.Add(Timing.CallDelayed(0.2f, () => { TeamConvert.SetPlayerTeamName(tempPlayers, "serpentshand"); })); return; } } if (!HasReference) { MainPlugin.Singleton.TmMethods.RefNextTeamSpawn(ev.NextKnownTeam); Log.Debug("Possible admin spawn due to No Team Reference yet", this.plugin.Config.Debug); } spawnableTeamType = ev.NextKnownTeam; if (ev.NextKnownTeam == Respawning.SpawnableTeamType.NineTailedFox) { respawns++; } if (chosenTeam != null) { Log.Debug("Spawned " + chosenTeam.Name, this.plugin.Config.Debug); coroutineHandle.Add(Timing.CallDelayed(0.2f, () => MainPlugin.Singleton.TmMethods.ChangePlysToTeam(tempPlayers, chosenTeam))); if (random.Next(0, 100) <= chosenTeam.CassieMessageChaosAnnounceChance && ev.NextKnownTeam == Respawning.SpawnableTeamType.ChaosInsurgency) { Cassie.DelayedGlitchyMessage(chosenTeam.CassieMessageChaosMessage, 0, 0.25f, 0.25f); } } MainPlugin.Singleton.TmMethods.RemoveTeamReference(); }
private static bool Prefix(RespawnManager __instance) { try { if (!RespawnWaveGenerator.SpawnableTeams.TryGetValue(__instance.NextKnownTeam, out SpawnableTeam spawnableTeam) || __instance.NextKnownTeam == SpawnableTeamType.None) { ServerConsole.AddLog("Fatal error. Team '" + __instance.NextKnownTeam + "' is undefined.", ConsoleColor.Red); } else { List <API.Features.Player> list = ListPool <API.Features.Player> .Shared.Rent(API.Features.Player.List.Where(player => player.IsDead && !player.IsOverwatchEnabled)); if (__instance._prioritySpawn) { var tempList = ListPool <API.Features.Player> .Shared.Rent(); tempList.AddRange(list.OrderBy(item => item.ReferenceHub.characterClassManager.DeathTime)); ListPool <API.Features.Player> .Shared.Return(list); list = tempList; } else { list.ShuffleList(); } // Code that should be here is in RespawningTeamEventArgs::ReissueNextKnownTeam var ev = new RespawningTeamEventArgs(list, __instance.NextKnownTeam); Handlers.Server.OnRespawningTeam(ev); if (ev.IsAllowed && ev.SpawnableTeam != null) { while (list.Count > ev.MaximumRespawnAmount) { list.RemoveAt(list.Count - 1); } list.ShuffleList(); List <ReferenceHub> referenceHubList = ListPool <ReferenceHub> .Shared.Rent(); foreach (API.Features.Player me in list) { try { RoleType classid = ev.SpawnableTeam.Value.ClassQueue[Mathf.Min(referenceHubList.Count, spawnableTeam.ClassQueue.Length - 1)]; me.ReferenceHub.characterClassManager.SetPlayersClass(classid, me.ReferenceHub.gameObject); referenceHubList.Add(me.ReferenceHub); ServerLogs.AddLog(ServerLogs.Modules.ClassChange, "Player " + me.ReferenceHub.LoggedNameFromRefHub() + " respawned as " + classid + ".", ServerLogs.ServerLogType.GameEvent); } catch (Exception ex) { if (me != null) { ServerLogs.AddLog(ServerLogs.Modules.ClassChange, "Player " + me.ReferenceHub.LoggedNameFromRefHub() + " couldn't be spawned. Err msg: " + ex.Message, ServerLogs.ServerLogType.GameEvent); } else { ServerLogs.AddLog(ServerLogs.Modules.ClassChange, "Couldn't spawn a player - target's ReferenceHub is null.", ServerLogs.ServerLogType.GameEvent); } } } if (referenceHubList.Count > 0) { ServerLogs.AddLog(ServerLogs.Modules.ClassChange, $"RespawnManager has successfully spawned {referenceHubList.Count} players as {__instance.NextKnownTeam}!", ServerLogs.ServerLogType.GameEvent); RespawnTickets.Singleton.GrantTickets(__instance.NextKnownTeam, -referenceHubList.Count * spawnableTeam.TicketRespawnCost); if (UnitNamingRules.TryGetNamingRule(__instance.NextKnownTeam, out UnitNamingRule rule)) { rule.GenerateNew(__instance.NextKnownTeam, out string regular); foreach (ReferenceHub referenceHub in referenceHubList) { referenceHub.characterClassManager.NetworkCurSpawnableTeamType = (byte)__instance.NextKnownTeam; referenceHub.characterClassManager.NetworkCurUnitName = regular; } rule.PlayEntranceAnnouncement(regular); } RespawnEffectsController.ExecuteAllEffects(RespawnEffectsController.EffectType.UponRespawn, __instance.NextKnownTeam); } ListPool <ReferenceHub> .Shared.Return(referenceHubList); } ListPool <API.Features.Player> .Shared.Return(list); __instance.NextKnownTeam = SpawnableTeamType.None; } return(false); } catch (Exception e) { Exiled.API.Features.Log.Error($"Exiled.Events.Patches.Events.Server.RespawningTeam: {e}\n{e.StackTrace}"); return(true); } }
private static void Server_RespawningTeam(RespawningTeamEventArgs ev) => ev.Players.Clear();
/// <summary> /// Called before respawning a wave of Chaso Insurgency or NTF. /// </summary> /// <param name="ev">The <see cref="RespawningTeamEventArgs"/> instance.</param> public static void OnRespawningTeam(RespawningTeamEventArgs ev) => RespawningTeam.InvokeSafely(ev);
internal void OnRespawningTeam(RespawningTeamEventArgs ev) { Plugin.Log.Debug($"Ghost spectators added to respawn list."); //ev.ToRespawn.AddRange(Plugin.GhostList); }
public void OnRespawningTeam(RespawningTeamEventArgs ev) { ev.Players.Remove(_ply); }
public void OnRespawningTeam(RespawningTeamEventArgs ev) { Timing.CallDelayed(3f, () => // Clear them after the wave spawns instead. { Tracking.NextSpawnWave.Clear(); Tracking.NextSpawnWaveGetsRole.Clear(); Tracking.SpawnWaveSpawns.Clear(); }); bool ntfSpawning = ev.NextKnownTeam == Respawning.SpawnableTeamType.NineTailedFox; if (!Subclass.Instance.Config.AdditiveChance) { List <RoleType> hasRole = new List <RoleType>(); foreach (SubClass subClass in Subclass.Instance.Classes.Values.Where(e => e.BoolOptions["Enabled"] && (!e.IntOptions.ContainsKey("MaxSpawnPerRound") || Tracking.ClassesSpawned(e) < e.IntOptions["MaxSpawnPerRound"]) && (ntfSpawning ? (e.AffectsRoles.Contains(RoleType.NtfCadet) || e.AffectsRoles.Contains(RoleType.NtfCommander) || e.AffectsRoles.Contains(RoleType.NtfLieutenant)) : e.AffectsRoles.Contains(RoleType.ChaosInsurgency)) && ((e.BoolOptions.ContainsKey("OnlyAffectsSpawnWave") && e.BoolOptions["OnlyAffectsSpawnWave"]) || (e.BoolOptions.ContainsKey("AffectsSpawnWave") && e.BoolOptions["AffectsSpawnWave"])))) { if ((ntfSpawning ? (subClass.AffectsRoles.Contains(RoleType.NtfCadet) || subClass.AffectsRoles.Contains(RoleType.NtfCommander) || subClass.AffectsRoles.Contains(RoleType.NtfLieutenant)) : subClass.AffectsRoles.Contains(RoleType.ChaosInsurgency)) && (rnd.NextDouble() * 100) < subClass.FloatOptions["ChanceToGet"]) { if (ntfSpawning) { if (!hasRole.Contains(RoleType.NtfCadet) && subClass.AffectsRoles.Contains(RoleType.NtfCadet)) { Tracking.NextSpawnWaveGetsRole.Add(RoleType.NtfCadet, subClass); hasRole.Add(RoleType.NtfCadet); } if (!hasRole.Contains(RoleType.NtfLieutenant) && subClass.AffectsRoles.Contains(RoleType.NtfLieutenant)) { Tracking.NextSpawnWaveGetsRole.Add(RoleType.NtfLieutenant, subClass); hasRole.Add(RoleType.NtfLieutenant); } if (!hasRole.Contains(RoleType.NtfCommander) && subClass.AffectsRoles.Contains(RoleType.NtfCommander)) { Tracking.NextSpawnWaveGetsRole.Add(RoleType.NtfCommander, subClass); hasRole.Add(RoleType.NtfCommander); } if (hasRole.Count == 3) { break; } } else { if (subClass.AffectsRoles.Contains(RoleType.ChaosInsurgency)) { Tracking.NextSpawnWaveGetsRole.Add(RoleType.ChaosInsurgency, subClass); break; } } } } } else { double num = (rnd.NextDouble() * 100); if (!ntfSpawning && !Subclass.Instance.ClassesAdditive.ContainsKey(RoleType.ChaosInsurgency)) { return; } else if (ntfSpawning && !Subclass.Instance.ClassesAdditive.ContainsKey(RoleType.NtfCadet) && !Subclass.Instance.ClassesAdditive.ContainsKey(RoleType.NtfCommander) && !Subclass.Instance.ClassesAdditive.ContainsKey(RoleType.NtfLieutenant)) { return; } if (!ntfSpawning) { foreach (var possibity in Subclass.Instance.ClassesAdditive[RoleType.ChaosInsurgency].Where(e => e.Key.BoolOptions["Enabled"] && (!e.Key.IntOptions.ContainsKey("MaxSpawnPerRound") || Tracking.ClassesSpawned(e.Key) < e.Key.IntOptions["MaxSpawnPerRound"]) && ((e.Key.BoolOptions.ContainsKey("OnlyAffectsSpawnWave") && e.Key.BoolOptions["OnlyAffectsSpawnWave"]) || (e.Key.BoolOptions.ContainsKey("AffectsSpawnWave") && e.Key.BoolOptions["AffectsSpawnWave"])))) { Log.Debug($"Evaluating possible subclass {possibity.Key.Name} for next spawn wave", Subclass.Instance.Config.Debug); if (num < possibity.Value) { Tracking.NextSpawnWaveGetsRole.Add(RoleType.ChaosInsurgency, possibity.Key); break; } else { Log.Debug($"Next spawn wave did not get subclass {possibity.Key.Name}", Subclass.Instance.Config.Debug); } } } else { RoleType[] roles = { RoleType.NtfCommander, RoleType.NtfLieutenant, RoleType.NtfCadet }; foreach (RoleType role in roles) { foreach (var possibity in Subclass.Instance.ClassesAdditive[role].Where(e => e.Key.BoolOptions["Enabled"] && (!e.Key.IntOptions.ContainsKey("MaxSpawnPerRound") || Tracking.ClassesSpawned(e.Key) < e.Key.IntOptions["MaxSpawnPerRound"]) && ((e.Key.BoolOptions.ContainsKey("OnlyAffectsSpawnWave") && e.Key.BoolOptions["OnlyAffectsSpawnWave"]) || (e.Key.BoolOptions.ContainsKey("AffectsSpawnWave") && e.Key.BoolOptions["AffectsSpawnWave"])))) { Log.Debug($"Evaluating possible subclass {possibity.Key.Name} for next spawn wave", Subclass.Instance.Config.Debug); if (num < possibity.Value) { Tracking.NextSpawnWaveGetsRole.Add(role, possibity.Key); break; } else { Log.Debug($"Next spawn wave did not get subclass {possibity.Key.Name}", Subclass.Instance.Config.Debug); } } } } } Tracking.NextSpawnWave = ev.Players; }
private static bool Prefix(RespawnManager __instance) { SpawnableTeam spawnableTeam; if (!RespawnWaveGenerator.SpawnableTeams.TryGetValue(__instance.NextKnownTeam, out spawnableTeam) || __instance.NextKnownTeam == SpawnableTeamType.None) { ServerConsole.AddLog("Fatal error. Team '" + __instance.NextKnownTeam + "' is undefined.", ConsoleColor.Red); } else { List <API.Features.Player> list = API.Features.Player.List.Where(p => p.IsDead && !p.IsOverwatchEnabled).ToList(); if (__instance._prioritySpawn) { list = list.OrderBy(item => item.ReferenceHub.characterClassManager.DeathTime).ToList(); } else { list.ShuffleList(); } RespawnTickets singleton = RespawnTickets.Singleton; int a = singleton.GetAvailableTickets(__instance.NextKnownTeam); if (a == 0) { a = singleton.DefaultTeamAmount; RespawnTickets.Singleton.GrantTickets(singleton.DefaultTeam, singleton.DefaultTeamAmount, true); } int num = Mathf.Min(a, spawnableTeam.MaxWaveSize); List <ReferenceHub> referenceHubList = ListPool <ReferenceHub> .Rent(); var ev = new RespawningTeamEventArgs(list, num, __instance.NextKnownTeam); Handlers.Server.OnRespawningTeam(ev); while (list.Count > num) { list.RemoveAt(list.Count - 1); } list.ShuffleList(); foreach (API.Features.Player me in list) { try { RoleType classid = spawnableTeam.ClassQueue[Mathf.Min(referenceHubList.Count, spawnableTeam.ClassQueue.Length - 1)]; me.ReferenceHub.characterClassManager.SetPlayersClass(classid, me.ReferenceHub.gameObject); referenceHubList.Add(me.ReferenceHub); ServerLogs.AddLog(ServerLogs.Modules.ClassChange, "Player " + me.ReferenceHub.LoggedNameFromRefHub() + " respawned as " + classid + ".", ServerLogs.ServerLogType.GameEvent); } catch (Exception ex) { if (me != null) { ServerLogs.AddLog(ServerLogs.Modules.ClassChange, "Player " + me.ReferenceHub.LoggedNameFromRefHub() + " couldn't be spawned. Err msg: " + ex.Message, ServerLogs.ServerLogType.GameEvent); } else { ServerLogs.AddLog(ServerLogs.Modules.ClassChange, "Couldn't spawn a player - target's ReferenceHub is null.", ServerLogs.ServerLogType.GameEvent); } } } if (referenceHubList.Count > 0) { ServerLogs.AddLog(ServerLogs.Modules.ClassChange, $"RespawnManager has successfully spawned {referenceHubList.Count} players as {__instance.NextKnownTeam}!", ServerLogs.ServerLogType.GameEvent); RespawnTickets.Singleton.GrantTickets(__instance.NextKnownTeam, -referenceHubList.Count * spawnableTeam.TicketRespawnCost); UnitNamingRule rule; if (UnitNamingRules.TryGetNamingRule(__instance.NextKnownTeam, out rule)) { string regular; rule.GenerateNew(__instance.NextKnownTeam, out regular); foreach (ReferenceHub referenceHub in referenceHubList) { referenceHub.characterClassManager.NetworkCurSpawnableTeamType = (byte)__instance.NextKnownTeam; referenceHub.characterClassManager.NetworkCurUnitName = regular; } rule.PlayEntranceAnnouncement(regular); } RespawnEffectsController.ExecuteAllEffects(RespawnEffectsController.EffectType.UponRespawn, __instance.NextKnownTeam); } __instance.NextKnownTeam = SpawnableTeamType.None; } return(false); }