kon-engine 0.2.0

A modular 2D game engine for Rust, built with a focus on ECS performance and simplicity.
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
131
132
133
134
135
136
137

<p align="center">
  <img src="assets/kon_stacked.svg" alt="Kon Engine" width="210">
</p>

A modular 2D game engine in Rust with a custom SparseSet-based ECS. Built from scratch to learn how game engines actually work.

> ⚠️ **Heads up:** This is an experimental/educational project. I'm building this to understand engine internals, not to compete with existing engines.

## What's Inside


The project is split into workspace crates:

**Currently Working**
- **`kon_core`** - App lifecycle, plugins, events
- **`kon_ecs`** - Custom ECS
- **`kon_macros`** - Proc macros for `#[system]` and `#[component]`
- **`kon_window`** - Winit-based window management
- **`kon_input`** - Input handling

**Still Cooking 🍳**
- **`kon_math`** - Math stuff with Glam integration (WIP)
- **`kon_renderer`** - WGPU renderer (WIP)
- **`kon_physics`** - 2D physics (Planned)
- **`kon_editor`** - Editor tools (Planned)

## Features


- [x] Plugin-based architecture
- [x] Custom SparseSet ECS with O(1) component access
- [x] Write systems as regular Rust functions
- [x] Ergonomic query API
- [x] Event system for decoupled communication
- [x] Window context management
- [x] Keyboard/mouse input
- [ ] Hardware-accelerated 2D rendering
- [ ] Collision detection and physics
- [ ] Integrated editor

## Quick Example


Here's how you write a simple simulation:

```rust
use kon::prelude::*;

// Define your data
#[component]

struct Position { x: f32, y: f32 }

#[component]

struct Velocity { x: f32, y: f32 }

// Setup runs once
#[system]

fn setup(ctx: &mut Context) {
    ctx.window().set_config(WindowConfig::default().with_title("A beautiful title"));
    
    ctx.world()
        .spawn()
        .insert(Position { x: 0.0, y: 0.0 })
        .insert(Velocity { x: 1.0, y: 0.0 })
        .tag("player")
        .id();
}

// Movement runs every frame
#[system]

fn movement(ctx: &mut Context) {
    ctx.world()
        .select_mut::<(Position, Velocity)>()
        .each(|entity, (pos, vel)| {
            pos.x += vel.x;
            pos.y += vel.y;
            println!("{:?} moved to ({}, {})", entity, pos.x, pos.y);
        });
}

// Update runs every frame
#[system]

fn update(ctx: &mut Context) {
    if ctx.input().just_key_pressed(KeyCode::Escape) {
        ctx.quit();
    }
    
    ctx.on::<WindowCloseRequested>(|_, context| {
        context.quit();
    });
}

// Wire everything together
fn main() {
    Kon::new()
        .add_plugin(DefaultPlugins)
        .add_startup_system(setup)
        .add_system(movement)
        .add_system(update)
        .run();
}
```

## How to Use


**As a dependency:**

```bash
cargo add kon-engine
```

Or in your `Cargo.toml`:

```toml
[dependencies]
kon-engine = "0.2.0"
```

**From source:**

```bash
git clone https://github.com/cey0225/kon.git
cd kon

# Run examples

# Linux/macOS

./kon.sh ecs_demo/query_demo
./kon.sh ecs_demo/tag_demo

# Windows

./kon.ps1 ecs_demo/query_demo
./kon.ps1 ecs_demo/tag_demo
```

## License


Dual-licensed under MIT or Apache 2.0, pick whichever works for you.

- MIT: [LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT
- Apache 2.0: [LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0