►
From YouTube: Scalable Multiplayer Game Design with OpenShift (E3)
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.
Today's session will look into the game server running on OpenShift, accessing the server via AMQP, hacking on a front end, deeper exploration of Red Hat Data Grid, and more.
A
A
A
D
A
A
A
We
could
be
using
internal
stuff
inside
that
red
hat
single
sign-on,
which
is
where
is
that
it's
this
guy
key
cloak
here.
But
you
know
we
just
decided
to
use
github
because
it's
easy
we've
got
the.
I
don't
have
the
lobby
deployed,
because
I
was
running
that
locally
and
I
can't
remember
last
time
we
did
do
a
little
bit
with
amq
and
the
chat
right.
I
think
that
was
with
the
last
stream
was.
I.
E
A
F
A
A
E
A
And
so
in
the
and
I'll
paste
this
into
the
restream
chat
for
those
who
are
curious.
So
in
red
hat
game
dev.
We
now
have
this
srt
game
server,
which
github
is
correctly
identified
as
being
c
c,
plus
and
so
rodney
spent
some
time.
You
had
to
kind
of
back
out
some
proprietary
stuff
on
this
side
or
was
that
the
client
again.
E
A
E
E
Yeah
and
most
recently
had
been
like
10
11.6,
so
I
put
it
over
to
my
fedora
30
box
and
then
basically
made
a
container
which
reflected
the
state
of
my
box,
essentially,
which
was
all
the
dependent
libraries
up
there,
that
you
see
in
the
dnf
command
and
then
as
well.
Just
recently,
we
added
the
ability
to
specify
the
broker
uri
via
the
command
line,
so
that
when
you
run
containerized
it
doesn't,
it
knows
where
to
try
to
connect
to
so
you
can
see
there
online.
E
A
B
A
E
A
E
E
A
B
A
B
A
A
Right,
I
think
it
is
it's
honestly,
like
other
than
the
sort
of
the
one
guy
who,
like
chops,
up
carcasses
with
the
things
that
they
make
like
to
prove
that
they're
sharp
the
show's
actually
really
good,
like
they
give
these
blacksmiths
very
interesting
challenges
to
to
make
weird
knives
and
swords
and
weapons
and
things
in
a
very
short
period
of
time
and
like
it's
just
really
interesting,
to
watch
how
they
problem
solve.
It's
kind
of
like
watching,
live
coding,
but
with
fire
and
metal.
A
A
A
A
A
Together:
okay,
information-
that
is
new
to
me.
So
if
we
look
at
the
artemisi
thing,
what
we
will
see
is
I
have
an
address
already
for
the
game
lobby
that
I
created
using
a
crd,
so
this
is
going
to
be
like
more
power
of
operators,
kind
of
cool
stuff.
So
if
we
dig
into
the
cluster,
if
I
go
to
the
administrator
view
and
I
go
to
administration
and
I
go
to
custom
resource
definitions
and
I
go
to
activemqrtemus
address,
what
we
see
is
there
is
a
custom
resource
definition
for
an
activemq
address
and
I'll.
A
Let
rodney
explain
what
the
difference
is
between
addresses
and
queues
and
listeners
and
all
that
other
stuff,
but
we
basically
defined
in
yamo
hey.
We
want
an
address
named
lobby
with
a
queue
named
base
with
a
multicast
type,
and
when
we
create
this
yaml
instance,
the
activemq
operator
sees
it
and
basically
configures
the
broker
to
have
it
there.
So
here's
our
thing
that
I
basically
wrote
some
yaml
and
magically
it
appeared
in
here.
C
For
those
of
you
that
are
just
joining
us
and
haven't
been
on
previous
screen
streams
that
we've
done
all
of
this
is
open
shift
right
like
none
of
this
is
like.
Oh,
we
sat
and
like
configured
some
random
app
in
a
corner
right.
You
know
those
are
our
like
actual
gameplay
code,
but
all
this
back
and
stuff
right
all
of
the
red
hat
services
that
you
see.
That's
all
openshift,
that's
all
you
know
pretty
much.
You
know
multiple
click
and
yaml
file
deployments.
C
A
A
This
is
all
it
is
so
when
I
create
this
yaml
file,
because
I've
installed
the
operator
for
activemq
and
because
I
have
a
activemq
broker
defined,
which
caused
the
operator
to
deploy
the
broker
when
it
sees
this
activemq
rtms
address
called
lobby
in
the
srt
namespace.
It's
like,
oh,
I
know
about
that
broker,
I'm
going
to
configure
the
actual
broker
to
do
the
thing
that's
requested.
So
what
we
can
do
right
here
is
we
can
copy.
I
don't
know
why
I
did
that
with
highlighting
I'm
going
to
go
here.
A
B
B
B
E
A
Know
how
to
do
that
and
then
ps
go
to
mq.
This
is
gonna,
be
the
game.
Server
address,
cr
and
so
we'll
copy
this,
and
the
reason
that
we're
doing
what
we're
doing
right
now
is
the
the
game.
Server
expects
to
talk
to
a
broker.
The
game.
Client
will
talk
to
the
same
broker
and
the
end
user,
the
game
player
when
they
do
things
in
their
client
that
sends
messages
to
the
broker
and
then
the
game,
server,
picks
up
those
messages
and
then
performs
whatever
calculations
are
required
to
interpret
the
user's
actions.
A
It
then
sends
messages
back
to
the
broker,
which
then
go
back
to
the
client,
and
then
the
client
sees
so
to
speak.
Whatever
the
result
of
the
input
was
so
if
I
was
playing
a
platformer
and
I
hit
the
jump
button
that
would
turn
into
the
character
actually
jumping
and
then
the
client
would
render
the
character
jumping.
So
what
I
want
is
in
the
namespace
srt.
D
G
E
E
So
the
community
there
had
decided
essentially
that
the
way
in
which
active
mq
was
written,
it
was
written
before
you
know.
Multi-Core
processors
were
very
common
on
the
desktop,
for
example,
so
symmetric
multiprocessing
wasn't
really
a
thing,
so
it's
very
heavy
with
mutexes
and
locks
and
very
large
thread
pools
that
kind
of
thing,
whereas
hornet
cue
was
kind
of
written
with
a
a
more
efficient
core
that
that
didn't
do
that
type
of
thing.
So
what
they
did.
E
They
took
the
hornet
q
code
base
and
they
took
the
active
mq
code
base
and
over
the
span
of
about
two
years,
they
made
them
into
this
new
thing
called
active
mq
artemis,
so
that
active
mq
as
a
message
broker
could
move
forward
into
this
into
this
more
parallel
and
concurrent
future,
where
we
basically
maxed
out
gigahertz
and
we're
just
throwing
cores
at
the
problem
right.
So
so
as
a
as
an
addendum,
then
to
moving
into
the
future.
E
E
E
When
you
send
one
message,
it
goes
to
all
consumers
right
so
because
of
that,
there's
a
little
bit
of
a
mismatch
here
between
what
we
were
doing
in
the
past
individually
with
this
game
server
and
now
what
this
new
broker
provides
in
the
way
configuration,
and
so
we
just
moved
to
using
this
new
well
new
broker,
so
I
hadn't
even
really
tested.
I
tested
it
connected
to
the
to
the
broker,
but
I
didn't
actually
test
the
usage
at
this
point.
Sure
yeah.
A
A
No,
this
is
exciting,
so
for
those
who
are
watching
while
roddy
was
talking,
I
created
this
tiny
little
ammo
file.
That
said,
hey.
I
want
this
queue
with
an
address
and
almost
immediately
like
within
less
than
a
second,
the
operator
said.
Hey
I
created
what
you
asked
for
and
now,
if
we
refresh
the
interface,
actually
it
refreshed
itself.
So
if
I
look
in
the
addresses
now,
we
have
command
in
multicast
command.
In
so.
E
E
Like
you
know,
in
a
lot
of
cases,
so
a
lot
of
production
deployments
we
might
see-
I
don't
know
four
to
12
brokers
deployed
in
a
cluster
topology
in
order
to
handle
the
load
from
all
the
clients
coming
in
and
be
able
to
still
be
responsive
right.
So
normally,
what
you
have
to
do
here
is
like
either
go
to
each
one
individually
and
create
it
or
you'd,
write
a
shell
script
or
maybe
do
some
ansible
or
something
like
that.
But
in
this
case
what.
E
Will
do
yeah
it's
exactly
right.
It's
the
whole
idea
of
the
operator.
The
operator
just
goes
to
every
broker
for
you
and
creates
the
address
right
and
then
upon
scale
down
or
scale
up.
It'll
also
say:
oh
hey
you
scaled
down
and
you
scaled
up.
That's
a
new
broker.
We
need
to
add
the
address
to
that
one
for
you.
A
A
G
C
A
B
A
A
E
A
E
E
A
A
E
A
A
A
What
we
see
is
the
expansion,
so
any
hostname
will
all
auto
search,
srt
service
cluster
local,
to
find
the
host
name
to
get
the
resolution,
and
so
because
we
have
a
service
named
blah
blah
blah
blah
blah.
I
can
just
use
the
short
name
of
this
service
when
I
try
to
connect
to
things.
If
we
go
back
to
the
code
that
roddy
has
and
we
look
at
the
dockerfile
or
the
container
file,
what
we
see
is
it
tries
to
connect
to
the
broker
uri
environment
variable.
E
A
A
Okay,
and
so
when
I
hit
the
tab
button,
you
see
this
little
validated
thing
it
actually
openshift
reached
out
and
queried
the
registry
to
figure
out
like
what
is
actually.
What
is
this
image?
Do
I?
What
do
I
know
about
it?
You
know
what
metadata
is
available
from
the
registry.
Oh
runtime,
icon,
that's
cool.
C
Yeah
I
want
to
take
this
second
just
to
say
thanks
for
all
the
follows,
we
got
tempest
drift
and
jar
back
purus
yeah,
and
we
also
got
like
a
massive
rate.
I
don't
know
if
you
guys
saw
like
a
minute
or
two
ago
we
had
like
50
people
like
jump
in
and
just
see
what's
up
with
that.
So
thanks
for
joining
us,
if
you
drop
by.
C
C
A
Call
it
game
server,
app,
that's
fine,
it
is
associated
with
other
things
that
will
be
called
game
server.
That's
also
fine.
Regular
kubernetes
deployment
is
also
fine.
We
don't
need
a
route
to
the
game
server
because
nobody's
going
to
talk
directly
to
the
game
server,
but
what
we
do
need
is
to
add
an
environment
variable
on
the
deployment
and
that
environment
variable
shall
be
known
as
broker
uri.
E
E
A
Okay,
so
this
is
gonna
blow
up
because
we
don't
actually
have
the
broker
listening
for
stomp
yet
so
this
will
be
actually
an
interesting
test
of
several
things.
I'm
going
to
go
ahead
and
deploy
this,
and
what
will
happen
is
we
will
see
our
tomcat
icon,
which
again
has
nothing
to
do
with
the
game
server,
because
it's
written
in
c.
So
it's
funny
that
it's
the
tomcat
icon
and
so
it's
container
creating,
which
is
just
it's
pulling
the
image
into
the
cluster.
D
E
A
E
E
E
Yeah
and
I
think
I've
gotten
that
feedback
a
number
of
times
now
it's
the
decision
to
do
that
made
sense
at
the
time
when
we
were
doing
the
development,
but
I
think
we're
going
to
need
to
revisit
it.
So
when
we
were
looking
at
that,
we
were
looking
at
some
of
our
other,
our
other
products
that
have
gone
down
this
road
with
their
crds
and
how
they
did
it,
and
this
was
the
route
that
they
took.
So
we
did
the
same.
A
D
A
A
E
A
E
A
A
A
E
B
E
D
D
E
A
A
E
So
if
it
hadn't
so
in
the
case
of
the
broker,
one
of
one
of
the
key
use
cases
for
a
broker
in
general
as
a
networking,
I
guess
component
is
for
running
stateful
right.
So
if,
if
you'd
killed
it
off
and
it
was
stateful,
what
would
happen
because
of
the
staple
set
is
that
the
pvc
would
remain
mapped,
which
is
the
persistent
volume
claim
for
that?
A
Yeah
so
one
thing
that
we
did
not
do
or
or
that
we
did
not
ask
the
operator
to
do
with
our
definition
was
we
didn't
ask
it
to
create
any
storage.
So
if
we
look
at
our
project
here,
the
only
pvcs
we
have
are
for
the
jboss
data
grid
and
for
the
key
cloak,
because
those
two
operators
the
way
that
they're
configured
they
did
that,
but
you
don't
see
a
claim
for
the
broker.
A
A
E
E
D
A
A
In
20
minutes
we
took
like
a
random
image
and
sort
of
got
it
going
and
used
some
operators
to
heavily
reconfigure
services
that
were
already
deployed
in
production
like
if
you
ignore
our
clowning
horrible
production,
hygiene
or
whatever,
like
okay,
fine.
We
took
a
major
outage
for
like
30
seconds
of
our
infrastructure.
A
Yeah,
and
even
more
so
in
reality,
even
if
we
only
had
one
what
we
would
have
done,
if
we
realized
that
we
needed
to
like
sort
of
burn
it,
all
down
is
like
we
could
have
done
some
kind
of
like
a
b
ish
deployment,
where
we
spin
up
a
new
broker
and
then
point
all
the
services
at
the
new
broker
and
then
do
some
kind
of
what
that,
like
there's
a
million
ways
that
we
could
have
done
this.
That.
E
E
A
E
E
So
there's
no
message
of
saying
commanding
that
makes
sense
right.
There's
no
clients
just
went,
I
don't
know
if
there's
any
sense
starting
out
and
no
there's
not
because
it's
essentially
waiting
for
somebody
to
join
before
like
if
we
look
back
to
what
we've
done
previously,
like
nothing
happens
here
until
that
client
connects
and
then
basically
kicks
off
the
creation
of
the
entities
in
the
physics
simulation
and
then,
as
soon
as
that
happens,
then
there's
some
data
being
spewed
out
to
the
game
event.
E
G
A
A
E
F
A
E
D
F
D
A
E
F
B
B
A
A
F
A
A
D
A
D
E
E
B
B
C
E
Yeah,
ideally
here
what
we
would
have
is
like
we'd
have
a
nice
little
container.
We
could
launch
containing
all
the
clients
and
then
you
could
just
like
log
into
the
terminal,
even
in
the
client
container
and
pick
the
client
you
want
to
use
for
testing,
and
then
you
know,
use
that,
then
to
generate
some
traffic
right
in
the
case
of
the
broker,
the
broker
itself
can
be
used
to
produce
and
consume
traffic,
but
only
by
the
core
protocol,
which
again
doesn't
help
us
in
this
case.
E
C
E
C
Yeah,
I
came
prepared
absolutely
so.
What
I
basically
did
here
is
kind
of
canonified
and
worked
through
our
game
design
document
that
we're
working
on.
So
while
eric
is
getting
a
stop,
client
up
and
running,
I
figured
I
will
pop
through
it
yeah,
so
we
kind
of
when
you're
building
out
a
game
like
this,
we
kind
of
talked.
C
I
think
two
sessions
ago,
a
little
bit
about
how
you
set
up
that
game
design,
but
it
all
starts
with
the
document
right
and
what
you're
doing
is
just
kind
of
putting
together
all
your
ideas
on
paper.
So
you
can
collaborate
with
your
teammates
and
build
out
your
vision.
So
first
thing
you
want
to
do
is
kind
of
summarize
what
you're
building
right
and
what
we're
building
is
a
massive
multiplayer
space
combat
arena
and
we're
really
focusing
on
those
large-scale
battles
right,
and
we
also
want
to
add
a
little
bit
of
level
strategy
right.
C
We're
not
just
going
to
make
a
game
that
isn't
fun
to
play
just
to
demo
things,
but
we
do
want
to
keep
in
mind
that
what
we're
doing
here
is
demoing
capabilities
of
openshift.
So
these
are
our
design
pillars
that
we've
settled
on
the
first
one
being
massive
scale.
Second,
one
being
persistence
right,
you
want
to
be
able
to
demonstrate
that
the
universe
that
players
are
inhabiting
is
persistent
and
can
live
on
openshift
over
time.
Of
course,
we
want
player
agency
right.
We
don't
just
want
this
to
be.
C
You
know
a
demo
where
you
click
and
connect,
and
it
says:
hey,
I'm
working,
you
want
to
be
able
to
prove
like
I
can
interact
with
this
system
and
participate
in
it
and,
of
course,
strategy
and
tactics,
because
you
know
what
is
a
game
without
the
layer
of
fun
in
intriguing
it
and,
of
course,
real
time
combat.
We
want
to
be
able
to
prove
that
openshift
can
handle
the
level
of
demand
necessary
with
real-time
games
and
not
just
kind
of
a
turn-based.
C
You
know
message
service
so
that
first
pillar
massive
scale,
that's
kind
of
the
thing
with
openshift
right.
That's
that's!
The
important
thing
about
cloud
native
development
is
that
scalability
is
now
a
known
problem.
It's
not
a
oh
god!
How
many
machines
do
we
have
to
buy
and
are
these
servers
designed
correctly
to
handle
our
you
know
our
server?
And
how
do
we
have
to
write
this
code
work
with
the
hardware
we
have
in
the
budget?
C
We
have
right
now
it's
a
lot
more
about
making
those
intelligent
decisions
and
trade-offs
in
a
space
where
you
don't
have
to
own
the
hardware.
You
don't
have
to
own
the
entire
setup
and
infrastructure,
but
instead
you
can
rely
on
the
expertise
and
services
of
others
and
scale
up
and
down
as
necessary.
So
you
don't
have
those
expenditures
constantly
costing
you
money
as
you're
working
through
development
deployment
and
your
life
cycle
of
the
game.
C
Persistence,
of
course,
is
important,
like
I
said,
because
we
want
people
to
be
able
to
experience
that
passage
of
time,
but
we
also
want
to
be
able
to
really
demonstrate
like
you
can
build
a
persistent
universe.
You
can
build
a
persistent
world
and
experience
with
open
shift
and
still
roll
through
updates
and
be
able
to
mitigate
problems
such
as
downtime
or
you
know,
large-scale
updates
and
deployments
that
affect
the
entirety
of
your
game.
C
Openshift
can
handle
that
with
ease
and
so
being
able
to
have
that
persistent
universe
makes
that
you
know
apparent
and
obvious
player
agency.
Of
course,
as
we
said,
is
important,
because
we
want
to
be
able
to
show
that
players
can
actually
interact
with
the
system.
It's
not
just
a
you
know
passive
demo,
but
we
also
wanted
to
be
able
to
design
the
game
where
the
players
could
choose
their
level
of
difficulty,
where
it's
their
choice
of
how
much
they
want
to
involve
themselves
in
the
game.
C
So
when
we're
handing
off
this
demo,
you
know
and
kind
of
showing
it
to
people
and
having
everyone.
You
know
in
the
twitch
chat,
connect
and
play
with
us.
It's
not
something
where
it's
like.
Oh
god,
you
know,
I
meant
it
on
destroyed
right,
but
you'd
be
able
to
kind
of
affect
and
choose
how
you
participate
in
the
demo
and
still
get
a
good
experience
out
of
it.
C
This
is
the
fun
part
of
the
game
right.
This
is
the
the
big
player
portion
strategy
and
tactics,
and
we
wanted
to
make
sure
that
the
way
you
interact
with
the
game
is
very
simplified.
It's
something
that
can
be
understood
very
quickly,
but
has
a
lot
of
potential
for
emergent
complexity
and
that's
kind
of
one
of
the
you
know.
Beautiful
things
about
game
design
is
allowing
for
that
emerging
complexity
to
really
affect
how
players
are
the
game
and
how
the
game
evolves
over
time.
So
that
means
we
really
want
to
make
it.
C
That
itself
right
is
a
very
simplistic
interaction,
very
simplistic
way
to
be
a
part
of
the
game
universe,
and
yet
it's
going
to
have
a
whole
lot
of
implications
for
the
player.
If
you're
positioning,
you
know
yourself
with
another
player
in
between
you
and
a
player,
that's
attacking
you
right!
That
player
is
going
to
intercept
those
different
energy
weapons
or
missiles,
or
whatever
else
is
going
on.
C
You
know
those
are
all
going
to
be
decisions
you
can
make
simply
by
positioning
and
movement
and
then
same
thing,
of
course,
with
your
choice
and
repairs
and
upgrades
as
you
make
your
way
through
the
game.
There's
real-time
combat
it's
pretty
obvious
right.
This
isn't
going
to
be
turn-based
you're
not
going
to
be
tapping
through
a
queue
or
anything
like
that.
You're
in
real
time,
be
able
to
see
everything
unfold
in
front
of
you,
which
means
you
know
the
open
shift
deployment.
C
Our
game
server
will
have
to
be
reasonably
performing,
especially
at
the
massive
scale
that
we're
going
to
be
operating
and
deploying
on
openshift.
It's
also
important
to
receive
that
immediate
feedback
as
well.
We
have
a
summary
here
that
basically
is
kind
of
like
a
what?
What
can
the
game
you
know
feel
like
if
you're
playing
it
so
I'll?
Read
that
out
real
quick,
you
tap,
engage
and
watch
as
your
ship
warps
into
the
battlefield
within
moments
of
zooming
out
to
assess
the
situation
you
get
hit
with
a
blast
of
red
laser
fire.
C
The
fight
has
begun.
You
quickly,
scope
out
another
larger
ship
and
flee
behind
it
successfully,
letting
them
take
the
hit
from
the
massive
blast
of
a
quantum
cannon
from
your
pursuer.
You
arrive
on
the
other
side
of
the
patsy
behemoth
and
unleash
your
missile
barrage.
The
enemy
is
no
more.
However.
You
now
have
the
problematic
situation
of
needing
to
survive
against
your
faux
shield,
long
enough
to
upgrade
and
repair
so
that
kind
of
gives
you
kind
of
like
that
overview
of
like
what
do.
G
C
Of
like
the
big
yeah,
like
that's
the
pitch
statement,
right,
there's
the
hype,
there's
the
excitement.
Let's
do
it
core
mechanics.
As
we
said,
we
got
our
massive
scale,
we
got
persistence,
we
got
player
agency,
strategy,
tactics
and
real
time
and
combat
our
interface
is
all
going
to
be
mobile
and
browser
based
right.
So
that's
pinch
to
zoom
tap
to
move
same
thing.
You
know
you're
gonna,
click
or
use
your
scroll
wheel
and
then,
of
course,
we're
gonna
have
our
upgrade
and
repair
dialogue
as
you're
working
your
way
through
the
game.
C
C
B
A
B
E
E
E
D
B
B
F
A
G
D
A
G
E
E
G
E
F
B
F
D
D
G
E
More
top
yeah
yeah
at
the
very
very
top
you
can
see
what
the
arguments
are
that
are
passed
so
essentially,
the
way
it
works
at
the
moment
is
that
when
the
broker
container
starts
up
in
the
pod,
there's
an
instance
of
the
broker
created
and
these
flags
are
passed
through.
So,
as
you
can
see,
there,
the
require
login
to
take
effect
because
the
flag
was
passed
to
the
create
to
allow
anonymous
access.
E
E
A
E
G
F
A
E
E
F
E
C
E
A
C
F
D
E
E
A
E
E
E
D
A
E
B
D
A
F
D
B
B
B
E
E
A
E
Yeah,
so
if
I've
connected
at
this
point,
then
we're
not
getting
any
notifications.
So
in
the
case
of
the
the
old
broker
straight
active
mq,
we
would
get
a
message
there
saying
that
a
connection
was
accepted,
but
in
the
case
of
artemis
I
don't
know
that
that's
the
case,
so
that
doesn't
really
help
us
any.
E
B
B
E
B
E
B
B
E
G
A
E
F
A
F
G
E
E
A
E
E
A
A
A
A
B
F
F
A
E
D
A
E
E
F
A
E
E
E
Yeah
so,
for
example,
in
the
case
of
the
broker,
when
we
were
testing
the
core
protocol,
which
is
a
non-browser
native
non-cloud
native
protocol,
it
was
not
sni
aware
and
one
of
the
things
we
had
to
fix.
For
example,
when
broker
7
was
released,
we
had
to
go
in
and
actually
add
the
sni
code
to
the
tls
implementation
of
the
protocol
to.
F
F
E
A
C
A
E
B
D
E
E
C
A
C
E
E
They
could
handle
web
sockets
as
well
as
had
a
client
that
would
work
in
c
plus
plus,
which
would
allow
me
to
do
the
back-end
server,
we're
basically
making
a
move
to
mqp,
which
is
an
iso
standard
protocol,
amqp
1.0,
to
be
exact
so
that
the
downside
there
is
that
it's
tcp
based
and
hasn't
moved
to
being
udp
based
as
well,
yet
which,
from
a
game
server
point
of
view,
is
okay
well,
at
least
from
a
first
person.
Shooter
point
of
view
would
be
seen
as
kind
of
sucky
and
slow.
E
E
E
Amqp
is
going
to
be
building
in
a
udp
support
so
that
it
can
support
other
business
type
protocols
like
sctp,
for
the
telco
space
and
then
in
the
future.
We
may
move
to
using
something
like
quick
quic,
which
is
currently
being
standardized
at
the
ietf
and
is
going
to
form
the
basis
of
http
3,
and
it
is
a
udp-based
protocol
which
enables
us
to
like
avoid
some
of
the
tcp
based
problems,
but
as
well
get
some
standardization.
C
E
E
E
So
here
we
can
see
that
we're
setting
up
basically
an
event,
so
this
is
kind
of
a
c
sharp
style
event
mechanism,
but
being
used
in
c
plus
through
the
poco
library.
So,
if
anybody's
familiar
with
boost,
the
poco
project
is
kind
of
a
a
standard,
open
library
of
c
plus
plus
functionality,
similar
in
some
ways
to
the
functionality
provided
by
boost,
but
perhaps
not
as
heavyweight
as
what
boost
might
be
seen
as.
E
So,
for
example,
here
we're
looking
at
so
essentially
we
can
see
right
here
that
the
event
response
from
the
command
consumer
to
handle
a
received,
cms
message
event
as
it
comes
in
as
a
bytes
message,
is
to
simply
on
cue
the
message
for
processing
and
not
necessarily
document
its
arrival
right.
So
even
if
we
were
to
do
something
like.
E
So
yeah,
so
one
of
the
tricky
parts
here
is
that
so
going
back
to
this
client
for
a
long
while
I
had
been
writing
c,
plus,
plus
extremely
heavily
between
2008
and
2012.
I
probably
wrote
you
know
a
few
hundred
thousand
lines,
or
even
more
of
my
own
code
for
my
own
engines
and
stuff
for
the
mobile
games
that
I
put
out,
but
most
recently
here
at
red
hat,
I've
been
writing
all
in
go.
D
E
E
E
E
E
A
F
D
E
E
D
E
A
E
D
A
A
Kind
of
to
recap,
a
little
bit
of
today
right,
we,
we
got
the
game
server
image
running
and
we
actually
sort
of
got
it
to
talk
to
the
broker
and
we
showed
a
little
bit
more
about
kind
of
using
the
amq
operator,
and
you
know
making
all
those
things
talk
and
work
and
walk,
and
so
really,
at
this
point
now
we're
getting
closer
to
getting
a
functional
game
server
that
we
can
then
talk
to.
And
then
it
just
becomes
sort
of
this
back
and
forth.
A
Iteration
of
make
a
little
bit
of
the
client
to
do
the
thing
and
then
add
more
function
in
the
game
server
and
then
make
a
little
bit
of
the
client
and
then
the
game
server
and
at
some
point,
that'll
get
integrated
into
the
data
grid,
where
we
actually
pull
player
information
and
store
player
information
about
what's
going
on
in
the
universe
into
the
data
grid,
and
so
with
that
I
bid
all
of
you
farewell
happy
holidays
to
everyone.
No
matter
what
you
celebrate
or
if
you
don't
celebrate
anything
then
happy
winter
time.