コード例 #1
0
 //spravuje vyhru
 private static void SpravaVyhry(List <Mravec> mravce, Suradnice suradnice, TypySubojov typySubojov, int cas)
 {
     if (typySubojov == TypySubojov.subojPriPrechode)
     {
         foreach (Mravec mravec in mravce)
         {
             mravec.NastavVyhralPriPrechode(true);
             mravec.ZvysEnergia();
             nahradneMraveniskoPohybujuce[suradnice.ZistiXSuradnicu(),
                                          suradnice.ZistiYSuradnicu()].Add(mravec);
             HlaskyCinnostiMravcovStavObjektov.MravecBojovalV(cas,
                                                              mravec.ZistiIdMravca(), (int)mravec.ZistiTypyMravcov() + 1, suradnice.ZistiXSuradnicu(), suradnice.ZistiYSuradnicu(),
                                                              mravec.ZistiEnergiaMravca());
         }
     }
     else
     {
         nahradneMraveniskoStojace[suradnice.ZistiXSuradnicu(),
                                   suradnice.ZistiYSuradnicu()] = new List <Mravec>();
         foreach (Mravec mravec in mravce)
         {
             mravec.NastavVyhralNaPolicku(true);
             mravec.ZvysEnergia(); nahradneMraveniskoStojace[suradnice.ZistiXSuradnicu(),
                                                             suradnice.ZistiYSuradnicu()].Add(mravec);
             HlaskyCinnostiMravcovStavObjektov.MravecBojovalV(cas, mravec.ZistiIdMravca(), (int)mravec.ZistiTypyMravcov() + 1,
                                                              suradnice.ZistiXSuradnicu(),
                                                              suradnice.ZistiYSuradnicu(), mravec.ZistiEnergiaMravca());
         }
     }
 }
コード例 #2
0
        //spracuje mravce, ktore zanikli pri suboji
        private static void VymazMravcePodlaTypu(Mravenisko mravenisko, TypyMravcov typyMravcov, Suradnice suradniceTypu1,
                                                 Suradnice suradniceTypu2, Suradnice suradniceTypu3,
                                                 Suradnice suradniceTypu4, List <Mravec> mravceTypu1, List <Mravec> mravceTypu2,
                                                 List <Mravec> mravceTypu3, List <Mravec> mravceTypu4, int cas)
        {
            switch (typyMravcov)
            {
            case TypyMravcov.MravecTypu1:
                VymazMravce(mravenisko, suradniceTypu2, mravceTypu2, cas);
                VymazMravce(mravenisko, suradniceTypu3, mravceTypu3, cas);
                VymazMravce(mravenisko, suradniceTypu4, mravceTypu4, cas); break;

            case TypyMravcov.MravecTypu2:
                VymazMravce(mravenisko, suradniceTypu1, mravceTypu1, cas);
                VymazMravce(mravenisko, suradniceTypu3, mravceTypu3, cas);
                VymazMravce(mravenisko, suradniceTypu4, mravceTypu4, cas); break;

            case TypyMravcov.MravecTypu3:
                VymazMravce(mravenisko, suradniceTypu1, mravceTypu1, cas);
                VymazMravce(mravenisko, suradniceTypu2, mravceTypu2, cas);
                VymazMravce(mravenisko, suradniceTypu4, mravceTypu4, cas); break;

            case TypyMravcov.MravecTypu4:
                VymazMravce(mravenisko, suradniceTypu1, mravceTypu1, cas);
                VymazMravce(mravenisko, suradniceTypu2, mravceTypu2, cas);
                VymazMravce(mravenisko, suradniceTypu3, mravceTypu3, cas); break;
            }
        }
コード例 #3
0
        //spravuje posun mravca, ked ide dopredu
        public void PosunMravca(Suradnice suradnice, Mravec mravecZmeneny)
        {
            int xSuradnica = suradnice.ZistiXSuradnicu();
            int ySuradnica = suradnice.ZistiYSuradnicu();

            mraveniskoMravce[xSuradnica, ySuradnica].Remove(mravecZmeneny);
            mraveniskoMravce[mravecZmeneny.ZistiXSuradnicu(), mravecZmeneny.ZistiYSuradnicu()].Add(mravecZmeneny);
        }
コード例 #4
0
 public PolickaPriBojiNaPolicku(Suradnice suradnice, List <TypyMravcov> typyMravcovPole = default(List <TypyMravcov>))
 {
     NastavSuradnice(suradnice);
     if (typyMravcovPole != default(List <TypyMravcov>) && typyMravcovPole.Count > 0)
     {
         this.typyMravcovPole = typyMravcovPole;
     }
 }
コード例 #5
0
        //zisti existenciu skupiny mravcov, ktore idu z policka so suradnicami "suradnice" na policku  "vpravo"
        //od nich a tymi co idu naopak
        //spracuje ich suboj
        public static void ZistiPohybVZahajSuboj(Mravenisko mravenisko, Suradnice suradnice, int cas)
        {
            List <Mravec> mravceSmerV          = new List <Mravec>(); //mravce iduce smerom na v
            List <Mravec> mravceSmerZ          = new List <Mravec>(); //mravce iduce smerom na z
            List <Mravec> mravceNaOdstranenieV = new List <Mravec>();
            List <Mravec> mravceNaOdstranenieZ = new List <Mravec>();


            //suradnice kam ide mravce v smere v
            Suradnice suradniceNaVychode = NasledujucePolickoMraveniska.SmerV(suradnice, mravenisko.ZistiRozmerMraveniska());
            //suradnice odkial idu mravce v smere v
            Suradnice suradniceSmerV = suradnice;

            foreach (Mravec mravec in nahradneMraveniskoPohybujuce[suradniceNaVychode.ZistiXSuradnicu(), suradniceNaVychode.ZistiYSuradnicu()])
            {
                if (ZistiCiSaSuradniceRovnaju(suradniceSmerV, mravec.ZistiStareSuradnica()))
                {
                    mravceNaOdstranenieV.Add(mravec);
                    mravceSmerV.Add(mravec);
                }
            }

            mravceNaOdstranenieZ = new List <Mravec>();

            //suradnice odkial idu mravce v smere z
            Suradnice suradniceSmerZ = suradniceNaVychode;
            //suradnice kam idu mravce v smere z
            Suradnice suradniceNaZapade = suradnice;

            foreach (Mravec mravec in nahradneMraveniskoPohybujuce[suradniceNaZapade.ZistiXSuradnicu(), suradniceNaZapade.ZistiYSuradnicu()])
            {
                if (ZistiCiSaSuradniceRovnaju(suradniceSmerZ, mravec.ZistiStareSuradnica()))
                {
                    mravceNaOdstranenieZ.Add(mravec);
                    mravceSmerZ.Add(mravec);
                }
            }


            //ak ma suboj zmysel, tak ho spusti
            if (mravceSmerV.Count > 0 && mravceSmerZ.Count > 0 && mravceSmerV[0].ZistiTypyMravcov() !=
                mravceSmerZ[0].ZistiTypyMravcov())
            {
                foreach (Mravec mravec in mravceNaOdstranenieZ) //vymazanie mravcov, ktore idu bojovat z nahradneho mraveniska, aby nevznikli duplikaty, ked sa budu mravce zapisovat
                {
                    nahradneMraveniskoPohybujuce[suradniceNaZapade.ZistiXSuradnicu(), suradniceNaZapade.ZistiYSuradnicu()].Remove(mravec);
                }

                foreach (Mravec mravec in mravceNaOdstranenieV) //vymazanie mravcov, ktore idu bojovat z nahradneho mraveniska, aby nevznikli duplikaty, ked sa budu mravce zapisovat
                {
                    nahradneMraveniskoPohybujuce[suradniceNaVychode.ZistiXSuradnicu(), suradniceNaVychode.ZistiYSuradnicu()].Remove(mravec);
                }

                SubojPohybujuce(mravceSmerV, suradniceNaVychode, mravceSmerZ, suradniceNaZapade, mravenisko, cas);
            }
        }
コード例 #6
0
        //spravuje parenie mravcov, na to aby vznikli nove mravce musia byt splnene urcite podmienky
        public static void ParenieMravcovDanaSuradnica(Mravenisko mravenisko, Suradnice suradnica, int cas)
        {
            List <Mravec> pariaceSaMravce = new List <Mravec>();
            int           xSuradnica      = suradnica.ZistiXSuradnicu();
            int           ySuradnica      = suradnica.ZistiYSuradnicu();

            foreach (PohybujuceSaObjekty pohybObjekt in mravenisko.VratObjektPohybujuceSaNaDanychSuradniciach(suradnica))
            {
                Mravec mravec = pohybObjekt as Mravec;

                if (mravec.ZistiParitSa())
                {
                    HlaskyCinnostiMravcovStavObjektov.MravecSaRozhodolParit(cas, mravec.ZistiIdMravca(), (int)mravec.ZistiTypyMravcov() + 1,
                                                                            suradnica.ZistiXSuradnicu(), suradnica.ZistiYSuradnicu());
                    if (mravec.ZistiEnergiaMravca() > 3)
                    {
                        pariaceSaMravce.Add(mravec);
                    }
                }
            }
            int energiaPreMravcov = 0;
            int energia           = 0;

            int pocetMravcovNovych = pariaceSaMravce.Count / 2;

            if (pocetMravcovNovych > 0)
            {
                mravenisko.NastavParenie(xSuradnica, ySuradnica, true);

                foreach (Mravec mravec in pariaceSaMravce)
                {
                    energia            = mravec.ZistiEnergiaMravca() / 3;
                    energiaPreMravcov += energia;
                    mravec.ZnizEnergia(energia);
                    HlaskyCinnostiMravcovStavObjektov.MravecSaPari(cas, mravec.ZistiIdMravca(), (int)mravec.ZistiTypyMravcov() + 1,
                                                                   suradnica.ZistiXSuradnicu(), suradnica.ZistiYSuradnicu());
                    HlaskyCinnostiMravcovStavObjektov.ZnizenaEnergiaMravcaParenie(cas, mravec.ZistiIdMravca(), (int)mravec.ZistiTypyMravcov() + 1,
                                                                                  mravec.ZistiXSuradnicu(),
                                                                                  mravec.ZistiYSuradnicu(), mravec.ZistiEnergiaMravca());
                    mravec.NastavPodariloSa(true);
                }

                energia = energiaPreMravcov / pocetMravcovNovych;

                TypyMravcov typyMravcov = default(TypyMravcov);
                typyMravcov = pariaceSaMravce[0].ZistiTypyMravcov();

                for (int i = 0; i < pocetMravcovNovych - 1; i++)
                {
                    mravenisko.PridanieMravcaKonkretnaPozicia(typyMravcov, xSuradnica, ySuradnica, energia, cas);
                    energiaPreMravcov -= energia;
                }

                mravenisko.PridanieMravcaKonkretnaPozicia(typyMravcov, xSuradnica, ySuradnica, energiaPreMravcov, cas);
            }
        }
コード例 #7
0
 //zisti rovnost suradnic
 private static bool ZistiCiSaSuradniceRovnaju(Suradnice suradnice1, Suradnice suradnice2)
 {
     if (suradnice1.ZistiXSuradnicu() == suradnice2.ZistiXSuradnicu() &&
         suradnice1.ZistiYSuradnicu() == suradnice2.ZistiYSuradnicu())
     {
         return(true);
     }
     else
     {
         return(false);
     }
 }
コード例 #8
0
        //zistuje suradnice nasledujuceho policka v smere v
        public static Suradnice SmerV(Suradnice suradnice, int rozmer)
        {
            int xSuradnica;
            int ySuradnica;

            xSuradnica = (suradnice.ZistiXSuradnicu() + 1) % rozmer;
            ySuradnica = suradnice.ZistiYSuradnicu();

            Suradnice noveSuradnice = new Suradnice(xSuradnica, ySuradnica);

            return(noveSuradnice);
        }
コード例 #9
0
        //zisti typ nepohybujuceho objektu na suradniciach
        public TypyObjektov ZistiCoJeNaDanychSuradniciach(Suradnice suradnice)
        {
            int xSuradnica = suradnice.ZistiXSuradnicu();
            int ySuradnica = suradnice.ZistiYSuradnicu();

            if (mraveniskoTypyPolicok[xSuradnica, ySuradnica] == default(NepohybujuceSaObjekty))
            {
                return(default(TypyObjektov));
            }

            return(mraveniskoTypyPolicok[xSuradnica, ySuradnica].ZistiTypObjektu());
        }
コード例 #10
0
        //spracuje mravce, ktore zanikli pri suboji
        private static void VymazMravce(Mravenisko mravenisko, Suradnice suradnice, List <Mravec> mravce, int cas)
        {
            foreach (Mravec mravec in mravce)
            {
                mravec.ZnizEnergia(Konstanty.maximumEnergiaMravec * 7);
                mravenisko.OdstranenieMravca(suradnice, mravec.ZistiIdMravca());
                HlaskyCinnostiMravcovStavObjektov.MravecZanikolNaPolickuPriBoji(cas, mravec.ZistiIdMravca(), (int)mravec.ZistiTypyMravcov() + 1,
                                                                                mravec.ZistiXSuradnicu(), mravec.ZistiYSuradnicu());

                mravec.NastavPodariloSa(false);
            }
        }
コード例 #11
0
        //zisti existenciu skupiny mravcov, ktore idu z policka so suradnicami "suradnice" na policko pod nimi
        //a tymi co ide opacne
        //spracuje ich suboj
        public static void ZistiPohybSZahajSuboj(Mravenisko mravenisko, Suradnice suradnice, int cas)
        {
            List <Mravec> mravceSmerS          = new List <Mravec>();                              //mravce iduce smerom s
            List <Mravec> mravceSmerJ          = new List <Mravec>();                              //mravce iduce smerom j
            List <Mravec> mravceNaOdstranenieS = new List <Mravec>();                              //mravce na odstranenie iduce smerom s

            Suradnice suradniceNaSevere = suradnice;                                               //suradnice
            Suradnice suradniceSmerS    =
                NasledujucePolickoMraveniska.SmerJ(suradnice, mravenisko.ZistiRozmerMraveniska()); //suradnice odkial idu mravce

            //smerujuce na s

            foreach (Mravec mravec in nahradneMraveniskoPohybujuce[suradniceNaSevere.ZistiXSuradnicu(), suradniceNaSevere.ZistiYSuradnicu()])
            {
                if (ZistiCiSaSuradniceRovnaju(mravec.ZistiStareSuradnica(), suradniceSmerS))
                {
                    mravceNaOdstranenieS.Add(mravec);
                    mravceSmerS.Add(mravec);
                }
            }

            List <Mravec> mravceNaOdstranenieJ = new List <Mravec>();                                                                       //mravce na odstranenie iduce smerom j
            Suradnice     suradniceNaJuhu      = NasledujucePolickoMraveniska.SmerJ(suradniceNaSevere, mravenisko.ZistiRozmerMraveniska()); //suradnice kam idu mravce
            // iduce zo "suradniceNaSevere", teda iduce smerom j
            Suradnice suradniceSmerJ = suradnice;                                                                                           //suradnice odkial idu mravce smerujuce na j

            foreach (Mravec mravec in nahradneMraveniskoPohybujuce[suradniceNaJuhu.ZistiXSuradnicu(), suradniceNaJuhu.ZistiYSuradnicu()])
            {
                if (ZistiCiSaSuradniceRovnaju(suradniceSmerJ, mravec.ZistiStareSuradnica()))
                {
                    mravceNaOdstranenieJ.Add(mravec);
                    mravceSmerJ.Add(mravec);
                }
            }

            //ak ma suboj zmysel, tak ho spusti
            if (mravceSmerS.Count > 0 && mravceSmerJ.Count > 0 && mravceSmerS[0].ZistiTypyMravcov() !=
                mravceSmerJ[0].ZistiTypyMravcov())
            {
                foreach (Mravec mravec in mravceNaOdstranenieS) //vymazanie mravcov, ktore idu bojovat z nahradneho mraveniska, aby nevznikli duplikaty, ked sa budu mravce zapisovat
                {
                    nahradneMraveniskoPohybujuce[suradniceNaSevere.ZistiXSuradnicu(), suradniceNaSevere.ZistiYSuradnicu()].Remove(mravec);
                }

                foreach (Mravec mravec in mravceNaOdstranenieJ) //vymazanie mravcov, ktore idu bojovat z nahradneho mraveniska, aby nevznikli duplikaty, ked sa budu mravce zapisovat
                {
                    nahradneMraveniskoPohybujuce[suradniceNaJuhu.ZistiXSuradnicu(), suradniceNaJuhu.ZistiYSuradnicu()].Remove(mravec);
                }

                SubojPohybujuce(mravceSmerS, suradniceNaSevere, mravceSmerJ, suradniceNaJuhu, mravenisko, cas);
            }
        }
コード例 #12
0
        //nastavy "suradnice" podla typu mravcov
        private static void NastavSuradnicePodlaTypu(ref Suradnice suradniceTypu1, ref Suradnice suradniceTypu2,
                                                     ref Suradnice suradniceTypu3, ref Suradnice suradniceTypu4, Suradnice suradnice, TypyMravcov typyMravcov)
        {
            switch (typyMravcov)
            {
            case TypyMravcov.MravecTypu1: suradniceTypu1 = suradnice; break;

            case TypyMravcov.MravecTypu2: suradniceTypu2 = suradnice; break;

            case TypyMravcov.MravecTypu3: suradniceTypu3 = suradnice; break;

            case TypyMravcov.MravecTypu4: suradniceTypu4 = suradnice; break;
            }
        }
コード例 #13
0
        //spravuje vyhru
        public static void SpracujVyhru(Suradnice suradniceTypu1, Suradnice suradniceTypu2, Suradnice suradniceTypu3,
                                        Suradnice suradniceTypu4, TypyMravcov typyMravcov, List <Mravec> mravceTypu1, List <Mravec> mravceTypu2,
                                        List <Mravec> mravceTypu3, List <Mravec> mravceTypu4, TypySubojov typySubojov, int cas)
        {
            switch (typyMravcov)
            {
            case TypyMravcov.MravecTypu1: SpravaVyhry(mravceTypu1, suradniceTypu1, typySubojov, cas); break;

            case TypyMravcov.MravecTypu2: SpravaVyhry(mravceTypu2, suradniceTypu2, typySubojov, cas); break;

            case TypyMravcov.MravecTypu3: SpravaVyhry(mravceTypu3, suradniceTypu3, typySubojov, cas); break;

            case TypyMravcov.MravecTypu4: SpravaVyhry(mravceTypu4, suradniceTypu4, typySubojov, cas); break;
            }
        }
コード例 #14
0
 //da mravce na miesto na ktore uskocili pri prechode
 private static void VratMravceNaPolickoZKtorehoIsliUskociliNanTeraz(Suradnice suradnice,
                                                                     List <Mravec> mravce, Mravenisko mravenisko, int cas)
 {
     foreach (Mravec mravec in mravce)
     {
         mravec.OtocitVlavo();
         mravec.OtocitVlavo();
         mravec.ChodDopredu(mravenisko.ZistiRozmerMraveniska());
         mravec.OtocitVlavo();
         mravec.OtocitVlavo();
         HlaskyCinnostiMravcovStavObjektov.MravecPrisielNaPolicko(cas, mravec.ZistiIdMravca(), (int)mravec.ZistiTypyMravcov() + 1,
                                                                  mravec.ZistiXSuradnicu(), mravec.ZistiYSuradnicu());
         mravenisko.PosunMravca(mravec.ZistiStareSuradnica(), mravec);
         nahradneMraveniskoStojace[suradnice.ZistiXSuradnicu(), suradnice.ZistiYSuradnicu()].Add(mravec);
     }
 }
コード例 #15
0
        //zistuje suradnice nasledujuceho policka podla daneho smeru
        public static Suradnice ZistiSuradniceNasledujucehoPolicka(Suradnice suradnice, SmerPohybu smer, int rozmer)
        {
            Suradnice suradniceNove = default(Suradnice);

            switch (smer)
            {
            case SmerPohybu.s: suradniceNove = SmerS(suradnice, rozmer); break;

            case SmerPohybu.v: suradniceNove = SmerV(suradnice, rozmer); break;

            case SmerPohybu.j: suradniceNove = SmerJ(suradnice, rozmer); break;

            case SmerPohybu.z: suradniceNove = SmerZ(suradnice, rozmer); break;
            }

            return(suradniceNove);
        }
コード例 #16
0
        //roztriedi mravce na urcenych suradniciach podla ich typov
        private static void RoztriedMravceNaPolickuPodlaTypovSuradnice(Suradnice suradnice, List <Mravec> mravceTypu1,
                                                                       List <Mravec> mravceTypu2, List <Mravec> mravceTypu3, List <Mravec> mravceTypu4)
        {
            foreach (Mravec mravec in nahradneMraveniskoStojace[suradnice.ZistiXSuradnicu(), suradnice.ZistiYSuradnicu()])
            {
                switch (mravec.ZistiTypyMravcov())
                {
                case TypyMravcov.MravecTypu1: mravceTypu1.Add(mravec); break;

                case TypyMravcov.MravecTypu2: mravceTypu2.Add(mravec); break;

                case TypyMravcov.MravecTypu3: mravceTypu3.Add(mravec); break;

                case TypyMravcov.MravecTypu4: mravceTypu4.Add(mravec); break;
                }
            }
        }
コード例 #17
0
        //spracovanie suboja mravcov roznych typov na danom policku
        public static void SubojNepohybujuce(Mravenisko mravenisko, Suradnice suradnice, int cas)
        {
            List <Mravec> mravceTypu1 = new List <Mravec>();
            List <Mravec> mravceTypu2 = new List <Mravec>();
            List <Mravec> mravceTypu3 = new List <Mravec>();
            List <Mravec> mravceTypu4 = new List <Mravec>();

            List <Mravec> vyherneMravce = new List <Mravec>();

            RoztriedMravceNaPolickuPodlaTypovSuradnice(suradnice, mravceTypu1, mravceTypu2, mravceTypu3, mravceTypu4);

            int energiaMravceTypu1 = ZistiEnergiaMravcov(mravceTypu1);
            int energiaMravceTypu2 = ZistiEnergiaMravcov(mravceTypu2);
            int energiaMravceTypu3 = ZistiEnergiaMravcov(mravceTypu3);
            int energiaMravceTypu4 = ZistiEnergiaMravcov(mravceTypu4);

            int pocetMravcovCelkovo;

            pocetMravcovCelkovo = mravceTypu1.Count + mravceTypu2.Count + mravceTypu3.Count + mravceTypu4.Count;

            //pokial ma suboj zmysel, tak sa spusti
            if (PritomnostMravceViacTypov(pocetMravcovCelkovo, mravceTypu1.Count, mravceTypu2.Count, mravceTypu3.Count, mravceTypu4.Count))
            {
                VlozPolickBojNepohybujuci(suradnice, mravenisko, mravceTypu1, mravceTypu2, mravceTypu3, mravceTypu4);

                TypyMravcov typyMravcov = ZistiVyhercaSuboja(energiaMravceTypu1, energiaMravceTypu2, energiaMravceTypu3, energiaMravceTypu4);

                SpracujVyhru(suradnice, suradnice, suradnice, suradnice, typyMravcov, mravceTypu1, mravceTypu2,
                             mravceTypu3, mravceTypu4, TypySubojov.subojPriStatiNaPolicku, cas);

                NastavNeparenie(mravceTypu1);
                NastavNeparenie(mravceTypu2);
                NastavNeparenie(mravceTypu3);
                NastavNeparenie(mravceTypu4);

                NastavBojovalNaPolickuDetail(mravceTypu1);
                NastavBojovalNaPolickuDetail(mravceTypu2);
                NastavBojovalNaPolickuDetail(mravceTypu3);
                NastavBojovalNaPolickuDetail(mravceTypu4);

                VymazMravcePodlaTypu(mravenisko, typyMravcov, suradnice, suradnice, suradnice, suradnice,
                                     mravceTypu1, mravceTypu2, mravceTypu3, mravceTypu4, cas);
            }
        }
コード例 #18
0
        //odstranenie mravca podla jeho id
        public void OdstranenieMravca(Suradnice suradnice, int cisloMravca)
        {
            Mravec mravec = default(Mravec);

            foreach (Mravec mravecHladany in mraveniskoMravce[suradnice.ZistiXSuradnicu(), suradnice.ZistiYSuradnicu()])
            {
                if (mravecHladany.ZistiIdMravca() == cisloMravca)
                {
                    mravec = mravecHladany;
                }
            }

            if (mravec != default(Mravec))
            {
                mraveniskoMravce[suradnice.ZistiXSuradnicu(), suradnice.ZistiYSuradnicu()].Remove(mravec);
            }

            ZnizeniePoctuMravcov(mravec);
        }
コード例 #19
0
        //vlozi policka na ktorych sa bojovalo pri boji na polickach do prislusneho pola v premennej "mravenisko"
        private static void VlozPolickBojNepohybujuci(Suradnice suradnice, Mravenisko mravenisko, List <Mravec> mravceTypu1, List <Mravec> mravceTypu2, List <Mravec> mravceTypu3,
                                                      List <Mravec> mravceTypu4)
        {
            PolickaPriBojiNaPolicku polickaPriBojiNaPolicku = new PolickaPriBojiNaPolicku(suradnice);

            if (mravceTypu1.Count > 0)
            {
                polickaPriBojiNaPolicku.VlozTypMravca(TypyMravcov.MravecTypu1);
            }
            if (mravceTypu2.Count > 0)
            {
                polickaPriBojiNaPolicku.VlozTypMravca(TypyMravcov.MravecTypu2);
            }
            if (mravceTypu3.Count > 0)
            {
                polickaPriBojiNaPolicku.VlozTypMravca(TypyMravcov.MravecTypu3);
            }
            if (mravceTypu4.Count > 0)
            {
                polickaPriBojiNaPolicku.VlozTypMravca(TypyMravcov.MravecTypu4);
            }

            mravenisko.NastavPolickoBojNaPolicku(polickaPriBojiNaPolicku, suradnice.ZistiXSuradnicu(), suradnice.ZistiYSuradnicu());
        }
コード例 #20
0
        //zisti typ policka vpredu, dostane suradnice policka, ktore je vpredu
        private static TypyPolicok ZistiTypPolickaVpredu(Mravenisko mravenisko, TypyMravcov typyMravcov, Suradnice suradnice)
        {
            TypyPolicok typyPolicok = default(TypyPolicok);

            switch (mravenisko.VratObjektNepohybujuceSaNaDanychSuradniciach(suradnice).ZistiTypObjektu())
            {
            case TypyObjektov.skala:
                typyPolicok = TypyPolicok.skala; break;

            case TypyObjektov.prazdnaZem:
            {
                List <PohybujuceSaObjekty> mravce = mravenisko.VratObjektPohybujuceSaNaDanychSuradniciach(suradnice);
                if (mravce.Count == 0)
                {
                    typyPolicok = TypyPolicok.prazdnaZem;
                }
                else if ((mravce[0] as Mravec).ZistiTypyMravcov() == typyMravcov)
                {
                    typyPolicok = TypyPolicok.priatelPrazdnaZem;
                }
                else
                {
                    typyPolicok = TypyPolicok.nepriatelPrazdnaZem;
                }
            }
            break;

            case TypyObjektov.potrava:
            {
                List <PohybujuceSaObjekty> mravce = mravenisko.VratObjektPohybujuceSaNaDanychSuradniciach(suradnice);
                if (mravce.Count == 0)
                {
                    typyPolicok = TypyPolicok.potrava;
                }
                else if ((mravce[0] as Mravec).ZistiTypyMravcov() == typyMravcov)
                {
                    typyPolicok = TypyPolicok.priatelPotrava;
                }
                else
                {
                    typyPolicok = TypyPolicok.nepriatelPotrava;
                }
            }
            break;
            }

            return(typyPolicok);
        }
コード例 #21
0
 public NepohybujuceSaObjekty VratObjektNepohybujuceSaNaDanychSuradniciach(Suradnice suradnice)
 {
     return(mraveniskoTypyPolicok[suradnice.ZistiXSuradnicu(), suradnice.ZistiYSuradnicu()]);
 }
コード例 #22
0
 public List <PohybujuceSaObjekty> VratObjektPohybujuceSaNaDanychSuradniciach(Suradnice suradnice)
 {
     return(mraveniskoMravce[suradnice.ZistiXSuradnicu(), suradnice.ZistiYSuradnicu()]);
 }
コード例 #23
0
 public List <PohybujuceSaObjekty> VratObjektPohybujuceSaNaDanychSuradniciachZobrazovanie(Suradnice suradnice)
 {
     if (ZistiFazaMraveniska() == FazaMraveniska.poNastaveniSmerOtocenia || ZistiFazaMraveniska() == FazaMraveniska.poNastaveniSmerAktivnehoPohybuStatie)
     {
         return(mraveniskoMravcePredPohybom[suradnice.ZistiXSuradnicu(), suradnice.ZistiYSuradnicu()]);
     }
     else
     {
         return(mraveniskoMravce[suradnice.ZistiXSuradnicu(), suradnice.ZistiYSuradnicu()]);
     }
 }
コード例 #24
0
        //spracovanie suboja dvoch proti sebe iducich skupin mravcov (kde jedna skupina obsahuje mravce toho isteho typu)
        private static void SubojPohybujuce(List <Mravec> mravce1, Suradnice suradnice1, List <Mravec> mravce2,
                                            Suradnice suradnice2, Mravenisko mravenisko, int cas)
        {
            PolickaPriPrechadzajucomBoji polickaPriPrechadzajucomBoji1 = new PolickaPriPrechadzajucomBoji(suradnice1, mravce1[0].ZistiTypyMravcov());
            PolickaPriPrechadzajucomBoji polickaPriPrechadzajucomBoji2 = new PolickaPriPrechadzajucomBoji(suradnice2, mravce2[0].ZistiTypyMravcov(),
                                                                                                          polickaPriPrechadzajucomBoji1);

            polickaPriPrechadzajucomBoji1.NastavDruhePolicko(polickaPriPrechadzajucomBoji2);
            mravenisko.NastavPolickoBojPrechadzajuce(polickaPriPrechadzajucomBoji1, polickaPriPrechadzajucomBoji1.ZistiSuradniceMravcov().ZistiXSuradnicu(),
                                                     polickaPriPrechadzajucomBoji1.ZistiSuradniceMravcov().ZistiYSuradnicu());
            mravenisko.NastavPolickoBojPrechadzajuce(polickaPriPrechadzajucomBoji2, polickaPriPrechadzajucomBoji2.ZistiSuradniceMravcov().ZistiXSuradnicu(),
                                                     polickaPriPrechadzajucomBoji2.ZistiSuradniceMravcov().ZistiYSuradnicu());

            List <Mravec> mravceTypu1 = new List <Mravec>();
            List <Mravec> mravceTypu2 = new List <Mravec>();
            List <Mravec> mravceTypu3 = new List <Mravec>();
            List <Mravec> mravceTypu4 = new List <Mravec>();

            List <Mravec> vyherneMravce = new List <Mravec>();

            List <Mravec> mravceUskokTypu1 = new List <Mravec>();
            List <Mravec> mravecUskokTypu2 = new List <Mravec>();
            List <Mravec> mravecUskokTypu3 = new List <Mravec>();
            List <Mravec> mravecUskokTypu4 = new List <Mravec>();

            RoztriedMravcePodlaTypovMravce(mravce1, mravceTypu1, mravceTypu2, mravceTypu3, mravceTypu4);
            RoztriedMravcePodlaTypovMravce(mravce2, mravceTypu1, mravceTypu2, mravceTypu3, mravceTypu4);

            NastavBojovaliPriPrechodeDetail(mravceTypu1);
            NastavBojovaliPriPrechodeDetail(mravceTypu2);
            NastavBojovaliPriPrechodeDetail(mravceTypu3);
            NastavBojovaliPriPrechodeDetail(mravceTypu4);

            Suradnice suradniceMravcovTypu1PreUskok = default(Suradnice);
            Suradnice suradniceMravcovTypu2PreUskok = default(Suradnice);
            Suradnice suradniceMravcovTypu3PreUskok = default(Suradnice);
            Suradnice suradniceMravcovTypu4PreUskok = default(Suradnice);

            Suradnice suradniceMravcovTypu1 = default(Suradnice);
            Suradnice suradniceMravcovTypu2 = default(Suradnice);
            Suradnice suradniceMravcovTypu3 = default(Suradnice);
            Suradnice suradniceMravcovTypu4 = default(Suradnice);

            NastavSuradnicePodlaTypu(ref suradniceMravcovTypu1PreUskok, ref suradniceMravcovTypu2PreUskok,
                                     ref suradniceMravcovTypu3PreUskok, ref suradniceMravcovTypu4PreUskok
                                     , suradnice2, mravce1[0].ZistiTypyMravcov());
            NastavSuradnicePodlaTypu(ref suradniceMravcovTypu1PreUskok, ref suradniceMravcovTypu2PreUskok,
                                     ref suradniceMravcovTypu3PreUskok, ref suradniceMravcovTypu4PreUskok,
                                     suradnice1, mravce2[0].ZistiTypyMravcov());

            NastavSuradnicePodlaTypu(ref suradniceMravcovTypu1, ref suradniceMravcovTypu2, ref suradniceMravcovTypu3, ref suradniceMravcovTypu4, suradnice1,
                                     mravce1[0].ZistiTypyMravcov());
            NastavSuradnicePodlaTypu(ref suradniceMravcovTypu1, ref suradniceMravcovTypu2, ref suradniceMravcovTypu3, ref suradniceMravcovTypu4, suradnice2,
                                     mravce2[0].ZistiTypyMravcov());


            ZistiSpravujUskakujuceMravce(mravenisko, ref mravceTypu1, mravceUskokTypu1, cas);
            ZistiSpravujUskakujuceMravce(mravenisko, ref mravceTypu2, mravecUskokTypu2, cas);
            ZistiSpravujUskakujuceMravce(mravenisko, ref mravceTypu3, mravecUskokTypu3, cas);
            ZistiSpravujUskakujuceMravce(mravenisko, ref mravceTypu4, mravecUskokTypu4, cas);

            VratMravceNaPolickoZKtorehoIsliUskociliNanTeraz(suradniceMravcovTypu1PreUskok, mravceUskokTypu1, mravenisko, cas);
            VratMravceNaPolickoZKtorehoIsliUskociliNanTeraz(suradniceMravcovTypu2PreUskok, mravecUskokTypu2, mravenisko, cas);
            VratMravceNaPolickoZKtorehoIsliUskociliNanTeraz(suradniceMravcovTypu3PreUskok, mravecUskokTypu3, mravenisko, cas);
            VratMravceNaPolickoZKtorehoIsliUskociliNanTeraz(suradniceMravcovTypu4PreUskok, mravecUskokTypu4, mravenisko, cas);

            int energiaMravceTypu1 = ZistiEnergiaMravcov(mravceTypu1);
            int energiaMravceTypu2 = ZistiEnergiaMravcov(mravceTypu2);
            int energiaMravceTypu3 = ZistiEnergiaMravcov(mravceTypu3);
            int energiaMravceTypu4 = ZistiEnergiaMravcov(mravceTypu4);

            TypyMravcov typyMravcov = ZistiVyhercaSuboja(energiaMravceTypu1, energiaMravceTypu2, energiaMravceTypu3, energiaMravceTypu4);

            SpracujVyhru(suradniceMravcovTypu1, suradniceMravcovTypu2, suradniceMravcovTypu3, suradniceMravcovTypu4, typyMravcov,
                         mravceTypu1, mravceTypu2, mravceTypu3, mravceTypu4, TypySubojov.subojPriPrechode, cas);

            VymazMravcePodlaTypu(mravenisko, typyMravcov, suradniceMravcovTypu1, suradniceMravcovTypu2, suradniceMravcovTypu3, suradniceMravcovTypu4, mravceTypu1,
                                 mravceTypu2, mravceTypu3, mravceTypu4, cas);
        }
コード例 #25
0
        List <TypyMravcov> typyMravcovPole = new List <TypyMravcov>(); //typy mravcov ucastnikov suboja

        private void NastavSuradnice(Suradnice suradnice)
        {
            this.suradnice = suradnice;
        }
コード例 #26
0
 public PolickaPriPrechadzajucomBoji(Suradnice suradnice, TypyMravcov typyMravcov, PolickaPriPrechadzajucomBoji druhePolicko = default(PolickaPriPrechadzajucomBoji))
 {
     NastavSuradniceMravcov(suradnice);
     NastavTypMravcov(typyMravcov);
     NastavDruhePolicko(druhePolicko);
 }
コード例 #27
0
        //vykresli 2 spojnice spajajuce policka, tieto ciary reprezentuju boj mravcov pri prechadzani medzi tymito polickami,
        //farby ciar reprezentuju typy mravcov, ktore bojuju takisto vykresli
        private static void VykresliBojPriPrechadzaniSpojnice(Mravenisko mravenisko, Graphics graphics, int i, int j, int velkostStvorceka)
        {
            if (mravenisko.ZistiPolickaBojPrechadzajuce(i, j) != default(List <PolickaPriPrechadzajucomBoji>) &&
                mravenisko.ZistiPolickaBojPrechadzajuce(i, j).Count > 0)
            {
                foreach (PolickaPriPrechadzajucomBoji polickaPriPrechadzajucomBoji1 in mravenisko.ZistiPolickaBojPrechadzajuce(i, j))
                {
                    PolickaPriPrechadzajucomBoji polickaPriPrechadzajucomBoji2 = polickaPriPrechadzajucomBoji1.ZistiDruhePolicko();

                    Suradnice suradnice1 = polickaPriPrechadzajucomBoji1.ZistiSuradniceMravcov();
                    Suradnice suradnice2 = polickaPriPrechadzajucomBoji2.ZistiSuradniceMravcov();

                    Pen pen1 = new Pen(ZistiFarbuMravcov(polickaPriPrechadzajucomBoji1.ZistiTypMravcov()), 3);
                    Pen pen2 = new Pen(ZistiFarbuMravcov(polickaPriPrechadzajucomBoji2.ZistiTypMravcov()), 3);


                    if (NasledujucePolickoMraveniska.SmerJ(suradnice1, mravenisko.ZistiRozmerMraveniska()).ZistiXSuradnicu() == suradnice2.ZistiXSuradnicu() &&
                        NasledujucePolickoMraveniska.SmerJ(suradnice1, mravenisko.ZistiRozmerMraveniska()).ZistiYSuradnicu() == suradnice2.ZistiYSuradnicu())
                    {
                        if (Math.Abs(suradnice1.ZistiYSuradnicu() - suradnice2.ZistiYSuradnicu()) == 1)
                        {
                            VykresliCiaru(pen1, suradnice1.ZistiXSuradnicu() * velkostStvorceka, suradnice1.ZistiYSuradnicu() * velkostStvorceka,
                                          suradnice2.ZistiXSuradnicu() * velkostStvorceka, suradnice2.ZistiYSuradnicu() * velkostStvorceka,
                                          graphics, velkostStvorceka / 2, velkostStvorceka / 2);
                            VykresliCiaru(pen2, suradnice1.ZistiXSuradnicu() * velkostStvorceka, suradnice1.ZistiYSuradnicu() * velkostStvorceka,
                                          suradnice2.ZistiXSuradnicu() * velkostStvorceka, suradnice2.ZistiYSuradnicu() * velkostStvorceka,
                                          graphics, velkostStvorceka / 2 + 3, velkostStvorceka / 2);
                        }
                        else
                        {
                            VykresliCiaru(pen1, suradnice1.ZistiXSuradnicu() * velkostStvorceka, suradnice1.ZistiYSuradnicu() * velkostStvorceka,
                                          suradnice1.ZistiXSuradnicu() * velkostStvorceka, suradnice1.ZistiYSuradnicu() * velkostStvorceka + velkostStvorceka / 2,
                                          graphics, velkostStvorceka / 2, velkostStvorceka / 2);
                            VykresliCiaru(pen2, suradnice1.ZistiXSuradnicu() * velkostStvorceka, suradnice1.ZistiYSuradnicu() * velkostStvorceka,
                                          suradnice1.ZistiXSuradnicu() * velkostStvorceka, suradnice1.ZistiYSuradnicu() * velkostStvorceka + velkostStvorceka / 2,
                                          graphics, velkostStvorceka / 2 + 3, velkostStvorceka / 2);
                            VykresliCiaru(pen1, suradnice2.ZistiXSuradnicu() * velkostStvorceka, suradnice2.ZistiYSuradnicu() * velkostStvorceka - velkostStvorceka / 2,
                                          suradnice2.ZistiXSuradnicu() * velkostStvorceka, suradnice2.ZistiYSuradnicu() * velkostStvorceka,
                                          graphics, velkostStvorceka / 2, velkostStvorceka / 2);
                            VykresliCiaru(pen2, suradnice2.ZistiXSuradnicu() * velkostStvorceka, suradnice2.ZistiYSuradnicu() * velkostStvorceka - velkostStvorceka / 2,
                                          suradnice2.ZistiXSuradnicu() * velkostStvorceka, suradnice2.ZistiYSuradnicu() * velkostStvorceka,
                                          graphics, velkostStvorceka / 2 + 3, velkostStvorceka / 2);
                        }
                    }
                    else if (NasledujucePolickoMraveniska.SmerZ(suradnice1, mravenisko.ZistiRozmerMraveniska()).ZistiXSuradnicu() == suradnice2.ZistiXSuradnicu() &&
                             NasledujucePolickoMraveniska.SmerZ(suradnice1, mravenisko.ZistiRozmerMraveniska()).ZistiYSuradnicu() == suradnice2.ZistiYSuradnicu())
                    {
                        if (Math.Abs(suradnice1.ZistiXSuradnicu() - suradnice2.ZistiXSuradnicu()) == 1)
                        {
                            VykresliCiaru(pen1, suradnice1.ZistiXSuradnicu() * velkostStvorceka, suradnice1.ZistiYSuradnicu() * velkostStvorceka,
                                          suradnice2.ZistiXSuradnicu() * velkostStvorceka, suradnice2.ZistiYSuradnicu() * velkostStvorceka,
                                          graphics, velkostStvorceka / 2, velkostStvorceka / 2);

                            VykresliCiaru(pen2, suradnice1.ZistiXSuradnicu() * velkostStvorceka, suradnice1.ZistiYSuradnicu() * velkostStvorceka, suradnice2.ZistiXSuradnicu()
                                          * velkostStvorceka, suradnice2.ZistiYSuradnicu() * velkostStvorceka,
                                          graphics, velkostStvorceka / 2, velkostStvorceka / 2 + 3);
                        }
                        else
                        {
                            VykresliCiaru(pen1, suradnice1.ZistiXSuradnicu() * velkostStvorceka - velkostStvorceka / 2, suradnice1.ZistiYSuradnicu() * velkostStvorceka,
                                          suradnice1.ZistiXSuradnicu() * velkostStvorceka, suradnice1.ZistiYSuradnicu() * velkostStvorceka,
                                          graphics, velkostStvorceka / 2, velkostStvorceka / 2);

                            VykresliCiaru(pen2, suradnice1.ZistiXSuradnicu() * velkostStvorceka - velkostStvorceka / 2, suradnice1.ZistiYSuradnicu() * velkostStvorceka,
                                          suradnice1.ZistiXSuradnicu() * velkostStvorceka,
                                          suradnice1.ZistiYSuradnicu() * velkostStvorceka,
                                          graphics, velkostStvorceka / 2, velkostStvorceka / 2 + 3);

                            VykresliCiaru(pen1, suradnice2.ZistiXSuradnicu() * velkostStvorceka, suradnice2.ZistiYSuradnicu() * velkostStvorceka,
                                          suradnice2.ZistiXSuradnicu() * velkostStvorceka + velkostStvorceka / 2, suradnice2.ZistiYSuradnicu() * velkostStvorceka,
                                          graphics, velkostStvorceka / 2, velkostStvorceka / 2);

                            VykresliCiaru(pen2, suradnice2.ZistiXSuradnicu() * velkostStvorceka, suradnice2.ZistiYSuradnicu() * velkostStvorceka,
                                          suradnice2.ZistiXSuradnicu() * velkostStvorceka + velkostStvorceka / 2, suradnice2.ZistiYSuradnicu() * velkostStvorceka,
                                          graphics, velkostStvorceka / 2, velkostStvorceka / 2 + 3);
                        }
                    }
                }
            }
        }
コード例 #28
0
        //zisti typ policka, na ktorom mravec stoji
        private static TypyPolicok ZistiTypPolickaSucasne(Mravenisko mravenisko, TypyMravcov typyMravcov, Suradnice suradnice)
        {
            TypyPolicok typyPolicok = default(TypyPolicok);

            switch (mravenisko.VratObjektNepohybujuceSaNaDanychSuradniciach(suradnice).ZistiTypObjektu())
            {
            case TypyObjektov.prazdnaZem:
            {
                List <PohybujuceSaObjekty> mravce = mravenisko.VratObjektPohybujuceSaNaDanychSuradniciach(suradnice);
                if (mravce.Count > 1)
                {
                    typyPolicok = TypyPolicok.priatelPrazdnaZem;
                }
                else
                {
                    typyPolicok = TypyPolicok.prazdnaZem;
                }
            }
            break;

            case TypyObjektov.potrava:
            {
                List <PohybujuceSaObjekty> mravce = mravenisko.VratObjektPohybujuceSaNaDanychSuradniciach(suradnice);
                if (mravce.Count > 1)
                {
                    typyPolicok = TypyPolicok.priatelPotrava;
                }
                else
                {
                    typyPolicok = TypyPolicok.potrava;
                }
            }
            break;
            }

            return(typyPolicok);
        }
コード例 #29
0
 private void NastavSuradniceMravcov(Suradnice suradnice)
 {
     SuradniceMravcov = suradnice;
 }