Merge pull request #67 from sam-mfb/control-cleanup

Control cleanup

Author: sam-mfb

src/core/controls/blankControls.test.ts

@@ -0,0 +1,102 @@
+/**
+ * @fileoverview Tests for blankControls utility
+ */
+
+import { describe, it, expect } from 'vitest'
+import { blankControls } from './blankControls'
+
+describe('blankControls', () => {
+  it('creates blank controls with all values false', () => {
+    const source = {
+      a: true,
+      b: true,
+      c: true
+    }
+
+    const result = blankControls(source)
+
+    expect(result).toEqual({
+      a: false,
+      b: false,
+      c: false
+    })
+  })
+
+  it('preserves keys from source regardless of their values', () => {
+    const source = {
+      foo: false,
+      bar: false,
+      baz: false
+    }
+
+    const result = blankControls(source)
+
+    expect(result).toEqual({
+      foo: false,
+      bar: false,
+      baz: false
+    })
+  })
+
+  it('applies overrides to specific controls', () => {
+    const source = {
+      a: true,
+      b: true,
+      c: true
+    }
+
+    const result = blankControls(source, { b: true })
+
+    expect(result).toEqual({
+      a: false,
+      b: true,
+      c: false
+    })
+  })
+
+  it('applies multiple overrides', () => {
+    const source = {
+      x: true,
+      y: true,
+      z: true
+    }
+
+    const result = blankControls(source, { x: true, z: true })
+
+    expect(result).toEqual({
+      x: true,
+      y: false,
+      z: true
+    })
+  })
+
+  it('works with no overrides', () => {
+    const source = {
+      thrust: true,
+      fire: true,
+      shield: true
+    }
+
+    const result = blankControls(source, {})
+
+    expect(result).toEqual({
+      thrust: false,
+      fire: false,
+      shield: false
+    })
+  })
+
+  it('handles source with different property names', () => {
+    const source = {
+      propA: true,
+      propB: false,
+      propC: true
+    }
+
+    const result = blankControls(source, { propC: true })
+
+    expect(result.propA).toBe(false)
+    expect(result.propB).toBe(false)
+    expect(result.propC).toBe(true)
+  })
+})

src/core/controls/blankControls.ts

@@ -0,0 +1,26 @@
+/**
+ * @fileoverview Utility for creating blank control matrices
+ */
+
+/**
+ * Creates a blank control matrix with all controls set to false.
+ * Optionally allows specific controls to be overridden.
+ *
+ * @param source - A source control matrix to use as a template
+ * @param overrides - Optional partial control matrix to override specific controls
+ * @returns A complete control matrix with all controls false except overrides
+ */
+export function blankControls<T extends Record<string, boolean>>(
+  source: T,
+  overrides?: Partial<T>
+): T {
+  const blank = {} as T
+  const keys = Object.keys(source) as (keyof T)[]
+
+  // Set all controls to false
+  for (const key of keys) {
+    blank[key] = (overrides?.[key] ?? false) as T[keyof T]
+  }
+
+  return blank
+}

src/core/controls/index.ts

@@ -21,3 +21,7 @@ export {
 } from './types'
 
 export { getControls } from './getControls'
+
+export { mergeControls } from './mergeControls'
+
+export { blankControls } from './blankControls'

src/core/controls/mergeControls.test.ts

@@ -0,0 +1,120 @@
+/**
+ * @fileoverview Tests for mergeControls utility
+ */
+
+import { describe, it, expect } from 'vitest'
+import { mergeControls } from './mergeControls'
+
+describe('mergeControls', () => {
+  it('merges two control sets with OR logic', () => {
+    const controls1 = {
+      a: true,
+      b: false,
+      c: true
+    }
+
+    const controls2 = {
+      a: false,
+      b: true,
+      c: true
+    }
+
+    const result = mergeControls(controls1, controls2)
+
+    expect(result).toEqual({
+      a: true, // true OR false = true
+      b: true, // false OR true = true
+      c: true // true OR true = true
+    })
+  })
+
+  it('handles all false controls', () => {
+    const controls1 = {
+      x: false,
+      y: false,
+      z: false
+    }
+
+    const controls2 = {
+      x: false,
+      y: false,
+      z: false
+    }
+
+    const result = mergeControls(controls1, controls2)
+
+    expect(result).toEqual({
+      x: false,
+      y: false,
+      z: false
+    })
+  })
+
+  it('handles all true in first set', () => {
+    const controls1 = {
+      foo: true,
+      bar: true
+    }
+
+    const controls2 = {
+      foo: false,
+      bar: false
+    }
+
+    const result = mergeControls(controls1, controls2)
+
+    expect(result).toEqual({
+      foo: true,
+      bar: true
+    })
+  })
+
+  it('merges more than two control sets', () => {
+    const controls1 = {
+      a: true,
+      b: false,
+      c: false
+    }
+
+    const controls2 = {
+      a: false,
+      b: true,
+      c: false
+    }
+
+    const controls3 = {
+      a: false,
+      b: false,
+      c: true
+    }
+
+    const result = mergeControls(controls1, controls2, controls3)
+
+    expect(result.a).toBe(true)
+    expect(result.b).toBe(true)
+    expect(result.c).toBe(true)
+  })
+
+  it('works with different property names', () => {
+    const controls1 = {
+      thrust: true,
+      shield: false
+    }
+
+    const controls2 = {
+      thrust: false,
+      shield: true
+    }
+
+    const result = mergeControls(controls1, controls2)
+
+    expect(result.thrust).toBe(true)
+    expect(result.shield).toBe(true)
+  })
+
+  it('throws error when called with no arguments', () => {
+    expect(() => mergeControls()).toThrow(
+      'mergeControls requires at least one control set'
+    )
+  })
+})

src/core/controls/mergeControls.ts

@@ -0,0 +1,29 @@
+/**
+ * @fileoverview Utility for merging multiple control sources
+ */
+
+/**
+ * Merges multiple control matrices using OR logic.
+ * Type-safe approach that ensures all control properties are handled.
+ *
+ * @param controlSets - One or more control matrices to merge
+ * @returns A merged control matrix where each control is true if any source has it true
+ */
+export function mergeControls<T extends Record<string, boolean>>(
+  ...controlSets: T[]
+): T {
+  if (controlSets.length === 0) {
+    throw new Error('mergeControls requires at least one control set')
+  }
+
+  const result = { ...controlSets[0] } as T
+  const keys = Object.keys(result) as (keyof T)[]
+
+  for (const key of keys) {
+    result[key] = controlSets.some(
+      controls => controls[key]
+    ) as unknown as T[keyof T]
+  }
+
+  return result
+}

src/game/components/GameRenderer.tsx

@@ -2,7 +2,12 @@ import React, { useEffect, useRef, useState } from 'react'
 import type { FrameInfo, KeyInfo, MonochromeBitmap } from '@lib/bitmap'
 import { useAppDispatch, useAppSelector, type RootState } from '../store'
 import { togglePause, showMap, hideMap, pause, unpause } from '../gameSlice'
-import { getControls, type ControlMatrix } from '@core/controls'
+import {
+  getControls,
+  mergeControls,
+  blankControls,
+  type ControlMatrix
+} from '@core/controls'
 import { Map } from './Map'
 import { bitmapToCollisionItem, type CollisionService } from '@/core/collision'
 import { Collision } from '@/core/collision/constants'
@@ -136,37 +141,14 @@ const GameRenderer: React.FC<GameRendererProps> = ({
         const keyboardControls = getControls(keyInfo, bindings)
 
         // Merge keyboard and touch controls (OR logic for each control)
-        const mergedControls: ControlMatrix = {
-          thrust: keyboardControls.thrust || touchControls.thrust,
-          left: keyboardControls.left || touchControls.left,
-          right: keyboardControls.right || touchControls.right,
-          fire: keyboardControls.fire || touchControls.fire,
-          shield: keyboardControls.shield || touchControls.shield,
-          selfDestruct:
-            keyboardControls.selfDestruct || touchControls.selfDestruct,
-          pause: keyboardControls.pause || touchControls.pause,
-          quit: keyboardControls.quit || touchControls.quit,
-          nextLevel: keyboardControls.nextLevel || touchControls.nextLevel,
-          extraLife: keyboardControls.extraLife || touchControls.extraLife,
-          map: keyboardControls.map || touchControls.map
-        }
+        const mergedControls = mergeControls(keyboardControls, touchControls)
 
         // If map is showing, use blank controls (all false) to prevent game input
         const controls = showMapState
-          ? {
-              thrust: false,
-              left: false,
-              right: false,
-              fire: false,
-              shield: false,
-              selfDestruct: false,
-              pause: false,
-              quit: false,
-              nextLevel: false,
-              extraLife: false,
+          ? blankControls(mergedControls, {
               // need to still detect the map key
               map: mergedControls.map
-            }
+            })
           : mergedControls
 
         if (controls.map) {