rename from ts to src

src/client.js

@@ -0,0 +1,152 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+exports.__esModule = true;
+exports.Client = void 0;
+var room_1 = require("./room");
+var manager_1 = require("./manager");
+var logger_1 = require("./logger");
+var Client = /** @class */ (function () {
+    function Client(socket, manager) {
+        this.socket = socket;
+        // @ts-ignore
+        this.name = socket.handshake.query.name;
+        // @ts-ignore
+        this.game = socket.handshake.query.game;
+        this.id = socket.id;
+        this.setEvents(manager);
+    }
+    Object.defineProperty(Client.prototype, "serialized", {
+        get: function () {
+            return {
+                id: this.id,
+                name: this.name,
+                game: this.game,
+                isReady: this.isReady,
+                isPlayer: this.isPlayer,
+                isSpectator: this.isSpectator
+            };
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Client.prototype.setEvents = function (mng) {
+        var _this = this;
+        var s = this.socket;
+        s.on('room-list', function () { return _this.sendRoomList(); });
+        s.on('client-list', function () { return _this.sendClientList(); });
+        s.on('set-ready', function (ready) { return _this.setReady(ready); });
+        s.on('game-settings', function (settings) { return _this.setGameSettings(settings); });
+        s.on('create-lobby', function (settings, name) { return _this.createRoom(settings, name); });
+        s.on('join-lobby', function (roomId) { return _this.joinRoom(roomId); });
+        s.on('leave-lobby', function (roomId) { return _this.leaveRoom(roomId); });
+        s.on('join-spectators', function () { return _this.joinSpectators(); });
+        s.on('join-players', function () { return _this.joinPlayers(); });
+        s.on('start-game', function (lobbyId) { return mng.startGame(_this, lobbyId); });
+        s.on('stop-game', function (lobbyId) { return mng.stopGame(_this, lobbyId); });
+        s.on('feedback', function (content) { return mng.saveFeedbackToFile(_this, content); });
+        s.on('disconnect', function () { return mng.disconnected(_this); });
+        this.send('connected');
+    };
+    Client.prototype.sendRoomList = function () {
+        var rooms = manager_1.ConnectionManager.RoomListByGame(this.game);
+        this.send('room-list', rooms);
+    };
+    Client.prototype.sendClientList = function () {
+        var clients = manager_1.ConnectionManager.ClientListByClientId(this.id);
+        this.send('client-list', clients);
+    };
+    Client.prototype.setReady = function (ready) {
+        var room = room_1.Room.getByClientId(this.id, manager_1.ConnectionManager.Instance.rooms);
+        if (room) {
+            this.isReady = ready;
+            room.toAll('client-list', room.clients);
+        }
+    };
+    Client.prototype.setGameSettings = function (settings) {
+        var room = room_1.Room.getByClientId(this.id, manager_1.ConnectionManager.Instance.rooms);
+        if (room) {
+            room.gameSettings = settings;
+            room.toAll('game-settings', settings);
+        }
+    };
+    Client.prototype.createRoom = function (settings, name) {
+        var room = manager_1.ConnectionManager.Instance.createRoom(settings, name);
+        room.add(this);
+        this.send('created-lobby', room);
+        (0, logger_1.log)('lobby-created', this, room);
+    };
+    Client.prototype.joinRoom = function (roomId) {
+        var room = room_1.Room.getByRoomId(roomId, manager_1.ConnectionManager.Instance.rooms);
+        if (!room) {
+            this.send('join-failed', 'Room does not exist!');
+            (0, logger_1.log)('join-non-existent', this, new room_1.Room('not-existent', roomId));
+        }
+        else if (room.hasStarted && !room.settings.spectators) {
+            this.send('join-failed', 'Game has started yet!');
+            (0, logger_1.log)('join-started', this, room);
+        }
+        else {
+            room.add(this);
+            (0, logger_1.log)('member-joined', this, room);
+        }
+        return room;
+    };
+    Client.prototype.leaveRoom = function (_roomId) {
+        var room = room_1.Room.getByClientId(this.id, manager_1.ConnectionManager.Instance.rooms);
+        if (!room)
+            return;
+        this.leave(room.id);
+        if (room.runningGame)
+            room.runningGame.removeClient(this);
+        room.clients.splice(room.clients.indexOf(this), 1);
+        room.toAll('member-left', this.id, this.name);
+        room.toAll('client-list', room.clients);
+        this.send('left-lobby');
+        (0, logger_1.log)('member-left', this, room);
+        if (room.isEmpty && !room.settings.always) {
+            manager_1.ConnectionManager.Instance.deleteRoom(room);
+        }
+    };
+    Client.prototype.joinSpectators = function () {
+        var room = room_1.Room.getByClientId(this.id, manager_1.ConnectionManager.Instance.rooms);
+        if (!room)
+            return;
+        this.isSpectator = true;
+        this.isPlayer = false;
+        room.toAll('client-list', room.clients);
+    };
+    Client.prototype.joinPlayers = function () {
+        var room = room_1.Room.getByClientId(this.id, manager_1.ConnectionManager.Instance.rooms);
+        if (!room)
+            return;
+        if (room.hasStarted)
+            return;
+        this.isSpectator = false;
+        this.isPlayer = true;
+        room.toAll('client-list', room.clients);
+    };
+    Client.prototype.send = function (event) {
+        var _a;
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        (_a = this.socket).emit.apply(_a, __spreadArray([event], (0, manager_1.serializeObject)(args), false));
+    };
+    Client.prototype.join = function (roomId) {
+        this.socket.join(roomId);
+    };
+    Client.prototype.leave = function (roomId) {
+        this.socket.leave(roomId);
+    };
+    return Client;
+}());
+exports.Client = Client;

src/games/chainreact.js

@@ -0,0 +1,113 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+exports.__esModule = true;
+exports.Chainreact = void 0;
+var game_standard_1 = require("./game_standard");
+var Chainreact = /** @class */ (function (_super) {
+    __extends(Chainreact, _super);
+    function Chainreact(room, settings) {
+        var _this = _super.call(this, room, settings) || this;
+        _this.readyForTurn = [];
+        return _this;
+    }
+    Chainreact.prototype.setEvents = function (client) {
+        var _this = this;
+        var socket = client.socket;
+        socket.on('ready-for-turn', function (isDead) {
+            if (isDead) {
+                client.isPlayer = false;
+                client.isSpectator = true;
+                _this.room.toAll('client-list', _this.room.clients);
+            }
+            else {
+                _this.readyForTurn.push(client);
+            }
+            var allReady = true;
+            _this.room.players.forEach(function (c) {
+                if (_this.readyForTurn.find(function (r) { return r.id === c.id; }) == null) {
+                    allReady = false;
+                }
+            });
+            if (allReady) {
+                _this.nextTurn();
+                _this.readyForTurn = [];
+            }
+        });
+        socket.on('set-slot', function (fieldsIndex, slotsIndex) {
+            _this.room.toAll('set-slot', fieldsIndex, slotsIndex, socket.id);
+        });
+        socket.on('game-data', function (data) { return _this.currentGameData = data; });
+    };
+    Chainreact.prototype.addClient = function (client) {
+        _super.prototype.addClient.call(this, client);
+        if (client.isSpectator) {
+            var room = this.room;
+            var data = this.currentGameData;
+            var hues = this.colorHues;
+            var turnId = '';
+            if (this.room.players[this.currentTurnIndex])
+                turnId = this.room.players[this.currentTurnIndex].id;
+            client.send('start-spectate', room, data, hues, turnId);
+        }
+    };
+    Chainreact.prototype.removeClient = function (client) {
+        _super.prototype.removeClient.call(this, client);
+        if (this.room.players.indexOf(client) === this.currentTurnIndex)
+            this.nextTurn(true);
+        var s = client.socket;
+        s.removeAllListeners('set-slot');
+        s.removeAllListeners('ready-for-turn');
+        s.removeAllListeners('game-data');
+    };
+    Chainreact.prototype.nextTurn = function (skip) {
+        if (this.currentTurnIndex != null && !skip) {
+            this.currentTurnIndex++;
+            if (this.currentTurnIndex >= this.room.players.length) {
+                this.currentTurnIndex = 0;
+            }
+        }
+        else if (!skip) {
+            this.setTurnAndColors();
+        }
+        var index = this.currentTurnIndex;
+        if (skip) {
+            index = this.currentTurnIndex + 1;
+            if (index >= this.room.players.length) {
+                index = 0;
+                this.currentTurnIndex = 0;
+            }
+        }
+        if (this.room.players.length) {
+            this.room.toAll('current-turn', this.room.players[index].id);
+        }
+    };
+    Chainreact.prototype.setTurnAndColors = function () {
+        this.currentTurnIndex = Math.floor(Math.random() * this.room.players.length);
+        var colorHues = [0, 60, 120, 240];
+        this.colorHues = {};
+        for (var _i = 0, _a = this.room.players; _i < _a.length; _i++) {
+            var c = _a[_i];
+            var index = Math.floor(Math.random() * colorHues.length);
+            var hue = colorHues[index];
+            colorHues.splice(index, 1);
+            this.colorHues[c.id] = hue;
+        }
+        this.room.toAll('player-colors', this.colorHues);
+    };
+    return Chainreact;
+}(game_standard_1.ServerGame));
+exports.Chainreact = Chainreact;

src/games/game_standard.js

@@ -0,0 +1,49 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+exports.__esModule = true;
+exports.ServerGame = void 0;
+var ServerGame = /** @class */ (function () {
+    function ServerGame(room, settings) {
+        var _this = this;
+        this.settings = settings;
+        this.room = room;
+        this.room.clients.forEach(function (c) { return _this.addClient(c); });
+    }
+    ServerGame.prototype.addClient = function (client) {
+        this.setEvents(client);
+    };
+    ServerGame.prototype.removeClient = function (client) {
+        this.removeEvents(client);
+    };
+    ServerGame.prototype.gameAction = function (action) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+    };
+    ServerGame.prototype.setEvents = function (client) {
+        var _this = this;
+        var socket = client.socket;
+        socket.on('game-action', function (action) {
+            var args = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                args[_i - 1] = arguments[_i];
+            }
+            return _this.gameAction.apply(_this, __spreadArray([action], args, false));
+        });
+    };
+    ServerGame.prototype.removeEvents = function (client) {
+        var socket = client.socket;
+        socket.removeAllListeners('game-action');
+    };
+    return ServerGame;
+}());
+exports.ServerGame = ServerGame;

src/games/global_draw.js

@@ -0,0 +1,151 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+exports.__esModule = true;
+exports.GlobalDraw = void 0;
+var game_standard_1 = require("./game_standard");
+var logger_1 = require("../logger");
+var fs = require("fs");
+var GlobalDraw = /** @class */ (function (_super) {
+    __extends(GlobalDraw, _super);
+    function GlobalDraw(lobby, settings) {
+        var _this = _super.call(this, lobby, settings) || this;
+        _this.linesPath = "json_data/global_draw/lines.json";
+        _this.pixelsPath = "json_data/global_draw/pixels.json";
+        _this.pixelCount = 1000;
+        _this.lines = [];
+        _this.pixels = [];
+        for (var x = 0; x < _this.pixelCount; x++) {
+            var column = [];
+            for (var y = 0; y < _this.pixelCount; y++) {
+                column.push({ x: x, y: y, c: "#ffffff" });
+            }
+            _this.pixels.push(column);
+        }
+        var linesLoaded = false;
+        var pixelsLoaded = false;
+        _this.loadDrawingsFromFile(_this.linesPath, function (data) {
+            _this.lines = data;
+        }, function () {
+            linesLoaded = true;
+            if (pixelsLoaded) {
+                _this.startSaveInterval();
+            }
+        });
+        _this.loadDrawingsFromFile(_this.pixelsPath, function (data) {
+            for (var x = 0; x < _this.pixelCount; x++) {
+                for (var y = 0; y < _this.pixelCount; y++) {
+                    if (data[x])
+                        if (data[x][y])
+                            _this.pixels[x][y].c = data[x][y].c;
+                }
+            }
+        }, function () {
+            pixelsLoaded = true;
+            if (linesLoaded) {
+                _this.startSaveInterval();
+            }
+        });
+        return _this;
+    }
+    GlobalDraw.prototype.startSaveInterval = function () {
+        var _this = this;
+        this.saveAllDrawingsToFile();
+        //Saves once every day
+        setInterval(function () { return _this.saveAllDrawingsToFile(); }, 1000 * 60 * 60 * 24);
+    };
+    GlobalDraw.prototype.addLine = function (line) {
+        this.lines.push(line);
+        this.room.toAll('add-line', line);
+    };
+    GlobalDraw.prototype.fillPixel = function (pixel) {
+        this.pixels[pixel.x][pixel.y].c = pixel.c;
+        this.room.toAll('fill-pixel', pixel);
+    };
+    GlobalDraw.prototype.loadDrawingsFromFile = function (drawingsPath, successs, done) {
+        var _this = this;
+        fs.readFile(drawingsPath, 'utf8', function (err, data) {
+            if (err)
+                (0, logger_1.log)('load-error', null, _this.room, err.message);
+            else {
+                try {
+                    var parsed = JSON.parse(data);
+                    (0, logger_1.log)('load-success', null, _this.room);
+                    successs(parsed);
+                }
+                catch (e) {
+                    (0, logger_1.log)('parse-error', null, _this.room, e.message);
+                }
+            }
+            done();
+        });
+    };
+    GlobalDraw.prototype.saveDrawingsToFile = function (drawings, drawingsPath, callback) {
+        var splits = drawingsPath.split('/');
+        var path = splits.slice(0, splits.length - 1).reduce(function (prev, curr) { return prev + '/' + curr; });
+        var name = splits[splits.length - 1];
+        if (!fs.existsSync(path)) {
+            fs.mkdirSync(path, { recursive: true });
+        }
+        fs.writeFile(drawingsPath, JSON.stringify(drawings), callback);
+    };
+    GlobalDraw.prototype.saveAllDrawingsToFile = function () {
+        var _this = this;
+        var linesSaved = false;
+        var pixelsSaved = false;
+        this.saveDrawingsToFile(this.lines, this.linesPath, function (err) {
+            if (err)
+                (0, logger_1.log)('save-error', null, _this.room, err.message);
+            else {
+                linesSaved = true;
+                if (pixelsSaved) {
+                    _this.room.toAll('all-saved');
+                    linesSaved = false;
+                    pixelsSaved = false;
+                }
+                (0, logger_1.log)('save-success', null, _this.room, 'Successfully saved lines to file');
+            }
+        });
+        this.saveDrawingsToFile(this.pixels, this.pixelsPath, function (err) {
+            if (err)
+                (0, logger_1.log)('save-error', null, _this.room, err.message);
+            else {
+                pixelsSaved = true;
+                if (linesSaved) {
+                    _this.room.toAll('all-saved');
+                    pixelsSaved = false;
+                    linesSaved = false;
+                }
+                (0, logger_1.log)('save-success', null, _this.room, 'Successfully saved pixels to file');
+            }
+        });
+    };
+    GlobalDraw.prototype.addClient = function (client) {
+        this.setEvents(client);
+    };
+    GlobalDraw.prototype.setEvents = function (client) {
+        var _this = this;
+        _super.prototype.setEvents.call(this, client);
+        var socket = client.socket;
+        socket.on('add-line', function (line) { return _this.addLine(line); });
+        socket.on('fill-pixel', function (pixel) { return _this.fillPixel(pixel); });
+        socket.on('request-all-lines', function () { return socket.emit('add-all', _this.lines); });
+        socket.on('request-all-pixels', function () { return socket.emit('fill-all', _this.pixels); });
+        socket.on('save-all', function () { return _this.saveAllDrawingsToFile(); });
+    };
+    return GlobalDraw;
+}(game_standard_1.ServerGame));
+exports.GlobalDraw = GlobalDraw;

src/games/memory.js

@@ -0,0 +1,44 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+exports.__esModule = true;
+exports.Memory = void 0;
+var game_standard_1 = require("./game_standard");
+var Memory = /** @class */ (function (_super) {
+    __extends(Memory, _super);
+    function Memory(room, settings) {
+        return _super.call(this, room, settings) || this;
+    }
+    Memory.prototype.gameAction = function (action) {
+        var _a;
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        (_a = this.room).toAll.apply(_a, __spreadArray(['game-action', action], args, false));
+    };
+    return Memory;
+}(game_standard_1.ServerGame));
+exports.Memory = Memory;

src/games/pong.js

@@ -0,0 +1,27 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+exports.__esModule = true;
+exports.Pong = void 0;
+var game_standard_1 = require("./game_standard");
+var Pong = /** @class */ (function (_super) {
+    __extends(Pong, _super);
+    function Pong(lobby, settings) {
+        return _super.call(this, lobby, settings) || this;
+    }
+    return Pong;
+}(game_standard_1.ServerGame));
+exports.Pong = Pong;

src/lib/vector.js

@@ -0,0 +1,76 @@
+"use strict";
+exports.__esModule = true;
+exports.p = exports.Vector = void 0;
+var Vector = /** @class */ (function () {
+    function Vector(x, y) {
+        this.x = x;
+        this.y = y;
+    }
+    Vector.fromAngle = function (angle) {
+        return new Vector(Math.cos(angle), Math.sin(angle));
+    };
+    Vector.sub = function (v1, v2) {
+        return new Vector(v1.x - v2.x, v1.y - v2.y);
+    };
+    Vector.div = function (v1, divider) {
+        return new Vector(v1.x / divider, v1.y / divider);
+    };
+    Vector.prototype.add = function (other) {
+        this.x += other.x;
+        this.y += other.y;
+        return this;
+    };
+    Vector.prototype.mult = function (scalar) {
+        this.x *= scalar;
+        this.y *= scalar;
+        return this;
+    };
+    Vector.prototype.addMag = function (length) {
+        this.setMag(this.mag() + length);
+        return this;
+    };
+    Vector.prototype.setMag = function (length) {
+        var mag = this.mag();
+        this.x /= mag;
+        this.y /= mag;
+        this.x *= length;
+        this.y *= length;
+        return this;
+    };
+    Vector.prototype.rotate = function (rad) {
+        var r = this.rotated(rad);
+        this.x = r.x;
+        this.y = r.y;
+        return this;
+    };
+    Vector.prototype.copy = function () {
+        return new Vector(this.x, this.y);
+    };
+    Vector.prototype.heading = function () {
+        var r = this.rotated(Math.PI / -2);
+        return Math.atan2(r.x, -r.y);
+    };
+    Vector.prototype.mag = function () {
+        return Math.sqrt(this.x * this.x + this.y * this.y);
+    };
+    Vector.prototype.serialized = function () {
+        return {
+            x: this.x,
+            y: this.y
+        };
+    };
+    Vector.prototype.rotated = function (rad) {
+        var x = Math.cos(rad) * this.x - Math.sin(rad) * this.y, y = Math.sin(rad) * this.x + Math.cos(rad) * this.y;
+        return new Vector(x, y);
+    };
+    return Vector;
+}());
+exports.Vector = Vector;
+exports.p = {
+    createVector: function (x, y) {
+        return new Vector(x, y);
+    },
+    dist: function (x1, y1, x2, y2) {
+        return Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
+    }
+};

src/logger.js

@@ -0,0 +1,97 @@
+"use strict";
+exports.__esModule = true;
+exports.log = void 0;
+var fs = require("fs");
+var util = require("util");
+var logFolder = "./logs";
+if (!fs.existsSync(logFolder)) {
+    fs.mkdirSync(logFolder);
+}
+var logFile = fs.createWriteStream(logFolder + '/' + new Date().getTime() + '.log', { flags: 'a' });
+var logStdout = process.stdout;
+console.log = function () {
+    logFile.write(util.format.apply(null, arguments) + '\n');
+    logStdout.write(util.format.apply(null, arguments) + '\n');
+};
+console.error = console.log;
+process.on('uncaughtException', function (err) {
+    console.error('Uncaught error: ', err);
+    process.exit(1);
+});
+process.stdin.pipe(logFile);
+function log(type, client, lobby, msg) {
+    var now = new Date(Date.now()).toString(), message, name, game;
+    var date = '[' + now.substring(0, now.indexOf('GMT') - 1) + ']';
+    if (client) {
+        game = '[' + client.game + ']';
+        var short = client.id.substring(0, Math.round(client.id.length / 3));
+        name = '"' + client.name + '(' + short + '...)"';
+    }
+    else {
+        if (type === 'lobby-deleted') {
+            game = '[' + lobby.gameName + ']';
+        }
+        else {
+            game = '[undefined]';
+        }
+        name = 'UNKNOWN';
+    }
+    if (lobby) {
+        game = '[' + lobby.gameName + ']';
+    }
+    switch (type) {
+        case 'join-non-existent':
+            message = name + ' tried to join non-existent lobby "' + lobby.id + '"';
+            break;
+        case 'join-started':
+            message = name + ' tried to join the started game "' + lobby.id + '"';
+            break;
+        case 'lobby-created':
+            message = name + ' created new lobby: "' + lobby.id + '"';
+            break;
+        case 'game-started':
+            message = name + ' started the game: "' + lobby.id + '"';
+            break;
+        case 'game-stopped':
+            message = name + ' stopped the game: "' + lobby.id + '"';
+            break;
+        case 'member-joined':
+            message = name + ' joined the lobby "' + lobby.id + '"';
+            break;
+        case 'member-left':
+            message = name + ' left the lobby "' + lobby.id + '"';
+            break;
+        case 'lobby-deleted':
+            message = 'Lobby "' + lobby.id + '" was deleted';
+            break;
+        case 'save-success':
+            message = msg;
+            break;
+        case 'save-error':
+            message = 'Failed to save contents to file: ' + msg;
+            break;
+        case 'load-success':
+            message = 'Successfully loaded and parsed file contents';
+            break;
+        case 'load-error':
+            message = 'Failed to load file: ' + msg;
+            break;
+        case 'parse-error':
+            message = 'Failed to parse contents: ' + msg;
+            break;
+        case 'feedback':
+            message = 'Saved feedback to file: ' + msg;
+            break;
+        case 'connection':
+            message = name + ' connected';
+            break;
+        case 'disconnection':
+            message = name + ' disconnected';
+            break;
+        case 'startup':
+            message = msg;
+            break;
+    }
+    console.log(date + game + ' ---> {' + message + '}');
+}
+exports.log = log;

src/manager.js

@@ -0,0 +1,126 @@
+"use strict";
+exports.__esModule = true;
+exports.serializeObject = exports.ConnectionManager = void 0;
+var room_1 = require("./room");
+var client_1 = require("./client");
+var logger_1 = require("./logger");
+var fs = require("fs");
+var ConnectionManager = /** @class */ (function () {
+    function ConnectionManager(io) {
+        ConnectionManager.Instance = this;
+        this.io = io;
+        this.rooms = [];
+        var drawSettings = {
+            project: {
+                name: 'global-draw',
+                playerCounts: null
+            },
+            always: true,
+            spectators: true
+        };
+        var drawRoom = this.createRoom(drawSettings, '');
+        drawRoom.id = 'global-draw-room';
+        drawRoom.startGame();
+        this.rooms.push(drawRoom);
+    }
+    ConnectionManager.RoomListByGame = function (game) {
+        return this.Instance.rooms.filter(function (l) { return l.gameName === game; });
+    };
+    ConnectionManager.ClientListByClientId = function (clientId) {
+        var room = room_1.Room.getByClientId(clientId, this.Instance.rooms);
+        return room.clients;
+    };
+    ConnectionManager.prototype.newSocket = function (socket) {
+        var client = new client_1.Client(socket, this);
+        (0, logger_1.log)('connection', client);
+    };
+    ConnectionManager.prototype.roomListUpdate = function () {
+        this.io.sockets.emit('room-list', serializeObject(this.rooms));
+    };
+    ConnectionManager.prototype.createRoom = function (settings, name) {
+        var roomId = room_1.Room.generateCode(10);
+        // @ts-ignore
+        var room = new room_1.Room(name, roomId, settings, this.io);
+        this.rooms.push(room);
+        this.roomListUpdate();
+        return room;
+    };
+    ConnectionManager.prototype.deleteRoom = function (room) {
+        this.rooms.splice(this.rooms.indexOf(room), 1);
+        this.roomListUpdate();
+        (0, logger_1.log)('lobby-deleted', null, room);
+    };
+    //Starts the game of a room with given id
+    ConnectionManager.prototype.startGame = function (client, _roomId) {
+        var lobby = room_1.Room.getByClientId(client.id, this.rooms);
+        if (!lobby)
+            return;
+        if (!lobby.hasStarted) {
+            lobby.startGame();
+            (0, logger_1.log)('game-started', client, lobby);
+        }
+        this.io.sockets.emit('room-list', serializeObject(this.rooms));
+    };
+    //Stops the game of a lobby with given id
+    ConnectionManager.prototype.stopGame = function (client, lobbyId) {
+        var lobby = room_1.Room.getByRoomId(lobbyId, this.rooms);
+        if (!lobby)
+            return;
+        lobby.stopGame(client);
+        (0, logger_1.log)('game-stopped', client, lobby);
+    };
+    //Saves user feedback to a file
+    ConnectionManager.prototype.saveFeedbackToFile = function (client, content) {
+        var date = new Date(Date.now()).toString();
+        var path = "feedback/" + client.game + '.txt';
+        var saveToFile = function (content) {
+            fs.writeFile(path, content, function (err) {
+                if (err)
+                    (0, logger_1.log)('save-error', client, null, err.message);
+                else
+                    (0, logger_1.log)('feedback', client, null, path);
+            });
+        };
+        if (fs.existsSync(path)) {
+            fs.readFile(path, 'utf8', function (err, data) {
+                if (err)
+                    (0, logger_1.log)('load-error', client, null, err.message);
+                else {
+                    (0, logger_1.log)('load-success', client, null);
+                    var newContent = data + '\n\n\n\n' + date + '\n\n' + content;
+                    saveToFile(newContent);
+                }
+            });
+        }
+        else {
+            saveToFile(date + '\n' + content);
+        }
+    };
+    //Removes a disconnected client from all references
+    ConnectionManager.prototype.disconnected = function (client) {
+        var room = room_1.Room.getByClientId(client.id, this.rooms);
+        if (room)
+            client.leaveRoom(room.id);
+        (0, logger_1.log)('disconnection', client);
+    };
+    return ConnectionManager;
+}());
+exports.ConnectionManager = ConnectionManager;
+function serializeObject(object) {
+    function serialize(obj) {
+        if (!obj)
+            return obj;
+        if (obj.serialized)
+            return obj.serialized;
+        else if (obj instanceof Array) {
+            var content_1 = [];
+            obj.forEach(function (o) {
+                content_1.push(serialize(o));
+            });
+            return content_1;
+        }
+        return obj;
+    }
+    return serialize(object);
+}
+exports.serializeObject = serializeObject;

src/manager.ts

@@ -51,7 +51,6 @@ export class ConnectionManager {
 
 	createRoom(settings: Settings.Global | any, name: string): Room {
 		let roomId = Room.generateCode(10);
-		// @ts-ignore
 		let room = new Room(name, roomId, settings, this.io);
 
 		this.rooms.push(room);

src/room.js

@@ -0,0 +1,164 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+exports.__esModule = true;
+exports.Room = void 0;
+var memory_1 = require("./games/memory");
+var pong_1 = require("./games/pong");
+var global_draw_1 = require("./games/global_draw");
+var chainreact_1 = require("./games/chainreact");
+var manager_1 = require("./manager");
+var Room = /** @class */ (function () {
+    function Room(name, id, settings, io) {
+        this.id = id;
+        this.name = name;
+        if (!io || !settings)
+            return;
+        this.settings = settings;
+        this.gameName = settings.project.name;
+        this.clientCounts = settings.project.playerCounts;
+        this.io = io;
+        this.clients = [];
+        this.gameSettings = {};
+    }
+    Object.defineProperty(Room.prototype, "leader", {
+        get: function () {
+            return this.players[0];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Room.prototype, "players", {
+        get: function () {
+            return this.clients.filter(function (c) { return c.isPlayer; });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Room.prototype, "spectators", {
+        get: function () {
+            return this.clients.filter(function (c) { return c.isSpectator; });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Room.prototype, "serialized", {
+        get: function () {
+            return {
+                id: this.id,
+                name: this.name,
+                game: this.gameName,
+                clientCounts: this.clientCounts,
+                clients: (0, manager_1.serializeObject)(this.clients),
+                hasStarted: this.hasStarted
+            };
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Room.prototype, "isEmpty", {
+        get: function () {
+            return !(this.clients.length);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Room.prototype, "hasStarted", {
+        get: function () {
+            return this.runningGame != null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Room.getByRoomId = function (id, lobbies) {
+        for (var _i = 0, lobbies_1 = lobbies; _i < lobbies_1.length; _i++) {
+            var l = lobbies_1[_i];
+            if (l.id === id)
+                return l;
+        }
+        return null;
+    };
+    Room.getByClientId = function (id, lobbies) {
+        for (var _i = 0, lobbies_2 = lobbies; _i < lobbies_2.length; _i++) {
+            var l = lobbies_2[_i];
+            for (var _a = 0, _b = l.clients; _a < _b.length; _a++) {
+                var c = _b[_a];
+                if (c.id === id)
+                    return l;
+            }
+        }
+        return null;
+    };
+    Room.generateCode = function (elements) {
+        var code = '';
+        var possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+        while (elements--) {
+            code += possible.charAt(Math.floor(Math.random() * possible.length));
+        }
+        return code;
+    };
+    Room.prototype.startGame = function () {
+        var seed = Math.random() * 10000;
+        this.toAll('start-game', seed);
+        this.runGame();
+    };
+    Room.prototype.stopGame = function (client) {
+        this.toAll('stop-game', client);
+        this.runningGame = null;
+    };
+    Room.prototype.add = function (client) {
+        this.clients.push(client);
+        var isPlayer = !this.hasStarted && this.hasValidPlayerCount();
+        client.isPlayer = isPlayer;
+        client.isSpectator = !isPlayer;
+        client.isReady = false;
+        client.join(this.id);
+        this.toAll('member-joined', client.id, client.name);
+        this.toAll('client-list', this.clients);
+        this.toAll('game-settings', this.gameSettings);
+        if (this.hasStarted)
+            this.runningGame.addClient(client);
+    };
+    Room.prototype.hasValidPlayerCount = function () {
+        var _this = this;
+        var valid = false;
+        this.clientCounts.forEach(function (c) {
+            if (c === _this.clients.length)
+                valid = true;
+        });
+        return valid;
+    };
+    Room.prototype.runGame = function () {
+        switch (this.gameName) {
+            case 'memory':
+                this.runningGame = new memory_1.Memory(this, this.settings);
+                break;
+            case 'pong':
+                this.runningGame = new pong_1.Pong(this, this.settings);
+                break;
+            case 'global-draw':
+                this.runningGame = new global_draw_1.GlobalDraw(this, this.settings);
+                break;
+            case 'chainreact':
+                this.runningGame = new chainreact_1.Chainreact(this, this.settings);
+                break;
+        }
+    };
+    Room.prototype.toAll = function (event) {
+        var _a;
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        (_a = this.io.to(this.id)).emit.apply(_a, __spreadArray([event, (0, manager_1.serializeObject)(this)], (0, manager_1.serializeObject)(args), false));
+    };
+    return Room;
+}());
+exports.Room = Room;

src/server.js

@@ -0,0 +1,27 @@
+'use strict';
+exports.__esModule = true;
+var logger_1 = require("./logger");
+var manager_1 = require("./manager");
+var https = require("https");
+var socket_io_1 = require("socket.io");
+var fs = require("fs");
+var ini = require("ini");
+function GameServer() {
+    var p2p = require('socket.io-p2p-server').Server;
+    var rootDir = __dirname + '/..';
+    var httpsPort = ini.parse(fs.readFileSync(rootDir + '/env_config.ini', 'utf-8'))['nodejs_port'];
+    var cert = fs.readFileSync(rootDir + '/ssl_certificate/cert.pem');
+    var key = fs.readFileSync(rootDir + '/ssl_certificate/key.pem');
+    var httpsServer = https.createServer({ key: key, cert: cert });
+    var sIO = new socket_io_1.Server(httpsServer, {
+        cors: {
+            origin: ["https://play.benjamin-kraft.local", "https://dev.play.benjamin-kraft.eu", "https://play.benjamin-kraft.eu"]
+        }
+    });
+    sIO.use(p2p);
+    httpsServer.listen(httpsPort);
+    var connectionManager = new manager_1.ConnectionManager(sIO);
+    // On new connection
+    sIO.on('connection', function (socket) { return connectionManager.newSocket(socket); });
+    (0, logger_1.log)('startup', null, null, 'Server is listening on port ' + httpsPort);
+}

src/server.ts

@@ -0,0 +1,39 @@
+'use strict';
+
+
+import {log} from "./logger";
+import {ConnectionManager} from "./manager";
+
+import https = require('https');
+import {Server} from 'socket.io';
+import fs = require('fs');
+import ini = require('ini');
+
+function GameServer(){
+	const p2p = require('socket.io-p2p-server').Server;
+
+	let rootDir = __dirname + '/..';
+
+	let httpsPort = ini.parse(fs.readFileSync(rootDir + '/env_config.ini', 'utf-8'))['nodejs_port'];
+
+	let cert = fs.readFileSync(rootDir + '/ssl_certificate/cert.pem');
+	let key = fs.readFileSync(rootDir + '/ssl_certificate/key.pem');
+
+	let httpsServer = https.createServer({key: key, cert: cert});
+
+	let sIO = new Server(httpsServer, {
+		cors: {
+			origin: ["https://play.benjamin-kraft.local", "https://dev.play.benjamin-kraft.eu", "https://play.benjamin-kraft.eu"]
+		}
+	});
+	sIO.use(p2p);
+
+	httpsServer.listen(httpsPort);
+
+	let connectionManager = new ConnectionManager(sIO);
+
+	// On new connection
+	sIO.on('connection', socket => connectionManager.newSocket(socket));
+
+	log('startup', null, null, 'Server is listening on port ' + httpsPort);
+}

ts/server.ts

@@ -1,35 +0,0 @@
-'use strict';
-
-import {log} from "./logger";
-import {ConnectionManager} from "./manager";
-
-import https = require('https');
-import {Server} from 'socket.io';
-const p2p = require('socket.io-p2p-server').Server;
-import fs = require('fs');
-import ini = require('ini');
-
-let rootDir = __dirname + '/..';
-
-let httpsPort = ini.parse(fs.readFileSync(rootDir + '/env_config.ini', 'utf-8'))['nodejs_port'];
-
-let cert = fs.readFileSync(rootDir + '/ssl_certificate/cert.pem');
-let key = fs.readFileSync(rootDir + '/ssl_certificate/key.pem');
-
-let httpsServer = https.createServer({key: key, cert: cert});
-
-let sIO = new Server(httpsServer, {
-	cors: {
-		origin: ["https://play.benjamin-kraft.local", "https://dev.play.benjamin-kraft.eu", "https://play.benjamin-kraft.eu"]
-	}
-});
-sIO.use(p2p);
-
-httpsServer.listen(httpsPort);
-
-let connectionManager = new ConnectionManager(sIO);
-
-// On new connection
-sIO.on('connection', socket => connectionManager.newSocket(socket));
-
-log('startup', null, null, 'Server is listening on port ' + httpsPort);

tsconfig.json

@@ -4,10 +4,6 @@
 		"module": "commonjs",
 		"sourceMap": true,
 		"alwaysStrict": true,
-        "outDir": "./js",
 		"removeComments": true
-    },
-    "include": [
-        "./ts"
-    ]
+	}
 }