ADD - tower stack phone game

frontend/src/features/games/tower-stack/engine.ts

@@ -0,0 +1,139 @@
+import type {
+  TowerActiveBlock,
+  TowerBlock,
+  TowerGameState,
+  TowerPlacement,
+} from './types'
+
+export const TOWER_FIELD_WIDTH = 100
+export const TOWER_BASE_WIDTH = 68
+export const TOWER_PERFECT_TOLERANCE = 1.35
+export const TOWER_START_SPEED = 23
+export const TOWER_MAX_SPEED = 48
+
+function speedForLevel(level: number): number {
+  return Math.min(
+    TOWER_MAX_SPEED,
+    TOWER_START_SPEED + Math.max(0, level - 1) * 1.65,
+  )
+}
+
+function createActiveBlock(
+  level: number,
+  width: number,
+  direction: -1 | 1,
+): TowerActiveBlock {
+  return {
+    colorIndex: level % 6,
+    direction,
+    id: level,
+    level,
+    speed: speedForLevel(level),
+    width,
+    x: direction === 1 ? 0 : TOWER_FIELD_WIDTH - width,
+  }
+}
+
+export function createTowerGame(): TowerGameState {
+  const base: TowerBlock = {
+    colorIndex: 0,
+    id: 0,
+    level: 0,
+    width: TOWER_BASE_WIDTH,
+    x: (TOWER_FIELD_WIDTH - TOWER_BASE_WIDTH) / 2,
+  }
+
+  return {
+    active: createActiveBlock(1, TOWER_BASE_WIDTH, 1),
+    blocks: [base],
+    perfects: 0,
+    score: 0,
+    status: 'playing',
+  }
+}
+
+export function advanceTowerBlock(
+  state: TowerGameState,
+  elapsedSeconds: number,
+): TowerGameState {
+  if (state.status !== 'playing' || !state.active || elapsedSeconds <= 0) {
+    return state
+  }
+
+  const active = { ...state.active }
+  let nextX = active.x + active.direction * active.speed * elapsedSeconds
+  const maximumX = TOWER_FIELD_WIDTH - active.width
+
+  while (nextX < 0 || nextX > maximumX) {
+    if (nextX > maximumX) {
+      nextX = maximumX - (nextX - maximumX)
+      active.direction = -1
+    } else {
+      nextX = -nextX
+      active.direction = 1
+    }
+  }
+
+  active.x = nextX
+  return { ...state, active }
+}
+
+export function placeTowerBlock(state: TowerGameState): TowerPlacement {
+  if (state.status !== 'playing' || !state.active) {
+    return { cutSide: null, cutWidth: 0, outcome: 'missed', state }
+  }
+
+  const active = state.active
+  const support = state.blocks[state.blocks.length - 1]
+  const overlapStart = Math.max(active.x, support.x)
+  const overlapEnd = Math.min(active.x + active.width, support.x + support.width)
+  const overlapWidth = overlapEnd - overlapStart
+
+  if (overlapWidth <= 0) {
+    return {
+      cutSide: active.x < support.x ? 'left' : 'right',
+      cutWidth: active.width,
+      outcome: 'missed',
+      state: { ...state, active: null, status: 'over' },
+    }
+  }
+
+  const offset = active.x - support.x
+  const isPerfect = Math.abs(offset) <= TOWER_PERFECT_TOLERANCE
+  const placedWidth = isPerfect
+    ? Math.min(TOWER_BASE_WIDTH, support.width + 0.85)
+    : overlapWidth
+  const placedX = isPerfect
+    ? support.x - (placedWidth - support.width) / 2
+    : overlapStart
+  const block: TowerBlock = {
+    colorIndex: active.colorIndex,
+    id: active.id,
+    level: active.level,
+    width: placedWidth,
+    x: placedX,
+  }
+  const nextLevel = active.level + 1
+  const direction: -1 | 1 = nextLevel % 2 === 0 ? -1 : 1
+
+  return {
+    cutSide: isPerfect ? null : offset < 0 ? 'left' : 'right',
+    cutWidth: isPerfect ? 0 : active.width - overlapWidth,
+    outcome: isPerfect ? 'perfect' : 'placed',
+    state: {
+      active: createActiveBlock(nextLevel, placedWidth, direction),
+      blocks: [...state.blocks, block],
+      perfects: state.perfects + (isPerfect ? 1 : 0),
+      score: state.score + 1 + (isPerfect ? 3 : 0),
+      status: 'playing',
+    },
+  }
+}
+
+export function pauseTowerGame(state: TowerGameState): TowerGameState {
+  return state.status === 'playing' ? { ...state, status: 'paused' } : state
+}
+
+export function resumeTowerGame(state: TowerGameState): TowerGameState {
+  return state.status === 'paused' ? { ...state, status: 'playing' } : state
+}