Index
A
Adaptive Tile Refresh (ATR)
addUseless method
Adobe Edge Animate
afterInit methods
Almost Native Graphics Layer Engine (ANGLE) library
Analog inputs
Application programming interfaces (APIs)
Arrays
error-prone changes
indexed properties
JIT compilers
logical groups
single interleaved
structure of
Artificial intelligence (AI)
Asm.js code
Asset grouping
Audio formats
Automated workflow
advantage
command-line primer
game optimization and packaging
Grunt
creation
file installation
HTML5 games
Node.js installation
Bash command line
command-line integration
default settings
Git Bash
http://nodejs.org
screen
npm
reproducible build process
Autotiles technique
abyss
shadows
smooth transitions
design purposes
magic number
neighbors
noSurface flag
object tile
perfection
symmetry
tile unprocessed
upper-left corner
upper-right tile
useless corners
B
Bash commands
Binary JSON (BSON)
Bucketing method
alpha values
BucketGrid class
BucketGrid insertion
complex pixel coverage area
findClickedSprite function
getImageData method
inner loop
isPixelTransparent function
min/max boundaries
off-screen canvas
pixel perfect picking
PNGs/GIFs
precision issues
Python script
spatial acceleration structure
SpriteProto updation
2D binning algorithm
2D grid
zIndex
Buffer usage enumeration
C
Canvas 2D API
affine transformation
battery problems
bitmap image
DrawImage
Get/PutImageData
illustrator/flash
ImageData output
browser compatibility
color transformation
alpha
browser implementation
“darker” operator
FA and FB
formula
get/putImageData
globalCompositeOperation property
RGB channels
CSS
Dirty Rect
drawImage
drawing paths
GPU cache
in-memory canvas
memory problems
Path API
character
drawing
output
Canvas picking
bounding box method
brute force technique
bucketing (see Bucketing method)
convex hull picking (see Convex hull picking)
sprite prototype
definition
drawSprites() function
loadProtos function
rendering
SpriteInstance class
Canvas Profiler
Chords
Clang
_clearOnError method
Client-side storage
Cocos2d
action
animation
Cocos2d-html5 (see Cocos2d-html5)
Cocos2d JSB (see Cocos2d JSB)
community
coordinate system
director
game types
layer
nodes
scene
scheduler
sprite
touch event
2D game development
web sites
Cocos2d-html5
built-in examples
download page
Fruit Attack
index page
MoonWarriors
test cases
web server installation
vs. Cocos2d
directory structure
JavaScript Binding
template structure
tiled editor
tower defence game
applicationDidFinishLaunching() function
background tile maps
collision detection
component design
deploying
enemies and actions
GameLayer.js file
GameMaps
game over scene
main menu scene creation
menu items
multi-resolution adaptation
music and sound effects
project setting configuration
scenes and layers
SystemMenuLayer class
tool bar layer
towers and bullets
Cocos2d JSB
Android project
development setup
hybrid project screen
iOS project
configuration
copy bundle resources
resource addition
native code
project creation log
Coercion
automatically convert
equality checking
parseInt and parseFloat
truthiness
Content distribution networks (CDNs)
Convex hull picking
advanced data structures
hull generation process
industrial strength implementation
ray casting
texture atlases
trade-off
vs. traditional bounding box
Crunch
Crunch texture format
dxt-util.js file
Emscripten/Javascript interface
compile command line
Crunch constants
crunch_lib.js file
decompressCRN function
dxt_utils.js file
EXPORTED_FUNCTIONS array
loadCRN method
Web Workers
CrunchPendingTexture class
crunch-worker.js message handling
DXTLoader constructor
D
Dart
devicePixelRatio property
Digital input
Dirty Rect method
drawImage() method
DXTLoader constructor and SupportsType method
E
ECMAScript 3 (ES3)
ECMAScript 5 (ES5)
ECMAScript 6 (ES6)
Emscripten compiler
arithmetic
asm.js
clang
game port
AstroMenace renderer
FreeType
game building
game choosing
game content loading
libogg and libvorbis
Linux or Mac command lines
main loop
multiple platforms
OpenGL
SDL_Delay function
lerp function
LLVM IR translates
memory representation
vs. native
strlen function
toolchain (see Emscripten toolchain)
workflow
Emscripten toolchain
Canvas
debugging
Hello World program
input events
performance
Web Audio API
WebGL
F
Fast canvas rendering
1,024 × 024 canvas tile boundaries
64 × 64 tile boundary grid
box-box intersection code
CanvasTile
fillCanvasTile
map drawing
Faster map rendering
DrawMap function
fast canvas rendering (see Fast canvas rendering)
load function
map object
tiled map (see Tiled map)
Firebase
Flash assets
authoring tool
cutout animation
devices and browsers
fonts
nine-slice images
sounds
sprite sheets
vectorization
Float32Array
Free object
FrightCycle game
client-side prediction
dependencies
game state
node build.js
node server/app.js
server and client communication
server commands
synchronizing time
Fullscreen API
button creation
device orientation
disabling zoom
entering and exiting fullscreen
homescreen
Android
Chrome menu
detecting standalone
Firefox OS
icons
iOS
meta tags
shortcut
losing fullscreen
lower resolution
canvas
computing frame rate
GPUs
graphic quality
running
Sindre Sorhus
sprites sharp
CSS scaling
motion blur
pixel grid
staying sharp
system and address bar
G
game_loop
Gamepad API
browsers support
Google Chrome
Mozilla Firefox
devices support
draft stage
Hungry Fridge
mobile vs. desktop
Phaser game framework
start screen
implementation
axis events
buttonPressed function
gamepadconnected function
gamepaddisconnected function
gamepad object
project setup
source code
Geolocating assets
Girls Raised in Tennessee Science (GRITS)
Global deopt
Google Web Designer
Graphics processing unit (GPU)
GruntFile.js ×in
H
High-Performance JavaScript
discarding offscreen particles
object pools
demo source code
free-indexes array
free object
garbage collection
getFree method
goal
iteration
looping
memory spikes
memory usage
particles array
recyclable objects
structure
profiling
rendering loop
virtual machine
benchmarking
deoptimization
function optimization
optimization
warm-up phase
WebGL demo
HTMLCanvasElement
HTML5 game build scripts
HTTP caching
I
init methods
Input latency
J
JavaScript
OOP model
class-based language
prototypical inheritance
operators
coercion (see Coercion)
instance of operator
strings and booleans
types
arrays
booleans
null
numbers
objects
strings
undefined
variables and scoping rules
declaration hoisting
declaration scoping
JavaScript data structures
encoded data
execution performance
flattening
memory and code profilers
memory usage characteristics
null-out references
object count
performance data
resources
string name
TypedArray
ArrayBuffer
ArrayBufferView
drawbacks
Math.fround function
memory buffer
JavaScript Object Notation (JSON)
file
format
object
K
Kaazing
L
Load and save methods
loadDDS method
Local deopt
lockOrientation method
Lockstep method
M
Main loop
browser controlling
inputs
outputs
game build up
accumulating time
demand rendering
extrapolation
falling behind
internal game clock
interpolation
time delta
user input
user input processing
analog input
chords
digital inputs
game-specific input values
positional inputs
sequences
Memory caching
MessagePack
Mobile web game techniques
Canvas (see Canvas 2D API)
real devices
Mozilla Shumway
Multiplatform games
asset sizes
audio
control method
baseline requirements
game design
joypad
mobiles/tablets
mouse and keyboard
touch screen
trap setting
Venn diagram
interaction design
interface design
maintenance
performance testing
benchmarking systems
Bugmark Test Suite
DOM manipulation
Scooby-Doo game
physics engine
intersection point
JavaScript game loops
line intersection
linked list collection
slope and friction
Scooby Doo Funfair Freak-Out
N
Network time protocol (NTP)
Non-deterministic game logic
O
Object-oriented programming (OOP)
Old-school video game techniques
animations
background image
bouncing ball
paintball() function
painting
viewports
color cycling
getImageData()
HTML5
metadata
paintPixels() function
spritesheet-based approach
update loop
variables
dirty rectangles
application
bounding box
circle
graphical algorithms
modified cells
paintPlayer() function
radius
small red circle
rendering massive grids
for() loops
grid performance
interval and shouldRepaint flag
paintCell() function
process
rendering routine
simple grid
update() function
update routine
update loops
ATR
DOMHighResTimeStamp
processing time
RequestAnimationFrame Polyfill
setInterval function
setTimeout function
shouldRepaint
OpenGL legacy emulation layer
Open Graphics Library for Embedded Systems (OpenGL ES)
Optimal asset loading
asset hosting
asset grouping
CDNs
geolocating assets
server compression
caching data
client-side storage
mapping table
memory caching
server and client communication process
server and client side location
static asset loading
textureCache.get function
data formats
audio formats
JSON format
texture formats
P, Q
paintBall() function
Point class
Polymorphism
Pool structure
Positional inputs
Pusher
R
Rawkets
Real-time multiplayer network programming
challenges
bandwidth
broadcast vs. lockstep
fast-forwarding the game state
latency
NTP synchronization
state broadcast vs. lockstep
state latency
synchronization
code writing tips
checksums
floating point
game engine
game state independent
input delay calculations
particular game-state change
FrightCycle FrightCycle game)
Recyclable objects
Request Animation Frame (RAF)
Responsive design
aspect ratio and dpi
fit inside screen
float middle
ReadPixels
stretch
cloud-computing resources
common tablet resolutions
development-process viewpoint
devicePixelRatio
hardware
layout
MainRoach
normal vs. high-ppi screens
screen dimensions
desktop browser
mobile device
two-dimensional content
S
Scalable vector graphics (SVG)
Sequences
Server compression
Socket.IO
app.js.file
client code
custom event
get and set functions
mobile operating systems
quiz game
sending chat message
sending random question
Software skeletal animation benchmark
Spriter
State broadcast method
State latency
Synchronization
T
Tar files
Texture formats
Textures extension
Texture sheet
Tiled editor
Tiled map
code form
coordinate spaces
data format
GID-to-range table
GRITS project
imgLoadCount variable
JSON.parse method
layers
TILEDMap.js file
view-rect
Two-dimensional map editor
addSpriteSheet method
autotiles off
autotiles on
builder window
camera
editor tool
extendTile function
game application
graphic editor
index.html, jQuery UI
localStoage
main window
MapField
ObjectTile type
renderer
serialization
SpriteList
SurfaceTile type
Tile.id
TileList
Tileset version
TypeScript
Boolean type
canvas drawing
CanvasMapRenderer
clearMap method
draw method
drawTile method
gameloop
IMapRenderer
requestAnimationFrame
two-dimensional array
compiler
engine functionality
enemies and treasure adding
rendering larger maps
rendering sprites
game class creation
command prompt
JavaScript file
keyword “export”
rogue, definition
handling movement
keyup method
map’s public properties
newDirection property
placeholder position creation
project directory creation
concat
connect
deploy directory
developerDependencies
game.css file
game.js file
game’s index page
GruntFile.js
Grunt intallation
grunt.loadNpmTask
index.html file
main.ts file
Node.js
package.json file
RogueTS
Visual Studio
string type
U
User input processing
digital input
V
Vertex array object (VAO)
W, X, Y, Z
ANGLE library
blink data flow
browser supported images
BMP
GIF
JPEG
PNG
WEBP
compressed textures
DDS files
constants
vs. JPEG image file sizes
loadDDS Method
parsing utility functions
_uploadDXT method
drawing model
extensions
draw buffers
instanced array
VAO extension
WebGL 2
Google’s Mountain View campus
GPU process
graphics library
memory use
modify state functions
OpenGL ES
query state functions
scene rendering
batching
frustum culling
OpenGL ES 2.0 pipeline
texture binding
WebGL image gallery
Web IDL
WebGL inspector
Web Graphics Library (WebGL)
Web interface definition language (Web IDL)
WebSocket
application-programming interface (see WebSocket API)
channels and events
connection setting up
data sending and receiving
encoding data
GRITS
JSON key values
scaling and reducing overhead
autonomous Clients/Echo server
BSON
deltas and Infrequent worldviews
Dumb Clients/Authoritative Server
Socket.IO (see Socket.IO)
WebSocket API
event handlers
interface functions
simple echo server
3.128.226.121