Struct ScriptEngine 

pub struct ScriptEngine {
    pub log_queue: Arc<Mutex<Vec<(String, String)>>>,
    /* private fields */
}

Lua Scripting Motoru — Genişletilmiş API ile oyun mantığını yönetir

Fields

log_queue: Arc<Mutex<Vec<(String, String)>>>

Log messages emitted from Lua (print), stored as (level, message) pairs.

Implementations

impl ScriptEngine

pub const DEFAULT_INSTRUCTION_BUDGET: u32 = 2_000_000

Default ceiling for a single call into Lua: on_update for one script, one entity hook, or the top level of a script being loaded.

Two million instructions is generously above what a per-frame script should ever execute and far below “the window stopped responding”. It is a runaway guard, not a performance budget: a script that trips it has a bug, and the alternative to tripping it was hanging the process, because while true do end in a Lua VM the host has no timeout on is unrecoverable — no signal, no watchdog, and the frame never ends.

pub const DEFAULT_MEMORY_LIMIT: usize

Default ceiling on the VM’s heap. Reached, an allocation fails as a catchable Lua error instead of the process growing until the OOM killer decides which program dies — which on a machine running an editor and a game is not necessarily this one.

pub fn new() -> Result<Self, LuaError>

pub fn set_instruction_budget(&mut self, instructions: u32)

Change the per-call instruction ceiling. Rounded down to a multiple of the hook step, and never to zero — a budget of zero would fail every script on its first hook.

pub fn set_memory_limit(&mut self, bytes: usize) -> Result<usize, LuaError>

Change the VM’s heap ceiling in bytes. Returns the previous limit.

pub fn load_script(&mut self, path: &str) -> Result<(), String>

pub fn update( &mut self, world: &World, input: &Input, dt: f32, ) -> Result<(), String>

Her frame çağrılan güncelleme — World verilerini Lua’ya aktarır, scriptleri çalıştırır

pub fn declared_properties( &self, script_path: &str, ) -> BTreeMap<String, ScriptValue>

Per-entity script güncelleme — Script component’i olan entity’ler için izole ortamda çalıştırır The properties a script DECLARES, read from its properties table.

The convention is a plain assignment at the top of the file:

properties = { open_speed = 2.4, locked = false }

which lands in the script’s own environment (_G is that environment — see load_script). This is the schema and the defaults: the editor lists these names, and an entity that has not overridden one runs with the declared value.

Anything that is not a number, boolean or string is skipped rather than guessed at — a nested table is a script’s own business and not an inspector row.

pub fn update_entity( &mut self, entity_id: u32, script_path: &str, dt: f32, properties: &BTreeMap<String, ScriptValue>, ) -> Result<(), String>

Runs on_entity_update(entity_id, dt, props) for one entity.

properties are that entity’s own values — the third argument exists because scripts are loaded per PATH, so two entities running the same file share one Lua environment and cannot each keep a value in it. Passing them is additive: a script whose on_entity_update takes two parameters simply ignores the third, which is why this did not need a new hook name.

pub fn flush_commands(&self, world: &mut World, dt: f32) -> Vec<ScriptCommand>

Komut kuyruğundaki tüm komutları World’e uygular ve oyun mantığı için kalan komutları döndürür

pub fn get_pending_audio_scene_commands(&self) -> Vec<ScriptCommand>

Runtime’da bekleyen ses/sahne komutlarını döndürür (demo tarafında ele alınır)

pub fn reload_if_changed(&mut self, path: &str) -> Result<bool, String>

Script’in hot-reload edilip edilmeyeceğini kontrol eder

pub fn has_function(&mut self, path: &str, name: &str) -> bool

Belirli bir isimdeki Lua fonksiyonunun var olup olmadığını kontrol eder

Takes &mut self even though it only reads: registry_value mutates the underlying lua_State, and the unsafe impl Sync above is only sound while no &self method reaches the VM.

pub fn run_entity_update( &mut self, path: &str, func_name: &str, ctx: &ScriptContext, ) -> Result<ScriptResult, String>

Belirli bir isimdeki Lua fonksiyonunu çağırır (per-entity scriptler için)

Takes &mut self: calling into the VM mutates the lua_State, and the unsafe impl Sync above is only sound while no &self method does that.

pub fn command_queue(&self) -> &Arc<CommandQueue>

Komut kuyruğuna doğrudan erişim (internals)

Trait Implementations

impl Debug for ScriptEngine

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Sync for ScriptEngine