feat: initial elysium idle game prototype

Sets up the full monorepo with pnpm workspaces. Includes shared types
package, Hono API with Discord OAuth/JWT auth, Prisma v6 + MongoDB
Atlas, and React + Vite frontend with game loop, five tabs, and
Discord-linked save/load.

apps/api/src/routes/auth.ts

@@ -0,0 +1,97 @@
+import type { Player } from "@elysium/types";
+import { Hono } from "hono";
+import { prisma } from "../db/client.js";
+import { INITIAL_GAME_STATE } from "../data/initialState.js";
+import {
+  buildOAuthUrl,
+  exchangeCode,
+  fetchDiscordUser,
+} from "../services/discord.js";
+import { signToken } from "../services/jwt.js";
+
+export const authRouter = new Hono();
+
+authRouter.get("/url", (context) => {
+  try {
+    const url = buildOAuthUrl();
+    return context.json({ url });
+  } catch {
+    return context.json({ error: "Failed to build OAuth URL" }, 500);
+  }
+});
+
+authRouter.get("/callback", async (context) => {
+  const code = context.req.query("code");
+
+  if (!code) {
+    return context.json({ error: "Missing code parameter" }, 400);
+  }
+
+  try {
+    const tokenData = await exchangeCode(code);
+    const discordUser = await fetchDiscordUser(tokenData.access_token);
+
+    const existing = await prisma.player.findUnique({
+      where: { discordId: discordUser.id },
+    });
+
+    const now = Date.now();
+
+    if (!existing) {
+      const player = await prisma.player.create({
+        data: {
+          discordId: discordUser.id,
+          username: discordUser.username,
+          discriminator: discordUser.discriminator,
+          avatar: discordUser.avatar,
+          characterName: discordUser.username,
+          createdAt: now,
+          lastSavedAt: now,
+          totalGoldEarned: 0,
+          totalClicks: 0,
+        },
+      });
+
+      const playerShape: Player = {
+        discordId: player.discordId,
+        username: player.username,
+        discriminator: player.discriminator,
+        avatar: player.avatar ?? null,
+        characterName: player.characterName,
+        createdAt: player.createdAt,
+        lastSavedAt: player.lastSavedAt,
+        totalGoldEarned: player.totalGoldEarned,
+        totalClicks: player.totalClicks,
+      };
+
+      const initialState = INITIAL_GAME_STATE(playerShape, playerShape.characterName);
+      await prisma.gameState.create({
+        data: {
+          discordId: player.discordId,
+          state: initialState,
+          updatedAt: now,
+        },
+      });
+
+      const jwtToken = signToken(player.discordId);
+      const clientUrl = process.env["CORS_ORIGIN"] ?? "http://localhost:5173";
+      return context.redirect(`${clientUrl}/auth/callback?token=${jwtToken}&isNew=true`);
+    }
+
+    const updated = await prisma.player.update({
+      where: { discordId: discordUser.id },
+      data: {
+        username: discordUser.username,
+        discriminator: discordUser.discriminator,
+        avatar: discordUser.avatar,
+      },
+    });
+
+    const jwtToken = signToken(updated.discordId);
+    const clientUrl = process.env["CORS_ORIGIN"] ?? "http://localhost:5173";
+    return context.redirect(`${clientUrl}/auth/callback?token=${jwtToken}&isNew=false`);
+  } catch {
+    const clientUrl = process.env["CORS_ORIGIN"] ?? "http://localhost:5173";
+    return context.redirect(`${clientUrl}/auth/callback?error=auth_failed`);
+  }
+});

apps/api/src/routes/boss.ts

@@ -0,0 +1,100 @@
+import type { BossDamageRequest, GameState } from "@elysium/types";
+import { Hono } from "hono";
+import { prisma } from "../db/client.js";
+import { authMiddleware } from "../middleware/auth.js";
+
+const RATE_LIMIT_WINDOW_MS = 1_000;
+const MAX_DAMAGE_PER_SECOND = 10_000;
+
+export const bossRouter = new Hono();
+
+bossRouter.use("*", authMiddleware);
+
+bossRouter.post("/damage", async (context) => {
+  const discordId = context.get("discordId") as string;
+  const body = await context.req.json<BossDamageRequest>();
+
+  if (!body.bossId || body.damage == null || body.damage <= 0) {
+    return context.json({ error: "Invalid request body" }, 400);
+  }
+
+  // Rate limiting: sum damage dealt to this boss in the last second
+  const windowStart = Date.now() - RATE_LIMIT_WINDOW_MS;
+  const aggregate = await prisma.bossDamageLog.aggregate({
+    where: { discordId, bossId: body.bossId, dealtAt: { gt: windowStart } },
+    _sum: { damage: true },
+  });
+
+  const recentDamage = aggregate._sum.damage ?? 0;
+
+  if (recentDamage + body.damage > MAX_DAMAGE_PER_SECOND) {
+    return context.json({ error: "Rate limit exceeded" }, 429);
+  }
+
+  const record = await prisma.gameState.findUnique({ where: { discordId } });
+
+  if (!record) {
+    return context.json({ error: "No save found" }, 404);
+  }
+
+  const state = record.state as unknown as GameState;
+  const boss = state.bosses.find((b) => b.id === body.bossId);
+
+  if (!boss) {
+    return context.json({ error: "Boss not found" }, 404);
+  }
+
+  if (boss.status !== "in_progress" && boss.status !== "available") {
+    return context.json({ error: "Boss is not currently available" }, 400);
+  }
+
+  if (boss.prestigeRequirement > state.prestige.count) {
+    return context.json({ error: "Prestige requirement not met" }, 403);
+  }
+
+  await prisma.bossDamageLog.create({
+    data: { discordId, bossId: body.bossId, damage: body.damage, dealtAt: Date.now() },
+  });
+
+  boss.status = "in_progress";
+  boss.currentHp = Math.max(0, boss.currentHp - body.damage);
+  const defeated = boss.currentHp <= 0;
+
+  let rewards: { gold: number; essence: number; crystals: number; upgradeIds: string[] } | undefined;
+
+  if (defeated) {
+    boss.status = "defeated";
+    state.resources.gold += boss.goldReward;
+    state.resources.essence += boss.essenceReward;
+    state.resources.crystals += boss.crystalReward;
+    state.player.totalGoldEarned += boss.goldReward;
+
+    for (const upgradeId of boss.upgradeRewards) {
+      const upgrade = state.upgrades.find((u) => u.id === upgradeId);
+      if (upgrade) {
+        upgrade.unlocked = true;
+      }
+    }
+
+    const bossIndex = state.bosses.findIndex((b) => b.id === body.bossId);
+    const nextBoss = state.bosses[bossIndex + 1];
+    if (nextBoss && nextBoss.prestigeRequirement <= state.prestige.count) {
+      nextBoss.status = "available";
+    }
+
+    rewards = {
+      gold: boss.goldReward,
+      essence: boss.essenceReward,
+      crystals: boss.crystalReward,
+      upgradeIds: boss.upgradeRewards,
+    };
+  }
+
+  const now = Date.now();
+  await prisma.gameState.update({
+    where: { discordId },
+    data: { state: state as object, updatedAt: now },
+  });
+
+  return context.json({ currentHp: boss.currentHp, defeated, rewards });
+});

apps/api/src/routes/game.ts

@@ -0,0 +1,62 @@
+import type { GameState, SaveRequest } from "@elysium/types";
+import { Hono } from "hono";
+import { prisma } from "../db/client.js";
+import { authMiddleware } from "../middleware/auth.js";
+import { calculateOfflineGold } from "../services/offlineProgress.js";
+
+export const gameRouter = new Hono();
+
+gameRouter.use("*", authMiddleware);
+
+gameRouter.get("/load", async (context) => {
+  const discordId = context.get("discordId") as string;
+
+  const record = await prisma.gameState.findUnique({ where: { discordId } });
+
+  if (!record) {
+    return context.json({ error: "No save found" }, 404);
+  }
+
+  const state = record.state as unknown as GameState;
+  const now = Date.now();
+
+  const { offlineGold, offlineSeconds } = calculateOfflineGold(state, now);
+
+  if (offlineGold > 0) {
+    state.resources.gold += offlineGold;
+    state.player.totalGoldEarned += offlineGold;
+  }
+
+  state.lastTickAt = now;
+
+  return context.json({ state, offlineGold, offlineSeconds });
+});
+
+gameRouter.post("/save", async (context) => {
+  const discordId = context.get("discordId") as string;
+  const body = await context.req.json<SaveRequest>();
+
+  if (!body.state) {
+    return context.json({ error: "Missing state in request body" }, 400);
+  }
+
+  const now = Date.now();
+
+  await prisma.player.update({
+    where: { discordId },
+    data: {
+      lastSavedAt: now,
+      totalGoldEarned: body.state.player.totalGoldEarned,
+      totalClicks: body.state.player.totalClicks,
+      characterName: body.state.player.characterName,
+    },
+  });
+
+  await prisma.gameState.upsert({
+    where: { discordId },
+    create: { discordId, state: body.state, updatedAt: now },
+    update: { state: body.state, updatedAt: now },
+  });
+
+  return context.json({ savedAt: now });
+});

apps/api/src/routes/prestige.ts

@@ -0,0 +1,63 @@
+import type { GameState, PrestigeRequest } from "@elysium/types";
+import { Hono } from "hono";
+import { prisma } from "../db/client.js";
+import { authMiddleware } from "../middleware/auth.js";
+import {
+  buildPostPrestigeState,
+  isEligibleForPrestige,
+} from "../services/prestige.js";
+
+export const prestigeRouter = new Hono();
+
+prestigeRouter.use("*", authMiddleware);
+
+prestigeRouter.post("/", async (context) => {
+  const discordId = context.get("discordId") as string;
+  const body = await context.req.json<PrestigeRequest>();
+
+  const characterName = body.characterName?.trim();
+  if (!characterName) {
+    return context.json({ error: "characterName is required" }, 400);
+  }
+
+  const record = await prisma.gameState.findUnique({ where: { discordId } });
+
+  if (!record) {
+    return context.json({ error: "No save found" }, 404);
+  }
+
+  const state = record.state as unknown as GameState;
+
+  if (!isEligibleForPrestige(state)) {
+    return context.json(
+      { error: "Not eligible for prestige — collect 1,000,000 total gold first" },
+      400,
+    );
+  }
+
+  const { newState, newPrestigeData, runestonesEarned } = buildPostPrestigeState(
+    state,
+    characterName,
+  );
+
+  const now = Date.now();
+  await prisma.gameState.update({
+    where: { discordId },
+    data: { state: newState as object, updatedAt: now },
+  });
+
+  await prisma.player.update({
+    where: { discordId },
+    data: {
+      characterName,
+      totalGoldEarned: 0,
+      totalClicks: 0,
+      lastSavedAt: now,
+    },
+  });
+
+  return context.json({
+    runestones: runestonesEarned,
+    newPrestigeCount: newPrestigeData.count,
+  });
+});

apps/api/src/routes/profile.ts

@@ -0,0 +1,31 @@
+import type { GameState } from "@elysium/types";
+import { Hono } from "hono";
+import { prisma } from "../db/client.js";
+
+export const profileRouter = new Hono();
+
+profileRouter.get("/:discordId", async (context) => {
+  const { discordId } = context.req.param();
+
+  const [player, gameStateRecord] = await Promise.all([
+    prisma.player.findUnique({ where: { discordId } }),
+    prisma.gameState.findUnique({ where: { discordId } }),
+  ]);
+
+  if (!player) {
+    return context.json({ error: "Player not found" }, 404);
+  }
+
+  const state = gameStateRecord?.state as unknown as GameState | undefined;
+  const prestigeCount = state?.prestige.count ?? 0;
+
+  return context.json({
+    characterName: player.characterName,
+    username: player.username,
+    avatar: player.avatar ?? null,
+    prestigeCount,
+    totalGoldEarned: player.totalGoldEarned,
+    totalClicks: player.totalClicks,
+    createdAt: player.createdAt,
+  });
+});