# Simple Game Engine
This project aims to create a minimal, yet usable, game engine. It is heavily inspired by [the Pixel Game Engine][pge],
with the goal of creating something that abstracts away the complexities of creating graphical, interactive apps and
games. Right now, it's a thin wrapper around [SDL2][sdl2] (using the [sdl2
crate][sdl2-crate]) for visuals.
[pge]: <https://github.com/OneLoneCoder/olcPixelGameEngine>
[sdl2]: <https://www.libsdl.org>
[sdl2-crate]: <https://crates.io/crates/sdl2>
This is highly experimental so far, so if you have any ideas or would like to contribute, please [sub mit an
issue](https;//github.com/mcb2003/audio-game-engine-rs/issues).
## Features
* **Very simple to use:** Just implement the [`Application trait][sge::Application] on a type of your choice, then pass an instance of this type to [Engine::new()][Engine::new].
* **Powerful:** Anything you can do with sdl2 from Rust, you can do with this library, and we provide thin abstractions over some of the more convoluted sdl2 interfaces.
* **Built-in text rendering:** No need to find a TTF font and distribute it with your application, just call the [Canvas::draw_text()][Canvas::draw_text] method. ([see below](#caveats-with-text-rendering))
[sge::Application]: <https://docs.rs/simple-game-engine/0.6.1/simple_game_engine/trait.Application.html>
[Engine::new]: <https://docs.rs/simple-game-engine/latest/simple_game_engine/struct.Engine.html#method.new>
[Canvas::draw_text]: <https://docs.rs/simple_game_engine/latest/canvas/struct.Canvas.html#method.draw_text>
## Caveats With Text Rendering
This crate uses the [GNU Unifont][unifont] for built-in text rendering. As such, if you wish to use this feature, you
must distribute your project under the [GPL][gpl]. As this is not desirable for many projects, this feature is only
enabled if this crate is built with the "unifont" cargo feature.
```toml
[dependencies.simple-game-engine]
version = "0.8.2"
features = ["unifont"]
```
If you'd like to render text without using this font, consider checking out the [SDL2 TTF module][sdl2-ttf]
[unifont]: <http://unifoundry.com/unifont/index.html>
[gpl]: <https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html>
[sdl2-ttf]: <https://docs.rs/sdl2/latest/sdl2/ttf/index.html>
## Install
Add the following to your `Cargo.toml`:
```toml
[dependencies]
simple-game-engine = "0.8.2"
```
This crate depends on [sdl2][sdl2], which can be built and linked in several ways:
* By default, the system version of sdl is used if it exists.
* With the "bundled_sdl" feature, the latest version of sdl2 will be downloaded, compiled and dynamically linked to your program. This requires you install [cmake][cmake].
* With the "static_sdl" feature, sdl2 will be linked statically.
Please see the [sdl2 crate README][sdl2-readme] for installation instructions for each platform.
[cmake]: <https://cmake.org>
[sdl2-readme]: <https://github.com/Rust-SDL2/rust-sdl2#readme>
## Example
The simplest SGE program looks like this:
```rust
use simple_game_engine::{self as sge, prelude::*};
use std::error::Error;
struct App {}
impl sge::Application for App {
fn on_create(
&mut self,
canvas: &mut WindowCanvas,
input: &InputState,
) -> sge::ApplicationResult {
// Do one-time initialisation here
Ok(true) // `true` indicates to continue running the application
}
fn on_update(
&mut self,
canvas: &mut WindowCanvas,
input: &InputState,
elapsed_time: f64,
) -> sge::ApplicationResult {
// Handle user input, update the canvas, and perform any other tasks to be ran on each frame
Ok(true) // `true` indicates to continue running the application
}
}
fn main() -> Result<(), Box<dyn Error>> {
let mut app = App {};
let mut engine = sge::Engine::new(
&mut app, // Application instance
"Test App", // Window title
640, // Window width
480, // Window height
)?;
engine.start(true) // `true` starts the app with vsync enabled
}
```
`on_create` and `on_update` are optional, but their default implementation does nothing, so
you'll probably want to define some logic for at least `on_update`, which is called for every
frame.