Rust & Gamedev

Giorgio Pomettini
ROME - APRIL 13/14 2018
Rust & Gamedev

C# C++
• Memory safety
• Portability (Mono)

C# C++
• Memory safety
• GC Spikes

C# C++
• Memory safety
• GC Spikes
• Performance
• Libraries

C# C++
• Memory safety
• GC Spikes
• Performance
• Libraries
• Segfaults

Why Rust?
• Guaranteed memory safety (without GC)

Why Rust?
• Performance similar to C/C++

Why Rust?
• The compiler prevents all data races

Why Rust?
• No null checking

Why Rust?
• Multiparadigm (Procedural, Functional and OOP*)

Why Rust?
• Has an integrated package manager

Why Rust?
• Great community

Why Rust?
• Great community
• Release cycle of 6 weeks

Why Rust?
Most loved programming language
by the Stack Overﬂow community in
2016, 2017 and 2018

A bit of history
•2009 - Graydon Hoare releases Rust 0.1

A bit of history
•2010 - Mozilla starts sponsoring Rust

A bit of history
•2011 - LLVM support as back-end

A bit of history
•2012 - First release of the compiler

A bit of history
•2012 - First release of the compiler
•2015 - Rust Stable 1.0

Hello World
$ curl https://sh.rustup.rs -sSf | sh

Hello World
$ cargo new hello_world --bin

Hello World
fn main() {
println!("Hello, world!");
}

Hello World
$ cargo run
Compiling hello_world v0.1.0 (file:///path/to/project/hello_world)
Running `target/debug/hello_world`
Hello, world!

Structs
struct Character {
hp: u32,
weapon: Weapon
}
struct Weapon {
name: String,
damage: u32
}

Structs
struct Character {
hp: u32,
weapon: Weapon
}
struct Weapon {
name: String,
damage: u32
}
TypeVariable name

Implementations
impl Character {
fn new() -> Character {
Character {
hp: 0,
weapon: Weapon::new()
}
}
}
impl Weapon {
fn new() -> Weapon {
Weapon {
name: String::from("None"),
damage: 0
}
}
}

Implementations
impl Character {
fn new() -> Character {
Character {
hp: 0,
weapon: Weapon::new()
}
}
}
impl Weapon {
fn new() -> Weapon {
Weapon {
name: String::from("None"),
damage: 0
}
}
}
Logic for Weapon struct
Constructor

fn main() {
let player: Character = Character::new();
player.hp = 10;
}

fn main() {
let mut player: Character = Character::new();
player.hp = 10;
}
Variables are immutable by default

fn main() {
...
let mut sword: Weapon = Weapon::new();
sword.damage = 5;
player.weapon = sword;
}

fn main() {
...
sword.damage = 5;
let mut ally: Character = Character::new();
ally.weapon = sword;
}

fn main() {
...
sword.damage = 5;
}
error[E0382]: use of moved value: `sword`
--> src/main.rs:10:19

Every value has a single owner at any given time.  
 
You can move a value from one owner to another, but when a
value’s owner goes away, the value is freed along with it.
Ownership (T)

Sword
Hp
Weapon
Stack
Player
Ally
Hp
Weapon
Name *
Damage

Sword
Hp
Weapon
Stack
Player
Ally
Hp
Weapon
Name *
Damage
Moved

fn main() {
player.hp = 10;
sword.damage = 5;
player.weapon = sword.clone();
}

fn main() {
player.hp = 10;
sword.damage = 5;
}
I clone the weapon

fn main() {
player.hp = 10;
sword.damage = 5;
}
I clone the weapon
The original weapon will be moved

fn main() {
player.hp = 10;
sword.damage = 5;
}
I clone the weapon
The original weapon will be moved
Out of scope: memory erased

fn main() {
player.hp = 10;
sword.damage = 5;
display_character_hp(player);
}
I want to make a function that displays the player’s hp

fn main() {
player.hp = 10;
sword.damage = 5;
display_character_hp(player);
}
But the player will be moved here

Borrowing (&T)
You can borrow a reference to a value.  
 
Borrowed references are temporary pointers; they allow you to
operate on values you don’t own.

fn main() {
player.hp = 10;
sword.damage = 5;
display_character_hp(&player);
}
I borrow the Player to the function

fn main() {
player.hp = 10;
sword.damage = 5;
}
I borrow the Player to the function
fn display_character_hp(character: &Character)
{
println!("The character has {:?} hps”, character.hp);
}
When I exit the scope Player will be available again

impl Character {
...
fn attack(&self, target: &Character) {
}
}

The function has a reference to itself
in order to get the weapon damage points
impl Character {
...
}
}

The function has a reference to itself
in order to get the weapon damage points
impl Character {
...
}
}
And borrows a player in order
to modify its HPs

impl Character {
...
target.hp -= self.weapon.damage;
}
}

fn main() {
...
ally.attack(&player);
}
Plot twist! The ally attacks!
impl Character {
...
}
}

fn main() {
...
ally.attack(&player);
}
impl Character {
...
}
}
error[E0594]: cannot assign to ﬁeld `target.hp` of immutable binding
--> src/main.rs:38:9
|
37 | fn attack(&self, target: &Character) {
| ---------- use `&mut Character` here to make mutable
38 | target.hp -= self.weapon.damage;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot mutably borrow ﬁeld of immutable binding

Mutable Borrowing (&mut T)
You can borrow a mutable reference to a value

Borrowing a mutable reference forbids any  
other access to the value

fn main() {
...
ally.attack(&mut player);
}
impl Character {
...
fn attack(&self, target: &mut Character) {
}
}

fn main() {
...
ally.attack(&mut player);
}
impl Character {
...
fn attack(&self, target: &mut Character) {
}
}
Now takes a mutable reference

• No dangling pointers
Was it hard?


• No memory leaks
Was it hard?


• No memory leaks

• No segfaults
Was it hard?


• No memory leaks

• No segfaults

• No data races
Was it hard?


• No memory leaks

• No segfaults

• No data races

• Performance comparable to C++
Was it hard?


• No memory leaks

• No segfaults

• No data races

• Performance comparable to C++

• Basically if it compiles, it will never break
Was it hard?

• Tough learning curve
Cons of Rust (ATM)


• Lack of libraries
Cons of Rust (ATM)



• Poor IDEs support
Cons of Rust (ATM)



• Poor IDEs support

• Long compile times
Cons of Rust (ATM)

• Tough learning curve *

• Lack of libraries *

• Poor IDEs support *

• Long compile times *

They’re working on it!
Cons of Rust (ATM)

Crates
[package]
name = "hello_world"
version = "0.1.0"
authors = ["Giorgio Pomettini <giorgio.pomettini@gmail.com>"]
Cargo.toml

Crates
[package]
version = "0.1.0"
[dependencies]
rand = "0.3"
Cargo.toml

Crates
[package]
version = "0.1.0"
[dependencies]
rand = "0.3"
extern crate rand;
use rand::Rng;
fn main() {
...
ally.weapon.damage = rand::thread_rng().gen_range(0, 10);
}
Cargo.toml

What about the IDE?
https://areweideyet.com/
• Syntax Highlighting
• Code Completion
• Code Formatting
• Debugging

What about the IDE?
https://areweideyet.com/
My pick: 
❤ VS Code + RLS ❤ • Syntax Highlighting
• Code Completion
• Code Formatting
• Debugging

Who uses Rust in production?
Everyday we work with something (partially) built in Rust

(Gamedev)

(Gamedev)
WAIT! Don’t leave the room yet!

(Gamedev)
“Penso che Rust sia il
linguaggio low level più
eﬃcace, pratico e divertente.
Codice legacy a parte ho
ﬁnalmente chiuso con C/C++”

(Gamedev)
Ho un sogno: entro i
prossimi dieci anni spero
che tutto il nostro codice
nativo sarà in Rust […]

(Gamedev)
“Rustiﬁzzare” le
codebase diventerà
presto un obbligo di
sicurezza per chi fa
platform development

Games written in Rust
SHAR (WIP, Steam) *
A futuristic soccer game with deterministic physics synchronized between clients

Citybound (WIP) *
Like SimCity but with a million people on the screen at the same time,
each one with a diﬀerent routine

A Snake’s Tale (Steam, App Store, Play Store) *
A colorful puzzle game. Runs on every PC and mobile platform

WitchBrook (WIP, Steam + Console) *
From the same authors of Stardew Valley. First pure Rust console game

Where should I start?
•Rust Book

•Rust Book
•Into_Rust();

•Rust Book
•Into_Rust();
•Programming Rust

•Rust Book
•Into_Rust();
•Programming Rust
•#rust-beginners IRC

•Rust Book
•Into_Rust();
•Programming Rust
•/r/Rust Reddit

•Rust Book
•Into_Rust();
•Programming Rust
•/r/Rust Reddit
•Clippy (code linter)

http://arewegameyet.com/

Game Engines
Piston GGEZ Amethyst
Pros
Cons

Game Engines
Pros
Modular

Lot of components

Support for 2d and 3d
Cons
Not beginner friendly

Game Engines
Pros
Modular

Lot of components

Inspired by Love2D

Easy to learn

Lightweight
Cons
Not beginner friendly Few components

Game Engines
Pros
Modular

Lot of components

Inspired by Love2D

Easy to learn

Lightweight
Data-driven

Good for prototyping

Cons
Not beginner friendly Few components Poor documentation

Let’s make an Idle Game!
// I load GGEZ
extern crate ggez;
use ggez::{GameResult, Context, ContextBuilder};
use ggez::graphics::{self, DrawMode, Point2, Font, Text};
use ggez::conf;
use ggez::event::{self, MouseButton};
struct MainState {
font: Font,
text: Text,
cookies: u32
}

impl MainState {
// Context Init. The context holds the hardware state
// GameResult is a value of type Result used for error handling
fn new(ctx: &mut Context) -> GameResult<MainState> {
// Load the text
let font = graphics::Font::new(ctx, "/DejaVuSerif.ttf", 32)?;
// Draw the empty text
let text = graphics::Text::new(ctx, "", &font)?;
let s = MainState { font, text, cookies: 0 };
// If we got no errors I return the state
Ok(s)
}
}

impl MainState {
// Context Init. The context holds the hardware state
// GameResult is a value of type Result used for error handling
fn new(ctx: &mut Context) -> GameResult<MainState> {
// Load the text
let font = graphics::Font::new(ctx, "/DejaVuSerif.ttf", 32)?;
// Draw the empty text
let text = graphics::Text::new(ctx, "", &font)?;
let s = MainState { font, text, cookies: 0 };
// If we got no errors I return the state
Ok(s)
}
}
In Rust errors are values (Result)

impl event::EventHandler for MainState {
fn update(&mut self, ctx: &mut Context) -> GameResult<()> {
// I draw the cookie amount on screen
self.text = graphics::Text::new(ctx, &format!("Cookies: {}", self.cookies), &self.font)?;
Ok(())
}
fn draw(&mut self, ctx: &mut Context) -> GameResult<()> {
// I clear the screen
graphics::clear(ctx);
// I draw the text
graphics::draw(ctx, &self.text, Point2::new(250.0, 150.0), 0.0)?;
// I draw a pseudo cookie
graphics::circle(ctx, DrawMode::Fill, Point2::new(400.0, 400.0), 100.0, 2.0)?;
// Blit
graphics::present(ctx);
Ok(())
}
fn mouse_button_down_event(&mut self, _ctx: &mut Context, _button: MouseButton, _x: i32, _y: i32) {
// Every time I click the screen I get one cookie
self.cookies += 1;
}
}

impl event::EventHandler for MainState {
fn update(&mut self, ctx: &mut Context) -> GameResult<()> {
// I draw the cookie amount on screen
self.text = graphics::Text::new(ctx, &format!("Cookies: {}", self.cookies), &self.font)?;
Ok(())
}
fn draw(&mut self, ctx: &mut Context) -> GameResult<()> {
// I clear the screen
graphics::clear(ctx);
// I draw the text
graphics::draw(ctx, &self.text, Point2::new(250.0, 150.0), 0.0)?;
// I draw a pseudo cookie
graphics::circle(ctx, DrawMode::Fill, Point2::new(400.0, 400.0), 100.0, 2.0)?;
// Blit
graphics::present(ctx);
Ok(())
}
fn mouse_button_down_event(&mut self, _ctx: &mut Context, _button: MouseButton, _x: i32, _y: i32) {
// Every time I click the screen I get one cookie
self.cookies += 1;
}
}
This is a trait. It’s like a C# interface

pub fn main() {
// Context Builder will set up the window
let cb = ContextBuilder::new("Cookie Clicker", "Pomettini")
.window_setup(conf::WindowSetup::default().title("Cookie Clicker"))
.window_mode(conf::WindowMode::default().dimensions(800, 600));
// I initialize the context
let ctx = &mut cb.build().unwrap();
// I set MainState as the starting state
let state = &mut MainState::new(ctx).unwrap();
// I run the event loop
event::run(ctx, state).unwrap();
}

But… is there Unity for Rust?

But… is there Unity for Rust?
https://github.com/GodotNativeTools/godot-rust

Let’s make our Game Engine!
C Bindings Pure Rust

Window + Input sdl2 glutin (GLFW)

Graphics gl-rs (OpenGL) glium

Audio alto (OpenAL) rodio

Physics nphysics

Physics nphysics
ezing (Easing), pathﬁnding (Pathﬁnding), tiled (Tilemaps)

Special thanks to the Rust Roma community
and in particular to Enrico Risa

• Mail: giorgio.pomettini@gmail.com

• Sito web: www.videogio.co

• Twitter: @dreamquest

Rust & Gamedev

More Related Content

What's hot

Similar to Rust & Gamedev

More from Giorgio Pomettini

Recently uploaded

Rust & Gamedev