コード例 #1
0
        public void PridanieMravcaKonkretnaPozicia(TypyMravcov typyMravcov, int xSuradnica, int ySuradnica, int energia, int cas)
        {
            Mravec mravec;

            mravec = new Mravec(xSuradnica, ySuradnica, true, true, typyMravcov, cisloNasledujucehoMravca, energia);
            mraveniskoMravce[xSuradnica, ySuradnica].Add(mravec);
            //
            cisloNasledujucehoMravca++;

            pocet++;

            switch (typyMravcov)
            {
            case TypyMravcov.MravecTypu1: ZvysPocetMravcovTypu1(); break;

            case TypyMravcov.MravecTypu2: ZvysPocetMravcovTypu2(); break;

            case TypyMravcov.MravecTypu3: ZvysPocetMravcovTypu3(); break;

            case TypyMravcov.MravecTypu4: ZvysPocetMravcovTypu4(); break;
            }
            HlaskyCinnostiMravcovStavObjektov.MravecVznikolNaPolickuSoZaciatocnouEnergiou(cas, mravec.ZistiIdMravca(),
                                                                                          (int)mravec.ZistiTypyMravcov() + 1,
                                                                                          mravec.ZistiXSuradnicu(), mravec.ZistiYSuradnicu(),
                                                                                          energia);
            Console.WriteLine(pocet);
        }
コード例 #2
0
        //vykresli smer otocenia mravcov na polickach
        private static bool VykresliSmerOtoceniaMravcovNaPolickach(Mravenisko mravenisko, Graphics graphics, int i, int j, int velkostStvorceka)
        {
            bool smerPohybuS = false, smerPohybuZ = false, smerPohybuJ = false, smerPohybuV = false;

            foreach (PohybujuceSaObjekty objekt in mravenisko.VratObjektPohybujuceSaNaDanychSuradniciachZobrazovanie(new Suradnice(i, j)))
            {
                Mravec mravec = objekt as Mravec;

                switch (mravec.ZistiSmerPohybu())
                {
                case SmerPohybu.s: smerPohybuS = true; break;

                case SmerPohybu.z: smerPohybuZ = true; break;

                case SmerPohybu.j: smerPohybuJ = true; break;

                case SmerPohybu.v: smerPohybuV = true; break;
                }
            }

            Pen        pen        = new Pen(Color.Black, 2);
            SolidBrush solidBrush = new SolidBrush(Color.Yellow);

            int zakladX = i * velkostStvorceka;
            int zakladY = j * velkostStvorceka;

            if (smerPohybuS)
            {
                VykresliTrojuholnik(pen, solidBrush, graphics, zakladX + velkostStvorceka / 4, zakladY + velkostStvorceka / 4,
                                    zakladX + velkostStvorceka / 2, zakladY + 1, zakladX + velkostStvorceka * 3 / 4, zakladY + velkostStvorceka / 4);
            }

            if (smerPohybuZ)
            {
                VykresliTrojuholnik(pen, solidBrush, graphics, zakladX + velkostStvorceka / 4, zakladY + velkostStvorceka / 4,
                                    zakladX + 1, zakladY + velkostStvorceka / 2, zakladX + velkostStvorceka / 4, zakladY + velkostStvorceka * 3 / 4);
            }

            if (smerPohybuJ)
            {
                VykresliTrojuholnik(pen, solidBrush, graphics, zakladX + velkostStvorceka / 4, zakladY + velkostStvorceka * 3 / 4,
                                    zakladX + velkostStvorceka / 2, zakladY + velkostStvorceka - 1, zakladX + velkostStvorceka * 3 / 4,
                                    zakladY + velkostStvorceka * 3 / 4);
            }

            if (smerPohybuV)
            {
                VykresliTrojuholnik(pen, solidBrush, graphics, zakladX + velkostStvorceka * 3 / 4, zakladY + velkostStvorceka / 4,
                                    zakladX + velkostStvorceka - 1, zakladY + velkostStvorceka / 2, zakladX + velkostStvorceka * 3 / 4,
                                    zakladY + velkostStvorceka * 3 / 4);
            }

            if (smerPohybuV || smerPohybuS || smerPohybuZ || smerPohybuJ)
            {
                return(true);
            }

            return(false);
        }
コード例 #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 Udalost(int casNastania, int priorita,
                TypyUdalosti typyUdalosti, Mravec objektMravec = default(Mravec))
 {
     NastavCasNastania(casNastania);
     NastavPriorita(priorita);
     NastavTypUdalost(typyUdalosti);
     NastavObjektMravec(objektMravec);
 }
コード例 #5
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);
            }
        }
コード例 #6
0
        //vykana cinnosti mravcov, ktore az tak nesuvisia s pohybom a ide o samostatnu cinnost konkretneho mravca
        public static void VykonanieCinnnostiMravcovNepohyb(Udalost udalost, Mravenisko mravenisko, Halda <Udalost> halda, int cas)
        {
            Mravec mravec = udalost.ZistiObjektMravec();

            switch (udalost.ZistiCinnostMravca())
            {
            case CinnostiMravcov.najedzSa:
                mravec.NajedzSa(
                    mravenisko, cas); break;
            }
        }
コード例 #7
0
        //znizenie poctu mravcov
        private void ZnizeniePoctuMravcov(Mravec mravec)
        {
            if (mravec != default(Mravec))
            {
                switch (mravec.ZistiTypyMravcov())
                {
                case TypyMravcov.MravecTypu1: ZnizPocetMravcovTypu1(); break;

                case TypyMravcov.MravecTypu2: ZnizPocetMravcovTypu2(); break;

                case TypyMravcov.MravecTypu3: ZnizPocetMravcovTypu3(); break;

                case TypyMravcov.MravecTypu4: ZnizPocetMravcovTypu4(); break;
                }
            }
        }
コード例 #8
0
 //zistenie novych pozicii mravcov
 private static void ZistiNovePozicieMravcov(Mravenisko mravenisko)
 {
     for (int i = 0; i < mravenisko.ZistiRozmerMraveniska(); i++)
     {
         for (int j = 0; j < mravenisko.ZistiRozmerMraveniska(); j++)
         {
             if (mravenisko.VratObjektPohybujuceSaNaDanychSuradniciachZobrazovanie(new Suradnice(i, j)).Count > 0)
             {
                 Mravec mravec = mravenisko.VratObjektPohybujuceSaNaDanychSuradniciachZobrazovanie(new Suradnice(i, j))[0] as Mravec;
                 typyMravcePoPohybe[i, j] = mravec.ZistiTypyMravcov();
             }
             else
             {
                 typyMravcePoPohybe[i, j] = TypyMravcov.defaulMravec;
             }
         }
     }
 }
コード例 #9
0
        //znizi energiu mravcov na konci jedneho "casu" behu simulacie
        public static void ZnizenieEnergiaNaKonci(Mravenisko mravenisko, Halda <Udalost> halda, int cas)
        {
            List <Mravec> mravceNaOdstranenie = new List <Mravec>();

            for (int i = 0; i < mravenisko.ZistiRozmerMraveniska(); i++)
            {
                for (int j = 0; j < mravenisko.ZistiRozmerMraveniska(); j++)
                {
                    foreach (PohybujuceSaObjekty objekt in mravenisko.
                             VratObjektPohybujuceSaNaDanychSuradniciach(new Suradnice(i, j)))
                    {
                        Mravec mravec = objekt as Mravec;
                        mravec.ZnizEnergia(Konstanty.maximumEnergiaMravec / 20);
                        HlaskyCinnostiMravcovStavObjektov.ZnizenaEnergiaMravcaNaKonciDanehoCasu(cas, mravec.ZistiIdMravca(),
                                                                                                (int)mravec.ZistiTypyMravcov() + 1,
                                                                                                mravec.ZistiXSuradnicu(),
                                                                                                mravec.ZistiYSuradnicu(),
                                                                                                mravec.ZistiEnergiaMravca());
                        if (!mravec.ZistiExistenciu())
                        {
                            mravceNaOdstranenie.Add(mravec);
                        }
                    }
                }
            }

            foreach (Mravec mravec in mravceNaOdstranenie)
            {
                mravenisko.NastavUbytokMravcovPoZnizeniEnergie(mravec.ZistiXSuradnicu(), mravec.ZistiYSuradnicu(), true);
                mravenisko.ZvysPocetMravcovOdisliZnizenimEnergie(mravec.ZistiXSuradnicu(), mravec.ZistiYSuradnicu());

                mravenisko.OdstranenieMravca(mravec.ZistiSuradnica(), mravec.ZistiIdMravca());

                HlaskyCinnostiMravcovStavObjektov.MravecZanikolNaPolickuNedostatokEnergie(cas, mravec.ZistiIdMravca(),
                                                                                          (int)mravec.ZistiTypyMravcov() + 1,
                                                                                          mravec.ZistiXSuradnicu(),
                                                                                          mravec.ZistiYSuradnicu());
            }

            Udalost udalost = new Udalost(cas + 1, (int)TypyUdalosti.znizenieEnergiaNaKonci,
                                          TypyUdalosti.znizenieEnergiaNaKonci);

            halda.VlozPrvok(udalost, udalost.ZistiCasNastania(), udalost.ZistiPriorita());
        }
コード例 #10
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);
        }
コード例 #11
0
        //nastavy nove cinnosti mravcov na zaklade ich pozicie a strategie
        public static void NastavenieNovychCinnostiMravcov(Mravenisko mravenisko, Halda <Udalost> halda, int cas)
        {
            Udalost udalost = new Udalost(cas + 1, (int)TypyUdalosti.nastavenieNasledujucichCinnostiMravcov,
                                          TypyUdalosti.nastavenieNasledujucichCinnostiMravcov);

            halda.VlozPrvok(udalost, udalost.ZistiCasNastania(), udalost.ZistiPriorita());

            for (int i = 0; i < mravenisko.ZistiRozmerMraveniska(); i++)
            {
                for (int j = 0; j < mravenisko.ZistiRozmerMraveniska(); j++)
                {
                    foreach (PohybujuceSaObjekty pohybObjekt in mravenisko.VratObjektPohybujuceSaNaDanychSuradniciach(new Suradnice(i, j)))
                    {
                        Mravec mravec = pohybObjekt as Mravec;
                        NastavenieCinnostiMravcov.NastavenieCinnostiMravca(halda, cas, mravec, mravenisko);
                    }
                }
            }

            SpravaMraveniskaMravcov.InicializaciaMraveniska(mravenisko);
            SpravaMraveniskaMravcov.NajdiStojacichMravcov(mravenisko);
        }
コード例 #12
0
        //nastavi cinnosti mravca, v zavislosti od toho vytvori Udalost, parit sa je cinnost viacerych mravcov a najedenie sa
        //nie je pohybova cinnost a tak maju samostatny typ udalosti
        public static void NastavenieCinnostiMravca(Halda <Udalost> halda, int cas, Mravec mravec, Mravenisko mravenisko)
        {
            CinnostiMravcov cinnostiMravcovNova = ZistenieCinnostiMravca(ZistiTypPolickaSucasne(mravenisko, mravec.ZistiTypyMravcov(),
                                                                                                mravec.ZistiSuradnica()), ZistiTypPolickaVpredu(mravenisko, mravec.ZistiTypyMravcov(),
                                                                                                                                                NasledujucePolickoMraveniska.ZistiSuradniceNasledujucehoPolicka(
                                                                                                                                                    mravec.ZistiSuradnica(),
                                                                                                                                                    mravec.ZistiSmerPohybu(), mravenisko.ZistiRozmerMraveniska())),
                                                                         mravec.ZistiTypyMravcov());

            mravec.NastavCinnostMravca(cinnostiMravcovNova);


            if (cinnostiMravcovNova == CinnostiMravcov.paritSa)
            {
                mravec.NastavParitSa(true);
                if (!NastaveneHodnotyPocasKrokov.ZistiParenie())
                {
                    Udalost udalost = new Udalost(cas + 1, (int)TypyUdalosti.paritSa,
                                                  TypyUdalosti.paritSa);
                    halda.VlozPrvok(udalost, udalost.ZistiCasNastania(), udalost.ZistiPriorita());

                    NastaveneHodnotyPocasKrokov.NastavParenie(true);
                }
            }
            else if (cinnostiMravcovNova == CinnostiMravcov.najedzSa)
            {
                Udalost udalost = new Udalost(cas + 1, (int)TypyUdalosti.vykonanieCinnostiMravcovNepohybovych,
                                              TypyUdalosti.vykonanieCinnostiMravcovNepohybovych, mravec);
                halda.VlozPrvok(udalost, udalost.ZistiCasNastania(), udalost.ZistiPriorita());
            }
            else
            {
                Udalost udalost = new Udalost(cas + 1, (int)TypyUdalosti.vykonanieCinnostiMravcovPohybovych + (int)cinnostiMravcovNova,
                                              TypyUdalosti.vykonanieCinnostiMravcovPohybovych, mravec);

                halda.VlozPrvok(udalost, udalost.ZistiCasNastania(), udalost.ZistiPriorita());
            }
        }
コード例 #13
0
        //vykona cinnosti, ktore suvisua s pohybom mravcov (okrem boja)
        public static void VykonanieCinnostiMravcovPohyb(Udalost udalost, Mravenisko mravenisko, Halda <Udalost> halda, int cas)
        {
            Mravec mravec = udalost.ZistiObjektMravec();

            switch (udalost.ZistiCinnostMravca())
            {
            case CinnostiMravcov.zostan:
                mravec.ZostanStat(mravenisko, cas);
                break;

            case CinnostiMravcov.otocSaVlavo:
                mravec.OtocSaVlavo(mravenisko, cas);
                break;

            case CinnostiMravcov.chodDopreduUtok:
                mravec.ChodDopreduUtok(mravenisko, cas);
                break;

            case CinnostiMravcov.chodDopreduObrana:
                mravec.ChodDopreduObrana(mravenisko, cas);
                break;
            }
        }
コード例 #14
0
        //vykresli kruh, tam kde mravce zostali stat
        private static bool VykresliZostanieStatiaMravcov(Mravenisko mravenisko, Graphics graphics, int i, int j, int velkostStvorceka)
        {
            bool zostaliStat = false;

            foreach (PohybujuceSaObjekty objekt in mravenisko.VratObjektPohybujuceSaNaDanychSuradniciachZobrazovanie(new Suradnice(i, j)))
            {
                Mravec mravec = objekt as Mravec;

                if (mravec.ZistiCinnostMravca() == CinnostiMravcov.zostan)
                {
                    zostaliStat = true;
                }
            }

            if (zostaliStat)
            {
                VykresliElipsu(i * velkostStvorceka + velkostStvorceka / 4, j * velkostStvorceka + velkostStvorceka / 4, velkostStvorceka / 2, velkostStvorceka / 2,
                               Color.Aqua, graphics);
                return(true);
            }

            return(false);
        }
コード例 #15
0
        //vykresli policka, kde sa mravce uspesne najedli, taktiez vypise kolko mravcov sa najedlo
        private static bool VykresliJedenieMravcov(Mravenisko mravenisko, Graphics graphics, int i, int j, int velkostStvorceka)
        {
            int pocetMravcovNajedlo = 0;

            if (mravenisko.ZistiJedenie(i, j))
            {
                foreach (PohybujuceSaObjekty objekt in mravenisko.VratObjektPohybujuceSaNaDanychSuradniciachZobrazovanie(new Suradnice(i, j)))
                {
                    Mravec mravec = objekt as Mravec;

                    if (mravec.ZistiCinnostMravca() == CinnostiMravcov.najedzSa && mravec.ZistiPodariloSa() == true)
                    {
                        pocetMravcovNajedlo++;
                    }
                }

                VykresliObdlznik(i * velkostStvorceka, j * velkostStvorceka, velkostStvorceka, velkostStvorceka, Color.LightGreen, graphics);
                VypisPocetMravcovNaPolicku(i, j, velkostStvorceka, velkostStvorceka, velkostStvorceka, pocetMravcovNajedlo, graphics, Color.Black);

                return(true);
            }

            return(false);
        }
コード例 #16
0
 private void NastavObjektMravec(Mravec objektMravec)
 {
     mravec = objektMravec;
 }
コード例 #17
0
        //vykresli smer pohybu mravcov na polickach
        private static bool VykresliSmerPohybuMravcovNaPolickach(Mravenisko mravenisko, Graphics graphics, int i, int j, int velkostStvorceka)
        {
            bool aktivnySmerPohybuS = false; bool aktivneSmerPohybuZ = false; bool aktivnySmerPohybuJ = false; bool aktivnySmerPohybuV = false;

            foreach (PohybujuceSaObjekty pohybujuceSaObjekty in mravenisko.VratObjektPohybujuceSaNaDanychSuradniciachZobrazovanie(new Suradnice(i, j)))
            {
                Mravec mravec = pohybujuceSaObjekty as Mravec;

                if (mravec.ZistiCinnostMravca() == CinnostiMravcov.chodDopreduObrana || mravec.ZistiCinnostMravca() == CinnostiMravcov.chodDopreduUtok)
                {
                    switch (mravec.ZistiSmerPohybu())
                    {
                    case SmerPohybu.s: aktivnySmerPohybuS = true; break;

                    case SmerPohybu.v: aktivnySmerPohybuV = true; break;

                    case SmerPohybu.j: aktivnySmerPohybuJ = true; break;

                    case SmerPohybu.z: aktivneSmerPohybuZ = true; break;
                    }
                }
            }

            int zakladX = i * velkostStvorceka;
            int zakladY = j * velkostStvorceka;

            Pen        pen        = new Pen(Color.Black, 2);
            SolidBrush solidBrush = new SolidBrush(Color.WhiteSmoke);

            if (aktivnySmerPohybuS)
            {
                VykresliTrojuholnik(pen, solidBrush, graphics, zakladX + velkostStvorceka / 4, zakladY + velkostStvorceka / 4,
                                    zakladX + velkostStvorceka / 2, zakladY + 1, zakladX + velkostStvorceka * 3 / 4, zakladY + velkostStvorceka / 4);
            }

            if (aktivneSmerPohybuZ)
            {
                VykresliTrojuholnik(pen, solidBrush, graphics, zakladX + velkostStvorceka / 4, zakladY + velkostStvorceka / 4,
                                    zakladX + 1, zakladY + velkostStvorceka / 2, zakladX + velkostStvorceka / 4, zakladY + velkostStvorceka * 3 / 4);
            }

            if (aktivnySmerPohybuJ)
            {
                VykresliTrojuholnik(pen, solidBrush, graphics, zakladX + velkostStvorceka / 4, zakladY + velkostStvorceka * 3 / 4,
                                    zakladX + velkostStvorceka / 2, zakladY + velkostStvorceka - 1, zakladX + velkostStvorceka * 3 / 4,
                                    zakladY + velkostStvorceka * 3 / 4);
            }

            if (aktivnySmerPohybuV)
            {
                VykresliTrojuholnik(pen, solidBrush, graphics, zakladX + velkostStvorceka * 3 / 4, zakladY + velkostStvorceka / 4,
                                    zakladX + velkostStvorceka - 1, zakladY + velkostStvorceka / 2, zakladX + velkostStvorceka * 3 / 4,
                                    zakladY + velkostStvorceka * 3 / 4);
            }

            if (aktivnySmerPohybuS || aktivneSmerPohybuZ || aktivnySmerPohybuJ || aktivnySmerPohybuV)
            {
                return(true);
            }

            return(false);
        }