479 lines
17 KiB
Go
479 lines
17 KiB
Go
package koboldsim
|
|
|
|
import (
|
|
"math"
|
|
|
|
"git.chromaticdragon.app/kistaro/CardSimEngine/cardsim"
|
|
)
|
|
|
|
// KoboldMine is the state of a kobold mine.
|
|
type KoboldMine struct {
|
|
BasePopulation float64 `cardsim:"stathidden"`
|
|
|
|
MiningIncome float64 `cardsim:"stathidden" cardsim_name:"Mining Productivity"`
|
|
ScavengingIncome float64 `cardsim:"stathidden" cardsim_name:"Scavenging Productivity"`
|
|
AlchemyIncome float64 `cardsim:"stathidden" cardsim_name:"Alchemy Productivity"`
|
|
HospitalityIncome float64 `cardsim:"stathidden" cardsim_name:"Hospitality Productivity"`
|
|
AgricultureIncome float64 `cardsim:"stathidden" cardsim_name:"Agriculture Productivity"`
|
|
ManufacturingIncome float64 `cardsim:"stathidden" cardsim_name:"Manufacturing Productivity"`
|
|
PlanarIncome float64 `cardsim:"stathidden" cardsim_name:"Planar Productivity"`
|
|
PublishingIncome float64 `cardsim:"stathidden" cardsim_name:"Publishing Productivity"`
|
|
ForestryIncome float64 `cardsim:"stathidden" cardsim_name:"Forestry Productivity"`
|
|
FinanceIncome float64 `cardsim:"stathidden" cardsim_name:"Finance Productivity"`
|
|
GadgetryIncome float64 `cardsim:"stathidden" cardsim_name:"Gadgetry Productivity"`
|
|
FishingIncome float64 `cardsim:"stathidden" cardsim_name:"Fishing Productivity"`
|
|
ConstructionIncome float64 `cardsim:"stathidden" cardsim_name:"Construction Productivity"`
|
|
|
|
PropagandaExpense float64 `cardsim:"stathidden" cardsim_name:"Propaganda Investment"`
|
|
BureaucracyExpense float64 `cardsim:"stathidden" cardsim_name:"Bureaucracy Investment"`
|
|
WarExpense float64 `cardsim:"stathidden" cardsim_name:"War Investment"`
|
|
QoLExpense float64 `cardsim:"stathidden" cardsim_name:"QoL Investment"`
|
|
LogisticsExpense float64 `cardsim:"stathidden" cardsim_name:"Logistics Investment"`
|
|
DragonSubsExpense float64 `cardsim:"stathidden" cardsim_name:"Dragon Subsidies Investment"`
|
|
ResearchSubsExpense float64 `cardsim:"stathidden" cardsim_name:"Research Subsidies Investment"`
|
|
EducationExpense float64 `cardsim:"stathidden" cardsim_name:"Education Investment"`
|
|
HealthcareExpense float64 `cardsim:"stathidden" cardsim_name:"Healthcare Investment"`
|
|
ForeignRelExpense float64 `cardsim:"stathidden" cardsim_name:"Foreign Relations Investment"`
|
|
PoliceExpense float64 `cardsim:"stathidden" cardsim_name:"Law Enforcement Investment"`
|
|
EconPlanExpense float64 `cardsim:"stathidden" cardsim_name:"Economic Planning Investment"`
|
|
ParksExpense float64 `cardsim:"stathidden" cardsim_name:"Parks and Aesthetics Investment"`
|
|
FaithExpense float64 `cardsim:"stathidden" cardsim_name:"Faith Investment"`
|
|
|
|
FoodSupply float64 `cardsim:"stathidden"`
|
|
ObesogenicFood float64 `cardsim:"stathidden"`
|
|
ForeignRelations float64 `cardsim:"stathidden"`
|
|
HiddenRelPenalty float64 `cardsim:"stathidden"` // Lower is better.
|
|
Secrecy float64 `cardsim:"stathidden"`
|
|
PointOfDimReturns float64 `cardsim:"stathidden"`
|
|
Rebellion float64 `cardsim:"stathidden"`
|
|
Madness float64 `cardsim:"stathidden"`
|
|
Cruelty float64 `cardsim:"stathidden"`
|
|
|
|
// AnotherExpense float64 `cardsim:"hiddenround5"`
|
|
// A different way of adding stats that is slightly more empowering.
|
|
}
|
|
|
|
func (k *KoboldMine) ProductivityFunc(s float64) func() float64 {
|
|
return func() float64 {
|
|
return math.Max(s*float64(k.Kobolds()), 0)
|
|
}
|
|
}
|
|
|
|
func (k *KoboldMine) ProductivityTotal() float64 {
|
|
total := math.Max(k.MiningIncome, 0.01)
|
|
total += math.Max(k.ScavengingIncome, 0)
|
|
total += math.Max(k.AlchemyIncome, 0)
|
|
total += math.Max(k.HospitalityIncome, 0)
|
|
total += math.Max(k.AgricultureIncome, 0)
|
|
total += math.Max(k.ManufacturingIncome, 0)
|
|
total += math.Max(k.PlanarIncome, 0)
|
|
total += math.Max(k.PublishingIncome, 0)
|
|
total += math.Max(k.FinanceIncome, 0)
|
|
total += math.Max(k.GadgetryIncome, 0)
|
|
total += math.Max(k.FishingIncome, 0)
|
|
total += math.Max(k.ConstructionIncome, 0.02)
|
|
total += math.Max(k.PropagandaExpense, 0)
|
|
total += math.Max(k.BureaucracyExpense, 0)
|
|
total += math.Max(k.WarExpense, 0)
|
|
total += math.Max(k.QoLExpense, 0)
|
|
total += math.Max(k.LogisticsExpense, 0)
|
|
total += math.Max(k.DragonSubsExpense, 0)
|
|
total += math.Max(k.ResearchSubsExpense, 0)
|
|
total += math.Max(k.EducationExpense, 0)
|
|
total += math.Max(k.HealthcareExpense, 0)
|
|
total += math.Max(k.ForeignRelExpense, 0)
|
|
total += math.Max(k.PoliceExpense, 0)
|
|
total += math.Max(k.EconPlanExpense, 0)
|
|
total += math.Max(k.ParksExpense, 0)
|
|
total += math.Max(k.FaithExpense, 0)
|
|
return total
|
|
}
|
|
|
|
func (k *KoboldMine) ProductivityMultiplier() float64 {
|
|
return math.Pow(0.95, math.Max(0, k.ProductivityTotal()-k.PointOfDimReturns))
|
|
}
|
|
|
|
func (k *KoboldMine) TrueMiningIncome() float64 {
|
|
return math.Max(k.MiningIncome*k.ProductivityMultiplier(), 0.01)
|
|
}
|
|
|
|
func (k *KoboldMine) TrueScavengingIncome() float64 {
|
|
return math.Max(k.ScavengingIncome*k.ProductivityMultiplier(), 0)
|
|
}
|
|
|
|
func (k *KoboldMine) TrueAlchemyIncome() float64 {
|
|
return math.Max(k.AlchemyIncome*k.ProductivityMultiplier(), 0)
|
|
}
|
|
|
|
func (k *KoboldMine) TrueHospitalityIncome() float64 {
|
|
return math.Max(k.HospitalityIncome*k.ProductivityMultiplier(), 0)
|
|
}
|
|
|
|
func (k *KoboldMine) TrueAgricultureIncome() float64 {
|
|
return math.Max(k.AgricultureIncome*k.ProductivityMultiplier(), 0)
|
|
}
|
|
|
|
func (k *KoboldMine) TrueManufacturingIncome() float64 {
|
|
return math.Max(k.ManufacturingIncome*k.ProductivityMultiplier(), 0)
|
|
}
|
|
|
|
func (k *KoboldMine) TruePlanarIncome() float64 {
|
|
return math.Max(k.PlanarIncome*k.ProductivityMultiplier(), 0)
|
|
}
|
|
|
|
func (k *KoboldMine) TruePublishingIncome() float64 {
|
|
return math.Max(k.PublishingIncome*k.ProductivityMultiplier(), 0)
|
|
}
|
|
|
|
func (k *KoboldMine) TrueForestryIncome() float64 {
|
|
return math.Max(k.ForestryIncome*k.ProductivityMultiplier(), 0)
|
|
}
|
|
|
|
func (k *KoboldMine) TrueFinanceIncome() float64 {
|
|
return math.Max(k.FinanceIncome*k.ProductivityMultiplier(), 0)
|
|
}
|
|
|
|
func (k *KoboldMine) TrueGadgetryIncome() float64 {
|
|
return math.Max(k.GadgetryIncome*k.ProductivityMultiplier(), 0)
|
|
}
|
|
|
|
func (k *KoboldMine) TrueFishingIncome() float64 {
|
|
return math.Max(k.FishingIncome*k.ProductivityMultiplier(), 0)
|
|
}
|
|
|
|
func (k *KoboldMine) TrueConstructionIncome() float64 {
|
|
return math.Max(k.ConstructionIncome*k.ProductivityMultiplier(), 0)
|
|
}
|
|
|
|
func (k *KoboldMine) TruePropagandaExpense() float64 {
|
|
return math.Max(k.PropagandaExpense*k.ProductivityMultiplier(), 0)
|
|
}
|
|
|
|
func (k *KoboldMine) TrueBureaucracyExpense() float64 {
|
|
return math.Max(k.BureaucracyExpense*k.ProductivityMultiplier(), 0)
|
|
}
|
|
|
|
func (k *KoboldMine) TrueWarExpense() float64 {
|
|
return math.Max(k.WarExpense*k.ProductivityMultiplier(), 0)
|
|
}
|
|
|
|
func (k *KoboldMine) TrueQoLExpense() float64 {
|
|
return math.Max(k.QoLExpense*k.ProductivityMultiplier(), 0)
|
|
}
|
|
|
|
func (k *KoboldMine) TrueLogisticsExpense() float64 {
|
|
return math.Max(k.LogisticsExpense*k.ProductivityMultiplier(), 0)
|
|
}
|
|
|
|
func (k *KoboldMine) TrueDragonSubsExpense() float64 {
|
|
return math.Max(k.DragonSubsExpense*k.ProductivityMultiplier(), 0)
|
|
}
|
|
|
|
func (k *KoboldMine) TrueResearchSubsExpense() float64 {
|
|
return math.Max(k.ResearchSubsExpense*k.ProductivityMultiplier(), 0)
|
|
}
|
|
|
|
func (k *KoboldMine) TrueEducationExpense() float64 {
|
|
return math.Max(k.EducationExpense*k.ProductivityMultiplier(), 0)
|
|
}
|
|
|
|
func (k *KoboldMine) TrueHealthcareExpense() float64 {
|
|
return math.Max(k.HealthcareExpense*k.ProductivityMultiplier(), 0)
|
|
}
|
|
|
|
func (k *KoboldMine) TrueForeignRelExpense() float64 {
|
|
return math.Max(k.ForeignRelExpense*k.ProductivityMultiplier(), 0)
|
|
}
|
|
|
|
func (k *KoboldMine) TruePoliceExpense() float64 {
|
|
return math.Max(k.PoliceExpense*k.ProductivityMultiplier(), 0)
|
|
}
|
|
|
|
func (k *KoboldMine) TrueEconPlanExpense() float64 {
|
|
return math.Max(k.EconPlanExpense*k.ProductivityMultiplier(), 0)
|
|
}
|
|
|
|
func (k *KoboldMine) TrueParksExpense() float64 {
|
|
return math.Max(k.ParksExpense*k.ProductivityMultiplier(), 0)
|
|
}
|
|
|
|
func (k *KoboldMine) TrueFaithExpense() float64 {
|
|
return math.Max(k.FaithExpense*k.ProductivityMultiplier(), 0)
|
|
}
|
|
|
|
func (k *KoboldMine) TotalSectorIncome() float64 {
|
|
return float64(k.Kobolds()) * (math.Max(k.TrueMiningIncome(), 0.01) + math.Max(k.TrueScavengingIncome(), 0) + math.Max(k.TrueAlchemyIncome(), 0) + math.Max(k.TrueHospitalityIncome(), 0) + math.Max(k.TrueAgricultureIncome(), 0) + math.Max(k.TrueManufacturingIncome(), 0) + math.Max(k.TruePlanarIncome(), 0) + math.Max(k.TruePublishingIncome(), 0) + math.Max(k.TrueFinanceIncome(), 0) + math.Max(k.TrueGadgetryIncome(), 0) + math.Max(k.TrueFishingIncome(), 0) + math.Max(k.TrueConstructionIncome(), 0.02))
|
|
}
|
|
|
|
func (k *KoboldMine) TotalGovExpense() float64 {
|
|
return float64(k.Kobolds()) * (math.Max(k.TruePropagandaExpense(), 0) + math.Max(k.TrueBureaucracyExpense(), 0) + math.Max(k.TrueWarExpense(), 0) + math.Max(k.TrueQoLExpense(), 0) + math.Max(k.TrueLogisticsExpense(), 0) + math.Max(k.TrueDragonSubsExpense(), 0) + math.Max(k.TrueResearchSubsExpense(), 0) + math.Max(k.TrueEducationExpense(), 0) + math.Max(k.TrueHealthcareExpense(), 0) + math.Max(k.TrueForeignRelExpense(), 0) + math.Max(k.TruePoliceExpense(), 0) + math.Max(k.TrueEconPlanExpense(), 0) + math.Max(k.TrueParksExpense(), 0) + math.Max(k.TrueFaithExpense(), 0))
|
|
}
|
|
|
|
func (k *KoboldMine) Taxation() float64 {
|
|
return (k.TotalGovExpense() / (k.TotalSectorIncome() + k.TotalGovExpense())) * 100
|
|
}
|
|
|
|
func (k *KoboldMine) StatTaxRate() float64 {
|
|
return k.Taxation()
|
|
}
|
|
|
|
func (k *KoboldMine) Kobolds() int64 {
|
|
return int64((k.BasePopulation + (k.HealthcareExpense * 1000)) * k.FoodSupply * (1 - 0.5*(k.StatObesity()/100)) * (1 + k.TrueForeignRelations()))
|
|
}
|
|
|
|
func (k *KoboldMine) DisplayedFoodSupply() float64 {
|
|
return (k.FoodSupply - 1) * 100
|
|
}
|
|
|
|
func (k *KoboldMine) StatObesogenicity() float64 {
|
|
return (k.ObesogenicFood - 1) * 100
|
|
}
|
|
|
|
func (k *KoboldMine) StatObesity() float64 {
|
|
return (100 / (2.3 + math.Exp(-0.04*(k.DisplayedFoodSupply()-37)))) + 100/(2.3+math.Exp(-0.04*(k.StatObesogenicity()-37)))
|
|
}
|
|
|
|
func (k *KoboldMine) TrueForeignRelations() float64 {
|
|
return (1 - math.Max(math.Min(k.Secrecy, 1), 0)) * (math.Max(math.Min(k.ForeignRelations, 1), -1) - k.HiddenRelPenalty)
|
|
}
|
|
|
|
func (k *KoboldMine) DisplayedForeignRelations() float64 {
|
|
return math.Max(math.Min((k.ForeignRelations*100), 100), -100)
|
|
}
|
|
|
|
func (k *KoboldMine) DisplayedSecrecy() float64 {
|
|
return k.Secrecy * 100
|
|
}
|
|
|
|
// func (k *KoboldMine) StatSqualor() float64 {
|
|
// return ???
|
|
//}
|
|
// I want squalor to start out high and new "nations" to be plagued by crimes of poverty. As the economy comes online, squalor should be suppressed. Different categories of investment are differently effective in achieving this, with QoL spending being the most effective and Scavenging Income... maybe even aggravating squalor. How do I stat this? Game design is hard.
|
|
|
|
// Okay, so I'm thinking that I want to generate a Squalor Resistance stat based on all the categories of input.
|
|
|
|
func (k *KoboldMine) SqualorReduction() float64 {
|
|
total := math.Max(k.MiningIncome, 0.01)
|
|
total -= math.Max(k.ScavengingIncome, 0)
|
|
total += math.Max(k.AlchemyIncome, 0)
|
|
total += math.Max(k.HospitalityIncome, 0) * 2
|
|
total += math.Max(k.ManufacturingIncome, 0)
|
|
total += math.Max(k.PlanarIncome, 0)
|
|
total += math.Max(k.PublishingIncome, 0) * 2
|
|
total += math.Max(k.FinanceIncome, 0) * 3
|
|
total += math.Max(k.GadgetryIncome, 0) * 2
|
|
total += math.Max(k.ConstructionIncome, 0.02) * 2
|
|
total += math.Max(k.PropagandaExpense, 0)
|
|
total += math.Max(k.BureaucracyExpense, 0) * 2
|
|
total += math.Max(k.QoLExpense, 0) * 20
|
|
total += math.Max(k.LogisticsExpense, 0)
|
|
total += math.Max(k.ResearchSubsExpense, 0) * 2
|
|
total += math.Max(k.EducationExpense, 0) * 4
|
|
total += math.Max(k.HealthcareExpense, 0) * 6
|
|
total += math.Max(k.ForeignRelExpense, 0)
|
|
total += math.Max(k.PoliceExpense, 0)
|
|
total += math.Max(k.EconPlanExpense, 0)
|
|
total += math.Max(k.ParksExpense, 0) * 3
|
|
total += math.Max(k.FaithExpense, 0) * 10
|
|
return total
|
|
}
|
|
|
|
func (k *KoboldMine) StatSqualor() float64 {
|
|
return 100 * math.Pow(1.204, 1.2-(2*k.SqualorReduction()))
|
|
}
|
|
|
|
// So I want squalor to be a value between 100 and 0 that reduces readily at the start and then becomes increasingly difficult to further reduce. This initial squalor stat starts at about 80%, but may not change rapidly enough. Note that the 1.2-(2* sequence is meant to balance it at 80% starting point. If I change the velocity on the 2* side, I have to change the 1.2 offset as well. I really hope this math works, because I don't quite understand it.
|
|
|
|
func (k *KoboldMine) StatChaos() float64 {
|
|
return (k.Rebellion + k.Madness + k.Cruelty) / 3
|
|
}
|
|
|
|
func (k *KoboldMine) Stats() []cardsim.Stat {
|
|
stats := cardsim.ExtractStats(k)
|
|
funcs := []cardsim.Stat{
|
|
cardsim.StatFunc(
|
|
"Mining Income",
|
|
k.ProductivityFunc(k.TrueMiningIncome()),
|
|
),
|
|
cardsim.StatFunc(
|
|
"Scavenging Income",
|
|
k.ProductivityFunc(k.TrueScavengingIncome()),
|
|
),
|
|
cardsim.StatFunc(
|
|
"Alchemy Income",
|
|
k.ProductivityFunc(k.TrueAlchemyIncome()),
|
|
),
|
|
cardsim.StatFunc(
|
|
"Hospitality Income",
|
|
k.ProductivityFunc(k.TrueHospitalityIncome()),
|
|
),
|
|
cardsim.StatFunc(
|
|
"Agriculture Income",
|
|
k.ProductivityFunc(k.TrueAgricultureIncome()),
|
|
),
|
|
cardsim.StatFunc(
|
|
"Manufacturing Income",
|
|
k.ProductivityFunc(k.TrueManufacturingIncome()),
|
|
),
|
|
cardsim.StatFunc(
|
|
"Planar Harvesting Income",
|
|
k.ProductivityFunc(k.TruePlanarIncome()),
|
|
),
|
|
cardsim.StatFunc(
|
|
"Book Publishing Income",
|
|
k.ProductivityFunc(k.TruePublishingIncome()),
|
|
),
|
|
cardsim.StatFunc(
|
|
"Forestry Income",
|
|
k.ProductivityFunc(k.TrueForestryIncome()),
|
|
),
|
|
cardsim.StatFunc(
|
|
"Finance Income",
|
|
k.ProductivityFunc(k.TrueFinanceIncome()),
|
|
),
|
|
cardsim.StatFunc(
|
|
"Gadgetry Income",
|
|
k.ProductivityFunc(k.TrueGadgetryIncome()),
|
|
),
|
|
cardsim.StatFunc(
|
|
"Fishing Income",
|
|
k.ProductivityFunc(k.TrueFishingIncome()),
|
|
),
|
|
cardsim.StatFunc(
|
|
"Construction Income",
|
|
k.ProductivityFunc(k.TrueConstructionIncome()),
|
|
),
|
|
cardsim.StatFunc(
|
|
"Propaganda Expense",
|
|
k.ProductivityFunc(k.TruePropagandaExpense()),
|
|
),
|
|
cardsim.StatFunc(
|
|
"Bureaucracy Expense",
|
|
k.ProductivityFunc(k.TrueBureaucracyExpense()),
|
|
),
|
|
cardsim.StatFunc(
|
|
"War Expense",
|
|
k.ProductivityFunc(k.TrueWarExpense()),
|
|
),
|
|
cardsim.StatFunc(
|
|
"QoL Expense",
|
|
k.ProductivityFunc(k.TrueQoLExpense()),
|
|
),
|
|
cardsim.StatFunc(
|
|
"Logistics Expense",
|
|
k.ProductivityFunc(k.TrueLogisticsExpense()),
|
|
),
|
|
cardsim.StatFunc(
|
|
"Dragon Subsidies",
|
|
k.ProductivityFunc(k.TrueDragonSubsExpense()),
|
|
),
|
|
cardsim.StatFunc(
|
|
"Research Subsidies",
|
|
k.ProductivityFunc(k.TrueResearchSubsExpense()),
|
|
),
|
|
cardsim.StatFunc(
|
|
"Education Expense",
|
|
k.ProductivityFunc(k.TrueEducationExpense()),
|
|
),
|
|
cardsim.StatFunc(
|
|
"Healthcare Expense",
|
|
k.ProductivityFunc(k.TrueHealthcareExpense()),
|
|
),
|
|
cardsim.StatFunc(
|
|
"Foreign Relations Expense",
|
|
k.ProductivityFunc(k.TrueForeignRelExpense()),
|
|
),
|
|
cardsim.StatFunc(
|
|
"Law Enforcement Expense",
|
|
k.ProductivityFunc(k.TruePoliceExpense()),
|
|
),
|
|
cardsim.StatFunc(
|
|
"Economic Planning Expense",
|
|
k.ProductivityFunc(k.TrueEconPlanExpense()),
|
|
),
|
|
cardsim.StatFunc(
|
|
"Parks and Aesthetics Expense",
|
|
k.ProductivityFunc(k.TrueParksExpense()),
|
|
),
|
|
cardsim.StatFunc(
|
|
"Faith Expense",
|
|
k.ProductivityFunc(k.TrueFaithExpense()),
|
|
),
|
|
cardsim.StatFunc(
|
|
"Total Sector Income",
|
|
k.TotalSectorIncome,
|
|
),
|
|
cardsim.StatFunc(
|
|
"Total Government Expense",
|
|
k.TotalGovExpense,
|
|
),
|
|
cardsim.StatFunc(
|
|
"Foreign Relations",
|
|
k.DisplayedForeignRelations,
|
|
),
|
|
cardsim.StatFunc(
|
|
"Secrecy",
|
|
k.DisplayedSecrecy,
|
|
),
|
|
cardsim.StatFunc(
|
|
"Food Supply",
|
|
k.DisplayedFoodSupply,
|
|
),
|
|
cardsim.StatFunc(
|
|
"Kobolds",
|
|
k.Kobolds,
|
|
),
|
|
cardsim.InvisibleStatFunc(
|
|
"Squalor Reduction",
|
|
k.SqualorReduction,
|
|
),
|
|
cardsim.StatFunc(
|
|
"Squalor",
|
|
k.StatSqualor,
|
|
),
|
|
}
|
|
stats = append(stats, funcs...)
|
|
// cardsim.SortStats(stats)
|
|
return stats
|
|
}
|
|
|
|
func NewKoboldMine() *KoboldMine {
|
|
return &KoboldMine{
|
|
BasePopulation: 1025,
|
|
MiningIncome: 0.15,
|
|
ScavengingIncome: 0.1,
|
|
AlchemyIncome: 0.01,
|
|
HospitalityIncome: 0.0,
|
|
AgricultureIncome: 0.0,
|
|
ManufacturingIncome: 0.10,
|
|
PlanarIncome: 0.00,
|
|
PublishingIncome: 0.02,
|
|
ForestryIncome: 0.0,
|
|
FinanceIncome: 0.02,
|
|
GadgetryIncome: 0.03,
|
|
FishingIncome: 0.0,
|
|
ConstructionIncome: 0.05,
|
|
PropagandaExpense: 0.01,
|
|
BureaucracyExpense: 0.05,
|
|
WarExpense: 0.1,
|
|
QoLExpense: 0.01,
|
|
LogisticsExpense: 0.02,
|
|
DragonSubsExpense: 0.0,
|
|
ResearchSubsExpense: 0.0,
|
|
EducationExpense: 0.01,
|
|
HealthcareExpense: 0.01,
|
|
ForeignRelExpense: 0.0,
|
|
PoliceExpense: 0.03,
|
|
EconPlanExpense: 0.02,
|
|
ParksExpense: 0.0,
|
|
FaithExpense: 0.03,
|
|
FoodSupply: 0.20,
|
|
ForeignRelations: -0.40,
|
|
HiddenRelPenalty: -0.01,
|
|
Secrecy: .95,
|
|
PointOfDimReturns: 1.0,
|
|
}
|
|
}
|
|
|
|
// Note that the mine initializes with 1.02 points of overall productivity.
|