Deduct Covenant aura via Nature's Aura IAuraChunk; drop misleading message

User report after deploy 58e26a1: casting Ars spells produced
"Insufficient Aura: Need 20, have 1000000" (visibly contradictory)
and the bar didn't deplete.

Diagnosis from latest.log + Covenant 2.2.6 bytecode trace:

1. The misleading message came from VirtueRingHandler.onSpellResolvePost,
   not from the pre-cast mixin (no DENIED warn in log). The post-resolve
   handler fires after the spell already cast and shows the message
   whenever SanctifiedLegacyCompat.consumeCovenantAura returns false.

2. consumeCovenantAura short-circuited to false because
   covenantConsumeAuraMethod is null. The startup log confirmed:
   [OK] Covenant aura reflection initialized — consume=false, ...

3. There IS no consume method on Covenant's ModUtils because Covenant's
   "aura" is not a per-player resource. ResourceSyncEvents.getPlayerAuraChunk
   reads ambient aura via:
     IAuraChunk.triangulateAuraInArea(level, playerPos, 35)
   The value belongs to the surrounding chunks (Nature's Aura's
   world-aura system), not the player.

The canonical way to spend aura is to drain it from the chunks via
Nature's Aura's public IAuraChunk API. Covenant's next server tick
re-triangulates and ships a CurrentAuraSyncPacket, so the HUD bar
moves naturally.

Changes:

  compat/SanctifiedLegacyCompat.java
    - Add 4 new Method fields for IAuraChunk: getAuraChunk, getHighestSpot,
      triangulateAuraInArea, drainAura (instance).
    - New initNaturesAuraReflection() called from init() right after
      initCovenantAuraReflection(). Logs OK or DEGRADED at boot.
    - Rewrite consumeCovenantAura(Player, int):
        * Server-side only (ServerPlayer check).
        * IAuraChunk.getHighestSpot(level, playerPos, 35, playerPos)
          finds the highest-aura spot in the same 35-block radius Covenant
          samples from.
        * IAuraChunk.getAuraChunk(level, spot) -> chunk.drainAura(spot, cost).
        * Returns true iff drained > 0.
    - Augment getCovenantAura(Player) with a server-context fast path
      (triangulateAuraInArea). Now works on dedicated servers (where
      ClientResourceData is never populated).
    - Augment hasEnoughCovenantAura(Player, int) with the same fast path.
    - Added a tryGetInstance() helper next to the existing tryGetStatic.

  events/VirtueRingHandler.java
    - onSpellResolvePost: when consumeCovenantAura returns false, log a
      single WARN line and return. Do NOT show the player a chat message
      ("Insufficient Aura: Need X, have Y") — that text is misleading
      because the spell already cast and the bar IS the canonical visual
      cue (it won't move, telling the user the deduction failed).
    - Success-path message ("Consumed X aura (Y remaining)") unchanged.

Build verified: ./gradlew build runs reobfJar; deployed jar 283,429 bytes.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: otectus

src/main/java/com/otectus/arsnspells/compat/SanctifiedLegacyCompat.java

@@ -118,6 +118,18 @@ private static final class CurioState {
     private static java.lang.reflect.Method covenantGetVirtuousFractionMethod = null;
     private static boolean covenantAuraReflectionResolved = false;
 
+    // --- Nature's Aura bridge ---
+    // Covenant's "aura" is not a per-player resource — it's a sample of the world's
+    // ambient aura via IAuraChunk.triangulateAuraInArea(level, playerPos, 35). To
+    // deduct aura we must drain it from the surrounding chunks via the same public
+    // Nature's Aura API. drainAura at the highest-aura spot is the canonical pattern
+    // (Aura Cache, Sky Channeler, every Nature's Aura consumer item does this).
+    private static java.lang.reflect.Method auraChunkGetAuraChunkMethod = null;
+    private static java.lang.reflect.Method auraChunkGetHighestSpotMethod = null;
+    private static java.lang.reflect.Method auraChunkTriangulateMethod = null;
+    private static java.lang.reflect.Method auraChunkDrainAuraMethod = null;
+    private static boolean naturesAuraReflectionResolved = false;
+
     /**
      * LP Source modes for config.
      */
@@ -153,6 +165,7 @@ public static void init() {
 
             if (isLoaded) {
                 initCovenantAuraReflection();
+                initNaturesAuraReflection();
             }
 
             // Warn if LP_SOURCE_MODE is BLOOD_MAGIC_ONLY but Blood Magic isn't installed
@@ -288,6 +301,61 @@ private static java.lang.reflect.Method tryGetStatic(Class<?> owner, String name
         }
     }
 
+    /** Look up an instance method by name + parameter types; return null on miss. */
+    private static java.lang.reflect.Method tryGetInstance(Class<?> owner, String name, Class<?>... params) {
+        try {
+            return owner.getMethod(name, params);
+        } catch (NoSuchMethodException e) {
+            return null;
+        }
+    }
+
+    /**
+     * Resolve Nature's Aura's IAuraChunk API at startup. This is the actual write path
+     * for "consuming Covenant aura" — Covenant samples ambient aura via
+     * IAuraChunk.triangulateAuraInArea, so any drain on the surrounding chunks shows up
+     * in Covenant's bar on the next tick.
+     *
+     * <p>Required signatures (Nature's Aura 39.4, verified by javap):
+     * <pre>
+     *   public static IAuraChunk getAuraChunk(Level, BlockPos)
+     *   public static BlockPos getHighestSpot(Level, BlockPos, int radius, BlockPos defaultPos)
+     *   public static int triangulateAuraInArea(Level, BlockPos, int radius)
+     *   public abstract int drainAura(BlockPos, int amount)  // returns amount actually drained
+     * </pre>
+     */
+    private static void initNaturesAuraReflection() {
+        try {
+            Class<?> chunkCls = Class.forName("de.ellpeck.naturesaura.api.aura.chunk.IAuraChunk");
+            Class<?> levelCls = Class.forName("net.minecraft.world.level.Level");
+            Class<?> posCls = Class.forName("net.minecraft.core.BlockPos");
+
+            auraChunkGetAuraChunkMethod = tryGetStatic(chunkCls, "getAuraChunk", levelCls, posCls);
+            auraChunkGetHighestSpotMethod = tryGetStatic(chunkCls, "getHighestSpot", levelCls, posCls, int.class, posCls);
+            auraChunkTriangulateMethod = tryGetStatic(chunkCls, "triangulateAuraInArea", levelCls, posCls, int.class);
+            auraChunkDrainAuraMethod = tryGetInstance(chunkCls, "drainAura", posCls, int.class);
+
+            naturesAuraReflectionResolved = true;
+            boolean ok = auraChunkGetAuraChunkMethod != null
+                && auraChunkGetHighestSpotMethod != null
+                && auraChunkTriangulateMethod != null
+                && auraChunkDrainAuraMethod != null;
+            if (ok) {
+                LOGGER.info("  [OK] Nature's Aura reflection initialized — drain=true, triangulate=true, getHighestSpot=true, getAuraChunk=true");
+            } else {
+                LOGGER.error("  [DEGRADED] Nature's Aura reflection partial — drain={}, triangulate={}, getHighestSpot={}, getAuraChunk={}",
+                    auraChunkDrainAuraMethod != null,
+                    auraChunkTriangulateMethod != null,
+                    auraChunkGetHighestSpotMethod != null,
+                    auraChunkGetAuraChunkMethod != null);
+                LOGGER.error("  [DEGRADED] Ars-spell aura deduction will silently fail; the green HUD bar won't move on Ars casts.");
+            }
+        } catch (Throwable t) {
+            naturesAuraReflectionResolved = false;
+            LOGGER.error("  [FAIL] Nature's Aura reflection failed (class missing?) — Ars-spell aura deduction disabled", t);
+        }
+    }
+
     /**
      * Return true if the player has at least {@code cost} Covenant aura.
      *
@@ -298,12 +366,25 @@ private static java.lang.reflect.Method tryGetStatic(Class<?> owner, String name
      */
     public static boolean hasEnoughCovenantAura(Player player, int cost) {
         if (player == null || cost <= 0) return true;
+        // Server-authoritative path first — IAuraChunk.triangulateAuraInArea returns
+        // the same number Covenant uses for the bar. Works on both single-player and
+        // dedicated servers (ClientResourceData isn't populated on dedicated).
+        try {
+            if (player instanceof net.minecraft.server.level.ServerPlayer
+                && naturesAuraReflectionResolved
+                && auraChunkTriangulateMethod != null) {
+                Object v = auraChunkTriangulateMethod.invoke(null,
+                    player.level(), player.blockPosition(), 35);
+                if (v instanceof Number) {
+                    return ((Number) v).intValue() >= cost;
+                }
+            }
+        } catch (Throwable t) {
+            LOGGER.debug("hasEnoughCovenantAura: triangulate failed", t);
+        }
         if (!covenantAuraReflectionResolved) return true; // degraded: allow
 
         try {
-            // Path 0 (preferred): ClientResourceData.getCurrentAura(). Player arg is unused
-            // — Covenant tracks current aura per-client, not per-Player. Works for the local
-            // player (the only one whose Covenant aura the client knows about).
             if (clientResourceDataGetCurrentAuraMethod != null) {
                 Object v = clientResourceDataGetCurrentAuraMethod.invoke(null);
                 if (v instanceof Number) {
@@ -332,27 +413,57 @@ public static boolean hasEnoughCovenantAura(Player player, int cost) {
     }
 
     /**
-     * Spend {@code cost} aura from the player's Covenant pool. Returns true on
-     * successful deduction; false if reflection didn't resolve or the call
-     * returned a "could not pay" signal.
+     * Spend {@code cost} aura from the world around the player. Returns {@code true}
+     * iff a positive amount was actually drained.
+     *
+     * <p>Covenant has no per-player consume API because its aura value is just a
+     * sample of the ambient Nature's Aura level in the chunks around the player
+     * (radius 35, same as Covenant's {@code triangulateAuraInArea} call). To
+     * "consume aura" we drain it from the highest-aura spot in that area via
+     * Nature's Aura's public {@code IAuraChunk.drainAura}. Covenant's own
+     * {@code ResourceSyncEvents.getPlayerAuraChunk} will pick up the change on
+     * the next server tick and ship a fresh {@code CurrentAuraSyncPacket} to the
+     * client, which is what makes the HUD bar move.
+     *
+     * <p>This is the canonical Nature's Aura consume pattern used by every
+     * official aura sink in the ecosystem (Aura Cache, Sky Channeler, etc.).
+     *
+     * <p>Must be called on the logical server (we touch world state). The
+     * companion check {@code player instanceof ServerPlayer} short-circuits
+     * otherwise — calling from a non-server context returns false silently.
      */
     public static boolean consumeCovenantAura(Player player, int cost) {
         if (player == null || cost <= 0) return false;
-        if (!covenantAuraReflectionResolved || covenantConsumeAuraMethod == null) return false;
+        if (!(player instanceof net.minecraft.server.level.ServerPlayer)) return false;
+        if (!naturesAuraReflectionResolved
+            || auraChunkGetAuraChunkMethod == null
+            || auraChunkGetHighestSpotMethod == null
+            || auraChunkDrainAuraMethod == null) {
+            return false;
+        }
         try {
-            Object result = covenantConsumeAuraMethod.invoke(null, player, cost);
-            if (result instanceof Boolean) {
-                return (Boolean) result;
-            }
-            if (result instanceof Number) {
-                return ((Number) result).intValue() >= cost;
+            net.minecraft.world.level.Level level = player.level();
+            net.minecraft.core.BlockPos playerPos = player.blockPosition();
+            // 35 matches Covenant's triangulation radius — anywhere inside this area is
+            // guaranteed to affect the next ambient-aura sample.
+            Object highest = auraChunkGetHighestSpotMethod.invoke(null, level, playerPos, 35, playerPos);
+            if (!(highest instanceof net.minecraft.core.BlockPos)) return false;
+            net.minecraft.core.BlockPos spot = (net.minecraft.core.BlockPos) highest;
+            Object chunkObj = auraChunkGetAuraChunkMethod.invoke(null, level, spot);
+            if (chunkObj == null) return false;
+            Object drainedObj = auraChunkDrainAuraMethod.invoke(chunkObj, spot, cost);
+            if (drainedObj instanceof Number) {
+                int drained = ((Number) drainedObj).intValue();
+                if (drained > 0) {
+                    LOGGER.debug("Drained {} aura from chunk spot {} for {} (requested {})",
+                        drained, spot, player.getName().getString(), cost);
+                    return true;
+                }
             }
-            // void return type: assume success
-            return true;
         } catch (Throwable t) {
-            LOGGER.error("consumeCovenantAura reflection failed", t);
-            return false;
+            LOGGER.error("consumeCovenantAura: IAuraChunk drain failed", t);
         }
+        return false;
     }
 
     /**
@@ -361,11 +472,21 @@ public static boolean consumeCovenantAura(Player player, int cost) {
      * available either.
      */
     public static int getCovenantAura(Player player) {
-        if (!covenantAuraReflectionResolved) return 0;
         try {
-            // Path 0 (preferred): ClientResourceData.getCurrentAura(). Static, no Player
-            // arg — see the comment in hasEnoughCovenantAura. Returns the local-client
-            // aura value, which is exactly what we need for HUD/peak tracking.
+            // Server-authoritative path: ask Nature's Aura directly for the ambient aura
+            // around the player. This is exactly what Covenant samples in its server-tick
+            // sync handler, so it's the truth — and it works on dedicated servers where
+            // ClientResourceData is never populated.
+            if (player instanceof net.minecraft.server.level.ServerPlayer
+                && naturesAuraReflectionResolved
+                && auraChunkTriangulateMethod != null) {
+                Object v = auraChunkTriangulateMethod.invoke(null,
+                    player.level(), player.blockPosition(), 35);
+                if (v instanceof Number) return ((Number) v).intValue();
+            }
+            if (!covenantAuraReflectionResolved) return 0;
+            // Client-context path: ClientResourceData.getCurrentAura() — what Covenant's
+            // own HUD reads from. Player arg is unused (it's a per-client singleton).
             if (clientResourceDataGetCurrentAuraMethod != null) {
                 Object v = clientResourceDataGetCurrentAuraMethod.invoke(null);
                 if (v instanceof Number) return ((Number) v).intValue();

src/main/java/com/otectus/arsnspells/events/VirtueRingHandler.java

@@ -214,18 +214,15 @@ public static void onSpellResolvePost(SpellResolveEvent.Post event) {
 
         boolean success = SanctifiedLegacyCompat.consumeCovenantAura(player, pending.auraCost);
         if (!success) {
-            // Should be rare — the canCast pre-validation in MixinSpellResolverPreCast already
-            // gated this. Log and skip. Note: in "degraded mode" (Covenant reflection unresolved),
-            // consumeCovenantAura intentionally returns false; this is logged at startup, not here.
-            LOGGER.debug("Aura consumption failed at Post for {} (spell already cast, no payment made)",
-                player.getName().getString());
-
-            int currentAura = SanctifiedLegacyCompat.getCovenantAura(player);
-            player.displayClientMessage(
-                Component.translatable("message.ars_n_spells.aura.insufficient", pending.auraCost, currentAura)
-                    .withStyle(ChatFormatting.AQUA),
-                true
-            );
+            // Either ambient aura was genuinely insufficient OR Nature's Aura reflection
+            // failed to resolve at startup (degraded mode — already logged at boot). In
+            // both cases the spell has already cast and we don't surface a chat message
+            // because the bar IS the canonical visual cue: it either didn't move (no
+            // aura was deducted) or moved by less than requested (partial drain). A
+            // post-cast "Insufficient Aura" chat message would be misleading because
+            // the player CAN see the bar value and the spell DID succeed.
+            LOGGER.warn("Aura consumption returned false for {} (cost={}); bar will not reflect this cast",
+                player.getName().getString(), pending.auraCost);
             return;
         }