Beispiel #1
0
        /// <summary>
        /// Vraag de speler of hij een ander rondje wil doen.
        /// </summary>
        /// <param name="stopDeSpel">true als ja . false als nee.</param>
        /// <param name="huidigeBord">huidigeBord.</param>
        /// <param name="vraagEenRondje">True of false. Wil je nog een rondje.</param>
        /// <param name="speler">De speler.</param>
        /// <param name="spelers">De spelers.</param>
        public void VraagNieuwRond(ref bool stopDeSpel, Bord huidigeBord, ref bool vraagEenRondje, Speler speler, IList <Speler> spelers)
        {
            Console.WriteLine("Wil je nog een rondje , J of N?");
            string nieuwRondjes = Console.ReadLine();

            nieuwRondjes.ToLower();
            while ((nieuwRondjes != "j") && (nieuwRondjes != "n"))
            {
                Console.WriteLine("Geef J of N !");
                nieuwRondjes = Console.ReadLine();
            }

            if (nieuwRondjes == "j")
            {
                stopDeSpel = false;
                huidigeBord.ResetBord();
                this.spel.NeiuwRondje(huidigeBord, spelers);
            }
            else
            {
                stopDeSpel     = true;
                vraagEenRondje = false;
                this.DeWinner(speler, spelers);
            }
        }
Beispiel #2
0
        /// <summary>
        /// Zet een teken op het bord.
        /// </summary>
        /// <param name="bord">Bord.</param>
        /// <param name="spelers">Spelers.</param>
        public void Zet(Bord bord, IList <Speler> spelers)
        {
            short indexOpHetBord = 0;

            // is de zet valid?
            do
            {
                indexOpHetBord = this.BepaalZet(bord, spelers);
            }while (!bord.IsValidZet(indexOpHetBord));

            bord.DoeZet(this, indexOpHetBord);
        }
Beispiel #3
0
        /// <summary>
        /// Dit start het spel.
        /// </summary>
        /// <param name="dimension">Het formaat van het bord.</param>
        /// <returns>Het getekende bord.</returns>
        public Bord Start(short dimension)
        {
            // maak een bord, met de jusite dimension.
            // hoe bepaal je wie mag beginnen?
            this.huidigeBord = new Bord(dimension, this);

            // wie begint?
            this.huidigeBord.TekenBord();
            Speler huidigeSpeler = this.spelers[this.wieStart];

            this.WieIsSpeler(huidigeSpeler);
            while (!this.stopDeSpel || this.huidigeBord.HeeftTekenGewonnen(huidigeSpeler.TeGebruikenTeken))
            {
                List <short> vrijVelden = this.huidigeBord.VrijVelden();

                // teken het bord
                // vraag aan speler 1 wat hij wil doen
                huidigeSpeler.Zet(this.huidigeBord, this.spelers);
                this.huidigeBord.TekenBord();
                if (this.huidigeBord.HeeftTekenGewonnen(huidigeSpeler.TeGebruikenTeken))
                {
                    huidigeSpeler.UHeeftGewonnen();

                    // todo, vertel de andere speler dat hij heeft verloren.
                    this.TegenSpeler(huidigeSpeler, this.spelers).UHeeftVerloren(huidigeSpeler);

                    huidigeSpeler.BeeindigBord(this.huidigeBord);
                    huidigeSpeler.UkrijgtEenPunt(huidigeSpeler);

                    if (!this.huidigeBord.IsBordFinished())
                    {
                        this.VraagNieuwRondje(huidigeSpeler);
                    }
                }

                if (this.huidigeBord.IsBordFinished())
                {
                    this.stopDeSpel = true;
                    huidigeSpeler.HetBoordIsVol();
                    this.VraagNieuwRondje(huidigeSpeler);
                }

                huidigeSpeler = this.TegenSpeler(huidigeSpeler, this.spelers);
            }

            if (this.vraagEenRondje)
            {
                this.VraagNieuwRondje(huidigeSpeler);
            }

            return(this.huidigeBord);
        }
Beispiel #4
0
        /// <summary>
        /// Dit start het spel.
        /// </summary>
        /// <param name="dimension">Het formaat van het bord.</param>
        /// <returns>Het getekende bord.</returns>
        public Bord Start(short dimension)
        {
            // maak een bord, met de jusite dimension
            // hoe bepaal je wie mag beginnen?
            this._huidigeBord = new Bord(dimension, this);
            Teken teken = new Teken();

            // wie begint?
            this._huidigeBord.TekenBord();
            this.WieStart();
            Speler huidigeSpeler = this._spelers[this.wieStart];

            while (!this.stopDeSpel)
            {
                List <short> vrijVelden = this._huidigeBord.VrijVelden();

                // teken het bord
                // vraag aan speler 1 wat hij wil doen
                Console.WriteLine();
                huidigeSpeler.Zet(this._huidigeBord);
                this._huidigeBord.TekenBord();
                if (this._huidigeBord.HeeftTekenGewonnen(huidigeSpeler.TeGebruikenTeken))
                {
                    Console.WriteLine();
                    Console.WriteLine(huidigeSpeler.Naam + " : Hoeraaaa " + huidigeSpeler.Naam + " je bent gewonnen !!!!");
                    Console.WriteLine();
                    huidigeSpeler.BeeindigBord(this._huidigeBord);
                    Console.WriteLine(huidigeSpeler.Naam + " Je hebt : " + huidigeSpeler.Punten + " Punt !!");
                    this.VraagNieuwRondje(huidigeSpeler);
                }

                if (this._huidigeBord.IsBordFinished())
                {
                    this.stopDeSpel = true;
                    Console.WriteLine("Het boord is vol !!!");
                }

                huidigeSpeler = this.TegenSpeler(huidigeSpeler);
            }

            if (this.vraagEenRondje)
            {
                this.VraagNieuwRondje(huidigeSpeler);
            }

            return(this._huidigeBord);
        }
Beispiel #5
0
        /// <summary>
        /// bepaal een vrij vak en kies dat.
        /// Kun je winnen? bepalen.
        /// </summary>
        /// <param name="bord">het bord waarp gespeeld wordt. </param>
        /// <param name="spelers">De spelers.</param>
        /// <returns>index van het veld op het bord. </returns>
        public override short BepaalZet(Bord bord, IList <Speler> spelers)
        {
            // todo
            // welke vakjes zijn nog leeg?
            // vragen aan bord om aan te geven wat leeg is
            // loop door de lege velden.
            List <short> vrijeVelden = bord.VrijVelden();

            foreach (short index in vrijeVelden)
            {
                bord.DoeZet(this, index);

                // als ik mijn teken daar invul, win ik dan.
                // of wint de tegenstander dan?
                if (bord.HeeftTekenGewonnen(this.TeGebruikenTeken))
                {
                    bord.ResetVeld(index);
                    return(index);
                }
                else
                {
                    Spel spel = new Spel();

                    // ik heb niet gewonnen, reset het veld en laat de tegespeler de zet doen
                    Speler tegenSpeler = bord.TegenSpeler(this, spelers);

                    bord.DoeZet(tegenSpeler, index);
                    if (bord.HeeftTekenGewonnen(tegenSpeler.TeGebruikenTeken))
                    {
                        // tegenstander heeft gewonnen
                        bord.ResetVeld(index);
                        return(index);
                    }
                }

                // altijd weer het bord resetten
                bord.ResetVeld(index);
            }

            // als ik hier kom,
            return(vrijeVelden[0]);
        }
Beispiel #6
0
        /// <summary>
        /// vraag aan de speler welke zet hij wil doen.
        /// </summary>
        /// <param name="bord">het bord waarp gespeeld wordt</param>
        /// <returns>index van het veld op het bord</returns>
        public override short BepaalZet(Bord bord)
        {
            // vraag aan de gebruiker wat hij/zij wil doen?
            Console.WriteLine("Welke zet wil je doen ?");
            short        spelerKeuze = 0;
            List <short> vrijeVelden = bord.VrijVelden();

            do
            {
                Console.Write("Kies een nummer ");

                foreach (short vrijVeld in vrijeVelden)
                {
                    Console.Write(vrijVeld.ToString() + ", ");
                }

                Console.WriteLine();
                string splelerKiest = Console.ReadLine();
                if (short.TryParse(splelerKiest, out spelerKeuze))
                {
                    spelerKeuze = short.Parse(splelerKiest);
                }
                else
                {
                    while (!short.TryParse(splelerKiest, out spelerKeuze))
                    {
                        Console.WriteLine("U hebt geen nummer ingevoerd");
                        splelerKiest = Console.ReadLine();
                        short.TryParse(splelerKiest, out spelerKeuze);
                    }
                }
            }while (vrijeVelden.IndexOf(spelerKeuze) < 0);
            int GebruikerNummer = spelerKeuze;

            return((short)GebruikerNummer);
        }
Beispiel #7
0
 /// <summary>
 /// Vraag de speler voor niuew rondje.
 /// </summary>
 /// <param name="huidigeBord">huidigeBord.</param>
 /// <param name="spelers">De spelers.</param>
 public void NeiuwRondje(Bord huidigeBord, IList<Speler> spelers)
 {
     this.spelers = spelers;
     this.Start(huidigeBord.Dimension);
 }
Beispiel #8
0
 /// <summary>
 /// Dit method geef een punt aan de winnaar.
 /// </summary>
 /// <param name="bord">Het boord.</param>
 public void BeeindigBord(Bord bord)
 {
     // ben ik winnaar?
     // ja geef me dan een punt
     this.Punten++;
 }
Beispiel #9
0
 /// <summary>
 /// functie om te bepalen welke set de gebruiker wil doen.
 /// </summary>
 /// <param name="bord">het bord waarmee gespeeld wordt. </param>
 /// <param name="spelers">Spelers.</param>
 /// <returns>de index van het vakje op het bord. </returns>
 public abstract short BepaalZet(Bord bord, IList <Speler> spelers);
Beispiel #10
0
        /// <summary>
        /// bepaal een vrij vak en kies dat.
        /// Kun je winnen? bepalen.
        /// </summary>
        /// <param name="bord">het bord waarp gespeeld wordt. </param>
        /// <returns>index van het veld op het bord. </returns>
        public override short BepaalZet(Bord bord)
        {
            // todo
            // welke vakjes zijn nog leeg?
            // vragen aan bord om aan te geven wat leeg is
            // loop door de lege velden.
            List <short> vrijeVelden = bord.VrijVelden();

            foreach (short index in vrijeVelden)
            {
                bord.DoeZet(this, index);

                // als ik mijn teken daar invul, win ik dan.
                // of wint de tegenstander dan?
                if (bord.HeeftTekenGewonnen(this.TeGebruikenTeken))
                {
                    bord.ResetVeld(index);
                    return(index);
                }
                else
                {
                    // ik heb niet gewonnen, reset het veld en laat de tegespeler de zet doen
                    Speler tegenSpeler = bord.TegenSpeler(this);

                    bord.DoeZet(tegenSpeler, index);
                    if (bord.HeeftTekenGewonnen(tegenSpeler.TeGebruikenTeken))
                    {
                        // tegenstander heeft gewonnen
                        bord.ResetVeld(index);
                        return(index);
                    }
                }

                // altijd weer het bord resetten
                bord.ResetVeld(index);
            }

            // als ik hier kom,
            return(vrijeVelden[0]);

            // is er een volgende zet
            // ja, probeer die dan
            // nee,
            //  loop dan weer door de mogelijke zetten heen
            // nee, is er dan een volgende
            // ja, kijk daar dan mee
            // nee
            // dan kies ik de eerste uit de mogelijke zetten

            // kan ik winnen?
            // ja, dan dat vakje kiezen
            // nee
            // kan de tegenstander winnen?
            // ja
            // dan dat vakje kiezen
            // anders kies de eerste
            Random random        = new Random();
            int    bepaalHetBord = bord.Dimension * bord.Dimension;
            int    result        = random.Next(0, bepaalHetBord);

            short i = (short)result;

            return(i);
        }
Beispiel #11
0
 /// <summary>
 /// functie om te bepalen welke set de gebruiker wil doen.
 /// </summary>
 /// <param name="bord">het bord waarmee gespeeld wordt. </param>
 /// <returns>de index van het vakje op het bord. </returns>
 public abstract short BepaalZet(Bord bord);