Claude/feat manual overrides

.gitignore

@@ -12,3 +12,11 @@ __pycache__/
 .DS_Store
 Thumbs.db
 Desktop.ini
+tools/database/generated/
+
+# Local agent / debug clutter
+.claude/
+.codex_tmp/
+.codex_tmp_delta/
+battleinfo/
+*.bak

CHANGELOG.md

@@ -0,0 +1,33 @@
+# Changelog
+
+## 0.9.1.6-deltacalc
+
+- Mega-stone trump now swaps the holder's ability to the mega's intrinsic, on both sides. Charizardite Y → Drought, Charizardite X → Tough Claws, Gardevoirite → Pixilate, Mawilite → Huge Power, Mewtwonite X → Steadfast, Mewtwonite Y → Insomnia, etc. Hand-verified for all 47 Gen 6-7 megas. The DB doesn't carry abilities so the trump rule reads from a curated `MEGA_ABILITY_BY_FORM_KEY` map keyed by `<species>-mega(-x|-y)?`. Ability-conditional effects (Tough Claws on contact, Pixilate's Normal→Fairy + 1.2×, etc.) fire automatically as soon as the mega stone is detected. Opponent-side ability override still respects manual user-cycled overrides; player side always overrides since there's no manual-cycle mechanism for the player.
+
+## 0.9.1.5-deltacalc
+
+- Fix mega-stone cycle not changing damage numbers (the v0.9.1.4 trump rule actually firing). Root cause: `computeMegaSwap` only consulted Cobblemon's `species.getForm(setOf("mega-x"))` to source the mega's base stats, and Cobblemon's actual aspect-name convention for Mega Charizard X / Y (and others) doesn't match `"mega-x"` / `"megax"`, so the lookup silently returned the base form and the swap bailed out. The calc now reads mega base stats directly from the bundled battle database (`charizard-mega-x` → 78/130/111/130/85/100, `charizard-mega-y` → 78/104/78/159/115/100, etc.) — hand-verified for every Gen 6-7 mega — and only falls back to the Cobblemon aspect lookup when the DB doesn't have the entry. Aspect-fallback candidate list also widened (`mega_x`, `x`, `mega-form`) for mods that register megas under non-standard aspects.
+- Surfaced mega stones in the opponent item-cycle UI. Charizard now shows Charizardite X / Charizardite Y as cycle options, Gardevoir gets Gardevoirite, etc., for every Gen 6-7 mega-capable species — previously the cycle only included usage-derived items plus a generic common-items list, so reaching a mega stone via cycle required the species' competitive usage data to include it.
+
+## 0.9.1.4-deltacalc
+
+- Mega-stone trump rule for both sides: when the held item is a mega stone matching the species, the calc now forces the snapshot into its mega form (base stats, types, intrinsic ability) regardless of Cobblemon's live form. Previously this only applied to the opponent; the player side respected `partyPokemon` stats, which silently downgraded the calc when (a) the player hadn't pressed mega-evolve yet or (b) Cobblemon's post-switch-in visual glitch reverted the sprite to base form. Player `actualStats` are now re-derived heuristically from the new mega base stats whenever a mega stone is detected (precision trade-off vs. always-correct mega base; accepted per user direction). Only triggers on items in the mega-stone table — non-mega items never override live state.
+- Data: scraped 7 new mons from `#custom-pokemon` (Trapinch-ATOM, Sevygarde, Hydrapple-Ultra, Applin/Dipplin/Flapple/Appletun-Ultra). Curated sets for Hydrapple-Ultra (AV Regenerator) and Sevygarde (defensive Toxic/Haze utility).
+- Data: curated Trick Room Cresselia set replaces the OU defensive default.
+- Removed Gigantamax handling — not in the Delta pack (Dynamax kept).
+
+## 0.9.1.3-deltacalc
+
+- Fix Parasol Prayer / Delta Stream: damage calc now clamps super-effective-vs-Flying moves to neutral on Flying-type defenders when either active Pokemon has the ability.
+- Fix mega evolution stats lost after switch-out/switch-in: `FormTracker` preserves `isMega` across switches so the calc keeps using mega base stats even when Cobblemon's sprite reverts to base form (visual glitch). Player-side `actualStats` are re-derived from mega base stats in this state so `partyPokemon` reporting base values doesn't silently downgrade the calc.
+- Fix Return / Frustration: now always calculated at 102 BP since the calc has no access to friendship; matches competitive max-friendship convention.
+- Fix variant-alias overwrite in `BattleDatabase`: a two-pass indexer (primary identifiers first, aliases via `putIfAbsent`) prevents 303 variant entries from overwriting their base species' lookup key. Fixes Ursaluna defaulting to Bloodmoon, Zapdos/Moltres defaulting to Galar, Decidueye defaulting to Hisui, Camerupt defaulting to Mega, Basculegion defaulting to F, Aegislash defaulting to Blade, every typed Arceus, every regional/Gigantamax form, and similar mismatches.
+- Fix Facade vs. burn: Facade now correctly bypasses burn's 0.5× physical Atk drop in addition to doubling its base power (previously netted to 1×, wiping out the BP boost).
+- Harden Guts trigger: requires a recognized status name (burn/poison/paralysis/sleep/freeze + aliases) instead of any non-null status string.
+
+## 0.9.1-deltacalc
+
+- Rebrands the client mod as DeltaCalc for release packaging
+- Adds the damage calculator panel and battle overlay improvements for Cobblemon Delta battles
+- Includes battle-state export support for external analysis workflows
+- Bundles a release icon and aligns packaged metadata with the DeltaCalc repository

README.md

@@ -0,0 +1,31 @@
+# DeltaCalc
+
+DeltaCalc is a client-side utility mod for Cobblemon Delta on Fabric 1.21.1. It adds an in-battle damage calculator, expanded battle overlays, richer tooltips, team indicators, and optional battle-state export for external analysis tools.
+
+## Features
+
+- Live damage calculation panel for active battle states (left-click and drag the header to reposition; position is saved automatically)
+- Battle info overlays for weather, terrain, side conditions, and boosts
+- Team indicators and enriched Pokemon move/tooltips
+- Battle log enhancements
+- Optional structured battle export for external tooling
+
+## Requirements
+
+- Minecraft 1.21.1
+- Fabric Loader
+- Fabric API
+- Fabric Language Kotlin
+- Cobblemon 1.7.3+1.21.1
+- Java 21
+
+## Installation
+
+1. Install Fabric Loader for Minecraft 1.21.1.
+2. Add Fabric API, Fabric Language Kotlin, Cobblemon, and DeltaCalc to your `mods` folder.
+3. Launch the game and configure DeltaCalc through Mod Menu if you have it installed.
+
+## Notes For Release
+
+- The internal mod id remains `cobblemonextendedbattleui` for compatibility with the current codebase.
+- Set `MODRINTH_PROJECT_SLUG` in [`CobblemonExtendedBattleUI.kt`](/Z:/Cb%20delta/DeltaCalc/src/main/kotlin/com/cobblemonextendedbattleui/CobblemonExtendedBattleUI.kt:1) after the Modrinth project is created if you want in-game update checks.

build.gradle.kts

@@ -41,6 +41,9 @@ dependencies {
     modCompileOnly("me.shedaniel.cloth:cloth-config-fabric:${property("cloth_config_version")}") {
         exclude(group = "net.fabricmc.fabric-api")
     }
+
+    testImplementation(kotlin("test"))
+    testImplementation("org.junit.jupiter:junit-jupiter:5.10.2")
 }
 
 tasks.processResources {
@@ -78,6 +81,13 @@ tasks.named<net.fabricmc.loom.task.RemapJarTask>("remapJar") {
     archiveFileName.set("deltacalc.jar")
 }
 
+val prismJar by tasks.registering(Copy::class) {
+    dependsOn(tasks.named<net.fabricmc.loom.task.RemapJarTask>("remapJar"))
+    from(tasks.named<net.fabricmc.loom.task.RemapJarTask>("remapJar").flatMap { it.archiveFile })
+    into(layout.buildDirectory.dir("libs"))
+    rename { "deltacalc-prism.jar" }
+}
+
 tasks.named<org.gradle.jvm.tasks.Jar>("sourcesJar") {
     archiveFileName.set("deltacalc-sources.jar")
 }
@@ -91,10 +101,12 @@ val purgePrototypeArtifacts by tasks.registering(Delete::class) {
 
 tasks.named("build") {
     dependsOn(purgePrototypeArtifacts)
+    dependsOn(prismJar)
 }
 
 tasks.named("assemble") {
     dependsOn(purgePrototypeArtifacts)
+    dependsOn(prismJar)
 }
 
 tasks.named("clean") {
@@ -106,6 +118,10 @@ tasks.named("clean") {
     }
 }
 
+tasks.test {
+    useJUnitPlatform()
+}
+
 loom {
     accessWidenerPath.set(file("src/main/resources/cobblemonextendedbattleui.accesswidener"))
     mixin {

gradle.properties

@@ -6,7 +6,7 @@ yarn_mappings=1.21.1+build.3
 loader_version=0.17.2
 fabric_version=0.116.6+1.21.1
 
-mod_version=0.9.1-deltacalc
+mod_version=0.9.1.6-deltacalc
 maven_group=com.cobblemonextendedbattleui
 archives_base_name=deltacalc
 

src/main/java/com/cobblemonextendedbattleui/mixin/BattleHealthChangeHandlerMixin.java

@@ -14,6 +14,9 @@
 import com.cobblemonextendedbattleui.TeamIndicatorUI;
 import com.cobblemonextendedbattleui.BattleStateTracker;
 import com.cobblemonextendedbattleui.PanelConfig;
+import com.cobblemonextendedbattleui.battle.messages.MessageParser;
+import com.cobblemonextendedbattleui.battle.state.PokemonRegistry;
+import com.cobblemonextendedbattleui.calc.DebugDumper;
 import net.minecraft.client.MinecraftClient;
 
 import java.util.UUID;
@@ -80,6 +83,9 @@ private void onHandlePre(BattleHealthChangePacket packet, MinecraftClient client
 
                         if (hpChange > 0.5f) {
                             DamageTracker.INSTANCE.recordDamage(pokemonName, hpChange);
+                            DebugDumper.INSTANCE.recordActualDamage(
+                                    uuid, pokemonName, oldPercent, newPercent, maxHp, isFlat);
+                            inferLifeOrbFromSelfDamage(uuid, pokemonName, hpChange);
                         } else if (hpChange < -0.5f) {
                             DamageTracker.INSTANCE.recordHealing(pokemonName, -hpChange);
                         }
@@ -100,4 +106,35 @@ private void onHandlePre(BattleHealthChangePacket packet, MinecraftClient client
             // Silent fail to avoid breaking gameplay
         }
     }
+
+    /**
+     * Infer Life Orb when an attacker takes ~10% self-damage immediately after using a move.
+     * Cobblemon's `cobblemon.battle.damage.lifeorb` translation key handles the explicit case,
+     * but Delta builds may not always emit it. This is a fallback so the calc's item-aware
+     * damage modifiers (Life Orb's +30% multiplier) actually fire.
+     *
+     * Filters to avoid false positives:
+     *  - Target must be the most recent move's user (i.e. self-damage on the attacker).
+     *  - The move must still be resolving (lastMoveResolved=false) so this isn't a hazard tick.
+     *  - Damage delta in [9.0, 11.0]% — tight enough to exclude:
+     *      * Iron Barbs / Rough Skin (12.5%)
+     *      * Rocky Helmet (16.67%)
+     *      * Brave Bird / Flare Blitz / Wood Hammer recoil (33%)
+     *      * Take Down / Submission recoil (25%)
+     *  - setItem with HELD is no-op when an item is already revealed, so confirmed items win.
+     */
+    private void inferLifeOrbFromSelfDamage(UUID targetUuid, String targetName, float damagePct) {
+        if (damagePct < 9.0f || damagePct > 11.0f) return;
+        if (MessageParser.INSTANCE.getLastMoveResolved()) return;
+        String attacker = MessageParser.INSTANCE.getLastMoveUser();
+        String moveName = MessageParser.INSTANCE.getLastMoveName();
+        if (attacker == null || moveName == null) return;
+
+        UUID attackerUuid = PokemonRegistry.INSTANCE.resolvePokemonUuid(attacker, null);
+        if (attackerUuid == null || !attackerUuid.equals(targetUuid)) return;
+
+        // Don't overwrite a confirmed item — setItem(HELD) is no-op when already set.
+        BattleStateTracker.INSTANCE.setItem(
+                attacker, "Life Orb", BattleStateTracker.ItemStatus.HELD, null);
+    }
 }

src/main/java/com/cobblemonextendedbattleui/mixin/BattleMessageHandlerMixin.java

@@ -15,7 +15,7 @@
  * Intercept raw battle messages for EBU's state tracking and custom log, then prevent
  * Cobblemon's default handler from populating its own message queue when the custom log is active.
  */
-@Mixin(value = BattleMessageHandler.class, remap = false)
+@Mixin(value = BattleMessageHandler.class, priority = 2000, remap = false)
 public class BattleMessageHandlerMixin {
 
     @Inject(method = "handle", at = @At("HEAD"), cancellable = true)

src/main/java/com/cobblemonextendedbattleui/mixin/BattleSwitchHandlerMixin.java

@@ -7,12 +7,14 @@
 
 import com.cobblemon.mod.common.client.CobblemonClient;
 import com.cobblemon.mod.common.client.battle.ClientBattle;
+import com.cobblemon.mod.common.client.battle.ClientBattlePokemon;
 import com.cobblemon.mod.common.client.net.battle.BattleSwitchPokemonHandler;
 import com.cobblemon.mod.common.net.messages.client.battle.BattleSwitchPokemonPacket;
 import com.cobblemon.mod.common.net.messages.client.battle.BattleInitializePacket;
 import com.cobblemonextendedbattleui.BattleStateTracker;
 import com.cobblemonextendedbattleui.DamageTracker;
 import com.cobblemonextendedbattleui.PanelConfig;
+import com.cobblemonextendedbattleui.battle.state.AbilityItemTracker;
 import net.minecraft.client.MinecraftClient;
 
 import java.util.UUID;
@@ -33,6 +35,35 @@ private void onHandlePre(BattleSwitchPokemonPacket packet, MinecraftClient clien
         // Skip if no tracking is needed
         if (!needsStateTracking && !needsDamageTracking) return;
 
+        // Regenerator restores 33% HP to the OUTGOING Pokemon on switch-out.
+        // At HEAD inject the slot still holds the active (outgoing) Pokemon, so
+        // packet.getPnx() resolves to it. Gated on >0% HP because Regenerator
+        // does not trigger from a KO-forced switch (faint message zeros HP first).
+        if (needsStateTracking && needsDamageTracking) {
+            try {
+                ClientBattle battle = CobblemonClient.INSTANCE.getBattle();
+                if (battle != null) {
+                    var slotResult = battle.getPokemonFromPNX(packet.getPnx());
+                    if (slotResult != null) {
+                        ClientBattlePokemon outgoing = slotResult.getSecond().getBattlePokemon();
+                        if (outgoing != null) {
+                            UUID outgoingUuid = outgoing.getUuid();
+                            String ability = AbilityItemTracker.INSTANCE.getRevealedAbility(outgoingUuid);
+                            if (ability != null && ability.equalsIgnoreCase("Regenerator")) {
+                                Float currentHp = DamageTracker.INSTANCE.getLastKnownHpPercent(outgoingUuid);
+                                if (currentHp != null && currentHp > 0f) {
+                                    float restored = Math.min(100f, currentHp + 33.33f);
+                                    DamageTracker.INSTANCE.updateHpPercent(outgoingUuid, restored);
+                                }
+                            }
+                        }
+                    }
+                }
+            } catch (Exception e) {
+                // Silent fail to avoid breaking gameplay
+            }
+        }
+
         try {
             BattleInitializePacket.ActiveBattlePokemonDTO newPokemon = packet.getNewPokemon();
             if (newPokemon == null) return;

src/main/java/com/cobblemonextendedbattleui/mixin/DeltaClientBattleMessageQueueMixin.java

@@ -0,0 +1,65 @@
+package com.cobblemonextendedbattleui.mixin;
+
+import com.cobblemonextendedbattleui.BattleLog;
+import com.cobblemonextendedbattleui.BattleMessageInterceptor;
+import com.cobblemonextendedbattleui.BoostTraceLog;
+import com.cobblemonextendedbattleui.PanelConfig;
+import net.minecraft.text.Text;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Pseudo;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+import java.util.Collection;
+import java.util.List;
+
+/**
+ * DeltaClient short-circuits Cobblemon's native BattleMessageHandler and appends
+ * incoming battle messages directly into ClientBattleMessageQueue via a synthetic
+ * deltaclient$add(Collection) method. Hook that path so battle state tracking and
+ * the custom log still see the same raw messages.
+ */
+@Pseudo
+@Mixin(targets = "com.cobblemon.mod.common.client.battle.ClientBattleMessageQueue", remap = false)
+public class DeltaClientBattleMessageQueueMixin {
+
+    @Inject(
+        method = "deltaclient$add(Ljava/util/Collection;)V",
+        at = @At("HEAD"),
+        require = 0
+    )
+    private void cobblemonextendedbattleui$processDeltaQueuedMessages(Collection<?> messages, CallbackInfo ci) {
+        if (messages == null || messages.isEmpty()) {
+            return;
+        }
+
+        List<Text> textMessages = messages.stream()
+            .filter(Text.class::isInstance)
+            .map(Text.class::cast)
+            .toList();
+
+        if (textMessages.isEmpty()) {
+            return;
+        }
+
+        boolean containsBoostMessage = textMessages.stream().anyMatch(text ->
+            text != null && (
+                text.getString().contains(" rose") ||
+                text.getString().contains(" fell") ||
+                text.getString().contains("stat changes")
+            )
+        );
+        if (containsBoostMessage) {
+            BoostTraceLog.INSTANCE.append("delta queue received " + textMessages.size() + " messages: " + textMessages);
+        }
+
+        if (PanelConfig.INSTANCE.needsBattleStateTracking()) {
+            BattleMessageInterceptor.INSTANCE.processMessages(textMessages);
+        }
+
+        if (PanelConfig.INSTANCE.getEnableBattleLog()) {
+            BattleLog.INSTANCE.processMessages(textMessages);
+        }
+    }
+}

src/main/java/com/deltacalc/battle/BattleTracker.java

@@ -1,11 +1,11 @@
 package com.deltacalc.battle;
 
+import com.cobblemon.mod.common.client.CobblemonClient;
 import com.deltacalc.config.DeltaCalcConfig;
 import com.deltacalc.inference.ConfidenceBand;
 import com.deltacalc.inference.GuessState;
 import com.deltacalc.inference.GuessValue;
 import java.util.List;
-import java.util.Locale;
 import java.util.Optional;
 import java.util.UUID;
 import net.minecraft.client.MinecraftClient;
@@ -37,13 +37,13 @@ public void tick(MinecraftClient client) {
         String screenName = screen == null ? "<none>" : screen.getClass().getName();
         if (!screenName.equals(lastScreenName)) {
             lastScreenName = screenName;
-            logger.info("DeltaCalc screen changed to {}", screenName);
+            logger.debug("DeltaCalc screen changed to {}", screenName);
         }
 
-        boolean battleActive = config.demoBattleForced() || isLikelyBattleScreen(screen);
+        boolean battleActive = config.demoBattleForced() || CobblemonClient.INSTANCE.getBattle() != null;
         if (battleActive && currentSnapshot == null) {
             currentSnapshot = createDemoSnapshot();
-            logger.info("DeltaCalc entered battle context using {}", config.demoBattleForced() ? "forced demo snapshot" : "screen heuristic");
+            logger.info("DeltaCalc entered battle context using {}", config.demoBattleForced() ? "forced demo snapshot" : "Cobblemon ClientBattle");
             return;
         }
 
@@ -93,18 +93,6 @@ public void cycleDemoReveal() {
         logger.info("DeltaCalc cycled demo reveal state to step {}", demoRevealStep);
     }
 
-    private boolean isLikelyBattleScreen(Screen screen) {
-        if (screen == null) {
-            return false;
-        }
-
-        String className = screen.getClass().getName().toLowerCase(Locale.ROOT);
-        String title = screen.getTitle() == null ? "" : screen.getTitle().getString().toLowerCase(Locale.ROOT);
-        return className.contains("battle")
-            || className.contains("cobblemon")
-            || title.contains("battle");
-    }
-
     private ActiveMonSnapshot withOpponentReveal(ActiveMonSnapshot opponent, String move, String item, String ability) {
         List<String> knownMoves = move == null ? opponent.knownMoves() : List.of(move);
         GuessValue<String> revealedItem = item == null

src/main/java/com/deltacalc/calc/MoveDefinition.java

@@ -5,7 +5,16 @@ public record MoveDefinition(
     String type,
     int power,
     MoveCategory category,
-    boolean fallback
+    boolean fallback,
+    int minHits,
+    int maxHits
 ) {
+    public MoveDefinition(String name, String type, int power, MoveCategory category, boolean fallback) {
+        this(name, type, power, category, fallback, 1, 1);
+    }
+
+    public boolean isMultiHit() {
+        return maxHits > 1;
+    }
 }