Esempio n. 1
0
        private async Task ExportGameUpdates(ExportOptions opts, string outDir)
        {
            _logger.Information("Fetching games list...");
            var games = _gameStore.GetGames(new GameStore.GameQueryOptions
            {
                HasFinished = true
            });

            var chunks = games.Select(async game =>
            {
                await Task.Yield();

                var data = (IGameData)game;

                var filename = data.Season != -1
                    ? Path.Join(outDir, $"season{data.Season}", $"day{data.Day}", $"{game.GameId}.json")
                    : Path.Join(outDir, $"tournament{data.Tournament}", $"day{data.Day}", $"{game.GameId}.json");

                var updates = _gameUpdateStore.GetGameUpdates(new GameUpdateStore.GameUpdateQueryOptions
                {
                    Game = new[] { game.GameId }
                });

                _logger.Information("Writing game {GameId} (Season {Season} Day {Day}) to {Filename}", game.GameId,
                                    data.Season, data.Day, filename);
                await WriteValues(opts, updates.Select(ToFileGameUpdate), filename);
            }).Buffer(20);

            await foreach (var chunk in chunks)
            {
                await Task.WhenAll(chunk);
            }
        }
Esempio n. 2
0
        public async Task LeaveGame(string gameCode)
        {
            await Groups.RemoveFromGroupAsync(Context.ConnectionId, gameCode);

            Game game   = GameStore.GetGame(gameCode);
            var  player = game.Players.FirstOrDefault(e => e.ConnectionId == Context.ConnectionId);

            if (player == null || game.Status == GameStatus.Completed)
            {
                return;
            }
            if (game.Status == GameStatus.NotStarted)
            {
                game.Players.Remove(player);
                if (game.Players.Count == 0)
                {
                    GameStore.RemoveGame(gameCode);
                    await Clients.Group(GameList).GameListUpdated(GameStore.GetGames());
                }

                return;
            }

            player.ChallengesRemaining = 0;
            if (game.Players.Count == 1)
            {
                game.Status = GameStatus.Completed;
            }
        }
Esempio n. 3
0
        public async Task CreateGame(string playerName, int answerSeconds, int challengeSeconds)
        {
            Player admin = new Player(Context.ConnectionId, playerName);
            Game   game  = GameStore.AddGame(admin, answerSeconds, challengeSeconds);

            await Groups.AddToGroupAsync(Context.ConnectionId, game.Code);

            await Clients.Caller.GameUpdated(game);

            await Clients.Group(GameList).GameListUpdated(GameStore.GetGames());
        }
Esempio n. 4
0
        public async Task JoinGame(string playerName, string code)
        {
            Game game = GameStore.GetGame(code);

            Player player = new Player(Context.ConnectionId, playerName);

            game.Players.Add(player);

            await Groups.AddToGroupAsync(Context.ConnectionId, game.Code);

            await Clients.Group(game.Code).GameUpdated(game);

            await Clients.Group("gameList").GameListUpdated(GameStore.GetGames());
        }
Esempio n. 5
0
        public IActionResult GetGames()
        {
            // TODO Subscribe caller to game list update

            return(Ok(GameStore.GetGames()));
        }
Esempio n. 6
0
        public async Task RetrieveGameList()
        {
            await Groups.AddToGroupAsync(Context.ConnectionId, GameList);

            await Clients.Caller.GameListUpdated(GameStore.GetGames());
        }