WIP native command migration and UI updates

Author: gajop

config/README.md

@@ -10,6 +10,10 @@ Exactly one does; the other two build nothing.
 | `ui-rust.json`                     | rust   | rust     | the native (Rust) UI               |
 | `ui-chili-native-chonsole.json`    | chili  | rust     | Chili UI, native console           |
 | `ui-rmlui-native-chonsole.json`    | rmlui  | rust     | Lua RmlUi UI, native console       |
+| `ui-rust-dev.json`                 | rust   | rust     | native UI + Dev tab, debug logging |
+
+A config may also carry an `env` object; its entries are set in the engine's
+environment (`ui-rust-dev.json` uses it for `SBC_DEV_PANEL` and `SBC_LOG_LEVEL`).
 
 The old names (`rust-rmlui.json`, `mixed-rust-*`) named the *chonsole*, not the
 UI, so `rust-rmlui` was the Lua UI. They are renamed above.

config/ui-rust-dev.json

@@ -0,0 +1,8 @@
+{
+  "chonsole": "rust",
+  "ui": "rust",
+  "env": {
+    "SBC_DEV_PANEL": "1",
+    "SBC_LOG_LEVEL": "debug"
+  }
+}

docs/porting/conventions.md

@@ -208,6 +208,8 @@ the file reads like a newspaper (headline first, detail below).
   ordering meaning. The rule is only: the public command on top, helpers underneath.
 - Keep one `impl` block per type — don't split a type's methods across several
   `impl` blocks to satisfy ordering; order the methods *within* the block instead.
+- Within each `impl` block, put every `pub`/`pub(...)` method before its private
+  methods. The Rust step-down lint enforces this independently for each block.
 - Free helper functions go below the code that calls them; a leaf used by several
   callers goes after the last of them.
 

native/src/sbc/actions/clipboard.rs

@@ -8,8 +8,9 @@ use std::any::Any;
 
 use spring_native::prelude::NativeInterfaceRef;
 
+use crate::sbc::command_system::command::Command;
 use crate::sbc::command_system::model::{Model, ModelFactory};
-use crate::sbc::objects::ObjectKind;
+use crate::sbc::objects::{AddObjectCommand, ObjectKind};
 
 inventory::submit! {
     ModelFactory { make: |_iface| Box::new(Clipboard::default()) }
@@ -44,16 +45,15 @@ impl Clipboard {
         }
     }
 
-    /// Build AddObjectCommand envelopes for every copied object, offset so the
+    /// Build `AddObjectCommand`s for every copied object, offset so the
     /// centroid lands at `(ground_x, ground_z)`. Each object's Y maintains its
     /// original height-above-ground, queried live from the terrain.
-    pub fn paste_envelopes(
+    pub fn paste_commands(
         &self,
         interface: &NativeInterfaceRef,
         ground_x: f32,
         ground_z: f32,
-        next: &mut u64,
-    ) -> Vec<String> {
+    ) -> Vec<Box<dyn Command>> {
         if self.copied.is_empty() {
             return vec![];
         }
@@ -76,7 +76,7 @@ impl Clipboard {
         let dz = ground_z - cz / count as f32;
 
         let terrain = interface.terrain();
-        let mut envelopes = Vec::new();
+        let mut commands = Vec::new();
         for (kind, json) in &self.copied {
             let mut obj = json.clone();
             if let serde_json::Value::Object(map) = &mut obj {
@@ -95,16 +95,9 @@ impl Clipboard {
                     pos["z"] = serde_json::json!(nz);
                 }
             }
-            envelopes.push(crate::sbc::envelope::envelope_fields(
-                "AddObjectCommand",
-                next,
-                serde_json::json!({
-                    "objType": kind,
-                    "params": obj,
-                }),
-            ));
+            commands.push(Box::new(AddObjectCommand::new(*kind, obj)) as Box<dyn Command>);
         }
-        envelopes
+        commands
     }
 }
 

native/src/sbc/actions/dialog.rs

@@ -4,13 +4,15 @@
 use spring_native::prelude::NativeInterfaceRef;
 
 use super::paths::PROJECTS_DIR;
+use crate::sbc::command_system::command::Command;
 
 /// What an action wants the manager to do.
 pub enum ActionResult {
     /// Nothing to do (not executable, or handled internally like selection ops).
     None,
-    /// Route these command envelopes through the command system.
-    Commands(Vec<String>),
+    /// Submit these typed commands directly — no JSON envelope, no `className`,
+    /// no producer-assigned id (the command manager allocates one on execute).
+    NativeCommands(Vec<Box<dyn Command>>),
     /// Open the file browser. `on_accept` is called with the picked path.
     OpenFileDialog {
         config: FileDialogConfig,
@@ -55,6 +57,6 @@ pub struct FileDialogResult {
     pub file_type: Option<String>,
 }
 
-/// A type-erased callback that produces command envelopes from a dialog result.
+/// A type-erased callback that produces typed commands from a dialog result.
 pub type FileAcceptFn =
-    Box<dyn FnOnce(&FileDialogResult, &NativeInterfaceRef, &mut u64) -> Vec<String>>;
+    Box<dyn FnOnce(&FileDialogResult, &NativeInterfaceRef) -> Vec<Box<dyn Command>>>;

native/src/sbc/actions/project.rs

@@ -6,71 +6,57 @@ use spring_native::prelude::NativeInterfaceRef;
 
 use super::helpers::{game_id, rand_u32};
 use super::paths::PROJECTS_DIR;
-use crate::sbc::envelope::envelope_fields;
+use crate::sbc::command_system::command::Command;
+use crate::sbc::project::commands::{ReloadIntoProjectCommand, SaveProjectInfoCommand};
+use crate::sbc::project::ProjectData;
 
 /// The blank map's archive name; its size comes from `randomMapOptions`.
 const BLANK_MAP: &str = "SB_Blank_Map";
 
-/// Build the command envelopes for creating a new project, called by the
-/// manager after the NewProject dialog completes.
+/// Build the commands for creating a new project, called by the manager after
+/// the NewProject dialog completes.
 pub fn commit_new_project(
     name: &str,
     map_name: &str,
     size_x: Option<f32>,
     size_y: Option<f32>,
     interface: &NativeInterfaceRef,
-    next: &mut u64,
-) -> Vec<String> {
+) -> Vec<Box<dyn Command>> {
     let project_name = name.trim().trim_end_matches(".sdd");
     let path = format!("{PROJECTS_DIR}{project_name}.sdd");
     let (game_name, game_version) = game_id(interface);
 
     // For the blank map, the size is carried in randomMapOptions and the engine
     // generates a fresh map; a seed keeps the archive out of a stale cache.
     let random_map_options = if map_name == BLANK_MAP {
-        serde_json::json!({
+        Some(serde_json::json!({
             "mapSeed": rand_u32(),
             "new_map_x": size_x.unwrap_or(10.0),
             "new_map_y": size_y.unwrap_or(10.0),
-        })
+        }))
     } else {
-        serde_json::Value::Null
+        None
     };
 
     // The full project record, so the chosen map and target game are saved into
     // the start script the reload reads back.
-    let mut project = serde_json::json!({
-        "name": project_name,
-        "path": path,
-        "mapName": map_name,
-        "game": { "name": game_name, "version": game_version },
-        "mutators": [format!("{project_name} 1.0")],
-    });
-    if !random_map_options.is_null() {
-        project["randomMapOptions"] = random_map_options;
-    }
+    let project = ProjectData {
+        name: Some(project_name.to_string()),
+        path: Some(path.clone()),
+        map_name: Some(map_name.to_string()),
+        game: Some(serde_json::json!({ "name": game_name, "version": game_version })),
+        random_map_options,
+        mutators: vec![format!("{project_name} 1.0")],
+    };
 
     vec![
-        envelope_fields(
-            "SaveProjectInfoCommand",
-            next,
-            serde_json::json!({
-                "name": project_name,
-                "path": path,
-                "isNewProject": true,
-                "project": project,
-            }),
-        ),
-        envelope_fields(
-            "ReloadIntoProjectCommand",
-            next,
-            serde_json::json!({
-                "path": path,
-                "modOptions": serde_json::json!({}),
-                "gameName": game_name,
-                "gameVersion": game_version,
-            }),
-        ),
+        Box::new(SaveProjectInfoCommand::new(
+            project_name.to_string(),
+            path.clone(),
+            true,
+            Some(project),
+        )),
+        Box::new(ReloadIntoProjectCommand::new(path, game_name, game_version)),
     ]
 }