protected virtual void OnMatchStarted()
{
// Initialize the Game itself
game = new Game(pitch, homeTeamData.Team, awayTeamData.Team, matchStanding.TimeElapsed);
// When the match starts
// Start the timer as well
matchTimer.Start();
MatchStarted?.Invoke(this, EventArgs.Empty);
}
public void StartMatch()
{
IsRunning = true;
var player = GetPlayerWhoHasNotPlayed();
MatchStarted?.Invoke(this, EventArgs.Empty);
RoundStarted?.Invoke(this, new RoundStartedEventArgs(CurrentRound));
StartPreparationTimer(player);
}
private void Handle(MatchStarted request)
{
CurrentMatch.Started = true;
CurrentMatch.Team1Score = 0;
CurrentMatch.Team2Score = 0;
Context.Parent.Tell(new MatchChanged()
{
Match = CurrentMatch
});
}
Task IMultiplayerClient.MatchStarted()
{
Scheduler.Add(() =>
{
if (Room == null)
{
return;
}
MatchStarted?.Invoke();
}, false);
return(Task.CompletedTask);
}
protected override void ConsumeMatchStarted(MatchStarted message)
{
var token = this.cancellationTokenSource.Token;
Console.ForegroundColor = this.Team.ConsoleColor;
Console.WriteLine($"{this.Number} - {this.Name} joins the game");
Task.Factory.StartNew(
() => { Play(token); },
token,
TaskCreationOptions.LongRunning,
TaskScheduler.Default
)
.ConfigureAwait(false);
}
Task IMultiplayerClient.MatchStarted()
{
if (Room == null)
{
return(Task.CompletedTask);
}
Schedule(() =>
{
if (Room == null)
{
return;
}
PlayingUsers.AddRange(Room.Users.Where(u => u.State == MultiplayerUserState.Playing).Select(u => u.UserID));
MatchStarted?.Invoke();
});
return(Task.CompletedTask);
}
private void ChangeMatchState(int matchId, StateEnum state)
{
//db
UoW.MatchRepo.UpdateMatchState(matchId, state);
//ui
switch (state)
{
case StateEnum.Confirmed:
break;
case StateEnum.Playing:
MatchStarted?.Invoke(matchId);
break;
case StateEnum.Ended:
MatchEnded?.Invoke(matchId);
break;
default:
break;
}
}
protected virtual void OnMatchStarted()
{
MatchStarted?.Invoke(this, EventArgs.Empty);
}
protected virtual void OnMatchStarted(object source)
{
MatchStarted?.Invoke(source, EventArgs.Empty);
}
public void Handle(MatchStarted domainEvent)
{
IsStarted = true;
HomeTeamPlayers = domainEvent.HomeTeam;
GuestTeamPlayers = domainEvent.GuestTeam;
}
private void HandleCurrentEvents()
{
foreach (BaseEvent baseEvent in currentTick.Events)
{
switch (baseEvent.Type)
{
case EventType.MatchStarted:
MatchStarted?.Invoke(this, baseEvent);
break;
case EventType.RoundAnnounceMatchStarted:
break;
case EventType.RoundStart:
RoundStart?.Invoke(this, (RoundStartEvent)baseEvent);
break;
case EventType.RoundEnd:
RoundEnd?.Invoke(this, (RoundEndEvent)baseEvent);
break;
case EventType.WinPanelMatch:
WinPanelMatch?.Invoke(this, baseEvent);
break;
case EventType.RoundFinal:
break;
case EventType.LastRoundHalf:
break;
case EventType.RoundOfficiallyEnd:
RoundOfficiallyEnd?.Invoke(this, baseEvent);
break;
case EventType.RoundMVP:
RoundMVP?.Invoke(this, (RoundMVPEvent)baseEvent);
break;
case EventType.FreezetimeEnded:
FreezetimeEnded?.Invoke(this, baseEvent);
break;
case EventType.PlayerKilled:
PlayerKilled?.Invoke(this, (PlayerKilledEvent)baseEvent);
break;
case EventType.PlayerTeam:
PlayerTeam?.Invoke(this, (PlayerTeamEvent)baseEvent);
break;
case EventType.WeaponFired:
WeaponFired?.Invoke(this, (WeaponFiredEvent)baseEvent);
break;
case EventType.SmokeNadeStarted:
SmokeNadeStarted?.Invoke(this, (SmokeNadeStartedEvent)baseEvent);
break;
case EventType.SmokeNadeEnded:
SmokeNadeEnded?.Invoke(this, (SmokeNadeEndedEvent)baseEvent);
break;
case EventType.DecoyNadeStarted:
DecoyNadeStarted?.Invoke(this, (DecoyNadeStartedEvent)baseEvent);
break;
case EventType.DecoyNadeEnded:
DecoyNadeEnded?.Invoke(this, (DecoyNadeEndedEvent)baseEvent);
break;
case EventType.FireNadeStarted:
FireNadeStarted?.Invoke(this, (FireNadeStartedEvent)baseEvent);
break;
case EventType.FireNadeWithOwnerStarted:
FireNadeWithOwnerStarted?.Invoke(this, (FireNadeWithOwnerStartedEvent)baseEvent);
break;
case EventType.FireNadeEnded:
FireNadeEnded?.Invoke(this, (FireNadeEndedEvent)baseEvent);
break;
case EventType.FlashNadeExploded:
FlashNadeExploded?.Invoke(this, (FlashNadeExplodedEvent)baseEvent);
break;
case EventType.ExplosiveNadeExploded:
ExplosiveNadeExploded?.Invoke(this, (ExplosiveNadeExplodedEvent)baseEvent);
break;
case EventType.NadeReachedTarget:
NadeReachedTarget?.Invoke(this, (NadeReachedTargetEvent)baseEvent);
break;
case EventType.BombBeginPlant:
BombBeginPlant?.Invoke(this, (BombBeginPlantEvent)baseEvent);
break;
case EventType.BombAbortPlant:
BombAbortPlant?.Invoke(this, (BombAbortPlantEvent)baseEvent);
break;
case EventType.BombPlanted:
BombPlanted?.Invoke(this, (BombPlantedEvent)baseEvent);
break;
case EventType.BombDefused:
BombDefused?.Invoke(this, (BombDefusedEvent)baseEvent);
break;
case EventType.BombExploded:
BombExploded?.Invoke(this, (BombExplodedEvent)baseEvent);
break;
case EventType.BombBeginDefuse:
BombBeginDefuse?.Invoke(this, (BombBeginDefuseEvent)baseEvent);
break;
case EventType.BombAbortDefuse:
BombAbortDefuse?.Invoke(this, (BombAbortDefuseEvent)baseEvent);
break;
case EventType.PlayerHurt:
PlayerHurt?.Invoke(this, (PlayerHurtEvent)baseEvent);
break;
case EventType.Blind:
Blind?.Invoke(this, (BlindEvent)baseEvent);
break;
case EventType.PlayerBind:
PlayerBind?.Invoke(this, (PlayerBindEvent)baseEvent);
break;
case EventType.PlayerDisconnect:
PlayerDisconnect?.Invoke(this, (PlayerDisconnectEvent)baseEvent);
break;
case EventType.SayText:
SayText?.Invoke(this, (SayTextEvent)baseEvent);
break;
case EventType.SayText2:
SayText2?.Invoke(this, (SayText2Event)baseEvent);
break;
case EventType.PlayerJump:
PlayerJump?.Invoke(this, (PlayerJumpEvent)baseEvent);
break;
case EventType.PlayerFootstep:
PlayerFootstep?.Invoke(this, (PlayerFootstepEvent)baseEvent);
break;
case EventType.OtherDeath:
OtherDeath?.Invoke(this, (OtherDeathEvent)baseEvent);
break;
case EventType.EntitySpawned:
EntitySpawned?.Invoke(this, (EntitySpawnedEvent)baseEvent);
break;
case EventType.EntityRemoved:
EntityRemoved?.Invoke(this, (EntityRemovedEvent)baseEvent);
break;
default:
break;
}
}
}
protected virtual void ConsumeMatchStarted(MatchStarted message)
{
}
protected virtual void OnMatchStarted(EventArgs e)
{
MatchStarted?.Invoke(this, e);
}
public DomainResult Start(TeamReadModel teamAtHome, TeamReadModel teamAsGuest)
{
var matchStarted = new MatchStarted(MatchId, teamAtHome.Players, teamAsGuest.Players);
return(DomainResult.Ok(matchStarted));
}
public void Apply(MatchStarted domainEvent)
{
_isStarted = true;
HomeTeamPlayers = domainEvent.HomeTeam;
GuestTeamPlayers = domainEvent.GuestTeam;
}