magdo
288 lines
11 KiB
TypeScript
288 lines
11 KiB
TypeScript
import { StartGameCommand } from './StartGameCommand';
|
|
import { GameAggregate, GameDeck, GameCard, DeckType, GameState } from '../../../Domain/Game/GameAggregate';
|
|
import { DeckAggregate } from '../../../Domain/Deck/DeckAggregate';
|
|
import { IGameRepository } from '../../../Domain/IRepository/IGameRepository';
|
|
import { IDeckRepository } from '../../../Domain/IRepository/IDeckRepository';
|
|
import { DIContainer } from '../../Services/DIContainer';
|
|
import { RedisService } from '../../Services/RedisService';
|
|
import { logOther, logError } from '../../Services/Logger';
|
|
import { randomBytes } from 'crypto';
|
|
import { GenerateBoardCommand } from './GenerateBoardCommand';
|
|
|
|
export interface ActiveGameData {
|
|
gameId: string;
|
|
gameCode: string;
|
|
hostId?: string;
|
|
maxPlayers: number;
|
|
currentPlayers: GamePlayerData[];
|
|
state: GameState;
|
|
createdAt: Date;
|
|
startedAt?: Date;
|
|
currentTurn?: string;
|
|
websocketRoom: string;
|
|
}
|
|
|
|
export interface GamePlayerData {
|
|
playerId: string;
|
|
playerName?: string;
|
|
joinedAt: Date;
|
|
isOnline: boolean;
|
|
position?: number;
|
|
}
|
|
|
|
export class StartGameCommandHandler {
|
|
private gameRepository: IGameRepository;
|
|
private deckRepository: IDeckRepository;
|
|
private redisService: RedisService;
|
|
|
|
constructor() {
|
|
this.gameRepository = DIContainer.getInstance().gameRepository;
|
|
this.deckRepository = DIContainer.getInstance().deckRepository;
|
|
this.redisService = RedisService.getInstance();
|
|
}
|
|
|
|
async handle(command: StartGameCommand): Promise<GameAggregate> {
|
|
const startTime = performance.now();
|
|
|
|
try {
|
|
logOther('Starting game creation', `deckCount: ${command.deckids.length}, maxPlayers: ${command.maxplayers}, loginType: ${command.logintype}`);
|
|
|
|
// Generate unique game code
|
|
const gamecode = this.generateGameCode();
|
|
|
|
// Fetch all decks by IDs
|
|
const decks = await this.fetchDecks(command.deckids);
|
|
|
|
// Validate we have 3 deck types
|
|
this.validateDeckTypes(decks);
|
|
|
|
// Group decks by type and shuffle cards within each type
|
|
const gamedecks = await this.createShuffledGameDecks(decks);
|
|
|
|
// Create the game aggregate
|
|
const gameData: Partial<GameAggregate> = {
|
|
gamecode,
|
|
maxplayers: command.maxplayers,
|
|
logintype: command.logintype,
|
|
createdby: command.userid!,
|
|
orgid: command.orgid || null,
|
|
gamedecks,
|
|
players: [],
|
|
winner: null,
|
|
state: GameState.WAITING,
|
|
startdate: null,
|
|
enddate: null
|
|
};
|
|
|
|
// Save the game to database
|
|
const savedGame = await this.gameRepository.create(gameData);
|
|
|
|
// Create Redis object for real-time game management
|
|
await this.createGameInRedis(savedGame, command.userid);
|
|
|
|
// Trigger async board generation (don't block game creation)
|
|
this.triggerAsyncBoardGeneration(savedGame.id).catch((error: Error) => {
|
|
logError('Async board generation failed', error);
|
|
});
|
|
|
|
const endTime = performance.now();
|
|
logOther('Game created successfully', `gameId: ${savedGame.id}, gameCode: ${savedGame.gamecode}, executionTime: ${Math.round(endTime - startTime)}ms`);
|
|
|
|
return savedGame;
|
|
|
|
} catch (error) {
|
|
const endTime = performance.now();
|
|
logError('Failed to create game', error instanceof Error ? error : new Error(String(error)));
|
|
logOther('Game creation failed', `executionTime: ${Math.round(endTime - startTime)}ms`);
|
|
throw new Error('Failed to start game: ' + (error instanceof Error ? error.message : String(error)));
|
|
}
|
|
}
|
|
|
|
private generateGameCode(): string {
|
|
// Generate a 6-character alphanumeric game code
|
|
const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
|
|
let result = '';
|
|
const randomBytesArray = randomBytes(6);
|
|
|
|
for (let i = 0; i < 6; i++) {
|
|
result += chars[randomBytesArray[i] % chars.length];
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private async fetchDecks(deckIds: string[]): Promise<DeckAggregate[]> {
|
|
const decks: DeckAggregate[] = [];
|
|
|
|
for (const deckId of deckIds) {
|
|
const deck = await this.deckRepository.findById(deckId);
|
|
if (!deck) {
|
|
throw new Error(`Deck with ID ${deckId} not found`);
|
|
}
|
|
decks.push(deck);
|
|
}
|
|
|
|
return decks;
|
|
}
|
|
|
|
private validateDeckTypes(decks: DeckAggregate[]): void {
|
|
const deckTypes = new Set(decks.map(deck => deck.type));
|
|
|
|
// Check if we have all 3 required deck types (LUCK=0, JOKER=1, QUESTION=2)
|
|
const requiredTypes = [0, 1, 2]; // Based on Type enum in DeckAggregate
|
|
const missingTypes = requiredTypes.filter(type => !deckTypes.has(type));
|
|
|
|
if (missingTypes.length > 0) {
|
|
throw new Error(`Missing required deck types: ${missingTypes.join(', ')}. Game requires LUCK, JOKER, and QUESTION deck types.`);
|
|
}
|
|
|
|
logOther('Deck types validation passed', `foundTypes: [${Array.from(deckTypes).join(', ')}]`);
|
|
}
|
|
|
|
private async createShuffledGameDecks(decks: DeckAggregate[]): Promise<GameDeck[]> {
|
|
// Group decks by type
|
|
const decksByType = new Map<number, DeckAggregate[]>();
|
|
|
|
decks.forEach(deck => {
|
|
if (!decksByType.has(deck.type)) {
|
|
decksByType.set(deck.type, []);
|
|
}
|
|
decksByType.get(deck.type)!.push(deck);
|
|
});
|
|
|
|
const gamedecks: GameDeck[] = [];
|
|
|
|
// Process each deck type
|
|
for (const [deckType, typeDecks] of decksByType) {
|
|
// Collect all cards from decks of this type
|
|
const allCards: GameCard[] = [];
|
|
|
|
typeDecks.forEach(deck => {
|
|
deck.cards.forEach(card => {
|
|
const gameCard: GameCard = {
|
|
cardid: this.generateCardId(),
|
|
question: card.text,
|
|
answer: card.answer || undefined,
|
|
consequence: card.consequence || null,
|
|
played: false,
|
|
playerid: undefined
|
|
};
|
|
allCards.push(gameCard);
|
|
});
|
|
});
|
|
|
|
// Shuffle all cards of this type
|
|
const shuffledCards = this.shuffleArray(allCards);
|
|
|
|
// Create game deck for this type
|
|
const gameDeck: GameDeck = {
|
|
deckid: typeDecks[0].id, // Use first deck ID as representative
|
|
decktype: this.mapDeckTypeToGameDeckType(deckType),
|
|
cards: shuffledCards
|
|
};
|
|
|
|
gamedecks.push(gameDeck);
|
|
|
|
logOther('Created shuffled game deck', `type: ${deckType}, cardCount: ${shuffledCards.length}, sourceDecks: ${typeDecks.length}`);
|
|
}
|
|
|
|
return gamedecks;
|
|
}
|
|
|
|
private mapDeckTypeToGameDeckType(deckType: number): DeckType {
|
|
// Map DeckAggregate.Type to GameAggregate.DeckType
|
|
switch (deckType) {
|
|
case 0: return DeckType.LUCK; // LUCK = 0
|
|
case 1: return DeckType.JOCKER; // JOKER = 1
|
|
case 2: return DeckType.QUEST; // QUESTION = 2
|
|
default: throw new Error(`Unknown deck type: ${deckType}`);
|
|
}
|
|
}
|
|
|
|
private shuffleArray<T>(array: T[]): T[] {
|
|
const shuffled = [...array];
|
|
for (let i = shuffled.length - 1; i > 0; i--) {
|
|
const j = Math.floor(Math.random() * (i + 1));
|
|
[shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
|
|
}
|
|
return shuffled;
|
|
}
|
|
|
|
private generateCardId(): string {
|
|
return randomBytes(8).toString('hex');
|
|
}
|
|
|
|
private async createGameInRedis(game: GameAggregate, hostId?: string): Promise<void> {
|
|
try {
|
|
const redisKey = `game:${game.id}`;
|
|
|
|
const gameData: ActiveGameData = {
|
|
gameId: game.id,
|
|
gameCode: game.gamecode,
|
|
hostId: hostId,
|
|
maxPlayers: game.maxplayers,
|
|
currentPlayers: [],
|
|
state: game.state,
|
|
createdAt: game.createdate,
|
|
websocketRoom: `game_${game.gamecode}`
|
|
};
|
|
|
|
// Store game data in Redis with TTL (24 hours)
|
|
await this.redisService.setWithExpiry(redisKey, JSON.stringify(gameData), 24 * 60 * 60);
|
|
|
|
// Create game room for WebSocket connections
|
|
await this.redisService.set(`game_room:${game.gamecode}`, game.id);
|
|
|
|
logOther('Game created in Redis', {
|
|
gameId: game.id,
|
|
gameCode: game.gamecode,
|
|
hostId: hostId,
|
|
websocketRoom: gameData.websocketRoom,
|
|
redisKey
|
|
});
|
|
|
|
} catch (error) {
|
|
logError('Failed to create game in Redis', error instanceof Error ? error : new Error(String(error)));
|
|
// Don't throw error here - Redis failure shouldn't prevent game creation
|
|
logOther('Game created successfully despite Redis error', {
|
|
gameId: game.id,
|
|
gameCode: game.gamecode
|
|
});
|
|
}
|
|
}
|
|
|
|
private async triggerAsyncBoardGeneration(gameId: string): Promise<void> {
|
|
try {
|
|
// Calculate default field counts based on game configuration
|
|
// For now, use reasonable defaults - this should be configurable by host in the future
|
|
const maxSpecialFieldsPercentage = parseInt(process.env.MAX_SPECIAL_FIELDS_PERCENTAGE || '67');
|
|
const maxSpecialFields = Math.floor((100 * maxSpecialFieldsPercentage) / 100);
|
|
|
|
// Default distribution: 60% positive, 25% negative, 15% luck
|
|
const positiveFieldCount = Math.floor(maxSpecialFields * 0.6);
|
|
const negativeFieldCount = Math.floor(maxSpecialFields * 0.25);
|
|
const luckFieldCount = Math.floor(maxSpecialFields * 0.15);
|
|
|
|
const command: GenerateBoardCommand = {
|
|
gameId,
|
|
positiveFieldCount,
|
|
negativeFieldCount,
|
|
luckFieldCount
|
|
};
|
|
|
|
logOther(`Triggering async board generation for game ${gameId}`, {
|
|
positiveFieldCount,
|
|
negativeFieldCount,
|
|
luckFieldCount,
|
|
totalSpecialFields: positiveFieldCount + negativeFieldCount + luckFieldCount
|
|
});
|
|
|
|
// Execute board generation in background
|
|
await DIContainer.getInstance().generateBoardCommandHandler.execute(command);
|
|
|
|
} catch (error) {
|
|
logError(`Async board generation failed for game ${gameId}`, error as Error);
|
|
// Don't propagate error - board generation failure shouldn't affect game creation
|
|
}
|
|
}
|
|
} |