示例#1
0
        private IgraZvj(List <Igrac> igraci, int trenutniIgracIndex,
                        Mapa mapa, int brKruga)
        {
            this.igraci             = igraci;
            this.trenutniIgracIndex = trenutniIgracIndex;
            this.mapa      = mapa;
            this.brKruga   = brKruga;
            this.konflikti = new Queue <Konflikt>();

            osnovniEfekti = PodaciAlat.ucitajBazuEfekata();
            for (int i = 0; i < igraci.Count; i++)
            {
                this.igraci[i].izracunajEfekte(this);
                this.igraci[i].staviNoveTehnologije(this);
                this.igraci[i].izracunajPoeneIstrazivanja(this);
                this.igraci[i].staviPredefiniraneDizajnove();
                foreach (Kolonija kolonija in igraci[i].kolonije)
                {
                    kolonija.resetirajEfekte();
                }
            }

            foreach (Zvijezda zvj in mapa.zvijezde)
            {
                zvj.IzracunajEfekte();
            }
        }
示例#2
0
 private static Zvijezda OdrediOdabranuZvj(Mapa mapa, string zvjString)
 {
     string[] pozicija = zvjString.Split(new char[] { ' ' });
     return(mapa.najblizaZvijezda(
                double.Parse(pozicija[0], PodaciAlat.DecimalnaTocka),
                double.Parse(pozicija[1], PodaciAlat.DecimalnaTocka),
                -1));
 }
示例#3
0
        public static Igrac Ucitaj(PodaciCitac ulaz, Mapa mapa)
        {
            Tip tip = Tip.COVJEK;

            if (ulaz.podatak(PohTip) != PohTipCovjek)
            {
                tip = Tip.RACUNALO;
            }

            int          id           = ulaz.podatakInt(PohId);
            string       ime          = ulaz.podatak(PohIme);
            Organizacija organizacija = Organizacija.lista[ulaz.podatakInt(PohOrganizacija)];
            Color        boja         = OdrediBoju(ulaz.podatak(PohBoja));

            foreach (Color color in BojeIgraca)
            {
                if (boja.R == color.R && boja.G == color.G && boja.B == color.B)
                {
                    boja = color;
                }
            }

            Zvijezda odabranaZvj   = OdrediOdabranuZvj(mapa, ulaz.podatak(PohPogledZvj));
            Planet   odabranPlanet = odabranaZvj.planeti[ulaz.podatakInt(PohPogledPlanet)];

            Dictionary <int, Zvijezda> zvijezdeID = new Dictionary <int, Zvijezda>();

            foreach (Zvijezda zvj in mapa.zvijezde)
            {
                zvijezdeID.Add(zvj.id, zvj);
            }

            int brDizajnova = ulaz.podatakInt(PohDizajn);
            List <DizajnZgrada> dizajnovi = new List <DizajnZgrada>();

            for (int i = 0; i < brDizajnova; i++)
            {
                Dizajn dizajn = Dizajn.Ucitaj(ulaz[PohDizajn + i]);
                dizajnovi.Add(new DizajnZgrada(dizajn));
            }

            int brTeh = ulaz.podatakInt(PohTehnologija);
            Dictionary <string, Tehnologija> tehnologije = new Dictionary <string, Tehnologija>();

            for (int i = 0; i < brTeh; i++)
            {
                Tehnologija teh = Tehnologija.Ucitaj(ulaz[PohTehnologija + i]);
                tehnologije.Add(teh.tip.kod, teh);
            }
            double koncPoenaRazvoja = ulaz.podatakDouble(PohTehRazKonc);

            int[] tmpIntovi = ulaz.podatakIntPolje(PohTehURazvoju);
            LinkedList <Tehnologija> tehURazvoju = new LinkedList <Tehnologija>();

            foreach (int tehId in tmpIntovi)
            {
                tehURazvoju.AddLast(tehnologije[Tehnologija.TechInfo.tehnologijeRazvoj[tehId].kod]);
            }

            tmpIntovi = ulaz.podatakIntPolje(PohTehUIstraz);
            LinkedList <Tehnologija> tehUIstraz = new LinkedList <Tehnologija>();

            foreach (int tehId in tmpIntovi)
            {
                tehUIstraz.AddLast(tehnologije[Tehnologija.TechInfo.tehnologijeIstrazivanje[tehId].kod]);
            }

            tmpIntovi = ulaz.podatakIntPolje(PohPosjeceneZvj);
            HashSet <Zvijezda> posjeceneZvijezde = new HashSet <Zvijezda>();

            foreach (int zvjId in tmpIntovi)
            {
                posjeceneZvijezde.Add(zvijezdeID[zvjId]);
            }

            Dictionary <int, Dizajn> dizajnID = new Dictionary <int, Dizajn>();

            foreach (DizajnZgrada dizajnZgrada in dizajnovi)
            {
                dizajnID.Add(dizajnZgrada.dizajn.id, dizajnZgrada.dizajn);
            }
            tmpIntovi = ulaz.podatakIntPolje(PohFloteStac);
            MyDictionary <Zvijezda, Flota> floteStacionarne = new MyDictionary <Zvijezda, Flota>();

            for (int i = 0; i < tmpIntovi.Length; i++)
            {
                floteStacionarne.Add(
                    zvijezdeID[tmpIntovi[i]],
                    Flota.Ucitaj(ulaz[PohFloteStac + i], dizajnID));
            }

            int brPokFlota = ulaz.podatakInt(PohFlotePokret);
            MySet <PokretnaFlota> flotePokretne = new MySet <PokretnaFlota>();

            for (int i = 0; i < brPokFlota; i++)
            {
                flotePokretne.Add(PokretnaFlota.Ucitaj(ulaz[PohFlotePokret + i], dizajnID, zvijezdeID));
            }

            int brPoruka = ulaz.podatakInt(PohPoruka);
            LinkedList <Poruka> poruke = new LinkedList <Poruka>();

            for (int i = 0; i < brPoruka; i++)
            {
                poruke.AddLast(Poruka.Ucitaj(ulaz[PohPoruka + i], zvijezdeID, dizajnID));
            }

            return(new Igrac(id, tip, ime, boja, organizacija, odabranaZvj, odabranPlanet,
                             poruke, dizajnovi, tehnologije, tehURazvoju, koncPoenaRazvoja, tehUIstraz,
                             posjeceneZvijezde, floteStacionarne, flotePokretne));
        }
示例#4
0
        public static IgraZvj Ucitaj(string ulaz)
        {
            PodaciCitac citac = PodaciCitac.Procitaj(ulaz);

            int brKruga       = citac.podatakInt(PohKrug);
            int trenutniIgrac = citac.podatakInt(PohTrenutniIgrac);
            int brIgraca      = citac.podatakInt(PohBrIgraca);

            Mapa         mapa   = Mapa.Ucitaj(citac[Mapa.PohranaTip]);
            List <Igrac> igraci = new List <Igrac>();

            for (int i = 0; i < brIgraca; i++)
            {
                Igrac igrac = Igrac.Ucitaj(citac[Igrac.PohranaTip + i], mapa);

                if (igrac.tip == Igrac.Tip.RACUNALO)
                {
                    igrac.Upravljac = new ORIKoordinator(igrac);
                }

                igraci.Add(igrac);
            }

            Dictionary <int, Zvijezda> zvijezdeID = new Dictionary <int, Zvijezda>();

            foreach (Zvijezda zvj in mapa.zvijezde)
            {
                zvijezdeID.Add(zvj.id, zvj);
            }

            Dictionary <int, Zgrada.ZgradaInfo> zgradeInfoID = new Dictionary <int, Zgrada.ZgradaInfo>(Zgrada.ZgradaInfoID);

            foreach (Igrac igrac in igraci)
            {
                foreach (DizajnZgrada dizajZgrada in igrac.dizajnoviBrodova)
                {
                    zgradeInfoID.Add(dizajZgrada.id, dizajZgrada);
                    Dizajn.ProvjeriId(dizajZgrada.dizajn);
                }
            }

            int brKolonija = citac.podatakInt(Kolonija.PohranaTip);

            for (int i = 0; i < brKolonija; i++)
            {
                Kolonija kolonija = Kolonija.Ucitaj(
                    citac[Kolonija.PohranaTip + i],
                    igraci,
                    zvijezdeID,
                    zgradeInfoID);
                kolonija.planet.kolonija = kolonija;
            }

            int brUprava = citac.podatakInt(ZvjezdanaUprava.PohranaTip);

            for (int i = 0; i < brUprava; i++)
            {
                ZvjezdanaUprava zvjUprava = ZvjezdanaUprava.Ucitaj(
                    citac[ZvjezdanaUprava.PohranaTip + i],
                    igraci,
                    zvijezdeID,
                    zgradeInfoID);
                zvjUprava.LokacijaZvj.uprave[zvjUprava.Igrac.id] = zvjUprava;
            }

            return(new IgraZvj(igraci, trenutniIgrac, mapa, brKruga));
        }
示例#5
0
        public IgraZvj(List <Igrac.ZaStvoriti> igraci, Mapa.GraditeljMape mapa, PocetnaPopulacija pocetnaPop)
        {
            this.igraci        = new List <Igrac>();
            this.mapa          = mapa.mapa;
            trenutniIgracIndex = 0;
            fazaIgre           = FazaIgre.NoviKrug;
            brKruga            = 0;
            tempPoeniRazvoja   = new long[igraci.Count];
            tempPoeniIstraz    = new long[igraci.Count];
            konflikti          = new Queue <Konflikt>();
            osnovniEfekti      = PodaciAlat.ucitajBazuEfekata();

            foreach (Igrac.ZaStvoriti igrac in igraci)
            {
                if (igrac.tip == Igrac.Tip.COVJEK)
                {
                    this.igraci.Add(igrac.stvoriIgraca(this.igraci.Count));
                }
            }

            foreach (Igrac.ZaStvoriti igrac in igraci)
            {
                if (igrac.tip == Igrac.Tip.RACUNALO)
                {
                    this.igraci.Add(igrac.stvoriRacunalnogIgraca(this.igraci.Count));
                }
            }

            Vadjenje <Zvijezda> pocetnePozicije = new Vadjenje <Zvijezda>();

            foreach (Zvijezda pl in mapa.pocetnePozicije)
            {
                pocetnePozicije.dodaj(pl);
            }

            for (int i = 0; i < igraci.Count; i++)
            {
                this.igraci[i].izracunajEfekte(this);
                postaviIgraca(this.igraci[i], pocetnePozicije.izvadi(), pocetnaPop);
                this.igraci[i].staviNoveTehnologije(this);
                this.igraci[i].izracunajPoeneIstrazivanja(this);
                this.igraci[i].staviPredefiniraneDizajnove();
            }

            foreach (Zvijezda zvj in this.mapa.zvijezde)
            {
                foreach (Planet pl in zvj.planeti)
                {
                    if (pl.kolonija != null)
                    {
                        pl.kolonija.resetirajEfekte();
                    }
                }
                zvj.IzracunajEfekte();

                //	Za potrebe debugiranja

                /* for (int i = 0; i < igraci.Count; i++)
                 *      this.igraci[i].posjeceneZvjezde.Add(zvj); */
            }
        }
示例#6
0
            public GraditeljMape(int tipMape, int brIgraca)
            {
                mapa            = new Mapa();
                pocetnePozicije = new List <Zvijezda>();

                Random             rnd = new Random();
                double             x, y;
                int                velicinaMape   = Mapa.velicinaMape[tipMape].velicina;
                HashSet <Zvijezda> pozicijeIgraca = new HashSet <Zvijezda>();

                #region Stvaranje zvijezda
                {
                    const double OSTUPANJE_ZVJ = 0.35;

                    for (y = 0; y < velicinaMape; y++)
                    {
                        for (x = 0; x < velicinaMape; x++)
                        {
                            mapa.zvijezde.Add(new Zvijezda(
                                                  mapa.zvijezde.Count,
                                                  Zvijezda.Tip_Nedodijeljen,
                                                  (x + OSTUPANJE_ZVJ * 2 * rnd.NextDouble()) * UDALJENOST,
                                                  (y + OSTUPANJE_ZVJ * 2 * rnd.NextDouble()) * UDALJENOST
                                                  ));
                        }
                    }
                }
                #endregion

                #region Pozicije igrača
                {
                    List <Zvijezda> igraceveZvijezde       = new List <Zvijezda>();
                    const double    UDALJENOST_OD_SREDISTA = 0.85;
                    double          pomakFi = rnd.Next(2) * Math.PI + 0.25 * Math.PI;
                    double          R       = UDALJENOST * (velicinaMape - 1) / 2.0;

                    for (double igrac = 0; igrac < brIgraca; igrac++)
                    {
                        x = R + UDALJENOST_OD_SREDISTA * R * Math.Cos(pomakFi + (igrac * 2 * Math.PI) / brIgraca);
                        y = R + UDALJENOST_OD_SREDISTA * R * Math.Sin(pomakFi + (igrac * 2 * Math.PI) / brIgraca);
                        double   minR        = double.MaxValue;
                        Zvijezda zvjNajbolja = null;;

                        foreach (Zvijezda zvj in mapa.zvijezde)
                        {
                            double r = Math.Sqrt((x - zvj.x) * (x - zvj.x) + (y - zvj.y) * (y - zvj.y));
                            if (r < minR)
                            {
                                minR        = r;
                                zvjNajbolja = zvj;
                            }
                        }

                        zvjNajbolja.tip = Zvijezda.Tip_PocetnaPozicija;
                        pozicijeIgraca.Add(zvjNajbolja);
                        igraceveZvijezde.Add(zvjNajbolja);
                    }
                }
                #endregion

                #region Imenovanje zvijezda
                {
                    List <int> zvjezdja = new List <int>();
                    Dictionary <int, List <Zvijezda> > zvjezdeUZvjezdju = new Dictionary <int, List <Zvijezda> >();
                    int zvje;
                    int i;

                    Vadjenje <int> vz   = new Vadjenje <int>();
                    Vadjenje <int> dodZ = new Vadjenje <int>();
                    for (i = 0; i < PodaciAlat.zvijezdja.Count; i++)
                    {
                        vz.dodaj(i);
                    }

                    for (i = 0; i < Mapa.velicinaMape[tipMape].brZvijezdja; i++)
                    {
                        zvje = vz.izvadi();
                        for (int j = 0; j < 8; j++)
                        {
                            zvjezdja.Add(zvje);
                        }
                    }

                    vz = new Vadjenje <int>(zvjezdja);
                    foreach (Zvijezda zvj in mapa.zvijezde)
                    {
                        zvje = vz.izvadi();
                        if (!zvjezdeUZvjezdju.ContainsKey(zvje))
                        {
                            zvjezdeUZvjezdju.Add(zvje, new List <Zvijezda>());
                        }

                        zvjezdeUZvjezdju[zvje].Add(zvj);
                    }

                    foreach (int izvj in zvjezdeUZvjezdju.Keys)
                    {
                        if (zvjezdeUZvjezdju[izvj].Count == 1)
                        {
                            zvjezdeUZvjezdju[izvj][0].ime = PodaciAlat.zvijezdja[izvj].nominativ;
                        }
                        else
                        {
                            Vadjenje <Zvijezda> vZvj = new Vadjenje <Zvijezda>(zvjezdeUZvjezdju[izvj]);
                            for (int j = 0; j < zvjezdeUZvjezdju[izvj].Count; j++)
                            {
                                vZvj.izvadi().ime =
                                    PodaciAlat.prefiksZvijezdja[(PodaciAlat.PrefiksZvijezdja)j] +
                                    " " +
                                    PodaciAlat.zvijezdja[izvj].genitiv;
                            }
                        }
                    }
                }
                #endregion

                #region Dodijela tipa zvijezdama i stvaranje planeta
                {
                    Vadjenje <int> tipovi        = new Vadjenje <int>();
                    int            brZvj         = mapa.zvijezde.Count - brIgraca;
                    double         kontrolniBroj = 0;

                    #region  Određivanje broja zvijezda pojedinog tipa
                    for (int tip = 0; tip < Zvijezda.Tipovi.Count; tip++)
                    {
                        for (int i = 0; i < Zvijezda.Tipovi[tip].udioPojave * brZvj; i++)
                        {
                            tipovi.dodaj(tip);
                        }

                        kontrolniBroj += Zvijezda.Tipovi[tip].udioPojave * brZvj;
                        if (kontrolniBroj - tipovi.kolicina() >= 0.5)
                        {
                            tipovi.dodaj(tip);
                        }
                    }
                    for (int i = 0; brZvj > tipovi.kolicina(); i++)
                    {
                        tipovi.dodaj(Zvijezda.Tip_Nikakva);
                    }
                    #endregion

                    #region Pridjeljivanje tipova
                    Dictionary <int, List <Zvijezda> > zvijezdePoTipu = new Dictionary <int, List <Zvijezda> >();
                    foreach (Zvijezda zvj in mapa.zvijezde)
                    {
                        if (zvj.tip != Zvijezda.Tip_PocetnaPozicija)
                        {
                            zvj.tip = tipovi.izvadi();
                            if (!zvijezdePoTipu.ContainsKey(zvj.tip))
                            {
                                zvijezdePoTipu[zvj.tip] = new List <Zvijezda>();
                            }
                            zvijezdePoTipu[zvj.tip].Add(zvj);
                        }
                    }
                    for (int i = mapa.zvijezde.Count - 1; i > 0; i--)
                    {
                        if (mapa.zvijezde[i].tip == Zvijezda.Tip_Nikakva)
                        {
                            mapa.zvijezde.RemoveAt(i);
                        }
                    }
                    for (int i = 0; i < mapa.zvijezde.Count; i++)
                    {
                        mapa.zvijezde[i].id = i;
                    }
                    #endregion

                    #region Određivanje raspodijeljivih planeta
                    Dictionary <int, Vadjenje <Planet.Tip>[]> tipoviPlaneta = new Dictionary <int, Vadjenje <Planet.Tip>[]>();
                    Planet.Tip[] enumTipova = new Planet.Tip[] { Planet.Tip.NIKAKAV, Planet.Tip.ASTEROIDI, Planet.Tip.KAMENI, Planet.Tip.PLINOVITI };
                    Dictionary <Planet.Tip, int> brPlanetaPoTipu = new Dictionary <Planet.Tip, int>();
                    foreach (Planet.Tip tip in enumTipova)
                    {
                        brPlanetaPoTipu.Add(tip, 0);
                    }
                    foreach (int tipZvj in zvijezdePoTipu.Keys)
                    {
                        if (tipZvj == Zvijezda.Tip_Nikakva)
                        {
                            continue;
                        }

                        Dictionary <Planet.Tip, double[]> tipoviPoPozicijama = new Dictionary <Planet.Tip, double[]>();
                        foreach (Planet.Tip tipPlaneta in enumTipova)
                        {
                            tipoviPoPozicijama[tipPlaneta] = new double[BR_PLANETA];
                            Zvijezda.TipInfo.PojavnostPlaneta parametri = Zvijezda.Tipovi[tipZvj].pojavnostPlaneta[tipPlaneta];

                            double suma = 0;
                            for (int i = 0; i < BR_PLANETA; i++)
                            {
                                tipoviPoPozicijama[tipPlaneta][i] = (1 - parametri.odstupanje) + rnd.NextDouble() * parametri.odstupanje;
                                if (i <= parametri.gomiliste)
                                {
                                    tipoviPoPozicijama[tipPlaneta][i] *= parametri.unutarnjaUcestalost + (1 - parametri.unutarnjaUcestalost) * i / (BR_PLANETA * parametri.gomiliste);
                                }
                                else
                                {
                                    tipoviPoPozicijama[tipPlaneta][i] *= 1 + (parametri.vanjskaUcestalost - 1) * (i - BR_PLANETA * parametri.gomiliste) / (BR_PLANETA * (1 - parametri.gomiliste));
                                }
                                suma += tipoviPoPozicijama[tipPlaneta][i];
                            }

                            if (suma > 0)
                            {
                                for (int i = 0; i < BR_PLANETA; i++)
                                {
                                    tipoviPoPozicijama[tipPlaneta][i] *= parametri.tezinaPojave / suma;
                                }
                            }
                        }

                        tipoviPlaneta[tipZvj] = new Vadjenje <Planet.Tip> [BR_PLANETA];
                        for (int i = 0; i < BR_PLANETA; i++)
                        {
                            tipoviPlaneta[tipZvj][i] = new Vadjenje <Planet.Tip>();
                            double suma = 0;
                            foreach (Planet.Tip tipPlaneta in enumTipova)
                            {
                                suma += tipoviPoPozicijama[tipPlaneta][i];
                            }

                            foreach (Planet.Tip tipPlaneta in enumTipova)
                            {
                                double n = tipoviPoPozicijama[tipPlaneta][i] * zvijezdePoTipu[tipZvj].Count / suma;
                                brPlanetaPoTipu[tipPlaneta] += (int)n;
                                for (int j = 1; j <= n; j++)
                                {
                                    tipoviPlaneta[tipZvj][i].dodaj(tipPlaneta);
                                }
                            }

                            while (tipoviPlaneta[tipZvj][i].kolicina() < zvijezdePoTipu[tipZvj].Count)
                            {
                                tipoviPlaneta[tipZvj][i].dodaj(Planet.Tip.NIKAKAV);
                            }
                        }
                    }
                    Dictionary <Planet.Tip, Vadjenje <double> > randVelicina = new Dictionary <Planet.Tip, Vadjenje <double> >();
                    Dictionary <Planet.Tip, Vadjenje <double> > randAtmKval  = new Dictionary <Planet.Tip, Vadjenje <double> >();
                    Dictionary <Planet.Tip, Vadjenje <double> > randAtmGust  = new Dictionary <Planet.Tip, Vadjenje <double> >();
                    Dictionary <Planet.Tip, Vadjenje <double> > randMinerPov = new Dictionary <Planet.Tip, Vadjenje <double> >();
                    Dictionary <Planet.Tip, Vadjenje <double> > randMinerDub = new Dictionary <Planet.Tip, Vadjenje <double> >();
                    foreach (Planet.Tip tipPl in enumTipova)
                    {
                        randAtmGust.Add(tipPl, new Vadjenje <double>());
                        randAtmKval.Add(tipPl, new Vadjenje <double>());
                        randMinerDub.Add(tipPl, new Vadjenje <double>());
                        randMinerPov.Add(tipPl, new Vadjenje <double>());
                        randVelicina.Add(tipPl, new Vadjenje <double>());
                        for (double i = 0; i < brPlanetaPoTipu[tipPl]; i++)
                        {
                            randAtmGust[tipPl].dodaj(i / brPlanetaPoTipu[tipPl]);
                            randAtmKval[tipPl].dodaj(i / brPlanetaPoTipu[tipPl]);
                            randMinerDub[tipPl].dodaj(i / brPlanetaPoTipu[tipPl]);
                            randMinerPov[tipPl].dodaj(i / brPlanetaPoTipu[tipPl]);
                            randVelicina[tipPl].dodaj(i / brPlanetaPoTipu[tipPl]);
                        }
                    }
                    #endregion

                    #region Dodavanje planeta
                    foreach (Zvijezda zvj in mapa.zvijezde)
                    {
                        //if (zvj.tip == Zvijezda.Tip_Nikakva || mapa.pozicijeIgraca.Contains(zvj))
                        if (zvj.tip == Zvijezda.Tip_Nikakva || zvj.tip == Zvijezda.Tip_PocetnaPozicija)
                        {
                            continue;
                        }

                        for (int i = 0; i < BR_PLANETA; i++)
                        {
                            Planet.Tip tip      = tipoviPlaneta[zvj.tip][i].izvadi();
                            double     velicina = randVelicina[tip].izvadi();
                            double     AtmGust  = randAtmGust[tip].izvadi();
                            double     AtmKval  = randAtmKval[tip].izvadi();
                            double     MinerPov = randMinerPov[tip].izvadi();
                            double     MinerDub = randMinerDub[tip].izvadi();
                            zvj.planeti.Add(
                                new Planet(tip, i, zvj, velicina,
                                           AtmKval, AtmGust,
                                           MinerPov, MinerDub));
                        }
                    }
                    #endregion

                    #region Dodavanje crvotočina
                    List <Zvijezda> popisZvijezda = new List <Zvijezda>();
                    foreach (Zvijezda zvj in mapa.zvijezde)
                    {
                        if (zvj.tip != Zvijezda.Tip_Nikakva && zvj.tip != Zvijezda.Tip_Nedodijeljen)
                        {
                            popisZvijezda.Add(zvj);
                        }
                    }

                    Vadjenje <Zvijezda> zvijezdeIshodista = new Vadjenje <Zvijezda>(popisZvijezda);
                    while (zvijezdeIshodista.kolicina() > 0)
                    {
                        Zvijezda ishodiste = zvijezdeIshodista.izvadi();

                        List <Usporediv <Zvijezda, double> > odredista = new List <Usporediv <Zvijezda, double> >();
                        foreach (Zvijezda zvj in popisZvijezda)
                        {
                            if (zvj.crvotocine.Count < MaxCrvotocinaPoZvj)
                            {
                                if (ishodiste.udaljenost(zvj) <= MaxDometCrvotocine)
                                {
                                    if (!zvj.crvotocine.Contains(ishodiste) && !ishodiste.crvotocine.Contains(zvj))
                                    {
                                        if (zvj != ishodiste)
                                        {
                                            odredista.Add(new Usporediv <Zvijezda, double>(zvj, ishodiste.udaljenost(zvj)));
                                        }
                                    }
                                }
                            }
                        }
                        odredista.Sort();

                        int brNovihCrvotocina = Math.Min(MinCrvotocinaPoZvj - ishodiste.crvotocine.Count, odredista.Count);
                        for (int i = 0; i < brNovihCrvotocina; i++)
                        {
                            ishodiste.crvotocine.Add(odredista[i].objekt);
                            odredista[i].objekt.crvotocine.Add(ishodiste);
                        }
                    }
                    #endregion
                }
                #endregion

                int br = 0;
                foreach (Zvijezda zvj in pozicijeIgraca)
                {
                    br++;
                    zvj.ime = "Doma " + br;
                    PocetnaPozicija konf = PocetnaPozicija.konfiguracije[rnd.Next(PocetnaPozicija.konfiguracije.Count)];
                    zvj.tip = konf.tipZvjezde;
                    zvj.promjeniVelicinu(konf.velicinaZvijezde);
                    for (int i = 0; i < BR_PLANETA; i++)
                    {
                        Planet planet = new Planet(konf.planeti[i], zvj, null);
                        zvj.planeti.Add(planet);
                    }
                    pocetnePozicije.Add(zvj);
                }
            }