424 lines
15 KiB
Go
424 lines
15 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"`
|
|
ForeignRelations float64 `cardsim:"stathidden"`
|
|
HiddenRelPenalty float64 `cardsim:"stathidden"` // Lower is better.
|
|
Secrecy float64 `cardsim:"stathidden"`
|
|
PointOfDimReturns 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) TotalEconomicPotential() float64 {
|
|
// return (math.Max(k.MiningIncome, 0.01) + math.Max(k.ScavengingIncome, 0) + math.Max(k.AlchemyIncome, 0) + math.Max(k.HospitalityIncome, 0) + math.Max(k.AgricultureIncome, 0) + math.Max(k.ManufacturingIncome, 0) + math.Max(k.PlanarIncome, 0) + math.Max(k.PublishingIncome, 0) + math.Max(k.FinanceIncome, 0) + math.Max(k.GadgetryIncome, 0) + math.Max(k.FishingIncome, 0) + math.Max(k.ConstructionIncome, 0.02) + math.Max(k.PropagandaExpense, 0) + math.Max(k.BureaucracyExpense, 0) + math.Max(k.WarExpense, 0) + math.Max(k.QoLExpense, 0) + math.Max(k.LogisticsExpense, 0) + math.Max(k.DragonSubsExpense, 0) + math.Max(k.ResearchSubsExpense, 0) + math.Max(k.EducationExpense, 0) + math.Max(k.HealthcareExpense, 0) + math.Max(k.ForeignRelExpense, 0) + math.Max(k.PoliceExpense, 0) + math.Max(k.EconPlanExpense, 0) + math.Max(k.ParksExpense, 0) + math.Max(k.FaithExpense, 0)) * 0.8
|
|
//} // This function is intended to enable "crowding out" effects at a later point. Each +1 increase in overall productivity increases TEP by 0.8, losing 1/5th of the gain to crowding, which should manifest as everything else declining. Now, uh... How do I scale investments by the TEP stat? With a simple multiplication, a 0.01 increase to mining would be a 0.08 increase to everything else. Damn it, I thought I had something.
|
|
|
|
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) StatObesity() float64 {
|
|
return 100 / (2.3 + math.Exp(-0.04*(k.DisplayedFoodSupply()-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) 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,
|
|
),
|
|
}
|
|
stats = append(stats, funcs...)
|
|
// cardsim.SortStats(stats)
|
|
return stats
|
|
}
|
|
|
|
func NewKoboldMine() *KoboldMine {
|
|
return &KoboldMine{
|
|
BasePopulation: 1030,
|
|
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.
|