Esempio n. 1
0
        public void ActionPossible_WhenFalseWithSingleError_ReturnsCorrectInfo()
        {
            var result = ActionPossible.False("You cannot perform this action");

            Assert.Multiple(() =>
            {
                Assert.That(result.IsPossible, Is.False);
                Assert.That(result.IsImpossible, Is.True);
                Assert.That(result.Errors, Contains.Item("You cannot perform this action"));
            });
        }
Esempio n. 2
0
        public void ActionPossible_WhenUnauthorized_ReturnsCorrectInfo()
        {
            var result = ActionPossible.Unauthorized();

            Assert.Multiple(() =>
            {
                Assert.That(result.IsPossible, Is.False);
                Assert.That(result.IsImpossible, Is.True);
                Assert.That(result.Errors, Contains.Item("Unauthorized Action"));
            });
        }
Esempio n. 3
0
        public void ActionPossible_WhenTrue_ReturnsCorrectInfo()
        {
            var result = ActionPossible.True();

            Assert.Multiple(() =>
            {
                Assert.That(result.IsPossible, Is.True);
                Assert.That(result.IsImpossible, Is.False);
                Assert.That(result.Errors, Is.Empty);
            });
        }
Esempio n. 4
0
        public void ActionPossible_WhenReturned_StaticErrorListBecomesEmpty_DefaultMessageInErrorList()
        {
            ActionPossible.AddError("Error message 1");
            ActionPossible.AddError("Error message 2");
            ActionPossible.AddError("Error message 3");

            var result = ActionPossible.FalseWithErrors();

            Assert.That(result.Errors.Count(), Is.EqualTo(3));

            var nextResult = ActionPossible.FalseWithErrors();

            Assert.Multiple(() =>
            {
                Assert.That(nextResult.Errors.Count(), Is.EqualTo(1));
                Assert.That(nextResult.Errors, Contains.Item("You are not allowed to perform this action"));
            });
        }
Esempio n. 5
0
        public void ActionPossible_WhenFalseWithManyError_ReturnsCorrectInfo()
        {
            ActionPossible.AddError("Error message 1");
            ActionPossible.AddError("Error message 2");
            ActionPossible.AddError("Error message 3");

            var result = ActionPossible.FalseWithErrors();

            Assert.Multiple(() =>
            {
                Assert.That(result.IsPossible, Is.False);
                Assert.That(result.IsImpossible, Is.True);
                Assert.That(result.Errors.Count(), Is.EqualTo(3));
                Assert.That(result.Errors, Contains.Item("Error message 1"));
                Assert.That(result.Errors, Contains.Item("Error message 2"));
                Assert.That(result.Errors, Contains.Item("Error message 3"));
            });
        }
Esempio n. 6
0
        /// <summary>
        /// Calcule les actions possible pour le joueur concerné : si aucune action n'est possible renvoie null
        /// </summary>
        /// <param name="J">Le joueur concerné</param>
        /// <returns></returns>
        internal Dictionary <TypeActionJoueur, ActionPossible> CalculActionsPossibles(Joueur j)
        {
            Dictionary <TypeActionJoueur, ActionPossible> actions = null;

            if (!j.JeterCartes && j.TapisJoueur > 0)
            {
                actions = new Dictionary <TypeActionJoueur, ActionPossible>();
                // Passe
                actions[TypeActionJoueur.Passe] = ActionPossible.Jeter;

                // Parole ou suivre
                if (
                    (j.DerniereAction == TypeActionJoueur.GrosseBlind && j == this.DerniereRelance && this.Etape == EtapeDonne.PreFlop) ||
                    (this.MontantDerniereRelance == 0)
                    )
                {
                    actions[TypeActionJoueur.Parole] = new ActionPossible(TypeActionJoueur.Parole, 0, 0);
                }
                else if (j.TapisJoueur >= this.MontantDerniereRelance)
                {
                    // Pour suivre, montant min = la mise actuelle du joueur, montant max = la somme totale à mettre
                    actions[TypeActionJoueur.Suit] = new ActionPossible(TypeActionJoueur.Suit, j.Mise, this.MontantDerniereRelance);
                }


                // Relance / mise
                if (j.TapisJoueur > this.RelanceMinimum())
                {
                    // Si le joueur est le premier à parler : il mise, sinon il relance
                    TypeActionJoueur actionJoueur = TypeActionJoueur.Relance;
                    if (this.MontantDerniereRelance == 0)
                    {
                        actionJoueur = TypeActionJoueur.Mise;
                    }
                    actions[actionJoueur] = new ActionPossible(actionJoueur, this.RelanceMinimum(), j.TapisJoueur);
                }

                // Tapis
                actions[TypeActionJoueur.Tapis] = new ActionPossible(TypeActionJoueur.Tapis, j.TapisJoueur, j.TapisJoueur);
            }

            return(actions);
        }
Esempio n. 7
0
 public ActionPossible Execute(MakeMeTeaCommand command)
 {
     return(ActionPossible.True());
 }
 public ActionPossible Execute(GetMeSomethingValidAsyncQuery query)
 {
     return(ActionPossible.True());
 }
Esempio n. 9
0
 public ActionPossible Execute(MakeMeCoffeCommand command)
 {
     return(ActionPossible.Unauthorized());
 }
 public ActionPossible Execute(GetMeSomethingInvalidQuery query)
 {
     return(ActionPossible.False("I cannot perform this action"));
 }
Esempio n. 11
0
 public ActionPossible Execute(GetMeSomethingInvalidAsyncQuery query)
 {
     return(ActionPossible.Unauthorized());
 }