public void Update(AccurateDelta delta)
{
Parallel.ForEach(_rooms.Values, (room) =>
{
try
{
if (room == null)
{
return;
}
if (room.Id == 0 || !room.Players.Any())
{
Remove(room);
return;
}
room?.Update(delta);
}
catch (Exception ex)
{
Logger.Error(ex.ToString());
}
});
}
public override void Update(AccurateDelta delta)
{
base.Update(delta);
try
{
var teamMgr = Room.TeamManager;
if (Room.GameState == GameState.Playing &&
!StateMachine.IsInState(GameRuleState.EnteringResult) &&
!StateMachine.IsInState(GameRuleState.Result) &&
RoundTime >= TimeSpan.FromSeconds(5))
{
// Did we reach round limit?
var roundTimeLimit = TimeSpan.FromMilliseconds(Room.Options.TimeLimit.TotalMilliseconds);
if (RoundTime >= roundTimeLimit)
{
StateMachine.Fire(GameRuleStateTrigger.StartResult);
}
}
}
catch (Exception e)
{
Room.Logger.Error(e.ToString());
}
}
public override void Update(AccurateDelta delta)
{
base.Update(delta);
var teamMgr = Room.TeamManager;
try
{
if (Room.GameState == GameState.Playing &&
!StateMachine.IsInState(GameRuleState.EnteringResult) &&
!StateMachine.IsInState(GameRuleState.Result) &&
RoundTime >= TimeSpan.FromSeconds(5))
{
var min = teamMgr.Values.Min(team =>
team.Keys.Count(plr => plr.RoomInfo.HasLoaded));
if (min == 0 && !Room.Options.IsFriendly)
StateMachine.Fire(GameRuleStateTrigger.StartResult);
if (teamMgr.Values.Any(team => team.Score > Room.Options.ScoreLimit))
StateMachine.Fire(GameRuleStateTrigger.StartResult);
if (CurrentRound - 1 > Room.Options.TimeLimit.Minutes)
StateMachine.Fire(GameRuleStateTrigger.StartResult);
if (CurrentRound > 0)
{
if (_waitingNextRound)
{
_nextRoundTime += delta.delta;
if (_nextRoundTime >= SCaptainNextroundTime)
{
NextRound();
}
}
else
{
foreach (var plr in PlayersCaptain.Where(x => !ValidPlayer(x.Key)))
{
PlayersCaptain.TryRemove(plr.Key, out _);
}
if ((!AlphaCaptains.Any() || !BetaCaptains.Any()) /* &&
Room.TeamManager.PlayersPlaying.Count() > 1 && !Room.Options.IsFriendly*/)
SubRoundEnd();
_subRoundTime += delta.delta;
if (_subRoundTime >= SCaptainRoundTime)
SubRoundEnd();
}
}
}
}
catch (Exception e)
{
Room.Logger.Error(e.ToString());
}
}
public override void Update(AccurateDelta delta)
{
base.Update(delta);
try
{
var teamMgr = Room.TeamManager;
if (Room.GameState == GameState.Playing &&
!StateMachine.IsInState(GameRuleState.EnteringResult) &&
!StateMachine.IsInState(GameRuleState.Result) &&
RoundTime >= TimeSpan.FromSeconds(5))
{
// Still have enough players?
var min = teamMgr.Values.Min(team =>
team.Keys.Count(plr =>
plr.RoomInfo.State != PlayerState.Lobby &&
plr.RoomInfo.State != PlayerState.Spectating));
if (min == 0 && !Room.Options.IsFriendly)
{
StateMachine.Fire(GameRuleStateTrigger.StartResult);
}
var isFirstHalf = StateMachine.IsInState(GameRuleState.FirstHalf);
var isSecondHalf = StateMachine.IsInState(GameRuleState.SecondHalf);
if (isFirstHalf || isSecondHalf)
{
var scoreLimit = isFirstHalf ? Room.Options.ScoreLimit / 2 : Room.Options.ScoreLimit;
var trigger = isFirstHalf
? GameRuleStateTrigger.StartHalfTime
: GameRuleStateTrigger.StartResult;
// Did we reach ScoreLimit?
if (teamMgr.Values.Any(team => team.Score >= scoreLimit) &&
StateMachine.CanFire(trigger))
{
StateMachine.Fire(trigger);
}
// Did we reach round limit?
var roundTimeLimit = TimeSpan.FromMilliseconds(Room.Options.TimeLimit.TotalMilliseconds / 2);
if (RoundTime >= roundTimeLimit &&
StateMachine.CanFire(trigger))
{
StateMachine.Fire(trigger);
}
}
}
}
catch (Exception e)
{
Room.Logger.Error(e.ToString());
}
}
public override void Update(AccurateDelta delta)
{
base.Update(delta);
try
{
var teamMgr = Room.TeamManager;
if (Room.GameState == GameState.Playing &&
!StateMachine.IsInState(GameRuleState.EnteringResult) &&
!StateMachine.IsInState(GameRuleState.Result) &&
RoundTime >= TimeSpan.FromSeconds(5))
{
// Still have enough players?
if (teamMgr.PlayersPlaying.Count() < PlayersNeededToStart)
{
StateMachine.Fire(GameRuleStateTrigger.StartResult);
}
// Did we reach ScoreLimit?
if (teamMgr.PlayersPlaying.Any(plr => plr.RoomInfo.Stats.TotalScore >= Room.Options.ScoreLimit))
{
StateMachine.Fire(GameRuleStateTrigger.StartResult);
}
// Did we reach round limit?
var roundTimeLimit = TimeSpan.FromMilliseconds(Room.Options.TimeLimit.TotalMilliseconds);
if (RoundTime >= roundTimeLimit)
{
StateMachine.Fire(GameRuleStateTrigger.StartResult);
}
}
}
catch (Exception e)
{
Room.Logger.Error(e.ToString());
}
}
public virtual void Update(AccurateDelta delta)
{
RoundTime += delta.delta;
Room.RoundTime = RoundTime;
#region PrepareGame
if (StateMachine.IsInState(GameRuleState.Preparing))
{
switch (PrepareState)
{
case GameStartState.Loading:
if (Room.RoundTime > GameLoadMaxTime)
{
foreach (var player in Room.Players.Values.Where(x =>
(x.RoomInfo.IsReady || Room.Master == x) && !x.RoomInfo.HasLoaded))
{
player.RoomInfo.IsReady = false;
player.Room?.Leave(player);
}
}
if (Room.Players.Values.Count(x => x.RoomInfo.HasLoaded) >=
Room.Players.Values.Count(x => x.RoomInfo.IsReady || Room.Master == x) ||
Room.RoundTime > GameLoadMaxTime)
{
GameStartTime = Room.RoundTime;
if (GameRule == GameRule.Chaser ||
GameRule == GameRule.Practice ||
GameRule == GameRule.CombatTrainingDM ||
GameRule == GameRule.CombatTrainingTD)
{
PrepareState = GameStartState.ReadyToStart;
}
else
{
PrepareState = GameStartState.Countdown;
foreach (var member in Room.Players.Values)
{
if (member.RoomInfo.HasLoaded)
{
member.Session.SendAsync(
new RoomGamePlayCountDownAckMessage(
(int)GameStartWaitTime.TotalMilliseconds));
member.Session.SendAsync(new GameRefreshGameRuleInfoAckMessage(Room.GameState,
GameTimeState.StartGameCounter,
Room.Options.TimeLimit.TotalMilliseconds));
}
}
}
}
break;
case GameStartState.Countdown:
if ((Room.RoundTime - GameStartTime).TotalMilliseconds >
GameStartWaitTime.TotalMilliseconds + 500)
{
PrepareState = GameStartState.ReadyToStart;
}
break;
case GameStartState.ReadyToStart:
if (StateMachine.CanFire(GameRuleStateTrigger.StartGame))
{
Room.IsPreparing = false;
RoundTime = TimeSpan.Zero;
PrepareState = GameStartState.Playing;
StateMachine.Fire(GameRuleStateTrigger.StartGame);
}
break;
}
}
#endregion
#region Playing
if (StateMachine.IsInState(GameRuleState.Playing))
{
foreach (var plr in Room.TeamManager.PlayersPlaying)
{
plr.RoomInfo.PlayTime += delta.delta;
plr.RoomInfo.CharacterPlayTime[plr.CharacterManager.CurrentSlot] += delta.delta;
}
}
#endregion
#region HalfTime
if (StateMachine.IsInState(GameRuleState.EnteringHalfTime))
{
if (RoundTime >= PreHalfTimeWaitTime)
{
if (StateMachine.CanFire(GameRuleStateTrigger.StartHalfTime))
{
RoundTime = TimeSpan.Zero;
StateMachine.Fire(GameRuleStateTrigger.StartHalfTime);
}
}
else
{
foreach (var plr in Room.TeamManager.PlayersPlaying)
{
var message = ((int)(PreHalfTimeWaitTime - RoundTime).TotalSeconds + 1).ToString();
plr.Session.SendAsync(new GameEventMessageAckMessage(GameEventMessage.HalfTimeIn, 2, 0, 0,
message));
}
}
}
if (StateMachine.IsInState(GameRuleState.HalfTime) &&
RoundTime >= HalfTimeWaitTime)
{
StateMachine.Fire(GameRuleStateTrigger.StartSecondHalf);
}
#endregion
#region Result
if (StateMachine.IsInState(GameRuleState.EnteringResult))
{
if (RoundTime >= PreResultWaitTime)
{
RoundTime = TimeSpan.Zero;
StateMachine.Fire(GameRuleStateTrigger.StartResult);
}
else
{
foreach (var plr in Room.TeamManager.PlayersPlaying)
{
var message = (int)(PreResultWaitTime - RoundTime).TotalSeconds + 1 + " second(s)";
plr.Session?.SendAsync(new GameEventMessageAckMessage(GameEventMessage.ResultIn, 3, 0, 0,
message));
}
}
}
if (StateMachine.IsInState(GameRuleState.Result) &&
RoundTime >= ResultWaitTime)
{
if (StateMachine.CanFire(GameRuleStateTrigger.EndGame))
{
RoundTime = TimeSpan.Zero;
StateMachine.Fire(GameRuleStateTrigger.EndGame);
}
}
#endregion
#region CoinBuff
if (this.StateMachine.IsInState(GameRuleState.Playing))
{
foreach (var plr in this.Room.TeamManager.PlayersPlaying)
{
plr.PlayerCoinBuff.Update(1);
}
}
#endregion
}
public override void Update(AccurateDelta delta)
{
base.Update(delta);
try
{
var teamMgr = Room.TeamManager;
if (Room.GameState == GameState.Playing &&
!StateMachine.IsInState(GameRuleState.EnteringResult) &&
!StateMachine.IsInState(GameRuleState.Result) &&
RoundTime >= TimeSpan.FromSeconds(5))
{
if (teamMgr.PlayersPlaying.Count() < PlayersNeededToStart && !Room.Options.IsFriendly)
{
StateMachine.Fire(GameRuleStateTrigger.StartResult);
}
if (RoundTime >= Room.Options.TimeLimit)
{
StateMachine.Fire(GameRuleStateTrigger.StartResult);
}
if (_waitingNextChaser)
{
_nextChaserTimer += delta.delta;
if (_nextChaserTimer >= SNextChaserWaitTime)
{
NextChaser();
}
}
else
{
_chaserTimer += delta.delta;
if (_chaserTimer >= _chaserRoundTime)
{
var diff = Room.Options.TimeLimit - RoundTime;
if (diff >= _chaserRoundTime + SNextChaserWaitTime)
{
ChaserLose();
}
}
else
{
if (!ValidPlayer(Chaser))
{
ChaserLose();
}
}
if (!ValidPlayer(ChaserTarget) || Chaser == ChaserTarget)
{
NextTarget();
}
if (_chaserTimer > s_spanTime && !ArePlayersAlive() &&
Room.TeamManager.PlayersPlaying.Count() > 1 && !Room.Options.IsFriendly)
{
ChaserWin();
}
}
}
}
catch (Exception e)
{
Room.Logger.Error(e.ToString());
}
}
public void Update(AccurateDelta delta)
{
Parallel.ForEach(_channels.Values, (channel) => channel?.Update(delta));
}
public void Update(AccurateDelta delta)
{
if (Disposed)
{
return;
}
try
{
if (!Players.Any())
{
RoomManager.Remove(this);
return;
}
if (!(Master?.IsLoggedIn() ?? true) || Master?.Room != this)
{
ChangeMasterIfNeeded(GetPlayerWithLowestPing(), true);
ChangeHostIfNeeded(GetPlayerWithLowestPing(), true);
}
if (!TeamManager.NoSpectatorPlayers.Any() && TeamManager.Players.Any())
{
foreach (var spectator in TeamManager.Spectators)
{
TeamManager.ChangeMode(spectator, PlayerGameMode.Normal);
}
}
if (IsChangingRules)
{
_changingRulesTimer += delta.delta;
if (_changingRulesTimer >= _changingRulesTime && !IsChangingRulesCooldown)
{
RoomManager.Channel.BroadcastCencored(new RoomChangeRoomInfoAck2Message(GetRoomInfo()));
Broadcast(new RoomChangeRuleAckMessage(Options.Map <RoomCreationOptions, ChangeRuleDto2>()));
Broadcast(new GameChangeStateAckMessage(GameState));
IsChangingRulesCooldown = true;
}
foreach (var player in _players.Values)
{
player.RoomInfo.LastMapID = (byte)Options.MapId;
}
if (_changingRulesTimer >= _changingRulesTime.Add(TimeSpan.FromSeconds(3)))
{
IsChangingRules = false;
IsChangingRulesCooldown = false;
}
}
else
{
foreach (var player in Players.Values.Where(x => !TeamManager.Players.Contains(x)))
{
TeamManager.Join(player);
}
}
if (VoteKickMgr.State == VoteKickManager.KickState.Execution)
{
_voteKicktimer += delta.delta;
if (_voteKicktimer < _voteKickTime)
{
VoteKickMgr.Update();
}
else
{
_voteKicktimer = TimeSpan.Zero;
VoteKickMgr.Evaluate();
}
}
}
catch (Exception e)
{
Logger.Error(e.ToString());
}
GameRuleManager?.Update(delta);
}
public void Update(AccurateDelta delta)
{
RoomManager?.Update(delta);
}
