예제 #1
0
        /// <summary>
        /// Vrací všechny platné tahy pro zadanou pozici a pro zadaného hráče.
        /// </summary>
        public static List<Tah> VratPlatneTahy(Pozice pole, Manazer.StavPole hrac, HraciDeska hraciDeska)
        {
            if(hraciDeska.Hrac(pole) == hrac)
                return VratPlatneTahy(pole.Radek, pole.Sloupec, hrac, hraciDeska);

            return new List<Tah>();
        }
예제 #2
0
 /*public static Tah VratNejlepsiTah(HraciDeska hraciDeska, Manazer.StavPole hrac, int hloubka)
 {
     GenerujVsechnyTahy(hraciDeska, hrac, hloubka, true);
     return vyslednyTah;
 }*/
 public static void NejlepsiTah(HraciDeska hraciDeska, Manazer.StavPole hrac, int hloubka)
 {
     vlakno = new Thread(() => { GenerujVsechnyTahy(hraciDeska, hrac, hloubka, true);
     AkcePoNalezeniTahu(vyslednyTah);
     });
     vlakno.Start();
 }
예제 #3
0
 /// <summary>
 /// Zjistíme, jestli je daný tah validní.
 /// </summary>
 public static bool ValidniTah(int radekKam, int sloupecKam, int radekOdkud, int sloupecOdkud,
     Manazer.StavPole hrac, HraciDeska hraciDeska)
 {
     return DoBoku(radekKam, sloupecKam, radekOdkud, sloupecOdkud) ||
         Dopredu(radekKam, sloupecKam, radekOdkud, sloupecOdkud, hrac) ||
         Diagonalne(radekKam, sloupecKam, radekOdkud, sloupecOdkud, hrac) ||
         Skok(radekKam, sloupecKam, radekOdkud, sloupecOdkud, hrac, hraciDeska);
 }
예제 #4
0
        /// <summary>
        /// Ohodonotí danou pozici na hrací desce z pohledu útočníka.
        /// Tedy čím více bodů, tím lépe pro útočníka (a naopak pro obránce).
        /// </summary>
        /// <returns>Ohodnocení pozice vyjádřené v celých bodech (int).</returns>
        public static int Ohodnot(HraciDeska hraciDeska)
        {
            int stupen;
            Random rand = new Random();

            // Za každého živého útočníku +100 bodů
            stupen = hraciDeska.PocetUtocniku() * 100;

            int PocetUtocnikuVPevnosti = 0;

            for(int i = 0; i < hraciDeska.rozmer; i++)
            {
                for(int j = 0; j < hraciDeska.rozmer; j++)
                {
                    if(hraciDeska.Hrac(i, j) == Manazer.StavPole.utok)
                    {

                        if(HraciDeska.Pevnost(i, j))
                        {
                            // Pokud jsou všichni útočníci v pevnosti, jistě je to nejlepší tah
                            if (++PocetUtocnikuVPevnosti == 9)
                            {
                                return Int16.MaxValue;
                            }

                            // Za každého panáčka v horním řádku pevnosti +65 bodů
                            if(i == 0)
                                stupen += 65;

                            // Za každého panáčka na levém či pravém boku pevnosti +55 bodů
                            if((j == 2 || j == 4) && (i != 2))
                                stupen += 55;

                            // Za každého panáčka v penosti +20 bodů
                            stupen += 35;
                        }

                        // Za každý pohyb o pole dopředu +10 bodů
                        stupen += ((7 - i) * 10);

                        // Přidáme náhodné číslo od 0 do 9, aby počítač netáhl vždy stejně
                        stupen += rand.Next(10);
                    }
                    else if(hraciDeska.Hrac(i, j) == Manazer.StavPole.obrana)
                    {
                        // Čím dál je obránce od pevnosti, tím lépe
                        stupen += 25 * i;
                    }
                }
            }

            return stupen;
        }
예제 #5
0
        /// <summary>
        /// Zkopíruje hrací desku.
        /// </summary>
        /// <returns>Kopie desky.</returns>
        public HraciDeska Copy()
        {
            HraciDeska novaDeska = new HraciDeska();

            for(int i = 0; i < rozmer; i++)
                for(int j = 0; j < rozmer; j++)
                    novaDeska.deska[i, j] = deska[i, j];

            novaDeska.aktualniTah = aktualniTah;

            return novaDeska;
        }
예제 #6
0
        /// <summary>
        /// Vrací všechny platné tahy pro zadanou pozici a pro zadaného hráče.
        /// </summary>
        public static List<Tah> VratPlatneTahy(int radekOdkud, int sloupecOdkud, 
            Manazer.StavPole hrac, HraciDeska hraciDeska)
        {
            List<Tah> platneTahy = new List<Tah>();

            if(hraciDeska.Hrac(radekOdkud, sloupecOdkud) == hrac)
            {
                for(int i = 0; i < hraciDeska.rozmer; i++)
                {
                    for(int j = 0; j < hraciDeska.rozmer; j++)
                    {
                        if(ValidniTah(i, j, radekOdkud, sloupecOdkud, hrac, hraciDeska) &&
                            hraciDeska.MuzemeTahnout(i, j))
                        {
                            Tah tah = new Tah(new Pozice(radekOdkud, sloupecOdkud), new Pozice(i, j));

                            platneTahy.Add(tah);
                        }
                    }
                }
            }

            return platneTahy;
        }
예제 #7
0
        /// <summary>
        /// Zjišťuje, zda již někdo nevyhrál. Vrací buď hráče, který vyhrál nebo vrací Hraci.mimo.
        /// </summary>
        public static Manazer.MoznostiVyher KdoVyhral(HraciDeska hraciDeska)
        {
            if (hraciDeska.PocetUtocniku() < 9)
            {
                return Manazer.MoznostiVyher.obrana;
            }

            if (hraciDeska.ObsazenaPevnost())
            {
                return Manazer.MoznostiVyher.utok;
            }

            if(ZablokovanyHrac(Manazer.StavPole.obrana, hraciDeska))
            {
                return Manazer.MoznostiVyher.utok;
            }

            if(ZablokovanyHrac(Manazer.StavPole.utok, hraciDeska))
            {
                return Manazer.MoznostiVyher.obrana;
            }

            return Manazer.MoznostiVyher.nikdo;
        }
예제 #8
0
        /// <summary>
        /// Vygeneruje všechny možné situace hry do zadané hloubky a následně do
        /// slotu "vyslednyTah" uloží nejlepší pozici.
        /// </summary>
        private static int GenerujVsechnyTahy(HraciDeska hraciDeska, Manazer.StavPole hrac, 
            int hloubka, bool prvniFunkce)
        {
            if(hloubka == 0)
                return Ohodnoceni.Ohodnot(hraciDeska);

            List<List<Tah>> validniTahy = Rozhodci.VratVsechnyPlatneTahy(hrac, hraciDeska);
            List<int> ohodnoceni = new List<int>();
            Manazer.StavPole dalsiHrac;

            if(hrac == Manazer.StavPole.obrana)
                dalsiHrac = Manazer.StavPole.utok;
            else
                dalsiHrac = Manazer.StavPole.obrana;

            for(int i = 0; i < validniTahy.Count; i++)
            {
                for(int j = 0; j < validniTahy[i].Count; j++)
                {
                    HraciDeska novaDeska = hraciDeska.Copy();
                    // HraciDeska novaDeska = (HraciDeska) hraciDeska.Clone();
                    novaDeska.Tahni(validniTahy[i][j]);
                    novaDeska.OdstranPreskoceneKameny(validniTahy[i][j]);
                    ohodnoceni.Add(GenerujVsechnyTahy(novaDeska, dalsiHrac, hloubka - 1, false));
                }
            }

            int pomoc;

            if(hrac == Manazer.StavPole.utok)
            {
                pomoc = Int32.MinValue;
            }
            else
            {
                pomoc = Int32.MaxValue;
            }

            foreach(int cislo in ohodnoceni)
            {
                if(hrac == Manazer.StavPole.utok)
                {
                    if(cislo > pomoc)
                        pomoc = cislo;
                }
                else
                {
                    if(cislo < pomoc)
                        pomoc = cislo;
                }
            }

            if(prvniFunkce)
            {
                int index = ohodnoceni.IndexOf(pomoc);
                int i, j, citac;

                citac = 0;

                for(i = 0; i < validniTahy.Count; i++)
                {
                    for(j = 0; j < validniTahy[i].Count; j++)
                    {
                        if(citac++ == index)
                            vyslednyTah = validniTahy[i][j];
                    }
                }

                return 0;
            }

            return pomoc;
        }
예제 #9
0
 public Schranka(Manazer ManazerHry, HraciDeska AktualniHraciDeska)
 {
     this.AktualniHraciDeska = AktualniHraciDeska;
     this.ManazerHry = ManazerHry;
 }
예제 #10
0
        /// <summary>
        /// Vrací všechny platné tahy daného hráče v tomto kole
        /// </summary>
        public static List<List<Tah>> VratVsechnyPlatneTahy(Manazer.StavPole hrac, HraciDeska hraciDeska)
        {
            List<List<Tah>> vsechnyPlatneTahy = new List<List<Tah>>();

            for(int i = 0; i < hraciDeska.rozmer; i++)
                for(int j = 0; j < hraciDeska.rozmer; j++)
                {
                    // Zjistíme všechny platné tahy z dané pozice...
                    List<Tah> tahy = VratPlatneTahy(i, j, hrac, hraciDeska);

                    // ...a pokud z této pozice můžeme alespoň někam táhnout, uložíme si tah
                    if(tahy.Count > 0)
                        vsechnyPlatneTahy.Add(tahy);
                }

            // Pokud obránce může skákat, zahodíme obyčejné tahy a zjistíme,
            // jestli nemůže obránce skákat ještě dál (vícenásobný skok).
            if(MuzeObranceSkakat(vsechnyPlatneTahy))
            {
                List<Pozice> poziceObrancu = hraciDeska.VratPoziceObrancu();

                vsechnyPlatneTahy = OdstranObycejneTahy(vsechnyPlatneTahy);

                // Skoky prvního obránce
                Skoky skoky = VsechnySkoky(poziceObrancu[0], hraciDeska);

                // Skoky druhého obránce
                Skoky skoky2 = VsechnySkoky(poziceObrancu[1], hraciDeska);

                vsechnyPlatneTahy.Clear();

                // serializujeme skoky do listů
                List<Tah> platneTahy1 = Serializace(skoky);
                List<Tah> platneTahy2 = Serializace(skoky2);

                // Pokud může obránce alespoň jednou skočit, uložíme si skok
                if(platneTahy1.Count != 0)
                    vsechnyPlatneTahy.Add(platneTahy1);

                if(platneTahy2.Count != 0)
                    vsechnyPlatneTahy.Add(platneTahy2);
            }

            return vsechnyPlatneTahy;
        }
예제 #11
0
        /// <summary>
        /// Zablokovali jsme obránce?
        /// </summary>
        private static bool ZablokovanyObrance(HraciDeska hraciDeska)
        {
            List<Pozice> obranci;

            // obranci = hraciDeska.VratPoziceObrancu();
            obranci = hraciDeska.VratPoziceHrace(Manazer.StavPole.obrana);

            foreach(Pozice pole in obranci)
                if((VratPlatneTahy(pole, Manazer.StavPole.obrana, hraciDeska)).Count > 0)
                    return false;

            return true;
        }
예제 #12
0
        /// <summary>
        /// Zablokovali jsme na hrací desce daného hráče?
        /// </summary>
        private static bool ZablokovanyHrac(Manazer.StavPole barvaHrace, HraciDeska hraciDeska)
        {
            List<Pozice> hraci;

            hraci = hraciDeska.VratPoziceHrace(barvaHrace);

            foreach(Pozice pole in hraci)
                if((VratPlatneTahy(pole, barvaHrace, hraciDeska)).Count > 0)
                    return false;

            return true;
        }
예제 #13
0
        /// <summary>
        /// Vrací všechny (i násobné) skoky jednoho obránce.
        /// </summary>
        private static Skoky VsechnySkoky(Pozice souradniceObrance, HraciDeska hraciDeska)
        {
            List<Tah> obrancovySkoky;

            Skoky skok = new Skoky();
            skok.odkud = souradniceObrance;
            skok.skoky = null;

            obrancovySkoky = KamMuzeObranceSkocit(souradniceObrance, hraciDeska);

            if(obrancovySkoky.Count != 0)
            {
                skok.skoky = new List<Skoky>();

                foreach(Tah tah in obrancovySkoky)
                {
                    HraciDeska novaHraciDeska;
                    novaHraciDeska = hraciDeska.Copy();
                    // novaHraciDeska = (HraciDeska) hraciDeska.Clone();
                    novaHraciDeska.Tahni(tah);
                    novaHraciDeska.OdstranPreskoceneKameny(tah);

                    Skoky novySkok = new Skoky(tah.seznamTahu[1], null);
                    novySkok.deska = novaHraciDeska;
                    skok.skoky.Add(novySkok);
                }

                HelpSkoky(skok);
            }

            return skok;
        }
예제 #14
0
        /// <summary>
        /// Skáče obránce horizontálně nebo vertikálně nebo diagonálně?
        /// </summary>
        private static bool Skok(int radekKam, int sloupecKam, int radekOdkud, int sloupecOdkud,
            Manazer.StavPole hrac, HraciDeska hraciDeska)
        {
            if(hrac == Manazer.StavPole.obrana)
            {
                Manazer.StavPole hracNaPozici;
                int rozdilRadku = Math.Abs(radekKam - radekOdkud);
                int rozdilSloupcu = Math.Abs(sloupecKam - sloupecOdkud);

                // Obecný skok
                if((sloupecKam == sloupecOdkud && rozdilRadku == 2) ||
                    (radekKam == radekOdkud && rozdilSloupcu == 2) ||
                    (rozdilRadku == rozdilSloupcu && rozdilSloupcu == 2))
                {
                    int preskokRadek = (radekOdkud + radekKam) / 2;
                    int preskokSloupec = (sloupecKam + sloupecOdkud) / 2;

                    // Skáče obránce přes roh hrací desky?
                    if((rozdilRadku == rozdilSloupcu && rozdilSloupcu == 2) &&
                        (((preskokRadek == 2) && (preskokSloupec == 1 || preskokSloupec == 5)) ||
                        ((preskokRadek == 4) && (preskokSloupec == 1 || preskokSloupec == 5)) ||
                        ((preskokRadek == 1) && (preskokSloupec == 2 || preskokSloupec == 4)) ||
                        ((preskokRadek == 5) && (preskokSloupec == 2 || preskokSloupec == 4))))
                        return false;

                    hracNaPozici = hraciDeska.Hrac(preskokRadek, preskokSloupec);

                    if(hracNaPozici == Manazer.StavPole.utok)
                    {
                        return true;
                    }
                }
            }

            return false;
        }
예제 #15
0
        /// <summary>
        /// Vrací všechny skoky jedné úrovně jednoho obránce.
        /// </summary>
        private static List<Tah> KamMuzeObranceSkocit(Pozice souradniceObrance, HraciDeska hraciDeska)
        {
            List<Tah> tahy;

            tahy = VratPlatneTahy(souradniceObrance, Manazer.StavPole.obrana, hraciDeska);
            tahy = OdstranObycejneTahy(tahy);

            return tahy;
        }
예제 #16
0
        /// <summary>
        /// Prostě restartuje hru.
        /// </summary>
        public void Restart()
        {
            Deska = new HraciDeska();
            NastaveniObranci = false;
            hracNaTahu = Manazer.StavPole.obrana;
            Deska.Restart();
            this.KonecHry = false;
            PocetTahu = 0;
            Vitez = MoznostiVyher.nikdo;

            TahyZpet = new Stack<Tah>();
            TahyVpred = new Stack<Tah>();

            if(Obrance.umelaInteligence)
            {
                NastavObrance();
            }
        }