Connectivity optimization

Classes/Incoming/levelEnter.ts

@@ -0,0 +1,6 @@
+import { levelState } from "../levelState"
+
+export class levelEnter{
+    previousRoom : levelState
+    targetRoom : levelState
+}

Classes/Incoming/levelUpdateClient.ts

@@ -0,0 +1,5 @@
+import { playerData } from "../playerData";
+
+export class levelUpdateClient{
+    player : playerData
+}

Classes/Incoming/levelUpdateHost.ts

@@ -0,0 +1,7 @@
+import { levelState } from "../levelState";
+import { playerData } from "../playerData";
+
+export class levelUpdateHost{
+    player : playerData
+    room : levelState
+}

Classes/Incoming/lobbyJoin.ts

@@ -0,0 +1,5 @@
+import { playerData } from "../playerData";
+
+export class lobbyJoin{
+    player : playerData
+}

Classes/enemyData.ts

@@ -6,4 +6,21 @@ export class enemyData{
     templateId  : number
     rigidbody   : physicsObject
     stats       : Stat[] = []
+
+    static copyStart(e: enemyData): any {
+        let enemy : any = {}
+        enemy.id = e.id
+        enemy.templateId = e.templateId
+        enemy.rigidbody = physicsObject.characterOnly(e.rigidbody)
+        enemy.stats = e.stats
+        return enemy
+    }
+    
+    static copyUpdate(e: enemyData): any {
+        let enemy : any = {}
+        enemy.id = e.id
+        enemy.rigidbody = physicsObject.characterOnly(e.rigidbody)
+        enemy.stats = e.stats
+        return enemy
+    }
 }

Classes/levelState.ts

@@ -1,6 +1,6 @@
 import { enemyData } from "./enemyData";
-import { physicsObject } from "./physicsObject";
 import { playerData } from "./playerData";
+import { propData } from "./propData";
 
 export class levelState{
     id : string
@@ -9,7 +9,7 @@ export class levelState{
     completed : boolean = false
     isDungeon : boolean = false
     enemies : enemyData[] = []
-    objects : physicsObject[] = []
+    objects : propData[] = []
     players : playerData[] = []
 
     getRandomInt(max) {
@@ -23,15 +23,37 @@ export class levelState{
         this.completed = false
     }
 
-    copyLight() {
+    copyStart(){
+        let level : any = {}
+        level.id = this.id
+        level.seed = this.seed
+        level.hostId = this.hostId
+        level.completed = this.completed
+        level.isDungeon = this.isDungeon
+        if(this.enemies.length > 0) level.enemies = this.enemies.map(e => enemyData.copyStart(e))
+        if(this.objects.length > 0) level.objects = this.objects.map(e => propData.copyPropStart(e))
+        if(this.players.length > 0) level.players = this.players.map(pl=> pl.copyUpdate())
+        return level
+    }
+
+    copyUpdate(){
+        let level : any = {}
+        level.id = this.id
+        level.seed = this.seed
+        level.hostId = this.hostId
+        level.completed = this.completed
+        if(this.enemies.length > 0) level.enemies = this.enemies.map(e => enemyData.copyUpdate(e))
+        if(this.objects.length > 0) level.objects = this.objects.map(e => propData.copyPropUpdate(e))
+        if(this.players.length > 0) level.players = this.players.map(pl=> pl.copyUpdate())
+        return level
+    }
+
+    copyState(){
         let level : any = {}
         level.id = this.id
         level.seed = this.seed
         level.hostId = this.hostId
         level.completed = this.completed
-        level.enemies = this.enemies
-        level.objects = this.objects
-        level.players = this.players.map(pl=>pl.copyLight())
         return level
     }
 

Classes/lobbyState.ts

@@ -14,7 +14,7 @@ export class lobbyState{
         lobby.players = []
         lobby.users = []
         for (let i = 0; i < this.players.length; i++) {
-            lobby.players.push(this.players[i].copyLight());
+            lobby.players.push(this.players[i].copyUpdate());
         }
         lobby.rooms = this.rooms
         lobby.dungeons = this.dungeons

Classes/physicsObject.ts

@@ -1,16 +1,45 @@
 export class physicsObject{
-    name : string
-    templateId : number
     //array of floats [3]
-    kinematic : boolean
     position : number[] = [0,0,0]
     rotation : number[] = [0,0,0]
     velocity : number[] = [0,0,0]
     angularVelocity : number[] = [0,0,0]
 
-    static copyLight(o: physicsObject) {
-        let pObject = Object.assign({}, o)
+    static isKinematic(o:physicsObject){
+        return !o.hasOwnProperty("velocity")
+    }
 
+    static copyAll(o: physicsObject) {
+        let pObject = Object.assign({}, o)
+        return pObject
+    }
+
+    static characterOnly(o: physicsObject) {
+        let pObject : any = {}
+        pObject.position = o.position
+        pObject.velocity = o.velocity
+        return pObject
+    }
+    
+    static copyStart(o: physicsObject) {
+        let pObject : any = {}
+        pObject.position = o.position
+        pObject.rotation = o.rotation
+        if(!this.isKinematic(o)){
+            pObject.velocity = o.velocity
+            pObject.angularVelocity = o.angularVelocity
+        }
+        return pObject
+    }
+
+    static copyUpdate(o: physicsObject) {
+        let pObject : any = {}
+        if(!this.isKinematic(o)){
+            pObject.position = o.position
+            pObject.rotation = o.rotation
+            pObject.velocity = o.velocity
+            pObject.angularVelocity = o.angularVelocity
+        }
         return pObject
     }
 }

Classes/playerData.ts

@@ -11,12 +11,29 @@ export class playerData{
     rigidbody : physicsObject = new physicsObject()
     damageInfo : enemyDamageInfo[] = []
 
-    copyLight(){
+    copyStart(){
         let player : any = {}
         player.id = this.id
-        //player.room = this.room
-        player.rigidbody = physicsObject.copyLight(this.rigidbody)
-        player.damageInfo = this.damageInfo
+        player.characterId = this.characterId
+        player.rigidbody = physicsObject.characterOnly(this.rigidbody)
+        return player
+    }
+
+    copyUpdate(){
+        let player : any = {}
+        player.id = this.id
+        if(this.rigidbody == null){
+            console.log(this)
+        }
+        player.rigidbody = physicsObject.characterOnly(this.rigidbody)
+        if(this.damageInfo.length > 0) player.damageInfo = this.damageInfo
+        return player
+    }
+
+    copyInventory(){
+        let player : any = {}
+        player.id = this.id
+        player.inventory = this.inventory
         return player
     }
     

Classes/propData.ts

@@ -0,0 +1,22 @@
+import { physicsObject } from "./physicsObject"
+
+export class propData{
+    name       : string
+    templateId : number
+    rigidbody  : physicsObject
+
+    static copyPropStart(o: propData) {
+        let pObject = Object.assign({}, o)
+        pObject.rigidbody = physicsObject.copyStart(o.rigidbody)
+        return pObject
+    }
+
+    static copyPropUpdate(o: propData) {
+        let pObject : any = {}
+        pObject.name = o.name
+        if(!physicsObject.isKinematic(o.rigidbody)){
+            pObject.rigidbody = physicsObject.copyUpdate(o.rigidbody)
+        }
+        return pObject
+    }
+}

Classes/roomChangeRequest.ts

@@ -1,6 +0,0 @@
-import { levelState } from "./levelState"
-
-export class roomChangeData{
-    previousRoom : string
-    targetRoom : levelState
-}

Level/_clear.ts

@@ -1,11 +1,11 @@
 import { game } from "../game";
 
-export function clearRoom(socket, data){
+export function clear(socket, data){
     if(!socket.hasOwnProperty("player")) return;
 
     let buff = Buffer.from(data, 'base64');
     let data1 : string = JSON.parse(buff.toString('utf-8'));
 
     let room = game.lobbyState.roomComplete(data1)
-    game.socketIO.emit("lobby/cleared", JSON.stringify(room))
+    game.socketIO.emit("level/cleared", JSON.stringify(room.copyState()))
 }

Level/_enter.ts

@@ -0,0 +1,30 @@
+import { game } from "../game";
+import { playerData } from "../Classes/playerData";
+import { roomChangeResponse } from "../Classes/roomChangeResponse";
+import { levelEnter } from "../Classes/Incoming/levelEnter";
+
+export function enter(socket, data){
+    if(!socket.hasOwnProperty("player")) return;
+
+    let buff = Buffer.from(data, 'base64');
+    let data1 : levelEnter = JSON.parse(buff.toString('utf-8'));
+    let player : playerData = socket.player
+
+    socket.join(data1.targetRoom.id)
+    let newRoom = game.lobbyState.roomEnter(data1.targetRoom, player)
+    player.room = newRoom.id
+
+    socket.leave(data1.previousRoom.id)
+    let oldRoom = game.lobbyState.roomExit(data1.previousRoom.id, player)
+    
+    let data2 = new roomChangeResponse()
+    data2.player = player.copyUpdate()
+    data2.newRoom = newRoom.copyStart()
+    data2.previousRoom = oldRoom.copyState()
+
+    socket.emit("level/entered", JSON.stringify(data2))
+
+    data2.newRoom = newRoom.copyState()
+
+    socket.broadcast.emit("level/entered", JSON.stringify(data2))
+}

Level/_playerUpdate.ts

@@ -1,10 +1,11 @@
+import { levelUpdateClient } from "../Classes/Incoming/levelUpdateClient";
 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 data1 : levelUpdateClient = JSON.parse(buff.toString('utf-8'));
 
     let player : playerData = socket.player
     if(player == null){
@@ -12,7 +13,7 @@ export function playerUpdate(socket, data){
         return
     }
     
-    player.room = data1.room
-    player.rigidbody = data1.rigidbody
-    player.damageInfo = player.damageInfo.concat(data1.damageInfo)
+    player.rigidbody = data1.player.rigidbody
+    if(data1.player.hasOwnProperty("damageInfo"))
+        player.damageInfo = player.damageInfo.concat(data1.player.damageInfo)
 }

Level/_projectile.ts

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

Level/_update.ts

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

Level/levelSocket.ts

@@ -1,11 +1,26 @@
+import { clear } from "./_clear";
+import { enter } from "./_enter";
+import { playerUpdate } from "./_playerUpdate";
 import { projectile } from "./_projectile";
 import { update } from "./_update";
 
 export function registerLevelCallbacks(socket){
+    socket.on('level/enter', (data) => {
+        enter(socket, data)
+    });
+
+    socket.on('level/cleared', (data) => {
+        clear(socket, data)
+    });
+
     socket.on('level/update', (data) => {
         update(socket, data)
     });
 
+    socket.on('level/playerUpdate', (data) => {
+        playerUpdate(socket, data)
+    });
+
     socket.on('level/projectile', (data) => {
         projectile(socket, data)
     });

Lobby/_enter.ts

@@ -1,24 +0,0 @@
-import { roomChangeData as roomChangeRequest } from "../Classes/roomChangeRequest";
-import { roomChangeResponse } from "../Classes/roomChangeResponse";
-import { game } from "../game";
-
-export function enter(socket, data){
-    if(!socket.hasOwnProperty("player")) return;
-
-    let buff = Buffer.from(data, 'base64');
-    let data1 : roomChangeRequest = JSON.parse(buff.toString('utf-8'));
-
-    socket.join(data1.targetRoom.id)
-    let newRoom = game.lobbyState.roomEnter(data1.targetRoom, socket.player)
-    socket.player.room = newRoom.id
-
-    socket.leave(data1.previousRoom)
-    let oldRoom = game.lobbyState.roomExit(data1.previousRoom, socket.player)
-    
-    let data2 = new roomChangeResponse()
-    data2.player = socket.player.copyLight()
-    data2.newRoom = newRoom.copyLight()
-    data2.previousRoom = oldRoom.copyLight()
-
-    game.socketIO.emit("lobby/entered", JSON.stringify(data2))
-}

Lobby/_loadoutChanged.ts

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

Lobby/_playerJoin.ts

@@ -1,3 +1,4 @@
+import { lobbyJoin } from "../Classes/Incoming/lobbyJoin";
 import { levelState } from "../Classes/levelState";
 import { lobbyMessage } from "../Classes/lobbyMessage";
 import { playerData } from "../Classes/playerData";
@@ -5,32 +6,36 @@ import { userData } from "../Classes/userData";
 import { game } from "../game";
 
 export function playerJoin(socket, data){
-    if(!socket.hasOwnProperty("user")) return;
+    if(!socket.hasOwnProperty("player")) return;
 
     let buff = Buffer.from(data, 'base64');
-    let data1 : playerData = JSON.parse(buff.toString('utf-8'));
+    let data1 : lobbyJoin = JSON.parse(buff.toString('utf-8'));
+    let player : playerData = socket.player
 
-    socket.player.characterId = data1.characterId
-    game.lobbyState.addUser(socket.user, socket.player)
-
-    let newUser = {users:[userData.makeSafe(socket.user)], players:[socket.player], rooms:[]};
-    let existingUsers = {users:game.lobbyState.users.map(u=> userData.makeSafe(u)), players:[], rooms:[]}
-    
-    game.lobbyState.players.forEach(player=>{
-        if(player.id == socket.player.id){
-            existingUsers.players.push(player)
-        }
-        else{
-            let newPlayer = Object.assign({}, player);
-            delete(newPlayer.inventory)
-            existingUsers.players.push(newPlayer)
-        }
-    })
-
-    let room = game.lobbyState.roomEnter(new levelState("0_0", -1), socket.player)
-    existingUsers.rooms = game.lobbyState.rooms
+    player.room = "0_0"
+    player.characterId = data1.player.characterId
+    game.lobbyState.addUser(socket.user, player)
+    let spawnRoom = game.lobbyState.roomEnter(new levelState("0_0", -1), player)
     socket.join("0_0")
 
+    let newUser = {
+        users:[userData.makeSafe(socket.user)],
+        players:[player.copyStart()],
+        rooms:[]
+    };
+    let existingUsers = {
+        users:game.lobbyState.users.map(u=> userData.makeSafe(u)),
+        players:game.lobbyState.players.map(p=>p.copyStart()),
+        rooms:[]
+    }
+
+    game.lobbyState.rooms.forEach(room=>{
+        if(room == spawnRoom)
+            existingUsers.rooms.push(spawnRoom.copyStart())
+        else
+            existingUsers.rooms.push(room.copyState())
+    })
+
     //send only player to all existing players
     socket.broadcast.emit("lobby/playerJoin", JSON.stringify(newUser));
 

Lobby/lobbySocket.ts

@@ -1,27 +1,12 @@
-import { clearRoom } from "./_clearRoom";
-import { enter } from "./_enter";
 import { loadoutChanged } from "./_loadoutChanged";
 import { message } from "./_message";
 import { playerJoin } from "./_playerJoin";
-import { playerUpdate } from "./_playerUpdate";
 
 export function registerLobbyCallbacks(socket){
-    socket.on('lobby/enter', (data) => {
-        enter(socket, data)
-    });
-
-    socket.on('lobby/cleared', (data) => {
-        clearRoom(socket, data)
-    });
-
     socket.on('lobby/playerJoin', (data) => {
         playerJoin(socket, data)
     });
 
-    socket.on('lobby/playerUpdate', (data) => {
-        playerUpdate(socket, data)
-    });
-
     socket.on('lobby/loadoutChanged', (data) => {
         loadoutChanged(socket, data)
     });

index.ts

@@ -59,9 +59,8 @@ setInterval(async () => {
     let userCount = game.lobbyState.players.length
     if(userCount > 0){
         game.lobbyState.rooms.forEach(room=>{
-            let roomData = room.copyLight()
-
-            io.in(room.id).emit('lobby/update', JSON.stringify(roomData))
+            let roomData = room.copyUpdate()
+            io.in(room.id).emit('level/update', JSON.stringify(roomData))
         })
         game.playersDB.forEach(p=>{
             p.damageInfo = []
@@ -71,6 +70,7 @@ setInterval(async () => {
 
 setInterval(() => {
     let lobbyState = game.lobbyState
+    console.clear()
     console.log("Players:")
     for(let i = 0; i < lobbyState.players.length; i++){
         console.log(lobbyState.players[i].id + " " + lobbyState.players[i].room)
@@ -78,12 +78,15 @@ setInterval(() => {
     console.log("Rooms:")
     for(let i = 0; i < lobbyState.rooms.length; i++){
         console.log(lobbyState.rooms[i].id + " " + lobbyState.rooms[i].hostId)
+        lobbyState.rooms[i].objects.forEach(object => {
+            console.log("\t" + object.name + ": " + JSON.stringify(object.rigidbody))
+        });
     }
     console.log("Dungeon:")
     for(let i = 0; i < lobbyState.dungeons.length; i++){
         console.log(lobbyState.dungeons[i].entranceId + " " + lobbyState.dungeons[i].playerCount)
     }
-}, 60 * 1000)
+}, 1000)
 
 process.on('SIGINT', function () {
     console.log('Ctrl-C...');