@jaysonder/tts-server 1.0.0

package/src/game/services/room-manager.service.ts

@@ -0,0 +1,152 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { generateRoomCode } from '../../common/utils/room-code.js';
+import { GameSettingsSchema, PlayerNameSchema } from '@nemsae/tts-validation';
+import type { ZodIssue } from 'zod';
+import type { Room, Player, GameSettings, GameState } from '../../common/types/index.js';
+
+@Injectable()
+export class RoomManagerService {
+  private readonly logger = new Logger(RoomManagerService.name);
+  private rooms = new Map<string, Room>();
+
+  createRoom(hostName: string, settings: GameSettings): Room {
+    const nameResult = PlayerNameSchema.safeParse(hostName);
+    if (!nameResult.success) {
+      const error = nameResult.error.issues.map((e: ZodIssue) => e.message).join(', ');
+      this.logger.error(`Invalid host name provided, hostName: ${hostName.substring(0, 20)}, error: ${error}`);
+      throw new Error(`Invalid host name: ${error}`);
+    }
+    const sanitizedHostName = nameResult.data;
+
+    const settingsResult = GameSettingsSchema.safeParse(settings);
+    if (!settingsResult.success) {
+      const errors = settingsResult.error.issues.map((e: ZodIssue) => e.message).join(', ');
+      this.logger.error(`Invalid game settings provided, errors: ${errors}, settings: ${JSON.stringify(settings)}`);
+      throw new Error(`Invalid game settings: ${errors}`);
+    }
+
+    const roomCode = this.generateUniqueCode();
+    const hostId = `host-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
+
+    this.logger.debug(`Creating room, roomCode: ${roomCode}, hostName: ${sanitizedHostName}, settings: ${JSON.stringify(settings)}`);
+
+    const host: Player = {
+      id: hostId,
+      name: sanitizedHostName,
+      isHost: true,
+      isReady: true,
+      currentScore: 0,
+      isConnected: true,
+    };
+
+    const game: GameState = {
+      roomCode,
+      settings,
+      players: [host],
+      twisters: [],
+      currentRound: -1,
+      roundResults: [],
+      status: 'lobby',
+      startedAt: null,
+      pausedAt: null,
+      totalPausedTime: 0,
+      currentTwisterStartTime: null,
+      roundTimeLimit: null,
+    };
+
+    const room: Room = {
+      code: roomCode,
+      game,
+      hostId,
+      createdAt: Date.now(),
+    };
+
+    this.rooms.set(roomCode, room);
+    this.logger.log(`Room created, roomCode: ${roomCode}, hostId: ${hostId}, totalRooms: ${this.rooms.size}`);
+    return room;
+  }
+
+  joinRoom(roomCode: string, playerName: string): { room: Room; player: Player } | null {
+    const nameResult = PlayerNameSchema.safeParse(playerName);
+    if (!nameResult.success) {
+      this.logger.warn(`Join failed - invalid player name, playerName: ${playerName.substring(0, 20)}, error: ${nameResult.error.issues.map((e: ZodIssue) => e.message).join(', ')}`);
+      return null;
+    }
+    const sanitizedPlayerName = nameResult.data;
+
+    this.logger.debug(`Attempting to join room, roomCode: ${roomCode}, playerName: ${sanitizedPlayerName}`);
+
+    const room = this.rooms.get(roomCode.toUpperCase());
+    if (!room) {
+      this.logger.warn(`Join failed - room not found, roomCode: ${roomCode}`);
+      return null;
+    }
+    if (room.game.players.length >= 4) {
+      this.logger.warn(`Join failed - room full, roomCode: ${roomCode}, currentPlayers: ${room.game.players.length}`);
+      return null;
+    }
+    if (room.game.status !== 'lobby') {
+      this.logger.warn(`Join failed - game already started, roomCode: ${roomCode}, status: ${room.game.status}`);
+      return null;
+    }
+
+    const player: Player = {
+      id: `player-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
+      name: sanitizedPlayerName,
+      isHost: false,
+      isReady: false,
+      currentScore: 0,
+      isConnected: true,
+    };
+
+    room.game.players.push(player);
+    this.logger.log(`Player joined room, roomCode: ${roomCode}, playerId: ${player.id}, playerName: ${playerName}, totalPlayers: ${room.game.players.length}`);
+    return { room, player };
+  }
+
+  getRoom(roomCode: string): Room | undefined {
+    return this.rooms.get(roomCode.toUpperCase());
+  }
+
+  removePlayer(roomCode: string, playerId: string): boolean {
+    const room = this.rooms.get(roomCode);
+    if (!room) return false;
+
+    const player = room.game.players.find((p: Player) => p.id === playerId);
+    this.logger.debug(`Removing player, roomCode: ${roomCode}, playerId: ${playerId}, playerName: ${player?.name}`);
+
+    room.game.players = room.game.players.filter((p: Player) => p.id !== playerId);
+
+    if (room.game.players.length === 0) {
+      this.rooms.delete(roomCode);
+      this.logger.log(`Room deleted - no players remaining, roomCode: ${roomCode}, totalRooms: ${this.rooms.size}`);
+      return true;
+    }
+
+    if (room.hostId === playerId && room.game.players.length > 0) {
+      room.game.players[0].isHost = true;
+      room.hostId = room.game.players[0].id;
+      this.logger.log(`Host reassigned, roomCode: ${roomCode}, newHostId: ${room.hostId}, newHostName: ${room.game.players[0].name}`);
+    }
+
+    return true;
+  }
+
+  getActiveLobbyPlayerCount(): number {
+    let count = 0;
+    for (const room of this.rooms.values()) {
+      if (room.game.status === 'lobby') {
+        count += room.game.players.length;
+      }
+    }
+    return count;
+  }
+
+  private generateUniqueCode(): string {
+    let code: string;
+    do {
+      code = generateRoomCode();
+    } while (this.rooms.has(code));
+    return code;
+  }
+}

package/src/game/services/scoring.service.ts

@@ -0,0 +1,46 @@
+export function levenshteinDistance(source: string, target: string): number {
+  if (source === target) return 0;
+  if (source.length === 0) return target.length;
+  if (target.length === 0) return source.length;
+
+  const matrix = Array.from({ length: source.length + 1 }, () => new Array<number>(target.length + 1).fill(0));
+
+  for (let i = 0; i <= source.length; i++) matrix[i][0] = i;
+  for (let j = 0; j <= target.length; j++) matrix[0][j] = j;
+
+  for (let i = 1; i <= source.length; i++) {
+    for (let j = 1; j <= target.length; j++) {
+      const cost = source[i - 1] === target[j - 1] ? 0 : 1;
+      matrix[i][j] = Math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + cost);
+    }
+  }
+
+  return matrix[source.length][target.length];
+}
+
+function normalizeText(value: string): string {
+  return value
+    .toLowerCase()
+    .replace(/[^a-z0-9\s]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+export function scoreTwister(spoken: string, target: string): { similarity: number } {
+  const normalizedTarget = normalizeText(target);
+  const normalizedInput = normalizeText(spoken);
+
+  if (normalizedTarget.length === 0 && normalizedInput.length === 0) {
+    return { similarity: 100 };
+  }
+
+  if (normalizedTarget.length === 0 || normalizedInput.length === 0) {
+    return { similarity: 0 };
+  }
+
+  const distance = levenshteinDistance(normalizedTarget, normalizedInput);
+  const longestLength = Math.max(normalizedTarget.length, normalizedInput.length);
+  const rawScore = ((longestLength - distance) / longestLength) * 100;
+
+  return { similarity: Math.max(0, Math.round(rawScore)) };
+}

package/src/game/services/twister-generator.service.ts

@@ -0,0 +1,119 @@
+import { Injectable, Logger } from '@nestjs/common';
+import OpenAI from 'openai';
+import { TopicSchema, RoundsSchema, CustomLengthSchema } from '@nemsae/tts-validation';
+import type { ZodIssue } from 'zod';
+import type { Twister, TwisterLength, TwisterTopic } from '../../common/types/index.js';
+
+function getLengthInstruction(length: TwisterLength, customLength?: number): string {
+  if (length === 'custom' && customLength) {
+    return `Each tongue twister must be exactly ${customLength} words long.`;
+  }
+  const lengthMap: Record<'short' | 'medium' | 'long', string> = {
+    short: 'Keep each tongue twister very brief, around 5 words.',
+    medium: 'Make each tongue twister moderately long, around 10 words.',
+    long: 'Make each tongue twister quite lengthy, around 20 words.',
+  };
+  return lengthMap[length as 'short' | 'medium' | 'long'];
+}
+
+@Injectable()
+export class TwisterGeneratorService {
+  private readonly logger = new Logger(TwisterGeneratorService.name);
+  private openai: OpenAI;
+
+  constructor() {
+    this.openai = new OpenAI({
+      apiKey: process.env.OPENAI_API_KEY,
+    });
+  }
+
+  async generateTwisters(
+    topic: TwisterTopic,
+    length: TwisterLength,
+    customLength: number | undefined,
+    rounds: number,
+  ): Promise<Twister[]> {
+    const topicResult = TopicSchema.safeParse(topic);
+    if (!topicResult.success) {
+      const error = topicResult.error.issues.map((e: ZodIssue) => e.message).join(', ');
+      this.logger.error(`Invalid topic provided, original: ${topic.substring(0, 50)}, error: ${error}`);
+      throw new Error(`Invalid topic: ${error}`);
+    }
+    const sanitizedTopic = topicResult.data;
+
+    const roundsResult = RoundsSchema.safeParse(rounds);
+    if (!roundsResult.success) {
+      const error = roundsResult.error.issues.map((e: ZodIssue) => e.message).join(', ');
+      this.logger.error(`Invalid rounds provided, original: ${rounds}, error: ${error}`);
+      throw new Error(`Invalid rounds: ${error}`);
+    }
+    const validatedRounds = roundsResult.data;
+
+    let validatedCustomLength: number | undefined = undefined;
+    if (length === 'custom' && customLength !== undefined) {
+      const customLengthResult = CustomLengthSchema.safeParse(customLength);
+      if (!customLengthResult.success) {
+        const error = customLengthResult.error.issues.map((e: ZodIssue) => e.message).join(', ');
+        this.logger.error(`Invalid custom length provided, original: ${customLength}, error: ${error}`);
+        throw new Error(`Invalid custom length: ${error}`);
+      }
+      validatedCustomLength = customLengthResult.data;
+    }
+
+    const lengthInstruction = getLengthInstruction(length, validatedCustomLength);
+
+    this.logger.log(`Generating twisters, topic: ${sanitizedTopic}, length: ${length}, customLength: ${validatedCustomLength}, rounds: ${validatedRounds}`);
+
+    const systemPrompt = `You are a tongue twister generator. Generate ${validatedRounds} unique, fun, and challenging tongue twisters that are difficult to say quickly.
+Each tongue twister should feature words related to the topic: ${sanitizedTopic}.
+${lengthInstruction}
+Return only the tongue twisters, one per line, with no numbering, no explanations, and no additional text.`;
+
+    try {
+      const response = await this.openai.chat.completions.create({
+        model: 'o3-mini',
+        messages: [
+          { role: 'system', content: systemPrompt },
+          { role: 'user', content: `Generate ${validatedRounds} unique tongue twisters about ${sanitizedTopic}.` },
+        ],
+        reasoning_effort: 'low',
+      });
+
+      const content = response.choices[0]?.message?.content?.trim() ?? '';
+
+      this.logger.debug(`OpenAI response: ${content.substring(0, 100)}`);
+
+      const texts = content
+        .split('\n')
+        .map((line: string) => line.trim())
+        .filter((line: string) => line.length > 0);
+
+      const usedTexts = new Set<string>();
+
+      const twisters = texts
+        .filter((text: string) => {
+          const normalized = text.toLowerCase();
+          if (usedTexts.has(normalized)) return false;
+          usedTexts.add(normalized);
+          return true;
+        })
+        .map((text: string, index: number) => {
+          const difficulty: 1 | 2 | 3 = length === 'short' ? 1 : length === 'medium' ? 2 : 3;
+          return {
+            id: `ai-${Date.now()}-${index}-${Math.random().toString(36).slice(2, 7)}`,
+            text,
+            difficulty,
+            topic: sanitizedTopic,
+            length,
+          };
+        });
+
+      this.logger.log(`Twisters generated, count: ${twisters.length}, texts: ${JSON.stringify(twisters.map((t: Twister) => t.text))}`);
+
+      return twisters;
+    } catch (error) {
+      this.logger.error(`Failed to generate twisters, error: ${error instanceof Error ? error.message : String(error)}`);
+      throw error;
+    }
+  }
+}

package/src/main.ts

@@ -0,0 +1,22 @@
+import { Logger } from '@nestjs/common';
+import 'dotenv/config';
+import { NestFactory } from '@nestjs/core';
+import { ConfigService } from '@nestjs/config';
+import { AppModule } from './app.module.js';
+
+const logger = new Logger('Bootstrap');
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+
+  app.enableCors({
+    origin: app.get(ConfigService).get<string>('CLIENT_URL'),
+    credentials: true,
+  });
+
+  const port = app.get(ConfigService).get<number>('PORT') || 3001;
+  await app.listen(port);
+  logger.log(`Application running on port ${port}`);
+}
+
+void bootstrap();

package/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "target": "ES2022",
+    "strict": true,
+    "strictPropertyInitialization": false,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}