ts-game-decorators 1.0.0

package/dist/config/redis.d.ts

@@ -0,0 +1,7 @@
+export declare const createRedisAdapter: () => Promise<any>;
+export declare const getRedisAdapter: () => any;
+export declare const getRedisClients: () => {
+    pubClient: any;
+    subClient: any;
+};
+export declare const closeRedisConnections: () => Promise<void>;

package/dist/config/redis.js

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.closeRedisConnections = exports.getRedisClients = exports.getRedisAdapter = exports.createRedisAdapter = void 0;
+const redis_1 = require("redis");
+const redis_adapter_1 = require("@socket.io/redis-adapter");
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config();
+const REDIS_URL = process.env.REDIS_URL || 'redis://localhost:6379';
+const REDIS_USERNAME = process.env.REDIS_USERNAME;
+const REDIS_PASSWORD = process.env.REDIS_PASSWORD;
+// Redis client instances for reuse
+let pubClient = null;
+let subClient = null;
+let redisAdapter = null;
+const createRedisAdapter = async () => {
+    try {
+        console.log('🔗 Connecting to Redis...');
+        // Build Redis client configuration
+        const redisConfig = {
+            url: REDIS_URL,
+            socket: {
+                reconnectStrategy: (retries) => {
+                    if (retries > 10) {
+                        console.error('❌ Redis: Too many retries, giving up');
+                        return new Error('Too many retries');
+                    }
+                    console.log(`🔄 Redis: Retrying connection (${retries}/10)`);
+                    return Math.min(retries * 100, 3000);
+                }
+            }
+        };
+        // Only add authentication if credentials are provided
+        if (REDIS_USERNAME) {
+            redisConfig.username = REDIS_USERNAME;
+        }
+        if (REDIS_PASSWORD) {
+            redisConfig.password = REDIS_PASSWORD;
+        }
+        console.log(`🔗 Redis config: ${REDIS_URL} ${REDIS_USERNAME ? `(username: ${REDIS_USERNAME})` : ''} ${REDIS_PASSWORD ? '(password: ***)' : '(no auth)'}`);
+        // Create publisher client
+        pubClient = (0, redis_1.createClient)(redisConfig);
+        // Create subscriber client (duplicate of publisher)
+        subClient = pubClient.duplicate();
+        // Error handling for publisher
+        pubClient.on('error', (err) => {
+            console.error('❌ Redis Publisher Error:', err);
+        });
+        pubClient.on('connect', () => {
+            console.log('✅ Redis Publisher connected');
+        });
+        pubClient.on('reconnecting', () => {
+            console.log('🔄 Redis Publisher reconnecting...');
+        });
+        // Error handling for subscriber
+        subClient.on('error', (err) => {
+            console.error('❌ Redis Subscriber Error:', err);
+        });
+        subClient.on('connect', () => {
+            console.log('✅ Redis Subscriber connected');
+        });
+        subClient.on('reconnecting', () => {
+            console.log('🔄 Redis Subscriber reconnecting...');
+        });
+        // Connect both clients
+        await Promise.all([pubClient.connect(), subClient.connect()]);
+        // Create Socket.IO Redis adapter
+        redisAdapter = (0, redis_adapter_1.createAdapter)(pubClient, subClient, {
+            key: 'socket.io',
+            requestsTimeout: 5000
+        });
+        console.log('✅ Redis adapter created successfully');
+        return redisAdapter;
+    }
+    catch (error) {
+        console.error('❌ Failed to create Redis adapter:', error);
+        throw error;
+    }
+};
+exports.createRedisAdapter = createRedisAdapter;
+// Function to get Redis adapter instance
+const getRedisAdapter = () => {
+    return redisAdapter;
+};
+exports.getRedisAdapter = getRedisAdapter;
+// Function to get Redis clients for direct operations
+const getRedisClients = () => {
+    return { pubClient, subClient };
+};
+exports.getRedisClients = getRedisClients;
+// Graceful shutdown for Redis connections
+const closeRedisConnections = async () => {
+    try {
+        console.log('🛑 Closing Redis connections...');
+        if (pubClient && pubClient.isOpen) {
+            try {
+                await pubClient.quit();
+                console.log('✅ Redis Publisher connection closed');
+            }
+            catch (error) {
+                console.error('❌ Error closing Redis Publisher connection:', error);
+            }
+        }
+        else if (pubClient) {
+            console.log('⚠️ Redis Publisher was already closed');
+        }
+        if (subClient && subClient.isOpen) {
+            try {
+                await subClient.quit();
+                console.log('✅ Redis Subscriber connection closed');
+            }
+            catch (error) {
+                console.error('❌ Error closing Redis Subscriber connection:', error);
+            }
+        }
+        else if (subClient) {
+            console.log('⚠️ Redis Subscriber was already closed');
+        }
+    }
+    catch (error) {
+        console.error('❌ Error closing Redis connections:', error);
+    }
+};
+exports.closeRedisConnections = closeRedisConnections;

package/dist/db/couchbaseClient.d.ts

@@ -0,0 +1,4 @@
+import { Collection } from 'couchbase';
+export declare function connectToCouchbase(): Promise<void>;
+export declare function queryData(query: string): Promise<any[]>;
+export declare function getCouchbaseUsersCollection(): Collection;

package/dist/db/couchbaseClient.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectToCouchbase = connectToCouchbase;
+exports.queryData = queryData;
+exports.getCouchbaseUsersCollection = getCouchbaseUsersCollection;
+const couchbase_1 = require("couchbase");
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config();
+let cluster;
+let bucket;
+let dataCollection;
+async function connectToCouchbase() {
+    try {
+        // Kết nối với Couchbase Cluster
+        cluster = await couchbase_1.Cluster.connect(`couchbase://${process.env.COUCHBASE_URL || '165.22.240.52'}`, {
+            username: process.env.COUCHBASE_USERNAME || 'nhat.huy.7996@gmail.com',
+            password: process.env.COUCHBASE_PASSWORD || 'oc3qKtHXELXL',
+        });
+        // Lấy bucket từ cluster
+        bucket = cluster.bucket(process.env.COUCHBASE_BUCKET || 'buildAnArmy');
+        //Get collection 
+        dataCollection = bucket.collection('users');
+        console.log('✅ Connected to Couchbase');
+    }
+    catch (err) {
+        console.error('❌ Failed to connect to Couchbase:', err);
+    }
+}
+/*
+* query Data from couchbase
+* @param query: string
+* @returns array of rows
+*/
+async function queryData(query) {
+    try {
+        const result = await cluster.query(query);
+        return result.rows; // Return array of rows
+    }
+    catch (err) {
+        console.error('Error executing query:', err);
+        throw new Error('Failed to fetch top users');
+    }
+}
+function getCouchbaseUsersCollection() {
+    if (!dataCollection) {
+        throw new Error('Couchbase is not connected. Call connectToCouchbase first.');
+    }
+    return dataCollection;
+}

package/dist/db/lowdbClient.d.ts

@@ -0,0 +1,5 @@
+import { Low } from 'lowdb';
+interface Data {
+}
+export declare const db: Low<Data>;
+export {};

package/dist/db/lowdbClient.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.db = void 0;
+const lowdb_1 = require("lowdb");
+const node_1 = require("lowdb/node");
+// File lưu dữ liệu
+const adapter = new node_1.JSONFile("db.json");
+exports.db = new lowdb_1.Low(adapter, { users: [] });

package/dist/decorators/autoRouter.d.ts

@@ -0,0 +1,7 @@
+import 'reflect-metadata';
+import { Express } from 'express';
+export declare function RouterController(basePath?: string): ClassDecorator;
+export declare function Get(path: string): MethodDecorator;
+export declare function Post(path: string): MethodDecorator;
+export declare function Authen(): MethodDecorator & ClassDecorator;
+export declare function registerRoutes(app: Express, authMiddleware: any, ...controllers: any[]): void;

package/dist/decorators/autoRouter.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouterController = RouterController;
+exports.Get = Get;
+exports.Post = Post;
+exports.Authen = Authen;
+exports.registerRoutes = registerRoutes;
+require("reflect-metadata");
+const express_1 = require("express");
+const ROUTER_META = Symbol('router');
+const ROUTES_META = Symbol('routes');
+const AUTHEN_META = Symbol('authen');
+function RouterController(basePath = '') {
+    return (target) => {
+        Reflect.defineMetadata(ROUTER_META, basePath, target);
+    };
+}
+function Get(path) {
+    return (target, propertyKey) => {
+        const routes = Reflect.getMetadata(ROUTES_META, target.constructor) || [];
+        routes.push({ method: 'get', path, handler: propertyKey });
+        Reflect.defineMetadata(ROUTES_META, routes, target.constructor);
+    };
+}
+function Post(path) {
+    return (target, propertyKey) => {
+        const routes = Reflect.getMetadata(ROUTES_META, target.constructor) || [];
+        routes.push({ method: 'post', path, handler: propertyKey });
+        Reflect.defineMetadata(ROUTES_META, routes, target.constructor);
+    };
+}
+function Authen() {
+    return (target, propertyKey) => {
+        if (propertyKey) {
+            // Method
+            const authenMethods = Reflect.getMetadata(AUTHEN_META, target.constructor) || [];
+            authenMethods.push(propertyKey);
+            Reflect.defineMetadata(AUTHEN_META, authenMethods, target.constructor);
+        }
+        else {
+            // Class
+            Reflect.defineMetadata(AUTHEN_META, true, target);
+        }
+    };
+}
+function registerRoutes(app, authMiddleware, ...controllers) {
+    controllers.forEach(Controller => {
+        const basePath = Reflect.getMetadata(ROUTER_META, Controller) || '';
+        const routes = Reflect.getMetadata(ROUTES_META, Controller) || [];
+        const classAuthen = Reflect.getMetadata(AUTHEN_META, Controller);
+        const instance = new Controller();
+        const router = (0, express_1.Router)();
+        routes.forEach((route) => {
+            const handler = (req, res, next) => {
+                Promise.resolve(instance[route.handler](req, res, next)).catch(next);
+            };
+            const methodAuthenArr = Reflect.getMetadata(AUTHEN_META, Controller) || [];
+            const methodAuthen = Array.isArray(methodAuthenArr) && methodAuthenArr.includes(route.handler);
+            const routeMethod = route.method;
+            if (classAuthen || methodAuthen) {
+                router[routeMethod](route.path, authMiddleware, handler);
+            }
+            else {
+                router[routeMethod](route.path, handler);
+            }
+        });
+        app.use(basePath, router);
+    });
+}

package/dist/decorators/initServer.d.ts

@@ -0,0 +1,19 @@
+import { Express } from 'express';
+import { Server as HTTPServer } from 'http';
+import { Server as SocketIOServer } from 'socket.io';
+export interface InitOptions {
+    port: number;
+    apiControllers?: any[];
+    socketServices?: any[];
+    authAPIMiddleware?: any;
+    onReady?: (app: Express, io: SocketIOServer, httpServer: HTTPServer) => void;
+    publicPath?: string;
+    expressConfig?: (app: Express) => void;
+    socketConfig?: (io: SocketIOServer) => void;
+    createRedisAdapter?: () => Promise<any>;
+}
+export declare function initServer(options: InitOptions): Promise<{
+    app: import("express-serve-static-core").Express;
+    io: SocketIOServer<import("socket.io").DefaultEventsMap, import("socket.io").DefaultEventsMap, import("socket.io").DefaultEventsMap, any>;
+    httpServer: HTTPServer;
+}>;

package/dist/decorators/initServer.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initServer = initServer;
+const express_1 = __importDefault(require("express"));
+const http_1 = require("http");
+const socket_io_1 = require("socket.io");
+const autoRouter_1 = require("./autoRouter");
+const socketDecorators_1 = require("./socketDecorators");
+async function initServer(options) {
+    const app = (0, express_1.default)();
+    const httpServer = (0, http_1.createServer)(app);
+    const io = new socket_io_1.Server(httpServer, {
+        cors: {
+            origin: '*',
+            methods: ['GET', 'POST']
+        },
+        transports: ['websocket', 'polling'],
+        allowUpgrades: true,
+        connectTimeout: 45000,
+        pingTimeout: 60000,
+        pingInterval: 25000,
+        cookie: {
+            name: 'io',
+            httpOnly: true,
+            secure: true,
+            sameSite: 'none',
+            maxAge: 24 * 60 * 60 * 1000
+        },
+        connectionStateRecovery: {
+            maxDisconnectionDuration: 2 * 60 * 1000,
+            skipMiddlewares: true,
+        }
+    });
+    // Redis adapter support
+    if (options.createRedisAdapter) {
+        try {
+            const redisAdapter = await options.createRedisAdapter();
+            if (redisAdapter) {
+                io.adapter(redisAdapter);
+                console.log('✅ Socket.IO Redis adapter configured');
+            }
+        }
+        catch (err) {
+            console.warn('⚠️ Redis adapter failed to initialize, using default adapter:', err);
+        }
+    }
+    // Express config
+    app.use(express_1.default.json());
+    app.use((req, res, next) => {
+        res.header('Access-Control-Allow-Origin', '*');
+        res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, Authorization');
+        res.header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+        res.header('Access-Control-Allow-Credentials', 'true');
+        next();
+    });
+    if (options.publicPath) {
+        app.use(express_1.default.static(options.publicPath));
+    }
+    if (options.expressConfig) {
+        options.expressConfig(app);
+    }
+    // Register API controllers
+    if (options.apiControllers && options.apiControllers.length > 0) {
+        (0, autoRouter_1.registerRoutes)(app, options.authAPIMiddleware, ...options.apiControllers);
+    }
+    // Register socket services
+    if (options.socketServices && options.socketServices.length > 0) {
+        (0, socketDecorators_1.registerSocketServices)(io, ...options.socketServices);
+    }
+    if (options.socketConfig) {
+        options.socketConfig(io);
+    }
+    // Error handling
+    app.use((err, req, res, next) => {
+        console.error('Error:', err);
+        res.status(500).json({ error: 'Something went wrong!', details: err.message });
+    });
+    httpServer.listen(options.port, () => {
+        console.log(`Server is running on http://localhost:${options.port}`);
+        if (options.onReady)
+            options.onReady(app, io, httpServer);
+    });
+    return { app, io, httpServer };
+}

package/dist/decorators/socketDecorators.d.ts

@@ -0,0 +1,8 @@
+import 'reflect-metadata';
+import { Server } from 'socket.io';
+export declare function AuthenSocket(): MethodDecorator & ClassDecorator;
+export declare function SocketService(): ClassDecorator;
+export declare function OnEvent(event: string): MethodDecorator;
+export declare function OnDisconnect(): MethodDecorator;
+export declare function OnError(): MethodDecorator;
+export declare function registerSocketServices(io: Server, ...serviceClasses: any[]): void;

package/dist/decorators/socketDecorators.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthenSocket = AuthenSocket;
+exports.SocketService = SocketService;
+exports.OnEvent = OnEvent;
+exports.OnDisconnect = OnDisconnect;
+exports.OnError = OnError;
+exports.registerSocketServices = registerSocketServices;
+require("reflect-metadata");
+const SOCKET_SERVICE_META = Symbol('socket_service');
+const SOCKET_EVENTS_META = Symbol('socket_events');
+const SOCKET_AUTHEN_META = Symbol('socket_authen');
+// Decorator cho xác thực socket
+function AuthenSocket() {
+    return (target, propertyKey) => {
+        if (propertyKey) {
+            // Method
+            const authenMethods = Reflect.getMetadata(SOCKET_AUTHEN_META, target.constructor) || [];
+            authenMethods.push(propertyKey);
+            Reflect.defineMetadata(SOCKET_AUTHEN_META, authenMethods, target.constructor);
+        }
+        else {
+            // Class
+            Reflect.defineMetadata(SOCKET_AUTHEN_META, true, target);
+        }
+    };
+}
+function SocketService() {
+    return (target) => {
+        Reflect.defineMetadata(SOCKET_SERVICE_META, true, target);
+    };
+}
+function OnEvent(event) {
+    return (target, propertyKey) => {
+        const events = Reflect.getMetadata(SOCKET_EVENTS_META, target.constructor) || [];
+        events.push({ type: 'event', event, handler: propertyKey });
+        Reflect.defineMetadata(SOCKET_EVENTS_META, events, target.constructor);
+    };
+}
+function OnDisconnect() {
+    return (target, propertyKey) => {
+        const events = Reflect.getMetadata(SOCKET_EVENTS_META, target.constructor) || [];
+        events.push({ type: 'disconnect', handler: propertyKey });
+        Reflect.defineMetadata(SOCKET_EVENTS_META, events, target.constructor);
+    };
+}
+function OnError() {
+    return (target, propertyKey) => {
+        const events = Reflect.getMetadata(SOCKET_EVENTS_META, target.constructor) || [];
+        events.push({ type: 'error', handler: propertyKey });
+        Reflect.defineMetadata(SOCKET_EVENTS_META, events, target.constructor);
+    };
+}
+function registerSocketServices(io, ...serviceClasses) {
+    // Import middleware xác thực socket
+    const { authSocketToken } = require('../middleware/auth');
+    io.on('connection', (socket) => {
+        serviceClasses.forEach(ServiceClass => {
+            if (!Reflect.getMetadata(SOCKET_SERVICE_META, ServiceClass))
+                return;
+            const instance = new ServiceClass();
+            const events = Reflect.getMetadata(SOCKET_EVENTS_META, ServiceClass) || [];
+            const classAuthen = Reflect.getMetadata(SOCKET_AUTHEN_META, ServiceClass);
+            const methodAuthenArr = Reflect.getMetadata(SOCKET_AUTHEN_META, ServiceClass) || [];
+            events.forEach((evt) => {
+                const methodAuthen = Array.isArray(methodAuthenArr) && methodAuthenArr.includes(evt.handler);
+                const needAuth = classAuthen || methodAuthen;
+                const handler = (...args) => {
+                    Promise.resolve(instance[evt.handler](socket, ...args)).catch(console.error);
+                };
+                if (evt.type === 'event') {
+                    socket.on(evt.event, (...args) => {
+                        if (needAuth) {
+                            authSocketToken(socket, (err) => {
+                                if (err)
+                                    return socket.emit('server:error', err.message);
+                                handler(...args);
+                            });
+                        }
+                        else {
+                            handler(...args);
+                        }
+                    });
+                }
+                else if (evt.type === 'disconnect') {
+                    socket.on('disconnect', (...args) => handler(...args));
+                }
+                else if (evt.type === 'error') {
+                    socket.on('error', (...args) => handler(...args));
+                }
+            });
+        });
+    });
+}

package/dist/middleware/auth.d.ts

@@ -0,0 +1,4 @@
+import { Response, NextFunction } from 'express';
+import { AuthenticatedRequest, AuthenticatedSocket } from '../types';
+export declare const authAPIToken: (req: AuthenticatedRequest, res: Response, next: NextFunction) => void | Response<any, Record<string, any>>;
+export declare const authSocketToken: (socket: AuthenticatedSocket, next: (err?: Error) => void) => void;

package/dist/middleware/auth.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authSocketToken = exports.authAPIToken = void 0;
+const utils_1 = require("../utils/utils");
+const authAPIToken = (req, res, next) => {
+    // Skip authentication for OPTIONS requests (CORS preflight)
+    if (req.method === 'OPTIONS') {
+        console.log('🔄 Skipping auth for OPTIONS request (CORS preflight)');
+        return next();
+    }
+    console.log('🔍 Request method:', req.method);
+    console.log('🔍 Request URL:', req.url);
+    const auth = req.headers.authorization; // "Bearer <token>" 
+    const token = (auth === null || auth === void 0 ? void 0 : auth.startsWith("Bearer ")) ? auth.slice(7) : undefined;
+    console.log('🔑 API authentication token:', token);
+    if (!token) {
+        return res.status(401).json({
+            success: false,
+            message: 'No token provided'
+        });
+    }
+    try {
+        const decoded = utils_1.utils.tokenDecode(token);
+        req.userId = decoded.userId;
+        console.log('✅ API authenticated successfully for walletId:', decoded.walletId);
+        next();
+    }
+    catch (error) {
+        console.error(error);
+        return res.status(403).json({
+            success: false,
+            message: error
+        });
+    }
+};
+exports.authAPIToken = authAPIToken;
+const authSocketToken = (socket, next) => {
+    console.log('🔐 Socket authentication middleware triggered for socket:', socket.id);
+    try {
+        var token = socket.handshake.auth.token;
+        console.log(socket.handshake);
+        console.log(`🔑 Socket authentication token: ${token ? 'Present' : 'Missing'}`);
+        // Temporarily allow connections without token for debugging
+        if (!token) {
+            console.log('⚠️ No token provided, but allowing connection for debugging');
+            token = socket.handshake.query.token;
+        }
+        const decoded = utils_1.utils.tokenDecode(token);
+        console.log(decoded);
+        socket.userId = decoded.userId;
+        next();
+    }
+    catch (error) {
+        console.error('❌ Socket authentication error:', error);
+        // Temporarily allow connection even with invalid token for debugging
+        console.log('⚠️ Invalid token, but allowing connection for debugging');
+        socket.userId = 'anonymous';
+        next();
+    }
+};
+exports.authSocketToken = authSocketToken;

package/dist/types/index.d.ts

@@ -0,0 +1,22 @@
+import { Socket } from 'socket.io';
+import { Request } from 'express';
+export interface ApiResponse {
+    success: boolean;
+    message: string;
+    data?: any;
+}
+export interface AuthenticatedSocket extends Socket {
+    userId?: string;
+}
+export interface AuthenticatedRequest extends Request {
+    userId?: string;
+}
+export interface Vector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface Vector2 {
+    x: number;
+    y: number;
+}

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/map.d.ts

@@ -0,0 +1,45 @@
+import { Vector3 } from ".";
+/**
+ * Loại hình dạng của obstacle
+ */
+export declare enum ObstacleShape {
+    BOX = "box",
+    CYLINDER = "cylinder"
+}
+/**
+ * Obstacle (vật cản) trên map
+ */
+export interface Obstacle {
+    id: string;
+    shape: ObstacleShape;
+    position: Vector3;
+    size: Vector3;
+    rotation?: Vector3;
+}
+/**
+ * Bounding box để kiểm tra collision
+ */
+export interface BoundingBox {
+    min: Vector3;
+    max: Vector3;
+}
+/**
+ * Map configuration
+ */
+export interface MapData {
+    id: string;
+    name: string;
+    width: number;
+    length: number;
+    height?: number;
+    obstacles: Obstacle[];
+    spawnPoints?: Vector3[];
+}
+/**
+ * Collision check result
+ */
+export interface CollisionResult {
+    hasCollision: boolean;
+    obstacle?: Obstacle;
+    penetrationDepth?: number;
+}

package/dist/types/map.js

@@ -0,0 +1,12 @@
+"use strict";
+// Map and Obstacle types
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObstacleShape = void 0;
+/**
+ * Loại hình dạng của obstacle
+ */
+var ObstacleShape;
+(function (ObstacleShape) {
+    ObstacleShape["BOX"] = "box";
+    ObstacleShape["CYLINDER"] = "cylinder";
+})(ObstacleShape || (exports.ObstacleShape = ObstacleShape = {}));

package/dist/utils/collisionDetector.d.ts

@@ -0,0 +1,35 @@
+import { Obstacle, CollisionResult, MapData } from '../types/map';
+import { Vector3 } from '../types';
+export declare class CollisionDetector {
+    private static mapsDirectory;
+    static loadMap(nameMap: string): MapData;
+    /**
+     * Kiểm tra va chạm giữa player và tất cả obstacles trên map
+     * @param playerPosition Vị trí player muốn di chuyển đến
+     * @param playerRadius Bán kính collision của player (dạng cylinder/capsule)
+     * @param playerHeight Chiều cao của player
+     * @param obstacles Danh sách obstacles trên map
+     * @returns CollisionResult chứa thông tin về va chạm
+     */
+    static checkCollision(playerPosition: Vector3, playerRadius: number, playerHeight: number, obstacles: Obstacle[]): CollisionResult;
+    /**
+     * Kiểm tra va chạm giữa player (cylinder) và box obstacle
+     */
+    private static checkPlayerVsBox;
+    /**
+     * Kiểm tra va chạm giữa player (cylinder) và cylinder obstacle
+     */
+    private static checkPlayerVsCylinder;
+    /**
+     * Tính bounding box của obstacle
+     */
+    private static getObstacleBoundingBox;
+    /**
+     * Kiểm tra xem position có nằm trong giới hạn map không
+     */
+    static isInMapBounds(position: Vector3, mapWidth: number, mapLength: number): boolean;
+    /**
+     * Clamp position vào trong giới hạn map
+     */
+    static clampToMapBounds(position: Vector3, mapWidth: number, mapLength: number): Vector3;
+}

package/dist/utils/collisionDetector.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollisionDetector = void 0;
+/**
+ * Collision Detection Utility
+ * Xử lý việc kiểm tra va chạm giữa player và obstacles
+ */
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const map_1 = require("../types/map");
+class CollisionDetector {
+    static loadMap(nameMap) {
+        const filePath = path_1.default.join(this.mapsDirectory, `${nameMap}.json`);
+        console.log(`[MapLoader] Loading map from: ${filePath}`);
+        const jsonData = fs_1.default.readFileSync(filePath, 'utf8');
+        const mapData = JSON.parse(jsonData);
+        console.log(`[MapLoader] Loaded map: ${mapData.name} (ID: ${mapData.id})`);
+        return mapData;
+    }
+    /**
+     * Kiểm tra va chạm giữa player và tất cả obstacles trên map
+     * @param playerPosition Vị trí player muốn di chuyển đến
+     * @param playerRadius Bán kính collision của player (dạng cylinder/capsule)
+     * @param playerHeight Chiều cao của player
+     * @param obstacles Danh sách obstacles trên map
+     * @returns CollisionResult chứa thông tin về va chạm
+     */
+    static checkCollision(playerPosition, playerRadius, playerHeight, obstacles) {
+        for (const obstacle of obstacles) {
+            let hasCollision = false;
+            if (obstacle.shape === map_1.ObstacleShape.BOX) {
+                hasCollision = this.checkPlayerVsBox(playerPosition, playerRadius, playerHeight, obstacle);
+            }
+            else if (obstacle.shape === map_1.ObstacleShape.CYLINDER) {
+                hasCollision = this.checkPlayerVsCylinder(playerPosition, playerRadius, playerHeight, obstacle);
+            }
+            if (hasCollision) {
+                return {
+                    hasCollision: true,
+                    obstacle: obstacle
+                };
+            }
+        }
+        return { hasCollision: false };
+    }
+    /**
+     * Kiểm tra va chạm giữa player (cylinder) và box obstacle
+     */
+    static checkPlayerVsBox(playerPos, playerRadius, playerHeight, obstacle) {
+        // Tính bounding box của obstacle
+        const obstacleBox = this.getObstacleBoundingBox(obstacle);
+        // Kiểm tra overlap trên trục Y (chiều cao)
+        const playerBottom = playerPos.y;
+        const playerTop = playerPos.y + playerHeight;
+        if (playerTop < obstacleBox.min.y || playerBottom > obstacleBox.max.y) {
+            return false; // Không va chạm theo chiều cao
+        }
+        // Kiểm tra va chạm 2D trên mặt phẳng XZ
+        // Tìm điểm gần nhất trên box với player position
+        const closestX = Math.max(obstacleBox.min.x, Math.min(playerPos.x, obstacleBox.max.x));
+        const closestZ = Math.max(obstacleBox.min.z, Math.min(playerPos.z, obstacleBox.max.z));
+        // Tính khoảng cách từ player đến điểm gần nhất
+        const distanceX = playerPos.x - closestX;
+        const distanceZ = playerPos.z - closestZ;
+        const distanceSquared = distanceX * distanceX + distanceZ * distanceZ;
+        // Va chạm nếu khoảng cách nhỏ hơn bán kính player
+        return distanceSquared < (playerRadius * playerRadius);
+    }
+    /**
+     * Kiểm tra va chạm giữa player (cylinder) và cylinder obstacle
+     */
+    static checkPlayerVsCylinder(playerPos, playerRadius, playerHeight, obstacle) {
+        const obstacleRadius = obstacle.size.x; // Bán kính cylinder là size.x
+        const obstacleHeight = obstacle.size.y;
+        // Kiểm tra overlap trên trục Y
+        const playerBottom = playerPos.y;
+        const playerTop = playerPos.y + playerHeight;
+        const obstacleBottom = obstacle.position.y - obstacleHeight / 2;
+        const obstacleTop = obstacle.position.y + obstacleHeight / 2;
+        if (playerTop < obstacleBottom || playerBottom > obstacleTop) {
+            return false; // Không va chạm theo chiều cao
+        }
+        // Kiểm tra va chạm 2D giữa 2 circles trên mặt phẳng XZ
+        const distanceX = playerPos.x - obstacle.position.x;
+        const distanceZ = playerPos.z - obstacle.position.z;
+        const distanceSquared = distanceX * distanceX + distanceZ * distanceZ;
+        const minDistance = playerRadius + obstacleRadius;
+        return distanceSquared < (minDistance * minDistance);
+    }
+    /**
+     * Tính bounding box của obstacle
+     */
+    static getObstacleBoundingBox(obstacle) {
+        const halfSize = {
+            x: obstacle.size.x / 2,
+            y: obstacle.size.y / 2,
+            z: obstacle.size.z / 2
+        };
+        return {
+            min: {
+                x: obstacle.position.x - halfSize.x,
+                y: obstacle.position.y - halfSize.y,
+                z: obstacle.position.z - halfSize.z
+            },
+            max: {
+                x: obstacle.position.x + halfSize.x,
+                y: obstacle.position.y + halfSize.y,
+                z: obstacle.position.z + halfSize.z
+            }
+        };
+    }
+    /**
+     * Kiểm tra xem position có nằm trong giới hạn map không
+     */
+    static isInMapBounds(position, mapWidth, mapLength) {
+        const halfWidth = mapWidth / 2;
+        const halfLength = mapLength / 2;
+        return position.x >= -halfWidth && position.x <= halfWidth &&
+            position.z >= -halfLength && position.z <= halfLength;
+    }
+    /**
+     * Clamp position vào trong giới hạn map
+     */
+    static clampToMapBounds(position, mapWidth, mapLength) {
+        const halfWidth = mapWidth / 2;
+        const halfLength = mapLength / 2;
+        return {
+            x: Math.max(-halfWidth, Math.min(halfWidth, position.x)),
+            y: position.y,
+            z: Math.max(-halfLength, Math.min(halfLength, position.z))
+        };
+    }
+}
+exports.CollisionDetector = CollisionDetector;
+CollisionDetector.mapsDirectory = path_1.default.join(__dirname, '../../maps');

package/dist/utils/discordConnector.d.ts

@@ -0,0 +1 @@
+export declare function sendDiscordNotification(message: string): Promise<void>;

package/dist/utils/discordConnector.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendDiscordNotification = sendDiscordNotification;
+const discord_js_1 = require("discord.js");
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config();
+const token = process.env.DISCORD_TOKEN;
+const channelId = process.env.CHANNEL_ID;
+if (!token || !channelId) {
+    console.error("Vui lòng cung cấp DISCORD_TOKEN và CHANNEL_ID trong .env");
+    process.exit(1);
+}
+const client = new discord_js_1.Client({
+    intents: [discord_js_1.GatewayIntentBits.Guilds, discord_js_1.GatewayIntentBits.GuildMessages],
+});
+client.once(discord_js_1.Events.ClientReady, async () => {
+    var _a;
+    console.log(`Bot đã đăng nhập với tên: ${(_a = client.user) === null || _a === void 0 ? void 0 : _a.tag}`);
+    const channel = client.channels.cache.get(channelId);
+    if (!channel) {
+        console.error("Không tìm thấy kênh!");
+        return;
+    }
+    // channel.send("Bot đã hoạt động! 🚀");
+});
+client.on(discord_js_1.Events.MessageCreate, async (message) => {
+    // Bỏ qua tin nhắn của chính bot
+    if (message.author.bot)
+        return;
+    // Kiểm tra bot có bị tag hay không
+    if (message.mentions.has(client.user)) {
+        console.log(`📩 Được tag bởi ${message.author.tag}: ${message.content}`);
+        if (message.content.toLowerCase().includes("game"))
+            await message.reply(`Chào ${message.author.username}! Game đây nhá!!\n
+    🤖 [Shadow Javelin](https://t.me/gamedevtoi_bot/shadow_javelin)\n
+    🍉 [Garden DHH](https://t.me/gamedevtoi_bot/gardenDHH)`);
+    }
+});
+// Xử lý lỗi Discord client
+client.on(discord_js_1.Events.Error, (error) => {
+    console.error('Discord client error:', error);
+});
+// Đăng nhập với xử lý lỗi
+client.login(token).catch((error) => {
+    console.error('❌ Discord login failed:', error.message);
+    console.log('⚠️  Discord bot không khả dụng');
+});
+function Connect() {
+    return new Promise((resolve, reject) => {
+        // Nếu đã ready thì resolve ngay
+        if (client.isReady()) {
+            resolve(client);
+            return;
+        }
+        // Timeout sau 5 giây nếu không kết nối được
+        const timeout = setTimeout(() => {
+            clearInterval(check);
+            reject(new Error('Discord connection timeout'));
+        }, 5000);
+        const check = setInterval(() => {
+            if (client.isReady()) {
+                clearTimeout(timeout);
+                clearInterval(check);
+                resolve(client);
+            }
+        }, 100);
+    });
+}
+// Hàm gửi thông báo
+async function sendDiscordNotification(message) {
+    try {
+        await Connect();
+        console.log(`Gửi tin đến server!`);
+        const channel = client.channels.cache.get(channelId);
+        if (channel) {
+            await channel.send(message);
+        }
+        else {
+            console.error("Không thể gửi tin nhắn, kênh không tồn tại!");
+        }
+    }
+    catch (error) {
+        console.error("❌ Không thể gửi Discord notification:", error instanceof Error ? error.message : error);
+        // Server vẫn tiếp tục chạy, chỉ log lỗi
+    }
+}

package/dist/utils/teleConnector.d.ts

@@ -0,0 +1,4 @@
+import TelegramBot from "node-telegram-bot-api";
+export declare const botTele: TelegramBot;
+export declare function sendMessage(message: string, userId?: string, thread_id?: string): Promise<void>;
+export declare function sendMessageNoti(message: string): Promise<void>;

package/dist/utils/teleConnector.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.botTele = void 0;
+exports.sendMessage = sendMessage;
+exports.sendMessageNoti = sendMessageNoti;
+const node_telegram_bot_api_1 = __importDefault(require("node-telegram-bot-api"));
+const dotenv_1 = __importDefault(require("dotenv"));
+const node_fetch_1 = __importDefault(require("node-fetch"));
+dotenv_1.default.config();
+const token = process.env.TELEGRAM_BOT_TOKEN;
+const gameUrl = "https://t.me/gamedevtoi_bot/shadow_javelin";
+if (!token) {
+    throw new Error("Missing TELEGRAM_BOT_TOKEN in .env file");
+}
+exports.botTele = new node_telegram_bot_api_1.default(token, { polling: true });
+exports.botTele.on("inline_query", async (query) => {
+    const results = [
+        {
+            type: "article",
+            id: "1",
+            title: "PlayGame",
+            input_message_content: {
+                message_text: gameUrl,
+            },
+        }
+    ];
+    exports.botTele.answerInlineQuery(query.id, results);
+});
+exports.botTele.onText(/\/games/, (msg) => {
+    exports.botTele.sendMessage(msg.chat.id, "Chào bạn! Đây là những game hiện có 🎮", {
+        reply_markup: {
+            keyboard: [[{ text: "🎮 Shadow Javelin" }, { text: "🍉 Garden DHH" }]],
+            resize_keyboard: true,
+            one_time_keyboard: false,
+        },
+    });
+});
+exports.botTele.on("message", (msg) => {
+    var _a;
+    if (msg.text === "🎮 Shadow Javelin") {
+        exports.botTele.sendMessage(msg.chat.id, `🚀 Nhấn vào đây để chơi: [Shadow Javelin](${gameUrl})`, {
+            parse_mode: "Markdown",
+        });
+    }
+    if (msg.text === "🍉 Garden DHH") {
+        exports.botTele.sendMessage(msg.chat.id, `🚀 Nhấn vào đây để chơi: [Garden DHH](https://t.me/gamedevtoi_bot/gardenDHH)`, {
+            parse_mode: "Markdown",
+        });
+    }
+    if ((_a = msg.text) === null || _a === void 0 ? void 0 : _a.startsWith("/noti")) {
+        //sendNotiAllUser(msg.text.replace("/noti", ""));
+    }
+});
+async function sendMessage(message, userId = "", thread_id = "") {
+    try {
+        const url = `https://api.telegram.org/bot${token}/sendMessage`;
+        const response = await (0, node_fetch_1.default)(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                chat_id: userId,
+                message_thread_id: thread_id,
+                text: message,
+            }),
+        });
+        const data = await response.json();
+    }
+    catch (e) {
+        console.error(`Send message to tele fail!`);
+    }
+}
+async function sendMessageNoti(message) {
+    sendMessage(message, process.env.TELEGRAM_CHATID || "", process.env.TELEGRAM_THREAD_ID || "");
+}
+console.log("🤖 Bot is running...");

package/dist/utils/utils.d.ts

@@ -0,0 +1,5 @@
+export declare const utils: {
+    getMinutesPassed: (startAt: string) => number;
+    tokenDecode(token: string): any;
+    tokenEncode(data: any): string;
+};

package/dist/utils/utils.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utils = void 0;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config();
+exports.utils = {
+    getMinutesPassed: function (startAt) {
+        const startDate = new Date(startAt);
+        const currentDate = new Date();
+        const diffInMilliseconds = currentDate.getTime() - startDate.getTime();
+        return Math.floor(diffInMilliseconds / (1000 * 60)); // Chuyển đổi từ milliseconds sang phút
+    },
+    tokenDecode(token) {
+        const secret = process.env.JWT_SECRET || 'your-secret-key';
+        console.log('🔍 JWT Secret status:', process.env.JWT_SECRET ? 'Using environment JWT_SECRET' : 'Using default secret');
+        try {
+            const decoded = jsonwebtoken_1.default.verify(token, secret);
+            return decoded;
+        }
+        catch (error) {
+            console.error('❌ JWT verification failed:', error);
+            console.error('🔍 Token preview:', token.substring(0, 50) + '...');
+            console.error('🔍 Secret being used:', secret.substring(0, 10) + '...');
+            throw error;
+        }
+    },
+    tokenEncode(data) {
+        const secret = process.env.JWT_SECRET || 'your-secret-key';
+        console.log('🔍 Creating JWT with secret:', process.env.JWT_SECRET ? 'Using environment JWT_SECRET' : 'Using default secret');
+        const token = jsonwebtoken_1.default.sign(data, secret, { expiresIn: '7d' });
+        console.log('✅ JWT token created successfully');
+        console.log('🔍 Token:', token);
+        return token;
+    }
+};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "ts-game-decorators",
+  "version": "1.0.0",
+  "description": "Express & Socket.IO decorators for auto routing and event handling. using for backend game development.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepare": "npm run build"
+  },
+  "keywords": [
+    "express",
+    "socket.io",
+    "decorators",
+    "typescript",
+    "router",
+    "auto-router"
+  ],
+  "author": "gamedevtoi",
+  "license": "MIT",
+  "dependencies": {
+    "express": "^4.18.2",
+    "socket.io": "^4.7.4",
+    "reflect-metadata": "^0.1.13"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  }
+}