The document is a transcript from a talk given by Rob Hawkes about the development of his HTML5 and JavaScript multiplayer space shooter game called Rawkets. Some of the main issues he faced included excessive network traffic due to sending too much data, as well as players easily manipulating game code since it was in the global namespace. He overcame these issues by implementing a structured message protocol to reduce network payload, and adding his own namespace to better organize code and make cheating more difficult.

1. Hi, I’m Rob Hawkes and I’m here today to give an inside look at the development of Rawkets,
my HTML5 and JavaScript multiplayer space shooter.

2. If you don’t already know, I work at Mozilla.
My official job title is Technical Evangelist, but I prefer Rawket Scientist, which is what it says
on my business card.
Part of my job is to engage with developers like you and me about cool new technologies on
the Web.

3. Created by Phil Banks (@emirpprime)
Aside from that I spend most of my time experimenting with HTML5 and other cool
technologies.
I basically have an addiction to visual programming and hacking around with code.
It’s fun!

4. Throughout this talk I plan to take a journey through some of the issues that plagued early
development of the game, and cover the subsequent solutions that helped resolve them.
There’ll be some code, but I’m more interested in highlighting the concepts and theories
involved.
So far the talks have all been awesome and have often gone into some great detail about
particular technologies and techniques. This talk will be quite light-hearted in comparison
and more of an overview of technologies and techniques, so hopefully I’ll be able to postpone
that feeling of death-by-awesomeness for a little while longer.
However, if you have any questions with what I talk about then feel free to grab me after the
talk either in person or online. I’ll be putting my contact details up at the end and the slides
will be put online at my blog, which I’ll also mention at the end.

5. ion
t
ta lab
e n
erim from m y
Exp ate
adu
a gr
is
kets
Raw
Rawkets is a project that originally came out of this experimentation, from a desire to learn
more about WebSockets in regards to multiplayer gaming.
Now, the game is much more mature and I’d consider it as a separate entity aside from the
experiments. It’s something that I plan to develop and support way beyond the original scope
of learning WebSockets.

6. ts ?
ke
aw ckets
is R Ro
at ts,
d
an
Wh ocke
bS
s, We
ke
Raw
Rawkets stands for Rawkes (my blog), WebSockets, and Rockets.

7. Rawkets is a multiplayer space game that allows you to shoot your friends in the face with
HTML5 technologies.
It’s still not really at a beta release level yet, hence the bugs you might notice in this video.
http://rawkets.com

8. By now you’ve probably realised that the graphics at the beginning of this talk and on the
posters aren’t the real game graphics.
They are actually an awesome “artists impression” illustration that I commissioned a guy
called Reid Southen to create.
Perhaps when WebGL gets better it will become a reality. Who knows.

9. It looks pretty awesome as a 6ft banner. So awesome in fact that my girlfriend actually asked
me if I was going to put it up in our flat our not. She seemed pretty down about me saying no
(it smells pretty horrible).
This is a photo of me in front of the banner at my university end-of-year show. If you think it
looks small then let me put it into perspective by telling you that it’s about 8ft away.

10. g y
o lo
chn ing
Te ebg
am
W in
ed
olv
inv
tech
fthe
eo
Som
There are a few key technologies that are involved in the development of the game.
All of them bar one are tightly related to HTML or JavaScript.

11. vas
an
C tfo
rm
pla
ics
raph
g
2D
Canvas for 2D graphics.

12. d io
a u
sh sic
Fla nd
m u
rou
ackg
db
an
cts
effe
nd
Sou
Flash audio for game sound effects and background music.
I’ll explain why I use Flash over HTML5 Audio further on in the talk.

13. e ts
ock
bS ation
e
W omm un
ic
yerc
ltipla
Mu
WebSockets is used for the communication between each player and the game server.
For anyone not up to speed with WebSockets, you effectively use HTTP to upgrade a
connection and access fully bi-directional streaming communication.

14. e.js
od
N cation
uni
m
com
rk
etwo
dn
an
logic
e
Gam
Node is used as the game server, controlling the logic and handling the WebSockets
connections to the players.
It will eventually be used for player authentication and the storage of data so gameplay can
persist over multiple game sessions.
This is all made relatively easy with great third-party modules, like Socket.IO for WebSockets,
and others that handle Redis and MongoDB for storage, for example.
http://nodejs.org

15. es
u
ss ge
I n lle
ha
ac
be
an
esc
gam
aking
M
It’s not all plain sailing when making a gaming using HTML5 and JavaScript.
I’m going to cover a few of the main issues that tripped me up during the development of
Rawkets.

16. in g
o rk
etw ug
ht
N Itho
y as
as
se
ta
No
Issues with networking have plagued development of the game right from the beginning.
This probably stems from my lack of prior experience with socket connection and multiplayer
gaming in general.
In the original prototype of the game the network communication was woefully simple and
everything was transmitted in a verbose format with no further thought.
In hindsight it’s obvious why I was experiencing massive performance issues with the
network communication. I was basically sending way too much data back and forth.

17. col
to n
ro atio
e p
sag mun
ic
es tcom
M hor
ds
an
ured
ct
Stru
One of the ways that I solved these problems was by implementing a structured protocol for
the messages that are being sent and received.
This included assigning each message type a number and using enumeration to represent
those types in the code.

18. Enumeration
types = {
PING: 1,
SYNC: 2,
SYNC_COMPLETED: 3,
NEW_PLAYER: 4,
UPDATE_PLAYER: 5,
UPDATE_INPUT: 6,
REMOVE_PLAYER: 7
};
By enumerating the messages types like this I was able to refer to them in a verbose format
within the code, but benefit from only sending the one or two digit number when
transmitting a message.
This is only possible if both the client and server follow the same protocol in regards to which
number refers to which message type.
It’s a simple but effective solution and allowed me to cut a large number of characters from
transmitted messages.

19. Message package
{
z: 1,
id: 1234567890,
t: 1316763202872,
s: {
x: 5,
y: 34,
v: 3,
a: 0.46
}
}
Put together with the message types, a full message package is put together as a JSON
representation of a JavaScript object.
All the other pieces of data are attached to the object with a key that is as short as possible.
The z key that you can see above is a reserved key that is used solely for the message type.
The other keys in this example are a timestamp, the player id, and the player state.

20. io n
s
es ible
pr ss
om po
C uch
as
asm
ata
gd
cin
du
Re
Data in WebSockets is transmitted as verbose plain text, so it’s important to cut down and
compress it as much as possible.
Some of the ways that I’ve done this include rounding numerical values, reducing the length
of words if they’re only used for reference, and generally removing any data that isn’t
necessary.
There is also BISON, which is a binary representation of JSON that can cut down the amount
of data sent back and forth even further, but I’ve heard conflicting reports about its
performance so your mileage may vary.
http://kaijaeger.com/articles/introducing-bison-binary-interchange-standard.html

21. in g
it
lim ation
ate un
ic
R om
m
c
n on
ow
gd
uttin
C
Aside from the message protocol, one of the biggest issues with networking has been dealing
with the sheer number of messages being sent back and forth during the lifetime of a game.

22. MESSAGES IN MESSAGES OUT
1 1
1 1
Having only one player in the game is easy, you have one message coming in to the server,
saying the player has moved, for example, and one message coming back out, updating the
player with details from the server.

23. MESSAGES IN MESSAGES OUT
2 4
1 2
2 1
So say we now have two players, there is still only 1 message in from each player, but now
each player receives 2 messages back from the server; one for them, and one for the other
player.
This isn’t too bad, but notice how the server is having to send 4 messages – 2 for each
player.

24. MESSAGES IN MESSAGES OUT
4 16
1 4
4 1
1 4
4 1
4 players now, look how the server is having to send 16 messages, yet it only receives 4.
If you haven’t already noticed, the messages out from the server are the square of the
number of players.
But 16 messages out is alright, it’s hardly going to tax the server.

25. MESSAGES IN MESSAGES OUT
30 900
1 30
30 1
1 30
30 1
So imagine if we now move into properly multiplayer territory.
30 players in the game would mean 30 messages coming in to the server, and 900 – NINE
HUNDRED – messages going out, every update. That’s a silly amount of data for just 30
people.
But let’s go further still…

26. MESSAGES IN MESSAGES OUT
100 10000
1 100
100 1
1 100
100 1
Say we go massively multiplayer and have 100 players in the game at one time.
It’s not so bad for each individual player, they send one message in and get 100 back – that’s
bearable.
But check out the server, it’s getting 100 messages in and is having to send out 10,000 back,
every update. That’s just a mentally stupid number that’s going to cause a lot of grief.

27. nce
lige es
tel essag
In se m
iti
prior
e
am
theg
tting
Le
Fortunately there is a way around this that cuts down the amount of messages sent; you just
need to send data only for players visible to another player, in essence filtering out game
data that doesn't affect the current player.
Another trick I used is to only send updates when a player is active and moving. If they
haven’t moved since the last frame and nothing else has changed then why bother sending
an update and wasting bandwidth?
These are such simple solutions, but ones that I never even considered at first.

28. TC P
ing
ect lw
ith
it
esp .D
ea
R sesT
CP
etsu
ck
So
Web
Something else that I discovered is important to be aware of when making a game with
WebSockets is that you’re using TCP.
This is a problem as such, but it means that you need to play by a certain set of rules, and to
expect a certain set of issues.
By the way, I should point out that that you could argue that the icon that I’ve used could
represent WebSockets, but that’s not why I used it. It’s the US plug symbol and I just thought
it was funny because it looks like a surprised face. The UK plug symbol is boring in
comparison.

29. e r
ord
th e ou
t it
ey ab
Ob om
uch
’t d
can
You
One issue with TCP is that packets will come through in order and get queued up if there are
any significant connection issues.
This can be a problem with a real-time game as it can cause hang-ups in the transmission
and subsequently a hang-up in the graphic display.
In short, the ordering issue can result in jumpy gameplay. Not fun.
With UDP this wouldn’t be so much of a problem, but we don’t have that luxury yet. Although
similar protocols are in the pipeline and may make their way into our lives relatively soon,
things like Media Streaming APIs and WebRTC.

30. t.IO
e
ck ages
So
se ess
U drop
sm
tly
en
tellig
It in
I use Socket.IO for all the WebSockets communication for Rawkets simply because it’s easy to
use and it has Flash fallback for browsers that don’t support the technology yet.
The cool thing about the latest version of Socket.IO is that is has introduced the concept of
volatile messages.
These volatile messages are completely voluntary, and messages sent with them aren't
actually sent if the client is having network problems, saving bandwidth for other more
important messages.
It’s not an ideal solution, but it’ll certainly help alleviate some of the issues that come with
TCP.

31. ters
ea
Ch urse
ac
and
ssing
ble
A
There’s no denying it, your code is going to be visible to anyone who wants to look at the
source.
I experienced this early on in the development of the game with players adding in their own
features, like invincibility, epic speed, rapid-fire, and even creating completely new weapons
like cluster bombs!
Now don’t get me wrong, I actually appreciate the cheaters because they highlighted all the
errors of my ways, for free. One of the benefits of the open nature of JavaScript is that it can
be looked at and poked very easily by others, which means that I can fix bugs quicker than if
I was testing on my own.

32. re s
su ad
lo is b
d c
an op
en
als wide
b
lo ping code
G ee
K
There are two reasons why cheating was so prevalent and so easy to do.
The first is that by keeping all the game code in the global namespace and not using any
closures, I was practically inviting people to come in and edit the game code. It was too easy
to do!
It was so easy in fact that after a few hours of releasing the first prototype, players were
already sharing code snippets that others could paste into their browser console to get new
features. Annoying, but actually pretty cool.

33. (function() {
var rawkets = rawkets || {},
r = rawkets;
rawkets.namespace = function(namespace_str) {
var parts = namespace_str.split("."),
parent = rawkets,
i;
if (parts[0] === "rawkets") {
parts = parts.slice(1);
};
for (i = 0; i < parts.length; i++) {
if (typeof parent[parts[i]] === "undefined") {
parent[parts[i]] = {};
};
parent = parent[parts[i]];
};
return parent;
};
window.rawkets = window.r = rawkets;
})(window);
By adding my own “rawkets” namespace I was able to hide code away, and by deliberately
utilising closures and private variables I was able to further frustrate efforts by cheaters to
overwrite game functionality.
Plus the new namespace makes writing new code and modules so much neater.
Code manipulation isn’t something that I can prevent entirely, but I can at least make it as
difficult as possible.

34. rity
o
th hing
a u
nt oo
dt
Clie ys
ag
a
alw
’t
isn
er
Pow
I’m not going to lie, the first version of Rawkets was way too trusting.
I used what is referred to as the authoritative client model, which basically means that the
client, the player, made all the decisions regarding its position and then sent those positions
to the server.
The server than trusted those positions and transmitted them to all the other players, which
is fine until the client edits their position and increments it by 100 pixel per frame, rather
than 5. Bad times.
This can be referred to as the “Here I am” approach.

35. ri ty
o
th wer
a u
r
ve ish th at
po
er
S elinqu
R
The solution is to make the server authoritative, which means that you prevent manipulation
of the client’s code from doing any damage.
All the movement logic is now performed on the server, meaning that when a client moves it
simply lets the server know which direction it wants to move. From there the server calculates
the new position and sends it back to the client.
This can be referred to as the “Where am I?” approach, and if done right it can completely
remove the ability to cheat.

36. Inherent latency
40ms 40ms
Input Move Update
+0 +40 +80
80ms total round-trip
However, the problem with the authoritative server model is that there is some inherent
latency within the system.
What I mean by this is that it obviously takes some time for a movement to be sent from the
client to the server, then for the server to move the client, and then for the server to send the
new position back again.
In the example here imagine that there is a 40ms latency between the client and server,
which means that a message sent to the server will take a total of 80ms to make the round-
trip.
The problem here is what happens during that 80ms period that you’re waiting for the
updated position? If you do nothing then there’s going to be an 80ms delay between you
pressing the up arrow and your rawket moving forward. Not good.

37. io n
dict h
pre no
ug
nt ’t e
Clie hority isn
ut
vera
Ser
To solve the latency issues with the authoritative server you need to implement some element
of prediction on the client.
What I mean by prediction is an ability for the client to guess, quite accurately, where it
should move the player before the message comes back from the server detailing the new
position.

38. Instant movement
40ms 40ms
Input Move Update
+0 +40 +80
Prediction happens here
The prediction happens as soon as the client performs some sort of movement (a key-press,
etc), before the server has received the input.
All the prediction does is run the same physics as the server, based on the new input.
This is exactly as if were using the authoritative client model, apart from one important
difference.

39. ion
ct
re rong
or
C oesw
ng
tio
redic
p
hen
W
Whereas the authoritative client model would be in control, with the authoritative server
model and client prediction, the server is in control.
The whole point of using the authoritative server is because the client can’t be trusted. So it
makes sense that prediction can’t be trusted either.
To get around this you use periodically check the client position against the server and
perform a correction if necessary.
This may sound simple in concept, but it’s one of the hardest aspect of multiplayer gaming to
get right. Simply because it’s obvious when you get it wrong.

40. var correction = function(time, state, input, entity, rk4) {
...
if (Math.abs(state.x - lastMove.state.x) > 2) {
...
var currentTime = time,
currentInput = input;
entity.setState(state); // Rewind entity state
var move, // Current move
frameTime; // Time between correction and stored move
for (m = 0; m < moveCount; m++) {
move = moves[m];
frameTime = (move.time - currentTime) / 1000;
// Update physics based on corrected time, input and state
...
currentTime = move.time;
currentInput = move.input;
move.state = entity.getState();
};
};
};
This is the Gaffer on Games approach by Glen Fiedler.
There are also other solutions, like Valve’s approach which is based on the old QuakeWorld
theory.
I’m actually yet to get client-side prediction working faultlessly, and I’d love to see other
games developers sharing their JavaScript-based prediction techniques. I know that a lot of
developers are working on this.
http://gafferongames.com/game-physics/networked-physics/
http://developer.valvesoftware.com/wiki/Latency_Compensating_Methods_in_Client/
Server_In-game_Protocol_Design_and_Optimization

41. ility
b
ta ning
S un
er
am
theg
ping
Kee
Keeping the game running is massively important, especially while it’s in rapid development
and is prone to crashing (through errors of my own I must add).
I needed a way to automatically restart the game server if it crashed or something went
horribly wrong.

42. mmonit.com/monit
To do that I originally went with Monit scripts that monitor the WebSockets port for activity.
If the port is inactive for 3 separate checks in a row then the game is automatically restarted
in Node.
Ideally the game shouldn't crash, but this has proven to be a great solution that allows me to
continue rapidly developing the game without worrying about it going down permanently if
I'm not around.
http://mmonit.com/monit/

43. Monit script
check host rawkets.com with address 127.0.0.1
start program = "/etc/init.d/rawkets start"
stop program = "/etc/init.d/rawkets stop"
if failed port 8000 type tcp for 2 times within 3 cycles then restart
Just as a quick example, here is the entire monit script for keeping the game up and running.
I’d say four lines of code was pretty impressive!
This effectively checks port 8000 on rawkets.com for an active tcp connection every cycle (60
seconds), and will only restart the game if there is a problem for at least 2 cycles.
The time between cycles can be changed in the monit configuration files.

44. Init.d script
#!/bin/sh
case "$1" in
start)
cd /rawkets
/usr/local/bin/node rawkets.js 2>&1 >> /var/log/node.log &
exit 1
;;
stop)
/usr/bin/pkill -f 'node rawkets.js'
exit 1
;;
esac
exit 1
This is the init.d script that I use to start and stop the game server from the command line.
All it does is binds a particular set of shell commands to “start” and “stop” keywords, which I
use to start and stop the Node process for the game.
I’m not massively experienced with init.d scripts so I’m sure that it can probably be
optimised, but it works perfectly for my needs and is pretty damn cool.

45. github.com/indexzero/forever
Now I use a little Node module called Forever. It’s amazing!
https://github.com/indexzero/forever

46. Forever
forever start rawkets.js
All I have to do now is make sure the game process quits on a catastrophic error and Forever
will automatically restart it for me.
Using Forever is as simple as installing the module with NPM and then starting your Node
script using the Forever demon. The rest is taken care of for you.

47. github.com/hookio/hook.io
Some of you may also be interested in hook.io, which can help create more stable Node
applications.
The concept is to decouple your application logic by breaking it into individual processes so
that if one process goes down the rest can continue to run and your entire game doesn’t
crash.
You use hook.io through its event system that lets you communicate between these separate
processes, regardless of whether they’re on the same server or not. It’s a pretty cool concept.
https://github.com/hookio/hook.io

48. io ?
u d
h a et
la s ad
yy
y F ite
re
Wh isn’t
qu
dio
Au
L5
HTM
So why in a proud HTML5 and JavaScript game have I resorted to Flash?
To put it bluntly, HTML5 Audio support is severely lacking in areas for the needs of game
development.
One particular example is support for looping, which is severely lacking and inconsistent
across most browsers.
Opera has the best implementation so far, but the rest all have some kind of pause between
loops, which makes short and constantly looping audio very obvious and annoying.
There are some solutions, like using JavaScript to try and loop the audio just before it is
finished, or using the audio data APIs in Firefox and Chrome, but none are ideal so I went
with Flash audio for now until it gets fixed.

49. o re
s m ot
ad al
Lo hy
ou
eac
est
am
L5g
HTM
There’s loads of stuff that I couldn’t fit in that I’d love to have talked about.
Things like:
- Canvas optimisation.
- Using internal events to decouple game logic.
- Using the same code for client and server.
- setTimeout vs. requestAnimationFrame.
- How to handle storage.
- Control systems for different platforms, like Seb Lee-Delisle’s approach.

50. tu re
e fu ng
Th tg
am
i
ip cr
aS
in Jav
ee
os
liket
I’d
hat
W
There are a few things that I’d like to see in the near future to help with game development.
Need a way to benchmark browsers, connections and operating systems.
- Like Google Analytics, but for game performance and feature detection.
- Measuring FPS.
- Measuring network performance.
Better HTML5 audio.
Hardware accelerated canvas on Mac and mobile devices.
Better documentation for game development in JavaScript. This is something I’m working on
with Mozilla, but more documentation is needed in general. I’d love to see more game
developers sharing their solutions to problems that they encountered during their games.

51. fun
in g
eth little to ol
om a
S rking
on
wo
en
be
I’ve
So before I finish I’d like to show you one more thing, something that I’ve been working on
recently to help with my game development.

52. Game profiler
It’s a JavaScript game performance profiler that I’m working on for Rawkets.
The purpose is to visualise performance of key areas of game and network logic in a way that
makes it easy to see where things can be improved.
It’s early days, the idea and resulting code are only a week old, but the hope is to eventually
release it as a browser addon or module for other games developers and animators to use.
Right now I’m focussing on getting it working well for my own requirements and making sure
the resulting visualisation is easy to understand (which it isn’t yet, as you can see).

53. Webkit timeline-like
The idea is to create something very much like the Webkit timeline panel, just customised for
apps and gaming to give a much more fine-grained view of performance.
I’m by no means a competent tools developer, but I’m hoping something like this will at least
give me a better idea about exactly where I can increase the performance of Rawkets.

54. Rob Hawkes
@robhawkes
Rawkes.com
Personal website and blog
RECENT PROJECTS MORE COOL STUFF
Twitter sentiment analysis Rawket Scientist
Delving into your soul Technical Evangelist at Mozilla
Rawkets.com ExplicitWeb.co.uk
HTML5 & WebSockets game Web development podcast
Twitter - @robhawkes
Rawkes - http://rawkes.com

55. Foundation HTML5 Canvas
Out now
Paperback and digital formats
Become a canvas master
Learn how to animate
Make two cool space games
RAWKES.COM/FOUNDATIONCANVAS
Foundation HTML5 Canvas is out now on Amazon and other reputable book stores.

56. Mozilla Dev Derby
Every month
Next month is CSS Media Queries
November is HTML5 canvas
Win prizes (like an Android)
DEVELOPER.MOZILLA.ORG/EN-US/DEMOS/DEVDERBY
Also, you should definitely take part in the Dev Derby, which is a monthly competition run by
the Mozilla Developer Network to see what can be done with the latest Web technologies.
This month the focus is on Geolocation, next month is on CSS Media Queries, and November
is on HTML5 canvas.
The winners get cool prizes, like an Android phone. It’s a great excuse to play around with
these technologies.
https://developer.mozilla.org/en-US/demos/devderby

57. Ask MDN
One hour every fortnight
Web development topics
ASKMDN Hand-picked experts
Great discussions
onGameStart special (hopefully)
@ASKMDN & #ASKMDN ON TWITTER
And lastly, I’d like to quickly mention Ask MDN which is a project that I’m working on at
Mozilla.
The concept is simple. One hour every fortnight we gather a bunch of experts on Twitter to
answer your questions about a particular topic.
We’ve had 4 sessions to date and it’s going down really well. If you follow @AskMDN on
Twitter you’ll be sure not to miss the next session.
http://twitter.com/AskMDN

58. Thank you.
If you have any questions feel free to grab me on Twitter (@robhawkes), or email
rob@rawkes.com