KoboldSim/koboldsim/stats.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.