@nice2dev/game-engine 0.1.0

package/dist/types/ai/AI.d.ts

@@ -0,0 +1,140 @@
+import type { EntityId, Vec2 } from '../core/types';
+export type BTStatus = 'success' | 'failure' | 'running';
+export interface BTContext {
+    entityId: EntityId;
+    dt: number;
+    blackboard: Map<string, unknown>;
+}
+export interface BTNode {
+    name: string;
+    tick(ctx: BTContext): BTStatus;
+    reset(): void;
+}
+export declare class BTAction implements BTNode {
+    name: string;
+    private fn;
+    constructor(name: string, fn: (ctx: BTContext) => BTStatus);
+    tick(ctx: BTContext): BTStatus;
+    reset(): void;
+}
+export declare class BTCondition implements BTNode {
+    name: string;
+    private condition;
+    constructor(name: string, condition: (ctx: BTContext) => boolean);
+    tick(ctx: BTContext): BTStatus;
+    reset(): void;
+}
+export declare class BTSequence implements BTNode {
+    name: string;
+    children: BTNode[];
+    private currentIndex;
+    constructor(name: string, children: BTNode[]);
+    tick(ctx: BTContext): BTStatus;
+    reset(): void;
+}
+export declare class BTSelector implements BTNode {
+    name: string;
+    children: BTNode[];
+    private currentIndex;
+    constructor(name: string, children: BTNode[]);
+    tick(ctx: BTContext): BTStatus;
+    reset(): void;
+}
+export declare class BTParallel implements BTNode {
+    name: string;
+    children: BTNode[];
+    private successThreshold;
+    constructor(name: string, children: BTNode[], successThreshold?: number);
+    tick(ctx: BTContext): BTStatus;
+    reset(): void;
+}
+export declare class BTDecorator implements BTNode {
+    name: string;
+    child: BTNode;
+    private decorator;
+    constructor(name: string, child: BTNode, decorator: (result: BTStatus, ctx: BTContext) => BTStatus);
+    tick(ctx: BTContext): BTStatus;
+    reset(): void;
+}
+/** Inverter: success→failure, failure→success. */
+export declare function btInvert(child: BTNode): BTDecorator;
+/** Repeat N times or until failure. */
+export declare class BTRepeat implements BTNode {
+    name: string;
+    child: BTNode;
+    private maxRepeats;
+    private count;
+    constructor(name: string, child: BTNode, maxRepeats: number);
+    tick(ctx: BTContext): BTStatus;
+    reset(): void;
+}
+export interface SteeringAgent {
+    position: Vec2;
+    velocity: Vec2;
+    maxSpeed: number;
+    maxForce: number;
+}
+export declare function steerSeek(agent: SteeringAgent, target: Vec2): Vec2;
+export declare function steerFlee(agent: SteeringAgent, target: Vec2): Vec2;
+export declare function steerArrive(agent: SteeringAgent, target: Vec2, slowRadius: number): Vec2;
+export declare function steerWander(agent: SteeringAgent, wanderDistance: number, wanderRadius: number, wanderAngle: number): {
+    force: Vec2;
+    newAngle: number;
+};
+export declare function steerSeparation(agent: SteeringAgent, neighbors: Vec2[], radius: number): Vec2;
+export interface FSMState<T> {
+    name: string;
+    enter?(context: T): void;
+    update?(context: T, dt: number): void;
+    exit?(context: T): void;
+}
+export declare class FiniteStateMachine<T> {
+    private states;
+    private currentState;
+    private context;
+    constructor(context: T);
+    addState(state: FSMState<T>): void;
+    setState(name: string): void;
+    update(dt: number): void;
+    getCurrentState(): string | null;
+}
+export interface UtilityAction {
+    name: string;
+    score: (ctx: unknown) => number;
+    execute: (ctx: unknown) => void;
+}
+export declare function selectBestAction(actions: UtilityAction[], ctx: unknown): UtilityAction | null;
+export interface GOAPAction {
+    name: string;
+    cost: number;
+    preconditions: Record<string, boolean>;
+    effects: Record<string, boolean>;
+}
+export interface GOAPGoal {
+    name: string;
+    conditions: Record<string, boolean>;
+    priority: number;
+}
+export declare function planGOAP(worldState: Record<string, boolean>, goal: GOAPGoal, actions: GOAPAction[], maxDepth?: number): GOAPAction[] | null;
+export interface DialogNode {
+    id: string;
+    speakerId: string;
+    text: string;
+    responses: DialogResponse[];
+    condition?: string;
+    onEnter?: string;
+}
+export interface DialogResponse {
+    text: string;
+    nextNodeId: string;
+    condition?: string;
+    effect?: string;
+}
+export interface DialogTree {
+    id: string;
+    startNodeId: string;
+    nodes: Map<string, DialogNode>;
+}
+export declare function createDialogTree(id: string, nodes: DialogNode[]): DialogTree;
+/** Get available responses (filter by conditions using evaluator). */
+export declare function getAvailableResponses(tree: DialogTree, nodeId: string, evaluateCondition?: (condition: string) => boolean): DialogResponse[];

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

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

package/dist/types/animation/Animation.d.ts

@@ -0,0 +1,90 @@
+import type { Rect } from '../core/types';
+export interface AnimationFrame {
+    /** Source rect in the sprite sheet. */
+    srcRect: Rect;
+    /** Duration of this frame in seconds. */
+    duration: number;
+    /** Optional event to fire when this frame starts. */
+    event?: string;
+}
+export interface AnimationClip {
+    name: string;
+    frames: AnimationFrame[];
+    loop: boolean;
+    /** Playback speed multiplier (default 1). */
+    speed: number;
+}
+export type AnimationEventCallback = (clipName: string, eventName: string) => void;
+export type EasingFn = (t: number) => number;
+export declare const Easing: {
+    readonly linear: (t: number) => number;
+    readonly easeInQuad: (t: number) => number;
+    readonly easeOutQuad: (t: number) => number;
+    readonly easeInOutQuad: (t: number) => number;
+    readonly easeInCubic: (t: number) => number;
+    readonly easeOutCubic: (t: number) => number;
+    readonly easeInOutCubic: (t: number) => number;
+    readonly easeOutBounce: (t: number) => number;
+    readonly easeOutElastic: (t: number) => number;
+};
+export declare class SpriteAnimator {
+    private clips;
+    private currentClip;
+    private frameIndex;
+    private elapsed;
+    private playing;
+    private onEvent;
+    private finished;
+    get isPlaying(): boolean;
+    get isFinished(): boolean;
+    get currentClipName(): string | null;
+    get currentFrameIndex(): number;
+    addClip(clip: AnimationClip): void;
+    removeClip(name: string): void;
+    play(name: string, restart?: boolean): void;
+    stop(): void;
+    resume(): void;
+    setEventCallback(cb: AnimationEventCallback): void;
+    getCurrentFrame(): AnimationFrame | null;
+    update(dt: number): void;
+    private fireEvent;
+}
+export interface TweenConfig<T extends Record<string, number>> {
+    target: T;
+    from?: Partial<T>;
+    to: Partial<T>;
+    duration: number;
+    easing?: EasingFn;
+    delay?: number;
+    onComplete?: () => void;
+    onUpdate?: (t: number) => void;
+}
+export declare class TweenManager {
+    private tweens;
+    create<T extends Record<string, number>>(config: TweenConfig<T>): void;
+    update(dt: number): void;
+    clear(): void;
+    get count(): number;
+}
+export interface AnimState {
+    name: string;
+    clipName: string;
+}
+export interface AnimTransition {
+    from: string;
+    to: string;
+    condition: () => boolean;
+}
+export declare class AnimationStateMachine {
+    private states;
+    private transitions;
+    private current;
+    private animator;
+    constructor(animator: SpriteAnimator);
+    addState(name: string, clipName: string): void;
+    addTransition(from: string, to: string, condition: () => boolean): void;
+    get currentState(): string | null;
+    forceState(name: string): void;
+    update(): void;
+}
+export declare function createClipFromSheet(name: string, sheetColumns: number, startIndex: number, frameCount: number, frameWidth: number, frameHeight: number, frameDuration?: number, loop?: boolean): AnimationClip;

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

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

package/dist/types/audio/AudioAdvanced.d.ts

@@ -0,0 +1,190 @@
+export type WaveformType = 'sine' | 'square' | 'sawtooth' | 'triangle' | 'noise' | 'pulse';
+export interface OscillatorConfig {
+    waveform: WaveformType;
+    frequency: number;
+    amplitude: number;
+    phase: number;
+    detune: number;
+    pulseWidth?: number;
+}
+export interface EnvelopeADSR {
+    attack: number;
+    decay: number;
+    sustain: number;
+    release: number;
+}
+export declare const DEFAULT_ADSR: EnvelopeADSR;
+export interface SynthPatch {
+    name: string;
+    oscillators: OscillatorConfig[];
+    envelope: EnvelopeADSR;
+    filterType: 'lowpass' | 'highpass' | 'bandpass' | 'notch' | 'none';
+    filterFrequency: number;
+    filterResonance: number;
+    filterEnvelope?: EnvelopeADSR;
+    filterEnvAmount: number;
+    lfo?: LFOConfig;
+    gain: number;
+    pan: number;
+}
+export interface LFOConfig {
+    waveform: WaveformType;
+    frequency: number;
+    amplitude: number;
+    target: 'frequency' | 'amplitude' | 'filter' | 'pan';
+}
+/** Generate a single sample from an oscillator (for procedural audio). */
+export declare function oscillatorSample(config: OscillatorConfig, time: number): number;
+/** Compute ADSR envelope value at a given time. */
+export declare function adsrValue(env: EnvelopeADSR, time: number, noteOffTime: number | null): number;
+/** Preset synth patches. */
+export declare const SYNTH_PRESETS: Record<string, SynthPatch>;
+export type EffectType = 'reverb' | 'delay' | 'distortion' | 'chorus' | 'flanger' | 'phaser' | 'compressor' | 'equalizer' | 'tremolo' | 'bitcrusher' | 'limiter';
+export interface AudioEffect {
+    type: EffectType;
+    enabled: boolean;
+    wet: number;
+    params: Record<string, number>;
+}
+export interface ReverbParams {
+    roomSize: number;
+    damping: number;
+    preDelay: number;
+}
+export interface DelayParams {
+    time: number;
+    feedback: number;
+    pingPong: boolean;
+}
+export interface DistortionParams {
+    amount: number;
+    tone: number;
+}
+export interface ChorusParams {
+    rate: number;
+    depth: number;
+    delay: number;
+}
+export interface CompressorParams {
+    threshold: number;
+    ratio: number;
+    attack: number;
+    release: number;
+    knee: number;
+}
+export interface EQBand {
+    frequency: number;
+    gain: number;
+    q: number;
+    type: 'lowshelf' | 'highshelf' | 'peaking';
+}
+export declare function createReverb(roomSize?: number, damping?: number, wet?: number): AudioEffect;
+export declare function createDelay(time?: number, feedback?: number, wet?: number): AudioEffect;
+export declare function createDistortion(amount?: number, tone?: number, wet?: number): AudioEffect;
+export declare function createCompressor(threshold?: number, ratio?: number, attack?: number, release?: number): AudioEffect;
+export interface AudioEffectsChain {
+    effects: AudioEffect[];
+    masterGain: number;
+    masterPan: number;
+}
+export declare function createEffectsChain(effects?: AudioEffect[]): AudioEffectsChain;
+export type MusicLayerState = 'playing' | 'fading-in' | 'fading-out' | 'stopped';
+export interface MusicLayer {
+    id: string;
+    trackId: string;
+    volume: number;
+    loop: boolean;
+    syncToBar: boolean;
+    state: MusicLayerState;
+    fadeTime: number;
+    conditions: MusicCondition[];
+}
+export interface MusicCondition {
+    parameter: string;
+    operator: '=' | '!=' | '<' | '>' | '<=' | '>=';
+    value: number | string;
+}
+export interface MusicTransition {
+    fromState: string;
+    toState: string;
+    type: 'crossfade' | 'cut' | 'stinger' | 'musical';
+    duration: number;
+    stingerTrackId?: string;
+    syncPoint: 'immediate' | 'next-beat' | 'next-bar' | 'next-section';
+}
+export interface AdaptiveMusicConfig {
+    bpm: number;
+    beatsPerBar: number;
+    states: MusicState[];
+    transitions: MusicTransition[];
+    parameters: Map<string, number>;
+    currentState: string;
+}
+export interface MusicState {
+    name: string;
+    layers: MusicLayer[];
+    intensity: number;
+}
+export declare function evaluateMusicConditions(conditions: MusicCondition[], params: Map<string, number>): boolean;
+export declare function findNextMusicState(config: AdaptiveMusicConfig): string | null;
+/** Beat/bar timing helpers. */
+export declare function beatDuration(bpm: number): number;
+export declare function barDuration(bpm: number, beatsPerBar: number): number;
+export declare function currentBeat(time: number, bpm: number): number;
+export declare function nextBarTime(time: number, bpm: number, beatsPerBar: number): number;
+export interface AudioAnalysisConfig {
+    fftSize: 256 | 512 | 1024 | 2048 | 4096;
+    smoothingTimeConstant: number;
+    minDecibels: number;
+    maxDecibels: number;
+}
+export declare const DEFAULT_ANALYSIS_CONFIG: AudioAnalysisConfig;
+export interface AudioBands {
+    sub: number;
+    bass: number;
+    lowMid: number;
+    mid: number;
+    highMid: number;
+    presence: number;
+    brilliance: number;
+    overall: number;
+}
+export declare function extractBands(frequencyData: Uint8Array, sampleRate: number): AudioBands;
+export interface AudioReactiveBinding {
+    band: keyof AudioBands;
+    target: string;
+    min: number;
+    max: number;
+    smoothing: number;
+    sensitivity: number;
+}
+export interface VoiceChatConfig {
+    codec: 'opus' | 'pcm';
+    sampleRate: 16000 | 24000 | 48000;
+    bitrate: number;
+    channelCount: 1 | 2;
+    echoCancellation: boolean;
+    noiseSuppression: boolean;
+    autoGainControl: boolean;
+    vadEnabled: boolean;
+    vadThreshold: number;
+    spatialAudio: boolean;
+    maxDistance: number;
+    pushToTalk: boolean;
+    pushToTalkKey: string;
+    muteOnDeafen: boolean;
+}
+export declare const DEFAULT_VOICE_CONFIG: VoiceChatConfig;
+export interface VoiceParticipant {
+    peerId: string;
+    displayName: string;
+    isMuted: boolean;
+    isDeafened: boolean;
+    isSpeaking: boolean;
+    volume: number;
+    position?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}

package/dist/types/audio/AudioManager.d.ts

@@ -0,0 +1,55 @@
+import type { AudioChannel, Vec2 } from '../core/types';
+import { EventBus } from '../core/EventBus';
+export interface SoundOptions {
+    volume?: number;
+    loop?: boolean;
+    channel?: AudioChannel;
+    pitch?: number;
+    pan?: number;
+    position?: Vec2;
+    maxDistance?: number;
+}
+export interface MusicOptions {
+    volume?: number;
+    loop?: boolean;
+    fadeIn?: number;
+}
+export declare class AudioManager {
+    readonly events: EventBus;
+    private ctx;
+    private masterGain;
+    private channelGains;
+    private bufferCache;
+    private activeMusic;
+    private activeSounds;
+    private pool;
+    private _listenerPos;
+    private _muted;
+    private volumes;
+    /** Initialize audio context (must be called after user gesture). */
+    init(): void;
+    /** Ensure context is running (after autoplay policy). */
+    resume(): Promise<void>;
+    dispose(): void;
+    /** Load an audio file and cache its buffer. */
+    load(id: string, url: string): Promise<void>;
+    /** Check if a sound is loaded. */
+    isLoaded(id: string): boolean;
+    /** Play a sound effect. Returns an ID to control it. */
+    play(id: string, options?: SoundOptions): number;
+    /** Stop a specific playing sound. */
+    stopSound(soundId: number): void;
+    /** Play background music with optional crossfade. */
+    playMusic(id: string, options?: MusicOptions): void;
+    /** Stop music with fade out. */
+    stopMusic(fadeOut?: number): void;
+    private fadeOutMusic;
+    setVolume(channel: AudioChannel, volume: number): void;
+    getVolume(channel: AudioChannel): number;
+    get muted(): boolean;
+    set muted(value: boolean);
+    setListenerPosition(pos: Vec2): void;
+    /** Stop all sounds and music, properly disconnecting audio nodes. */
+    stopAll(): void;
+    get activeSoundCount(): number;
+}

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

@@ -0,0 +1 @@
+export { AudioManager, type SoundOptions, type MusicOptions, } from './AudioManager';

package/dist/types/community/Community.d.ts

@@ -0,0 +1,112 @@
+export interface CommunityConfig {
+    projectName: string;
+    repoUrl: string;
+    license: 'MIT' | 'Apache-2.0' | 'BSD-3-Clause' | 'GPL-3.0';
+    discordUrl?: string;
+    websiteUrl?: string;
+    maintainers: string[];
+}
+export interface GameJamEntry {
+    id: string;
+    title: string;
+    author: string;
+    description: string;
+    url: string;
+    thumbnailUrl: string;
+    tags: string[];
+    submittedAt: number;
+    rating: number;
+    votes: number;
+}
+export interface ShowcaseProject {
+    id: string;
+    title: string;
+    author: string;
+    description: string;
+    url: string;
+    thumbnailUrl: string;
+    engineVersion: string;
+    features: string[];
+    stars: number;
+}
+export interface CertificationLevel {
+    id: string;
+    name: string;
+    description: string;
+    requirements: string[];
+    badge: string;
+}
+export interface SecurityCheckItem {
+    id: string;
+    category: string;
+    description: string;
+    severity: 'critical' | 'high' | 'medium' | 'low';
+    passed: boolean;
+    notes?: string;
+}
+export interface RoadmapItem {
+    id: string;
+    title: string;
+    description: string;
+    status: 'planned' | 'in-progress' | 'completed' | 'deferred';
+    milestone: string;
+    priority: 'critical' | 'high' | 'medium' | 'low';
+    estimatedVersion: string;
+}
+export declare function generateContributing(config: CommunityConfig): string;
+export declare function generateCodeOfConduct(config: CommunityConfig): string;
+export declare class GameJamPlatform {
+    private entries;
+    private jamActive;
+    private jamTitle;
+    private jamTheme;
+    private jamDeadline;
+    createJam(title: string, theme: string, durationDays: number): void;
+    submit(entry: Omit<GameJamEntry, 'submittedAt' | 'rating' | 'votes'>): GameJamEntry | null;
+    vote(entryId: string, rating: number): boolean;
+    getLeaderboard(): GameJamEntry[];
+    getEntries(tag?: string): GameJamEntry[];
+    get info(): {
+        title: string;
+        theme: string;
+        active: boolean;
+        deadline: number;
+        entryCount: number;
+        timeRemaining: number;
+    };
+    endJam(): GameJamEntry[];
+}
+export declare class ShowcaseGallery {
+    private projects;
+    add(project: ShowcaseProject): void;
+    remove(id: string): boolean;
+    star(id: string): void;
+    getFeatured(count?: number): ShowcaseProject[];
+    getByFeature(feature: string): ShowcaseProject[];
+    search(query: string): ShowcaseProject[];
+    getAll(): ShowcaseProject[];
+}
+export declare const CERTIFICATION_LEVELS: CertificationLevel[];
+export declare function checkCertification(levelId: string, completedRequirements: string[]): {
+    eligible: boolean;
+    completed: number;
+    total: number;
+    missing: string[];
+};
+export declare const SECURITY_AUDIT_CHECKLIST: SecurityCheckItem[];
+export declare function runSecurityAudit(checks: SecurityCheckItem[]): {
+    passed: number;
+    failed: number;
+    criticalFailures: SecurityCheckItem[];
+    score: number;
+};
+export declare function generateGitHubActionsCI(config: CommunityConfig): string;
+export declare const V2_ROADMAP: RoadmapItem[];
+export declare function getRoadmapByMilestone(milestone: string): RoadmapItem[];
+export declare function getRoadmapProgress(): {
+    total: number;
+    completed: number;
+    inProgress: number;
+    planned: number;
+    percent: number;
+};

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

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

package/dist/types/core/EventBus.d.ts

@@ -0,0 +1,16 @@
+export type EventHandler<T = unknown> = (data: T) => void;
+export declare class EventBus {
+    private handlers;
+    /** Subscribe to an event. Returns unsubscribe function. */
+    on<T = unknown>(event: string, handler: EventHandler<T>): () => void;
+    /** Subscribe once — auto-removes after first call. */
+    once<T = unknown>(event: string, handler: EventHandler<T>): () => void;
+    /** Unsubscribe from an event. */
+    off<T = unknown>(event: string, handler: EventHandler<T>): void;
+    /** Emit an event to all subscribers. */
+    emit<T = unknown>(event: string, data: T): void;
+    /** Remove all handlers for an event, or all events if no arg. */
+    clear(event?: string): void;
+    /** Check if an event has any listeners. */
+    has(event: string): boolean;
+}

package/dist/types/core/GameClock.d.ts

@@ -0,0 +1,29 @@
+export declare class GameClock {
+    private _startTime;
+    private _elapsed;
+    private _delta;
+    private _frame;
+    private _timeScale;
+    private _paused;
+    private _fixedDelta;
+    constructor(fixedFps?: number);
+    /** Total elapsed time in seconds (affected by timeScale) */
+    get elapsed(): number;
+    /** Delta time for current frame in seconds */
+    get delta(): number;
+    /** Fixed timestep for physics */
+    get fixedDelta(): number;
+    /** Current frame number */
+    get frame(): number;
+    /** Time scale multiplier (0 = frozen, 1 = normal, 2 = 2x) */
+    get timeScale(): number;
+    set timeScale(value: number);
+    get paused(): boolean;
+    /** Real time since start in seconds (unaffected by timeScale) */
+    get realTime(): number;
+    /** Called each frame with raw delta */
+    tick(rawDelta: number): void;
+    pause(): void;
+    resume(): void;
+    reset(): void;
+}

package/dist/types/core/GameConfig.d.ts

@@ -0,0 +1,20 @@
+import type { GameSettings, PhysicsSettings, AudioSettings, RenderingSettings, DeepPartial } from './types';
+export declare const DEFAULT_PHYSICS: PhysicsSettings;
+export declare const DEFAULT_AUDIO: AudioSettings;
+export declare const DEFAULT_RENDERING: RenderingSettings;
+export declare const DEFAULT_SETTINGS: GameSettings;
+export declare class GameConfig {
+    private _settings;
+    constructor(overrides?: DeepPartial<GameSettings>);
+    get settings(): Readonly<GameSettings>;
+    get width(): number;
+    get height(): number;
+    get targetFps(): number;
+    get maxPlayers(): number;
+    get physics(): Readonly<PhysicsSettings>;
+    get audio(): Readonly<AudioSettings>;
+    get rendering(): Readonly<RenderingSettings>;
+    update(overrides: DeepPartial<GameSettings>): void;
+    toJSON(): GameSettings;
+    static fromJSON(json: GameSettings): GameConfig;
+}