@nice2dev/game-engine 1.1.5 → 1.1.6

package/dist/types/systems/NiceCombo.d.ts

@@ -0,0 +1,131 @@
+import { EventEmitter } from 'events';
+export type ComboId = string;
+export type InputId = string;
+export type ActionId = string;
+export type EntityId = string;
+export interface InputDefinition {
+    id: InputId;
+    name: string;
+    aliases?: string[];
+}
+export interface ComboStep {
+    inputs: InputId[];
+    timing?: TimingWindow;
+    action?: ActionId;
+    canCancel?: ActionId[];
+    holdDuration?: number;
+    release?: boolean;
+}
+export interface TimingWindow {
+    minDelay: number;
+    maxDelay: number;
+}
+export interface ComboDefinition {
+    id: ComboId;
+    name: string;
+    steps: ComboStep[];
+    priority?: number;
+    requirements?: ComboRequirements;
+    result: ComboResult;
+    tags?: string[];
+}
+export interface ComboRequirements {
+    minComboCount?: number;
+    minMeter?: number;
+    state?: string;
+    airborne?: boolean;
+    grounded?: boolean;
+}
+export interface ComboResult {
+    action: ActionId;
+    damage?: number;
+    meterGain?: number;
+    hitstun?: number;
+    knockback?: number;
+    properties?: Record<string, unknown>;
+}
+export interface BufferedInput {
+    inputId: InputId;
+    timestamp: number;
+    pressed: boolean;
+    released: boolean;
+    held: boolean;
+    holdDuration: number;
+}
+export interface ComboState {
+    entityId: EntityId;
+    currentCombo?: ComboId;
+    currentStep: number;
+    comboCount: number;
+    meter: number;
+    maxMeter: number;
+    multiplier: number;
+    inputBuffer: BufferedInput[];
+    lastActionTime: number;
+    inRecovery: boolean;
+    canCancel: boolean;
+}
+export interface ComboMatch {
+    comboId: ComboId;
+    matchedAt: number;
+    confidence: number;
+}
+export type ComboEventType = 'input-buffered' | 'combo-started' | 'combo-step' | 'combo-completed' | 'combo-dropped' | 'combo-extended' | 'meter-changed' | 'multiplier-changed';
+export interface ComboEvent {
+    type: ComboEventType;
+    entityId: EntityId;
+    comboId?: ComboId;
+    step?: number;
+    comboCount?: number;
+    meter?: number;
+    multiplier?: number;
+}
+export interface ComboConfig {
+    bufferDuration?: number;
+    defaultTimingWindow?: TimingWindow;
+    maxComboCount?: number;
+    maxMeter?: number;
+    baseMultiplier?: number;
+    multiplierPerHit?: number;
+    dropTimeWindow?: number;
+    inputLeniency?: number;
+}
+export declare const DEFAULT_COMBO_CONFIG: ComboConfig;
+export declare class NiceCombo extends EventEmitter {
+    private inputs;
+    private combos;
+    private entities;
+    private config;
+    constructor(config?: Partial<ComboConfig>);
+    registerInput(input: InputDefinition): void;
+    unregisterInput(inputId: InputId): boolean;
+    registerCombo(combo: ComboDefinition): void;
+    unregisterCombo(comboId: ComboId): boolean;
+    getCombo(comboId: ComboId): ComboDefinition | undefined;
+    registerEntity(entityId: EntityId): void;
+    unregisterEntity(entityId: EntityId): boolean;
+    getState(entityId: EntityId): ComboState | undefined;
+    bufferInput(entityId: EntityId, inputId: InputId, pressed: boolean, released?: boolean): void;
+    private processBuffer;
+    private matchStep;
+    private findMatches;
+    private meetsRequirements;
+    private startCombo;
+    private advanceStep;
+    private completeCombo;
+    dropCombo(entityId: EntityId): void;
+    canCancel(entityId: EntityId, intoAction: ActionId): boolean;
+    cancel(entityId: EntityId): void;
+    addMeter(entityId: EntityId, amount: number): void;
+    useMeter(entityId: EntityId, amount: number): boolean;
+    getMeter(entityId: EntityId): number;
+    getComboCount(entityId: EntityId): number;
+    getMultiplier(entityId: EntityId): number;
+    getCurrentCombo(entityId: EntityId): ComboDefinition | undefined;
+    isInCombo(entityId: EntityId): boolean;
+    update(_deltaTime: number): void;
+}
+export declare function createComboSystem(config?: Partial<ComboConfig>): NiceCombo;
+export declare function defineCombo(id: ComboId, name: string, steps: ComboStep[], result: ComboResult, options?: Partial<Omit<ComboDefinition, 'id' | 'name' | 'steps' | 'result'>>): ComboDefinition;
+export declare function step(inputs: InputId[], action?: ActionId, options?: Partial<Omit<ComboStep, 'inputs' | 'action'>>): ComboStep;
+export default NiceCombo;

package/dist/types/systems/NiceCommand.d.ts

@@ -0,0 +1,112 @@
+export type CommandId = string;
+export interface Command {
+    id: CommandId;
+    name: string;
+    description?: string;
+    timestamp: number;
+    execute(): void;
+    undo(): void;
+    redo?(): void;
+    canMerge?(other: Command): boolean;
+    merge?(other: Command): Command;
+}
+export interface CommandHistoryEntry {
+    command: Command;
+    timestamp: number;
+    merged: boolean;
+}
+export interface Transaction {
+    id: string;
+    name: string;
+    commands: Command[];
+    active: boolean;
+    timestamp: number;
+}
+export type CommandEventType = 'command-executed' | 'command-undone' | 'command-redone' | 'history-changed' | 'transaction-started' | 'transaction-committed' | 'transaction-rolled-back';
+export interface CommandEvent {
+    type: CommandEventType;
+    timestamp: number;
+    command?: Command;
+    data?: unknown;
+}
+export type CommandEventCallback = (event: CommandEvent) => void;
+export interface CommandConfig {
+    maxHistory: number;
+    enableMerging: boolean;
+    mergeTimeout: number;
+}
+export declare const DEFAULT_COMMAND_CONFIG: CommandConfig;
+export declare abstract class BaseCommand implements Command {
+    readonly id: CommandId;
+    readonly name: string;
+    readonly description?: string;
+    readonly timestamp: number;
+    constructor(name: string, description?: string);
+    abstract execute(): void;
+    abstract undo(): void;
+    redo(): void;
+}
+export declare class FunctionCommand extends BaseCommand {
+    private executeFn;
+    private undoFn;
+    constructor(name: string, executeFn: () => void, undoFn: () => void, description?: string);
+    execute(): void;
+    undo(): void;
+}
+export declare class PropertyCommand<T, K extends keyof T> extends BaseCommand {
+    private target;
+    private property;
+    private oldValue;
+    private newValue;
+    constructor(target: T, property: K, newValue: T[K], name?: string);
+    execute(): void;
+    undo(): void;
+    canMerge(other: Command): boolean;
+    merge(other: Command): Command;
+}
+export declare class BatchCommand extends BaseCommand {
+    private commands;
+    constructor(commands: Command[], name?: string);
+    execute(): void;
+    undo(): void;
+    getCommands(): Command[];
+}
+export declare class NiceCommand {
+    private config;
+    private undoStack;
+    private redoStack;
+    private activeTransaction;
+    private eventListeners;
+    private lastCommandTime;
+    constructor(config?: Partial<CommandConfig>);
+    on(event: CommandEventType, callback: CommandEventCallback): () => void;
+    private emit;
+    execute(command: Command): void;
+    run(name: string, executeFn: () => void, undoFn: () => void): void;
+    setProperty<T, K extends keyof T>(target: T, property: K, value: T[K]): void;
+    batch(commands: Command[], name?: string): void;
+    undo(): boolean;
+    redo(): boolean;
+    undoMultiple(count: number): number;
+    redoMultiple(count: number): number;
+    beginTransaction(name: string): string;
+    commitTransaction(): void;
+    rollbackTransaction(): void;
+    isInTransaction(): boolean;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    getUndoCount(): number;
+    getRedoCount(): number;
+    getUndoStack(): Command[];
+    getRedoStack(): Command[];
+    getLastCommand(): Command | null;
+    getHistory(): CommandHistoryEntry[];
+    clear(): void;
+    clearRedo(): void;
+    destroy(): void;
+}
+export declare function createCommandSystem(config?: Partial<CommandConfig>): NiceCommand;
+export declare function createCommand(name: string, execute: () => void, undo: () => void): Command;
+export declare function createPropertyCommand<T, K extends keyof T>(target: T, property: K, value: T[K]): Command;
+export declare function createBatchCommand(commands: Command[], name?: string): Command;
+export declare function undoable(target: object, propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;

package/dist/types/systems/NiceCompanion.d.ts

@@ -0,0 +1,182 @@
+export type CompanionId = string;
+export type AbilityId = string;
+export type PersonalityTrait = string;
+export type CompanionState = 'inactive' | 'active' | 'traveling' | 'waiting' | 'combat' | 'dead';
+export type BehaviorMode = 'follow' | 'stay' | 'aggressive' | 'defensive' | 'passive' | 'support';
+export type RelationshipLevel = 'stranger' | 'acquaintance' | 'friend' | 'close_friend' | 'companion' | 'soulmate';
+export interface CompanionStats {
+    health: number;
+    maxHealth: number;
+    stamina: number;
+    maxStamina: number;
+    attack: number;
+    defense: number;
+    speed: number;
+    level: number;
+    experience: number;
+}
+export interface CompanionAbility {
+    id: AbilityId;
+    name: string;
+    description: string;
+    cooldown: number;
+    cost: number;
+    damage?: number;
+    healing?: number;
+    effect?: string;
+    unlockLevel: number;
+}
+export interface CompanionDefinition {
+    id: CompanionId;
+    name: string;
+    title?: string;
+    description: string;
+    portrait?: string;
+    model?: string;
+    baseStats: Omit<CompanionStats, 'level' | 'experience'>;
+    statsPerLevel: Partial<CompanionStats>;
+    maxLevel: number;
+    personality: PersonalityTrait[];
+    likes: string[];
+    dislikes: string[];
+    abilities: CompanionAbility[];
+    synergies?: Array<{
+        companionId: CompanionId;
+        bonusName: string;
+        bonusEffect: Record<string, number>;
+    }>;
+    recruitmentQuest?: string;
+    recruitmentCost?: {
+        type: string;
+        amount: number;
+    };
+    minPlayerLevel?: number;
+    voiceId?: string;
+    dialogueSet?: string;
+    tags?: string[];
+}
+export interface CompanionInstance {
+    companionId: CompanionId;
+    stats: CompanionStats;
+    currentHealth: number;
+    currentStamina: number;
+    state: CompanionState;
+    behaviorMode: BehaviorMode;
+    position: {
+        x: number;
+        y: number;
+        z?: number;
+    };
+    targetPosition?: {
+        x: number;
+        y: number;
+        z?: number;
+    };
+    affinity: number;
+    relationshipLevel: RelationshipLevel;
+    giftHistory: Array<{
+        itemId: string;
+        time: number;
+    }>;
+    conversationCount: number;
+    abilityCooldowns: Map<AbilityId, number>;
+    combatTarget?: string;
+    equipment?: Record<string, string>;
+    unlockedAbilities: AbilityId[];
+    perks?: string[];
+}
+export interface GiftPreference {
+    itemId: string;
+    affinityGain: number;
+    reaction: 'love' | 'like' | 'neutral' | 'dislike' | 'hate';
+}
+export interface RelationshipTier {
+    level: RelationshipLevel;
+    minAffinity: number;
+    bonuses: Record<string, number>;
+    unlocksDialogue?: string[];
+    unlocksQuest?: string;
+}
+export declare const DEFAULT_RELATIONSHIP_TIERS: RelationshipTier[];
+export type CompanionEventType = 'companion-recruited' | 'companion-dismissed' | 'companion-activated' | 'companion-deactivated' | 'companion-leveled' | 'companion-ability-unlocked' | 'companion-ability-used' | 'companion-damaged' | 'companion-healed' | 'companion-died' | 'companion-revived' | 'affinity-changed' | 'relationship-leveled' | 'gift-given' | 'behavior-changed';
+export interface CompanionEvent {
+    type: CompanionEventType;
+    timestamp: number;
+    companionId: CompanionId;
+    data?: unknown;
+}
+export type CompanionEventCallback = (event: CompanionEvent) => void;
+export interface CompanionConfig {
+    maxActiveCompanions: number;
+    maxRecruitedCompanions: number;
+    experiencePerLevel: number[];
+    affinityDecayRate: number;
+    dailyGiftLimit: number;
+    reviveCost?: {
+        type: string;
+        amount: number;
+    };
+    storageKey: string;
+}
+export declare const DEFAULT_COMPANION_CONFIG: CompanionConfig;
+export declare class NiceCompanion {
+    private config;
+    private definitions;
+    private giftPreferences;
+    private relationshipTiers;
+    private recruited;
+    private active;
+    private eventListeners;
+    constructor(config?: Partial<CompanionConfig>);
+    on(event: CompanionEventType, callback: CompanionEventCallback): () => void;
+    private emit;
+    registerCompanion(def: CompanionDefinition): void;
+    registerGiftPreferences(companionId: CompanionId, preferences: GiftPreference[]): void;
+    setRelationshipTiers(tiers: RelationshipTier[]): void;
+    recruit(companionId: CompanionId): boolean;
+    dismiss(companionId: CompanionId): boolean;
+    activate(companionId: CompanionId): boolean;
+    deactivate(companionId: CompanionId): boolean;
+    setBehavior(companionId: CompanionId, mode: BehaviorMode): boolean;
+    setPosition(companionId: CompanionId, position: {
+        x: number;
+        y: number;
+        z?: number;
+    }): void;
+    setTarget(companionId: CompanionId, target: {
+        x: number;
+        y: number;
+        z?: number;
+    } | undefined): void;
+    damage(companionId: CompanionId, amount: number): number;
+    heal(companionId: CompanionId, amount: number): number;
+    revive(companionId: CompanionId, healthPercent?: number): boolean;
+    useAbility(companionId: CompanionId, abilityId: AbilityId): boolean;
+    addExperience(companionId: CompanionId, amount: number): boolean;
+    private levelUp;
+    changeAffinity(companionId: CompanionId, amount: number): void;
+    giveGift(companionId: CompanionId, itemId: string): {
+        success: boolean;
+        reaction: string;
+        affinityGain: number;
+    };
+    private getRelationshipLevelForAffinity;
+    getRelationshipTier(companionId: CompanionId): RelationshipTier | undefined;
+    getActiveSynergies(): Array<{
+        companions: CompanionId[];
+        bonusName: string;
+        effects: Record<string, number>;
+    }>;
+    getCompanion(companionId: CompanionId): CompanionInstance | undefined;
+    getDefinition(companionId: CompanionId): CompanionDefinition | undefined;
+    getRecruited(): CompanionInstance[];
+    getActive(): CompanionInstance[];
+    isRecruited(companionId: CompanionId): boolean;
+    isActive(companionId: CompanionId): boolean;
+    update(deltaTime: number): void;
+    private save;
+    private load;
+    reset(): void;
+    destroy(): void;
+}
+export declare function createCompanionSystem(config?: Partial<CompanionConfig>): NiceCompanion;

package/dist/types/systems/NiceController.d.ts

@@ -0,0 +1,144 @@
+export type ControllerId = number;
+export type ProfileId = string;
+export type StandardButton = 'a' | 'b' | 'x' | 'y' | 'lb' | 'rb' | 'lt' | 'rt' | 'back' | 'start' | 'ls' | 'rs' | 'dpad-up' | 'dpad-down' | 'dpad-left' | 'dpad-right' | 'home';
+export type StandardAxis = 'left-x' | 'left-y' | 'right-x' | 'right-y';
+export interface ButtonState {
+    pressed: boolean;
+    touched: boolean;
+    value: number;
+    justPressed: boolean;
+    justReleased: boolean;
+    heldTime: number;
+}
+export interface AxisState {
+    raw: number;
+    value: number;
+    deadzone: number;
+    inverted: boolean;
+    sensitivity: number;
+}
+export interface ControllerState {
+    id: ControllerId;
+    connected: boolean;
+    name: string;
+    mapping: string;
+    buttons: Map<StandardButton, ButtonState>;
+    axes: Map<StandardAxis, AxisState>;
+    lastActiveTime: number;
+    profileId?: ProfileId;
+    vibrating: boolean;
+}
+export interface StickVector {
+    x: number;
+    y: number;
+    magnitude: number;
+    angle: number;
+}
+export interface InputProfile {
+    id: ProfileId;
+    name: string;
+    buttonMappings: Map<StandardButton, StandardButton>;
+    axisDeadzones: Map<StandardAxis, number>;
+    axisInversions: Map<StandardAxis, boolean>;
+    axisSensitivities: Map<StandardAxis, number>;
+    triggerThreshold: number;
+}
+export interface VibrationPattern {
+    duration: number;
+    strongMagnitude: number;
+    weakMagnitude: number;
+}
+export interface VibrationSequence {
+    patterns: VibrationPattern[];
+    loop: boolean;
+}
+export interface ActionBinding {
+    action: string;
+    button?: StandardButton;
+    axis?: StandardAxis;
+    axisDirection?: 'positive' | 'negative';
+    threshold?: number;
+}
+export type ControllerEventType = 'controller-connected' | 'controller-disconnected' | 'button-pressed' | 'button-released' | 'button-held' | 'axis-changed' | 'stick-moved' | 'trigger-pressed' | 'trigger-released' | 'action-triggered' | 'vibration-started' | 'vibration-stopped';
+export interface ControllerEvent {
+    type: ControllerEventType;
+    timestamp: number;
+    controllerId?: ControllerId;
+    data?: unknown;
+}
+export type ControllerEventCallback = (event: ControllerEvent) => void;
+export interface ControllerConfig {
+    /** Default deadzone for sticks */
+    defaultDeadzone: number;
+    /** Default trigger threshold */
+    defaultTriggerThreshold: number;
+    /** Button hold time (ms) to trigger held event */
+    holdTime: number;
+    /** Enable vibration */
+    enableVibration: boolean;
+    /** Max controllers to track */
+    maxControllers: number;
+    /** Polling interval (ms, 0 = use requestAnimationFrame) */
+    pollingInterval: number;
+    /** Enable virtual gamepad */
+    enableVirtualGamepad: boolean;
+}
+export declare const DEFAULT_CONTROLLER_CONFIG: ControllerConfig;
+export declare class NiceController {
+    private config;
+    private controllers;
+    private profiles;
+    private actionBindings;
+    private previousButtonStates;
+    private running;
+    private animationFrameId?;
+    private pollTimerId?;
+    private virtualGamepad?;
+    private eventListeners;
+    constructor(config?: Partial<ControllerConfig>);
+    on(event: ControllerEventType, callback: ControllerEventCallback): () => void;
+    private emit;
+    private createDefaultProfile;
+    private initVirtualGamepad;
+    setVirtualButton(button: StandardButton, pressed: boolean): void;
+    setVirtualAxis(axis: StandardAxis, value: number): void;
+    private createControllerState;
+    createProfile(id: ProfileId, name: string, options?: Partial<InputProfile>): InputProfile;
+    setControllerProfile(controllerId: ControllerId, profileId: ProfileId): void;
+    getProfile(profileId: ProfileId): InputProfile | undefined;
+    bindAction(action: string, binding: Omit<ActionBinding, 'action'>): void;
+    unbindAction(action: string): void;
+    clearBindings(): void;
+    isActionPressed(action: string, controllerId?: ControllerId): boolean;
+    getActionValue(action: string, controllerId?: ControllerId): number;
+    start(): void;
+    private poll;
+    stop(): void;
+    private scanGamepads;
+    private onGamepadConnected;
+    private onGamepadDisconnected;
+    private addController;
+    private removeController;
+    update(): void;
+    private updateVirtualGamepad;
+    private applyDeadzone;
+    private checkActionTriggers;
+    getController(controllerId: ControllerId): ControllerState | undefined;
+    getControllers(): ControllerState[];
+    getConnectedCount(): number;
+    isButtonPressed(controllerId: ControllerId, button: StandardButton): boolean;
+    isButtonJustPressed(controllerId: ControllerId, button: StandardButton): boolean;
+    getButtonValue(controllerId: ControllerId, button: StandardButton): number;
+    getAxisValue(controllerId: ControllerId, axis: StandardAxis): number;
+    getStick(controllerId: ControllerId, stick: 'left' | 'right'): StickVector | null;
+    vibrate(controllerId: ControllerId, duration: number, options?: {
+        strong?: number;
+        weak?: number;
+    }): void;
+    vibratePattern(controllerId: ControllerId, sequence: VibrationSequence): void;
+    private playVibrationSequence;
+    private vibrateGamepad;
+    stopVibration(controllerId: ControllerId): void;
+    destroy(): void;
+}
+export declare function createControllerSystem(config?: Partial<ControllerConfig>): NiceController;