public void PlayGame(Guid redOffensive,
Guid redDefensive,
Guid blueOffensive,
Guid blueDefensive,
int scoreRed,
int scoreBlue)
{
ValidatePlayers(redOffensive, redDefensive, blueOffensive, blueDefensive);
var scoreValidator = new ScoreValidator(scoreRed, scoreBlue);
if (!scoreValidator.IsValid)
{
throw new InvalidOperationException(scoreValidator.Message);
}
var @event = new GamePlayed
{
RedOffensive = redOffensive,
RedDefensive=redDefensive,
BlueOffensive=blueOffensive,
BlueDefensive = blueDefensive,
ScoreRed = scoreRed,
ScoreBlue = scoreBlue,
};
Append(@event);
Apply(@event);
}
private void Payout(GamePlayed game, Player winner)
{
if (game.GameComplete)
{
_context.SaveChanges();
var gamebetter = _context.GamesPlayed.Include(gp => gp.Winner).Include(gp => gp.Players).ThenInclude(gpp => gpp.Player).Single(g => g.Id == game.Id);
var stake = gamebetter.Stake;
foreach (var player in gamebetter.Players)
{
var be = new BoardEntry();
be.Game = gamebetter;
be.Player = player.Player;
if (gamebetter.Winner.Id == player.Player.Id)
{
var winnings = gamebetter.Players.Count() * stake;
be.Difference = winnings - stake;
}
else
{
be.Difference = -stake;
}
_context.Board.Add(be);
}
_context.SaveChanges();
}
}
public IActionResult GameSetup(GameSetupViewModel model)
{
GamePlayed game = new GamePlayed();
game.StartedByPlayerID = model.StartingPlayerID;
game.CourseID = model.SelectedCourseID;
game.GameFinished = false;
game.PlayerID = model.StartingPlayerID;
data.GamesPlayed.Insert(game);
data.GamesPlayed.Save();
var gameOptions = new QueryOptions <GamePlayed>
{
Includes = "Player, Course",
Where = gp => gp.GameFinished == false && gp.StartedByPlayerID == model.StartingPlayerID && gp.Score == 0
};
List <GamePlayed> openGames = new List <GamePlayed>(data.GamesPlayed.List(gameOptions));
ViewBag.Holes = data.Holes.List(new QueryOptions <Hole> {
Where = h => h.CourseID == model.SelectedCourseID
});
ViewBag.Course = data.Courses.Get(model.SelectedCourseID);
ViewBag.StartingPlayer = data.Players.Get(model.StartingPlayerID);
Course c = data.Courses.Get(model.SelectedCourseID);
ViewBag.Weather = GetWeather(c.ZipCode);
return(View("InGame", openGames));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,GameId,DatePlayed")] GamePlayed gamePlayed)
{
if (id != gamePlayed.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(gamePlayed);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!GamePlayedExists(gamePlayed.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["GameId"] = new SelectList(_context.Games, "Id", "Name", gamePlayed.GameId);
return(View(gamePlayed));
}
public void PlayGame(Guid redOffensive,
Guid redDefensive,
Guid blueOffensive,
Guid blueDefensive,
int scoreRed,
int scoreBlue)
{
ValidatePlayers(redOffensive, redDefensive, blueOffensive, blueDefensive);
var scoreValidator = new ScoreValidator(scoreRed, scoreBlue);
if (!scoreValidator.IsValid)
{
throw new InvalidOperationException(scoreValidator.Message);
}
var @event = new GamePlayed
{
RedOffensive = redOffensive,
RedDefensive = redDefensive,
BlueOffensive = blueOffensive,
BlueDefensive = blueDefensive,
ScoreRed = scoreRed,
ScoreBlue = scoreBlue,
};
Append(@event);
Apply(@event);
}
public async Task <IActionResult> Edit(Guid id, [Bind("Id,DateTime,GameComplete,IsDraw,Stake")] GamePlayed gamePlayed)
{
if (id != gamePlayed.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(gamePlayed);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!GamePlayedExists(gamePlayed.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(gamePlayed));
}
public static List <GamePlayed> getGamesPlayed(int playerId)
{
List <GamePlayed> games = new List <GamePlayed>();
SqliteCommand command = new SqliteCommand("select * from game_results where first_player = @id", DatabaseConnection.connection);
command.Parameters.Add(new SqliteParameter("@id", playerId));
IDataReader reader = command.ExecuteReader();
while (reader.Read())
{
GamePlayed game = new GamePlayed();
game.id = reader.GetInt32(0);
game.firstPlayer = getPlayerWithId(reader.GetInt32(1));
game.secondPlayer = getPlayerWithId(reader.GetInt32(2));
game.winner = reader.GetInt32(3);
game.datetime = new DateTime(reader.GetInt64(4));
games.Add(game);
}
reader.Close();
return(games);
}
public IActionResult UpdateScoreIndividual(GamePlayed game)
{
data.GamesPlayed.Update(game);
data.GamesPlayed.Save();
var gameOptions = new QueryOptions <GamePlayed>
{
Includes = "Player",
Where = gp => gp.GameFinished == false && gp.GamePlayedID == game.GamePlayedID
};
List <GamePlayed> openGames = new List <GamePlayed>(data.GamesPlayed.List(gameOptions));
ViewBag.Holes = data.Holes.List(new QueryOptions <Hole> {
Where = h => h.CourseID == game.CourseID
});
ViewBag.Course = data.Courses.Get(game.CourseID);
ViewBag.StartingPlayer = data.Players.Get(game.PlayerID);
ViewBag.Players = data.Players.List(new QueryOptions <Player> {
});
ViewBag.CurrentGame = game;
Course c = data.Courses.Get(game.CourseID);
ViewBag.Weather = GetWeather(c.ZipCode);
return(View("InGameIndividual", openGames));
}
// Start is called before the first frame update
void Start()
{
win = Resources.Load <Sprite>("grey_boxCheckmark");
lose = Resources.Load <Sprite>("grey_boxCross");
string nickname = PlayerPrefs.GetString("player");
player = DatabaseDataAcces.getPlayerWithNickname(nickname);
games = DatabaseDataAcces.getGamesPlayed(player.id);
for (int i = games.Count - 1; i >= 0; i--)
{
GamePlayed g = games[i];
GameObject item = Instantiate(prefab);
Image image = item.transform.Find("Image").GetComponent <Image>();
Text player2 = item.transform.Find("player2").GetComponent <Text>();
if (g.winner == 1)
{
image.sprite = win;
}
else
{
image.sprite = lose;
}
player2.text = g.secondPlayer.nickname;
item.transform.SetParent(content.transform, false);
}
}
public IActionResult AddPlayer(AddPlayerViewModel model)
{
Player p = data.Players.Get(model.PlayerID);
if (p.Password == model.Password)
{
GamePlayed game = new GamePlayed();
game.CourseID = model.CourseID;
game.PlayerID = model.PlayerID;
game.StartedByPlayerID = model.StartedByPlayerID;
game.GameFinished = false;
data.GamesPlayed.Insert(game);
data.GamesPlayed.Save();
}
Player loggedInPlayer = data.Players.Get(model.StartedByPlayerID);
ViewBag.LoggedInPlayer = loggedInPlayer;
ViewBag.Courses = data.Courses.List(new QueryOptions <Course> {
});
ViewBag.Games = data.GamesPlayed.List(new QueryOptions <GamePlayed>
{
Includes = "Player, Course",
Where = gp => gp.GameFinished == false && gp.StartedByPlayerID == model.StartedByPlayerID && gp.Score == 0
});
return(View("GameSetup"));
}
public IActionResult UpdateScoreIndividual(int id)
{
GamePlayed game = data.GamesPlayed.Get(id);
ViewBag.Course = data.Courses.Get(game.CourseID);
ViewBag.Player = data.Players.Get(game.PlayerID);
return(View(game));
}
public GamePlayedDTO ToDto(GamePlayed domain)
{
return(new GamePlayedDTO()
{
PlayerId = domain.PlayerId,
GameId = domain.GameId,
TeamId = domain.TeamId,
CreatedOnUtc = domain.CreatedOn
});
}
public async Task <IActionResult> Create([Bind("Id,GameId,DatePlayed")] GamePlayed gamePlayed)
{
if (ModelState.IsValid)
{
_context.Add(gamePlayed);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["GameId"] = new SelectList(_context.Games, "Id", "Name", gamePlayed.GameId);
return(View(gamePlayed));
}
public async Task <IActionResult> Create([Bind("Id,DateTime,GameComplete,IsDraw,Stake")] GamePlayed gamePlayed)
{
if (ModelState.IsValid)
{
gamePlayed.Id = Guid.NewGuid();
_context.Add(gamePlayed);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(gamePlayed));
}
public async Task <GamePlayedDTO> Upsert(GamePlayedDTO dto)
{
var result = await this.Handler.Execute(_log, async() =>
{
GamePlayed gamePlayed = _gamePlayedFactory.CreateDomainObject(dto);
gamePlayed.Validate();
gamePlayed = await _gamePlayedRepository.Upsert(gamePlayed);
return(_gamePlayedMapper.ToDto(gamePlayed));
});
return(result);
}
public Task RecordGameResult(DateTime day, string homeTeam, int homeScore, string visitorTeam, int visitorScore)
{
var message = new GamePlayed
{
Date = day.Date,
Home = new TeamResult {
Name = homeTeam, Score = homeScore
},
Visitor = new TeamResult {
Name = visitorTeam, Score = visitorScore
}
};
return(Host.SendMessageAndWait(message));
}
public void Handle(GamePlayed @event)
{
_gamesPlayed++;
HandleVinkekatSituations(@event);
var result = _scoreCalculator.Calculate(_playerCache[@event.RedOffensive],
_playerCache[@event.RedDefensive],
_playerCache[@event.BlueOffensive],
_playerCache[@event.BlueDefensive],
@event.ScoreRed,
@event.ScoreBlue,
_gamesPlayed / _playerCount, @event.Date);
_activitites.Add(result.Story);
SetScore(result, @event.RedWinner);
_minMaxCache.Update(result.BlueDefensive.ScoreCount, result.BlueOffensive.ScoreCount, result.RedDefensive.ScoreCount, result.RedOffensive.ScoreCount);
}
private void HandleVinkekatSituations(GamePlayed @event)
{
if (@event.ScoreBlue == 0)
{
CurrentVinkekat = new Tuple <PlayarName, PlayarName>(_playerCache[@event.BlueOffensive].Name,
_playerCache[@event.BlueDefensive].Name);
}
if (@event.ScoreRed == 0)
{
CurrentVinkekat = new Tuple <PlayarName, PlayarName>(_playerCache[@event.RedOffensive].Name,
_playerCache[@event.RedDefensive].Name);
}
if (@event.ScoreBlue == 1 || @event.ScoreRed == 1)
{
AddActivity(new Activity("A vinkekat was close!", @event.Date));
}
}
public IActionResult DeleteGamesIndividual(int id)
{
GamePlayed g = data.GamesPlayed.Get(id);
var gamesToDelete = new QueryOptions <GamePlayed>
{
Where = gp => gp.GamePlayedID == id
};
var toDelete = data.GamesPlayed.List(gamesToDelete);
foreach (GamePlayed gp in toDelete)
{
data.GamesPlayed.Delete(gp);
}
data.GamesPlayed.Save();
ToIndex(g.PlayerID);
return(View("Index"));
}
private IActionResult GameManagerView(GamePlayed game)
{
var GameTypeAttributes = game.Game.Type.GetAttributes();
if (GameTypeAttributes.Any(attr => attr.GetType() == typeof(AccrualHandsAttribute)))
{
return(View("ManageAccrual", game));
}
else if (GameTypeAttributes.Any(attr => attr.GetType() == typeof(FixedHandsAttribute)))
{
return(View("ManageFixedHands", game));
}
else
{
return(View("ManageSimple", game));
}
}
public IActionResult EndGame(int id)
{
GamePlayed g = new GamePlayed();
var gOptions = new QueryOptions <GamePlayed>
{
Where = gp => gp.GameFinished == false && gp.StartedByPlayerID == id && gp.Score != 0
};
var finishedGames = data.GamesPlayed.List(gOptions);
foreach (GamePlayed game in finishedGames)
{
game.GameFinished = true;
data.GamesPlayed.Update(game);
g = game;
}
data.GamesPlayed.Save();
ToIndex(id);
return(View("Index"));
}
public IActionResult EndGameIndividual(int id)
{
GamePlayed g = data.GamesPlayed.Get(id);
var gOptions = new QueryOptions <GamePlayed>
{
Where = gp => gp.GamePlayedID == id
};
var finishedGames = data.GamesPlayed.List(gOptions);
foreach (GamePlayed game in finishedGames)
{
game.GameFinished = true;
data.GamesPlayed.Update(game);
g = game;
}
data.GamesPlayed.Save();
ToIndex(g.PlayerID);
return(View("Index"));
}
public ActionResult CreateGame(StartGameModel model)
{
var newGamePlayed = new GamePlayed();
var players = new List <GamePlayers>();
players.AddRange(_context.Players.Where(pl => model.SelectedPlayers.Contains(pl.Id)).Select(x => new GamePlayers()
{
Player = x
}));
var game = _context.Games.First(ga => ga.Id == model.SelectedGame);
newGamePlayed.Players = players;
newGamePlayed.Game = game;
if (model.SelectedGameStake != null)
{
newGamePlayed.Stake = model.SelectedGameStake.Value;
}
else
{
newGamePlayed.Stake = game.DefaultStake;
}
_context.GamesPlayed.Add(newGamePlayed);
_context.SaveChanges();
//Add the first hand too.
var newhand = new Hand();
newhand.Game = newGamePlayed;
var scores = new List <PlayerHand>();
foreach (var player in players)
{
var plhand = new PlayerHand();
plhand.Player = player.Player;
plhand.Hand = newhand;
plhand.Done = false;
scores.Add(plhand);
}
newhand.Scores = scores;
newGamePlayed.Hands = new Hand[] { newhand };
_context.SaveChanges();
return(RedirectToAction("Manage", new { gameId = newGamePlayed.Id }));
}
public IActionResult RemovePlayer(int id)
{
GamePlayed game = data.GamesPlayed.Get(id);
data.GamesPlayed.Delete(game);
data.GamesPlayed.Save();
Player loggedInPlayer = data.Players.Get(game.StartedByPlayerID);
ViewBag.LoggedInPlayer = loggedInPlayer;
ViewBag.Courses = data.Courses.List(new QueryOptions <Course> {
});
ViewBag.Games = data.GamesPlayed.List(new QueryOptions <GamePlayed>
{
Includes = "Player, Course",
Where = gp => gp.GameFinished == false && gp.StartedByPlayerID == game.StartedByPlayerID && gp.Score == 0
});
return(View("GameSetup"));
}
public IActionResult ContinueGame(int id)
{
GamePlayed game = data.GamesPlayed.Get(id);
var gameOptions = new QueryOptions <GamePlayed>
{
Includes = "Player",
Where = gp => gp.GamePlayedID == id
};
List <GamePlayed> games = new List <GamePlayed>(data.GamesPlayed.List(gameOptions));
ViewBag.Holes = data.Holes.List(new QueryOptions <Hole> {
Where = h => h.CourseID == game.CourseID
});
ViewBag.Course = data.Courses.Get(game.CourseID);
ViewBag.StartingPlayer = data.Players.Get(game.PlayerID);
ViewBag.CurrentGame = game;
Course c = data.Courses.Get(game.CourseID);
ViewBag.Weather = GetWeather(c.ZipCode);
return(View("InGameIndividual", games));
}
public override string ToString()
{
string user = "";
switch (UserWon)
{
case Users.computer:
{
user = "******";
break;
}
case Users.circle:
{
user = "******";
break;
}
case Users.ex:
{
user = "******";
break;
}
case Users.draw:
{
return("Date: " + GamePlayed.ToString() + " game was drawn");
}
default:
{
user = "";
break;
}
}
return("Date: " + GamePlayed.ToString() + " " + user + " won");
}
public RedirectToActionResult DeleteGamePlayed(GamePlayed gp)
{
data.GamesPlayed.Delete(gp);
data.GamesPlayed.Save();
return(RedirectToAction("GamePlayedList"));
}
public void Apply(GamePlayed @event)
{
}
public async Task <List <Game> > ScrapeH2(bool getCustoms, string playerName)
{
//ServicePointManager.DefaultConnectionLimit = 90;
WebClient bungie = new WebClient(); //used to get count of pages of games played
//HttpClient IDDownloader = new HttpClient();
List <Game> gameList = new List <Game>();
//IDDownloader.DefaultRequestHeaders.ConnectionClose = true;
string GT = playerName;
string matchHistoryP2;
string matchHistoryP1;
string fullhtml;
int sigStartGameCount;
int sigEndGameCount;
int numofGames;
int approxNumOfPages;
int sigStartGameID;
int sigEndGameID;
int sigMidGameID;
int sigStartGameType;
int sigEndGameType;
int sigStartDate;
int sigEndDate;
int sigStartMap;
int sigEndMap;
int sigStartPlaylist;
int sigEndPlaylist;
string taskResult;
int gameID = 0;
int corruptPages = 0;
List <string> corruptedPages = new List <string>();
string date;
//if (getCustoms) - don't need get customs logic, customs included in regular gameID feed for H2
matchHistoryP2 = "&ctl00_mainContent_bnetpgl_recentgamesChangePage="; //URL for MM games
matchHistoryP1 = "http://halo.bungie.net/stats/playerstatshalo2.aspx?player="; //first part of match history page string
//2nd part of match history page string. concatted to current page
fullhtml = bungie.DownloadString(matchHistoryP1 + GT + matchHistoryP2 + 1); //first page of GT1s game history
sigStartGameCount = fullhtml.IndexOf(" <strong>"); //index of first char in HTML line that gives you total MM games
sigEndGameCount = fullhtml.IndexOf("</strong>", sigStartGameCount); //index of next char after final digit of total MM games
//fist char + length of that substring as start index, length of characters in number of MM games as endingChar - startingChar - length of "Intro" substring = number of MM games as string
numofGames = int.Parse(fullhtml.Substring(sigStartGameCount + " <strong>".Length, (sigEndGameCount - sigStartGameCount - " <strong>".Length)));
approxNumOfPages = (numofGames / 25) + 1; //25 games a page, +1 to make sure a page isn't missed due to integer division
bungie.Dispose();
List <Task <string> > newTasks = new List <Task <string> >();
List <string> taskIDandSiteLink = new List <string>();
for (int i = 1; i <= approxNumOfPages; i++)
{
Uri siteLink = new Uri(matchHistoryP1 + GT + matchHistoryP2 + i); //GT = name of player, passed to method.
//creates url like http://halo.bungie.net/stats/playerstatshalo3.aspx?player=infury&ctl00_mainContent_bnetpgl_recentgamesChangePage=1
//taskIDandSiteLink.Add(tasks.Last().Id + " " + siteLink.ToString()); //list of taskIDs and what page they should download
newTasks.Add(httpReq(siteLink));
}
while (newTasks.Count > 0)
{
//if (tasks.Count < 2) //debugging; why the f**k will this not complete for all tasks
//System.Diagnostics.Debug.WriteLine("last 15 tasks");
System.Diagnostics.Debug.WriteLine("new iteration of while loop");
var taskComplete = await Task.WhenAny(newTasks);
newTasks.Remove(taskComplete); //remove finished task from list
System.Diagnostics.Debug.WriteLine("Task " + taskComplete.Id + " finshed at " + System.DateTime.Now + " - " + newTasks.Count + " tasks remain");
try
{
taskResult = taskComplete.Result;
//taskComplete.Dispose();
}
catch
{
System.Diagnostics.Debug.WriteLine(taskComplete.Id.ToString());
//Debug.Print(taskComplete.Id.ToString());
// taskComplete.Dispose();
taskResult = "";
continue;
}
sigMidGameID = 0;
sigStartGameID = 0;
sigEndGameID = 0;
if (taskResult.IndexOf("No games found for this player.") != -1 ||
taskResult.IndexOf("It seems that you have encountered a problem with our site.") != -1)
{
corruptPages++;
corruptedPages.Add(taskResult);
continue; //if index of above IS NOT negative one, then it's a corrupted page or a customs page that doesn't exist.
//skip this task and await the next one
}
for (int x = 0; x < 25; x++) //25 GameIDs per page
{
sigStartGameID = taskResult.IndexOf("GameStatsHalo2", sigMidGameID); //find gameID
sigEndGameID = taskResult.IndexOf("&player", sigMidGameID);
try
{
GamePlayed foundGame = new GamePlayed();
Game gameDetailed = new Game();
int.TryParse(taskResult.Substring(sigStartGameID + "GameStatsHalo2.aspx?gameid=".Length, sigEndGameID - "GameStatsHalo2.aspx?gameid=".Length - sigStartGameID), out gameID);
foundGame.gameID = gameID;
gameDetailed.gameID = gameID;
//get gametype for this row --working
sigStartGameType = taskResult.IndexOf("\">", sigEndGameID);
sigEndGameType = taskResult.IndexOf("</a", sigEndGameID);
gameDetailed.gametype = taskResult.Substring(sigStartGameType + "\">".Length, sigEndGameType - "\">".Length - sigStartGameType);
//get date for this row -- working
sigStartDate = taskResult.IndexOf("</td><td>\r\n ", sigEndGameType) + "</td><td>\r\n ".Length;
sigEndDate = taskResult.IndexOf("M", sigStartDate) + 1;
date = taskResult.Substring(sigStartDate, sigEndDate - sigStartDate);
//get map for this row -- working
sigStartMap = taskResult.IndexOf("</td><td>\r\n ", sigEndDate) + "</td><td>\r\n ".Length;
sigEndMap = taskResult.IndexOf("\r\n", sigStartMap);
gameDetailed.map = taskResult.Substring(sigStartMap, sigEndMap - sigStartMap);
//get playlist for this row
sigStartPlaylist = taskResult.IndexOf("</td><td>\r\n ", sigEndMap) + "</td><td>\r\n ".Length;
sigEndPlaylist = taskResult.IndexOf("\r\n", sigStartPlaylist);
gameDetailed.playlist = taskResult.Substring(sigStartPlaylist, sigEndPlaylist - sigStartPlaylist);
try
{
gameDetailed.gamedate = DateTime.Parse(date); //try to parse what we think is the date, if parse fails it's not a valid gameID
//detailTable.Rows.Add(gameID, map, playlist, gametype, dateConvert, GT);
gameList.Add(gameDetailed);
}
catch
{
System.Diagnostics.Debug.WriteLine(gameID + " couldn't be parsed");
//int ix = 0;
break;
}
}
catch
{
x = 0;
break; //if parse fails before x = 25, taskResult page didn't have a full 25 games iterate to next Task
}
sigMidGameID = sigEndGameID + 1; //increment index by 1 to find next instance of a GameID in the html
}
System.Diagnostics.Debug.WriteLine("Task " + taskComplete.Id + " completed");
//taskComplete.Dispose();
}
/* if (GameDetailsTable.Rows.Count == 0) //if there aren't already games in this table from a previous instance of this method
* GameDetailsTable = detailTable; //assign details table to player property since idk if you can return more than one thing per method
* else
* GameDetailsTable.Merge(detailTable); //if rowcount != 0, merge existing GameDetailsTable with one from this instance of the method */
return(gameList);
}
public void Apply(GamePlayed @event)
{
}
public void Handle(GamePlayed @event)
{
_query.Handle(@event);
}
public void Handle(GamePlayed @event)
{
_gamesPlayed++;
HandleVinkekatSituations(@event);
var result = _scoreCalculator.Calculate(_playerCache[@event.RedOffensive],
_playerCache[@event.RedDefensive],
_playerCache[@event.BlueOffensive],
_playerCache[@event.BlueDefensive],
@event.ScoreRed,
@event.ScoreBlue,
_gamesPlayed / _playerCount, @event.Date);
_activitites.Add(result.Story);
SetScore(result, @event.RedWinner);
_minMaxCache.Update(result.BlueDefensive.ScoreCount, result.BlueOffensive.ScoreCount, result.RedDefensive.ScoreCount, result.RedOffensive.ScoreCount);
}
private void HandleVinkekatSituations(GamePlayed @event)
{
if (@event.ScoreBlue == 0)
{
CurrentVinkekat = new Tuple<PlayarName, PlayarName>(_playerCache[@event.BlueOffensive].Name,
_playerCache[@event.BlueDefensive].Name);
}
if (@event.ScoreRed == 0)
{
CurrentVinkekat = new Tuple<PlayarName, PlayarName>(_playerCache[@event.RedOffensive].Name,
_playerCache[@event.RedDefensive].Name);
}
if (@event.ScoreBlue == 1 || @event.ScoreRed == 1)
{
AddActivity(new Activity("A vinkekat was close!", @event.Date));
}
}
public void Handle(GamePlayed command)
{
_eventStorage.Append <AggregateRoot>(command.RootId, new Event[] { command });
}
