예제 #1
0
        private static void initColonies(Player[] players, ColonyCollection colonies, StartingConditions startingConditions,
                                         TemporaryDB derivates, StaticsDB statics)
        {
            foreach (Colony colony in colonies)
            {
                var colonyProc = new ColonyProcessor(colony);

                colonyProc.CalculateBaseEffects(statics, derivates.Players.Of[colony.Owner]);
                derivates.Colonies.Add(colonyProc);
            }

            foreach (Player player in players)
            {
                var weights = new ChoiceWeights <Colony>();

                foreach (Colony colony in colonies.OwnedBy[player])
                {
                    weights.Add(colony, derivates.Colonies.Of[colony].Desirability);
                }

                var    maxPopulation       = colonies.OwnedBy[player].Sum(x => derivates.Colonies.Of[x].MaxPopulation);
                double totalPopulation     = Math.Min(startingConditions.Population, maxPopulation);
                double totalInfrastructure = Math.Min(startingConditions.Infrastructure, maxPopulation);

                foreach (var colony in colonies.OwnedBy[player])
                {
                    colony.Population = weights.Relative(colony) * totalPopulation;
                    derivates.Colonies.Of[colony].CalculateBaseEffects(statics, derivates.Players.Of[player]);
                }
            }
        }
예제 #2
0
        private static ColonyCollection createColonies(Player[] players, IList <StarSystemBuilder> starSystems,
                                                       IList <int> homeSystemIndices, StartingConditions startingConditions, StaticsDB statics)
        {
            var colonies = new ColonyCollection();

            for (int playerI = 0; playerI < players.Length; playerI++)
            {
                var planets = starSystems[homeSystemIndices[playerI]].Planets;
                var fitness = planets.
                              ToDictionary(x => x, x => ColonyProcessor.DesirabilityOf(x, statics));

                for (int i = 0; i < Math.Min(startingConditions.Colonies, planets.Count); i++)
                {
                    var planet = Methods.FindBest(planets, x => fitness[x]);
                    colonies.Add(new Colony(
                                     0,
                                     planet,
                                     players[playerI]
                                     ));

                    fitness[planet] = double.NegativeInfinity;
                }
            }

            return(colonies);
        }
예제 #3
0
 public StatesDB(StarCollection stars, WormholeCollection wormholes, PlanetCollection planets,
                 ColonyCollection Colonies, StellarisCollection stellarises,
                 DevelopmentProgressCollection developmentAdvances, ResearchProgressCollection researchAdvances,
                 TreatyCollection treaties, ReportCollection reports, DesignCollection designs,
                 FleetCollection fleets, ColonizationCollection colonizations)
 {
     this.Colonies             = Colonies;
     this.Planets              = planets;
     this.Stars                = stars;
     this.Stellarises          = stellarises;
     this.Wormholes            = wormholes;
     this.DevelopmentAdvances  = developmentAdvances;
     this.ResearchAdvances     = researchAdvances;
     this.Reports              = reports;
     this.Designs              = designs;
     this.Fleets               = fleets;
     this.ColonizationProjects = colonizations;
     this.Treaties             = treaties;
 }
예제 #4
0
        private static ColonyCollection createColonies(Player[] players,
                                                       IList <StarSystem> starSystems, IList <int> homeSystemIndices, StartingConditions startingConditions)
        {
            var colonies = new ColonyCollection();

            for (int playerI = 0; playerI < players.Length; playerI++)
            {
                //TODO(later): pick top most suitable planets
                for (int colonyI = 0; colonyI < startingConditions.Colonies; colonyI++)
                {
                    colonies.Add(new Colony(
                                     1,                 //TODO(v0.6): make a constant
                                     starSystems[homeSystemIndices[playerI]].Planets[colonyI],
                                     players[playerI]
                                     ));
                }
            }

            return(colonies);
        }
예제 #5
0
        private static ColonyCollection createColonies(Player[] players, IList <StarSystemBuilder> starSystems,
                                                       IList <int> homeSystemIndices, StartingConditions startingConditions, StaticsDB statics)
        {
            var colonies = new ColonyCollection();

            for (int playerI = 0; playerI < players.Length; playerI++)
            {
                var planets = new HashSet <Planet>(starSystems[homeSystemIndices[playerI]].Planets);
                var fitness = planets.
                              ToDictionary(x => x, x => ColonyProcessor.DesirabilityOf(x, statics));

                while (planets.Count > startingConditions.Colonies)
                {
                    planets.Remove(Methods.FindWorst(planets, x => fitness[x]));
                }

                foreach (var planet in planets)
                {
                    colonies.Add(new Colony(0, planet, players[playerI]));
                }
            }

            return(colonies);
        }
예제 #6
0
        private static Tuple <StatesDB, Player[], Player> loadSaveData(IkonComposite saveData, ObjectDeindexer deindexer, StaticsDB statics)
        {
            var stateData  = saveData[MainGame.StatesKey].To <IkonComposite>();
            var ordersData = saveData[MainGame.OrdersKey].To <IkonArray>();

            var stars = new StarCollection();

            foreach (var rawData in stateData[StatesDB.StarsKey].To <IEnumerable <IkonComposite> >())
            {
                stars.Add(StarData.Load(rawData, deindexer));
            }

            var planets = new PlanetCollection();

            foreach (var rawData in stateData[StatesDB.PlanetsKey].To <IEnumerable <IkonComposite> >())
            {
                planets.Add(Planet.Load(rawData, deindexer));
            }

            var wormholes = new WormholeCollection();

            foreach (var rawData in stateData[StatesDB.WormholesKey].To <IEnumerable <IkonComposite> >())
            {
                wormholes.Add(Wormhole.Load(rawData, deindexer));
            }

            var players = new List <Player>();

            foreach (var rawData in saveData[MainGame.PlayersKey].To <IEnumerable <IkonComposite> >())
            {
                players.Add(Player.Load(rawData, deindexer));
            }

            var organellePlayer = Player.Load(saveData[MainGame.OrganellePlayerKey].To <IkonComposite>(), deindexer);

            var developments = new DevelopmentProgressCollection();

            foreach (var rawData in stateData[StatesDB.DevelopmentAdvancesKey].To <IEnumerable <IkonComposite> >())
            {
                developments.Add(DevelopmentProgress.Load(rawData, deindexer));
            }

            var research = new ResearchProgressCollection();

            foreach (var rawData in stateData[StatesDB.ResearchAdvancesKey].To <IEnumerable <IkonComposite> >())
            {
                research.Add(ResearchProgress.Load(rawData, deindexer));
            }

            var treaties = new TreatyCollection();

            foreach (var rawData in stateData[StatesDB.TreatiesKey].To <IEnumerable <IkonComposite> >())
            {
                treaties.Add(Treaty.Load(rawData, deindexer));
            }

            var reports = new ReportCollection();

            foreach (var rawData in stateData[StatesDB.ReportsKey].To <IEnumerable <IkonComposite> >())
            {
                reports.Add(ReportFactory.Load(rawData, deindexer));
            }

            var designs = new DesignCollection();

            foreach (var rawData in stateData[StatesDB.DesignsKey].To <IEnumerable <IkonComposite> >())
            {
                var design = Design.Load(rawData, deindexer);
                design.CalcHash(statics);
                designs.Add(design);
                deindexer.Add(design.ConstructionProject, design.ConstructionProject.IdCode);
            }

            var colonizations = new ColonizationCollection();

            foreach (var rawData in stateData[StatesDB.ColonizationKey].To <IEnumerable <IkonComposite> >())
            {
                colonizations.Add(ColonizationProject.Load(rawData, deindexer));
            }

            var fleets = new FleetCollection();

            foreach (var rawData in stateData[StatesDB.IdleFleetsKey].To <IEnumerable <IkonComposite> >())
            {
                fleets.Add(Fleet.Load(rawData, deindexer));
            }

            var colonies = new ColonyCollection();

            foreach (var rawData in stateData[StatesDB.ColoniesKey].To <IEnumerable <IkonComposite> >())
            {
                colonies.Add(Colony.Load(rawData, deindexer));
            }

            var stellarises = new StellarisCollection();

            foreach (var rawData in stateData[StatesDB.StellarisesKey].To <IEnumerable <IkonComposite> >())
            {
                stellarises.Add(StellarisAdmin.Load(rawData, deindexer));
            }

            for (int i = 0; i < players.Count; i++)
            {
                players[i].Orders = PlayerOrders.Load(ordersData[i].To <IkonComposite>(), deindexer);
            }
            organellePlayer.Orders = PlayerOrders.Load(saveData[MainGame.OrganelleOrdersKey].To <IkonComposite>(), deindexer);

            return(new Tuple <StatesDB, Player[], Player>(
                       new StatesDB(stars, wormholes, planets, colonies, stellarises, developments, research, treaties, reports, designs, fleets, colonizations),
                       players.ToArray(),
                       organellePlayer
                       ));
        }