Ejemplo n.º 1
0
        // pomoci deskaCopy zkousim pozdeji legalnost mych tahu:
        public Deska ZkusZahratTah(Tah tah)
        {
            List <Pozice> seznamPozic = tah.GetSeznamPozic;
            Pozice        odkud       = null;
            Deska         deskaCopy   = cloneDJ();

            if (seznamPozic.Count() == 2)
            {
                Pozice kam;
                odkud = seznamPozic[0];
                if (deskaCopy.ProvedPosunKamene(odkud, kam = seznamPozic[1], tah))
                {
                    return(deskaCopy);
                }
                return(null);
            }

            foreach (Pozice kam in seznamPozic)
            {
                if (odkud != null && !deskaCopy.JePosunPreskokemKameneProtihrace(odkud, kam))
                {
                    return(null);
                }
                if (odkud != null)
                {
                    deskaCopy.ProvedPosunKamene(odkud, kam, tah);
                }
                odkud = kam;
            }
            return(deskaCopy);
        }
Ejemplo n.º 2
0
 // Test na Legalni posun figurkou a zaroven Posun Bez preskoku:
 public bool JdeOLegalniPosunBezPreskoku(Pozice odkud, Pozice kam)
 {
     return(!JePolePrazdne(odkud) && JePolePrazdne(kam) &&                               // pole odkud neni prazdne a pole kam je prazdne a  zaroven musi byt splnena jedna z podminek:
            (RozdilPozicVyska(odkud, kam, true) == RozdilPozicSirka(odkud, kam, true) || // 1. absolutni rozdil vysek, sirek je stejny (Diagonalni posun)
             RozdilPozicVyska(odkud, kam, true) == 0 ||                                  // 2. rozdil vysek je 0, cili vodorovny posun
             RozdilPozicSirka(odkud, kam, true) == 0) &&                                 // 3. rozdil sirek je 0, cili svisly posun
            JsouPoleMeziPosunemPrazdne(odkud, kam));                                     // 4. pole mezi posunem jsou prazdna
 }
Ejemplo n.º 3
0
        // Pomocna metoda Klonuj() - vyrabim si novou identickou instanci objektu Pozice
        public Pozice Klonuj()
        {
            Pozice poz = new Pozice();

            poz.SetVyska(vyska);
            poz.SetSirka(sirka);
            return(poz);
        }
Ejemplo n.º 4
0
        // Za zadanych [sirka,vyska] intů si vytvorim Pozici - objekt se sloty x,y:
        public Pozice VytvorPozici(int sirka, int vyska)
        {
            Pozice pozice = new Pozice();

            pozice.SetVyska(vyska);
            pozice.SetSirka(sirka);
            return(pozice);
        }
Ejemplo n.º 5
0
 // Skok o jedno policko (rakticky 8 ruznych smeru)
 public bool JePosunPreskokem(Pozice odkud, Pozice kam)
 {
     return
         (((RozdilPozicVyska(odkud, kam, true) == 2 && RozdilPozicSirka(odkud, kam, true) == 2) && // skacu ob-jedno policko // tady jsem mel chybu, bylo potreba osetrit 3 mozne stavy, kdy jsou bud obe s,v stejne
           !JePolePrazdne(odkud) && JePolePrazdne(kam)) ||                                         // a zaroven skacu z neprazdneho na prazdne policko
          ((RozdilPozicVyska(odkud, kam, true) == 2 && RozdilPozicSirka(odkud, kam, true) == 0) && // stav kdy je pouze v rozdilna o 2 policka
           !JePolePrazdne(odkud) && JePolePrazdne(kam)) ||
          ((RozdilPozicVyska(odkud, kam, true) == 0 && RozdilPozicSirka(odkud, kam, true) == 2) && // stav kdy je pouze s rozdilna o 2 policka
           !JePolePrazdne(odkud) && JePolePrazdne(kam)));
 }
Ejemplo n.º 6
0
 // Rozdil 2-ou pozic SIRKOVY (univerzalni pouziti):
 public int RozdilPozicSirka(Pozice odkud, Pozice kam, bool abs)
 {
     if (abs)
     {
         return(Math.Abs(kam.GetSirka - odkud.GetSirka));
     }
     else
     {
         return(kam.GetSirka - odkud.GetSirka);
     }
 }
Ejemplo n.º 7
0
        // Test, zda-li se jedna o Objekt Pozice a zda-li obsahuje sloty vyska, sirka:
        public bool equals(Object srovnavana)
        {
            if (typeof(Object) != typeof(Pozice))
            {
                return(false);
            }

            Pozice sr = (Pozice)srovnavana;

            return(vyska == sr.GetVyska && sirka == sr.GetSirka);
        }
Ejemplo n.º 8
0
        // zjistuje prazdne pozice nebo preskocitelne(protihracova pozice) v danem smeru sirka, vyska:
        private List <Pozice> ZjistiPoziceVeSmeru(Deska deska, Pozice vychoziPozice, Pozice pomocnaPozice, int sirka, int vyska, bool jenPreskok, bool bezPreskoku)
        {
            // rekurzivne si pricitam nebo odecitam o jednicku (sirku a vysku Pozice)
            int novaVyska = vychoziPozice.GetVyska + vyska;
            int novaSirka = vychoziPozice.GetSirka + sirka;

            if (Pozice.OdpovidaRozsahu(novaSirka) && Pozice.OdpovidaRozsahu(novaVyska))
            {
                pomocnaPozice.SetSirka(novaSirka);
                pomocnaPozice.SetVyska(novaVyska);

                // Jestlize je vedlejsi policko prazdne
                if (deska.JePolePrazdne(pomocnaPozice))
                {
                    // bool hodnota - kdyz chci zjistit jen ty pozice kdy neskacu pres protihrace:
                    if (!jenPreskok)
                    {
                        List <Pozice> seznamPozic = new List <Pozice>();
                        //rekurzivne volam tutez funkci, dokud parametry novaVyska a novaSirka odpovidaji rozsahu desky:
                        List <Pozice> vracenePozice = ZjistiPoziceVeSmeru(deska, pomocnaPozice, pomocnaPozice.Klonuj(), sirka, vyska, false, true);
                        seznamPozic.Add(pomocnaPozice.Klonuj());
                        if (vracenePozice != null)
                        {
                            seznamPozic.AddRange(vracenePozice);
                        }
                        return(seznamPozic);
                    }
                    return(null);
                }

                // jestlize je vedleji policko obsazene:
                novaSirka = vychoziPozice.GetSirka + sirka * 2;
                novaVyska = vychoziPozice.GetVyska + vyska * 2;

                if (Pozice.OdpovidaRozsahu(novaSirka) && Pozice.OdpovidaRozsahu(novaVyska))
                {
                    pomocnaPozice.SetSirka(novaSirka);
                    pomocnaPozice.SetVyska(novaVyska);

                    // Jestlize se jedna o preskok kamene soupere:
                    if (deska.JePosunPreskokemKameneProtihrace(vychoziPozice, pomocnaPozice))
                    {
                        List <Pozice> seznamPozic = new List <Pozice>();
                        seznamPozic.Add(pomocnaPozice.Klonuj());
                        return(seznamPozic);
                    }
                    return(null);
                }
                return(null);
            }
            return(null);
        }
Ejemplo n.º 9
0
        // Kdekoliv, kde si potrebuju vypsat seznamPozic v textovem formatu
        public string VratJakoText()
        {
            string result = "[";

            for (int i = 0; i < seznamPozic.Count(); ++i)
            {
                Pozice p = seznamPozic[i];
                result = result + p.VratJakoText();
            }
            result = result + "]";

            return(result.ToUpper());
        }
Ejemplo n.º 10
0
        // Vysledkem teto metody je Pozice, ktera se pozdeji ma vymazat - preskocit pri ztv. ob-skoku pres soupere:
        public Pozice VratPoziciMeziPosunem(Pozice odkud, Pozice kam)
        {
            if (!JePosunPreskokem(odkud, kam)) // Vyvolani vyjimky kdyz nejde o ob-skokem
            {
                MessageBox.Show("Doslo k vyjimce v metode VratPoziciMeziPosunem pro aktualni desku");
                throw new Exception("Tento skok neni preskokem!");
            }

            int vyska = odkud.GetVyska + RozdilPozicVyska(odkud, kam, false) / 2;
            int sirka = odkud.GetSirka + RozdilPozicSirka(odkud, kam, false) / 2;

            return(VytvorPozici(sirka, vyska));
        }
Ejemplo n.º 11
0
        // Zahraj tah:
        // Pomocna kontrola, kde se mi stala chyba
        public bool ZahrajTah(Tah tah)
        {
            List <Pozice> seznamPozic    = tah.GetSeznamPozic;
            Pozice        odkud          = null;
            List <Pozice> odehranePozice = new List <Pozice>();

            foreach (Pozice kam in seznamPozic)
            {
                odehranePozice.Add(kam);
                if (odkud != null && !ProvedPosunKamene(odkud, kam, tah))
                {
                    MessageBox.Show("VYJIMKA: Metoda ProvedPosunKamene(odkud, kam) nebyla provedena !");
                    MessageBox.Show("ZahrajTah-vstupni parametr tah byl: " + tah.VratJakoText());

                    throw new Exception("metoda ZahrajTah byla zavolana pro neplatny tah !");
                }
                odkud = kam;
            }
            return(true);
        }
Ejemplo n.º 12
0
        // Generuje tahy  - Pouze Preskoku:
        public void GenerujTahyPreskoku(Pozice odkud, Deska deska, List <Pozice> seznamPozicPreskoku, List <Tah> seznamVygenerovanychTahu)
        {
            List <Pozice> seznamPreskoku   = new List <Pozice>(seznamPozicPreskoku);
            List <Pozice> poziceProPreskok = VratPoziceKamJdeSkocit(deska, odkud, true); // negace true je false - budu zjistovat preskoky

            if (poziceProPreskok.Count() == 0)
            {
                seznamVygenerovanychTahu.Add(MainWindow.VytvorTah(new List <Pozice>(seznamPreskoku)));
                return;
            }

            foreach (Pozice kam in poziceProPreskok)
            {
                seznamPreskoku.Add(kam);
                deska.ProvedPosunKamene(odkud, kam, null);
                GenerujTahyPreskoku(kam, deska, seznamPreskoku, seznamVygenerovanychTahu);
                int index = seznamPreskoku.Count() - 1;
                seznamPreskoku.RemoveAt(index);
                deska.VratZpetPosunKamene(kam, odkud, deska.VratPoziciMeziPosunem(kam, odkud));
            }
        }
Ejemplo n.º 13
0
        // Slozitejsi test, zda-li jsou policka mezi posunem prazdna - tzv. Posun Bez Preskoku:
        public bool JsouPoleMeziPosunemPrazdne(Pozice odkud, Pozice kam)
        {
            if (RozdilPozicVyska(odkud, kam, true) <= 1 && RozdilPozicSirka(odkud, kam, true) <= 1)
            {
                return(true);  // Automaticky, kdyz je rozdil nulovy nebo jen o jednu pozici, vysledek je true
            }

            int pocet = Math.Max(RozdilPozicVyska(odkud, kam, true), RozdilPozicSirka(odkud, kam, true));

            for (int i = 1; i < pocet; ++i)
            {
                int znamenko;
                int sirka;
                int vyska;
                if (odkud.GetSirka == kam.GetSirka)
                {
                    sirka = odkud.GetSirka;
                }
                else
                {
                    znamenko = Math.Sign(kam.GetSirka - odkud.GetSirka);
                    sirka    = odkud.GetSirka + i * znamenko;
                }
                if (odkud.GetVyska == kam.GetVyska)
                {
                    vyska = kam.GetVyska;
                }
                else
                {
                    znamenko = Math.Sign(kam.GetVyska - odkud.GetVyska);
                    vyska    = odkud.GetVyska + i * znamenko;
                }
                if (!JePolePrazdne(VytvorPozici(sirka, vyska))) // pokud na zadane nove vytvorene pozici neni nula, ukonci cyklus a vysledek metody je false
                {
                    return(false);
                }
            }
            return(true); // pokud cyklus prosel cely, tak vysledek metody je true
        }
Ejemplo n.º 14
0
        // pouziti pozdeji v metodach GenerujTahy a GenerujTahyPreskoku
        public bool VratZpetPosunKamene(Pozice odkud, Pozice kam, Pozice preskocena)
        {
            int odkudKamen = hraciDeska[odkud.GetVyska, odkud.GetSirka];

            if (preskocena == null && JdeOLegalniPosunBezPreskoku(odkud, kam))
            {
                hraciDeska[kam.GetVyska, kam.GetSirka]     = odkudKamen;
                hraciDeska[odkud.GetVyska, odkud.GetSirka] = 0;
                return(true);
            }
            if (JePosunPreskokem(odkud, kam))
            {
                Pozice preskakovanaPozice = VratPoziciMeziPosunem(odkud, kam);
                if (hraciDeska[preskakovanaPozice.GetVyska, preskakovanaPozice.GetSirka] == 0)
                {
                    hraciDeska[kam.GetVyska, kam.GetSirka]     = odkudKamen;
                    hraciDeska[odkud.GetVyska, odkud.GetSirka] = 0;
                    hraciDeska[preskakovanaPozice.GetVyska, preskakovanaPozice.GetSirka] = MainWindow.VratOpacnyTypKamene(odkudKamen);
                    return(true);
                }
                return(false);
            }
            return(false);
        }
Ejemplo n.º 15
0
        // pouziti pozdeji v metodach GenerujTahy, GenerujNejlepsiTah
        public bool vratTahZpet(Tah tah)
        {
            Pozice        odkud       = null;
            List <Pozice> seznamPozic = new List <Pozice>(tah.GetSeznamPozic);

            seznamPozic.Reverse();
            List <Pozice> preskoceneKameny = new List <Pozice>(tah.GetPreskoceneKameny);

            foreach (Pozice kam in seznamPozic)
            {
                if (odkud != null)
                {
                    Pozice preskocena = new Pozice();

                    if (preskoceneKameny.Count() == 0)
                    {
                        preskocena = null;
                    }
                    else
                    {
                        preskocena = preskoceneKameny.Last();
                        int index = preskoceneKameny.Count() - 1;
                        preskoceneKameny.RemoveAt(index);
                    }
                    if (!VratZpetPosunKamene(odkud, kam, preskocena))
                    {
                        MessageBox.Show("VYJIMKA: metoda vratTahZpet byla zavolana pro neplatny tah!");
                        MessageBox.Show("vratTahZpet Odkud: " + odkud.VratJakoText() + "vratTahZpet Kam: " + kam.VratJakoText() + "vratTahZpet preskocena: " + preskocena);

                        throw new Exception("metoda vratTahZpet byla zavolana pro neplatny tah!");
                    }
                }
                odkud = kam;
            }
            return(true);
        }
Ejemplo n.º 16
0
        // Prakticky presun, vymazani kamenu z desky, cili pole jako takove
        // meni hodnoty [8,8] svych prvku, muze to byt vzdy jen jedna ze tri hodnot:
        // 0 = volno, 1 = bily hrac, 2 = cerny hrac
        public bool ProvedPosunKamene(Pozice odkud, Pozice kam, Tah tah)
        {
            int odkudKamen = hraciDeska[odkud.GetVyska, odkud.GetSirka];

            if (JdeOLegalniPosunBezPreskoku(odkud, kam))
            {
                hraciDeska[kam.GetVyska, kam.GetSirka]     = odkudKamen;
                hraciDeska[odkud.GetVyska, odkud.GetSirka] = 0;
                return(true);
            }
            if (JePosunPreskokemKameneProtihrace(odkud, kam))
            {
                Pozice preskakovanyKamen = VratPoziciMeziPosunem(odkud, kam);
                hraciDeska[kam.GetVyska, kam.GetSirka]     = odkudKamen;
                hraciDeska[odkud.GetVyska, odkud.GetSirka] = 0;
                hraciDeska[preskakovanyKamen.GetVyska, preskakovanyKamen.GetSirka] = 0;
                if (tah != null)
                {
                    tah.PridejPreskocenyKamen(preskakovanyKamen); // ve tride Tah je slot na preskocene kameny
                }
                return(true);
            }
            return(false);
        }
Ejemplo n.º 17
0
        // Zjisti seznam pozic kam vsude jde z vychozi pozice skocit.
        // Prakticky se jedna o zjisteni skoku do 8-mi smeru (existuje 8 okolnich policek, lisicich se x,y o jednicku)
        // bud jsou obsazene, nebo volne a mozna i jde skakat dal nez o jedno .... viz seznamPozic
        public List <Pozice> VratPoziceKamJdeSkocit(Deska deska, Pozice vychoziPozice, bool jenPreskok)
        {
            List <Pozice> seznamPozic      = new List <Pozice>();
            Pozice        pomocnaPozice    = new Pozice();
            List <Pozice> generovanePozice = new List <Pozice>();

            int sirka;
            int vyska;

            pomocnaPozice.SetSirka(vychoziPozice.GetSirka);
            pomocnaPozice.SetVyska(vychoziPozice.GetVyska);

            for (int i = 0; i < 8; ++i)
            {
                switch (i)
                {
                case 0:
                    vyska            = 1;
                    sirka            = 0;
                    generovanePozice = ZjistiPoziceVeSmeru(deska, vychoziPozice, pomocnaPozice, sirka, vyska, jenPreskok, false);
                    if (generovanePozice == null)
                    {
                        continue;
                    }
                    seznamPozic.AddRange(generovanePozice);
                    continue;

                case 1:
                    vyska            = 1;
                    sirka            = 1;
                    generovanePozice = ZjistiPoziceVeSmeru(deska, vychoziPozice, pomocnaPozice, sirka, vyska, jenPreskok, false);
                    if (generovanePozice == null)
                    {
                        continue;
                    }
                    seznamPozic.AddRange(generovanePozice);
                    continue;

                case 2:
                    vyska            = 0;
                    sirka            = 1;
                    generovanePozice = ZjistiPoziceVeSmeru(deska, vychoziPozice, pomocnaPozice, sirka, vyska, jenPreskok, false);
                    if (generovanePozice == null)
                    {
                        continue;
                    }
                    seznamPozic.AddRange(generovanePozice);
                    continue;

                case 3:
                    vyska            = -1;
                    sirka            = 1;
                    generovanePozice = ZjistiPoziceVeSmeru(deska, vychoziPozice, pomocnaPozice, sirka, vyska, jenPreskok, false);
                    if (generovanePozice == null)
                    {
                        continue;
                    }
                    seznamPozic.AddRange(generovanePozice);
                    continue;

                case 4:
                    vyska            = -1;
                    sirka            = 0;
                    generovanePozice = ZjistiPoziceVeSmeru(deska, vychoziPozice, pomocnaPozice, sirka, vyska, jenPreskok, false);
                    if (generovanePozice == null)
                    {
                        continue;
                    }
                    seznamPozic.AddRange(generovanePozice);
                    continue;

                case 5:
                    vyska            = -1;
                    sirka            = -1;
                    generovanePozice = ZjistiPoziceVeSmeru(deska, vychoziPozice, pomocnaPozice, sirka, vyska, jenPreskok, false);
                    if (generovanePozice == null)
                    {
                        continue;
                    }
                    seznamPozic.AddRange(generovanePozice);
                    continue;

                case 6:
                    vyska            = 0;
                    sirka            = -1;
                    generovanePozice = ZjistiPoziceVeSmeru(deska, vychoziPozice, pomocnaPozice, sirka, vyska, jenPreskok, false);
                    if (generovanePozice == null)
                    {
                        continue;
                    }
                    seznamPozic.AddRange(generovanePozice);
                    continue;

                case 7:
                    vyska            = 1;
                    sirka            = -1;
                    generovanePozice = ZjistiPoziceVeSmeru(deska, vychoziPozice, pomocnaPozice, sirka, vyska, jenPreskok, false);
                    if (generovanePozice == null)
                    {
                        break;
                    }
                    seznamPozic.AddRange(generovanePozice);
                    break;
                }
            }
            return(seznamPozic);
        }
Ejemplo n.º 18
0
 public void PridejPreskocenyKamen(Pozice preskoceny)
 {
     preskoceneKameny.Add(preskoceny);
 }
Ejemplo n.º 19
0
 // Test na celkovou legalnost meho pohybu po desce:
 public bool JePosunLegalni(Pozice odkud, Pozice kam)
 {
     return(JdeOLegalniPosunBezPreskoku(odkud, kam) || JePosunPreskokemKameneProtihrace(odkud, kam));
     // mam jenom 2 druhy tahu: diagonalne-ortogonalni bez preskoků soupere
     // nebo ciste jen preskok soupere ob-policko
 }
Ejemplo n.º 20
0
 // Test, jestli skacu ob-policko a na tom ob-policku byl souper:
 public bool JePosunPreskokemKameneProtihrace(Pozice odkud, Pozice kam)
 {
     return(JePosunPreskokem(odkud, kam) &&                                            // jedna se o ob-skok a zaroven
            !JePolePrazdne(VratPoziciMeziPosunem(odkud, kam)) &&                       // policko, ktere jsem ob-skocil neni prazdne a zaroven
            VratObsahPole(odkud) != VratObsahPole(VratPoziciMeziPosunem(odkud, kam))); // obsah pole odkud (ja, treba 1=bily) se nerovna obsahu pole policka preskoceneho (trebas souper 2=cerny)
 }
Ejemplo n.º 21
0
 // Metoda na kontrolu souperovych kamenu vedle - VratPoziceKamJdeSkocit->ZjisitiPozice VeSmeru->JePosunPreskokemKameneProtihrace->seznamPozic
 public bool JeMoznostPreskoku(Deska deska, Pozice vychoziPozice)
 {
     return(!(generator.VratPoziceKamJdeSkocit(deska, vychoziPozice, true).Count() == 0));
 }
Ejemplo n.º 22
0
 // Pozice je pomocny objekt, ma stejne cleny vyska(0-7), sirka(0-7) jako ma Deska, coz je pole [8,8]
 // na zadane pozici je bud cislo 1 (Bily) nebo cislo 2 (Cerny hrac):
 public int VratObsahPole(Pozice pozice)
 {
     return(hraciDeska[pozice.GetVyska, pozice.GetSirka]);
 }
Ejemplo n.º 23
0
 // Kontrolni dotaz, jestli je pozice v poli prazdna [v,s] = 0:
 public bool JePolePrazdne(Pozice pozice)
 {
     return(VratObsahPole(pozice) == 0);
 }