Esempio n. 1
0
        public void Test19()
        {
            var game       = new GameInitializer(fourPlayers.Keys);
            var gameId     = Guid.NewGuid();
            var scoreBoard = game.StartGame(gameId);

            scoreBoard.ResetScores();

            var round = new TarokRound
            {
                Game      = GameType.Ena,
                Won       = false,
                Modifiers = new List <Modifier>()
                {
                    new Modifier(ModifierType.Valat, TeamModifier.NonPlaying, false)
                },
                ContraFactor     = Contra.Contra,
                ScoreDifference  = 35,
                LeadPlayer       = fourPlayers[nejc.PlayerId].PlayerId,
                SupportingPlayer = fourPlayers[luka.PlayerId].PlayerId,
            };

            scoreBoard.ApplyTarokRound(round);

            Assert.True(scoreBoard.Scores[jan.PlayerId].Score == 0);
            Assert.True(scoreBoard.Scores[erik.PlayerId].Score == 0);
            Assert.True(scoreBoard.Scores[nejc.PlayerId].Score == -500, "Nejc ima -500");
            Assert.True(scoreBoard.Scores[luka.PlayerId].Score == -500, "Luka ima -500");

            Assert.True(scoreBoard.Scores[jan.PlayerId].RadelcCount - scoreBoard.Scores[jan.PlayerId].UsedRadelcCount == 0);
            Assert.True(scoreBoard.Scores[erik.PlayerId].RadelcCount - scoreBoard.Scores[erik.PlayerId].UsedRadelcCount == 0);
            Assert.True(scoreBoard.Scores[nejc.PlayerId].RadelcCount - scoreBoard.Scores[nejc.PlayerId].UsedRadelcCount == 0);
            Assert.True(scoreBoard.Scores[luka.PlayerId].RadelcCount - scoreBoard.Scores[luka.PlayerId].UsedRadelcCount == 0);
        }
Esempio n. 2
0
        public void Test14()
        {
            var game       = new GameInitializer(fourPlayers.Keys);
            var gameId     = Guid.NewGuid();
            var scoreBoard = game.StartGame(gameId);

            scoreBoard.ResetScores();

            var round = new TarokRound
            {
                Game             = GameType.Ena,
                LeadPlayer       = jan.PlayerId,
                SupportingPlayer = luka.PlayerId,
                Won             = true,
                ScoreDifference = 10,
                MondFangPlayer  = luka.PlayerId,
                PagatFangPlayer = erik.PlayerId
            };

            scoreBoard.ApplyTarokRound(round);

            Assert.True(scoreBoard.Scores[jan.PlayerId].Score == 40);
            Assert.True(scoreBoard.Scores[luka.PlayerId].Score == 20);
            Assert.True(scoreBoard.Scores[erik.PlayerId].Score == -25);
        }
Esempio n. 3
0
        public void Test1()
        {
            var game       = new GameInitializer(fourPlayers.Keys);
            var gameId     = Guid.NewGuid();
            var scoreBoard = game.StartGame(gameId);

            scoreBoard.ResetScores();

            var round = new TarokRound
            {
                LeadPlayer       = jan.PlayerId,
                SupportingPlayer = erik.PlayerId,
                Game             = GameType.Ena,
                Won             = true,
                ScoreDifference = 15
            };

            round.Modifiers.Add(new Modifier(
                                    ModifierType.Trula,
                                    TeamModifier.Playing,
                                    announced: true
                                    ));

            scoreBoard.ApplyTarokRound(round);

            Assert.True(scoreBoard.Scores[jan.PlayerId].Score == 65);
            Assert.True(scoreBoard.Scores[erik.PlayerId].Score == 65);
        }
Esempio n. 4
0
        public void Test6()
        {
            var game       = new GameInitializer(fourPlayers.Keys);
            var gameId     = Guid.NewGuid();
            var scoreBoard = game.StartGame(gameId);

            scoreBoard.ResetScores();
            scoreBoard.AddRadelc();
            var round = new TarokRound
            {
                LeadPlayer       = jan.PlayerId,
                SupportingPlayer = luka.PlayerId,
                Game             = GameType.Ena,
                Won             = true,
                ScoreDifference = 20
            };

            round.Modifiers.Add(new Modifier
                                (
                                    ModifierType.PagatUltimo,
                                    TeamModifier.NonPlaying,
                                    announced: true,
                                    contra: Contra.Re
                                ));

            scoreBoard.ApplyTarokRound(round);

            Assert.True(scoreBoard.Scores[jan.PlayerId].Score == -300);
            Assert.True(scoreBoard.Scores[luka.PlayerId].Score == -300);
            Assert.True(scoreBoard.Scores[jan.PlayerId].RadelcCount - scoreBoard.Scores[jan.PlayerId].UsedRadelcCount == 0);
        }
Esempio n. 5
0
        public void Test3()
        {
            var game       = new GameInitializer(fourPlayers.Keys);
            var gameId     = Guid.NewGuid();
            var scoreBoard = game.StartGame(gameId);

            scoreBoard.ResetScores();

            var round = new TarokRound
            {
                LeadPlayer      = jan.PlayerId,
                Game            = GameType.Ena,
                Won             = false,
                ScoreDifference = 0
            };

            scoreBoard.ApplyTarokRound(round);

            Assert.True(scoreBoard.Scores[jan.PlayerId].Score == -30);
        }
Esempio n. 6
0
        public void Test10()
        {
            var game       = new GameInitializer(fourPlayers.Keys);
            var gameId     = Guid.NewGuid();
            var scoreBoard = game.StartGame(gameId);

            scoreBoard.ResetScores();

            var round = new TarokRound
            {
                Game            = GameType.Berac,
                LeadPlayer      = jan.PlayerId,
                Won             = false,
                ScoreDifference = 0
            };

            scoreBoard.ApplyTarokRound(round);

            Assert.True(scoreBoard.Scores[jan.PlayerId].Score == -70);
            Assert.True(scoreBoard.Scores[jan.PlayerId].RadelcCount - scoreBoard.Scores[jan.PlayerId].UsedRadelcCount == 1);
        }
Esempio n. 7
0
        public void Test16()
        {
            var game       = new GameInitializer(fourPlayers.Keys);
            var gameId     = Guid.NewGuid();
            var scoreBoard = game.StartGame(gameId);

            scoreBoard.ResetScores();

            var round = new TarokRound
            {
                Game            = GameType.SoloTri,
                LeadPlayer      = erik.PlayerId,
                Won             = true,
                ScoreDifference = 30,
            };

            round.Modifiers.Add(new Modifier(ModifierType.BarvniValat, TeamModifier.Playing, true));

            scoreBoard.ApplyTarokRound(round);

            Assert.True(scoreBoard.Scores[erik.PlayerId].Score == 125);
        }
Esempio n. 8
0
        public void Test9()
        {
            var game       = new GameInitializer(fourPlayers.Keys);
            var gameId     = Guid.NewGuid();
            var scoreBoard = game.StartGame(gameId);

            scoreBoard.ResetScores();
            scoreBoard.AddRadelc();
            var round = new TarokRound
            {
                Game            = GameType.OdprtiBerac,
                LeadPlayer      = jan.PlayerId,
                Won             = true,
                ContraFactor    = Contra.Contra,
                ScoreDifference = 0
            };

            scoreBoard.ApplyTarokRound(round);

            Assert.True(scoreBoard.Scores[jan.PlayerId].Score == 360);
            Assert.True(scoreBoard.Scores[jan.PlayerId].RadelcCount - scoreBoard.Scores[jan.PlayerId].UsedRadelcCount == 1);
        }
Esempio n. 9
0
        public void Test15()
        {
            var game       = new GameInitializer(fourPlayers.Keys);
            var gameId     = Guid.NewGuid();
            var scoreBoard = game.StartGame(gameId);

            scoreBoard.ResetScores();

            var round = new TarokRound
            {
                Game             = GameType.Ena,
                LeadPlayer       = jan.PlayerId,
                SupportingPlayer = luka.PlayerId,
                Won             = true,
                ScoreDifference = 30,
            };

            round.Modifiers.Add(new Modifier(ModifierType.Valat, TeamModifier.Playing, false));

            scoreBoard.ApplyTarokRound(round);

            Assert.True(scoreBoard.Scores[jan.PlayerId].Score == 250);
            Assert.True(scoreBoard.Scores[luka.PlayerId].Score == 250);
        }
        public async Task <RoundDTO> AddRound(CreateRoundDTO createRoundRequest)
        {
            var round  = Round.FromCreateRoundRequest(createRoundRequest);
            var gameId = round.GameId;

            var lastRound = await dbContext.Round
                            .AsNoTracking()
                            .OrderBy(r => r.RoundNumber)
                            .LastOrDefaultAsync(r => r.GameId == gameId);

            round.RoundNumber = (lastRound?.RoundNumber ?? 0) + 1;

            var gamePlayers = await dbContext.GamePlayer
                              .AsNoTracking()
                              .Where(g => g.GameId == gameId)
                              .OrderBy(p => p.Position)
                              .ToListAsync();

            ScoreBoard scoreBoard;

            if (lastRound == null)
            {
                var gameinit = new GameInitializer(gamePlayers.Select(p => p.PlayerId));
                scoreBoard = gameinit.StartGame(gameId);
            }
            else
            {
                var lastRoundResults = await dbContext.RoundResult
                                       .Where(r => r.RoundId == lastRound.RoundId)
                                       .ToListAsync();

                scoreBoard = ScoreBoard.FromRound(lastRoundResults);
            }

            var tarokRound = TarokRound.FromRound(round);

            var scores = scoreBoard.ApplyTarokRound(tarokRound);

            // TODO in case of Klop the client sent results are already here. No like.
            round.RoundResult.Clear();
            foreach (var player in gamePlayers)
            {
                var playerScore = scores[player.PlayerId];

                round.RoundResult.Add(new RoundResult()
                {
                    RoundId           = round.RoundId,
                    GameId            = gameId,
                    PlayerId          = player.PlayerId,
                    PlayerScore       = playerScore.Score,
                    PlayerRadelcCount = playerScore.RadelcCount,
                    PlayerRadelcUsed  = playerScore.UsedRadelcCount,
                    RoundScoreChange  = playerScore.RoundScoreChange
                });
            }

            dbContext.Round.Add(round);
            await dbContext.SaveChangesAsync();

            return(round.ToDto());
        }