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);
}
