ac6502 1.0.0

package/src/components/Cart.ts

@@ -0,0 +1,20 @@
+export class Cart {
+  
+  static START: number = 0x8000
+  static END: number = 0xFFFF
+  static CODE: number = 0xC000
+  static SIZE: number = Cart.END - Cart.START + 1
+
+  data: number[] = [...Array(Cart.SIZE)].fill(0x00)
+
+  read(address: number): number {
+    return this.data[address]
+  }
+
+  load(data: number[]): void {
+    if (data.length != Cart.SIZE) { return }
+
+    this.data = data
+  }
+
+}

package/src/components/IO/GPIOAttachments/GPIOAttachment.ts

@@ -0,0 +1,189 @@
+/**
+ * Interface for devices that can be attached to GPIO ports
+ */
+export interface GPIOAttachment {
+  /**
+   * Reset the attachment to its initial state
+   */
+  reset(): void
+
+  /**
+   * Update the attachment state based on CPU clock ticks
+   * @param cpuFrequency - The CPU frequency in Hz
+   */
+  tick(cpuFrequency: number): void
+
+  /**
+   * Read data from Port A
+   * @param ddr - Data Direction Register value
+   * @param or - Output Register value
+   * @returns The data to be read from the port
+   */
+  readPortA(ddr: number, or: number): number
+
+  /**
+   * Read data from Port B
+   * @param ddr - Data Direction Register value
+   * @param or - Output Register value
+   * @returns The data to be read from the port
+   */
+  readPortB(ddr: number, or: number): number
+
+  /**
+   * Write data to Port A
+   * @param value - The value being written
+   * @param ddr - Data Direction Register value
+   */
+  writePortA(value: number, ddr: number): void
+
+  /**
+   * Write data to Port B
+   * @param value - The value being written
+   * @param ddr - Data Direction Register value
+   */
+  writePortB(value: number, ddr: number): void
+
+  /**
+   * Check if the attachment is enabled
+   * @returns true if enabled, false otherwise
+   */
+  isEnabled(): boolean
+
+  /**
+   * Get the priority of this attachment (lower values = higher priority)
+   * @returns The priority value
+   */
+  getPriority(): number
+
+  /**
+   * Clear interrupt flags
+   * @param ca1 - Clear CA1 interrupt
+   * @param ca2 - Clear CA2 interrupt
+   * @param cb1 - Clear CB1 interrupt
+   * @param cb2 - Clear CB2 interrupt
+   */
+  clearInterrupts(ca1: boolean, ca2: boolean, cb1: boolean, cb2: boolean): void
+
+  /**
+   * Update control line states
+   * @param ca1 - CA1 control line state
+   * @param ca2 - CA2 control line state
+   * @param cb1 - CB1 control line state
+   * @param cb2 - CB2 control line state
+   */
+  updateControlLines(ca1: boolean, ca2: boolean, cb1: boolean, cb2: boolean): void
+
+  /**
+   * Check if CA1 interrupt is pending
+   * @returns true if interrupt is pending
+   */
+  hasCA1Interrupt(): boolean
+
+  /**
+   * Check if CA2 interrupt is pending
+   * @returns true if interrupt is pending
+   */
+  hasCA2Interrupt(): boolean
+
+  /**
+   * Check if CB1 interrupt is pending
+   * @returns true if interrupt is pending
+   */
+  hasCB1Interrupt(): boolean
+
+  /**
+   * Check if CB2 interrupt is pending
+   * @returns true if interrupt is pending
+   */
+  hasCB2Interrupt(): boolean
+}
+
+/**
+ * Base abstract class for GPIO attachments with common functionality
+ */
+export abstract class GPIOAttachmentBase implements GPIOAttachment {
+  protected priority: number
+  protected enabled: boolean
+  protected ca1Interrupt: boolean
+  protected ca2Interrupt: boolean
+  protected cb1Interrupt: boolean
+  protected cb2Interrupt: boolean
+
+  constructor(
+    priority: number,
+    ca1Interrupt: boolean = false,
+    ca2Interrupt: boolean = false,
+    cb1Interrupt: boolean = false,
+    cb2Interrupt: boolean = false
+  ) {
+    this.priority = priority
+    this.enabled = true
+    this.ca1Interrupt = ca1Interrupt
+    this.ca2Interrupt = ca2Interrupt
+    this.cb1Interrupt = cb1Interrupt
+    this.cb2Interrupt = cb2Interrupt
+  }
+
+  reset(): void {
+    this.enabled = true
+    this.ca1Interrupt = false
+    this.ca2Interrupt = false
+    this.cb1Interrupt = false
+    this.cb2Interrupt = false
+  }
+
+  tick(cpuFrequency: number): void {
+    // Default: no action
+  }
+
+  readPortA(ddr: number, or: number): number {
+    return 0xFF
+  }
+
+  readPortB(ddr: number, or: number): number {
+    return 0xFF
+  }
+
+  writePortA(value: number, ddr: number): void {
+    // Default: no action
+  }
+
+  writePortB(value: number, ddr: number): void {
+    // Default: no action
+  }
+
+  isEnabled(): boolean {
+    return this.enabled
+  }
+
+  getPriority(): number {
+    return this.priority
+  }
+
+  clearInterrupts(ca1: boolean, ca2: boolean, cb1: boolean, cb2: boolean): void {
+    if (ca1) this.ca1Interrupt = false
+    if (ca2) this.ca2Interrupt = false
+    if (cb1) this.cb1Interrupt = false
+    if (cb2) this.cb2Interrupt = false
+  }
+
+  updateControlLines(ca1: boolean, ca2: boolean, cb1: boolean, cb2: boolean): void {
+    // Default: no action
+  }
+
+  hasCA1Interrupt(): boolean {
+    return this.ca1Interrupt
+  }
+
+  hasCA2Interrupt(): boolean {
+    return this.ca2Interrupt
+  }
+
+  hasCB1Interrupt(): boolean {
+    return this.cb1Interrupt
+  }
+
+  hasCB2Interrupt(): boolean {
+    return this.cb2Interrupt
+  }
+}

package/src/components/IO/GPIOAttachments/GPIOJoystickAttachment.ts

@@ -0,0 +1,99 @@
+import { GPIOAttachmentBase } from './GPIOAttachment'
+
+/**
+ * GPIOJoystickAttachment - Emulates a joystick/gamepad connected to GPIO port
+ * 
+ * Buttons are active-low (0 = pressed, 1 = released)
+ * Can be attached to either Port A or Port B
+ */
+export class GPIOJoystickAttachment extends GPIOAttachmentBase {
+  // Joystick button bit masks
+  static readonly BUTTON_UP = 0x01
+  static readonly BUTTON_DOWN = 0x02
+  static readonly BUTTON_LEFT = 0x04
+  static readonly BUTTON_RIGHT = 0x08
+  static readonly BUTTON_A = 0x10
+  static readonly BUTTON_B = 0x20
+  static readonly BUTTON_SELECT = 0x40
+  static readonly BUTTON_START = 0x80
+
+  private buttonState: number
+  private attachedToPortA: boolean
+
+  constructor(attachToPortA: boolean = true, priority: number = 0) {
+    // Call parent constructor with priority and no control line interrupts
+    super(priority, false, false, false, false)
+    this.attachedToPortA = attachToPortA
+    this.buttonState = 0x00
+    this.reset()
+  }
+
+  reset(): void {
+    super.reset()
+    this.buttonState = 0x00
+  }
+
+  readPortA(ddr: number, or: number): number {
+    if (this.attachedToPortA) {
+      // Return inverted button state (active-low)
+      return (~this.buttonState) & 0xFF
+    }
+    return 0xFF
+  }
+
+  readPortB(ddr: number, or: number): number {
+    if (!this.attachedToPortA) {
+      // Return inverted button state (active-low)
+      return (~this.buttonState) & 0xFF
+    }
+    return 0xFF
+  }
+
+  /**
+   * Update the joystick button state
+   * @param buttons - Button state byte (1 = pressed, 0 = released)
+   */
+  updateJoystick(buttons: number): void {
+    this.buttonState = buttons & 0xFF
+  }
+
+  /**
+   * Get the current button state
+   * @returns The button state byte
+   */
+  getButtonState(): number {
+    return this.buttonState
+  }
+
+  /**
+   * Check if a specific button is pressed
+   * @param button - Button bit mask to check
+   * @returns true if button is pressed
+   */
+  isButtonPressed(button: number): boolean {
+    return (this.buttonState & button) !== 0
+  }
+
+  /**
+   * Press a button (set its bit)
+   * @param button - Button bit mask to press
+   */
+  pressButton(button: number): void {
+    this.buttonState |= button
+  }
+
+  /**
+   * Release a button (clear its bit)
+   * @param button - Button bit mask to release
+   */
+  releaseButton(button: number): void {
+    this.buttonState &= ~button
+  }
+
+  /**
+   * Clear all button presses
+   */
+  releaseAllButtons(): void {
+    this.buttonState = 0x00
+  }
+}