private void DetermineMigrationLocation(Pops pop, Civilization civ)
{
float topPlanetValue = 0f;
PlanetData topPlanet = null;
foreach (PlanetData pData in civ.PlanetList) // determine the top value of each planet and choose the best one
{
if (pData != pop.PlanetLocated)
{
float currentPlanetValue = MigrationValueOfPlanet(pData, pop);
if (currentPlanetValue > topPlanetValue)
{
topPlanetValue = currentPlanetValue;
topPlanet = pData;
}
}
}
if (topPlanetValue > Constants.Constants.StellarMigrationThreshold + UnityEngine.Random.Range(0, 200)) // if the best value is above a certain threshold
{
List <Region> eligibleRegionList = new List <Region>();
foreach (Region rData in topPlanet.RegionList.ToArray())
{
if (rData.IsHabitable)
{
eligibleRegionList.Add(rData);
}
}
if (eligibleRegionList.Count > 0)
{
int regionChoice = UnityEngine.Random.Range(0, eligibleRegionList.Count); // find an eligible region
// move the pop from one region on a planet to another planet and a suitable region
string oldPlanetName = pop.PlanetLocated.Name;
pop.IsMigratingOffPlanet = false; // reset the flag
pop.RegionLocated.PopsInTile.Remove(pop);
pop.RegionLocated.EmigratedLastTurn += 1;
pop.RegionLocated.PopsInTile.TrimExcess();
pop.RegionLocationID = eligibleRegionList[regionChoice].ID;
pop.RegionLocated.PopsInTile.Add(pop);
pop.RegionLocated.ImmigratedLastTurn += 1;
pop.PlanetHappinessLevel = 50; // reset planet happiness since they just moved
Debug.Log("In " + gDataRef.GameDate.ToString("N1") + ", a " + pop.PopClass.ToString() + " migrated from " + oldPlanetName + " to " + topPlanet.Name + ".");
topPlanet.MigratePopsBetweenRegions(); // rerun migration to move the pop to a more suitable region
}
else
{
pop.UnrestLevel += .05f; // can't leave
pop.PopSupport -= .05f; // and is pissed
}
}
else
{
pop.UnrestLevel += .05f; // can't leave
pop.PopSupport -= .05f; // and is pissed
}
}
public PdxSublist GetPopData()
{
//if(Eu4Provinces.Count == 0)
//{
// return null;
//}
return(Pops.GetData(this));
}
private void InitializePops(IRace race, int num)
{
Pops.Clear();
for (var i = 0; i < num; i++)
{
Pops.Add(new Pop(race));
}
}
[Fact] public void PopsDefaultToEmpty()
{
var reader = new BufferedReader("= { }");
var pops = new Pops();
pops.LoadPops(reader);
Assert.Empty(pops.StoredPops);
}
public Pops CalcPopsFor2ChTypes(Icon icon, Dictionary <string, double> pbties)
{
Pops pops = new Pops();
foreach (var pbty0 in pbties)
{
if (pbty0.Key.Contains(chTypes[0]))
{
foreach (var pbty1 in pbties)
{
if (pbty1.Key.Contains(chTypes[1]))
{
stringBuilder.Clear();
stringBuilder.Append(pbty0.Key).Append(":").Append(pbty1.Key);
pops.Add(stringBuilder.ToString(), Convert.ToInt32(icon.Personnel * pbty0.Value * pbty1.Value));
}
}
}
}
double pbtiesSum0 = 0;
double pbtiesSum1 = 0;
foreach (var pbty in pbties)
{
if (pbty.Key.Contains(chTypes[0]))
{
pbtiesSum0 += pbty.Value;
}
}
foreach (var pbty in pbties)
{
if (pbty.Key.Contains(chTypes[1]))
{
pbtiesSum1 += pbty.Value;
}
}
foreach (var pbty in pbties)
{
if (pbty.Key.Contains(chTypes[0]))
{
pops.Add(pbty.Key, Convert.ToInt32(icon.Personnel * pbty.Value * (1 - pbtiesSum1)));
}
}
foreach (var pbty in pbties)
{
if (pbty.Key.Contains(chTypes[1]))
{
pops.Add(pbty.Key, Convert.ToInt32(icon.Personnel * pbty.Value * (1 - pbtiesSum0)));
}
}
return(pops);
}
private void CalcPopEffects(Dictionary <string, float> effects, Eu4ProvinceBase fromProvince)
{
foreach (PopType popType in Enum.GetValues(typeof(PopType)))
{
var name = Enum.GetName(typeof(PopType), popType);
if (effects.ContainsKey(name))
{
Pops.AddPop(fromProvince, popType, (int)effects[name]);
}
}
}
private void CalcRelativePopEffects(Dictionary <string, float> effects, Eu4ProvinceBase fromProvince)
{
foreach (PopType popType in Enum.GetValues(typeof(PopType)))
{
var name = Enum.GetName(typeof(PopType), popType);
if (effects.ContainsKey("relative_" + name))
{
Pops.IncreaseJob(popType, effects["relative_" + name]);
}
}
}
public Pops CalcPopsFor1ChTypes(Icon icon, Dictionary <string, double> pbties)
{
Pops pops = new Pops();
foreach (var pbty in pbties)
{
pops.Add(pbty.Key, Convert.ToInt32(pbty.Value * icon.Personnel));
}
return(pops);
}
public void PopsCanBeLoaded()
{
var reader = new BufferedReader("= {\n 42={}\n 43 = {}\n }");
var pops = new Pops();
pops.LoadPops(reader);
var pop1 = pops.StoredPops[42];
var pop2 = pops.StoredPops[43];
Assert.Equal(2, pops.StoredPops.Count);
Assert.Equal((ulong)42, pop1.ID);
Assert.Equal((ulong)43, pop2.ID);
}
public void LiteralNonePopsAreNotLoaded()
{
var reader = new BufferedReader("= {\n 42=none\n 43={}\n 44=none\n }");
var pops = new Pops();
pops.LoadPops(reader);
Assert.Equal(1, pops.StoredPops.Count);
Assert.False(pops.StoredPops.ContainsKey(42));
Assert.True(pops.StoredPops.ContainsKey(43));
Assert.False(pops.StoredPops.ContainsKey(44));
var pop2 = pops.StoredPops[43];
Assert.Equal((ulong)43, pop2.ID);
}
/// <summary>
/// Gets a list of all cultures in the pool that have at least the threshhold as a proportion of the total population
/// </summary>
/// <param name="threshhold"></param>
/// <returns></returns>
public List <string> GetLargeCultures(float threshhold)
{
var cultures = new Dictionary <string, int>();
foreach (var pop in pops)
{
if (!cultures.ContainsKey(pop.Value.Culture))
{
cultures[pop.Value.Culture] = 0;
}
cultures[pop.Value.Culture] += pop.Value.Size;
}
var total = Pops.Sum(p => p.Size);
return(cultures.Where(c => c.Value / (float)total >= threshhold).Select(c => c.Key).ToList());
}
public void PostInitialise()
{
if (Eu4Provinces.Count > 0)
{
CalcEffects(World, SiblingProvinces, Eu4Provinces);
var largeCultures = Pops.GetLargeCultures(0.4f);
// TODO: dynamically create countries that don't have a primary nation in vic2
foreach (var cul in largeCultures)
{
World.CultureNations.KeyValuePairs.ForEach(cul, tag =>
{
Cores.Add(World.Vic2Countries.Find(c => c.CountryTag == tag) ?? new Vic2Country(World, tag, World.Cultures[cul]));
});
// add neoculture as accepted culture
if (World.V2Mapper.NeoCultures.ContainsKey(cul) && World.V2Mapper.NeoCultures[cul] == Owner?.PrimaryCulture)
{
if (!Owner.AcceptedCultures.Contains(cul))
{
Owner.AcceptedCultures.Add(cul);
}
}
if (World.Cultures[cul].PrimaryNation == null)
{
if (World.Cultures[cul].Group.Union == null)
{
}
}
else
{
Cores.Add(World.Cultures[cul].PrimaryNation);
}
if (World.Cultures[cul].Group.Union != null)
{
Cores.Add(World.Cultures[cul].Group.Union);
}
}
}
//effects on owner
if (Owner != null)
{
IterateEffects(World, World.CountryEffects.Sublists["province"], 1, Eu4Provinces, (effects, fromProvince) =>
{
Owner.FromProvinceEffect(effects);
});
}
}
private void Produce()
{
CarryIn(Pops.Select(pop => pop.Produce()).SelectMany(product => product));
}
private float MigrationValueOfPlanet(PlanetData pData, Pops pop)
{
float planetValue = 0f;
float FarmerJobsOnPlanet = 0f;
float MinerJobsOnPlanet = 0f;
float EngineerJobsOnPlanet = 0f;
float FluxmenJobsOnPlanet = 0f;
float AdministratorJobsOnPlanet = 0f;
float ScientistJobsOnPlanet = 0f;
float releventJobsOnPlanet = 0f;
foreach (Region rData in pData.RegionList)
{
FarmerJobsOnPlanet += rData.FarmingLevel - rData.FarmsStaffed;
MinerJobsOnPlanet += rData.MiningLevel - rData.MinesStaffed;
EngineerJobsOnPlanet += rData.ManufacturingLevel - rData.FactoriesStaffed;
FluxmenJobsOnPlanet += rData.HighTechLevel - rData.HighTechFacilitiesStaffed;
AdministratorJobsOnPlanet += rData.GovernmentLevel - rData.GovernmentFacilitiesStaffed;
ScientistJobsOnPlanet += rData.ScienceLevel - rData.LabsStaffed;
}
switch (pop.PopClass)
{
case Pops.ePopClass.Scientist:
releventJobsOnPlanet = ScientistJobsOnPlanet;
break;
case Pops.ePopClass.Farmer:
releventJobsOnPlanet = FarmerJobsOnPlanet;
break;
case Pops.ePopClass.Miner:
releventJobsOnPlanet = MinerJobsOnPlanet;
break;
case Pops.ePopClass.Engineer:
releventJobsOnPlanet = EngineerJobsOnPlanet;
break;
case Pops.ePopClass.Fluxmen:
releventJobsOnPlanet = FluxmenJobsOnPlanet;
break;
case Pops.ePopClass.Merchants:
break;
case Pops.ePopClass.Administrators:
releventJobsOnPlanet = AdministratorJobsOnPlanet;
break;
case Pops.ePopClass.None:
break;
default:
break;
}
planetValue += (2500 - HelperFunctions.Formulas.MeasureDistanceBetweenSystems(pData.System, pop.PlanetLocated.System)) + pData.AdjustedBio + pData.BasePlanetValue + (releventJobsOnPlanet * 50);
return(planetValue);
}
private List <Pop> GetUnemployed()
{
return(Pops.Where(pop => pop.Workplace == null).ToList());
}
public float CollectFaith()
{
return(Pops.Sum(pop => pop.Faith()));
}
public void IncreaseJob(PopType popType, float relativeAmount)
{
var pops = SplitPops((int)(Pops.Sum(p => p.Size) * relativeAmount), Pops, c => c, r => r);
pops.ForEach(AddPop);
}
private List <Workplace> GetVacantWorkplaces()
{
return(GetWorkplaces().Where(ws => !Pops.Select(pop => pop.Workplace).Contains(ws)).ToList());
}
