WIP

app.vue

@@ -1,4 +1,12 @@
 <script setup lang="ts">
+import { login, setupWebsocket } from '~/netcode';
+const lobby = await login()
+
+const socket = await setupWebsocket()
+
+onUnmounted(() => {
+  socket.close()
+})
 
 // import goStore, { setReady, oauth2_register_discord, setup_websocket, heron_cookie_login } from "@/netcode";
 

netcode/Query.ts

@@ -0,0 +1,29 @@
+import type { ClientMessage, ServerMessage } from "./interfaces/generic/index"
+type Callbacks = {
+    resolve: (value: ServerMessage) => void;
+    reject: (reason?: any) => void;
+}
+export class Query {
+    static readonly callbacks = new Map<string, Callbacks>()
+    readonly uuid: string
+    readonly message: Omit<ClientMessage, "uuid">
+    private readonly socket: WebSocket
+    constructor(socket: WebSocket, message: Omit<ClientMessage, "uuid">) {
+        this.uuid = crypto.randomUUID()
+        this.message = message
+        this.socket = socket
+    }
+
+
+    private serialize() {
+        return JSON.stringify({ uuid: this.uuid, ...this.message })
+    }
+
+    send() {
+        return new Promise<ServerMessage>((resolve, reject) => {
+            const callbacks = { resolve, reject }
+            this.socket.send(this.serialize())
+            Query.callbacks.set(this.uuid, callbacks)
+        })
+    }
+}

netcode/index.ts

@@ -1,7 +1,15 @@
+import { Lobby } from "./model/Lobby";
+import type { ServerMessage } from "./interfaces/generic";
+import { ServerQueryType, ClientQueryType } from "./interfaces/generic";
+import { Query } from "./Query";
+
 let socket: WebSocket
 export function setupWebsocket(): Promise<WebSocket> {
     return new Promise<WebSocket>((resolve, reject) => {
         if (socket) {
+            if (!socket.OPEN) {
+                return reject("socket closed")
+            }
             return resolve(socket);
         }
         const config = useRuntimeConfig();
@@ -30,8 +38,46 @@ export function setupWebsocket(): Promise<WebSocket> {
             console.error(error);
         };
 
-        socket.onmessage = function (event) {
+        socket.onmessage = function (ev: MessageEvent) {
-            const data = JSON.parse(event.data);
+            const data = ev.data as ServerMessage
-        };
+            const answer_to = ev.data.answer_to
+            if (!answer_to) { return }
+            const callback = Query.callbacks.get(answer_to)
+            if (!callback) { return }
+            if (data.type == ServerQueryType.ERROR) {
+                callback.reject()
+            } else {
+                callback.resolve(ev.data)
+            }
+        }
     });
 }
+
+
+export async function login() {
+    const socket = await setupWebsocket()
+
+    const query = new Query(socket, {
+        type: ClientQueryType.LOGIN,
+        method: "anon",
+        args: { code: "" },
+        target: ""
+    })
+    const loginInfo = await query.send()
+    // return new Promise<Lobby>((resolve, reject) => {
+    //     const handler = ((e: MessageEvent) => {
+    //         const data = e.data as ServerMessage
+    //         if (data.type == ServerQueryType.CREATE) {
+    //             if (data.args.objectType == "Lobby") {
+    //                 const lobby = new Lobby(socket, data.args as any)
+    //                 socket.removeEventListener("message", handler)
+    //                 resolve(lobby)
+    //             }
+    //         }
+    //     })
+    //     socket.onmessage = handler
+
+
+    // })
+}
+

netcode/model/GameObject.ts

@@ -0,0 +1,12 @@
+import type { IGameObject } from "../interfaces/generic";
+
+export abstract class GameObject implements IGameObject {
+    static readonly instances = new Map<string, GameObject>()
+    readonly uuid: string;
+    readonly socket: WebSocket
+    constructor(socket: WebSocket, { uuid }: { uuid: string }) {
+        this.uuid = uuid
+        this.socket = socket
+        GameObject.instances.set(this.uuid, this)
+    }
+}

netcode/model/Lobby.ts

@@ -0,0 +1,29 @@
+import { GameObject } from "./GameObject";
+import type { ICLobby } from "../interfaces/client";
+
+
+
+export class Lobby extends GameObject implements ICLobby {
+    static instance: Lobby
+    constructor(socket: WebSocket, data: { uuid: string, games: Array<string> }) {
+        if (Lobby.instance) { return Lobby.instance }
+        super(socket, data)
+        Lobby.instance = this
+    }
+
+
+    onAddGame() {
+
+    }
+    onRemoveGame() {
+
+    }
+
+    async request_createGame() {
+        throw Error("not implemented")
+    }
+
+    removeGame() {
+        throw Error("not implemented")
+    }
+}

pages/index.vue

@@ -1,13 +1,5 @@
 <script setup lang="ts">
-import { setupWebsocket } from '~/netcode';
-const socket = await setupWebsocket()
 
-socket.onmessage = (e) => {
-  console.log(JSON.parse(e.data))
-}
-onUnmounted(() => {
-  socket.close()
-})
 </script>
 
 <template>