Пример #1
0
        public async Task <Result <Player, JoinGameError> > JoinGameAsync(GameId gameId, string playerName)
        {
            var result = await _gameRepository.GetGameAndVersionAsync(gameId);

            return(await result.Map <Task <Result <Player, JoinGameError> > >(
                       async gameAndVersion =>
            {
                var(game, version) = gameAndVersion;

                if (game.Players.Count >= Models.Game.MaxNumberOfPlayers)
                {
                    return JoinGameError.GameFull;
                }

                var playerJoined = new PlayerJoined(playerName);
                await _eventRepository.AddEventAsync(gameId, playerJoined, version);

                var changedResources = playerJoined.ApplyAndGetModifiedResources(game);
                var changedResourceNames = ChangedResourcesResolver.GetResourceNames(changedResources);

                await _gameEventService.NotifyWorldUpdatedAsync(game.Id, changedResourceNames.ToArray());

                return Convert(game.Players.Last());
            },
                       readGameError =>
            {
                return readGameError switch
                {
                    ReadGameError.NotFound => Task.FromResult(new Result <Player, JoinGameError>(JoinGameError.GameNotFound)),
                    _ => throw new ArgumentOutOfRangeException(nameof(readGameError), readGameError, null)
                };
            }));
Пример #2
0
        public async Task <Result <Character, ExecuteActionError> > ExecuteActionAsync(GameId gameId, CharacterId characterId, Union <Move, UsePortal, ClearObstacle> action)
        {
            var result = await _gameRepository.GetGameAndVersionAsync(gameId);

            return(await result.Map(
                       async gameAndVersion =>
            {
                var(game, version) = gameAndVersion;

                var character = game.World.Characters.SingleOrDefault(characterCandidate => characterCandidate.Id == characterId);

                if (character == null)
                {
                    return ExecuteActionError.CharacterNotFound;
                }

                var createEventResult = action.Map(
                    move => Move(game, character, move.ActionName, move.NumberOfPathsToTravel),
                    usePortal => UsePortal(game, character, usePortal.PortalPath),
                    clearObstacle => ClearObstacle(game, character, clearObstacle.Obstacle));

                return await createEventResult.Map <Task <Result <Character, ExecuteActionError> > >(
                    async @event =>
                {
                    await _eventRepository.AddEventAsync(game.Id, @event, version);

                    var changedResources = @event.ApplyAndGetModifiedResources(game);

                    var changedResourceNames = ChangedResourcesResolver.GetResourceNames(changedResources);

                    await _gameEventService.NotifyWorldUpdatedAsync(game.Id, changedResourceNames.ToArray());

                    return CreateCharacter(character, game.World);
                },
                    error => Task.FromResult(new Result <Character, ExecuteActionError>(error)));
            },
                       readGameError => Task.FromResult(new Result <Character, ExecuteActionError>(ConvertToMoveCharacterError(readGameError)))));
        }