vantiv.io 1.0.0

package/src/classes/Managers/DanceFloorManagers.js

@@ -0,0 +1,509 @@
+const fs = require('fs');
+const path = require('path');
+
+class DanceFloor {
+    constructor(bot) {
+        this.bot = bot
+        this.DanceFloorIds = new Map()
+        this.UserToFloorDance = new Map()
+        this.fileWatchers = new Map()
+        this.originalEmotes = new Map()
+
+        this.bot.on('Movement', async (user, position, anchor) => {
+            await this._handlePlayerMovement(user.id, user.username, position, anchor);
+        });
+
+        this.bot.on('UserLeft', (user) => {
+            this._removePlayer(user.id);
+        });
+    }
+
+    async create(Id, corners, emotes) {
+        this._validateId(Id)
+        this._checkDuplicateId(Id)
+        this._validateCorners(corners)
+
+        const { emoteArray, filePath } = await this._parseEmotes(Id, emotes)
+
+        const danceFloor = {
+            id: Id,
+            corners: { ...corners },
+            emotes: emoteArray,
+            players: [],
+            filePath: filePath
+        }
+
+        this.DanceFloorIds.set(Id, danceFloor)
+
+        if (filePath) {
+            this._setupFileWatcher(Id, filePath)
+            this.originalEmotes.set(Id, emotes)
+        }
+
+        return danceFloor
+    }
+
+    async hotReload(floorId) {
+        const floor = this.DanceFloorIds.get(floorId);
+        if (!floor) {
+            throw new Error(`Dance floor ${floorId} not found`);
+        }
+
+        if (!floor.filePath) {
+            throw new Error(`No file path for hot-reload`);
+        }
+
+        try {
+            const { emoteArray } = await this._parseEmotes(floorId, floor.filePath, true);
+
+            floor.emotes = emoteArray;
+
+            for (const player of floor.players) {
+                player.emoteIndex = player.emoteIndex % emoteArray.length;
+            }
+
+            return true;
+
+        } catch (error) {
+            console.error(`Hot-reload failed: ${error.message}`);
+            return false;
+        }
+    }
+
+    async reloadAll() {
+        const results = [];
+        for (const [floorId, floor] of this.DanceFloorIds) {
+            if (floor.filePath) {
+                try {
+                    const success = await this.hotReload(floorId);
+                    results.push({ floorId, success });
+                } catch (error) {
+                    results.push({ floorId, success: false, error: error.message });
+                }
+            }
+        }
+        return results;
+    }
+
+    async updateEmotes(floorId, newEmotes) {
+        const floor = this.DanceFloorIds.get(floorId);
+        if (!floor) {
+            throw new Error(`Dance floor ${floorId} not found`);
+        }
+
+        const { emoteArray } = await this._parseEmotes(floorId, newEmotes);
+
+        floor.emotes = emoteArray;
+        floor.filePath = null;
+
+        this.originalEmotes.set(floorId, newEmotes);
+
+        if (this.fileWatchers.has(floorId)) {
+            this.fileWatchers.get(floorId).close();
+            this.fileWatchers.delete(floorId);
+        }
+
+        for (const player of floor.players) {
+            player.emoteIndex = player.emoteIndex % emoteArray.length;
+        }
+
+        return true;
+    }
+
+    destroy() {
+        for (const [floorId, floor] of this.DanceFloorIds) {
+            for (const player of floor.players) {
+                this._stopDancing(player.id);
+            }
+        }
+
+        for (const watcher of this.fileWatchers.values()) {
+            watcher.close();
+        }
+
+        this.DanceFloorIds.clear();
+        this.UserToFloorDance.clear();
+        this.fileWatchers.clear();
+        this.originalEmotes.clear();
+
+        this.bot.removeAllListeners('Movement');
+        this.bot.removeAllListeners('UserLeft');
+    }
+
+    getInfo(Id) {
+        if (!this.DanceFloorIds.has(Id)) return null
+        const floor = this.DanceFloorIds.get(Id)
+        return {
+            id: floor.id,
+            corners: floor.corners,
+            emotes: floor.emotes,
+            playerCount: floor.players,
+            filePath: floor.filePath,
+            hasWatcher: this.fileWatchers.has(Id)
+        }
+    }
+
+    _setupFileWatcher(floorId, filePath) {
+        if (this.fileWatchers.has(floorId)) {
+            this.fileWatchers.get(floorId).close();
+        }
+
+        try {
+            const watcher = fs.watch(filePath, { persistent: false }, (eventType) => {
+                if (eventType === 'change') {
+                    setTimeout(() => {
+                        this.hotReload(floorId).catch(err => {
+                            console.error(`Auto-reload failed for ${floorId}: ${err.message}`);
+                        });
+                    }, 100);
+                }
+            });
+
+            watcher.on('error', (err) => {
+                console.error(`File watcher error for ${floorId}: ${err.message}`);
+                this.fileWatchers.delete(floorId);
+            });
+
+            this.fileWatchers.set(floorId, watcher);
+
+        } catch (error) {
+            console.warn(`Could not setup file watcher for ${floorId}: ${error.message}`);
+        }
+    }
+
+    async _parseEmotes(floorId, File, isHotReload = false) {
+        let filePath = null;
+        let emoteArray;
+
+        if (typeof File === 'string') {
+            filePath = path.resolve(File);
+            emoteArray = await this._validateAndParseEmotes(filePath);
+
+        } else if (Array.isArray(File)) {
+            emoteArray = this._parseEmoteArray(File);
+
+        } else if (typeof File === 'object' && File !== null) {
+            emoteArray = this._parseSingleEmote(File);
+
+        } else {
+            throw new TypeError('Invalid emotes format');
+        }
+
+        if (!isHotReload && filePath) {
+            setTimeout(() => {
+                console.log(`📁 Loaded ${emoteArray.length} emotes from: ${filePath}`);
+            }, 300);
+        }
+
+        return { emoteArray, filePath };
+    }
+
+    async _addPlayer(floorId, userId, username, position) {
+        const floor = this.DanceFloorIds.get(floorId);
+        if (!floor) throw new Error(`Dance floor ${floorId} not found`);
+
+        if (!this._isInDanceFloor(position, floor.corners)) {
+            throw new Error(`Player ${username} not in boundaries`);
+        }
+
+        const newPlayer = {
+            id: userId,
+            username,
+            position,
+            timeoutId: null,
+            emoteIndex: 0
+        }
+
+        floor.players.push(newPlayer);
+        this.UserToFloorDance.set(userId, floorId);
+
+        await this._startDancing(userId, floor);
+    }
+
+    _removePlayer(userId) {
+        const floorId = this.UserToFloorDance.get(userId);
+        if (!floorId) return;
+
+        const floor = this.DanceFloorIds.get(floorId);
+        floor.players = floor.players.filter(p => p.id !== userId);
+        this.UserToFloorDance.delete(userId);
+
+        this._stopDancing(userId);
+    }
+
+    _getFloorByUser(userId) {
+        if (!this.UserToFloorDance.has(userId)) return null
+        return this.DanceFloorIds.get(this.UserToFloorDance.get(userId))
+    }
+
+    _isInDanceFloor(position, corners) {
+        const { x, y, z } = position;
+        const { x: minX, x1: maxX, y: minY, y1: maxY, z: minZ, z1: maxZ } = corners;
+
+        return x >= minX && x <= maxX &&
+            y >= minY && y <= maxY &&
+            z >= minZ && z <= maxZ;
+    }
+
+    async _handlePlayerMovement(userId, username, position, anchor) {
+        const currentFloorId = this.UserToFloorDance.get(userId);
+
+        for (const [floorId, floor] of this.DanceFloorIds) {
+            const isNowIn = anchor ? false : this._isInDanceFloor(position, floor.corners);
+
+            if (!currentFloorId && isNowIn) {
+                await this._addPlayer(floorId, userId, username, position);
+                break;
+            }
+
+            else if (currentFloorId === floorId && !isNowIn) {
+                this._removePlayer(userId);
+                break;
+            }
+
+            else if (currentFloorId === floorId && isNowIn) {
+                this._updatePlayerPosition(userId, position);
+                break;
+            }
+        }
+    }
+
+    _updatePlayerPosition(userId, position) {
+        if (userId && typeof userId !== 'string') throw new TypeError('userId must be an string')
+
+        if (position && typeof position !== 'object') throw new TypeError('position must be an object')
+        if (!position.x || (position.x && typeof position.x !== 'number')) throw new TypeError('position.x must be number')
+        if (!position.y || (position.y && typeof position.y !== 'number')) throw new TypeError('position.y must be number')
+        if (!position.z || (position.z && typeof position.z !== 'number')) throw new TypeError('position.z must be number')
+
+        const floor = this._getFloorByUser(userId);
+        if (!floor) return;
+
+        const playerIndex = floor.players.findIndex(p => p.id === userId);
+        if (playerIndex !== -1) {
+            floor.players[playerIndex].position = position;
+        }
+
+    }
+
+    async _startDancing(userId, floor) {
+        const player = floor.players.find(p => p.id === userId);
+        if (!player) return;
+
+        const emoteLoop = async () => {
+            if (!this.UserToFloorDance.has(userId) ||
+                this.UserToFloorDance.get(userId) !== floor.id) {
+                return;
+            }
+
+            const currentEmote = floor.emotes[player.emoteIndex];
+            if (currentEmote?.id) {
+                const status = await this.bot.player.emote(currentEmote.id, userId)
+                if (!status) {
+                    this._stopDancing(userId)
+                }  
+            }
+
+            player.emoteIndex = (player.emoteIndex + 1) % floor.emotes.length;
+
+            player.timeoutId = setTimeout(async () => {
+                player.timeoutId = null;
+                await emoteLoop();
+            }, currentEmote?.duration * 1000 || 3000);
+        };
+
+        if (player.timeoutId) {
+            clearTimeout(player.timeoutId);
+            player.timeoutId = null;
+        }
+
+        await emoteLoop();
+    }
+
+    _stopDancing(userId) {
+        const floorId = this.UserToFloorDance.get(userId);
+        if (!floorId) return false;
+
+        const floor = this.DanceFloorIds.get(floorId);
+        if (!floor) {
+            this.UserToFloorDance.delete(userId);
+            return false;
+        }
+
+        const playerIndex = floor.players.findIndex(p => p.id === userId);
+        if (playerIndex === -1) {
+            this.UserToFloorDance.delete(userId);
+            return false;
+        }
+
+        const player = floor.players[playerIndex];
+
+        if (player.timeoutId) {
+            clearTimeout(player.timeoutId);
+            player.timeoutId = null;
+        }
+
+        try {
+            this.bot.player.emote('idle', userId);
+        } catch (error) {
+        }
+
+        floor.players.splice(playerIndex, 1);
+
+        this.UserToFloorDance.delete(userId);
+
+        return true;
+    }
+
+    _validateId(Id) {
+        if (!Id || (Id && typeof Id !== 'string')) {
+            throw new TypeError('Id must be a non-empty string')
+        }
+    }
+
+    _checkDuplicateId(Id) {
+        if (this.DanceFloorIds.has(Id)) {
+            throw new Error(`Dance floor with Id '${Id}' already exists`)
+        }
+    }
+
+    _validateCorners(corners) {
+        if (!corners || typeof corners !== 'object') {
+            throw new TypeError('corners must be an object with x, y, z, x1, y1, z1 properties')
+        }
+
+        const requiredCorners = ['x', 'y', 'z', 'x1', 'y1', 'z1']
+        for (const corner of requiredCorners) {
+            this._validateCornerValue(corners, corner)
+        }
+    }
+
+    _validateCornerValue(corners, cornerName) {
+        if (typeof corners[cornerName] !== 'number') {
+            throw new TypeError(`corner.${cornerName} must be a number`)
+        }
+        if (corners[cornerName] < 0 || corners[cornerName] > 30) {
+            throw new RangeError(`corner.${cornerName} must be between 0 and 30 (inclusive)`)
+        }
+    }
+
+    async _validateAndParseEmotes(emotes) {
+        if (typeof emotes !== 'string') {
+            throw new TypeError('emotes must be a string file path to a JSON file')
+        }
+
+        const isFilePath = this._isValidFilePath(emotes)
+        if (!isFilePath) {
+            throw new TypeError('emotes must be a valid file path to a JSON file')
+        }
+
+        const jsonData = await this._readAndParseJsonFile(emotes)
+        this._validateJsonStructure(jsonData)
+
+        const emoteArray = this._parseEmotesFromJson(jsonData)
+
+        if (emoteArray.length === 0) {
+            throw new Error('JSON file must contain at least one emote in the emotes array')
+        }
+
+        return emoteArray
+    }
+
+    _parseEmoteArray(emotes) {
+        if (!Array.isArray(emotes)) {
+            throw new TypeError('Emote array must be an array')
+        }
+        if (emotes.length === 0) {
+            throw new Error('Emote array must contain at least one emote')
+        }
+        return emotes.map((emote, index) => this._validateAndParseEmote(emote, index))
+    }
+
+    _parseSingleEmote(emote) {
+        if (!emote || typeof emote !== 'object') {
+            throw new TypeError('Single emote must be an object')
+        }
+        return [this._validateAndParseEmote(emote, 0)]
+    }
+
+    _isValidFilePath(filePath) {
+        return filePath.endsWith('.json') ||
+            filePath.includes('/') ||
+            filePath.includes('\\') ||
+            filePath.includes('.json');
+    }
+
+    async _readAndParseJsonFile(filePath) {
+        try {
+            const fileContent = await fs.promises.readFile(filePath, 'utf8');
+            return JSON.parse(fileContent)
+        } catch (error) {
+            this._handleFileError(error, filePath)
+        }
+    }
+
+    _handleFileError(error, filePath) {
+        if (error.code === 'ENOENT') {
+            throw new Error(`Emote file not found: ${filePath}`)
+        }
+        if (error instanceof SyntaxError) {
+            throw new Error(`Invalid JSON in file: ${filePath}`)
+        }
+        throw new Error(`Failed to process emote file: ${error.message}`)
+    }
+
+    _validateJsonStructure(jsonData) {
+        if (!jsonData || typeof jsonData !== 'object') {
+            throw new Error('JSON file must contain an object')
+        }
+
+        if (!Array.isArray(jsonData.emotes)) {
+            throw new Error('JSON must have an "emotes" property containing an array')
+        }
+    }
+
+    _parseEmotesFromJson(jsonData) {
+        return jsonData.emotes.map((emote, index) => {
+            return this._validateAndParseEmote(emote, index)
+        })
+    }
+
+    _validateAndParseEmote(emote, index) {
+        if (!emote || typeof emote !== 'object') {
+            throw new Error(`Emote at index ${index} must be an object`)
+        }
+
+        this._validateEmoteProperty(emote, 'id', 'string', index)
+        this._validateEmoteProperty(emote, 'name', 'string', index)
+        this._validateEmoteProperty(emote, 'duration', 'number', index)
+
+        if (!emote.id.trim()) {
+            throw new Error(`Emote at index ${index} has an empty "id"`)
+        }
+
+        if (!emote.name.trim()) {
+            throw new Error(`Emote at index ${index} has an empty "name"`)
+        }
+
+        if (emote.duration < 0) {
+            throw new Error(`Emote at index ${index} has a negative "duration"`)
+        }
+
+        return {
+            id: emote.id.trim(),
+            name: emote.name.trim(),
+            duration: emote.duration
+        }
+    }
+
+    _validateEmoteProperty(emote, property, expectedType, index) {
+        if (!(property in emote)) {
+            throw new Error(`Emote at index ${index} is missing "${property}" property`)
+        }
+        if (typeof emote[property] !== expectedType) {
+            throw new Error(`Emote at index ${index} has invalid "${property}" type. Expected ${expectedType}`)
+        }
+    }
+}
+
+module.exports = DanceFloor

package/src/classes/Managers/Helpers/CleanupManager.js

@@ -0,0 +1,130 @@
+class CleanupManager {
+    constructor() {
+        this.timers = new Set();
+        this.intervals = new Set();
+        this.resources = new Set();
+        this.listeners = new Map();
+    }
+    
+    registerTimer(timer) {
+        this.timers.add(timer);
+        return timer;
+    }
+    
+    registerInterval(interval) {
+        this.intervals.add(interval);
+        return interval;
+    }
+    
+    registerResource(resource) {
+        this.resources.add(resource);
+        return resource;
+    }
+    
+    registerListener(emitter, event, listener) {
+        if (!this.listeners.has(emitter)) {
+            this.listeners.set(emitter, []);
+        }
+        
+        this.listeners.get(emitter).push({ event, listener });
+        emitter.on(event, listener);
+        
+        return { emitter, event, listener };
+    }
+    
+    registerCleanupMethod(method) {
+        const resource = { cleanup: method };
+        this.resources.add(resource);
+        return resource;
+    }
+    
+    cleanup() {
+        // Clear all timers
+        for (const timer of this.timers) {
+            clearTimeout(timer);
+        }
+        this.timers.clear();
+        
+        // Clear all intervals
+        for (const interval of this.intervals) {
+            clearInterval(interval);
+        }
+        this.intervals.clear();
+        
+        // Remove all listeners
+        for (const [emitter, listeners] of this.listeners) {
+            for (const { event, listener } of listeners) {
+                emitter.removeListener(event, listener);
+            }
+        }
+        this.listeners.clear();
+        
+        // Clean up all resources
+        for (const resource of this.resources) {
+            try {
+                if (typeof resource.cleanup === 'function') {
+                    resource.cleanup();
+                } else if (typeof resource.destroy === 'function') {
+                    resource.destroy();
+                } else if (typeof resource.close === 'function') {
+                    resource.close();
+                } else if (typeof resource.disconnect === 'function') {
+                    resource.disconnect();
+                }
+            } catch (error) {
+                // Silently fail during cleanup
+            }
+        }
+        this.resources.clear();
+    }
+    
+    removeTimer(timer) {
+        if (this.timers.has(timer)) {
+            clearTimeout(timer);
+            this.timers.delete(timer);
+            return true;
+        }
+        return false;
+    }
+    
+    removeInterval(interval) {
+        if (this.intervals.has(interval)) {
+            clearInterval(interval);
+            this.intervals.delete(interval);
+            return true;
+        }
+        return false;
+    }
+    
+    removeResource(resource) {
+        return this.resources.delete(resource);
+    }
+    
+    removeListener(emitter, event, listener) {
+        const listeners = this.listeners.get(emitter);
+        if (!listeners) return false;
+        
+        const index = listeners.findIndex(l => l.event === event && l.listener === listener);
+        if (index !== -1) {
+            emitter.removeListener(event, listener);
+            listeners.splice(index, 1);
+            
+            if (listeners.length === 0) {
+                this.listeners.delete(emitter);
+            }
+            return true;
+        }
+        return false;
+    }
+    
+    getStats() {
+        return {
+            timers: this.timers.size,
+            intervals: this.intervals.size,
+            resources: this.resources.size,
+            listeners: Array.from(this.listeners.values()).reduce((sum, arr) => sum + arr.length, 0)
+        };
+    }
+}
+
+module.exports = CleanupManager;