/// <summary>
        /// Als de hand Black Jack dan change de status van de hand en close de hand.
        /// </summary>
        /// <param name="hand">De hand die Balck Jack wordt.</param>
        private void HandelBlackJack(SpelerHand hand)
        {
            hand.ChangeStatus(HandStatussen.BlackJeck);

            // this.BetaalHand(hand);
        }
 /// <summary>
 /// Neem de fiches van de hand uit.
 /// </summary>
 /// <param name="hand">De hand.</param>
 private void VerzameelDeFiches(SpelerHand hand)
 {
     this.TellToPlayers(this.tafel.Spelers, Meldingen.Verliezen, hand, string.Empty);
     this.tafel.Fiches.Add(hand.Inzet.GeefMeFischesTerWaardeVan(hand.Inzet.WaardeVanDeFiches, 50, true));
 }
 /// <summary>
 /// Vermenigvuldig de waarde van de fisches in de hand met de factor.
 /// </summary>
 /// <param name="hand">Huidige hand.</param>
 /// <param name="factor">De factor die wordt betaald.</param>
 private void BetaalUit(SpelerHand hand, double factor)
 {
     // todo, ik wil hier naar afronden in het voordeel van de speler
     this.FichesVerdienen(hand, factor);
 }
        /// <summary>
        /// De eerste processen van het spel voor dat het spel start.
        /// Vraag de speler om fiches bij de hand te inzetten.
        /// Geef elke hand eerste kaart.Ook geeft allen de spelers tweede kaart.
        /// Dus de dealer krijgt een kaart.
        /// </summary>
        private bool Beginnen()
        {
            foreach (Speler speler in this.tafel.Spelers)
            {
                int waardeVanDeInzetten = 0;

                // todo, loopje
                while (speler.Fiches.WaardeVanDeFiches < speler.HuidigeTafel.MinimalenZet)
                {
                    this.communicator.TellPlayer(speler, Meldingen.VoorwaardenTafelFiches);
                    if (!this.FichesKopen(speler))
                    {
                        // Wil niet mee doen.
                        // de speler wil niet inzetten en doet dus niet mee
                        this.communicator.TellPlayer(speler, Meldingen.GeenFiches);
                        if (this.AskNieuwRondje(this.tafel.Spelers))
                        {
                            this.StartRonde();
                            return(false);
                        }
                        else
                        {
                            this.communicator.TellPlayer(speler, Meldingen.Gestopt);
                            this.communicator.SleuitHetSpel();
                            return(false);
                        }
                    }
                }

                // Vraag om te inzetten.
                foreach (Hand hand in this.spel.Handen)
                {
                    if (!hand.IsDealerHand)
                    {
                        this.spelerHand = hand as SpelerHand;
                        bool magInzetten = true;
                        if (this.spelerHand.Speler == speler)
                        {
                            while (!this.VraagAanSpelerInzetVoorEenHand(this.spelerHand, out waardeVanDeInzetten))
                            {
                                magInzetten = false;
                                break;
                            }

                            // als mag inzetten, dan laat de speler inzetten.
                            if (magInzetten)
                            {
                                this.spelerHand.Inzet.Add(this.spelerHand.Speler.Fiches.GeefMeFischesTerWaardeVan(waardeVanDeInzetten, 50, true));
                                this.communicator.TellHand(this.spelerHand, Meldingen.ToonInzet, string.Empty);
                            }
                            else
                            {
                                // Wil niet mee doen.
                                // de speler wil niet inzetten en doet dus niet mee
                                this.communicator.TellPlayer(speler, Meldingen.GeenFiches);
                                if (this.AskNieuwRondje(this.tafel.Spelers))
                                {
                                    this.StartRonde();
                                    return(false);
                                }
                                else
                                {
                                    this.communicator.TellPlayer(speler, Meldingen.Gestopt);
                                    this.communicator.SleuitHetSpel();
                                    return(false);
                                }
                            }
                        }
                    }
                }
            }

            // geef elke hand een kaart
            foreach (Hand hand in this.spel.Handen)
            {
                Kaart kaart = this.tafel.StapelKaarten.NeemEenKaart();
                if (kaart != null)
                {
                    hand.AddKaart(kaart);
                    if (!hand.IsDealerHand)
                    {
                        this.communicator.TellHand(hand, Meldingen.KaartenVanDeHand, string.Empty);
                    }

                    // this.TellToPlayers(this.spel.Spelers, Meldingen.KaartenVanDeHand, hand, string.Empty);
                }
                else
                {
                    // Als er geen kaarten in de stapel kaarten staan.
                    this.tafel.StapelKaarten = StapelKaartenFactory.CreateBlackJackKaarten(2);
                }
            }

            // geef elke hand een kaart, behalve de dealer
            foreach (Hand hand in this.spel.Handen)
            {
                if (!hand.IsDealerHand)
                {
                    Kaart kaart = this.tafel.StapelKaarten.NeemEenKaart();
                    if (kaart != null)
                    {
                        hand.AddKaart(kaart);
                    }
                    else
                    {
                        // Als er geen kaarten in de stapel kaarten staan.
                        this.tafel.StapelKaarten = StapelKaartenFactory.CreateBlackJackKaarten(2);
                    }
                }

                if (!hand.IsDealerHand)
                {
                    SpelerHand spelerhand = hand as SpelerHand;

                    // Dan laat de andere spelers weten wat is gebeurt.
                    //  this.TellToPlayers(this.spel.Spelers, Meldingen.KaartenVanDeHand, spelerhand, string.Empty);
                }
            }

            return(true);
        }
        /// <summary>
        /// Start een rondje.
        /// </summary>
        private void StartRonde()
        {
            if (this.tafel.Plekken == null)
            {
                throw new ArgumentNullException("Er zijn geen plekken met spelers.");
            }

            this.spel.ResetHanden();

            if (this.Beginnen())
            {
                while (this.spel.GaNaarDeVolgendeSpeelbareHand() != null)
                {
                    Hand spelerHand = this.spel.HuidigeHand;
                    this.spelerHand = spelerHand as SpelerHand;

                    if (spelerHand.Status != HandStatussen.BlackJeck && spelerHand.Status != HandStatussen.IsDood)
                    {
                        List <Acties> mogelijkActies = this.ControleerHand(spelerHand);
                        if (!spelerHand.IsDealerHand)
                        {
                            // Check of de speler Black jack.
                            if (this.IsBlackJack(spelerHand))
                            {
                                this.HandelBlackJack(this.spelerHand);
                                this.communicator.TellHand(spelerHand, Meldingen.KaartenVanDeHand, string.Empty);
                                this.communicator.TellHand(spelerHand, Meldingen.BlackJack, string.Empty);

                                // this.TellToPlayers(this.tafel.Spelers, Meldingen.BlackJack, spelerHand, string.Empty);
                            }

                            if (mogelijkActies.Count == 0)
                            {
                                // dan kan ik niks en ga ik naar de volgende hand. Bijv, omdat de hand is gesloten.
                                this.communicator.TellHand(this.spelerHand, Meldingen.GeenActie, string.Empty);
                                continue;
                            }

                            while ((mogelijkActies.Count > 0 && spelerHand.Status == HandStatussen.InSpel) ||
                                   spelerHand.Status == HandStatussen.Verdubbelen ||
                                   spelerHand.Status == HandStatussen.Gesplitst ||
                                   spelerHand.Status == HandStatussen.Gekochtocht)
                            {
                                if (mogelijkActies.Count == 1)
                                {
                                    this.ProcessActie(this.spelerHand, mogelijkActies[0]);
                                }
                                else
                                {
                                    // er zijn meerdere acties mogelijk, vraag aan de speler wat hij/zij wil.
                                    Acties gekozenActie = this.AskActie(mogelijkActies, this.spelerHand);
                                    if (this.ProcessActie(this.spelerHand, gekozenActie))
                                    {
                                        // Zoek de acties.
                                        mogelijkActies = this.ControleerHand(spelerHand);
                                    }
                                    else
                                    {
                                        // Als de speler mag de actie niet doen dan verwijdert dit actie.
                                        mogelijkActies.Remove(gekozenActie);
                                    }
                                }
                            }
                        }
                        else
                        {
                            if (this.MagDealerBehandelen())
                            {
                                // start behandelen met de dealer.
                                this.dealerHand = spelerHand as DealerHand;
                                this.BehandelDeDealer(this.dealerHand);
                            }
                            else
                            {
                                break;
                            }
                        }
                    }
                }

                this.BeeindHetSpel(this.spel.Handen);

                if (this.AskNieuwRondje(this.tafel.Spelers))
                {
                    this.StartRonde();
                }
                else
                {
                    // this.communicator.TellPlayer(this.spelerHand.Speler, Meldingen.ToonFichesInPortemonnee);
                    this.communicator.SleuitHetSpel();
                }
            }
        }
Beispiel #6
0
 /// <summary>
 /// Verdubbel de hand.
 /// </summary>
 /// <param name="hand">De hand die verdubbelt wordt.</param>
 /// <param name="stapelKaarten">De stapel kaarten van het spel.</param>
 /// <returns>Heeft de speler het verdubbelt of niet.</returns>
 public bool Verdubbelen(SpelerHand hand, StapelKaarten stapelKaarten)
 {
     // is eigenlijk Kopen
     return(this.Kopen(hand, stapelKaarten));
 }