Forestry tab

Mostly a commit to see if I can still commit.

.vscode/koboldsimsnippets.code-snippets

@@ -15,13 +15,4 @@
 	// 	],
 	// 	"description": "Log output to console"
 	// }
-	"KoboldMine Add case": {
-		"scope": "go",
-		"prefix": "case",
-		"body": [
-			"case ${1:field}:",
-			"\tk.${1:field} += amount",
-			"\treturn k.${1:field}",
-		],
-	}
 }

koboldsim/cards.go

@@ -27,70 +27,45 @@ var cards = []Card{
 				EnactionDesc: cardsim.MsgStr("Kobolds are known to be born warriors."),
 				CanDo:        YesWeAlsoCan,
 			},
-			&BasicPolicy{
+			&TablePolicy{
 				UnenactedDesc: cardsim.MsgStr(`Your head miner considers the matter worriedly.  "Creches under military control?  No.  That would invite chaos.  We need to dig deeper; we can have a peaceful, orderly society if we just get far enough away from surfacers."`),
 				EnactedDesc:   cardsim.MsgStr("[current policy] Your head miner is presently leading a project to dig as far away from the surface as possible."),
-				Do: func(p *Player) (cardsim.Message, error) {
+				EffectsTable: map[FieldLabel]float64{
-					p.Stats.BasePopulation += 40
+					BasePopulation: 40,
-					p.Stats.Mining += 2
+					Mining:         2,
-					p.Stats.Construction += 1
+					Construction:   1,
-					p.Stats.Manufacturing += 1
+					Manufacturing:  1,
-					p.Stats.Bureaucracy += 1
+					Bureaucracy:    1,
-					p.Stats.FoodSupply -= 1
+					FoodSupply:     -1,
-					p.Stats.Secrecy += 3
+					Secrecy:        3,
-					return cardsim.MsgStr("Kobolds are known to be cowards hiding in the dark."), nil
 				},
-				Undo: func(p *Player) error {
+				EnactionDesc: cardsim.MsgStr("Kobolds are known to be cowards hiding in the dark."),
-					p.Stats.BasePopulation -= 40
+				CanDo:        YesWeAlsoCan,
-					p.Stats.Mining -= 2
-					p.Stats.Manufacturing -= 1
-					p.Stats.Construction -= 1
-					p.Stats.Bureaucracy -= 1
-					p.Stats.FoodSupply += 1
-					p.Stats.Secrecy -= 3
-					return nil
 			},
-				CanDo: YesWeCan,
+			&TablePolicy{
-			},
-			&BasicPolicy{
 				UnenactedDesc: cardsim.MsgStr(`Your nursery director is incensed.  "Creches under military control?  Never!  Let young kobolds play!  In fact, cut the military just for suggesting this.  The threats facing us are completely overstated."`),
 				EnactedDesc:   cardsim.MsgStr("[current policy] Military funding has been diverted into early childhood education."),
-				Do: func(p *Player) (cardsim.Message, error) {
+				EffectsTable: map[FieldLabel]float64{
-					p.Stats.BasePopulation -= 40
+					BasePopulation:   -40,
-					p.Stats.Scavenging -= 1
+					Scavenging:       -1,
-					p.Stats.Militarism -= 2
+					Militarism:       -2,
-					p.Stats.Education += 1
+					Education:        1,
-					p.Stats.FoodSupply -= 1
+					FoodSupply:       -2,
-					p.Stats.ForeignRelations += 2
+					ForeignRelations: 2,
-					p.Stats.Madness -= 1
+					Madness:          -1,
-					p.Stats.Cruelty -= 1
+					Cruelty:          -1,
-					return cardsim.MsgStr("An undefended hunting outpost near the surface was recently wiped out by a raid."), nil
 				},
-				Undo: func(p *Player) error {
+				EnactionDesc: cardsim.MsgStr("An undefended hunting outpost near the surface was recently wiped out by a raid."),
-					p.Stats.BasePopulation += 40
+				CanDo:        YesWeAlsoCan,
-					p.Stats.Scavenging += 1
-					p.Stats.Militarism += 2
-					p.Stats.Education -= 1
-					p.Stats.FoodSupply += 1
-					p.Stats.ForeignRelations -= 2
-					p.Stats.Madness += 1
-					p.Stats.Cruelty += 1
-					return nil
-				},
-				CanDo: YesWeCan,
 			},
 			&VerbosePolicy{
-				Default: &BasicPolicy{
+				Default: &TablePolicy{
 					UnenactedDesc: cardsim.MsgStr("This isn't about a disaster and can probably be safely dismissed."),
-					Do: func(p *Player) (cardsim.Message, error) {
+					EffectsTable: map[FieldLabel]float64{
-						p.Stats.BasePopulation += 20
+						BasePopulation: 20,
-						return cardsim.MsgStr("Creche control doesn't shift that easily."), nil
 					},
-					Undo: func(p *Player) error {
+					EnactionDesc: cardsim.MsgStr("Creche control doesn't shift that easily."),
-						p.Stats.BasePopulation -= 20
+					CanDo:        YesWeAlsoCan,
-						return nil
-					},
-					CanDo: YesWeCan,
 				},
 				Variants: []Policy{
 					&BasicPolicy{
@@ -118,93 +93,66 @@ var cards = []Card{
 		Desc:  cardsim.MsgStr(" Good times are upon us! A great festival has been declared between many kobold tribes, celebrating the orderly nature of the kobold soul!  That's right, it's the Pan-Tribal Festival of Bureaucracy!"),
 		After: ShuffleIntoBottomHalf,
 		Policies: []Policy{
-			&BasicPolicy{
+			&TablePolicy{
 				UnenactedDesc: cardsim.MsgStr(`Your Minister of Administration is practically jumping for joy. "This is our opportunity to prove that we're a prosperous society and attract some fresh blood!  We need to raise salaries in the bureaucracy, grant some time off to our bureaucrats to make sure they can attend, and try to hire talent away from other tribes.  We'll forge productive trade relations by this, you'll see!`),
 				EnactedDesc:   cardsim.MsgStr("[current policy] Your bureaucrats are really looking forward to attending, where they can boast about how the festival boosted their salaries."),
-				Do: func(p *Player) (cardsim.Message, error) {
+				EffectsTable: map[FieldLabel]float64{
-					p.Stats.BasePopulation += 60
+					BasePopulation: 60,
-					p.Stats.Scavenging += 1
+					Scavenging:     1,
-					p.Stats.Bureaucracy += 3
+					Bureaucracy:    3,
-					p.Stats.FoodSupply += 2
+					FoodSupply:     1,
-					p.Stats.Gullibility -= 1
+					Gullibility:    -1,
-					return cardsim.MsgStr("Bureaucrats are considered pillars of society."), nil
 				},
-				Undo: func(p *Player) error {
+				EnactionDesc: cardsim.MsgStr("Bureaucrats are considered pillars of society."),
-					p.Stats.BasePopulation -= 80
+				CanDo:        YesWeAlsoCan,
-					p.Stats.Scavenging -= 1
-					p.Stats.Bureaucracy -= 3
-					p.Stats.FoodSupply -= 2
-					p.Stats.Gullibility += 1
-					return nil
 			},
-				CanDo: YesWeCan,
+			&TablePolicy{
-			},
-			&BasicPolicy{
 				UnenactedDesc: cardsim.MsgStr(`Your Minister of Finance pulls you aside. "This is a good opportunity to head-hunt.  Bureaucrats from many tribes will be attending.  There's got to be some who'll work for less than the ones we've got.  There are some terribly threatened or impoverished communities among kobolds.`),
 				EnactedDesc:   cardsim.MsgStr("[current policy] Your tribe's policy is clear: the festival of bureaucracy is a chance to trade workers with other kobold tribes in your attempts to build a more efficient government."),
-				Do: func(p *Player) (cardsim.Message, error) {
+				EffectsTable: map[FieldLabel]float64{
-					p.Stats.BasePopulation += 20
+					BasePopulation: 20,
-					p.Stats.Bureaucracy -= 1
+					Bureaucracy:    -1,
-					p.Stats.Gullibility -= 1
-					return cardsim.MsgStr("Immigrant bureaucrats complain about being under-appreciated."), nil
 				},
-				Undo: func(p *Player) error {
+				EnactionDesc: cardsim.MsgStr("Immigrant bureaucrats complain about being under-appreciated."),
-					p.Stats.BasePopulation -= 20
+				CanDo: func(t *TablePolicy, p *Player) bool {
-					p.Stats.Bureaucracy += 1
+					return p.Stats.Bureaucracy >= 2 && t.LastEnactedIdx != 3
-					p.Stats.Gullibility += 1
-					return nil
-				},
-				CanDo: func(b *BasicPolicy, p *Player) bool {
-					return p.Stats.Bureaucracy >= 2 && b.LastEnactedIdx != 3
 				},
 			},
-			&BasicPolicy{
+			&TablePolicy{
 				UnenactedDesc: cardsim.MsgStr(`Your Minister of Finance greets you exuberantly. "We've trimmed the wages of the bureaucracy beautifully, but maybe we can scout some outright volunteers.  Some tribes are absolute disasters, after all.`),
 				EnactedDesc:   cardsim.MsgStr(`[current policy] It's hard to find volunteer workers at the festival, but your tribe is doing its best.`),
-				Do: func(p *Player) (cardsim.Message, error) {
+				EffectsTable: map[FieldLabel]float64{
-					p.Stats.BasePopulation += 10
+					BasePopulation:   10,
-					p.Stats.Bureaucracy -= 2
+					Bureaucracy:      -2,
-					p.Stats.Rebellion += 1
+					Rebellion:        1,
-					return cardsim.MsgStr("The local bureaucracy is staffed by volunteer labor."), nil
+					Gullibility:      2,
+					Authoritarianism: -1,
 				},
-				Undo: func(p *Player) error {
+				EnactionDesc: cardsim.MsgStr("The local bureaucracy is staffed by volunteer labor."),
-					p.Stats.BasePopulation -= 10
+				CanDo: func(t *TablePolicy, p *Player) bool {
-					p.Stats.Bureaucracy += 2
+					return p.Stats.Bureaucracy < 2 && t.LastEnactedIdx != 3
-					p.Stats.Rebellion -= 1
-					return nil
-				},
-				CanDo: func(b *BasicPolicy, p *Player) bool {
-					return p.Stats.Bureaucracy < 2 && b.LastEnactedIdx != 3
 				},
 			},
-			&BasicPolicy{
+			&TablePolicy{
-				UnenactedDesc: cardsim.MsgStr(`One of your non-bureaucrat friends has been in a foul temper.  "This festival is everything that's wrong with our society. Life isn't about filling out forms. We ought to snub this festival and outright fire some bureaucrats."`),
+				UnenactedDesc: cardsim.MsgStr(`One of your non-bureaucrat friends has been in a foul temper.  "This festival is everything that's wrong with our society. Life isn't about filling out forms. We ought to snub this festival and outright fire a bunch of paper-pushers."`),
 				EnactedDesc:   cardsim.MsgStr("Your tribe currently bans the Pan-Tribal Festival of Bureaucracy.  There will be no local celebration without a policy change."),
-				Do: func(p *Player) (cardsim.Message, error) {
+				EffectsTable: map[FieldLabel]float64{
-					p.Stats.BasePopulation -= 80
+					BasePopulation: 80,
-					p.Stats.Bureaucracy -= 4
+					Bureaucracy:    4,
-					return cardsim.MsgStr("A wave of bureaucrats just emigrated along with kobolds incensed by the tribe's lack of respect for administration."), nil
+					Gullibility:    4,
 				},
-				Undo: func(p *Player) error {
+				EnactionDesc: cardsim.MsgStr("A wave of bureaucrats just emigrated along with kobolds incensed by the tribe's lack of respect for administration."),
-					p.Stats.BasePopulation += 80
+				CanDo:        YesWeAlsoCan,
-					p.Stats.Bureaucracy += 4
-					return nil
-				},
-				CanDo: YesWeCan,
 			},
 			&VerbosePolicy{
-				Default: &BasicPolicy{
+				Default: &TablePolicy{
 					UnenactedDesc: cardsim.MsgStr("Some kobolds will attend the festival on their own, and we may face desertions for our lack of interest."),
 					EnactedDesc:   cardsim.MsgStr("Some kobolds will attend the festival on their own. No change is expected."),
-					Do: func(p *Player) (cardsim.Message, error) {
+					EffectsTable: map[FieldLabel]float64{
-						p.Stats.BasePopulation -= 20
+						BasePopulation: -20,
-						return cardsim.MsgStr("A festival of bureaucracy lured away a few kobolds to other tribes."), nil
 					},
-					Undo: func(p *Player) error {
+					EnactionDesc: cardsim.MsgStr("A festival of bureaucracy lured away a few kobolds to other tribes."),
-						p.Stats.BasePopulation += 20
+					CanDo:        YesWeAlsoCan,
-						return nil
-					},
-					CanDo: YesWeCan,
 				},
 				Variants: []Policy{
 					nil,
@@ -234,137 +182,81 @@ var cards = []Card{
 		Desc:  cardsim.MsgStr("An inevitable concern of kobold tribes is the matter of trade.  Trade with other kobolds is straightforward, but overland caravans are unsafe.  Trade with surfacers is vital... but achieving it is difficult owing to anti-kobold sentiment."),
 		After: ShuffleIntoBottomHalf,
 		Policies: []Policy{
-			&BasicPolicy{
+			&TablePolicy{
 				UnenactedDesc: cardsim.MsgStr(`Speaking for the conservative opinion, one prospective merchant says, "We need illusions.  Our priority needs to be studying or trading to acquire or create spells or artifacts of disguising.  The high start-up costs will be balanced by subsequent free movement in a surface society that detests us."`),
 				EnactedDesc:   cardsim.MsgStr("[current policy] Your merchants rely on magical disguises to avoid being identified as kobolds while doing business on the surface."),
-				Do: func(p *Player) (cardsim.Message, error) {
+				EffectsTable: map[FieldLabel]float64{
-					p.Stats.Manufacturing += 3
+					Manufacturing: 3,
-					p.Stats.Logistics += 4
+					Logistics:     4,
-					p.Stats.Mining += 1
+					Mining:        1,
-					p.Stats.Alchemy += 1
+					Alchemy:       1,
-					p.Stats.Gadgetry += 1
+					Gadgetry:      1,
-					p.Stats.Scavenging += 1
+					Scavenging:    1,
-					p.Stats.FoodSupply += 1
+					FoodSupply:    1,
-					p.Stats.Secrecy += 5
+					Secrecy:       5,
-					p.Stats.Rebellion += 1
+					Rebellion:     1,
-					p.Stats.Greed += 1
+					Greed:         1,
-					p.Stats.Gullibility += 1
+					Gullibility:   1,
-					return cardsim.MsgStr("Nobody ever meets a kobold merchant."), nil
 				},
-				Undo: func(p *Player) error {
+				EnactionDesc: cardsim.MsgStr("Nobody ever meets a kobold merchant."),
-					p.Stats.Manufacturing -= 3
+				CanDo:        YesWeAlsoCan,
-					p.Stats.Logistics -= 4
-					p.Stats.Mining -= 1
-					p.Stats.Alchemy -= 1
-					p.Stats.Gadgetry -= 1
-					p.Stats.Scavenging -= 1
-					p.Stats.FoodSupply -= 1
-					p.Stats.Secrecy -= 5
-					p.Stats.Rebellion -= 1
-					p.Stats.Greed -= 1
-					p.Stats.Gullibility -= 1
-					return nil
 			},
-				CanDo: YesWeCan,
+			&TablePolicy{
-			},
-			&BasicPolicy{
 				UnenactedDesc: cardsim.MsgStr(`Brave but potentially headstrong, another prospective merchant has attended the meeting with the following plea.  "We must take head-on the risk of improving the status of kobolds!  Only by bravely attending the surface markets can we hope to achieve a true and lasting peace!"`),
 				EnactedDesc:   cardsim.MsgStr(`[current policy] Your merchants represent the tribe's peaceful ideals by visiting the surface openly despite occasional casaulties.`),
-				Do: func(p *Player) (cardsim.Message, error) {
+				EffectsTable: map[FieldLabel]float64{
-					p.Stats.BasePopulation -= 15
+					BasePopulation:    -15,
-					p.Stats.Manufacturing += 3
+					Manufacturing:     3,
-					p.Stats.Logistics += 4
+					Logistics:         4,
-					p.Stats.Mining += 1
+					Mining:            2,
-					p.Stats.Alchemy += 2
+					Alchemy:           1,
-					p.Stats.Gadgetry += 2
+					Gadgetry:          2,
-					p.Stats.Hospitality += 1
+					Hospitality:       1,
-					p.Stats.Publishing += 1
+					Publishing:        1,
-					p.Stats.ForeignRelExpense += 1
+					ForeignRelExpense: 1,
-					p.Stats.Militarism -= 1
+					Militarism:        -1,
-					p.Stats.Scavenging -= 1
+					Scavenging:        -1,
-					p.Stats.Secrecy -= 10
+					Secrecy:           -10,
-					p.Stats.ForeignRelations += 5
+					ForeignRelations:  5,
-					p.Stats.FoodSupply += 3
+					FoodSupply:        3,
-					p.Stats.Greed += 1
+					Greed:             1,
-					p.Stats.Madness -= 1
+					Madness:           -1,
-					p.Stats.Cruelty -= 1
+					Cruelty:           -1,
-					return cardsim.MsgStr("The tribe formally plans for attrition among its merchants."), nil
 				},
-				Undo: func(p *Player) error {
+				EnactionDesc: cardsim.MsgStr("The tribe formally plans for attrition among its merchants."),
-					p.Stats.BasePopulation += 15
+				CanDo:        YesWeAlsoCan,
-					p.Stats.Manufacturing -= 3
-					p.Stats.Logistics -= 4
-					p.Stats.Mining -= 1
-					p.Stats.Alchemy -= 2
-					p.Stats.Gadgetry -= 2
-					p.Stats.Hospitality -= 1
-					p.Stats.Publishing -= 1
-					p.Stats.ForeignRelExpense -= 1
-					p.Stats.Militarism += 1
-					p.Stats.Scavenging += 1
-					p.Stats.Secrecy += 10
-					p.Stats.ForeignRelations -= 5
-					p.Stats.FoodSupply -= 3
-					p.Stats.Greed -= 1
-					p.Stats.Madness -= 1
-					p.Stats.Cruelty -= 1
-					return nil
 			},
-				CanDo: YesWeCan,
+			&TablePolicy{
-			},
-			&BasicPolicy{
 				UnenactedDesc: cardsim.MsgStr(`A shady scavenger has offered to change careers and become a merchant.  Their proposal is, "Surfacers aren't all monolithic.  If we talk to the ones who are more greedy than prejudiced, we don't need magic or idealism.  We can get in contact with lots of people who'll buy lots of things from us, even things that might not have a market if we worked with 'good' merchants."`),
 				EnactedDesc:   cardsim.MsgStr("[current policy] Your merchants work with the underworld of the surface, forging connections with the people who are ironically less likely to murder them."),
-				Do: func(p *Player) (cardsim.Message, error) {
+				EffectsTable: map[FieldLabel]float64{
-					p.Stats.BasePopulation -= 5
+					BasePopulation:   -5,
-					p.Stats.Logistics += 1
+					Logistics:        1,
-					p.Stats.Scavenging += 3
+					Scavenging:       3,
-					p.Stats.Alchemy += 2
+					Alchemy:          2,
-					p.Stats.Gadgetry += 2
+					Gadgetry:         2,
-					p.Stats.Mining -= 1
+					Mining:           -1,
-					p.Stats.Manufacturing -= 1
+					Manufacturing:    -1,
-					p.Stats.HiddenRelPenalty += 2 // High is bad on this hidden stat.
+					HiddenRelPenalty: 2, //High is bad on this hidden stat.
-					p.Stats.Greed += 3
+					Greed:            3,
-					p.Stats.Gullibility -= 2
+					Gullibility:      -2,
-					return cardsim.MsgStr("Kobold merchants are instantly suspected of black market connections."), nil
 				},
-				Undo: func(p *Player) error {
+				EnactionDesc: cardsim.MsgStr("Kobold merchants are instantly suspected of black market connections."),
-					p.Stats.BasePopulation += 5
+				CanDo:        YesWeAlsoCan,
-					p.Stats.Logistics -= 1
-					p.Stats.Scavenging -= 3
-					p.Stats.Alchemy -= 2
-					p.Stats.Gadgetry -= 3
-					p.Stats.Mining += 1
-					p.Stats.Manufacturing += 1
-					p.Stats.HiddenRelPenalty -= 2
-					p.Stats.Greed -= 3
-					p.Stats.Gullibility += 2
-					return nil
 			},
-				CanDo: YesWeCan,
+			&TablePolicy{
-			},
+				UnenactedDesc: cardsim.MsgStr(`A mining forebold registered for the right to attend this meeting to say, "Surfacers can't be trusted and we shouldn't be supporting them with trade.  We need underground roads to ease trade with other kobolds.  It's a massive investment, but think of the reward: a world of underground civilizations supporting each other."`),
-			&BasicPolicy{
-				UnenactedDesc: cardsim.MsgStr(`A mining forebold registered for the right to attend this meeting, and says, "Surfacers can't be trusted and we shouldn't be supporting them with trade.  We need underground roads to ease trade with other kobolds.  It's a massive investment, but think of the reward: a world of underground civilizations supporting each other."`),
 				EnactedDesc:   cardsim.MsgStr(`[currentpolicy] Your merchants have been directed to focus on trade with other kobolds, and your miners are perpetually tunnelling towards other kobold tribes in pursuit of the dream of a world of underground roads.`),
-				Do: func(p *Player) (cardsim.Message, error) {
+				EffectsTable: map[FieldLabel]float64{
-					p.Stats.Mining += 5
+					Mining:       5,
-					p.Stats.Construction += 2
+					Construction: 2,
-					p.Stats.Logistics += 4
+					Logistics:    3,
-					p.Stats.FoodSupply -= 1
+					FoodSupply:   -1,
-					p.Stats.Secrecy += 15
+					Secrecy:      15,
-					p.Stats.Gullibility -= 2
+					Gullibility:  -2,
-					return cardsim.MsgStr("The vast network of caverns under the surface of the world is not a natural phenomenon."), nil
 				},
-				Undo: func(p *Player) error {
+				EnactionDesc: cardsim.MsgStr("The vast network of caverns under the surface of the world is not a natural phenomenon."),
-					p.Stats.Mining -= 5
+				CanDo:        YesWeAlsoCan,
-					p.Stats.Construction -= 2
-					p.Stats.Logistics -= 4
-					p.Stats.FoodSupply += 1
-					p.Stats.Secrecy -= 15
-					p.Stats.Gullibility += 2
-					return nil
-				},
-				CanDo: YesWeCan,
 			},
 			&VerbosePolicy{
 				Default: &BasicPolicy{
@@ -383,7 +275,7 @@ var cards = []Card{
 						UnenactedDesc: cardsim.MsgStr("Rejecting the illusion-based merchantry will cost us a great deal in trade and surface food, but we can certainly do it."),
 					},
 					&BasicPolicy{
-						UnenactedDesc: cardsim.MsgStr("Rejecting our idealistic approach to surface trade will save a few lives directly, but consider how much we need the food we might buy!"),
+						UnenactedDesc: cardsim.MsgStr("Rejecting our idealistic approach to surface trade will save a few lives directly, but consider how much we need the food we buy!"),
 					},
 					&BasicPolicy{
 						UnenactedDesc: cardsim.MsgStr("The surfacers' governments would certainly prefer us to abandon our underworld connections in their cities.  Do we care about that?  We'd be giving up some excellent profits."),
@@ -400,96 +292,62 @@ var cards = []Card{
 		Desc:  cardsim.MsgStr("Nobody would ever say a kobold smells bad, but the constant burrowing, manufacturing, and metallurgy that is common to kobold life is still a recipe for tense muscles and filthy scales.  A slate of proposals have come through to address this issue."),
 		After: ShuffleIntoBottomHalf,
 		Policies: []Policy{
-			&BasicPolicy{
+			&TablePolicy{
 				UnenactedDesc: cardsim.MsgStr(`A calm and cheerful scribe says, "We should have public baths!  We have more problems with flooding than drought in the deep underground, so we've got plenty of water.  We just need to channel it.  We could create a hub of social life while improving the health of everybody!"`),
 				EnactedDesc:   cardsim.MsgStr("[current policy] Public bathing is a staple social policy in the mines and warrens of your tribe."),
-				Do: func(p *Player) (cardsim.Message, error) {
+				EffectsTable: map[FieldLabel]float64{
-					p.Stats.Construction += 2
+					Construction: 2,
-					p.Stats.Welfare += 1
+					Welfare:      1,
-					p.Stats.Healthcare += 1
+					ParksExpense: 4,
-					p.Stats.ParksExpense += 4
+					Hospitality:  1,
-					p.Stats.Hospitality += 1
+					Madness:      -2,
-					p.Stats.Madness -= 1
+					Cruelty:      -1,
-					p.Stats.Cruelty -= 1
+					Greed:        -1,
-					p.Stats.Greed -= 1
-					return cardsim.MsgStr("The company of others makes cold water tolerable."), nil
 				},
-				Undo: func(p *Player) error {
+				EnactionDesc: cardsim.MsgStr("The company of others makes cold water tolerable."),
-					p.Stats.Construction -= 2
+				CanDo:        YesWeAlsoCan,
-					p.Stats.Welfare -= 1
-					p.Stats.Healthcare -= 1
-					p.Stats.ParksExpense -= 4
-					p.Stats.Hospitality -= 1
-					p.Stats.Madness += 1
-					p.Stats.Cruelty += 1
-					p.Stats.Greed += 1
-					return nil
 			},
-				CanDo: YesWeCan,
+			&TablePolicy{
-			},
-			&BasicPolicy{
 				UnenactedDesc: cardsim.MsgStr(`Your Minister of Finance is scandalized.  "A free service?  And such an expensive one to construct?  No, no, no.  The baths must pull their weight in the budget if they're ot be made at all.  We must set an entry fee."`),
 				EnactedDesc:   cardsim.MsgStr("[current policy] Elite bathhouses serve paying customers in your largest sites."),
-				Do: func(p *Player) (cardsim.Message, error) {
+				EffectsTable: map[FieldLabel]float64{
-					p.Stats.Construction += 2
+					Construction: 2,
-					p.Stats.Hospitality += 3
+					Hospitality:  3,
-					p.Stats.ParksExpense += 2
+					ParksExpense: 2,
-					return cardsim.MsgStr("A dirty body is the mark of the lower classes."), nil
+					Madness:      -1,
+					Greed:        1,
 				},
-				Undo: func(p *Player) error {
+				EnactionDesc: cardsim.MsgStr("A dirty body is the mark of the lower classes."),
-					p.Stats.Construction -= 2
+				CanDo:        YesWeAlsoCan,
-					p.Stats.Hospitality -= 3
-					p.Stats.ParksExpense -= 2
-					return nil
 			},
-				CanDo: YesWeCan,
+			&TablePolicy{
-			},
-			&BasicPolicy{
 				UnenactedDesc: cardsim.MsgStr(`Your head diplomat chimes in with, "If you want to make the service self-sustaining, build a bath in a shallow cave and invite the surfacers in for a fee.  Of course, we'll be giving up some of our secrecy, but it'll bring in foreign exchange to power our industries."`),
 				EnactedDesc:   cardsim.MsgStr("[current policy] Conservative kobolds are scandalized: not only has the tribe bathhouses, it has near-surface bathhouses for surfacers to visit."),
-				Do: func(p *Player) (cardsim.Message, error) {
+				EffectsTable: map[FieldLabel]float64{
-					p.Stats.Construction += 2
+					Construction:      2,
-					p.Stats.Hospitality += 4
+					Hospitality:       4,
-					p.Stats.Manufacturing += 1
+					Manufacturing:     1,
-					p.Stats.ParksExpense += 3
+					ParksExpense:      3,
-					p.Stats.FoodSupply += 1
+					FoodSupply:        1,
-					p.Stats.ForeignRelExpense += 1
+					ForeignRelExpense: 1,
-					p.Stats.ForeignRelations += 1
+					ForeignRelations:  1,
-					p.Stats.HiddenRelPenalty -= -2
+					HiddenRelPenalty:  -2,
-					p.Stats.Secrecy -= 10
+					Secrecy:           -20,
-					p.Stats.Cruelty -= 1
+					Cruelty:           -1,
-					return cardsim.MsgStr("Surfacers stink less in the tribe's vicinity."), nil
 				},
-				Undo: func(p *Player) error {
+				EnactionDesc: cardsim.MsgStr("Surfacers stink less in the tribe's vicinity."),
-					p.Stats.Construction -= 2
+				CanDo:        YesWeAlsoCan,
-					p.Stats.Hospitality -= 3
-					p.Stats.Manufacturing -= 1
-					p.Stats.ParksExpense -= 3
-					p.Stats.FoodSupply -= 1
-					p.Stats.ForeignRelExpense -= 1
-					p.Stats.ForeignRelations -= 1
-					p.Stats.HiddenRelPenalty += 2
-					p.Stats.Secrecy += 10
-					p.Stats.Cruelty += 1
-					return nil
-				},
-				CanDo: YesWeCan,
 			},
 			&VerbosePolicy{
-				Default: &BasicPolicy{
+				Default: &TablePolicy{
 					UnenactedDesc: cardsim.MsgStr("Bathhouses are a big project that would displace other things in the city center.  You could use the space for housing and services instead."),
 					EnactedDesc:   cardsim.MsgStr("When is the right time to embark on building public baths?  You can hew close to skeptics instead."),
-					Do: func(p *Player) (cardsim.Message, error) {
+					EffectsTable: map[FieldLabel]float64{
-						p.Stats.BasePopulation += 5
+						BasePopulation: 5,
-						p.Stats.Gullibility -= 1
+						Gullibility:    -1,
-						return cardsim.MsgStr("Opponents of public bathing won a recent political contest."), nil
 					},
-					Undo: func(p *Player) error {
+					EnactionDesc: cardsim.MsgStr("Opponents of public bathing won a recent political contest."),
-						p.Stats.BasePopulation -= 5
+					CanDo:        YesWeAlsoCan,
-						p.Stats.Gullibility += 1
-						return nil
-					},
-					CanDo: YesWeCan,
 				},
 			},
 		}, // End of "A Recipe for Stewed Kobold" policies
@@ -502,9 +360,19 @@ var cards = []Card{
 			return p.Stats.Militarism > 0
 		},
 		Policies: []Policy{
-			&BasicPolicy{
+			&TablePolicy{
 				UnenactedDesc: cardsim.MsgStr(`A scavenger clad in sturdy clothes says, "We need to secure a section of forests on the surface.  The surfacers strip too many of the forests bare; if we dispatch patrols ready to fight we can keep them from assarting the forest for their endlessly growing farm communities."`),
 				EnactedDesc:   cardsim.MsgStr("[current policy] The war department maintains your meagre conquest of a stretch of forest on the surface."),
+				EffectsTable: map[FieldLabel]float64{
+					BasePopulation:   -20,
+					Forestry:         3,
+					Militarism:       1,
+					FoodSupply:       3,
+					Secrecy:          -10,
+					ForeignRelations: -2,
+					Madness:          -1,
+					Gullibility:      -1,
+				},
 				Do: func(p *Player) (cardsim.Message, error) {
 					p.Stats.BasePopulation -= 20
 					p.Stats.Forestry += 3
@@ -516,18 +384,8 @@ var cards = []Card{
 					p.Stats.Gullibility -= 1
 					return cardsim.MsgStr("A bunch of lumberjacks just disappeared in a forest."), nil
 				},
-				Undo: func(p *Player) error {
+				EnactionDesc: cardsim.MsgStr("A bunch of lumberjacks just disappeared in a forest."),
-					p.Stats.BasePopulation += 20
+				CanDo:        YesWeAlsoCan,
-					p.Stats.Forestry -= 3
-					p.Stats.Militarism -= 1
-					p.Stats.FoodSupply -= 5
-					p.Stats.Secrecy += 10
-					p.Stats.ForeignRelations += 2
-					p.Stats.Madness += 1
-					p.Stats.Gullibility += 1
-					return nil
-				},
-				CanDo: YesWeCan,
 			},
 			&BasicPolicy{
 				UnenactedDesc: cardsim.MsgStr(`A very scrawny warrior waves a spear over their head and says, "That's not going far enough!  We need to seize farmland of our own!  Come on, we shouldn't have to eat cave lichen while the surfacers eat roast pig!"`),

koboldsim/cardtypes.go

@@ -9,7 +9,6 @@ import (
 var (
 	ErrOptionNotEnabled = errors.New("option not enabled")
 	ErrPolicyNotEnacted = errors.New("cannot unenact policy that is not enacted")
-	ErrNoFieldLabel     = errors.New("field does not exist")
 
 	// ErrUnimplemented and ErrKeepMessaage are "non-errors". They are used
 	// as special signals that the result needs to be handled in a special way;

koboldsim/stats.go

@@ -1,7 +1,9 @@
 package koboldsim
 
 import (
+	"errors"
 	"fmt"
+	"reflect"
 
 	"git.chromaticdragon.app/kistaro/CardSimEngine/cardsim"
 )
@@ -167,49 +169,81 @@ func NewKoboldMine() *KoboldMine {
 	}
 }
 
+// FieldLabel instances are strings exactly matching the name of an
+// exported field in `KoboldMine`. These are used to map field names to
+// amounts to change in `TablePolicy` instances, which are then looked
+// up by name (via reflection) when adding the stat.
 type FieldLabel string
 
 const (
+	Alchemy           FieldLabel = "Alchemy"
+	Authoritarianism  FieldLabel = "Authoritarianism"
 	BasePopulation    FieldLabel = "BasePopulation"
-	Scavenging       FieldLabel = "Scavenging"
+	Bureaucracy       FieldLabel = "Bureaucracy"
-	Militarism       FieldLabel = "Militarism"
+	Construction      FieldLabel = "Construction"
+	Cruelty           FieldLabel = "Cruelty"
+	Education         FieldLabel = "Education"
 	FoodSupply        FieldLabel = "FoodSupply"
 	ForeignRelations  FieldLabel = "ForeignRelations"
-	Rebellion        FieldLabel = "Rebellion"
+	ForeignRelExpense FieldLabel = "ForeignRelExpense"
+	Forestry          FieldLabel = "Forestry"
+	Gadgetry          FieldLabel = "Gadgetry"
+	Greed             FieldLabel = "Greed"
+	Gullibility       FieldLabel = "Gullibility"
+	Healthcare        FieldLabel = "Healthcare"
+	HiddenRelPenalty  FieldLabel = "HiddenRelPenalty"
+	Hospitality       FieldLabel = "Hospitality"
+	Logistics         FieldLabel = "Logistics"
 	Madness           FieldLabel = "Madness"
-	Cruelty          FieldLabel = "Cruelty"
+	Manufacturing     FieldLabel = "Manufacturing"
-	Authoritarianism FieldLabel = "Authoritarianism"
+	Militarism        FieldLabel = "Militarism"
+	Mining            FieldLabel = "Mining"
+	ParksExpense      FieldLabel = "ParksExpense"
+	Publishing        FieldLabel = "Publishing"
+	Rebellion         FieldLabel = "Rebellion"
+	Scavenging        FieldLabel = "Scavenging"
+	Secrecy           FieldLabel = "Secrecy"
+	Welfare           FieldLabel = "Welfare"
 )
 
+// ErrBadFieldLabel is an "error category" for all errors where a
+// FieldLabel did not correctly name a Field that could be used in Add.
+var ErrBadFieldLabel = errors.New("bad field label")
+
+// ErrNoFieldLabel is a kind of `ErrBadFieldLabel` used when no field
+// of the target has the exact name specified in the FieldLabel. Check
+// spelling and capitalization.
+var ErrNoFieldLabel = fmt.Errorf("%w: field does not exist", ErrBadFieldLabel)
+
+// ErrFieldNotFloat is a kind of `ErrBadFieldLabel` used when it is not
+// possible to read and assign a float to the named field. Is this the
+// name of a calculated stat (a function) rather than a base stat?
+var ErrFieldNotFloat = fmt.Errorf("%w: field type is not float", ErrBadFieldLabel)
+
+// ErrFieldSetPanic is a kind of `ErrBadFieldLabel` used when trying to
+// set the value of a field panicked. The panic message should be
+// preserved in the error to diagnose the problem. If the problem is
+// that the field is unexported, capitalize the name (including inside
+// the KoboldMine type). Any other issue is a more complicated bug,
+// because all of them that aren't already caught by ErrFieldNotFloat
+// imply something very unexpected happened with `k` itself (in `Add`).
+var ErrFieldSetPanic = fmt.Errorf("%w: panic when setting", ErrBadFieldLabel)
+
+// Use a FieldLabel to add an amount to the matching field. If no such
+// field can be found, the field is not exported, or the field is not
+// of type float64, this returns an error ad does not change any values.
 func (k *KoboldMine) Add(which FieldLabel, amount float64) error {
-	switch which {
+	kv := reflect.ValueOf(k).Elem()
-	case BasePopulation:
+	f := kv.FieldByName(string(which))
-		k.BasePopulation += amount
+	if !f.IsValid() {
-		return nil
+		return fmt.Errorf("cannot add %f to field %q: %w", amount, which, ErrNoFieldLabel)
-	case Scavenging:
-		k.Scavenging += amount
-		return nil
-	case Militarism:
-		k.Militarism += amount
-		return nil
-	case FoodSupply:
-		k.FoodSupply += amount
-		return nil
-	case ForeignRelations:
-		k.ForeignRelations += amount
-		return nil
-	case Rebellion:
-		k.Rebellion += amount
-		return nil
-	case Madness:
-		k.Madness += amount
-		return nil
-	case Cruelty:
-		k.Cruelty += amount
-		return nil
-	case Authoritarianism:
-		k.Authoritarianism += amount
-		return nil
 	}
-	return fmt.Errorf("cannot add %f to %q: %w", amount, which, ErrNoFieldLabel)
+	if !f.CanFloat() {
+		return fmt.Errorf("cannot add %f to field %q: %w", amount, which, ErrFieldNotFloat)
+	}
+
+	if err := try(func() { f.SetFloat(f.Float() + amount) }); err != nil {
+		return fmt.Errorf("could not add %f to field %q: %w", amount, which, err)
+	}
+	return nil
 }

koboldsim/util.go

@@ -1,6 +1,8 @@
 package koboldsim
 
 import (
+	"errors"
+	"fmt"
 	"math"
 
 	"golang.org/x/exp/constraints"
@@ -25,12 +27,45 @@ func Mean(vals ...float64) float64 {
 	return total / float64(len(vals))
 }
 
-func clamp[T constraints.Ordered](val, low, high T) T {
+// clamp returns the middle of the three provided values. It doesn't
-	if val < low {
+// matter which order the values are in. This function is known as `mid` in
-		return low
+// Pico-8's library, among others. It is usually used to clamp a value to a
+// range, and it doesn't care which order the range is written in.
+func clamp[T constraints.Ordered](a, b, c T) T {
+	if a <= b && a <= c {
+		// `a` is least; mid is lower of `b` or `c`
+		if b <= c {
+			return b
 		}
-	if val > high {
+		return c
-		return high
 	}
-	return val
+	if a >= b && a >= c {
+		// `a` is most; mid is greater of `b` or `c`
+		if b >= c {
+			return b
+		}
+		return c
+	}
+	// `a` is neither most nor least; therefore, `a` is mid
+	return a
+}
+
+var ErrWrappedPanic = errors.New("panic")
+
+// try catches a panic in the provided func and demotes it to an error, if any
+// panic occurs. The returned error, if any, wraps `ErrWrappedPanic`. If the
+// panic argument is itself an error, it is also wrapped; otherwise, it is
+// stringified into the error message using `%v`.
+func try(f func()) (finalErr error) {
+	defer func() {
+		if r := recover(); r != nil {
+			if e, ok := r.(error); ok {
+				finalErr = fmt.Errorf("%w: %w", ErrWrappedPanic, e)
+				return
+			}
+			finalErr = fmt.Errorf("%w: %v", ErrWrappedPanic, r)
+		}
+	}()
+	f()
+	return nil
 }