// ============================================================================= // UNDERGROUND — A Top-Down Stealth Roguelite // Hotel sub-floors. Silenced pistol. Close-quarters knife work. // ============================================================================= import * as canvas from "codetoy/canvas" import * as screen from "codetoy/screen" import * as input from "codetoy/input" import { deltaTime, elapsedTime } from "codetoy/time" // ============================================================================= // CONSTANTS // ============================================================================= const TILE: f64 = 40.0 const PLAYER_SPEED: f64 = 160.0 const PLAYER_RADIUS: f64 = 10.0 const BULLET_SPEED: f64 = 380.0 const BULLET_RADIUS: f64 = 4.0 const BULLET_DAMAGE: f64 = 25.0 const BULLET_TTL: f64 = 1.8 const FIRE_RATE: f64 = 0.35 const ENEMY_RADIUS: f64 = 11.0 const KNIFE_RANGE: f64 = 34.0 const KNIFE_DAMAGE: f64 = 80.0 const KNIFE_COOLDOWN: f64 = 0.6 const HEARING_RANGE: f64 = 320.0 const HEALTH_DROP_CHANCE: f64 = 0.38 const MAX_BULLETS: i32 = 64 const MAX_PARTICLES: i32 = 128 const MAX_ENEMIES: i32 = 32 const GRID_COLS: i32 = 5 const GRID_ROWS: i32 = 4 const CELL_W: f64 = 400.0 const CELL_H: f64 = 340.0 const ROOM_W: f64 = CELL_W - 40.0 const ROOM_H: f64 = CELL_H - 40.0 // Game states const STATE_MENU: i32 = 0 const STATE_PLAYING: i32 = 1 const STATE_DEAD: i32 = 2 const STATE_SUMMARY: i32 = 3 const STATE_HOLD_E: i32 = 4 // Enemy AI states const AI_PATROL: i32 = 0 const AI_INVESTIGATE: i32 = 1 const AI_CHASE: i32 = 2 const AI_EVADE: i32 = 3 const AI_SEARCH: i32 = 4 const AI_DEAD: i32 = 5 // Enemy roles const ROLE_GRUNT: i32 = 0 const ROLE_FLANKER: i32 = 1 const ROLE_SNIPER: i32 = 2 const ROLE_TANK: i32 = 3 // Room types const ROOM_NONE: i32 = 0 const ROOM_CORRIDOR_H: i32 = 1 const ROOM_CORRIDOR_V: i32 = 2 const ROOM_ARENA: i32 = 3 const ROOM_CROSS: i32 = 4 const ROOM_START: i32 = 5 const ROOM_END: i32 = 6 const ROOM_VENT: i32 = 7 // ============================================================================= // MATH HELPERS // ============================================================================= function lerp(a: f64, b: f64, t: f64): f64 { return a + (b - a) * t } function clamp(v: f64, lo: f64, hi: f64): f64 { return Math.max(lo, Math.min(hi, v)) } function dist2(ax: f64, ay: f64, bx: f64, by: f64): f64 { return (ax - bx) * (ax - bx) + (ay - by) * (ay - by) } function dist(ax: f64, ay: f64, bx: f64, by: f64): f64 { return Math.sqrt(dist2(ax, ay, bx, by)) } function angDiff(a: f64, b: f64): f64 { let d = b - a while (d > Math.PI) d -= Math.PI * 2.0 while (d < -Math.PI) d += Math.PI * 2.0 return d } // ============================================================================= // BASE COLLISION OBJECT // ============================================================================= class AABB { x: f64; y: f64; w: f64; h: f64 constructor(x: f64, y: f64, w: f64, h: f64) { this.x = x; this.y = y; this.w = w; this.h = h } get cx(): f64 { return this.x + this.w * 0.5 } get cy(): f64 { return this.y + this.h * 0.5 } contains(px: f64, py: f64): bool { return px >= this.x && px <= this.x + this.w && py >= this.y && py <= this.y + this.h } overlapsCircle(cx: f64, cy: f64, r: f64): bool { const nx = clamp(cx, this.x, this.x + this.w) const ny = clamp(cy, this.y, this.y + this.h) return dist2(cx, cy, nx, ny) < r * r } // Returns penetration push vector (px, py) to push circle out, stored in out[0], out[1] pushCircleOut(cx: f64, cy: f64, r: f64, out: f64[]): void { const nx = clamp(cx, this.x, this.x + this.w) const ny = clamp(cy, this.y, this.y + this.h) const ddx = cx - nx; const ddy = cy - ny const d = Math.sqrt(ddx * ddx + ddy * ddy) if (d < 0.001) { out[0] = 0.0; out[1] = -r; return } const overlap = r - d out[0] = (ddx / d) * overlap out[1] = (ddy / d) * overlap } // Ray vs AABB slab test — returns t or -1 rayIntersect(ox: f64, oy: f64, dx: f64, dy: f64): f64 { let tmin: f64 = 0.0; let tmax: f64 = 1e9 if (Math.abs(dx) > 0.0001) { const t1 = (this.x - ox) / dx; const t2 = (this.x + this.w - ox) / dx tmin = Math.max(tmin, Math.min(t1, t2)); tmax = Math.min(tmax, Math.max(t1, t2)) } else if (ox < this.x || ox > this.x + this.w) return -1.0 if (Math.abs(dy) > 0.0001) { const t1 = (this.y - oy) / dy; const t2 = (this.y + this.h - oy) / dy tmin = Math.max(tmin, Math.min(t1, t2)); tmax = Math.min(tmax, Math.max(t1, t2)) } else if (oy < this.y || oy > this.y + this.h) return -1.0 if (tmax < tmin || tmax < 0.0) return -1.0 return tmin >= 0.0 ? tmin : tmax } } // ============================================================================= // OBSTACLE — collidable world geometry // ============================================================================= class Obstacle extends AABB { solid: bool constructor(x: f64, y: f64, w: f64, h: f64, solid: bool = true) { super(x, y, w, h) this.solid = solid } draw(): void { // Dark concrete pillar / desk / wall chunk canvas.fill(55, 45, 38) canvas.rect(this.x, this.y, this.w, this.h, 3.0) // Top highlight edge canvas.stroke(80, 65, 52, 0.6) canvas.lineWidth(1.0) canvas.beginPath(); canvas.moveTo(this.x + 2, this.y + 2); canvas.lineTo(this.x + this.w - 2, this.y + 2); canvas.strokePath() // Shadow edge canvas.stroke(20, 15, 10, 0.7) canvas.beginPath(); canvas.moveTo(this.x + 2, this.y + this.h - 1); canvas.lineTo(this.x + this.w - 2, this.y + this.h - 1); canvas.strokePath() } } // Decorative-only obstacle (no collision, drawn below entities) class Decor extends AABB { kind: i32 // 0=rug, 1=vent, 2=drain, 3=lamp constructor(x: f64, y: f64, w: f64, h: f64, kind: i32 = 0) { super(x, y, w, h) this.kind = kind } draw(): void { if (this.kind == 0) { // Rug — warm amber rectangle with fringe pattern canvas.fill(110, 65, 25, 0.7) canvas.rect(this.x, this.y, this.w, this.h, 2.0) canvas.stroke(145, 90, 35, 0.5) canvas.lineWidth(1.5) for (let i: i32 = 1; i < 4; i++) { const xi = this.x + (this.w / 4.0) * (i as f64) canvas.beginPath(); canvas.moveTo(xi, this.y + 3); canvas.lineTo(xi, this.y + this.h - 3); canvas.strokePath() } } else if (this.kind == 1) { // Floor vent — grate lines canvas.fill(40, 40, 45, 0.8) canvas.rect(this.x, this.y, this.w, this.h, 1.0) canvas.stroke(60, 60, 65, 0.9) canvas.lineWidth(1.0) const slats: i32 = 4 for (let i: i32 = 0; i < slats; i++) { const yi = this.y + 3.0 + (this.h - 6.0) / (slats as f64) * (i as f64) canvas.beginPath(); canvas.moveTo(this.x + 2, yi); canvas.lineTo(this.x + this.w - 2, yi); canvas.strokePath() } } else if (this.kind == 2) { // Floor drain circle canvas.fill(35, 35, 40, 0.9) canvas.circle(this.cx, this.cy, this.w * 0.5) canvas.stroke(55, 55, 60, 0.8) canvas.lineWidth(1.0) canvas.beginPath(); canvas.moveTo(this.cx - this.w * 0.3, this.cy); canvas.lineTo(this.cx + this.w * 0.3, this.cy); canvas.strokePath() canvas.beginPath(); canvas.moveTo(this.cx, this.cy - this.w * 0.3); canvas.lineTo(this.cx, this.cy + this.w * 0.3); canvas.strokePath() } else if (this.kind == 3) { // Floor lamp base (ornate, no shadow cone) canvas.fill(90, 70, 40) canvas.circle(this.cx, this.cy, 7.0) canvas.fill(180, 140, 60, 0.6) canvas.circle(this.cx, this.cy, 4.0) } } } // ============================================================================= // PARTICLE // ============================================================================= class Particle { x: f64; y: f64; vx: f64; vy: f64 life: f64; maxLife: f64 r: f64; g: f64; b: f64; size: f64 active: bool constructor() { this.x = 0.0; this.y = 0.0; this.vx = 0.0; this.vy = 0.0 this.life = 0.0; this.maxLife = 0.0 this.r = 255.0; this.g = 200.0; this.b = 80.0; this.size = 3.0 this.active = false } spawn(x: f64, y: f64, vx: f64, vy: f64, life: f64, r: f64, g: f64, b: f64, sz: f64): void { this.x = x; this.y = y; this.vx = vx; this.vy = vy this.life = life; this.maxLife = life this.r = r; this.g = g; this.b = b; this.size = sz this.active = true } update(dt: f64): void { if (!this.active) return this.x += this.vx * dt; this.y += this.vy * dt this.vx *= 0.88; this.vy *= 0.88 this.life -= dt if (this.life <= 0.0) this.active = false } draw(): void { if (!this.active) return const a = clamp(this.life / this.maxLife, 0.0, 1.0) canvas.fill(this.r, this.g, this.b, a) canvas.circle(this.x, this.y, this.size * a + 0.5) } } // ============================================================================= // BULLET // ============================================================================= class Bullet { x: f64; y: f64; vx: f64; vy: f64 ttl: f64; fromPlayer: bool; damage: f64; active: bool constructor() { this.x = 0.0; this.y = 0.0; this.vx = 0.0; this.vy = 0.0 this.ttl = 0.0; this.fromPlayer = false; this.damage = 0.0; this.active = false } spawn(x: f64, y: f64, vx: f64, vy: f64, fromPlayer: bool, dmg: f64): void { this.x = x; this.y = y; this.vx = vx; this.vy = vy this.ttl = BULLET_TTL; this.fromPlayer = fromPlayer; this.damage = dmg; this.active = true } update(dt: f64): void { if (!this.active) return this.x += this.vx * dt; this.y += this.vy * dt this.ttl -= dt if (this.ttl <= 0.0) this.active = false } draw(): void { if (!this.active) return const a = clamp(this.ttl / BULLET_TTL, 0.3, 1.0) if (this.fromPlayer) { canvas.fill(200, 240, 255, a) } else { canvas.fill(255, 120, 60, a) } canvas.circle(this.x, this.y, BULLET_RADIUS) // Tracer tail canvas.stroke(this.fromPlayer ? 150.0 : 255.0, this.fromPlayer ? 220.0 : 80.0, this.fromPlayer ? 255.0 : 30.0, a * 0.4) canvas.lineWidth(1.5) canvas.beginPath() canvas.moveTo(this.x - this.vx * 0.04, this.y - this.vy * 0.04) canvas.lineTo(this.x, this.y) canvas.strokePath() } } // ============================================================================= // HEALTH PICKUP // ============================================================================= class HealthPickup { x: f64; y: f64; active: bool; amount: f64; pulse: f64 constructor(x: f64, y: f64) { this.x = x; this.y = y; this.active = true; this.amount = 30.0; this.pulse = 0.0 } update(dt: f64): void { this.pulse += dt * 3.0 } draw(): void { if (!this.active) return const p = Math.sin(this.pulse) * 2.0 canvas.fill(60, 180, 80, 0.85) canvas.circle(this.x, this.y, 7.0 + p) canvas.fill(120, 240, 130, 0.6) canvas.circle(this.x, this.y, 4.0 + p * 0.5) canvas.fill(220, 255, 220, 0.9) canvas.font("Arial", 8.0, "bold") canvas.text("+", this.x - 3.0, this.y + 3.0) } } // ============================================================================= // ENEMY // ============================================================================= class Enemy { x: f64; y: f64; vx: f64; vy: f64 svx: f64; svy: f64 // smoothed velocity hp: f64; maxHp: f64 role: i32; aiState: i32 angle: f64 // facing direction fovAngle: f64; fovRange: f64 speed: f64; fireRate: f64; fireCooldown: f64 patrolAngle: f64; patrolTimer: f64 stateTimer: f64 soundX: f64; soundY: f64 // last heard sound position lastKnownX: f64; lastKnownY: f64 active: bool innerR: f64; outerR: f64 level: i32 knifeReaction: f64 // stun time from close melee indicatorTimer: f64 // ! or ? display indicatorChar: i32 // 0=none, 1=?, 2=! constructor(x: f64, y: f64, role: i32, level: i32) { this.x = x; this.y = y; this.vx = 0.0; this.vy = 0.0; this.svx = 0.0; this.svy = 0.0 this.role = role; this.level = level; this.aiState = AI_PATROL this.patrolAngle = Math.random() * Math.PI * 2.0; this.patrolTimer = 0.0 this.stateTimer = 0.0; this.fireCooldown = 0.0 this.soundX = 0.0; this.soundY = 0.0; this.lastKnownX = x; this.lastKnownY = y this.active = true; this.knifeReaction = 0.0 this.indicatorTimer = 0.0; this.indicatorChar = 0 this.angle = 0.0 const lvlHpMult = 1.0 + (level as f64) * 0.2 const lvlSpeedMult = 1.0 + (level as f64) * 0.1 if (role == ROLE_GRUNT) { this.maxHp = 60.0 * lvlHpMult; this.speed = 70.0 * lvlSpeedMult this.fovAngle = 0.96; this.fovRange = 280.0 this.fireRate = 0.7; this.innerR = 90.0; this.outerR = 180.0 } else if (role == ROLE_FLANKER) { this.maxHp = 45.0 * lvlHpMult; this.speed = 95.0 * lvlSpeedMult this.fovAngle = 1.22; this.fovRange = 260.0 this.fireRate = 0.6; this.innerR = 80.0; this.outerR = 200.0 } else if (role == ROLE_SNIPER) { this.maxHp = 40.0 * lvlHpMult; this.speed = 50.0 * lvlSpeedMult this.fovAngle = 0.61; this.fovRange = 500.0 this.fireRate = 1.2; this.innerR = 140.0; this.outerR = 400.0 } else { // TANK this.maxHp = 140.0 * lvlHpMult; this.speed = 48.0 * lvlSpeedMult this.fovAngle = 0.79; this.fovRange = 220.0 this.fireRate = 1.0; this.innerR = 100.0; this.outerR = 220.0 } this.hp = this.maxHp } get dead(): bool { return this.hp <= 0.0 } takeDamage(dmg: f64): void { this.hp -= dmg if (this.hp <= 0.0) { this.hp = 0.0; this.aiState = AI_DEAD } } drawBody(): void { if (this.aiState == AI_DEAD) return const a = this.aiState == AI_CHASE ? 1.0 : 0.85 // Body color by role let r: f64 = 160.0; let g: f64 = 50.0; let b: f64 = 50.0 if (this.role == ROLE_FLANKER) { r = 50.0; g = 80.0; b = 170.0 } else if (this.role == ROLE_SNIPER) { r = 80.0; g = 160.0; b = 80.0 } else if (this.role == ROLE_TANK) { r = 90.0; g = 60.0; b = 90.0 } // Shadow canvas.fill(0, 0, 0, 0.2) canvas.circle(this.x + 2, this.y + 3, ENEMY_RADIUS + 1) canvas.fill(r, g, b, a) canvas.circle(this.x, this.y, ENEMY_RADIUS) // Directional facing line (gun barrel) canvas.stroke(220, 200, 170, 0.9) canvas.lineWidth(2.0) canvas.beginPath() canvas.moveTo(this.x, this.y) canvas.lineTo(this.x + Math.cos(this.angle) * ENEMY_RADIUS * 1.6, this.y + Math.sin(this.angle) * ENEMY_RADIUS * 1.6) canvas.strokePath() // Health bar const barW = 20.0 const hpF = clamp(this.hp / this.maxHp, 0.0, 1.0) canvas.fill(30, 10, 10, 0.8) canvas.rect(this.x - barW * 0.5, this.y - ENEMY_RADIUS - 8.0, barW, 3.0) canvas.fill(200.0 * (1.0 - hpF), 200.0 * hpF, 30.0, 0.9) canvas.rect(this.x - barW * 0.5, this.y - ENEMY_RADIUS - 8.0, barW * hpF, 3.0) // State indicator if (this.indicatorTimer > 0.0 && this.indicatorChar > 0) { const ch = this.indicatorChar == 1 ? "?" : "!" canvas.fill(this.indicatorChar == 1 ? 240.0 : 255.0, this.indicatorChar == 1 ? 220.0 : 80.0, 40.0, this.indicatorTimer) canvas.font("Arial", 13.0, "bold") canvas.text(ch, this.x - 4.0, this.y - ENEMY_RADIUS - 12.0) } // Knife stun flicker if (this.knifeReaction > 0.0) { canvas.fill(255, 255, 80, this.knifeReaction * 0.8) canvas.circle(this.x, this.y, ENEMY_RADIUS + 4.0) } } drawFov(): void { if (this.aiState == AI_DEAD) return const alpha = this.aiState == AI_CHASE ? 0.15 : 0.06 canvas.fill(255, 220, 60, alpha) const steps: i32 = 10 // Cap visual range — keeps polygon small, LOS logic uses full fovRange const visRange = Math.min(this.fovRange, 180.0) const pts = new Array() pts.push(this.x); pts.push(this.y) for (let i: i32 = 0; i <= steps; i++) { const a = this.angle - this.fovAngle + (this.fovAngle * 2.0 / (steps as f64)) * (i as f64) pts.push(this.x + Math.cos(a) * visRange) pts.push(this.y + Math.sin(a) * visRange) } canvas.polygon(pts) } } // ============================================================================= // PLAYER // ============================================================================= class Player { x: f64; y: f64; vx: f64; vy: f64 hp: f64; maxHp: f64 angle: f64 fireCooldown: f64; fireRate: f64 knifeCD: f64 active: bool silenced: bool; machineGun: bool score: i32; level: i32 stealthStreak: i32 screenShake: f64 constructor(x: f64, y: f64) { this.x = x; this.y = y; this.vx = 0.0; this.vy = 0.0 this.hp = 100.0; this.maxHp = 100.0; this.angle = 0.0 this.fireCooldown = 0.0; this.fireRate = FIRE_RATE this.knifeCD = 0.0; this.active = true this.silenced = false; this.machineGun = false this.score = 0; this.level = 1; this.stealthStreak = 0 this.screenShake = 0.0 } draw(): void { // Drop shadow canvas.fill(0, 0, 0, 0.25) canvas.circle(this.x + 2, this.y + 3, PLAYER_RADIUS + 2) // Body — dark operative uniform canvas.fill(30, 35, 42) canvas.circle(this.x, this.y, PLAYER_RADIUS + 2) // Tactical vest highlight canvas.fill(50, 55, 65, 0.9) canvas.circle(this.x, this.y, PLAYER_RADIUS) // Direction indicator (gun arm) canvas.stroke(180, 190, 200, 0.95) canvas.lineWidth(2.5) canvas.beginPath() canvas.moveTo(this.x + Math.cos(this.angle) * 6.0, this.y + Math.sin(this.angle) * 6.0) canvas.lineTo(this.x + Math.cos(this.angle) * PLAYER_RADIUS * 2.0, this.y + Math.sin(this.angle) * PLAYER_RADIUS * 2.0) canvas.strokePath() // Stealthy overlay — player appears darker if (this.stealthStreak >= 3) { canvas.fill(10, 15, 25, 0.35) canvas.circle(this.x, this.y, PLAYER_RADIUS + 3) } } drawLaser(walls: Obstacle[]): void { // Find first wall hit const dx = Math.cos(this.angle); const dy = Math.sin(this.angle) let minT: f64 = 600.0 for (let i: i32 = 0; i < walls.length; i++) { const t = walls[i].rayIntersect(this.x, this.y, dx, dy) if (t > 0.0 && t < minT) minT = t } const ex = this.x + dx * minT; const ey = this.y + dy * minT if (this.silenced) { canvas.stroke(60, 180, 60, 0.28) canvas.lineWidth(1.0) } else { canvas.stroke(0, 220, 255, 0.55) canvas.lineWidth(1.5) // Glow pass canvas.stroke(0, 200, 255, 0.12) canvas.lineWidth(4.0) canvas.beginPath(); canvas.moveTo(this.x, this.y); canvas.lineTo(ex, ey); canvas.strokePath() canvas.stroke(0, 220, 255, 0.55) canvas.lineWidth(1.5) } canvas.beginPath(); canvas.moveTo(this.x, this.y); canvas.lineTo(ex, ey); canvas.strokePath() canvas.fill(0, 240, 255, 0.8) canvas.circle(ex, ey, 2.5) } } // ============================================================================= // ROOM GRID // ============================================================================= class RoomCell { col: i32; row: i32; type: i32 worldX: f64; worldY: f64 obstacles: Obstacle[] decors: Decor[] enemies: Enemy[] pickups: HealthPickup[] connectN: bool; connectS: bool; connectE: bool; connectW: bool onPath: bool; visited: bool constructor(col: i32, row: i32, type: i32) { this.col = col; this.row = row; this.type = type this.worldX = col as f64 * CELL_W + 10.0 this.worldY = row as f64 * CELL_H + 10.0 this.obstacles = []; this.decors = []; this.enemies = []; this.pickups = [] this.connectN = false; this.connectS = false; this.connectE = false; this.connectW = false this.onPath = false; this.visited = false } get cx(): f64 { return this.worldX + ROOM_W * 0.5 } get cy(): f64 { return this.worldY + ROOM_H * 0.5 } } // ============================================================================= // SOUND RING (gunshot visual feedback) // ============================================================================= class SoundRing { x: f64; y: f64; radius: f64; age: f64; active: bool constructor() { this.x = 0.0; this.y = 0.0; this.radius = 0.0; this.age = 0.0; this.active = false } spawn(x: f64, y: f64): void { this.x = x; this.y = y; this.radius = 0.0; this.age = 0.0; this.active = true } update(dt: f64): void { if (!this.active) return this.age += dt; this.radius = (this.age / 0.5) * HEARING_RANGE if (this.age >= 0.5) this.active = false } draw(): void { if (!this.active) return const a = clamp(1.0 - this.age / 0.5, 0.0, 1.0) * 0.45 const lw = clamp(3.0 * (1.0 - this.age / 0.5), 0.5, 3.0) canvas.stroke(255, 220, 80, a) canvas.lineWidth(lw) canvas.beginPath() // draw arc approximation with polygon const steps: i32 = 32 let first = true for (let i: i32 = 0; i <= steps; i++) { const ang = ((i as f64) / (steps as f64)) * Math.PI * 2.0 const px = this.x + Math.cos(ang) * this.radius const py = this.y + Math.sin(ang) * this.radius if (first) { canvas.moveTo(px, py); first = false } else { canvas.lineTo(px, py) } } canvas.strokePath() } } // ============================================================================= // GAME WORLD // ============================================================================= var gState: i32 = STATE_MENU var gLevel: i32 = 1 var gScore: i32 = 0 var gHighScore: i32 = 0 var gKills: i32 = 0 var gTotalEnemies: i32 = 0 var gHoldETimer: f64 = 0.0 var gSummaryTimer: f64 = 0.0 var gPlayer: Player = new Player(0.0, 0.0) var gBullets: Bullet[] = [] var gParticles: Particle[] = [] var gSoundRings: SoundRing[] = [] var gEnemies: Enemy[] = [] var gPickups: HealthPickup[] = [] var gObstacles: Obstacle[] = [] var gDecors: Decor[] = [] var gCells: RoomCell[] = [] var gPath: i32[] = [] // indices into gCells var gStartCell: i32 = 0 var gEndCell: i32 = 0 var gCamX: f64 = 0.0 var gCamY: f64 = 0.0 var gShakeX: f64 = 0.0 var gShakeY: f64 = 0.0 var gShake: f64 = 0.0 var gKnifeFlash: f64 = 0.0 var gDeathMsg: string = "Back to the lobby." var gBadge: string = "" var gMouseX: f64 = 0.0 var gMouseY: f64 = 0.0 var gKeys_w: bool = false var gKeys_a: bool = false var gKeys_s: bool = false var gKeys_d: bool = false var gKeys_e: bool = false var gMouseDown: bool = false // ============================================================================= // POOL HELPERS // ============================================================================= function spawnBullet(x: f64, y: f64, vx: f64, vy: f64, fromPlayer: bool, dmg: f64): void { for (let i: i32 = 0; i < gBullets.length; i++) { if (!gBullets[i].active) { gBullets[i].spawn(x, y, vx, vy, fromPlayer, dmg); return } } if (gBullets.length < MAX_BULLETS) { const b = new Bullet(); b.spawn(x, y, vx, vy, fromPlayer, dmg); gBullets.push(b) } } function spawnParticle(x: f64, y: f64, vx: f64, vy: f64, life: f64, r: f64, g: f64, b: f64, sz: f64): void { for (let i: i32 = 0; i < gParticles.length; i++) { if (!gParticles[i].active) { gParticles[i].spawn(x, y, vx, vy, life, r, g, b, sz); return } } if (gParticles.length < MAX_PARTICLES) { const p = new Particle(); p.spawn(x, y, vx, vy, life, r, g, b, sz); gParticles.push(p) } } function spawnMuzzleFlash(x: f64, y: f64, angle: f64, machineGun: bool): void { const n: i32 = machineGun ? 8 : 4 for (let i: i32 = 0; i < n; i++) { const a = angle + (Math.random() - 0.5) * 0.8 const spd = 60.0 + Math.random() * 80.0 spawnParticle(x, y, Math.cos(a) * spd, Math.sin(a) * spd, 0.12, machineGun ? 255.0 : 200.0, machineGun ? 140.0 : 220.0, 60.0, 3.0 + Math.random() * 2.0) } } function spawnImpactSpark(x: f64, y: f64): void { for (let i: i32 = 0; i < 5; i++) { const a = Math.random() * Math.PI * 2.0; const spd = 30.0 + Math.random() * 50.0 spawnParticle(x, y, Math.cos(a) * spd, Math.sin(a) * spd, 0.2, 255.0, 200.0, 80.0, 2.0) } } function spawnBlood(x: f64, y: f64): void { for (let i: i32 = 0; i < 8; i++) { const a = Math.random() * Math.PI * 2.0; const spd = 20.0 + Math.random() * 60.0 spawnParticle(x, y, Math.cos(a) * spd, Math.sin(a) * spd, 0.4, 180.0 + Math.random() * 40.0, 20.0, 20.0, 2.5 + Math.random() * 2.0) } } function spawnKnifeEffect(x: f64, y: f64): void { for (let i: i32 = 0; i < 12; i++) { const a = Math.random() * Math.PI * 2.0; const spd = 40.0 + Math.random() * 90.0 spawnParticle(x, y, Math.cos(a) * spd, Math.sin(a) * spd, 0.5, 220.0, 200.0, 80.0, 1.5 + Math.random() * 2.5) } } // ============================================================================= // LEVEL GENERATION — GRID WITH WINDING PATH // ============================================================================= function generateLevel(levelNum: i32): void { gCells = [] gPath = [] gObstacles = [] gDecors = [] gEnemies = [] gPickups = [] gBullets = [] gParticles = [] gSoundRings = [] gKills = 0; gTotalEnemies = 0 // Init empty grid for (let r: i32 = 0; r < GRID_ROWS; r++) { for (let c: i32 = 0; c < GRID_COLS; c++) { gCells.push(new RoomCell(c, r, ROOM_NONE)) } } // Generate winding path from left to right using DFS-like random walk // Start: random row on col 0, End: random row on col GRID_COLS-1 const startRow: i32 = Math.floor(Math.random() * (GRID_ROWS as f64)) as i32 const endRow: i32 = Math.floor(Math.random() * (GRID_ROWS as f64)) as i32 gStartCell = startRow * GRID_COLS + 0 gEndCell = endRow * GRID_COLS + (GRID_COLS - 1) // BFS/random walk: start at startCell, try to reach endCell using random moves let visited: bool[] = [] for (let i: i32 = 0; i < GRID_COLS * GRID_ROWS; i++) visited.push(false) const path = windingPath(startRow, 0, endRow, GRID_COLS - 1, visited) gPath = path for (let i: i32 = 0; i < path.length; i++) { const idx = path[i] gCells[idx].onPath = true } // Set connectivity between adjacent path cells for (let i: i32 = 0; i < path.length - 1; i++) { const a = path[i]; const b = path[i + 1] const ac = gCells[a]; const bc = gCells[b] const dc = bc.col - ac.col; const dr = bc.row - ac.row if (dc == 1) { ac.connectE = true; bc.connectW = true } else if (dc == -1) { ac.connectW = true; bc.connectE = true } else if (dr == 1) { ac.connectS = true; bc.connectN = true } else if (dr == -1) { ac.connectN = true; bc.connectS = true } } // Assign room types for (let i: i32 = 0; i < path.length; i++) { const idx = path[i]; const cell = gCells[idx] if (idx == gStartCell) { cell.type = ROOM_START } else if (idx == gEndCell) { cell.type = ROOM_END } else { const r: f64 = Math.random() if (r < 0.15) cell.type = ROOM_VENT else if (r < 0.40) cell.type = ROOM_CORRIDOR_H else if (r < 0.57) cell.type = ROOM_CORRIDOR_V else if (r < 0.78) cell.type = ROOM_ARENA else cell.type = ROOM_CROSS } populateCell(cell, levelNum) } // Place player at start const sc = gCells[gStartCell] gPlayer.x = sc.cx; gPlayer.y = sc.cy gPlayer.hp = Math.min(gPlayer.hp, gPlayer.maxHp) // don't restore // Flatten obstacles and decors from cells for (let i: i32 = 0; i < gCells.length; i++) { if (!gCells[i].onPath) continue for (let j: i32 = 0; j < gCells[i].obstacles.length; j++) gObstacles.push(gCells[i].obstacles[j]) for (let j: i32 = 0; j < gCells[i].decors.length; j++) gDecors.push(gCells[i].decors[j]) for (let j: i32 = 0; j < gCells[i].enemies.length; j++) { gEnemies.push(gCells[i].enemies[j]) gTotalEnemies++ } for (let j: i32 = 0; j < gCells[i].pickups.length; j++) gPickups.push(gCells[i].pickups[j]) } // Add boundary walls for the full grid area // (outer walls already implicit — corridors between rooms act as passages) } // Winding path using iterative random DFS function windingPath(sr: i32, sc: i32, er: i32, ec: i32, visited: bool[]): i32[] { const path: i32[] = [] const stack: i32[] = [] const parent: i32[] = [] for (let i: i32 = 0; i < GRID_COLS * GRID_ROWS; i++) parent.push(-1) const startIdx = sr * GRID_COLS + sc stack.push(startIdx); visited[startIdx] = true while (stack.length > 0) { const cur = stack[stack.length - 1] const cr = cur / GRID_COLS; const cc = cur % GRID_COLS if (cur == er * GRID_COLS + ec) break // Shuffle neighbours const dirs: i32[] = [0, 1, 2, 3] // fisher-yates for (let i: i32 = 3; i > 0; i--) { const j: i32 = Math.floor(Math.random() * ((i + 1) as f64)) as i32 const tmp = dirs[i]; dirs[i] = dirs[j]; dirs[j] = tmp } let pushed = false for (let di: i32 = 0; di < 4; di++) { const d = dirs[di] let nr = cr; let nc = cc if (d == 0) nr-- else if (d == 1) nr++ else if (d == 2) nc-- else nc++ if (nr < 0 || nr >= GRID_ROWS || nc < 0 || nc >= GRID_COLS) continue const ni = nr * GRID_COLS + nc if (visited[ni]) continue visited[ni] = true; parent[ni] = cur; stack.push(ni); pushed = true; break } if (!pushed) { stack.pop() } } // Reconstruct path let rcur = er * GRID_COLS + ec while (rcur != -1) { path.push(rcur); rcur = parent[rcur] } // reverse const rev: i32[] = [] for (let i: i32 = path.length - 1; i >= 0; i--) rev.push(path[i]) return rev } function populateCell(cell: RoomCell, levelNum: i32): void { const wx = cell.worldX; const wy = cell.worldY const rw = ROOM_W; const rh = ROOM_H // Outer wall obstacles for this cell // N wall opening const wallT: f64 = 10.0 const doorW: f64 = 60.0 const doorH: f64 = 60.0 // North/South corridor openings if (!cell.connectN) { cell.obstacles.push(new Obstacle(wx, wy, rw, wallT)) } else { cell.obstacles.push(new Obstacle(wx, wy, rw * 0.5 - doorW * 0.5, wallT)) cell.obstacles.push(new Obstacle(wx + rw * 0.5 + doorW * 0.5, wy, rw * 0.5 - doorW * 0.5, wallT)) } if (!cell.connectS) { cell.obstacles.push(new Obstacle(wx, wy + rh - wallT, rw, wallT)) } else { cell.obstacles.push(new Obstacle(wx, wy + rh - wallT, rw * 0.5 - doorW * 0.5, wallT)) cell.obstacles.push(new Obstacle(wx + rw * 0.5 + doorW * 0.5, wy + rh - wallT, rw * 0.5 - doorW * 0.5, wallT)) } if (!cell.connectW) { cell.obstacles.push(new Obstacle(wx, wy, wallT, rh)) } else { cell.obstacles.push(new Obstacle(wx, wy, wallT, rh * 0.5 - doorH * 0.5)) cell.obstacles.push(new Obstacle(wx, wy + rh * 0.5 + doorH * 0.5, wallT, rh * 0.5 - doorH * 0.5)) } if (!cell.connectE) { cell.obstacles.push(new Obstacle(wx + rw - wallT, wy, wallT, rh)) } else { cell.obstacles.push(new Obstacle(wx + rw - wallT, wy, wallT, rh * 0.5 - doorH * 0.5)) cell.obstacles.push(new Obstacle(wx + rw - wallT, wy + rh * 0.5 + doorH * 0.5, wallT, rh * 0.5 - doorH * 0.5)) } // ---- Connector gap walls ---- // The gap between ROOM_W and CELL_W (40px) is open floor. Add thin wall strips // flanking each doorway opening so the player can't escape through the sides. const gapW: f64 = CELL_W - ROOM_W // 40px horizontal gap const gapH: f64 = CELL_H - ROOM_H // 40px vertical gap const halfDoorW: f64 = doorW * 0.5 const halfDoorH: f64 = doorH * 0.5 if (cell.connectE) { // Two strips above and below the opening along the east gap const gapX = wx + ROOM_W const midY = wy + ROOM_H * 0.5 // Top strip: from room top to opening top cell.obstacles.push(new Obstacle(gapX, wy, gapW, ROOM_H * 0.5 - halfDoorH)) // Bottom strip: from opening bottom to room bottom cell.obstacles.push(new Obstacle(gapX, midY + halfDoorH, gapW, ROOM_H * 0.5 - halfDoorH)) } if (cell.connectS) { // Two strips left and right of the opening along the south gap const gapY = wy + ROOM_H const midX = wx + ROOM_W * 0.5 // Left strip cell.obstacles.push(new Obstacle(wx, gapY, ROOM_W * 0.5 - halfDoorW, gapH)) // Right strip cell.obstacles.push(new Obstacle(midX + halfDoorW, gapY, ROOM_W * 0.5 - halfDoorW, gapH)) } if (cell.type == ROOM_START) { cell.decors.push(new Decor(wx + rw * 0.25, wy + rh * 0.25, 120.0, 80.0, 0)) cell.decors.push(new Decor(wx + rw * 0.7, wy + rh * 0.6, 40.0, 28.0, 1)) return } if (cell.type == ROOM_END) { cell.decors.push(new Decor(wx + rw * 0.5 - 60.0, wy + rh * 0.3, 120.0, 70.0, 0)) return } // ---- VENT room ---- // Narrow duct passages: only the centre strip in each connected direction is // open; thick wall blocks fill the rest of the room interior creating a // tight cruciform crawlspace. No enemies — stealth shortcut. if (cell.type == ROOM_VENT) { const ventW: f64 = doorW // passage width matches doorway (60px) const ventH: f64 = doorH // Determine which axes this cell connects on const hasH: bool = cell.connectE || cell.connectW // horizontal duct const hasV: bool = cell.connectN || cell.connectS // vertical duct // Fill the four quadrant-ish blocks leaving only the duct strips open if (hasH && hasV) { // Cross duct: four corner blocks cell.obstacles.push(new Obstacle(wx + wallT, wy + wallT, rw * 0.5 - wallT - ventW * 0.5, rh * 0.5 - wallT - ventH * 0.5)) // NW cell.obstacles.push(new Obstacle(wx + rw * 0.5 + ventW * 0.5, wy + wallT, rw * 0.5 - wallT - ventW * 0.5, rh * 0.5 - wallT - ventH * 0.5)) // NE cell.obstacles.push(new Obstacle(wx + wallT, wy + rh * 0.5 + ventH * 0.5, rw * 0.5 - wallT - ventW * 0.5, rh * 0.5 - wallT - ventH * 0.5)) // SW cell.obstacles.push(new Obstacle(wx + rw * 0.5 + ventW * 0.5, wy + rh * 0.5 + ventH * 0.5, rw * 0.5 - wallT - ventW * 0.5, rh * 0.5 - wallT - ventH * 0.5)) // SE } else if (hasH) { // Horizontal duct only: block top and bottom halves except centre strip cell.obstacles.push(new Obstacle(wx + wallT, wy + wallT, rw - wallT * 2.0, rh * 0.5 - ventH * 0.5 - wallT)) cell.obstacles.push(new Obstacle(wx + wallT, wy + rh * 0.5 + ventH * 0.5, rw - wallT * 2.0, rh * 0.5 - ventH * 0.5 - wallT)) } else { // Vertical duct only cell.obstacles.push(new Obstacle(wx + wallT, wy + wallT, rw * 0.5 - ventW * 0.5 - wallT, rh - wallT * 2.0)) cell.obstacles.push(new Obstacle(wx + rw * 0.5 + ventW * 0.5, wy + wallT, rw * 0.5 - ventW * 0.5 - wallT, rh - wallT * 2.0)) } // Vent grate decors along the duct centreline if (hasH) { let gx = wx + wallT + 8.0 while (gx < wx + rw - wallT - 36.0) { cell.decors.push(new Decor(gx, wy + rh * 0.5 - ventH * 0.5 + 4.0, 28.0, ventH - 8.0, 1)) gx += 44.0 } } if (hasV) { let gy = wy + wallT + 8.0 while (gy < wy + rh - wallT - 36.0) { cell.decors.push(new Decor(wx + rw * 0.5 - ventW * 0.5 + 4.0, gy, ventW - 8.0, 28.0, 1)) gy += 44.0 } } return // no enemies in vent rooms } // Interior obstacles if (cell.type == ROOM_CORRIDOR_H) { cell.obstacles.push(new Obstacle(wx + rw * 0.4, wy + rh * 0.3, rw * 0.2, rh * 0.1)) cell.obstacles.push(new Obstacle(wx + rw * 0.4, wy + rh * 0.6, rw * 0.2, rh * 0.1)) cell.decors.push(new Decor(wx + rw * 0.5 - 16.0, wy + rh * 0.5 - 16.0, 32.0, 32.0, 2)) spawnEnemies(cell, 2, levelNum) } else if (cell.type == ROOM_CORRIDOR_V) { cell.obstacles.push(new Obstacle(wx + rw * 0.18, wy + rh * 0.35, rw * 0.1, rh * 0.3)) cell.obstacles.push(new Obstacle(wx + rw * 0.72, wy + rh * 0.35, rw * 0.1, rh * 0.3)) cell.decors.push(new Decor(wx + rw * 0.45, wy + rh * 0.45, 32.0, 22.0, 1)) spawnEnemies(cell, 2, levelNum) } else if (cell.type == ROOM_ARENA) { // Four solid pillars near corners const pw: f64 = 32.0; const ph: f64 = 32.0 cell.obstacles.push(new Obstacle(wx + rw * 0.22, wy + rh * 0.22, pw, ph)) cell.obstacles.push(new Obstacle(wx + rw * 0.78 - pw, wy + rh * 0.22, pw, ph)) cell.obstacles.push(new Obstacle(wx + rw * 0.22, wy + rh * 0.78 - ph, pw, ph)) cell.obstacles.push(new Obstacle(wx + rw * 0.78 - pw, wy + rh * 0.78 - ph, pw, ph)) cell.decors.push(new Decor(wx + rw * 0.5 - 50.0, wy + rh * 0.5 - 35.0, 100.0, 70.0, 0)) cell.decors.push(new Decor(wx + rw * 0.5 - 16.0, wy + rh * 0.75 - 16.0, 32.0, 32.0, 2)) spawnEnemies(cell, 3, levelNum) } else if (cell.type == ROOM_CROSS) { // L-shaped cover blocks cell.obstacles.push(new Obstacle(wx + rw * 0.18, wy + rh * 0.18, rw * 0.18, rh * 0.1)) cell.obstacles.push(new Obstacle(wx + rw * 0.18, wy + rh * 0.18, rw * 0.1, rh * 0.18)) cell.obstacles.push(new Obstacle(wx + rw * 0.64, wy + rh * 0.64, rw * 0.18, rh * 0.18)) cell.decors.push(new Decor(wx + rw * 0.5 - 16.0, wy + rh * 0.5 - 16.0, 32.0, 32.0, 2)) cell.decors.push(new Decor(wx + rw * 0.6, wy + rh * 0.18, 14.0, 14.0, 3)) spawnEnemies(cell, 3, levelNum) } } function spawnEnemies(cell: RoomCell, count: i32, levelNum: i32): void { for (let i: i32 = 0; i < count; i++) { const angle = ((i as f64) / (count as f64)) * Math.PI * 2.0 const ex = cell.cx + Math.cos(angle) * 80.0 const ey = cell.cy + Math.sin(angle) * 80.0 const r: f64 = Math.random() let role = ROLE_GRUNT if (r < 0.15 && levelNum >= 2) role = ROLE_SNIPER else if (r < 0.30 && levelNum >= 2) role = ROLE_FLANKER else if (r < 0.40 && levelNum >= 3) role = ROLE_TANK cell.enemies.push(new Enemy(ex, ey, role, levelNum)) } } // ============================================================================= // COLLISION // ============================================================================= function pushEntityOutOfWalls(ex: f64, ey: f64, radius: f64): f64[] { let nx = ex; let ny = ey const pushOut: f64[] = [0.0, 0.0] for (let i: i32 = 0; i < gObstacles.length; i++) { const o = gObstacles[i] if (!o.solid) continue if (o.overlapsCircle(nx, ny, radius)) { o.pushCircleOut(nx, ny, radius, pushOut) nx += pushOut[0]; ny += pushOut[1] } } const result: f64[] = [nx, ny] return result } function hasLOS(ax: f64, ay: f64, bx: f64, by: f64): bool { const dx = bx - ax; const dy = by - ay const len = Math.sqrt(dx * dx + dy * dy) if (len < 1.0) return true const ndx = dx / len; const ndy = dy / len for (let i: i32 = 0; i < gObstacles.length; i++) { const o = gObstacles[i] if (!o.solid) continue const t = o.rayIntersect(ax, ay, ndx, ndy) if (t > 0.0 && t < len) return false } return true } // ============================================================================= // ENEMY LOGIC UPDATE // ============================================================================= function updateEnemy(e: Enemy, dt: f64): void { if (e.aiState == AI_DEAD) return if (e.knifeReaction > 0.0) { e.knifeReaction -= dt; return } // stunned e.fireCooldown -= dt e.stateTimer -= dt if (e.indicatorTimer > 0.0) e.indicatorTimer -= dt * 2.0 const toPlayerDx = gPlayer.x - e.x const toPlayerDy = gPlayer.y - e.y const dPlayer = Math.sqrt(toPlayerDx * toPlayerDx + toPlayerDy * toPlayerDy) const playerAngle = Math.atan2(toPlayerDy, toPlayerDx) const angleToCone = Math.abs(angDiff(e.angle, playerAngle)) const inFov = dPlayer < e.fovRange && angleToCone < e.fovAngle const hasLos = inFov && hasLOS(e.x, e.y, gPlayer.x, gPlayer.y) // ---- State transitions ---- if (e.aiState == AI_PATROL) { if (hasLos) { enterChase(e) } patrolMove(e, dt) } else if (e.aiState == AI_INVESTIGATE) { if (hasLos) { enterChase(e) } else { investigateMove(e, dt) if (e.stateTimer <= 0.0) { // Arrived or timed out, do scan then return to patrol e.aiState = AI_PATROL e.indicatorChar = 0 } } } else if (e.aiState == AI_CHASE) { e.lastKnownX = gPlayer.x; e.lastKnownY = gPlayer.y if (!hasLos) { e.stateTimer = 2.0 + Math.random() * 2.0 e.aiState = AI_SEARCH } else { chaseMove(e, dt) tryShoot(e) } } else if (e.aiState == AI_SEARCH) { searchMove(e, dt) if (hasLos) { enterChase(e) } else if (e.stateTimer <= 0.0) { e.aiState = AI_PATROL; e.indicatorChar = 0 } } else if (e.aiState == AI_EVADE) { evadeMove(e, dt) if (e.stateTimer <= 0.0) { if (hasLos) enterChase(e) else e.aiState = AI_PATROL } } // Rotate angle toward desired facing let targetAngle = e.angle if (e.aiState == AI_CHASE || e.aiState == AI_EVADE) { targetAngle = playerAngle } else if (e.aiState == AI_PATROL || e.aiState == AI_INVESTIGATE || e.aiState == AI_SEARCH) { targetAngle = Math.atan2(e.vy + 0.001, e.vx + 0.001) } const da = angDiff(e.angle, targetAngle) e.angle += da * dt * 4.5 // Apply smoothed velocity const pos = pushEntityOutOfWalls(e.x + e.svx * dt, e.y + e.svy * dt, ENEMY_RADIUS) e.x = pos[0]; e.y = pos[1] // Separation from other enemies for (let i: i32 = 0; i < gEnemies.length; i++) { const o = gEnemies[i] if (o == e || o.aiState == AI_DEAD) continue const sdx = e.x - o.x; const sdy = e.y - o.y const sd = Math.sqrt(sdx * sdx + sdy * sdy) const minD = ENEMY_RADIUS * 2.0 + 4.0 if (sd < minD && sd > 0.1) { const push = (minD - sd) * 0.5 e.x += (sdx / sd) * push; e.y += (sdy / sd) * push } } // Separation from player — enemies keep distance (KNIFE mechanic pressure) if (dPlayer < e.innerR * 0.5) { // Enemy tries to back away urgently const ad = Math.max(dPlayer, 1.0) e.svx += (-toPlayerDx / ad) * 120.0 * dt e.svy += (-toPlayerDy / ad) * 120.0 * dt } } function enterChase(e: Enemy): void { e.aiState = AI_CHASE e.indicatorChar = 2; e.indicatorTimer = 1.0 } function patrolMove(e: Enemy, dt: f64): void { e.patrolTimer -= dt if (e.patrolTimer <= 0.0) { e.patrolTimer = 2.0 + Math.random() * 2.5 e.patrolAngle = Math.random() * Math.PI * 2.0 } const spd = e.speed * 0.45 const fx = Math.cos(e.patrolAngle) * spd const fy = Math.sin(e.patrolAngle) * spd e.svx = lerp(e.svx, fx, dt * 3.0); e.svy = lerp(e.svy, fy, dt * 3.0) e.vx = e.svx; e.vy = e.svy } function investigateMove(e: Enemy, dt: f64): void { const dx = e.soundX - e.x; const dy = e.soundY - e.y const d = Math.sqrt(dx * dx + dy * dy) if (d < 15.0) { e.stateTimer = 0.0; return } const spd = e.speed * 1.4 e.svx = lerp(e.svx, (dx / d) * spd, dt * 4.0); e.svy = lerp(e.svy, (dy / d) * spd, dt * 4.0) e.vx = e.svx; e.vy = e.svy } function chaseMove(e: Enemy, dt: f64): void { const dx = gPlayer.x - e.x; const dy = gPlayer.y - e.y const d = Math.max(Math.sqrt(dx * dx + dy * dy), 1.0) let radialF: f64 = 0.0 let tangF: f64 = 0.0 // Radial force let radialMult: f64 = 1.0; let tangMult: f64 = 0.6 if (e.role == ROLE_FLANKER) { radialMult = 0.5; tangMult = 1.8 } else if (e.role == ROLE_SNIPER) { radialMult = 0.8; tangMult = 0.3 } else if (e.role == ROLE_TANK) { radialMult = 1.2; tangMult = 0.2 } if (d > e.outerR) radialF = 1.0 else if (d < e.innerR) radialF = -1.0 else tangF = 1.0 // Perpendicular tangent const tx = -dy / d; const ty = dx / d const tangDir = Math.sin(elapsedTime() * 0.8 + e.x * 0.01) > 0.0 ? 1.0 : -1.0 const fxR = (dx / d) * radialF * radialMult * e.speed const fyR = (dy / d) * radialF * radialMult * e.speed const fxT = tx * tangDir * tangF * tangMult * e.speed const fyT = ty * tangDir * tangF * tangMult * e.speed e.svx = lerp(e.svx, fxR + fxT, dt * 7.0) e.svy = lerp(e.svy, fyR + fyT, dt * 7.0) e.vx = e.svx; e.vy = e.svy } function searchMove(e: Enemy, dt: f64): void { const dx = e.lastKnownX - e.x; const dy = e.lastKnownY - e.y const d = Math.sqrt(dx * dx + dy * dy) if (d < 12.0) { return } e.svx = lerp(e.svx, (dx / d) * e.speed * 0.7, dt * 3.0) e.svy = lerp(e.svy, (dy / d) * e.speed * 0.7, dt * 3.0) e.vx = e.svx; e.vy = e.svy } function evadeMove(e: Enemy, dt: f64): void { const dx = e.x - e.soundX; const dy = e.y - e.soundY const d = Math.max(Math.sqrt(dx * dx + dy * dy), 1.0) e.svx = lerp(e.svx, (dx / d) * e.speed * 1.3, dt * 6.0) e.svy = lerp(e.svy, (dy / d) * e.speed * 1.3, dt * 6.0) e.vx = e.svx; e.vy = e.svy } function alertNearbyEnemies(x: f64, y: f64): void { for (let i: i32 = 0; i < gEnemies.length; i++) { const e = gEnemies[i] if (e.aiState == AI_DEAD) continue const d = dist(e.x, e.y, x, y) if (d < HEARING_RANGE) { if (e.aiState == AI_PATROL) { e.aiState = AI_INVESTIGATE e.soundX = x; e.soundY = y e.stateTimer = 5.0 + Math.random() * 3.0 e.indicatorChar = 1; e.indicatorTimer = 1.0 } } } } function tryShoot(e: Enemy): void { if (e.fireCooldown > 0.0) return const adjFireRate = Math.max(0.3, e.fireRate - (gLevel as f64) * 0.04) e.fireCooldown = adjFireRate + (Math.random() - 0.5) * 0.2 const angle = Math.atan2(gPlayer.y - e.y, gPlayer.x - e.x) const spread = e.role == ROLE_SNIPER ? 0.02 : (e.role == ROLE_FLANKER ? 0.15 : 0.1) const a = angle + (Math.random() - 0.5) * spread * 2.0 spawnBullet(e.x, e.y, Math.cos(a) * BULLET_SPEED * 0.85, Math.sin(a) * BULLET_SPEED * 0.85, false, 12.0 + (gLevel as f64) * 2.0) } // ============================================================================= // PLAYER MELEE — KNIFE TAKEDOWN // ============================================================================= function tryKnife(): void { if (gPlayer.knifeCD > 0.0) return for (let i: i32 = 0; i < gEnemies.length; i++) { const e = gEnemies[i] if (e.aiState == AI_DEAD) continue const d = dist(gPlayer.x, gPlayer.y, e.x, e.y) if (d < KNIFE_RANGE) { e.takeDamage(KNIFE_DAMAGE) e.knifeReaction = 0.55 e.svx = (e.x - gPlayer.x) * 4.0; e.svy = (e.y - gPlayer.y) * 4.0 spawnKnifeEffect((e.x + gPlayer.x) * 0.5, (e.y + gPlayer.y) * 0.5) if (e.dead) { spawnBlood(e.x, e.y); onEnemyKilled(e, true) } gPlayer.knifeCD = KNIFE_COOLDOWN gKnifeFlash = 0.15 gShake = 3.0 return } } gPlayer.knifeCD = KNIFE_COOLDOWN * 0.3 // short cooldown if whiff } function onEnemyKilled(e: Enemy, silent: bool): void { gKills++ let pts = 100 if (e.role == ROLE_FLANKER) pts = 150 else if (e.role == ROLE_SNIPER) pts = 200 else if (e.role == ROLE_TANK) pts = 300 gScore += pts if (gScore > gHighScore) gHighScore = gScore // Health pickup drop if (Math.random() < HEALTH_DROP_CHANCE) { gPickups.push(new HealthPickup(e.x + (Math.random() - 0.5) * 20.0, e.y + (Math.random() - 0.5) * 20.0)) } } // ============================================================================= // MAIN INIT // ============================================================================= function startGame(): void { gPlayer = new Player(0.0, 0.0) gPlayer.score = 0; gPlayer.level = 1 gScore = 0; gLevel = 1; gKills = 0 gPlayer.silenced = false; gPlayer.machineGun = false gPlayer.stealthStreak = 0 generateLevel(1) gState = STATE_PLAYING // Snap camera immediately so first frame has correct view gCamX = gPlayer.x - screen.width() * 0.5 gCamY = gPlayer.y - screen.height() * 0.5 gShakeX = 0.0; gShakeY = 0.0; gShake = 0.0 } function nextLevel(): void { // Badge and upgrades const killPct = gTotalEnemies > 0 ? (gKills as f64) / (gTotalEnemies as f64) : 0.0 if (killPct == 0.0) { gBadge = "⭐ STEALTHY" gPlayer.stealthStreak++ gPlayer.silenced = true gPlayer.hp = Math.min(gPlayer.hp + 15.0, gPlayer.maxHp) } else if (killPct >= 1.0) { gBadge = "💀 MASSACRE" gPlayer.stealthStreak = 0 gPlayer.machineGun = true; gPlayer.silenced = false gPlayer.hp = Math.min(gPlayer.hp + 5.0, gPlayer.maxHp) } else if (killPct >= 0.5) { gBadge = "✓ SOLDIER" gPlayer.stealthStreak = 0 gPlayer.hp = Math.min(gPlayer.hp + 10.0, gPlayer.maxHp) } else { gBadge = "" gPlayer.hp = Math.min(gPlayer.hp + 10.0, gPlayer.maxHp) } if (gPlayer.machineGun) { gPlayer.fireRate = 0.06 } else { gPlayer.fireRate = FIRE_RATE } gScore += 200 gLevel++ generateLevel(gLevel) gState = STATE_PLAYING // Snap camera to new spawn point gCamX = gPlayer.x - screen.width() * 0.5 gCamY = gPlayer.y - screen.height() * 0.5 gShakeX = 0.0; gShakeY = 0.0; gShake = 0.0 } // ============================================================================= // ELEVATOR / EXIT ZONE // ============================================================================= function checkElevatorZone(): bool { const ec = gCells[gEndCell] const d = dist(gPlayer.x, gPlayer.y, ec.cx, ec.cy) return d < 40.0 } function anyEnemyChasing(): bool { for (let i: i32 = 0; i < gEnemies.length; i++) { if (gEnemies[i].aiState == AI_CHASE) return true } return false } // ============================================================================= // CAMERA // ============================================================================= function updateCamera(dt: f64): void { const tw = screen.width(); const th = screen.height() const tx = gPlayer.x - tw * 0.5 const ty = gPlayer.y - th * 0.5 gCamX = lerp(gCamX, tx, dt * 6.0) gCamY = lerp(gCamY, ty, dt * 6.0) // Screen shake if (gShake > 0.0) { gShake -= dt * 12.0 if (gShake < 0.0) gShake = 0.0 gShakeX = (Math.random() - 0.5) * gShake * 2.0 gShakeY = (Math.random() - 0.5) * gShake * 2.0 } else { gShakeX = 0.0; gShakeY = 0.0 } } // ============================================================================= // DRAW WORLD // ============================================================================= function drawFloor(): void { // Draw floor of each active room cell for (let i: i32 = 0; i < gCells.length; i++) { const cell = gCells[i] if (!cell.onPath) continue // Floor base const isStart = cell.type == ROOM_START const isEnd = cell.type == ROOM_END const isVent = cell.type == ROOM_VENT if (isStart) { canvas.fill(65, 48, 30) // warm amber lobby floor } else if (isEnd) { canvas.fill(35, 45, 55) // cool blue-grey elevator bay } else if (isVent) { canvas.fill(28, 32, 30) // dark matte metal duct } else { canvas.fill(42, 38, 33) // dark concrete } canvas.rect(cell.worldX, cell.worldY, ROOM_W, ROOM_H) // Vent room: draw a corrugated metal border around the duct if (isVent) { canvas.stroke(55, 70, 58, 0.7) canvas.lineWidth(2.0) canvas.beginPath() canvas.moveTo(cell.worldX + 2, cell.worldY + 2) canvas.lineTo(cell.worldX + ROOM_W - 2, cell.worldY + 2) canvas.lineTo(cell.worldX + ROOM_W - 2, cell.worldY + ROOM_H - 2) canvas.lineTo(cell.worldX + 2, cell.worldY + ROOM_H - 2) canvas.lineTo(cell.worldX + 2, cell.worldY + 2) canvas.strokePath() // Rivet dots at corners canvas.fill(70, 85, 72, 0.8) canvas.circle(cell.worldX + 8.0, cell.worldY + 8.0, 3.0) canvas.circle(cell.worldX + ROOM_W - 8.0, cell.worldY + 8.0, 3.0) canvas.circle(cell.worldX + 8.0, cell.worldY + ROOM_H - 8.0, 3.0) canvas.circle(cell.worldX + ROOM_W - 8.0, cell.worldY + ROOM_H - 8.0, 3.0) } // Tile grid overlay canvas.stroke(50, 45, 40, 0.3) canvas.lineWidth(0.5) const tileSize: f64 = 20.0 let tx = cell.worldX while (tx < cell.worldX + ROOM_W) { canvas.beginPath(); canvas.moveTo(tx, cell.worldY); canvas.lineTo(tx, cell.worldY + ROOM_H); canvas.strokePath() tx += tileSize } let ty = cell.worldY while (ty < cell.worldY + ROOM_H) { canvas.beginPath(); canvas.moveTo(cell.worldX, ty); canvas.lineTo(cell.worldX + ROOM_W, ty); canvas.strokePath() ty += tileSize } // Corridor connections — fill gap between cells if (cell.connectE) { canvas.fill(42, 38, 33) canvas.rect(cell.worldX + ROOM_W, cell.worldY + ROOM_H * 0.5 - 30.0, 40.0, 60.0) } if (cell.connectS) { canvas.fill(42, 38, 33) canvas.rect(cell.worldX + ROOM_W * 0.5 - 30.0, cell.worldY + ROOM_H, 60.0, 40.0) } // Elevator marker for end room if (isEnd) { // Elevator door panel canvas.fill(30, 35, 45) canvas.rect(cell.cx - 25.0, cell.worldY + 8.0, 50.0, 30.0, 2.0) canvas.stroke(80, 100, 130, 0.8) canvas.lineWidth(1.5) canvas.beginPath(); canvas.moveTo(cell.cx, cell.worldY + 8.0); canvas.lineTo(cell.cx, cell.worldY + 38.0); canvas.strokePath() // Call button canvas.fill(255, 200, 60, 0.9) canvas.circle(cell.cx + 30.0, cell.worldY + 22.0, 5.0) // Floor label canvas.fill(140, 160, 200, 0.9) canvas.font("monospace", 9.0, "bold") canvas.text("B" + (gLevel + 1).toString(), cell.cx - 8.0, cell.worldY + 20.0) } } } function drawElevatorProgress(): void { if (gState != STATE_HOLD_E) return const ec = gCells[gEndCell] const pct = gHoldETimer / 2.0 // Progress arc around button const bx = ec.cx + 30.0; const by = ec.worldY + 22.0 canvas.stroke(255, 200, 60, 0.9) canvas.lineWidth(3.0) const steps: i32 = 20 const angEnd = -Math.PI * 0.5 + pct * Math.PI * 2.0 let first = true for (let i: i32 = 0; i <= steps; i++) { const a = -Math.PI * 0.5 + (i as f64 / steps as f64) * (angEnd + Math.PI * 0.5) const px = bx + Math.cos(a) * 10.0; const py = by + Math.sin(a) * 10.0 if (first) { canvas.moveTo(px, py); canvas.beginPath(); first = false } else canvas.lineTo(px, py) } canvas.strokePath() } // AssemblyScript doesn't have String.padStart — simple zero-pad helper function zeroPad(n: i32, width: i32): string { let s = n.toString() while (s.length < width) s = "0" + s return s } function drawHUD(): void { canvas.resetTransform() const sw = screen.width(); const sh = screen.height() // Health bar const hbW: f64 = 140.0; const hbH: f64 = 10.0 const hbX: f64 = 16.0; const hbY: f64 = sh - 30.0 canvas.fill(20, 15, 12, 0.85) canvas.rect(hbX, hbY, hbW, hbH, 3.0) const hf = clamp(gPlayer.hp / gPlayer.maxHp, 0.0, 1.0) canvas.fill(200.0 * (1.0 - hf) + 20.0, 180.0 * hf + 20.0, 30.0, 0.9) canvas.rect(hbX, hbY, hbW * hf, hbH, 3.0) canvas.fill(180, 160, 130, 0.8) canvas.font("monospace", 9.0) canvas.text("HP " + Math.floor(gPlayer.hp).toString() + "/" + gPlayer.maxHp.toString(), hbX, hbY - 4.0) // Score canvas.fill(210, 185, 110, 0.95) canvas.font("monospace", 13.0, "bold") canvas.text(zeroPad(gScore, 6), sw - 80.0, 22.0) canvas.fill(120, 110, 90, 0.7) canvas.font("monospace", 8.0) canvas.text("HI " + zeroPad(gHighScore, 6), sw - 80.0, 34.0) // Level canvas.fill(160, 140, 100, 0.85) canvas.font("monospace", 10.0, "bold") canvas.text("B" + (gLevel + 1).toString(), 16.0, 20.0) canvas.fill(100, 90, 70, 0.7) canvas.font("monospace", 8.0) canvas.text("FLOOR", 16.0, 30.0) // Upgrade icon if (gPlayer.silenced) { canvas.fill(60, 180, 60, 0.9) canvas.font("monospace", 9.0) canvas.text("[SIL]", 16.0, 45.0) } else if (gPlayer.machineGun) { canvas.fill(255, 140, 40, 0.9) canvas.font("monospace", 9.0) canvas.text("[MG]", 16.0, 45.0) } // Kill counter canvas.fill(140, 110, 90, 0.7) canvas.font("monospace", 8.0) canvas.text(gKills.toString() + "/" + gTotalEnemies.toString() + " KIA", hbX, sh - 40.0) // Knife cooldown indicator if (gPlayer.knifeCD > 0.0) { const kf = 1.0 - gPlayer.knifeCD / KNIFE_COOLDOWN canvas.fill(220, 200, 80, 0.8) canvas.font("monospace", 8.0) canvas.text("KNIFE" + (kf < 1.0 ? " ..." : " RDY"), hbX + 150.0, sh - 30.0) } // Elevator hold E hint if (gState == STATE_HOLD_E || checkElevatorZone()) { canvas.fill(255, 200, 60, 0.9) canvas.font("monospace", 11.0, "bold") canvas.text("HOLD [E] TO EXTRACT", sw * 0.5 - 70.0, sh - 14.0) } // Knife flash UI if (gKnifeFlash > 0.0) { canvas.fill(255, 220, 60, gKnifeFlash * 0.4) canvas.rect(0.0, 0.0, sw, sh) } } function drawMenu(): void { canvas.resetTransform() const sw = screen.width(); const sh = screen.height() canvas.fill(18, 14, 10) canvas.rect(0.0, 0.0, sw, sh) // Title canvas.fill(200, 175, 100, 0.95) canvas.font("Georgia", 46.0, "bold") canvas.text("UNDERGROUND", sw * 0.5 - 155.0, sh * 0.38) canvas.fill(120, 100, 65, 0.7) canvas.font("monospace", 11.0) canvas.text("sub-floor operative · permadeath · no mercy", sw * 0.5 - 115.0, sh * 0.38 + 28.0) // Key hints canvas.fill(160, 140, 90, 0.85) canvas.font("monospace", 13.0) canvas.text("WASD — move MOUSE — aim CLICK — shoot", sw * 0.5 - 130.0, sh * 0.55) canvas.text("RIGHT CLICK / R — knife takedown at close range", sw * 0.5 - 130.0, sh * 0.55 + 22.0) canvas.text("E (hold) — call elevator when area clear", sw * 0.5 - 130.0, sh * 0.55 + 44.0) const pulse = Math.abs(Math.sin(elapsedTime() * 2.0)) canvas.fill(210, 185, 110, 0.6 + pulse * 0.4) canvas.font("monospace", 14.0, "bold") canvas.text("[ PRESS ANY KEY TO BEGIN ]", sw * 0.5 - 100.0, sh * 0.75) canvas.fill(80, 70, 50, 0.5) canvas.font("monospace", 8.0) canvas.text("HI " + zeroPad(gHighScore, 6), sw * 0.5 - 20.0, sh * 0.88) } function drawGameOver(): void { canvas.resetTransform() const sw = screen.width(); const sh = screen.height() canvas.fill(8, 5, 3, 1.0) canvas.rect(0.0, 0.0, sw, sh) canvas.fill(190, 50, 40, 0.95) canvas.font("Georgia", 36.0, "bold") canvas.text("YOU'RE MADE.", sw * 0.5 - 85.0, sh * 0.38) canvas.fill(150, 100, 60, 0.8) canvas.font("monospace", 12.0) canvas.text(gDeathMsg, sw * 0.5 - 70.0, sh * 0.48) canvas.fill(160, 140, 90, 0.7) canvas.font("monospace", 10.0) canvas.text("SCORE: " + gScore.toString() + " HI: " + gHighScore.toString(), sw * 0.5 - 60.0, sh * 0.57) const pulse = Math.abs(Math.sin(elapsedTime() * 2.0)) canvas.fill(140, 120, 80, 0.5 + pulse * 0.5) canvas.font("monospace", 12.0) canvas.text("[ ANY KEY — BACK TO LOBBY ]", sw * 0.5 - 90.0, sh * 0.72) } function drawSummary(): void { canvas.resetTransform() const sw = screen.width(); const sh = screen.height() canvas.fill(10, 8, 5, 0.9) canvas.rect(0.0, 0.0, sw, sh) canvas.fill(200, 175, 100, 0.95) canvas.font("Georgia", 24.0, "bold") canvas.text("FLOOR CLEARED", sw * 0.5 - 70.0, sh * 0.3) const kPct: f64 = gTotalEnemies > 0 ? (gKills as f64) / (gTotalEnemies as f64) : 0.0 canvas.fill(140, 120, 85, 0.8) canvas.font("monospace", 11.0) canvas.text("ELIMINATED: " + gKills.toString() + " / " + gTotalEnemies.toString() + " (" + Math.floor(kPct * 100.0).toString() + "%)", sw * 0.5 - 90.0, sh * 0.42) if (gBadge.length > 0) { canvas.fill(255, 220, 80, 0.95) canvas.font("monospace", 14.0, "bold") canvas.text(gBadge, sw * 0.5 - 50.0, sh * 0.52) } canvas.fill(120, 100, 70, 0.6) canvas.font("monospace", 9.0) canvas.text("DESCENDING IN " + Math.ceil(gSummaryTimer).toString() + "s...", sw * 0.5 - 50.0, sh * 0.75) } // ============================================================================= // UPDATE // ============================================================================= export function update(): void { const dt = Math.min(deltaTime(), 0.033) // cap at ~30fps min // Track mouse position every frame gMouseX = input.mouseX() gMouseY = input.mouseY() if (gState == STATE_MENU) { drawMenu() return } if (gState == STATE_DEAD) { drawGameOver() return } if (gState == STATE_SUMMARY) { gSummaryTimer -= dt if (gSummaryTimer <= 0.0) nextLevel() drawSummary() return } // ---- PLAYING / HOLD_E ---- updateCamera(dt) gKnifeFlash = Math.max(0.0, gKnifeFlash - dt * 4.0) // Player movement let pdx: f64 = 0.0; let pdy: f64 = 0.0 if (gKeys_w) pdy -= 1.0 if (gKeys_s) pdy += 1.0 if (gKeys_a) pdx -= 1.0 if (gKeys_d) pdx += 1.0 const pm = Math.sqrt(pdx * pdx + pdy * pdy) if (pm > 0.0) { pdx /= pm; pdy /= pm } gPlayer.vx = pdx * PLAYER_SPEED; gPlayer.vy = pdy * PLAYER_SPEED // Move player with wall resolution const np = pushEntityOutOfWalls(gPlayer.x + gPlayer.vx * dt, gPlayer.y + gPlayer.vy * dt, PLAYER_RADIUS) gPlayer.x = np[0]; gPlayer.y = np[1] // Aim const worldMX = gMouseX + gCamX const worldMY = gMouseY + gCamY gPlayer.angle = Math.atan2(worldMY - gPlayer.y, worldMX - gPlayer.x) // Fire cooldown gPlayer.fireCooldown -= dt gPlayer.knifeCD -= dt // Shoot if (gMouseDown && gPlayer.fireCooldown <= 0.0) { const fr = gPlayer.machineGun ? 0.06 : gPlayer.fireRate gPlayer.fireCooldown = fr const spread = gPlayer.machineGun ? (Math.random() - 0.5) * 0.1 : 0.0 const a = gPlayer.angle + spread spawnBullet(gPlayer.x, gPlayer.y, Math.cos(a) * BULLET_SPEED, Math.sin(a) * BULLET_SPEED, true, gPlayer.machineGun ? 14.0 : BULLET_DAMAGE) spawnMuzzleFlash(gPlayer.x + Math.cos(a) * 12.0, gPlayer.y + Math.sin(a) * 12.0, a, gPlayer.machineGun) if (!gPlayer.silenced) { // Spawn sound ring let ringFound = false for (let i: i32 = 0; i < gSoundRings.length; i++) { if (!gSoundRings[i].active) { gSoundRings[i].spawn(gPlayer.x, gPlayer.y); ringFound = true; break } } if (!ringFound) { const sr = new SoundRing(); sr.spawn(gPlayer.x, gPlayer.y); gSoundRings.push(sr) } alertNearbyEnemies(gPlayer.x, gPlayer.y) } } // Knife auto-trigger when very close for (let i: i32 = 0; i < gEnemies.length; i++) { const e = gEnemies[i] if (e.aiState == AI_DEAD) continue if (dist(gPlayer.x, gPlayer.y, e.x, e.y) < KNIFE_RANGE * 0.7 && gPlayer.knifeCD <= 0.0) { tryKnife() break } } // Update enemies for (let i: i32 = 0; i < gEnemies.length; i++) updateEnemy(gEnemies[i], dt) // Update bullets for (let i: i32 = 0; i < gBullets.length; i++) { const b = gBullets[i] if (!b.active) continue b.update(dt) if (!b.active) continue // Wall collision let hitWall = false for (let j: i32 = 0; j < gObstacles.length; j++) { if (gObstacles[j].solid && gObstacles[j].overlapsCircle(b.x, b.y, BULLET_RADIUS)) { spawnImpactSpark(b.x, b.y) if (!b.fromPlayer) alertNearbyEnemies(b.x, b.y) else { // Bullet impact near enemy causes reaction for (let k: i32 = 0; k < gEnemies.length; k++) { const e = gEnemies[k] if (e.aiState == AI_DEAD) continue if (dist(e.x, e.y, b.x, b.y) < 200.0 && e.aiState != AI_CHASE) { e.aiState = AI_EVADE e.soundX = b.x; e.soundY = b.y e.stateTimer = 0.8 + Math.random() * 0.5 e.indicatorChar = 2; e.indicatorTimer = 0.8 } } } b.active = false; hitWall = true; break } } if (hitWall) continue if (b.fromPlayer) { // Hit enemies for (let j: i32 = 0; j < gEnemies.length; j++) { const e = gEnemies[j] if (e.aiState == AI_DEAD) continue if (dist(b.x, b.y, e.x, e.y) < ENEMY_RADIUS + BULLET_RADIUS) { e.takeDamage(b.damage) spawnBlood(e.x, e.y) if (e.dead) onEnemyKilled(e, false) else { enterChase(e) } b.active = false; gShake = 2.0; break } } } else { // Hit player if (dist(b.x, b.y, gPlayer.x, gPlayer.y) < PLAYER_RADIUS + BULLET_RADIUS) { gPlayer.hp -= b.damage spawnBlood(gPlayer.x, gPlayer.y) b.active = false; gShake = 4.0 if (gPlayer.hp <= 0.0) { gPlayer.hp = 0.0 gDeathMsg = "Back to the lobby." gState = STATE_DEAD } } } } // Update pickups for (let i: i32 = 0; i < gPickups.length; i++) { const p = gPickups[i] if (!p.active) continue p.update(dt) if (dist(gPlayer.x, gPlayer.y, p.x, p.y) < PLAYER_RADIUS + 8.0) { gPlayer.hp = Math.min(gPlayer.hp + p.amount, gPlayer.maxHp) p.active = false } } // Update particles for (let i: i32 = 0; i < gParticles.length; i++) gParticles[i].update(dt) // Update sound rings for (let i: i32 = 0; i < gSoundRings.length; i++) gSoundRings[i].update(dt) // Elevator hold E if (gState == STATE_PLAYING && checkElevatorZone() && !anyEnemyChasing()) { if (gKeys_e) { gHoldETimer += dt gState = STATE_HOLD_E if (gHoldETimer >= 2.0) { gState = STATE_SUMMARY gSummaryTimer = 4.0 } } else { gHoldETimer = Math.max(0.0, gHoldETimer - dt * 3.0) if (gState == STATE_HOLD_E) gState = STATE_PLAYING } } else { if (!gKeys_e) gHoldETimer = Math.max(0.0, gHoldETimer - dt * 3.0) if (gState == STATE_HOLD_E) gState = STATE_PLAYING } // =================== RENDER =================== // If state changed mid-frame (e.g. player just died), skip world render this frame if (gState == STATE_DEAD) { drawGameOver() return } if (gState == STATE_SUMMARY) { drawSummary() return } // Background (off-screen areas) canvas.resetTransform() canvas.fill(12, 10, 8) canvas.rect(0.0, 0.0, screen.width(), screen.height()) // Apply camera transform canvas.push() canvas.translate(-gCamX + gShakeX, -gCamY + gShakeY) // Layer 1: Floor drawFloor() // Layer 2: Decors for (let i: i32 = 0; i < gDecors.length; i++) gDecors[i].draw() // Layer 3: Obstacles for (let i: i32 = 0; i < gObstacles.length; i++) gObstacles[i].draw() // Layer 4: Pickups for (let i: i32 = 0; i < gPickups.length; i++) gPickups[i].draw() // Layer 5: FOV cones for (let i: i32 = 0; i < gEnemies.length; i++) gEnemies[i].drawFov() // Layer 6: Bullets for (let i: i32 = 0; i < gBullets.length; i++) gBullets[i].draw() // Layer 7: Enemies for (let i: i32 = 0; i < gEnemies.length; i++) gEnemies[i].drawBody() // Layer 8: Player gPlayer.draw() gPlayer.drawLaser(gObstacles) // Layer 9: Sound rings for (let i: i32 = 0; i < gSoundRings.length; i++) gSoundRings[i].draw() // Layer 10: Particles for (let i: i32 = 0; i < gParticles.length; i++) gParticles[i].draw() // Elevator progress arc drawElevatorProgress() // Path minimap hint — subtle arrow to next room drawPathArrow() canvas.pop() // Layer 11: HUD (screen space) drawHUD() } function drawPathArrow(): void { // Draw subtle arrow from player toward next unvisited path room const ec = gCells[gEndCell] const dx = ec.cx - gPlayer.x; const dy = ec.cy - gPlayer.y const d = Math.sqrt(dx * dx + dy * dy) if (d < 60.0) return const ndx = dx / d; const ndy = dy / d const ax = gPlayer.x + ndx * 28.0; const ay = gPlayer.y + ndy * 28.0 canvas.stroke(200, 180, 80, 0.25) canvas.lineWidth(1.5) canvas.beginPath(); canvas.moveTo(gPlayer.x + ndx * 20.0, gPlayer.y + ndy * 20.0); canvas.lineTo(ax, ay); canvas.strokePath() // Arrowhead canvas.beginPath() canvas.moveTo(ax, ay) canvas.lineTo(ax + Math.cos(Math.atan2(ndy, ndx) + Math.PI * 0.85) * 6.0, ay + Math.sin(Math.atan2(ndy, ndx) + Math.PI * 0.85) * 6.0) canvas.lineTo(ax + Math.cos(Math.atan2(ndy, ndx) - Math.PI * 0.85) * 6.0, ay + Math.sin(Math.atan2(ndy, ndx) - Math.PI * 0.85) * 6.0) canvas.lineTo(ax, ay) canvas.fillPath() } // ============================================================================= // INPUT HANDLERS // ============================================================================= export function onKeyDown(key: string): void { if (key == "w" || key == "W" || key == "ArrowUp") gKeys_w = true if (key == "s" || key == "S" || key == "ArrowDown") gKeys_s = true if (key == "a" || key == "A" || key == "ArrowLeft") gKeys_a = true if (key == "d" || key == "D" || key == "ArrowRight") gKeys_d = true if (key == "e" || key == "E") gKeys_e = true if (key == "r" || key == "R") tryKnife() if (gState == STATE_MENU || gState == STATE_DEAD) { startGame() } } export function onKeyUp(key: string): void { if (key == "w" || key == "W" || key == "ArrowUp") gKeys_w = false if (key == "s" || key == "S" || key == "ArrowDown") gKeys_s = false if (key == "a" || key == "A" || key == "ArrowLeft") gKeys_a = false if (key == "d" || key == "D" || key == "ArrowRight") gKeys_d = false if (key == "e" || key == "E") gKeys_e = false } export function onMouseDown(button: i32): void { if (button == 0) gMouseDown = true if (button == 2) tryKnife() if (gState == STATE_MENU || gState == STATE_DEAD) startGame() } export function onMouseUp(button: i32): void { if (button == 0) gMouseDown = false } export function resize(width: f64, height: f64): void { // handled via screen module }