►
Description
In this talk, Herbert will walk you through how he got started with Rust, created the Rust Roguelike Tutorial and then Hands-On Rust. The talk will focus on using game development as a means of learning Rust, and step through the creation of Flappy Dragon - a simple game used in Hands-On Rust to teach the language basics.
About Herbert Wolverson
Herbert Wolverson has worked as a programmer and an indie game developer since the late 1990s. He’s taught programming and IT skills at a variety of levels, contributes to multiple Open Source projects, and is active in the game development scene.
Rust Linz at https://rust-linz.at
Twitter: https://twitter.com/rustlinz
Herbert Wolverson: https://twitter.com/herberticus
Speak at Rust Linz: https://sessionize.com/rust-linz
A
A
And
hopefully,
why
you
should
listen
to
me?
Then
we're
going
to
look
at
making
a
game
flappy
dragon.
It's
only
a
couple
of
hundred
lines
of
rust
code,
it's
pretty
straightforward
and
it's
a
good
example
of
how
rust
can
be
very
productive
for
making
a
game
and
then
we're
going
to
look
at
the
rust
game
development
ecosystem
overall,
looking
at
a
few
of
the
engines
that
are
starting
to
come
along
looking
at
the
explosive
growth
in
rest,
use
in
the
game
industry
and
then
we'll
open
up
for
questions.
A
A
A
Now
I
was
at
the
tender
age
of
six
or
seven
at
the
time,
and
it
wasn't
long
before
I
was
starting
to
get
fed
up
with
just
the
games
that
were
on
the
intro
intro
tape.
Yep.
We
loaded
games
from
cassette
back
then
into
all
32k
of
ram,
so
my
dad
started
showing
me
basic
yours.
You
can
see
on
the
right.
What's
probably
the
first
program,
most
people
write
when
they
pick
up
a
boosie
micro,
hello,
world
and
back
then
the
norm
was
that
magazines
came
out.
A
A
So,
over
the
last
decade,
or
so,
I
was
primarily
writing
games
in
c
or
c
plus,
plus
using
gcc
individual
studio.
It
actually
got
started
out
with
text
based
muds,
the
old
ones.
Where
the
console
says
you
are
in
a
10
foot
by
10
foot
room.
There
is
a
hole
in
the
ground
here
and
if
somebody
else
who's
logged
into
the
same
system
comes
in
it'll
tell
you
herbert
is
here
and
you
might
interact,
you
might
not,
but
it's
very
simple,
text-based
stuff,
but
it
helps
a
lot
of
fun.
A
Then
I
started
getting
into
tile-based
games,
ang
band
net
hack,
that
sort
of
thing
and
started
bringing
working
on
bringing
in
graphics
to
those
I
became
completely
addicted
to
dwarf
fortress,
which
I
still
think
is
the
best
game.
Ever
and
knox
futura
is,
I
think,
at
some
point
in
people's
lives.
Everybody
decides
that
they're
going
to
make
a
dwarf
fortress
knox.
A
Sorry,
you
didn't
need
to
skip
yet
the
unreal
is
fantastic
in
that
you
can
lay
out
your
maps
write
a
lot
of
code,
things
work
and
it's
a
real
pain
in
that
you
allocate
memory,
do
something
with
it,
and
unreal
actually
has
a
garbage
collector,
but
you're,
never
quite
sure
when
it's
going
to
run-
and
you
very
quickly
start
tying
yourself
in
knots
with.
Maybe
the
subject
is
this:
maybe
it
doesn't,
and
likewise
when
you're
threading,
I
particularly
when
you're
sending
events
in
between
actors.
A
It
gets
pretty
muddy
as
to
which
thread
the
event.
Will
fire
on
what
exactly
will
happen
and
I
started
getting
into
fun
problems
that
on
my
relative
potato
development
computer,
my
game
would
run
great,
give
it
to
somebody
running
a
absolute
monster
with
tons
of
cars
and
lots
of
ram,
and
things
would
randomly
break.
A
So
I
wanted
to
know:
is
this
going
to
help
me
and
from
what
they
were
saying
it
sounded
like
it
was
going
to
be
a
really
good
shot
because,
first
of
all,
rust
won't
let
you
do
really
stupid
things
with
memory
and
believe
me,
I
was
getting
really
good
at
doing
stupid
things
with
memory
and
multi-threaded.
Synchronization
is
rust's
other
big,
strong
point.
I've
seriously
never
used
a
language
that
made
threading
so
easy
and
that's
just
that's
just
lovely,
so
the
roguelike
dev
forum
on
reddit
was
running
a
let's
make
a
roguelike.
A
They
do
this
every
summer.
Typically,
they
provide
a
tutorial
in
python
using
like
a
library
called
libp
cod.
Well,
I
decided
okay.
Well
I
I
know
this
much
python
and
I've
written
this
in
c,
so
I'm
gonna
follow
along
with
the
tutorial,
but
I'm
going
to
concurrently,
try
and
write
it
and
rest
use
it
to
learn
rest,
and
it
was
a
you
know
a
little
bit
of
a
rocky
start,
but
the
program
you
can
see
running
on
the
right
side.
B
A
Slide
was
the
result.
I
made
it
all
the
way
through
the
tutorial.
I
did
prove
the
old
adage
that
if
you
write
c
for
long
enough,
then
sooner
or
later
you
can
write
c
in
any
language.
I
quickly
started
to
realize.
Yes,
this
works.
I
like
rust.
I
need
to
go
back
and
I
need
to
create
this
in
good
rest
and
because
I
really
wanted
to
provide
some
solid
underpinnings.
I
created
bracket
lube
bracket
lid
is
a
lot
like
led
cod,
which
is
it's
primarily
a
virtual
console.
A
It
can
compile
to
native
gl
random
cursors.
If
you
want
to
use
it
over
ssh
compile
into
a
web
assembly,
it's
relatively
flexible.
I
actually
made
version
0.01
in
a
day,
and
most
of
that
was
spent
figuring
out
opengl
bindings
over
the
next
couple
of
years,
or
so
it's
gained
just
about
everything
from
pathfinding
to
field
of
view,
and
it
did
this.
As
I
was
working
on
the
taking
my
seven
day.
A
A
A
And
because
they
were
curating,
specs
and
tutorial
spends
a
lot
of
time
using
it,
they
onboarded
the
rust
tutorial
into
the
amesis
foundation.
They
were
also
talking
to
a
company
called
the
pragmatic
publishers,
pregra
about
getting
a
book
about
game,
rust,
game
development,
the
publisher
liked
what
they
saw
from
the
tutorial.
After
a
few
weeks,
it
was
decided
that
I
would
create
hands-on
rasp,
which
initially
started
that
life
known
as
learn
rust
by
making
a
game,
and
that
book
is
currently
on
it,
bringing
its
way
to
production.
A
I'll,
give
you
some
details
about
it
in
a
minute
now,
for
this
next
section,
we're
going
to
be
looking
at
a
game
called
flappy
dragon
flappy
bird.
This
is
the
third
chapter
in
the
hands
on
rust.
It's
flappy
bird
has
very
much
become
the
hello
world
of
game
programming
and
for
quite
a
few
reasons.
First
of
all,
it's
a
great
way
to
try
a
new
language.
It's
simple
enough
that
even
writing
it
low
level
you're
not
going
to
need
more
than
one
file
worth
of
code.
A
They
task
the
artists,
they
spend
a
really
long
time,
making
everything
beautiful
and
then
they
play
the
game
and
discover.
Well,
this
is
not
fun.
We
have
to
make
some
pretty
big
changes.
So
whenever
I
start
a
project,
I
try
to
stick
to
very
simple.
If
it's
3d
basic
cube
sphere
type
things,
if
it's
2d,
I
pretty
much
usually
start
with
ascii
or
something
hand
drawn
in
microsoft,
paint
you
that
way,
you're
keeping
it
simple.
Once
you've
got
a
prototype
that
works.
A
A
A
Now
flappy
bird
is
great,
because
there's
only
one
control
flap,
which
adds
upward
velocity,
you
press
the
flap
control
you
flap
upwards.
Conversely,
you've
continually
got
gravity
pulling
you
down
towards
the
bottom.
If
you
fall
off
the
bottom
of
the
screen,
you're
dead,
there's
also
because
otherwise
this
would
be
a
really
simple
game.
Obstacles
appearing
on
the
screen,
you
have
to
try
and
dodge
the
obstacles
if
you
hit
them
once
again,
you're
a
dead
bird.
A
So
when
you
do
cargo
new
and
create
your
project,
you
find
yourself
looking
at
hello
world
now
the
problem
with
follow
up
with
just
starting
typing
and
printing
out
your
level
is
that
games
work
a
little
differently
from
console
programs.
Your
operating
system
is
continually
sending
you
a
stream
of
events.
It
might
be
telling
you
the
mouse
moved
over
here.
Somebody
moves
the
window,
somebody
resized
the
window.
A
Somebody
closed
the
program
even
or
you
know
if
they
want
to
give
you
nightmare,
feel
somebody
dragged
the
window
to
between
two
monitors,
each
of
which
has
a
different
display
scaling
and
under
the
hood.
You
find
yourself
having
to
worry
about
most
of
these
and
that's
why
bracket
lib
simplifies
things
a
little
bit
well,
but
instead
of
a
typical
console
program
which
blocks
every
time
it's
waiting
for
input,
you
want
to
keep
running.
So
if
you
were,
you
could
do
this
purely
on
a
console
using
threads
or
using
non-blocking.
A
I
o,
and
it
starts
to
get
messy
and
not
very
cross-platform.
It
also
starts
to
get
stuttery
when
you
start
to
build
a
really
big
game
so
to
support
so
pretty
much
every
game
out.
There
uses
a
game
loop
now
game
loops,
typically
start
up
by
doing
all
of
the
interaction
required
with
the
operating
system
to
actually
get
a
window
on
the
screen.
In
some
cases,
that
can
be
a
lot
more
work
than
you
might
think.
A
For
example,
I've
seen
simple
vulcan
or
wgpu
initialization
wind
up
at
four
or
five
hundred
lines
of
code,
and
you
need
to
make
that
cross-platform
not
worry
about
it
too
much
so
generally.
Let
the
library
do
that
for
you
and
then
going
into
the
loop
at
the
beginning
of
the
loop
you,
your
library,
will
be
asking
the
operating
system.
A
So
tell
me:
what's
going
on
pulling
pulling
it
for
state
and
you'll
start
getting
notice
that
the
cursor
moved
keys
were
pressed,
you
might
get
notice
that
somebody
wants
to
quit
altogether
now,
if
you're
still
going,
then
you
call
it.
Then
the
library
calls
into
your
program's
pick
function
and
tick.
Is
your
interface
with
the
universe,
we'll
be
writing
one
in
just
a
second
tick,
typically
runs
30
or
more
times
a
second,
because
it's
running
every
time
the
operating
system
is
refreshing.
A
A
So
when
it
comes
out
of
the
tick
function,
it's
then
up
to
the
library
to
take
the
whatever
data
it
has
that
describes
what
you
want
to
be
on
the
screen
and
actually
put
it
there
and
again,
you
start
getting
into
fun
with
ever
with
making
sure
that
this
applies
to
the
exact
platform
you're
riding
on.
So,
for
example,
you
might
be
talking
to
vulcan,
you
might
be
talking
to
opengl
or
metal,
and
ideally
your
library
should
extract
that
away
from
you
and
that's
probably
three
quarters
of
the
code
in
bracket
lib.
A
So
then
it
says
well,
have
we
been
told
we
need
to
quit?
If
you
have,
then
it
tears
everything
down,
which
again
is
more
work
than
you
might
think.
If
it
hasn't,
then
you
go
back
to
step
two
and
you
look
for
look
for
more
information,
and
the
game
just
keeps
on
looping
through
this
until
there's
nothing
else
to
do
so.
This
is
hello
bracket
terminal
implemented
using
bracket
lib,
we'll
be
going
over
the
elements
of
this
in
a
second,
but
just
to
give
you
an
overview
at
the
top.
A
You've
got
the
prelude
which
imports
all
of
the
things
that
I
thought
were
important
enough,
that
you
might
need
them
from
bracket
lit
state,
which
is
a
structure
we'll
talk
about
that
in
a
second
that
defines
everything
your
program
needs
to
remember,
while
it's
running
because
every
time
it
goes
into
tick,
it's
not
going
to
have
any
other
way
to
remember
what
its
previous
state
was.
Every
call
to
take
is
independent,
then
there's
the
tech
function
itself
and
at
the
very
bottom,
we
initialize
the
library.
A
So,
let's
start
by
taking
a
look
at
that
here
in
the
main
function,
we're
using
b
term
builder
to
request
an
80x50
text
console-
and
this
is
what's
called
the
builder
pattern-
and
you
see
it
all
the
time
in
rest,
you
typically
start
with
a
function
that
describes
the
basic
outline
of
what
you
want.
Then
you
call
more
and
more
with
functions.
Chained
together
like
this,
so
in
this
case
we're
specifying
the
window.
A
Title
should
be
flappy
dragon
and
then,
at
the
end
of
the
builder
pattern,
there's
usually
a
function
called
build
or
something
similar
that
when
you
call
it
sets
all
combines.
All
of
the
features
that
you
described
and
pulls
them
together
into
some
sort
of
overall
description
of
what
you
want
it's
I
find
it
a
much
more
friendly
approach
to
writing
configuration
either
a
giant
ini
file
or
typing,
or
having
to
remember
every
single
little
setting
in
a
giant
list
of
30
40
parameters
that
you
might
wind
up
with.
A
A
So
I
could
also
write
that
expect
and
then
a
nice
message
saying
failed
to
initialize
or
I
could
just
unwrap
it
and
in
the
event
of
an
error,
it
crashes
completely.
What
the
question
mark
does
is
it
says?
Well,
if
this
function
returns,
an
error
and
I
encounter
an
error
I'll,
simply
bail
out
and
and
the
rest
run
time
will
display
the
error
or,
if
you
wanted
to,
you,
can
be
calling
this
from
inside
other
functions,
catch
them
and
try
and
handle
it.
A
And
then
we've
got
the
context
we
made
the
state
object,
so
we
call
into
main
loop
and
we
pass
it
state
which
currently
doesn't
have
any
data
in
it.
Now
structures
are
just
like
objects
in
other
languages.
There
are
ways
combining
data
together
to
store
it
together.
In
this
case,
for
hello
world,
we
really
don't
have
anything
that
we
need
to
remember
from
the
previous
frame,
so
we
implement
gamestate,
which
is
a
trait
a
trait,
is
basically
an
interface
when
you
you
know,
bracket
lib
requires
that
you
implement
game
state
for
your
main
program.
A
Game
state
require
in
order
to
function.
Game
state
requires
that
you
have
a
tick
the
amount
itself
I
always
thought
was
a
little
ugly,
but
it
means
it
can
see.
The
contents
of
that
instance
of
state
and
ctx
context
is
just
a
link
to
the
terminal
itself
gives
you
various
commands
in
this
case
it
clears
the
screen
with
cls
and
it
prints
hello
bracket
terminal
on
the
screen.
A
Now
the
nice
way
thing
about
doing
it
with
trades
like
that
is
that
bracket
live,
doesn't
have
to
know
anything
about
how
your
program
works.
It
just
guarantees
that,
as
long
as
you
follow
the
contract
of
communicating
with
the
library
through
this
interface,
your
program
will
work,
and
as
long
as
I
don't
break
the
interface
I
can
update
bracket
lib
and
your
program
will
continue
to
work
all
right.
So
next
up
now
that
we've
looked
at
the
basic,
what
goes
into
flappy
dragon
and
we've
looked
at
how
to
get
hello
world
onto
the
screen.
A
We're
going
to
look
at
the
general
control
flow
that
defines
what
flappy
bird
looks
like
it's
actually
got.
One
of
the
most
simple
general
flows,
you'll
find
very
common
one.
When
you
launch
the
program,
it
shows
you
a
menu
asking
you.
Would
you
like
to
play
the
game
or
quit?
If
you
choose
to
play,
then
obviously
the
game
runs
sooner
or
later
it's
inevitable.
A
The
player
will
die
and
just
like
taxes,
you
can't
avoid
gravity.
Lobster
goals
forever.
When
that
happens,
you
go
to
a
screen
that
tells
you
game
over,
hopefully
tells
you
your
score
and
you
have
the
option
of
playing
again
or
bailing
out
and
quitting.
So
it's
relatively
simple.
Now
I
love
rest
enumerations.
They
are
very
detailed.
You
can
extend
them
massively.
This
is
a
really
simple
one,
but
I
find
that
it
really.
A
A
A
Rust,
isn't
very
strict
about
what
you
name
your
constructors.
You
typically
see
them
with
names
like
neo
or
default,
and
what
the
new
function
does
there
is.
It
just
sets
the
mode
to
be
we're
looking
at
the
menu,
and
we
also
made
a
function
called
restart
all
this
does,
is
it
tells
it
we're
going
to
start
the
game
or
restart
the
game
if
you've
previously
died
and
we're
going
to
set
the
game
mode
to
playing
also
made
a
function
to
display
our
main
menu?
This
is
very
straightforward.
A
If
you
saw
hello
world
and
context
cls
clears
the
screen,
then
it
prints
welcome
to
flappy
dragon
press
p
to
play
the
game
cue
to
quit
the
game.
Now,
if
let
is
probably
my
least
favorite
named
piece
of
syntax,
it's
really
the
same
thing
as
match,
but
just
for
one
case
and
what
it's
really
doing
here
is
it's
telling
you
there's
a
variable
in
context
called
key,
which
is
an
option:
it's
either
none
meaning
no
key
is
pressed
or
it's
sum
and
contains
a
key
code
telling
you
what
key
is
pressed.
A
It's
saying,
if
context
key
matches
the
pattern
of
sum
then
make
of
it
then
take
the
variable
key
from
inside
it
and
make
it
available
inside
this
block,
and
then
we
call
match
which
is
like
switch
or
case
in
other
languages,
and
if
it
matches
p,
then
we
restart
the
game.
If
it
matches
q,
we
tell
context
or
quitting
otherwise
the
underbar
means
everything
else
and
rust
will
not
let
you
skip
options.
A
This
extends
the
pick
function.
So
now
we've
got
the
game
mode.
We
know
if
it's
the
menu,
we
should
call
the
main
menu.
If
it's
game
over,
you
should
call
dead.
If
you're
playing
the
game,
then
you
call
play
and
I've
actually
created
stubs
for
dead
dead
looks
just
like
the
main
menu,
except
instead
of
saying
welcome
to
the
game.
It
says
you
are
dead
and
play
is
one
line
of
code
that
simply
says
that
you
are
dead.
A
Well,
it's
common
to
stub
things
out
like
this,
get
the
basic
structure
of
your
program
put
together
and
it
does
then
we've
extended
the
initialization
there
to
instead
of
calling
state
with
curly
brackets,
it
calls
the
constructor
and
on
the
right
you
can
see
the
entire
game
flow
of
the
game.
We
have
right
now
the
menu
comes
up.
You
press
p
to
play.
You
instantly
die.
You
are
dead
p
to
play
again
all
right,
so
that
isn't
a
whole
lot
of
fun.
Menu
quest
is
probably
not
everybody's
favorite.
A
A
A
So
that
way,
obstacles
will
get
closer
and
we'll
see
a
good
example
of
that
in
a
second
now,
the
y-coordinate,
just
like
a
graph,
is
telling
you
the
current
vertical
position
of
the
bird
and
velocity
which
you'll
notice
as
a
float
is
so
you
can
put
decimal
numbers
in
instead
of
having
to
just
use.
Whole
numbers
is
telling
you
the
current
vertical
movement
trajectory
of
the
bird
and
this
is
kept
independent
from
y,
because
velocity
is
cumulative.
A
So,
as
you're
as
gravity
affects
you,
you
start
falling
faster
when
you
flap,
you
start
moving
upwards,
and
these
can
add
together
to
give
you
relatively
smooth
movement
a
new
function.
Also,
this
is
attached
to
the
player
called
render.
It
simply
sets
one
character
on
the
terminal
to
a
yellow
and
black
at
symbol.
I
picked
the
at
because
in
a
lot
of
ascii
games
ad
is
traditionally
the
player.
A
A
So
we
start
off
by
saying:
if
our
current
velocity
is
less
than
2,
then
we
add
0.2
to
it
now,
there's
no
magic
in
those
numbers.
I,
as
with
a
lot
of
game
development,
I
started
with
other
numbers.
I
kept
changing
them
until
I
found
one
that
I
felt
flowed
felt
about
right.
It's
certainly
not
an
accurate
representation
of
gravity,
although
you
do
have
terminal
velocity,
so
your
velocity
won't
get
to
be
more
than
2.0
and
the
reason
for
that
was
that
you
are
falling
off
the
screen
far
too
rapidly.
A
If
now
y
zero
is
the
top
of
the
screen,
so
if
you've
fallen
off
the
top
of
the
screen,
we're
going
to
clamp
you
to
it,
so
you
can't
just
flap
off
the
screen
and
win
the
game,
and
then
we've
made
a
function
called
flap.
This
sets
the
velocity
to
minus
two.
Now,
as
you
saw
above,
we're
adding
velocity
to
fall
downwards,
so
subtracting
velocity
makes
you
jump
upwards
and
rather
than
modif,
rather
than
adding
it
to
the
current
velocity,
which
would
mean
you
had
to
absolutely
pound
the
space
bar.
A
So
now
that
we've
created
player,
all
that
remains
is
to
add
the
player
into
the
state
that
we've
been
carrying
around
with
us.
Also
added
in
a
function,
a
variable
called
frame
time,
we'll
talk
about
exactly
what
that
does
in
a
second.
But
it's
important.
We
set
it
to
zero
and
we'll
be
using
it
to
make
sure
that
the
game
runs
at
the
same
speed
on
different
computers.
A
A
That
way,
if
you
run
on
a
slow
computer
or
a
fast
computer,
it
renders
the
physics
ticks
along
at
the
same
speed,
and
it's
pretty
important.
You
remember
to
do
that,
because
otherwise
you
can
make
a
game
that
runs
beautifully
on
a
slow
computer
and
is
completely
unplayable,
and
when
you
give
it
to
your
friend,
who's
just
bought
the
latest
and
greatest
gaming
rig.
A
A
And
lastly,
if
player
y
falls
off
the
bottom
of
the
screen
screen
height,
then
we
set
it
to
end
the
game
and
on
the
right
here
you
can
see.
The
game
is
running
the
you
flap
a
few
times.
Eventually,
gravity
gets
the
better
of
you
you're
dead,
the
game
is
over
and
that's
actually
all
you
need
to
model
the
movement
of
the
bird.
A
So
the
next
element
that
we're
going
to
look
at
is
obstacles.
Obstacles
are
really
a
key
part
of
making
flappy
bird
an
interesting
game.
If
there
was
nothing
whizzing
on
the
screen
for
you
to
dodge,
then
you'd
have
absolutely
nothing
to
do
and
you
wouldn't
get
the
horrible
impact,
end
game
and
the
adrenaline
that
keeps
you
playing
so
we're
going
to
go
ahead
and
use
a
struct
to
define
an
obstacle.
A
Now,
if
you
remember
we're
increasing
the
guard's
x
position
every
turn
now
we
the
x
position
this
describes,
so
the
bird
is
describing
how
far
along
in
the
world
I
am
for
the
obstacle.
It's
also
saying
where
I
am
in
world
space
and
will
then
be
transformed
into
screen
space
with
the
effect
the
obstacle
is
getting
closer
and
closer
and
closer
to
the
bird.
A
A
A
So
we
start
off
by
transforming
screen
x,
which
is
the
current
x
minus
the
player
x
that
get
that
gives
you
the
effect
once
again
of
moving
the
world
around
the
bird.
Instead
of
vice
versa,
calculate
half
size,
we're
using
half
the
size
makes
sense
to
just
calculate
it
once
most
of
the
time.
The
up
the
compiler
optimizer
will
notice
that
you're
using
it
twice
and
not
penalize
you,
but
it's
always
good
to
be
clear.
A
A
And
then
we,
then
we
create
a
function
called
hit
obstacle.
Once
again,
we
calculate
half
the
size
does
x.
Match
is
saying:
is
the
player
adjacent
to
the
wall?
If
the
player
is
not,
there's
no
point
in
really
calculating
anything
else,
because
if
the
player
is
not
next
to
the
wall,
they
can't
hit
it.
A
A
A
I've
also
introduced
a
new
variable
called
score
because
you
saw
it
in
the
obstacle,
and
so
when
you
create
a
new
game,
you
set
the
score
to
zero.
You
also
repeat
this
code
in
restart,
I
run
the
tech
function.
It's
actually
pretty
simple
to
wire.
This
up,
you
add
obstacle,
render
to
the
to
the
text
function
and
it
renders
the
obstacle.
A
A
The
biggest
change
here
was
that
I
explicitly
set
the
score
to
zero,
because
I
forgot
to
do
that
earlier
and
then
on
this
in
the
play
function,
when
it
tells
you
press
space
to
flap,
we've
added
a
line
print
the
current
score
now
you'll
notice.
This
uses
the
format
macro,
which
is
one
of
the
really
most
beautiful
macros.
In
rest.
You
can
format
just
about
anything.
The
amount
of
controls
that
you
get
is
incredible
and
we've
extended
the
dead
function
to
say
you
are
dead.
A
A
A
A
So
animation
frames
like
I
like
you
saw
there-
was
there
were
a
total
of
four
graphics
there
representing
the
dragon
and
they
run
in
order.
So
you
start
off
with
the
dragon
with
his
wings
up
then
down
a
little
more
towards
the
bottom
starting
and
then
you,
then
you
go
back
the
other
way.
When
you
combine
these
together,
you
get
a
nice
bouncy
bouncing
slapping
dragon.
A
So
in
the
in
the
game,
we
define,
if
a
constant
array
called
dragon
frames,
just
listing
the
characters
on
the
character
indices
on
the
font
map.
Now
the
source
code
for
all
of
this
will
be
up
in
a
second,
so
don't
worry
too
much
about
following
along
and
we
extend
the
player
to
list
the
current
frame
and
the
now.
Obviously,
we
set
that
to
zero.
A
A
A
Likewise
for
in
gravity
and
movement.
We've
just
had
to
update
a
few
things
to
use
floating
point
numbers
instead
of
integers
we've
also
storing
frame.
This
is
the
current
animation
frame.
We
set
it
to
zero.
If
you
remember
it
adds
every
time
we
render
the
dragon,
we
add
one
to
it,
and
the
percentage
six
is
modulo
six,
which
is
the
same
as
a
remainder.
A
If
so,
the
frame
numbers
will
go
zero,
one,
two
three
four
five
and
then
back
to
zero.
This
will
get
you
your
animation
cycle
running
continuously
and
because
it
doesn't
we're
not
actually
tracking
how,
where
exactly
your
wings
are
at
any
time.
We
don't
really
need
to
worry
too
much
about
where
it
is
for
collision
detection
or
anything
like
that,
but
this
does
make
the
game
a
whole
lot.
A
A
The
positions
are
in
floating
point,
so
point
f.
Instead
of
just
point
and
self
dot
y
is
now
a
floating
point.
We
are
not
going
to
rotate
it
or
scale
it
where
calling
y
to
the
dark
blue
background
and
we're
pulling
the
character
to
render
out
of
frame
and
because
we
changed
layer,
it's
a
good
idea
to
change
it
back
at
the
end,
because
otherwise
you
might
forget,
and
wind
up
with
text
all
over
the
place.
A
A
The
game
itself
is
one
change
away
from
webassembly
friendliness
I'll,
be
posting
an
article
on
that
next
week.
The-
and
this
is
like-
I
said,
the
third
chapter
of
hands
unrest.
I
hope
you've
enjoyed
it
and
gained
something
to
gain
something
that
you
feel
like
you
can
build
and
hopefully
inspire
you
to
go
for
us
and
make
something
cool
and
to
help
you
make
something
cool.
A
We're
going
to
have
a
look
at
the
rest
game,
development
ecosystem,
so
full
disclosure,
first
of
all,
amethyst,
are
actually
the
sponsors
of
two
of
my
open
source
projects.
So
I
have
to
say
nice
things
about
them.
Fortunately,
that's
pretty
easy
because
they,
they
are
actually
really
great
bunch
of
guys
nice
to
work
with
now
we're
going
to
focus
initially
on
the
amethyst.
B
A
A
I
don't
know
if
you
use
unreal,
but
it
it's
really
quite
amazing.
The
first
time
you
pull
up
the
editor
download
some
marketplace.
Assets
drag
a
dragon
onto
the
screen,
drag
a
jeep
onto
the
screen
scroll
in
a
bit
of
terrain,
hit
play
and
you've
got
an
animated,
flapping
dragon
who
doesn't
do
anything
and
a
jeep
on
the
screen,
and
you
can
move
the
camera
around
and
then,
with
a
bit
of
dragon
drop.
You
can
turn
that
into
a
playable
but
simple
game
pretty
quickly,
so
unfortunately,
rust
does
not
have
that.
A
Yet
what
it
does
have
is
plug-ins
for
both
unity
and
unreal,
that
let
you
write
rust
code
interface
with
the
unreal
or
unity
engine
and
provide
some
of
the
safety
which
is
especially
useful
when
you're
writing
an
unreal.
Now,
the
only
downside
is,
you
can
get
into
second
syndrome.
Second
system
syndrome.
A
Sorry,
that's
a
tongue
twister
where
you've
defined
everything.
In
rest,
it
looks
beautiful
and
then
you
have
to
make
sure
you
output
everything
into
unreal.
That's
a
really
common
problem.
When
you're
calling
things
cross
language,
you
do
wind
up
duplicating
yourself
a
little
bit
actually,
as
you
saw
in
the
previous
excellent
talk,
but
rust
is
gaining
a
lot
of
popularity
amongst
game
developers
in
general
for
making
tools.
It's
not
really
there
yet
for
making
a
full-featured
next
assassin's
creed,
but
it
is
getting
there.
A
So
the
both
amethyst
and
bevy
are
entity
component
systems
based
now.
What
an
entity
component
system
is
is
it's
a
way
to
represent
most
of
your
gamers
data
and
decouple
having
functions
attached
to
all
of
your
data?
Instead,
you
have
systems
that
treat
your
ecs
like
a
sql
database,
so
you
might
say
I
want
to
apply
gravity.
A
So
I
need
all
entities
that
know
where
they
are
in
the
world
and
don't
have
a
tag
indicating
that
they
can
fly
so
then
your
system
would
go
through
and
apply
a
downwards
momentum
to
every
item
now
amethyst
and
then
bevy
also
extend
this
a
bit
by
providing
you
with
a
bunch
of
pre-made
components.
So
you
could
say
that
orgs
have
a
display
component.
That
makes
them
look
like
a
nasty
little
green
critter.
A
They
have
a
position
component,
but
then
you
would
write
some
game
logic
that
says,
look
at
all
the
position:
components
if
they're
find
things
that
are
adjacent
and
they
attack
each
other,
and
so
amethyst
is
currently
in
the
process
being
rewritten.
The
first
version
used
specs,
it's
currently
rewriting
to
legion.
A
Now
amethyst
is
a
very
slow
trajectory
for
development.
It
they
take
their
time.
They
try
to
make
things
work
when
they
release
them.
So
if
you
want
to
spend
a
long
time
on,
our
project,
diamond
list
is
pretty
safe
because
the
chances
are
they're
not
going
to
pull
too
much
of
the
rug
out
from
under
you.
A
Now
the
slow
trajectory
upset
and
bothered
a
few
people.
So
devi
came
along
the
ortho
primary
author
of
bevy
describes
it
as
being
amethyst
2.0.
I
know
there
are
some
discussions
between
the
groups.
It
may
yet
be
amethyst
2.0
and
it
is
under
massive
development
and
pretty
much
every
time.
I
look
at
rustgame.forms
something
new
with
bevy
has
come
out,
and
that
is
amazing.
A
It's
also
really
frustrating.
If
you're
trying
to
make
a
large
project
with
it,
I
would
recommend
waiting
a
little
bit
because
you
either
find
yourself
having
to
freeze
and
stick
to
a
certain
api
level,
or
you
find
yourself
rewriting
things
quite
a
lot
and
that's
inevitable
in
the
in
the
early
stages
of
any
sort
of
engine,
but
it
does
make
it
does
make
for
a
rather
frustrating
time
now.
Bevi
is
becoming
very
popular
for
2d
and
simpler
3d
games.
I've
seen
everything
from
3d
chess
to
pong
to
missile
defense
written
in
it.
A
It's
got
some
really
nice
tricks
like
hot
reloading,
they're,
really
working
hard
on
a
user
interface
layer
and
the
intent
is
that
once
the
ui
layer
works,
you'll
start
to
get
an
editor,
and
the
editor
is
partly
inspired
by
one
rust
project
that
I
recommend
keeping
an
eye
on
rg
3d,
just
like
amethyst
and
bevy.
It's
free,
open
source,
no
cost
libra
and
libra,
it's
also
under
heavy
development,
and
it's
already
hit
the
point
that
they
have
a
functional.
A
3D
editor
map
editor
a
certain
amount
of
network
code,
and
you
can
make
beautiful,
looking
first
person,
shooter
type
games
or
third
person
that
look
like
the
screenshots
you
see
on
the
right.
They
have
really
been
coming
along
fast
and
furious.
Every
time
I
look
at
their
website,
they're
producing
something
more
beautiful.
A
A
A
Now
the
book
is
in
beta
and
I
personally
thought
it
was
kind
of
weird.
The
books
have
a
beta
I'd,
never
heard
of
that
before,
but
the
growth
of
ebooks
makes
this
possible
so
version
one
comes
comes
up.
Everybody
who
buys
the
book
is
guaranteed
to
get
all
of
the
future
versions,
including
the
final
release,
just
as
an
ebook,
but
they're
kind
enough
to
send
me
a
rata
and
bug
reports.
A
So
some
successive
versions
have
been
getting
better
and
better
or
up
to
beta6.
Now
it's
currently
off
with
the
slightly
serpentine
process
of
production,
which
is
how
it
becomes
a
final,
hopefully
beautiful,
properly
laid
out
and
spelling
corrected
ebook,
and
it
will
also
be
available
in
full
color
on
paper
right
now
you
can
get
the
beta
on
pregprog.com.
A
If
you
use
the
coupon
rust
limbs,
that'll
get
you
a
10
discount
for
the
next
month
or
so
the
print
version
you
can
pre-order
on
amazon
waterstones.
Your
favorite
bookseller
should
be
available
either
late
june
or
early
july,
depending
on
how
bad
my
spelling
is
with
the
copywriters
all
right.
If
you
need
to
contact
me,
I
am
at
herberticus
on
twitter,
the
bracket
on
reddit,
and
I'm
in
the
discord.
A
Am
I
just
before
I
go
to
questions
I'd
just
like
to
say.
Thank
you
so
much
for
having
me.
It
really
is
an
honor
to
virtually
travel
around
the
world
and
talk
to
people
who
love
the
same
things.
I
do
I'm
hoping
when
there's
less
of
a
pandemic
issue
that
I
can
hopefully
come
and
do
some
of
this
in
person
all
right.
Thank
you.
B
Thank
you
so
much
herbert.
Thank
you.
Thank
you
very
much.
It
was
a
really
inspiring
talk
and
just
to
share
one
piece
of
feedback
that
we
got
you
see.
Aval
was
talking
wow.
This
was
really
eye
opening.
I
really
enjoyed
it.
It
was
so
interesting.
You
know.
Let
me
give
you
a
quick
personal
background.
B
As
one
of
the
mentors
of
the
coda
dojo
linz,
the
programming
club
for
kids,
I
spend
every
single
week
many
hours
with
with
with
pupils,
starting
at
let's
say,
eight
nine,
something
like
this
building
simple
games.
So
I
100
percent
agreed
to
your
saying
that
building
simple
games
is
a
great
way
of
learning
languages
and
I
very
much
enjoyed
what
you
showed
us
with
with
flappy
bird,
so
yeah.
I
think
you
just
changed
my
mind
about
whether
we
should
try
rust
even
for
relative
beginners,
and
that
is
my
first
question
to
you.
B
What
do
you
think
compared
to
all
the
language
that
you
have
learned?
What
is
the
the
amount
of
experience
that
a
young
coder
should
have
in
your
in
your
opinion,
to
start
learning
rust?
Is
it
a
good
first
language?
Is
it
a
good?
Second
language,
should
they
already
learn
c
before
they
approach
us?
What
is
your
point
of
view
on
that?
I
would
love
to
hear
that.
A
Your
first
language
should
probably
be
something
like
python
basic
something
simple
enough
that
it
won't
bite
you
too
hard
when,
while
you're
still
figuring
out
what
is
a
variable,
because
rust
is
a
great
ergonomic
language,
but
it
doesn't
have
at
least
until
the
publisher
lets
me
write
it.
It
doesn't
have
something
to
really
come
in
with
what
is
a
variable.
B
Yeah
yeah,
I
I
I'm
with
you.
We
we
do
a
lot
of
work
with
the
javascript
language
for
for
kids,
so
we
start
with
online
development
environments
and
maybe
rust
would
really
be
a
good,
a
good
second
language.
My
second
talk
would
my
second
question
would
be-
maybe
I
maybe
I'm
I
don't
know
a
tool
for
for
beginners.
I
love
web-based
development
environments.
B
Do
you
know
of
any
web-based
development
environments
with
which
somebody,
a
beginner,
could
build
a
simple
program
without
having
to
set
up
the
entire
tooling
and
rust
and
and
installing
visuals
to
the
code?
And
things
like
that?
You
know
that's
kind
of
a
hurdle,
and
I
would
love
to
hear
your
thoughts
on
how
we
can
make
it
as
simple
as
possible
for
beginners
to
get
rust
running
on
their
machine.
A
For
a
basic
console
based
programs
on
the
main
rust
website,
there's
a
rust
playground
and
I
actually
use
this
all
the
time
for
just
demoing,
some
things,
quick
and
simple:
it's
it's
not
so
good
when
you
want
to
make
something
complicated.
If
you
just
want
to
show
off
a
concept,
that's
great
now,
I
wish
I
could
remember
the
link
I'll,
try
and
find
it
and
send
it
to
you.
But
there
was
a
fellow.
A
A
few
months
ago
I
saw
was
working
on
a
webassembly,
rust
playground
and
it
was
coming
along
really
nicely.
You
could
start
to
define
much
more
complicated
programs,
it
can
pile
them
into
wassum
and
then
run
them
in
your
browser.
That
right
away
gives
you
access
to
opengl,
sound
libraries
and
all
sorts
of
more
complicated
features.
B
C
No,
I
don't
have
any
questions,
I'm
I'm
just
so.
First,
I'm
very
surprised
that
I'm
already
here,
my
kids
are
asleep
way
too.
Well.
Now,
that's
that's
that's
for
his
hand
and
I
was
able
to
catch
the
latter
half
of
the
talk,
so
that
was
that
was
very
nice
and
congratulations
on
your
book.
So
I'm
I'm
I'm
book
collector.
So
I
ordered
basically
every
rust
book
from
from
every
publisher
that
that
has
printed
books
you're
still
on
on
my
list,
but
I
I
guess
I
give
the
10
discount
a
go,
sounds
good.
A
C
C
A
C
B
I've
written
two
books
and
I
had
exactly
the
same
situation.
I
said
yes
to
the
second
book
before
I
really
finished
the
first
one
and
I
wasn't
really
aware
of
what
I'm
saying
yes
to,
but
at
the
end
it
was.
It
was
pretty
nice.
Yeah
writing
a
book
is
really
a
lot
of
work,
but
it
pays
off.
It's
really
a
nice
nice
thing,
yeah,
it's
fine,
okay,
I
think
with
that
we
are
through.
I
also
if
I
take
a
look
at
the
watch.
B
We
hit
today
the
two
hour
mark
that
we
have
set
for
our
meetup,
exactly
it's
7
30
here
and
yeah
herbert.
At
this
point,
we
have
to
say
thank
you
very
much
for
for
this
talk.
We
really
enjoyed
it
and
whenever
your
book
is
ready
or
when
you
have
something
to
tell
us
about
your
second
book,
whatever
you're
always
welcome
as
a
speaker
here
at
the
rust
meter
prince.
Thank
you
very
much
for
virtually
trading
traveling
from
the
united
states
to
to
linz.