refactor

Account/_emitLogin.ts

@@ -0,0 +1,21 @@
+import { loginResponse } from "../Classes/loginResponse";
+import { playerData } from "../Classes/playerData";
+import { userData } from "../Classes/userData";
+
+export function emitLogin(socket, user : userData | null, player:playerData, registered:boolean = false){
+    if(user != null){
+        socket.emit("account/login", JSON.stringify(new loginResponse(true, user, player)));
+        socket.user = user
+        socket.player = player
+        if(registered){
+            console.log(`User ${(user as userData).login} registerd and logged in`);
+        }
+        else{
+            console.log(`User ${(user as userData).login} logged in`);
+        }
+    }
+    else{
+        socket.emit("account/login", JSON.stringify(new loginResponse(false, null, null)));
+        console.log("Login Failed");
+    }
+}

Account/_login.ts

@@ -0,0 +1,21 @@
+import { userData } from "../Classes/userData";
+import { players } from "../Player/players";
+import { emitLogin } from "./_emitLogin";
+import { users } from "./users";
+
+export function login(socket, data){
+    let buff = Buffer.from(data, 'base64');
+        let json : userData = JSON.parse(buff.toString('utf-8'));
+        if (!json.login || !json.password) return
+
+        let result = users.readUser(json.login, json.password);
+        let player = null
+        if(result != null){
+            player = players.readPlayer(result.id)
+            if(player == null){
+                player = players.createPlayer(result.id)
+            }
+        }
+
+        emitLogin(socket, result, player);
+}

Account/_register.ts

@@ -0,0 +1,18 @@
+import { userData } from "../Classes/userData";
+import { players } from "../Player/players";
+import { emitLogin } from "./_emitLogin";
+import { users } from "./users";
+
+export function register(socket, data){
+    let buff = Buffer.from(data, 'base64');
+        let json : userData = JSON.parse(buff.toString('utf-8'));
+        if (!json.login || !json.password) return
+
+        let result = users.createUser(json.login, json.password);
+        let player = null
+        if(result != null){
+            player = players.createPlayer(result.id)
+        }
+
+        emitLogin(socket, result, player);
+}

Account/accountSocket.ts

@@ -1,56 +1,12 @@
-import { loginResponse } from "../Classes/loginResponse";
+import { register } from "./_register";
-import { playerData } from "../Classes/playerData";
+import { login } from "./_login";
-import { userData } from "../Classes/userData";
-import { users } from "./users";
-import { players } from "../Player/players";
 
 export function registerAccountCallbacks(socket){
-    function emitLogin(user : userData | null, player:playerData, registered:boolean = false){
-        if(user != null){
-            socket.emit("account/login", JSON.stringify(new loginResponse(true, user, player)));
-            socket.user = user
-            socket.player = player
-            if(registered){
-                console.log(`User ${(user as userData).login} registerd and logged in`);
-            }
-            else{
-                console.log(`User ${(user as userData).login} logged in`);
-            }
-        }
-        else{
-            socket.emit("account/login", JSON.stringify(new loginResponse(false, null, null)));
-            console.log("Login Failed");
-        }
-    }
-    
     socket.on('account/register', (data) => {
-        let buff = Buffer.from(data, 'base64');
+        register(socket, data)
-        let json : userData = JSON.parse(buff.toString('utf-8'));
-        if (!json.login || !json.password) return
-
-        let result = users.createUser(json.login, json.password);
-        let player = null
-        if(result != null){
-            player = players.createPlayer(result.id)
-        }
-
-        emitLogin(result, player);
     });
 
     socket.on('account/login', (data) => {
-        let buff = Buffer.from(data, 'base64');
+        login(socket, data)
-        let json : userData = JSON.parse(buff.toString('utf-8'));
-        if (!json.login || !json.password) return
-
-        let result = users.readUser(json.login, json.password);
-        let player = null
-        if(result != null){
-            player = players.readPlayer(result.id)
-            if(player == null){
-                player = players.createPlayer(result.id)
-            }
-        }
-
-        emitLogin(result, player);
     });
 }

Items/_delete1.ts

@@ -0,0 +1,15 @@
+import { playerData } from "../Classes/playerData";
+
+export function delete1(socket, data){
+    if(!socket.hasOwnProperty("user")) return;
+
+        let buff = Buffer.from(data, 'base64');
+        let data1 = Number(buff.toString('utf-8'));
+
+        let player : playerData = socket.player
+        let item = player.inventory.items.findIndex(i=>i.id == data1);
+        if(item == -1){
+            console.log("Error! Item " + item + " not found!")
+        }
+        player.inventory.items.splice(item, 1)
+}

Items/_deleteMany.ts

@@ -0,0 +1,22 @@
+import { inventoryItemTransaction } from "../Classes/inventoryItemTransaction";
+import { playerData } from "../Classes/playerData";
+
+export function deleteMany(socket, data){
+    if(!socket.hasOwnProperty("user")) return;
+
+    let buff = Buffer.from(data, 'base64');
+    let data1 : inventoryItemTransaction[] = JSON.parse(buff.toString('utf-8'));
+
+    let player : playerData = socket.player
+    data1.forEach(t=>{
+        switch(t.type){
+            case 0:
+                player.inventory.items.find(i=>i.id == t.itemId).count += t.amount;
+                break;
+            case 2:
+                let item = player.inventory.items.findIndex(i=>i.id == t.itemId);
+                player.inventory.items.splice(item, 1)
+                break;
+        }
+    })
+}

Items/_pickup.ts

@@ -0,0 +1,70 @@
+import { itemData } from "../Classes/itemData";
+import { lobbyMessage } from "../Classes/lobbyMessage";
+import { playerData } from "../Classes/playerData";
+import { game } from "../game";
+
+export function pickup(socket, data){
+    
+    if(!socket.hasOwnProperty("user")) return;
+
+    let buff = Buffer.from(data, 'base64');
+    let data1 : itemData = JSON.parse(buff.toString('utf-8'));
+
+    let player : playerData = socket.player
+    if(player != null){
+        
+        let inventory = player.inventory
+        let template = game.getItemTemplate(data1.templateId)
+        let items = inventory.items.filter(i=>i.templateId == data1.templateId)
+        let totalAdded = 0
+
+        if(data1.count > template.maxCount)
+        {
+            console.log("ERROR ERROR ITEM ERROR")
+            return;
+        }
+
+        items.forEach(item=>{
+            var maxAmount =  Math.min(template.maxCount - item.count, data1.count - totalAdded);
+
+            if (maxAmount > 0)
+            {
+                item.count += maxAmount;
+                totalAdded += maxAmount;
+            }
+        })
+
+        if(totalAdded < data1.count)
+        {
+            let maxAmount = data1.count - totalAdded
+            let itemCopy = itemData.copy(data1);
+            itemCopy.count = maxAmount;
+            totalAdded += maxAmount;
+            inventory.items.push(itemCopy);
+        }
+
+        if (totalAdded == data1.count)
+        {
+            if(data1.rarity >= 75){
+                let message = socket.user.login + " picked up "
+                if(data1.rarity >= 95){
+                    message += "<color=purple>" + data1.name + "</color> (epic)"
+                }
+                else if(data1.rarity >= 75){
+                    message += "<color=red>" + data1.name + "</color> (rare)"
+                }
+                else if(data1.rarity >= 60){
+                    message += "<color=yellow>" + data1.name + "</color> (uncommon)"
+                }
+                else
+                    message += data1.name;
+
+                game.addMessage(new lobbyMessage(message))
+            }
+        }
+        else
+        {
+            console.log("ERROR ERROR ITEM ERROR")
+        }
+    }
+}

Items/_request.ts

@@ -0,0 +1,16 @@
+import { itemGenerated } from "../Classes/itemGenerated";
+import { itemRequest } from "../Classes/itemRequest";
+import { generateItemByType } from "./itemGeneration";
+
+export function request(socket, data){
+    if(!socket.hasOwnProperty("user")) return;
+
+    let buff = Buffer.from(data, 'base64');
+    let data1 : itemRequest = JSON.parse(buff.toString('utf-8'));
+
+    let response = new itemGenerated()
+    response.instanceId = data1.instanceId
+    response.item = generateItemByType(data1.itemType)
+    
+    socket.emit("item/generated", JSON.stringify(response))
+}

Items/itemSocket.ts

@@ -1,122 +1,22 @@
-import { itemData } from "../Classes/itemData";
+import { delete1 } from "./_delete1";
-import { itemGenerated } from "../Classes/itemGenerated";
+import { deleteMany } from "./_deleteMany";
-import { generateItemByType } from "./itemGeneration";
+import { pickup } from "./_pickup";
-import { itemRequest } from "../Classes/itemRequest";
+import { request } from "./_request";
-import { lobbyMessage } from "../Classes/lobbyMessage";
-import { game } from "../game";
-import { playerData } from "../Classes/playerData";
-import { inventoryItemTransaction } from "../Classes/inventoryItemTransaction";
 
 export function registerItemCallbacks(socket){
     socket.on('item/pickup', (data) => {
-        if(!socket.hasOwnProperty("user")) return;
+        pickup(socket, data)
-
-        let buff = Buffer.from(data, 'base64');
-        let data1 : itemData = JSON.parse(buff.toString('utf-8'));
-
-        let player : playerData = socket.player
-        if(player != null){
-            
-            let inventory = player.inventory
-            let template = game.getItemTemplate(data1.templateId)
-            let items = inventory.items.filter(i=>i.templateId == data1.templateId)
-            let totalAdded = 0
-
-            if(data1.count > template.maxCount)
-            {
-                console.log("ERROR ERROR ITEM ERROR")
-                return;
-            }
-
-            items.forEach(item=>{
-                var maxAmount =  Math.min(template.maxCount - item.count, data1.count - totalAdded);
-
-                if (maxAmount > 0)
-                {
-                    item.count += maxAmount;
-                    totalAdded += maxAmount;
-                }
-            })
-
-            if(totalAdded < data1.count)
-            {
-                let maxAmount = data1.count - totalAdded
-                let itemCopy = itemData.copy(data1);
-                itemCopy.count = maxAmount;
-                totalAdded += maxAmount;
-                inventory.items.push(itemCopy);
-            }
-
-            if (totalAdded == data1.count)
-            {
-                if(data1.rarity >= 75){
-                    let message = socket.user.login + " picked up "
-                    if(data1.rarity >= 95){
-                        message += "<color=purple>" + data1.name + "</color> (epic)"
-                    }
-                    else if(data1.rarity >= 75){
-                        message += "<color=red>" + data1.name + "</color> (rare)"
-                    }
-                    else if(data1.rarity >= 60){
-                        message += "<color=yellow>" + data1.name + "</color> (uncommon)"
-                    }
-                    else
-                        message += data1.name;
-    
-                    game.addMessage(new lobbyMessage(message))
-                }
-            }
-            else
-            {
-                console.log("ERROR ERROR ITEM ERROR")
-            }
-        }
     });
 
     socket.on('item/delete', (data) => {
-        if(!socket.hasOwnProperty("user")) return;
+        delete1(socket, data)
-
-        let buff = Buffer.from(data, 'base64');
-        let data1 = Number(buff.toString('utf-8'));
-
-        let player : playerData = socket.player
-        let item = player.inventory.items.findIndex(i=>i.id == data1);
-        if(item == -1){
-            console.log("Error! Item " + item + " not found!")
-        }
-        player.inventory.items.splice(item, 1)
     });
 
     socket.on('item/deleteMany', (data) => {
-        if(!socket.hasOwnProperty("user")) return;
+        deleteMany(socket, data)
-
-        let buff = Buffer.from(data, 'base64');
-        let data1 : inventoryItemTransaction[] = JSON.parse(buff.toString('utf-8'));
-
-        let player : playerData = socket.player
-        data1.forEach(t=>{
-            switch(t.type){
-                case 0:
-                    player.inventory.items.find(i=>i.id == t.itemId).count += t.amount;
-                    break;
-                case 2:
-                    let item = player.inventory.items.findIndex(i=>i.id == t.itemId);
-                    player.inventory.items.splice(item, 1)
-                    break;
-            }
-        })
     });
 
     socket.on('item/request', (data) => {
-        if(!socket.hasOwnProperty("user")) return;
+        request(socket, data)
-
-        let buff = Buffer.from(data, 'base64');
-        let data1 : itemRequest = JSON.parse(buff.toString('utf-8'));
-
-        let response = new itemGenerated()
-        response.instanceId = data1.instanceId
-        response.item = generateItemByType(data1.itemType)
-        
-        socket.emit("item/generated", JSON.stringify(response))
     });
 }

Level/_projectile.ts

@@ -0,0 +1,10 @@
+import { game } from "../game";
+
+export function projectile(socket, data){
+    if(!socket.hasOwnProperty("user")) return;
+
+    let buff = Buffer.from(data, 'base64');
+    //let data1 = JSON.parse();
+    
+    game.socketIO.emit('level/projectile', buff.toString('utf-8'))
+}

Level/_update.ts

@@ -0,0 +1,26 @@
+import { levelState } from "../Classes/levelState";
+import { game } from "../game";
+
+export function update(socket, data){
+    if(!socket.hasOwnProperty("user")) return;
+
+    let buff = Buffer.from(data, 'base64');
+    let rawJson = JSON.parse(buff.toString('utf-8'));
+    let data1 : levelState = rawJson;
+
+    let room = game.lobbyState.rooms.find(l=>l.id == data1.id)
+    if (room == null){
+        room = new levelState()
+        room.id = data1.id
+        game.lobbyState.rooms.push(room)
+    }
+
+    let player = socket.player
+    player.room = rawJson.player.room
+    player.rigidbody = rawJson.player.rigidbody
+    //only in non-host player
+    //player.damageInfo = rawJson.player.damageInfo
+    
+    room.enemies = data1.enemies
+    room.objects = data1.objects
+}

Level/levelSocket.ts

@@ -1,37 +1,12 @@
-import { levelState } from "../Classes/levelState";
+import { projectile } from "./_projectile";
-import { game } from "../game";
+import { update } from "./_update";
 
 export function registerLevelCallbacks(socket){
     socket.on('level/update', (data) => {
-        if(!socket.hasOwnProperty("user")) return;
+        update(socket, data)
-
-        let buff = Buffer.from(data, 'base64');
-        let rawJson = JSON.parse(buff.toString('utf-8'));
-        let data1 : levelState = rawJson;
-
-        let room = game.lobbyState.rooms.find(l=>l.id == data1.id)
-        if (room == null){
-            room = new levelState()
-            room.id = data1.id
-            game.lobbyState.rooms.push(room)
-        }
-
-        let player = socket.player
-        player.room = rawJson.player.room
-        player.rigidbody = rawJson.player.rigidbody
-        //only in non-host player
-        //player.damageInfo = rawJson.player.damageInfo
-        
-        room.enemies = data1.enemies
-        room.objects = data1.objects
     });
 
     socket.on('level/projectile', (data) => {
-        if(!socket.hasOwnProperty("user")) return;
+        projectile(socket, data)
-
-        let buff = Buffer.from(data, 'base64');
-        //let data1 = JSON.parse();
-        
-        game.socketIO.emit('level/projectile', buff.toString('utf-8'))
     });
 }

Lobby/_loadoutChanged.ts

@@ -0,0 +1,16 @@
+import { playerData } from "../Classes/playerData";
+import { game } from "../game";
+
+export function loadoutChanged(socket, data){
+    if(!socket.hasOwnProperty("user")) return;
+
+    let buff = Buffer.from(data, 'base64');
+    let data1 : playerData = JSON.parse(buff.toString('utf-8'));
+
+    let player : playerData = socket.player
+    player.inventory.weapon = data1.inventory.weapon
+    player.inventory.equipment = data1.inventory.equipment
+    player.validateEquipment()
+
+    game.socketIO.emit("lobby/loadoutChanged", JSON.stringify(player))
+}

Lobby/_message.ts

@@ -0,0 +1,12 @@
+import { lobbyMessage } from "../Classes/lobbyMessage";
+import { game } from "../game";
+
+export function message(socket, data){
+    if(!socket.hasOwnProperty("user")) return;
+
+    let buff = Buffer.from(data, 'base64');
+    let data1 : lobbyMessage = JSON.parse(buff.toString('utf-8'));
+    data1.timestamp = new Date().toLocaleString();
+
+    game.addMessage(data1)
+}

Lobby/_playerJoin.ts

@@ -0,0 +1,21 @@
+import { lobbyMessage } from "../Classes/lobbyMessage";
+import { lobbyState } from "../Classes/lobbyState";
+import { playerData } from "../Classes/playerData";
+import { userData } from "../Classes/userData";
+import { game } from "../game";
+
+export function playerJoin(socket, data){
+    if(!socket.hasOwnProperty("user")) return;
+
+    let buff = Buffer.from(data, 'base64');
+    let data1 : playerData = JSON.parse(buff.toString('utf-8'));
+
+    socket.player.characterId = data1.characterId
+    game.lobbyState.addUser(socket.user, socket.player)
+
+    let newLobbyState : lobbyState = Object.assign({}, game.lobbyState);
+    newLobbyState.users = newLobbyState.users.map(u=> userData.makeSafe(u))
+
+    game.socketIO.emit("lobby/playerJoin", JSON.stringify(newLobbyState))
+    game.addMessage(new lobbyMessage(socket.user.login + " joined"))
+}

Lobby/_playerUpdate.ts

@@ -0,0 +1,18 @@
+import { playerData } from "../Classes/playerData";
+
+export function playerUpdate(socket, data){
+    if(!socket.hasOwnProperty("user")) return;
+
+    let buff = Buffer.from(data, 'base64');
+    let data1 : playerData = JSON.parse(buff.toString('utf-8'));
+
+    let player : playerData = socket.player
+    if(player == null){
+        console.log("Error! Player not spawned!")
+    }
+    else{
+        player.room = data1.room
+        player.rigidbody = data1.rigidbody
+        player.damageInfo = player.damageInfo.concat(data1.damageInfo)
+    }
+}

Lobby/lobbySocket.ts

@@ -1,65 +1,22 @@
-import { lobbyMessage } from "../Classes/lobbyMessage";
+import { loadoutChanged } from "./_loadoutChanged";
-import { lobbyState } from "../Classes/lobbyState";
+import { message } from "./_message";
-import { playerData } from "../Classes/playerData"
+import { playerJoin } from "./_playerJoin";
-import { playerInventory } from "../Classes/playerInventory";
+import { playerUpdate } from "./_playerUpdate";
-import { userData } from "../Classes/userData";
-import { game } from "../game";
 
 export function registerLobbyCallbacks(socket){
     socket.on('lobby/playerJoin', (data) => {
-        if(!socket.hasOwnProperty("user")) return;
+        playerJoin(socket, data)
-
-        let buff = Buffer.from(data, 'base64');
-        let data1 : playerData = JSON.parse(buff.toString('utf-8'));
-
-        socket.player.characterId = data1.characterId
-        game.lobbyState.addUser(socket.user, socket.player)
-
-        let newLobbyState : lobbyState = Object.assign({}, game.lobbyState);
-        newLobbyState.users = newLobbyState.users.map(u=> userData.makeSafe(u))
-
-        game.socketIO.emit("lobby/playerJoin", JSON.stringify(newLobbyState))
-        game.addMessage(new lobbyMessage(socket.user.login + " joined"))
     });
 
     socket.on('lobby/playerUpdate', (data) => {
-        if(!socket.hasOwnProperty("user")) return;
+        playerUpdate(socket, data)
-
-        let buff = Buffer.from(data, 'base64');
-        let data1 : playerData = JSON.parse(buff.toString('utf-8'));
-
-        let player : playerData = socket.player
-        if(player == null){
-            console.log("Error! Player not spawned!")
-        }
-        else{
-            player.room = data1.room
-            player.rigidbody = data1.rigidbody
-            player.damageInfo = player.damageInfo.concat(data1.damageInfo)
-        }
     });
 
     socket.on('lobby/loadoutChanged', (data) => {
-        if(!socket.hasOwnProperty("user")) return;
+        loadoutChanged(socket, data)
-
-        let buff = Buffer.from(data, 'base64');
-        let data1 : playerData = JSON.parse(buff.toString('utf-8'));
-
-        let player : playerData = socket.player
-        player.inventory.weapon = data1.inventory.weapon
-        player.inventory.equipment = data1.inventory.equipment
-        player.validateEquipment()
-
-        game.socketIO.emit("lobby/loadoutChanged", JSON.stringify(player))
     });
 
     socket.on('lobby/message', (data) => {
-        if(!socket.hasOwnProperty("user")) return;
+        message(socket, data)
-
-        let buff = Buffer.from(data, 'base64');
-        let data1 : lobbyMessage = JSON.parse(buff.toString('utf-8'));
-        data1.timestamp = new Date().toLocaleString();
-
-        game.addMessage(data1)
     });
 }