fix(update): many updates

Author: ThornWalli

packages/app/lib/classes/Renderer.ts

@@ -5,8 +5,7 @@ import { OutputPass } from 'three/addons/postprocessing/OutputPass.js';
 import { OutlinePass } from 'three/addons/postprocessing/OutlinePass.js';
 import { RenderPass } from 'three/addons/postprocessing/RenderPass.js';
 
-import { ReplaySubject, type Observable } from 'rxjs';
-import { fromEvent } from 'rxjs';
+import { Observable, ReplaySubject, fromEvent } from 'rxjs';
 import {
   Clock,
   SRGBColorSpace,
@@ -28,6 +27,7 @@ import {
 } from 'three';
 import IntersectionRendererModule from './rendererModule/Intersection';
 import DebugRendererModule from './rendererModule/Debug';
+import type { HasEventTargetAddRemove } from 'rxjs/internal/observable/fromEvent';
 
 export type RendererModuleList = (
   | typeof DebugRendererModule
@@ -76,6 +76,7 @@ export default class Renderer<
       rotate: boolean;
     }>;
     rotation$: ReplaySubject<number>;
+    controlsChange$: Observable<Event>;
   };
   shadowQuality: ShadowQuality = ShadowQuality.OFF;
 
@@ -131,7 +132,8 @@ export default class Renderer<
         zoom: boolean;
         rotate: boolean;
       }>(1),
-      rotation$: new ReplaySubject<number>(1)
+      rotation$: new ReplaySubject<number>(1),
+      controlsChange$: new Observable<Event>()
     };
 
     this.dimension = dimension;
@@ -155,6 +157,10 @@ export default class Renderer<
     this.initComposer();
     if (options.controls) {
       this.initControls();
+      this.observables.controlsChange$ = fromEvent<Event>(
+        this.controls as HasEventTargetAddRemove<Event>,
+        'change'
+      );
     }
 
     //#region Modules

packages/app/lib/classes/UnitChunkManager.ts

@@ -71,25 +71,23 @@ export default class UnitChunkManager {
 
   updateVisibility(camera: Camera) {
     const visibleChunks = this.findVisibleChunks(camera); // Finde alle sichtbaren Chunks
-
-    this.chunks.forEach(chunk => {
-      chunk.visible = false;
-      Array.from(chunk.units.values())
-        .filter(unit => !unit.modules.player.player?.client)
-        .forEach(unit => unit.setChunkVisible(false));
-    });
-
     const visibleUnits = new Set<Unit>();
-    visibleChunks.forEach(key => {
-      if (this.chunks.has(key)) {
-        const chunk = this.chunks.get(key)!;
+
+    Array.from(this.chunks.entries()).forEach(([key, chunk]) => {
+      if (visibleChunks.has(key)) {
         chunk.visible = true;
         chunk.units.forEach(unit => {
           unit.setChunkVisible(true);
           visibleUnits.add(unit);
         });
+      } else {
+        chunk.visible = false;
+        Array.from(chunk.units.values())
+          .filter(unit => !unit.modules.player.player?.client)
+          .forEach(unit => unit.setChunkVisible(false));
       }
     });
+
     return visibleUnits;
   }
 
@@ -112,7 +110,6 @@ export default class UnitChunkManager {
     frustum.setFromProjectionMatrix(projScreenMatrix);
 
     const visibleChunkKeys = new Set<string>();
-
     const allChunkPositions = this.getChunkPositions();
 
     for (const pos of allChunkPositions) {

packages/app/lib/classes/roomModule/Units.ts

@@ -1,16 +1,26 @@
-import type { Vector3, Camera } from 'three';
+import type { Vector3 } from 'three';
 import RoomModule, {
   type RoomModuleObservables,
   type RoomModuleState
 } from '../RoomModule';
 import type Unit from '../Unit';
 import UnitChunkManager from '../UnitChunkManager';
-import { Subject, concatMap, distinctUntilChanged, map } from 'rxjs';
+import {
+  EMPTY,
+  Subject,
+  concatMap,
+  debounceTime,
+  distinctUntilChanged,
+  map,
+  merge,
+  switchMap
+} from 'rxjs';
 import { ArrayKeyMap } from '../ArrayKeyMap';
 import type { AnimationLoopValue } from '../Renderer';
 import { FLOOR_HEIGHT } from '../../utils/ground';
 import type Room from '../Room';
 import type { ConditionDirectionsDescription } from '../../utils/pathfindng';
+import { getFloorRange } from '../../utils/floor';
 
 interface Observables extends RoomModuleObservables {
   addUnit$: Subject<Unit>;
@@ -68,6 +78,23 @@ export default class UnitsModule extends RoomModule<State, Observables> {
         )
         .subscribe(void 0)
     );
+
+    this.subscription.add(
+      merge(
+        this.room.app.renderer.observables.controlsChange$,
+        this.room.app.modules.player.observables.currentPlayer$.pipe(
+          switchMap(player => player?.observables.unit$ || EMPTY),
+          switchMap(({ unit }) => unit.observables.position$)
+        )
+      )
+        .pipe(debounceTime(20))
+        .subscribe(() => {
+          const units = this.chunkManager.updateVisibility(
+            this.room.app.renderer.camera
+          );
+          this.state.visibleUnits = Array.from(units);
+        })
+    );
   }
 
   //#region methods
@@ -162,27 +189,29 @@ export default class UnitsModule extends RoomModule<State, Observables> {
   }
 
   override update(v: AnimationLoopValue) {
-    this.state.visibleUnits.forEach(unit => {
-      unit.update(v);
-    });
+    this.state.visibleUnits.forEach(unit => unit.update(v));
   }
 
-  override updateThrottle(time: number, { camera }: { camera: Camera }) {
-    const units = this.chunkManager.updateVisibility(camera);
-    this.state.visibleUnits = Array.from(units);
-  }
+  // override updateThrottle(time: number, { camera }: { camera: Camera }) {
+  //   const units = this.chunkManager.updateVisibility(camera);
+  //   this.state.visibleUnits = Array.from(units);
+  // }
 
+  private _updateVisiblity_lastFloorIndex: number | null = null;
   updateVisiblity(
     floorIndex?: number,
     units: Unit[] = Array.from(this.state.units.values())
   ) {
-    units.forEach(unit => unit.setVisible(false));
     floorIndex = floorIndex ?? this.room.modules.floor.getFloor();
-    for (let f = 0; f <= floorIndex; f++) {
-      this.getUnitsByFloor(f).forEach(unit => unit.setVisible(true));
+
+    if (this._updateVisiblity_lastFloorIndex !== floorIndex) {
+      const floors = getFloorRange(floorIndex);
+      units.forEach(unit =>
+        unit.setVisible(floors.includes(Math.floor(unit.position.y)))
+      );
     }
+    this._updateVisiblity_lastFloorIndex = floorIndex;
   }
-
   //#endregion
 }
 

packages/app/lib/classes/unitModule/Movement.ts

@@ -182,20 +182,23 @@ export default class MovementUnitModule extends UnitModule<
       }
 
       return new Promise<{ position: Vector3 } | null>(resolve => {
-        const subscription = new Subscription();
-        subscription.add(
-          this.observables.moveAbort$.subscribe(() => {
-            resolve(null);
-            subscription.unsubscribe();
-          })
-        );
-        subscription.add(
-          this.observables.moveEnd$.subscribe(position => {
-            console.log('EEEEEEND');
-            resolve({ position });
-            subscription.unsubscribe();
-          })
-        );
+        if (this.movements.length) {
+          const subscription = new Subscription();
+          subscription.add(
+            this.observables.moveAbort$.subscribe(() => {
+              resolve(null);
+              subscription.unsubscribe();
+            })
+          );
+          subscription.add(
+            this.observables.moveEnd$.subscribe(position => {
+              resolve({ position });
+              subscription.unsubscribe();
+            })
+          );
+        } else {
+          resolve(null);
+        }
       });
     } else {
       console.warn(
@@ -219,6 +222,7 @@ export default class MovementUnitModule extends UnitModule<
 
     if (!this.currentMovement && this.lastMovement) {
       this.lastMovement = null;
+
       this.observables.moveEnd$.next(this.unit.getPosition());
     }
 

packages/app/lib/utils/floor.ts

@@ -3,3 +3,11 @@ import type { Vector3 } from 'three';
 export function getFloorFromPosition(position: Vector3) {
   return Math.floor(position.y);
 }
+
+export function getFloorRange(max: number, min = 0): number[] {
+  const range: number[] = [];
+  for (let i = min; i <= max; i++) {
+    range.push(i);
+  }
+  return range;
+}