gorlorn 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1432 @@
+// src/GorlornGame.tsx
+import { useEffect, useRef, useState } from "react";
+
+// src/Constants.ts
+var Constants = {
+  IsDebugMode: false,
+  AutoClearStats: false,
+  DieInOneHit: false,
+  EnemyDiameter: 0.058,
+  HeroDiameter: 0.056,
+  BulletDiameter: 0.026,
+  HeartDiameter: 0.035,
+  ButtonDiameter: 0.1,
+  HealthBarLength: 0.35,
+  HealthBarThickness: 0.06,
+  EnemySpeed: 0.7,
+  HeroSpeed: 0.9,
+  HeroAcceleration: 8,
+  BulletSpeed: 0.8,
+  HeartSpeed: 0.3,
+  PlayerFrozenOnHitMs: 2e3,
+  PlayerBlinksOnHitMs: 3e3,
+  ChainBulletLifeTimeMs: 300,
+  StartingEnemySpawnIntervalMs: 400,
+  EnemySpawnRateAcceleration: 0.995,
+  EnemySpeedIncrement: 8e-4,
+  MaxComboSize: 20,
+  EnemyDamage: 20,
+  PlayerHealth: 140,
+  HeartHealthRestore: 40,
+  MinShotIntervalMs: 250,
+  StartingChainCountToSpawnHeart: 4
+};
+
+// src/Images.ts
+function makeSprite(src, width, height) {
+  const img = new window.Image();
+  img.src = src;
+  return { img, width, height };
+}
+var _Images = class _Images {
+  static load(screenWidth, screenHeight, onComplete, assetBasePath = "/gorlorn") {
+    if (_Images._isLoaded) {
+      onComplete();
+      return;
+    }
+    const base = assetBasePath.replace(/\/+$/, "");
+    const xPct = (p) => Math.round(screenWidth * p);
+    const yPct = (p) => Math.round(screenHeight * p);
+    const avg = (screenWidth + screenHeight) / 2;
+    const byWidth = (p) => Math.round(avg * p);
+    const btnH = yPct(0.1);
+    const btnW = btnH * 5;
+    const sprites = [
+      ["Hero", `${base}/hero.png`, byWidth(Constants.HeroDiameter), byWidth(Constants.HeroDiameter)],
+      ["Background", `${base}/space.png`, xPct(1.1), yPct(1.1)],
+      ["Title", `${base}/title.png`, xPct(0.7), yPct(0.7 / 4.347826086956522)],
+      ["Bullet", `${base}/bullet.png`, byWidth(Constants.BulletDiameter), byWidth(Constants.BulletDiameter)],
+      ["BulletCombo", `${base}/bullet_combo.png`, byWidth(Constants.BulletDiameter), byWidth(Constants.BulletDiameter)],
+      ["DeathText", `${base}/death_text.png`, yPct(0.2 * 5.58333), yPct(0.2)],
+      ["Enemy", `${base}/enemy.png`, byWidth(Constants.EnemyDiameter), byWidth(Constants.EnemyDiameter)],
+      ["Heart", `${base}/heart.png`, byWidth(Constants.HeartDiameter), byWidth(Constants.HeartDiameter)],
+      ["LeftButton", `${base}/left_button.png`, xPct(Constants.ButtonDiameter), xPct(Constants.ButtonDiameter)],
+      ["RightButton", `${base}/right_button.png`, xPct(Constants.ButtonDiameter), xPct(Constants.ButtonDiameter)],
+      ["ButtonPlay", `${base}/button_play.png`, btnW, btnH],
+      ["ButtonStatistics", `${base}/button_statistics.png`, btnW, btnH],
+      ["ButtonAbout", `${base}/button_about.png`, btnW, btnH],
+      ["ButtonQuit", `${base}/button_quit.png`, btnW, btnH]
+    ];
+    let remaining = sprites.length;
+    const done = () => {
+      if (--remaining === 0) {
+        _Images._isLoaded = true;
+        onComplete();
+      }
+    };
+    for (const [key, src, w, h] of sprites) {
+      const sprite = makeSprite(src, w, h);
+      sprite.img.onload = done;
+      sprite.img.onerror = done;
+      _Images[key] = sprite;
+    }
+  }
+};
+_Images._isLoaded = false;
+var Images = _Images;
+
+// src/UI/Background.ts
+var NUM_POINTS = 10;
+var Background = class {
+  constructor(gorlorn) {
+    this.horizontalLineStarts = [];
+    this.horizontalLinesOffset = 0;
+    this.time = 0;
+    this.backgroundXOffset = 0;
+    this.backgroundYOffset = 0;
+    this.gridAnimationDurationMs = 300;
+    this.isRetractingGrid = false;
+    this.isExpandingGrid = false;
+    this.gorlorn = gorlorn;
+    this.targetGridTopY = gorlorn.getYFromPercent(0.45);
+    this.gridTopY = this.targetGridTopY;
+    for (let i = 0; i < NUM_POINTS; i++) {
+      this.horizontalLineStarts.push(gorlorn.getXFromPercent(1 / NUM_POINTS * i));
+    }
+  }
+  retractGrid(durationMs) {
+    this.gridAnimationDurationMs = durationMs;
+    this.isRetractingGrid = true;
+  }
+  extendGrid(durationMs) {
+    this.gridAnimationDurationMs = durationMs;
+    this.isExpandingGrid = true;
+  }
+  update(dt) {
+    const speed = this.gorlorn.screenWidth * 0.1;
+    this.time += dt;
+    this.backgroundXOffset = this.gorlorn.getXFromPercent(0.05) * Math.cos(this.time / 2) - this.gorlorn.getXFromPercent(0.05);
+    this.backgroundYOffset = this.gorlorn.getYFromPercent(0.05) * Math.sin(this.time / 2) - this.gorlorn.getYFromPercent(0.05);
+    this.horizontalLinesOffset += speed * dt;
+    if (this.isRetractingGrid) {
+      this.gridTopY += this.targetGridTopY / (this.gridAnimationDurationMs / 1e3) * dt;
+      if (this.gridTopY > this.gorlorn.screenHeight) this.isRetractingGrid = false;
+    } else if (this.isExpandingGrid) {
+      this.gridTopY -= this.targetGridTopY / (this.gridAnimationDurationMs / 1e3) * dt;
+      if (this.gridTopY <= this.targetGridTopY) {
+        this.gridTopY = this.targetGridTopY;
+        this.isExpandingGrid = false;
+      }
+    }
+  }
+  draw(ctx) {
+    const bg = Images.Background;
+    ctx.drawImage(bg.img, this.backgroundXOffset, this.backgroundYOffset, bg.width, bg.height);
+    ctx.save();
+    ctx.strokeStyle = "rgb(247,33,155)";
+    ctx.lineWidth = this.gorlorn.getYFromPercent(5e-3);
+    const centerX = this.gorlorn.screenWidth * 0.5;
+    const bottomY = this.gorlorn.screenHeight + (this.gridTopY - this.targetGridTopY);
+    for (let i = 0; i < NUM_POINTS; i++) {
+      const lineStart = (this.horizontalLineStarts[i] + this.horizontalLinesOffset) % this.gorlorn.screenWidth;
+      const distFromCenter = centerX - lineStart;
+      const bottomX = centerX - distFromCenter * 3.2;
+      ctx.beginPath();
+      ctx.moveTo(lineStart, this.gridTopY);
+      ctx.lineTo(bottomX, bottomY);
+      ctx.stroke();
+    }
+    let y = this.gridTopY;
+    let yInterval = this.gorlorn.getYFromPercent(0.05);
+    while (y < this.gorlorn.screenHeight) {
+      ctx.beginPath();
+      ctx.moveTo(0, y);
+      ctx.lineTo(this.gorlorn.screenWidth, y);
+      ctx.stroke();
+      y += yInterval;
+      yInterval *= 1.3;
+    }
+    ctx.restore();
+  }
+};
+
+// src/Entities/Points.ts
+var Points = class {
+  constructor(gorlorn, points, chainCount, x, y) {
+    this.gorlorn = gorlorn;
+    this.pointString = String(points);
+    this.timeCreatedMs = Date.now();
+    this.x = x;
+    this.y = y;
+    this.textSize = Math.round(gorlorn.getYFromPercent(0.03 + chainCount * 5e-3));
+    if (points > Math.pow(2, 5)) {
+      this.color = "rgb(255,0,0)";
+      this.lifeTimeMs = 1250;
+      this.speed = gorlorn.screenWidth * 0.15;
+    } else {
+      this.color = "rgb(255,255,255)";
+      this.lifeTimeMs = 800;
+      this.speed = gorlorn.screenHeight * 0.1;
+    }
+  }
+  update(dt) {
+    if (Date.now() - this.timeCreatedMs > this.lifeTimeMs) return true;
+    this.y += this.speed * dt;
+    return false;
+  }
+  draw(ctx) {
+    ctx.font = `${this.textSize}px sans-serif`;
+    ctx.fillStyle = this.color;
+    ctx.textAlign = "left";
+    ctx.fillText(this.pointString, this.x, this.y);
+  }
+};
+
+// src/UI/HealthBar.ts
+var HealthBar = class {
+  constructor(x, y, thickness, length) {
+    this.x = x;
+    this.y = y;
+    this.thickness = thickness;
+    this.length = length;
+  }
+  draw(ctx, healthPercent) {
+    const padding = 2;
+    const fillLength = Math.round((this.length - padding * 2) * healthPercent);
+    ctx.fillStyle = "rgb(55,55,55)";
+    ctx.fillRect(this.x, this.y, this.length, this.thickness);
+    ctx.fillStyle = "rgb(255,0,0)";
+    ctx.fillRect(this.x + padding, this.y + padding, fillLength, this.thickness - padding * 2);
+    ctx.fillStyle = "rgb(22,22,22)";
+    ctx.fillRect(this.x + padding + fillLength, this.y + padding, this.length - padding * 2 - fillLength, this.thickness - padding * 2);
+  }
+};
+
+// src/UI/HUD.ts
+var HUD = class {
+  constructor(gorlorn) {
+    this.points = [];
+    this.pointers = [];
+    this.isPointerDown = false;
+    this.keyLeftDown = false;
+    this.keyRightDown = false;
+    // Public state read by Hero, Button, etc.
+    this.isLeftPressed = false;
+    this.isRightPressed = false;
+    this.isClickedFlag = false;
+    this.isEscapeDown = false;
+    this.clickX = 0;
+    this.clickY = 0;
+    this.gorlorn = gorlorn;
+    this.buttonHitBoxDiameter = Math.round(gorlorn.getXFromPercent(Constants.ButtonDiameter) * 1.2);
+    this.leftBoxRight = this.buttonHitBoxDiameter;
+    this.leftBoxBottom = gorlorn.screenHeight;
+    this.rightBoxLeft = gorlorn.screenWidth - this.buttonHitBoxDiameter;
+    this.rightBoxBottom = gorlorn.screenHeight;
+    const healthBarLength = gorlorn.getXFromPercent(Constants.HealthBarLength);
+    const healthBarThickness = gorlorn.getYFromPercent(Constants.HealthBarThickness);
+    this.healthBar = new HealthBar(
+      gorlorn.getXFromPercent(0.99) - healthBarLength,
+      gorlorn.getYFromPercent(0.01),
+      healthBarThickness,
+      healthBarLength
+    );
+    this.scoreTextSize = gorlorn.getYFromPercent(0.08);
+    this.highScoreTextSize = gorlorn.getYFromPercent(0.05);
+  }
+  handlePointerEvent(e) {
+    if (this.isClickedFlag) this.isClickedFlag = false;
+    if (e.action === "down") {
+      this.pointers.push({ id: e.id, x: e.x, y: e.y });
+      if (this.pointers.length === 1 && !this.isPointerDown) {
+        this.isClickedFlag = true;
+        this.clickX = e.x;
+        this.clickY = e.y;
+      }
+    } else if (e.action === "up") {
+      this.pointers = this.pointers.filter((p) => p.id !== e.id);
+    } else if (e.action === "move") {
+      for (const p of this.pointers) {
+        if (p.id === e.id) {
+          p.x = e.x;
+          p.y = e.y;
+        }
+      }
+    }
+    this.isPointerDown = this.pointers.length === 1;
+    this.recomputeDirections();
+  }
+  handleKeyDown(key) {
+    if (key === "ArrowLeft") this.keyLeftDown = true;
+    if (key === "ArrowRight") this.keyRightDown = true;
+    if (key === "Escape") this.isEscapeDown = true;
+    this.recomputeDirections();
+  }
+  handleKeyUp(key) {
+    if (key === "ArrowLeft") this.keyLeftDown = false;
+    if (key === "ArrowRight") this.keyRightDown = false;
+    if (key === "Escape") this.isEscapeDown = false;
+    this.recomputeDirections();
+  }
+  recomputeDirections() {
+    let pointerLeft = false;
+    let pointerRight = false;
+    if (this.pointers.length > 0) {
+      const latest = this.pointers[this.pointers.length - 1];
+      pointerLeft = latest.x <= this.leftBoxRight && latest.y >= this.gorlorn.screenHeight - this.buttonHitBoxDiameter;
+      pointerRight = latest.x >= this.rightBoxLeft && latest.y >= this.gorlorn.screenHeight - this.buttonHitBoxDiameter;
+    }
+    this.isLeftPressed = pointerLeft || this.keyLeftDown;
+    this.isRightPressed = pointerRight || this.keyRightDown;
+  }
+  addPoints(x, y, chainCount) {
+    const pts = Math.pow(2, chainCount);
+    this.gorlorn.gameStats.score += pts;
+    this.points.push(new Points(this.gorlorn, pts, chainCount, x, y));
+  }
+  update(dt) {
+    this.points = this.points.filter((p) => !p.update(dt));
+  }
+  draw(ctx) {
+    ctx.save();
+    ctx.font = `${this.highScoreTextSize}px sans-serif`;
+    ctx.fillStyle = "white";
+    ctx.textAlign = "left";
+    ctx.fillText(`High Score: ${this.gorlorn.getHighScore()}`, this.gorlorn.getXFromPercent(0.01), this.gorlorn.getYFromPercent(0.065));
+    ctx.font = `${this.scoreTextSize}px sans-serif`;
+    ctx.fillText(`Score: ${this.gorlorn.gameStats.score}`, this.gorlorn.getXFromPercent(0.01), this.gorlorn.getYFromPercent(0.14));
+    const lb = Images.LeftButton;
+    const lbx = Math.round((this.leftBoxRight - lb.width) / 2);
+    const lby = Math.round(this.gorlorn.screenHeight - this.buttonHitBoxDiameter + (this.buttonHitBoxDiameter - lb.height) / 2);
+    ctx.drawImage(lb.img, lbx, lby, lb.width, lb.height);
+    const rb = Images.RightButton;
+    const rbx = Math.round(this.rightBoxLeft + (this.buttonHitBoxDiameter - rb.width) / 2);
+    const rby = Math.round(this.gorlorn.screenHeight - this.buttonHitBoxDiameter + (this.buttonHitBoxDiameter - rb.height) / 2);
+    ctx.drawImage(rb.img, rbx, rby, rb.width, rb.height);
+    for (const p of this.points) {
+      p.draw(ctx);
+    }
+    this.healthBar.draw(ctx, this.gorlorn.hero.getHealthPercent());
+    ctx.restore();
+  }
+};
+
+// src/Entities/Entity.ts
+function rectsIntersect(a, b) {
+  return a.left < b.right && a.right > b.left && a.top < b.bottom && a.bottom > b.top;
+}
+function rectContainsRect(outer, inner) {
+  return inner.left >= outer.left && inner.right <= outer.right && inner.top >= outer.top && inner.bottom <= outer.bottom;
+}
+var Entity = class {
+  constructor(sprite) {
+    this.x = 0;
+    this.y = 0;
+    this.opacity = 1;
+    this.vx = 0;
+    this.vy = 0;
+    this.maxV = Number.MAX_VALUE;
+    this.ax = 0;
+    this.ay = 0;
+    this.hitBox = { left: 0, top: 0, right: 0, bottom: 0 };
+    this.isBlinking = false;
+    this.timeStartedBlinkingMs = 0;
+    this.blinkDurationMs = 0;
+    this.blinkOpacityDelta = 0;
+    this.sprite = sprite;
+    this.width = sprite.width;
+    this.height = sprite.width;
+    this.timeCreatedMs = Date.now();
+  }
+  update(dt) {
+    this.x += this.vx * dt;
+    this.y += this.vy * dt;
+    this.vx = Math.max(-this.maxV, Math.min(this.maxV, this.vx + this.ax * dt));
+    this.vy = Math.max(-this.maxV, Math.min(this.maxV, this.vy + this.ay * dt));
+    this.hitBox = {
+      left: this.x - this.width * 0.48,
+      top: this.y - this.height * 0.48,
+      right: this.x + this.width * 0.48,
+      bottom: this.y + this.height * 0.48
+    };
+    if (this.isBlinking) {
+      if (Date.now() >= this.timeStartedBlinkingMs + this.blinkDurationMs) {
+        this.opacity = 1;
+        this.isBlinking = false;
+      } else {
+        this.opacity += dt * this.blinkOpacityDelta;
+        if (this.opacity >= 1) {
+          this.opacity = 1;
+          this.blinkOpacityDelta *= -1;
+        } else if (this.opacity <= 0) {
+          this.opacity = 0;
+          this.blinkOpacityDelta *= -1;
+        }
+      }
+    }
+    return false;
+  }
+  draw(ctx) {
+    const prevAlpha = ctx.globalAlpha;
+    if (this.opacity !== 1) ctx.globalAlpha = this.opacity;
+    ctx.drawImage(
+      this.sprite.img,
+      this.x - this.width / 2,
+      this.y - this.height / 2,
+      this.width,
+      this.height
+    );
+    if (this.opacity !== 1) ctx.globalAlpha = prevAlpha;
+  }
+  getTimeCreatedMs() {
+    return this.timeCreatedMs;
+  }
+  isOlderThan(other) {
+    return this.timeCreatedMs < other.getTimeCreatedMs();
+  }
+  startBlinking(durationMs) {
+    this.timeStartedBlinkingMs = Date.now();
+    this.blinkDurationMs = durationMs;
+    this.isBlinking = true;
+    this.blinkOpacityDelta = -17;
+  }
+  getIsBlinking() {
+    return this.isBlinking;
+  }
+  testHitEntity(other) {
+    return rectsIntersect(this.hitBox, other.hitBox);
+  }
+};
+
+// src/Entities/Hero.ts
+var Hero = class extends Entity {
+  constructor(gorlorn) {
+    super(Images.Hero);
+    this.lastShotFiredMs = 0;
+    this.direction = "None";
+    this.gorlorn = gorlorn;
+    this.speed = gorlorn.screenWidth * Constants.HeroSpeed;
+    this.acceleration = gorlorn.screenWidth * Constants.HeroAcceleration;
+    this.health = Constants.PlayerHealth;
+    this.maxV = this.speed;
+    this.x = gorlorn.screenWidth * 0.5;
+    this.y = gorlorn.getYFromPercent(0.995 - Constants.HeroDiameter);
+  }
+  dealDamage(damage) {
+    if (this.getIsBlinking()) return;
+    this.health -= damage;
+    this.startBlinking(Constants.PlayerBlinksOnHitMs);
+    if (this.health <= 1e-3 || Constants.DieInOneHit) {
+      this.health = 0;
+      this.gorlorn.die();
+    }
+    this.gorlorn.bulletManager.fireBulletSpray(this.x, this.y, 6, 0, Math.PI * 1.1, Math.PI * 1.9);
+  }
+  restoreHealth() {
+    this.health = Math.min(Constants.PlayerHealth, this.health + Constants.HeartHealthRestore);
+  }
+  getHealthPercent() {
+    return this.health / Constants.PlayerHealth;
+  }
+  update(dt) {
+    const hud = this.gorlorn.hud;
+    const canMoveAndShoot = !this.getIsBlinking() || Date.now() > this.timeStartedBlinkingMs + Constants.PlayerFrozenOnHitMs;
+    if (canMoveAndShoot && hud.isLeftPressed) {
+      if (this.direction === "Right") this.vx = 0;
+      this.ax = -this.acceleration;
+      this.direction = "Left";
+    } else if (canMoveAndShoot && hud.isRightPressed) {
+      if (this.direction === "Left") this.vx = 0;
+      this.ax = this.acceleration;
+      this.direction = "Right";
+    } else {
+      this.vx = 0;
+      this.ax = 0;
+      this.direction = "None";
+    }
+    super.update(dt);
+    this.x = Math.min(Math.max(this.x, this.width * 0.5), this.gorlorn.screenWidth - this.width * 0.5);
+    if (canMoveAndShoot) {
+      const now = Date.now();
+      if (now - this.lastShotFiredMs > Constants.MinShotIntervalMs) {
+        this.lastShotFiredMs = now;
+        this.gorlorn.bulletManager.fireBullet(this.x, this.y, Math.PI * 1.5);
+        this.gorlorn.gameStats.shotsFired++;
+      }
+    }
+    return false;
+  }
+};
+
+// src/Entities/Bullet.ts
+var Bullet = class extends Entity {
+  constructor(gorlorn, sprite, x, y, speed, angle, chainCount, lifetimeMs) {
+    super(sprite);
+    this.gorlorn = gorlorn;
+    this.lifeTimeMs = lifetimeMs;
+    this.chainCount = chainCount;
+    this.createdTimeMs = Date.now();
+    this.x = x;
+    this.y = y;
+    this.vx = speed * Math.cos(angle);
+    this.vy = speed * Math.sin(angle);
+  }
+  isChainBullet() {
+    return this.chainCount > 1;
+  }
+  getChainCount() {
+    return this.chainCount;
+  }
+  update(dt) {
+    if (this.lifeTimeMs !== 0 && Date.now() - this.createdTimeMs > this.lifeTimeMs) {
+      return true;
+    }
+    super.update(dt);
+    const gameArea = { left: 0, top: 0, right: this.gorlorn.screenWidth, bottom: this.gorlorn.screenHeight };
+    return !rectContainsRect(gameArea, this.hitBox);
+  }
+};
+
+// src/BulletManager.ts
+var BulletManager = class {
+  constructor(gorlorn) {
+    this.bullets = [];
+    this.chainCountToSpawnHeart = Constants.StartingChainCountToSpawnHeart;
+    this.gorlorn = gorlorn;
+    this.speed = (gorlorn.screenWidth + gorlorn.screenHeight) / 2 * Constants.BulletSpeed;
+  }
+  fireBullet(originX, originY, angle, chainCount = 1, lifeTimeMs = 0) {
+    const sprite = chainCount === 1 ? Images.Bullet : Images.BulletCombo;
+    this.bullets.push(new Bullet(this.gorlorn, sprite, originX, originY, this.speed, angle, chainCount, lifeTimeMs));
+  }
+  fireBulletSpray(originX, originY, numBullets, chainCount, minAngle = 0, maxAngle = Math.PI * 2) {
+    const newChainCount = Math.min(Constants.MaxComboSize, chainCount + 1);
+    for (let i = 0; i < numBullets; i++) {
+      const angle = minAngle + Math.random() * (maxAngle - minAngle);
+      this.fireBullet(originX, originY, angle, newChainCount, Constants.ChainBulletLifeTimeMs);
+    }
+  }
+  update(dt) {
+    const dead = [];
+    const enemyKillers = [];
+    for (const bullet of this.bullets) {
+      if (bullet.update(dt)) {
+        dead.push(bullet);
+        continue;
+      }
+      const killedEnemy = this.gorlorn.enemyManager.tryKillEnemy(bullet);
+      if (killedEnemy !== null) {
+        this.gorlorn.hud.addPoints(bullet.x, bullet.y, bullet.getChainCount());
+        dead.push(bullet);
+        enemyKillers.push(bullet);
+        if (bullet.getChainCount() > this.chainCountToSpawnHeart) {
+          this.gorlorn.heartManager.spawnHeart(bullet.x, bullet.y);
+          this.chainCountToSpawnHeart++;
+        }
+      } else if (bullet.y - bullet.height < 0) {
+        dead.push(bullet);
+      }
+    }
+    this.bullets = this.bullets.filter((b) => !dead.includes(b));
+    for (const b of enemyKillers) {
+      this.fireBulletSpray(b.x, b.y, 3, b.getChainCount());
+      this.gorlorn.gameStats.highestCombo = Math.max(b.getChainCount() + 1, this.gorlorn.gameStats.highestCombo);
+    }
+  }
+  draw(ctx) {
+    for (const bullet of this.bullets) {
+      bullet.draw(ctx);
+    }
+  }
+};
+
+// src/Entities/Enemy.ts
+var Enemy = class extends Entity {
+  constructor(gorlorn, sprite) {
+    super(sprite);
+    this.hasEnteredScreen = false;
+    this.gorlorn = gorlorn;
+  }
+  update(dt) {
+    super.update(dt);
+    if (this.gorlorn.hero.testHitEntity(this)) {
+      this.gorlorn.hero.dealDamage(Constants.EnemyDamage);
+      return true;
+    }
+    if (this.x <= this.width * 0.5 || this.x >= this.gorlorn.screenWidth - this.width * 0.5) {
+      this.vx *= -1;
+    }
+    if (this.hasEnteredScreen) {
+      if (this.y <= this.height * 0.5 || this.y >= this.gorlorn.screenHeight - this.height * 0.5) {
+        this.vy *= -1;
+      }
+      this.x = Math.min(Math.max(this.x, this.width * 0.5), this.gorlorn.screenWidth - this.width * 0.5);
+      this.y = Math.min(Math.max(this.y, this.height * 0.5), this.gorlorn.screenHeight - this.height * 0.5);
+    } else if (this.y > this.height) {
+      this.hasEnteredScreen = true;
+    }
+    return false;
+  }
+};
+
+// src/EnemyManager.ts
+var EnemyManager = class {
+  constructor(gorlorn) {
+    this.enemies = [];
+    this.timeLastEnemySpawnedMs = 0;
+    this.enemySpawnIntervalMs = Constants.StartingEnemySpawnIntervalMs;
+    this.enemySpeed = Constants.EnemySpeed;
+    this.timeLastRateUpdateMs = 0;
+    this.gorlorn = gorlorn;
+  }
+  tryKillEnemy(bullet) {
+    for (const enemy of this.enemies) {
+      if (!(bullet.isChainBullet() && bullet.isOlderThan(enemy)) && enemy.testHitEntity(bullet)) {
+        this.gorlorn.gameStats.enemiesVanquished++;
+        this.enemies = this.enemies.filter((e) => e !== enemy);
+        return enemy;
+      }
+    }
+    return null;
+  }
+  update(dt) {
+    const now = Date.now();
+    if (now - this.timeLastEnemySpawnedMs > this.enemySpawnIntervalMs) {
+      this.timeLastEnemySpawnedMs = now;
+      this.spawnEnemy();
+    }
+    const dead = [];
+    for (const enemy of this.enemies) {
+      if (enemy.update(dt)) dead.push(enemy);
+    }
+    this.enemies = this.enemies.filter((e) => !dead.includes(e));
+    if (now - this.timeLastRateUpdateMs > 1e3) {
+      this.enemySpawnIntervalMs *= Constants.EnemySpawnRateAcceleration;
+      this.enemySpeed += Constants.EnemySpeedIncrement;
+      this.timeLastRateUpdateMs = now;
+    }
+  }
+  draw(ctx) {
+    for (const enemy of this.enemies) {
+      enemy.draw(ctx);
+    }
+  }
+  spawnEnemy() {
+    const angle = this.getEnemyAngle();
+    const speed = (this.gorlorn.screenWidth + this.gorlorn.screenHeight) / 2 * this.enemySpeed;
+    const minX = this.gorlorn.screenWidth * 0.2;
+    const enemy = new Enemy(this.gorlorn, Images.Enemy);
+    enemy.x = minX + Math.random() * this.gorlorn.screenWidth * 0.6;
+    enemy.y = this.gorlorn.getYFromPercent(0.025);
+    enemy.vx = speed * Math.cos(angle);
+    enemy.vy = speed * Math.sin(angle);
+    this.enemies.push(enemy);
+  }
+  getEnemyAngle() {
+    const left = Math.random() < 0.5;
+    if (left) {
+      return Math.PI * 0.2 + Math.random() * Math.PI * 0.2;
+    } else {
+      return Math.PI * 0.6 + Math.random() * Math.PI * 0.2;
+    }
+  }
+};
+
+// src/Entities/Heart.ts
+var Heart = class extends Entity {
+  constructor(gorlorn, sprite, x, y) {
+    super(sprite);
+    this.timeEnteredPhaseMs = 0;
+    this.phase = "Descending";
+    this.gorlorn = gorlorn;
+    this.x = x;
+    this.y = y;
+    this.vy = gorlorn.getSpeed(Constants.HeartSpeed);
+  }
+  update(dt) {
+    super.update(dt);
+    if (this.gorlorn.hero.testHitEntity(this)) {
+      this.gorlorn.gameStats.heartsCollected++;
+      this.gorlorn.hero.restoreHealth();
+      return true;
+    }
+    const now = Date.now();
+    if (this.phase === "Descending") {
+      if (this.y > this.gorlorn.getYFromPercent(0.96)) {
+        this.y = this.gorlorn.getYFromPercent(0.96);
+        this.timeEnteredPhaseMs = now;
+        this.vy = 0;
+        this.phase = "Paused";
+      }
+    } else if (this.phase === "Paused") {
+      if (now - this.timeEnteredPhaseMs > 3e3) {
+        this.timeEnteredPhaseMs = now;
+        this.startBlinking(2e3);
+        this.phase = "Blinking";
+      }
+    } else if (this.phase === "Blinking") {
+      if (now - this.timeEnteredPhaseMs > 2e3) {
+        return true;
+      }
+    }
+    return false;
+  }
+};
+
+// src/HeartManager.ts
+var HeartManager = class {
+  constructor(gorlorn) {
+    this.hearts = [];
+    this.gorlorn = gorlorn;
+  }
+  spawnHeart(x, y) {
+    this.hearts.push(new Heart(this.gorlorn, Images.Heart, x, y));
+  }
+  update(dt) {
+    this.hearts = this.hearts.filter((h) => !h.update(dt));
+  }
+  draw(ctx) {
+    for (const heart of this.hearts) {
+      heart.draw(ctx);
+    }
+  }
+};
+
+// src/GorlornStats.ts
+var GorlornStats = class _GorlornStats {
+  constructor() {
+    this.score = 0;
+    this.highScore = 0;
+    this.shotsFired = 0;
+    this.enemiesVanquished = 0;
+    this.highestCombo = 0;
+    this.gamesPlayed = 0;
+    this.heartsCollected = 0;
+    this.timePlayedMs = 0;
+  }
+  add(stats) {
+    this.score += stats.score;
+    this.highScore = Math.max(this.highScore, stats.score);
+    this.highestCombo = Math.max(this.highestCombo, stats.highestCombo);
+    this.shotsFired += stats.shotsFired;
+    this.enemiesVanquished += stats.enemiesVanquished;
+    this.gamesPlayed++;
+    this.heartsCollected += stats.heartsCollected;
+    this.timePlayedMs += stats.timePlayedMs;
+  }
+  save() {
+    try {
+      localStorage.setItem("GorlornStatistics", JSON.stringify(this));
+    } catch (e) {
+    }
+  }
+  static load() {
+    try {
+      const json = localStorage.getItem("GorlornStatistics");
+      if (json) {
+        const stats = new _GorlornStats();
+        Object.assign(stats, JSON.parse(json));
+        return stats;
+      }
+    } catch (e) {
+    }
+    return new _GorlornStats();
+  }
+};
+
+// src/Screens/ScreenBase.ts
+var ScreenBase = class {
+  constructor(gorlorn) {
+    this.gorlorn = gorlorn;
+  }
+};
+
+// src/UI/Button.ts
+var Button = class {
+  constructor(gorlorn, sprite, centerX, centerY) {
+    this.isClickedFlag = false;
+    this.gorlorn = gorlorn;
+    this.sprite = sprite;
+    this.x = centerX - sprite.width / 2;
+    this.y = centerY - sprite.height / 2;
+  }
+  isClicked() {
+    return this.isClickedFlag;
+  }
+  update() {
+    const hud = this.gorlorn.hud;
+    this.isClickedFlag = hud.isClickedFlag && hud.clickX >= this.x && hud.clickX <= this.x + this.sprite.width && hud.clickY >= this.y && hud.clickY <= this.y + this.sprite.height;
+  }
+  draw(ctx) {
+    ctx.drawImage(this.sprite.img, this.x, this.y, this.sprite.width, this.sprite.height);
+  }
+};
+
+// src/Screens/MenuScreen.ts
+var MenuScreen = class extends ScreenBase {
+  constructor(gorlorn) {
+    super(gorlorn);
+    this.playButton = new Button(gorlorn, Images.ButtonPlay, gorlorn.getXFromPercent(0.5), gorlorn.getYFromPercent(0.46));
+    this.statisticsButton = new Button(gorlorn, Images.ButtonStatistics, gorlorn.getXFromPercent(0.5), gorlorn.getYFromPercent(0.6));
+    this.aboutButton = new Button(gorlorn, Images.ButtonAbout, gorlorn.getXFromPercent(0.5), gorlorn.getYFromPercent(0.74));
+    this.quitButton = new Button(gorlorn, Images.ButtonQuit, gorlorn.getXFromPercent(0.5), gorlorn.getYFromPercent(0.88));
+  }
+  show(_previousScreen) {
+  }
+  leave() {
+    return true;
+  }
+  update(_dt) {
+    this.playButton.update();
+    this.statisticsButton.update();
+    this.aboutButton.update();
+    this.quitButton.update();
+    if (this.playButton.isClicked()) {
+      this.gorlorn.startGame();
+    } else if (this.statisticsButton.isClicked()) {
+      this.gorlorn.showStatistics();
+    } else if (this.aboutButton.isClicked()) {
+      this.gorlorn.showAboutScreen();
+    }
+    return false;
+  }
+  draw(ctx) {
+    this.gorlorn.background.draw(ctx);
+    const title = Images.Title;
+    ctx.drawImage(title.img, this.gorlorn.getXFromPercent(0.15), this.gorlorn.getYFromPercent(0.15), title.width, title.height);
+    this.playButton.draw(ctx);
+    this.statisticsButton.draw(ctx);
+    this.aboutButton.draw(ctx);
+    this.quitButton.draw(ctx);
+  }
+};
+
+// src/UI/HeroSummonEffect.ts
+var HeroSummonEffect = class {
+  constructor(gorlorn, comingFromMenu) {
+    this.titleOpacity = 1;
+    this.heroOpacity = 0;
+    this.beamY = 0;
+    this.gorlorn = gorlorn;
+    this.phase = comingFromMenu ? "FadeOutTitle" : "BeamDescending";
+    this.beamSpeed = gorlorn.getYFromPercent(6);
+    this.beamWidth = gorlorn.getXFromPercent(0.1);
+    this.beamX = (gorlorn.screenWidth - this.beamWidth) / 2;
+  }
+  update(dt) {
+    switch (this.phase) {
+      case "FadeOutTitle":
+        this.titleOpacity = Math.max(0, this.titleOpacity - dt);
+        if (this.titleOpacity <= 0) this.phase = "BeamDescending";
+        break;
+      case "BeamDescending":
+        this.beamY += this.beamSpeed * dt;
+        if (this.beamY >= this.gorlorn.screenHeight) {
+          this.beamY = this.gorlorn.screenHeight;
+          this.phase = "FadeInHero";
+        }
+        break;
+      case "FadeInHero":
+        this.heroOpacity = Math.min(1, this.heroOpacity + dt);
+        if (this.heroOpacity >= 1) this.phase = "BeamAscending";
+        break;
+      case "BeamAscending":
+        this.beamY -= this.beamSpeed * dt;
+        if (this.beamY <= 0) return true;
+        break;
+    }
+    return false;
+  }
+  draw(ctx) {
+    ctx.save();
+    if (this.phase === "FadeOutTitle") {
+      const title = Images.Title;
+      ctx.globalAlpha = this.titleOpacity;
+      ctx.drawImage(title.img, this.gorlorn.getXFromPercent(0.15), this.gorlorn.getYFromPercent(0.15), title.width, title.height);
+    }
+    ctx.globalAlpha = 140 / 255;
+    ctx.fillStyle = "rgb(247,255,109)";
+    ctx.fillRect(this.beamX, 0, this.beamWidth, this.beamY);
+    const hero = this.gorlorn.hero;
+    ctx.globalAlpha = this.heroOpacity;
+    ctx.drawImage(
+      Images.Hero.img,
+      hero.x - hero.width / 2,
+      hero.y - hero.height / 2,
+      hero.width,
+      hero.height
+    );
+    ctx.restore();
+  }
+};
+
+// src/Screens/GameScreen.ts
+var GameScreen = class extends ScreenBase {
+  constructor(gorlorn) {
+    super(gorlorn);
+    this.heroSummonEffect = null;
+  }
+  show(previousScreen) {
+    const comingFromMenu = previousScreen instanceof MenuScreen;
+    this.heroSummonEffect = new HeroSummonEffect(this.gorlorn, comingFromMenu);
+  }
+  leave() {
+    return true;
+  }
+  update(dt) {
+    if (this.heroSummonEffect !== null) {
+      if (this.heroSummonEffect.update(dt)) {
+        this.heroSummonEffect = null;
+      }
+    } else {
+      this.gorlorn.enemyManager.update(dt);
+      this.gorlorn.bulletManager.update(dt);
+      this.gorlorn.hero.update(dt);
+      this.gorlorn.hud.update(dt);
+      this.gorlorn.heartManager.update(dt);
+    }
+    return false;
+  }
+  draw(ctx) {
+    this.gorlorn.background.draw(ctx);
+    this.gorlorn.bulletManager.draw(ctx);
+    this.gorlorn.enemyManager.draw(ctx);
+    if (this.heroSummonEffect !== null) {
+      this.heroSummonEffect.draw(ctx);
+    } else {
+      this.gorlorn.hud.draw(ctx);
+      this.gorlorn.hero.draw(ctx);
+    }
+    this.gorlorn.heartManager.draw(ctx);
+  }
+};
+
+// src/UI/FloatingNumbers.ts
+var FloatingNumbers = class {
+  constructor(gorlorn, number, y, letterWidthXPercent, letterHeightYPercent, r, g, b) {
+    this.letters = [];
+    this.age = 0;
+    this.gorlorn = gorlorn;
+    this.textSize = gorlorn.getYFromPercent(letterHeightYPercent);
+    this.color = `rgb(${r},${g},${b})`;
+    const s = number.toLocaleString();
+    const letterWidth = gorlorn.getXFromPercent(letterWidthXPercent);
+    const totalWidth = letterWidth * s.length;
+    let x = (gorlorn.screenWidth - totalWidth) * 0.5;
+    for (let i = 0; i < s.length; i++) {
+      const ch = s[i];
+      this.letters.push({ x, baseY: y, y, index: i, char: ch });
+      x += ch === "," ? letterWidth * 0.3333 : letterWidth;
+    }
+  }
+  update(dt) {
+    this.age += dt;
+    const offsetAmt = this.gorlorn.getYFromPercent(0.015);
+    for (const letter of this.letters) {
+      const adjustedAge = this.age - 50 * letter.index;
+      letter.y = letter.baseY + offsetAmt * Math.cos(adjustedAge * 3);
+    }
+  }
+  draw(ctx) {
+    ctx.save();
+    ctx.font = `${this.textSize}px sans-serif`;
+    ctx.fillStyle = this.color;
+    ctx.textAlign = "left";
+    for (const letter of this.letters) {
+      ctx.fillText(letter.char, letter.x, letter.y);
+    }
+    ctx.restore();
+  }
+};
+
+// src/Screens/DeathScreen.ts
+var RED_FLASH_DURATION_MS = 90;
+var DeathScreen = class extends ScreenBase {
+  constructor(gorlorn, newHighScore) {
+    super(gorlorn);
+    this.phase = "BackgroundFadeIn";
+    this.timeEnteredPhaseMs = 0;
+    this.backgroundOpacity = 0;
+    this.highScoreFloatingNumbers = null;
+    this.highScoreTextSize = gorlorn.getYFromPercent(0.1);
+    if (newHighScore) {
+      this.highScoreFloatingNumbers = new FloatingNumbers(
+        gorlorn,
+        gorlorn.gameStats.score,
+        gorlorn.getYFromPercent(0.225),
+        0.04,
+        0.12,
+        95,
+        152,
+        234
+      );
+    }
+  }
+  show(_previousScreen) {
+    this.enterPhase("BackgroundFadeIn");
+  }
+  leave() {
+    return true;
+  }
+  update(dt) {
+    if (this.phase === "BackgroundFadeIn") {
+      this.backgroundOpacity = Math.min(1, this.backgroundOpacity + 0.5 * dt);
+      if (this.backgroundOpacity >= 1) this.enterPhase("RedFlash");
+    } else if (this.phase === "RedFlash") {
+      if (Date.now() >= this.timeEnteredPhaseMs + RED_FLASH_DURATION_MS) {
+        this.enterPhase("Done");
+      }
+    } else if (this.phase === "Done") {
+      if (this.gorlorn.hud.isClickedFlag) {
+        this.gorlorn.startGame();
+      }
+      if (this.highScoreFloatingNumbers) {
+        this.highScoreFloatingNumbers.update(dt);
+      }
+    }
+    return false;
+  }
+  draw(ctx) {
+    this.gorlorn.background.draw(ctx);
+    this.gorlorn.bulletManager.draw(ctx);
+    this.gorlorn.enemyManager.draw(ctx);
+    this.gorlorn.hero.draw(ctx);
+    ctx.fillStyle = `rgba(0,0,0,${this.backgroundOpacity})`;
+    ctx.fillRect(0, 0, this.gorlorn.screenWidth, this.gorlorn.screenHeight);
+    if (this.phase === "RedFlash") {
+      const flashPercent = Math.min(1, (Date.now() - this.timeEnteredPhaseMs) / RED_FLASH_DURATION_MS);
+      ctx.fillStyle = `rgba(255,0,0,${200 / 255 * flashPercent})`;
+      ctx.fillRect(0, 0, this.gorlorn.screenWidth, this.gorlorn.screenHeight);
+    }
+    if (this.phase === "RedFlash" || this.phase === "Done") {
+      if (this.phase === "Done") {
+        const dt = Images.DeathText;
+        ctx.drawImage(
+          dt.img,
+          (this.gorlorn.screenWidth - dt.width) * 0.5,
+          (this.gorlorn.screenHeight - dt.height) * 0.5,
+          dt.width,
+          dt.height
+        );
+        if (this.highScoreFloatingNumbers) {
+          ctx.save();
+          ctx.font = `${this.highScoreTextSize}px sans-serif`;
+          ctx.fillStyle = "rgb(95,152,234)";
+          ctx.textAlign = "center";
+          ctx.fillText("New High Score!", this.gorlorn.getXFromPercent(0.5), this.gorlorn.getYFromPercent(0.1));
+          ctx.restore();
+          this.highScoreFloatingNumbers.draw(ctx);
+        }
+      }
+    }
+  }
+  enterPhase(phase) {
+    this.phase = phase;
+    this.timeEnteredPhaseMs = Date.now();
+  }
+};
+
+// src/Screens/AboutScreen.ts
+var GRID_ANIMATION_DURATION_MS = 300;
+var AboutScreen = class extends ScreenBase {
+  constructor(gorlorn) {
+    super(gorlorn);
+    this.timeEnteredMs = 0;
+    this.timeLeftMs = 0;
+    this.versionTextSize = gorlorn.getYFromPercent(0.04);
+    this.messageTextSize = gorlorn.getYFromPercent(0.04);
+    this.backBtnH = gorlorn.getYFromPercent(0.1);
+    this.backBtnW = this.backBtnH * 5;
+    this.backBtnX = gorlorn.getXFromPercent(0.5) - this.backBtnW / 2;
+    this.backBtnY = gorlorn.getYFromPercent(0.82) - this.backBtnH / 2;
+  }
+  show(_previousScreen) {
+    this.timeEnteredMs = Date.now();
+    this.gorlorn.background.retractGrid(GRID_ANIMATION_DURATION_MS);
+  }
+  leave() {
+    this.gorlorn.background.extendGrid(GRID_ANIMATION_DURATION_MS);
+    this.timeLeftMs = Date.now();
+    return false;
+  }
+  update(_dt) {
+    if (this.timeLeftMs === 0 && Date.now() - this.timeEnteredMs > GRID_ANIMATION_DURATION_MS) {
+      const hud = this.gorlorn.hud;
+      const backClicked = hud.isClickedFlag && hud.clickX >= this.backBtnX && hud.clickX <= this.backBtnX + this.backBtnW && hud.clickY >= this.backBtnY && hud.clickY <= this.backBtnY + this.backBtnH;
+      if (backClicked) {
+        this.gorlorn.showMenu();
+      }
+    }
+    return this.timeLeftMs !== 0 && Date.now() - this.timeLeftMs > GRID_ANIMATION_DURATION_MS;
+  }
+  draw(ctx) {
+    this.gorlorn.background.draw(ctx);
+    const title = Images.Title;
+    ctx.drawImage(title.img, this.gorlorn.getXFromPercent(0.15), this.gorlorn.getYFromPercent(0.15), title.width, title.height);
+    if (Date.now() - this.timeEnteredMs > GRID_ANIMATION_DURATION_MS && this.timeLeftMs === 0) {
+      ctx.save();
+      ctx.fillStyle = "white";
+      ctx.textAlign = "left";
+      ctx.font = `${this.versionTextSize}px sans-serif`;
+      ctx.fillText("Version 1.0", this.gorlorn.getXFromPercent(0.15), this.gorlorn.getYFromPercent(0.19) + title.height);
+      ctx.font = `${this.messageTextSize}px sans-serif`;
+      ctx.textAlign = "center";
+      const cx = this.gorlorn.getXFromPercent(0.5);
+      ctx.fillText("This simple game was created for fun and to learn Android", cx, this.gorlorn.getYFromPercent(0.5));
+      ctx.fillText("development. To check out some REAL (and free!) games, go to:", cx, this.gorlorn.getYFromPercent(0.57));
+      ctx.fillText("              www.smileysmazehunt.com", cx, this.gorlorn.getYFromPercent(0.64));
+      ctx.fillStyle = "rgba(20, 30, 50, 0.85)";
+      ctx.strokeStyle = "rgba(150, 200, 255, 0.8)";
+      ctx.lineWidth = Math.max(1, this.backBtnH * 0.05);
+      ctx.fillRect(this.backBtnX, this.backBtnY, this.backBtnW, this.backBtnH);
+      ctx.strokeRect(this.backBtnX, this.backBtnY, this.backBtnW, this.backBtnH);
+      ctx.fillStyle = "white";
+      ctx.font = `${this.backBtnH * 0.45}px sans-serif`;
+      ctx.textAlign = "center";
+      ctx.textBaseline = "middle";
+      ctx.fillText("BACK", this.backBtnX + this.backBtnW / 2, this.backBtnY + this.backBtnH / 2);
+      ctx.restore();
+    }
+  }
+};
+
+// src/Screens/StatisticsScreen.ts
+var BACKGROUND_RETRACT_MS = 300;
+var StatisticsScreen = class extends ScreenBase {
+  constructor(gorlorn, stats) {
+    super(gorlorn);
+    this.phase = "Entering";
+    this.timeEnteredPhaseMs = 0;
+    this.statsSizePercent = 0;
+    this.stats = stats;
+  }
+  show(_previousScreen) {
+    this.enterPhase("Entering");
+    this.gorlorn.background.retractGrid(BACKGROUND_RETRACT_MS);
+  }
+  leave() {
+    this.gorlorn.background.extendGrid(BACKGROUND_RETRACT_MS);
+    this.enterPhase("Leaving");
+    return false;
+  }
+  update(dt) {
+    const rate = 1e3 / BACKGROUND_RETRACT_MS * dt * 0.9;
+    if (this.phase === "Entering") {
+      this.statsSizePercent = Math.min(1, this.statsSizePercent + rate);
+      if (this.timeInPhase() > BACKGROUND_RETRACT_MS) {
+        this.statsSizePercent = 1;
+        this.enterPhase("ShowingStats");
+      }
+    } else if (this.phase === "Leaving") {
+      this.statsSizePercent -= 1e3 / BACKGROUND_RETRACT_MS * dt;
+      if (this.timeInPhase() > BACKGROUND_RETRACT_MS) {
+        this.statsSizePercent = 0;
+        return true;
+      }
+    }
+    return false;
+  }
+  draw(ctx) {
+    this.gorlorn.background.draw(ctx);
+    const height = this.gorlorn.getYFromPercent(0.6) * this.statsSizePercent;
+    const width = height * 2.4;
+    const x = (this.gorlorn.screenWidth - width) * 0.5;
+    const y = (this.gorlorn.screenHeight - height) * 0.5 + this.gorlorn.getYFromPercent(0.05);
+    this.drawStatsInGrid(ctx, x, y, width, height);
+  }
+  drawStatsInGrid(ctx, x, y, width, height) {
+    const columnWidthPercents = [0.32, 0.26, 0.33, 0.15];
+    const numRows = 5;
+    const rowHeight = height / numRows;
+    const strings = [
+      "High Score: ",
+      this.formatNum(this.stats.highScore),
+      "",
+      "",
+      "Career Score: ",
+      this.formatNum(this.stats.score),
+      "",
+      "",
+      "Highest Combo: ",
+      this.formatNum(this.stats.highestCombo),
+      "Shots Fired: ",
+      this.formatNum(this.stats.shotsFired),
+      "Time Played: ",
+      this.formatTime(this.stats.timePlayedMs),
+      "Enemies Killed: ",
+      this.formatNum(this.stats.enemiesVanquished),
+      "Games Played: ",
+      this.formatNum(this.stats.gamesPlayed),
+      "Hearts Collected: ",
+      this.formatNum(this.stats.heartsCollected)
+    ];
+    ctx.save();
+    ctx.font = `${18}px sans-serif`;
+    ctx.fillStyle = "white";
+    ctx.textAlign = "left";
+    let cy = y;
+    for (let row = 0; row < numRows; row++) {
+      let cx = x;
+      for (let col = 0; col < columnWidthPercents.length; col++) {
+        ctx.fillText(strings[row * columnWidthPercents.length + col], cx, cy);
+        cx += width * columnWidthPercents[col];
+      }
+      cy += rowHeight;
+    }
+    ctx.restore();
+  }
+  formatNum(n) {
+    return n.toLocaleString();
+  }
+  formatTime(ms) {
+    const totalSec = Math.floor(ms / 1e3);
+    const h = Math.floor(totalSec / 3600);
+    const m = Math.floor(totalSec % 3600 / 60);
+    const s = totalSec % 60;
+    return `${String(h).padStart(2, "0")}:${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}`;
+  }
+  timeInPhase() {
+    return Date.now() - this.timeEnteredPhaseMs;
+  }
+  enterPhase(phase) {
+    this.phase = phase;
+    this.timeEnteredPhaseMs = Date.now();
+  }
+};
+
+// src/Gorlorn.ts
+var Gorlorn = class {
+  constructor(screenWidth, screenHeight) {
+    this.gameStats = new GorlornStats();
+    this.activeScreen = null;
+    this.pendingScreen = null;
+    this.isInitialized = false;
+    this.timeStartedMs = 0;
+    this.screenWidth = screenWidth;
+    this.screenHeight = screenHeight;
+    this.cumulativeStats = GorlornStats.load();
+  }
+  // ── Coordinate helpers ────────────────────────────────────────────────
+  getXFromPercent(percent) {
+    return Math.round(this.screenWidth * percent);
+  }
+  getYFromPercent(percent) {
+    return Math.round(this.screenHeight * percent);
+  }
+  getSpeed(screenSizePercentage) {
+    return (this.screenWidth + this.screenHeight) / 2 * screenSizePercentage;
+  }
+  getHighScore() {
+    return this.cumulativeStats.highScore;
+  }
+  // ── Game-flow methods ─────────────────────────────────────────────────
+  startGame() {
+    this.timeStartedMs = Date.now();
+    this.gameStats = new GorlornStats();
+    this.hero = new Hero(this);
+    this.enemyManager = new EnemyManager(this);
+    this.bulletManager = new BulletManager(this);
+    this.heartManager = new HeartManager(this);
+    this.setScreen(new GameScreen(this));
+  }
+  die() {
+    const newHighScore = this.gameStats.score > this.cumulativeStats.highScore;
+    this.gameStats.timePlayedMs = Date.now() - this.timeStartedMs;
+    this.cumulativeStats.add(this.gameStats);
+    this.cumulativeStats.save();
+    this.setScreen(new DeathScreen(this, newHighScore));
+  }
+  showMenu() {
+    if (this.activeScreen instanceof MenuScreen) return;
+    this.setScreen(new MenuScreen(this));
+  }
+  showAboutScreen() {
+    this.setScreen(new AboutScreen(this));
+  }
+  showStatistics() {
+    this.setScreen(new StatisticsScreen(this, this.cumulativeStats));
+  }
+  // Stubs for ad methods (no-ops on web)
+  showAd() {
+  }
+  hideAd() {
+  }
+  // ── Main loop ─────────────────────────────────────────────────────────
+  update(dt) {
+    if (!this.isInitialized) {
+      this.background = new Background(this);
+      this.hud = new HUD(this);
+      this.isInitialized = true;
+      this.setScreen(new MenuScreen(this));
+      return;
+    }
+    this.background.update(dt);
+    if (this.hud.isEscapeDown && !(this.activeScreen instanceof MenuScreen)) {
+      this.showMenu();
+    }
+    if (this.activeScreen === null || this.activeScreen.update(dt)) {
+      if (this.pendingScreen !== null) {
+        this.pendingScreen.show(this.activeScreen);
+        this.activeScreen = this.pendingScreen;
+        this.pendingScreen = null;
+      }
+    }
+  }
+  draw(ctx) {
+    if (!this.isInitialized) {
+      ctx.fillStyle = "rgb(100,100,100)";
+      ctx.fillRect(0, 0, this.screenWidth, this.screenHeight);
+      return;
+    }
+    if (this.activeScreen !== null) {
+      this.activeScreen.draw(ctx);
+    }
+  }
+  // ── Internal ──────────────────────────────────────────────────────────
+  setScreen(screen) {
+    if (this.pendingScreen !== null) return;
+    if (this.activeScreen === null || this.activeScreen.leave()) {
+      screen.show(this.activeScreen);
+      this.activeScreen = screen;
+    } else {
+      this.pendingScreen = screen;
+    }
+  }
+};
+
+// src/GorlornGame.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var GAME_W = 800;
+var GAME_H = 600;
+function GorlornGame({ assetBasePath = "/gorlorn" } = {}) {
+  const canvasRef = useRef(null);
+  const containerRef = useRef(null);
+  const [loading, setLoading] = useState(true);
+  const [displaySize, setDisplaySize] = useState({ w: GAME_W, h: GAME_H });
+  useEffect(() => {
+    const container = containerRef.current;
+    if (!container) return;
+    const observer = new ResizeObserver(([entry]) => {
+      const { width, height } = entry.contentRect;
+      const aspect = GAME_W / GAME_H;
+      let w = width, h = width / aspect;
+      if (h > height) {
+        h = height;
+        w = h * aspect;
+      }
+      setDisplaySize({ w: Math.floor(w), h: Math.floor(h) });
+    });
+    observer.observe(container);
+    return () => observer.disconnect();
+  }, []);
+  useEffect(() => {
+    const canvas = canvasRef.current;
+    if (!canvas) return;
+    const W = canvas.width;
+    const H = canvas.height;
+    Images.load(W, H, () => {
+      setLoading(false);
+      const ctx = canvas.getContext("2d");
+      if (!ctx) return;
+      const game = new Gorlorn(W, H);
+      let animFrameId;
+      let lastTime = null;
+      function loop(timestamp) {
+        const dt = lastTime === null ? 0 : (timestamp - lastTime) / 1e3;
+        lastTime = timestamp;
+        game.update(dt);
+        game.draw(ctx);
+        animFrameId = requestAnimationFrame(loop);
+      }
+      animFrameId = requestAnimationFrame(loop);
+      function canvasPoint(e) {
+        const rect = canvas.getBoundingClientRect();
+        const scaleX = W / rect.width;
+        const scaleY = H / rect.height;
+        return {
+          action: e.type === "pointerdown" ? "down" : e.type === "pointerup" ? "up" : "move",
+          id: e.pointerId,
+          x: Math.round((e.clientX - rect.left) * scaleX),
+          y: Math.round((e.clientY - rect.top) * scaleY)
+        };
+      }
+      function onPointerDown(e) {
+        e.preventDefault();
+        canvas.setPointerCapture(e.pointerId);
+        if (game.hud) game.hud.handlePointerEvent(canvasPoint(e));
+      }
+      function onPointerUp(e) {
+        e.preventDefault();
+        if (game.hud) game.hud.handlePointerEvent(canvasPoint(e));
+      }
+      function onPointerMove(e) {
+        e.preventDefault();
+        if (game.hud) game.hud.handlePointerEvent(canvasPoint(e));
+      }
+      function onKeyDown(e) {
+        if (e.key === "ArrowLeft" || e.key === "ArrowRight" || e.key === "Escape") {
+          e.preventDefault();
+          if (game.hud) game.hud.handleKeyDown(e.key);
+        }
+      }
+      function onKeyUp(e) {
+        if (e.key === "ArrowLeft" || e.key === "ArrowRight" || e.key === "Escape") {
+          if (game.hud) game.hud.handleKeyUp(e.key);
+        }
+      }
+      canvas.addEventListener("pointerdown", onPointerDown);
+      canvas.addEventListener("pointerup", onPointerUp);
+      canvas.addEventListener("pointermove", onPointerMove);
+      window.addEventListener("keydown", onKeyDown);
+      window.addEventListener("keyup", onKeyUp);
+      return () => {
+        cancelAnimationFrame(animFrameId);
+        canvas.removeEventListener("pointerdown", onPointerDown);
+        canvas.removeEventListener("pointerup", onPointerUp);
+        canvas.removeEventListener("pointermove", onPointerMove);
+        window.removeEventListener("keydown", onKeyDown);
+        window.removeEventListener("keyup", onKeyUp);
+      };
+    }, assetBasePath);
+  }, []);
+  return /* @__PURE__ */ jsx("div", { ref: containerRef, style: { flex: 1, width: "100%", minHeight: 0, display: "flex", alignItems: "center", justifyContent: "center" }, children: /* @__PURE__ */ jsxs("div", { style: { position: "relative", width: displaySize.w, height: displaySize.h }, children: [
+    /* @__PURE__ */ jsx(
+      "canvas",
+      {
+        ref: canvasRef,
+        width: GAME_W,
+        height: GAME_H,
+        style: { display: "block", touchAction: "none", width: displaySize.w, height: displaySize.h }
+      }
+    ),
+    loading && /* @__PURE__ */ jsx(
+      "div",
+      {
+        style: {
+          position: "absolute",
+          inset: 0,
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+          background: "rgb(100,100,100)",
+          color: "white",
+          fontSize: 24
+        },
+        children: "Loading\u2026"
+      }
+    )
+  ] }) });
+}
+export {
+  GorlornGame
+};