@nice2dev/game-engine 0.1.0

package/dist/types/templates/ActionTemplates.d.ts

@@ -0,0 +1,173 @@
+import type { Vec2, EntityId } from '../core/types';
+export interface PlatformerConfig {
+    moveSpeed: number;
+    jumpForce: number;
+    gravity: number;
+    maxJumps: number;
+    coyoteTime: number;
+    jumpBufferTime: number;
+    wallSlideSpeed: number;
+    wallJumpForce: Vec2;
+    dashSpeed: number;
+    dashDuration: number;
+    groundCheckDistance: number;
+    maxFallSpeed: number;
+}
+export declare const DEFAULT_PLATFORMER_CONFIG: PlatformerConfig;
+export interface PlatformerState {
+    grounded: boolean;
+    jumpsRemaining: number;
+    coyoteTimer: number;
+    jumpBufferTimer: number;
+    wallSliding: boolean;
+    dashing: boolean;
+    dashTimer: number;
+    facingRight: boolean;
+    velocity: Vec2;
+}
+export declare function createPlatformerState(): PlatformerState;
+export declare function updatePlatformer(state: PlatformerState, input: {
+    moveX: number;
+    jump: boolean;
+    dash: boolean;
+}, config: PlatformerConfig, dt: number): Vec2;
+export interface RunAndGunConfig {
+    moveSpeed: number;
+    jumpForce: number;
+    gravity: number;
+    fireRate: number;
+    bulletSpeed: number;
+    bulletDamage: number;
+    spreadAngle: number;
+    maxAmmo: number;
+    reloadTime: number;
+    aimDirections: 8 | 4;
+    scrollSpeed: number;
+}
+export declare const DEFAULT_RUN_AND_GUN_CONFIG: RunAndGunConfig;
+export type WeaponType = 'pistol' | 'shotgun' | 'machinegun' | 'rocket' | 'laser' | 'flamethrower';
+export interface WeaponDef {
+    type: WeaponType;
+    name: string;
+    damage: number;
+    fireRate: number;
+    bulletSpeed: number;
+    spread: number;
+    bulletsPerShot: number;
+    ammoMax: number;
+    reloadTime: number;
+    piercing: boolean;
+    explosive: boolean;
+    explosionRadius: number;
+}
+export declare const PRESET_WEAPONS: Record<WeaponType, WeaponDef>;
+export interface BeatEmUpConfig {
+    moveSpeed: number;
+    combo: ComboChain[];
+    grabRange: number;
+    throwDamage: number;
+    knockbackForce: number;
+    healthMax: number;
+    lives: number;
+    iFrameDuration: number;
+    specialMeterMax: number;
+    specialCostPerUse: number;
+    laneCount: number;
+    laneHeight: number;
+}
+export interface ComboChain {
+    name: string;
+    sequence: string[];
+    damage: number[];
+    timing: number;
+}
+export declare const DEFAULT_BEAT_EM_UP_CONFIG: BeatEmUpConfig;
+export interface BeatEmUpState {
+    comboIndex: number;
+    comboTimer: number;
+    specialMeter: number;
+    iFrameTimer: number;
+    health: number;
+    lives: number;
+    currentLane: number;
+}
+export declare function createBeatEmUpState(config: BeatEmUpConfig): BeatEmUpState;
+export interface HackAndSlashConfig {
+    moveSpeed: number;
+    attackSpeed: number;
+    attackRange: number;
+    attackArc: number;
+    damage: number;
+    critChance: number;
+    critMultiplier: number;
+    dodgeSpeed: number;
+    dodgeDuration: number;
+    dodgeCooldown: number;
+    healthMax: number;
+    manaMax: number;
+    manaRegen: number;
+    xpPerLevel: number;
+    xpScaling: number;
+    skillSlots: number;
+}
+export declare const DEFAULT_HACK_AND_SLASH_CONFIG: HackAndSlashConfig;
+export interface SkillDef {
+    id: string;
+    name: string;
+    manaCost: number;
+    cooldown: number;
+    damage: number;
+    range: number;
+    aoe: boolean;
+    aoeRadius: number;
+    projectile: boolean;
+    projectileSpeed: number;
+}
+export interface TwinStickConfig {
+    moveSpeed: number;
+    fireRate: number;
+    bulletSpeed: number;
+    bulletDamage: number;
+    bulletLifetime: number;
+    healthMax: number;
+    shieldMax: number;
+    shieldRegenRate: number;
+    shieldRegenDelay: number;
+    maxBullets: number;
+    spreadAngle: number;
+    bulletCount: number;
+    homingStrength: number;
+}
+export declare const DEFAULT_TWIN_STICK_CONFIG: TwinStickConfig;
+export interface TwinStickState {
+    health: number;
+    shield: number;
+    shieldRegenTimer: number;
+    fireTimer: number;
+    score: number;
+    killStreak: number;
+    multiplier: number;
+}
+export declare function createTwinStickState(config: TwinStickConfig): TwinStickState;
+export interface Projectile {
+    id: number;
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+    damage: number;
+    lifetime: number;
+    ownerId: EntityId;
+    piercing: boolean;
+    hitEntities: Set<EntityId>;
+}
+export declare class ProjectilePool {
+    private pool;
+    private active;
+    private nextId;
+    spawn(x: number, y: number, vx: number, vy: number, damage: number, lifetime: number, ownerId: EntityId, piercing?: boolean): Projectile;
+    update(dt: number): void;
+    getActive(): readonly Projectile[];
+    remove(id: number): void;
+    clear(): void;
+}

package/dist/types/templates/PartyTemplates.d.ts

@@ -0,0 +1,195 @@
+export interface MinigameCollectionConfig {
+    maxPlayers: number;
+    roundsPerGame: number;
+    minigameTimeLimit: number;
+    transitionDuration: number;
+    selectionMode: 'random' | 'vote' | 'sequential';
+    scoreMode: 'points' | 'stars' | 'coins';
+    bonusRound: boolean;
+    bonusEveryNRounds: number;
+    tiebreaker: boolean;
+}
+export declare const DEFAULT_MINIGAME_COLLECTION_CONFIG: MinigameCollectionConfig;
+export type MinigameType = 'ffa' | 'teams' | '1v3' | '2v2' | 'duel' | 'coop';
+export interface MinigameDef {
+    id: string;
+    name: string;
+    description: string;
+    type: MinigameType;
+    duration: number;
+    minPlayers: number;
+    maxPlayers: number;
+    rules: string;
+    winCondition: 'last_standing' | 'high_score' | 'first_to_goal' | 'time_trial';
+}
+export interface MinigameCollectionState {
+    currentRound: number;
+    players: MinigamePlayer[];
+    currentMinigame: MinigameDef | null;
+    phase: 'lobby' | 'selection' | 'playing' | 'results' | 'final';
+    history: Array<{
+        minigameId: string;
+        winners: string[];
+    }>;
+}
+export interface MinigamePlayer {
+    id: string;
+    name: string;
+    score: number;
+    stars: number;
+    wins: number;
+    connected: boolean;
+}
+export declare function createMinigameCollectionState(players: Array<{
+    id: string;
+    name: string;
+}>): MinigameCollectionState;
+export declare function awardPoints(state: MinigameCollectionState, rankings: Array<{
+    playerId: string;
+    position: number;
+}>, basePoints?: number): void;
+export interface QuizConfig {
+    questionsPerRound: number;
+    timePerQuestion: number;
+    answerOptions: number;
+    scoreForCorrect: number;
+    bonusForSpeed: boolean;
+    streakBonus: number;
+    maxPlayers: number;
+    categoryCount: number;
+    lifelines: QuizLifeline[];
+}
+export type QuizLifeline = '50/50' | 'skip' | 'extra_time' | 'ask_audience' | 'double_points';
+export declare const DEFAULT_QUIZ_CONFIG: QuizConfig;
+export interface QuizQuestion {
+    id: string;
+    category: string;
+    question: string;
+    answers: string[];
+    correctIndex: number;
+    difficulty: number;
+    imageId?: string;
+    explanation?: string;
+}
+export interface QuizState {
+    currentQuestion: number;
+    scores: Map<string, number>;
+    streaks: Map<string, number>;
+    answers: Map<string, number | null>;
+    lifelinesUsed: Map<string, Set<string>>;
+    phase: 'waiting' | 'question' | 'reveal' | 'scoreboard' | 'finished';
+    timer: number;
+}
+export declare function createQuizState(playerIds: string[]): QuizState;
+export declare function scoreQuizAnswer(state: QuizState, playerId: string, answerIndex: number, correctIndex: number, timeRemaining: number, config: QuizConfig): number;
+export interface BoardGameConfig {
+    boardType: 'linear' | 'grid' | 'hex' | 'custom';
+    spaceCount: number;
+    diceCount: number;
+    diceSides: number;
+    maxPlayers: number;
+    turnOrder: 'clockwise' | 'counterclockwise' | 'random';
+    startSpace: number;
+    winCondition: 'reach_end' | 'most_points' | 'last_standing' | 'collect_all';
+    eventSpaces: boolean;
+    shopSpaces: boolean;
+    branchPaths: boolean;
+}
+export declare const DEFAULT_BOARD_GAME_CONFIG: BoardGameConfig;
+export type BoardSpaceType = 'normal' | 'event' | 'shop' | 'minigame' | 'bonus' | 'penalty' | 'start' | 'finish';
+export interface BoardSpace {
+    index: number;
+    type: BoardSpaceType;
+    label: string;
+    nextSpaces: number[];
+    effect?: string;
+}
+export interface BoardGameState {
+    currentTurn: number;
+    currentPlayer: number;
+    players: Array<{
+        id: string;
+        name: string;
+        position: number;
+        score: number;
+        coins: number;
+        items: string[];
+        skippedTurns: number;
+    }>;
+    diceResult: number[];
+    phase: 'roll' | 'move' | 'event' | 'shop' | 'end_turn' | 'game_over';
+}
+export declare function rollDice(count: number, sides: number): number[];
+export declare function createBoardGameState(playerInfos: Array<{
+    id: string;
+    name: string;
+}>, config: BoardGameConfig): BoardGameState;
+export interface ReactionGameConfig {
+    type: 'speed_tap' | 'color_match' | 'simon_says' | 'whack_a_mole' | 'quick_draw';
+    roundCount: number;
+    roundDuration: number;
+    minReactionTime: number;
+    targetCount: number;
+    decoyChance: number;
+    penaltyForDecoy: number;
+    targetShowDuration: number;
+    speedIncrease: number;
+    maxPlayers: number;
+}
+export declare const DEFAULT_REACTION_CONFIG: ReactionGameConfig;
+export interface ReactionState {
+    round: number;
+    scores: Map<string, number>;
+    reactionTimes: Map<string, number[]>;
+    currentTargets: Array<{
+        id: number;
+        x: number;
+        y: number;
+        isDecoy: boolean;
+        showTime: number;
+    }>;
+    phase: 'waiting' | 'ready' | 'go' | 'results';
+    nextTargetId: number;
+}
+export declare function createReactionState(playerIds: string[]): ReactionState;
+export declare function getAverageReactionTime(state: ReactionState, playerId: string): number;
+export interface DrawingGameConfig {
+    roundDuration: number;
+    maxPlayers: number;
+    roundsPerPlayer: number;
+    hintInterval: number;
+    maxHints: number;
+    canvasWidth: number;
+    canvasHeight: number;
+    brushColors: string[];
+    brushSizes: number[];
+    categories: string[];
+    pointsForGuess: number;
+    pointsForDrawer: number;
+    bonusForSpeed: boolean;
+}
+export declare const DEFAULT_DRAWING_CONFIG: DrawingGameConfig;
+export interface DrawingStroke {
+    points: Array<{
+        x: number;
+        y: number;
+    }>;
+    color: string;
+    size: number;
+    tool: 'brush' | 'eraser' | 'fill';
+}
+export interface DrawingGameState {
+    currentDrawer: string;
+    currentWord: string;
+    hint: string;
+    hintsGiven: number;
+    timer: number;
+    strokes: DrawingStroke[];
+    scores: Map<string, number>;
+    guessedPlayers: Set<string>;
+    round: number;
+    phase: 'choosing' | 'drawing' | 'reveal' | 'finished';
+}
+export declare function createDrawingState(playerIds: string[]): DrawingGameState;
+export declare function generateHint(word: string, hintsGiven: number): string;
+export declare function checkGuess(guess: string, word: string): boolean;

package/dist/types/templates/PuzzleTemplates.d.ts

@@ -0,0 +1,127 @@
+export interface Match3Config {
+    columns: number;
+    rows: number;
+    gemTypes: number;
+    minMatch: number;
+    swapDuration: number;
+    fallSpeed: number;
+    scorePerGem: number;
+    comboMultiplier: number;
+    movesLimit: number;
+    timeLimit: number;
+    powerUpThreshold: number;
+}
+export declare const DEFAULT_MATCH3_CONFIG: Match3Config;
+export type GemType = number;
+export interface Match3Board {
+    cols: number;
+    rows: number;
+    cells: GemType[];
+}
+export declare function createMatch3Board(config: Match3Config): Match3Board;
+export declare function findMatches(board: Match3Board, minMatch: number): number[];
+export declare function removeMatches(board: Match3Board, indices: number[]): void;
+export declare function applyGravity(board: Match3Board, config: Match3Config): void;
+export declare function swapGems(board: Match3Board, idx1: number, idx2: number): void;
+export interface BlockPuzzleConfig {
+    columns: number;
+    rows: number;
+    fallInterval: number;
+    lockDelay: number;
+    softDropMultiplier: number;
+    hardDrop: boolean;
+    holdPiece: boolean;
+    previewCount: number;
+    lineScores: number[];
+    levelSpeedFactor: number;
+    linesPerLevel: number;
+}
+export declare const DEFAULT_BLOCK_PUZZLE_CONFIG: BlockPuzzleConfig;
+/** Standard tetrominoes as 4×4 bitmask rotations. */
+export declare const TETROMINOES: Record<string, number[][]>;
+export interface BlockPuzzleState {
+    board: number[];
+    currentPiece: string;
+    currentRotation: number;
+    pieceX: number;
+    pieceY: number;
+    score: number;
+    level: number;
+    lines: number;
+    heldPiece: string | null;
+    preview: string[];
+    gameOver: boolean;
+}
+export declare function createBlockPuzzleState(config: BlockPuzzleConfig): BlockPuzzleState;
+export declare function checkLines(board: number[], cols: number, rows: number): number[];
+export declare function clearLines(board: number[], cols: number, lineRows: number[]): void;
+export interface PhysicsPuzzleConfig {
+    gravity: number;
+    maxObjects: number;
+    goalType: 'reach' | 'destroy' | 'collect' | 'balance';
+    starThresholds: [number, number, number];
+    hintDelay: number;
+    undoSteps: number;
+}
+export declare const DEFAULT_PHYSICS_PUZZLE_CONFIG: PhysicsPuzzleConfig;
+export interface PuzzleLevelDef {
+    id: string;
+    name: string;
+    goalType: PhysicsPuzzleConfig['goalType'];
+    targetScore: number;
+    availableObjects: string[];
+    maxPlacements: number;
+}
+export interface HiddenObjectConfig {
+    timeLimit: number;
+    hintCooldown: number;
+    penaltyPerMisclick: number;
+    zoomEnabled: boolean;
+    maxZoom: number;
+    scorePerFind: number;
+    bonusTimePerFind: number;
+}
+export declare const DEFAULT_HIDDEN_OBJECT_CONFIG: HiddenObjectConfig;
+export interface HiddenObjectDef {
+    id: string;
+    name: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    found: boolean;
+}
+export interface HiddenObjectLevel {
+    sceneImage: string;
+    objects: HiddenObjectDef[];
+}
+export interface CardDef {
+    id: string;
+    name: string;
+    suit?: string;
+    rank?: number;
+    value: number;
+    imageId: string;
+    properties: Record<string, unknown>;
+}
+export interface DeckConfig {
+    cards: CardDef[];
+    shuffled: boolean;
+    maxHandSize: number;
+    drawCount: number;
+}
+export declare class Deck {
+    private cards;
+    private discardPile;
+    constructor(config: DeckConfig);
+    shuffle(): void;
+    draw(): CardDef | null;
+    drawMultiple(count: number): CardDef[];
+    discard(card: CardDef): void;
+    reshuffleDiscard(): void;
+    remaining(): number;
+    discarded(): number;
+    peek(count?: number): CardDef[];
+}
+/** Create a standard 52-card deck. */
+export declare function createStandardDeck(): CardDef[];

package/dist/types/templates/RPGTemplates.d.ts

@@ -0,0 +1,210 @@
+import type { Vec2 } from '../core/types';
+export interface RPGConfig {
+    moveSpeed: number;
+    tileSize: number;
+    gridMovement: boolean;
+    maxPartySize: number;
+    baseStats: RPGStats;
+    xpCurve: 'linear' | 'quadratic' | 'cubic';
+    xpBase: number;
+    xpScale: number;
+    maxLevel: number;
+    battleSystem: 'action' | 'turn-based' | 'atb';
+    encounterRate: number;
+    inventorySlots: number;
+}
+export interface RPGStats {
+    hp: number;
+    mp: number;
+    attack: number;
+    defense: number;
+    magic: number;
+    speed: number;
+    luck: number;
+}
+export declare const DEFAULT_RPG_CONFIG: RPGConfig;
+export declare function xpForLevel(level: number, config: RPGConfig): number;
+export interface RPGCharacter {
+    id: string;
+    name: string;
+    level: number;
+    xp: number;
+    stats: RPGStats;
+    currentHp: number;
+    currentMp: number;
+    equipment: Record<string, string | null>;
+    skills: string[];
+    statusEffects: StatusEffect[];
+}
+export interface StatusEffect {
+    id: string;
+    name: string;
+    duration: number;
+    statMod: Partial<RPGStats>;
+    dot: number;
+    hot: number;
+}
+export interface ItemDef {
+    id: string;
+    name: string;
+    description: string;
+    type: 'weapon' | 'armor' | 'accessory' | 'consumable' | 'key' | 'material';
+    slot?: string;
+    stackable: boolean;
+    maxStack: number;
+    statBonus: Partial<RPGStats>;
+    price: number;
+    rarity: 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary';
+    effectId?: string;
+}
+export interface Inventory {
+    slots: Array<{
+        itemId: string;
+        count: number;
+    } | null>;
+    gold: number;
+}
+export declare function createInventory(capacity: number): Inventory;
+export declare function addItem(inv: Inventory, itemId: string, count: number, itemDefs: Map<string, ItemDef>): boolean;
+export interface VisualNovelConfig {
+    textSpeed: number;
+    autoAdvanceDelay: number;
+    skipSpeed: number;
+    historyLength: number;
+    saveSlots: number;
+    maxCharactersOnScreen: number;
+    transitionDuration: number;
+}
+export declare const DEFAULT_VISUAL_NOVEL_CONFIG: VisualNovelConfig;
+export type VNCommandType = 'dialog' | 'choice' | 'show' | 'hide' | 'scene' | 'music' | 'sfx' | 'wait' | 'set' | 'if' | 'jump' | 'end';
+export interface VNCommand {
+    type: VNCommandType;
+    character?: string;
+    text?: string;
+    choices?: VNChoice[];
+    asset?: string;
+    position?: string;
+    expression?: string;
+    variable?: string;
+    value?: string | number | boolean;
+    condition?: string;
+    label?: string;
+    duration?: number;
+}
+export interface VNChoice {
+    text: string;
+    label: string;
+    condition?: string;
+}
+export interface VNScript {
+    id: string;
+    name: string;
+    commands: VNCommand[];
+    labels: Record<string, number>;
+}
+export declare function parseVNLabels(commands: VNCommand[]): Record<string, number>;
+export interface VNState {
+    scriptId: string;
+    commandIndex: number;
+    variables: Record<string, string | number | boolean>;
+    history: VNCommand[];
+    visibleCharacters: Array<{
+        id: string;
+        position: string;
+        expression: string;
+    }>;
+    currentBackground: string;
+    textProgress: number;
+    waitingForChoice: boolean;
+}
+export declare function createVNState(scriptId: string): VNState;
+export interface PointAndClickConfig {
+    walkSpeed: number;
+    doubleClickRun: boolean;
+    runMultiplier: number;
+    interactionDistance: number;
+    inventoryPosition: 'top' | 'bottom' | 'sidebar';
+    cursorTypes: string[];
+    verbCoin: boolean;
+    hotspotHighlight: boolean;
+}
+export declare const DEFAULT_POINT_AND_CLICK_CONFIG: PointAndClickConfig;
+export interface Hotspot {
+    id: string;
+    name: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    actions: Record<string, string>;
+    description: string;
+    enabled: boolean;
+}
+export interface RoomDef {
+    id: string;
+    name: string;
+    background: string;
+    walkableArea: Array<{
+        x: number;
+        y: number;
+    }>;
+    hotspots: Hotspot[];
+    exits: Array<{
+        targetRoom: string;
+        position: Vec2;
+        direction: string;
+    }>;
+}
+export interface RoguelikeConfig {
+    mapWidth: number;
+    mapHeight: number;
+    roomMinSize: number;
+    roomMaxSize: number;
+    maxRooms: number;
+    fovRadius: number;
+    turnBased: boolean;
+    permadeath: boolean;
+    metaProgression: boolean;
+    floorCount: number;
+    itemDropRate: number;
+    eliteChance: number;
+    bossEveryNFloors: number;
+}
+export declare const DEFAULT_ROGUELIKE_CONFIG: RoguelikeConfig;
+export type TileType = 'wall' | 'floor' | 'door' | 'stairs_up' | 'stairs_down' | 'water' | 'lava';
+export interface DungeonRoom {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    connected: boolean;
+}
+/** BSP dungeon generator. */
+export declare function generateDungeon(config: RoguelikeConfig): {
+    tiles: TileType[];
+    rooms: DungeonRoom[];
+};
+/** Simple FOV (field of view) via raycasting. */
+export declare function computeFOV(tiles: TileType[], mapWidth: number, cx: number, cy: number, radius: number): Set<number>;
+export interface DungeonCrawlerConfig {
+    /** First-person or top-down perspective. */
+    perspective: 'first-person' | 'top-down';
+    gridSize: number;
+    partySize: number;
+    automap: boolean;
+    trapChance: number;
+    secretWallChance: number;
+    encounterRate: number;
+    lootQualityScale: number;
+    puzzleFrequency: number;
+}
+export declare const DEFAULT_DUNGEON_CRAWLER_CONFIG: DungeonCrawlerConfig;
+export interface DungeonFloorDef {
+    floor: number;
+    theme: string;
+    width: number;
+    height: number;
+    encounters: string[];
+    boss: string | null;
+    lootTable: string;
+}