Reus decompiled growth code

        private void UpdateGrowthSpeed()
        {
            float num = 0f;
            float num2 = 0f;
            float num3 = 0f;
            float totalFood = this.Civilization.TotalFood;
            float totalMechanics = this.Civilization.TotalMechanics;
            float totalValuables = this.Civilization.TotalValuables;
            float arg_51_0 = totalFood * this.parameters.PopulationSustainance / this.parameters.GrowthDif;
            float arg_6C_0 = totalMechanics * this.parameters.TechnologySustainance / this.parameters.GrowthDif;
            float arg_87_0 = totalValuables * this.parameters.WealthSustainance / this.parameters.GrowthDif;
            if (totalFood * this.parameters.PopulationSustainance > this.Civilization.Population)
            {
                num += this.parameters.BaseGrowth;
            }
            if (totalMechanics * this.parameters.TechnologySustainance > this.Civilization.Technology)
            {
                num2 += this.parameters.BaseGrowth;
            }
            if (totalValuables * this.parameters.WealthSustainance > this.Civilization.Wealth)
            {
                num3 += this.parameters.BaseGrowth;
            }
            num += (totalFood * this.parameters.PopulationSustainance - this.Civilization.Population) * this.parameters.AbundanceToPopGrowth;
            num2 += (totalMechanics * this.parameters.TechnologySustainance - this.Civilization.Technology) * this.parameters.MechanicsToTechGrowth;
            num3 += (totalValuables * this.parameters.WealthSustainance - this.Civilization.Wealth) * this.parameters.ValuablesToWealthGrowth;
            float num4 = num;
            float num5 = num2;
            float num6 = num3;
            num = Math.Min(num, this.parameters.MaxGrowth);
            num2 = Math.Min(num2, this.parameters.MaxGrowth);
            num3 = Math.Min(num3, this.parameters.MaxGrowth);
            this.Civilization.PopulationGrowth.InitialValue = num;
            this.Civilization.TechnologyGrowth.InitialValue = num2;
            this.Civilization.WealthGrowth.InitialValue = num3;
            if (num4 > this.parameters.GreedThreshold + this.Civilization.ApathyRR * this.parameters.ReductionRankPower)
            {
                this.Civilization.ApathyGrowth.InitialValue = this.parameters.GreedGrowth;
            }
            else
            {
                this.Civilization.ApathyGrowth.InitialValue = this.parameters.GreedGrowthMinimum;
            }
            if (num5 > this.parameters.GreedThreshold + this.Civilization.ApathyRR * this.parameters.ReductionRankPower)
            {
                this.Civilization.ToxicityGrowth.InitialValue = this.parameters.GreedGrowth;
            }
            else
            {
                this.Civilization.ToxicityGrowth.InitialValue = this.parameters.GreedGrowthMinimum;
            }
            if (num6 > this.parameters.GreedThreshold + this.Civilization.ApathyRR * this.parameters.ReductionRankPower)
            {
                this.Civilization.GreedGrowth.InitialValue = this.parameters.GreedGrowth;
                return;
            }
            this.Civilization.GreedGrowth.InitialValue = this.parameters.GreedGrowthMinimum;
        }




        protected override void Tick(GameTime gameTime)
        {
            this.firstGrowTick = false;
            float num = new float[]
            {
                this.Civilization.Population,
                this.Civilization.Wealth,
                this.Civilization.Technology
            }.Max();
            float num2 = this.parameters.BaseHP + this.parameters.HPModifier * (0.75f * num + 0.25f * ((this.Civilization.Population + this.Civilization.Wealth + this.Civilization.Technology) / 3f));
            float num3 = (float)((int)((num2 - this.Civilization.MaxHP) / this.parameters.HPStepSize)) * this.parameters.HPStepSize;
            this.Civilization.MaxHP += num3;
            if (num3 > 0f)
            {
                this.Civilization.HP += num3;
            }
            this.Civilization.MaxHP = Math.Max(this.parameters.BaseHP, this.Civilization.MaxHP);
            this.Civilization.HP += this.parameters.HPRegen / 100f * this.Civilization.MaxHP;
            this.Civilization.HP = Math.Min(this.Civilization.HP, this.Civilization.MaxHP);
            this.UpdateGrowthSpeed();
            this.Civilization.DangerAcceptance = this.parameters.DangerAcceptanceBase + this.parameters.DangerAcceptanceModifier * this.Civilization.StatStrength;
            this.Civilization.DangerPatrollingLevel = this.parameters.DangerPatrollingBase + this.parameters.DangerPatrollingModifier * this.Civilization.StatStrength;
            this.GrowReach();
            float num4 = this.parameters.BasePopulationCap + this.Civilization.TotalFood * this.parameters.AbundanceToPopulationCapFactor;
            float num5 = this.parameters.BaseWealthCap + this.Civilization.TotalValuables * this.parameters.AbundanceToPopulationCapFactor;
            float num6 = this.parameters.BaseTechnologyCap + this.Civilization.TotalMechanics * this.parameters.AbundanceToPopulationCapFactor;
            float max = this.parameters.HardCapPercentagePopulation / 100f * num4;
            float max2 = this.parameters.HardCapPercentageWealth / 100f * num5;
            float max3 = this.parameters.HardCapPercentageTechnology / 100f * num6;
            float value = this.Civilization.Population + ((this.Civilization.Population >= num4) ? this.parameters.SoftCapGrowthRatio : 1f) * this.Civilization.PopulationGrowth;
            float value2 = this.Civilization.Wealth + ((this.Civilization.Wealth >= num5) ? this.parameters.SoftCapGrowthRatio : 1f) * this.Civilization.WealthGrowth;
            float value3 = this.Civilization.Technology + ((this.Civilization.Technology >= num6) ? this.parameters.SoftCapGrowthRatio : 1f) * this.Civilization.TechnologyGrowth;
            this.Civilization.Population = MathHelper.Clamp(value, 0f, max);
            this.Civilization.Wealth = MathHelper.Clamp(value2, 0f, max2);
            this.Civilization.Technology = MathHelper.Clamp(value3, 0f, max3);
            this.Civilization.Apathy.InitialValue = MathHelper.Clamp(this.Civilization.Apathy.InitialValue + this.Civilization.ApathyGrowth, 0f, this.parameters.IrresponsibilityCap);
            this.Civilization.Greed.InitialValue = MathHelper.Clamp(this.Civilization.Greed.InitialValue + this.Civilization.GreedGrowth, 0f, this.parameters.IrresponsibilityCap);
            this.Civilization.Toxicity.InitialValue = MathHelper.Clamp(this.Civilization.Toxicity.InitialValue + this.Civilization.ToxicityGrowth, 0f, this.parameters.IrresponsibilityCap);
            if (this.Civilization.DangerState == CivilizationDangerStates.Struggling)
            {
                this.Civilization.ReachPoints -= ModelSettings.Instance.CivParams.Danger.DangerShrinkRate;
            }
            else
            {
                if (this.Civilization.DangerState == CivilizationDangerStates.Panic)
                {
                    this.Civilization.ReachPoints -= ModelSettings.Instance.CivParams.Danger.DangerShrinkRatePanic;
                }
                else
                {
                    this.Civilization.ReachPoints += this.parameters.ReachPointsPerSecond;
                }
            }
            float val = this.Civilization.Army + this.parameters.ArmyRegenPerTick;
            float val2 = this.ComputeMaxArmy();
            this.Civilization.Army = Math.Min(val, val2);
            if (!this.Civilization.IsTypeGrounded)
            {
                Patch[] cityCenter = this.Civilization.CityCenter;
                this.Civilization.CivilizationType = ((PatchType[])Enum.GetValues(typeof(PatchType))).ArgMax((PatchType t) => cityCenter.Count((Patch p) => p.Type == t));
            }
        }





        private void GrowReach()
        {
            if (this.Civilization.IsDisrupted)
            {
                if (this.Civilization.ReachPoints <= -this.parameters.ReachLossCost)
                {
                    float num = this.Civilization.GetReach(true, 0).Sum((Patch p) => p.Danger);
                    float num2 = this.Civilization.GetReach(false, 0).Sum((Patch p) => p.Danger);
                    int num3;
                    Reach reach;
                    if (num > num2 || (num.Equals(num2) && (double)RandomHelper.NextFloat() < 0.5))
                    {
                        num3 = -1;
                        reach = this.Civilization.ReachLeft;
                    }
                    else
                    {
                        num3 = 1;
                        reach = this.Civilization.ReachRight;
                    }
                    this.Civilization.ReachPoints += this.parameters.ReachLossCost;
                    reach.NextPatch = this.Civilization.Planet.Surface[reach.NextPatch.Index + num3];
                    reach.Span--;
                }
            }
            else
            {
                float num4 = this.ComputeBuyValue(this.Civilization.ReachLeft.NextPatch);
                float num5 = this.ComputeBuyValue(this.Civilization.ReachRight.NextPatch);
                int num6 = 0;
                float num7 = 0f;
                Reach reach2 = null;
                if (this.Civilization.ReachPoints >= num4)
                {
                    num6 = 1;
                    num7 = num4;
                    reach2 = this.Civilization.ReachLeft;
                }
                else
                {
                    if (this.Civilization.ReachPoints >= num5)
                    {
                        num6 = -1;
                        num7 = num5;
                        reach2 = this.Civilization.ReachRight;
                    }
                }
                if (num6 != 0)
                {
                    reach2.NextPatch = this.Civilization.Planet.Surface[reach2.NextPatch.Index + num6];
                    reach2.Span++;
                    this.Civilization.ReachPoints -= num7;
                }
            }
            Patch disruptedPatch = this.GetDisruptedPatch(true);
            this.Civilization.ReachLeft.IsDisrupted = (disruptedPatch != null);
            disruptedPatch = this.GetDisruptedPatch(false);
            this.Civilization.ReachRight.IsDisrupted = (disruptedPatch != null);
        }




        private Patch GetDisruptedPatch(bool left)
        {
            return this.Civilization.GetReach(left, 0).FirstOrDefault(new Func<Patch, bool>(this.Civilization.IsDangerous));
        }




        private float ComputeBuyValue(Patch patch)
        {
            float num = 0f;
            float num2 = 1f;
            if (patch.Owner != null)
            {
                return float.PositiveInfinity;
            }
            num += this.parameters.ReachExpandDangerModifier * patch.Slots.OfType<NatureAsset>().Sum((NatureAsset a) => a.Definition.Danger);
            num += this.parameters.ReachExpandDistanceModifier * (float)(this.Civilization.GetDistance(patch.Index) - Civilization.Radius);
            if (patch.Type != this.Civilization.CivilizationType)
            {
                switch (patch.Type)
                {
                    case PatchType.Swamp:
                    {
                        num += this.parameters.ReachExpandSwampCost;
                        break;
                    }
                    case PatchType.Desert:
                    {
                        num += this.parameters.ReachExpandDesertCost;
                        break;
                    }
                    case PatchType.Ocean:
                    {
                        num += this.parameters.ReachExpandOceanCost;
                        break;
                    }
                    case PatchType.Mountain:
                    {
                        num += this.parameters.ReachExpandMountainCost;
                        break;
                    }
                }
            }
            else
            {
                num2 -= this.parameters.ReachExpandSameTypeDiscount;
            }
            num2 -= this.parameters.ReachExpandAssetDiscount * (float)patch.Slots.OfType<FloraAsset>().Count((FloraAsset f) => f.Definition.IsSpecial && f.Definition.Danger <= 0f);
            num2 -= this.parameters.ReachExpandAssetDiscount * (float)patch.Slots.OfType<AnimalSourceAsset>().Count((AnimalSourceAsset f) => f.Definition.Danger <= 0f);
            return num * num2;
        }