@loonylabs/create-game 0.1.0

package/template/apps/server/src/handlers/actionEvent.ts

@@ -0,0 +1,55 @@
+import { meleeAttack, rollLoot, aggregateStats } from '@loonylabs/gamedev-core';
+import type { GameSession } from '../gameState.js';
+import { DEFAULT_ITEM_POOL } from '../../../game-data/src/loot/item-pool.js';
+
+const PLAYER_MELEE_RANGE = 1.5;
+const BASE_MELEE_DAMAGE = 15;
+
+export function handleMeleeAction(session: GameSession, socketId: string): void {
+  const player = session.state.players.get(socketId);
+  if (!player) return;
+
+  const aliveEnemies = session.state.enemies.filter(g => g.alive);
+  const targets = aliveEnemies.map(g => ({
+    entityId: g.entityId,
+    x: g.x,
+    y: g.y,
+    health: g.hp,
+  }));
+
+  const stats = aggregateStats(player.equipped);
+  const damage = BASE_MELEE_DAMAGE + (stats.attack ?? 0);
+
+  const results = meleeAttack(
+    { x: player.x, y: player.y },
+    targets,
+    PLAYER_MELEE_RANGE,
+    damage,
+  );
+
+  for (const result of results) {
+    if (!result.hit) continue;
+
+    const enemy = session.state.enemies.find(g => g.entityId === result.targetId);
+    if (!enemy || !enemy.alive) continue;
+
+    enemy.hp -= result.damage;
+    console.log(`[combat] Player ${player.entityId} hits Enemy ${enemy.entityId} (${enemy.enemyDefId}) for ${result.damage} (hp: ${enemy.hp})`);
+
+    if (enemy.hp <= 0) {
+      enemy.alive = false;
+      console.log(`[combat] Enemy ${enemy.entityId} (${enemy.enemyDefId}) died at (${enemy.x.toFixed(1)}, ${enemy.y.toFixed(1)})`);
+
+      // Drop loot
+      const seed = Date.now() ^ enemy.entityId;
+      const item = rollLoot(1, seed, DEFAULT_ITEM_POOL);
+      session.state.worldItems.push({
+        entityId: session.nextEntityId(),
+        x: enemy.x,
+        y: enemy.y,
+        item,
+      });
+      console.log(`[loot] Dropped "${item.name}" at (${enemy.x.toFixed(1)}, ${enemy.y.toFixed(1)})`);
+    }
+  }
+}

package/template/apps/server/src/handlers/craftHandler.ts

@@ -0,0 +1,59 @@
+import type { Socket } from 'socket.io';
+import { matchRecipe } from '@loonylabs/gamedev-core';
+import type { Recipe } from '@loonylabs/gamedev-core';
+import type { GameSession } from '../gameState.js';
+import type { InventoryItem } from '@loonylabs/gamedev-protocol';
+
+function toInventoryItems(inventory: Array<{ id: string; name: string; rarity: string; statBonus: Record<string, number> }>): InventoryItem[] {
+  return inventory.map((item, slot) => ({
+    id: item.id,
+    name: item.name,
+    rarity: item.rarity as 'common' | 'rare' | 'unique',
+    gridW: 1,
+    gridH: 1,
+    slot,
+    statBonus: item.statBonus,
+  }));
+}
+
+export function handleCraftRequest(
+  session: GameSession,
+  socket: Socket,
+  grid: Array<string | null>,
+  recipes: Recipe[],
+): void {
+  const player = session.state.players.get(socket.id);
+  if (!player) return;
+
+  const recipe = matchRecipe(grid, recipes);
+  if (!recipe) {
+    socket.emit('message', { type: 'CRAFT_RESULT', success: false, error: 'No matching recipe' });
+    return;
+  }
+
+  // Verify player has all required items
+  const requiredIds = grid.filter((id): id is string => id !== null);
+  for (const id of requiredIds) {
+    if (!player.inventory.find(i => i.id === id)) {
+      socket.emit('message', { type: 'CRAFT_RESULT', success: false, error: 'Missing ingredients' });
+      return;
+    }
+  }
+
+  // Remove one of each required item
+  for (const id of requiredIds) {
+    const idx = player.inventory.findIndex(i => i.id === id);
+    if (idx !== -1) player.inventory.splice(idx, 1);
+  }
+
+  // Add crafted item
+  player.inventory.push({
+    id: recipe.id,
+    name: recipe.name,
+    rarity: recipe.rarity,
+    statBonus: recipe.statBonus,
+  });
+
+  socket.emit('message', { type: 'CRAFT_RESULT', success: true, item: recipe });
+  socket.emit('message', { type: 'INVENTORY_UPDATE', items: toInventoryItems(player.inventory) });
+}

package/template/apps/server/src/handlers/equipHandler.ts

@@ -0,0 +1,73 @@
+import type { Socket } from 'socket.io';
+import type { GameSession, PlayerState } from '../gameState.js';
+import type { InventoryItem } from '@loonylabs/gamedev-protocol';
+import type { Item } from '@loonylabs/gamedev-core';
+
+function equippedToProtocol(equipped: Record<string, Item | undefined>): Record<string, InventoryItem> {
+  const result: Record<string, InventoryItem> = {};
+  for (const [slotId, item] of Object.entries(equipped)) {
+    if (!item) continue;
+    result[slotId] = {
+      id: item.id,
+      name: item.name,
+      rarity: item.rarity,
+      gridW: 1,
+      gridH: 1,
+      slot: 0,
+      statBonus: item.statBonus,
+    };
+  }
+  return result;
+}
+
+function inventoryToProtocol(inventory: Item[]): InventoryItem[] {
+  return inventory.map((it, slot) => ({
+    id: it.id,
+    name: it.name,
+    rarity: it.rarity,
+    gridW: 1,
+    gridH: 1,
+    slot,
+    statBonus: it.statBonus,
+  }));
+}
+
+function sendUpdates(socket: Socket, player: PlayerState): void {
+  socket.emit('message', { type: 'EQUIPMENT_UPDATE', equipped: equippedToProtocol(player.equipped as Record<string, Item | undefined>) });
+  socket.emit('message', { type: 'INVENTORY_UPDATE', items: inventoryToProtocol(player.inventory) });
+}
+
+export function handleEquipRequest(session: GameSession, socket: Socket, slotId: string, itemId: string): void {
+  const player = session.state.players.get(socket.id);
+  if (!player) return;
+
+  const itemIdx = player.inventory.findIndex(i => i.id === itemId);
+  if (itemIdx === -1) return;
+
+  const item = player.inventory[itemIdx];
+
+  // If slot is already occupied, swap current item back to inventory
+  const existing = player.equipped[slotId];
+  if (existing) {
+    player.inventory.push(existing);
+  }
+
+  // Move item from inventory to equipped
+  player.inventory.splice(itemIdx, 1);
+  player.equipped[slotId] = item;
+
+  sendUpdates(socket, player);
+}
+
+export function handleUnequipRequest(session: GameSession, socket: Socket, slotId: string): void {
+  const player = session.state.players.get(socket.id);
+  if (!player) return;
+
+  const item = player.equipped[slotId];
+  if (!item) return;
+
+  delete player.equipped[slotId];
+  player.inventory.push(item);
+
+  sendUpdates(socket, player);
+}

package/template/apps/server/src/handlers/raycastHandler.ts

@@ -0,0 +1,97 @@
+import { Server } from 'socket.io';
+import { GameSession } from '../gameState.js';
+import { intersectRayAABB, rollLoot } from '@loonylabs/gamedev-core';
+import { HUMANOID_HITBOXES } from '../../../game-data/src/combat/hitboxes.js';
+import { DEFAULT_ITEM_POOL } from '../../../game-data/src/loot/item-pool.js';
+import type { Vec3 } from '@loonylabs/gamedev-core';
+
+export function handleRaycastAction(
+  session: GameSession,
+  io: Server,
+  entityId: number,
+  origin: Vec3,
+  direction: Vec3,
+  range: number,
+  baseDamage = 10,
+  getGroundY?: (x: number, z: number) => number | null,
+) {
+  console.log(`[server] processing raycast from ${entityId} origin:`, origin, "dir:", direction);
+  const entities = session.getAllEntities();
+  let closestDist = range;
+  let closestHit: { entityId: number; multiplier: number; label: string; point: Vec3 } | null = null;
+
+  for (const entity of entities) {
+    if (entity.entityId === entityId) continue; // Don't hit yourself
+
+    // Check each hitbox for this entity
+    for (const hitbox of HUMANOID_HITBOXES) {
+      // Calculate absolute hitbox bounds
+      // entity.x is world X, entity.y is world Z
+      const groundY = getGroundY
+        ? (getGroundY(entity.x, entity.y) ?? 0)
+        : session.getCellHeight(Math.round(entity.x), Math.round(entity.y));
+      const min = {
+        x: entity.x + hitbox.min.x,
+        y: groundY + hitbox.min.y,
+        z: entity.y + hitbox.min.z,
+      };
+      const max = {
+        x: entity.x + hitbox.max.x,
+        y: groundY + hitbox.max.y,
+        z: entity.y + hitbox.max.z,
+      };
+
+      const dist = intersectRayAABB(origin, direction, min, max);
+      if (dist !== null && dist < closestDist) {
+        closestDist = dist;
+        closestHit = {
+          entityId: entity.entityId,
+          multiplier: hitbox.multiplier,
+          label: hitbox.label,
+          point: {
+            x: origin.x + direction.x * dist,
+            y: origin.y + direction.y * dist,
+            z: origin.z + direction.z * dist,
+          },
+        };
+      }
+    }
+  }
+
+  // Calculate endpoint for VFX
+  const endPoint = closestHit ? closestHit.point : {
+    x: origin.x + direction.x * range,
+    y: origin.y + direction.y * range,
+    z: origin.z + direction.z * range,
+  };
+
+  // Broadcast VFX to everyone
+  io.emit('message', {
+    type: 'COMBAT_VFX',
+    vfxType: 'tracer',
+    origin,
+    endPoint,
+    hit: closestHit !== null,
+  });
+
+  if (closestHit) {
+    const damage = Math.floor(baseDamage * closestHit.multiplier);
+    const result = session.applyDamage(closestHit.entityId, damage);
+    console.log(`[combat] Entity ${entityId} hit ${closestHit.entityId} in ${closestHit.label} for ${damage} dmg`);
+
+    if (result?.dead) {
+      const enemy = session.state.enemies.find(g => g.entityId === closestHit.entityId);
+      if (enemy) {
+        const seed = Date.now() ^ enemy.entityId;
+        const item = rollLoot(1, seed, DEFAULT_ITEM_POOL);
+        session.state.worldItems.push({
+          entityId: session.nextEntityId(),
+          x: enemy.x,
+          y: enemy.y,
+          item,
+        });
+        console.log(`[loot] Dropped "${item.name}" at (${enemy.x.toFixed(1)}, ${enemy.y.toFixed(1)})`);
+      }
+    }
+  }
+}

package/template/apps/server/src/handlers/skillHandler.ts

@@ -0,0 +1,87 @@
+import { Server } from 'socket.io';
+import type { GameSession } from '../gameState.js';
+import type { SkillBook } from '@loonylabs/gamedev-core';
+import { canUseSkill, recordSkillUse } from '@loonylabs/gamedev-core';
+import { handleRaycastAction } from './raycastHandler.js';
+import type { Vec3 } from '@loonylabs/gamedev-protocol';
+
+const PLAYER_MAX_HP = 100;
+
+export function handleUseSkill(
+  session: GameSession,
+  io: Server,
+  socketId: string,
+  skillId: string,
+  skillBook: SkillBook,
+  origin?: Vec3,
+  direction?: Vec3,
+  getGroundY?: (x: number, z: number) => number | null,
+): void {
+  const player = session.state.players.get(socketId);
+  if (!player) return;
+
+  const def = skillBook[skillId];
+  if (!def) {
+    console.log(`[skill] Unknown skill: ${skillId}`);
+    return;
+  }
+
+  const now = Date.now();
+  const lastUsed = player.skillCooldowns[skillId] ?? 0;
+
+  if (!canUseSkill(def, lastUsed, now)) {
+    const remaining = Math.ceil((def.cooldown - (now - lastUsed)) / 100) / 10;
+    console.log(`[skill] ${skillId} on cooldown for ${remaining}s`);
+    io.to(socketId).emit('message', {
+      type: 'SKILL_EXECUTION',
+      skillId,
+      casterEntityId: player.entityId,
+      success: false,
+    });
+    return;
+  }
+
+  player.skillCooldowns = recordSkillUse(player.skillCooldowns, skillId, now);
+
+  const damage = def.stats.damage ?? 10;
+  const range = def.stats.range ?? 20;
+
+  switch (def.actionType) {
+    case 'raycast':
+      if (origin && direction) {
+        handleRaycastAction(session, io, player.entityId, origin, direction, range, damage, getGroundY);
+      }
+      break;
+
+    case 'melee': {
+      // Simple melee: damage nearest entity within range
+      const entities = session.getAllEntities();
+      for (const e of entities) {
+        if (e.entityId === player.entityId) continue;
+        const dx = e.x - player.x;
+        const dy = e.y - player.y;
+        if (Math.sqrt(dx * dx + dy * dy) <= range) {
+          session.applyDamage(e.entityId, damage);
+          console.log(`[skill] ${skillId} melee hit entity ${e.entityId} for ${damage} dmg`);
+          break;
+        }
+      }
+      break;
+    }
+
+    case 'self_heal': {
+      const heal = def.stats.value ?? 30;
+      player.hp = Math.min(PLAYER_MAX_HP, player.hp + heal);
+      console.log(`[skill] ${skillId} healed player ${player.entityId} to ${player.hp}hp`);
+      break;
+    }
+  }
+
+  io.emit('message', {
+    type: 'SKILL_EXECUTION',
+    skillId,
+    casterEntityId: player.entityId,
+    success: true,
+  });
+  console.log(`[skill] ${player.entityId} used ${skillId} (${def.actionType})`);
+}

package/template/apps/server/src/handlers/terraformHandler.ts

@@ -0,0 +1,74 @@
+/**
+ * @file handlers/terraformHandler.ts
+ * Handles TERRAFORM messages — modifies voxel terrain and broadcasts deltas.
+ */
+import type { Server } from 'socket.io';
+import type { GameSession } from '../gameState.js';
+import { applyTerraform, VOXEL_CHUNK_X, VOXEL_CHUNK_Z } from '@loonylabs/gamedev-core';
+import type { VoxelChunk, TerraformEdit } from '@loonylabs/gamedev-core';
+import type { Terraform } from '@loonylabs/gamedev-protocol';
+
+/** Rate limiter: max edits per second per player. */
+const RATE_LIMIT_MS = 200; // 5 edits/sec
+const lastEditTime = new Map<number, number>();
+
+/**
+ * Handle a TERRAFORM message from a player.
+ *
+ * @param session - The current game session
+ * @param io - Socket.io server for broadcasting
+ * @param entityId - The player's entity ID
+ * @param msg - The validated terraform message
+ * @param getChunk - Function to retrieve/generate a voxel chunk
+ * @param persistEdits - Function to persist edits to the database
+ */
+export function handleTerraform(
+  session: GameSession,
+  io: Server,
+  entityId: number,
+  msg: Terraform,
+  getChunk: (cx: number, cz: number) => VoxelChunk | null,
+  persistEdits?: (cx: number, cz: number, edits: TerraformEdit[]) => void,
+): void {
+  // Rate limit
+  const now = Date.now();
+  const lastTime = lastEditTime.get(entityId) ?? 0;
+  if (now - lastTime < RATE_LIMIT_MS) return;
+  lastEditTime.set(entityId, now);
+
+  // Convert world coords to chunk coords + local coords
+  const cx = Math.floor(msg.x / VOXEL_CHUNK_X);
+  const cz = Math.floor(msg.z / VOXEL_CHUNK_Z);
+  const lx = msg.x - cx * VOXEL_CHUNK_X;
+  const ly = msg.y;
+  const lz = msg.z - cz * VOXEL_CHUNK_Z;
+
+  const chunk = getChunk(cx, cz);
+  if (!chunk) return;
+
+  // Apply terraform edit
+  const edits = applyTerraform(
+    chunk, lx, ly, lz,
+    msg.radius,
+    msg.mode,
+    msg.material ?? 1,
+  );
+
+  if (edits.length === 0) return;
+
+  // Persist to database
+  persistEdits?.(cx, cz, edits);
+
+  // Broadcast delta to all clients
+  const flatEdits: number[] = [];
+  for (const edit of edits) {
+    flatEdits.push(edit.lx, edit.ly, edit.lz, edit.density, edit.material);
+  }
+
+  io.emit('VOXEL_DELTA', {
+    type: 'VOXEL_DELTA',
+    cx,
+    cz,
+    edits: flatEdits,
+  });
+}