@nice2dev/game-engine 1.1.5 → 1.1.6

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

@@ -0,0 +1,225 @@
+export type EntityId = string;
+export type AbilityId = string;
+export type ResourceId = string;
+export type UpgradeId = string;
+export type ComboId = string;
+export interface ResourceDefinition {
+    id: ResourceId;
+    name: string;
+    color?: string;
+    maxValue: number;
+    regeneration: number;
+    /** Regen only when not casting */
+    regenOutOfCombat: boolean;
+}
+export interface EntityResources {
+    [resourceId: string]: {
+        current: number;
+        max: number;
+        regen: number;
+    };
+}
+export type TargetingType = 'self' | 'single-enemy' | 'single-ally' | 'single-any' | 'aoe-position' | 'aoe-enemy' | 'aoe-ally' | 'aoe-all' | 'cone' | 'line' | 'none';
+export interface TargetingConfig {
+    type: TargetingType;
+    range: number;
+    radius?: number;
+    angle?: number;
+    width?: number;
+    length?: number;
+    maxTargets?: number;
+    requiresLineOfSight?: boolean;
+    piercing?: boolean;
+}
+export type AbilityType = 'active' | 'passive' | 'toggle' | 'channeled';
+export interface AbilityCost {
+    resourceId: ResourceId;
+    amount: number;
+    /** Cost per second for channeled */
+    perSecond?: number;
+}
+export interface AbilityEffect {
+    type: string;
+    value: number;
+    duration?: number;
+    scaling?: {
+        stat: string;
+        ratio: number;
+    }[];
+    [key: string]: unknown;
+}
+export interface AbilityDefinition {
+    id: AbilityId;
+    name: string;
+    description: string;
+    icon?: string;
+    type: AbilityType;
+    /** Resource costs */
+    costs: AbilityCost[];
+    /** Cooldown in seconds */
+    cooldown: number;
+    /** Max charges (0 = no charges) */
+    maxCharges: number;
+    /** Charge recharge time */
+    chargeRechargeTime: number;
+    /** Cast time (0 = instant) */
+    castTime: number;
+    /** Can cast while moving */
+    castWhileMoving: boolean;
+    /** Interruptible */
+    interruptible: boolean;
+    /** Channel duration (for channeled abilities) */
+    channelDuration?: number;
+    /** Channel ticks */
+    channelTicks?: number;
+    /** Global cooldown */
+    triggersGlobalCooldown: boolean;
+    globalCooldownDuration?: number;
+    /** Targeting configuration */
+    targeting: TargetingConfig;
+    /** Effects applied */
+    effects: AbilityEffect[];
+    /** Tags for filtering */
+    tags: string[];
+    /** Unlock level */
+    unlockLevel: number;
+    /** Animation to play */
+    animation?: string;
+    /** Sound to play */
+    sound?: string;
+    /** Visual effect */
+    vfx?: string;
+    /** Combo chain info */
+    comboChain?: ComboId;
+    comboWindow?: number;
+}
+export interface AbilityState {
+    abilityId: AbilityId;
+    currentCooldown: number;
+    charges: number;
+    chargeRechargeTimer: number;
+    isToggled: boolean;
+    upgrades: UpgradeId[];
+    /** Combo state */
+    comboStep: number;
+    comboTimer: number;
+}
+export interface CastState {
+    abilityId: AbilityId;
+    casterId: EntityId;
+    targetId?: EntityId;
+    targetPosition?: {
+        x: number;
+        y: number;
+        z?: number;
+    };
+    castProgress: number;
+    castDuration: number;
+    channelProgress?: number;
+    channelDuration?: number;
+    currentTick?: number;
+    isCasting: boolean;
+    isChanneling: boolean;
+    startTime: number;
+}
+export interface AbilityUpgrade {
+    id: UpgradeId;
+    abilityId: AbilityId;
+    name: string;
+    description: string;
+    icon?: string;
+    /** Effects modified */
+    modifiers: {
+        property: string;
+        operation: 'add' | 'multiply' | 'set';
+        value: number;
+    }[];
+    /** Prerequisites */
+    prerequisites: UpgradeId[];
+    cost: number;
+}
+export interface ComboDefinition {
+    id: ComboId;
+    name: string;
+    /** Abilities in sequence */
+    abilities: AbilityId[];
+    /** Window to continue combo */
+    comboWindow: number;
+    /** Bonus on completion */
+    finisherBonus?: AbilityEffect;
+}
+export type AbilityEventType = 'ability-cast-start' | 'ability-cast-complete' | 'ability-cast-interrupted' | 'ability-channel-start' | 'ability-channel-tick' | 'ability-channel-complete' | 'ability-cooldown-start' | 'ability-cooldown-ready' | 'ability-charge-gained' | 'ability-toggled' | 'ability-upgraded' | 'combo-advanced' | 'combo-completed' | 'combo-broken' | 'resource-changed' | 'global-cooldown-start';
+export interface AbilityEvent {
+    type: AbilityEventType;
+    timestamp: number;
+    entityId?: EntityId;
+    abilityId?: AbilityId;
+    data?: unknown;
+}
+export type AbilityEventCallback = (event: AbilityEvent) => void;
+export interface AbilityConfig {
+    /** Default global cooldown */
+    defaultGlobalCooldown: number;
+    /** Allow queueing abilities */
+    abilityQueue: boolean;
+    /** Queue window before cast ends */
+    queueWindow: number;
+    /** Auto-target if single target */
+    autoTargetSingleEnemy: boolean;
+}
+export declare const DEFAULT_ABILITY_CONFIG: AbilityConfig;
+export declare class NiceAbility {
+    private config;
+    private abilities;
+    private resources;
+    private upgrades;
+    private combos;
+    private entityAbilities;
+    private entityResources;
+    private entityCasts;
+    private globalCooldowns;
+    private queuedAbilities;
+    private eventListeners;
+    constructor(config?: Partial<AbilityConfig>);
+    on(event: AbilityEventType, callback: AbilityEventCallback): () => void;
+    private emit;
+    registerAbility(ability: AbilityDefinition): void;
+    registerResource(resource: ResourceDefinition): void;
+    registerUpgrade(upgrade: AbilityUpgrade): void;
+    registerCombo(combo: ComboDefinition): void;
+    registerEntity(entityId: EntityId, abilityIds?: AbilityId[], resourceOverrides?: EntityResources): void;
+    unregisterEntity(entityId: EntityId): void;
+    grantAbility(entityId: EntityId, abilityId: AbilityId): void;
+    revokeAbility(entityId: EntityId, abilityId: AbilityId): void;
+    canUseAbility(entityId: EntityId, abilityId: AbilityId): {
+        canUse: boolean;
+        reason?: string;
+    };
+    getCooldownRemaining(entityId: EntityId, abilityId: AbilityId): number;
+    getCooldownPercent(entityId: EntityId, abilityId: AbilityId): number;
+    getCharges(entityId: EntityId, abilityId: AbilityId): number;
+    getResource(entityId: EntityId, resourceId: ResourceId): {
+        current: number;
+        max: number;
+    } | undefined;
+    useAbility(entityId: EntityId, abilityId: AbilityId, targetId?: EntityId, targetPosition?: {
+        x: number;
+        y: number;
+        z?: number;
+    }): boolean;
+    private executeAbility;
+    interruptCast(entityId: EntityId): boolean;
+    queueAbility(entityId: EntityId, abilityId: AbilityId, targetId?: EntityId): void;
+    private advanceCombo;
+    applyUpgrade(entityId: EntityId, upgradeId: UpgradeId): boolean;
+    getUpgradedValue(entityId: EntityId, abilityId: AbilityId, property: string): number | undefined;
+    update(deltaTime: number): void;
+    getEntityAbilities(entityId: EntityId): AbilityId[];
+    getAbilityState(entityId: EntityId, abilityId: AbilityId): AbilityState | undefined;
+    getCastState(entityId: EntityId): CastState | undefined;
+    resetCooldown(entityId: EntityId, abilityId: AbilityId): void;
+    resetAllCooldowns(entityId: EntityId): void;
+    setResource(entityId: EntityId, resourceId: ResourceId, value: number): void;
+    destroy(): void;
+}
+export declare function createAbilitySystem(config?: Partial<AbilityConfig>): NiceAbility;

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

@@ -0,0 +1,230 @@
+import { EventEmitter } from 'events';
+export type EntityId = string;
+export type ProfileId = string;
+export type ColorBlindMode = 'none' | 'protanopia' | 'deuteranopia' | 'tritanopia' | 'achromatopsia' | 'custom';
+export interface ColorTransform {
+    mode: ColorBlindMode;
+    intensity: number;
+    customMatrix?: number[][];
+}
+export interface HighContrastSettings {
+    enabled: boolean;
+    theme: 'dark' | 'light' | 'custom';
+    outlineStrength: number;
+    backgroundColor?: string;
+    foregroundColor?: string;
+    accentColor?: string;
+}
+export interface VisualSettings {
+    colorBlind: ColorTransform;
+    highContrast: HighContrastSettings;
+    textSize: number;
+    uiScale: number;
+    reduceMotion: boolean;
+    reduceFlashing: boolean;
+    flashingThreshold: number;
+    screenShake: number;
+    cameraBobbing: number;
+    hudOpacity: number;
+    iconHighlighting: boolean;
+    objectOutlines: boolean;
+    depthIndicators: boolean;
+}
+export interface AudioAccessibilitySettings {
+    visualSoundIndicators: boolean;
+    spatialAudioVisualization: boolean;
+    monoAudio: boolean;
+    audioDescriptions: boolean;
+    speechEnhancement: boolean;
+    dynamicRangeCompression: number;
+    frequencyShift: number;
+    alertVolume: number;
+}
+export type SubtitleStyle = 'minimal' | 'standard' | 'detailed';
+export type CaptionType = 'dialogue' | 'effect' | 'music' | 'directional';
+export interface SubtitleSettings {
+    enabled: boolean;
+    style: SubtitleStyle;
+    fontSize: number;
+    fontFamily: string;
+    textColor: string;
+    backgroundColor: string;
+    backgroundOpacity: number;
+    showSpeakerNames: boolean;
+    showSpeakerColors: boolean;
+    showEmotions: boolean;
+    maxLines: number;
+    position: 'top' | 'bottom';
+    wordWrap: boolean;
+    letterSpacing: number;
+    lineSpacing: number;
+}
+export interface CaptionSettings {
+    showSoundEffects: boolean;
+    showMusicCues: boolean;
+    showDirectionalIndicators: boolean;
+    effectIconSize: number;
+    effectDuration: number;
+}
+export interface Subtitle {
+    id: string;
+    text: string;
+    speaker?: string;
+    speakerColor?: string;
+    emotion?: string;
+    type: CaptionType;
+    direction?: number;
+    startTime: number;
+    duration: number;
+    priority: number;
+}
+export interface InputAccessibilitySettings {
+    stickyKeys: boolean;
+    keyRepeatDelay: number;
+    keyRepeatRate: number;
+    holdToToggle: boolean;
+    holdThreshold: number;
+    tapAssist: boolean;
+    tapWindow: number;
+    autoAim: boolean;
+    autoAimStrength: number;
+    aimAssist: boolean;
+    aimAssistStrength: number;
+    oneHandedMode: boolean;
+    preferredHand: 'left' | 'right';
+    simplifiedControls: boolean;
+    autoRun: boolean;
+    autoSprint: boolean;
+}
+export interface InputRemapping {
+    actionId: string;
+    primaryKey?: string;
+    secondaryKey?: string;
+    gamepadButton?: string;
+    touchGesture?: string;
+    isHold: boolean;
+    isToggle: boolean;
+}
+export interface CognitiveSettings {
+    tutorialDetail: 'minimal' | 'standard' | 'detailed' | 'always';
+    objectiveReminders: boolean;
+    reminderInterval: number;
+    autoNavigation: boolean;
+    pathHighlighting: boolean;
+    interactionHighlighting: boolean;
+    puzzleHints: boolean;
+    hintDelay: number;
+    readableFont: boolean;
+    dyslexicFont: boolean;
+    simplifiedHud: boolean;
+    pauseOnFocusLoss: boolean;
+    extendedTimers: number;
+    skipQTE: boolean;
+}
+export interface DifficultyModifiers {
+    damageReceived: number;
+    damageDealt: number;
+    healingReceived: number;
+    resourceGain: number;
+    enemyAggression: number;
+    enemyAccuracy: number;
+    parryWindow: number;
+    dodgeWindow: number;
+    regenRate: number;
+    respawnPenalty: number;
+    invincibilityTime: number;
+}
+export interface AccessibilityProfile {
+    id: ProfileId;
+    name: string;
+    visual: VisualSettings;
+    audio: AudioAccessibilitySettings;
+    subtitles: SubtitleSettings;
+    captions: CaptionSettings;
+    input: InputAccessibilitySettings;
+    inputRemaps: Map<string, InputRemapping>;
+    cognitive: CognitiveSettings;
+    difficulty: DifficultyModifiers;
+    createdAt: number;
+    updatedAt: number;
+}
+export type AccessibilityEventType = 'settings-changed' | 'profile-created' | 'profile-loaded' | 'profile-deleted' | 'subtitle-shown' | 'subtitle-hidden' | 'sound-visualized' | 'navigation-assist' | 'hint-requested' | 'screen-reader-text';
+export interface AccessibilityEvent {
+    type: AccessibilityEventType;
+    profileId?: ProfileId;
+    data?: Record<string, unknown>;
+}
+export interface AccessibilitySystemConfig {
+    maxSubtitlesOnScreen?: number;
+    defaultSubtitleDuration?: number;
+    soundIndicatorDuration?: number;
+    screenReaderEnabled?: boolean;
+    autoDetectSettings?: boolean;
+}
+export declare const DEFAULT_ACCESSIBILITY_CONFIG: AccessibilitySystemConfig;
+export declare function getDefaultVisualSettings(): VisualSettings;
+export declare function getDefaultAudioSettings(): AudioAccessibilitySettings;
+export declare function getDefaultSubtitleSettings(): SubtitleSettings;
+export declare function getDefaultCaptionSettings(): CaptionSettings;
+export declare function getDefaultInputSettings(): InputAccessibilitySettings;
+export declare function getDefaultCognitiveSettings(): CognitiveSettings;
+export declare function getDefaultDifficultyModifiers(): DifficultyModifiers;
+export declare class NiceAccessibility extends EventEmitter {
+    private profiles;
+    private entityProfiles;
+    private activeSubtitles;
+    private soundIndicators;
+    private config;
+    private nextProfileId;
+    constructor(config?: Partial<AccessibilitySystemConfig>);
+    createProfile(name: string): ProfileId;
+    deleteProfile(profileId: ProfileId): boolean;
+    getProfile(profileId: ProfileId): AccessibilityProfile | undefined;
+    getEntityProfile(entityId: EntityId): AccessibilityProfile | undefined;
+    setEntityProfile(entityId: EntityId, profileId: ProfileId): boolean;
+    getAllProfiles(): AccessibilityProfile[];
+    updateVisualSettings(profileId: ProfileId, updates: Partial<VisualSettings>): void;
+    updateAudioSettings(profileId: ProfileId, updates: Partial<AudioAccessibilitySettings>): void;
+    updateSubtitleSettings(profileId: ProfileId, updates: Partial<SubtitleSettings>): void;
+    updateCaptionSettings(profileId: ProfileId, updates: Partial<CaptionSettings>): void;
+    updateInputSettings(profileId: ProfileId, updates: Partial<InputAccessibilitySettings>): void;
+    updateCognitiveSettings(profileId: ProfileId, updates: Partial<CognitiveSettings>): void;
+    updateDifficultyModifiers(profileId: ProfileId, updates: Partial<DifficultyModifiers>): void;
+    setInputRemap(profileId: ProfileId, remap: InputRemapping): void;
+    removeInputRemap(profileId: ProfileId, actionId: string): void;
+    getInputRemap(profileId: ProfileId, actionId: string): InputRemapping | undefined;
+    resetInputRemaps(profileId: ProfileId): void;
+    showSubtitle(subtitle: Omit<Subtitle, 'id'>): string;
+    hideSubtitle(subtitleId: string): void;
+    getActiveSubtitles(): Subtitle[];
+    visualizeSound(direction: number, type: string): void;
+    getSoundIndicators(): {
+        direction: number;
+        type: string;
+    }[];
+    announce(text: string, priority?: 'polite' | 'assertive'): void;
+    describeElement(elementId: string, description: string): void;
+    requestNavigationAssist(fromPosition: {
+        x: number;
+        y: number;
+        z: number;
+    }, toTarget: string | {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
+    requestHint(context: string): void;
+    transformColor(r: number, g: number, b: number, mode: ColorBlindMode, intensity: number): {
+        r: number;
+        g: number;
+        b: number;
+    };
+    applyDamageModifier(profileId: ProfileId, damage: number, isReceived: boolean): number;
+    getTimerMultiplier(profileId: ProfileId): number;
+    shouldSkipQTE(profileId: ProfileId): boolean;
+    applyPreset(profileId: ProfileId, preset: 'low_vision' | 'deaf' | 'motor' | 'cognitive'): void;
+    exportProfile(profileId: ProfileId): string | null;
+    importProfile(json: string, name?: string): ProfileId | null;
+}
+export declare function createAccessibilitySystem(config?: Partial<AccessibilitySystemConfig>): NiceAccessibility;
+export default NiceAccessibility;

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

@@ -0,0 +1,153 @@
+import { EventEmitter } from 'events';
+export type EntityId = string;
+export type AchievementId = string;
+export type CategoryId = string;
+export type StatId = string;
+export type AchievementTier = 'bronze' | 'silver' | 'gold' | 'platinum' | 'diamond';
+export interface TierConfig {
+    tier: AchievementTier;
+    points: number;
+    color: string;
+    multiplier: number;
+}
+export declare const DEFAULT_TIER_CONFIG: TierConfig[];
+export interface AchievementCategory {
+    id: CategoryId;
+    name: string;
+    description: string;
+    icon?: string;
+    order: number;
+}
+export type AchievementType = 'standard' | 'progressive' | 'hidden' | 'secret' | 'timed';
+export interface AchievementCriteria {
+    type: 'stat' | 'event' | 'collection' | 'combo';
+    statId?: StatId;
+    eventType?: string;
+    targetValue: number;
+    operator?: 'gte' | 'lte' | 'eq' | 'gt' | 'lt';
+    conditions?: AchievementCriteria[];
+    allRequired?: boolean;
+    timeLimit?: number;
+}
+export interface AchievementReward {
+    type: 'points' | 'item' | 'title' | 'currency' | 'unlock' | 'cosmetic';
+    value: string | number;
+    metadata?: Record<string, unknown>;
+}
+export interface Achievement {
+    id: AchievementId;
+    name: string;
+    description: string;
+    category: CategoryId;
+    type: AchievementType;
+    tier: AchievementTier;
+    icon?: string;
+    criteria: AchievementCriteria;
+    rewards: AchievementReward[];
+    prerequisites?: AchievementId[];
+    milestones?: {
+        threshold: number;
+        reward: AchievementReward;
+    }[];
+    points: number;
+    rarity?: number;
+    order?: number;
+}
+export type StatType = 'counter' | 'maximum' | 'minimum' | 'timer' | 'average';
+export interface Statistic {
+    id: StatId;
+    name: string;
+    description: string;
+    type: StatType;
+    defaultValue: number;
+    format?: string;
+    category?: string;
+}
+export interface EntityStat {
+    statId: StatId;
+    currentValue: number;
+    maxValue: number;
+    minValue: number;
+    totalValue: number;
+    count: number;
+    firstRecorded: number;
+    lastUpdated: number;
+}
+export interface AchievementProgress {
+    achievementId: AchievementId;
+    currentProgress: number;
+    targetProgress: number;
+    percentComplete: number;
+    milestonesClaimed: number[];
+    isCompleted: boolean;
+    completedAt?: number;
+    rewardsClaimed: boolean;
+    startedAt?: number;
+}
+export interface EntityAchievements {
+    entityId: EntityId;
+    progress: Map<AchievementId, AchievementProgress>;
+    stats: Map<StatId, EntityStat>;
+    totalPoints: number;
+    completedCount: number;
+    tier: AchievementTier;
+}
+export type AchievementEventType = 'achievement-unlocked' | 'progress-updated' | 'milestone-reached' | 'reward-claimed' | 'stat-updated' | 'tier-upgraded' | 'secret-revealed';
+export interface AchievementEvent {
+    type: AchievementEventType;
+    entityId: EntityId;
+    achievementId?: AchievementId;
+    statId?: StatId;
+    data?: Record<string, unknown>;
+}
+export interface AchievementSystemConfig {
+    tierConfigs?: TierConfig[];
+    retroactiveUnlocks?: boolean;
+    showHiddenProgress?: boolean;
+    notifyOnProgress?: boolean;
+    progressNotifyThreshold?: number;
+}
+export declare const DEFAULT_ACHIEVEMENT_CONFIG: AchievementSystemConfig;
+export declare class NiceAchievement extends EventEmitter {
+    private achievements;
+    private categories;
+    private statistics;
+    private entities;
+    private eventHandlers;
+    private config;
+    constructor(config?: Partial<AchievementSystemConfig>);
+    defineCategory(category: AchievementCategory): void;
+    getCategory(id: CategoryId): AchievementCategory | undefined;
+    getAllCategories(): AchievementCategory[];
+    defineAchievement(achievement: Achievement): void;
+    getAchievement(id: AchievementId): Achievement | undefined;
+    getAllAchievements(): Achievement[];
+    getAchievementsByCategory(categoryId: CategoryId): Achievement[];
+    defineStatistic(stat: Statistic): void;
+    getStatistic(id: StatId): Statistic | undefined;
+    registerEntity(entityId: EntityId): void;
+    getEntityAchievements(entityId: EntityId): EntityAchievements | undefined;
+    updateStat(entityId: EntityId, statId: StatId, value: number): void;
+    incrementStat(entityId: EntityId, statId: StatId, amount?: number): void;
+    getStat(entityId: EntityId, statId: StatId): EntityStat | undefined;
+    triggerEvent(entityId: EntityId, eventType: string, value?: number): void;
+    updateProgress(entityId: EntityId, achievementId: AchievementId, amount: number): void;
+    private checkStatAchievements;
+    private completeAchievement;
+    private updateEntityTier;
+    claimRewards(entityId: EntityId, achievementId: AchievementId): AchievementReward[] | null;
+    hasClaimedRewards(entityId: EntityId, achievementId: AchievementId): boolean;
+    getProgress(entityId: EntityId, achievementId: AchievementId): AchievementProgress | undefined;
+    isCompleted(entityId: EntityId, achievementId: AchievementId): boolean;
+    getCompletedAchievements(entityId: EntityId): Achievement[];
+    getInProgressAchievements(entityId: EntityId): Achievement[];
+    getVisibleAchievements(entityId: EntityId): Achievement[];
+    getCompletionPercentage(entityId: EntityId, categoryId?: CategoryId): number;
+    getTotalPoints(entityId: EntityId): number;
+    checkRetroactiveUnlocks(entityId: EntityId): void;
+}
+export declare function createAchievementSystem(config?: Partial<AchievementSystemConfig>): NiceAchievement;
+export declare function defineAchievement(options: Achievement): Achievement;
+export declare function defineStatistic(options: Statistic): Statistic;
+export declare function defineCategory(options: AchievementCategory): AchievementCategory;
+export default NiceAchievement;