@nodemod/core 1.0.0

package/README.md

@@ -0,0 +1,60 @@
+# NodeMod Core
+
+TypeScript-first NodeMod core library for Half-Life server plugins.
+
+## Overview
+
+NodeMod Core provides a comprehensive, type-safe API for developing Half-Life server plugins using TypeScript. It offers enhanced utilities, event handling, player management, and entity manipulation while maintaining full compatibility with the underlying NodeMod system.
+
+## Features
+
+### Core Modules
+- **Command System** - Register and handle server commands
+- **Menu System** - Create interactive menus for players
+- **Message System** - Send various types of messages to clients
+- **Resource Management** - Handle server resources and downloads
+- **Sound System** - Play sounds and manage audio
+
+### Enhanced Modules  
+- **Player Management** - Advanced player utilities and information
+- **Entity System** - Enhanced entity manipulation and wrapping
+- **Event Handling** - Comprehensive event system with type safety
+- **Trace System** - Ray tracing and collision detection
+
+### Native Modules
+- **CVar System** - Server variable management
+- **File System** - File operations and management
+
+### Utility Modules
+- **General Utilities** - Common helper functions and tools
+- **Entity Debugging** - Debug entity private data and offsets
+- **Message Helpers** - Chat, HUD, and communication utilities
+
+## Installation
+
+```bash
+npm install @nodemod/core
+```
+
+## Basic Usage
+
+```typescript
+import nodemodCore from '@nodemod/core';
+
+// Send a message to all players
+nodemodCore.util.messageAll('Hello from NodeMod Core!');
+
+// Get all connected players
+const players = nodemodCore.player.getAll();
+
+// Create an entity
+const entity = nodemodCore.entity.create('info_target');
+```
+
+## Documentation
+
+Full API documentation is available in the `/docs` directory.
+
+## License
+
+MIT

package/dist/core/cmd.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Context object containing information about a command execution.
+ */
+export interface CommandContext {
+    /** The raw command text as entered by the client */
+    text: string;
+    /** Array of parsed command arguments, including the command name as the first element */
+    args: string[];
+    /** The client entity that issued the command */
+    client: nodemod.Entity;
+}
+/**
+ * Handler function for client commands.
+ */
+export interface CommandHandler {
+    (ctx: CommandContext): void;
+}
+/**
+ * Handler function for server commands.
+ */
+export interface ServerCommandHandler {
+    (): void;
+}
+/**
+ * Configuration options for registering a command.
+ */
+export interface CommandOptions {
+    /** The command name (without prefix) */
+    name: string;
+    /** Whether this is a client or server command */
+    type: 'client' | 'server';
+    /** The handler function to execute when the command is invoked */
+    handler: CommandHandler | ServerCommandHandler;
+}
+/**
+ * Command manager for handling both client and server commands in the nodemod plugin system.
+ *
+ * @example
+ * ```typescript
+ * // Register a client command
+ * nodemodCore.cmd.add({
+ *   name: 'hello',
+ *   type: 'client',
+ *   handler: (ctx) => {
+ *     console.log(`Hello ${ctx.client.name}!`);
+ *   }
+ * });
+ *
+ * // Register a server command
+ * nodemodCore.cmd.add({
+ *   name: 'restart',
+ *   type: 'server',
+ *   handler: () => {
+ *     console.log('Server restarting...');
+ *   }
+ * });
+ * ```
+ */
+export default class NodemodCmd {
+    /** Array of registered commands */
+    private commands;
+    /**
+     * Parses a command string into an array of arguments, respecting quoted strings.
+     *
+     * @param command - The raw command string to parse
+     * @returns Array of parsed arguments
+     *
+     * @example
+     * ```typescript
+     * parseCommand('say "hello world" test') // Returns: ['say', 'hello world', 'test']
+     * parseCommand('kick player reason') // Returns: ['kick', 'player', 'reason']
+     * ```
+     */
+    private parseCommand;
+    /**
+     * Creates a new NodemodCmd instance and sets up command event listeners.
+     * Automatically handles client command events from the nodemod system.
+     */
+    constructor();
+    /**
+     * Retrieves a registered command by name and type.
+     *
+     * @param commandName - The name of the command to find
+     * @param type - The type of command ('client' or 'server')
+     * @returns The command options if found, undefined otherwise
+     */
+    getCommand(commandName: string, type: string): CommandOptions | undefined;
+    /**
+     * Adds a new command to the command registry.
+     * For server commands, automatically registers them with the native engine.
+     *
+     * @param options - Command configuration options
+     *
+     * @example
+     * ```typescript
+     * // Client command
+     * nodemodCore.cmd.add({
+     *   name: 'info',
+     *   type: 'client',
+     *   handler: (ctx) => {
+     *     console.log(`Player: ${ctx.client.name}, Args: ${ctx.args.join(' ')}`);
+     *   }
+     * });
+     *
+     * // Server command
+     * nodemodCore.cmd.add({
+     *   name: 'status',
+     *   type: 'server',
+     *   handler: () => {
+     *     console.log('Server is running');
+     *   }
+     * });
+     * ```
+     */
+    add(options: CommandOptions): void;
+    /**
+     * Convenience method to register a client command with a simplified handler signature.
+     * The handler receives the client entity and arguments (excluding the command name).
+     *
+     * @param name - The command name
+     * @param handler - Function that receives the client and arguments
+     *
+     * @example
+     * ```typescript
+     * nodemodCore.cmd.register('kick', (client, args) => {
+     *   const targetName = args[0];
+     *   const reason = args.slice(1).join(' ');
+     *   console.log(`${client.name} wants to kick ${targetName}: ${reason}`);
+     * });
+     * ```
+     */
+    register(name: string, handler: (client: nodemod.Entity, args: string[]) => void): void;
+    /**
+     * Executes a server command through the native engine.
+     * Automatically appends a newline character to the command.
+     *
+     * @param command - The server command to execute
+     *
+     * @example
+     * ```typescript
+     * nodemodCore.cmd.run('changelevel de_dust2');
+     * nodemodCore.cmd.run('kick "Player Name"');
+     * nodemodCore.cmd.run('say "Server announcement"');
+     * ```
+     */
+    run(command: string): void;
+}
+//# sourceMappingURL=cmd.d.ts.map

package/dist/core/cmd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cmd.d.ts","sourceRoot":"","sources":["../../src/core/cmd.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAC;IACb,yFAAyF;IACzF,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,gDAAgD;IAChD,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,CAAC,GAAG,EAAE,cAAc,GAAG,IAAI,CAAC;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,IAAI,IAAI,CAAC;CACV;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,wCAAwC;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,iDAAiD;IACjD,IAAI,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAC1B,kEAAkE;IAClE,OAAO,EAAE,cAAc,GAAG,oBAAoB,CAAC;CAChD;AAID;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,OAAO,OAAO,UAAU;IAC7B,mCAAmC;IACnC,OAAO,CAAC,QAAQ,CAAwB;IAExC;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,YAAY;IA8BpB;;;OAGG;;IAiBH;;;;;;OAMG;IACH,UAAU,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS;IAIzE;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,GAAG,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;IAelC;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,IAAI,GAAG,IAAI;IAQvF;;;;;;;;;;;;OAYG;IACH,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;CAG3B"}

package/dist/core/cmd.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Extend the nodemod namespace to include missing methods
+/**
+ * Command manager for handling both client and server commands in the nodemod plugin system.
+ *
+ * @example
+ * ```typescript
+ * // Register a client command
+ * nodemodCore.cmd.add({
+ *   name: 'hello',
+ *   type: 'client',
+ *   handler: (ctx) => {
+ *     console.log(`Hello ${ctx.client.name}!`);
+ *   }
+ * });
+ *
+ * // Register a server command
+ * nodemodCore.cmd.add({
+ *   name: 'restart',
+ *   type: 'server',
+ *   handler: () => {
+ *     console.log('Server restarting...');
+ *   }
+ * });
+ * ```
+ */
+class NodemodCmd {
+    /** Array of registered commands */
+    commands = [];
+    /**
+     * Parses a command string into an array of arguments, respecting quoted strings.
+     *
+     * @param command - The raw command string to parse
+     * @returns Array of parsed arguments
+     *
+     * @example
+     * ```typescript
+     * parseCommand('say "hello world" test') // Returns: ['say', 'hello world', 'test']
+     * parseCommand('kick player reason') // Returns: ['kick', 'player', 'reason']
+     * ```
+     */
+    parseCommand(command) {
+        const args = [];
+        let current = '';
+        let inQuotes = false;
+        let i = 0;
+        while (i < command.length) {
+            const char = command[i];
+            if (char === '"') {
+                inQuotes = !inQuotes;
+            }
+            else if (char === ' ' && !inQuotes) {
+                if (current.length > 0) {
+                    args.push(current);
+                    current = '';
+                }
+            }
+            else {
+                current += char;
+            }
+            i++;
+        }
+        // Add the last argument if there is one
+        if (current.length > 0) {
+            args.push(current);
+        }
+        return args;
+    }
+    /**
+     * Creates a new NodemodCmd instance and sets up command event listeners.
+     * Automatically handles client command events from the nodemod system.
+     */
+    constructor() {
+        nodemod.on('dllClientCommand', (client, rtext) => {
+            const args = this.parseCommand(rtext);
+            const commandName = args[0];
+            const ctx = { text: rtext, args, client };
+            const command = this.getCommand(commandName, 'client');
+            if (!command) {
+                return;
+            }
+            nodemod.setMetaResult(4 /* nodemod.META_RES.SUPERCEDE */); // Supercede the command
+            return command.handler(ctx);
+        });
+    }
+    /**
+     * Retrieves a registered command by name and type.
+     *
+     * @param commandName - The name of the command to find
+     * @param type - The type of command ('client' or 'server')
+     * @returns The command options if found, undefined otherwise
+     */
+    getCommand(commandName, type) {
+        return this.commands.find(v => v.name === commandName && v.type === type);
+    }
+    /**
+     * Adds a new command to the command registry.
+     * For server commands, automatically registers them with the native engine.
+     *
+     * @param options - Command configuration options
+     *
+     * @example
+     * ```typescript
+     * // Client command
+     * nodemodCore.cmd.add({
+     *   name: 'info',
+     *   type: 'client',
+     *   handler: (ctx) => {
+     *     console.log(`Player: ${ctx.client.name}, Args: ${ctx.args.join(' ')}`);
+     *   }
+     * });
+     *
+     * // Server command
+     * nodemodCore.cmd.add({
+     *   name: 'status',
+     *   type: 'server',
+     *   handler: () => {
+     *     console.log('Server is running');
+     *   }
+     * });
+     * ```
+     */
+    add(options) {
+        this.commands.push(options);
+        // Register server commands with the engine
+        if (options.type === 'server') {
+            // Create a wrapper function that calls our handler
+            const serverHandler = () => {
+                options.handler();
+            };
+            // Register with the native engine
+            nodemod.eng.addServerCommand(options.name, serverHandler);
+        }
+    }
+    /**
+     * Convenience method to register a client command with a simplified handler signature.
+     * The handler receives the client entity and arguments (excluding the command name).
+     *
+     * @param name - The command name
+     * @param handler - Function that receives the client and arguments
+     *
+     * @example
+     * ```typescript
+     * nodemodCore.cmd.register('kick', (client, args) => {
+     *   const targetName = args[0];
+     *   const reason = args.slice(1).join(' ');
+     *   console.log(`${client.name} wants to kick ${targetName}: ${reason}`);
+     * });
+     * ```
+     */
+    register(name, handler) {
+        this.add({
+            name,
+            type: 'client',
+            handler: (ctx) => handler(ctx.client, ctx.args.slice(1))
+        });
+    }
+    /**
+     * Executes a server command through the native engine.
+     * Automatically appends a newline character to the command.
+     *
+     * @param command - The server command to execute
+     *
+     * @example
+     * ```typescript
+     * nodemodCore.cmd.run('changelevel de_dust2');
+     * nodemodCore.cmd.run('kick "Player Name"');
+     * nodemodCore.cmd.run('say "Server announcement"');
+     * ```
+     */
+    run(command) {
+        nodemod.eng.serverCommand(command + '\n');
+    }
+}
+exports.default = NodemodCmd;
+//# sourceMappingURL=cmd.js.map

package/dist/core/cmd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cmd.js","sourceRoot":"","sources":["../../src/core/cmd.ts"],"names":[],"mappings":"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"}

package/dist/core/menu.d.ts

@@ -0,0 +1,300 @@
+/**
+ * Handler function for menu item actions.
+ */
+export interface MenuHandler {
+    (client: nodemod.Entity, menu?: Menu): void | Promise<void>;
+}
+/**
+ * Configuration for a single menu item.
+ */
+export interface MenuItem {
+    /** Display name of the menu item */
+    name: string;
+    /** Handler function to execute when item is selected */
+    handler?: MenuHandler;
+    /** Submenu to navigate to when item is selected */
+    submenu?: Menu;
+    /** Whether this item is disabled and cannot be selected */
+    disabled?: boolean;
+}
+/**
+ * Configuration options for creating a menu.
+ */
+export interface MenuOptions {
+    /** Title displayed at the top of the menu */
+    title: string;
+    /** Array of menu items */
+    items: MenuItem[];
+    /** Specific entity to show menu to (if undefined, shows to all players) */
+    entity?: nodemod.Entity;
+    /** Auto-close timeout in seconds (-1 for no timeout) */
+    time?: number;
+    /** Callback when menu times out */
+    onTimeout?: (client: nodemod.Entity) => void;
+    /** Callback when menu is exited */
+    onExit?: (client: nodemod.Entity) => void;
+    /** Text for exit button */
+    exitText?: string;
+    /** Text for back button */
+    backText?: string;
+    /** Text for next page button */
+    nextText?: string;
+    /** Text for previous page button */
+    prevText?: string;
+    /** Custom formatting functions */
+    formatters?: MenuFormatters;
+}
+/**
+ * Functions for customizing menu display formatting.
+ */
+export interface MenuFormatters {
+    /** Format the menu title */
+    title?: (title: string) => string;
+    /** Format individual menu items */
+    item?: (item: MenuItem, index: number, isDisabled: boolean) => string;
+    /** Format pagination display */
+    pagination?: (current: number, total: number) => string;
+    /** Format divider between title and items */
+    divider?: () => string;
+}
+/**
+ * Internal state tracking for active menus.
+ */
+export interface MenuState {
+    /** Currently displayed menu */
+    menu: Menu;
+    /** Current page number (0-based) */
+    currentPage: number;
+    /** Navigation history for back functionality */
+    history: Menu[];
+    /** Whether this menu is shown to all players */
+    isAll: boolean;
+    /** Array of client indices that have used this menu */
+    used: number[];
+    /** Timeout ID for auto-close functionality */
+    timeoutId?: any;
+}
+/**
+ * Map of menu states indexed by client or 'all' for global menus.
+ */
+export interface MenuStateMap {
+    [key: string]: MenuState;
+    [key: number]: MenuState;
+}
+/**
+ * Represents a menu that can be displayed to players with navigable items and submenus.
+ *
+ * @example
+ * ```typescript
+ * const menu = new Menu({
+ *   title: 'Player Actions',
+ *   items: [
+ *     {
+ *       name: 'Kick Player',
+ *       handler: (client) => {
+ *         console.log(`${client.name} selected kick player`);
+ *       }
+ *     },
+ *     {
+ *       name: 'Ban Player',
+ *       handler: (client) => {
+ *         console.log(`${client.name} selected ban player`);
+ *       }
+ *     }
+ *   ]
+ * });
+ * ```
+ */
+export declare class Menu {
+    /** Menu title displayed at the top */
+    title: string;
+    /** Array of menu items */
+    items: MenuItem[];
+    /** Specific entity this menu is for (undefined = all players) */
+    entity?: nodemod.Entity;
+    /** Auto-close timeout in seconds (-1 for no timeout) */
+    time: number;
+    /** Callback when menu times out */
+    onTimeout?: (client: nodemod.Entity) => void;
+    /** Callback when menu is exited */
+    onExit?: (client: nodemod.Entity) => void;
+    /** Text for exit button */
+    exitText: string;
+    /** Text for back button */
+    backText: string;
+    /** Text for next page button */
+    nextText: string;
+    /** Text for previous page button */
+    prevText: string;
+    /** Formatting functions for menu display */
+    formatters: Required<MenuFormatters>;
+    /** Parent menu for navigation hierarchy */
+    parent?: Menu;
+    /**
+     * Creates a new Menu instance.
+     *
+     * @param options - Menu configuration options
+     */
+    constructor(options: MenuOptions);
+    /**
+     * Static template methods for creating common menu types.
+     */
+    static template: {
+        /**
+         * Creates a simple menu with string items and optional handlers.
+         *
+         * @param title - Menu title
+         * @param items - Array of item names
+         * @param handlers - Optional array of handlers (must match items length)
+         * @returns Configured Menu instance
+         *
+         * @example
+         * ```typescript
+         * const menu = Menu.template.simple(
+         *   'Choose Action',
+         *   ['Option 1', 'Option 2', 'Option 3'],
+         *   [(client) => console.log('Option 1'), (client) => console.log('Option 2')]
+         * );
+         * ```
+         */
+        simple: (title: string, items: string[], handlers?: MenuHandler[]) => Menu;
+        /**
+         * Creates a Yes/No confirmation menu.
+         *
+         * @param title - Menu title/question
+         * @param onYes - Handler for Yes selection
+         * @param onNo - Handler for No selection
+         * @returns Configured Menu instance
+         *
+         * @example
+         * ```typescript
+         * const menu = Menu.template.yesNo(
+         *   'Are you sure?',
+         *   (client) => console.log('User confirmed'),
+         *   (client) => console.log('User declined')
+         * );
+         * ```
+         */
+        yesNo: (title: string, onYes: MenuHandler, onNo: MenuHandler) => Menu;
+        /**
+         * Creates a confirmation menu with Confirm/Cancel options.
+         *
+         * @param message - Confirmation message
+         * @param onConfirm - Handler for Confirm selection
+         * @param onCancel - Optional handler for Cancel selection
+         * @returns Configured Menu instance
+         *
+         * @example
+         * ```typescript
+         * const menu = Menu.template.confirm(
+         *   'Delete all data?',
+         *   (client) => deleteData(),
+         *   (client) => console.log('Cancelled')
+         * );
+         * ```
+         */
+        confirm: (message: string, onConfirm: MenuHandler, onCancel?: MenuHandler) => Menu;
+    };
+}
+import type NodemodMsg from './msg';
+import type NodemodUtil from '../utils/util';
+/**
+ * Menu system manager for handling interactive menus in the nodemod plugin system.
+ * Supports pagination, navigation, timeouts, and both client-specific and global menus.
+ *
+ * @example
+ * ```typescript
+ * // Show a menu to all players
+ * nodemodCore.menu.show({
+ *   title: 'Admin Menu',
+ *   items: [
+ *     { name: 'Kick Player', handler: handleKick },
+ *     { name: 'Change Map', handler: handleMapChange }
+ *   ]
+ * });
+ *
+ * // Show a menu to a specific player
+ * nodemodCore.menu.show({
+ *   title: 'Player Options',
+ *   entity: specificPlayer,
+ *   items: [
+ *     { name: 'View Stats', handler: showStats }
+ *   ]
+ * });
+ * ```
+ */
+export default class NodemodMenu {
+    /** Map of active menu states by client index or 'all' */
+    private menuStates;
+    /** Message service for sending menu data */
+    private msg;
+    /** Utility service */
+    private util;
+    /** Maximum items per page (leaves slots for navigation) */
+    private readonly ITEMS_PER_PAGE;
+    /**
+     * Creates a new NodemodMenu instance.
+     *
+     * @param msgService - Message service for sending menu displays
+     * @param utilService - Utility service
+     */
+    constructor(msgService: NodemodMsg, utilService: NodemodUtil);
+    /**
+     * Initializes event handlers for menu interactions.
+     */
+    private initializeEventHandlers;
+    /**
+     * Handles menu selection commands from clients.
+     *
+     * @param client - The client entity that sent the command
+     * @param text - The command text containing menu selection
+     */
+    private handleMenuCommand;
+    private handleBackExit;
+    private handlePrevPage;
+    private handleNextPage;
+    private handleItemSelection;
+    private cleanupMenuState;
+    /**
+     * Displays a menu to players. Can show to all players or a specific entity.
+     *
+     * @param options - Menu configuration or Menu instance
+     *
+     * @example
+     * ```typescript
+     * // Show to all players
+     * nodemodCore.menu.show({
+     *   title: 'Server Menu',
+     *   items: [
+     *     { name: 'Option 1', handler: (client) => console.log('Selected 1') }
+     *   ]
+     * });
+     *
+     * // Show to specific player
+     * nodemodCore.menu.show({
+     *   title: 'Personal Menu',
+     *   entity: player,
+     *   time: 30, // Auto-close after 30 seconds
+     *   items: [
+     *     { name: 'View Profile', handler: showProfile }
+     *   ]
+     * });
+     * ```
+     */
+    show(options: MenuOptions | Menu): void;
+    private showMenuInternal;
+    private buildMenuDisplay;
+    /**
+     * Closes the menu for a specific client.
+     *
+     * @param client - The client to close the menu for
+     */
+    closeMenu(client: nodemod.Entity): void;
+    /**
+     * Closes all active menus and clears all menu states.
+     */
+    closeAllMenus(): void;
+    /** Export Menu class for external use */
+    static Menu: typeof Menu;
+}
+//# sourceMappingURL=menu.d.ts.map