public async void OnRoundEnded(RoundEndedEventArgs ev)
{
if (Instance.Config.EventsToLog.RoundEnded)
{
await Network.SendAsync(new RemoteCommand("log", "gameEvents", string.Format(Language.RoundEnded, ev.LeadingTeam, Player.Dictionary.Count, Instance.Slots))).ConfigureAwait(false);
}
}
internal void OnRoundEnded(RoundEndedEventArgs ev)
{
if (!plugin.Config.Stats.Any(kvp => kvp.Value == true))
{
return;
}
if (plugin.Config.CycleStats)
{
CycleStats();
}
else
{
StringBuilder builder = new StringBuilder();
foreach (KeyValuePair <string, bool> stat in plugin.Config.Stats.Where(kvp => kvp.Value == true))
{
builder.AppendLine(GetString(stat.Key));
}
ushort displayTime = (ushort)Mathf.Clamp(ConfigFile.ServerConfig.GetInt("auto_round_restart_time", 10), 5, 1000);
Map.ClearBroadcasts();
Map.Broadcast(new Exiled.API.Features.Broadcast(builder.ToString(), displayTime));
}
}
private void _onRoundEnded(object sender, RoundEndedEventArgs e)
{
foreach (IFighter fighter in Fighters)
{
fighter.OnRoundEnded(new RoundEndedEventArgs(this, fighter));
}
}
public void OnRoundEnded(RoundEndedEventArgs ev)
{
foreach (CoroutineHandle coroutine in Coroutine)
{
Timing.KillCoroutines(coroutine);
}
}
private static void Parser_RoundEnd(object sender, RoundEndedEventArgs e)
{
if (_matchStarted)
{
_roundEndedCount = 1;
}
}
/// <summary>
/// Gets called when the server sent the RoundEnded event and the local player is ready for the next round
/// </summary>
/// <param name="args">The <see cref="RoundEndedEventArgs"/> instance containing the event data.</param>
public void OnRoundEnded(RoundEndedEventArgs args)
{
GameManager.Current.CurrentGame.CurrentPlayer.Score = args.Score;
GameManager.Current.CurrentGame.CurrentPlayer.CurrentPlayerState = Player.PlayerState.OpponentsTurn;
this.bounceCount++;
if (!args.GameEnded)
{
if (this.bounceCount % 2 == 0 && this.bounceCount > 1)
{
GameManager.Current.CurrentGame.CurrentRound = (this.bounceCount / 2) + 1;
}
var game = GameManager.Current.CurrentGame;
GameManager.Current.CurrentGame.CurrentPlayer = game.CurrentPlayer == game.LocalPlayer
? game.Opponent
: game.LocalPlayer;
}
this.RoundEnded(this, args);
// Reset the data for the current round
this.currentRoundEnded = false;
this.currentRoundEndedEventRecieved = false;
this.currentRoundEndedArguments = null;
}
private void Parser_RoundEnd(object sender, RoundEndedEventArgs e)
{
if (matchStarted)
{
roundEndedCount = 1;
}
}
protected void HandleRoundEnd(object sender, RoundEndedEventArgs e)
{
if (!isMatchStarted || isFreezetime)
{
return;
}
isFreezetime = true;
txtResult.AppendText("Round " + currentRoundNumber.ToString() + ": " + parser.IngameTick + "; ");
if (showDetailInfo)
{
txtResult.AppendText(Environment.NewLine);
foreach (Player player in parser.PlayingParticipants)
{
txtResult.AppendText("Player equipments at the round end; " + parser.CurrentTick + "; " + parser.CurrentTime + "; " + currentRoundNumber.ToString() + "; " + parser.Map);
txtResult.AppendText("; " + player.SteamID + "; " + player.Name);
foreach (Equipment weapon in player.Weapons)
{
txtResult.AppendText("; " + weapon.Weapon.ToString() + ",");
}
txtResult.AppendText(Environment.NewLine);
}
}
currentRoundNumber += 1;
}
public void OnRoundEnded(RoundEndedEventArgs ev)
{
// I may just consider using reflection and just loop over all members and clear them if I can.
TrackingAndMethods.KillAllCoroutines();
TrackingAndMethods.Coroutines.Clear();
TrackingAndMethods.PlayersWithSubclasses.Clear();
TrackingAndMethods.Cooldowns.Clear();
TrackingAndMethods.FriendlyFired.Clear();
TrackingAndMethods.PlayersThatBypassedTeslaGates.Clear();
TrackingAndMethods.PreviousRoles.Clear();
TrackingAndMethods.PlayersWithZombies.Clear();
TrackingAndMethods.PlayersThatHadZombies.Clear();
TrackingAndMethods.QueuedCassieMessages.Clear();
TrackingAndMethods.NextSpawnWave.Clear();
TrackingAndMethods.NextSpawnWaveGetsRole.Clear();
TrackingAndMethods.PlayersThatJustGotAClass.Clear();
TrackingAndMethods.SubClassesSpawned.Clear();
TrackingAndMethods.PreviousSubclasses.Clear();
TrackingAndMethods.PreviousBadges.Clear();
TrackingAndMethods.RagdollRoles.Clear();
TrackingAndMethods.AbilityUses.Clear();
TrackingAndMethods.PlayersInvisibleByCommand.Clear();
TrackingAndMethods.PlayersVenting.Clear();
TrackingAndMethods.NumSpawnWaves.Clear();
TrackingAndMethods.SpawnWaveSpawns.Clear();
TrackingAndMethods.ClassesGiven.Clear();
TrackingAndMethods.DontGiveClasses.Clear();
TrackingAndMethods.PlayersBloodLusting.Clear();
TrackingAndMethods.Zombie106Kills.Clear();
API.EnableAllClasses();
}
public void RoundEnd(RoundEndedEventArgs ev)
{
tranquilized.Clear();
armored.Clear();
scpShots.Clear();
testFix = true;
}
public void OnRoundEnd(RoundEndedEventArgs ev)
{
Timing.KillCoroutines(EscapeCoro);
foreach (Player p in Player.List)
{
p.RemoveExtraClass();
}
}
public void OnRoundEnd(RoundEndedEventArgs ev)
{
tcp.SendData(new Generic
{
eventName = "RoundEnd",
param = ((int)(Round.ElapsedTime.TotalSeconds / 60)).ToString()
});
}
private void TimerRoundEnded(object sender, RoundEndedEventArgs e)
{
if (File.Exists(RestEndSound))
{
var soundPlayer = new SoundPlayer(RestEndSound);
soundPlayer.Play();
}
}
public void OnRoundEnd(RoundEndedEventArgs ev)
{
foreach (CoroutineHandle handle in Commands.PunchCommand.Cooldowned.Values)
{
Timing.KillCoroutines(handle);
}
Commands.PunchCommand.Cooldowned.Clear();
}
internal void OnRoundEnded(RoundEndedEventArgs _)
{
foreach (Features.Player player in Exiled.API.Features.Player.List)
{
pluginInstance.Functions.SaveData(player);
}
TemporarilyDisabledWarns = true;
}
public void OnRoundEnd(RoundEndedEventArgs ev)
{
foreach (Npc npc in Npc.List)
{
npc.Kill(false);
}
RoundSummaryFix.__npc_endRequested = false;
NavigationNode.Clear();
}
protected virtual void eventsManager_RoundEnd(object sender, RoundEndedEventArgs e)
{
if (game.IsStarted)
{
game.Rounds.Last().Winner = game.GetTeam(e.Team.Id);
game.Rounds.Last().Reason = e.Reason;
//game.Rounds.Last().Duration = e.
}
}
public async void OnRoundEnded(RoundEndedEventArgs ev)
{
var playerCount = Exiled.API.Features.Player.List.Count();
var playerText = playerCount > 1 ? "players" : "player";
await _plugin.PublicWebhookExecutor.ExecuteWebhook(
$"Round ended with {playerCount} {playerText}, restarting in {ev.TimeToRestart} seconds",
"SCP-Bot",
false);
}
public void OnRoundEnded(RoundEndedEventArgs ev)
{
AnnouncementSettings settings = SimpleCassie.Instance.Config.RoundEnd;
Log.Info(
$"RoundStart: {settings.Enabled}, roundStartMsg: {settings.Message}, roundStartDelay: {settings.Delay}, roundStartNoise: {settings.MakeNoise}");
Timing.RunCoroutine(Extensions.CassieMessage(settings.Message, false, settings.MakeNoise,
settings.Delay));
}
public void OnRoundEnded(RoundEndedEventArgs ev)
{
foreach (CoroutineHandle coroutine in RunningCoroutines)
{
Timing.KillCoroutines(coroutine);
}
RunningCoroutines.Clear();
}
internal void OnRoundEnd(RoundEndedEventArgs ev)
{
scpKills.OrderByDescending(key => key.Value);
humanKills.OrderByDescending(key => key.Value);
KeyValuePair <Player, int> scpTop = scpKills.FirstOrDefault();
KeyValuePair <Player, KillData> humanTop = humanKills.FirstOrDefault();
Map.Broadcast(15,
$"{(scpTop.Equals(defaultScp) ? "<i>SCPs failed to obtain a kill.</i>" : $"<b><color=#FF0000>{scpTop.Key.Nickname}</color></b> <i>killed the most humans with</i> <b>{scpTop.Value} kill{(scpTop.Value > 1 ? "s" : "")}!</b>")}\n" +
public static void OnRoundEnded(RoundEndedEventArgs ev)
{
foreach (var kvp in _escapePosDict)
{
Object.Destroy(kvp.Value);
Log.Debug($"destroyed the '{kvp.Key}'", CustomEscape.Singleton.Config.Debug);
}
_escapePosDict.Clear();
}
private static void Parser_RoundEnd(object sender, RoundEndedEventArgs e)
{
if (!_matchStarted)
{
return;
}
_currentRound.Reason = e.Reason;
_roundEndedCount = 1;
}
public void OnRoundEnd(RoundEndedEventArgs ev)
{
Map.Broadcast(20, $"<size=50><color=blue>라운드</color>가 종료되었습니다.\n다음 라운드 시작까지 : {ev.TimeToRestart}초</size>");
Cassie.Message($"Xmas_JingleBells");
Map.TurnOffAllLights(20.0f, false);
foreach (CoroutineHandle coroutine in plugin.Coroutines)
{
Timing.KillCoroutines(coroutine);
}
}
private void CurrentDemoParser_RoundEnd(object sender, RoundEndedEventArgs e)
{
SteamController.LogToConsole("Round ended. " + e.Winner + " forces won the round. " + e.Reason + ". " + e.Message + ".");
if (e.Winner != Team.Spectate)
{
string teamName = e.Winner == Team.CounterTerrorist ? "Counter-Terrorists" : "Terrorists";
ShowWinText(teamName + "\n" + "Win");
}
}
private void HandleRoundEnd(object sender, RoundEndedEventArgs e)
{
RoundEndEvent newEvent = new RoundEndEvent()
{
Reason = (Models.RoundEndReason)((int)e.Reason),
Message = e.Message,
Winner = (Models.Team)((int)e.Winner),
};
CurrentTick.Events.Add(newEvent);
}
private void TimerRestEnded(object sender, RoundEndedEventArgs e)
{
RestGongTimer.Stop();
if (!SettingsManager.CurrentSettings.NeedToLoopRestSound)
{
_restSoundPlayer.Play();
}
++CurrentRoundIndex;
StartNextRound();
}
/// <summary>
/// Ends the round.
/// </summary>
/// <param name="firstPlayer">if set to <c>true</c> the current player started the game. This is necessary for the server to identify the player.</param>
/// <param name="score">The score.</param>
public void EndRound(bool firstPlayer, int score)
{
GameManager.Current.LogMessage(
string.Format("Finished round with a score of {0}", score),
Tracer.Debug);
GameManager.Current.CurrentGame.CurrentRound++;
GameManager.Current.CurrentGame.CurrentPlayer.Score += score;
var eventArgs = new RoundEndedEventArgs(score, false);
this.RoundEnded(this, eventArgs);
}
private void Server_RoundEnded(RoundEndedEventArgs ev)
{
NPManager.Singleton.PacketProcessor.Send <EventPacket>(
NPManager.Singleton.NetworkListener,
new EventPacket()
{
Type = (byte)EventType.RoundEnded,
Data = new byte[0],
},
DeliveryMethod.ReliableOrdered);
}
protected new void HandleRoundEnd(object sender, RoundEndedEventArgs e)
{
_matchStartedCount = 0;
base.HandleRoundEnd(sender, e);
// On ESEA demos round_announce_last_round_half isn't raised
if (CurrentRound.Number == 15)
{
IsSwapTeamRequired = true;
}
}
