Improve CPU accuracy for indexed addressing modes

- Add dummy reads on page boundary crossing for Absolute,X, Absolute,Y,
  and (Indirect),Y addressing modes. When indexing crosses a page boundary,
  the 6502 first reads from the "wrong" address (before carry is applied
  to high byte), then reads from the correct address.

- Add dummy read for STA with indexed addressing modes (Absolute,X,
  Absolute,Y, (Indirect),Y) even without page crossing, matching real
  6502 behavior where write instructions always perform a read cycle.

- Clean up (Indirect,X) addressing mode - remove incorrect page crossing
  check since zero-page indexing wraps within the zero page.

Fixes dummy read cycle errors in AccuracyCoin.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: bfirsh

src/cpu.js

@@ -215,6 +215,8 @@ CPU.prototype = {
         // indexed, but with the high byte.
         addr = this.load16bit(opaddr + 2);
         if ((addr & 0xff00) !== ((addr + this.REG_X) & 0xff00)) {
+          // Page boundary crossed - dummy read from wrong address first
+          this.load((addr & 0xff00) | ((addr + this.REG_X) & 0xff));
           cycleAdd = 1;
         }
         addr += this.REG_X;
@@ -225,6 +227,8 @@ CPU.prototype = {
         // indexed, but with the high byte.
         addr = this.load16bit(opaddr + 2);
         if ((addr & 0xff00) !== ((addr + this.REG_Y) & 0xff00)) {
+          // Page boundary crossed - dummy read from wrong address first
+          this.load((addr & 0xff00) | ((addr + this.REG_Y) & 0xff));
           cycleAdd = 1;
         }
         addr += this.REG_Y;
@@ -234,13 +238,9 @@ CPU.prototype = {
         // Pre-indexed Indirect mode. Find the 16-bit address
         // starting at the given location plus
         // the current X register. The value is the contents of that
-        // address.
+        // address. No page crossing or dummy read - wraps within zero page.
         addr = this.load(opaddr + 2);
-        if ((addr & 0xff00) !== ((addr + this.REG_X) & 0xff00)) {
-          cycleAdd = 1;
-        }
-        addr += this.REG_X;
-        addr &= 0xff;
+        addr = (addr + this.REG_X) & 0xff;
         addr = this.load16bit(addr);
         break;
       }
@@ -252,6 +252,8 @@ CPU.prototype = {
         // stored at that adress.
         addr = this.load16bit(this.load(opaddr + 2));
         if ((addr & 0xff00) !== ((addr + this.REG_Y) & 0xff00)) {
+          // Page boundary crossed - dummy read from wrong address first
+          this.load((addr & 0xff00) | ((addr + this.REG_Y) & 0xff));
           cycleAdd = 1;
         }
         addr += this.REG_Y;
@@ -936,6 +938,14 @@ CPU.prototype = {
         // *******
 
         // Store accumulator in memory
+        // For indexed addressing modes, STA always does a dummy read.
+        // Page-crossing case is handled in address mode; handle non-crossing here.
+        if (
+          cycleAdd === 0 &&
+          (addrMode === 8 || addrMode === 9 || addrMode === 11)
+        ) {
+          this.load(addr);
+        }
         this.write(addr, this.REG_ACC);
         break;
       }