@nice2dev/game-engine 0.1.0

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

@@ -0,0 +1,162 @@
+import type { Vec2 } from '../core/types';
+export interface TopDownRacingConfig {
+    maxSpeed: number;
+    acceleration: number;
+    braking: number;
+    friction: number;
+    turnSpeed: number;
+    driftFactor: number;
+    boostMultiplier: number;
+    boostDuration: number;
+    lapCount: number;
+    maxPlayers: number;
+    aiCount: number;
+    collisionBounce: number;
+}
+export declare const DEFAULT_TOP_DOWN_RACING_CONFIG: TopDownRacingConfig;
+export interface RacerState {
+    position: Vec2;
+    angle: number;
+    speed: number;
+    lateralSpeed: number;
+    lap: number;
+    checkpoint: number;
+    boostTimer: number;
+    finished: boolean;
+    raceTime: number;
+}
+export declare function createRacerState(startPos: Vec2, startAngle: number): RacerState;
+export declare function updateRacer(state: RacerState, input: {
+    throttle: number;
+    steer: number;
+    brake: boolean;
+    boost: boolean;
+}, config: TopDownRacingConfig, dt: number): void;
+export interface TrackCheckpoint {
+    x: number;
+    y: number;
+    width: number;
+    angle: number;
+}
+export interface SideScrollerRacingConfig {
+    scrollSpeed: number;
+    laneCount: number;
+    laneWidth: number;
+    playerSpeed: number;
+    obstacleFrequency: number;
+    coinFrequency: number;
+    powerUpFrequency: number;
+    difficultyScale: number;
+    maxLives: number;
+    iFrameDuration: number;
+}
+export declare const DEFAULT_SIDE_SCROLLER_RACING_CONFIG: SideScrollerRacingConfig;
+export type SportType = 'soccer' | 'basketball' | 'hockey' | 'volleyball';
+export interface SportsConfig {
+    sport: SportType;
+    fieldWidth: number;
+    fieldHeight: number;
+    teamSize: number;
+    matchDuration: number;
+    halves: number;
+    ballSpeed: number;
+    playerSpeed: number;
+    sprintMultiplier: number;
+    staminaDrain: number;
+    staminaRegen: number;
+    goalWidth: number;
+    shotPower: number;
+    passAccuracy: number;
+    aiDifficulty: number;
+}
+export declare const DEFAULT_SOCCER_CONFIG: SportsConfig;
+export declare const DEFAULT_BASKETBALL_CONFIG: SportsConfig;
+export interface SportsState {
+    score: [number, number];
+    currentHalf: number;
+    timeRemaining: number;
+    possession: 0 | 1;
+    ballPosition: Vec2;
+    ballVelocity: Vec2;
+}
+export declare function createSportsState(config: SportsConfig): SportsState;
+export interface GolfConfig {
+    maxPower: number;
+    ballFriction: number;
+    ballRestitution: number;
+    windEnabled: boolean;
+    maxWind: number;
+    parPerHole: number;
+    holes: number;
+    strokeLimit: number;
+}
+export declare const DEFAULT_GOLF_CONFIG: GolfConfig;
+export interface BilliardsConfig {
+    tableWidth: number;
+    tableHeight: number;
+    ballRadius: number;
+    friction: number;
+    restitution: number;
+    maxPower: number;
+    pocketRadius: number;
+    gameType: '8ball' | '9ball' | 'snooker';
+}
+export declare const DEFAULT_BILLIARDS_CONFIG: BilliardsConfig;
+export interface BilliardsBall {
+    id: number;
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+    pocketed: boolean;
+    color: string;
+    stripe: boolean;
+}
+export declare function updateBilliardsBalls(balls: BilliardsBall[], config: BilliardsConfig, dt: number): void;
+export interface RhythmConfig {
+    laneCount: number;
+    noteSpeed: number;
+    hitWindowPerfect: number;
+    hitWindowGreat: number;
+    hitWindowGood: number;
+    scorePerfect: number;
+    scoreGreat: number;
+    scoreGood: number;
+    comboMultiplierStep: number;
+    maxMultiplier: number;
+    healthDrain: number;
+    healthRegen: number;
+    healthMax: number;
+}
+export declare const DEFAULT_RHYTHM_CONFIG: RhythmConfig;
+export type NoteType = 'tap' | 'hold' | 'slide' | 'flick';
+export interface RhythmNote {
+    time: number;
+    lane: number;
+    type: NoteType;
+    duration?: number;
+    hit: boolean;
+    hitResult: 'perfect' | 'great' | 'good' | 'miss' | null;
+}
+export interface RhythmChart {
+    songId: string;
+    bpm: number;
+    offset: number;
+    difficulty: number;
+    notes: RhythmNote[];
+}
+export interface RhythmState {
+    score: number;
+    combo: number;
+    maxCombo: number;
+    multiplier: number;
+    health: number;
+    perfects: number;
+    greats: number;
+    goods: number;
+    misses: number;
+    songTime: number;
+}
+export declare function createRhythmState(config: RhythmConfig): RhythmState;
+export declare function judgeHit(noteTime: number, hitTime: number, config: RhythmConfig): 'perfect' | 'great' | 'good' | 'miss';
+export declare function applyHitResult(state: RhythmState, result: 'perfect' | 'great' | 'good' | 'miss', config: RhythmConfig): void;

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

@@ -0,0 +1,264 @@
+import type { EntityId } from '../core/types';
+export interface TowerDefenseConfig {
+    tileSize: number;
+    gridWidth: number;
+    gridHeight: number;
+    startGold: number;
+    startLives: number;
+    waveCount: number;
+    waveInterval: number;
+    interWaveDelay: number;
+    sellRefundRate: number;
+    maxTowersPerType: number;
+    speedMultipliers: number[];
+}
+export declare const DEFAULT_TOWER_DEFENSE_CONFIG: TowerDefenseConfig;
+export type TowerTargeting = 'first' | 'last' | 'strongest' | 'weakest' | 'closest';
+export interface TowerDef {
+    id: string;
+    name: string;
+    cost: number;
+    range: number;
+    damage: number;
+    attackSpeed: number;
+    projectileSpeed: number;
+    aoe: boolean;
+    aoeRadius: number;
+    slowPercent: number;
+    slowDuration: number;
+    targeting: TowerTargeting;
+    upgradePath: string[];
+}
+export interface EnemyWaveDef {
+    waveNumber: number;
+    enemies: Array<{
+        enemyId: string;
+        count: number;
+        delay: number;
+        pathIndex: number;
+    }>;
+    reward: number;
+}
+export interface TDEnemyDef {
+    id: string;
+    name: string;
+    health: number;
+    speed: number;
+    armor: number;
+    reward: number;
+    flying: boolean;
+    special: 'none' | 'heal' | 'shield' | 'split' | 'boss';
+}
+export interface TDState {
+    gold: number;
+    lives: number;
+    wave: number;
+    score: number;
+    towers: Array<{
+        defId: string;
+        gridX: number;
+        gridY: number;
+        upgradeLevel: number;
+    }>;
+    inWave: boolean;
+    speed: number;
+}
+export declare function createTDState(config: TowerDefenseConfig): TDState;
+export interface RTSConfig {
+    mapWidth: number;
+    mapHeight: number;
+    maxPopulation: number;
+    startResources: RTSResources;
+    buildSpeed: number;
+    gatherRate: number;
+    fogOfWar: boolean;
+    maxSelectCount: number;
+    controlGroups: number;
+}
+export interface RTSResources {
+    gold: number;
+    wood: number;
+    food: number;
+    stone: number;
+}
+export declare const DEFAULT_RTS_CONFIG: RTSConfig;
+export type UnitCommand = 'move' | 'attack' | 'patrol' | 'hold' | 'gather' | 'build' | 'repair' | 'stop';
+export interface RTSUnitDef {
+    id: string;
+    name: string;
+    health: number;
+    damage: number;
+    attackSpeed: number;
+    range: number;
+    moveSpeed: number;
+    armor: number;
+    cost: RTSResources;
+    buildTime: number;
+    populationCost: number;
+    canGather: boolean;
+    canBuild: boolean;
+    abilities: string[];
+}
+export interface RTSBuildingDef {
+    id: string;
+    name: string;
+    health: number;
+    width: number;
+    height: number;
+    cost: RTSResources;
+    buildTime: number;
+    produces: string[];
+    researches: string[];
+    providesPopulation: number;
+    requiresBuilding: string | null;
+}
+export interface RTSState {
+    resources: RTSResources;
+    population: number;
+    maxPopulation: number;
+    selectedUnits: EntityId[];
+    controlGroups: Map<number, EntityId[]>;
+}
+export declare function createRTSState(config: RTSConfig): RTSState;
+export interface TacticsConfig {
+    gridWidth: number;
+    gridHeight: number;
+    maxUnitsPerSide: number;
+    movementType: 'manhattan' | 'diagonal';
+    heightLevels: number;
+    heightAdvantageBonus: number;
+    coverBonus: number;
+    flanking: boolean;
+    flankingBonus: number;
+    criticalHitChance: number;
+    initiativeSystem: boolean;
+    undoMoves: boolean;
+    turnTimeLimit: number;
+}
+export declare const DEFAULT_TACTICS_CONFIG: TacticsConfig;
+export interface TacticsUnitDef {
+    id: string;
+    name: string;
+    classType: string;
+    health: number;
+    moveRange: number;
+    attackRange: number;
+    damage: number;
+    defense: number;
+    initiative: number;
+    skills: TacticsSkillDef[];
+}
+export interface TacticsSkillDef {
+    id: string;
+    name: string;
+    range: number;
+    aoe: number;
+    damage: number;
+    cooldown: number;
+    mpCost: number;
+    effect: string;
+}
+export type TacticsTile = 'floor' | 'wall' | 'water' | 'cover_low' | 'cover_high' | 'stairs' | 'pit';
+export interface TacticsTurnOrder {
+    units: Array<{
+        entityId: EntityId;
+        initiative: number;
+        acted: boolean;
+    }>;
+    currentIndex: number;
+    turnNumber: number;
+}
+export declare function createTurnOrder(units: Array<{
+    entityId: EntityId;
+    initiative: number;
+}>): TacticsTurnOrder;
+export declare function nextUnit(order: TacticsTurnOrder): EntityId | null;
+export interface CityBuilderConfig {
+    gridWidth: number;
+    gridHeight: number;
+    startMoney: number;
+    taxRate: number;
+    populationGrowthRate: number;
+    demandCycle: number;
+    buildingCategories: string[];
+    happinessFactors: string[];
+    pollutionDecay: number;
+}
+export declare const DEFAULT_CITY_BUILDER_CONFIG: CityBuilderConfig;
+export interface CityBuildingDef {
+    id: string;
+    name: string;
+    category: string;
+    cost: number;
+    width: number;
+    height: number;
+    income: number;
+    upkeep: number;
+    populationCapacity: number;
+    jobCapacity: number;
+    happiness: number;
+    pollution: number;
+    powerRequired: number;
+    waterRequired: number;
+    requirements: string[];
+}
+export interface CityState {
+    money: number;
+    population: number;
+    happiness: number;
+    demand: {
+        residential: number;
+        commercial: number;
+        industrial: number;
+    };
+    buildings: Array<{
+        defId: string;
+        gridX: number;
+        gridY: number;
+    }>;
+    totalIncome: number;
+    totalUpkeep: number;
+}
+export declare function createCityState(config: CityBuilderConfig): CityState;
+export declare function updateCity(state: CityState, config: CityBuilderConfig, dt: number): void;
+export interface IdleConfig {
+    baseClickValue: number;
+    offlineProgressRate: number;
+    maxOfflineHours: number;
+    prestigeThreshold: number;
+    prestigeMultiplier: number;
+    autoSaveInterval: number;
+    notationStyle: 'standard' | 'scientific' | 'engineering';
+}
+export declare const DEFAULT_IDLE_CONFIG: IdleConfig;
+export interface IdleGeneratorDef {
+    id: string;
+    name: string;
+    baseCost: number;
+    costMultiplier: number;
+    baseOutput: number;
+    unlockAt: number;
+}
+export interface IdleUpgradeDef {
+    id: string;
+    name: string;
+    description: string;
+    cost: number;
+    targetGenerator: string;
+    multiplier: number;
+    purchased: boolean;
+}
+export interface IdleState {
+    currency: number;
+    totalEarned: number;
+    clickValue: number;
+    generators: Map<string, number>;
+    upgrades: Set<string>;
+    prestigeCount: number;
+    prestigeMultiplier: number;
+    lastSave: number;
+}
+export declare function createIdleState(): IdleState;
+export declare function getGeneratorCost(def: IdleGeneratorDef, owned: number): number;
+export declare function getIdleIncome(state: IdleState, defs: IdleGeneratorDef[]): number;
+export declare function formatNumber(n: number, style?: IdleConfig['notationStyle']): string;

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

@@ -0,0 +1,92 @@
+import { World } from '../ecs/World';
+import { type WaveConfig, type LootDrop } from '../procedural/Procedural';
+export interface WaveDefenseConfig {
+    arenaWidth: number;
+    arenaHeight: number;
+    playerSpeed: number;
+    bulletSpeed: number;
+    bulletCooldown: number;
+    baseEnemyHp: number;
+    enemyHpGrowth: number;
+    waveConfig: WaveConfig;
+    upgrades: UpgradeDef[];
+    lootDrops: LootDrop[];
+}
+export interface UpgradeDef {
+    id: string;
+    name: string;
+    description: string;
+    cost: number;
+    costGrowth: number;
+    maxLevel: number;
+    effect: UpgradeEffect;
+}
+export type UpgradeEffect = {
+    type: 'speed';
+    bonus: number;
+} | {
+    type: 'firerate';
+    bonus: number;
+} | {
+    type: 'damage';
+    bonus: number;
+} | {
+    type: 'health';
+    bonus: number;
+} | {
+    type: 'magnet';
+    bonus: number;
+};
+export declare const DEFAULT_WAVE_DEFENSE_CONFIG: WaveDefenseConfig;
+export interface WaveDefenseState {
+    phase: 'playing' | 'shop' | 'gameover';
+    wave: number;
+    score: number;
+    coins: number;
+    kills: number;
+    playerHp: number;
+    maxHp: number;
+    upgradeLevels: Record<string, number>;
+    /** Enemies remaining in current wave. */
+    enemiesRemaining: number;
+    /** Time survived. */
+    timeSurvived: number;
+}
+export declare class WaveDefenseTemplate {
+    private config;
+    private rng;
+    private waveGen;
+    private lootTable;
+    private state;
+    private _moveSpeed;
+    private _bulletCooldown;
+    private _damage;
+    private _magnetRange;
+    private _cooldownTimer;
+    constructor(config?: Partial<WaveDefenseConfig>, seed?: number);
+    getState(): Readonly<WaveDefenseState>;
+    setupScene(world: World, playerCount?: number): void;
+    private createPlayer;
+    private createWall;
+    nextWave(world: World): void;
+    private spawnTimers;
+    private scheduleSpawnGroup;
+    private spawnEnemy;
+    update(world: World, dt: number, inputActions: {
+        moveX: number;
+        moveY: number;
+    }[]): void;
+    private spawnBullet;
+    onBulletHitEnemy(world: World, bulletId: number, enemyId: number): void;
+    onEnemyHitPlayer(world: World, enemyId: number, _playerId: number): void;
+    getAvailableUpgrades(): (UpgradeDef & {
+        currentLevel: number;
+        currentCost: number;
+    })[];
+    buyUpgrade(upgradeId: string): boolean;
+    private recalcStats;
+    /** After the shop phase, start the next wave. */
+    startNextWave(world: World): void;
+    /** Reset the game entirely. */
+    reset(world: World, playerCount?: number): void;
+}

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

@@ -0,0 +1,2 @@
+export { WaveDefenseTemplate, DEFAULT_WAVE_DEFENSE_CONFIG } from './WaveDefense';
+export type { WaveDefenseConfig, WaveDefenseState, UpgradeDef, UpgradeEffect } from './WaveDefense';

package/dist/types/tilemap/Tilemap.d.ts

@@ -0,0 +1,66 @@
+import type { Vec2, Rect } from '../core/types';
+export interface TileDef {
+    id: number;
+    name: string;
+    /** Source rect in the tileset spritesheet. */
+    srcRect: Rect;
+    solid: boolean;
+    /** Collision shape override (aabb by default). */
+    collisionShape?: 'none' | 'full' | 'half-top' | 'half-bottom' | 'slope-left' | 'slope-right';
+    /** Custom properties. */
+    properties?: Record<string, unknown>;
+}
+export interface TilesetDef {
+    name: string;
+    imageId: string;
+    tileWidth: number;
+    tileHeight: number;
+    columns: number;
+    tiles: TileDef[];
+}
+export interface TilemapLayer {
+    name: string;
+    visible: boolean;
+    opacity: number;
+    /** 2D array: data[y][x] = tileId (0 = empty). */
+    data: number[][];
+}
+export interface TilemapData {
+    width: number;
+    height: number;
+    tileWidth: number;
+    tileHeight: number;
+    tilesetId: string;
+    layers: TilemapLayer[];
+}
+export declare class Tilemap {
+    readonly width: number;
+    readonly height: number;
+    readonly tileWidth: number;
+    readonly tileHeight: number;
+    private layers;
+    private tileset;
+    constructor(width: number, height: number, tileWidth?: number, tileHeight?: number);
+    get pixelWidth(): number;
+    get pixelHeight(): number;
+    setTileset(ts: TilesetDef): void;
+    getTileset(): TilesetDef | null;
+    addLayer(name: string): TilemapLayer;
+    getLayer(name: string): TilemapLayer | undefined;
+    getLayers(): TilemapLayer[];
+    getTile(layerName: string, x: number, y: number): number;
+    setTile(layerName: string, x: number, y: number, tileId: number): void;
+    /** Fill a rectangle with a tile. */
+    fillRect(layerName: string, x: number, y: number, w: number, h: number, tileId: number): void;
+    /** Flood fill from a position. */
+    floodFill(layerName: string, x: number, y: number, tileId: number): void;
+    worldToTile(worldX: number, worldY: number): Vec2;
+    tileToWorld(tileX: number, tileY: number): Vec2;
+    isSolid(tileX: number, tileY: number): boolean;
+    /** Get all solid tiles overlapping a world-space AABB. */
+    getSolidTilesInRect(rect: Rect): Vec2[];
+    render(ctx: CanvasRenderingContext2D, tilesetImage: HTMLImageElement | HTMLCanvasElement, camera: Rect): void;
+    toJSON(): TilemapData;
+    static fromJSON(data: TilemapData): Tilemap;
+}
+export declare function computeAutoTileMask(map: Tilemap, layerName: string, x: number, y: number): number;

package/dist/types/tilemap/index.d.ts

@@ -0,0 +1 @@
+export * from './Tilemap';