Port trigger and variable commands to native

Author: gajop

docs/porting/01-slices.md

@@ -38,7 +38,7 @@ spread across the slices they belong to, not deferred as a catch-all.
 | 6 | [Areas](#6-areas) | done (stable) |
 | 7 | [Teams & diplomacy](#7-teams--diplomacy) | done (stable) |
 | 8 | [Project lifecycle](#8-project-lifecycle) — save / load / export / sync / start / stop + scenario-info | review (scenario info in stable) |
-| 9 | [Triggers + Variables](#9-triggers--variables) — depends on areas, teams | wip (not in stable) |
+| 9 | [Triggers + Variables](#9-triggers--variables) — depends on areas, teams | done (stable) |
 
 Notes from review:
 - **Map settings** (sun/lighting/atmosphere/water/map-rendering) are general map
@@ -316,6 +316,13 @@ project-scoped values triggers reference. Trigger conditions/actions are
 polymorphic nested data — the heaviest serialization shape in the codebase, but
 pure project logic (no engine API).
 
+**Status:** done (stable) — add / remove / update for variables and triggers
+are Rust-only, backed by native managers. Native mirrors trigger/variable state
+into LuaRules because the existing Lua `RuntimeModel` still executes trigger
+actions. Integration tests cover LuaRules and LuaUI bridge delivery independently,
+plus both runtime execute paths: `ExecuteTriggerCommand` and
+`ExecuteTriggerActionsCommand`.
+
 **Model:**
 - [scen_edit/model/variable_manager.lua](../../scen_edit/model/variable_manager.lua)
 - [scen_edit/model/trigger_manager.lua](../../scen_edit/model/trigger_manager.lua)

native/src/sbc/lua_bridge.rs

@@ -1,13 +1,12 @@
 //! Native → Lua message channel.
 //!
-//! The native plugin pushes messages to the widget side via
-//! `Spring.SendLuaUIMsg`, framed `springboard|native|<json>`. The widget's
-//! `RecieveGadgetMessage` (`op == "native"`) decodes the JSON and routes by
-//! `tag`:
+//! The native plugin pushes messages to Lua as
+//! `springboard|native|<json>`. LuaUI receives messages via
+//! `Spring.SendLuaUIMsg`; LuaRules receives messages via `SendLuaRulesMsg`.
+//! Both sides decode JSON and route by `tag`:
 //!
-//! - `tag: "command"` → reconstruct + execute a `Widget*Command` (used by the
-//!   command-system widget-notify, e.g. `WidgetCommandExecuted`, and by model
-//!   mirror updates).
+//! - `tag: "command"` -> reconstruct + execute a `Widget*Command` mirror update.
+//! - `tag: "notify"` -> fire a model-manager listener on LuaUI.
 //!
 //! Everything goes through one channel + one widget router, so adding a new
 //! notification is just another `{tag, ...}` shape — no per-manager plumbing.
@@ -24,6 +23,12 @@ pub fn send(interface: &NativeInterfaceRef, body: serde_json::Value) {
     let _ = interface.messages().send_lua_uimsg(&payload, "");
 }
 
+/// Send a JSON envelope to the synced LuaRules side.
+pub fn send_rules(interface: &NativeInterfaceRef, body: serde_json::Value) {
+    let payload = format!("{MESSAGE_PREFIX}|native|{body}");
+    let _ = interface.messages().send_lua_rules_msg(&payload);
+}
+
 /// Send a widget-side command over the native message channel.
 pub fn widget_command(interface: &NativeInterfaceRef, data: serde_json::Value) {
     send(
@@ -34,3 +39,15 @@ pub fn widget_command(interface: &NativeInterfaceRef, data: serde_json::Value) {
         }),
     );
 }
+
+/// Send a command to LuaRules. This is used when native owns project data that
+/// Lua runtime code still consumes from the synced Lua model.
+pub fn rules_command(interface: &NativeInterfaceRef, data: serde_json::Value) {
+    send_rules(
+        interface,
+        serde_json::json!({
+            "tag": "command",
+            "data": data,
+        }),
+    );
+}

native/src/sbc/lua_bridge_tests.rs

@@ -0,0 +1,104 @@
+use spring_native::RulesParamValue;
+use std::collections::HashMap;
+use std::sync::{Mutex, OnceLock};
+
+use crate::sbc::lua_bridge::MESSAGE_PREFIX;
+use crate::sbc::message_handler::MessageHandler;
+use crate::sbc::sbc::SBC;
+use crate::sbc::tests::tests_api::TestCtx;
+
+inventory::submit! {
+    MessageHandler {
+        tag: "bridge_test_ack",
+        handler: bridge_test_ack,
+    }
+}
+
+fn acks() -> &'static Mutex<HashMap<String, f32>> {
+    static ACKS: OnceLock<Mutex<HashMap<String, f32>>> = OnceLock::new();
+    ACKS.get_or_init(|| Mutex::new(HashMap::new()))
+}
+
+fn bridge_test_ack(_sbc: &mut SBC, data: serde_json::Value) {
+    let Some(name) = data.get("name").and_then(|v| v.as_str()) else {
+        return;
+    };
+    let Some(value) = data.get("value").and_then(|v| v.as_f64()) else {
+        return;
+    };
+    if let Ok(mut acks) = acks().lock() {
+        acks.insert(name.to_string(), value as f32);
+    }
+}
+
+fn bridge_payload(name: &str, value: f32) -> String {
+    let msg = serde_json::json!({
+        "tag": "bridge_test",
+        "data": {
+            "name": name,
+            "value": value,
+        },
+    });
+    format!("{MESSAGE_PREFIX}|native|{msg}")
+}
+
+fn read_game_rules_param(ctx: &mut TestCtx, name: &str) -> Result<f32, String> {
+    let (value, _, exists) = ctx
+        .sbc
+        .interface()
+        .rules_params()
+        .get_game_rules_param(name)
+        .map_err(|err| format!("GetGameRulesParam({name}) failed: {err:?}"))?;
+    if !exists {
+        return Err(format!("{name} was not set by the bridge"));
+    }
+    let RulesParamValue::Float(value) = value else {
+        return Err(format!("{name} came back as {value:?}, expected float"));
+    };
+    Ok(value)
+}
+
+fn assert_bridge_value(ctx: &mut TestCtx, name: &str, expected: f32) -> Result<(), String> {
+    let actual = read_game_rules_param(ctx, name)?;
+    if (actual - expected).abs() > 0.01 {
+        return Err(format!("{name} = {actual}, expected {expected}"));
+    }
+    Ok(())
+}
+
+fn assert_luaui_ack(name: &str, expected: f32) -> Result<(), String> {
+    let actual = acks()
+        .lock()
+        .map_err(|err| format!("bridge ack lock poisoned: {err}"))?
+        .remove(name)
+        .ok_or_else(|| format!("{name} was not acknowledged by LuaUI"))?;
+    if (actual - expected).abs() > 0.01 {
+        return Err(format!("{name} ack = {actual}, expected {expected}"));
+    }
+    Ok(())
+}
+
+fn lua_rules_bridge(ctx: &mut TestCtx) -> Result<(), String> {
+    let name = "sbc_luarules_bridge_test";
+    let expected = 321.0;
+    let payload = bridge_payload(name, expected);
+    match ctx.sbc.interface().messages().send_lua_rules_msg(&payload) {
+        Ok(true) => assert_bridge_value(ctx, name, expected),
+        Ok(false) => Err(format!("LuaRules rejected payload: {payload}")),
+        Err(err) => Err(format!("SendLuaRulesMsg failed: {err:?}")),
+    }
+}
+
+fn luaui_bridge(ctx: &mut TestCtx) -> Result<(), String> {
+    let name = "sbc_luaui_bridge_test";
+    let expected = 654.0;
+    let payload = bridge_payload(name, expected);
+    match ctx.sbc.interface().messages().send_lua_uimsg(&payload, "") {
+        Ok(true) => assert_luaui_ack(name, expected),
+        Ok(false) => Err(format!("LuaUI rejected payload: {payload}")),
+        Err(err) => Err(format!("SendLuaUIMsg failed: {err:?}")),
+    }
+}
+
+crate::integration_test!("lua_rules_bridge", lua_rules_bridge);
+crate::integration_test!("luaui_bridge", luaui_bridge);

native/src/sbc/message_handler.rs

@@ -0,0 +1,26 @@
+//! Registry for non-command Lua → native messages, keyed by the envelope `tag`.
+//! Each feature self-registers its handlers via `inventory::submit!`, so
+//! [`SBC::route`](crate::sbc::sbc::SBC) stays feature-agnostic: it knows only
+//! `"command"` and otherwise asks this registry.
+
+use crate::sbc::sbc::SBC;
+
+/// One non-command message handler, collected by `inventory` and keyed by the
+/// envelope tag it answers (e.g. `"save_model"`).
+pub struct MessageHandler {
+    pub tag: &'static str,
+    pub handler: fn(&mut SBC, serde_json::Value),
+}
+inventory::collect!(MessageHandler);
+
+/// Dispatch a tagged message to its registered handler. Returns `false` if no
+/// feature registered a handler for `tag`.
+pub fn dispatch(sbc: &mut SBC, tag: &str, data: serde_json::Value) -> bool {
+    for handler in inventory::iter::<MessageHandler> {
+        if handler.tag == tag {
+            (handler.handler)(sbc, data);
+            return true;
+        }
+    }
+    false
+}

native/src/sbc/mod.rs

@@ -7,10 +7,14 @@ mod objects;
 mod project;
 mod teams;
 mod textures;
+mod triggers;
+mod variables;
 
 mod hashable_float;
 mod io;
 mod log;
 mod lua_bridge;
+mod lua_bridge_tests;
+mod message_handler;
 pub mod sbc;
 mod tests;

native/src/sbc/sbc.rs

@@ -92,7 +92,11 @@ impl SBC {
 
         match envelope.tag.as_str() {
             "command" => self.run_command(envelope.data),
-            other => error!("Not a command (tag: {other})"),
+            other => {
+                if !crate::sbc::message_handler::dispatch(self, other, envelope.data) {
+                    error!("Not a command (tag: {other})");
+                }
+            }
         }
     }
 

native/src/sbc/triggers/commands/add_trigger_command.rs

@@ -0,0 +1,36 @@
+use serde::Deserialize;
+
+use crate::sbc::command_system::command::Command;
+use crate::sbc::command_system::context::Context;
+use crate::sbc::command_system::registry::register_command;
+use crate::sbc::triggers::TriggerManager;
+
+/// Adds a trigger. 1:1 with `scen_edit/command/add_trigger_command.lua`:
+/// execute adds (recording the id), unexecute removes.
+#[derive(Deserialize, Debug)]
+pub struct AddTriggerCommand {
+    trigger: serde_json::Value,
+    #[serde(skip)]
+    id: Option<i32>,
+}
+
+impl Command for AddTriggerCommand {
+    fn execute(&mut self, ctx: &mut Context) {
+        // On redo, reuse the id assigned the first time so the trigger returns
+        // with the same id (we clone the data, so carry the id forward).
+        let mut trigger = self.trigger.clone();
+        if let (Some(id), Some(obj)) = (self.id, trigger.as_object_mut()) {
+            obj.insert("id".to_string(), serde_json::json!(id));
+        }
+        let id = ctx.model::<TriggerManager>().add_trigger(trigger);
+        self.id = Some(id);
+    }
+
+    fn unexecute(&mut self, ctx: &mut Context) {
+        if let Some(id) = self.id {
+            ctx.model::<TriggerManager>().remove_trigger(id);
+        }
+    }
+}
+
+register_command!(AddTriggerCommand, "AddTriggerCommand");

native/src/sbc/triggers/commands/mod.rs

@@ -0,0 +1,3 @@
+mod add_trigger_command;
+mod remove_trigger_command;
+mod update_trigger_command;

native/src/sbc/triggers/commands/remove_trigger_command.rs

@@ -0,0 +1,36 @@
+use serde::Deserialize;
+
+use crate::sbc::command_system::command::Command;
+use crate::sbc::command_system::context::Context;
+use crate::sbc::command_system::registry::register_command;
+use crate::sbc::triggers::TriggerManager;
+
+/// Removes a trigger. 1:1 with `scen_edit/command/remove_trigger_command.lua`:
+/// execute saves the trigger then removes it; unexecute re-adds the saved
+/// trigger (which carries its id, so it returns unchanged).
+#[derive(Deserialize, Debug)]
+pub struct RemoveTriggerCommand {
+    #[serde(rename = "triggerID")]
+    trigger_id: i32,
+    #[serde(skip)]
+    saved: Option<serde_json::Value>,
+}
+
+impl Command for RemoveTriggerCommand {
+    fn execute(&mut self, ctx: &mut Context) {
+        self.saved = ctx
+            .model::<TriggerManager>()
+            .get_trigger(self.trigger_id)
+            .cloned();
+        ctx.model::<TriggerManager>()
+            .remove_trigger(self.trigger_id);
+    }
+
+    fn unexecute(&mut self, ctx: &mut Context) {
+        if let Some(t) = self.saved.clone() {
+            ctx.model::<TriggerManager>().add_trigger(t);
+        }
+    }
+}
+
+register_command!(RemoveTriggerCommand, "RemoveTriggerCommand");

native/src/sbc/triggers/commands/update_trigger_command.rs

@@ -0,0 +1,51 @@
+use serde::Deserialize;
+
+use crate::sbc::command_system::command::Command;
+use crate::sbc::command_system::context::Context;
+use crate::sbc::command_system::registry::register_command;
+use crate::sbc::triggers::TriggerManager;
+
+/// Updates a trigger in place. 1:1 with
+/// `scen_edit/command/update_trigger_command.lua`: execute saves the old trigger
+/// then sets the new one (keyed by `trigger.id`); unexecute restores the old.
+#[derive(Deserialize, Debug)]
+pub struct UpdateTriggerCommand {
+    trigger: serde_json::Value,
+    #[serde(skip)]
+    old: Option<serde_json::Value>,
+}
+
+impl UpdateTriggerCommand {
+    fn trigger_id(&self) -> Option<i32> {
+        self.trigger
+            .get("id")
+            .and_then(|v| v.as_i64())
+            .map(|v| v as i32)
+    }
+}
+
+impl Command for UpdateTriggerCommand {
+    fn execute(&mut self, ctx: &mut Context) {
+        let Some(id) = self.trigger_id() else {
+            return;
+        };
+        // Snapshot once: redo re-runs this same instance, so re-capturing here
+        // would store the already-updated value.
+        if self.old.is_none() {
+            self.old = ctx.model::<TriggerManager>().get_trigger(id).cloned();
+        }
+        ctx.model::<TriggerManager>()
+            .set_trigger(id, self.trigger.clone());
+    }
+
+    fn unexecute(&mut self, ctx: &mut Context) {
+        let Some(id) = self.trigger_id() else {
+            return;
+        };
+        if let Some(old) = self.old.clone() {
+            ctx.model::<TriggerManager>().set_trigger(id, old);
+        }
+    }
+}
+
+register_command!(UpdateTriggerCommand, "UpdateTriggerCommand");