Key Combinations

Muhtasim-Rasheed · Muhtasim-Rasheed · commit 91586ba87972 · 2025-08-14T17:32:08.000+06:00
diff --git a/src/utils/helpers.rs b/src/utils/helpers.rs
@@ -23,7 +23,11 @@ pub fn resolve_expression(expr: &Expression, state: &mut State) -> Value {
             }
             Value::Object(object)
         }
-        Expression::Closure { args, body, returns } => {
+        Expression::Closure {
+            args,
+            body,
+            returns,
+        } => {
             let closure = Function {
                 args: args.clone(),
                 body: body.clone(),
@@ -321,6 +325,81 @@ pub fn string_to_keycode(s: &str) -> Option<Key> {
     }
 }
 
+pub fn keycode_to_string(key: Key) -> String {
+    use Key::*;
+    match key {
+        A => "a".to_string(),
+        B => "b".to_string(),
+        C => "c".to_string(),
+        D => "d".to_string(),
+        E => "e".to_string(),
+        F => "f".to_string(),
+        G => "g".to_string(),
+        H => "h".to_string(),
+        I => "i".to_string(),
+        J => "j".to_string(),
+        K => "k".to_string(),
+        L => "l".to_string(),
+        M => "m".to_string(),
+        N => "n".to_string(),
+        O => "o".to_string(),
+        P => "p".to_string(),
+        Q => "q".to_string(),
+        R => "r".to_string(),
+        S => "s".to_string(),
+        T => "t".to_string(),
+        U => "u".to_string(),
+        V => "v".to_string(),
+        W => "w".to_string(),
+        X => "x".to_string(),
+        Y => "y".to_string(),
+        Z => "z".to_string(),
+
+        Num0 => "0".to_string(),
+        Num1 => "1".to_string(),
+        Num2 => "2".to_string(),
+        Num3 => "3".to_string(),
+        Num4 => "4".to_string(),
+        Num5 => "5".to_string(),
+        Num6 => "6".to_string(),
+        Num7 => "7".to_string(),
+        Num8 => "8".to_string(),
+        Num9 => "9".to_string(),
+
+        GraveAccent => "`".to_owned(),
+        Minus => "-".to_owned(),
+        Equal => "=".to_owned(),
+        LeftBracket => "(".to_owned(),
+        RightBracket => ")".to_owned(),
+        Backslash => "\\".to_owned(),
+        Semicolon => ";".to_owned(),
+        Apostrophe => "'".to_owned(),
+        Comma => ",".to_owned(),
+        Period => ".".to_owned(),
+        Slash => "/".to_owned(),
+
+        LeftControl => "lctrl".to_owned(),
+        RightControl => "rctrl".to_owned(),
+        LeftShift => "lshift".to_owned(),
+        RightShift => "rshift".to_owned(),
+        LeftAlt => "lalt".to_owned(),
+        RightAlt => "ralt".to_owned(),
+        LeftSuper => "lsuper".to_owned(),
+        RightSuper => "rsuper".to_owned(),
+        Tab => "tab".to_owned(),
+        Delete => "del".to_owned(),
+        Backspace => "back".to_owned(),
+        Left => "left".to_owned(),
+        Right => "right".to_owned(),
+        Up => "up".to_owned(),
+        Down => "down".to_owned(),
+        Space => "space".to_owned(),
+        Enter => "enter".to_owned(),
+        Escape => "escape".to_owned(),
+        _ => "unknown".to_owned(),
+    }
+}
+
 pub fn draw_line(start: Vec2, end: Vec2, thickness: f32, shader: &ShaderProgram, color: Vec4) {
     let direction = (end - start).normalize();
     let length = (end - start).length();
diff --git a/src/utils/language.rs b/src/utils/language.rs
@@ -1,5 +1,5 @@
-use std::collections::HashMap;
 use super::Value;
+use std::collections::HashMap;
 
 // ========================= Tokenizer ========================= \\
 
@@ -307,11 +307,7 @@ impl Expression {
             }
             Expression::Closure { args, returns, .. } => {
                 let args_str = args.join(", ");
-                format!(
-                    "({}) {} {{ ... }}",
-                    args_str,
-                    returns.to_string(),
-                )
+                format!("({}) {} {{ ... }}", args_str, returns.to_string(),)
             }
             Expression::ListMemberAccess { list, index } => {
                 format!("{}[{}]", list.to_string(), index.to_string())
diff --git a/src/utils/runtime.rs b/src/utils/runtime.rs
@@ -64,6 +64,7 @@ struct ProjectConfig {
 
 #[derive(Debug)]
 pub struct InputManager {
+    key_history: Vec<glfw::Key>,
     keys_down: HashSet<glfw::Key>,
     keys_pressed: HashSet<glfw::Key>,
     keys_released: HashSet<glfw::Key>,
@@ -75,6 +76,7 @@ pub struct InputManager {
 impl InputManager {
     pub fn new() -> Self {
         Self {
+            key_history: Vec::new(),
             keys_down: HashSet::new(),
             keys_pressed: HashSet::new(),
             keys_released: HashSet::new(),
@@ -101,6 +103,7 @@ impl InputManager {
                         if !self.keys_down.contains(&key) {
                             self.keys_pressed.insert(key);
                         }
+                        self.key_history.push(key);
                         self.keys_down.insert(key);
                     }
                     glfw::Action::Release => {
@@ -130,6 +133,10 @@ impl InputManager {
         }
     }
 
+    pub fn key_history(&self) -> &[glfw::Key] {
+        &self.key_history
+    }
+
     pub fn is_key_down(&self, key: glfw::Key) -> bool {
         self.keys_down.contains(&key)
     }
diff --git a/src/utils/sprite/builtins/builtins.rs b/src/utils/sprite/builtins/builtins.rs
@@ -97,7 +97,7 @@ pub fn builtins() -> HashMap<String, Callable> {
     builtin!(builtins, "switch_costume", |st, ar| looks::switch_costume(st, ar));
     builtin!(builtins, "next_costume", |st, _| looks::next_costume(st));
     builtin!(builtins, "previous_costume", |st, _| looks::previous_costume(st));
-    builtin!(builtins,"switch_backdrop",|st, ar| looks::switch_backdrop(st, ar));
+    builtin!(builtins, "switch_backdrop",|st, ar| looks::switch_backdrop(st, ar));
     builtin!(builtins, "next_backdrop", |st, _| looks::next_backdrop(st));
     builtin!(builtins, "previous_backdrop", |st, _| looks::previous_backdrop(st));
     builtin!(builtins, "set_scale", |st, ar| looks::set_scale(st, ar));
@@ -128,6 +128,8 @@ pub fn builtins() -> HashMap<String, Callable> {
     builtin!(builtins, "key_down", |st, ar| events::key_down(st, ar));
     builtin!(builtins, "key_pressed", |st, ar| events::key_pressed(st, ar));
     builtin!(builtins, "key_released", |st, ar| events::key_released(st, ar));
+    builtin!(builtins, "last_key", |st, _| events::last_key(st));
+    builtin!(builtins, "combination_pressed", |st, ar| events::combination_pressed(st, ar));
     builtin!(builtins, "mouse_button_down", |st, ar| events::mouse_button_down(st, ar));
     builtin!(builtins, "mouse_button_pressed", |st, ar| events::mouse_button_pressed(st, ar));
     builtin!(builtins, "mouse_button_released", |st, ar| events::mouse_button_released(st, ar));
diff --git a/src/utils/sprite/builtins/events.rs b/src/utils/sprite/builtins/events.rs
@@ -1,7 +1,8 @@
-use crate::utils::*;
 use glam::*;
 
-pub fn key_down(state: &State, args: &[Value]) -> Result {
+use crate::utils::{State, Value, function, keycode_to_string, string_to_keycode, string_to_mouse};
+
+pub fn key_down(state: &State, args: &[Value]) -> function::Result {
     if let [Value::String(key)] = args {
         let key_code = string_to_keycode(key).ok_or(format!("Invalid key code: '{}'", key))?;
         Ok(Value::Boolean(state.input_manager.is_key_down(key_code)))
@@ -10,7 +11,7 @@ pub fn key_down(state: &State, args: &[Value]) -> Result {
     }
 }
 
-pub fn key_pressed(state: &State, args: &[Value]) -> Result {
+pub fn key_pressed(state: &State, args: &[Value]) -> function::Result {
     if let [Value::String(key)] = args {
         let key_code = string_to_keycode(key).ok_or(format!("Invalid key code: '{}'", key))?;
         Ok(Value::Boolean(state.input_manager.is_key_pressed(key_code)))
@@ -19,7 +20,7 @@ pub fn key_pressed(state: &State, args: &[Value]) -> Result {
     }
 }
 
-pub fn key_released(state: &State, args: &[Value]) -> Result {
+pub fn key_released(state: &State, args: &[Value]) -> function::Result {
     if let [Value::String(key)] = args {
         let key_code = string_to_keycode(key).ok_or(format!("Invalid key code: '{}'", key))?;
         Ok(Value::Boolean(
@@ -30,7 +31,34 @@ pub fn key_released(state: &State, args: &[Value]) -> Result {
     }
 }
 
-pub fn mouse_button_down(state: &State, args: &[Value]) -> Result {
+pub fn last_key(state: &State) -> function::Result {
+    let key_history = state.input_manager.key_history();
+    if let Some(key) = key_history.last() {
+        Ok(Value::String(keycode_to_string(*key)))
+    } else {
+        Ok(Value::Null)
+    }
+}
+
+pub fn combination_pressed(state: &State, args: &[Value]) -> function::Result {
+    let key_codes: Result<Vec<glfw::Key>, _> = args
+        .iter()
+        .map(|arg| match arg {
+            Value::String(s) => string_to_keycode(s).ok_or_else(|| format!("Invalid key: {}", s)),
+            _ => Err("All arguments must be strings".to_string()),
+        })
+        .collect();
+
+    let key_codes = match key_codes {
+        Ok(codes) if !codes.is_empty() => codes,
+        _ => return Ok(Value::Boolean(false)),
+    };
+
+    let matches = state.input_manager.key_history().ends_with(&key_codes);
+    Ok(Value::Boolean(matches))
+}
+
+pub fn mouse_button_down(state: &State, args: &[Value]) -> function::Result {
     if let [Value::String(button)] = args {
         let button_code =
             string_to_mouse(button).ok_or(format!("Invalid mouse button: '{}'", button))?;
@@ -42,7 +70,7 @@ pub fn mouse_button_down(state: &State, args: &[Value]) -> Result {
     }
 }
 
-pub fn mouse_button_pressed(state: &State, args: &[Value]) -> Result {
+pub fn mouse_button_pressed(state: &State, args: &[Value]) -> function::Result {
     if let [Value::String(button)] = args {
         let button_code =
             string_to_mouse(button).ok_or(format!("Invalid mouse button: '{}'", button))?;
@@ -54,7 +82,7 @@ pub fn mouse_button_pressed(state: &State, args: &[Value]) -> Result {
     }
 }
 
-pub fn mouse_button_released(state: &State, args: &[Value]) -> Result {
+pub fn mouse_button_released(state: &State, args: &[Value]) -> function::Result {
     if let [Value::String(button)] = args {
         let button_code =
             string_to_mouse(button).ok_or(format!("Invalid mouse button: '{}'", button))?;
@@ -66,19 +94,19 @@ pub fn mouse_button_released(state: &State, args: &[Value]) -> Result {
     }
 }
 
-pub fn mouse_x(state: &State) -> Result {
+pub fn mouse_x(state: &State) -> function::Result {
     Ok(Value::Number(
         state.window.get_cursor_pos().0 as f32 * 2.0 - state.window.get_size().0 as f32,
     ))
 }
 
-pub fn mouse_y(state: &State) -> Result {
+pub fn mouse_y(state: &State) -> function::Result {
     Ok(Value::Number(
         -(state.window.get_cursor_pos().1 as f32 * 2.0 - state.window.get_size().1 as f32),
     ))
 }
 
-pub fn sprite_clicked(state: &State) -> Result {
+pub fn sprite_clicked(state: &State) -> function::Result {
     if !state
         .input_manager
         .is_mouse_button_pressed(glfw::MouseButton::Left)
@@ -111,7 +139,7 @@ pub fn sprite_clicked(state: &State) -> Result {
     }
 }
 
-pub fn is_backdrop(state: &State, args: &[Value]) -> Result {
+pub fn is_backdrop(state: &State, args: &[Value]) -> function::Result {
     if let [Value::Number(index)] = args {
         let backdrop = state.project.stage.backdrop();
         if backdrop == *index as usize {
@@ -124,7 +152,7 @@ pub fn is_backdrop(state: &State, args: &[Value]) -> Result {
     }
 }
 
-pub fn broadcast_id_of(state: &State, args: &[Value]) -> Result {
+pub fn broadcast_id_of(state: &State, args: &[Value]) -> function::Result {
     if let [Value::String(message)] = args {
         if let Some(broadcast) = state.project.get_broadcast(message) {
             Ok(Value::Number(broadcast.id as f32))
@@ -136,7 +164,7 @@ pub fn broadcast_id_of(state: &State, args: &[Value]) -> Result {
     }
 }
 
-pub fn broadcast(state: &mut State, args: &[Value]) -> Result {
+pub fn broadcast(state: &mut State, args: &[Value]) -> function::Result {
     if let [Value::String(message)] = args {
         state.project.broadcast(message.clone());
         Ok(Value::Null)
