lobbyid -> lobby_id

Author: evolutionleo

Client/objects/oLobbiesDemo/Draw_0.gml

@@ -6,7 +6,7 @@ draw_set_valign(fa_middle)
 for(var i = 0; i < array_length(global.lobbies); i++) {
 	var lobby = global.lobbies[i]
 	var lobby_string = string(i+1) + ")" + string({
-		lobbyid: lobby.lobbyid,
+		lobby_id: lobby.lobby_id,
 		//level: lobby.level.name,
 		//mode: lobby.level.mode,
 		//room_name: lobby.level.room_name,
@@ -21,11 +21,11 @@ for(var i = 0; i < array_length(global.lobbies); i++) {
 draw_text(room_width/2, room_height/2+100, "Press buttons 1-9 to join lobbies\nL to leave\nR to refresh")
 
 if (global.lobby) {
-	draw_text(room_width/2, room_height-150, "joined lobbyid: " + global.lobby.lobbyid + "\n"
+	draw_text(room_width/2, room_height-150, "joined lobby_id: " + global.lobby.lobby_id + "\n"
 		+ "players: " + string(global.lobby.player_count) + "/"
 		+ string(global.lobby.max_players))
 	//draw_text(room_width/2, room_height-150,
-	//	str_format("joined lobbyid: %\n players: %/%", global.lobby.lobbyid,
+	//	str_format("joined lobby_id: %\n players: %/%", global.lobby.lobby_id,
 	//		global.lobby.player_count, global.lobby.max_players))
 }
 else {

Client/objects/oLobbiesDemo/Step_0.gml

@@ -5,7 +5,7 @@ for(var i = 1; i <= 9; i++) {
 	if (keyboard_check_pressed(ord(string(i)))) {
 		trace("pressed %", i)
 		if (i-1 < array_length(global.lobbies)) {
-			sendLobbyJoin(global.lobbies[i-1].lobbyid)
+			sendLobbyJoin(global.lobbies[i-1].lobby_id)
 		}
 	}
 }

Client/scripts/gameplaySenders/gameplaySenders.gml

@@ -4,7 +4,7 @@ function sendPlayerControls(inputs) {
 	var input_names = variable_struct_get_names(inputs)
 	for(var i = 0; i < variable_struct_names_count(inputs); i++) {
 		var input_name = input_names[i]
-		data[$ input_name] = self.inputs[input_name]
+		data[$ input_name] = self.inputs[$ input_name]
 	}
 
 

Client/scripts/lobbyHandlers/lobbyHandlers.gml

@@ -9,7 +9,7 @@ addHandler("lobby info", function(data) {
 	var lobby = data.lobby
 	for(var i = 0; i < array_length(global.lobbies); i++) {
 		var _lobby = global.lobbies[i]
-		if (_lobby.lobbyid == lobby.lobbyid) {
+		if (_lobby.lobby_id == lobby.lobby_id) {
 			global.lobbies[i] = lobby
 		}
 	}

Client/scripts/lobbySenders/lobbySenders.gml

@@ -1,13 +1,13 @@
-function sendLobbyJoin(lobbyid) {
-	send({cmd: "lobby join", lobbyid: lobbyid})
+function sendLobbyJoin(lobby_id) {
+	send({cmd: "lobby join", lobby_id: lobby_id})
 }
 
 function sendLobbyLeave() {
 	send({cmd: "lobby leave"})
 }
 
-function sendLobbyRequestInfo(lobbyid) {
-	send({cmd: "lobby info", lobbyid: lobbyid})
+function sendLobbyRequestInfo(lobby_id) {
+	send({cmd: "lobby info", lobby_id: lobby_id})
 }
 
 function sendLobbyRequestList() {

TypescriptServer/src/cmd/handlers/auth.ts

@@ -20,11 +20,11 @@ addHandler('session create', async (c, data) => {
 
         await c.register(c.account);
 
-        c.send({ cmd: 'session create', success: true, session: c.session.token });
+        c.sendSessionCreate(true, '', c.session.token);
         c.sendLogin(true);
     }
     catch (reason) {
-        c.send({ cmd: 'session create', success: false, reason: reason.toString() });
+        c.sendSessionCreate(false, reason.toString());
     }
 });
 

TypescriptServer/src/cmd/handlers/custom.ts

@@ -1,4 +1,5 @@
 import { addHandler } from "#cmd/handlePacket";
+import { PlayerInputs } from "#entities/player";
 import Point from "#types/point";
 import { clamp } from "#util/maths";
 

TypescriptServer/src/cmd/handlers/lobby.ts

@@ -7,18 +7,18 @@ addHandler('lobby list', (c) => {
 });
 
 addHandler('lobby info', (c, data) => {
-    const lobbyid = data.lobbyid;
-    if (lobbyExists(lobbyid))
-        c.sendLobbyInfo(lobbyid);
+    const lobby_id = data.lobby_id;
+    if (lobbyExists(lobby_id))
+        c.sendLobbyInfo(lobby_id);
 });
 
 addHandler('lobby join', (c, data) => {
     if (!global.config.lobby.allow_join_by_id)
         return;
 
-    const lobbyid = data.lobbyid;
-    if (lobbyExists(lobbyid))
-        c.lobbyJoin(lobbyid);
+    const lobby_id = data.lobby_id;
+    if (lobbyExists(lobby_id))
+        c.lobbyJoin(lobby_id);
 });
 
 addHandler('lobby leave', (c, data) => {

TypescriptServer/src/cmd/senders/auth.ts

@@ -9,6 +9,7 @@ declare module "#cmd/sendStuff" {
         sendRegister(success:boolean, reason?:string)
         sendLogin(success:boolean, reason?:string)
         sendSession(success:boolean, reason?:string, session_token?:string)
+        sendSessionCreate(success:boolean, reason?:string, session_token?:string)
     }
 }
 
@@ -37,4 +38,11 @@ SendStuff.prototype.sendSession = function(success, reason:string = '', token =
         token = this.session.token;
     }
     this.send({ cmd: 'session login', success, reason, session: token });
+}
+
+SendStuff.prototype.sendSessionCreate = function(success, reason:string = '', token = undefined) {
+    if (token === undefined && success) {
+        token = this.session.token;
+    }
+    this.send({ cmd: 'session create', success: true, reason, session: token });
 }

TypescriptServer/src/cmd/senders/chat.ts

@@ -4,13 +4,14 @@ import { IMessage } from "#schemas/chat";
 declare module '#cmd/sendStuff' {
     interface SendStuff {
         sendChatMessage(chat_id:string, message:IMessage):void
-        // sendSomething():void
+        sendChatHistory(chat_id:string, messages:IMessage[]):void
     }
 }
 
-/**
- * @param {}
- */
-// SendStuff.prototype.sendSomething = function() {
-//     this.send({ cmd: '',  })
-// }
+SendStuff.prototype.sendChatMessage = function(chat_id:string, message:IMessage) {
+    this.send({ cmd: 'chat msg', chat_id, message });
+}
+
+SendStuff.prototype.sendChatHistory = function(chat_id:string, messages:IMessage[]) {
+    this.send({ cmd: 'chat history', chat_id, history: messages });
+}

TypescriptServer/src/cmd/senders/lobby.ts

@@ -8,7 +8,7 @@ declare module '#cmd/sendStuff' {
         sendLobbyReject(lobby:Lobby, reason?:string):void
         sendLobbyLeave(lobby:Lobby, reason?:string, forced?:boolean):void
         sendLobbyUpdate(lobby: Lobby):void
-        sendLobbyInfo(lobbyid: string):void
+        sendLobbyInfo(lobby_id: string):void
         sendLobbyList():void
     }
 }
@@ -49,8 +49,8 @@ SendStuff.prototype.sendLobbyList = function() {
 }
 
 /**
- * @param {string} lobbyid 
+ * @param {string} lobby_id 
  */
-SendStuff.prototype.sendLobbyInfo = function(lobbyid:string) {
-    this.send({ cmd: 'lobby info', lobby: global.lobbies[lobbyid].getInfo()})
+SendStuff.prototype.sendLobbyInfo = function(lobby_id:string) {
+    this.send({ cmd: 'lobby info', lobby: global.lobbies[lobby_id].getInfo()})
 }

TypescriptServer/src/cmd/validators/lobby.ts

@@ -1,5 +1,5 @@
 import { addValidator } from "#cmd/validator";
 
 addValidator(['lobby info', 'lobby join'], {
-    lobbyid: { type: 'string', optional: true }
+    lobby_id: { type: 'string', optional: true }
 });

TypescriptServer/src/concepts/chat.ts

@@ -4,6 +4,7 @@ import Account, { IProfile } from "#schemas/profile";
 import { ObjectId } from "mongoose";
 
 import ChatLog, { IChatLog, IMessage } from "#schemas/chat";
+import { randomInt } from "crypto";
 
 export { IChatLog, IMessage };
 
@@ -13,15 +14,28 @@ export function chatFind(chat_id:string) {
 }
 
 export function chatCreate(members:IProfile[] = []) {
-    let chat = new Chat(new ChatLog());
+    let chatlog = new ChatLog();
+    let chat_id:string;
+
+    while(true) {
+        // a random 6-digit number
+        chat_id = randomInt(100000, 999999).toString();
+        if (chat_id in global.chats) { // just in case of a collision
+            continue;
+        }
+        else {
+            chatlog._id = chat_id;
+            break;
+        }
+    }
+
+    let chat = new Chat(chatlog);
 
     for(let member of members) {
         chat.addMember(member, true);
     }
 
     chat.save();
-
-    let chat_id = chat.chat_id;
     global.chats[chat_id] = chat;
 }
 
@@ -112,9 +126,13 @@ export class Chat {
             name: client.name,
             content
         };
-
         this.messages.push(message);
         this.save();
+
+        // broadcast to all online users
+        this.online_members.forEach(
+            member => member.sendChatMessage(this.chat_id, message)
+        );
     }
 }
 

TypescriptServer/src/concepts/client.ts

@@ -29,7 +29,7 @@ import { Chat, chatFind } from '#concepts/chat';
 export type ClientInfo = {
     name: string;
     party_id: string;
-    lobbyid: string;
+    lobby_id: string;
     room_name: string;
 };
 
@@ -329,18 +329,18 @@ export default class Client extends SendStuff implements IClient {
         return {
             name: this.name,
             party_id: this.party?.party_id,
-            lobbyid: this.lobby?.lobbyid,
+            lobby_id: this.lobby?.lobby_id,
             room_name: this.room?.level.name
         };
     }
 
     // Below are some preset functions (you probably don't want to change them
 
 
-    lobbyJoin(lobbyid?:string) {
+    lobbyJoin(lobby_id?:string) {
         let lobby:Lobby;
-        if (lobbyid) {
-            lobby = lobbyFind(lobbyid);
+        if (lobby_id) {
+            lobby = lobbyFind(lobby_id);
         }
         else {
             lobby = MatchMaker.findNonfullLobby(this);
@@ -595,9 +595,9 @@ export default class Client extends SendStuff implements IClient {
                 });
         }
         if (this.profile !== null) {
-            // save the current lobbyid
+            // save the current lobby_id
             if (this.lobby !== null) {
-                this.profile.state.lobbyid = this.lobby.lobbyid;
+                this.profile.state.lobby_id = this.lobby.lobby_id;
             }
 
             await this.profile.save()

TypescriptServer/src/concepts/lobby.ts

@@ -11,37 +11,40 @@ import Match from '#matchmaking/match';
 
 // note: only create lobbies with createLobby(), don't call the constructor directly
 export function lobbyCreate(map:GameMap) { // returns the lobby instance
+    if (Object.keys(global.lobbies).length > 900000) return null;
+
     let lobby = new Lobby(map);
 
+    // get the ID
     while(true) {
         // a random 6-digit number
-        let lobbyid = crypto.randomInt(100000, 999999).toString();
-        if (lobbyid in global.lobbies) { // just in case of a collision
+        let lobby_id = crypto.randomInt(100000, 999999).toString();
+        if (lobby_id in global.lobbies) { // just in case of a collision
             continue;
         }
         else {
-            global.lobbies[lobbyid] = lobby;
-            lobby.lobbyid = lobbyid;
+            global.lobbies[lobby_id] = lobby;
+            lobby.lobby_id = lobby_id;
             break;
         }
     }
 
     return lobby;
 }
 
-export function lobbyFind(lobbyid:string) {
-    return global.lobbies[lobbyid];
+export function lobbyFind(lobby_id:string) {
+    return global.lobbies[lobby_id];
 }
 
-export function lobbyExists(lobbyid:string) {
-    return global.lobbies.hasOwnProperty(lobbyid);
+export function lobbyExists(lobby_id:string) {
+    return global.lobbies.hasOwnProperty(lobby_id);
 }
 
-export function lobbyDelete(lobbyid:string) {
-    let lobby = global.lobbies[lobbyid];
+export function lobbyDelete(lobby_id:string) {
+    let lobby = global.lobbies[lobby_id];
     lobby.close();
 
-    delete global.lobbies[lobbyid];
+    delete global.lobbies[lobby_id];
 }
 
 export function lobbyList():Lobby[] {
@@ -51,7 +54,7 @@ export function lobbyList():Lobby[] {
 export type LobbyStatus = 'open' | 'closed';
 
 export type SerializedLobby = {
-    lobbyid: string,
+    lobby_id: string,
     status: LobbyStatus,
     max_players: number,
     player_count: number,
@@ -60,7 +63,7 @@ export type SerializedLobby = {
 }
 
 export type LobbyInfo = {
-    lobbyid: string,
+    lobby_id: string,
     status: LobbyStatus,
     max_players: number,
     player_count: number,
@@ -72,7 +75,7 @@ export type LobbyInfo = {
 
 // in context of an MMO this is a shard/separated world
 export default class Lobby extends EventEmitter {
-    lobbyid:string = '-1'; // assigned when created
+    lobby_id:string = '-1'; // assigned when created
     status:LobbyStatus = 'open';
     /** @type {Client[]} */
     players:Client[] = [];
@@ -242,7 +245,7 @@ export default class Lobby extends EventEmitter {
     // (e.x. we don't want to send functions and everything about every player)
     serialize():SerializedLobby {
         return {
-            lobbyid: this.lobbyid,
+            lobby_id: this.lobby_id,
             rooms: global.config.rooms_enabled
                 ? this.rooms.map(r => r.serialize())
                 : undefined,
@@ -255,7 +258,7 @@ export default class Lobby extends EventEmitter {
 
     getInfo():LobbyInfo {
         return {
-            lobbyid: this.lobbyid,
+            lobby_id: this.lobby_id,
             rooms: global.config.rooms_enabled
                 ? this.rooms.map(r => r.getInfo())
                 : undefined,