Example #1
0
 public Tamanitelj(Mreža mreža, int duljinaBroda, IEnumerable <Polje> pogođenaPolja)
 {
     this.mreža         = mreža;
     this.duljinaBroda  = duljinaBroda;
     this.tražilica     = new TražilicaNizovaPolja(mreža);
     this.pogođenaPolja = new List <Polje>(pogođenaPolja);
 }
Example #2
0
        private Flota SložiBrodove(Mreža mreža,
                                   IEnumerable <int> duljineBrodova)
        {
            Flota flota = new Flota();
            TražilicaNizovaPolja tražilica = new TražilicaNizovaPolja(mreža);
            istačPolja           istač     = new  istačPolja(mreža);

            foreach (int duljina in duljineBrodova)
            {
                var polja = mreža.RaspoloživaPolja;
                // raspoloživih polja manje nego duljina – ništa od flote!
                if (polja.Count() < duljina)
                {
                    return(null);
                }
                var kandidati = tražilica.DajNizovePolja(duljina);
                // nema više nizova polja – ništa od flote!
                if (kandidati.Count() == 0)
                {
                    return(null);
                }
                var izbor = Izaberi(kandidati);
                flota.DodajBrod(izbor);
                istač.Ukloni(izbor);
            }
            return(flota);
        }
 public Topništvo(int redaka, int stupaca, int[] duljineBrodova)
 {
     mreža = new Mreža(redaka, stupaca);
     this.duljineBrodova = new List <int>(duljineBrodova);
     this.duljineBrodova.Sort((d1, d2) => d2 - d1);
     PromjeniTaktikuUNapipavanje();
 }
Example #4
0
 public Topništvo(int redaka, int stupaca, IEnumerable <int> duljineBrodova)
 {
     mreža = new Mreža(redaka, stupaca);
     this.duljineBrodova = new List <int>(duljineBrodova);
     TaktikaGađanja      = TaktikaGađanja.Nasumično;
     pucač = new SlučajniPucač(mreža, duljineBrodova.First());
 }
Example #5
0
 public Kružitelj(Mreža mreža, int duljinaBroda, Polje pogođenoPolje)
 {
     this.mreža        = mreža;
     this.duljinaBroda = duljinaBroda;
     this.tražilica    = new TražilicaNizovaPolja(mreža);
     pogođenaPolja.Add(pogođenoPolje);
 }
Example #6
0
        private void EliminirajPoljaOkoBroda(Mreža mreža, IEnumerable <Polje> brodskaPolja)
        {
            IEnumerable <Polje> zaEliminirati = PoljaKojaTrebaEliminiratiOkoBroda(brodskaPolja, mreža.Redaka, mreža.Stupaca);

            foreach (Polje p in zaEliminirati)
            {
                mreža.EliminirajPolje(p);
            }
        }
 public Flota SložiFlotu(int redaka, int stupaca, IEnumerable <int> duljineBrodova)
 {
     for (int n = 0; n < brojPokušaja; ++n)
     {
         Mreža mreža = new Mreža(redaka, stupaca);
         Flota flota = SložiFlotu(mreža, duljineBrodova);
         if (flota != null)
         {
             return(flota);
         }
     }
     throw new ApplicationException("Ne može složiti flotu");
 }
Example #8
0
        private Flota SložiBrodove(int[] duljineBrodova, Mreža mreža)
        {
            Flota flota = new Flota();

            // za svaku duljinu broda:
            for (int i = 0; i < duljineBrodova.Length; ++i)
            {
                var  slobodnaPolja = mreža.DajSlobodnaPolja();
                var  pp            = izbornikPolja.IzaberiPočetnoPolje(slobodnaPolja, duljineBrodova[i]);
                var  pbr           = mreža.DajPoljaZaBrod(pp.Smjer, pp.Polje, duljineBrodova[i]);
                Brod b             = new Brod(pbr);
                flota.DodajBrod(b);
                EliminirajPoljaOkoBroda(mreža, pbr);
            }
            return(flota);
        }
Example #9
0
        public Flota SložiFlotu(int redaka, int stupaca, int[] duljineBrodova)
        {
            const int brojPokušaja = 5;

            for (int i = 0; i < brojPokušaja; ++i)
            {
                try
                {
                    Mreža mreža = new Mreža(redaka, stupaca);
                    return(SložiBrodove(duljineBrodova, mreža));
                }
                catch (ApplicationException) { }
            }
            // ako ne uspije složiti niti nakon 5 pokušaja, baca iznimku
            throw new ApplicationException();
        }
Example #10
0
        public Flota SložiFlotu(int redaka, int stupaca,
                                IEnumerable <int> duljineBrodova)
        {
            duljineBrodova = duljineBrodova.OrderByDescending(d => d);
            const int brojPokušaja = 5;

            for (int i = 0; i < brojPokušaja; ++i)
            {
                Mreža mreža = new Mreža(redaka, stupaca);
                Flota flota = SložiBrodove(mreža, duljineBrodova);
                if (flota != null)
                {
                    return(flota);
                }
            }
            return(null);
        }
Example #11
0
        public Flota SložiFlotu(int redaka, int stupaca, int[] duljineBrodova)
        {
            Flota f = new Flota();
            // napravi mrežu
            Mreža m = new Mreža(redaka, stupaca);

            // za svaku duljinu broda:
            for (int i = 0; i < duljineBrodova.Length; ++i)
            {
                var  slobodnaPolja = m.DajSlobodnaPolja();
                var  pp            = IzaberiPočetnoPolje(slobodnaPolja, duljineBrodova[i]);
                var  pbr           = DajPoljaZaBrod(pp.Item1, pp.Item2, duljineBrodova[i]);
                Brod b             = new Brod(pbr);
                f.DodajBrod(b);
                EliminirajPoljaOkoBroda(m, pbr);
            }
            return(f);
        }
        private Flota SložiFlotu(Mreža mreža, IEnumerable <int> duljineBrodova)
        {
            Flota           flota      = new Flota();
            TerminatorPolja terminator = new TerminatorPolja(mreža);

            foreach (int i in duljineBrodova)
            {
                var nizovi = mreža.DajNizoveSlobodnihPolja(i);
                if (nizovi.Count() == 0)
                {
                    return(null);
                }
                int indeks = slučajni.Next(nizovi.Count());
                var niz    = nizovi.ElementAt(indeks);
                flota.DodajBrod(niz);
                terminator.UkloniPolja(niz);
            }
            return(flota);
        }
 public SelektivniSlučajniPucač(Mreža mreža, int duljinaBroda)
     : base(mreža, duljinaBroda)
 {
 }
Example #14
0
 public Napipač(Mreža mreža, int duljinaBroda)
 {
     this.mreža        = mreža;
     this.duljinaBroda = duljinaBroda;
 }
Example #15
0
 protected Pucač(Mreža mreža, Polje pogođeno, int duljinaBroda)
     : this(mreža, duljinaBroda)
 {
     pogođenaPolja.Add(pogođeno);
 }
Example #16
0
 protected Pucač(Mreža mreža, IEnumerable <Polje> pogođena, int duljinaBroda)
     : this(mreža, duljinaBroda)
 {
     pogođenaPolja.AddRange(pogođena);
 }
Example #17
0
 protected Pucač(Mreža mreža, int duljinaBroda)
 {
     this.mreža        = mreža;
     this.duljinaBroda = duljinaBroda;
 }
 public LinijskiPucač(Mreža mreža, IEnumerable <Polje> pogođena, int duljinaBroda)
     : base(mreža, pogođena, duljinaBroda)
 {
     Debug.Assert(pogođena.Count() == 2);
 }
Example #19
0
 public SelektivniNapipač(Mreža mreža, int duljinaBroda) : base(mreža, duljinaBroda)
 {
 }
 public TerminatorPolja(Mreža mreža)
 {
     this.mreža = mreža;
 }
Example #21
0
 public KružniPucač(Polje prvoPogođeno, Mreža mreža)
 {
     pogođenaPolja.Add(prvoPogođeno);
     this.mreža = mreža;
 }
Example #22
0
 public Napipač(Mreža mreža, int duljinaBroda)
 {
     this.mreža        = mreža;
     this.duljinaBroda = duljinaBroda;
     this.tražilica    = new TražilicaNizovaPolja(mreža);
 }
Example #23
0
 public KružniPucač(Polje prvoPogođeno, Mreža mreža)
 {
     this.prvoPogođeno = prvoPogođeno;
     this.mreža        = mreža;
 }
 public KružniPucač(Mreža mreža, Polje pogođeno, int duljinaBroda)
     : base(mreža, pogođeno, duljinaBroda)
 {
     nizoviPoljaUNastavku = DajNizovePoljaUNastavcima();
 }
Example #25
0
 public istačPolja(Mreža mreža)
 {
     this.mreža = mreža;
 }
Example #26
0
 public SustavniPucač(IEnumerable <Polje> pogođena, Mreža mreža)
 {
     pogođenaPolja = new List <Polje>(pogođena);
     pogođenaPolja.Sort((a, b) => a.Redak - b.Redak + a.Stupac - b.Stupac);
     this.mreža = mreža;
 }
 public TražilicaNizovaPolja(Mreža mreža)
 {
     this.mreža = mreža;
 }