Big API refactor

kiln-core/src/action.rs

@@ -4,9 +4,10 @@
 //! functions), the rate-limiting delay constant, and [`action_to_map`] which
 //! converts an `Action` to a Rhai map for `Queue.peek()` / `Queue.pop()`.
 
+use std::fmt::Debug;
 use crate::log::LogLine;
 use crate::map_file::color_to_hex;
-use crate::utils::{Direction, ObjectId, ScriptArg};
+use crate::utils::{Direction, ObjectId};
 use color::Rgba8;
 use rhai::Dynamic;
 
@@ -27,13 +28,47 @@ pub enum ScrollLine {
     Choice { choice: String, display: String },
 }
 
+#[derive(Clone, PartialEq)]
+pub enum SendArg {
+    None,
+    Int(i64),
+    Float(f64),
+    String(String),
+}
+
+impl From<Dynamic> for SendArg {
+    fn from(value: Dynamic) -> Self {
+        if value.is_int() {
+            Self::Int(value.as_int().unwrap())
+        } else if value.is_float() {
+            Self::Float(value.as_float().unwrap())
+        } else if value.is_string() {
+            Self::String(value.into_string().unwrap())
+        } else {
+            Self::None
+        }
+    }
+}
+
+impl Into<Dynamic> for SendArg {
+    fn into(self) -> Dynamic {
+        match self {
+            SendArg::None => Dynamic::UNIT,
+            SendArg::Int(value) => Dynamic::from(value),
+            SendArg::Float(value) => Dynamic::from(value),
+            SendArg::String(value) => Dynamic::from(value),
+        }
+    }
+}
+
 /// One deferred mutation emitted by a script, applied by [`crate::game::GameState`]
 /// after it is promoted onto the board queue.
 ///
 /// [`Action::Delay`] is the exception: it is **never** promoted to the board queue.
 /// It lives only in the per-object output queue and is consumed by `ScriptHost::drain`
 /// to pace how quickly other actions are released.
-pub(crate) enum Action {
+#[derive(Clone)]
+pub enum Action {
     /// Move the source object one cell in a direction (subject to passability).
     Move(Direction),
     /// Set the source object's glyph tile index.
@@ -59,7 +94,7 @@ pub(crate) enum Action {
     Send {
         target: ObjectId,
         fn_name: String,
-        arg: Option<ScriptArg>,
+        arg: SendArg,
     },
     /// Open a scrollable text overlay. Pauses game ticks while shown; a choice
     /// selection dispatches [`Send`](Action::Send) to the source object.
@@ -67,15 +102,15 @@ pub(crate) enum Action {
     /// Teleport the source object to `(x, y)`. Blocked (with a logged error) if
     /// the source is solid and the destination already has a solid occupant.
     /// Zero time cost — multiple teleports may fire in one frame.
-    Teleport { x: i32, y: i32 },
+    Teleport { x: i64, y: i64 },
     /// Shove the pushable chain starting at `(x, y)` one step in `dir` (acts on
     /// arbitrary cells, not the source object). Zero time cost.
-    Push { x: i32, y: i32, dir: Direction },
+    Push { x: i64, y: i64, dir: Direction },
     /// Shift a set of cells, given as `(x, y)` coordinates: each cell moves to the
     /// next coordinate in the list, unless it can't move, or that cell is blocked.
     /// Rotates the contents of the last cell back to the beginning.
     /// Zero time cost.
-    Shift(Vec<(i32, i32)>),
+    Shift(Vec<(i64, i64)>),
     /// Add `n` to the player's gem count (negative subtracts; the count is
     /// clamped at 0). Zero time cost. Applied to `GameState::player.gems`.
     AddGems(i64),
@@ -93,6 +128,29 @@ pub(crate) enum Action {
     Die,
 }
 
+impl Debug for Action {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Action::Move(dir) => write!(f, "Move({:?})", dir),
+            Action::SetTile(i) => write!(f, "SetTile({i})"),
+            Action::Log(msg) => write!(f, "Log({:?})", msg),
+            Action::SetTag { .. } => write!(f, "SetTag"),
+            Action::Say(_, _) => write!(f, "Say"),
+            Action::Delay(t) => write!(f, "Delay({t})"),
+            Action::SetColor { .. } => write!(f, "SetColor"),
+            Action::Send { .. } => write!(f, "Send"),
+            Action::Scroll(_) => write!(f, "Scroll"),
+            Action::Teleport { .. } => write!(f, "Teleport"),
+            Action::Push { .. } => write!(f, "Push"),
+            Action::Shift(_) => write!(f, "Shift"),
+            Action::AddGems(n) => write!(f, "AddGems({n}"),
+            Action::AlterHealth(health) => write!(f, "AlterHealth({health})"),
+            Action::SetKey(_, _) => write!(f, "SetKey"),
+            Action::Die => write!(f, "Die")
+        }
+    }
+}
+
 // ── Direction helper ──────────────────────────────────────────────────────────
 
 fn dir_to_str(d: Direction) -> &'static str {
@@ -169,13 +227,12 @@ pub(crate) fn action_to_map(action: &Action) -> rhai::Map {
             m.insert("type".into(), ds("Send"));
             m.insert("target".into(), Dynamic::from(*target as i64));
             m.insert("name".into(), Dynamic::from(fn_name.clone()));
-            if let Some(a) = arg {
-                let dyn_arg = match a {
-                    ScriptArg::Str(s) => Dynamic::from(s.clone()),
-                    ScriptArg::Num(n) => Dynamic::from(*n),
-                };
-                m.insert("arg".into(), dyn_arg);
-            }
+            match arg {
+                SendArg::Int(i) => m.insert("arg".into(), Dynamic::from(*i)),
+                SendArg::Float(f) => m.insert("arg".into(), Dynamic::from(*f)),
+                SendArg::String(s) => m.insert("arg".into(), Dynamic::from(s.clone())),
+                SendArg::None => m.insert("arg".into(), Dynamic::UNIT)
+            };
         }
         // Scroll lines are not inspectable via the queue map API; emit type only.
         Action::Scroll(_) => {
@@ -215,3 +272,12 @@ pub(crate) fn action_to_map(action: &Action) -> rhai::Map {
     }
     m
 }
+
+/// An action promoted from an object's output queue onto the board queue, tagged
+/// with the object that issued it.
+pub struct BoardAction {
+    /// The stable [`ObjectId`] of the object that issued the action.
+    pub(crate) source: ObjectId,
+    /// The action to apply.
+    pub(crate) action: Action,
+}