fel
le

Egerek és macskák

Egy városbeli kis téren (NxN mátrix) különböző dolgok állhatnak. Állhat ott egy "vánkos", ami egy ülőhelyet reprezentál, kispad, stb. A vánkosnak túl sok szerepe nem lesz, de foglal egy helyet.

Szerepelhetnek ezen a területen egerek és macskák. A macskák szokásosan az egereket kergetik, akik fejvesztetten menekülnek (ha tudnak). Ha egy macska utolér egy egeret, akkor ráteszi a jobb első mancsát (egér blokkolása). A blokkolt egér, és az őt blokkoló macska a továbbiakban nem mozog. Egy macska egyszerre csak egy egeret blokkolhat.

Az egerek is mozoghatnak, csak akkor amikor a külvilágból erre parancsot kapnak (felkérik őket). Az egerek csak szomszédos cellára lépheteknek át, csakis ha az a cella üres. Az egerek nem túl okos állatok, és elég nagy pánikban is vannak, de annyi eszük azért van, hogy olyan cellába nem mennek át, amely szomszédos egy macskával (mert a következő körben ez a macska őt el fogja kapni). Az egér tehát csak akkor mozog ha nincs blokkolva, valamint csak olyan üres cellába lép át, amely biztonságos.

A macskák célirányosan mozognak, de csak 4 mezőnyi távolságra lát el. Ha valamelyik irányban egeret lát, abba az irányba mozog. Ha nem lát semerre, de előző körben látott, akkor továbbra is ezen irányba mozog. Ha ez sem igaz, akkor random irányban fog mozogni. Ha a macska már blokkolt egy egeret, akkor nem mozog.

A tér szomszédságában kutyatelep van, ahonnan hangos ugatás hallatszik. Ennek hatására a téren álló macskák néha megijednek. Ha egy olyan macsak ijed meg, amelyik blokkol egy egeret, akkor ijedtében az egeret elengedheti (kis százalékos eséllyel). Ha egy olyan macska ijed meg, amelyik követett egy egeret, az összezavarodik, és elfelejti merre volt az az egér.

Vánkos osztály:

  • nincs mezője,
  • sem metódusa

Egér osztály:

  • bool blokkolt: mező, tárolja hogy az egeret blokkolja-e már egy macska
  • fv void mozog(): a külvilág hívja meg, az egér ellép valamely cellába ha tud
  • érdemes tárolni egy mezőben hogy mi az a tér, ahol az egér tartózkodik, hogy megkönnyítsük a függvényhívásokat
  • konstruktor a tér paraméterrel (nem lehet null)

Macska osztály:

  • Egér blokkolt: az egér példány akit blokkol a macska, ha nem blokkol semmit, akkor null értékű.
  • szintén a tér példány, ahol a macska van
  • az irány (1..8), amerre utoljára egeret látott, ha még nem látott akkor 0.
  • fv void mozog(): a külvilág hívja meg, a macska mozog (ha nem blokkol épp egy egeret)
  • fv void megijed(): a külvilág hívja meg, ha hangos zaj hallatszik. A macska reagál rá.

Cella segédosztály:

  • x és y int mezők, melyek leírnak egy koordinátát a mátrixon belül
  • konstruktor a két mezővel

Lathato segédosztály:

  • Object targy: a tárgy ami látható,
  • int irany: az irány amiben látható (1..8)
  • int tavolsag: hány lépésre látható az a tárgy
  • Cella c: a cellát leíró koordináták
  • konstruktor a négy paraméterrel.

Tér osztály:

  • tárol egy mátrixot, melynek méretét a konstruktorban lehet megadni
  • List<Cella> uresCellak(Object n): az "n" tárgy (vánkos, egér, macska, ...) környezetében lévő üres cellák listája.
  • List<Object> nemUresCellak(Cella c): adott cella környezetében lévő objektumok listája.
  • List<Lathato> miVanArra(Object n, int irany, int maxTav): adott "n" állat adott irányban (1..8) néz, adott távolságig. A lista felsorolja hogy ebbe az irányba mit lát. Ha adott mélységig arrafele nincs "semmi" (csak üres cellák) akkor a listába Lathato példány kerül, ahol a tárgy értéke null. Ha cella sincs az adott irányban (szélen áll a néző) akkor a listába null érték kerül.
  • Object tartalom(Cella c): megadja a cella tartalmát (mi áll az adott cellán)
  • void Elhelyez(Object n, int x, int y): adott tárgy elhelyezése az adott koordinátákra
  • void Mozgat(Object n, Cella c): adott objektum áthelyezése adott cellára
  • void Szimulacio(bool hangos): minden objektumot mozgat, illetve ha volt hangosság, megijeszti őket. Minden objektumot csak egyszer választ ki, random sorrendben.

Főprogram:

  • példányosít egy 20x20 teret,
  • elhelyez rajta random helyekre 10 db. vánkost,
  • elhelyez random helyekre 30 macskát,
  • elhelyez random helyekre 40 egeret,
  • futtat 100 szimulációs lépést, minden lépésben 5% eséllyel lesz hangos esemény (így elvileg a 100 körben kb. 5-ször fordul ez elő).
  • a végén megadja, hány macska tudott egeret fogni (a 100-as szimuláció végén hány macska blokkol épp egy egeret).

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace first
{
    class mezo
    {
        public List<cella>ucell (Object p)
        {
            cella c =megkeres (p);
            if (c ==null)throw new Exception("nincs a mátrixon");
            List<cella>r =new List<cella>();
            for (int i =c.x-1; i <=c.x +1; i++)
            {
            for (int j = c.y-1; j < c.y+1; j++)
                        {
                         if (joKord (i,j) && t[i,j]==null)
                r.Add(new cella (i,j));
                        }
            }
            return r;
        }
        protected bool joKord (int x, int y)
        {
            if (x<0 || y<0) return false;
            if (x>=N|| y>=M) return false; // N és M a mátrix mérete
            return true;
        }
       
        protected cella megkeres (object p)
        {
            for(int i =0;i<N; i++)
            {
                for(int j =0; j<M;j++)
                    if (t[i,j]==p)
                        return new cella(i,j);
            }
            return null;
        }
 
        protected lathato mivan(int x, int y, int dx, int tav)
        {
            for(int i =0;i<tav;i++)
            {
                x=x+dx;
                y=y+dy;
                if(joKord(x,y)==false && i ==0)
                    return null;
                if (joKord (x,y)&& tav[x,y]!=null)
                    return new lathato(t[x,y],irany,i+1,new cella(x,y));
                if (joKord (x,y)==false)
                    new lathato(null,irany,i,new cella (x-dx,y-dy));
                return new lathato(null, irany,4,new cella(x,y));
            }
        }
 
        public List<lathato>Lathatoak(object p)
        {
            List<lathato>r =ney List<lathato>();
            cella c =megkeres(p);
            if (c ==null) throw new Exception("...");
            r.Add(mivan)
        }
 
        public void mozgat(object p, cella pc)
        {
 
        }
        public List<object> kornyezet(cella pc)
        {
 
        }
    }
 
    class cella
    {
        public int x;
        public int y;
    }
    class vankos
    {
 
    }
    class eger
    {
        public bool blockede; //blokkolva van -e az egér...
        protected mezo ter; //itt tároljuk a téren lévő egér helyzetét
        static Random rnd = new Random();
 
        public eger(mezo terulet)
        {
            if (terulet == null) throw new Exception("A terület nem lehet null");
            this.terulet = terulet;
        }
        protected bool biztonsagose(cella p)
        {
            List<object> kornyezete = terulet.kornyezet(c);
            foreach (object d in kornyezete)
            {
                if (d is macska) return false;
            }
        }
        public void mozog()
        {
            if (this.blocked) return;
            List<cella> emezo = ter.ucell(this);
            if (emezo.Count == 0) return;
            List<cella> bizmezo = new List<cella>();
            foreach (cella c in emezo)
            {
                if (biztonsagose(c))
                {
                    bizmezo.Add(c);
                }
                if (bizmezo.Count == 0)
                    return;
            }
            int csz = rnd.Next(0, bizmezo.Count);
            cella m =bizmezo [csz]; //teret kérjük meg a tárolásra...
            terulet.mozgat(this, m);
 
        }
        class macska
        {
            public eger blokkol; // ha nem blokkol semmit akor null van benne
            protected mezo ter;
            protected mezo tolsopoz; //azt tárolja,
            protected int utolsoirany;
            static Random rnd = new Random();
 
 
            public macska(mezo p)
            {
                if (p == null) throw new Exception("üres mező nem lehet");
                this.ter = p;
            }
            public void mozog()
            {
                if (blokkol != null) return;
                List<Lahato> L = ter.lathatoak(this);
                int irany = valasztas(L); // itt választjuk ki az irányt. (1-8-ig)
                if (irany == 0) irany = utolsoirany;
                lathato k = terulet.vane(this, irany);
                if (irany == 0 || k == null || k.targy != null && (k.targy is eger == false))
                {
                    List<cella> ures = ter.urescellak(this);
                    if (ures.Count == 0) eturn;
                    int poz = rnd.Next(ures.Count);
                    cella c = ures[poz];
                    terulet.mozgat(this, c);
                    return;
               }
                //____________________________________________________________
               
                    if (k.targy is eger)
                    {
                        this.blokkol = k.targy as eger;
                        (k.targy as eger).blockede = true;
                        return;
                    }
                    ter.mozgat(this, k.c);
           
                protected int valasztas (List<lathato> L)
                {
                    int min =int.MaxValue;
                    List<int>legkozelebbiek =new List<int>(8);
                    foreach (lathato l in L)
                    {
                        if (l !=null && l.targy is eger)
                        {
                            if (min>l.tavolsag)
                            {
                                min = l.tavolsag;
                                legkozelebbek.clear();
                                lagkozelebbiek.add(l.irany);
                            }
                            else if (min ==l.tavolsag)
                                legkozelebbiek.Add(l.irany);
                        }
                    }
                    if (legkozelbbiek.Count==0)return;
                    return legkozelebbiek [rnd.Next(legkozelebbiek.Count)];
                }
 
 
 
            }
        }
        class lathato // mi látható a macska környezetében???? Adj egy listát!
        {
            public object targy; //lehet null, ha arra nincs semmi
            public int irany;
            public int tavolsag;
            public cella c;
 
 
        }
 
    }
    class Program
    {
 
        static void Main(string[] args)
        {
        }
    }
}
 
Hernyák Zoltán
2013-05-11 12:07:02