@nice2dev/game-engine 1.3.12 → 1.3.14

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

@@ -1,131 +0,0 @@
-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

@@ -1,112 +0,0 @@
-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

@@ -1,182 +0,0 @@
-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

@@ -1,144 +0,0 @@
-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;