public StellarisProcessor this[StellarisAdmin stellaris]
{
get
{
return this.Stellarises.Of[stellaris];
}
}
internal StellarisInfo(StellarisAdmin stellaris, MainGame game)
{
this.Stellaris = stellaris;
this.Owner = new PlayerInfo(stellaris.Owner);
this.Population = game.States.Colonies.
AtStar[stellaris.Location.Star].
Where(x => x.Owner == stellaris.Owner).
Sum(x => x.Population);
}
//TODO(v0.8) can unintentionally land non-colony ships like scouts
private void doColonization()
{
foreach (var project in this.game.States.ColonizationProjects)
{
var playerProc = this.game.Derivates[project.Owner];
bool colonyExists = this.game.States.Colonies.AtPlanet.Contains(project.Destination);
var colonizers = this.game.States.Fleets.At[project.Destination.Star.Position].
Where(x => x.Owner == project.Owner && x.Ships.Any(s => s.PopulationTransport > 0));
var arrivedPopulation = colonizers.SelectMany(x => x.Ships).Sum(x => x.PopulationTransport);
var colonizationTreshold = this.game.Statics.ColonyFormulas.ColonizationPopulationThreshold.Evaluate(null);
if (!colonyExists && arrivedPopulation >= colonizationTreshold)
{
var colony = new Colony(0, project.Destination, project.Owner);
var colonyProc = new ColonyProcessor(colony);
colonyProc.CalculateBaseEffects(this.game.Statics, this.game.Derivates.Players.Of[colony.Owner]);
foreach (var fleet in colonizers)
{
foreach (var shipGroup in fleet.Ships)
{
var shipStats = playerProc.DesignStats[shipGroup.Design];
if (shipStats.ColonizerPopulation <= 0)
{
continue;
}
var landingLimit = (long)Math.Ceiling((colonizationTreshold - colony.Population) / shipStats.ColonizerPopulation);
var shipsLanded = Math.Min(shipGroup.Quantity, landingLimit);
colonyProc.AddPopulation(shipsLanded * shipStats.ColonizerPopulation);
foreach (var building in shipStats.ColonizerBuildings)
{
if (colony.Buildings.ContainsKey(building.Key))
{
colony.Buildings[building.Key] += building.Value * shipGroup.Quantity;
}
else
{
colony.Buildings.Add(building.Key, building.Value * shipGroup.Quantity);
}
}
shipGroup.Quantity -= shipsLanded;
shipGroup.PopulationTransport -= shipsLanded * shipStats.ColonizerPopulation;
if (shipGroup.Quantity < 1)
{
fleet.Ships.PendRemove(shipGroup);
}
}
fleet.Ships.ApplyPending();
if (fleet.Ships.Count == 0)
{
game.States.Fleets.PendRemove(fleet);
}
}
game.States.Fleets.ApplyPending();
this.game.States.Colonies.Add(colony);
this.game.Derivates.Colonies.Add(colonyProc);
this.game.Orders[project.Owner].ConstructionPlans[colony] = new ConstructionOrders(PlayerOrders.DefaultSiteSpendingRatio);
this.game.Orders[project.Owner].AutomatedConstruction[colony] = new ConstructionOrders(0);
if (this.game.States.Stellarises.At[project.Destination.Star].All(x => x.Owner != project.Owner))
{
var stellaris = new StellarisAdmin(project.Destination.Star, project.Owner);
this.game.States.Stellarises.Add(stellaris);
this.game.Derivates.Stellarises.Add(new StellarisProcessor(stellaris));
this.game.Orders[project.Owner].Policies[stellaris] = game.Statics.Policies.First();
this.game.Orders[project.Owner].AutomatedConstruction[stellaris] = new ConstructionOrders(0);
}
}
if (colonyExists || arrivedPopulation >= colonizationTreshold)
{
this.game.Orders[project.Owner].ColonizationTargets.Remove(project.Destination);
this.game.States.ColonizationProjects.PendRemove(project);
}
}
this.game.States.ColonizationProjects.ApplyPending();
}
internal StellarisAdminController(MainGame game, StellarisAdmin stellaris, bool readOnly, Player player) :
base(stellaris, readOnly, game, player)
{
}
public StellarisProcessor(StellarisAdmin stellaris) : base()
{
this.Stellaris = stellaris;
}
private void doColonization()
{
foreach (var project in this.game.States.ColonizationProjects)
{
var playerProc = this.game.Derivates.Of(project.Owner);
bool colonyExists = this.game.States.Colonies.AtPlanet.Contains(project.Destination);
var colonizers = this.game.States.Fleets.At[project.Destination.Star.Position].Where(
x =>
{
if (x.Owner != project.Owner || x.Missions.Count == 0)
{
return(false);
}
var mission = x.Missions.First.Value as ColonizationMission;
return(mission != null && mission.Target == project.Destination);
});
var arrivedPopulation = colonizers.SelectMany(x => x.Ships).Sum(x => playerProc.DesignStats[x.Design].ColonizerPopulation * x.Quantity);
var colonizationTreshold = this.game.Statics.ColonyFormulas.ColonizationPopulationThreshold.Evaluate(null);
if (!colonyExists && arrivedPopulation >= colonizationTreshold)
{
var colony = new Colony(0, project.Destination, project.Owner);
var colonyProc = new ColonyProcessor(colony);
colonyProc.CalculateBaseEffects(this.game.Statics, this.game.Derivates.Players.Of[colony.Owner]);
foreach (var fleet in colonizers)
{
foreach (var shipGroup in fleet.Ships)
{
var shipStats = playerProc.DesignStats[shipGroup.Design];
var groupPopulation = shipStats.ColonizerPopulation * shipGroup.Quantity;
var landingLimit = (long)Math.Ceiling((colonizationTreshold - colony.Population) / shipStats.ColonizerPopulation);
var shipsLanded = Math.Min(shipGroup.Quantity, landingLimit);
colonyProc.AddPopulation(shipsLanded * shipStats.ColonizerPopulation);
foreach (var building in shipStats.ColonizerBuildings)
{
if (colony.Buildings.ContainsKey(building.Key))
{
colony.Buildings[building.Key] += building.Value * shipGroup.Quantity;
}
else
{
colony.Buildings.Add(building.Key, building.Value * shipGroup.Quantity);
}
}
shipGroup.Quantity -= shipsLanded;
if (shipGroup.Quantity < 1)
{
fleet.Ships.PendRemove(shipGroup);
}
}
fleet.Ships.ApplyPending();
if (fleet.Ships.Count == 0)
{
game.States.Fleets.PendRemove(fleet);
}
}
game.States.Fleets.ApplyPending();
this.game.States.Colonies.Add(colony);
this.game.Derivates.Colonies.Add(colonyProc);
if (this.game.States.Stellarises.At[project.Destination.Star].All(x => x.Owner != project.Owner))
{
var stellaris = new StellarisAdmin(project.Destination.Star, project.Owner);
this.game.States.Stellarises.Add(stellaris);
this.game.Derivates.Stellarises.Add(new StellarisProcessor(stellaris));
}
}
if (colonyExists || !colonyExists && arrivedPopulation >= colonizationTreshold)
{
project.Owner.Orders.ColonizationOrders.Remove(project.Destination);
this.game.States.ColonizationProjects.PendRemove(project);
}
}
this.game.States.ColonizationProjects.ApplyPending();
}
private StellarisProcessor(StellarisAdmin stellaris, StellarisProcessor original) : base(original)
{
this.Stellaris = stellaris;
}
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
));
}
internal StellarisProcessor Of(StellarisAdmin stellaris)
{
return(this.Stellarises.Of[stellaris]);
}
