rhai/examples/event_handler_map/main.rs

152 lines
4.1 KiB
Rust
Raw Normal View History

2022-01-16 15:45:25 +01:00
//! Implementation of the Event Handler With State Pattern - Map Style
2022-01-16 16:15:37 +01:00
#[cfg(any(feature = "no_function", feature = "no_object"))]
pub fn main() {
panic!("This example does not run under 'no_function' or 'no_object'.")
}
2022-01-16 15:45:25 +01:00
#[cfg(not(feature = "no_function"))]
#[cfg(not(feature = "no_object"))]
pub fn main() {
use rhai::{Dynamic, Engine, Map, Scope, AST};
use std::io::{stdin, stdout, Write};
2022-01-16 15:45:25 +01:00
const SCRIPT_FILE: &str = "event_handler_map/script.rhai";
2022-01-16 15:45:25 +01:00
#[derive(Debug)]
struct Handler {
pub engine: Engine,
pub scope: Scope<'static>,
pub ast: AST,
}
2022-01-16 15:45:25 +01:00
fn print_scope(scope: &Scope) {
for (i, (name, constant, value)) in scope.iter_raw().enumerate() {
#[cfg(not(feature = "no_closure"))]
let value_is_shared = if value.is_shared() { " (shared)" } else { "" };
#[cfg(feature = "no_closure")]
let value_is_shared = "";
println!(
"[{}] {}{}{} = {:?}",
i + 1,
if constant { "const " } else { "" },
name,
value_is_shared,
*value.read_lock::<Dynamic>().unwrap(),
)
}
println!();
2022-01-28 11:59:18 +01:00
}
2022-01-16 15:45:25 +01:00
println!("Events Handler Example - Map Style");
println!("==================================");
let mut input = String::new();
// Read script file
print!("Script file [{}]: ", SCRIPT_FILE);
stdout().flush().expect("flush stdout");
input.clear();
stdin().read_line(&mut input).expect("read input");
let path = match input.trim() {
"" => SCRIPT_FILE,
path => path,
};
// Create Engine
2022-02-27 15:47:13 +01:00
let mut engine = Engine::new();
// Prevent shadowing of `state`
#[allow(deprecated)]
engine.on_def_var(|_, info, _| Ok(info.name != "state"));
2022-01-16 15:45:25 +01:00
// Create a custom 'Scope' to hold state
let mut scope = Scope::new();
// Add any system-provided state into the custom 'Scope'.
// Constants can be used to optimize the script.
scope.push_constant("MY_CONSTANT", 42_i64);
// Use an object map to hold state
let mut states = Map::new();
// Default states can be added
states.insert("bool_state".into(), Dynamic::FALSE);
// Add the main states-holding object map and call it 'state'
2022-06-13 10:32:33 +02:00
scope.push("state", states);
2022-01-16 15:45:25 +01:00
// Compile the handler script.
println!("> Loading script file: {path}");
2022-01-16 15:45:25 +01:00
let ast = match engine.compile_file_with_scope(&mut scope, path.into()) {
Ok(ast) => ast,
Err(err) => {
eprintln!("! Error: {err}");
2022-01-16 15:45:25 +01:00
println!("Cannot continue. Bye!");
return;
}
};
println!("> Script file loaded.");
println!();
println!("quit = exit program");
println!("scope = print scope");
println!("event arg = run function with argument");
println!();
// Run the 'init' function to initialize the state, retaining variables.
2022-08-12 16:48:15 +02:00
let result = engine.call_fn::<()>(&mut scope, &ast, "init", ());
2022-01-16 15:45:25 +01:00
if let Err(err) = result {
eprintln!("! {err}")
2022-01-16 15:45:25 +01:00
}
// Create handler instance
let mut handler = Handler { engine, scope, ast };
// Events loop
loop {
print!("event> ");
stdout().flush().expect("flush stdout");
// Read event
input.clear();
stdin().read_line(&mut input).expect("read input");
let mut fields = input.trim().splitn(2, ' ');
let event = fields.next().expect("event").trim();
let arg = fields.next().unwrap_or("").to_string();
2022-01-16 15:45:25 +01:00
// Process event
match event {
"quit" => break,
"scope" => {
print_scope(&handler.scope);
continue;
}
// Map all other events to function calls
_ => {
let engine = &handler.engine;
let scope = &mut handler.scope;
let ast = &handler.ast;
let result = engine.call_fn::<()>(scope, ast, event, (arg,));
2022-01-16 15:45:25 +01:00
if let Err(err) = result {
eprintln!("! {err}")
2022-01-16 15:45:25 +01:00
}
}
}
}
println!("Bye!");
}