vantiv.io 1.0.0

package/src/classes/Caches/MovementCache.js

@@ -0,0 +1,357 @@
+class MovementCache {
+    constructor() {
+        this._activeCache = new Map();
+        this._inactiveCache = new Map();
+        this._usernameToId = new Map();
+        this._changes = new Map();
+        this._inactiveThreshold = 30 * 1000;
+        this._cleanupInterval = setInterval(() => this._cleanInactive(), 30 * 1000);
+    }
+
+    _cleanInactive() {
+        const now = Date.now();
+
+        for (const [userId, data] of this._inactiveCache) {
+            if (now - data.lastSeen > this._inactiveThreshold) {
+                this._inactiveCache.delete(userId);
+                this._changes.delete(userId);
+                this._usernameToId.delete(data.username);
+            }
+        }
+
+        for (const [userId, data] of this._activeCache) {
+            if (now - data.lastSeen > this._inactiveThreshold) {
+                this._inactiveCache.set(userId, data);
+                this._activeCache.delete(userId);
+                this._changes.delete(userId);
+            }
+        }
+    }
+
+    _toUint8Array(position) {
+        const buffer = new Uint8Array(4);
+        buffer[0] = Math.round(position.x);
+        buffer[1] = Math.round(position.y);
+        buffer[2] = Math.round(position.z);
+        buffer[3] = this._facingToByte(position.facing);
+        return buffer;
+    }
+
+    _facingToByte(facing) {
+        const map = { 'FrontRight': 0, 'FrontLeft': 1, 'BackRight': 2, 'BackLeft': 3 };
+        return map[facing] || 0;
+    }
+
+    _byteToFacing(byte) {
+        const map = ['FrontRight', 'FrontLeft', 'BackRight', 'BackLeft'];
+        return map[byte] || 'FrontRight';
+    }
+
+    _fromUint8Array(buffer) {
+        return {
+            x: buffer[0],
+            y: buffer[1],
+            z: buffer[2],
+            facing: this._byteToFacing(buffer[3])
+        };
+    }
+
+    _hasPositionChanged(userId, newPosition) {
+        const oldData = this._activeCache.get(userId);
+        if (!oldData) return true;
+
+        const oldPos = this._fromUint8Array(oldData.position);
+        return oldPos.x !== newPosition.x || oldPos.y !== newPosition.y || oldPos.z !== newPosition.z || oldPos.facing !== newPosition.facing;
+    }
+
+    _update(userId, username, position, anchor = null) {
+        this._usernameToId.set(username, userId);
+
+        const hasChanged = this._hasPositionChanged(userId, position);
+
+        if (hasChanged) {
+            const cachedData = {
+                position: this._toUint8Array(position),
+                anchor: anchor ? { entity_id: anchor.entity_id, anchor_ix: anchor.anchor_ix } : null,
+                lastSeen: Date.now(),
+                username: username
+            };
+
+            this._activeCache.set(userId, cachedData);
+            this._changes.set(userId, cachedData);
+            this._inactiveCache.delete(userId);
+            return true;
+        } else {
+            const existing = this._activeCache.get(userId) || this._inactiveCache.get(userId);
+            if (existing) {
+                existing.lastSeen = Date.now();
+            } else {
+                this._inactiveCache.set(userId, {
+                    position: this._toUint8Array(position),
+                    anchor,
+                    lastSeen: Date.now(),
+                    username: username
+                });
+            }
+            return false;
+        }
+    }
+
+    _getById(userId) {
+        let data = this._activeCache.get(userId) || this._inactiveCache.get(userId);
+        if (data) {
+            return {
+                position: this._fromUint8Array(data.position),
+                anchor: data.anchor,
+                lastSeen: data.lastSeen,
+                username: data.username
+            };
+        }
+        return null;
+    }
+
+    getPlayersInSquare(center, sideLength) {
+        const halfSide = sideLength / 2;
+
+        return this.getPlayersInRectangle({
+            c1: { x: center.x - halfSide, z: center.z - halfSide },
+            c2: { x: center.x + halfSide, z: center.z - halfSide },
+            c3: { x: center.x + halfSide, z: center.z + halfSide },
+            c4: { x: center.x - halfSide, z: center.z + halfSide }
+        });
+    }
+
+    getPlayersInRectangle({ c1, c2, c3, c4 }) {
+        const playersInArea = [];
+
+        const allUsers = new Map([...this._activeCache, ...this._inactiveCache]);
+
+        for (const [userId, cachedData] of allUsers) {
+            const position = this._fromUint8Array(cachedData.position);
+
+            if (this._isPointInRectangle(position, { c1, c2, c3, c4 })) {
+                playersInArea.push({
+                    user: {
+                        id: userId,
+                        username: cachedData.username
+                    },
+                    position: position,
+                    anchor: cachedData.anchor,
+                    lastSeen: cachedData.lastSeen
+                });
+            }
+        }
+
+        return playersInArea;
+    }
+
+    _isPointInRectangle(point, { c1, c2, c3, c4 }) {
+        const corners = [c1, c2, c3, c4];
+
+        let inside = false;
+        for (let i = 0, j = corners.length - 1; i < corners.length; j = i++) {
+            const xi = corners[i].x, zi = corners[i].z;
+            const xj = corners[j].x, zj = corners[j].z;
+
+            const intersect = ((zi > point.z) !== (zj > point.z)) &&
+                (point.x < (xj - xi) * (point.z - zi) / (zj - zi) + xi);
+
+            if (intersect) inside = !inside;
+        }
+
+        return inside;
+    }
+
+    getPlayersInCircle(center, radius) {
+        const playersInArea = [];
+        const radiusSquared = radius * radius;
+        const allUsers = this._activeCache.size + this._inactiveCache.size > 0 ?
+            new Map([...this._activeCache, ...this._inactiveCache]) : new Map();
+
+        if (allUsers.size === 0) return playersInArea;
+
+        for (const [userId, cachedData] of allUsers) {
+            const pos = this._fromUint8Array(cachedData.position);
+            const dx = pos.x - center.x;
+            const dz = pos.z - center.z;
+            const distSq = dx * dx + dz * dz;
+
+            if (distSq <= radiusSquared) {
+                const distance = Math.sqrt(distSq);
+                const roundedDistance = distance % 1 === 0 ? distance : Math.round(distance * 100) / 100;
+
+                playersInArea.push({
+                    user: { id: userId, username: cachedData.username },
+                    position: pos,
+                    anchor: cachedData.anchor,
+                    lastSeen: cachedData.lastSeen,
+                    distance: roundedDistance
+                });
+            }
+        }
+
+        if (playersInArea.length > 1) {
+            playersInArea.sort((a, b) => a.distance - b.distance);
+        }
+
+        return playersInArea;
+    }
+
+    getPlayersInVerticalRange(minY, maxY) {
+        const playersInRange = [];
+        const allUsers = new Map([...this._activeCache, ...this._inactiveCache]);
+
+        for (const [userId, cachedData] of allUsers) {
+            const position = this._fromUint8Array(cachedData.position);
+
+            if (position.y >= minY && position.y <= maxY) {
+                playersInRange.push({
+                    user: {
+                        id: userId,
+                        username: cachedData.username
+                    },
+                    position: position,
+                    anchor: cachedData.anchor,
+                    lastSeen: cachedData.lastSeen
+                });
+            }
+        }
+
+        return playersInRange;
+    }
+
+    getClosestPlayer(point) {
+        const allPlayers = this.getPlayersByDistance(point, Infinity);
+        return allPlayers.length > 0 ? allPlayers[0] : null;
+    }
+
+    getPlayersByDistance(point, maxDistance = Infinity) {
+        if (this._activeCache.size === 0 && this._inactiveCache.size === 0) {
+            return [];
+        }
+
+        const playersWithDistance = [];
+        const maxDistanceSq = maxDistance * maxDistance;
+
+        // Pre-calculate for performance
+        const pointX = point.x;
+        const pointZ = point.z;
+
+        // Check active cache first (most likely to be relevant)
+        for (const [userId, cachedData] of this._activeCache) {
+            const pos = this._fromUint8Array(cachedData.position);
+            const dx = pos.x - pointX;
+            const dz = pos.z - pointZ;
+            const distSq = dx * dx + dz * dz;
+
+            if (distSq <= maxDistanceSq) {
+                playersWithDistance.push({
+                    user: { id: userId, username: cachedData.username },
+                    position: pos,
+                    anchor: cachedData.anchor,
+                    lastSeen: cachedData.lastSeen,
+                    distance: Math.sqrt(distSq)
+                });
+            }
+        }
+
+        for (const [userId, cachedData] of this._inactiveCache) {
+            const pos = this._fromUint8Array(cachedData.position);
+            const dx = pos.x - pointX;
+            const dz = pos.z - pointZ;
+            const distSq = dx * dx + dz * dz;
+
+            if (distSq <= maxDistanceSq) {
+                playersWithDistance.push({
+                    user: { id: userId, username: cachedData.username },
+                    position: pos,
+                    anchor: cachedData.anchor,
+                    lastSeen: cachedData.lastSeen,
+                    distance: Math.sqrt(distSq)
+                });
+            }
+        }
+
+        if (playersWithDistance.length > 1) {
+            playersWithDistance.sort((a, b) => a.distance - b.distance);
+        }
+
+        return playersWithDistance;
+    }
+
+    isPlayerInSquare(userId, center, sideLength) {
+        const player = this._getById(userId);
+        if (!player) return false;
+
+        const halfSide = sideLength / 2;
+        const corners = {
+            c1: { x: center.x - halfSide, z: center.z - halfSide },
+            c2: { x: center.x + halfSide, z: center.z - halfSide },
+            c3: { x: center.x + halfSide, z: center.z + halfSide },
+            c4: { x: center.x - halfSide, z: center.z + halfSide }
+        };
+
+        return this._isPointInRectangle(player.position, corners);
+    }
+
+    isPlayerInRectangle(userId, corners) {
+        const player = this._getById(userId);
+        if (!player) return false;
+
+        return this._isPointInRectangle(player.position, corners);
+    }
+
+    getPlayerCountInSquare(center, sideLength) {
+        return this.getPlayersInSquare(center, sideLength).length;
+    }
+
+    getPlayerCountInRectangle(corners) {
+        return this.getPlayersInRectangle(corners).length;
+    }
+
+    _getByUsername(username) {
+        const userId = this._usernameToId.get(username);
+        return userId ? this._getById(userId) : null;
+    }
+
+    get(identifier) {
+        const byId = this._getById(identifier);
+        if (byId) return byId;
+        return this._getByUsername(identifier);
+    }
+
+    _remove(userId) {
+        const data = this._activeCache.get(userId) || this._inactiveCache.get(userId);
+        if (data) {
+            this._usernameToId.delete(data.username);
+        }
+        this._activeCache.delete(userId);
+        this._inactiveCache.delete(userId);
+        this._changes.delete(userId);
+    }
+
+    getStats() {
+        const activeUsers = this._activeCache.size;
+        const inactiveUsers = this._inactiveCache.size;
+        const memoryUsage = (activeUsers * 120) + (inactiveUsers * 80);
+
+        return {
+            activeUsers,
+            inactiveUsers,
+            memoryUsage,
+            changesProcessed: this._changes.size,
+            totalUsers: activeUsers + inactiveUsers
+        };
+    }
+
+    destroy() {
+        clearInterval(this._cleanupInterval);
+        this._activeCache.clear();
+        this._inactiveCache.clear();
+        this._usernameToId.clear();
+        this._changes.clear();
+    }
+}
+
+module.exports = { MovementCache }
+

package/src/classes/Handlers/AxiosErrorHandler.js

@@ -0,0 +1,68 @@
+class AxiosErrorHandler {
+    static handle(error, logger, method, context = {}) {
+        const errorInfo = {
+            ...context,
+            code: error.code,
+            message: error.message
+        }
+
+        if (error.response) {
+            errorInfo.status = error.response.status
+            errorInfo.statusText = error.response.statusText
+            errorInfo.data = error.response.data
+
+            switch (error.response.status) {
+                case 400:
+                    logger.warn(method, `Bad Request`, errorInfo)
+                    break
+                case 401:
+                    logger.warn(method, `Unauthorized`, errorInfo)
+                    break
+                case 403:
+                    logger.warn(method, `Forbidden`, errorInfo)
+                    break
+                case 404:
+                    logger.warn(method, `Not Found`, errorInfo)
+                    break
+                case 429:
+                    logger.warn(method, `Rate Limited`, errorInfo)
+                    break
+                case 500:
+                    logger.error(method, `Server Error`, errorInfo)
+                    break
+                case 502:
+                    logger.error(method, `Bad Gateway`, errorInfo)
+                    break
+                case 503:
+                    logger.error(method, `Service Unavailable`, errorInfo)
+                    break
+                default:
+                    logger.error(method, `HTTP ${error.response.status}`, errorInfo)
+            }
+        } else if (error.request) {
+            logger.error(method, `Network Error - No response received`, errorInfo)
+        } else if (error.code === 'ECONNABORTED') {
+            logger.error(method, `Request Timeout`, errorInfo)
+        } else if (error.code === 'ENOTFOUND') {
+            logger.error(method, `DNS Lookup Failed`, errorInfo)
+        } else {
+            logger.error(method, `Unexpected Error`, errorInfo)
+        }
+
+        return null
+    }
+
+    static isNotFound(error) {
+        return error.response && error.response.status === 404
+    }
+
+    static isRateLimited(error) {
+        return error.response && error.response.status === 429
+    }
+
+    static isServerError(error) {
+        return error.response && error.response.status >= 500
+    }
+}
+
+module.exports = { AxiosErrorHandler }

package/src/classes/Handlers/ErrorHandler.js

@@ -0,0 +1,65 @@
+class ErrorHandler {
+    static isConnectionError(error) {
+        const connectionErrors = [
+            'ECONNREFUSED', 'ECONNRESET', 'EPIPE', 'ETIMEDOUT',
+            'ENOTFOUND', 'EHOSTUNREACH', 'ENETUNREACH'
+        ];
+        
+        return connectionErrors.includes(error.code);
+    }
+    
+    static isWebSocketError(error) {
+        const wsErrors = [
+            'is not connected',
+            'WebSocket is not open',
+            'readyState',
+            'WebSocket'
+        ];
+        
+        return wsErrors.some(msg => error.message.includes(msg));
+    }
+    
+    static isRateLimitError(error) {
+        return error.response?.status === 429 || 
+               error.message?.includes('rate limit') ||
+               error.message?.includes('too many requests');
+    }
+    
+    static createError(error, context = {}) {
+        const enhancedError = new Error(error.message || error);
+        
+        enhancedError.timestamp = Date.now();
+        enhancedError.context = context;
+        enhancedError.originalError = error;
+        enhancedError.code = error.code;
+        
+        if (error.response) {
+            enhancedError.status = error.response.status;
+            enhancedError.statusText = error.response.statusText;
+            enhancedError.data = error.response.data;
+        }
+        
+        return enhancedError;
+    }
+    
+    static shouldRetry(error, attempt, maxRetries) {
+        if (attempt >= maxRetries) return false;
+        
+        // Don't retry these errors
+        if (error.code === 'ENOTFOUND') return false;
+        if (error.response?.status >= 400 && error.response?.status < 500) return false;
+        
+        // Retry these errors
+        if (this.isConnectionError(error)) return true;
+        if (this.isRateLimitError(error)) return true;
+        if (error.response?.status >= 500) return true;
+        
+        return false;
+    }
+    
+    static getRetryDelay(attempt, baseDelay = 100) {
+        return Math.min(baseDelay * Math.pow(2, attempt), 5000);
+    }
+}
+
+module.exports = ErrorHandler;