Minor refactor and bug fixing

2025-10-29 16:56:34 +00:00 · 2023-09-08 22:41:37 +02:00
parent 89c39c7038
commit 74d5480587
59 changed files with 174 additions and 2392 deletions
--- a/client/src/unit/databases/aircraftdatabase.ts
+++ b/client/src/unit/databases/aircraftdatabase.ts
@@ -0,0 +1,37 @@
+import { getMissionHandler } from "../..";
+import { GAME_MASTER } from "../../constants/constants";
+import { UnitDatabase } from "./unitdatabase"
+
+export class AircraftDatabase extends UnitDatabase {
+    constructor() {
+        super('databases/units/aircraftdatabase.json');
+    }
+
+	getCategory() {
+		return "Aircraft";
+    }
+
+    getSpawnPointsByName(name: string) {
+        if (getMissionHandler().getCommandModeOptions().commandMode == GAME_MASTER || !getMissionHandler().getCommandModeOptions().restrictSpawns) 
+            return 0;
+
+        const blueprint = this.getByName(name);
+        if (blueprint?.cost != undefined)
+            return blueprint?.cost; 
+            
+        if (blueprint?.era == "WW2")
+            return 20;
+        else if (blueprint?.era == "Early Cold War")
+            return 50;
+        else if (blueprint?.era == "Mid Cold War")
+            return 100;
+        else if (blueprint?.era == "Late Cold War")
+            return 200;
+        else if (blueprint?.era == "Modern")
+            return 400;
+        return 0;
+    }
+}
+
+export var aircraftDatabase = new AircraftDatabase();
+
--- a/client/src/unit/databases/groundunitdatabase.ts
+++ b/client/src/unit/databases/groundunitdatabase.ts
@@ -0,0 +1,36 @@
+import { getMissionHandler } from "../..";
+import { GAME_MASTER } from "../../constants/constants";
+import { UnitDatabase } from "./unitdatabase"
+
+export class GroundUnitDatabase extends UnitDatabase {
+    constructor() {
+        super('databases/units/groundunitdatabase.json');
+    }
+
+    getSpawnPointsByName(name: string) {
+        if (getMissionHandler().getCommandModeOptions().commandMode == GAME_MASTER || !getMissionHandler().getCommandModeOptions().restrictSpawns) 
+            return 0;
+
+        const blueprint = this.getByName(name);
+        if (blueprint?.cost != undefined)
+            return blueprint?.cost; 
+            
+        if (blueprint?.era == "WW2")
+            return 20;
+        else if (blueprint?.era == "Early Cold War")
+            return 50;
+        else if (blueprint?.era == "Mid Cold War")
+            return 100;
+        else if (blueprint?.era == "Late Cold War")
+            return 200;
+        else if (blueprint?.era == "Modern")
+            return 400;
+        return 0;
+    }
+
+    getCategory() {
+        return "GroundUnit";
+    }
+}
+
+export var groundUnitDatabase = new GroundUnitDatabase();
--- a/client/src/unit/databases/helicopterdatabase.ts
+++ b/client/src/unit/databases/helicopterdatabase.ts
@@ -0,0 +1,37 @@
+import { getMissionHandler } from "../..";
+import { GAME_MASTER } from "../../constants/constants";
+import { UnitDatabase } from "./unitdatabase"
+
+export class HelicopterDatabase extends UnitDatabase {
+    constructor() {
+        super('databases/units/helicopterdatabase.json');
+    }
+
+    getSpawnPointsByName(name: string) {
+        if (getMissionHandler().getCommandModeOptions().commandMode == GAME_MASTER || !getMissionHandler().getCommandModeOptions().restrictSpawns) 
+            return 0;
+
+        const blueprint = this.getByName(name);
+        if (blueprint?.cost != undefined)
+            return blueprint?.cost; 
+            
+        if (blueprint?.era == "WW2")
+            return 20;
+        else if (blueprint?.era == "Early Cold War")
+            return 50;
+        else if (blueprint?.era == "Mid Cold War")
+            return 100;
+        else if (blueprint?.era == "Late Cold War")
+            return 200;
+        else if (blueprint?.era == "Modern")
+            return 400;
+        return 0;
+    }
+
+	getCategory() {
+		return "Helicopter";
+	}
+}
+
+export var helicopterDatabase = new HelicopterDatabase();
+
--- a/client/src/unit/databases/navyunitdatabase.ts
+++ b/client/src/unit/databases/navyunitdatabase.ts
@@ -0,0 +1,36 @@
+import { getMissionHandler } from "../..";
+import { GAME_MASTER } from "../../constants/constants";
+import { UnitDatabase } from "./unitdatabase"
+
+export class NavyUnitDatabase extends UnitDatabase {
+    constructor() {
+        super('databases/units/navyunitdatabase.json');
+    }
+
+    getSpawnPointsByName(name: string) {
+        if (getMissionHandler().getCommandModeOptions().commandMode == GAME_MASTER || !getMissionHandler().getCommandModeOptions().restrictSpawns)  
+            return 0;
+
+        const blueprint = this.getByName(name);
+        if (blueprint?.cost != undefined)
+            return blueprint?.cost; 
+            
+        if (blueprint?.era == "WW2")
+            return 20;
+        else if (blueprint?.era == "Early Cold War")
+            return 50;
+        else if (blueprint?.era == "Mid Cold War")
+            return 100;
+        else if (blueprint?.era == "Late Cold War")
+            return 200;
+        else if (blueprint?.era == "Modern")
+            return 400;
+        return 0;
+    }
+
+    getCategory() {
+        return "NavyUnit";
+    }
+}
+
+export var navyUnitDatabase = new NavyUnitDatabase();
--- a/client/src/unit/databases/unitdatabase.ts
+++ b/client/src/unit/databases/unitdatabase.ts
@@ -0,0 +1,219 @@
+import { LatLng } from "leaflet";
+import { getMissionHandler, getUnitsManager } from "../..";
+import { GAME_MASTER } from "../../constants/constants";
+import { UnitBlueprint } from "../../@types/unitdatabase";
+
+export class UnitDatabase {
+    blueprints: { [key: string]: UnitBlueprint } = {};
+
+    constructor(url: string = "") {
+        if (url !== "") {
+            var xhr = new XMLHttpRequest();
+            xhr.open('GET', url, true);
+            xhr.responseType = 'json';
+            xhr.onload = () => {
+            var status = xhr.status;
+                if (status === 200) {
+                    this.blueprints = xhr.response;
+                } else {
+                    console.error(`Error retrieving database from ${url}`)
+                }
+            };
+            xhr.send();
+        }
+    }
+
+    getCategory() {
+        return "";
+    }
+
+    /* Gets a specific blueprint by name */
+    getByName(name: string) {
+        if (name in this.blueprints)
+            return this.blueprints[name];
+        return null;
+    }
+
+    /* Gets a specific blueprint by label */
+    getByLabel(label: string) {
+        for (let unit in this.blueprints) {
+            if (this.blueprints[unit].label === label)
+                return this.blueprints[unit];
+        }
+        return null;
+    }
+
+    getBlueprints() {
+        if (getMissionHandler().getCommandModeOptions().commandMode == GAME_MASTER || !getMissionHandler().getCommandModeOptions().restrictSpawns)
+            return this.blueprints;
+        else {
+            var filteredBlueprints: { [key: string]: UnitBlueprint } = {};
+            for (let unit in this.blueprints) {
+                const blueprint = this.blueprints[unit];
+                if (this.getSpawnPointsByName(blueprint.name) <= getMissionHandler().getAvailableSpawnPoints() && 
+                    getMissionHandler().getCommandModeOptions().eras.includes(blueprint.era) &&
+                    (!getMissionHandler().getCommandModeOptions().restrictToCoalition || blueprint.coalition === getMissionHandler().getCommandedCoalition() || blueprint.coalition === undefined)) {
+                    filteredBlueprints[unit] = blueprint;
+                }
+            }
+            return filteredBlueprints;
+        }
+    }
+
+    /* Returns a list of all possible roles in a database */
+    getRoles() {
+        var roles: string[] = [];
+        var filteredBlueprints = this.getBlueprints();
+        for (let unit in filteredBlueprints) {
+            var loadouts = filteredBlueprints[unit].loadouts;
+            if (loadouts) {
+                for (let loadout of loadouts) {
+                    for (let role of loadout.roles) {
+                        if (role !== "" && !roles.includes(role))
+                            roles.push(role);
+                    }
+                }
+            }
+        }
+        return roles;
+    }
+
+    /* Returns a list of all possible types in a database */
+    getTypes() {
+        var filteredBlueprints = this.getBlueprints();
+        var types: string[] = [];
+        for (let unit in filteredBlueprints) {
+            var type = filteredBlueprints[unit].type;
+            if (type && type !== "" && !types.includes(type))
+                types.push(type);
+        }
+        return types;
+    }
+
+    /* Returns a list of all possible periods in a database */
+    getEras() {
+        var filteredBlueprints = this.getBlueprints();
+        var eras: string[] = [];
+        for (let unit in filteredBlueprints) {
+            var era = filteredBlueprints[unit].era;
+            if (era && era !== "" && !eras.includes(era))
+                eras.push(era);
+        }
+        return eras;
+    }
+
+    /* Returns a list of all possible ranges in a database */
+    getRanges() {
+        var filteredBlueprints = this.getBlueprints();
+        var ranges: string[] = [];
+        for (let unit in filteredBlueprints) {
+            var range = filteredBlueprints[unit].range;
+            if (range && range !== "" && !ranges.includes(range))
+                ranges.push(range);
+        }
+        return ranges;
+    }
+
+    /* Get all blueprints by range */
+    getByRange(range: string) {
+        var filteredBlueprints = this.getBlueprints();
+        var unitswithrange = [];
+        for (let unit in filteredBlueprints) {
+            if (filteredBlueprints[unit].range === range) {
+                unitswithrange.push(filteredBlueprints[unit]);
+            }
+        }
+        return unitswithrange;
+    }
+
+    /* Get all blueprints by type */
+    getByType(type: string) {
+        var filteredBlueprints = this.getBlueprints();
+        var units = [];
+        for (let unit in filteredBlueprints) {
+            if (filteredBlueprints[unit].type === type) {
+                units.push(filteredBlueprints[unit]);
+            }
+        }
+        return units;
+    }
+
+    /* Get all blueprints by role */
+    getByRole(role: string) {
+        var filteredBlueprints = this.getBlueprints();
+        var units = [];
+        for (let unit in filteredBlueprints) {
+            var loadouts = filteredBlueprints[unit].loadouts;
+            if (loadouts) {
+                for (let loadout of loadouts) {
+                    if (loadout.roles.includes(role) || loadout.roles.includes(role.toLowerCase())) {
+                        units.push(filteredBlueprints[unit])
+                        break;
+                    }
+                }
+            }
+        }
+        return units;
+    }
+
+    /* Get the names of all the loadouts for a specific unit and for a specific role */
+    getLoadoutNamesByRole(name: string, role: string) {
+        var filteredBlueprints = this.getBlueprints();
+        var loadoutsByRole = [];
+        var loadouts = filteredBlueprints[name].loadouts;
+        if (loadouts) {
+            for (let loadout of loadouts) {
+                if (loadout.roles.includes(role) || loadout.roles.includes("")) {
+                    loadoutsByRole.push(loadout.name)
+                }
+            }
+        }
+        return loadoutsByRole;
+    }
+
+    /* Get the livery names for a specific unit */
+    getLiveryNamesByName(name: string) {
+        var liveries = this.blueprints[name].liveries;
+        if (liveries !== undefined)
+            return Object.values(liveries);
+        else
+            return [];
+    }
+
+    /* Get the loadout content from the unit name and loadout name */
+    getLoadoutByName(name: string, loadoutName: string) {
+        var loadouts = this.blueprints[name].loadouts;
+        if (loadouts) {
+            for (let loadout of loadouts) {
+                if (loadout.name === loadoutName)
+                    return loadout;
+            }
+        }
+        return null;
+    }
+
+    generateTestGrid(initialPosition: LatLng) {
+        var filteredBlueprints = this.getBlueprints();
+        const step = 0.01;
+        var nUnits = Object.values(filteredBlueprints).length;
+        var gridSize = Math.ceil(Math.sqrt(nUnits));
+        Object.values(filteredBlueprints).forEach((unitBlueprint: UnitBlueprint, idx: number) => {
+            var row = Math.floor(idx / gridSize);
+            var col = idx - row * gridSize;
+            var location = new LatLng(initialPosition.lat + col * step, initialPosition.lng + row * step)
+            getUnitsManager().spawnUnits(this.getCategory(), [{unitType: unitBlueprint.name, location: location, altitude: 1000, loadout: ""}]);
+        })
+    }
+
+    getSpawnPointsByLabel(label: string) {
+        var blueprint = this.getByLabel(label);
+        if (blueprint)
+            return this.getSpawnPointsByName(blueprint.name);
+        else
+            return Infinity;
+    }
+
+    getSpawnPointsByName(name: string) {
+        return Infinity;
+    }
+}