@nice2dev/game-engine 1.0.28 → 1.1.6

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

@@ -0,0 +1,452 @@
+/**
+ * NiceModding - Mod Support System
+ *
+ * Comprehensive modding system for supporting user-created content,
+ * mod loading, sandbox environments, and mod management.
+ *
+ * Features:
+ * - Mod loading and registration
+ * - Mod dependencies
+ * - Mod versioning
+ * - Sandbox execution
+ * - Asset override system
+ * - Hook/event system
+ * - Mod configuration
+ * - Mod workshop integration
+ * - Conflict detection
+ * - Load order management
+ * - Mod profiles
+ * - Hot reloading (dev mode)
+ *
+ * @packageDocumentation
+ */
+import { EventEmitter } from 'events';
+/** Unique mod ID */
+export type ModId = string;
+/** Unique hook ID */
+export type HookId = string;
+/** Unique asset ID */
+export type AssetId = string;
+/** Unique profile ID */
+export type ProfileId = string;
+/** Mod state */
+export type ModState = 'unloaded' | 'loading' | 'loaded' | 'initializing' | 'active' | 'error' | 'disabled';
+/** Hook priority */
+export type HookPriority = 'first' | 'high' | 'normal' | 'low' | 'last';
+/** Mod category */
+export type ModCategory = 'gameplay' | 'content' | 'graphics' | 'audio' | 'ui' | 'utility' | 'total_conversion' | 'other';
+/** Permission type */
+export type ModPermission = 'filesystem' | 'network' | 'native' | 'save_data' | 'achievements' | 'ui_override' | 'core_override';
+/** Mod manifest */
+export interface ModManifest {
+    id: ModId;
+    name: string;
+    version: string;
+    description: string;
+    author: string;
+    authorUrl?: string;
+    homepage?: string;
+    repository?: string;
+    license?: string;
+    category: ModCategory;
+    tags: string[];
+    gameVersion: string;
+    minGameVersion?: string;
+    maxGameVersion?: string;
+    dependencies: ModDependency[];
+    conflicts: ModId[];
+    loadBefore?: ModId[];
+    loadAfter?: ModId[];
+    permissions: ModPermission[];
+    entryPoint: string;
+    assets?: ModAsset[];
+    config?: ModConfigSchema;
+    screenshots?: string[];
+    changelog?: string;
+}
+/** Mod dependency */
+export interface ModDependency {
+    modId: ModId;
+    version?: string;
+    minVersion?: string;
+    maxVersion?: string;
+    optional?: boolean;
+}
+/** Mod asset definition */
+export interface ModAsset {
+    id: AssetId;
+    type: 'texture' | 'audio' | 'model' | 'data' | 'script' | 'shader';
+    path: string;
+    overrides?: string;
+    priority?: number;
+}
+/** Mod configuration schema */
+export interface ModConfigSchema {
+    fields: ModConfigField[];
+    defaults?: Record<string, unknown>;
+}
+/** Mod configuration field */
+export interface ModConfigField {
+    key: string;
+    type: 'string' | 'number' | 'boolean' | 'select' | 'color' | 'keybind';
+    label: string;
+    description?: string;
+    default?: unknown;
+    options?: Array<{
+        value: unknown;
+        label: string;
+    }>;
+    min?: number;
+    max?: number;
+    step?: number;
+    category?: string;
+}
+/** Loaded mod instance */
+export interface ModInstance {
+    manifest: ModManifest;
+    state: ModState;
+    loadedAt?: number;
+    activatedAt?: number;
+    error?: string;
+    config: Record<string, unknown>;
+    exports?: ModExports;
+    loadOrder: number;
+    hash?: string;
+}
+/** Mod exports (API provided by mod) */
+export interface ModExports {
+    onLoad?: () => void | Promise<void>;
+    onUnload?: () => void | Promise<void>;
+    onActivate?: () => void | Promise<void>;
+    onDeactivate?: () => void | Promise<void>;
+    onConfigChange?: (key: string, value: unknown) => void;
+    api?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+/** Mod hook registration */
+export interface ModHook {
+    id: HookId;
+    modId: ModId;
+    hookName: string;
+    callback: HookCallback;
+    priority: HookPriority;
+    enabled: boolean;
+}
+/** Hook callback function */
+export type HookCallback = (context: HookContext) => HookResult | Promise<HookResult>;
+/** Hook context */
+export interface HookContext {
+    hookName: string;
+    args: unknown[];
+    modId?: ModId;
+    result?: unknown;
+    cancelled?: boolean;
+    metadata?: Record<string, unknown>;
+}
+/** Hook result */
+export interface HookResult {
+    result?: unknown;
+    cancel?: boolean;
+    modify?: unknown;
+}
+/** Asset override */
+export interface AssetOverride {
+    originalPath: string;
+    modPath: string;
+    modId: ModId;
+    priority: number;
+    type: ModAsset['type'];
+}
+/** Mod profile */
+export interface ModProfile {
+    id: ProfileId;
+    name: string;
+    description?: string;
+    enabledMods: ModId[];
+    modConfigs: Record<ModId, Record<string, unknown>>;
+    loadOrder: ModId[];
+    createdAt: number;
+    updatedAt: number;
+    isActive: boolean;
+}
+/** Mod conflict */
+export interface ModConflict {
+    modA: ModId;
+    modB: ModId;
+    type: 'explicit' | 'asset' | 'hook' | 'dependency';
+    description: string;
+    severity: 'error' | 'warning' | 'info';
+}
+/** Mod load result */
+export interface ModLoadResult {
+    success: boolean;
+    modId: ModId;
+    error?: string;
+    warnings?: string[];
+    loadTime?: number;
+}
+/** Workshop item */
+export interface WorkshopItem {
+    id: string;
+    modId: ModId;
+    name: string;
+    description: string;
+    author: string;
+    version: string;
+    downloads: number;
+    rating: number;
+    ratingCount: number;
+    thumbnailUrl?: string;
+    tags: string[];
+    createdAt: number;
+    updatedAt: number;
+    size: number;
+    isInstalled: boolean;
+    isSubscribed: boolean;
+}
+/** Mod statistics */
+export interface ModStatistics {
+    totalMods: number;
+    activeMods: number;
+    disabledMods: number;
+    errorMods: number;
+    totalHooks: number;
+    totalAssetOverrides: number;
+    loadTime: number;
+}
+/** Mod event types */
+export type ModEventType = 'mod_registered' | 'mod_unregistered' | 'mod_loading' | 'mod_loaded' | 'mod_error' | 'mod_activated' | 'mod_deactivated' | 'mod_config_changed' | 'hook_registered' | 'hook_called' | 'asset_override_added' | 'profile_changed' | 'conflict_detected' | 'load_order_changed';
+/** Mod event data */
+export interface ModEvent {
+    type: ModEventType;
+    timestamp: number;
+    modId?: ModId;
+    hookId?: HookId;
+    profileId?: ProfileId;
+    data?: unknown;
+    error?: string;
+}
+/** Mod event callback */
+export type ModEventCallback = (event: ModEvent) => void;
+/** Modding system configuration */
+export interface ModdingConfig {
+    modsDirectory: string;
+    enableSandbox: boolean;
+    enableHotReload: boolean;
+    maxModLoadTime: number;
+    maxHookExecutionTime: number;
+    allowedPermissions: ModPermission[];
+    autoLoadEnabled: boolean;
+    saveConfigOnChange: boolean;
+    validateManifests: boolean;
+    cacheAssets: boolean;
+    parallelLoading: boolean;
+    maxParallelLoads: number;
+}
+/** Default configuration */
+export declare const DEFAULT_MODDING_CONFIG: ModdingConfig;
+/**
+ * Mod support and management system
+ */
+export declare class NiceModding extends EventEmitter {
+    private config;
+    private mods;
+    private hooks;
+    private assetOverrides;
+    private profiles;
+    private activeProfile?;
+    private loadOrder;
+    private conflicts;
+    private modApi;
+    private hookIdCounter;
+    constructor(config?: Partial<ModdingConfig>);
+    /**
+     * Emit mod event
+     */
+    private emitEvent;
+    /**
+     * Generate unique hook ID
+     */
+    private generateHookId;
+    /**
+     * Register mod from manifest
+     */
+    registerMod(manifest: ModManifest): boolean;
+    /**
+     * Validate mod manifest
+     */
+    private validateManifest;
+    /**
+     * Check mod permissions
+     */
+    private checkPermissions;
+    /**
+     * Unregister mod
+     */
+    unregisterMod(modId: ModId): Promise<boolean>;
+    /**
+     * Load mod
+     */
+    loadMod(modId: ModId): Promise<ModLoadResult>;
+    /**
+     * Load mod module (simulation)
+     */
+    private loadModModule;
+    /**
+     * Load mod dependencies
+     */
+    private loadDependencies;
+    /**
+     * Check version compatibility
+     */
+    private isVersionCompatible;
+    /**
+     * Unload mod
+     */
+    unloadMod(modId: ModId): Promise<boolean>;
+    /**
+     * Activate mod
+     */
+    activateMod(modId: ModId): Promise<boolean>;
+    /**
+     * Deactivate mod
+     */
+    deactivateMod(modId: ModId): Promise<boolean>;
+    /**
+     * Get mod instance
+     */
+    getMod(modId: ModId): ModInstance | undefined;
+    /**
+     * Get all mods
+     */
+    getAllMods(): ModInstance[];
+    /**
+     * Get active mods
+     */
+    getActiveMods(): ModInstance[];
+    /**
+     * Get mods by category
+     */
+    getModsByCategory(category: ModCategory): ModInstance[];
+    /**
+     * Register hook
+     */
+    registerHook(modId: ModId, hookName: string, callback: HookCallback, priority?: HookPriority): HookId | undefined;
+    /**
+     * Sort hooks by priority
+     */
+    private sortHooks;
+    /**
+     * Unregister hook
+     */
+    unregisterHook(hookId: HookId): boolean;
+    /**
+     * Remove all hooks for a mod
+     */
+    private removeModHooks;
+    /**
+     * Call hook
+     */
+    callHook(hookName: string, ...args: unknown[]): Promise<HookContext>;
+    /**
+     * Check if hook exists
+     */
+    hasHook(hookName: string): boolean;
+    /**
+     * Register asset override
+     */
+    private registerAssetOverride;
+    /**
+     * Remove mod asset overrides
+     */
+    private removeModAssetOverrides;
+    /**
+     * Resolve asset path
+     */
+    resolveAssetPath(originalPath: string): string;
+    /**
+     * Get asset overrides for path
+     */
+    getAssetOverrides(originalPath: string): AssetOverride[];
+    /**
+     * Get mod config
+     */
+    getModConfig(modId: ModId): Record<string, unknown> | undefined;
+    /**
+     * Set mod config value
+     */
+    setModConfigValue(modId: ModId, key: string, value: unknown): boolean;
+    /**
+     * Reset mod config to defaults
+     */
+    resetModConfig(modId: ModId): boolean;
+    /**
+     * Get load order
+     */
+    getLoadOrder(): ModId[];
+    /**
+     * Set load order
+     */
+    setLoadOrder(order: ModId[]): boolean;
+    /**
+     * Move mod in load order
+     */
+    moveModInLoadOrder(modId: ModId, direction: 'up' | 'down'): boolean;
+    /**
+     * Detect conflicts for mod
+     */
+    private detectConflicts;
+    /**
+     * Get conflicts
+     */
+    getConflicts(): ModConflict[];
+    /**
+     * Get conflicts for mod
+     */
+    getModConflicts(modId: ModId): ModConflict[];
+    /**
+     * Create profile
+     */
+    createProfile(id: ProfileId, name: string, description?: string): ModProfile;
+    /**
+     * Delete profile
+     */
+    deleteProfile(profileId: ProfileId): boolean;
+    /**
+     * Get profile
+     */
+    getProfile(profileId: ProfileId): ModProfile | undefined;
+    /**
+     * Get all profiles
+     */
+    getAllProfiles(): ModProfile[];
+    /**
+     * Set active profile
+     */
+    setActiveProfile(profileId: ProfileId): Promise<boolean>;
+    /**
+     * Save current state to active profile
+     */
+    saveToProfile(): boolean;
+    /**
+     * Get mod API
+     */
+    getModApi(modId: ModId): Record<string, unknown> | undefined;
+    /**
+     * Call mod API method
+     */
+    callModApi(modId: ModId, method: string, ...args: unknown[]): Promise<unknown>;
+    /**
+     * Get modding statistics
+     */
+    getStatistics(): ModStatistics;
+    /**
+     * Destroy modding system
+     */
+    destroy(): Promise<void>;
+}
+/**
+ * Create modding system instance
+ */
+export declare function createModdingSystem(config?: Partial<ModdingConfig>): NiceModding;
+export default NiceModding;

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

@@ -0,0 +1,152 @@
+import { EventEmitter } from 'events';
+export type MountId = string;
+export type RiderId = string;
+export type MountTypeId = string;
+export interface Vector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export type MountCategory = 'ground' | 'flying' | 'aquatic' | 'amphibious' | 'all-terrain';
+export interface MountType {
+    id: MountTypeId;
+    name: string;
+    description?: string;
+    category: MountCategory;
+    baseSpeed: number;
+    sprintMultiplier: number;
+    acceleration: number;
+    turnRate: number;
+    seats: number;
+    size: 'small' | 'medium' | 'large' | 'huge';
+    stamina: number;
+    staminaRegenRate: number;
+    abilities: MountAbilityId[];
+    equipmentSlots?: MountEquipmentSlot[];
+    flightCeiling?: number;
+    diveDepth?: number;
+    canJump?: boolean;
+    jumpHeight?: number;
+    canSwim?: boolean;
+    swimSpeed?: number;
+    canFly?: boolean;
+    flySpeed?: number;
+    riderAnimations: {
+        idle: string;
+        walk: string;
+        run: string;
+        sprint?: string;
+        jump?: string;
+        fly?: string;
+        swim?: string;
+    };
+}
+export type MountEquipmentSlot = 'saddle' | 'armor' | 'shoes' | 'accessory' | 'bags';
+export interface MountEquipment {
+    id: string;
+    name: string;
+    slot: MountEquipmentSlot;
+    speedBonus?: number;
+    staminaBonus?: number;
+    armorBonus?: number;
+    bagSlots?: number;
+    effects?: string[];
+}
+export type MountAbilityId = string;
+export interface MountAbility {
+    id: MountAbilityId;
+    name: string;
+    description?: string;
+    cooldown: number;
+    staminaCost: number;
+    type: 'movement' | 'combat' | 'utility';
+    effect: (mount: Mount, rider: RiderId) => void;
+}
+export interface Mount {
+    id: MountId;
+    typeId: MountTypeId;
+    ownerId: RiderId;
+    name: string;
+    summoned: boolean;
+    position: Vector3;
+    rotation: number;
+    currentSpeed: number;
+    isSprinting: boolean;
+    isJumping: boolean;
+    isFlying: boolean;
+    isSwimming: boolean;
+    currentStamina: number;
+    maxStamina: number;
+    speedModifier: number;
+    riders: Map<number, RiderId>;
+    equipment: Map<MountEquipmentSlot, MountEquipment>;
+    abilityCooldowns: Map<MountAbilityId, number>;
+    inventory?: unknown[];
+    customData: Record<string, unknown>;
+}
+export type MountEventType = 'mount-created' | 'mount-removed' | 'mount-summoned' | 'mount-dismissed' | 'rider-mounted' | 'rider-dismounted' | 'mount-ability-used' | 'mount-equipment-changed' | 'mount-sprint-start' | 'mount-sprint-end' | 'mount-flight-start' | 'mount-flight-end' | 'mount-stamina-depleted';
+export interface MountEvent {
+    type: MountEventType;
+    mountId: MountId;
+    riderId?: RiderId;
+    data?: Record<string, unknown>;
+}
+export interface MountSystemConfig {
+    maxMountsPerPlayer?: number;
+    mountSummonTime?: number;
+    dismountCooldown?: number;
+    staminaCostSprint?: number;
+    staminaCostFly?: number;
+    staminaCostJump?: number;
+}
+export declare const DEFAULT_MOUNT_CONFIG: MountSystemConfig;
+export declare class NiceMount extends EventEmitter {
+    private mounts;
+    private mountTypes;
+    private abilities;
+    private ownerMounts;
+    private activeMounts;
+    private riderMounts;
+    private nextMountId;
+    private config;
+    constructor(config?: Partial<MountSystemConfig>);
+    registerType(type: MountType): void;
+    getType(typeId: MountTypeId): MountType | undefined;
+    getAllTypes(): MountType[];
+    getTypesByCategory(category: MountCategory): MountType[];
+    registerAbility(ability: MountAbility): void;
+    getAbility(abilityId: MountAbilityId): MountAbility | undefined;
+    create(ownerId: RiderId, typeId: MountTypeId, name: string): MountId | null;
+    remove(mountId: MountId): boolean;
+    get(mountId: MountId): Mount | undefined;
+    getByOwner(ownerId: RiderId): Mount[];
+    summon(mountId: MountId, position: Vector3): boolean;
+    dismiss(mountId: MountId): boolean;
+    getActiveMount(ownerId: RiderId): Mount | undefined;
+    mount(riderId: RiderId, mountId: MountId, seatIndex?: number): boolean;
+    dismount(riderId: RiderId): boolean;
+    getRiderMount(riderId: RiderId): Mount | undefined;
+    isRiding(riderId: RiderId): boolean;
+    getRiders(mountId: MountId): Array<{
+        riderId: RiderId;
+        seatIndex: number;
+    }>;
+    getSpeed(mountId: MountId): number;
+    setSprinting(mountId: MountId, sprinting: boolean): void;
+    jump(mountId: MountId): boolean;
+    setFlying(mountId: MountId, flying: boolean): boolean;
+    setSwimming(mountId: MountId, swimming: boolean): void;
+    update(deltaTime: number): void;
+    equip(mountId: MountId, equipment: MountEquipment): boolean;
+    unequip(mountId: MountId, slot: MountEquipmentSlot): MountEquipment | null;
+    getEquipment(mountId: MountId, slot: MountEquipmentSlot): MountEquipment | undefined;
+    useAbility(mountId: MountId, abilityId: MountAbilityId): boolean;
+    getAbilityCooldown(mountId: MountId, abilityId: MountAbilityId): number;
+}
+export declare function createMountSystem(config?: Partial<MountSystemConfig>): NiceMount;
+export declare function defineMountType(data: MountType): MountType;
+export declare function defineMountAbility(data: Omit<MountAbility, 'effect'> & {
+    effect?: MountAbility['effect'];
+}): MountAbility;
+export declare function defineMountEquipment(data: MountEquipment): MountEquipment;
+export default NiceMount;