Merge executed improvement plans

Author: JustMarkDev

.github/workflows/checks.yml

@@ -0,0 +1,34 @@
+name: Checks
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  checks:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v2
+
+      - name: Check Rust formatting
+        run: cargo fmt --check
+
+      - name: Test Rust
+        run: cargo test
+
+      - name: Install frontend dependencies
+        run: bun install --frozen-lockfile
+
+      - name: Check frontend
+        run: bun run check
+
+      - name: Audit frontend dependencies
+        run: bun audit

index.html

@@ -99,7 +99,9 @@ <h2>OPTIMIZATION PARAMS</h2>
 
             <div class="control-row">
               <div class="control-item">
-                <label for="param-sigma">Walking Radius: <span id="param-sigma-value">200m</span></label>
+                <label for="param-sigma"
+                  >Walking Radius: <span id="param-sigma-value">200m</span></label
+                >
                 <input id="param-sigma" type="range" min="50" max="1000" step="50" value="200" />
               </div>
             </div>

src/app.js

@@ -1,6 +1,8 @@
 // FICSIT Starting Position Optimizer
 // Web Dashboard Logic
 
+import { hasOptimizationObjective, nonZeroWeights, parseNodes, RESOURCES } from "./mapContracts.js";
+
 const LAND_MASK_SECTORS = 128;
 const LAND_MASK_BUFFER_CM = 22000;
 const MAP_PIXEL_TO_CM = 1 / 0.0013653321;
@@ -19,41 +21,6 @@ const PRESET_SIGMAS = {
   collectibles: 1000,
 };
 
-// Resource Registry and Stylings
-const RESOURCES = [
-  // Core Resources
-  { id: "iron", name: "Iron Ore", color: "#4682B4", category: "core" },
-  { id: "copper", name: "Copper Ore", color: "#B87333", category: "core" },
-  { id: "limestone", name: "Limestone", color: "#E5E5C0", category: "core" },
-  { id: "coal", name: "Coal", color: "#555555", category: "core" },
-  { id: "water", name: "Water (Static)", color: "#00BFFF", category: "core" },
-  { id: "oil", name: "Crude Oil", color: "#2E2E2E", category: "core" },
-  { id: "sulfur", name: "Sulfur", color: "#DAA520", category: "core" },
-  { id: "quartz", name: "Raw Quartz", color: "#FFD1DC", category: "core" },
-  { id: "caterium", name: "Caterium Ore", color: "#FFD700", category: "core" },
-  { id: "bauxite", name: "Bauxite", color: "#CD5C5C", category: "core" },
-  { id: "uranium", name: "Uranium", color: "#7FFF00", category: "core" },
-  { id: "sam", name: "SAM Ore", color: "#9370DB", category: "core" },
-  { id: "nitrogenwell", name: "Nitrogen Gas Well", color: "#48D1CC", category: "core" },
-  { id: "waterwell", name: "Water Well", color: "#1E90FF", category: "core" },
-  { id: "geyser", name: "Geyser", color: "#A9A9A9", category: "core" },
-
-  // Collectibles / Research
-  { id: "blueslug", name: "Blue Slug", color: "#00FFFF", category: "collectible" },
-  { id: "yellowslug", name: "Yellow Slug", color: "#FFFF00", category: "collectible" },
-  { id: "purpleslug", name: "Purple Slug", color: "#FF00FF", category: "collectible" },
-  { id: "mercer", name: "Mercer Sphere", color: "#FF7F50", category: "collectible" },
-  { id: "somersloop", name: "Somersloop", color: "#D1C4E9", category: "collectible" },
-  { id: "harddrive", name: "Hard Drive", color: "#CD7F32", category: "collectible" },
-  { id: "paleberry", name: "Paleberry", color: "#DB7093", category: "collectible" },
-  { id: "berylnut", name: "Berylnut", color: "#D2B48C", category: "collectible" },
-  { id: "baconagaric", name: "Bacon Agaric", color: "#BC8F8F", category: "collectible" },
-
-  // Threats
-  { id: "sporeflower", name: "Spore Flower", color: "#8B008B", category: "threat" },
-  { id: "gaspillar", name: "Gas Pillar", color: "#2E8B57", category: "threat" },
-];
-
 // App State
 const state = {
   rawNodes: [],
@@ -158,156 +125,6 @@ function computeBuildableLandPolygon(nodes) {
   });
 }
 
-// Parse Complete Map Data from Raw JSON format
-function parseNodes(data) {
-  const nodes = [];
-  const waterwellIndices = [];
-
-  if (data && data.options) {
-    data.options.forEach((category) => {
-      if (category.options) {
-        category.options.forEach((subcat) => {
-          if (subcat.options) {
-            subcat.options.forEach((item) => {
-              let resType = "";
-              const id = item.layerId;
-              if (id.startsWith("limestone")) resType = "limestone";
-              else if (id.startsWith("iron")) resType = "iron";
-              else if (id.startsWith("copper")) resType = "copper";
-              else if (id.startsWith("caterium")) resType = "caterium";
-              else if (id.startsWith("coal")) resType = "coal";
-              else if (id.startsWith("oilWell") || id.startsWith("oil")) resType = "oil";
-              else if (id.startsWith("sulfur")) resType = "sulfur";
-              else if (id.startsWith("bauxite")) resType = "bauxite";
-              else if (id.startsWith("quartz")) resType = "quartz";
-              else if (id.startsWith("uranium")) resType = "uranium";
-              else if (id.startsWith("sam")) resType = "sam";
-              else if (id.startsWith("nitrogen")) resType = "nitrogenwell";
-              else if (id.startsWith("water")) resType = "waterwell";
-              else if (id.startsWith("geyser")) resType = "geyser";
-              else if (id === "greenSlugs") resType = "blueslug";
-              else if (id === "yellowSlugs") resType = "yellowslug";
-              else if (id === "purpleSlugs") resType = "purpleslug";
-              else if (id === "mercerSpheres") resType = "mercer";
-              else if (id === "somersloops") resType = "somersloop";
-              else if (id === "hardDrives") resType = "harddrive";
-              else if (id === "paleBerry") resType = "paleberry";
-              else if (id === "berylNut") resType = "berylnut";
-              else if (id === "baconAgaric") resType = "baconagaric";
-              else if (id === "sporeFlowers") resType = "sporeflower";
-              else if (id === "pillars") resType = "gaspillar";
-
-              if (!resType) return;
-
-              if (item.markers) {
-                const addMarker = (marker) => {
-                  let rawType = marker.type || resType;
-                  let mType = resType;
-
-                  switch (rawType) {
-                    case "Desc_Stone_C":
-                      mType = "limestone";
-                      break;
-                    case "Desc_OreIron_C":
-                      mType = "iron";
-                      break;
-                    case "Desc_OreCopper_C":
-                      mType = "copper";
-                      break;
-                    case "Desc_OreGold_C":
-                      mType = "caterium";
-                      break;
-                    case "Desc_Coal_C":
-                      mType = "coal";
-                      break;
-                    case "Desc_LiquidOil_C":
-                      mType = "oil";
-                      break;
-                    case "Desc_Sulfur_C":
-                      mType = "sulfur";
-                      break;
-                    case "Desc_OreBauxite_C":
-                      mType = "bauxite";
-                      break;
-                    case "Desc_RawQuartz_C":
-                      mType = "quartz";
-                      break;
-                    case "Desc_OreUranium_C":
-                      mType = "uranium";
-                      break;
-                    case "Desc_SAM_C":
-                      mType = "sam";
-                      break;
-                    case "Desc_NitrogenGas_C":
-                      mType = "nitrogenwell";
-                      break;
-                    case "Desc_Water_C":
-                      mType = "waterwell";
-                      break;
-                    default:
-                      if (marker.pathName && marker.pathName.includes("BP_ResourceNodeGeyser")) {
-                        mType = "geyser";
-                      } else {
-                        mType = resType;
-                      }
-                      break;
-                  }
-
-                  if (mType.startsWith("water")) mType = "waterwell";
-                  if (mType.startsWith("nitrogen")) mType = "nitrogenwell";
-
-                  let purityStr = marker.purity || item.purity || "normal";
-                  let purityMultiplier = 1.0;
-                  if (purityStr.includes("pure") && !purityStr.includes("impure")) {
-                    purityMultiplier = 2.0;
-                  } else if (purityStr.includes("impure") || purityStr.includes("inpure")) {
-                    purityMultiplier = 0.5;
-                  }
-
-                  let obstructed = !!marker.obstructed;
-                  if (!obstructed && mType === "caterium") {
-                    const isStartingCaterium =
-                      Math.abs(marker.x - -220000.0) < 50000.0 &&
-                      Math.abs(marker.y - -150000.0) < 50000.0;
-                    if (!isStartingCaterium) obstructed = true;
-                  }
-
-                  const node = {
-                    resource_type: mType,
-                    x: parseFloat(marker.x),
-                    y: parseFloat(marker.y),
-                    z: parseFloat(marker.z || 0),
-                    purityMultiplier,
-                    purity: purityStr,
-                    obstructed,
-                  };
-
-                  nodes.push(node);
-
-                  if (mType === "waterwell") {
-                    waterwellIndices.push(nodes.length - 1);
-                  }
-                };
-
-                if (Array.isArray(item.markers)) {
-                  item.markers.forEach(addMarker);
-                } else if (typeof item.markers === "object" && item.markers !== null) {
-                  Object.keys(item.markers).forEach((k) => {
-                    addMarker(item.markers[k]);
-                  });
-                }
-              }
-            });
-          }
-        });
-      }
-    });
-  }
-
-  nodes.waterwellIndices = waterwellIndices;
-  return nodes;
-}
-
 // Distance to nearest water body helper.
 // NOTE: We only use static water body rectangles and water wells.
 // The old "coast edge" checks (x < -250000 → dist=0) were REMOVED because the map's
@@ -326,6 +143,14 @@ async function runGlobalOptimization() {
   els.mapLoading.classList.add("active");
 
   try {
+    const weights = nonZeroWeights(config.weights);
+    if (!hasOptimizationObjective(config.weights)) {
+      els.mapLoading.innerHTML = `<span style="color: #ff3333; font-weight: bold; font-size: 1.1rem; margin-bottom: 12px;">OPTIMIZATION FAILED: Select at least one weighted resource.</span>
+        <span style="font-size: 0.8rem; color: var(--color-text-muted);">Enable a resource slider or apply a phase preset, then try again.</span>`;
+      els.mapLoading.classList.add("active");
+      return;
+    }
+
     // Build the request body
     const reqBody = {
       utility_func: config.utilityFunc,
@@ -335,7 +160,7 @@ async function runGlobalOptimization() {
       game_phase: config.gamePhase,
       sigma: config.sigma,
       ignore_spawns: config.ignoreSpawns,
-      weights: Object.fromEntries(Object.entries(config.weights).filter(([_, v]) => v !== 0)),
+      weights,
     };
 
     const apiRes = await fetch("/api/optimize", {

src/data_loader.rs

@@ -183,3 +183,113 @@ pub fn load_nodes_from_file<P: AsRef<Path>>(
     file.read_to_string(&mut s)?;
     load_nodes_from_str(&s)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::models::Purity;
+
+    #[test]
+    fn parses_new_map_format_marker() {
+        let nodes = load_nodes_from_str(
+            r#"{
+                "options": [
+                    {
+                        "options": [
+                            {
+                                "options": [
+                                    {
+                                        "layerId": "ironNodes",
+                                        "markers": [
+                                            {
+                                                "type": "Desc_OreIron_C",
+                                                "x": 123.5,
+                                                "y": -456.25,
+                                                "z": 78.0,
+                                                "purity": "RP_Pure",
+                                                "obstructed": true
+                                            }
+                                        ]
+                                    }
+                                ]
+                            }
+                        ]
+                    }
+                ]
+            }"#,
+        )
+        .expect("new map format should parse");
+
+        assert_eq!(nodes.len(), 1);
+        assert_eq!(nodes[0].resource_type, "iron");
+        assert_eq!(nodes[0].purity, Purity::Pure);
+        assert_eq!(nodes[0].x, 123.5);
+        assert_eq!(nodes[0].y, -456.25);
+        assert_eq!(nodes[0].z, 78.0);
+        assert!(nodes[0].obstructed);
+    }
+
+    #[test]
+    fn parses_old_resource_node_array_format() {
+        let nodes = load_nodes_from_str(
+            r#"[
+                {
+                    "type": "copper",
+                    "purity": "normal",
+                    "x": 1.0,
+                    "y": 2.0,
+                    "z": 3.0,
+                    "obstructed": false
+                }
+            ]"#,
+        )
+        .expect("old node array format should parse");
+
+        assert_eq!(nodes.len(), 1);
+        assert_eq!(nodes[0].resource_type, "copper");
+        assert_eq!(nodes[0].purity, Purity::Normal);
+        assert_eq!(nodes[0].x, 1.0);
+        assert_eq!(nodes[0].y, 2.0);
+        assert_eq!(nodes[0].z, 3.0);
+        assert!(!nodes[0].obstructed);
+    }
+
+    #[test]
+    fn parses_engine_purity_tokens() {
+        let fixture = |purity: &str| {
+            format!(
+                r#"{{
+                    "options": [
+                        {{
+                            "options": [
+                                {{
+                                    "options": [
+                                        {{
+                                            "layerId": "limestoneNodes",
+                                            "markers": [
+                                                {{
+                                                    "type": "Desc_Stone_C",
+                                                    "x": 0.0,
+                                                    "y": 0.0,
+                                                    "purity": "{purity}"
+                                                }}
+                                            ]
+                                        }}
+                                    ]
+                                }}
+                            ]
+                        }}
+                    ]
+                }}"#
+            )
+        };
+
+        let impure = load_nodes_from_str(&fixture("RP_Inpure")).expect("impure token should parse");
+        let normal = load_nodes_from_str(&fixture("RP_Normal")).expect("normal token should parse");
+        let pure = load_nodes_from_str(&fixture("RP_Pure")).expect("pure token should parse");
+
+        assert_eq!(impure[0].purity, Purity::Impure);
+        assert_eq!(normal[0].purity, Purity::Normal);
+        assert_eq!(pure[0].purity, Purity::Pure);
+    }
+}