Unify preset configs

JustMarkDev · JustMarkDev · commit a3fd89557ef7 · 2026-06-14T21:43:26.000+02:00
diff --git a/src/app.js b/src/app.js
@@ -12,15 +12,6 @@ let PRESETS = {};
 let PRESETS_RAW = [];
 let buildableLandPolygon = [];
 
-const PRESET_SIGMAS = {
-  phase1: 200,
-  phase2: 300,
-  phase3: 400,
-  phase4: 600,
-  phase5: 800,
-  collectibles: 1000,
-};
-
 // App State
 const state = {
   rawNodes: [],
@@ -636,12 +627,13 @@ function applyPhasePreset(phaseId) {
   if (rawPreset) {
     state.config.ignoreSpawns = rawPreset.ignore_spawns;
     els.paramIgnoreSpawns.value = rawPreset.ignore_spawns ? "true" : "false";
+    setWalkingRadius(rawPreset.sigma);
   } else {
     // Fallbacks just in case
     state.config.ignoreSpawns = false;
     els.paramIgnoreSpawns.value = "false";
+    setWalkingRadius(200);
   }
-  setWalkingRadius(PRESET_SIGMAS[phaseId] ?? rawPreset?.sigma ?? 200);
 
   // Redraw weight sliders UI
   renderWeightSliders();
diff --git a/src/main.rs b/src/main.rs
@@ -3,34 +3,23 @@ mod models;
 mod optimizer;
 mod server;
 
-use models::{GamePhase, OptimizerConfig, PurityOverride};
+use models::{OptimizerConfig, PurityOverride};
 use std::collections::HashMap;
 use std::env;
 
 fn apply_preset_weights(preset_idx: usize, weights: &mut HashMap<String, f64>) {
-    weights.clear();
-    match preset_idx {
-        0 => models::GamePhase::Phase1.apply_weights(weights),
-        1 => models::GamePhase::Phase2.apply_weights(weights),
-        2 => models::GamePhase::Phase3.apply_weights(weights),
-        3 => models::GamePhase::Phase4.apply_weights(weights),
-        4 => models::GamePhase::Phase5.apply_weights(weights),
-        5 => apply_collectibles_weights(weights),
-        _ => {}
+    if let Some(preset) = models::all_presets().get(preset_idx) {
+        *weights = preset.build_weights();
     }
 }
 
-fn apply_collectibles_weights(weights: &mut HashMap<String, f64>) {
-    weights.clear();
-    weights.insert("blueslug".to_string(), 0.3);
-    weights.insert("yellowslug".to_string(), 0.8);
-    weights.insert("purpleslug".to_string(), 1.2);
-    weights.insert("mercer".to_string(), 1.0);
-    weights.insert("somersloop".to_string(), 1.0);
-    weights.insert("harddrive".to_string(), 1.5);
-    weights.insert("paleberry".to_string(), 0.0);
-    weights.insert("berylnut".to_string(), 0.0);
-    weights.insert("baconagaric".to_string(), 0.0);
+fn apply_preset_argument(input: &str, config: &mut OptimizerConfig) -> bool {
+    if let Some(preset) = models::preset_by_id_or_phase(input) {
+        models::apply_preset_to_config(preset, config);
+        true
+    } else {
+        false
+    }
 }
 
 fn print_help() {
@@ -80,7 +69,9 @@ fn main() {
 
     let mut custom_file_path: Option<String> = None;
     let mut config = OptimizerConfig::default();
-    GamePhase::Phase1.apply_weights(&mut config.weights);
+    if let Some(preset) = models::preset_by_id_or_phase("phase1") {
+        models::apply_preset_to_config(preset, &mut config);
+    }
 
     let mut output_json = false;
     let mut run_simulation = false;
@@ -197,10 +188,7 @@ fn main() {
             "--tier" | "--phase" => {
                 if i + 1 < args.len() {
                     let phase_str = &args[i + 1];
-                    if let Some(phase) = GamePhase::from_str(phase_str) {
-                        phase.apply_weights(&mut config.weights);
-                        config.game_phase = phase;
-                    } else {
+                    if !apply_preset_argument(phase_str, &mut config) {
                         eprintln!("Error: Invalid phase/tier value '{}'.", phase_str);
                         return;
                     }
@@ -211,8 +199,7 @@ fn main() {
                 }
             }
             "--collectibles" => {
-                apply_collectibles_weights(&mut config.weights);
-                config.game_phase = GamePhase::Phase5;
+                apply_preset_argument("collectibles", &mut config);
                 i += 1;
             }
             "--ignore-spawns" | "--ignore-starting-areas" => {
@@ -312,7 +299,7 @@ fn run_full_simulation_matrix(nodes: &[models::ResourceNode]) {
     }
 
     let mut sim_configs = Vec::new();
-    let presets = 0..6;
+    let presets = 0..models::all_presets().len();
     let purities = [
         PurityOverride::Default,
         PurityOverride::Normal,
@@ -330,18 +317,18 @@ fn run_full_simulation_matrix(nodes: &[models::ResourceNode]) {
         models::DistanceDecay::Linear,
         models::DistanceDecay::LogisticStep,
     ];
-    let sigma = 700.0;
 
     for preset_idx in presets {
         for &purity in &purities {
             for &utility in &utilities {
                 for &decay in &decays {
+                    let preset = models::all_presets()[preset_idx];
                     sim_configs.push(SimConfig {
                         preset_idx,
                         purity,
                         utility,
                         decay,
-                        sigma,
+                        sigma: preset.sigma,
                     });
                 }
             }
@@ -355,21 +342,15 @@ fn run_full_simulation_matrix(nodes: &[models::ResourceNode]) {
     let results: Vec<(SimConfig, optimizer::OptimizationResult)> = sim_configs
         .into_iter()
         .map(|config| {
+            let preset = models::all_presets()[config.preset_idx];
             let mut opt_config = OptimizerConfig {
                 sigma: config.sigma,
                 weights: HashMap::new(),
                 purity_override: config.purity,
                 strategy: models::SearchStrategy::Hybrid,
                 utility_func: config.utility,
                 decay_func: config.decay,
-                game_phase: match config.preset_idx {
-                    0 => models::GamePhase::Phase1,
-                    1 => models::GamePhase::Phase2,
-                    2 => models::GamePhase::Phase3,
-                    3 => models::GamePhase::Phase4,
-                    4 => models::GamePhase::Phase5,
-                    _ => models::GamePhase::Phase1,
-                },
+                game_phase: preset.phase,
                 ignore_spawns: true,
             };
             apply_preset_weights(config.preset_idx, &mut opt_config.weights);
@@ -425,3 +406,32 @@ fn run_full_simulation_matrix(nodes: &[models::ResourceNode]) {
         csv_path
     );
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn cli_phase_preset_application_sets_radius_and_spawn_behavior() {
+        let mut phase1_config = OptimizerConfig::default();
+        assert!(apply_preset_argument("phase1", &mut phase1_config));
+        assert_eq!(phase1_config.sigma, 200.0);
+        assert!(!phase1_config.ignore_spawns);
+
+        let mut phase4_config = OptimizerConfig::default();
+        assert!(apply_preset_argument("phase4", &mut phase4_config));
+        assert_eq!(phase4_config.sigma, 600.0);
+        assert!(phase4_config.ignore_spawns);
+    }
+
+    #[test]
+    fn cli_collectibles_preset_application_uses_shared_weights() {
+        let mut config = OptimizerConfig::default();
+        assert!(apply_preset_argument("collectibles", &mut config));
+
+        assert_eq!(config.sigma, 1000.0);
+        assert!(config.ignore_spawns);
+        assert_eq!(config.weights.get("blueslug").copied(), Some(0.3));
+        assert_eq!(config.weights.get("harddrive").copied(), Some(1.5));
+    }
+}
diff --git a/src/models.rs b/src/models.rs
@@ -214,6 +214,131 @@ impl GamePhase {
     }
 }
 
+#[derive(Debug, Clone, Copy)]
+pub struct PresetDescriptor {
+    pub id: &'static str,
+    pub name: &'static str,
+    pub phase: GamePhase,
+    pub sigma: f64,
+    pub ignore_spawns: bool,
+    weight_builder: fn(&mut HashMap<String, f64>),
+}
+
+impl PresetDescriptor {
+    pub fn build_weights(self) -> HashMap<String, f64> {
+        let mut weights = HashMap::new();
+        (self.weight_builder)(&mut weights);
+        weights
+    }
+}
+
+fn apply_phase1_weights(weights: &mut HashMap<String, f64>) {
+    GamePhase::Phase1.apply_weights(weights);
+}
+
+fn apply_phase2_weights(weights: &mut HashMap<String, f64>) {
+    GamePhase::Phase2.apply_weights(weights);
+}
+
+fn apply_phase3_weights(weights: &mut HashMap<String, f64>) {
+    GamePhase::Phase3.apply_weights(weights);
+}
+
+fn apply_phase4_weights(weights: &mut HashMap<String, f64>) {
+    GamePhase::Phase4.apply_weights(weights);
+}
+
+fn apply_phase5_weights(weights: &mut HashMap<String, f64>) {
+    GamePhase::Phase5.apply_weights(weights);
+}
+
+pub fn apply_collectibles_weights(weights: &mut HashMap<String, f64>) {
+    weights.clear();
+    weights.insert("blueslug".to_string(), 0.3);
+    weights.insert("yellowslug".to_string(), 0.8);
+    weights.insert("purpleslug".to_string(), 1.2);
+    weights.insert("mercer".to_string(), 1.0);
+    weights.insert("somersloop".to_string(), 1.0);
+    weights.insert("harddrive".to_string(), 1.5);
+    weights.insert("paleberry".to_string(), 0.0);
+    weights.insert("berylnut".to_string(), 0.0);
+    weights.insert("baconagaric".to_string(), 0.0);
+}
+
+pub static PRESET_DESCRIPTORS: &[PresetDescriptor] = &[
+    PresetDescriptor {
+        id: "phase1",
+        name: "Phase 1 — Early Game (Tiers 1-2)",
+        phase: GamePhase::Phase1,
+        sigma: 200.0,
+        ignore_spawns: false,
+        weight_builder: apply_phase1_weights,
+    },
+    PresetDescriptor {
+        id: "phase2",
+        name: "Phase 2 — Steel & Coal (Tiers 3-4)",
+        phase: GamePhase::Phase2,
+        sigma: 300.0,
+        ignore_spawns: false,
+        weight_builder: apply_phase2_weights,
+    },
+    PresetDescriptor {
+        id: "phase3",
+        name: "Phase 3 — Oil & Quartz (Tiers 5-6)",
+        phase: GamePhase::Phase3,
+        sigma: 400.0,
+        ignore_spawns: false,
+        weight_builder: apply_phase3_weights,
+    },
+    PresetDescriptor {
+        id: "phase4",
+        name: "Phase 4 — Aluminum & Nuclear (Tiers 7-8)",
+        phase: GamePhase::Phase4,
+        sigma: 600.0,
+        ignore_spawns: true,
+        weight_builder: apply_phase4_weights,
+    },
+    PresetDescriptor {
+        id: "phase5",
+        name: "Phase 5 — Quantum (Tier 9)",
+        phase: GamePhase::Phase5,
+        sigma: 800.0,
+        ignore_spawns: true,
+        weight_builder: apply_phase5_weights,
+    },
+    PresetDescriptor {
+        id: "collectibles",
+        name: "Collectibles — Slugs, Artifacts & Hard Drives",
+        phase: GamePhase::Phase5,
+        sigma: 1000.0,
+        ignore_spawns: true,
+        weight_builder: apply_collectibles_weights,
+    },
+];
+
+pub fn all_presets() -> &'static [PresetDescriptor] {
+    PRESET_DESCRIPTORS
+}
+
+pub fn preset_by_id_or_phase(input: &str) -> Option<&'static PresetDescriptor> {
+    let input = input.to_lowercase();
+    all_presets()
+        .iter()
+        .find(|preset| preset.id == input.as_str())
+        .or_else(|| GamePhase::from_str(&input).and_then(preset_by_phase))
+}
+
+pub fn preset_by_phase(phase: GamePhase) -> Option<&'static PresetDescriptor> {
+    all_presets().iter().find(|preset| preset.phase == phase)
+}
+
+pub fn apply_preset_to_config(preset: &PresetDescriptor, config: &mut OptimizerConfig) {
+    config.weights = preset.build_weights();
+    config.game_phase = preset.phase;
+    config.sigma = preset.sigma;
+    config.ignore_spawns = preset.ignore_spawns;
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ResourceNode {
     #[serde(rename = "type")]
@@ -377,3 +502,43 @@ impl Default for OptimizerConfig {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn applying_phase_presets_sets_full_config() {
+        let mut phase1_config = OptimizerConfig::default();
+        let phase1 = preset_by_id_or_phase("phase1").expect("phase1 preset missing");
+        apply_preset_to_config(phase1, &mut phase1_config);
+        assert_eq!(phase1_config.game_phase, GamePhase::Phase1);
+        assert_eq!(phase1_config.sigma, 200.0);
+        assert!(!phase1_config.ignore_spawns);
+        assert!(!phase1_config.weights.is_empty());
+
+        let mut phase4_config = OptimizerConfig::default();
+        let phase4 = preset_by_id_or_phase("phase4").expect("phase4 preset missing");
+        apply_preset_to_config(phase4, &mut phase4_config);
+        assert_eq!(phase4_config.game_phase, GamePhase::Phase4);
+        assert_eq!(phase4_config.sigma, 600.0);
+        assert!(phase4_config.ignore_spawns);
+        assert!(!phase4_config.weights.is_empty());
+    }
+
+    #[test]
+    fn collectibles_preset_has_expected_weights_and_radius() {
+        let preset = preset_by_id_or_phase("collectibles").expect("collectibles preset missing");
+        let weights = preset.build_weights();
+
+        assert_eq!(preset.phase, GamePhase::Phase5);
+        assert_eq!(preset.sigma, 1000.0);
+        assert!(preset.ignore_spawns);
+        assert_eq!(weights.get("blueslug").copied(), Some(0.3));
+        assert_eq!(weights.get("yellowslug").copied(), Some(0.8));
+        assert_eq!(weights.get("purpleslug").copied(), Some(1.2));
+        assert_eq!(weights.get("mercer").copied(), Some(1.0));
+        assert_eq!(weights.get("somersloop").copied(), Some(1.0));
+        assert_eq!(weights.get("harddrive").copied(), Some(1.5));
+    }
+}
diff --git a/src/server.rs b/src/server.rs
