nodejs-slikenet/index.js

Node.js native addon for SLikeNet networking library with improved thread management architecture

const EventEmitter = require('events');
const slikenet = require('./build/Release/slikenet');

class SlikeNetPeer extends EventEmitter {
    constructor() {
        super();
        this.peer = slikenet.createPeer();
        this.isInitialized = false;
        this.isStarted = false;
        
        // Set up event callbacks that will emit events
        this.setupEventCallbacks();
    }

    /**
     * Setup event callbacks that emit events
     */
    setupEventCallbacks() {
        // Connection callback
        slikenet.setConnectCallback(this.peer, () => {
            console.log('Connected to server');
            this.emit('connect');
        });

        // Disconnection callback  
        slikenet.setDisconnectCallback(this.peer, () => {
            console.log('Disconnected from server');
            this.emit('disconnect');
        });
    }

    /**
     * Initialize the peer
     * @param {number} maxConnections - Maximum number of connections
     * @returns {boolean} Success status
     */
    initialize(maxConnections = 32) {
        if (this.isInitialized) {
            console.warn('Peer already initialized');
            return true;
        }
        
        this.isInitialized = slikenet.initializePeer(this.peer);
        return this.isInitialized;
    }

    /**
     * Startup the peer
     * @param {number} maxConnections - Maximum number of connections
     * @param {number} maxIncomingConnections - Maximum incoming connections
     * @returns {boolean} Success status
     */
    startup(maxConnections = 32, maxIncomingConnections = 0) {
        if (!this.isInitialized) {
            console.error('Peer must be initialized first');
            return false;
        }
        
        if (this.isStarted) {
            console.warn('Peer already started');
            return true;
        }
        
        this.isStarted = slikenet.startupPeer(this.peer, maxConnections, maxIncomingConnections);
        return this.isStarted;
    }

    /**
     * Connect to a server
     * @param {string} host - Server hostname or IP
     * @param {number} port - Server port
     * @returns {number} Connection result code
     */
    connect(host, port) {
        if (!this.isStarted) {
            console.error('Peer must be started first');
            return -1;
        }
        
        return slikenet.connectPeer(this.peer, host, port);
    }

    /**
     * Check if connected
     * @returns {boolean} Connection status
     */
    isConnected() {
        return slikenet.isConnected(this.peer);
    }

    /**
     * Send data
     * @param {string|Buffer} data - Data to send
     * @returns {boolean} Success status
     */
    send(data) {
        if (!this.isStarted) {
            console.error('Peer must be started first');
            return false;
        }
        
        return slikenet.sendData(this.peer, data);
    }

    /**
     * Listen for specific packet ID
     * @param {number} packetID - Packet ID to listen for
     * @param {function} handler - Handler function for the packet
     */
    listen(packetID, handler) {
        if (typeof packetID !== 'number' || packetID < 0 || packetID > 255) {
            throw new Error('packetID must be a number between 0 and 255');
        }
        
        if (typeof handler !== 'function') {
            throw new Error('handler must be a function');
        }
        
        slikenet.listen(this.peer, packetID, handler);
    }

    /**
     * Remove listener for specific packet ID
     * @param {number} packetID - Packet ID to remove listener from
     * @param {function} handler - Handler function to remove
     */
    removeListener(packetID, handler) {
        if (typeof packetID !== 'number' || packetID < 0 || packetID > 255) {
            throw new Error('packetID must be a number between 0 and 255');
        }
        
        slikenet.removeListener(this.peer, packetID, handler);
    }

    /**
     * Remove all listeners
     */
    removeAllListeners() {
        slikenet.removeAllListeners(this.peer);
    }

    /**
     * Get connection state
     * @returns {number} Connection state (0 = disconnected, 1 = connected)
     */
    getConnectionState() {
        return slikenet.getConnectionState(this.peer);
    }

    /**
     * Get connection statistics
     * @returns {string} Statistics string
     */
    getStatistics() {
        return slikenet.getStatistics(this.peer);
    }

    /**
     * Shutdown the peer
     */
    shutdown() {
        if (this.isStarted) {
            slikenet.shutdownPeer(this.peer);
            this.isStarted = false;
        }
        this.isInitialized = false;
        
        // Remove all event listeners
        this.removeAllListeners();
    }
}

// Export the class and raw functions
module.exports = {
    SlikeNetPeer,
    createPeer: slikenet.createPeer,
    initializePeer: slikenet.initializePeer,
    startupPeer: slikenet.startupPeer,
    shutdownPeer: slikenet.shutdownPeer,
    connectPeer: slikenet.connectPeer,
    isConnected: slikenet.isConnected,
    sendData: slikenet.sendData,
    listen: slikenet.listen,
    removeListener: slikenet.removeListener,
    removeAllListeners: slikenet.removeAllListeners,
    getStatistics: slikenet.getStatistics,
    getConnectionState: slikenet.getConnectionState,
    setConnectCallback: slikenet.setConnectCallback,
    setDisconnectCallback: slikenet.setDisconnectCallback
};