Feature/may bug fixes

src/app/game/StaticEntityManager.ts

@@ -0,0 +1,88 @@
+import * as THREE from 'three';
+
+interface StaticEntity {
+  id: string;
+  name: string;
+  position: THREE.Vector3;
+  rotation: THREE.Euler;
+}
+
+export class StaticEntityManager {
+  private scene: THREE.Scene;
+  private staticEntities: Map<string, THREE.Mesh> = new Map();
+
+  constructor(scene: THREE.Scene) {
+    this.scene = scene;
+  }
+
+  public async addStaticEntity(entity: StaticEntity): Promise<void> {
+    if (this.staticEntities.has(entity.id)) {
+      console.warn(`Static entity with ID ${entity.id} already exists`);
+      return;
+    }
+
+    const geometry = new THREE.BoxGeometry(1, 1, 1);
+    const material = new THREE.MeshBasicMaterial({ color: 0x808080 });
+    const mesh = new THREE.Mesh(geometry, material);
+    mesh.position.copy(entity.position);
+    mesh.rotation.copy(entity.rotation);
+    mesh.userData = {
+      type: 'staticEntity',
+      id: entity.id,
+      name: entity.name
+    };
+
+    this.staticEntities.set(entity.id, mesh);
+    this.scene.add(mesh);
+  }
+
+  public createPortal(position: THREE.Vector3, destinationMap: string): THREE.Mesh {
+    const geometry = new THREE.BoxGeometry(2, 2, 2);
+    const material = new THREE.MeshBasicMaterial({ 
+      color: 0x00ff00,
+      transparent: true,
+      opacity: 0.5
+    });
+    const portal = new THREE.Mesh(geometry, material);
+    portal.position.copy(position);
+    portal.userData = {
+      type: 'portal',
+      destinationMap: destinationMap
+    };
+    this.scene.add(portal);
+    return portal;
+  }
+
+  public updateStaticEntityPosition(id: string, position: THREE.Vector3): void {
+    const entity = this.staticEntities.get(id);
+    if (entity) {
+      entity.position.copy(position);
+    }
+  }
+
+  public removeStaticEntity(id: string): void {
+    const entity = this.staticEntities.get(id);
+    if (entity) {
+      this.scene.remove(entity);
+      this.staticEntities.delete(id);
+    }
+  }
+
+  public async removeAllStaticEntities(): Promise<void> {
+    for (const [id] of this.staticEntities) {
+      this.removeStaticEntity(id);
+    }
+  }
+
+  public hasStaticEntity(id: string): boolean {
+    return this.staticEntities.has(id);
+  }
+
+  public getStaticEntityIds(): Map<string, THREE.Mesh> {
+    return this.staticEntities;
+  }
+
+  public getStaticEntityPosition(id: string): THREE.Vector3 | undefined {
+    return this.staticEntities.get(id)?.position;
+  }
+} 

src/app/game/game.component.ts

@@ -15,6 +15,7 @@ import { PlayerData } from '../models/player/PlayerData';
 import { AlienManager } from './AlienManager';
 import { PlayerManager } from './PlayerManager';
 import { CSS2DRenderer } from 'three/addons/renderers/CSS2DRenderer.js';
+import { StaticEntityManager } from './StaticEntityManager';
 
 @Component({
   selector: 'app-game',
@@ -29,6 +30,7 @@ export class GameComponent implements OnInit, OnDestroy {
   public entities: Map<string, PlayerDto> = new Map();
   public alienManager?: AlienManager;
   public playerManager?: PlayerManager;
+  public staticEntityManager?: StaticEntityManager;
   public stats?: Stats;
   public currentMapName?: string;
   public playerData: PlayerData | undefined;
@@ -43,7 +45,7 @@ export class GameComponent implements OnInit, OnDestroy {
   constructor(
     private hubService: HubService,
     private route: ActivatedRoute,
-    private keyboardService: KeyboardService
+    public keyboardService: KeyboardService
   ) {}
 
   ngOnInit(): void {
@@ -64,6 +66,9 @@ export class GameComponent implements OnInit, OnDestroy {
       this.camera.aspect = window.innerWidth / window.innerHeight;
       this.camera.updateProjectionMatrix();
       this.renderer.setSize(window.innerWidth, window.innerHeight);
+      if (this.labelRenderer) {
+        this.labelRenderer.setSize(window.innerWidth, window.innerHeight);
+      }
     }
   }
 
@@ -76,6 +81,14 @@ export class GameComponent implements OnInit, OnDestroy {
       console.warn('HubMessage: Received error:', error);
     });
 
+    hubService.on('teleportSuccessful', (message: string) => {
+      console.log('Teleportation successful:', message);
+    });
+
+    hubService.on('teleportFailed', (error: string) => {
+      console.error('Teleportation failed:', error);
+    });
+
     hubService.on('loginSuccessful', (response: PlayerData) => {
       console.log('HubMessage: Login successful:', response);
       this.playerData = response;
@@ -149,6 +162,7 @@ export class GameComponent implements OnInit, OnDestroy {
     await initializeThreeJs(this);
     this.playerManager = new PlayerManager(this.scene!);
     this.alienManager = new AlienManager(this.scene!);
+    this.staticEntityManager = new StaticEntityManager(this.scene!);
     this.setupPerformanceMeters();
     this.animate();
   }
@@ -172,6 +186,16 @@ export class GameComponent implements OnInit, OnDestroy {
       this.alienManager.animate();
     }
 
+    // Update player position for portal detection
+    if (this.playerData && this.playerManager) {
+      const playerPosition = this.playerManager.getPlayerPosition(
+        this.playerData.id
+      );
+      if (playerPosition) {
+        this.keyboardService.setPlayerPosition(playerPosition);
+      }
+    }
+
     // Update orbit controls to follow player if available
     if (this.playerData && this.playerManager && this.controls) {
       const playerPosition = this.playerManager.getPlayerPosition(
@@ -232,6 +256,10 @@ export class GameComponent implements OnInit, OnDestroy {
     if (this.scene) {
       this.scene.clear();
     }
+    this.keyboardService.clearPortals();
+    if (this.staticEntityManager) {
+      this.staticEntityManager.removeAllStaticEntities();
+    }
   }
 
   // Public method to handle player movement

src/app/game/game.utils.ts

@@ -1,7 +1,12 @@
 import * as THREE from 'three';
 import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
 import { CSS2DRenderer } from 'three/addons/renderers/CSS2DRenderer.js';
-import { PlayerDto, SpaceMapData, AlienDto } from './types/SpaceMapData';
+import {
+  PlayerDto,
+  SpaceMapData,
+  AlienDto,
+  StaticEntityDto,
+} from './types/SpaceMapData';
 import { GameComponent } from './game.component';
 
 // Define layers
@@ -124,20 +129,20 @@ export async function loadNewSpacemap(
   spaceMapData: SpaceMapData
 ): Promise<void> {
   if (component.isLoadingSpacemap) {
-    console.log('Skipping spacemap update - still loading previous map');
     return;
   }
 
   try {
     component.isLoadingSpacemap = true;
-    console.log('Loading new space map: ', spaceMapData);
+    console.log('Loading new spacemap: ', spaceMapData);
     component.currentMapName = spaceMapData.mapName;
     await clearScene(component);
     await loadMapEnvironment(component, spaceMapData);
 
-    // Load players and aliens for the new map
+    // Load players, aliens, and static entities for the new map
     await loadPlayers(spaceMapData.mapObject.players, component);
     await loadAliens(spaceMapData.mapObject.aliens, component);
+    await loadStaticEntities(spaceMapData.mapObject.staticEntities, component);
   } finally {
     component.isLoadingSpacemap = false;
   }
@@ -384,17 +389,83 @@ export async function loadAliens(aliens: AlienDto[], component: GameComponent) {
   }
 }
 
+export async function loadStaticEntities(
+  staticEntities: StaticEntityDto[],
+  component: GameComponent
+): Promise<void> {
+  if (!component.staticEntityManager) {
+    console.error('Static entity manager not initialized');
+    return;
+  }
+
+  for (const entity of staticEntities) {
+    const position = parsePositionDTOtoVector3(entity.position);
+    await component.staticEntityManager.addStaticEntity({
+      id: entity.id,
+      name: entity.name,
+      position: position,
+      rotation: new THREE.Euler(0, 0, 0),
+    });
+  }
+}
+
 export async function updateSpacemap(
   component: GameComponent,
   spaceMapData: SpaceMapData
 ): Promise<void> {
   if (component.isLoadingSpacemap) {
-    console.log('Skipping spacemap update - still loading previous map');
     return;
   }
 
   try {
     component.isLoadingSpacemap = true;
+
+    // Clear existing portals
+    component.keyboardService.clearPortals();
+
+    // Handle static entities and portals
+    if (component.staticEntityManager) {
+      const staticEntities = spaceMapData.mapObject.staticEntities;
+      const currentStaticEntityIds = new Set(
+        staticEntities.map((entity) => entity.id)
+      );
+
+      // Remove static entities that are no longer in the map
+      for (const [id] of component.staticEntityManager.getStaticEntityIds()) {
+        if (!currentStaticEntityIds.has(id)) {
+          component.staticEntityManager.removeStaticEntity(id);
+        }
+      }
+
+      // Add or update static entities
+      for (const entity of staticEntities) {
+        const position = parsePositionDTOtoVector3(entity.position);
+        if (component.staticEntityManager.hasStaticEntity(entity.id)) {
+          component.staticEntityManager.updateStaticEntityPosition(
+            entity.id,
+            position
+          );
+        } else {
+          if ('destinationMap' in entity) {
+            // This is a portal
+            const portalMesh = component.staticEntityManager.createPortal(
+              position,
+              entity.destinationMap
+            );
+            component.keyboardService.addPortal(portalMesh);
+          } else {
+            // This is a regular static entity
+            await component.staticEntityManager.addStaticEntity({
+              id: entity.id,
+              name: entity.name,
+              position: position,
+              rotation: new THREE.Euler(0, 0, 0),
+            });
+          }
+        }
+      }
+    }
+
     const entities = component.entities;
     const entitiesIn = spaceMapData.mapObject.players;
 

src/app/game/services/hub.service.ts

@@ -30,11 +30,17 @@ export class HubService {
     });
   }
 
-  public on<T = unknown>(event: string, callback: (...args: T[]) => void): void {
+  public on<T = unknown>(
+    event: string,
+    callback: (...args: T[]) => void
+  ): void {
     this.hubConnection?.on(event, callback);
   }
 
-  public off<T = unknown>(event: string, callback: (...args: T[]) => void): void {
+  public off<T = unknown>(
+    event: string,
+    callback: (...args: T[]) => void
+  ): void {
     this.hubConnection?.off(event, callback);
   }
 
@@ -73,6 +79,9 @@ type ServerRequestTypes = {
       z: number;
     };
   };
+  requestTeleport: {
+    destinationMap: string;
+  };
 };
 
 type RequestLogin = {