thread-split events display

src/core/worker/Worker.worker.ts

@@ -77,6 +77,24 @@ ctx.addEventListener('message', async (e: MessageEvent<MainThreadMessage>) => {
                 throw error;
             }
             break;
+        case 'player_profile':
+            if (!gameRunner) {
+                throw new Error('Game runner not initialized');
+            }
+
+            try {
+                const actions = (await gameRunner).playerActions(message.playerID, message.x, message.y)
+                sendMessage({
+                    type: 'player_actions_result',
+                    id: message.id,
+                    result: actions
+                } as PlayerActionsResultMessage);
+            } catch (error) {
+                console.error('Failed to check borders:', error);
+                throw error;
+            }
+            break;
+
 
         default:
             console.warn('Unknown message :', message);

src/core/worker/WorkerClient.ts

@@ -1,4 +1,4 @@
-import { PlayerActions, PlayerID, Tile } from "../game/Game";
+import { PlayerActions, PlayerID, PlayerInfo, PlayerProfile, Tile } from "../game/Game";
 import { GameUpdateViewData } from "../GameView";
 import { GameConfig, GameID, Turn } from "../Schemas";
 import { generateID } from "../Util";
@@ -91,6 +91,30 @@ export class WorkerClient {
         });
     }
 
+    playerInfo(playerID: number): Promise<PlayerProfile> {
+        return new Promise((resolve, reject) => {
+            if (!this.isInitialized) {
+                reject(new Error('Worker not initialized'));
+                return;
+            }
+
+            const messageId = generateID()
+
+            this.messageHandlers.set(messageId, (message) => {
+                if (message.type === 'player_profile_result' && message.result !== undefined) {
+                    resolve(message.result);
+                }
+            });
+
+            this.worker.postMessage({
+                type: 'player_profile',
+                id: messageId,
+                playerID: playerID,
+            });
+
+        })
+    }
+
     playerInteraction(playerID: PlayerID, tile: Tile): Promise<PlayerActions> {
         return new Promise((resolve, reject) => {
             if (!this.isInitialized) {

src/core/worker/WorkerMessages.ts

@@ -1,6 +1,6 @@
 import { GameUpdateViewData } from "../GameView";
 import { GameConfig, GameID, Turn } from "../Schemas";
-import { PlayerActions, PlayerID } from "../game/Game";
+import { PlayerActions, PlayerID, PlayerProfile } from "../game/Game";
 
 export type WorkerMessageType =
     | 'heartbeat'
@@ -9,7 +9,9 @@ export type WorkerMessageType =
     | 'turn'
     | 'game_update'
     | 'player_actions'
-    | 'player_actions_result';
+    | 'player_actions_result'
+    | 'player_profile'
+    | 'player_profile_result'
 
 // Base interface for all messages
 interface BaseWorkerMessage {
@@ -55,8 +57,18 @@ export interface PlayerActionsResultMessage extends BaseWorkerMessage {
     result: PlayerActions;
 }
 
+export interface PlayerProfileMessage extends BaseWorkerMessage {
+    type: 'player_profile'
+    playerID: number
+}
+
+export interface PlayerProfileResultMessage extends BaseWorkerMessage {
+    type: 'player_profile_result'
+    result: PlayerProfile
+}
+
 // Union types for type safety
-export type MainThreadMessage = HeartbeatMessage | InitMessage | TurnMessage | PlayerActionsMessage
+export type MainThreadMessage = HeartbeatMessage | InitMessage | TurnMessage | PlayerActionsMessage | PlayerProfileMessage
 
 // Message send from worker
-export type WorkerMessage = InitializedMessage | GameUpdateMessage | PlayerActionsResultMessage;
+export type WorkerMessage = InitializedMessage | GameUpdateMessage | PlayerActionsResultMessage | PlayerProfileResultMessage