Thesis of @anonym-HPI

backend/src/exercise/exercise-wrapper.ts

@@ -215,8 +215,9 @@ export class ExerciseWrapper extends NormalType<
             type: '[Exercise] Tick',
             patientUpdates,
             /**
-             * refresh every {@link refreshTreatmentInterval} * {@link tickInterval} ms seconds
+             * Refresh every {@link refreshTreatmentInterval} * {@link tickInterval} ms seconds
              */
+            // TODO: Refactor this: do this in the reducer instead of sending it in the action
             refreshTreatments:
                 this.tickCounter % this.refreshTreatmentInterval === 0,
             tickInterval: this.tickInterval,

backend/src/exercise/patient-ticking.ts

@@ -2,49 +2,30 @@ import type {
     ExerciseState,
     HealthPoints,
     Patient,
+    PatientUpdate,
     PersonnelType,
-    UUID,
 } from 'digital-fuesim-manv-shared';
-import { healthPointsDefaults, isAlive } from 'digital-fuesim-manv-shared';
+import {
+    getElement,
+    healthPointsDefaults,
+    isAlive,
+} from 'digital-fuesim-manv-shared';
 
 /**
  * The count of assigned personnel and material that cater for a {@link Patient}.
  */
 type Catering = { [key in PersonnelType | 'material']: number };
 
-interface PatientTickResult {
-    /**
-     * The id of the patient
-     */
-    id: UUID;
-    /**
-     * The new {@link HealthPoints} the patient should have
-     */
-    nextHealthPoints: HealthPoints;
-    /**
-     * The next {@link PatientHealthState} the patient should be in
-     */
-    nextStateId: UUID;
-    /**
-     * The new state time of the patient
-     */
-    nextStateTime: number;
-    /**
-     * The time a patient was treated overall
-     */
-    treatmentTime: number;
-}
-
 /**
  * Apply the patient tick to the {@link state}
  * @param state The {@link ExerciseState} the patient tick should be applied on later
  * @param patientTickInterval The interval in ms between calls to this function
- * @returns An array of {@link PatientTickResult}s to apply to the {@link state} in a reducer
+ * @returns An array of {@link PatientUpdate}s to apply to the {@link state} in a reducer
  */
 export function patientTick(
     state: ExerciseState,
     patientTickInterval: number
-): PatientTickResult[] {
+): PatientUpdate[] {
     return (
         Object.values(state.patients)
             // Only look at patients that are alive and have a position, i.e. are not in a vehicle
@@ -86,43 +67,30 @@ function getDedicatedResources(
     state: ExerciseState,
     patient: Patient
 ): Catering {
+    const cateringTypes: Catering = {
+        notarzt: 0,
+        notSan: 0,
+        rettSan: 0,
+        san: 0,
+        gf: 0,
+        material: 0,
+    };
+
     if (!patient.isBeingTreated) {
-        return {
-            gf: 0,
-            material: 0,
-            notarzt: 0,
-            notSan: 0,
-            rettSan: 0,
-            san: 0,
-        };
+        return cateringTypes;
     }
-    const material = Object.values(state.materials).filter((thisMaterial) =>
-        Object.keys(thisMaterial.assignedPatientIds).includes(patient.id)
-    ).length;
-    const treatingPersonnel = Object.values(state.personnel).filter(
-        (thisPersonnel) =>
-            Object.keys(thisPersonnel.assignedPatientIds).includes(patient.id)
+
+    cateringTypes.material = Object.keys(patient.assignedMaterialIds).length;
+
+    // Get the number of every personnel
+    Object.keys(patient.assignedPersonnelIds).forEach(
+        (personnelId) =>
+            cateringTypes[
+                getElement(state, 'personnel', personnelId).personnelType
+            ]++
     );
-    const notarzt = treatingPersonnel.filter(
-        (thisPersonnel) => thisPersonnel.personnelType === 'notarzt'
-    ).length;
-    const notSan = treatingPersonnel.filter(
-        (thisPersonnel) => thisPersonnel.personnelType === 'notSan'
-    ).length;
-    const rettSan = treatingPersonnel.filter(
-        (thisPersonnel) => thisPersonnel.personnelType === 'rettSan'
-    ).length;
-    const san = treatingPersonnel.filter(
-        (thisPersonnel) => thisPersonnel.personnelType === 'san'
-    ).length;
-    return {
-        gf: 0,
-        material,
-        notarzt,
-        notSan,
-        rettSan,
-        san,
-    };
+
+    return cateringTypes;
 }
 
 /**
@@ -143,7 +111,7 @@ function getNextPatientHealthPoints(
     const notarzt = treatedBy.notarzt;
     const notSan = treatedBy.notSan;
     const rettSan = treatedBy.rettSan;
-    // TODO: Sans should be able to treat patients too
+    // TODO: Sans should be able to treat patients too.
     const functionParameters =
         patient.healthStates[patient.currentHealthStateId]!.functionParameters;
     // To do anything the personnel needs material

frontend/src/app/pages/exercises/exercise/shared/exercise-map/feature-managers/catering-lines-feature-manager.ts

@@ -4,6 +4,7 @@ import LineString from 'ol/geom/LineString';
 import type { TranslateEvent } from 'ol/interaction/Translate';
 import type VectorLayer from 'ol/layer/Vector';
 import type VectorSource from 'ol/source/Vector';
+import { rgbColorPalette } from 'src/app/shared/functions/colors';
 import type { CateringLine } from 'src/app/shared/types/catering-line';
 import type { FeatureManager } from '../utility/feature-manager';
 import { LineStyleHelper } from '../utility/style-helper/line-style-helper';
@@ -18,14 +19,20 @@ export class CateringLinesFeatureManager
     >
     implements FeatureManager<Feature<LineString>>
 {
+    readonly type = 'cateringLines';
     readonly unsupportedChangeProperties = new Set(['id'] as const);
 
-    private readonly lineStyleHelper = new LineStyleHelper(0.1, '#0dcaf0');
+    private readonly lineStyleHelper = new LineStyleHelper(
+        (feature) => ({
+            color: rgbColorPalette.cyan,
+        }),
+        0.05
+    );
 
     constructor(public readonly layer: VectorLayer<VectorSource<LineString>>) {
         super();
-        layer.setStyle((thisFeature, currentZoom) =>
-            this.lineStyleHelper.getStyle(thisFeature as Feature, currentZoom)
+        layer.setStyle((feature, currentZoom) =>
+            this.lineStyleHelper.getStyle(feature as Feature, currentZoom)
         );
     }
 

frontend/src/app/pages/exercises/exercise/shared/exercise-map/feature-managers/element-feature-manager.ts

@@ -1,24 +1,26 @@
-import type { UUID, Position, Size } from 'digital-fuesim-manv-shared';
+import type {
+    ExerciseState,
+    Position,
+    Size,
+    UUID,
+} from 'digital-fuesim-manv-shared';
+import { isArray } from 'lodash-es';
 import type { MapBrowserEvent } from 'ol';
 import { Feature } from 'ol';
+import type { Coordinate } from 'ol/coordinate';
+import { LineString } from 'ol/geom';
 import Point from 'ol/geom/Point';
+import type { TranslateEvent } from 'ol/interaction/Translate';
 import type VectorLayer from 'ol/layer/Vector';
-import type VectorSource from 'ol/source/Vector';
 import type OlMap from 'ol/Map';
-import type { AppState } from 'src/app/state/app.state';
-import type { Store } from '@ngrx/store';
-import { getStateSnapshot } from 'src/app/state/get-state-snapshot';
-import type { TranslateEvent } from 'ol/interaction/Translate';
-import { LineString } from 'ol/geom';
-import { isArray } from 'lodash-es';
-import type { Coordinate } from 'ol/coordinate';
+import type VectorSource from 'ol/source/Vector';
 import { Subject } from 'rxjs';
+import type { WithPosition } from '../../utility/types/with-position';
+import type { FeatureManager } from '../utility/feature-manager';
 import type { Coordinates } from '../utility/movement-animator';
 import { MovementAnimator } from '../utility/movement-animator';
-import { TranslateHelper } from '../utility/translate-helper';
-import type { FeatureManager } from '../utility/feature-manager';
-import type { WithPosition } from '../../utility/types/with-position';
 import type { OpenPopupOptions } from '../utility/popup-manager';
+import { TranslateHelper } from '../utility/translate-helper';
 import { ElementManager } from './element-manager';
 
 export interface PositionableElement {
@@ -81,6 +83,7 @@ export abstract class ElementFeatureManager<
     >
     implements FeatureManager<ElementFeature>
 {
+    abstract override readonly type: keyof ExerciseState;
     public readonly togglePopup$ = new Subject<OpenPopupOptions<any>>();
     protected readonly movementAnimator = new MovementAnimator<FeatureType>(
         this.olMap,
@@ -89,7 +92,6 @@ export abstract class ElementFeatureManager<
     protected readonly translateHelper = new TranslateHelper<FeatureType>();
 
     constructor(
-        protected readonly store: Store<AppState>,
         protected readonly olMap: OlMap,
         public readonly layer: VectorLayer<VectorSource<FeatureType>>,
         private readonly proposeMovementAction: (
@@ -154,55 +156,6 @@ export abstract class ElementFeatureManager<
         );
     }
 
-    protected getElementFromFeature(feature: Feature<any>) {
-        const id = feature.getId() as UUID;
-        const exerciseState = getStateSnapshot(this.store).exercise;
-        // We expect the id to be globally unique
-        if (exerciseState.materials[id]) {
-            return {
-                type: 'material',
-                value: exerciseState.materials[id] as unknown as Element,
-            } as const;
-        }
-        if (exerciseState.patients[id]) {
-            return {
-                type: 'patient',
-                value: exerciseState.patients[id] as unknown as Element,
-            } as const;
-        }
-        if (exerciseState.vehicles[id]) {
-            return {
-                type: 'vehicle',
-                value: exerciseState.vehicles[id] as unknown as Element,
-            } as const;
-        }
-        if (exerciseState.personnel[id]) {
-            return {
-                type: 'personnel',
-                value: exerciseState.personnel[id] as unknown as Element,
-            } as const;
-        }
-        if (exerciseState.mapImages[id]) {
-            return {
-                type: 'image',
-                value: exerciseState.mapImages[id] as unknown as Element,
-            } as const;
-        }
-        if (exerciseState.viewports[id]) {
-            return {
-                type: 'viewport',
-                value: exerciseState.viewports[id] as unknown as Element,
-            } as const;
-        }
-        if (exerciseState.transferPoints[id]) {
-            return {
-                type: 'transferPoint',
-                value: exerciseState.transferPoints[id] as unknown as Element,
-            } as const;
-        }
-        return undefined;
-    }
-
     public getCenter(feature: ElementFeature): Coordinate {
         const coordinates = feature.getGeometry()!.getCoordinates();
         if (!isCoordinateArray(coordinates)) {