poem_game_component/dist/index.d.ts

import * as express from 'express';
import { Request, Response } from 'express';

declare class Player {
    private id;
    private name;
    private score;
    private isEliminated;
    constructor(id: string, name: string);
    getId(): string;
    getName(): string;
    getScore(): number;
    isPlayerEliminated(): boolean;
    addScore(points: number): void;
    eliminate(): void;
}

declare enum GameType {
    POEM_MATCHING = "POEM_MATCHING",// 对诗
    FLOWER_POEM = "FLOWER_POEM",// 飞花令
    CHAIN_POEM = "CHAIN_POEM"
}

interface GameRule {
    validateAnswer(historyAnswers: string[], currentAnswer: string, initialCondition: string): Promise<boolean>;
    validateInitialCondition(initialCondition: string): Promise<boolean>;
}

declare enum GameStatus {
    PREPARING = "PREPARING",// 准备状态，可以添加玩家
    PLAYING = "PLAYING",// 游戏进行中，可以提交答案
    FINISHED = "FINISHED"
}

declare class Game {
    private id;
    private gameType;
    private initialCondition;
    private players;
    private currentPlayerIndex;
    private historyAnswers;
    private status;
    constructor(id: string, gameType: GameType, initialCondition: string);
    getId(): string;
    getGameType(): GameType;
    getInitialCondition(): string;
    getPlayers(): Player[];
    getCurrentPlayerIndex(): number;
    getCurrentPlayer(): Player;
    getHistoryAnswers(): string[];
    getStatus(): GameStatus;
    addPlayer(player: Player): void;
    submitAnswer(answer: string, rule: GameRule): Promise<boolean>;
    startGame(): void;
    isGameOver(): boolean;
    getWinner(): Player | null;
    getNextPlayer(): number;
}

interface GameRepository {
    save(game: Game): Promise<void>;
    findById(id: string): Promise<Game | null>;
    findAll(): Promise<Game[]>;
    update(game: Game): Promise<void>;
    delete(id: string): Promise<void>;
}

declare class RuleFactory {
    createRule(gameType: GameType): GameRule;
}

declare class GameFactory {
    private gameRepository;
    private ruleFactory;
    constructor(gameRepository: GameRepository, ruleFactory: RuleFactory);
    createGame(gameType: GameType, initialCondition: string): Promise<Game>;
}

declare class GameService {
    private gameFactory;
    private gameRepository;
    private ruleFactory;
    constructor(gameFactory: GameFactory, gameRepository: GameRepository, ruleFactory: RuleFactory);
    createGame(gameType: GameType, initialCondition: string): Promise<Game>;
    getPreparingGames(): Promise<Game[]>;
    getNotFinishedGames(): Promise<Game[]>;
    getFinishedGames(): Promise<Game[]>;
    joinGame(gameId: string, playerName: string): Promise<Game>;
    startGame(gameId: string): Promise<Game>;
    submitAnswer(gameId: string, answer: string): Promise<boolean>;
    getGame(gameId: string): Promise<Game>;
}

declare class GameController {
    private gameService;
    constructor(gameService: GameService);
    createGame(req: Request, res: Response): Promise<void>;
    getPreparingGames(req: Request, res: Response): Promise<void>;
    getNotFinishedGames(req: Request, res: Response): Promise<void>;
    getFinishedGames(req: Request, res: Response): Promise<void>;
    joinGame(req: Request, res: Response): Promise<void>;
    startGame(req: Request, res: Response): Promise<void>;
    submitAnswer(req: Request, res: Response): Promise<void>;
    getGame(req: Request, res: Response): Promise<void>;
}

declare function createRoutes(gameRepository: GameRepository): express.Router;

export { Game, GameController, GameFactory, type GameRepository, GameService, GameStatus, GameType, Player, RuleFactory, createRoutes };