Slow prosperity growth past 80 and add workshop trade upkeep (#45)

Province prosperity is unchanged up to prosperity-soft-cap (80). Past it
the excess grows with a square root, so each point is worth less (half at
140, a third at 240) without a hard ceiling. This stops guilds from
stacking production into the same provinces to run them far past 80.

Workshops now add 1% trade upkeep per level, like guild halls and
storehouses already do, so reinvesting in production levels off instead
of compounding forever.

Co-authored-by: Ryan <7389646+ryanbarlow97@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

Author: 3 people

src/main/java/net/tfminecraft/simplefactions/Cache.java

@@ -28,6 +28,8 @@ public class Cache {
 	public static double prestigePerTradePower = 0.1;
 	public static double prestigeFromTradeSoftCap = 2000;
 	public static double prestigeFromTradeFalloff = 0.1;
+	public static double prosperitySoftCap = 80;
+	public static double prosperitySoftCapScale = 20;
 	public static double maxPlaytimePrestigeExponent = 5;
 	public static String baseYear;
 	public static int baseIrlYear = java.time.Year.now().getValue();

src/main/java/net/tfminecraft/simplefactions/loaders/ConfigLoader.java

@@ -34,6 +34,8 @@ public void loadConfig(File configFile) {
 		Cache.prestigePerTradePower = config.getDouble("prestige-per-trade-power", 0.1);
 		Cache.prestigeFromTradeSoftCap = config.getDouble("prestige-from-trade-soft-cap", 2000);
 		Cache.prestigeFromTradeFalloff = config.getDouble("prestige-from-trade-falloff", 0.1);
+		Cache.prosperitySoftCap = config.getDouble("prosperity-soft-cap", 80);
+		Cache.prosperitySoftCapScale = config.getDouble("prosperity-soft-cap-scale", 20);
 		Cache.maxPlaytimePrestigeExponent = config.getDouble("max-prestige-playtime-exponent", 5);
 		Cache.bankBlock = config.getString("bank-block", "v.lodestone");
 		Cache.maxExtraNodeCapacity = config.getInt("max-extra-node-capacity", 0);

src/main/java/net/tfminecraft/simplefactions/map/provinces/ProsperitySoftCap.java

@@ -0,0 +1,29 @@
+package net.tfminecraft.simplefactions.map.provinces;
+
+import net.tfminecraft.simplefactions.Cache;
+
+/**
+ * Slows a province's prosperity past {@link Cache#prosperitySoftCap}.
+ *
+ * <p>Up to the cap nothing changes. Past it, the excess grows with a square
+ * root, so the next point is worth full value at the seam and less after:
+ * half at cap + 3 x scale, a third at cap + 8 x scale. There is no ceiling;
+ * it just gets harder and harder to add prosperity.
+ */
+public final class ProsperitySoftCap {
+
+	private ProsperitySoftCap() {
+	}
+
+	public static double apply(double prosperity) {
+		return diminish(prosperity, Cache.prosperitySoftCap, Cache.prosperitySoftCapScale);
+	}
+
+	static double diminish(double prosperity, double softCap, double scale) {
+		if (softCap <= 0 || scale <= 0 || prosperity <= softCap) {
+			return prosperity;
+		}
+		double extra = prosperity - softCap;
+		return softCap + 2.0 * scale * (Math.sqrt(1.0 + extra / scale) - 1.0);
+	}
+}

src/main/java/net/tfminecraft/simplefactions/map/provinces/Province.java

@@ -209,6 +209,7 @@ public void calculateProsperity() {
         double exponent = 1 + Math.min(0.1, participants * 0.005);
 
         total = Math.pow(total, exponent);
+        total = ProsperitySoftCap.apply(total);
         total = Math.round(total * 100.0) / 100.0;
         this.prosperity = total;
     }

src/main/resources/Guilds/branches.yml

@@ -48,6 +48,7 @@ workshops:
   modifiers:
     - production 3 1
     - prestige 0 5
+    - trade_upkeep 0 0.01
 storehouses:
   name: "#bf8a45Storehouses"
   icon: "barrel.0"

src/main/resources/config.yml

@@ -100,6 +100,12 @@ battle:
     siege: siege_default
     raid: campaign_raid_template
 
+# A province's prosperity is unchanged up to prosperity-soft-cap. Past it the
+# excess grows with a square root, so each point is worth less: half at
+# cap + 3 x scale, a third at cap + 8 x scale. No ceiling. 0 disables it.
+prosperity-soft-cap: 80
+prosperity-soft-cap-scale: 20
+
 branch-upgrade-cost: 100.0
 branch-upgrade-exponent: 1.07
 

src/test/java/net/tfminecraft/simplefactions/map/provinces/ProsperitySoftCapTest.java

@@ -0,0 +1,66 @@
+package net.tfminecraft.simplefactions.map.provinces;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import net.tfminecraft.simplefactions.Cache;
+
+class ProsperitySoftCapTest {
+
+	private double previousCap;
+	private double previousScale;
+
+	@BeforeEach
+	void setUp() {
+		previousCap = Cache.prosperitySoftCap;
+		previousScale = Cache.prosperitySoftCapScale;
+		Cache.prosperitySoftCap = 80;
+		Cache.prosperitySoftCapScale = 20;
+	}
+
+	@AfterEach
+	void tearDown() {
+		Cache.prosperitySoftCap = previousCap;
+		Cache.prosperitySoftCapScale = previousScale;
+	}
+
+	@Test
+	void apply_leavesProsperityUpToTheCapAlone() {
+		assertEquals(0.0, ProsperitySoftCap.apply(0), 1e-9);
+		assertEquals(42.5, ProsperitySoftCap.apply(42.5), 1e-9);
+		assertEquals(80.0, ProsperitySoftCap.apply(80), 1e-9);
+	}
+
+	@Test
+	void apply_slowsPastTheCapWithoutACeiling() {
+		assertEquals(120.0, ProsperitySoftCap.apply(140), 1e-9);
+		assertEquals(160.0, ProsperitySoftCap.apply(240), 1e-9);
+		double far = ProsperitySoftCap.apply(10_000);
+		assertTrue(far > 600, "expected continued growth far past the cap, was " + far);
+	}
+
+	@Test
+	void diminish_isSmoothAtTheCap() {
+		double atCap = ProsperitySoftCap.diminish(80.0, 80.0, 20.0);
+		double justAbove = ProsperitySoftCap.diminish(80.001, 80.0, 20.0);
+		assertEquals(0.001, justAbove - atCap, 1e-6);
+	}
+
+	@Test
+	void diminish_marginalValueHalvesAtCapPlusThreeScales() {
+		double step = 1e-4;
+		double at = ProsperitySoftCap.diminish(140.0, 80.0, 20.0);
+		double next = ProsperitySoftCap.diminish(140.0 + step, 80.0, 20.0);
+		assertEquals(0.5, (next - at) / step, 1e-3);
+	}
+
+	@Test
+	void diminish_zeroCapOrScaleDisablesIt() {
+		assertEquals(500.0, ProsperitySoftCap.diminish(500.0, 0.0, 20.0), 1e-9);
+		assertEquals(500.0, ProsperitySoftCap.diminish(500.0, 80.0, 0.0), 1e-9);
+	}
+}