Struct Registry 

pub struct Registry { /* private fields */ }

Implementations

impl Registry

pub unsafe fn from_raw(api: *const YogApi) -> Self

Build from the pointer passed by the runtime. Only called by export_mod!.

pub fn on_block_break<F>(&mut self, handler: F)

where F: Fn(&BlockBreakEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_chat<F>(&mut self, handler: F)

where F: Fn(&ChatEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_player_join<F>(&mut self, handler: F)

where F: Fn(&PlayerJoinEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_player_leave<F>(&mut self, handler: F)

where F: Fn(&PlayerLeaveEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_use_item<F>(&mut self, handler: F)

where F: Fn(&UseItemEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_use_block<F>(&mut self, handler: F)

where F: Fn(&UseBlockEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_attack_entity<F>(&mut self, handler: F)

where F: Fn(&AttackEntityEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_entity_damage<F>(&mut self, handler: F)

where F: Fn(&EntityDamageEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_entity_death<F>(&mut self, handler: F)

where F: Fn(&EntityDeathEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_entity_spawn<F>(&mut self, handler: F)

where F: Fn(&EntitySpawnEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_player_place_block<F>(&mut self, handler: F)

where F: Fn(&PlaceBlockEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_player_death<F>(&mut self, handler: F)

where F: Fn(&PlayerDeathEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_player_respawn<F>(&mut self, handler: F)

where F: Fn(&PlayerRespawnEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_advancement<F>(&mut self, handler: F)

where F: Fn(&AdvancementEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_entity_interact<F>(&mut self, handler: F)

where F: Fn(&EntityInteractEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_item_craft<F>(&mut self, handler: F)

where F: Fn(&CraftEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_explosion<F>(&mut self, handler: F)

where F: Fn(&ExplosionEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_item_pickup<F>(&mut self, handler: F)

where F: Fn(&ItemPickupEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_player_move<F>(&mut self, handler: F)

where F: Fn(&PlayerMoveEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_container_open<F>(&mut self, handler: F)

where F: Fn(&ContainerOpenEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_container_close<F>(&mut self, handler: F)

where F: Fn(&ContainerCloseEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_projectile_hit<F>(&mut self, handler: F)

where F: Fn(&ProjectileHitEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_tick<F>(&mut self, listener: F)

where F: Fn(&dyn Server) + Send + Sync + 'static,

pub fn on_server_started<F>(&mut self, listener: F)

where F: Fn(&dyn Server) + Send + Sync + 'static,

pub fn on_server_stopping<F>(&mut self, listener: F)

where F: Fn(&dyn Server) + Send + Sync + 'static,

pub fn on_command<F>(&mut self, name: impl AsRef<str>, handler: F)

where F: Fn(&CommandContext, &dyn Server) -> Option<String> + Send + Sync + 'static,

pub fn on_typed_command<F>( &mut self, name: impl AsRef<str>, schema: impl AsRef<str>, handler: F, )

where F: Fn(&CommandContext, &dyn Server) -> Option<String> + Send + Sync + 'static,

Register a command with Brigadier-typed arguments.

schema is a space-separated list of argument types: int, float, word, string (greedy, must be last), player, blockpos.

In the handler use ctx.arg_int(0), ctx.arg_blockpos(1), etc.

pub fn on_packet<F>(&mut self, channel: impl AsRef<str>, handler: F)

where F: Fn(&PacketEvent, &dyn Server) + Send + Sync + 'static,

pub fn on_client_packet<F>(&mut self, channel: impl AsRef<str>, handler: F)

where F: Fn(&PacketEvent, &dyn Server) + Send + Sync + 'static,

pub fn on_typed_packet<P, F>(&mut self, channel: impl AsRef<str>, handler: F)

where P: Packet + Send + Sync + 'static, F: Fn(&P, &dyn Server) + Send + Sync + 'static,

Register a typed-packet handler.

The payload is decoded from raw bytes using P’s Packet impl. Malformed payloads are silently dropped.

pub fn add_shaped_recipe(&mut self, recipe: ShapedRecipe)

Register a shaped crafting recipe.

pub fn add_shapeless_recipe(&mut self, recipe: ShapelessRecipe)

Register a shapeless crafting recipe.

pub fn add_furnace_recipe(&mut self, recipe: FurnaceRecipe)

Register a furnace smelting recipe.

pub fn register_item(&mut self, def: ItemDef)

pub fn register_block(&mut self, def: BlockDef)

pub fn register_inventory(&mut self, def: InventoryDef)

Register a real Container/Menu inventory screen — see yog_inventory::InventoryDef. Attach it to a block via BlockDef::inventory(id).

pub fn register_startup_grant(&mut self, grant: StartupGrant)

Register a startup grant: items/books to give once when a player first joins.

pub fn register_book(&mut self, book: &Book)

Register a book with its JSON-serialized content.

pub fn installed_mods(&self) -> Vec<ModInfo>

Register a menu entry — the host renders a button on vanilla screens (TitleScreen on Fabric, ModListScreen on Forge/NeoForge) that opens ui_id. label is the human-readable button text (e.g. “Yog Mods”). ui_id is the UI to open when clicked (e.g. “yog:modlist”). See installed_mods. During register() the list only contains mods loaded before this one.

pub fn interop(&self) -> Interop

Access the inter-mod communication layer.

Allows exporting function pointers from this mod and importing function pointers from other mods.

pub fn raw_api(&self) -> *const YogApi

Raw YogApi pointer — for passing to interop-imported functions that register content through the C ABI table directly.

pub fn register_menu_entry(&mut self, label: &str, ui_id: &str)

pub fn register_ui<F>(&mut self, ui_id: &str, handler: F)

where F: Fn(&str, &str) + Send + Sync + 'static,

Register a UI tree with an event callback. ui_id is the unique identifier (e.g. “mymod:menu”). handler receives (ui_id, event_id) when a widget is clicked.

pub fn schedule_once<F>(&self, delay_ticks: u64, handler: F)

where F: Fn(&dyn Server) + Send + Sync + 'static,

pub fn schedule_repeating<F>(&self, period_ticks: u64, handler: F)

where F: Fn(&dyn Server) + Send + Sync + 'static,

pub fn on_client_tick<F>(&mut self, handler: F)

where F: Fn(&ClientTickEvent) + Send + Sync + 'static,

Register a handler called every client tick (render thread, no server).

pub fn on_ui_render<F>(&mut self, ui_id: &str, handler: F)

where F: Fn(&GfxContext) + Send + Sync + 'static,

Register a render callback for a specific UI screen (ui_id).

Called from YogUIScreen.render() — i.e. AFTER renderBackground() darkens the screen — so your UI draws on top of the dimmed world view. Use this instead of on_hud_render for book/inventory screens.

Clicks are forwarded as "click:X:Y" via the register_ui handler so you can do hit-testing on your own stored layout.

pub fn on_hud_render<F>(&mut self, handler: F)

where F: Fn(&GfxContext) + Send + Sync + 'static,

Register a handler called every frame when the HUD is rendered.

gfx provides full GPU pipeline access plus 2D convenience draw calls. view_proj and camera_pos are zero in HUD context; use gfx.draw2d() for HUD elements.

pub fn on_world_render<F>(&mut self, handler: F)

where F: Fn(&GfxContext) + Send + Sync + 'static,

Register a handler called every frame at the end of world rendering.

gfx.view_proj() is the combined projection × view matrix (camera-relative). gfx.camera_pos() is the camera world position. To render at world position P, translate by P - camera_pos before drawing.

pub fn on_key_press<F>(&mut self, handler: F)

where F: Fn(&KeyPressEvent) -> bool + Send + Sync + 'static,

Register a handler for keyboard input (client-side). Return false to prevent Minecraft from processing the key.

pub fn on_screen_open<F>(&mut self, handler: F)

where F: Fn(&ScreenEvent) + Send + Sync + 'static,

Register a handler called when a GUI screen is opened.

pub fn on_screen_close<F>(&mut self, handler: F)

where F: Fn(&ScreenEvent) + Send + Sync + 'static,

Register a handler called when a GUI screen is closed.

Trait Implementations

impl Send for Registry

impl Sync for Registry