private void UpdateLocalExpansionDesire()
 {
     if (localTilePopulationCapCached <= 0f)
     {
         Utils.Log.Error($"'{nameof(localTilePopulationCapCached)}' was: '{localTilePopulationCapCached.OrNull()}'! - Should have been set by now! Setting it now... - '{this.parent.OrNull()}'");
         localTilePopulationCapCached = GetPopulationCapForTile(myTileId, populationSoftCap, populationHardCap, myTile);
     }
     if (population <= 0f || localTilePopulationCapCached <= 0f) { localExpansionDesireCached = 0f; populationDensityRatio = 0f; return; }
     if (population > localTilePopulationCapCached)
     {
         populationDensityRatio = 1;
     }
     else
     {
         populationDensityRatio = population / localTilePopulationCapCached;
     }
     localExpansionDesireCached = populationDensityRatio;
 }

 /// <summary>Calculate a faction's desire to expand it's settlement count</summary>
 /// <param name="faction">The faction who's expansion desire we are calculating</param>
 /// <param name="strongest">Strongest faction on the map</param>
 /// <param name="weakest">weakest faction on the map</param>
 /// <returns>float in a range of 0f-1f</returns>
 public static Ratio CalculateFactionExpansionDesire(this Faction faction, Faction strongest, Faction weakest)
 {
     if (faction == null || strongest == null || weakest == null)
     {
         Utils.Log.Error_Null(nameof(faction), nameof(strongest), nameof(weakest), $"({faction.AsParam(nameof(faction))}, {strongest.AsParam(nameof(strongest))}, {weakest.AsParam(nameof(weakest))})");
         return 0;
     }

     (int bases, int population, int popCap) = faction.GetSettlementCountAndTotalPopulation();
     float desire = (float)((float)population / popCap);

     if (faction == strongest) { desire *= 0.5f; }
     else if (faction == weakest) { desire *= 1.5f; }

     desire -= bases * 0.01f;

     return desire.ClampRatio();
 }

/// <summary>Calculate a faction's general desire to make peace with other factions</summary>
/// <param name="faction">The faction who's truce desire we are calculating</param>
/// <param name="strongest">Strongest faction on the map</param>
/// <param name="weakest">weakest faction on the map</param>
/// <returns>float in a range of 0f-1f</returns>
public static Ratio CalculateTruceDesire(this Faction faction, Faction strongest, Faction weakest)
{
    if (faction == null || strongest == null || weakest == null)
    {
        Utils.Log.Error_Null(nameof(faction), nameof(strongest), nameof(weakest), $"({faction.AsParam(nameof(faction))}, {strongest.AsParam(nameof(strongest))}, {weakest.AsParam(nameof(weakest))})");
        return 0;
    }

    if (faction.def.GetModExtension<FactionExtensions>()?.allowDiplomacy != true)
    {
        Utils.Log.ErrorOnce($"'{faction.OrNull()}' does not allow diplomacy but: '{nameof(CalculateTruceDesire)}' was called -> will always return '{Ratio.Zero}'!");
        return Ratio.Zero;
    }

    ushort ourSettlementCount = faction.SettlementCount();
    float desire = World.NQoL_WorldComp.AllSettlementsCount / (float)(ourSettlementCount * ourSettlementCount);

    if (faction == weakest) { desire *= 2f; }
    else if (faction == strongest) { desire *= 0.25f; }
    if (faction != strongest && faction.RelationWith(strongest).kind == FactionRelationKind.Hostile) { desire *= 2f; }
    desire *= 0.01f;

    return desire.ClampRatio();
}

public static float GetCurrentPopulationGrowthRatePerDay(float localStaticGrowthRate, float biomePopulationCap, float currentPopulation, Factor localFertility, Ratio populationDensityRatio)
{
    float logisticGrowth = biomePopulationCap * currentPopulation * (1f - populationDensityRatio);
    return localStaticGrowthRate * logisticGrowth * localFertility;
}

private Factor UpdateCachedFertility()
{
    localFertilityCached = myTileId.LocalFertility(Session.Instance.World!.grid) * 0.14285f;
    return localFertilityCached;
}

public static Factor LocalFertility(this int tile, WorldGrid? worldGrid = null, int radius = 6)
{
    if (tile < 0) { Utils.Log.Error_InvalidInput_WithReason(nameof(tile), $"({tile.AsParam(nameof(tile))}, {worldGrid.AsParam()})", "has an invalid tile id!"); return Factor.Invalid; }
    else { if (Session.Instance?.World == null || TileCount <= -1 || (worldGrid != null && Session.Instance!.World!.grid != worldGrid)) { Session.NewSession.World = Find.World; } }
    List<int> relevantTiles = Tile_.GetTilesInRadius(tile, radius, out int count, Session.Instance!.World!.grid); //RelevantTiles(tile, radius, out int count); // new List<int>(); //tile.NeighbouringTiles(WorldGrid);
    //int nC = n.Count;
    Factor totalFertility = 0f; // tile.TileFertilityFactor(WorldGrid);
    for (int i = 0; i < count; i++)
    {
        totalFertility += relevantTiles[i].TileFertilityFactor(Session.Instance!.World!.grid);
    }
    return Utils.Math.Clamp(totalFertility, 1f, 999f);
}

public static Factor TileFertilityFactor(this int tile, WorldGrid? worldGrid = null)
{
    if (tile < 0) { Utils.Log.Error_InvalidInput_WithReason(tile.AsParam(nameof(tile)), $"({tile.AsParam(nameof(tile))}, {worldGrid.AsParam(nameof(worldGrid))})", "has an invalid tile id!"); return Factor.Invalid; }
    else { if (Session.Instance?.World == null || TileCount <= -1) { Session.NewSession.World = Find.World; } }
    return Session.Instance!.World!.grid.tiles[tile].TileFertilityFactor(tile);
}

bool attackerVictory = DoBattleSim
(
    attackers: population * 0.5f,
    attackerTechLevel: myFaction!.def.techLevel,
    attackerCasualties: out float attackerCasualties,
    battleGoal: out battleGoal,
    defenders: theirComp!.population,
    defenderTechLevel: theirFaction.def.techLevel,
    defenderCasualties: out float defenderCasualties,
    hilliness: battleFieldTile.hilliness,
    attackSuccessChance: out _,
    attackerFaction: myFaction,
    defenderFaction: theirFaction,
    biome: battleFieldTile.biome,
    defenderComp: theirComp
);

public static bool MakeWarTornAround(this Tile tile, int tileId, WorldGrid? worldGrid = null)
{
}