goud-engine 0.0.828

GoudEngine — build 2D and 3D games in Rust with zero FFI overhead
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

# GoudEngine Rust SDK

[![crates.io](https://img.shields.io/crates/v/goud-engine.svg)](https://crates.io/crates/goud-engine)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

> **Alpha** — This SDK is under active development. APIs change frequently. [Report issues](https://github.com/aram-devdocs/GoudEngine/issues) · [Contact](mailto:aram.devdocs@gmail.com)

Build 2D and 3D games in Rust with zero FFI overhead.

## Install

```bash
cargo add goud-engine
```

## Quick Start

```rust
use goudengine::*;

fn main() {
    // GoudGame, Transform2D, Sprite, Vec2, Color, etc.
    // are all available directly through this crate.
}
```

## Flappy Bird Example

A complete Flappy Bird game is included in [`examples/rust/flappy_bird/`](https://github.com/aram-devdocs/GoudEngine/tree/main/examples/rust/flappy_bird). Run it with:

```bash
cargo run -p flappy-bird
```

The example demonstrates the main loop, sprite rendering, physics, and collision detection:

```rust
use goudengine::*;

fn main() {
    let engine = Engine::new(SCREEN_WIDTH as u32, SCREEN_HEIGHT as u32, "Flappy Bird");
    let mut manager = GameManager::new(&engine, "examples/csharp/flappy_goud/assets");
    manager.start();
    engine.enable_blending();

    while !engine.should_close() {
        let dt = engine.poll_events();
        engine.begin_frame();
        engine.clear(0.4, 0.7, 0.9, 1.0);

        if !manager.update(&engine, dt) { break; }
        manager.draw(&engine);

        engine.end_frame();
        engine.swap_buffers();
    }
}

// Bird physics: gravity, jump cooldown, rotation smoothing
pub struct Movement {
    pub velocity: f32,
    gravity: f32,
    jump_strength: f32,
    jump_cooldown_timer: f32,
}

impl Movement {
    pub fn apply_gravity(&mut self, dt: f32) {
        self.velocity += self.gravity * dt * TARGET_FPS;
        self.jump_cooldown_timer = (self.jump_cooldown_timer - dt).max(0.0);
    }

    pub fn try_jump(&mut self) {
        if self.jump_cooldown_timer <= 0.0 {
            self.velocity = self.jump_strength * TARGET_FPS;
            self.jump_cooldown_timer = JUMP_COOLDOWN;
        }
    }
}

// Pipe pair: random gap position, AABB collision
pub struct Pipe { pub x: f32, pub gap_y: f32 }

impl Pipe {
    pub fn collides_with_bird(&self, bird_x: f32, bird_y: f32, w: f32, h: f32) -> bool {
        aabb_overlap(bird_x, bird_y, w, h, self.x, self.top_pipe_y(), PIPE_IMAGE_WIDTH, PIPE_IMAGE_HEIGHT)
        || aabb_overlap(bird_x, bird_y, w, h, self.x, self.bottom_pipe_y(), PIPE_IMAGE_WIDTH, PIPE_IMAGE_HEIGHT)
    }
}

// Game loop: update → collision → spawn pipes → draw layers back-to-front
pub fn update(&mut self, engine: &Engine, dt: f32) -> bool {
    self.bird.update(dt, engine.is_key_pressed(KEY_SPACE));

    for pipe in &mut self.pipes {
        pipe.update(dt);
        if pipe.collides_with_bird(self.bird.x, self.bird.y, BIRD_WIDTH, BIRD_HEIGHT) {
            self.start(); // reset on collision
            return true;
        }
    }

    self.pipe_spawn_timer += dt;
    if self.pipe_spawn_timer > PIPE_SPAWN_INTERVAL {
        self.pipe_spawn_timer = 0.0;
        self.pipes.push(Pipe::new());
    }

    self.pipes.retain(|p| !p.is_off_screen());
    true
}
```

Controls: Space / Left Click to flap, R to restart, Escape to quit.

## Why a Separate Crate

This crate re-exports `goud_engine::sdk::*` from the internal engine. A standalone crate lets you depend on `goud-engine` without pulling in FFI exports, codegen build scripts, or napi dependencies. It also provides a clean versioned package for crates.io.

The internal crate `goud-engine-core` on crates.io is not intended for direct use.

## Design

Unlike the C#, Python, and TypeScript SDKs which call through FFI, this crate links directly against the Rust engine with zero overhead.

```rust
// This crate is a single re-export:
pub use goud_engine::sdk::*;
```

## Links

- [Repository](https://github.com/aram-devdocs/GoudEngine)
- [Rust Examples](https://github.com/aram-devdocs/GoudEngine/tree/main/examples/rust)
- [License: MIT](https://github.com/aram-devdocs/GoudEngine/blob/main/LICENSE)