shadowengine2d 2.0.0

A comprehensive 2D game engine built in Rust with ECS, rendering, audio, assets, animations, and scene management
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

// 2D Shooter Example for ShadowEngine2D
// Features: Player movement, shooting, enemies, score, UI widgets (slider, text input)


use shadowengine2d::prelude::*;
use winit::keyboard::KeyCode;
use shadowengine2d::ui::{SliderStyle, TextInputStyle};

struct GameState {
    score: u32,
    player_name: String,
    volume: f32,
}

fn main() -> EngineResult<()> {
    App::new()
        .set_window(WindowConfig {
            title: "2D Shooter Example".to_string(),
            width: 800,
            height: 600,
            resizable: false,
        })
        .add_startup_system(setup)
        .add_system(update)
        .add_system(ui_system)
        .insert_resource(GameState {
            score: 0,
            player_name: String::from("Player"),
            volume: 0.5,
        })
        .insert_resource(UiContext::default())
        .build()
        .run()
}

fn setup(engine: &mut Engine, resources: &mut Resources) -> EngineResult<()> {
    // Spawn player
    let player = engine.entities.spawn()
        .at_position(400.0, 500.0)
        .with_colored_square(Color::BLUE, 32.0)
        .build();
    resources.insert(player);
    Ok(())
}

fn update(engine: &mut Engine, resources: &mut Resources) -> EngineResult<()> {
    let player = *resources.get::<EntityId>().unwrap();
    let input = &engine.input;
    let mut pos = engine.entities.get_transform(player).unwrap().position;
    let speed = 300.0 * engine.time.delta_time();
    if input.is_key_pressed(KeyCode::ArrowLeft) || input.is_key_pressed(KeyCode::KeyA) {
        pos.x -= speed;
    }
    if input.is_key_pressed(KeyCode::ArrowRight) || input.is_key_pressed(KeyCode::KeyD) {
        pos.x += speed;
    }
    if input.is_key_pressed(KeyCode::ArrowUp) || input.is_key_pressed(KeyCode::KeyW) {
        pos.y -= speed;
    }
    if input.is_key_pressed(KeyCode::ArrowDown) || input.is_key_pressed(KeyCode::KeyS) {
        pos.y += speed;
    }
    if let Some(transform) = engine.entities.get_transform_mut(player) {
        transform.position = pos;
    }

    // Shooting
    if input.is_key_just_pressed(KeyCode::Space) {
        engine.entities.spawn()
            .at_position(pos.x, pos.y - 20.0)
            .with_colored_square(Color::new(1.0, 1.0, 0.0, 1.0), 8.0)
            .with_velocity(Velocity::new(0.0, -500.0))
            .build();
    }

    // Move bullets
    // Move bullets (iterate over all entities and update those with velocity)
    let entity_ids: Vec<_> = engine.entities.entities().to_vec();
        // Collect (entity, velocity) pairs first
        let moves: Vec<_> = entity_ids.iter()
            .filter_map(|&entity| engine.entities.get_velocity(entity).map(|vel| (entity, vel.velocity)))
            .collect();
        // Now mutate transforms in a separate loop
        let mut to_remove = Vec::new();
        for (entity, velocity) in moves {
            if let Some(transform) = engine.entities.get_transform_mut(entity) {
                transform.position.x += velocity.x * engine.time.delta_time();
                transform.position.y += velocity.y * engine.time.delta_time();
                if transform.position.y < -10.0 {
                    to_remove.push(entity);
                }
            }
        }
        for entity in to_remove {
            engine.entities.remove_entity(entity);
    }

    // TODO: Spawn/move enemies, collision, scoring

    Ok(())
}

fn ui_system(engine: &mut Engine, resources: &mut Resources) -> EngineResult<()> {
    // Split borrows for UiContext and GameState
    // Clone needed GameState fields first
    let (volume, player_name, score) = {
        let state_ref = resources.get::<GameState>().unwrap();
        (state_ref.volume, state_ref.player_name.clone(), state_ref.score)
    };
    let ui = resources.get_mut::<UiContext>().unwrap();
    ui.text("Volume", Position::new(20.0, 20.0), Color::WHITE);
    ui.slider(
        Rect::new(100.0, 20.0, 180.0, 24.0),
        0.0,
        1.0,
        volume,
        0.01,
        SliderStyle::default(),
    );
    ui.text("Name", Position::new(20.0, 60.0), Color::WHITE);
    ui.text_input(
        Rect::new(100.0, 60.0, 180.0, 32.0),
        &player_name,
        TextInputStyle::default(),
    );
    ui.text(format!("Score: {}", score), Position::new(20.0, 110.0), Color::WHITE);
    Ok(())
}