@nice2dev/game-engine 1.0.28 → 1.1.6

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

@@ -0,0 +1,148 @@
+import { EventEmitter } from 'events';
+export type EntityId = string;
+export type ChannelId = string;
+export type MessageId = string;
+export type ChannelType = 'global' | 'local' | 'party' | 'guild' | 'trade' | 'help' | 'combat' | 'system' | 'whisper' | 'custom';
+export interface ChatChannel {
+    id: ChannelId;
+    name: string;
+    type: ChannelType;
+    color?: string;
+    prefix?: string;
+    permission?: string;
+    isModerated: boolean;
+    moderators: Set<EntityId>;
+    bannedUsers: Map<EntityId, number>;
+    members?: Set<EntityId>;
+    maxRange?: number;
+}
+export interface ChatMessage {
+    id: MessageId;
+    channelId: ChannelId;
+    senderId: EntityId;
+    senderName: string;
+    content: string;
+    formattedContent?: string;
+    timestamp: number;
+    isSystem: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface DirectMessage {
+    id: MessageId;
+    senderId: EntityId;
+    senderName: string;
+    recipientId: EntityId;
+    content: string;
+    timestamp: number;
+    isRead: boolean;
+}
+export type CommandHandler = (senderId: EntityId, args: string[], rawMessage: string) => void | string;
+export interface ChatCommand {
+    name: string;
+    aliases: string[];
+    description: string;
+    usage: string;
+    permission?: string;
+    handler: CommandHandler;
+}
+export type FilterAction = 'block' | 'censor' | 'warn' | 'flag';
+export interface ChatFilter {
+    id: string;
+    pattern: RegExp;
+    action: FilterAction;
+    replacement?: string;
+    reason?: string;
+}
+export interface MuteEntry {
+    entityId: EntityId;
+    mutedBy: EntityId;
+    reason?: string;
+    expiresAt: number;
+    channelId?: ChannelId;
+}
+export interface Emote {
+    code: string;
+    name: string;
+    image?: string;
+    animation?: string;
+    unlockRequirement?: string;
+}
+export type ChatEventType = 'message-sent' | 'message-received' | 'message-blocked' | 'message-deleted' | 'dm-sent' | 'dm-received' | 'channel-joined' | 'channel-left' | 'channel-created' | 'channel-deleted' | 'user-muted' | 'user-unmuted' | 'user-banned' | 'user-unbanned' | 'command-executed' | 'filter-triggered';
+export interface ChatEvent {
+    type: ChatEventType;
+    channelId?: ChannelId;
+    senderId?: EntityId;
+    messageId?: MessageId;
+    data?: Record<string, unknown>;
+}
+export interface ChatSystemConfig {
+    maxMessageLength?: number;
+    maxHistoryPerChannel?: number;
+    maxDmHistory?: number;
+    rateLimitMessages?: number;
+    rateLimitWindowMs?: number;
+    enableFiltering?: boolean;
+    enableCommands?: boolean;
+    commandPrefix?: string;
+    allowLinks?: boolean;
+    linkWhitelist?: string[];
+}
+export declare const DEFAULT_CHAT_CONFIG: ChatSystemConfig;
+export declare class NiceChat extends EventEmitter {
+    private channels;
+    private messages;
+    private directMessages;
+    private commands;
+    private filters;
+    private emotes;
+    private mutes;
+    private ignoreList;
+    private rateLimits;
+    private entityChannels;
+    private nextMessageId;
+    private config;
+    constructor(config?: Partial<ChatSystemConfig>);
+    private initializeDefaultChannels;
+    createChannel(channel: ChatChannel): void;
+    deleteChannel(channelId: ChannelId): boolean;
+    getChannel(id: ChannelId): ChatChannel | undefined;
+    getAllChannels(): ChatChannel[];
+    joinChannel(entityId: EntityId, channelId: ChannelId): boolean;
+    leaveChannel(entityId: EntityId, channelId: ChannelId): boolean;
+    sendMessage(senderId: EntityId, senderName: string, channelId: ChannelId, content: string, metadata?: Record<string, unknown>): MessageId | null;
+    sendSystemMessage(channelId: ChannelId, content: string): MessageId | null;
+    deleteMessage(channelId: ChannelId, messageId: MessageId, moderatorId?: EntityId): boolean;
+    getHistory(channelId: ChannelId, limit?: number): ChatMessage[];
+    sendDirectMessage(senderId: EntityId, senderName: string, recipientId: EntityId, content: string): MessageId | null;
+    private getConversationKey;
+    getDirectMessageHistory(entityId1: EntityId, entityId2: EntityId, limit?: number): DirectMessage[];
+    markDirectMessageRead(messageId: MessageId): void;
+    registerCommand(command: ChatCommand): void;
+    unregisterCommand(name: string): void;
+    private handleCommand;
+    getCommands(): ChatCommand[];
+    addFilter(filter: ChatFilter): void;
+    removeFilter(filterId: string): void;
+    private applyFilters;
+    registerEmote(emote: Emote): void;
+    unregisterEmote(code: string): void;
+    private formatEmotes;
+    getEmotes(): Emote[];
+    mute(entityId: EntityId, moderatorId: EntityId, durationMs: number, reason?: string, channelId?: ChannelId): void;
+    unmute(entityId: EntityId, channelId?: ChannelId): void;
+    isMuted(entityId: EntityId, channelId?: ChannelId): boolean;
+    ban(entityId: EntityId, channelId: ChannelId, durationMs: number): void;
+    unban(entityId: EntityId, channelId: ChannelId): void;
+    setModerator(channelId: ChannelId, entityId: EntityId, isModerator: boolean): void;
+    ignore(entityId: EntityId, targetId: EntityId): void;
+    unignore(entityId: EntityId, targetId: EntityId): void;
+    isIgnoring(entityId: EntityId, targetId: EntityId): boolean;
+    getIgnoreList(entityId: EntityId): EntityId[];
+    private checkRateLimit;
+    getEntityChannels(entityId: EntityId): ChatChannel[];
+    searchMessages(channelId: ChannelId, query: string, limit?: number): ChatMessage[];
+}
+export declare function createChatSystem(config?: Partial<ChatSystemConfig>): NiceChat;
+export declare function defineChatFilter(options: Omit<ChatFilter, 'id'>): ChatFilter;
+export declare function defineChatCommand(options: ChatCommand): ChatCommand;
+export default NiceChat;

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

@@ -0,0 +1,375 @@
+/**
+ * NiceCheat - Debug & Cheat Code System
+ *
+ * Comprehensive cheat code and debug command system for game development,
+ * testing, and (optionally) player use.
+ *
+ * Features:
+ * - Cheat code registration
+ * - Konami code detection
+ * - Console commands
+ * - Key sequence detection
+ * - Debug variables
+ * - God mode, noclip, etc.
+ * - Resource manipulation
+ * - Teleportation
+ * - Spawn entities
+ * - Time manipulation
+ * - Access control
+ * - Cheat categories
+ * - History tracking
+ * - Anti-cheat detection
+ *
+ * @packageDocumentation
+ */
+import { EventEmitter } from 'events';
+/** Unique cheat ID */
+export type CheatId = string;
+/** Unique command ID */
+export type CommandId = string;
+/** Cheat category */
+export type CheatCategory = 'player' | 'world' | 'items' | 'resources' | 'debug' | 'fun' | 'developer' | 'custom';
+/** Access level */
+export type AccessLevel = 'public' | 'dev' | 'admin' | 'internal';
+/** Input method */
+export type InputMethod = 'keyboard' | 'gamepad' | 'console' | 'api';
+/** Konami code sequence */
+export declare const KONAMI_CODE: string[];
+/** Classic cheats */
+export declare const CLASSIC_CHEATS: {
+    IDDQD: string;
+    IDKFA: string;
+    IDCLIP: string;
+    IDNOCLIP: string;
+};
+/** Cheat definition */
+export interface CheatDefinition {
+    id: CheatId;
+    name: string;
+    description: string;
+    category: CheatCategory;
+    code?: string;
+    keySequence?: string[];
+    accessLevel: AccessLevel;
+    enabled: boolean;
+    handler: CheatHandler;
+    params?: CheatParam[];
+    cooldown?: number;
+    singleUse?: boolean;
+    disablesAchievements?: boolean;
+    icon?: string;
+}
+/** Cheat parameter */
+export interface CheatParam {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'select';
+    required?: boolean;
+    defaultValue?: unknown;
+    min?: number;
+    max?: number;
+    options?: string[];
+    description?: string;
+}
+/** Cheat handler function */
+export type CheatHandler = (params: Record<string, unknown>, context: CheatContext) => CheatResult | Promise<CheatResult>;
+/** Cheat context */
+export interface CheatContext {
+    inputMethod: InputMethod;
+    accessLevel: AccessLevel;
+    timestamp: number;
+    playerData?: unknown;
+    worldData?: unknown;
+}
+/** Cheat result */
+export interface CheatResult {
+    success: boolean;
+    message?: string;
+    data?: unknown;
+    sideEffects?: string[];
+}
+/** Console command */
+export interface ConsoleCommand {
+    id: CommandId;
+    name: string;
+    aliases?: string[];
+    description: string;
+    usage: string;
+    accessLevel: AccessLevel;
+    handler: CommandHandler;
+    params?: CommandParam[];
+    autoComplete?: boolean;
+}
+/** Command parameter */
+export interface CommandParam {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'entity' | 'item' | 'position';
+    required?: boolean;
+    description?: string;
+    suggestions?: string[];
+}
+/** Command handler function */
+export type CommandHandler = (args: string[], context: CommandContext) => CommandResult | Promise<CommandResult>;
+/** Command context */
+export interface CommandContext {
+    rawInput: string;
+    accessLevel: AccessLevel;
+    timestamp: number;
+}
+/** Command result */
+export interface CommandResult {
+    success: boolean;
+    output: string;
+    data?: unknown;
+}
+/** Debug variable */
+export interface DebugVariable {
+    name: string;
+    value: unknown;
+    type: string;
+    readonly?: boolean;
+    watchable?: boolean;
+    category?: string;
+}
+/** Key sequence tracker */
+export interface KeySequenceTracker {
+    cheatId: CheatId;
+    sequence: string[];
+    currentIndex: number;
+    timeout: number;
+    lastKeyTime: number;
+}
+/** Cheat activation record */
+export interface CheatActivation {
+    cheatId: CheatId;
+    timestamp: number;
+    inputMethod: InputMethod;
+    params?: Record<string, unknown>;
+    result: CheatResult;
+}
+/** Cheat statistics */
+export interface CheatStatistics {
+    totalActivations: number;
+    uniqueCheatsUsed: number;
+    categoryUsage: Record<CheatCategory, number>;
+    achievementsDisabled: boolean;
+    lastActivation?: number;
+    activationHistory: CheatActivation[];
+}
+/** Quick toggles */
+export interface QuickToggles {
+    godMode: boolean;
+    noclip: boolean;
+    infiniteAmmo: boolean;
+    infiniteHealth: boolean;
+    infiniteResources: boolean;
+    superSpeed: boolean;
+    slowMotion: boolean;
+    invisibility: boolean;
+    oneHitKill: boolean;
+    freezeEnemies: boolean;
+}
+/** Cheat event types */
+export type CheatEventType = 'cheat_activated' | 'cheat_failed' | 'cheat_registered' | 'cheat_unregistered' | 'command_executed' | 'command_failed' | 'konami_code' | 'sequence_progress' | 'toggle_changed' | 'achievements_disabled' | 'console_opened' | 'console_closed';
+/** Cheat event data */
+export interface CheatEvent {
+    type: CheatEventType;
+    timestamp: number;
+    cheatId?: CheatId;
+    commandId?: CommandId;
+    data?: unknown;
+    error?: string;
+}
+/** Cheat event callback */
+export type CheatEventCallback = (event: CheatEvent) => void;
+/** Cheat system configuration */
+export interface CheatConfig {
+    enabled: boolean;
+    consoleEnabled: boolean;
+    consoleKey: string;
+    accessLevel: AccessLevel;
+    sequenceTimeout: number;
+    maxHistorySize: number;
+    disableAchievementsOnCheat: boolean;
+    showNotifications: boolean;
+    logActivations: boolean;
+    allowInMultiplayer: boolean;
+    developerMode: boolean;
+    antiCheatEnabled: boolean;
+}
+/** Default configuration */
+export declare const DEFAULT_CHEAT_CONFIG: CheatConfig;
+/**
+ * Debug and cheat code system
+ */
+export declare class NiceCheat extends EventEmitter {
+    private config;
+    private cheats;
+    private commands;
+    private commandAliases;
+    private debugVariables;
+    private keySequenceTrackers;
+    private quickToggles;
+    private statistics;
+    private consoleOpen;
+    private consoleHistory;
+    private consoleHistoryIndex;
+    private inputBuffer;
+    private konamiProgress;
+    private lastKeyTime;
+    private cooldowns;
+    private usedCheats;
+    constructor(config?: Partial<CheatConfig>);
+    /**
+     * Emit cheat event
+     */
+    private emitEvent;
+    /**
+     * Setup keyboard listener
+     */
+    private setupKeyboardListener;
+    /**
+     * Handle key down
+     */
+    private handleKeyDown;
+    /**
+     * Check Konami code
+     */
+    private checkKonamiCode;
+    /**
+     * Check key sequences
+     */
+    private checkKeySequences;
+    /**
+     * Check text codes
+     */
+    private checkTextCodes;
+    /**
+     * Reset sequence trackers
+     */
+    private resetSequenceTrackers;
+    /**
+     * Register cheat
+     */
+    registerCheat(cheat: CheatDefinition): void;
+    /**
+     * Unregister cheat
+     */
+    unregisterCheat(cheatId: CheatId): boolean;
+    /**
+     * Get cheat
+     */
+    getCheat(cheatId: CheatId): CheatDefinition | undefined;
+    /**
+     * Get all cheats
+     */
+    getAllCheats(category?: CheatCategory): CheatDefinition[];
+    /**
+     * Register built-in cheats
+     */
+    private registerBuiltInCheats;
+    /**
+     * Activate cheat
+     */
+    activateCheat(cheatId: CheatId, params?: Record<string, unknown>, inputMethod?: InputMethod): Promise<CheatResult>;
+    /**
+     * Check if has access
+     */
+    private hasAccess;
+    /**
+     * Check if multiplayer (placeholder)
+     */
+    private isMultiplayer;
+    /**
+     * Toggle quick option
+     */
+    toggleQuick(toggle: keyof QuickToggles): boolean;
+    /**
+     * Set quick toggle
+     */
+    setQuickToggle(toggle: keyof QuickToggles, value: boolean): void;
+    /**
+     * Get quick toggles
+     */
+    getQuickToggles(): QuickToggles;
+    /**
+     * Is toggle active
+     */
+    isToggleActive(toggle: keyof QuickToggles): boolean;
+    /**
+     * Register command
+     */
+    registerCommand(command: ConsoleCommand): void;
+    /**
+     * Unregister command
+     */
+    unregisterCommand(commandId: CommandId): boolean;
+    /**
+     * Execute command
+     */
+    executeCommand(input: string): Promise<CommandResult>;
+    /**
+     * Parse command input
+     */
+    private parseCommandInput;
+    /**
+     * Register built-in commands
+     */
+    private registerBuiltInCommands;
+    /**
+     * Toggle console
+     */
+    toggleConsole(): void;
+    /**
+     * Open console
+     */
+    openConsole(): void;
+    /**
+     * Close console
+     */
+    closeConsole(): void;
+    /**
+     * Is console open
+     */
+    isConsoleOpen(): boolean;
+    /**
+     * Get console history
+     */
+    getConsoleHistory(): string[];
+    /**
+     * Get autocomplete suggestions
+     */
+    getAutocompleteSuggestions(input: string): string[];
+    /**
+     * Set debug variable
+     */
+    setDebugVariable(name: string, value: unknown, readonly?: boolean): void;
+    /**
+     * Get debug variable
+     */
+    getDebugVariable(name: string): unknown;
+    /**
+     * Get all debug variables
+     */
+    getDebugVariables(): DebugVariable[];
+    /**
+     * Get statistics
+     */
+    getStatistics(): CheatStatistics;
+    /**
+     * Are achievements disabled
+     */
+    areAchievementsDisabled(): boolean;
+    /**
+     * Reset cheat state (for new game)
+     */
+    resetState(): void;
+    /**
+     * Destroy cheat system
+     */
+    destroy(): void;
+}
+/**
+ * Create cheat system instance
+ */
+export declare function createCheatSystem(config?: Partial<CheatConfig>): NiceCheat;
+export default NiceCheat;

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

@@ -0,0 +1,186 @@
+import { EventEmitter } from 'events';
+export type EntityId = string;
+export type SurfaceId = string;
+export type ClimbableId = string;
+export interface Vector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export type SurfaceType = 'rock' | 'wood' | 'metal' | 'ice' | 'vine' | 'rope' | 'ladder' | 'ledge' | 'wall' | 'custom';
+export interface ClimbingSurface {
+    id: SurfaceId;
+    type: SurfaceType;
+    friction: number;
+    staminaCost: number;
+    speedModifier: number;
+    requiresTool: boolean;
+    toolId?: string;
+    canRest: boolean;
+    damageOnFall?: number;
+}
+export interface ClimbableObject {
+    id: ClimbableId;
+    surfaceId: SurfaceId;
+    bounds: {
+        min: Vector3;
+        max: Vector3;
+    };
+    holdPoints: HoldPoint[];
+    ledges: Ledge[];
+    vaultPoints: VaultPoint[];
+    isEnabled: boolean;
+}
+export interface HoldPoint {
+    id: string;
+    position: Vector3;
+    normal: Vector3;
+    type: 'grip' | 'edge' | 'crack' | 'hold';
+    size: 'small' | 'medium' | 'large';
+    stability: number;
+    maxWeight?: number;
+}
+export interface Ledge {
+    id: string;
+    start: Vector3;
+    end: Vector3;
+    width: number;
+    canHang: boolean;
+    canPullUp: boolean;
+    canShimmy: boolean;
+    canJumpFrom: boolean;
+}
+export interface VaultPoint {
+    id: string;
+    position: Vector3;
+    direction: Vector3;
+    height: number;
+    type: 'vault' | 'slide' | 'roll' | 'climb_over';
+    speedRequired: number;
+}
+export type ClimbingState = 'idle' | 'approaching' | 'grabbing' | 'climbing' | 'hanging' | 'shimmying' | 'pulling_up' | 'jumping' | 'falling' | 'resting' | 'vaulting';
+export interface Climber {
+    entityId: EntityId;
+    state: ClimbingState;
+    stamina: number;
+    maxStamina: number;
+    staminaRegen: number;
+    climbSpeed: number;
+    gripStrength: number;
+    currentClimbable?: ClimbableId;
+    currentHold?: string;
+    currentLedge?: string;
+    position: Vector3;
+    targetPosition?: Vector3;
+    handsState: {
+        left: {
+            attached: boolean;
+            holdId?: string;
+        };
+        right: {
+            attached: boolean;
+            holdId?: string;
+        };
+    };
+    feetState: {
+        left: {
+            attached: boolean;
+            holdId?: string;
+        };
+        right: {
+            attached: boolean;
+            holdId?: string;
+        };
+    };
+    timeClimbing: number;
+    skills: ClimbingSkills;
+}
+export interface ClimbingSkills {
+    efficiency: number;
+    balance: number;
+    strength: number;
+    agility: number;
+    endurance: number;
+}
+export type ClimbingEventType = 'climb-started' | 'climb-ended' | 'hold-grabbed' | 'hold-released' | 'ledge-grabbed' | 'ledge-pullup' | 'vault-started' | 'vault-completed' | 'stamina-depleted' | 'fall-started' | 'fall-ended' | 'skill-improved';
+export interface ClimbingEvent {
+    type: ClimbingEventType;
+    entityId: EntityId;
+    climbableId?: ClimbableId;
+    data?: Record<string, unknown>;
+}
+export interface ClimbingSystemConfig {
+    baseStamina?: number;
+    staminaRegenRate?: number;
+    staminaRegenDelay?: number;
+    restingRegenMultiplier?: number;
+    baseClimbSpeed?: number;
+    baseJumpForce?: number;
+    maxFallDistance?: number;
+    fallDamageThreshold?: number;
+    fallDamageMultiplier?: number;
+    autoGrabRange?: number;
+    ledgeDetectionRange?: number;
+    vaultDetectionRange?: number;
+}
+export declare const DEFAULT_CLIMBING_CONFIG: ClimbingSystemConfig;
+export declare class NiceClimbing extends EventEmitter {
+    private surfaces;
+    private climbables;
+    private climbers;
+    private config;
+    private lastStaminaRegen;
+    constructor(config?: Partial<ClimbingSystemConfig>);
+    private initializeDefaultSurfaces;
+    registerSurface(surface: ClimbingSurface): void;
+    getSurface(id: SurfaceId): ClimbingSurface | undefined;
+    registerClimbable(climbable: ClimbableObject): void;
+    unregisterClimbable(id: ClimbableId): void;
+    getClimbable(id: ClimbableId): ClimbableObject | undefined;
+    setClimbableEnabled(id: ClimbableId, enabled: boolean): void;
+    registerClimber(entityId: EntityId, skills?: Partial<ClimbingSkills>): void;
+    unregisterClimber(entityId: EntityId): void;
+    getClimber(entityId: EntityId): Climber | undefined;
+    startClimbing(entityId: EntityId, climbableId: ClimbableId, position: Vector3): boolean;
+    stopClimbing(entityId: EntityId): void;
+    grabHold(entityId: EntityId, holdId: string, hand: 'left' | 'right'): boolean;
+    releaseHold(entityId: EntityId, hand: 'left' | 'right'): void;
+    grabLedge(entityId: EntityId, ledgeId: string): boolean;
+    pullUp(entityId: EntityId): boolean;
+    shimmy(entityId: EntityId, direction: number, distance: number): boolean;
+    climb(entityId: EntityId, direction: Vector3): boolean;
+    jumpFromClimb(entityId: EntityId, direction: Vector3): boolean;
+    vault(entityId: EntityId, vaultPointId: string): boolean;
+    private startFall;
+    endFall(entityId: EntityId, fallHeight: number): {
+        damage: number;
+    };
+    rest(entityId: EntityId): boolean;
+    update(deltaTime: number): void;
+    private updateClimber;
+    improveSkill(entityId: EntityId, skill: keyof ClimbingSkills, amount: number): void;
+    detectNearbyClimbables(position: Vector3, radius: number): ClimbableObject[];
+    detectNearbyLedges(position: Vector3, radius: number): {
+        climbable: ClimbableObject;
+        ledge: Ledge;
+    }[];
+    detectNearbyVaultPoints(position: Vector3, radius: number): {
+        climbable: ClimbableObject;
+        vaultPoint: VaultPoint;
+    }[];
+    private calculateDistance;
+    private normalizeVector;
+    private isWithinBounds;
+    private findNearbyLedge;
+    private findClimbableAtPosition;
+    isClimbing(entityId: EntityId): boolean;
+    getClimberState(entityId: EntityId): ClimbingState | undefined;
+    getStamina(entityId: EntityId): {
+        current: number;
+        max: number;
+    } | undefined;
+}
+export declare function createClimbingSystem(config?: Partial<ClimbingSystemConfig>): NiceClimbing;
+export declare function defineClimbingSurface(options: ClimbingSurface): ClimbingSurface;
+export declare function defineClimbable(options: ClimbableObject): ClimbableObject;
+export default NiceClimbing;