lunar-core 1.0.0

core engine: game loop, ECS wiring, plugin system, scenes, hierarchy, error handling
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

//! engine core: game loop, ECS wiring, engine state
//!
//! this crate owns the main game loop and coordinates all subsystems.
//! game logic operates on handles, never direct references.
//!
//! # architecture
//!
//! the core crate ties together all engine subsystems:
//! - [`App`] provides a fluent builder for configuring the engine
//! - [`Engine`] owns the ECS world and schedule
//! - [`GameLoop`] manages fixed-timestep updates and frame capping
//! - plugins ([`GamePlugin`]) register systems and resources in dependency order
//!
//! # getting started
//!
//! ```ignore
//! use lunar_core::App;
//!
//! fn main() {
//!     App::new()
//!         .add_system(my_system)
//!         .run(60);
//! }
//!
//! fn my_system(time: Res<Time>) {
//!     println!("delta: {}s", time.delta_seconds());
//! }
//! ```

/// re-export `bevy_ecs` for direct ECS access
pub use bevy_ecs;
/// re-export lunar-math for math types
pub use lunar_math;

mod app;
mod command;
mod engine;
mod error;
mod game_loop;
mod hierarchy;
pub mod persist;
pub mod pool;
mod scene;
mod scene_format;
mod schedule;
mod state;
mod window;
mod world_manifest;

/// app builder and time resource
pub use app::{App, GamePlugin, LoopConfig, TickRateConfig, Time};
/// command registry for console commands
pub use command::{Command, CommandRegistry};
/// engine wrapper around `bevy_ecs` world and schedule
pub use engine::Engine;
/// error handling types
pub use error::{EngineError, EngineResult, ErrorEvent, ErrorSource};
/// game loop with fixed timestep
pub use game_loop::{GameLoop, TickRate};
/// entity hierarchy components and parent/child sync
pub use hierarchy::{Children, HierarchyPlugin, Parent, PostUpdate, sync_children};
/// scene system for game state management
pub use scene::{Scene, SceneManager};
/// scene definition format: RON authoring and binary runtime
pub use scene_format::{
	EntityDefinition, SceneData, SceneDefinition, SceneEntity, SceneInstance, SceneLayer,
	SceneLoader, SceneSprite, SceneTags, SceneText, SpriteDef, TextDef, TransformDef,
};
/// system scheduling: the built-in update stages
pub use schedule::UpdateStage;
/// engine running state
pub use state::EngineState;
/// world manifest: XML-based world definition with scenes and spatial chunks.
/// authoring + runtime types a game uses directly.
pub use world_manifest::{
	AdvancedSceneLoader, ChunkEntry, ComponentScene, EntityData, LoadMode, LoadedScenes,
	SceneEntry, StreamingConfig, StreamingState, WorldManifest,
};
/// compiled/interned manifest internals — reachable for tooling, but not part of
/// the game-facing contract (the manifest pipeline produces these; games don't author them).
#[doc(hidden)]
pub use world_manifest::{
	CompiledChunkEntry, CompiledSceneEntry, CompiledWorld, StringInterner, builtin_components,
};

/// window state resource, display resolution helpers, and available-resolutions resource
pub use window::{
	AvailableResolutions, DisplayResolution, STANDARD_RESOLUTIONS, WindowSettings,
	resolutions_for_aspect,
};

/// full prelude for game development
pub mod prelude;