Android build v1.1.8

android/app/build.gradle

@@ -7,8 +7,8 @@ android {
         applicationId "com.warren.iwanttoheal"
         minSdkVersion rootProject.ext.minSdkVersion
         targetSdkVersion rootProject.ext.targetSdkVersion
-        versionCode 83
-        versionName "1.1.4"
+        versionCode 87
+        versionName "1.1.8"
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
         aaptOptions {
              // Files and dirs to omit from the packaged assets dir, modified to accommodate modern web apps.

android/app/src/main/java/com/warren/iwanttoheal/AndroidDisplayPerformance.java

@@ -0,0 +1,51 @@
+package com.warren.iwanttoheal;
+
+import android.view.Display;
+import android.view.Window;
+import android.view.WindowManager;
+
+final class AndroidDisplayPerformance {
+
+    private static final float TARGET_REFRESH_RATE = 60.0f;
+
+    private AndroidDisplayPerformance() {}
+
+    static void preferBatteryRefreshRate(Window window, Display display) {
+        if (window == null || display == null) return;
+        Display.Mode currentMode = display.getMode();
+        Display.Mode selectedMode = closestBatteryMode(display, currentMode);
+        if (selectedMode == null) return;
+
+        WindowManager.LayoutParams attributes = window.getAttributes();
+        if (attributes.preferredDisplayModeId == selectedMode.getModeId()) return;
+        attributes.preferredDisplayModeId = selectedMode.getModeId();
+        window.setAttributes(attributes);
+    }
+
+    private static Display.Mode closestBatteryMode(Display display, Display.Mode currentMode) {
+        Display.Mode selectedMode = null;
+        float selectedScore = Float.MAX_VALUE;
+
+        for (Display.Mode mode : display.getSupportedModes()) {
+            if (
+                currentMode != null
+                    && (
+                        mode.getPhysicalWidth() != currentMode.getPhysicalWidth()
+                            || mode.getPhysicalHeight() != currentMode.getPhysicalHeight()
+                    )
+            ) {
+                continue;
+            }
+
+            float refreshRate = mode.getRefreshRate();
+            float score = Math.abs(refreshRate - TARGET_REFRESH_RATE);
+            if (refreshRate > TARGET_REFRESH_RATE + 0.5f) score += 1000.0f;
+            if (score < selectedScore) {
+                selectedMode = mode;
+                selectedScore = score;
+            }
+        }
+
+        return selectedMode;
+    }
+}

android/app/src/main/java/com/warren/iwanttoheal/ControllerBridgeActivity.java

@@ -1,26 +1,45 @@
 package com.warren.iwanttoheal;
 
 import android.content.Intent;
+import android.content.SharedPreferences;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.os.Build;
 import android.os.Bundle;
 import android.os.SystemClock;
+import android.view.InputDevice;
 import android.view.KeyEvent;
 import android.view.MotionEvent;
 import android.view.View;
 import com.getcapacitor.BridgeActivity;
 import java.io.File;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
 
 public abstract class ControllerBridgeActivity extends BridgeActivity {
 
     public static final String EXTRA_INITIAL_URL = "com.warren.iwanttoheal.INITIAL_URL";
-    private static final long DPAD_THROTTLE_MS = 220;
-    private long lastDpadDispatchAt = 0;
+    private static final String PREFS_NAME = "com.warren.iwanttoheal.performance";
+    private static final String CACHE_CLEARED_VERSION_KEY = "webview_cache_cleared_version";
+    private static final float AXIS_DEAD_ZONE = 0.45f;
+    private static final long DPAD_THROTTLE_MS = 55;
+    private final long[] lastDpadDispatchAt = new long[16];
+    private final Set<String> activeMotionTokens = new HashSet<>();
+    private final Map<String, Long> lastMotionDispatchAt = new HashMap<>();
 
     @Override
     public void onCreate(Bundle savedInstanceState) {
-        clearWebViewServiceWorkers();
+        boolean shouldClearWebViewCache = shouldClearWebViewCacheForCurrentVersion();
+        if (shouldClearWebViewCache) clearWebViewServiceWorkers();
         super.onCreate(savedInstanceState);
+        AndroidDisplayPerformance.preferBatteryRefreshRate(getWindow(), getWindowManager().getDefaultDisplay());
         if (bridge != null) {
+            if (shouldClearWebViewCache) {
                 bridge.getWebView().clearCache(true);
+                markWebViewCacheClearedForCurrentVersion();
+            }
         }
         loadIntentUrl();
     }
@@ -35,7 +54,13 @@ public abstract class ControllerBridgeActivity extends BridgeActivity {
     @Override
     public void onWindowFocusChanged(boolean hasFocus) {
         super.onWindowFocusChanged(hasFocus);
-        if (hasFocus) enableImmersiveMode();
+        if (hasFocus) {
+            enableImmersiveMode();
+            AndroidDisplayPerformance.preferBatteryRefreshRate(
+                getWindow(),
+                getWindowManager().getDefaultDisplay()
+            );
+        }
     }
 
     @Override
@@ -74,6 +99,34 @@ public abstract class ControllerBridgeActivity extends BridgeActivity {
         deleteIfExists(new File(webViewData, "Service Worker"));
     }
 
+    private boolean shouldClearWebViewCacheForCurrentVersion() {
+        return performancePreferences().getLong(CACHE_CLEARED_VERSION_KEY, -1L)
+            != currentVersionCode();
+    }
+
+    private void markWebViewCacheClearedForCurrentVersion() {
+        performancePreferences()
+            .edit()
+            .putLong(CACHE_CLEARED_VERSION_KEY, currentVersionCode())
+            .apply();
+    }
+
+    private SharedPreferences performancePreferences() {
+        return getSharedPreferences(PREFS_NAME, MODE_PRIVATE);
+    }
+
+    private long currentVersionCode() {
+        try {
+            PackageInfo packageInfo = getPackageManager().getPackageInfo(getPackageName(), 0);
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+                return packageInfo.getLongVersionCode();
+            }
+            return packageInfo.versionCode;
+        } catch (PackageManager.NameNotFoundException exception) {
+            return -1L;
+        }
+    }
+
     private void deleteIfExists(File file) {
         if (!file.exists()) return;
         if (file.isDirectory()) {
@@ -94,7 +147,88 @@ public abstract class ControllerBridgeActivity extends BridgeActivity {
 
         if (event.getAction() == KeyEvent.ACTION_DOWN) {
             boolean repeat = event.getRepeatCount() > 0;
-            if (isDpadToken(token) && shouldThrottleDpad()) return true;
+            if (isDpadToken(token) && shouldThrottleDpad(token)) return true;
+            dispatchNativeControllerToken(token, repeat);
+        }
+        return true;
+    }
+
+    @Override
+    public boolean dispatchGenericMotionEvent(MotionEvent event) {
+        if (
+            bridge == null
+                || event.getActionMasked() != MotionEvent.ACTION_MOVE
+                || !isControllerMotionEvent(event)
+        ) {
+            return super.dispatchGenericMotionEvent(event);
+        }
+
+        Set<String> currentTokens = new HashSet<>();
+        addAxisTokens(
+            currentTokens,
+            event.getAxisValue(MotionEvent.AXIS_HAT_X),
+            "Button14",
+            "Button15"
+        );
+        addAxisTokens(
+            currentTokens,
+            event.getAxisValue(MotionEvent.AXIS_HAT_Y),
+            "Button12",
+            "Button13"
+        );
+        addAxisTokens(
+            currentTokens,
+            event.getAxisValue(MotionEvent.AXIS_X),
+            "Axis0-",
+            "Axis0+"
+        );
+        addAxisTokens(
+            currentTokens,
+            event.getAxisValue(MotionEvent.AXIS_Y),
+            "Axis1-",
+            "Axis1+"
+        );
+
+        boolean hadMotionTokens = !activeMotionTokens.isEmpty();
+        long now = SystemClock.uptimeMillis();
+        for (String token : currentTokens) {
+            boolean repeat = activeMotionTokens.contains(token);
+            long lastDispatchAt = lastMotionDispatchAt.containsKey(token)
+                ? lastMotionDispatchAt.get(token)
+                : 0L;
+            if (!repeat || now - lastDispatchAt >= DPAD_THROTTLE_MS) {
+                dispatchNativeControllerToken(token, repeat);
+                lastMotionDispatchAt.put(token, now);
+            }
+        }
+        activeMotionTokens.clear();
+        activeMotionTokens.addAll(currentTokens);
+
+        if (currentTokens.isEmpty() && !hadMotionTokens) {
+            return super.dispatchGenericMotionEvent(event);
+        }
+        return true;
+    }
+
+    private boolean isControllerMotionEvent(MotionEvent event) {
+        int source = event.getSource();
+        return (source & InputDevice.SOURCE_JOYSTICK) == InputDevice.SOURCE_JOYSTICK
+            || (source & InputDevice.SOURCE_DPAD) == InputDevice.SOURCE_DPAD
+            || (source & InputDevice.SOURCE_GAMEPAD) == InputDevice.SOURCE_GAMEPAD;
+    }
+
+    private void addAxisTokens(
+        Set<String> tokens,
+        float value,
+        String negativeToken,
+        String positiveToken
+    ) {
+        if (value <= -AXIS_DEAD_ZONE) tokens.add(negativeToken);
+        if (value >= AXIS_DEAD_ZONE) tokens.add(positiveToken);
+    }
+
+    private void dispatchNativeControllerToken(String token, boolean repeat) {
+        if (bridge == null || bridge.getWebView() == null) return;
         String script =
             "window.dispatchEvent(new CustomEvent('ashen-halls-native-controller',"
                 + "{detail:{token:'" + token + "',repeat:" + repeat + "}}));";
@@ -105,13 +239,12 @@ public abstract class ControllerBridgeActivity extends BridgeActivity {
             }
         );
     }
-        return true;
-    }
 
-    private boolean shouldThrottleDpad() {
+    private boolean shouldThrottleDpad(String token) {
+        int buttonIndex = Integer.parseInt(token.substring("Button".length()));
         long now = SystemClock.uptimeMillis();
-        if (now - lastDpadDispatchAt < DPAD_THROTTLE_MS) return true;
-        lastDpadDispatchAt = now;
+        if (now - lastDpadDispatchAt[buttonIndex] < DPAD_THROTTLE_MS) return true;
+        lastDpadDispatchAt[buttonIndex] = now;
         return false;
     }
 
@@ -125,10 +258,13 @@ public abstract class ControllerBridgeActivity extends BridgeActivity {
     private String controllerToken(int keyCode) {
         switch (keyCode) {
             case KeyEvent.KEYCODE_BUTTON_A:
+            case KeyEvent.KEYCODE_DPAD_CENTER:
             case KeyEvent.KEYCODE_ENTER:
+            case KeyEvent.KEYCODE_NUMPAD_ENTER:
                 return "Button0";
             case KeyEvent.KEYCODE_BUTTON_B:
             case KeyEvent.KEYCODE_BACK:
+            case KeyEvent.KEYCODE_ESCAPE:
                 return "Button1";
             case KeyEvent.KEYCODE_BUTTON_X:
                 return "Button2";

android/app/src/main/java/com/warren/iwanttoheal/DualScreenPlugin.java

@@ -259,9 +259,11 @@ public class DualScreenPlugin extends Plugin {
     private final class TopDisplayPresentation extends Presentation {
 
         private final String initialUrl;
+        private final Display display;
 
         TopDisplayPresentation(Context context, Display display, String initialUrl) {
             super(context, display);
+            this.display = display;
             this.initialUrl = initialUrl;
         }
 
@@ -277,6 +279,7 @@ public class DualScreenPlugin extends Plugin {
                     | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
                     | View.SYSTEM_UI_FLAG_LAYOUT_STABLE
             );
+            AndroidDisplayPerformance.preferBatteryRefreshRate(getWindow(), display);
 
             FrameLayout container = new FrameLayout(getContext());
             container.setBackgroundColor(Color.BLACK);

src/App.tsx

@@ -20,6 +20,7 @@ import {
   type GameMode,
 } from './gameRepository'
 import { focusFirstControl } from './input.tsx'
+import { barFillStyle } from './components/barStyles'
 
 const CombatScreen = lazy(() => import('./components/CombatScreen').then((module) => ({ default: module.CombatScreen })))
 const CustomizeScreen = lazy(() => import('./components/CustomizeScreen').then((module) => ({ default: module.CustomizeScreen })))
@@ -455,7 +456,7 @@ function App() {
   const canShowCloudSync = account.id !== -1 && cloudSync.available
 
   return (
-    <main className={`game-shell ${screen === 'dungeons' || screen === 'raids' ? 'dungeon-shell' : ''} ${screen === 'customize' ? 'workshop-shell' : ''}`}>
+    <main className={`game-shell ${screen === 'dungeons' || screen === 'raids' ? 'dungeon-shell' : ''} ${screen === 'customize' ? 'workshop-shell' : ''} ${screen === 'settings' ? 'settings-shell' : ''}`}>
       <header className="topbar app-header">
         <button
           className="brand-button"
@@ -469,7 +470,7 @@ function App() {
           <small>Level {profile.character.level}</small>
           <small>Item Level {profile.gearStats.averageItemLevel.toFixed(1)}</small>
           <div className="header-xp" title={`${profile.character.experience} total experience`}>
-            <span style={{ width: `${experiencePercent}%` }} />
+            <span style={barFillStyle(experiencePercent)} />
           </div>
           <button className="logout-button" onClick={signOut} type="button">
             {gameMode === 'offline' ? 'Leave Offline' : `Sign Out ${account.username}`}

src/admin.tsx

@@ -3,9 +3,12 @@ import { createRoot } from 'react-dom/client'
 import './index.css'
 import './App.css'
 import { AdminScreen } from './components/AdminScreen'
+import { InputProvider } from './input'
 
 createRoot(document.getElementById('root')!).render(
   <StrictMode>
+    <InputProvider>
       <AdminScreen onBack={() => window.close()} />
+    </InputProvider>
   </StrictMode>,
 )

src/combat/spellCasting.ts

@@ -1,21 +1,79 @@
 import type { Spell } from '../game'
 
+export function cooldownNow() {
+  return Date.now()
+}
+
+export function cooldownRemaining(
+  cooldowns: Record<string, number>,
+  spellId: string,
+  now = cooldownNow(),
+) {
+  return Math.max(0, ((cooldowns[spellId] ?? 0) - now) / 1000)
+}
+
+export function hasActiveCooldowns(
+  cooldowns: Record<string, number>,
+  now = cooldownNow(),
+) {
+  return Object.values(cooldowns).some((readyAtMs) => readyAtMs > now)
+}
+
+export function pruneExpiredCooldowns(
+  cooldowns: Record<string, number>,
+  now = cooldownNow(),
+) {
+  let changed = false
+  const nextCooldowns: Record<string, number> = {}
+  for (const id in cooldowns) {
+    if (cooldowns[id] <= now) {
+      changed = true
+      continue
+    }
+    nextCooldowns[id] = cooldowns[id]
+  }
+  return changed ? nextCooldowns : cooldowns
+}
+
+export function reduceCooldown(
+  cooldowns: Record<string, number>,
+  spellId: string,
+  seconds: number,
+  now = cooldownNow(),
+) {
+  const readyAtMs = cooldowns[spellId]
+  if (!readyAtMs || readyAtMs <= now) return cooldowns
+  const nextReadyAtMs = readyAtMs - seconds * 1000
+  const nextCooldowns = { ...cooldowns }
+  if (nextReadyAtMs <= now) delete nextCooldowns[spellId]
+  else nextCooldowns[spellId] = nextReadyAtMs
+  return nextCooldowns
+}
+
 export function canCastSpell(
   spell: Spell,
   resource: number,
   cooldowns: Record<string, number>,
   resourceCost: number,
+  now = cooldownNow(),
 ) {
-  return resource >= resourceCost && (cooldowns[spell.id] ?? 0) <= 0
+  return resource >= resourceCost && cooldownRemaining(cooldowns, spell.id, now) <= 0
 }
 
 export function putSpellOnCooldown(
   cooldowns: Record<string, number>,
   spell: Spell,
   cooldownMultiplier = 1,
+  now = cooldownNow(),
 ) {
+  const cooldownMs = spell.cooldown * cooldownMultiplier * 1000
+  if (cooldownMs <= 0) {
+    const nextCooldowns = { ...cooldowns }
+    delete nextCooldowns[spell.id]
+    return nextCooldowns
+  }
   return {
     ...cooldowns,
-    [spell.id]: spell.cooldown * cooldownMultiplier,
+    [spell.id]: now + cooldownMs,
   }
 }

src/components/CombatScreen.tsx

@@ -46,7 +46,7 @@ import {
   spellPowerMultiplier,
   spellResourceCost as modifiedSpellResourceCost,
 } from '../combat/spellModifiers'
-import { advanceCooldowns, regenerateResource, tickSeconds } from '../combat/combatTick'
+import { regenerateResource } from '../combat/combatTick'
 import { advanceMemberTick, attachJumpedBounceHeals } from '../combat/combatEngine'
 import { applyCastStateUpdate } from '../combat/combatStateTransitions'
 import { buildCombatDualScreenState } from '../combat/dualScreenPayloads'
@@ -58,7 +58,11 @@ import {
   appendCombatLog,
   type BasicFloatingCombatText,
 } from '../combat/combatPresentation'
-import { canCastSpell } from '../combat/spellCasting'
+import {
+  canCastSpell,
+  pruneExpiredCooldowns,
+  reduceCooldown,
+} from '../combat/spellCasting'
 import {
   applySpellEffectProfile,
   buildSpellTargetPlan,
@@ -69,9 +73,11 @@ import {
   useInput,
 } from '../input'
 import { useFloatingCombatText } from '../hooks/useFloatingCombatText'
+import { useSpellSlots } from '../hooks/useSpellSlots'
 import { usePartyTargeting } from '../hooks/usePartyTargeting'
 import { PartyMemberFrame } from './PartyFrames'
-import { ResourceBar, SpellBar, type SpellSlot } from './SpellBars'
+import { ResourceBar, SpellBar } from './SpellBars'
+import { barFillStyle } from './barStyles'
 import { BonusItemReward, LootRollList, RewardXpSummary } from './RewardPanels'
 import { ResultScreen } from './ResultScreen'
 import {
@@ -668,10 +674,10 @@ export function CombatScreen({
       })
       floatingHeals.forEach((event) => addFloatingHeal(event.memberId, event.value))
       resourceSpentRef.current += effectiveCost
-      const nextCooldowns = { ...current.cooldowns }
+      let nextCooldowns = current.cooldowns
       if (spell.name === 'Mend' && activeEffects.has('mend_reduces_radiance_cooldown')) {
         const radiance = spellByName.get('Radiance')
-        if (radiance) nextCooldowns[radiance.id] = Math.max(0, (nextCooldowns[radiance.id] ?? 0) - 2)
+        if (radiance) nextCooldowns = reduceCooldown(nextCooldowns, radiance.id, 2)
       }
       setCombat(applyCastStateUpdate({
         current,
@@ -855,7 +861,7 @@ export function CombatScreen({
   const runCombatTick = useCallback(() => {
       const current = combatRef.current
       const nextElapsedTicks = current.elapsedTicks + 1
-      const nextCooldowns = advanceCooldowns(current.cooldowns, tickSeconds(TICK_MS))
+      const nextCooldowns = pruneExpiredCooldowns(current.cooldowns)
       let nextResource = regenerateResource(current.resource, 2.4, maxResource)
 
       const living = current.party.filter((member) => member.health > 0)
@@ -1161,17 +1167,17 @@ export function CombatScreen({
     }).reverse(),
     [enemyCount, enemyHealth, encounter.maxHealth],
   )
-  const spellSlots = useMemo<SpellSlot[]>(() => profile.abilitySlots.map((abilityId, slotIndex) => {
-    const spell = spellByKey.get(String(slotIndex + 1))
-    return abilityId && spell
-      ? {
-        ...spell,
-        cost: spellResourceCost(spell, roguelikeUpgradeCounts, freeCastReady),
-        slotIndex,
-        remaining: cooldowns[spell.id] ?? 0,
-      }
-      : null
-  }), [cooldowns, freeCastReady, profile.abilitySlots, roguelikeUpgradeCounts, spellByKey])
+  const spellSlotCost = useCallback(
+    (spell: Spell) => spellResourceCost(spell, roguelikeUpgradeCounts, freeCastReady),
+    [freeCastReady, roguelikeUpgradeCounts],
+  )
+  const spellSlots = useSpellSlots({
+    spells,
+    abilitySlots: profile.abilitySlots,
+    cooldowns,
+    active: status === 'playing' && !paused,
+    cost: spellSlotCost,
+  })
   const dualScreenState = useMemo(() => buildCombatDualScreenState({
     difficultyName: difficulty.name,
     dungeonName: dungeon.name,
@@ -1232,7 +1238,7 @@ export function CombatScreen({
   return (
       <main
         className={`game-shell ${dualScreenEnabled ? 'dual-top-game-shell' : ''}`}
-      data-combat-active={paused ? 'false' : 'true'}
+      data-combat-active={status === 'playing' && !paused ? 'true' : 'false'}
     >
       {!dualScreenEnabled && <header className="topbar">
         <div>
@@ -1266,13 +1272,13 @@ export function CombatScreen({
                 <div className="hard-enemy-bars">
                   {enemyHealthSegments.map((segment) => (
                     <div className="bar enemy-health" key={segment.index}>
-                      <span style={{ width: `${segment.percent}%` }} />
+                      <span style={barFillStyle(segment.percent)} />
                       <em>{encounter.enemyName} {segment.index + 1}: {Math.ceil(segment.health)} / {encounter.maxHealth}</em>
                     </div>
                   ))}
                 </div>
               ) : (
-                <div className="bar enemy-health"><span style={{ width: `${enemyPercent}%` }} /></div>
+                <div className="bar enemy-health"><span style={barFillStyle(enemyPercent)} /></div>
               )}
               <p>{encounter.description}</p>
             </div>

src/components/PartyFrames.tsx

@@ -7,6 +7,7 @@ import {
   memberHotEffects,
 } from '../combat/rules'
 import { ControllerBindingLabel } from './ControllerIcons'
+import { barFillStyle } from './barStyles'
 
 export type FloatingCombatText = {
   id: number
@@ -131,8 +132,8 @@ export const PartyMemberFrame = memo(function PartyMemberFrame({
         {showHeaderHealth && <small>{Math.ceil(member.health)} / {maxHealth}</small>}
       </div>
       <div className="bar member-health">
-        <span style={{ width: `${(member.health / maxHealth) * 100}%` }} />
-        {member.shield > 0 && <i style={{ width: `${(member.shield / maxHealth) * 100}%` }} />}
+        <span style={barFillStyle((member.health / maxHealth) * 100)} />
+        {member.shield > 0 && <i style={barFillStyle((member.shield / maxHealth) * 100, 'right')} />}
         {showHealthText && <em className="health-text">{Math.floor(member.health)} / {maxHealth}</em>}
       </div>
       <div className="floating-combat-texts" aria-hidden="true">

src/components/PvpRoguelikeScreen.tsx

@@ -13,9 +13,11 @@ import { completeRoguelike, type DungeonReward } from '../profile'
 import type { CharacterProfile, DungeonEncounter } from '../profile'
 import type { GameMode } from '../gameRepository'
 import { PartyMemberFrame } from './PartyFrames'
-import { SpellBar, type SpellSlot } from './SpellBars'
+import { SpellBar } from './SpellBars'
+import { barFillStyle } from './barStyles'
 import { focusFirstControl, useGameAction, useInput } from '../input'
 import { useDeadlineTimer, useRoundCountdown } from '../hooks/useCountdownTimer'
+import { useSpellSlots } from '../hooks/useSpellSlots'
 import { useSidedFloatingCombatText } from '../hooks/useFloatingCombatText'
 import { usePartyTargeting } from '../hooks/usePartyTargeting'
 import {
@@ -37,10 +39,14 @@ import {
   spellExtraTargets,
   spellResourceCost as modifiedSpellResourceCost,
 } from '../combat/spellModifiers'
-import { advanceCooldowns, regenerateResource, tickSeconds } from '../combat/combatTick'
+import { regenerateResource } from '../combat/combatTick'
 import { advanceMemberTick } from '../combat/combatEngine'
 import { buildPvpRoguelikeDualScreenState } from '../combat/dualScreenPayloads'
 import { applyPvpSpellCast } from '../combat/pvpSpellCasting'
+import {
+  pruneExpiredCooldowns,
+  reduceCooldown,
+} from '../combat/spellCasting'
 import {
   nextPvpRoguelikeStage,
   resolvePvpRoguelikeCombatOutcome,
@@ -398,12 +404,16 @@ export function PvPRoguelikeScreen({
   const cpuAlive = cpuSide.party.some((member) => member.health > 0)
   const playerBuffCounts = useMemo(() => createStackCounts(playerSide.buffs), [playerSide.buffs])
   const playerDebuffCounts = useMemo(() => createStackCounts(playerSide.debuffs), [playerSide.debuffs])
-  const playerSpellSlots = useMemo<SpellSlot[]>(() => starterSpells.map((spell, slotIndex) => ({
-    ...spell,
-    cost: spellResourceCost(spell, playerBuffCounts, playerDebuffCounts, playerSide.freeCastReady),
-    slotIndex,
-    remaining: playerSide.cooldowns[spell.id] ?? 0,
-  })), [playerBuffCounts, playerDebuffCounts, playerSide.cooldowns, playerSide.freeCastReady, starterSpells])
+  const playerSpellSlotCost = useCallback(
+    (spell: Spell) => spellResourceCost(spell, playerBuffCounts, playerDebuffCounts, playerSide.freeCastReady),
+    [playerBuffCounts, playerDebuffCounts, playerSide.freeCastReady],
+  )
+  const playerSpellSlots = useSpellSlots({
+    spells: starterSpells,
+    cooldowns: playerSide.cooldowns,
+    active: status === 'playing' && !paused,
+    cost: playerSpellSlotCost,
+  })
   const opponentBuffSummary = useMemo(
     () => cpuSide.buffs.length > 0 ? summarizeStacks(cpuSide.buffs, selfBuffChoicesCatalog) : 'none',
     [cpuSide.buffs, selfBuffChoicesCatalog],
@@ -880,9 +890,9 @@ export function PvPRoguelikeScreen({
         damageReductionTargets: new Set<string>(),
         groupTargets,
       }
-    const nextCooldowns = { ...current.cooldowns }
+    let nextCooldowns = current.cooldowns
     if (spell.kind === 'direct' && hasSpellEffect('mend_reduces_radiance_cooldown') && radianceEffect) {
-      nextCooldowns[radianceEffect.id] = Math.max(0, (nextCooldowns[radianceEffect.id] ?? 0) - 2)
+      nextCooldowns = reduceCooldown(nextCooldowns, radianceEffect.id, 2)
     }
     return applyPvpSpellCast({
       current,
@@ -994,7 +1004,7 @@ export function PvPRoguelikeScreen({
       ...side,
       party: nextParty,
       resource: regenerateResource(side.resource, 2.4, maxResource),
-      cooldowns: advanceCooldowns(side.cooldowns, tickSeconds(TICK_MS)),
+      cooldowns: pruneExpiredCooldowns(side.cooldowns),
       enemyHealth: Math.max(0, side.enemyHealth - partyDamageOutput(nextParty, encounterValue.partyDamage)),
     }
   }, [activeSpellEffects, addFloatingHeal, maxResource])
@@ -1428,13 +1438,13 @@ export function PvPRoguelikeScreen({
                   <div className="pvp-clear-wrap">
                     <span>Your clear {Math.max(0, Math.floor(playerSide.enemyHealth))} / {encounter.maxHealth}</span>
                     <div className="bar enemy-health boss-bar">
-                      <span style={{ width: `${(playerSide.enemyHealth / encounter.maxHealth) * 100}%` }} />
+                      <span style={barFillStyle((playerSide.enemyHealth / encounter.maxHealth) * 100)} />
                     </div>
                   </div>
                   <div className="pvp-resource-wrap">
                     <span>{gameClass.resourceName} {Math.floor(playerSide.resource)} / {maxResource}</span>
                     {speedMultiplier === 2 && <strong className="speed-badge">2x speed</strong>}
-                    <div className="bar mana-bar"><span style={{ width: `${(playerSide.resource / maxResource) * 100}%` }} /></div>
+                    <div className="bar mana-bar"><span style={barFillStyle((playerSide.resource / maxResource) * 100)} /></div>
                   </div>
                 </div>
               </div>
@@ -1468,12 +1478,12 @@ export function PvPRoguelikeScreen({
                   <div className="pvp-clear-wrap">
                     <span>{liveMatch ? `${liveMatch.opponentName} clear` : 'CPU clear'} {Math.max(0, Math.floor(cpuSide.enemyHealth))} / {encounter.maxHealth}</span>
                     <div className="bar enemy-health boss-bar">
-                      <span style={{ width: `${(cpuSide.enemyHealth / encounter.maxHealth) * 100}%` }} />
+                      <span style={barFillStyle((cpuSide.enemyHealth / encounter.maxHealth) * 100)} />
                     </div>
                   </div>
                   <div className="pvp-resource-wrap">
                     <span>{gameClass.resourceName} {Math.floor(cpuSide.resource)} / {maxResource}</span>
-                    <div className="bar mana-bar"><span style={{ width: `${(cpuSide.resource / maxResource) * 100}%` }} /></div>
+                    <div className="bar mana-bar"><span style={barFillStyle((cpuSide.resource / maxResource) * 100)} /></div>
                   </div>
                 </div>
               </div>
@@ -1499,6 +1509,7 @@ export function PvPRoguelikeScreen({
               bindings={activeBindings}
               canCast={status === 'playing' && !playerDone && playerAlive}
               className="pvp-bottom-spell-bar"
+              focusable={false}
               iconStyle={controllerIconStyle}
               onCast={castPlayerSpell}
               resource={playerSide.resource}

src/components/PvpStadiumScreen.tsx

@@ -11,9 +11,11 @@ import { completeRoguelike } from '../profile'
 import type { CharacterProfile } from '../profile'
 import type { GameMode } from '../gameRepository'
 import { PartyMemberFrame } from './PartyFrames'
-import { SpellBar, type SpellSlot } from './SpellBars'
+import { SpellBar } from './SpellBars'
+import { barFillStyle } from './barStyles'
 import { focusFirstControl, useGameAction, useInput, type InputAction } from '../input'
 import { useDeadlineTimer, useRoundCountdown } from '../hooks/useCountdownTimer'
+import { useSpellSlots } from '../hooks/useSpellSlots'
 import { useSidedFloatingCombatText } from '../hooks/useFloatingCombatText'
 import { usePartyTargeting } from '../hooks/usePartyTargeting'
 import { useDualScreen, useDualScreenPublisher } from '../dualScreen'
@@ -31,10 +33,13 @@ import {
   spellPowerMultiplier,
   spellResourceCost as modifiedSpellResourceCost,
 } from '../combat/spellModifiers'
-import { advanceCooldowns, regenerateResource, tickSeconds } from '../combat/combatTick'
+import { regenerateResource } from '../combat/combatTick'
 import { advanceMemberTick } from '../combat/combatEngine'
 import { buildStadiumDualScreenState } from '../combat/dualScreenPayloads'
 import { applyPvpSpellCast } from '../combat/pvpSpellCasting'
+import {
+  pruneExpiredCooldowns,
+} from '../combat/spellCasting'
 import {
   appendCombatLog,
   STADIUM_COMBAT_LOG_LIMIT,
@@ -400,12 +405,16 @@ export function PvpStadiumScreen({
   const opponentLabel = liveMatch ? liveMatch.opponentName : `CPU ${cpuDifficulty ?? 1}`
   const playerAlive = playerSide.party.some((member) => member.health > 0)
   const playerBuffCounts = useMemo(() => createStackCounts(playerSide.buffs), [playerSide.buffs])
-  const playerSpellSlots = useMemo<SpellSlot[]>(() => starterSpells.map((spell, slotIndex) => ({
-    ...spell,
-    cost: spellResourceCost(spell, playerBuffCounts, playerSide.freeCastReady),
-    slotIndex,
-    remaining: playerSide.cooldowns[spell.id] ?? 0,
-  })), [playerBuffCounts, playerSide.cooldowns, playerSide.freeCastReady, starterSpells])
+  const playerSpellSlotCost = useCallback(
+    (spell: Spell) => spellResourceCost(spell, playerBuffCounts, playerSide.freeCastReady),
+    [playerBuffCounts, playerSide.freeCastReady],
+  )
+  const playerSpellSlots = useSpellSlots({
+    spells: starterSpells,
+    cooldowns: playerSide.cooldowns,
+    active: status === 'playing' && !paused,
+    cost: playerSpellSlotCost,
+  })
   const opponentBuffSummary = useMemo(
     () => summarizeStacks(cpuSide.buffs, buffCatalog),
     [buffCatalog, cpuSide.buffs],
@@ -790,7 +799,7 @@ export function PvpStadiumScreen({
       ...side,
       party: nextParty,
       resource: regenerateResource(side.resource, RESOURCE_REGEN_PER_TICK, MAX_RESOURCE),
-      cooldowns: advanceCooldowns(side.cooldowns, tickSeconds(TICK_MS)),
+      cooldowns: pruneExpiredCooldowns(side.cooldowns),
       survivalSeconds: nextSurvival,
       dampeningPercent,
     }
@@ -1168,16 +1177,16 @@ export function PvpStadiumScreen({
             </section>
 
             <section className="dual-top-spell-strip">
-              {starterSpells.map((spell, slotIndex) => {
-                const remaining = playerSide.cooldowns[spell.id] ?? 0
-                const cost = spellResourceCost(spell, playerBuffCounts, playerSide.freeCastReady)
+              {playerSpellSlots.map((spell, slotIndex) => {
+                if (!spell) return null
+                const remaining = spell.remaining
                 const percent = remaining > 0
                   ? Math.min(100, (remaining / Math.max(1, spell.cooldown)) * 100)
                   : 0
                 return (
                   <button
                     className="dual-top-spell"
-                    disabled={status !== 'playing' || !playerAlive || remaining > 0 || playerSide.resource < cost || paused}
+                    disabled={status !== 'playing' || !playerAlive || remaining > 0 || playerSide.resource < spell.cost || paused}
                     key={spell.id}
                     onClick={() => castPlayerSpell(spell)}
                     type="button"
@@ -1192,7 +1201,7 @@ export function PvpStadiumScreen({
               <div className="dual-top-resource">
                 <strong>{gameClass.resourceName} {Math.floor(playerSide.resource)} / {MAX_RESOURCE}</strong>
                 <div className="bar mana-bar">
-                  <span style={{ width: `${(playerSide.resource / MAX_RESOURCE) * 100}%` }} />
+                  <span style={barFillStyle((playerSide.resource / MAX_RESOURCE) * 100)} />
                 </div>
               </div>
             </section>
@@ -1226,7 +1235,7 @@ export function PvpStadiumScreen({
                 </div>
                 <div className="pvp-resource-wrap">
                   <span>{gameClass.resourceName} {Math.floor(playerSide.resource)} / {MAX_RESOURCE}</span>
-                  <div className="bar mana-bar"><span style={{ width: `${(playerSide.resource / MAX_RESOURCE) * 100}%` }} /></div>
+                  <div className="bar mana-bar"><span style={barFillStyle((playerSide.resource / MAX_RESOURCE) * 100)} /></div>
                 </div>
               </div>
               <div className="party-grid pvp-party-grid">
@@ -1256,7 +1265,7 @@ export function PvpStadiumScreen({
                 </div>
                 <div className="pvp-resource-wrap">
                   <span>{gameClass.resourceName} {Math.floor(cpuSide.resource)} / {MAX_RESOURCE}</span>
-                  <div className="bar mana-bar"><span style={{ width: `${(cpuSide.resource / MAX_RESOURCE) * 100}%` }} /></div>
+                  <div className="bar mana-bar"><span style={barFillStyle((cpuSide.resource / MAX_RESOURCE) * 100)} /></div>
                 </div>
               </div>
               <div className="party-grid pvp-party-grid">
@@ -1280,6 +1289,7 @@ export function PvpStadiumScreen({
               bindings={activeBindings}
               canCast={status === 'playing' && playerAlive}
               className="pvp-bottom-spell-bar"
+              focusable={false}
               iconStyle={controllerIconStyle}
               onCast={castPlayerSpell}
               resource={playerSide.resource}

src/components/SettingsScreen.tsx

@@ -32,11 +32,13 @@ export function SettingsScreen({ onBack }: { onBack: () => void }) {
     capture,
     controllerIconStyle,
     directPartyTargeting,
+    combatTouchLocked,
     beginCapture,
     cancelCapture,
     resetBindings,
     setControllerIconStyle,
     setDirectPartyTargeting,
+    setCombatTouchLocked,
   } = useInput()
   const {
     enabled: dualScreenEnabled,
@@ -89,14 +91,8 @@ export function SettingsScreen({ onBack }: { onBack: () => void }) {
 
   return (
     <section className="content-screen settings-screen">
-      <div className="screen-heading">
-        <div>
-          <p className="eyebrow">Game Options</p>
-          <h1>Settings</h1>
-        </div>
-        <button className="back-button" onClick={onBack} type="button">Back</button>
-      </div>
-
+      <div className="settings-nav">
+        <button className="back-button settings-back-button" onClick={onBack} type="button">Back</button>
         <nav className="settings-tabs" role="tablist" aria-label="Settings sections">
           {([
             { key: 'display', label: 'Display' },
@@ -115,6 +111,7 @@ export function SettingsScreen({ onBack }: { onBack: () => void }) {
             </button>
           ))}
         </nav>
+      </div>
 
       {settingsTab === 'display' && (
         <section className="dual-screen-settings settings-tab-panel">
@@ -180,6 +177,14 @@ export function SettingsScreen({ onBack }: { onBack: () => void }) {
           >
             {directPartyTargeting ? 'Direct Targeting On' : 'Direct Targeting Off'}
           </button>
+          <button
+            aria-pressed={combatTouchLocked}
+            className={combatTouchLocked ? 'selected' : ''}
+            onClick={() => setCombatTouchLocked(!combatTouchLocked)}
+            type="button"
+          >
+            {combatTouchLocked ? 'Combat Touch Locked' : 'Combat Touch Unlocked'}
+          </button>
           <div className="controller-icon-options">
             <span>Controller Icons</span>
             {(['xbox', 'playstation', 'nintendo'] as const).map((style) => (

src/components/SpellBars.tsx

@@ -2,6 +2,7 @@ import { memo } from 'react'
 import type { ControllerIconStyle } from '../input'
 import type { Spell } from '../game'
 import { ControllerBindingLabel } from './ControllerIcons'
+import { barFillStyle } from './barStyles'
 
 export type SpellSlot = (Spell & {
   cost: number
@@ -28,7 +29,7 @@ export const ResourceBar = memo(function ResourceBar({
         {unavailableText ?? `${resourceName} ${Math.floor(resource)} / ${maxResource}`}
       </span>
       {speedMultiplier === 2 && <strong className="speed-badge">2x speed</strong>}
-      <div className="bar mana-bar"><span style={{ width: `${(resource / maxResource) * 100}%` }} /></div>
+      <div className="bar mana-bar"><span style={barFillStyle((resource / maxResource) * 100)} /></div>
     </div>
   )
 })
@@ -39,6 +40,7 @@ export const SpellButton = memo(function SpellButton({
   iconStyle,
   resourceName,
   disabled,
+  focusable = true,
   onCast,
   emptyKeyPrefix = 'empty',
 }: {
@@ -47,6 +49,7 @@ export const SpellButton = memo(function SpellButton({
   iconStyle: ControllerIconStyle
   resourceName: string
   disabled?: boolean
+  focusable?: boolean
   onCast: (spell: Spell) => void
   emptyKeyPrefix?: string
 }) {
@@ -60,9 +63,11 @@ export const SpellButton = memo(function SpellButton({
   return (
     <button
       className="spell"
+      data-controller-nav={focusable ? undefined : 'skip'}
       disabled={disabled}
       key={spell.id}
       onClick={() => onCast(spell)}
+      tabIndex={focusable ? undefined : -1}
       title={spell.description}
       type="button"
     >
@@ -94,6 +99,7 @@ export const SpellBar = memo(function SpellBar({
   canCast,
   onCast,
   className = 'spell-bar six-slots vertical-spell-bar',
+  focusable = true,
 }: {
   spells: SpellSlot[]
   bindings: Record<string, string>
@@ -103,6 +109,7 @@ export const SpellBar = memo(function SpellBar({
   canCast: boolean
   onCast: (spell: Spell) => void
   className?: string
+  focusable?: boolean
 }) {
   return (
     <div className={className}>
@@ -118,6 +125,7 @@ export const SpellBar = memo(function SpellBar({
           <SpellButton
             binding={bindings[`ability${slotIndex + 1}`]}
             disabled={!canCast || resource < spell.cost || spell.remaining > 0}
+            focusable={focusable}
             iconStyle={iconStyle}
             key={spell.id}
             onCast={onCast}

src/components/barStyles.ts

@@ -0,0 +1,16 @@
+import type { CSSProperties } from 'react'
+
+function clampScale(value: number) {
+  if (!Number.isFinite(value)) return 0
+  return Math.min(1, Math.max(0, value))
+}
+
+export function barFillStyle(
+  percent: number,
+  origin: 'left' | 'right' = 'left',
+): CSSProperties {
+  return {
+    transform: `scaleX(${clampScale(percent / 100)})`,
+    transformOrigin: `${origin} center`,
+  }
+}

src/dualScreen.tsx

@@ -19,9 +19,11 @@ import {
   dispatchExternalGameAction,
   type ControllerIconStyle,
   type InputAction,
+  useGameAction,
 } from './input'
 import { ControllerBindingLabel } from './components/ControllerIcons'
 import { PartyMemberFrame } from './components/PartyFrames'
+import { barFillStyle } from './components/barStyles'
 import { groupFloatingTextsByMember } from './combat/combatPresentation'
 
 const STORAGE_KEY = 'ashen-halls-dual-screen-enabled'
@@ -148,6 +150,16 @@ function formatDualTime(seconds: number) {
   return `${Math.floor(total / 60)}:${String(total % 60).padStart(2, '0')}`
 }
 
+function shouldRelayBottomAction(
+  action: InputAction,
+  state: DualScreenCombatState | null,
+) {
+  if (!state) return false
+  if (action === 'confirm' || action === 'toggleTouchLock') return false
+  if (state.status === 'playing') return true
+  return action === 'pause' || action === 'back'
+}
+
 export function DualScreenProvider({ children }: { children: ReactNode }) {
   const [enabled, setEnabledState] = useState(
     () => localStorage.getItem(STORAGE_KEY) === 'true',
@@ -401,6 +413,11 @@ export function DualScreenBottomDisplay() {
     channel?.close()
   }
 
+  useGameAction((action) => {
+    if (!shouldRelayBottomAction(action, state)) return
+    sendAction(action)
+  })
+
   if (!state && workshopState) {
     return (
       <main className="dual-bottom-display workshop-bottom-display">
@@ -448,7 +465,10 @@ export function DualScreenBottomDisplay() {
   }
 
   return (
-    <main className={`dual-bottom-display ${state.opponentParty ? 'pvp-opponent-bottom-display' : ''}`}>
+    <main
+      className={`dual-bottom-display ${state.opponentParty ? 'pvp-opponent-bottom-display' : ''}`}
+      data-combat-active={state.status === 'playing' && !state.paused ? 'true' : 'false'}
+    >
       <header className="dual-controls-header">
         <div>
           <p className="eyebrow">{state.opponentParty ? 'Opponent View' : `${state.difficultyName} ${state.contentName}`}</p>
@@ -480,7 +500,7 @@ export function DualScreenBottomDisplay() {
                 <strong>{Math.max(0, Math.floor(state.opponentEnemyHealth ?? 0))} / {state.encounterMaxHealth}</strong>
               </div>
               <div className="bar enemy-health boss-bar">
-                <span style={{ width: `${Math.max(0, ((state.opponentEnemyHealth ?? 0) / state.encounterMaxHealth) * 100)}%` }} />
+                <span style={barFillStyle(((state.opponentEnemyHealth ?? 0) / state.encounterMaxHealth) * 100)} />
               </div>
               {typeof state.opponentResource === 'number' && state.opponentMaxResource ? (
                 <>
@@ -489,7 +509,7 @@ export function DualScreenBottomDisplay() {
                     <strong>{Math.floor(state.opponentResource)} / {state.opponentMaxResource}</strong>
                   </div>
                   <div className="bar mana-bar">
-                    <span style={{ width: `${Math.max(0, (state.opponentResource / state.opponentMaxResource) * 100)}%` }} />
+                    <span style={barFillStyle((state.opponentResource / state.opponentMaxResource) * 100)} />
                   </div>
                 </>
               ) : null}
@@ -527,7 +547,7 @@ export function DualScreenBottomDisplay() {
           <span>{state.resourceName} {Math.floor(state.resource)} / {state.maxResource}</span>
           {state.speedMultiplier === 2 && <strong className="speed-badge">2x speed</strong>}
           <div className="bar mana-bar">
-            <span style={{ width: `${(state.resource / state.maxResource) * 100}%` }} />
+            <span style={barFillStyle((state.resource / state.maxResource) * 100)} />
           </div>
         </div>
       </section>
@@ -648,6 +668,7 @@ export function DualScreenTopCombat({
     return (
       <button
         className="dual-top-spell"
+        data-controller-nav={state.opponentParty ? 'skip' : undefined}
         disabled={
           !state.playerIsAlive
           || state.resource < spell.cost
@@ -678,14 +699,24 @@ export function DualScreenTopCombat({
             <span>{Math.ceil(state.encounterHealth)} / {state.encounterMaxHealth}</span>
           </div>
           <div className="bar enemy-health">
-            <span style={{ width: `${enemyPercent}%` }} />
-          </div>
-          <p>{state.encounterDescription}</p>
+            <span style={barFillStyle(enemyPercent)} />
           </div>
           {state.opponentParty && (
+            <div className="dual-top-resource">
+              <strong>{state.resourceName} {Math.floor(state.resource)} / {state.maxResource}</strong>
+              <div className="bar mana-bar">
+                <span style={barFillStyle((state.resource / state.maxResource) * 100)} />
+              </div>
+            </div>
+          )}
+          {!state.opponentParty && <p>{state.encounterDescription}</p>}
+        </div>
+        {state.opponentParty && (
+          <div className="dual-top-side-status">
             <div className="dual-top-cooldowns" aria-label="Cooldowns">
               {spellButtons}
             </div>
+          </div>
         )}
       </section>
 
@@ -720,7 +751,7 @@ export function DualScreenTopCombat({
           <div className="dual-top-resource">
             <strong>{state.resourceName} {Math.floor(state.resource)} / {state.maxResource}</strong>
             <div className="bar mana-bar">
-              <span style={{ width: `${(state.resource / state.maxResource) * 100}%` }} />
+              <span style={barFillStyle((state.resource / state.maxResource) * 100)} />
             </div>
           </div>
         </section>

src/hooks/useCooldownClock.ts

@@ -0,0 +1,36 @@
+import { useEffect, useState } from 'react'
+import { cooldownNow, hasActiveCooldowns } from '../combat/spellCasting'
+
+export function useCooldownClock(
+  cooldowns: Record<string, number>,
+  active: boolean,
+  intervalMs = 100,
+) {
+  const [now, setNow] = useState(cooldownNow)
+
+  useEffect(() => {
+    if (!active || !hasActiveCooldowns(cooldowns)) return undefined
+
+    let timer = 0
+    let startTimer = 0
+    const tick = () => {
+      const nextNow = cooldownNow()
+      setNow(nextNow)
+      if (timer && !hasActiveCooldowns(cooldowns, nextNow)) {
+        window.clearInterval(timer)
+        timer = 0
+      }
+    }
+
+    startTimer = window.setTimeout(() => {
+      tick()
+      timer = window.setInterval(tick, intervalMs)
+    }, 0)
+    return () => {
+      window.clearTimeout(startTimer)
+      if (timer) window.clearInterval(timer)
+    }
+  }, [active, cooldowns, intervalMs])
+
+  return now
+}

src/hooks/useFloatingCombatText.ts

@@ -15,29 +15,31 @@ type FloatingCombatTextOptions = {
   durationMs?: number
 }
 
-const FLOATING_TEXT_CLEANUP_INTERVAL_MS = 100
-
 export function useFloatingCombatText<TText extends BasicFloatingCombatText>({
   durationMs = 900,
 }: FloatingCombatTextOptions = {}) {
   const [floatingTexts, setFloatingTexts] = useState<TText[]>([])
   const nextId = useRef(1)
   const expirationsRef = useRef(new Map<number, number>())
+  const cleanupTimerRef = useRef<number | null>(null)
 
-  const clearFloatingTexts = useCallback(() => {
-    expirationsRef.current.clear()
-    setFloatingTexts([])
+  const clearCleanupTimer = useCallback(() => {
+    if (cleanupTimerRef.current === null) return
+    window.clearTimeout(cleanupTimerRef.current)
+    cleanupTimerRef.current = null
   }, [])
 
-  const addFloatingText = useCallback((entry: Omit<TText, 'id'>) => {
-    if (entry.value <= 0) return
-    const id = nextId.current++
-    expirationsRef.current.set(id, performance.now() + durationMs)
-    setFloatingTexts((current) => appendFloatingText(current, { ...entry, id } as TText))
-  }, [durationMs])
+  const scheduleCleanup = useCallback(() => {
+    function scheduleNext() {
+      clearCleanupTimer()
+      let nextExpiry = Infinity
+      for (const expiresAt of expirationsRef.current.values()) {
+        nextExpiry = Math.min(nextExpiry, expiresAt)
+      }
+      if (!Number.isFinite(nextExpiry)) return
 
-  useEffect(() => {
-    const timer = window.setInterval(() => {
+      cleanupTimerRef.current = window.setTimeout(() => {
+        cleanupTimerRef.current = null
         const now = performance.now()
         let removed = false
         for (const [id, expiresAt] of expirationsRef.current) {
@@ -45,11 +47,31 @@ export function useFloatingCombatText<TText extends BasicFloatingCombatText>({
           expirationsRef.current.delete(id)
           removed = true
         }
-      if (!removed) return
+        if (removed) {
           setFloatingTexts((current) => current.filter((text) => expirationsRef.current.has(text.id)))
-    }, FLOATING_TEXT_CLEANUP_INTERVAL_MS)
-    return () => window.clearInterval(timer)
-  }, [])
+        }
+        scheduleNext()
+      }, Math.max(0, nextExpiry - performance.now()))
+    }
+
+    scheduleNext()
+  }, [clearCleanupTimer])
+
+  const clearFloatingTexts = useCallback(() => {
+    clearCleanupTimer()
+    expirationsRef.current.clear()
+    setFloatingTexts([])
+  }, [clearCleanupTimer])
+
+  const addFloatingText = useCallback((entry: Omit<TText, 'id'>) => {
+    if (entry.value <= 0) return
+    const id = nextId.current++
+    expirationsRef.current.set(id, performance.now() + durationMs)
+    setFloatingTexts((current) => appendFloatingText(current, { ...entry, id } as TText))
+    scheduleCleanup()
+  }, [durationMs, scheduleCleanup])
+
+  useEffect(() => () => clearCleanupTimer(), [clearCleanupTimer])
 
   const floatingTextsByMember = useMemo(
     () => groupFloatingTextsByMember(floatingTexts),

src/hooks/useSpellSlots.ts

@@ -0,0 +1,38 @@
+import { useMemo } from 'react'
+import type { Spell } from '../game'
+import type { SpellSlot } from '../components/SpellBars'
+import { cooldownRemaining } from '../combat/spellCasting'
+import { useCooldownClock } from './useCooldownClock'
+
+type UseSpellSlotsOptions = {
+  spells: readonly Spell[]
+  cooldowns: Record<string, number>
+  active: boolean
+  cost: (spell: Spell) => number
+  abilitySlots?: readonly (number | null)[]
+}
+
+export function useSpellSlots({
+  spells,
+  cooldowns,
+  active,
+  cost,
+  abilitySlots,
+}: UseSpellSlotsOptions) {
+  const now = useCooldownClock(cooldowns, active)
+
+  return useMemo<SpellSlot[]>(() => {
+    const slotCount = abilitySlots?.length ?? spells.length
+    return Array.from({ length: slotCount }, (_, slotIndex) => {
+      if (abilitySlots && !abilitySlots[slotIndex]) return null
+      const spell = spells[slotIndex]
+      if (!spell) return null
+      return {
+        ...spell,
+        cost: cost(spell),
+        slotIndex,
+        remaining: cooldownRemaining(cooldowns, spell.id, now),
+      }
+    })
+  }, [abilitySlots, cooldowns, cost, now, spells])
+}

src/index.css

@@ -3,7 +3,9 @@
     linear-gradient(rgba(8, 9, 12, 0.88), rgba(8, 9, 12, 0.88)),
     repeating-linear-gradient(0deg, #171922 0 2px, #11131a 2px 4px);
   color: #f4eed8;
-  font-family: 'VT323', Consolas, monospace;
+  --body-font: ui-monospace, 'Roboto Mono', 'Droid Sans Mono', Consolas, monospace;
+  --pixel-font: ui-monospace, 'Roboto Mono', 'Droid Sans Mono', Consolas, monospace;
+  font-family: var(--body-font);
   font-synthesis: none;
   text-rendering: optimizeLegibility;
 }

src/input.tsx

@@ -37,6 +37,7 @@ export const INPUT_ACTIONS = [
   'targetParty6',
   'toggleTargetGroup',
   'toggleSpeed',
+  'toggleTouchLock',
   'pause',
 ] as const
 
@@ -66,6 +67,7 @@ export const ACTION_LABELS: Record<InputAction, string> = {
   targetParty6: 'Target Party Member 6',
   toggleTargetGroup: 'Switch Raid Target Group',
   toggleSpeed: 'Toggle 2x Speed',
+  toggleTouchLock: 'Toggle Combat Touch Lock',
   pause: 'Pause Menu',
 }
 
@@ -93,6 +95,7 @@ export const DEFAULT_BINDINGS: Record<InputDevice, InputBindings> = {
     targetParty6: 'F6',
     toggleTargetGroup: 'Tab',
     toggleSpeed: 'Backquote',
+    toggleTouchLock: 'F7',
     pause: 'Escape',
   },
   controller: {
@@ -115,9 +118,10 @@ export const DEFAULT_BINDINGS: Record<InputDevice, InputBindings> = {
     targetParty3: 'Button15',
     targetParty4: 'Button13',
     targetParty5: 'Button4',
-    targetParty6: 'Button10',
-    toggleTargetGroup: 'Button6',
+    targetParty6: 'Button6',
+    toggleTargetGroup: 'Button8',
     toggleSpeed: 'Button11',
+    toggleTouchLock: 'Button10',
     pause: 'Button9',
   },
 }
@@ -126,10 +130,20 @@ const STORAGE_KEY = 'ashen-halls-input-bindings-v1'
 const PREFERENCES_STORAGE_KEY = 'ashen-halls-input-preferences-v1'
 const GAME_ACTION_EVENT = 'ashen-halls-game-action'
 const NATIVE_CONTROLLER_EVENT = 'ashen-halls-native-controller'
-const FOCUSABLE_SELECTOR = 'button:not(:disabled), input:not(:disabled), select:not(:disabled), textarea:not(:disabled), [tabindex]:not([tabindex="-1"])'
+const FOCUSABLE_SELECTOR = 'button:not(:disabled):not([data-controller-nav="skip"]), input:not(:disabled):not([data-controller-nav="skip"]), select:not(:disabled):not([data-controller-nav="skip"]), textarea:not(:disabled):not([data-controller-nav="skip"]), [tabindex]:not([tabindex="-1"]):not([data-controller-nav="skip"])'
+const MAIN_CONTENT_SELECTOR = '.auth-shell, .menu-screen, .content-screen, .dungeon-run-screen, .dual-bottom-display'
+const HEADER_CONTENT_SELECTOR = '.app-header'
 const GAMEPAD_COMBAT_POLL_MS = 1000 / 60
 const GAMEPAD_MENU_POLL_MS = 1000 / 30
 const GAMEPAD_BROWSER_DISCONNECTED_POLL_MS = 250
+const CONTROLLER_REPEAT_INITIAL_MS = 260
+const CONTROLLER_REPEAT_MS = 85
+const DPAD_NAV_ACTIONS: Partial<Record<string, InputAction>> = {
+  Button12: 'navigateUp',
+  Button13: 'navigateDown',
+  Button14: 'navigateLeft',
+  Button15: 'navigateRight',
+}
 
 let lastControllerFocus: HTMLElement | null = null
 
@@ -144,11 +158,13 @@ type InputContextValue = {
   lastDevice: InputDevice
   controllerIconStyle: ControllerIconStyle
   directPartyTargeting: boolean
+  combatTouchLocked: boolean
   beginCapture: (device: InputDevice, action: InputAction) => void
   cancelCapture: () => void
   resetBindings: (device: InputDevice) => void
   setControllerIconStyle: (style: ControllerIconStyle) => void
   setDirectPartyTargeting: (enabled: boolean) => void
+  setCombatTouchLocked: (locked: boolean) => void
 }
 
 const InputContext = createContext<InputContextValue | null>(null)
@@ -187,6 +203,21 @@ function loadBindings(): Record<InputDevice, InputBindings> {
     if (savedController?.targetParty6 === 'Button11') {
       controller.targetParty6 = DEFAULT_BINDINGS.controller.targetParty6
     }
+    if (
+      savedController?.targetParty6 === undefined
+      || savedController.targetParty6 === 'Button10'
+    ) {
+      controller.targetParty6 = DEFAULT_BINDINGS.controller.targetParty6
+    }
+    if (
+      savedController?.toggleTargetGroup === undefined
+      || savedController.toggleTargetGroup === 'Button6'
+    ) {
+      controller.toggleTargetGroup = DEFAULT_BINDINGS.controller.toggleTargetGroup
+    }
+    if (savedController?.toggleTouchLock === undefined) {
+      controller.toggleTouchLock = DEFAULT_BINDINGS.controller.toggleTouchLock
+    }
     return {
       pc: { ...DEFAULT_BINDINGS.pc, ...saved.pc },
       controller,
@@ -201,15 +232,18 @@ function loadPreferences() {
     const saved = JSON.parse(localStorage.getItem(PREFERENCES_STORAGE_KEY) ?? '{}') as {
       controllerIconStyle?: ControllerIconStyle
       directPartyTargeting?: boolean
+      combatTouchLocked?: boolean
     }
     return {
       controllerIconStyle: saved.controllerIconStyle ?? 'xbox',
       directPartyTargeting: saved.directPartyTargeting ?? false,
+      combatTouchLocked: saved.combatTouchLocked ?? Capacitor.isNativePlatform(),
     }
   } catch {
     return {
       controllerIconStyle: 'xbox' as ControllerIconStyle,
       directPartyTargeting: false,
+      combatTouchLocked: Capacitor.isNativePlatform(),
     }
   }
 }
@@ -223,6 +257,7 @@ function bindingGroup(action: InputAction) {
   if (action.startsWith('targetParty') || action === 'toggleTargetGroup') return 'direct-targeting'
   if (action === 'previousTarget' || action === 'nextTarget') return 'relative-targeting'
   if (action === 'pause') return 'pause'
+  if (action === 'toggleTouchLock' || action === 'toggleSpeed') return 'system'
   return 'navigation'
 }
 
@@ -231,6 +266,16 @@ function isVisible(element: HTMLElement) {
   return element.getClientRects().length > 0
 }
 
+function focusableDescendants(scope: ParentNode) {
+  return Array.from(
+    scope.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR),
+  ).filter(isVisible)
+}
+
+function uniqueElements(elements: HTMLElement[]) {
+  return elements.filter((element, index) => elements.indexOf(element) === index)
+}
+
 function focusableElements() {
   const keyboard = document.querySelector<HTMLElement>('.controller-keyboard')
   const pauseMenu = document.querySelector<HTMLElement>('.pause-screen')
@@ -239,10 +284,22 @@ function focusableElements() {
       '.result-screen, .binding-capture, .dual-startup-prompt',
     ),
   ).find(isVisible)
-  const scope: ParentNode = keyboard ?? pauseMenu ?? dialog ?? document
-  return Array.from(
-    scope.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR),
+  const mainContent = Array.from(
+    document.querySelectorAll<HTMLElement>(MAIN_CONTENT_SELECTOR),
+  ).find(isVisible)
+  const overlay = keyboard ?? pauseMenu ?? dialog
+  if (overlay) return focusableDescendants(overlay)
+  const visibleHeaders = Array.from(
+    document.querySelectorAll<HTMLElement>(HEADER_CONTENT_SELECTOR),
   ).filter(isVisible)
+  if (!mainContent) return visibleHeaders.length > 0 ? [] : focusableDescendants(document)
+  const headerControls = visibleHeaders.flatMap(
+    (header) => focusableDescendants(header),
+  )
+  return uniqueElements([
+    ...focusableDescendants(mainContent),
+    ...headerControls,
+  ])
 }
 
 function rememberFocusableControl(element: HTMLElement) {
@@ -252,6 +309,7 @@ function rememberFocusableControl(element: HTMLElement) {
 function focusControl(element: HTMLElement) {
   rememberFocusableControl(element)
   element.focus({ preventScroll: true })
+  element.scrollIntoView({ block: 'nearest', inline: 'nearest' })
 }
 
 function currentFocusableControl(candidates = focusableElements()) {
@@ -266,6 +324,23 @@ function currentFocusableControl(candidates = focusableElements()) {
   return null
 }
 
+function rangeDistance(startA: number, endA: number, startB: number, endB: number) {
+  if (endA < startB) return startB - endA
+  if (endB < startA) return startA - endB
+  return 0
+}
+
+function changeSelectOption(select: HTMLSelectElement, direction: -1 | 1) {
+  const options = Array.from(select.options).filter((option) => !option.disabled)
+  const currentIndex = options.findIndex((option) => option.index === select.selectedIndex)
+  const nextOption = options[currentIndex + direction]
+  if (!nextOption) return false
+  select.selectedIndex = nextOption.index
+  select.dispatchEvent(new Event('input', { bubbles: true }))
+  select.dispatchEvent(new Event('change', { bubbles: true }))
+  return true
+}
+
 export function focusFirstControl() {
   const first = focusableElements()[0]
   if (first) focusControl(first)
@@ -286,21 +361,48 @@ function moveFocus(action: InputAction) {
   const currentY = currentRect.top + currentRect.height / 2
   const vertical = action === 'navigateUp' || action === 'navigateDown'
   const direction = action === 'navigateUp' || action === 'navigateLeft' ? -1 : 1
+  const currentIndex = candidates.indexOf(current)
+
+  const adjacent = candidates[currentIndex + direction]
+  const fallbackToAdjacent = () => {
+    if (adjacent) focusControl(adjacent)
+  }
 
   const ranked = candidates
     .filter((candidate) => candidate !== current)
-    .map((candidate) => {
+    .map((candidate, index) => {
       const rect = candidate.getBoundingClientRect()
       const x = rect.left + rect.width / 2
       const y = rect.top + rect.height / 2
-      const primary = vertical ? y - currentY : x - currentX
-      const secondary = vertical ? Math.abs(x - currentX) : Math.abs(y - currentY)
-      return { candidate, primary, score: Math.abs(primary) + secondary * 2.5 }
+      const primary = vertical
+        ? direction > 0
+          ? rect.top - currentRect.bottom
+          : currentRect.top - rect.bottom
+        : direction > 0
+          ? rect.left - currentRect.right
+          : currentRect.left - rect.right
+      const secondary = vertical
+        ? rangeDistance(currentRect.left, currentRect.right, rect.left, rect.right)
+        : rangeDistance(currentRect.top, currentRect.bottom, rect.top, rect.bottom)
+      return {
+        candidate,
+        index,
+        primary,
+        secondary,
+        score: Math.max(0, primary) + secondary * 2.5 + (vertical ? Math.abs(x - currentX) : Math.abs(y - currentY)) * 0.1,
+      }
     })
-    .filter(({ primary }) => Math.sign(primary) === direction)
-    .sort((a, b) => a.score - b.score)
+    .filter(({ primary }) => primary >= -4)
+  const sameRowHorizontal = !vertical
+    ? ranked.filter(({ secondary }) => secondary === 0)
+    : ranked
+  if (sameRowHorizontal.length === 0) {
+    fallbackToAdjacent()
+    return
+  }
+  sameRowHorizontal.sort((a, b) => a.score - b.score || a.secondary - b.secondary || a.index - b.index)
 
-  const next = ranked[0]?.candidate
+  const next = sameRowHorizontal[0]?.candidate
   if (!next) return
   focusControl(next)
 }
@@ -428,6 +530,7 @@ export function InputProvider({ children }: { children: ReactNode }) {
   const [preferences, setPreferences] = useState(loadPreferences)
   const [keyboardInput, setKeyboardInput] = useState<HTMLInputElement | HTMLTextAreaElement | null>(null)
   const [keyboardShift, setKeyboardShift] = useState(false)
+  const [touchLockMessage, setTouchLockMessage] = useState('')
   const bindingsRef = useRef(bindings)
   const preferencesRef = useRef(preferences)
   const captureRef = useRef(capture)
@@ -435,6 +538,7 @@ export function InputProvider({ children }: { children: ReactNode }) {
   const previousTokensRef = useRef(new Set<string>())
   const repeatRef = useRef<Record<string, number>>({})
   const gamepadConnectedRef = useRef(Capacitor.isNativePlatform())
+  const touchLockMessageTimerRef = useRef(0)
 
   useEffect(() => {
     bindingsRef.current = bindings
@@ -485,13 +589,38 @@ export function InputProvider({ children }: { children: ReactNode }) {
     setLastDevice(device)
     document.documentElement.dataset.inputDevice = device
 
-    if (action.startsWith('navigate')) {
-      if (uiOverlay || !combatActive) moveFocus(action)
+    if (action === 'toggleTouchLock') {
+      setPreferences((current) => ({
+        ...current,
+        combatTouchLocked: !current.combatTouchLocked,
+      }))
+      window.clearTimeout(touchLockMessageTimerRef.current)
+      const nextLocked = !preferencesRef.current.combatTouchLocked
+      setTouchLockMessage(`Combat touch ${nextLocked ? 'locked' : 'unlocked'}`)
+      touchLockMessageTimerRef.current = window.setTimeout(() => {
+        setTouchLockMessage('')
+      }, 1400)
+    } else if (action.startsWith('navigate')) {
+      if (uiOverlay || !combatActive) {
+        const active = currentFocusableControl()
+        if (
+          active instanceof HTMLSelectElement
+          && (action === 'navigateUp' || action === 'navigateDown')
+          && changeSelectOption(active, action === 'navigateUp' ? -1 : 1)
+        ) {
+          return
+        }
+        moveFocus(action)
+      }
     } else if (action === 'confirm') {
       const active = currentFocusableControl()
       if (isTextInput(active)) {
         setKeyboardInput(active)
         window.requestAnimationFrame(() => focusFirstControl())
+      } else if (active instanceof HTMLSelectElement) {
+        const select = active as HTMLSelectElement & { showPicker?: () => void }
+        if (select.showPicker) select.showPicker()
+        else active.click()
       } else if (
         active
         && active.matches('button:not(:disabled), [role="button"]')
@@ -528,12 +657,6 @@ export function InputProvider({ children }: { children: ReactNode }) {
       document.querySelector('[data-combat-active="true"]'),
     )
     const uiOverlay = hasUiOverlay()
-    const menuDpadActions: Partial<Record<string, InputAction>> = {
-      Button12: 'navigateUp',
-      Button13: 'navigateDown',
-      Button14: 'navigateLeft',
-      Button15: 'navigateRight',
-    }
     const uiPriority = [
       'navigateUp',
       'navigateDown',
@@ -551,8 +674,10 @@ export function InputProvider({ children }: { children: ReactNode }) {
       'targetParty6',
       'toggleTargetGroup',
       'toggleSpeed',
+      'toggleTouchLock',
     ] satisfies InputAction[]
     const combatPriority = [
+      'toggleTouchLock',
       'pause',
       'toggleSpeed',
       'ability1',
@@ -568,18 +693,18 @@ export function InputProvider({ children }: { children: ReactNode }) {
       'navigateLeft',
       'navigateRight',
     ] satisfies InputAction[]
-    const action = menuDpadActions[token] && (!combatActive || uiOverlay)
-      ? menuDpadActions[token]
+    const action = DPAD_NAV_ACTIONS[token] && (!combatActive || uiOverlay)
+      ? DPAD_NAV_ACTIONS[token]
       : uiOverlay
       ? uiPriority.find((candidate) => bindingsRef.current.controller[candidate] === token)
       : combatActive && preferencesRef.current.directPartyTargeting
       ? [...directTargetActions, ...combatPriority].find(
           (candidate) => bindingsRef.current.controller[candidate] === token,
         )
-      : combatActive && menuDpadActions[token]
-        ? menuDpadActions[token]
-      : !combatActive && menuDpadActions[token]
-      ? menuDpadActions[token]
+      : combatActive && DPAD_NAV_ACTIONS[token]
+        ? DPAD_NAV_ACTIONS[token]
+      : !combatActive && DPAD_NAV_ACTIONS[token]
+      ? DPAD_NAV_ACTIONS[token]
       : (combatActive ? combatPriority : INPUT_ACTIONS).find(
           (candidate) => bindingsRef.current.controller[candidate] === token,
         )
@@ -621,7 +746,9 @@ export function InputProvider({ children }: { children: ReactNode }) {
       rememberFocusableControl(target)
     }
     const onPointerDown = (event: PointerEvent) => {
+      if (event.pointerType !== 'touch') {
         document.documentElement.dataset.inputDevice = 'pc'
+      }
       const target = event.target
       if (!(target instanceof Element)) return
       const control = target.closest<HTMLElement>(FOCUSABLE_SELECTOR)
@@ -645,8 +772,14 @@ export function InputProvider({ children }: { children: ReactNode }) {
     return () => window.removeEventListener(NATIVE_CONTROLLER_EVENT, listener)
   }, [dispatchControllerToken])
 
+  useEffect(() => () => {
+    window.clearTimeout(touchLockMessageTimerRef.current)
+  }, [])
+
   useEffect(() => {
+    let focusFrame = 0
     const ensureFocus = () => {
+      focusFrame = 0
       const combatActive = document.querySelector('[data-combat-active="true"]')
       if (combatActive) return
       const candidates = focusableElements()
@@ -663,22 +796,37 @@ export function InputProvider({ children }: { children: ReactNode }) {
         }
       }
     }
+    const scheduleEnsureFocus = () => {
+      if (focusFrame) return
+      focusFrame = window.requestAnimationFrame(ensureFocus)
+    }
     const observer = new MutationObserver(() => {
-      window.requestAnimationFrame(ensureFocus)
+      scheduleEnsureFocus()
     })
     observer.observe(document.getElementById('root') ?? document.body, {
       attributes: true,
-      attributeFilter: ['aria-hidden', 'class', 'disabled', 'hidden', 'style'],
+      attributeFilter: ['aria-hidden', 'class', 'disabled', 'hidden'],
       childList: true,
       subtree: true,
     })
-    window.requestAnimationFrame(ensureFocus)
-    return () => observer.disconnect()
+    scheduleEnsureFocus()
+    return () => {
+      if (focusFrame) window.cancelAnimationFrame(focusFrame)
+      observer.disconnect()
+    }
   }, [])
 
   useEffect(() => {
     let timer = 0
+    if (Capacitor.isNativePlatform() && capture?.device !== 'controller') {
+      previousTokensRef.current = new Set()
+      repeatRef.current = {}
+      return undefined
+    }
     const nextDelay = () => {
+      if (Capacitor.isNativePlatform()) {
+        return GAMEPAD_COMBAT_POLL_MS
+      }
       if (!Capacitor.isNativePlatform() && !gamepadConnectedRef.current) {
         return GAMEPAD_BROWSER_DISCONNECTED_POLL_MS
       }
@@ -705,11 +853,11 @@ export function InputProvider({ children }: { children: ReactNode }) {
         const action = INPUT_ACTIONS.find(
           (candidate) => bindingsRef.current.controller[candidate] === token,
         )
-        const canRepeat = action?.startsWith('navigate') ?? false
+        const canRepeat = Boolean(action?.startsWith('navigate') || DPAD_NAV_ACTIONS[token])
         const nextRepeat = repeatRef.current[token] ?? 0
         if (pressed || (canRepeat && time >= nextRepeat)) {
           dispatchControllerToken(token, !pressed)
-          repeatRef.current[token] = time + (pressed ? 360 : 125)
+          repeatRef.current[token] = time + (pressed ? CONTROLLER_REPEAT_INITIAL_MS : CONTROLLER_REPEAT_MS)
         }
       })
 
@@ -735,7 +883,39 @@ export function InputProvider({ children }: { children: ReactNode }) {
       window.removeEventListener('gamepadconnected', onGamepadConnected)
       window.removeEventListener('gamepaddisconnected', onGamepadDisconnected)
     }
-  }, [assignBinding, dispatchControllerToken])
+  }, [assignBinding, capture, dispatchControllerToken])
+
+  useEffect(() => {
+    const shouldBlockTouch = () => (
+      Capacitor.isNativePlatform()
+      && preferencesRef.current.combatTouchLocked
+      && isCombatActive()
+      && !hasUiOverlay()
+    )
+    const blockTouch = (event: Event) => {
+      if (
+        typeof PointerEvent !== 'undefined'
+        && event instanceof PointerEvent
+        && event.pointerType !== 'touch'
+      ) return
+      if (!shouldBlockTouch()) return
+      event.preventDefault()
+      event.stopImmediatePropagation()
+    }
+    const options = { capture: true, passive: false }
+    document.addEventListener('pointerdown', blockTouch, options)
+    document.addEventListener('pointerup', blockTouch, options)
+    document.addEventListener('touchstart', blockTouch, options)
+    document.addEventListener('touchmove', blockTouch, options)
+    document.addEventListener('touchend', blockTouch, options)
+    return () => {
+      document.removeEventListener('pointerdown', blockTouch, options)
+      document.removeEventListener('pointerup', blockTouch, options)
+      document.removeEventListener('touchstart', blockTouch, options)
+      document.removeEventListener('touchmove', blockTouch, options)
+      document.removeEventListener('touchend', blockTouch, options)
+    }
+  }, [])
 
   const contextValue = useMemo<InputContextValue>(() => ({
     bindings,
@@ -743,6 +923,7 @@ export function InputProvider({ children }: { children: ReactNode }) {
     lastDevice,
     controllerIconStyle: preferences.controllerIconStyle,
     directPartyTargeting: preferences.directPartyTargeting,
+    combatTouchLocked: preferences.combatTouchLocked,
     beginCapture: (device, action) => setCapture({ device, action }),
     cancelCapture: () => setCapture(null),
     resetBindings: (device) => setBindings((current) => ({
@@ -757,6 +938,10 @@ export function InputProvider({ children }: { children: ReactNode }) {
       ...current,
       directPartyTargeting,
     })),
+    setCombatTouchLocked: (combatTouchLocked) => setPreferences((current) => ({
+      ...current,
+      combatTouchLocked,
+    })),
   }), [bindings, capture, lastDevice, preferences])
 
   function typeKeyboardKey(key: string) {
@@ -821,6 +1006,11 @@ export function InputProvider({ children }: { children: ReactNode }) {
           </section>
         </div>
       )}
+      {touchLockMessage && (
+        <div className="combat-touch-lock-status" aria-live="polite">
+          {touchLockMessage}
+        </div>
+      )}
     </InputContext.Provider>
   )
 }

src/main.tsx

@@ -9,7 +9,9 @@ import { DualScreenBottomDisplay, DualScreenProvider, DualScreenStartupPrompt }
 createRoot(document.getElementById('root')!).render(
   <StrictMode>
     {new URLSearchParams(window.location.search).get('display') === 'bottom' ? (
+      <InputProvider>
         <DualScreenBottomDisplay />
+      </InputProvider>
     ) : (
       <DualScreenProvider>
         <DualScreenStartupPrompt />