further refactor

Classes/Incoming/levelUpdateClient.ts

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

Classes/Incoming/levelUpdateHost.ts

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

Classes/Incoming/lobbyJoin.ts

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

Classes/Outgoing/accountResponses.ts

@@ -0,0 +1,20 @@
+import { characterData } from "../characterData.js";
+import { userData } from "../userData.js";
+
+export class loginResponse{
+    result : boolean
+    userData : userData
+    playerData : characterData
+
+    constructor(user : userData, player : characterData){
+        if (!user || !player){
+            this.result = false;
+            this.userData = this.playerData = null;
+        }
+        else{
+            this.result = true;
+            this.userData = user.makeSafe();
+            this.playerData = player;
+        }
+    }
+}

Classes/Outgoing/characterDataPartial.ts

@@ -0,0 +1,40 @@
+import { characterData } from "../characterData.js"
+import { enemyDamageInfo } from "../enemyDamageInfo.js"
+import { physicsObject } from "../physicsObject.js"
+import { playerInventory } from "../playerInventory.js"
+
+export class characterDataStart{
+    id : number
+    characterId : number
+    rigidbody : physicsObject = new physicsObject()
+
+    constructor(data : characterData){
+        this.id = data.id
+        this.characterId = data.characterId
+        this.rigidbody = physicsObject.characterOnly(data.rigidbody)
+    }
+}
+
+export class characterDataUpdate{
+    id : number
+    rigidbody : physicsObject = new physicsObject()
+    damageInfo : enemyDamageInfo[] = []
+
+    constructor(data : characterData){
+        this.id = data.id
+        this.rigidbody = physicsObject.characterOnly(data.rigidbody)
+        if(data.damageInfo.length > 0){
+            this.damageInfo = data.damageInfo
+        }
+    }
+}
+
+export class characterDataInventory{
+    id : number
+    inventory : playerInventory = new playerInventory()
+
+    constructor(data : characterData){
+        this.id = data.id
+        this.inventory = data.inventory
+    }
+}

Classes/Outgoing/enemyDataPartial.ts

@@ -0,0 +1,17 @@
+import { enemyData } from "../enemyData.js";
+import { Stat } from "../itemData.js";
+import { physicsObject } from "../physicsObject.js";
+
+export class enemyDataUpdate{
+    id          : number
+    templateId  : number
+    rigidbody   : physicsObject
+    stats       : Stat[] = []
+
+    constructor(data : enemyData){
+        this.id = data.id
+        this.templateId = data.templateId
+        this.rigidbody = physicsObject.characterOnly(data.rigidbody)
+        this.stats = data.stats
+    }
+}

Classes/Outgoing/levelStatePartial.ts

@@ -0,0 +1,63 @@
+import { enemyData } from "../enemyData.js"
+import { levelState } from "../levelState.js"
+import { propData } from "../propData.js"
+import { characterDataStart, characterDataUpdate } from "./characterDataPartial.js"
+import { enemyDataUpdate } from "./enemyDataPartial.js"
+import { propDataStart, propDataUpdate } from "./propDataPartial.js"
+
+export class levelStateStart{
+    id : string
+    seed : number = -1
+    hostId : number = -1
+    completed : boolean = false
+    isDungeon : boolean = false
+    enemies : enemyDataUpdate[] = []
+    objects : propDataStart[] = []
+    players : characterDataStart[] = []
+
+    constructor(data : levelState){
+        this.id = data.id
+        this.seed = data.seed
+        this.hostId = data.hostId
+        this.completed = data.completed
+        this.isDungeon = data.isDungeon
+        this.enemies = data.enemies.map(e => e.copyStart())
+        this.objects = data.objects.map(e => e.copyStart())
+        this.players = data.players.map(pl=> pl.copyStart())
+    }
+}
+
+export class levelStateUpdate{
+    id : string
+    seed : number = -1
+    hostId : number = -1
+    completed : boolean = false
+    isDungeon : boolean = false
+    enemies : enemyDataUpdate[] = []
+    objects : propDataUpdate[] = []
+    players : characterDataUpdate[] = []
+
+    constructor(data : levelState){
+        this.id = data.id
+        this.seed = data.seed
+        this.hostId = data.hostId
+        this.completed = data.completed
+        this.enemies = data.enemies.map(e => e.copyUpdate())
+        this.objects = data.objects.map(e => e.copyUpdate())
+        this.players = data.players.map(pl=> pl.copyUpdate())
+    }
+}
+
+export class levelStateState{
+    id : string
+    seed : number = -1
+    hostId : number = -1
+    completed : boolean = false
+
+    constructor(data : levelState){
+        this.id = data.id
+        this.seed = data.seed
+        this.hostId = data.hostId
+        this.completed = data.completed
+    }
+}

Classes/Outgoing/lobbyStatePartial.ts

@@ -0,0 +1,16 @@
+import { dungeonData } from "../dungeonData.js";
+import { levelState } from "../levelState.js";
+import { lobbyState } from "../lobbyState.js";
+import { characterDataUpdate } from "./characterDataPartial.js";
+
+export class lobbyStateLight{
+    activeUsers : characterDataUpdate[] = []
+    rooms       : levelState[] = []
+    dungeons    : dungeonData[] = []
+
+    constructor(data : lobbyState){
+        this.activeUsers = data.activeUsers.map(u=>u.character.copyUpdate())
+        this.rooms = data.rooms
+        this.dungeons = data.dungeons
+    }
+}

Classes/Outgoing/propDataPartial.ts

@@ -0,0 +1,28 @@
+import { physicsObject } from "../physicsObject.js"
+import { propData } from "../propData.js"
+
+export class propDataStart{
+    id         : number
+    templateId : number
+    rigidbody  : physicsObject
+    components : any
+
+    constructor(data : propData) {
+        this.id = data.id
+        this.templateId = data.templateId
+        this.rigidbody = physicsObject.copyStart(data.rigidbody)
+        this.components = data.components
+    }
+}
+
+export class propDataUpdate{
+    id         : number
+    rigidbody  : physicsObject
+    components : any
+
+    constructor(data : propData) {
+        this.id = data.id
+        this.rigidbody = physicsObject.copyUpdate(data.rigidbody)
+        this.components = data.components
+    }
+}

Classes/Outgoing/roomChangeResponse.ts

@@ -0,0 +1,8 @@
+import { characterDataUpdate } from "./characterDataPartial.js"
+import { levelStateStart, levelStateState } from "./levelStatePartial.js"
+
+export class roomChangeResponse{
+    player : characterDataUpdate
+    newRoom : levelStateStart
+    previousRoom : levelStateState
+}

Classes/Outgoing/userDataPartial.ts

@@ -0,0 +1,10 @@
+import { userData } from "../userData.js";
+
+export class userDataSafe{
+    id: number;
+    login: string;
+
+    constructor(data : userData){
+        Object.assign(this, data);
+    }
+}

Classes/characterData.ts

@@ -1,9 +1,10 @@
 import { enemyDamageInfo } from "./enemyDamageInfo.js";
+import { characterDataInventory, characterDataStart, characterDataUpdate } from "./Outgoing/characterDataPartial.js";
 import { physicsObject } from "./physicsObject.js";
 import { playerInventory } from "./playerInventory.js";
 import { questBook } from "./questBook.js";
 
-export class playerData{
+export class characterData{
     id : number
     level : number = 1
     room : string = "0_0"
@@ -13,50 +14,36 @@ export class playerData{
     questBook : questBook = new questBook()
     damageInfo : enemyDamageInfo[] = []
 
-    constructor(init?: Partial<playerData>) {
+    constructor(init?: Partial<characterData>) {
         Object.assign(this, init);
         this.questBook = new questBook(this.questBook)
-     }
+        this.inventory = new playerInventory(this.inventory)
+    }
 
     copyStart(){
-        let player : any = {}
-        player.id = this.id
-        player.characterId = this.characterId
-        player.rigidbody = physicsObject.characterOnly(this.rigidbody)
-        return player
+        return new characterDataStart(this)
     }
 
     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
+        return new characterDataUpdate(this)
     }
 
     copyInventory(){
-        let player : any = {}
-        player.id = this.id
-        player.inventory = this.inventory
-        return player
+        return new characterDataInventory(this)
     }
     
     getItemById(id : number){
         let item = this.inventory.items.find(i=>i.id == id)
         return item
     }
-    
+
+    resetDamageInfo(){
+        this.damageInfo = []
+    }
+
     validateEquipment(){
         if(this.inventory.equipment.length < 3){
             this.inventory.equipment = [-1, -1, -1]
         }
     }
-
-    save(fs){
-        let data = JSON.stringify(this, null, 2);
-        fs.writeFileSync(`Database/Players/${this.id}.json`, data);
-    }
 }

Classes/enemyData.ts

@@ -1,4 +1,5 @@
 import { Stat } from "./itemData.js"
+import { enemyDataUpdate } from "./Outgoing/enemyDataPartial.js"
 import { physicsObject } from "./physicsObject.js"
 
 export class enemyData{
@@ -7,21 +8,15 @@ export class enemyData{
     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
+    constructor(init?: Partial<enemyData>){
+        Object.assign(this, init);
+    }
+
+    copyStart() {
+        return new enemyDataUpdate(this)
     }
     
-    static copyUpdate(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
+    copyUpdate() {
+        return new enemyDataUpdate(this)
     }
 }

Classes/levelState.ts

@@ -1,6 +1,7 @@
 import { enemyData } from "./enemyData.js";
-import { playerData } from "./playerData.js";
+import { characterData } from "./characterData.js";
 import { propData } from "./propData.js";
+import { levelStateStart, levelStateState as levelStateInfo, levelStateUpdate } from "./Outgoing/levelStatePartial.js";
 
 export class levelState{
     id : string
@@ -10,7 +11,7 @@ export class levelState{
     isDungeon : boolean = false
     enemies : enemyData[] = []
     objects : propData[] = []
-    players : playerData[] = []
+    players : characterData[] = []
 
     getRandomInt(max) {
         return Math.floor(Math.random() * max);
@@ -24,37 +25,15 @@ export class levelState{
     }
 
     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
+        return new levelStateStart(this)
     }
 
     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
+        return new levelStateUpdate(this)
     }
 
     copyState(){
-        let level : any = {}
-        level.id = this.id
-        level.seed = this.seed
-        level.hostId = this.hostId
-        level.completed = this.completed
-        return level
+        return new levelStateInfo(this)
     }
 
     isHostValid(){
@@ -67,7 +46,7 @@ export class levelState{
         return true
     }
 
-    addPlayer(player : playerData) : boolean{
+    addPlayer(player : characterData) : boolean{
         let playerIdx = this.players.findIndex(p=>p.id==player.id)
         if(playerIdx != -1) return false
 
@@ -80,13 +59,10 @@ export class levelState{
         return true
     }
 
-    removePlayer(id) : boolean{
-        let playerIdx = this.players.findIndex(p=>p.id==id)
-        if(playerIdx == -1) return false
-
-        this.players.splice(playerIdx,1)
+    removePlayer(player : characterData) : boolean{
+        this.players = this.players.filter(p=> p !== player)
         
-        if(this.hostId == id){
+        if(this.hostId == player.id){
             if(this.players.length > 0){
                 this.hostId = this.players[0].id
             }

Classes/lobbyState.ts

@@ -1,55 +1,32 @@
-import { playerData } from "../Classes/playerData.js";
+import { Socket } from "socket.io";
+import { characterData } from "./characterData.js";
 import { dungeonData } from "./dungeonData.js";
 import { levelState } from "./levelState.js";
-import { userData } from "./userData.js";
+import { lobbyStateLight } from "./Outgoing/lobbyStatePartial.js";
 
 export class lobbyState{
-    users : userData[] = [];
-    players : playerData[] = [];
+    activeUsers : Socket[] = []
     rooms : levelState[] = []
     dungeons : dungeonData[] = []
 
     copyLight(){
-        let lobby = Object.assign({}, this);
-        lobby.players = []
-        lobby.users = []
-        for (let i = 0; i < this.players.length; i++) {
-            lobby.players.push(this.players[i].copyUpdate());
-        }
-        lobby.rooms = this.rooms
-        lobby.dungeons = this.dungeons
-        return lobby
+        return new lobbyStateLight(this)
     }
 
-    addUser(userData, playerData){
-        let uIdx = this.users.findIndex(u=>u.id == userData.id)
-        let pIdx = this.players.findIndex(u=>u.id == playerData.id)
-        if(uIdx != -1 || pIdx != -1){
-            console.log("User " + userData.login + " is already in the game!")
+    addUser(socket : Socket){
+        let uIdx = this.activeUsers.findIndex(u=>u === socket)
+        if(uIdx != -1){
+            console.log("User " + socket.user.login + " is already in the game!")
             return false;
         }
         
-        this.users.push(userData)
-        this.players.push(playerData)
+        this.activeUsers.push(socket)
         return true
     }
 
-    removeUser(id){
-        let idx = this.users.findIndex(u=>u.id == id)
-        if(idx != -1){
-            this.users.splice(idx, 1)
-        }
-
-        idx = this.players.findIndex(u=>u.id == id)
-        if(idx != -1){
-            let player = this.players[idx]
-            this.players.splice(idx, 1)
-            this.roomExit(player.room, player)
-        }
-    }
-
-    findPlayer(id: number){
-        return this.players.find(p=>p.id == id)
+    removeUser(socket : Socket){
+        this.roomExit(socket.character.room, socket.character)
+        this.activeUsers = this.activeUsers.filter(u=>u !== socket)
     }
 
     getDungeonRoot(name){
@@ -75,13 +52,17 @@ export class lobbyState{
         return room
     }
 
+    removeRoom(room : levelState){
+        this.rooms = this.rooms.filter(r => r !== room)
+    }
+
     createRoom(id : string, host : number){
         let room = new levelState(id, host)
         this.rooms.push(room)
         return room
     }
 
-    roomEnter(targetRoom : levelState, player: playerData){
+    roomEnter(targetRoom : levelState, player: characterData){
         if(!targetRoom.isDungeon){
             let room = this.getRoom(targetRoom.id, true)
 
@@ -112,19 +93,17 @@ export class lobbyState{
         return null
     }
 
-    roomExit(roomId : string, player: playerData){
+    roomExit(roomId : string, player: characterData){
         let room = this.getRoom(roomId, false)
         if(room != null){
-            
-            if(room.removePlayer(player.id)){
+            if(room.removePlayer(player)){
                 if(room.isDungeon){
                     let dungeon = this.getDungeon(this.getDungeonRoot(roomId), false)
                     dungeon.playerCount -= 1;
                     this.tryRemoveDungeon(room.id)
                 }
                 else if(room.hostId == -1){
-                    let roomIdx = this.rooms.indexOf(room)
-                    this.rooms.splice(roomIdx, 1)
+                    this.removeRoom(room)
                 }
             }
 
@@ -143,8 +122,7 @@ export class lobbyState{
         if(dungeon.playerCount == 0){
             this.dungeons.splice(dungeonIdx, 1)
             dungeon.rooms.forEach(room=>{
-                let roomIdx = this.rooms.findIndex(r=>r.id == room.id)
-                this.rooms.splice(roomIdx, 1)
+                this.removeRoom(room)
             })
         }
         

Classes/loginResponse.ts

@@ -1,16 +0,0 @@
-import { playerData } from "./playerData.js"
-import { userData } from "./userData.js"
-
-export class loginResponse{
-    result : boolean
-    userData : userData
-    playerData : playerData
-
-    constructor(result : boolean, user : userData, player : playerData){
-        this.result = result;
-        if(result){
-            this.userData = userData.makeSafe(user);
-            this.playerData = player;
-        }
-    }
-}

Classes/playerInventory.ts

@@ -4,4 +4,8 @@ export class playerInventory{
     weapon : number = -1
     equipment : number[] = [-1,-1,-1]
     items : itemData[] = []
+
+    constructor(init?: Partial<playerInventory>) {
+        Object.assign(this, init);
+     }
 }

Classes/propData.ts

@@ -1,3 +1,4 @@
+import { propDataStart, propDataUpdate } from "./Outgoing/propDataPartial.js"
 import { physicsObject } from "./physicsObject.js"
 
 export class propData{
@@ -6,21 +7,11 @@ export class propData{
     rigidbody  : physicsObject
     components : any
 
-    static copyPropStart(o: propData) {
-        let pObject = Object.assign({}, o)
-        pObject.rigidbody = physicsObject.copyStart(o.rigidbody)
-        return pObject
+    copyStart() {
+        return new propDataStart(this)
     }
 
-    static copyPropUpdate(o: propData) {
-        let pObject : any = {}
-        pObject.id = o.id
-        if(!physicsObject.isKinematic(o.rigidbody)){
-            pObject.rigidbody = physicsObject.copyUpdate(o.rigidbody)
-        }
-        if(o.components != null){
-            pObject.components = o.components
-        }
-        return pObject
+    copyUpdate() {
+        return new propDataUpdate(this)
     }
 }

Classes/roomChangeResponse.ts

@@ -1,8 +0,0 @@
-import { levelState } from "./levelState.js"
-import { playerData } from "./playerData.js"
-
-export class roomChangeResponse{
-    player : playerData
-    newRoom : levelState
-    previousRoom : levelState
-}

Classes/userData.ts

@@ -4,22 +4,14 @@ export class userData{
     login: string;
     password: string;
 
-    constructor(id:number, login:string, password:string){
-        this.id = id;
-        this.login = login;
-        this.password = password;
-        this.checksum = 0;
+    constructor(init?: Partial<userData>){
+        Object.assign(this, init);
     }
 
-    static makeSafe(user : userData){
-        let safeUser : any = Object.assign({}, user);
+    makeSafe() : userData{
+        let safeUser : userData = Object.assign({}, this);
         delete safeUser.password
         delete safeUser.checksum
         return safeUser
     }
-    
-    save(fs){
-        let data = JSON.stringify(this, null, 2);
-        fs.writeFileSync(`Database/Users/${this.id}_${this.login}.json`, data);
-    }
 }