fixed removing users from session

.gitignore

@@ -42,3 +42,4 @@ dist/**/*
 
 # ignore yarn.lock
 yarn.lock
+Database/mydb.sqlite3

Account/_emitLogin.ts

@@ -1,21 +0,0 @@
-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

@@ -1,21 +1,34 @@
-import { userData } from "../Classes/userData";
+import { userData } from "../Classes/userData.js";
-import { players } from "../Player/players";
+import { characters } from "../Characters/characters.js";
-import { emitLogin } from "./_emitLogin";
+import { userCheckResult, users } from "./users.js";
-import { users } from "./users";
+import { db } from "../index.js"
+import { Socket } from "socket.io";
+import { loginResponse, loginResult } from "../Classes/Outgoing/accountResponses.js";
+import { Endpoints } from "../endpoints.js";
 
-export function login(socket, data){
+export async function login(socket : Socket, data){
     let buff = Buffer.from(data, 'base64');
-        let json : userData = JSON.parse(buff.toString('utf-8'));
+    let json : userData = JSON.parse(buff.toString('utf-8'));
-        if (!json.login || !json.password) return
+    if (!json.login || !json.password){
+        console.log("login or password is missing")
+        return
+    }
 
-        let result = users.readUser(json.login, json.password);
+    const userCheck = await users.readUser(db, 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);
+    if(userCheck.result == userCheckResult.OK){
+        const user = userCheck.userData;
+        console.log(`User ${user.login} logged in`);
+        const character = await characters.readCharacter(db, user.id);
+        const result = new loginResponse(loginResult.success, user, character)
+
+        socket.user = user
+        socket.character = character
+        socket.emit(Endpoints.Login, JSON.stringify(result));
+    }
+    else{
+        console.log(`User ${json.login} did not log in`);
+        const result = new loginResponse(loginResult.fail, null, null)
+        socket.emit(Endpoints.Login, JSON.stringify(result));
+    }
 }

Account/_register.ts

@@ -1,18 +1,39 @@
-import { userData } from "../Classes/userData";
+import { userData } from "../Classes/userData.js";
-import { players } from "../Player/players";
+import { userCheckResult, users } from "./users.js";
-import { emitLogin } from "./_emitLogin";
+import { db } from "../index.js"
-import { users } from "./users";
+import { Socket } from "socket.io";
+import { loginResponse, loginResult } from "../Classes/Outgoing/accountResponses.js";
+import { Endpoints } from "../endpoints.js";
+import { characters } from "../Characters/characters.js";
 
-export function register(socket, data){
+export async function register(socket : Socket, data){
     let buff = Buffer.from(data, 'base64');
-        let json : userData = JSON.parse(buff.toString('utf-8'));
+    let json : userData = JSON.parse(buff.toString('utf-8'));
-        if (!json.login || !json.password) return
+    if (!json.login || !json.password){
+        console.log("login or password is missing")
+        return
+    }
 
-        let result = users.createUser(json.login, json.password);
+    const checkExisting = await users.readUser(db, json.login, null)
-        let player = null
+    if(checkExisting.result != userCheckResult.NotExist){
-        if(result != null){
+        const result = new loginResponse(loginResult.accountExists, null, null)
-            player = players.createPlayer(result.id)
+        socket.emit(Endpoints.Register, JSON.stringify(result))
-        }
+        return
+    }
 
-        emitLogin(socket, result, player);
+    const user = (await users.createUser(db, json.login, json.password)).userData;
+
+    if(user){
+        console.log(`User ${user.login} registered`);
+        const character = await characters.createCharacter(db, user.id);
+        const result = new loginResponse(loginResult.success, user, character)
+        socket.user = user
+        socket.character = character
+        socket.emit(Endpoints.Register, JSON.stringify(result))
+    }
+    else{
+        console.log(`User failed to register`);
+        const result = new loginResponse(loginResult.fail, null, null)
+        socket.emit(Endpoints.Register, JSON.stringify(result))
+    }
 }

Account/accountSocket.ts

@@ -1,12 +1,13 @@
-import { register } from "./_register";
+import { register } from "./_register.js";
-import { login } from "./_login";
+import { login } from "./_login.js";
+import { Endpoints } from "../endpoints.js";
 
 export function registerAccountCallbacks(socket){
-    socket.on('account/register', (data) => {
+    socket.on(Endpoints.Register, (data) => {
         register(socket, data)
     });
 
-    socket.on('account/login', (data) => {
+    socket.on(Endpoints.Login, (data) => {
         login(socket, data)
     });
 }

Account/users.ts

@@ -1,56 +1,45 @@
-import { game } from "../game";
+import { userData } from "../Classes/userData.js";
-import { userData } from "../Classes/userData";
+import { DatabaseController, dbUser } from "../Database/dbcontroller.js";
 
-export class users{
+export class userCheckResponse{
-    static createUser(login, password){
+    result : userCheckResult
-        if (game.accountsDB.find(u=>u.login == login) != null){
+    userData : userData
-            console.log(`User ${login} alread exists`);
-            return null;
-        }
 
-        var user = new userData(game.accountsDB.length, login, password);
+    constructor(result : userCheckResult, userData : userData){
-        game.accountsDB.push(user);
+        this.result = result;
-        return user;
+        this.userData = userData;
-    }
+    }
-    
+}
-    static readUser(login, password){
+
-        let user = game.accountsDB.find(u=>u.login == login && u.password == password)
+export enum userCheckResult{
-        if(user != null){
+    OK,
-            return user;
+    IncorrectPassword,
-        }
+    NotExist
-        return null;
+}
-    }
+
-
+export class users{
-    static readUserID(id : number){
+
-        let user = game.accountsDB.filter(u=>u.id == id)[0];
+    static async createUser(db: DatabaseController, login : string, password : string){
-        return user;
+        await db.run('INSERT INTO users (login, password) VALUES (?, ?)', [login, password]);
-    }
+        return await this.readUser(db, login, password)
-
+    }
-    static updateUser(userNew : userData){
+
-        let user = this.readUserID(userNew.id);
+    static async readUser(db: DatabaseController, login : string, password : string): Promise<userCheckResponse>{
-        let sum = Math.floor(Math.random() * 99999);
+        let user = await db.select<dbUser>(`SELECT * FROM users WHERE login = ? LIMIT 1`, [login])
-        while(sum == userNew.checksum){
+        if (user.length > 0){
-            sum = Math.floor(Math.random() * 99999);
+            let row = user[0]
-        }
+            if (row.password != password){
-        userNew.checksum = sum;
+                return new userCheckResponse(userCheckResult.IncorrectPassword, null)
-        game.accountsDB[game.accountsDB.indexOf(user)] = userNew;
+            }
-    }
+            return new userCheckResponse(userCheckResult.OK, new userData({...row}))
-
+        }
-    static saveUsers(fs){
+        else{
-        game.accountsDB.forEach(user => {user.save(fs)});
+            return new userCheckResponse(userCheckResult.NotExist, null)
-    }
+        }
-    
+    }
-    static loadUsers(fs){
+
-        fs.mkdirSync(`Database/Users/`, { recursive: true })
+    static async readUserID(db: DatabaseController, id : number){
-        fs.readdir(`Database/Users/`, (err, files) => {
+        let user = await db.select<dbUser>(`SELECT * FROM users WHERE id = ?`, [id])
-            files.forEach(file => {
+        return user;
-                fs.readFile(`Database/Users/${file}`, (err, data) => {
-                    if (err) throw err;
-                    let user : userData = Object.assign(new userData(-1,"",""), JSON.parse(data));
-                    game.accountsDB.push(user);
-                    console.log(`Loaded ${user.login}`);
-                });
-            });
-        });
     }
 }

Characters/characters.ts

@@ -0,0 +1,29 @@
+import { characterData } from "../Classes/characterData.js";
+import { DatabaseController, dbCharacter } from "../Database/dbcontroller.js";
+
+export class characters{
+    static async createCharacter(db: DatabaseController, userId : number){
+        await db.run('INSERT INTO characters (user_id) VALUES (?)', [userId]);
+        return await this.readCharacter(db, userId)
+    }
+
+    static async readCharacter(db: DatabaseController, userId : number): Promise<characterData>{
+        let player = await db.select<dbCharacter>(`SELECT * FROM characters WHERE user_id = ? LIMIT 1`, [userId])
+        if (player.length > 0){
+            let row = player[0]
+            return new characterData({
+                ...row,
+                inventory: row.inventory ? JSON.parse(row.inventory) : undefined,
+                questBook: row.questBook ? JSON.parse(row.questBook) : undefined,
+            })
+        }
+        else{
+            return null
+        }
+    }
+    
+    static async savePlayer(db: DatabaseController, data: characterData){
+        await db.run(`UPDATE characters SET inventory = ?, questBook = ? WHERE id = ?`, 
+            [JSON.stringify(data.inventory), JSON.stringify(data.questBook), data.id])
+    }
+}

Classes/Incoming/inventoryChange.ts

@@ -1,4 +1,4 @@
-import { itemData } from "../itemData"
+import { itemData } from "../itemData.js"
 
 export class inventoryChange{
     operation : number

Classes/Incoming/levelEnter.ts

@@ -1,4 +1,4 @@
-import { levelState } from "../levelState"
+import { levelState } from "../levelState.js"
 
 export class levelEnter{
     previousRoom : levelState

Classes/Incoming/levelUpdateClient.ts

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

Classes/Incoming/levelUpdateHost.ts

@@ -1,7 +1,10 @@
-import { levelState } from "../levelState";
+import { levelState } from "../levelState.js";
-import { playerData } from "../playerData";
+import { characterData } from "../characterData.js";
+import { Type } from "class-transformer";
 
 export class levelUpdateHost{
-    player : playerData
+    @Type(() => characterData)
+    player : characterData
+    @Type(() => levelState)
     room : levelState
 }

Classes/Incoming/lobbyJoin.ts

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

Classes/Outgoing/accountResponses.ts

@@ -0,0 +1,26 @@
+import { characterData } from "../characterData.js";
+import { userData } from "../userData.js";
+
+export enum loginResult{
+    success,
+    fail,
+    accountExists
+}
+
+export class loginResponse{
+    result : loginResult
+    userData : userData
+    playerData : characterData
+
+    constructor(result: loginResult, user : userData, player : characterData){
+        if (!user || !player){
+            this.result = result;
+            this.userData = this.playerData = null;
+        }
+        else{
+            this.result = result;
+            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

@@ -0,0 +1,49 @@
+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 characterData{
+    id : number
+    level : number = 1
+    room : string = "0_0"
+    characterId : number
+    inventory : playerInventory = new playerInventory()
+    rigidbody : physicsObject = new physicsObject()
+    questBook : questBook = new questBook()
+    damageInfo : enemyDamageInfo[] = []
+
+    constructor(init?: Partial<characterData>) {
+        Object.assign(this, init);
+        this.questBook = new questBook(this.questBook)
+        this.inventory = new playerInventory(this.inventory)
+    }
+
+    copyStart(){
+        return new characterDataStart(this)
+    }
+
+    copyUpdate(){
+        return new characterDataUpdate(this)
+    }
+
+    copyInventory(){
+        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]
+        }
+    }
+}

Classes/dungeonData.ts

@@ -1,5 +1,5 @@
-import { game } from "../game"
+import { game } from "../game.js"
-import { levelState } from "./levelState"
+import { levelState } from "./levelState.js"
 
 export class dungeonData{
     entranceId : string

Classes/enemyData.ts

@@ -1,5 +1,6 @@
-import { Stat } from "./itemData"
+import { Stat } from "./itemData.js"
-import { physicsObject } from "./physicsObject"
+import { enemyDataUpdate } from "./Outgoing/enemyDataPartial.js"
+import { physicsObject } from "./physicsObject.js"
 
 export class enemyData{
     id          : number
@@ -7,21 +8,15 @@ export class enemyData{
     rigidbody   : physicsObject
     stats       : Stat[] = []
 
-    static copyStart(e: enemyData): any {
+    constructor(init?: Partial<enemyData>){
-        let enemy : any = {}
+        Object.assign(this, init);
-        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 {
+    copyStart() {
-        let enemy : any = {}
+        return new enemyDataUpdate(this)
-        enemy.id = e.id
+    }
-        enemy.templateId = e.templateId
+    
-        enemy.rigidbody = physicsObject.characterOnly(e.rigidbody)
+    copyUpdate() {
-        enemy.stats = e.stats
+        return new enemyDataUpdate(this)
-        return enemy
     }
 }

Classes/itemData.ts

@@ -1,5 +1,5 @@
-import { game } from "../game"
+import { game } from "../game.js"
-import { inventoryChange } from "./Incoming/inventoryChange"
+import { inventoryChange } from "./Incoming/inventoryChange.js"
 
 export class itemData{
     name        : string

Classes/itemGenerated.ts

@@ -1,4 +1,4 @@
-import { itemData } from "./itemData"
+import { itemData } from "./itemData.js"
 
 export class itemGenerated{
     instanceId: number

Classes/itemPickup.ts

@@ -1,4 +1,4 @@
-import { itemData } from "./itemData"
+import { itemData } from "./itemData.js"
 
 export class itemPickup{
     instanceId: number

Classes/levelState.ts

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

Classes/lobbyState.ts

@@ -1,55 +1,32 @@
-import { playerData } from "../Classes/playerData";
+import { Socket } from "socket.io";
-import { dungeonData } from "./dungeonData";
+import { characterData } from "./characterData.js";
-import { levelState } from "./levelState";
+import { dungeonData } from "./dungeonData.js";
-import { userData } from "./userData";
+import { levelState } from "./levelState.js";
+import { lobbyStateLight } from "./Outgoing/lobbyStatePartial.js";
 
 export class lobbyState{
-    users : userData[] = [];
+    activeUsers : Socket[] = []
-    players : playerData[] = [];
     rooms : levelState[] = []
     dungeons : dungeonData[] = []
 
     copyLight(){
-        let lobby = Object.assign({}, this);
+        return new lobbyStateLight(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
     }
 
-    addUser(userData, playerData){
+    addUser(socket : Socket){
-        let uIdx = this.users.findIndex(u=>u.id == userData.id)
+        let uIdx = this.activeUsers.findIndex(u=>u === socket)
-        let pIdx = this.players.findIndex(u=>u.id == playerData.id)
+        if(uIdx != -1){
-        if(uIdx != -1 || pIdx != -1){
+            console.log("User " + socket.user.login + " is already in the game!")
-            console.log("User " + userData.login + " is already in the game!")
             return false;
         }
         
-        this.users.push(userData)
+        this.activeUsers.push(socket)
-        this.players.push(playerData)
         return true
     }
 
-    removeUser(id){
+    removeUser(socket : Socket){
-        let idx = this.users.findIndex(u=>u.id == id)
+        this.roomExit(socket.character.room, socket.character)
-        if(idx != -1){
+        this.activeUsers = this.activeUsers.filter(u=>u !== socket)
-            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)
     }
 
     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)){
-            if(room.removePlayer(player.id)){
                 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.removeRoom(room)
-                    this.rooms.splice(roomIdx, 1)
                 }
             }
 
@@ -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.removeRoom(room)
-                this.rooms.splice(roomIdx, 1)
             })
         }
         

Classes/loginResponse.ts

@@ -1,16 +0,0 @@
-import { playerData } from "./playerData"
-import { userData } from "./userData"
-
-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/playerData.ts

@@ -1,62 +0,0 @@
-import { enemyDamageInfo } from "./enemyDamageInfo";
-import { physicsObject } from "./physicsObject";
-import { playerInventory } from "./playerInventory";
-import { questBook } from "./questBook";
-
-export class playerData{
-    id : number
-    level : number = 1
-    room : string = "0_0"
-    characterId : number
-    inventory : playerInventory = new playerInventory()
-    rigidbody : physicsObject = new physicsObject()
-    questBook : questBook = new questBook()
-    damageInfo : enemyDamageInfo[] = []
-
-    constructor(init?: Partial<playerData>) {
-        Object.assign(this, init);
-        this.questBook = new questBook(this.questBook)
-     }
-
-    copyStart(){
-        let player : any = {}
-        player.id = this.id
-        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
-    }
-    
-    getItemById(id : number){
-        let item = this.inventory.items.find(i=>i.id == id)
-        return item
-    }
-    
-    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/playerInventory.ts

@@ -1,7 +1,11 @@
-import { itemData } from "./itemData";
+import { itemData } from "./itemData.js";
 
 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,4 +1,5 @@
-import { physicsObject } from "./physicsObject"
+import { propDataStart, propDataUpdate } from "./Outgoing/propDataPartial.js"
+import { physicsObject } from "./physicsObject.js"
 
 export class propData{
     id         : number
@@ -6,21 +7,11 @@ export class propData{
     rigidbody  : physicsObject
     components : any
 
-    static copyPropStart(o: propData) {
+    copyStart() {
-        let pObject = Object.assign({}, o)
+        return new propDataStart(this)
-        pObject.rigidbody = physicsObject.copyStart(o.rigidbody)
-        return pObject
     }
 
-    static copyPropUpdate(o: propData) {
+    copyUpdate() {
-        let pObject : any = {}
+        return new propDataUpdate(this)
-        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
     }
 }

Classes/questBook.ts

@@ -1,4 +1,4 @@
-import { questProgressData } from "./questProgressData";
+import { questProgressData } from "./questProgressData.js";
 
 export class questBook{
     quests = {}

Classes/roomChangeResponse.ts

@@ -1,8 +0,0 @@
-import { levelState } from "./levelState"
-import { playerData } from "./playerData"
-
-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){
+    constructor(init?: Partial<userData>){
-        this.id = id;
+        Object.assign(this, init);
-        this.login = login;
-        this.password = password;
-        this.checksum = 0;
     }
 
-    static makeSafe(user : userData){
+    makeSafe() : userData{
-        let safeUser : any = Object.assign({}, user);
+        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);
-    }
 }

Database/dbcontroller.ts

@@ -0,0 +1,92 @@
+import sqlite3 from 'sqlite3'
+import { open, Database  } from 'sqlite'
+
+export class dbUser{
+    id : number
+    login : string
+    password : string
+}
+
+export class dbCharacter{
+    id : number
+    user_id : number
+    level : number
+    inventory : string
+    questBook : string
+}
+
+export class DatabaseController {
+    private db: Database;
+
+    private constructor(db: Database) {
+        this.db = db;
+    }
+
+    static async create(filename = ':memory:'): Promise<DatabaseController> {
+        const db = await open({
+            filename,
+            driver: sqlite3.Database
+        });
+        let dbController = new DatabaseController(db);
+        dbController.basicSetup()
+        return dbController;
+    }
+
+    async basicSetup(){
+        await this.db.run(`CREATE TABLE IF NOT EXISTS characters (
+            id INTEGER PRIMARY KEY,
+            user_id INTEGER NOT NULL UNIQUE,
+            level INTEGER DEFAULT 0,
+            inventory TEXT,
+            questBook TEXT
+        );`)
+        await this.db.run(`CREATE TABLE IF NOT EXISTS users (
+            id INTEGER PRIMARY KEY,
+            login TEXT NOT NULL UNIQUE,
+            password TEXT NOT NULL
+        );`)
+    }
+    
+    async select<T = any>(sql: string, params?: any[]): Promise<T[]> {
+        const rows: unknown = await this.db.all(sql, params);
+        return Array.isArray(rows) ? (rows as T[]) : [];
+    }
+
+    async get<T = any>(sql: string, params?: any[]): Promise<T | undefined> {
+        return this.db.get<T>(sql, params);
+    }
+
+    async run(sql: string, params?: any[]): Promise<void> {
+        await this.db.run(sql, params);
+    }
+
+    async close(): Promise<void> {
+        await this.db.close();
+    }
+}
+
+// Usage example (you can put this in another file):
+
+// import { DatabaseController } from './db/DatabaseController';
+
+// (async () => {
+//     const db = await DatabaseController.create('mydb.sqlite3');
+  
+//     await db.run(`CREATE TABLE IF NOT EXISTS players (
+//         id INTEGER PRIMARY KEY,
+//         level INTEGER NOT NULL,
+//         inventory TEXT,
+//         questBook TEXT
+//     );`)
+//     await db.run(`CREATE TABLE IF NOT EXISTS users (
+//         id INTEGER PRIMARY KEY,
+//         login TEXT NOT NULL,
+//         password TEXT NOT NULL
+//     );`)
+
+//   await db.run('CREATE TABLE IF NOT EXISTS friends (id INTEGER PRIMARY KEY, name TEXT)');
+//   await db.run('INSERT INTO friends (name) VALUES (?)', ['Silver Fox']);
+//   const friends = await db.select('SELECT * FROM friends');
+//   console.log(friends); // [{ id: 1, name: 'Silver Fox' }]
+//   await db.close();
+// })();

Items/_updateInventory.ts

@@ -1,14 +1,13 @@
-import { inventoryChange } from "../Classes/Incoming/inventoryChange";
+import { inventoryChange } from "../Classes/Incoming/inventoryChange.js";
-import { itemData } from "../Classes/itemData";
+import { itemData } from "../Classes/itemData.js";
-import { playerData } from "../Classes/playerData";
+import { characterData } from "../Classes/characterData.js";
-
+import { Socket } from "socket.io";
-export function updateInventory(socket, data){
-    if(!socket.hasOwnProperty("player")) return;
 
+export function updateInventory(socket : Socket, data){
         let buff = Buffer.from(data, 'base64');
         let data1 : inventoryChange[] = JSON.parse(buff.toString('utf-8'));
 
-        let player : playerData = socket.player
+        let player : characterData = socket.character
         let inventory = player.inventory
 
         data1.forEach(change=>{

Items/itemGeneration.ts

@@ -1,5 +1,5 @@
-import { itemData, persistentItemData } from "../Classes/itemData";
+import { itemData, persistentItemData } from "../Classes/itemData.js";
-import {game} from "../game";
+import {game} from "../game.js";
 
 function getRandom(arr){
     return arr[Math.floor(Math.random()*arr.length)]

Items/itemSocket.ts

@@ -1,7 +1,8 @@
-import { updateInventory } from "./_updateInventory";
+import { Endpoints } from "../endpoints.js";
+import { updateInventory } from "./_updateInventory.js";
 
 export function registerItemCallbacks(socket){
-    socket.on('item/updateInventory', (data) => {
+    socket.on(Endpoints.UpdateInventory, (data) => {
         updateInventory(socket, data)
     });
 }

Items/items.ts

@@ -1,5 +1,5 @@
-import { persistentItemData } from "../Classes/itemData";
+import { persistentItemData } from "../Classes/itemData.js";
-import { game } from "../game";
+import { game } from "../game.js";
 
 const fs = require('fs');
 

Level/_clear.ts

@@ -1,11 +1,10 @@
-import { game } from "../game";
+import { Endpoints } from "../endpoints.js";
+import { game } from "../game.js";
 
 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("level/cleared", JSON.stringify(room.copyState()))
+    game.socketIO.emit(Endpoints.LevelCleared, JSON.stringify(room.copyState()))
 }

Level/_enter.ts

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

Level/_playerUpdate.ts

@@ -1,19 +1,20 @@
-import { levelUpdateClient } from "../Classes/Incoming/levelUpdateClient";
+import { Socket } from "socket.io";
-import { playerData } from "../Classes/playerData";
+import { levelUpdateClient } from "../Classes/Incoming/levelUpdateClient.js";
+import { characterData } from "../Classes/characterData.js";
 
-export function playerUpdate(socket, data){
+export function playerUpdate(socket : Socket, data){
-    if(!socket.hasOwnProperty("user")) return;
+    if(socket.user != null) return;
 
     let buff = Buffer.from(data, 'base64');
     let data1 : levelUpdateClient = JSON.parse(buff.toString('utf-8'));
 
-    let player : playerData = socket.player
+    let character : characterData = socket.character
-    if(player == null){
+    if(character == null){
         console.log("Error! Player not spawned!")
         return
     }
     
-    player.rigidbody = data1.player.rigidbody
+    character.rigidbody = data1.player.rigidbody
     if(data1.player.hasOwnProperty("damageInfo"))
-        player.damageInfo = player.damageInfo.concat(data1.player.damageInfo)
+        character.damageInfo = character.damageInfo.concat(data1.player.damageInfo)
 }

Level/_projectile.ts

@@ -1,10 +1,12 @@
-import { playerData } from "../Classes/playerData";
+import { Socket } from "socket.io";
+import { characterData } from "../Classes/characterData.js";
+import { Endpoints } from "../endpoints.js";
 
-export function projectile(socket, data){
+export function projectile(socket : Socket, data){
     if(!socket.hasOwnProperty("user")) return;
 
     let buff = Buffer.from(data, 'base64');
-    let player : playerData = socket.player
+    let character : characterData = socket.character
     
-    socket.to(player.room).emit('level/projectile', buff.toString('utf-8'))
+    socket.to(character.room).emit(Endpoints.LevelProjectile, buff.toString('utf-8'))
 }

Level/_update.ts

@@ -1,16 +1,16 @@
-import { levelUpdateHost } from "../Classes/Incoming/levelUpdateHost";
+import { Socket } from "socket.io";
-import { playerData } from "../Classes/playerData";
+import { levelUpdateHost } from "../Classes/Incoming/levelUpdateHost.js";
-import { game } from "../game";
+import { characterData } from "../Classes/characterData.js";
-
+import { game } from "../game.js";
-export function update(socket, data){
+import { plainToInstance } from "class-transformer";
-    if(!socket.hasOwnProperty("player")) return;
 
+export function update(socket : Socket, data){
     let buff = Buffer.from(data, 'base64');
-    let data1 : levelUpdateHost = JSON.parse(buff.toString('utf-8'));
+    let data1 : levelUpdateHost = plainToInstance(levelUpdateHost, JSON.parse(buff.toString('utf-8')));
-    let player : playerData = socket.player
+    let character : characterData = socket.character
 
     let room = game.lobbyState.rooms.find(l=>l.id == data1.room.id)
-    if (room == null || room.hostId != player.id){
+    if (room == null || room.hostId != character.id){
         return
     }
 
@@ -21,7 +21,7 @@ export function update(socket, data){
         data1.room.enemies = []
     }
 
-    player.rigidbody = data1.player.rigidbody
+    character.rigidbody = data1.player.rigidbody
     room.enemies = data1.room.enemies
     room.objects = data1.room.objects
 

Level/levelSocket.ts

@@ -1,27 +1,28 @@
-import { clear } from "./_clear";
+import { Endpoints } from "../endpoints.js";
-import { enter } from "./_enter";
+import { clear } from "./_clear.js";
-import { playerUpdate } from "./_playerUpdate";
+import { enter } from "./_enter.js";
-import { projectile } from "./_projectile";
+import { playerUpdate } from "./_playerUpdate.js";
-import { update } from "./_update";
+import { projectile } from "./_projectile.js";
+import { update } from "./_update.js";
 
 export function registerLevelCallbacks(socket){
-    socket.on('level/enter', (data) => {
+    socket.on(Endpoints.LevelEnter, (data) => {
         enter(socket, data)
     });
 
-    socket.on('level/cleared', (data) => {
+    socket.on(Endpoints.LevelCleared, (data) => {
         clear(socket, data)
     });
 
-    socket.on('level/update', (data) => {
+    socket.on(Endpoints.LevelUpdate, (data) => {
         update(socket, data)
     });
 
-    socket.on('level/playerUpdate', (data) => {
+    socket.on(Endpoints.LevelPlayerUpdate, (data) => {
         playerUpdate(socket, data)
     });
 
-    socket.on('level/projectile', (data) => {
+    socket.on(Endpoints.LevelProjectile, (data) => {
         projectile(socket, data)
     });
 }

Lobby/_loadoutChanged.ts

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

Lobby/_message.ts

@@ -1,5 +1,5 @@
-import { lobbyMessage } from "../Classes/lobbyMessage";
+import { lobbyMessage } from "../Classes/lobbyMessage.js";
-import { game } from "../game";
+import { game } from "../game.js";
 
 export function message(socket, data){
     if(!socket.hasOwnProperty("user")) return;

Lobby/_playerJoin.ts

@@ -1,46 +1,43 @@
-import { lobbyJoin } from "../Classes/Incoming/lobbyJoin";
+import { lobbyJoin } from "../Classes/Incoming/lobbyJoin.js";
-import { levelState } from "../Classes/levelState";
+import { levelState } from "../Classes/levelState.js";
-import { lobbyMessage } from "../Classes/lobbyMessage";
+import { lobbyMessage } from "../Classes/lobbyMessage.js";
-import { playerData } from "../Classes/playerData";
+import { characterData } from "../Classes/characterData.js";
-import { userData } from "../Classes/userData";
+import { game } from "../game.js";
-import { game } from "../game";
+import { Socket } from "socket.io";
-
+import { Endpoints } from "../endpoints.js";
-export function playerJoin(socket, data){
-    if(!socket.hasOwnProperty("player")) return;
 
+export function playerJoin(socket : Socket, data){
     let buff = Buffer.from(data, 'base64');
     let data1 : lobbyJoin = JSON.parse(buff.toString('utf-8'));
-    let player : playerData = socket.player
+    let character : characterData = socket.character
 
-    player.room = "0_0"
+    character.room = "0_0"
-    player.characterId = data1.player.characterId
+    character.characterId = data1.player.characterId
-    game.lobbyState.addUser(socket.user, player)
+    game.lobbyState.addUser(socket)
-    let spawnRoom = game.lobbyState.roomEnter(new levelState("0_0", -1), player)
+    let spawnRoom = game.lobbyState.roomEnter(new levelState("0_0", -1), character)
     socket.join("0_0")
 
     let newUser = {
-        users:[userData.makeSafe(socket.user)],
+        users:[socket.user.makeSafe()],
-        players:[player.copyStart()],
+        players:[character.copyStart()],
         rooms:[]
     };
     let existingUsers = {
-        users:game.lobbyState.users.map(u=> userData.makeSafe(u)),
+        users:game.lobbyState.activeUsers.map(u=> u.user.makeSafe()),
-        players:game.lobbyState.players.map(p=>p.copyStart()),
+        players:game.lobbyState.activeUsers.map(p=>p.character.copyStart()),
-        rooms:[]
+        rooms:game.lobbyState.rooms.map(room=>{
+            if(room == spawnRoom)
+                return spawnRoom.copyStart()
+            else
+                return room.copyState()
+        })
     }
 
-    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));
+    socket.broadcast.emit(Endpoints.PlayerJoin, JSON.stringify(newUser));
 
     //send all users to player (including player)
-    socket.emit("lobby/playerJoin", JSON.stringify(existingUsers))
+    socket.emit(Endpoints.PlayerJoin, JSON.stringify(existingUsers))
 
     game.addMessage(new lobbyMessage(socket.user.login + " joined"))
 }

Lobby/lobbySocket.ts

@@ -1,17 +1,18 @@
-import { loadoutChanged } from "./_loadoutChanged";
+import { Endpoints } from "../endpoints.js";
-import { message } from "./_message";
+import { loadoutChanged } from "./_loadoutChanged.js";
-import { playerJoin } from "./_playerJoin";
+import { message } from "./_message.js";
+import { playerJoin } from "./_playerJoin.js";
 
 export function registerLobbyCallbacks(socket){
-    socket.on('lobby/playerJoin', (data) => {
+    socket.on(Endpoints.PlayerJoin, (data) => {
         playerJoin(socket, data)
     });
 
-    socket.on('lobby/loadoutChanged', (data) => {
+    socket.on(Endpoints.LoadoutChanged, (data) => {
         loadoutChanged(socket, data)
     });
 
-    socket.on('lobby/message', (data) => {
+    socket.on(Endpoints.Message, (data) => {
         message(socket, data)
     });
 }

Player/players.ts

@@ -1,45 +0,0 @@
-import { game } from "../game";
-import { playerData } from "../Classes/playerData";
-
-export class players{
-    static createPlayer(id){
-        if (players.readPlayer(id) != null){
-            console.log(`Player ${id} alread exists`);
-            return null;
-        }
-
-        var player = new playerData();
-        player.id = id
-        game.playersDB.push(player);
-        return player;
-    }
-
-    static readPlayer(id : number){
-        let player = game.playersDB.find(u=>u.id == id);
-        return player;
-    }
-    
-    static savePlayers(fs){
-        game.playersDB.forEach(player => {player.save(fs)});
-    }
-    
-    static loadPlayers(fs){
-        fs.mkdirSync(`Database/Players/`, { recursive: true })
-        fs.readdir(`Database/Players/`, (err, files) => {
-            files.forEach(file => {
-                fs.readFile(`Database/Players/${file}`, (err, data) => {
-                    if (err) throw err;
-                    let player : playerData = new playerData(JSON.parse(data));
-                    game.playersDB.push(player);
-                    player.inventory.items.forEach(i=>{
-                        if(i.id > game.itemCount){
-                            game.itemCount = i.id
-                        }
-                    })
-                    player.validateEquipment()
-                    console.log(`Loaded pl ${player.id}`);
-                });
-            });
-        });
-    }
-}

Quest/_update.ts

@@ -1,12 +1,11 @@
-import { playerData } from "../Classes/playerData";
+import { Socket } from "socket.io";
-import { questProgressData } from "../Classes/questProgressData";
+import { characterData } from "../Classes/characterData.js";
-
+import { questProgressData } from "../Classes/questProgressData.js";
-export function update(socket, data){
-    if(!socket.hasOwnProperty("player")) return;
 
+export function update(socket : Socket, data){
     let buff = Buffer.from(data, 'base64');
     let data1 : questProgressData = JSON.parse(buff.toString('utf-8'));
-    let player : playerData = socket.player
+    let character : characterData = socket.character
 
-    player.questBook.updateQuest(data1)
+    character.questBook.updateQuest(data1)
 }

Quest/questSocket.ts

@@ -1,7 +1,8 @@
-import { update } from "./_update";
+import { Endpoints } from "../endpoints.js";
+import { update } from "./_update.js";
 
 export function registerQuestCallbacks(socket){
-    socket.on('quest/update', (data) => {
+    socket.on(Endpoints.QuestUpdate, (data) => {
         update(socket, data)
     });
 }

endpoints.ts

@@ -0,0 +1,16 @@
+export enum Endpoints{
+    Login       = "account/login",
+    Register    = "account/register",
+    Message         = 'lobby/message',
+    Messages        = "lobby/messages",
+    PlayerJoin      = "lobby/playerJoin",
+    LoadoutChanged  = "lobby/loadoutChanged",
+    LevelEnter          = 'level/enter',
+    LevelUpdate         = 'level/update',
+    LevelCleared        = 'level/cleared',
+    LevelEntered        = "level/entered",
+    LevelProjectile     = 'level/projectile',
+    LevelPlayerUpdate   = 'level/playerUpdate',
+    UpdateInventory = 'item/updateInventory',
+    QuestUpdate     = 'quest/update',
+}

game.ts

@@ -1,17 +1,12 @@
-import { userData } from "./Classes/userData";
+import { lobbyMessage } from "./Classes/lobbyMessage.js";
-import { lobbyMessage } from "./Classes/lobbyMessage";
+import { lobbyState } from "./Classes/lobbyState.js";
-import { lobbyState } from "./Classes/lobbyState";
+import { persistentItemData } from "./Classes/itemData.js";
-import { playerData } from "./Classes/playerData";
+import { Socket } from 'socket.io';
-import { persistentItemData } from "./Classes/itemData";
+import { Endpoints } from "./endpoints.js";
-import { levelState } from "./Classes/levelState";
-const fs = require('fs');
 
 export class game{
     static socketIO : any
-
     static itemCount : number = 0
-    static accountsDB : userData[] = []
-    static playersDB : playerData[] = []
     static itemsDB : persistentItemData[] = []
 
     static lobbyState : lobbyState = new lobbyState()
@@ -25,7 +20,7 @@ export class game{
         }
 
         game.messages.unshift(message)
-        game.socketIO.emit('lobby/messages', JSON.stringify(game.messages))
+        game.socketIO.emit(Endpoints.Messages, JSON.stringify(game.messages))
     }
 
     static getItemTemplate(templateId){

index.ts

@@ -1,34 +1,37 @@
-import { game } from "./game";
+import './socketExtended.js';
-import { users } from "./Account/users";
+import 'reflect-metadata';
-import { players } from "./Player/players";
+import express from 'express';
-import { registerItemCallbacks } from "./Items/itemSocket";
+import { createServer } from 'http';
-import { registerLobbyCallbacks } from "./Lobby/lobbySocket";
+import { Server as SocketIOServer } from 'socket.io';
-import { registerAccountCallbacks } from "./Account/accountSocket";
+import { game } from "./game.js";
-import { registerLevelCallbacks } from "./Level/levelSocket";
+import { characters } from "./Characters/characters.js";
-import { registerQuestCallbacks } from "./Quest/questSocket";
+import { registerItemCallbacks } from "./Items/itemSocket.js";
+import { registerLobbyCallbacks } from "./Lobby/lobbySocket.js";
+import { registerAccountCallbacks } from "./Account/accountSocket.js";
+import { registerLevelCallbacks } from "./Level/levelSocket.js";
+import { registerQuestCallbacks } from "./Quest/questSocket.js";
+import { DatabaseController } from './Database/dbcontroller.js';
+import { SocketExtended } from './socketExtended.js';
+import { Endpoints } from './endpoints.js';
 
-const express = require("express");
 const app = express();
 const port = 3000;
-const server = require('http').Server(app);
+const server = createServer(app);
-const fs = require('fs');
+export const db = await DatabaseController.create('./Database/mydb.sqlite3');
 
 server.listen(port, () => {
   console.log(`Server listening at port ${port}`);
 });
 
-const io = require("socket.io")(server, {
+const io = game.socketIO = new SocketIOServer(server, {
     path: "/webmmo/",
-	cors: {
+    cors: {
-        origin: '*',
+        origin: '\*',
         methods: ["GET", "POST"]
     }
 });
 
-users.loadUsers(fs);
+io.on('connection', (socket : SocketExtended) => {
-players.loadPlayers(fs);
-
-io.on('connection', (socket) => {
 	console.log("Got connection!");
 	socket.emit("connectSuccess", "");
 
@@ -38,46 +41,42 @@ io.on('connection', (socket) => {
     registerLevelCallbacks(socket);
     registerQuestCallbacks(socket);
     
-    socket.io = game.socketIO = io;
+    socket.io = io;
 
     socket.on("disconnect", () => {
         socket.disconnect()
-        if(socket.hasOwnProperty("player")){
+        if(socket.character != null){
-            socket.player.save(fs)
+            characters.savePlayer(db, socket.character)
-        }
-        if(socket.hasOwnProperty("user")){
-            socket.user.save(fs)
-            game.lobbyState.removeUser(socket.user.id)
-            delete socket.user
         }
+        game.lobbyState.removeUser(socket)
         console.log(socket.id + " disconnected");
     });
 
-    socket.on('error',function(er){
+    // socket.on('error',function(er){
-        console.log(er);
+    //     console.log(er);
-    });
+    // });
 });
 
 //Send player updates to everyone
 setInterval(async () => {
-    let userCount = game.lobbyState.players.length
+    let userCount = game.lobbyState.activeUsers.length
     if(userCount > 0){
         game.lobbyState.rooms.forEach(room=>{
             let roomData = room.copyUpdate()
-            io.in(room.id).emit('level/update', JSON.stringify(roomData))
+            io.in(room.id).emit(Endpoints.LevelUpdate, JSON.stringify(roomData))
         })
-        game.playersDB.forEach(p=>{
+        game.lobbyState.activeUsers.forEach(u=>{
-            p.damageInfo = []
+            u.character.resetDamageInfo()
         })
     }
 }, 1000/30)
 
 setInterval(() => {
     let lobbyState = game.lobbyState
-    console.clear()
+    //console.clear()
     console.log("Players:")
-    for(let i = 0; i < lobbyState.players.length; i++){
+    for(let i = 0; i < lobbyState.activeUsers.length; i++){
-        console.log(lobbyState.players[i].id + " " + lobbyState.players[i].room)
+        console.log(lobbyState.activeUsers[i].user.login + " " + lobbyState.activeUsers[i].character.room)
     }
     console.log("Rooms:")
     for(let i = 0; i < lobbyState.rooms.length; i++){
@@ -92,11 +91,6 @@ setInterval(() => {
     }
 }, 5000)
 
-setInterval(() => {
-    users.saveUsers(fs);
-    players.savePlayers(fs);
-}, 1000 * 60 * 60 * 12) //twice a day
-
 process.on('uncaughtException', function (err) {
     console.log('Caught exception: ', err);
   });
@@ -105,8 +99,7 @@ process.on('SIGINT', function () {
     console.log('Ctrl-C...');
     process.exit(2);
 });
+
 process.on('exit', function () {
-    users.saveUsers(fs);
-    players.savePlayers(fs);
     console.log("exitted");
 });

package.json

@@ -3,6 +3,7 @@
   "version": "1.0.0",
   "description": "",
   "main": "index.ts",
+  "type": "module",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
@@ -12,10 +13,15 @@
     "@types/express": "^4.17.13",
     "@types/node": "^17.0.25",
     "@types/socket.io": "^3.0.2",
+    "better-sqlite3": "^12.2.0",
+    "class-transformer": "^0.5.1",
     "cors": "^2.8.5",
     "express": "^4.17.3",
+    "reflect-metadata": "^0.2.2",
     "socket.io": "^4.4.1",
-    "ts-node": "^10.7.0",
+    "sqlite": "^5.1.1",
-    "typescript": "^4.6.3"
+    "sqlite3": "^5.1.7",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3"
   }
 }

socketExtended.ts

@@ -0,0 +1,24 @@
+import { characterData } from "./Classes/characterData.js"
+import { userData } from "./Classes/userData.js"
+import { Socket, Server as SocketIOServer } from 'socket.io';
+
+declare module 'socket.io' {
+  interface Socket {
+    io: SocketIOServer
+    user: userData
+    character: characterData
+  }
+}
+
+export class SocketExtended extends Socket
+{
+  validateUser() : boolean
+  {
+    return this.user != null;
+  }
+
+  validateCharacter() : boolean
+  {
+    return this.character != null;
+  }
+}

tsconfig.json

@@ -1,8 +1,13 @@
 {
     "compilerOptions": {
-      "target": "es5",
+      "module": "NodeNext",
-      "module": "commonjs",
+      "moduleResolution": "NodeNext",
+      "target": "ES2020",
+      "esModuleInterop": true,
+      "allowSyntheticDefaultImports": true,
       "sourceMap": true,
-      "noImplicitAny": false
+      "noImplicitAny": false,
+      "experimentalDecorators": true,
+      "emitDecoratorMetadata": true,
     }
   }