astrelis 0.2.4

A modular 2D/3D game engine framework
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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

//! Basic example demonstrating the Astrelis engine with the plugin system.
//!
//! This example shows how to:
//! - Create an Engine with plugins
//! - Use the MinimalPlugins or DefaultPlugins
//! - Add custom plugins
//! - Access resources from plugins
//!
//! Run with: cargo run -p astrelis --example basic_engine

use astrelis::prelude::*;

// Define a custom plugin
struct GameConfigPlugin {
    title: String,
    version: String,
}

impl GameConfigPlugin {
    fn new(title: &str, version: &str) -> Self {
        Self {
            title: title.to_string(),
            version: version.to_string(),
        }
    }
}

// A resource that the plugin will register
pub struct GameConfig {
    pub title: String,
    pub version: String,
    pub debug_mode: bool,
}

impl Plugin for GameConfigPlugin {
    type Dependencies = ();

    fn name(&self) -> &'static str {
        "GameConfigPlugin"
    }

    fn build(&self, resources: &mut Resources) {
        resources.insert(GameConfig {
            title: self.title.clone(),
            version: self.version.clone(),
            debug_mode: false,
        });

        println!("GameConfigPlugin: Registered GameConfig resource");
    }
}

// Another plugin that depends on the first
struct DebugPlugin;

impl Plugin for DebugPlugin {
    type Dependencies = GameConfigPlugin;

    fn name(&self) -> &'static str {
        "DebugPlugin"
    }

    fn build(&self, resources: &mut Resources) {
        // Access and modify the GameConfig
        if let Some(config) = resources.get_mut::<GameConfig>() {
            config.debug_mode = true;
            println!("DebugPlugin: Enabled debug mode for {}", config.title);
        }
    }
}

fn main() {
    println!("=== Example 1: Building engine with custom plugins ===\n");

    let engine = Engine::builder()
        .add_plugin(GameConfigPlugin::new("My Game", "1.0.0"))
        .add_plugin(DebugPlugin)
        .build();

    // Access the registered resources
    if let Some(config) = engine.get::<GameConfig>() {
        println!("Game Title: {}", config.title);
        println!("Game Version: {}", config.version);
        println!("Debug Mode: {}", config.debug_mode);
    }

    println!("\n=== Example 2: Using MinimalPlugins ===\n");

    let engine = Engine::builder().add_plugins(MinimalPlugins).build();

    // Check that AssetPlugin was registered
    assert!(engine.has_plugin("AssetPlugin"));
    println!(
        "AssetPlugin is registered: {}",
        engine.has_plugin("AssetPlugin")
    );

    // List all registered plugins
    println!("Registered plugins:");
    for name in engine.plugin_names() {
        println!("  - {}", name);
    }

    println!("\n=== Example 3: Using FnPlugin for quick setup ===\n");

    let engine = Engine::builder()
        .add_plugin(FnPlugin::new("QuickSetup", |resources| {
            resources.insert(42i32);
            resources.insert("Hello, World!".to_string());
        }))
        .build();

    println!("Integer resource: {:?}", engine.get::<i32>());
    println!("String resource: {:?}", engine.get::<String>());

    println!("\n=== Example 4: Pre-inserting resources ===\n");

    let engine = Engine::builder()
        .insert_resource(vec!["item1", "item2", "item3"])
        .add_plugin(FnPlugin::new("ItemCounter", |resources| {
            if let Some(items) = resources.get::<Vec<&'static str>>() {
                println!("Found {} items", items.len());
            }
        }))
        .build();

    println!("Items: {:?}", engine.get::<Vec<&'static str>>());

    println!("\nAll examples completed successfully!");
}