use std::time::SystemTime;
use crossterm::{
event::KeyCode,
style::{Attribute, Attributes, Color, ContentStyle},
};
use hex_color::HexColor;
use mlua::{FromLua, IntoLua, Lua, LuaOptions, StdLib, Table, Value};
use serde::{Deserialize, Serialize};
use crate::{
buffer::Cell,
scene::scene_id_by_name,
script::{FullScriptContext, Operation},
};
pub struct LuaModule {
interpreter: Lua,
}
impl LuaModule {
pub fn new(data: &[u8]) -> mlua::Result<Self> {
macro_rules! add_fn {
($lua: expr, $table: expr, $fn: ident) => {
$table.set(stringify!($fn), $lua.create_function($fn)?)?;
};
}
macro_rules! add_fns {
($lua: expr, [$($fn: ident),*]) => {
let tortuise_module = $lua.create_table()?;
$(add_fn!($lua, tortuise_module, $fn);)*
let globals = $lua.globals();
globals.set("tortuise", tortuise_module)?;
$lua.set_globals(globals)?;
};
}
let interpreter = Lua::new_with(
StdLib::TABLE | StdLib::STRING | StdLib::MATH,
LuaOptions::new().catch_rust_panics(true),
)?;
add_fns!(
interpreter,
[
add_cell,
window_size,
is_key_pressed_this_frame,
log,
warn,
error,
exit,
is_scene_loaded,
preload_scene,
switch_scene,
is_script_loaded,
preload_script,
unload_script,
activate_script,
deactivate_script,
state,
set_state,
entity,
set_entity,
storage,
set_storage,
clock,
time,
delta_time
]
);
interpreter.load(data).exec()?;
Ok(Self { interpreter })
}
pub fn run_function(&self, func: &str, ctx: FullScriptContext) -> mlua::Result<()> {
unsafe {
let ctx = std::ptr::from_mut(Box::leak(Box::new(ctx)));
self.interpreter.set_app_data(ctx.expose_provenance());
self.interpreter
.load(format!("if {func} then {func}() end"))
.exec()?;
drop(Box::from_raw(ctx));
Ok(())
}
}
}
#[allow(clippy::mut_from_ref)]
unsafe fn context(lua: &Lua) -> &mut FullScriptContext<'_> {
unsafe {
std::ptr::with_exposed_provenance_mut::<FullScriptContext>(*lua.app_data_ref().unwrap())
.as_mut_unchecked()
}
}
fn add_cell(lua: &Lua, cell: Table) -> mlua::Result<()> {
fn parse_color(mut color: String) -> Option<Color> {
color.make_ascii_uppercase();
color.retain(|c| c != '-' && c != ' ' && c != '_');
match &*color {
"RESET" => return Some(Color::Reset),
"BLACK" => return Some(Color::Black),
"DARKGREY" => return Some(Color::DarkGrey),
"DARKGRAY" => return Some(Color::DarkGrey),
"RED" => return Some(Color::Red),
"DARKRED" => return Some(Color::DarkRed),
"GREEN" => return Some(Color::Green),
"DARKGREEN" => return Some(Color::DarkGreen),
"YELLOW" => return Some(Color::Yellow),
"DARKYELLOW" => return Some(Color::DarkYellow),
"BLUE" => return Some(Color::Blue),
"DARKBLUE" => return Some(Color::DarkBlue),
"MAGENTA" => return Some(Color::Magenta),
"DARKMAGENTA" => return Some(Color::DarkMagenta),
"CYAN" => return Some(Color::Cyan),
"DARKCYAN" => return Some(Color::DarkCyan),
"WHITE" => return Some(Color::White),
"GREY" => return Some(Color::Grey),
"GRAY" => return Some(Color::Grey),
_ => (),
};
if color.starts_with('#') {
let color = HexColor::parse(&color).ok()?;
return Some(Color::Rgb {
r: color.r,
g: color.g,
b: color.b,
});
}
None
}
fn parse_attributes(value: Vec<String>) -> Attributes {
let mut attributes = Attributes::none();
for mut value in value {
value.make_ascii_uppercase();
value.retain(|c| c != '-' && c != ' ' && c != '_');
match &*value {
"BOLD" => attributes.set(Attribute::Bold),
"DIM" => attributes.set(Attribute::Dim),
"ITALIC" => attributes.set(Attribute::Italic),
"UNDERLINED" => attributes.set(Attribute::Underlined),
"DOUBLEUNDERLINED" => attributes.set(Attribute::DoubleUnderlined),
"UNDERCURLED" => attributes.set(Attribute::Undercurled),
"UNDERDOTTED" => attributes.set(Attribute::Underdotted),
"SLOWBLINK" => attributes.set(Attribute::SlowBlink),
"RAPIDBLINK" => attributes.set(Attribute::RapidBlink),
"REVERSE" => attributes.set(Attribute::Reverse),
"HIDDEN" => attributes.set(Attribute::Hidden),
"CROSSEDOUT" => attributes.set(Attribute::CrossedOut),
"FRAKTUR" => attributes.set(Attribute::Fraktur),
"FRAMED" => attributes.set(Attribute::Framed),
"ENCIRCLED" => attributes.set(Attribute::Encircled),
"OVERLINED" => attributes.set(Attribute::OverLined),
_ => (),
}
}
attributes
}
puffin::profile_function!();
unsafe { context(lua) }
.operation_queue
.push(Operation::AddCell(Cell {
character: cell.get("character")?,
style: ContentStyle {
foreground_color: parse_color(cell.get("foreground_color").unwrap_or_default()),
background_color: parse_color(cell.get("background_color").unwrap_or_default()),
underline_color: parse_color(cell.get("underline_color").unwrap_or_default()),
attributes: parse_attributes(cell.get("attributes").unwrap_or_default()),
},
x: cell.get("x")?,
y: cell.get("y")?,
z: cell.get("z")?,
}));
Ok(())
}
fn window_size(lua: &Lua, _: ()) -> mlua::Result<Table> {
puffin::profile_function!();
let window_size = &unsafe { context(lua) }.buffer.window_size;
let value = lua.create_table()?;
value.set("rows", window_size.rows)?;
value.set("columns", window_size.columns)?;
value.set("width", window_size.width)?;
value.set("height", window_size.height)?;
Ok(value)
}
fn is_key_pressed_this_frame(lua: &Lua, mut key: String) -> mlua::Result<bool> {
puffin::profile_function!();
key.make_ascii_uppercase();
key.retain(|c| c != '-' && c != '_' && c != ' ');
let key = match &*key {
"BACKSPACE" => KeyCode::Backspace,
"ENTER" => KeyCode::Enter,
"LEFT" => KeyCode::Left,
"RIGHT" => KeyCode::Right,
"UP" => KeyCode::Up,
"DOWN" => KeyCode::Down,
"HOME" => KeyCode::Home,
"END" => KeyCode::End,
"PAGEUP" => KeyCode::PageUp,
"PAGEDOWN" => KeyCode::PageDown,
"TAB" => KeyCode::Tab,
"BACKTAB" => KeyCode::BackTab,
"DELETE" => KeyCode::Delete,
"INSERT" => KeyCode::Insert,
"ESC" => KeyCode::Esc,
"ESCAPE" => KeyCode::Esc,
f if f.starts_with('F') => KeyCode::F(f[1..].parse::<u8>().unwrap()),
c if c.len() == 1 => KeyCode::Char(c.chars().next().unwrap()),
_ => return Err(mlua::Error::runtime(format!("Invalid key code: {key}"))),
};
Ok(unsafe { context(lua).input.is_key_pressed_this_frame(key) })
}
fn log(_: &Lua, value: Value) -> mlua::Result<()> {
puffin::profile_function!();
log::info!("{}", value.to_string()?);
Ok(())
}
fn warn(_: &Lua, value: Value) -> mlua::Result<()> {
puffin::profile_function!();
log::warn!("{}", value.to_string()?);
Ok(())
}
fn error(_: &Lua, value: Value) -> mlua::Result<()> {
puffin::profile_function!();
log::error!("{}", value.to_string()?);
Ok(())
}
fn exit(lua: &Lua, _: ()) -> mlua::Result<()> {
puffin::profile_function!();
unsafe { context(lua) }
.operation_queue
.push(Operation::Exit);
Ok(())
}
fn is_scene_loaded(lua: &Lua, scene: String) -> mlua::Result<()> {
puffin::profile_function!();
let context = unsafe { context(lua) };
let scene = scene_id_by_name(&context.manifest.scenes, &scene)
.ok_or(mlua::Error::runtime("No scene with the given name found"))?;
crate::scene::is_scene_loaded(
&context.manifest.scenes,
context.scripts,
&context.files,
scene,
);
Ok(())
}
fn preload_scene(lua: &Lua, scene: String) -> mlua::Result<()> {
puffin::profile_function!();
let context = unsafe { context(lua) };
let scene = scene_id_by_name(&context.manifest.scenes, &scene)
.ok_or(mlua::Error::runtime("No scene with the given name found"))?;
context.operation_queue.push(Operation::PreloadScene(scene));
Ok(())
}
fn switch_scene(lua: &Lua, scene: String) -> mlua::Result<()> {
puffin::profile_function!();
let context = unsafe { context(lua) };
let scene = scene_id_by_name(&context.manifest.scenes, &scene)
.ok_or(mlua::Error::runtime("No scene with the given name found"))?;
context.operation_queue.push(Operation::SwitchScene(scene));
Ok(())
}
fn is_script_loaded(lua: &Lua, script: String) -> mlua::Result<()> {
puffin::profile_function!();
let context = unsafe { context(lua) };
let script = context
.scripts
.script_id_by_name(&script)
.ok_or(mlua::Error::runtime("No script with the given name found"))?;
context.scripts.is_script_loaded(script, &context.files);
Ok(())
}
fn preload_script(lua: &Lua, script: String) -> mlua::Result<()> {
puffin::profile_function!();
let context = unsafe { context(lua) };
let script = context
.scripts
.script_id_by_name(&script)
.ok_or(mlua::Error::runtime("No script with the given name found"))?;
context
.operation_queue
.push(Operation::PreloadScript(script));
Ok(())
}
fn unload_script(lua: &Lua, script: String) -> mlua::Result<()> {
puffin::profile_function!();
let context = unsafe { context(lua) };
let script = context
.scripts
.script_id_by_name(&script)
.ok_or(mlua::Error::runtime("No script with the given name found"))?;
context
.operation_queue
.push(Operation::UnloadScript(script));
Ok(())
}
fn activate_script(lua: &Lua, script: String) -> mlua::Result<()> {
puffin::profile_function!();
let context = unsafe { context(lua) };
let script = context
.scripts
.script_id_by_name(&script)
.ok_or(mlua::Error::runtime("No script with the given name found"))?;
context
.operation_queue
.push(Operation::ActivateScript(script));
Ok(())
}
fn deactivate_script(lua: &Lua, script: String) -> mlua::Result<()> {
puffin::profile_function!();
let context = unsafe { context(lua) };
let script = context
.scripts
.script_id_by_name(&script)
.ok_or(mlua::Error::runtime("No script with the given name found"))?;
context
.operation_queue
.push(Operation::DeactivateScript(script));
Ok(())
}
fn state(lua: &Lua, default: MyLuaValue) -> mlua::Result<MyLuaValue> {
puffin::profile_function!();
let context = unsafe { context(lua) };
Ok(context
.scripts
.script_states
.get(&context.script_id)
.map(|state| postcard::from_bytes(state).unwrap())
.unwrap_or(default))
}
fn set_state(lua: &Lua, new_state: MyLuaValue) -> mlua::Result<()> {
puffin::profile_function!();
let context = unsafe { context(lua) };
context.operation_queue.push(Operation::UpdateState {
script_id: context.script_id,
new_state: postcard::to_stdvec(&new_state).unwrap().into_boxed_slice(),
});
Ok(())
}
fn entity(lua: &Lua, (name, default): (String, MyLuaValue)) -> mlua::Result<MyLuaValue> {
puffin::profile_function!();
let context = unsafe { context(lua) };
Ok(context
.scripts
.entities
.get(&*name)
.map(|state| postcard::from_bytes(state).unwrap())
.unwrap_or(default))
}
fn set_entity(lua: &Lua, (name, new_state): (String, MyLuaValue)) -> mlua::Result<()> {
puffin::profile_function!();
let context = unsafe { context(lua) };
context.operation_queue.push(Operation::UpdateEntity {
name: name.into_boxed_str(),
new_state: postcard::to_stdvec(&new_state).unwrap().into_boxed_slice(),
});
Ok(())
}
#[derive(Debug, Clone, Serialize, Deserialize)]
enum MyLuaValue {
Nil,
Boolean(bool),
Number(f64),
String(String),
Table(Vec<(MyLuaValue, MyLuaValue)>),
}
impl FromLua for MyLuaValue {
fn from_lua(value: Value, _: &Lua) -> mlua::Result<Self> {
Ok(match value {
Value::Nil => MyLuaValue::Nil,
Value::Boolean(b) => MyLuaValue::Boolean(b),
Value::Number(n) => MyLuaValue::Number(n),
Value::Integer(n) => MyLuaValue::Number(n as f64),
Value::String(s) => MyLuaValue::String(s.to_string_lossy()),
Value::Table(t) => {
let mut pairs = Vec::new();
t.for_each(|k, v| {
pairs.push((k, v));
Ok(())
})?;
MyLuaValue::Table(pairs)
}
_ => return Err(mlua::Error::runtime("Invalid storage type")),
})
}
}
impl IntoLua for MyLuaValue {
fn into_lua(self, lua: &Lua) -> mlua::Result<Value> {
Ok(match self {
MyLuaValue::Nil => Value::Nil,
MyLuaValue::Boolean(b) => Value::Boolean(b),
MyLuaValue::Number(n) => Value::Number(n),
MyLuaValue::String(s) => Value::String(lua.create_string(s)?),
MyLuaValue::Table(items) => {
let table = lua.create_table()?;
for (k, v) in items {
table.set(k.into_lua(lua)?, v.into_lua(lua)?)?;
}
Value::Table(table)
}
})
}
}
fn storage(lua: &Lua, default: MyLuaValue) -> mlua::Result<MyLuaValue> {
puffin::profile_function!();
let context = unsafe { context(lua) };
Ok(context
.storage
.get()
.map(|state| postcard::from_bytes(state).unwrap())
.unwrap_or(default))
}
fn set_storage(lua: &Lua, new_state: MyLuaValue) -> mlua::Result<()> {
puffin::profile_function!();
let context = unsafe { context(lua) };
context.operation_queue.push(Operation::UpdateStorage {
new_save: postcard::to_stdvec(&new_state).unwrap().into_boxed_slice(),
});
Ok(())
}
fn clock(lua: &Lua, _: ()) -> mlua::Result<f64> {
puffin::profile_function!();
let context = unsafe { context(lua) };
Ok(context.time.monotonic_now().as_secs_f64())
}
fn time(lua: &Lua, input: Option<Table>) -> mlua::Result<f64> {
puffin::profile_function!();
let context = unsafe { context(lua) };
if let Some(input) = input {
let date = chrono::NaiveDate::from_ymd_opt(
input.get("year")?,
input.get("month")?,
input.get("day")?,
)
.unwrap();
let time = chrono::NaiveTime::from_hms_opt(
input.get("hour").unwrap_or_default(),
input.get("min").unwrap_or_default(),
input.get("sec").unwrap_or_default(),
)
.unwrap();
let datetime = chrono::NaiveDateTime::new(date, time)
.and_local_timezone(chrono::Local)
.unwrap();
Ok(datetime
.signed_duration_since(chrono::DateTime::UNIX_EPOCH)
.as_seconds_f64())
} else {
Ok(context
.time
.system_now()
.duration_since(SystemTime::UNIX_EPOCH)
.unwrap()
.as_secs_f64())
}
}
fn delta_time(lua: &Lua, _: ()) -> mlua::Result<f64> {
puffin::profile_function!();
let context = unsafe { context(lua) };
Ok(context.time.delta_time().as_secs_f64())
}
|
