►
From YouTube: Scalable Multiplayer Game Design with OpenShift (E4)
Description
This monthly series explores what it takes to design a scale-out multiplayer video game architecture using containers and OpenShift. There will be live coding, philosophical design discussion, and everything in between.
Host:
Erik Jacobs
Guests:
* Derek Reese
* Michael Clayton
* Roderick Kieley
* Jared Sprague
A
Hey
everybody
welcome
back
to
another
episode
of
our
scalable
game,
design
stream,
I
was
gonna,
say
podcast,
but
this
is
totally
totally
not
a
podcast.
I'm
mick
jacobs,
I'm
the
host
here,
leaving
this
merry
band
of
rabble,
rousers
and
full
stack
developers.
I
guess
we
all
decided
we
were
so
today.
We've
got
derek
gries.
B
A
Who,
unfortunately,
had
pulling
all
nighter
so
he's
a
little
under
the
weather?
We've
got
roger
keeley,
hey.
C
A
A
Yeah,
that's
right:
yeah
roofers!
So
today
we've
made
a
ton
of
progress
since
the
break
we
skipped
a
month
because
we
wanted
to
make
lots
of
progress,
and
so
today
we've
got
an
interesting
agenda,
we're
going
to
start
with
roddy
and
he's
going
to
talk
about
amqp
and
stump
and
all
things
messaging
and
then
sort
of
give
a
little
bit
of
a
high
level
tour
of
some
of
the
rip
and
replace
we
did
to
change
from
stomp
to
amqp
on
the
server
side,
and
then
we
made
a
suit.
A
I
made
a
super
hack
job
of
a
prototype
of
the
web
client
that
jared
then
turned
into
a
much
prettier
version.
That
actually
is
something
that
humans
can
develop
on
and
not
fat-fingered
ham-fisted
people
like
me
so
he's
gonna,
show
that
off
and
then
we're
gonna
talk
a
little
bit
about
actual
game
designee
stuff.
So
now
that
we
have
sort
of
a
play
field
and
players,
we
need
to
start
thinking
about
like
how
big
should
the
play
field
be.
Where
should
we
put
the
players?
A
You
know
clearly
if
people
are
shooting
each
other,
they
shouldn't
start
right
on
top
of
another,
or
maybe
they
should.
I
don't
know
we'll
talk
about
it.
So
that
being
said,
roddy
I'm
I'm
going
to
kind
of
make
it
your
show
a
little
bit
only
in
the
sense
of
share
your
screen.
Do
your
thing,
your
tour.
C
So
yeah,
so
looking
back
at
how
we
got
here,
we
took
basically
something
that
was
a
proof.
C
We're
all
here
today,
so
we
had
a
bunch
of
code
that
came
in
from
like
2012
era,
and
it
was
based
on
stump
so
that
we
could
communicate
into
the
browser
and
then
using
a
payload
of
essentially
google
protocol
buffers
right,
so
basically
websocket
on
the
browser
side
using
stomp,
which
is
a
simple
text,
oriented
messaging
protocol.
I
think
that's
what
stomp
stands
work.
I.
C
So
yeah
the
goal
there
was
to
talk
to
like
a
c
plus
back
end
and
have
talked
through
websocket
into
a
browser
and
at
the
time
it
was
through
like
through
flash
using
the
old
netscape
api
in
the
browser.
So
since
then,
now
we
have
the
like
eric
said:
we
have
a
javascript
based
web
client.
C
The
chart
just
basically
puts
a
nice
structure
around
using
npm
plus
the
knowledge
and
he
said
actually
structured
properly,
and
then
we
here
today
wanted
to
be
doing
more
modern
things
moving
into
an
open
shift
deployment
that
type
of
thing,
and
so,
if
we
look
at
what
stomp
is
as
a
protocol,
it's
a
an
implementation
of
the
jms
api
and
so
jms
was
you
know,
java
messaging
system
or
something
like
that,
and
that
is
very
much
a
middleware
oriented
protocol.
C
So
looking
forward,
we
wanted
to
be
using
amqp.
Now,
if
I
can
find
where
the
chat
is
on
the
twitch
screen
or
actually
in
the
discord
is
probably
a
great
place
to
drop.
It.
C
Yeah
that'd
be
good,
so
we
wanted
to
start
using
this
amqp
thing,
because
we
hear
red
hat
believe
in
open
standards
and
an
open
fully
internationally
recognized
standard
is
better
than
a
de
facto
standard,
so
amqp
is
actually
a
full
standard.
Let's
see
if
I
can
find
the
right
links.
C
First,
it
started
out
at
oasis
I'll
just
drop
the
link
into
the
discord
channel
here.
Okay,.
C
Okay,
perfect
and
as
well,
we
can
see
that
later
on.
Basically
over
the
course
of
a
couple
of
years,
it
was
fully
standardized
through
working
groups
and
committees
into
amqp
1.0,
which
is
an
iso
standard,
19464
colon
2014
all
fully
available
with
regards
to
the
standard,
and
if
you
want
to
understand
how
the
the
gory
details
works.
So
one
of
the
important
things
there
is
that
it
actually
fully
defines
how
the
data
looks
on
the
wire
and
it
defines
a
type
system.
C
C
So
even
though
all
message
brokers
may
have
been
jms,
api
spec
compliant,
the
api
was
the
same,
but
what
happened
on
the
wire
is
different.
So
activemq
had
this
thing
called
open
wire,
which
was
basically
the
definition
of
how
the
data
looked
in
binary
going
across
the
wire
right,
whereas
amqp
includes
that
in
specification.
So
not
only
is
it
the
protocol
and
the
api
and
the
behavior,
it
is
also
what
the
type
system
and
the
data
that
looks
like
on
the
wire.
C
Now,
of
course,
that
being
said,
we
sidestep
a
little
bit
of
that
because
we
use
google
protocol
buffers
as
the
payload
in
the
data
section
for
the
amqp
messages
right
and
one
of
the
reasons
that
well
we'd
started
out
using
protocol
buffers,
but
I
still
like
the
idea
of
using
protocol
buffers,
because
the
message
formats
are
not
implicit,
they're
very
explicit
and
you
define
these.protofiles
to
basically
layout
like
this
is
my
data.
This
is
this
particular
type
of
message.
C
C
D
A
A
C
And
you
also
may
need
to
be
confident
they
can
get
there
right.
So
we
with
amqp,
you
have
different
types
of
settlement
mode
like
you
can
send
and
wait
for
settlement.
You
can
send
a
pre-settled
which
is
more
like
a
fire
and
forget.
So
we
have
this
different
types
of
delivery
depending
on
the
need,
but
ultimately
we're
sending
over
tcp
right.
So
amqp
is
a
layer
above
tcp
and
tcp.
Is
you
know
how
the
internet
works
right?
C
C
Or
sometimes
doesn't
work
like
the
head
of
the
line
blocking
problem
that
you
know
sometimes
gets
run
into
where
things
that
had
to
go
from.
You
know
here
to
beijing
and
I'm
in
eastern
canada
had
to
pass
through
a
lot
of
hops
right
and
depending
upon
pack
of
prioritization,
and
any
number
of
factors
that
are
completely
outside
of
control.
C
Tcp
might
wait
or
it
may
take
a
while
for
the
packet
to
get
through
or
the
packet
might
disappear,
and
the
hardware
at
different
levels
decides.
Oh,
I'm
just
going
to
keep
resending
it
and
the
application
is
basically
like
hey
what's
going
on
here.
I'd
really
like
to
do
something,
but
I'm
waiting
for
this
one
packet
and
then
one
packet
disappears
then
has
to
transmit
a
whole
bunch
again
so
like
it
can
be
a
really
bad
thing
when
it
comes
to
introducing
latency
this,
which
is
bad
for
games
right.
So
generally,.
C
For
some
types
of
games,
that's
true,
but
ideally
we
would
like
to
use
amk
for
all
types
of
games
and
host
all
types
of
games
on
openshift
right.
So
there
is
some
movement
to
utilize,
for
example,
the
library
where
we're
using
for
the
server,
which
is
now
called
cupid
proton,
which
is
an
amqp
implementation.
C
Move
there
to
basically
make
that
support,
not
only
raw
tcp,
which
was
recently
implemented
so
that
other
protocols
could
be
implemented
using
that
library,
but
also
udp,
meaning
we
hopefully
in
the
future,
can
do
a
fully
iso
standard
open
protocol
over
udp,
which
gets
us
closer
to
that.
You
know,
mix
and
match
of
reliable
udp
for
games
that
need
it
versus.
You
know
regular
tcp
for
something
like
maybe
a
turn-based
strategy
game
right.
So
I'm
just
going
to
drop
some
links
in
there
just
as
a
reference.
A
G
G
C
C
Yep,
so
what
we
were
using
is
this
library
in
the
past
called
the
cms
client
for
active
mq,
and
essentially
it
was
called
cms,
because
it
was
a
c
plus
plus
implementation
of
the
jms
1.0
api
specification
right.
So,
even
though
it
was
in
c
plus
plus,
it
was
very
familiar
for
those
backend
enterprise
e
developers
who
came
from
java.
A
C
So
so
what
we've
been
trying
to
do
over
the
last
month
or
two
is
basically
rip
and
replace
yeah.
C
We
did
succeed,
correct
so
I'll,
just
so
from
the
back
end
server
point
of
view,
I'll
just
drop
a
link
in
here
to
the
github
one
of
the
the
main
pull
requests
where
things
were
almost
working,
but
not
quite
where
you
can
see
a
lot
of
the
work
essentially
was
to
like
take
all
the
references
to
cms
out
and
not
only
do
we
depend
on
cms
in
the
back-end
server.
For
the
messaging
part,
the
server
was
kind
of
very
non
c,
plus
plus
11
adherent,
meaning
like
the
threading
model,
came
from
cms.
C
The
mutex
just
came
from
cms
all
that
kind
of
stuff.
So
there
was
a
couple
of
stage
process
where
we
put
in
standard
thread
we
put
in
more
like
standard
cues
we
put
in
standard
locking
mechanisms
and
then
as
well,
then
we
ripped
out
the
cms
messaging
stuff
we
put
in
the
amqp
messaging
stuff
and
then.
C
We
got
to
do
this
with
the
client
too
right
so
on
the
client
side.
There's
a
very
good
amqp
implementation,
written
in
javascript
by
a
fellow
messaging
engineer,
gordon
sim-
that
we
basically
hacked
into
place
quickly
and
then
jared
did
some
great
massaging
on
to
get
it
more
structured
and
look
sensible,
called
raya.
C
So
you
know
I
used.
I
had
a
date
what
we
call
a
day
of
learning
recently
and
I
spent
my
day
learning,
javascript
and
raya
to
kind
of
hack
it
into
place
a
bit
outside
my
wheelhouse,
but
I
have
a
little
bit
of
javascript
experience,
meaning
I
can
get
in
there
and
look
at
make
it
look
really
mangled
and
hopefully,
at
the
end
of
the
day,
it
works
right.
C
That's
what
happened
with
somebody
who
comes
from
like
a
static
type
language,
like
c
plus,
where
c
or
go
jumps
into
javascript,
but
I
think
at
the
end
of
the
day
I
think
the
result.
I
was
with
some
leadership
by
eric
to
smooth
over
my
mistakes
and
get
the
ball
rolling.
There
hardly.
C
G
A
G
C
A
A
Yeah
yeah:
we
we
get
to
skip
this.
What
is
it
do
not
we
get
to
pasco
and.
A
C
Yeah
I
can
hang
on.
Let
me
share
here
it's
a
little
bit
slow
where
there's
streams
going
all
over
the
place
here.
Let
me
share
screen.
Let
me
see
if
I
can
guess
the
right
screen.
C
G
D
A
D
G
C
Zoom,
the
others
will
not
be
able
to
record
until
you
reopen.
I
don't
think
I'm
going
to
do
that
now
quitting
might
be
bad.
A
C
C
All
right
so
so
I
guess
we
can
go.
Where
do
you
want
to
go
here?
I
don't
have
it
set
up
very
easily,
let's
go
to
main.
D
C
So
yeah,
so
essentially,
if
you
had
looked
in
here
before,
you
would
have
seen
like
an
active,
mq,
initialized
library
statement,
and
in
this
case
we
have
something
new
here:
control.
A
D
D
C
C
C
Do
I
see
settings
edit
settings
all
right,
so
maybe
we'll
show
it
a
little
closer
later.
What
I'll
do
I'll
go
and
I'll
make
it
bigger
and
come
back
all
right.
C
C
Still
see
sea
lion
yeah,
so
what
I've
highlighted
in
blue
that
I
can.
I
can
talk
more
to
you
later.
Maybe
there's
just
a
couple
of
co
lines
of
code,
like
literally
two
to
get
something.
That's
called
the
proton
container
up
and
running
in
a
thread,
so
essentially
we
create
an
instance
of
it
and
then
in
sdd
thread
you
know
we
capture
the
environment
and
then
we
and
then
we
do
container.run
and
essentially
it
has.
C
This
thing
called
the
proactor
and
basically
means
that
it
proactively
takes
care
of
intercepting
messages
and
then
gives
you
callbacks.
You
can
essentially
listen
for
on
the
container
and
when
you
receive
messages
of
certain
types
like
heals
get
back,
not
even
the
message,
but
you'll
get
an
event
from
proton
that
says
like
sender,
open
and
then,
when
you
get
a
sender
open,
you
know
like
hey,
I'm
good
to
go.
I've
created
a
sender,
we're
good.
You
can
send
the
message
now
yeah.
So
as
that's
kind
of
small.
C
I
will
stop
sharing
here
for
the
moment
and
we
can
maybe
transition
over
to
the
client
and
take
a
look
there
and
and
see
what
the
flip
side
of
the
equation
is,
because
it
takes
both
sides
of
the
coin.
In
order
for
us
to
actually
have
the
game
like
a
full
multiplayer
game.
C
A
Context,
true
jared:
do
you
want
to
yeah.
E
E
We
are
gonna
talk
about
that.
Okay,
do
you
see
my
screen,
then.
E
Okay,
all
right
so,
first,
just
just
a
few
updates
about
the
web
client.
The
first
one
is
this
cool
little
rocket
ship
that
one
of
our.
E
Yeah
one
yeah
one
of
our
fellow
game,
devs
made
in
about
an
hour
after
we
asked
for
we
needed
one,
so
that
was
awesome
but
yeah.
Let
me
just
okay,
so
first,
the
first
thing
I
want
to
talk
about
is
a
little
bit
like
I
re-architected
the
the
client
to
actually
put
some
architecture
around
it
so
that
we
can
have
a
sane
development
language
that
we
talk
to
each
other.
So
it's
this
is
a.
E
This
is
an
mvc,
basically
architecture,
but
it
shows
the
how
the
the
client
network
fix
fits
into
it.
So,
basically
we
have
the
the
client
code
that
roddy
and
eric
wrote
got
extracted
out
into
its
own
class
called
the
amqp
game.
Client
and
all
it
does,
is
talk
to
the
server
and
sync
the
state
and
send
commands
pretty
much
so
between
the
server
and
the
client.
It
syncs
the
model,
which
is
the
game
state
and
it
sends
commands
to
the
server.
So
it's
going
to
bi-directional:
it's
a
game.
E
Client,
it's
not
a
generic
client.
The
generic
client
is
the
raya
client
that
roddy
mentioned
earlier.
E
Yeah
and
that's
that's-
that's
generic!
It
just
sends
and
receives
the
game.
Clients
a
rapper
around
that
actually
has
some
game
logic
in
there
like
player,
join
game
and
player,
move
like
sending
a
move
command
of
the
player.
So
there's
a
wrapper
around
that,
and-
and
so
that's
what
it
does
so
that
took
all
that
stuff
out
and
put
it
into
that
class.
It's
much
easier
to
understand.
E
So
when
it
syncs
the
model,
what
it
does
is
it.
It
gets
instantiated
with
a
model
object
that
the
game
that
shared
across
the
whole
game
and
everything
that
comes
from
the
server
is
just
updating
that
model
and
it's
and
it
is
a
pojo.
I
don't
know
what
pojo
name
is
for
javascript.
I
guess
it's
still
pojo
and
yeah.
E
E
Right-
and
so
you
know
it
has
the
players
all
of
the
players
that
are
connected
and
whatever
other
kind
of
game
state.
That's
all
we
have
right
now.
Pretty
much
is
just
players,
but
in
the
future
it'll
have
you
know
other
actors
like
enemies
and
objects
that
you
can
run
into
asteroids.
I
don't
know
what
all
the
stuff
we're
going
to
add
to
it,
but
the
model
will
have
all
of
that
stuff
in
it.
E
The
mod
the
entire
model
is
always
on
this
server.
We
can
do
some
optimizations
in
the
future,
where
you
know
only
partial
bits
of
the
model
gets
synced
to
the
client
because
it
could
be
really
huge,
so
the
game.
So
the
the
game,
client
is
constantly
syncing
the
model,
and
then
we
have
the
controller,
which
is
like
the
orchestrator.
E
But
the
view
takes
that
model
and
renders
it
pretty
much
so
it
paints
all
of
the
players
on
the
screen
and
basically
the
state
of
the
world,
and
then
the
controller
does
stuff,
like
you
know,
any
kind
of
orchestrating
stuff
like
handling
key
commands.
That's
gonna
have
to
send
a
command
to
the
server
via
the
game.
Client,
that's
what
that
relationship
is
for,
and
this
architecture
is
very,
very
good
because
it
does
a
few
things.
Well,
it
separates
concerns
very
well,
but
what
it
does
is
the
imp.
E
One
thing
that's
really
important
in
multiplayer
game
is
that
the
model
and
this
between
the
client
and
the
server
stays
in
sync
so
having
that
extracted
out
into
its
own
object,
makes
that
a
lot
easier
to
do
than
having
it
coupled
in
with
other
parts
of
the
game,
makes
it
much
easier
to
pass
around
and
having
the
view
decoupled
from
everything
else
is
really
good,
because
it
lets
us
do
things
like
change
skins
and
that's
what
we
do
like
in
zorbio
like
well
in
another
game
we
made
where
you
can
have
many
different
skins
and
you
easily
accomplish
that
by
this
mvc
kind
of
pattern.
E
A
Nbc
pattern
where
somebody
could
write
like
the
unicorns
and
rainbows
plug
in
and
yeah,
and
then
somebody
else
could
write
the
nightmare
nightmare
before
christmas.
Skin.
G
E
When,
when
something
blows
up
with
a
skin,
you
could
get
different
color
particles
or
you.
E
B
Design
problem
too,
like
if
the
view
can
be
swapped
out
and
in
a
lot
of
games,
even
though
it's
not
intentional
by
the
developer,
you
can
still
get
into
the
directx
api
and
modify
the
view.
If
there's
information
in
the
model
that
you
don't
want
the
player
to
know,
but
they
still
have
it
on
the
client,
they
can
just
add
it
to
the
view
themselves
by
hacking.
It.
A
True
yeah
I
mean
then
you
get
in
then
we
get
into
the
thing
about,
like
you
know
how
world
of
warcraft
has
all
these
like
view,
plugins,
because
the
api's.
G
E
E
A
G
G
A
G
A
A
It's
like
during
during
the
arcade
week
when
we
had
the
redhead
arcade
up
which,
by
the
way,
is
technically
public.
Now
right.
Oh,
we.
B
A
When
we
had
that
up,
you
know
the
guy
that,
like
looked
at
the
javascript,
and
we
were
all
concerned
with
you
know
like
hashing
and
md5,
something
I
don't
remember
what
it
was
like.
He
just
like
changed
the
variable
in
the
browser
console
and
then
like
used
to
send
command,
and
it's
like.
Oh,
we
didn't
think
about
that.
A
Input
into
the
security
functions,
that's
like!
Oh,
it's
in
a
weird
way.
It's
like,
like
the
data
supply
chain
of
the
client
like
where,
where
does
somebody
perform
an
injection.
G
E
E
F
C
A
Yeah
and
browsers
are
true:
I
mean
the
tools
right.
Isn't
that
how
the
old?
Oh,
what
was
that
thing
called
the
game
genie
that
you'd
like
put
between
the
cartridge
and
the
console?
And
then
you
could,
like
flip
dip
switches.
C
And
stuff
and
it
would
modify
the
super
snapshot
that
was
magic
64..
You
push
the
button
and
you
can
end
up
into
disassembly
and
you're
just
going
to
manipulate
the
memory
directly
and
you
could
watch
the
assembly
commands
running
for
the
copy
protection
check
or
you
know
your
character
dying
or
whatever
yeah
you
just
jump
past.
It.
A
E
No,
no,
I
think
it's
totally
relevant
yeah,
so
all
right
well
I'll
move
on
then
so
we
can
get
going.
But
so
I
just
want
to
talk
just
like
super
briefly
about
the
refactoring
that
I
did
on
the
web.
Client
yeah,
starting
with
typescript
and
webpack.
So
someone
mentioned
typescript
in
chat,
and
I
also
have
a
background
in
c
plus,
plus
and
java.
E
Before
I
became
before
you
know,
I
moved
on
to
node
javascript,
and
so
when
I
was
like
well,
this
is
a
good
opportunity
to
learn,
learn
typescript,
so
I
started
by
trying
you
know
embarking
on
making
it
into
typescript
and
at
first
it
was
well.
It
was
awesome
like
I
was
like
giddy
when
I
was
like.
Oh
my
gosh,
like
in
a
javascript
class,
I
can
take
type
private
on
a
property
like
that's
insane
like
that's,
never
been
possible
in
just
normal
javascript.
E
You
can
you
type
private
and
then
the
variable
name-
and
this
is
a
string
and
you
can
even
make
it
read
only
it's
like
and
then
all
the
stuff
is
typed
and
just
being
able
to
type
that
it
felt
like
coming
home
almost
to
like
my
roots
of
javascript,
of
like
c
plus
and
java
and
then
and
then
on
all
of
the
parameters
and
stuff
and
the
the
other
wonderful
thing
about
it
is
when
you
import
the
types
of
all
the
libraries
that
you're
using
almost
you
know.
E
Most
editors
have
intellisense
where
you
can
just
hover
over
it
and
it'll.
Tell
you
all
the
stuff.
You
need
to
know
about
it
and
like
what
is
this
like
property?
That's
three
layers,
deep,
like
dot
dot,
dot
property
in
an
object
that
I'm
reading
right
now,
just
hover
over
like
in
normal
javascript.
That's
really
hard
to
do
like
you
have
no
idea
what.
E
It
works,
but
you
the
only
way
you
can
really
know
is
by
just
knowing
what
that
is
like.
You
have
to
have
trust
and
you
can
look
into
the
debugger,
but
with
typescript
you
can
see
exactly
what
type
it
is
and
all
of
the
stuff
about
it.
So
so
to
start
out,
I
said
that
was
that
all
is
the
good
part
about
it.
So
the
negative
thing
about
it
is:
if
you
have
to
write
something
in
a
super
short
amount
of
time
from
scratch,
typescript
is
gonna.
E
I
I
found
it
to
slow
my
slow
me
down
because
you
have
to
be
careful,
you
have
to
make
sure
everything's
typed
like,
and
sometimes
it
takes
the
time
to
look
up.
Okay,
what
is
this
function
returning
and
then
you
know,
is
it
actually
a
template
of
another
type
and,
and
it
take
it's
in
the
end,
it's
going
to
lead
to
much
more
robust
and
easy
to
read
code,
but
it
it
makes
it
it
slows
it
down
a
little
bit.
I
would
would
you
agree
with
that.
Michael.
F
In
general
yeah,
I
think
I
think
that's
true
of
all
strongly
typed
languages.
They
they
slow.
F
F
That
is
nice
about
typescript,
though
how
they've
implemented
the
compiler
is
that
even
the
errors
like
the?
If,
if
there's
a
type
error
that
that
occurs
when
you're
on
the
compiler,
it
shows
up
as
an
error,
but
I
by
default,
I
think
it's
still,
it
may
be
a
setting,
but
it
at
least
used
to
be
the
default.
Behavior
it'll
still
emit
javascript
to
run
in
the
browser.
F
So
even
if
there's
a
problem
with
the
types
you
can
kind
of
as
long
as
you're,
okay,
with
a
lot
of
red
text
in
your
console,
you
can
implement
stuff
really
quickly,
not
worrying
about
the
type
errors
and
have
it
run
in
browser
and
then
go.
E
F
E
I,
and
I
think
I
think
it
the
slowness-
is
really
amplified
at
the
beginning
when
you're
starting
something
from
scratch.
Oh
yeah,
oh
yeah,
and
that's
what
I
was
doing
so
I
think,
once
you
have
like
a
very
solid
foundation
and
you're,
not
like
all
of
your
library,
all
your
dependencies
are
pretty
much
set
and
working.
E
Then
you
know
in
your
code
basis
is
going
like.
Then
the
the
like
slowness
is
much
well,
it's.
It
almost
goes
away,
I
think
by
then,
but
when
you're
starting
from
scratch
and
you're
like
okay,
now
I
need
to
pull
in
a
totally
new
library
and
start
using
its
properties,
and
then
I
have
to
look
up
all
of
its
types.
It
like.
G
A
Skiing
and
kind
of
make
it
down
the
mountain.
The
first
time
like
not
too
bad,
yeah
snowboarding
is
no
and
so
like
the
ramp
up
curve
for
one
versus
the
other.
Like
one
is
this
like
sort
of
gradual
whatever
and
then
kind
of
there's
a
huge
ramp
later
and
the
other
one
is
like
huge
rep
at
the
beginning,
but
then
very
gradual
slope
kind
of.
E
Yeah,
so
I
I,
since
I
was
racing
to
finish
this
demo,
but
by
today
I
like
I
just
had
to
give
up
on
it
because
I
was
at
the
rate
I
was
going
with
typescript.
It
wasn't
gonna
happen,
not
that
I
don't
like
typescript
and
I
think
it's
awesome
it's
just.
I
had
to
go
fast
and
so
and
it's
starting
from
scratch.
So
quick.
E
Using
webpack
to
package
up
your
bundle,
so
webpack
is
a
a
quick
background
is
like
a
bundler
for
javascript.
So
it
takes
all
the
javascript
modules
you're
using
it
shoves
them
into
a
big
js
file
right
or
or
multiple.
You.
E
Yes-
and
it
also-
and
it
also
does
stuff
that
compiles
the
typescript
and
does
fable
transpiling
if
you
need
to
etc,
but
the
it
was
throwing
an
error
with
rhea
and
I
could
not
figure
it
out.
I
spent
like
several
hours
and
finally,
I
gave
up
and
I
I.
E
Yeah,
the
newest
version
of
webpack's,
pretty
breeze-
I
mean
you
know
it
has
a
lot
of
changes.
I
think
in
it.
So
I'm
yeah
so
I'll
like
talk
to
the
maintainers,
maybe
I'll
find
an
issue
about
it,
because
it
definitely
is
a
problem
with
ria,
but
because
I
need
to
get
something
working.
I
went
totally
buildless
and
that's
the
next
step.
G
E
Yeah,
so
that's
what
it
is
for
now
like
until
we
can
figure
out
some
of
the
bugs
of
about
it,
which
works
great
and
it's
like
clean.
It
also
makes
me
I
don't
know
I
feel
like
I
feel
freer
when
it
happens,
because
then
I
don't
have
to
worry
about
compiling
anything
or
doing
any
kind
of
weird
like
modification
it
just
it
makes
sense,
but
plus
it's
really
fast,
because
you
don't
have
to
wait
for
a
build
step.
You
just
change
the
thing
and
it
instantly
is
in
your
browser.
E
The
problem
with
it
is
that
yeah
so
we're
using
features
on
es8,
which
is
2017.
It
had
async
await,
and
probably
there
were
still
some
browsers
out
there
that
won't
support
that
natively
without
being
transpiled.
I
would
think
es6,
I
think,
is
like
universal
now,
but
es8
was
only
three
four
three
or
four
years
ago
and
browsers
are
kind
of
slow
to
people
are
slow
to
update.
So,
but
you
know
there's
a
demo,
so
I
think
it's
fine
and
all
it
works
for
all
all
of
the
people
working
on
it
anyway.
E
Well,
we'll
probably
add
a
bit
build
later
to
to
add
mabel
to
transpile
it,
but
or
not
so
browser
sync
it.
You
know
it's
a
night,
really
nice
tool
where
you
can
have
your
browser
on
one
side,
your
editor
on
one
side,
you
make
you
make
a
change
and
it
instantly
refreshes,
which
I
think
a
lot
of
front
ends
would
be
familiar
with
it,
but
it
it
really
helps
make
it
speed
up
development.
E
B
That
a
code
analysis
is
massive
and
important
for
keeping
large
game
code
bases
and
really
any
large
code
base
in
a
quality
maintainable
position.
Yes,
absolutely.
E
A
Are
you
using
vs
code.
D
E
E
Yeah
and
you'll
be
like
oh
crap.
I
need
to
change
that
and
then
it
has
a
thing
you
can
run
to
to
do
it
like
a
a
script,
that'll
run
to
check
the
entire
code
base
and
tell
you
any
errors.
F
Yeah
one
thing
I
want
to
mention
about
browser
or
not
browser,
but
editor
plugins
for
things
like
eslint,
is
that
they're
they're
awesome
because
they
show
you
in
a
very
like
editor
native
way,
where
the
errors
are
to
fix
them.
Yeah.
G
G
F
It
will
probably
run
on
every
javascript
file
you
open,
even
if
the
project
that
you're
working
on
isn't
supposed
to
be
using
eslint
and
interesting.
It's
not
so
bad
for
something
like
eslint,
but
it
kind
of
depends
on
like
there's
a
ton
of
eslint
settings
that
you
can
tweak
like.
Let's
say
you
don't
like
the
defaults,
so
you
change
the
defaults
to
something
like
you.
You
don't
want
to
be
warned
about
unused
function.
F
F
It's
I
guess
the
the
short
thing
of
what
I'm
trying
to
say
is
that
if
you
have
an
editor
plug-in
for
eslint
or
an
equivalent
for
other
tools,
try
to
find
the
setting
for
it.
That
says
only
use
this.
If
there's
an
eslint
rc
file
present
in
the
project.
E
Your
own
editor,
yeah
yeah.
You
want
to
make
sure
you
use
the
same
one,
that
the
project
is
using,
that's
for
sure,
yeah
yeah,
and
oh
thanks
for
that
michael
cool,
so
the
all
right
so
real
quickly.
The
structure
about
the
like
how
the
how
the
code
is
organized
pretty
much.
It's
pretty
simple,
only
you'll
notice
that
it
matches
the
architecture.
So
we've
got.
We
have
a
you
know
a
directory
for
model
view
and
controller.
E
The
scene
and
phaser
has
mostly
like
the
world
is
rendered
by
scenes.
So
you
have
a
scene
for
your
menu
and
then
you
have
a
scene
for
playing
and
then
when
you
die
and
you
get
taken
to
the
the
game
over
screen,
if
it's
a
different
screen,
it'll
show
you
that
scene
or,
for
example,
if
were
making
like
a
adventure,
game
and
you're
changing
room
to
room.
You
could
be
changing
scenes,
so
it
helps
it.
It
helps
keep
things
very
organized.
It's
a
very
nice
thing
about
phaser.
E
That
makes
a
ton
of
sense,
but
that's
under
views
and
then
all
the
networking
stuff
that
you
guys
had
written
went
into
the
network
directory.
So
all
the
protobuf
definitions
are
under
proto
and
then
I
made
the
amqp
game.
Client
is
a
network.
E
Yep
and
so
yeah-
that's
pretty
much
and
then,
of
course,
the
assets
okay,
so
that
is
it
for
the
slides.
I
don't
know
if
you
wanted
to
see
a
little
bit
of
code,
real
quickly,
sure
all
right.
So
let
me
share
my
whole
screen.
My
whole
desktop
entire
screen.
E
So
I
think
the
easiest
way
to
make
this
big
is
just
put
it
in
a
terminal.
E
You
guys
see
this
yeah.
Let's
show
I'm
going
to
show
the
preload
actually
so.
E
E
So
the
index
html
file,
like
I
said
since
it
has
no
build
and
also
is
this
font
good
enough
for
people
yeah.
D
E
E
E
It
starts
the
game.
It
starts
the
phaser
game,
it's
very
small,
so
one
that
yeah,
so
keeping
these
kind
of
discrete
files
is
easy
easier
to
understand.
So
in
phaser
it
just
takes
a
config
object
and
that
pretty
much
decides
to
decide
your
whole
game
world
and
then
once
the
game.
Oh
actually
one
important
thing
about
the
really
important
about
this
is
when
you
start
the
the
phaser
game,
you
pass
it
it's
scenes.
E
E
It
adds
the
scenes
to
the
game
container,
it's
it
doesn't
launch
them
until
you
tell
it
to,
but
it
will
launch
the
first
one,
the
first
one
it
will
launch.
Okay.
G
E
E
And
this
this
one
is
responsible
for
loading
loading,
the
game.
Obviously
it's
going
to
load
all
the
assets
do
any
asynchronous
loading
like
it
loads,
the
protobuf,
so
loads,
the
images
loads,
audio
loads,
the
protobufs
via
the
amq
game,
client,
and
it
does
all
of
that
it
does
that
it
waits
for
that
to
all
of
that
to
be
done
so
preload
is,
is
an
asynchronous
and
it
can
run
asynchronous
functions
and
the
game
won't
start
until
all
of
this
stuff
is
completed
loading
once
that's
all
done,
then
it
does.
E
It
calls
scene.start,
and
then
you
pass
it
the
key
of
the
scene.
You
want
to
jump
to
so
now
we're
going
to
go
to
the
menu
scene,
and
this
would
be
like
the
scene
that
has
the
play
button
on
it
and
you
pass.
You
can
pass
arbitrary
data
to
it,
which
is
the
client.
That's
the
amq
game,
client
and
the
model.
E
E
Exactly
so,
then,
that's
that
and
then
the
final
one
is
the
main,
the
main
play
area
scene
and
what
this,
what
this
does
is
like
back
to
the
architecture.
It's
it
pretty.
Much
just
renders
like
it
doesn't
do
any
network
stuff,
it
doesn't
do
any
model
stuff,
it
gets
the
model
from
the
you
know
it
get.
It
has
a
reference
to
the
model,
but
the
model
itself
is
getting
updated
by
the
the
amqp
game,
client
most
most
of
what
it
does.
E
So
it
starts
the
music
as
the
background
it
renders
the
scene
that
we're
in
and
then
here's
the
update
function,
that
change
that
updates,
the
player
positions
and,
and
it
does
it
without
any
knowledge
of
the
network.
It's
just
going
over
the
model.
The
model
in
the
background
is
getting
updated
by
the
the
client.
D
E
And
then,
oh
and
then
one
very
last
thing
which
which
we,
which
I
was
working
on
right
before
this
is
the
this
scene.
Also
right
now
is
handling
key
keyboard
presses
and
when
it
gets
a
keyboard
press,
it's
not
gonna
do
anything
itself.
It's
going
to
pass
that
to
the
client
to
send
the
command
to
the
server.
So
it's.
A
D
E
E
G
E
E
Yeah,
so
you
were
doing
you
had
a
fixed
width,
so
you
could
take
the
width
and
the
height
and
just
divide
it
by
two
yeah.
The
camera's
main
center
is
telling
you
the
x
and
y
of
the
very
center
of
the
camera
in
the
inner
window.
So
you
resize
it
no
matter
what
size
it
is
that
center
xy
is
the
center
of
the
browser
window
of
the
game
area
yeah.
So
it
makes
it
easier.
When
you
have
a
you
know:
a
dynamically
resizable
play
area.
E
Okay,
so
let
me
show
the
game
now.
I
probably
need
to
start
the
server
if
it's
running
it
looks
like
it's
running,
so
you.
E
Right
so
let's
go
ahead
and
refresh
here
so
so
this
is
a
full
screen
and
this
player
is
getting
drawn
by
via
the
server
the
client
and
passing
the
model
to
the
server
and
then
the
client,
rendering
the
players
yeah.
A
Well,
you're
on
it,
if
you
restart
the
server
and
pass
it
pass
it
so
right
now
it's
in
verbosity
one
which
isn't
particularly
interesting.
So
if
you
kill
that
and
then
add
a
dash
e,
so
it's
gonna
be
dash
e.
D
E
E
A
Yeah
but
you'll
see
so
as
soon
as
you
refresh
the
browser
and
you
go
back
to
the
server
now,
there's
a
player,
and
so
what
you'll
see
is
I
added
a
bunch
of
log
messages
into
the
server
game:
loop,
yeah,
yeah,
you're,
probably
gonna
have
to
maximize
it
because
it's
like
super
indented.
A
Yeah
and
so
you
and
you
can
kill
the
server
if
you
want
or
just
scroll,
but
what
you
can
see
is
it
iterates
the
server
iterates
over
all
the
players
and
then
puts
messages
onto
the
message
broker
with
information
about
each
player's
pod,
and
so
in
your
case
it
looks
like
you
ended
up
with
three
players.
Somehow
yeah.
A
Or
we've
got
something
weird
in
the
in
the
loop
right,
but
basically
it
says:
okay,
I'm
going
to
update
this
pod,
which
is
uuid
whatever
there
was
no
movement.
There
was
no
shooting
I'm
going
to
update
the
timers,
here's,
the
velocity
and
the
position,
and
I'm
going
to
send
that
out
to
the
client.
Okay,
next
player,
no
movement,
no
shooting
here's
the
position,
and
so
what
we
would
see
if
we
had
the
keyboard
commands
working,
which
we
don't
have.
A
A
A
A
D
C
D
G
E
A
E
A
E
A
Challenges
is
we're
using
yeah.
You
can
stop
sharing
screens.
Where
do
I
stop
sharing,
so
we're
using
box2d,
which
is
a
2d
physics
engine
for
c?
Well,
I
mean
it's.
The
one
we're
using
is
the
c
plus
plus
implementation.
There's
implementations
for
lots
of
languages,
and
one
of
the
interesting
things
about
box2d
is
that
the
universe
has
no
fixed
size.
It
is
theoretically
infinite
and
it
it
doesn't
even
really
have
a
way
you
have
to
like
clues
your
way
into
creating
a
bounded
2d
space.
A
If
you
will
so,
you
either
have
to
create
a
boundary
and
then
have
objects,
bounce
off
the
boundary
or
implement
some
other
game
design
trope
to
prevent
people
from
exceeding
the
boundaries
of
the
game.
But
the
other
challenge
is
like.
It
also
has
some
theoretical
units,
but
they
don't
mean
anything
in
our
in
our
game,
so
to
speak,
so
we
we
sort
of
need
to
figure
out
like
well.
Okay.
A
A
So
we
had
had
a
conversation
on
a
discord
a
couple
weeks
ago
about,
like
I
sort
of
looked
through
popular
small
spaceship
sci-fi
stuff.
I
was
like
how
big
is
the
ship
from
firefly?
How
big
is
the
rosinate
from
the
expanse,
like?
How
big
is
this
other
thing,
and
what
was
the
number
that
we
got
to
it.
C
A
A
Absolutely
I
mean
generally
we're
all
living
around
hog
day,
but
so
we
sort
of
need
the
both
extremes
of
the
scale
right
like
what.
What
are
we
envisioning
as
the
largest
slowest,
like
yuckiest
capital
ship
being
and
then
what's
like
the
starting
player,
size,
yeah.
B
Oh,
I
was
just
gonna
say
the
what
we
had
kind
of
talked
about,
or
what
I
talked
about
was
300
meters
to
600
meters.
That's
the
range.
B
The
reason
behind
that
behind
having
that
mid-level
range
is
that
we
want
players
to
feel
like
their
ship
upgrades,
their
substantial
changes
to
the
way
that
they
play
the
game.
So
that
means
either
we're
looking
at,
like
you
know,
fighter
size,
ships
or
capital
ships
right
and
if
they
get
too
large,
we'll
lose
detail
of
the
upgrades
visually
that
we
want
a
parent
from
like
a
game
design
perspective.
B
B
D
You
did
say
300
to
600
meters,
I'm
the
captain
now
somebody
says
to
cheeky:
can.
A
I
get
super
capital,
so
300
meters,
okay,
so
that
gives
us
one
number.
If
you
will-
and
we
almost
the
meters
is
almost
irrelevant,
so
it's
300
units,
whatever
those
units
are.
The
next
question
then
becomes
like
all
right.
Well
how
many
players?
A
You
want
to
be
able
to
like
move
a
little
bit
to
encounter
somebody
and
shoot
and
engage
and
like
there
needs
to
be
some
sort
of
area
of
play,
and
so,
if
you've
got
20
things
that
are
all
300
units
in
size
like
what
does
that
mean?
The
play
area
needs
to
be
from
a
unit
perspective
like
a
hundred
thousand
like
a
ten
thousand.
Like
I
don't
know
right,
we
have
to
pick
something.
A
And
I
think
that's
where
a
lot
of
the
game
tuning
will
come
into
play.
It's
like,
oh
god.
It
takes
me
five
minutes
to
get
to
a
player
like
the
player.
G
A
Yeah
yeah,
but
that
that
is
going
to
inform
a
bunch
of
other
things
like
velocities
right.
So
if,
if
the
play
field,
you
know,
do
we
make
the
playfield
smaller,
or
do
we
just
make
the
speed
of
the
ships
faster?
The
player
has
no
idea
doesn't
have
to
have
an
idea
what
the
units
are
until
later.
They
just
know
like
okay,
I'm
covering
ground
more
quickly
than
I
was
previously,
because
I
held
the
button
down
longer.
B
Yeah
I
mean,
if
I
were
to
pick
a
you
know,
a
size
to
start
with,
I'd
be
like
a
hundred
thousand
units,
and
the
reason
for
something
so
small
is
because
we
have
talked
about
this
mechanic
of
having
players
drift
towards
each
other,
regardless
of
where
they're
choosing
to
thrust
right
or
where
they're
trying
to
go.
They
need
to
move
relative
to
other
players
and
not
necessarily
at
a
static
point
in
the
map.
Right.
A
Players
across,
if
you
will
so
if
you
took
a
player
and
then
just
stacked
players
touching
all
the
way
across
the
playfield
that
would
be
333
of
them.
You
know.
Is
that
good
or
bad?
I
don't
know,
but
that's
the
number
that
we'll
go
with
for
now,
and
then
we
have
to
sort
of
determine
a
speed
right
like
a
like
a
top
speed
of
the
starting
unit.
If
you
will,
because
theoretically,
we
we
all
are
in
agreement,
maybe
that
every
mod
you
put
on
your
ship
makes
you
slower.
B
And
the
way
that
I
yes
and
the
way
that
I
like
to
do
balance
in
games
is
I
like
to
keep
all
numbers
under
50
and
if
I
can
help
at
all
numbers
under
20.
makes
balance
easier.
It's
a
lot
easier
to
talk
about
with
other
people.
Human
brains
are
really
bad
at
math.
That
goes
beyond
like
10
anyways,
like
we
in
our
brains,
we
represent
the
number
you
know
100
and
the
number
the
number
like
a
thousand
identically,
like
the
neurons
in
your
brain,
treat
them
identically,
except
the
word
that
you're
picking.
B
So
if
you're
balancing
around
these,
you
know
these
small
numbers,
it's
a
lot
easier
to
talk
about
a
lot
easier
to
make
sense,
and
it's
also
one
of
those
things
too,
where
it's
like.
We
don't
need
to
tell
the
truth
to
the
player
about
how
fast
they're
going
if
they,
if
you
know
it,
feels
good
in
the
game
to
go
super
fast.
We
just
have
the
background
move
super
fast
and
they
can.
A
B
A
G
F
A
B
Isn't
necessarily
a
problem
right
because
you're
never
going
to
do
that,
it's
all
about
fighting
their
players.
I
mean
the
biggest
thing:
that's
going
to
inform
all
of
our
balancing
decisions
about
scale
and
size
and
movement
and
everything.
Well,
maybe
that
is
our
target
our
target
session
time
right.
A
No,
it
makes
sense
yeah,
and
the
other
thing
is
that
if
we
do
the
so
this
brings
up
the
player
distribution,
and
so
I
already
forgot
the
name
of
the
of
the
distribution
mechanism,
but
essentially,
I
think
out
of
the
gate,
if
we
start
with
an
algorithm
that
equally
distributes
players
around
well
see.
This
is
where
it's
tricky,
because
if
you
do
equal
distribution-
and
you
start
the
very
first
player
in
the
dead
center
of
the
play
area,
then
the
next
player
equally
distributed
is
at
one
of
the
edges.
A
E
Yeah,
I
know
whatever
that's
yeah,
so
in
everyone
will
spawn
on
the
outer
side
of
on
the
outer
ring
when
they
start,
but
the
out
of
the
ring.
Let
me
fin
so
they're
all
divided
up
into
sections
of
a
ring
right
when
players
are
joining
we're
not
going
to
put,
I
don't
think
we
would
want
to
put
one
person
on
us,
an
outer
sector
on
the
left
side
and
then
one
person
on
the
outer
sector
on
the
right
side.
E
A
B
A
Of
a
sector
but
as
if
you
end
up
transitioning
or
transiting
from
a
sector
to
another
one
that
may
be
transparent
to
you,
but
you
did
so
because
you
crossed
some
literal
boundary
that
the
game
knows
about
doesn't
mean
the
player
knows
about
the
boundary.
Just
means
that
there
is
a
boundary
and
a
transition
between
kind
of
one
thing
to
the
other.
A
C
B
A
A
Player,
so
that's
so!
That's
10,
you
10
units,
basically
10
ship
size
units
which
is
300
ish
whatevers,
so
that's
3
000.
So
so
every
player
should
start
no
for
at
around
approximately
3
000
units
from
at
least
one
other
player.
E
And
the
other
thing
we
and
the
other
thing
we
want
to
do
like
another
like
that
brings
up
another
point
which
we've
seen
on
almost
every
multiplayer
game
we've
made,
which
is
it's.
It's
actually
hard
like
when
you're
first
starting
a
multiplayer
game,
it's
hard
to
get
a
lot
of
people
connected
at
the
same
time
and.
D
E
Go
ahead,
let
me
finish
yeah.
So
what
I'm?
What
I'm
saying
is
is
that,
let's
say
there
are
no
players
connected
at
all
right
and
one
person
joins
and
there's
no
players
to
be.
They
still
need
that.
What
what
eric
was
saying
about
getting
grabbing
their
attention
like
we
can't
rely
only
on
other
gay
players
being
connected.
We
have
to
have
other
stuff
going
on
whether
it's
npc
ships
flying
around
or
just
stuff
for
them
to
do,
because,
yes,
we
have
to
we,
we
can't
rely
on
another
player
being
there.
B
And
this
is
what
we
talked
about.
We
need
to
have
npc
ships,
no
matter
what,
because
we
have
to
test
the
scalability
right,
we
have
to
be
able
to
literally
spin
up.
You
know
10
million
players
and
throw
them
at
this
game
and
show
that
working
on
an
open
shift.
Maybe
maybe
we
want
to
pay
for
10
million
to
demo
it,
but
we
should
be
able
to
right.
C
A
Yeah
I
went
to
the
rest.
I
went
to
the
restroom
to
fill
my
water
and
I
was
like,
let
me
put
it
on
mute,
wait.
The
button
is
out.
A
Six
mute
buttons:
okay,
so
we've
got
sector
size
of
100,
000
units,
initial
ship,
size
of
300
units,
speed
of
300
units
per
second
to
start
and
a
player
distribution
of
3
000
units.
So
I
think
those
are
good
numbers
to
go
with
so
now.
The
question
then
becomes
what
the
hell
do.
We
do
in
box
2d
to
do
any
of
that
and
so
rodney.
I
don't
know.
C
Let
me
just
bring
open
box
2d
right,
so
every
every
body
you
create
in
box
2d
has
a
number
of
units
in
size
that
it
is
right
and
then
proportionally.
You
also
have
to
set
up
its
mass
and
its
friction
with
like
the
underlying
two-dimensional
surface
right.
So
there's
a
lot
of
parameters
there.
We
can
tweak
based
on
size
that
we
want
and.
C
C
A
balance
to
be
found
there
like
how
does
it
feel
when
we,
you
know
we
have
a
ship
that
looks
like
it
does
on
the
screen
there
now
and
we
apply
a
small
force
like
perceptually.
We
think
something
that
big
that
shouldn't.
If
I'm
just
pushing
my
finger
on
it,
that
thing
shouldn't
go
anywhere
like
I
should
be
really
pushing
on
it
hard
to
make
it
go
right,
so
there'll
be
a
balance
to
be
found
between
size,
mass
and
force
applied.
C
With
regards
to
like
when
I
click
the
button
and
apply
a
thrust.
If
I
picked
up
a
thruster,
and
I
want
to
move
it
over
to
the
other
side
like
a
little
tiny
thruster,
it
shouldn't
move
a
big
ship
very,
very
quickly,
right.
A
So
yes,
so,
given
that
we
want
a
maximum
speed
of
to
start
given
we
want
maximum
speed
of
300
units
a
second.
How
long
should
it
initially
take
somebody
to
get
to
maximum
speed?
The
reason
I
asked
that
question
this
way
is
this
is
going
to
back
us
into
a
force
number
versus
our
mass
number,
if
that
makes
any
sense
right.
C
B
Well,
I
I
would
say
the
first
thing
that
I
would
want
to
figure
out
is
turning
like
radius
and
time
and
everything,
and
to
me
you
want
to
get
that
like
feel
of
a
massive
capital
ship.
It
shouldn't
take
any
shorter
than
four
seconds
by
default
for
you
to
turn
on.
C
A
Assuming
you
had
only
guns
in
the
front
right
or
or
weapons
in
the
front,
but
yes
100,
sorry,
four
seconds
to
rotate
180
degrees
or
eight
seconds
to
rotate
360
degrees,
but
that
that
math
and
those
forces
can
actually
be
completely
separate
from
thrust
force.
So,
like
rotational
thrusters
versus
forward
like
accelerate
decelerate
thrust,
I
think
can
be
two
totally
different.
A
A
C
A
C
A
So,
okay,
so
we've
got
acceleration
of
15
is
just
like.
I
need
to
pull
up
like
just
basic
physics
formulas.
D
Here,
physics.
A
C
A
A
B
C
A
thousand
kilograms,
it's
a
thousand
kilograms,
a
metric
ton.
B
C
E
A
A
You
know
sort
of
get
it
giving
you
the
feel
of
space
travel,
suspending
a
little
disbelief
of
like
what
the
capabilities
of
physics
are
and
the
whole
like
jumping
between
stars
and
stuff
like
that,
but
that's
like
that
was
a
design
trope
that
they
came
out
of
the
box
with,
like,
I
don't
think
they
backed
into
like.
Oh
we've
got
really
realistic
sizes
and
whatever
it
was
like
we're
going
to
make
a
realistic
spaceship.
F
A
F
A
C
C
Yeah,
it's
it's
not
it's
not
difficult.
I
just
did
that
here
and
I
can
now
increase
the
font
size
via
click
and
scroll
wheel.
Oh
yeah,
captain
by
default
was
turned
off.
A
Us
make
it
as
hard
as
possible
to
show
you
anything
yes
yeah,
so
we'll
do
this
and
then
we've
got
about
30
minutes,
we'll
go
back
to
derek
and
maybe
talk
a
little
bit
about.
How
do
we
prevent
people
from
getting
to
the
borders.
C
So
yeah
like
so
originally
the
stuff
that
was
set
up,
if
you
think
back
to
the
early
demo,
essentially
what
we
had
was
circles
right,
even
though
now
we
have
like
a
boxy
ship,
but
you
can
basically
put
like
a
circle
shape
in
or
you
can
put
in
a
box
shape
so
we'll
have
to
update
the
back
end,
use
boxes
rather
than
circles
which
isn't
really
a
big
deal.
But
you
can
see
here,
like
your
stuff,
has
a
density
or
such
as
a
friction.
C
It
has
restitution,
it's
a
restitution
so
like
that's
the
shape
and
then
there's
a
body
definition
see
what
what's
that
this
is
in
the
body
definition.
I
don't
even
remember.
C
E
A
A
C
C
C
D
C
E
E
C
E
C
There's
a
number
of
good
examples
that
compile
and
run
out
of
the
box,
like
with
a
spotter
that
walks
across
the
screen,
all
kinds
of
stuff.
You
can
easily
tweak
values
and
test
things
out
right
like
what
I
did
when
I
was
developing
giggle
water.
I
built
like
a
little
interface.
We
could
just
tweak
the
values
directly
and
just
take
take
the
settings
from
the
gui
and
just
manipulate
it
on
the
fly
right.
C
Like
that's
one
of
the
reasons
why
I
think,
like
godot
and
unity
and
unreal
and
stuff
that
have
guise,
are
so
powerful
right.
So
in
an
ideal
world,
what
would
happen
with
this
game
server
is
that
it
would
really
become
a
gene,
more
generic
simulation
server,
where
we'd
hook,
where
we
basically
write
a
fro,
we'd
write.
G
C
Integration
in
the
front
end
in
unity
or
unreal
or
godot.
That
was
a
great
target
and
we'd
build
a
little
interface
there,
where
we
showed
what
was
going
on
like
through
the
id
through
the
game
development
environment,
even
though
all
the
values
were
being
fed
from
the
back
end
right
and
ideally
like
you'd,
have
an
interface
in
godot.
Where
we
say
hey,
I
want
to
launch
this
thing
on
openshift
we
have
a
little
open
shift.
Interface
enter
your
credentials.
You
go
get
your
display
token.
You
drop
your
token
in
click.
C
It
talks
back
and
forth
and
starts
receiving
the
updates
through
the
messaging
mechanism,
and
it's
all
visual
to
you
right
there
and
you
use
godot
to
build
your
world
and
then,
when
it
comes
time
to
launching
your
game,
you
can
check
on
the
status
of
your
world.
You
can
send
world
updates
and
then
there's
a
world
format
of
some
sort
that
the
game
server
runs
and
then
the
game
client
is
just
basically
saying
this
player
joins
and
then
the
back
end
knows
what
that
means
and
what
to
do.
With
regards
to
the
simulation
right.
C
D
C
Right
so
so
yeah
so
like
it
has
this
little
testbed
thingy,
where
there's
an
im
gui
plug
in
essentially
to
run
your
gui,
which
is
this
awesome
little
native
cc,
plus
plus
gui
implementation
like
in
a
couple
of
I
think
it
might
even
be
single
header,
where
you
can
look
at
your
different
shapes
and
stuff
that
you
have
and
test
them
out
and
test
like
hey.
C
What
does
it
mean
if
I
set
a
force
to
whatever
or
what
does
it
mean
if
I
change
the
mass
or
change
the
friction
right,
so
there
kind
of
isn't
like
a
box
to
the
world
editor
per
se,
at
least
not
that's
directly
with
box
cd.
As
far
as
I
know,
there
may
be
some
third-party
ones
out
there.
Oh
there
you
go,
I
see
derek
just
dropped,
one
in
right,
sorry,
yeah
in
the
discord
so
like
there's
a
javascript
web
demo
of
the
same
thing
right
to
test
this
stuff
out
so
yeah.
C
Yeah,
so
so
the
key
part
here
that
would
be
different
for
us
is
that
the
simulation
happens
on
the
back
end.
So
we
need
to
connect
up
the
messaging
as
well
right
because
we're
going
to
want
something
like
this,
so
that
we
can
rapidly
iterate
the
values
that
we
want
to
update,
because
we
don't
what
we
don't
want
to
have
to
do
is
go
in
and
hard
code,
some
values
in
the
game.
Server
build
a
game,
server,
build
a
container
rerun
the
game,
server.
A
A
B
C
A
C
D
C
C
A
C
C
Yeah,
I
think
that's
this
automatically
updates,
but
I
don't
know
if
that's
the
only
way
to
do
it,
because
in
this
case
you're
saying
that
a
body
has
a
number
of
fixtures
right.
So
you
have
to
think
in
terms
of
rigid
body
physics
right,
so
you
might
have
a
square
and
that
square
can
have
a
joint
and
on
that
joint
can
be
attached
a
circle
right.
A
C
So
because
we
just
wanted
to
be
handling
simple
movement
at
the
time
by
sticks
is
how
it
started
out
like
there
was
no
separate
thrusters
or
anything
like
that
right.
Whereas
if
we
had
a
box
like
this
and
we
attached
the
thruster
to
the
like
the
bottom
right
hand,
corner
there's
a
very
specific
place
where
that
force
should
be
acting
on
the
body
right.
C
A
C
A
C
D
A
Oh,
that's
why?
Okay,
somebody
just
came
back
to
the
house
wasn't
expecting
a
visitor
okay.
So,
in
the
place
where
we
create
the
pod,
we
would
just
add
a
set
mass
on
the
body.
C
C
It
on
fixtures,
you
can
see
there
you
go
on
the
body,
you
set
mass
data
right,
so
so
right.
So
that's
the
thing
it
can
like
the
way
we're
looking
forward
here
like
in
the
beginning.
We
can
just
set
a
mass
state
that
we
got
a
box.
We
want
to
give
them
mass
we're
trying
to
figure
out
the
really
basics.
C
But
what's
going
to
happen,
is
that
over
time,
when
we
pick
up,
let's
say
we're
this
box
we're
an
escape
pod,
we're
going
along,
we
run
into
a
thruster,
the
thruster
has
a
mass,
so
we
are
now
the
pod
mass
plus
the
thruster
mass
right
and
the
thruster
has
been
attached
to
the
pod
in
a
given
location
right,
and
so
we
can.
We
can
physically
simulate
all
that,
and
at
that
point
we
don't
want
to
calculate
the
mass
and
the
effect
of
having
a
mass
in
the
lower
right
hand
corner
of
the
pod
ourselves.
C
C
G
A
C
A
G
B
C
G
A
So
we
have
to
actually
get
this
into
the
real
units,
so
it's
20
000
times
150.
So
it's
three
three
hundred
thousand
I'm
bad
at
terrible
at
small
number.
Math.
A
C
A
At
the
current
scale,
right
of
100
100
000
units,
300
units
for
the
ship
or
three.
A
C
A
A
Yeah
yeah
yeah,
and
so
we
don't
want
to
do
that
because
we
want
the
ship
to
rotate,
not
just
not
to
move
just
sideways
literally
so
do
you
want
to
go
back
to
box
2d
and
take
a
look
at
like
where
it
would
go.
C
Right,
so
you
can
apply
to
a
point:
let's
just
do
a
search
for
apply
force
or
you
can
plot.
You
can
apply
a
rotational
force,
for
example,
so
apply
force
in
general
means
it
will
probably
take
a
vector
right,
so
you
have
a
vector
which
is
the
force
and
the
point
at
which
it
applies
to
the
body
right.
A
C
A
A
So
that
would
be
so
we
sort
of
have
to
change
the.
If
you
go
back
to
the
code,
we're
actually
going
to
have
to
add
some
different
logic
here,
because
the
we
might
have
to
tweak
the
move.
Cue.
Basically,
because
now
it's
going
to
be
you
know
both
of
these
are
are
for
now
is
the
thruster
on
or
is
it
off.
A
C
C
A
C
A
B
That
all
players
are
going
to
have
an
intrinsic
force
applied
to
them
that
has
them
all
moving
towards
each
other
and
that
will
increase
as
time
goes
on
to
help
push
those
players.
To
that.
You
know.
In
two
minutes
I
have
faced
all
other
players
yeah
and
instead
of
having
a
battle
royale,
you
know
scenario
where
it's
like.
Oh
the
borders
are
closing
in
on
me.
Oh
no,
it's
just
happening
in
the
background
automatically
it's
transparent
to
the
player,
the
forces
that
are
involved
in
keeping
the
game
active
and
interesting.
A
E
A
B
The
way
that
I
would
do
it
is
not
even
touch
the
you
know,
physics
engine
just
adjust
the
x
and
y
position
of
every
single
player
over
time.
Very
slowly
so,
and
you
would
just
calculate
you
know,
what's
the
distance
to
you
know
the
origin,
the
center
of
the
universe,
and
you
would
increase
that
in
you
know
a
bell
curve.
Essentially
that
would
accelerate
over
the
course.
C
A
A
All
derrick
is
suggesting
is
that
we
do
some
math
to
figure
out
a
number
which
is
an
offset
and
on
every
game
loop.
We
just
remove
that
offset
from
the
player's
position
before
the
physics
calculation
occurs,
so
you
were
at
position,
100,
comma
100
and
physics
wise.
Your
position
would
have
moved
away,
101,
comma
100,
but
because
of
magic
game
stuff,
you
actually
didn't
even
move
at
all
you're
still
at
100,
because
we
took
one
x
away
from
you,
whereas
I
think
that's
what
derek's
getting
at.
C
So
if
the
position
changes
and
we're
keeping
the
position
of
the
physics
simulation
and
the
position
that
we
keep
for
the
player
character
in
sync,
then
like
position
is
an
output
of
physics
simulation
based
on
mass
forces
and
velocity
and
acceleration
right
right,
physics,
isn't
positions
and
output.
So
if
we
intentionally
avoid
the
simulation
and
set
the
position,
we
have
to
let
the
simulation
know:
yeah,
hey,
we've
forcefully
changed
this
go
back
and
recalculate
everything.
C
C
C
Because
all
the
bodies
could
be
different,
like
you
could
now
have
two
bodies
in
collision,
meaning
that
physically
like,
if
you
have
collision
bounding
boxes
and
they
were
two
pixels
apart
and
you've
moved
the
position
to
be
four
pixels
to
the
left.
They're
now
two
pixels
in
collision
and
something
forcefully
has
to
happen
there.
There
has.
B
C
A
C
D
C
D
A
Point
you
can
no
longer
allow
new
players
into
the
sector
because
if
you
just
keep
allowing
new
players
into
the
sector,
but
the
pull
rate
to
the
center
increases
over
time,
the
last
player
to
join
basically
like
joins
and
then
instantly
is
like
smashed
into
all
the
other
flight.
You
know
what
I'm
saying
like
there's
got
to
be
some
like:
okay,
no
new
players,
because
it's
like
the
last
person
has
joined
and
then
the
rate
of
increase
towards
the
center
slowly
increases.
B
Yeah
and
to
me
it
would
be
like
new
players.
Yeah
new
players
can
join
in,
like
you
know,
rolling
window
of
30
seconds
right
for
30
seconds.
We
allow
new
players
to
join
or
whatever
and
get
into
that
combat
within
10
seconds
right
because
they
spawn
you
know
10
seconds
away
from
somebody
and
after
that
they
have
to
go
into
a
new
a
new
section.
The.
A
G
G
B
A
A
C
I
think
I
think
we
have
a
lot
of
stuff
here
to
do
work
on
before
the
next
session.