public void PerformGoldenAgeTasks()
        {
            if (GoldenAgeCanon.IsCivInGoldenAge(this))
            {
                GoldenAgeCanon.ChangeTurnsOfGoldenAgeForCiv(this, -1);

                if (GoldenAgeCanon.GetTurnsLeftOnGoldenAgeForCiv(this) <= 0)
                {
                    GoldenAgeCanon.StopGoldenAgeForCiv(this);
                }
            }
            else
            {
                int happiness = CivHappinessLogic.GetNetHappinessOfCiv(this);

                GoldenAgeCanon.ChangeGoldenAgeProgressForCiv(this, happiness);

                float progressTowards = GoldenAgeCanon.GetGoldenAgeProgressForCiv(this);
                float progressNeeded  = GoldenAgeCanon.GetNextGoldenAgeCostForCiv(this);

                if (progressTowards >= progressNeeded)
                {
                    GoldenAgeCanon.SetGoldenAgeProgressForCiv(this, 0f);
                    GoldenAgeCanon.StartGoldenAgeForCiv(this, GoldenAgeCanon.GetGoldenAgeLengthForCiv(this));
                }
            }
        }
        /// <inheritdoc/>
        public YieldSummary GetYieldMultipliersForCivilization(ICivilization civ)
        {
            if (civ == null)
            {
                throw new ArgumentNullException("civilization");
            }

            var retval = YieldSummary.Empty;

            foreach (var city in CityPossessionCanon.GetPossessionsOfOwner(civ))
            {
                foreach (var building in BuildingPossessionCanon.GetPossessionsOfOwner(city))
                {
                    retval += building.CivilizationYieldModifier;
                }
            }

            int civHappiness = CivHappinessLogic.GetNetHappinessOfCiv(civ);

            if (civHappiness < 0)
            {
                var goldAndProductionLoss = civHappiness * CivConfig.YieldLossPerUnhappiness;

                retval[YieldType.Gold]       += goldAndProductionLoss;
                retval[YieldType.Production] += goldAndProductionLoss;
            }

            if (GoldenAgeCanon.IsCivInGoldenAge(civ))
            {
                retval += CivConfig.GoldenAgeProductionModifiers;
            }

            return(retval);
        }
        public float GetFoodStockpileAdditionFromIncome(ICity city, float foodIncome)
        {
            var cityOwner = CityPossessionCanon.GetOwnerOfPossession(city);

            var ownerHappiness = CivilizationHappinessLogic.GetNetHappinessOfCiv(cityOwner);

            float unmodifiedFoodGained;

            if (ownerHappiness < 0)
            {
                if (ownerHappiness > -10)
                {
                    unmodifiedFoodGained = foodIncome / 4f;
                }
                else
                {
                    unmodifiedFoodGained = 0;
                }
            }
            else
            {
                unmodifiedFoodGained = foodIncome;
            }

            float growthModifier = CityModifiers.Growth.GetValueForCity(city);

            return(unmodifiedFoodGained * growthModifier);
        }
 public override void Refresh()
 {
     if (ObjectToDisplay != null)
     {
         HappinessField.text = YieldFormatter.GetTMProFormattedHappinessString(
             CivHappinessLogic.GetNetHappinessOfCiv(ObjectToDisplay)
             );
     }
 }
        private float GetUnhappinessPenalty(IUnit unit)
        {
            var unitOwner = UnitPossessionCanon.GetOwnerOfPossession(unit);

            if (unitOwner == null)
            {
                return(0f);
            }

            var ownerHappiness = CivilizationHappinessLogic.GetNetHappinessOfCiv(unitOwner);

            if (ownerHappiness < 0)
            {
                return(ownerHappiness * CivConfig.ModifierLossPerUnhappiness);
            }
            else
            {
                return(0f);
            }
        }