@loonylabs/create-game 0.1.0

package/template/apps/experiences/runner/track/trackGenerator.ts

@@ -0,0 +1,292 @@
+/**
+ * Procedural track generator for the Runner experience.
+ * Seed-based — same seed produces the same track.
+ * Streaming — generates ahead of the player, disposes behind.
+ */
+
+import { mulberry32 } from '../../../../packages/core/src/dungeon/prng.js';
+import type { SegmentDef, PlacedSegment, SegmentCollectible, SegmentPowerup, SegmentObstacle, PlacedCollectible, PlacedPowerup, PlacedObstacle } from './segmentTypes.js';
+import type { Lane, CollectibleType, PowerupType, ObstacleType } from './segmentTypes.js';
+import {
+  STRAIGHT_SEGMENT,
+  GAP_SEGMENT,
+  RAMP_SEGMENT,
+  NARROW_LEFT_SEGMENT,
+  NARROW_RIGHT_SEGMENT,
+  NARROW_CENTER_SEGMENT,
+} from './segmentTypes.js';
+import { LANE_WIDTH } from './laneSystem.js';
+
+export interface TrackGeneratorState {
+  seed: number;
+  /** Where the next segment starts (Z position) */
+  nextZ: number;
+  /** Segment counter */
+  nextIndex: number;
+  /** Currently active segments */
+  segments: PlacedSegment[];
+  /** Auto-incrementing ID for collectibles/powerups/obstacles */
+  nextItemId: number;
+}
+
+export function createTrackGenerator(seed: number): TrackGeneratorState {
+  return { seed, nextZ: 0, nextIndex: 0, segments: [], nextItemId: 1 };
+}
+
+/**
+ * Generate segments until we have enough ahead of playerZ.
+ * Remove segments that are behind playerZ - bufferBehind.
+ */
+export function updateTrack(
+  state: TrackGeneratorState,
+  playerZ: number,
+  lookAhead: number = 200,
+  bufferBehind: number = 50,
+): void {
+  // Generate ahead
+  while (state.nextZ < playerZ + lookAhead) {
+    const def = pickSegment(state.seed, state.nextIndex);
+    const startZ = state.nextZ;
+
+    // Place collectibles, powerups, obstacles with world positions
+    const collectibles: PlacedCollectible[] = [];
+    if (def.collectibles) {
+      for (const c of def.collectibles) {
+        collectibles.push({
+          id: state.nextItemId++,
+          type: c.type,
+          lane: c.lane,
+          x: c.lane * LANE_WIDTH,
+          y: 1,
+          z: startZ + c.offset * def.length,
+          collected: false,
+        });
+      }
+    }
+
+    let powerup: PlacedPowerup | null = null;
+    if (def.powerup) {
+      powerup = {
+        id: state.nextItemId++,
+        type: def.powerup.type,
+        lane: def.powerup.lane,
+        x: def.powerup.lane * LANE_WIDTH,
+        y: 1.5,
+        z: startZ + def.powerup.offset * def.length,
+        collected: false,
+      };
+    }
+
+    const obstacles: PlacedObstacle[] = [];
+    if (def.obstacles) {
+      for (const o of def.obstacles) {
+        obstacles.push({
+          id: state.nextItemId++,
+          type: o.type,
+          lane: o.lane,
+          x: o.lane * LANE_WIDTH,
+          z: startZ + o.offset * def.length,
+          height: o.height,
+        });
+      }
+    }
+
+    const segment: PlacedSegment = {
+      def,
+      startZ,
+      endZ: startZ + def.length,
+      index: state.nextIndex,
+      collectibles,
+      powerup,
+      obstacles,
+    };
+    state.segments.push(segment);
+    state.nextZ += def.length;
+    state.nextIndex++;
+  }
+
+  // Dispose behind
+  state.segments = state.segments.filter(s => s.endZ > playerZ - bufferBehind);
+}
+
+/**
+ * Pick a segment type based on difficulty (index).
+ * Higher index = more gaps, ramps, narrow sections.
+ */
+function pickSegment(seed: number, index: number): SegmentDef {
+  const rng = mulberry32(seed ^ (index * 31337));
+  // Consume a few values to decorrelate sequential indices
+  rng(); rng();
+  const roll = rng();
+
+  const difficulty = Math.min(index / 50, 1); // 0-1 over 50 segments
+
+  // First 3 segments are always straight (grace period)
+  if (index < 3) {
+    const def = { ...STRAIGHT_SEGMENT };
+    def.collectibles = generateCollectibles(rng, def, difficulty);
+    return def;
+  }
+
+  // Probability distribution shifts with difficulty:
+  // Early: 70% straight, 15% gap, 10% ramp, 5% narrow
+  // Late:  20% straight, 25% gap, 20% ramp, 35% narrow
+  const straightChance = 0.70 - 0.50 * difficulty;
+  const gapChance = 0.15 + 0.10 * difficulty;
+  const rampChance = 0.10 + 0.10 * difficulty;
+  // narrowChance = remaining
+
+  let def: SegmentDef;
+  if (roll < straightChance) {
+    // Vary straight segment length slightly
+    const lengthVariation = 15 + Math.floor(rng() * 15);
+    def = { ...STRAIGHT_SEGMENT, length: lengthVariation };
+  } else if (roll < straightChance + gapChance) {
+    // Gap length grows slightly with difficulty
+    const gapLen = 4 + Math.floor(difficulty * 4);
+    def = { ...GAP_SEGMENT, gapLength: gapLen };
+  } else if (roll < straightChance + gapChance + rampChance) {
+    def = { ...RAMP_SEGMENT };
+  } else {
+    // Narrow — pick subtype
+    const narrowRoll = rng();
+    if (narrowRoll < 0.33) def = { ...NARROW_LEFT_SEGMENT };
+    else if (narrowRoll < 0.66) def = { ...NARROW_RIGHT_SEGMENT };
+    else def = { ...NARROW_CENTER_SEGMENT };
+  }
+
+  // Place collectibles on most segments
+  def.collectibles = generateCollectibles(rng, def, difficulty);
+
+  // Place powerup rarely (decreasing with difficulty)
+  const powerupChance = 0.15 - 0.05 * difficulty;
+  if (rng() < powerupChance && def.type !== 'gap') {
+    def.powerup = generatePowerup(rng, def);
+  }
+
+  // Place obstacles on straight/ramp segments (increasing with difficulty)
+  if (index >= 5 && (def.type === 'straight' || def.type === 'ramp')) {
+    const obstacleChance = 0.1 + 0.4 * difficulty;
+    if (rng() < obstacleChance) {
+      def.obstacles = generateObstacles(rng, def, difficulty);
+    }
+  }
+
+  return def;
+}
+
+/** Generate collectible placements for a segment */
+function generateCollectibles(rng: () => number, def: SegmentDef, difficulty: number): SegmentCollectible[] {
+  const collectibles: SegmentCollectible[] = [];
+  // Skip gap segments (no collectibles in gap area)
+  if (def.type === 'gap') return collectibles;
+
+  // 60% chance of a coin line on the segment
+  if (rng() < 0.6) {
+    const availableLanes = ([-1, 0, 1] as Lane[]).filter((_, i) => def.lanes[i]);
+    if (availableLanes.length === 0) return collectibles;
+    const lane = availableLanes[Math.floor(rng() * availableLanes.length)];
+    const coinCount = 3 + Math.floor(rng() * 4); // 3-6 coins in a line
+    for (let i = 0; i < coinCount; i++) {
+      const offset = 0.2 + (i / coinCount) * 0.6; // spread over 20%-80% of segment
+      collectibles.push({ lane, offset, type: 'coin' });
+    }
+  }
+
+  // 5% chance of a gem
+  if (rng() < 0.05) {
+    const availableLanes = ([-1, 0, 1] as Lane[]).filter((_, i) => def.lanes[i]);
+    if (availableLanes.length > 0) {
+      const lane = availableLanes[Math.floor(rng() * availableLanes.length)];
+      collectibles.push({ lane, offset: 0.5, type: 'gem' });
+    }
+  }
+
+  return collectibles;
+}
+
+/** Generate a powerup for a segment */
+function generatePowerup(rng: () => number, def: SegmentDef): SegmentPowerup {
+  const availableLanes = ([-1, 0, 1] as Lane[]).filter((_, i) => def.lanes[i]);
+  const lane = availableLanes[Math.floor(rng() * availableLanes.length)];
+  const types: PowerupType[] = ['speed-boost', 'low-gravity', 'magnet'];
+  const type = types[Math.floor(rng() * types.length)];
+  return { lane, offset: 0.5, type };
+}
+
+/** Generate obstacles for a segment */
+function generateObstacles(rng: () => number, def: SegmentDef, difficulty: number): SegmentObstacle[] {
+  const obstacles: SegmentObstacle[] = [];
+  const availableLanes = ([-1, 0, 1] as Lane[]).filter((_, i) => def.lanes[i]);
+  if (availableLanes.length === 0) return obstacles;
+
+  // Place 1-2 obstacles, never blocking all lanes
+  const count = rng() < 0.3 + 0.3 * difficulty ? 2 : 1;
+  const maxBlocked = availableLanes.length - 1; // always leave at least one lane open
+  const usedLanes = new Set<Lane>();
+
+  for (let i = 0; i < Math.min(count, maxBlocked); i++) {
+    const freeLanes = availableLanes.filter(l => !usedLanes.has(l));
+    if (freeLanes.length <= 1) break; // don't block last open lane
+    const lane = freeLanes[Math.floor(rng() * freeLanes.length)];
+    usedLanes.add(lane);
+
+    const typeRoll = rng();
+    let type: ObstacleType;
+    let height: number;
+    if (typeRoll < 0.4) {
+      type = 'wall';
+      height = 3;
+    } else if (typeRoll < 0.7) {
+      type = 'low-barrier';
+      height = 1;
+    } else {
+      type = 'high-barrier';
+      height = 3;
+    }
+    obstacles.push({ lane, offset: 0.5, type, height });
+  }
+
+  return obstacles;
+}
+
+/**
+ * Get the ground height for a given position on the track.
+ * Returns the height of the track surface, or null if off-track (gap or no lane).
+ */
+export function getTrackGroundHeight(
+  state: TrackGeneratorState,
+  x: number,
+  z: number,
+  laneWidth: number = 2,
+): number | null {
+  // Find the segment containing this Z position
+  const segment = state.segments.find(s => z >= s.startZ && z < s.endZ);
+  if (!segment) return null;
+
+  // Check if we're on a valid lane
+  const laneIndex = Math.round(x / laneWidth) + 1; // -1->0, 0->1, 1->2
+  if (laneIndex < 0 || laneIndex > 2) return null;
+  if (!segment.def.lanes[laneIndex]) return null;
+
+  // Handle gap segments
+  if (segment.def.type === 'gap' && segment.def.gapLength) {
+    const segMid = (segment.startZ + segment.endZ) / 2;
+    const halfGap = segment.def.gapLength / 2;
+    if (z >= segMid - halfGap && z < segMid + halfGap) {
+      return null; // In the gap
+    }
+  }
+
+  // Handle ramp segments
+  if (segment.def.type === 'ramp' && segment.def.rampHeight) {
+    const progress = (z - segment.startZ) / segment.def.length;
+    // Triangle ramp: up to peak at 50%, back down
+    const rampProgress = progress < 0.5
+      ? progress * 2
+      : (1 - progress) * 2;
+    return rampProgress * segment.def.rampHeight;
+  }
+
+  return 0; // Flat ground
+}

package/template/apps/experiences/shooter/ai/aiStateMachine.ts

@@ -0,0 +1,394 @@
+/**
+ * Shooter Enemy AI — state machine with per-type behavior.
+ *
+ * States: idle → detect → chase → attack → retreat
+ * Pure functions operating on ShooterEnemy state.
+ */
+
+import type { PhysicsBody } from '../../../../packages/core/src/physics/gravity.js';
+import { applyMovementInput, applyFriction, applyHorizontalMovement } from '../../../../packages/core/src/physics/characterController.js';
+import type { MovementInput } from '../../../../packages/core/src/physics/characterController.js';
+import { updatePhysicsBody, snapToGround, DEFAULT_PHYSICS_CONFIG } from '../../../../packages/core/src/physics/gravity.js';
+import { resolveTerrainCollision } from '../../../../packages/core/src/physics/collision.js';
+import type { WeaponState } from '../data/weapon-config.js';
+import { processShoot, updateWeaponState, createWeaponState } from '../data/weapon-config.js';
+import type { EnemyTypeConfig, EnemyType } from '../data/enemy-types.js';
+import { ENEMY_CONFIGS } from '../data/enemy-types.js';
+import type { Vec3, AABB } from '../arena/arenaTypes.js';
+import type { Arena } from '../arena/arenaTypes.js';
+import { getArenaGroundHeight } from '../arena/arenaGenerator.js';
+import { hasLineOfSight, distance3D } from './lineOfSight.js';
+import { mulberry32 } from '../../../../packages/core/src/dungeon/prng.js';
+
+// ---------------------------------------------------------------------------
+// Enemy State
+// ---------------------------------------------------------------------------
+
+export type AIState = 'idle' | 'detect' | 'chase' | 'attack' | 'retreat';
+
+export interface ShooterEnemy {
+  entityId: number;
+  enemyType: EnemyType;
+  config: EnemyTypeConfig;
+  aiState: AIState;
+  body: PhysicsBody;
+  weapon: WeaponState;
+  health: number;
+  maxHealth: number;
+  targetPlayerId: string | null;
+  stateTimer: number;
+  alive: boolean;
+  /** Seed for per-enemy randomness (accuracy spread, patrol directions) */
+  rngSeed: number;
+}
+
+export function createShooterEnemy(
+  entityId: number,
+  type: EnemyType,
+  position: Vec3,
+  seed: number,
+): ShooterEnemy {
+  const config = ENEMY_CONFIGS[type];
+  return {
+    entityId,
+    enemyType: type,
+    config,
+    aiState: 'idle',
+    body: {
+      x: position.x,
+      y: position.y,
+      z: position.z,
+      velocityX: 0,
+      velocityY: 0,
+      velocityZ: 0,
+      isGrounded: true,
+      radius: 0.5,
+    },
+    weapon: createWeaponState(config.weaponConfig),
+    health: config.health,
+    maxHealth: config.health,
+    targetPlayerId: null,
+    stateTimer: 0,
+    alive: true,
+    rngSeed: seed,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// AI Update
+// ---------------------------------------------------------------------------
+
+export interface AIUpdateContext {
+  players: Map<string, { socketId: string; body: PhysicsBody; hp: number }>;
+  obstacles: AABB[];
+  arena: Arena;
+  /** Accumulated shoot intents from enemies this tick */
+  enemyShots: Array<{ enemyId: number; origin: Vec3; direction: Vec3; damage: number }>;
+}
+
+/**
+ * Update a single enemy's AI state and physics.
+ */
+export function updateShooterEnemyAI(
+  enemy: ShooterEnemy,
+  dt: number,
+  ctx: AIUpdateContext,
+): void {
+  if (!enemy.alive) return;
+
+  enemy.stateTimer += dt;
+  updateWeaponState(enemy.weapon, dt, enemy.config.weaponConfig);
+
+  // Find nearest visible player
+  const nearestPlayer = findNearestVisiblePlayer(enemy, ctx);
+
+  switch (enemy.aiState) {
+    case 'idle':
+      updateIdle(enemy, dt, nearestPlayer, ctx);
+      break;
+    case 'detect':
+      updateDetect(enemy, dt, nearestPlayer, ctx);
+      break;
+    case 'chase':
+      updateChase(enemy, dt, nearestPlayer, ctx);
+      break;
+    case 'attack':
+      updateAttack(enemy, dt, nearestPlayer, ctx);
+      break;
+    case 'retreat':
+      updateRetreat(enemy, dt, nearestPlayer, ctx);
+      break;
+  }
+
+  // Physics
+  applyFriction(enemy.body, dt, enemy.config.characterConfig);
+  applyHorizontalMovement(enemy.body, dt);
+
+  const groundFn = (x: number, z: number) => getArenaGroundHeight(ctx.arena, x, z);
+  const wallFn = (x: number, z: number) => {
+    for (const cover of ctx.arena.covers) {
+      if (x >= cover.aabb.min.x && x <= cover.aabb.max.x &&
+          z >= cover.aabb.min.z && z <= cover.aabb.max.z) {
+        return cover.height;
+      }
+    }
+    return getArenaGroundHeight(ctx.arena, x, z);
+  };
+
+  resolveTerrainCollision(enemy.body, wallFn);
+  updatePhysicsBody(enemy.body, dt, groundFn, DEFAULT_PHYSICS_CONFIG);
+  if (enemy.body.isGrounded) {
+    snapToGround(enemy.body, groundFn, DEFAULT_PHYSICS_CONFIG);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// State handlers
+// ---------------------------------------------------------------------------
+
+function updateIdle(
+  enemy: ShooterEnemy,
+  _dt: number,
+  nearestPlayer: NearestPlayerResult | null,
+  _ctx: AIUpdateContext,
+): void {
+  // Wander slightly (just stand)
+  if (nearestPlayer && nearestPlayer.distance <= enemy.config.detectionRadius) {
+    enemy.aiState = 'detect';
+    enemy.stateTimer = 0;
+    enemy.targetPlayerId = nearestPlayer.socketId;
+  }
+}
+
+function updateDetect(
+  enemy: ShooterEnemy,
+  _dt: number,
+  nearestPlayer: NearestPlayerResult | null,
+  _ctx: AIUpdateContext,
+): void {
+  // Wait for reaction time
+  if (enemy.stateTimer >= enemy.config.reactionTime) {
+    if (nearestPlayer && nearestPlayer.distance <= enemy.config.attackRange && nearestPlayer.hasLos) {
+      enemy.aiState = 'attack';
+    } else if (nearestPlayer) {
+      enemy.aiState = 'chase';
+    } else {
+      enemy.aiState = 'idle';
+    }
+    enemy.stateTimer = 0;
+  }
+}
+
+function updateChase(
+  enemy: ShooterEnemy,
+  dt: number,
+  nearestPlayer: NearestPlayerResult | null,
+  ctx: AIUpdateContext,
+): void {
+  if (!nearestPlayer) {
+    enemy.aiState = 'idle';
+    enemy.stateTimer = 0;
+    enemy.targetPlayerId = null;
+    return;
+  }
+
+  // Check retreat
+  if (shouldRetreat(enemy)) {
+    enemy.aiState = 'retreat';
+    enemy.stateTimer = 0;
+    return;
+  }
+
+  // In attack range + LoS? Switch to attack
+  if (nearestPlayer.distance <= enemy.config.attackRange && nearestPlayer.hasLos) {
+    enemy.aiState = 'attack';
+    enemy.stateTimer = 0;
+    return;
+  }
+
+  // Move toward player
+  moveToward(enemy, nearestPlayer.position, dt);
+}
+
+function updateAttack(
+  enemy: ShooterEnemy,
+  dt: number,
+  nearestPlayer: NearestPlayerResult | null,
+  ctx: AIUpdateContext,
+): void {
+  if (!nearestPlayer) {
+    enemy.aiState = 'idle';
+    enemy.stateTimer = 0;
+    enemy.targetPlayerId = null;
+    return;
+  }
+
+  // Check retreat
+  if (shouldRetreat(enemy)) {
+    enemy.aiState = 'retreat';
+    enemy.stateTimer = 0;
+    return;
+  }
+
+  // Lost LoS or out of range? Chase
+  if (!nearestPlayer.hasLos || nearestPlayer.distance > enemy.config.attackRange * 1.2) {
+    enemy.aiState = 'chase';
+    enemy.stateTimer = 0;
+    return;
+  }
+
+  // Try to shoot
+  tryEnemyShoot(enemy, nearestPlayer, ctx);
+
+  // Rusher: keep moving toward player while attacking
+  if (enemy.enemyType === 'rusher') {
+    moveToward(enemy, nearestPlayer.position, dt);
+  }
+}
+
+function updateRetreat(
+  enemy: ShooterEnemy,
+  dt: number,
+  nearestPlayer: NearestPlayerResult | null,
+  ctx: AIUpdateContext,
+): void {
+  if (!nearestPlayer) {
+    enemy.aiState = 'idle';
+    enemy.stateTimer = 0;
+    return;
+  }
+
+  // Move away from player
+  moveAway(enemy, nearestPlayer.position, dt);
+
+  // After retreating for 3 seconds, go back to chase
+  if (enemy.stateTimer > 3) {
+    enemy.aiState = 'chase';
+    enemy.stateTimer = 0;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+interface NearestPlayerResult {
+  socketId: string;
+  position: Vec3;
+  distance: number;
+  hasLos: boolean;
+}
+
+function findNearestVisiblePlayer(
+  enemy: ShooterEnemy,
+  ctx: AIUpdateContext,
+): NearestPlayerResult | null {
+  let nearest: NearestPlayerResult | null = null;
+
+  const eyePos = { x: enemy.body.x, y: enemy.body.y + 1.5, z: enemy.body.z };
+
+  for (const [socketId, player] of ctx.players) {
+    if (player.hp <= 0) continue;
+    const playerPos = { x: player.body.x, y: player.body.y + 1, z: player.body.z };
+    const dist = distance3D(eyePos, playerPos);
+
+    if (dist > enemy.config.detectionRadius) continue;
+
+    const hasLos = hasLineOfSight(eyePos, playerPos, ctx.obstacles);
+
+    if (!nearest || dist < nearest.distance) {
+      nearest = { socketId, position: playerPos, distance: dist, hasLos };
+    }
+  }
+
+  return nearest;
+}
+
+function moveToward(enemy: ShooterEnemy, target: Vec3, dt: number): void {
+  const dx = target.x - enemy.body.x;
+  const dz = target.z - enemy.body.z;
+  const len = Math.sqrt(dx * dx + dz * dz);
+  if (len < 0.5) return;
+
+  const input: MovementInput = {
+    x: dx / len,
+    z: dz / len,
+    sprint: enemy.enemyType === 'rusher',
+    glide: false,
+  };
+  applyMovementInput(enemy.body, input, dt, enemy.config.characterConfig);
+}
+
+function moveAway(enemy: ShooterEnemy, target: Vec3, dt: number): void {
+  const dx = enemy.body.x - target.x;
+  const dz = enemy.body.z - target.z;
+  const len = Math.sqrt(dx * dx + dz * dz);
+  if (len < 0.1) return;
+
+  const input: MovementInput = {
+    x: dx / len,
+    z: dz / len,
+    sprint: true,
+    glide: false,
+  };
+  applyMovementInput(enemy.body, input, dt, enemy.config.characterConfig);
+}
+
+function shouldRetreat(enemy: ShooterEnemy): boolean {
+  if (enemy.config.retreatThreshold === 0) return false;
+  return enemy.health / enemy.maxHealth <= enemy.config.retreatThreshold;
+}
+
+function tryEnemyShoot(
+  enemy: ShooterEnemy,
+  target: NearestPlayerResult,
+  ctx: AIUpdateContext,
+): void {
+  const fired = processShoot(enemy.weapon, enemy.config.weaponConfig);
+  if (!fired) return;
+
+  // Calculate aim direction with accuracy spread
+  const eyePos = { x: enemy.body.x, y: enemy.body.y + 1.5, z: enemy.body.z };
+  const dx = target.position.x - eyePos.x;
+  const dy = target.position.y - eyePos.y;
+  const dz = target.position.z - eyePos.z;
+  const len = Math.sqrt(dx * dx + dy * dy + dz * dz);
+  if (len < 0.001) return;
+
+  // Add accuracy spread
+  const rng = mulberry32(enemy.rngSeed + Math.floor(enemy.stateTimer * 1000));
+  const spreadX = (rng() - 0.5) * 2 * enemy.config.accuracySpread;
+  const spreadY = (rng() - 0.5) * 2 * enemy.config.accuracySpread;
+
+  const dir = {
+    x: dx / len + spreadX,
+    y: dy / len + spreadY,
+    z: dz / len,
+  };
+  // Re-normalize
+  const dirLen = Math.sqrt(dir.x * dir.x + dir.y * dir.y + dir.z * dir.z);
+  dir.x /= dirLen;
+  dir.y /= dirLen;
+  dir.z /= dirLen;
+
+  ctx.enemyShots.push({
+    enemyId: enemy.entityId,
+    origin: eyePos,
+    direction: dir,
+    damage: enemy.config.weaponConfig.damage,
+  });
+}
+
+/**
+ * Apply damage to an enemy. Returns true if enemy died.
+ */
+export function damageEnemy(enemy: ShooterEnemy, amount: number): boolean {
+  if (!enemy.alive) return false;
+  enemy.health -= amount;
+  if (enemy.health <= 0) {
+    enemy.health = 0;
+    enemy.alive = false;
+    return true;
+  }
+  return false;
+}