Design and Development - Game Development with Three.js - page 86

Performance-measuring tools
Finally, there are a number of useful tools for measuring JavaScript performance.
Conveniently, the original author of Three.js has written a library called Stats.js
( https://github.com/mrdoob/stats.js ) for tracking frame rates, the most crucial
performance statistic for games. For comprehensive tracing, Google's Web Tracing
Framework ( http://google.github.io/tracing-framework/index.html ) is hard
to beat, and it even has an example for tracing a WebGL game. You can also easily
get some statistics about onscreen geometry with the RenderStats library from Jerome
Etienne ( https://github.com/jeromeetienne/threex.rendererstats ).
For brute-force debugging, you may also want to try the console-extras library,
which makes it easier to log information about things that happen in the main game
loop without dumping thousands of messages ( https://github.com/unconed/
console-extras.js ).
Networking and multiplayer
Game networking is hard because the goal of networking is to keep game state in sync
across multiple devices, but network latency prevents devices from communicating
fast enough to keep that state from being occasionally inconsistent. Additionally,
floating point rounding errors create indeterminate results across devices for the same
set of input (this is where the timing and movement techniques discussed in Chapter 3 ,
Exploring and Interacting come into play, since small differences in precision can result
in huge differences over time). As a result, networking code becomes a process of
reconciling differences.
There are basically two different approaches to networking depending on the
requirements of the game. RTS and turn-based games usually use an approach called
lock-step , which is a peer-to-peer model in which each computer in a match sends its
commands to all the other computers in the match. The main strength of this model
is that only a small amount of data (the players' commands) needs to be sent over
the network, so it is useful when the game state is huge (for example, when there are
thousands of units in a map). However, running a game in lock-step depends on all
players having an identical copy of the game state, which is a great idea in theory but
is difficult to maintain for several reasons. First, although the JavaScript specification
states that floating point calculations should be deterministic, in practice there may be
subtle differences across implementations that could prevent clients from being in sync.