Bunch of minor fixes.

Stuff I noticed while revising the print edition.

Author: munificent

book/architecture-performance-and-games.markdown

@@ -186,7 +186,7 @@ extensibility should be engineered in so future changes are easier to make.
 
 People get really excited about this. They envision future developers (or just
 their future self) stepping into the codebase and finding it open-ended,
-powerful, and just beckoning to be extended. They imagine the One Game Engine To
+powerful, and just beckoning to be extended. They imagine The One Game Engine To
 Rule Them All.
 
 But this is where it starts to get tricky. Whenever you add a layer of

book/bytecode.markdown

@@ -498,8 +498,8 @@ We define another instruction type for a number literal like so:
 <aside name="single">
 
 Here, I'm reading a single byte for the value to avoid the fiddly code
-required to decode a multiple-byte integer, but in a real implementation, you'd
-want to be able to have literals that cover your full numeric range.
+required to decode a multiple-byte integer, but in a real implementation, you'll
+want to support literals that cover your full numeric range.
 
 </aside>
 
@@ -710,7 +710,7 @@ kind of behavior you want them to create.
 
 <aside name="text">
 
-The scripting system I wrote for [Henry Hatsworth and the Puzzling
+The scripting system I wrote for [Henry Hatsworth in the Puzzling
 Adventure][hatsworth] worked like this.
 
 [hatsworth]: http://en.wikipedia.org/wiki/Henry_Hatsworth_in_the_Puzzling_Adventure

book/data-locality.markdown

@@ -516,7 +516,7 @@ the CPU busy, instructions are *pipelined* so that the subsequent instructions
 start processing before the first one finishes.
 
 To do that, the CPU has to guess which instructions it will be executing next.
-In straight line code, that's easy, but with flow control, it's harder. While
+In straight line code, that's easy, but with control flow, it's harder. While
 it's executing the instructions for that `if`, does it guess that the particle
 is active and start executing the code for the `update()` call, or does it guess
 that it isn't?

book/double-buffer.markdown

@@ -226,7 +226,7 @@ isn't being accessed during modification.
 ## Sample Code
 
 Now that we've got the theory, let's see how it works in practice. We'll write a
-very bare-bones graphics system that lets us draw pixels on a frame buffer. In
+very bare-bones graphics system that lets us draw pixels on a framebuffer. In
 most consoles and PCs, the video driver provides this low-level part of the
 graphics system, but implementing it by hand here will let us see what's going on.
 First up is the buffer itself:
@@ -427,12 +427,11 @@ small change in `Stage`:
 ^code 12
 
 The `update()` function now updates all of the actors and *then* swaps
-all of their states.
-
-The end result of this is that an actor will only see a slap in the
-frame *after* it was actually slapped. This way, the actors will behave the
-same no matter their order in the stage's array. As far as the user or any
-outside code can tell, all of the actors update simultaneously within a frame.
+all of their states. The end result of this is that an actor will only see a
+slap in the frame *after* it was actually slapped. This way, the actors will
+behave the same no matter their order in the stage's array. As far as the user
+or any outside code can tell, all of the actors update simultaneously within a
+frame.
 
 ## Design Decisions
 
@@ -560,4 +559,4 @@ index.
  *  <p>You can find the Double Buffer pattern in use in almost every graphics
     API out there. For example, OpenGL has `swapBuffers()`, Direct3D has "swap
     chains", and Microsoft's XNA framework swaps the framebuffers within its
-    `endDraw()` function.</p>
+    `endDraw()` method.</p>

book/event-queue.markdown

@@ -395,7 +395,7 @@ class="pattern">Update Method</a> pattern.
 
 Now, we need to call that from somewhere convenient. What "convenient" means
 depends on your game. It may mean calling it from the main <a
-href="game-loop.html" class="pattern">Game Loop</a> or from a dedicated audio
+href="game-loop.html" class="pattern">game loop</a> or from a dedicated audio
 thread.
 
 This works fine, but it does presume we can process *every* sound request in a

book/flyweight.markdown

@@ -323,7 +323,7 @@ maintainable style.
     href="http://en.wikipedia.org/wiki/Factory_method_pattern" class="gof-
     pattern">Factory Method</a> pattern.
 
-    In order to return a previously created flyweight, you'll have to keep track
+ *  In order to return a previously created flyweight, you'll have to keep track
     of the pool of ones that you've already instantiated. As the name implies,
     that means that an <a href="object-pool.html" class="pattern">Object
     Pool</a> might be a helpful place to store them.

book/object-pool.markdown

@@ -247,10 +247,9 @@ particle class:
 ^code 1
 
 The default constructor initializes the particle to "not in use". A later call
-to `init()` initializes the particle to a live state.
-
-Particles are animated over time using the unsurprisingly named `animate()`
-function, which should be called once per frame.
+to `init()` initializes the particle to a live state. Particles are animated
+over time using the unsurprisingly named `animate()` function, which should be
+called once per frame.
 
 The pool needs to know which particles are available for reuse. It gets this
 from the particle's `inUse()` function. This function takes advantage of the fact that

book/singleton.markdown

@@ -493,7 +493,7 @@ other ways our codebase can get access to an object:
 
     ^code 11
 
-    With this, only `World` is globally available. Functions can get to the
+    With this, only `Game` is globally available. Functions can get to the
     other systems <span name="demeter">through</span> it:
 
     ^code 12
@@ -505,20 +505,20 @@ other ways our codebase can get access to an object:
 
     </aside>
 
-    If, later, the architecture is changed to support multiple `World` instances
+    If, later, the architecture is changed to support multiple `Game` instances
     (perhaps for streaming or testing purposes), `Log`, `FileSystem`, and
     `AudioPlayer` are all unaffected -- they won't even know the difference. The
-    downside with this, of course, is that more code ends up coupled to `World`
+    downside with this, of course, is that more code ends up coupled to `Game`
     itself. If a class just needs to play sound, our example still requires it
     to know about the world in order to get to the audio player.
 
-    We solve this with a hybrid solution. Code that already knows about World
+    We solve this with a hybrid solution. Code that already knows about `Game`
     can simply access `AudioPlayer` directly from it. For code that doesn't, we
     provide access to `AudioPlayer` using one of the other options described
     here.
 
  *  **Get it from a Service Locator.** So far, we're assuming the global class
-    is some regular concrete class like `World`. Another option is to define a
+    is some regular concrete class like `Game`. Another option is to define a
     class whose sole reason for being is to give global access to objects. This
     common pattern is called a <a class="pattern"
     href="service-locator.html">Service Locator</a> and gets its own chapter.

book/spatial-partition.markdown

@@ -362,9 +362,9 @@ rows out.
 There's a relatively short list of well-defined spatial partitioning data
 structures, and one option would be to go through them one at a time here.
 Instead, I tried to organize this by their essential characteristics. My hope is
-that once you do learn about quadtrees and BSPs and the like, this will help you
-understand *how* and *why* they work and why you might choose one over the
-other.
+that once you do learn about quadtrees and binary space partitions (BSPs) and
+the like, this will help you understand *how* and *why* they work and why you
+might choose one over the other.
 
 ### Is the partition hierarchical or flat?
 

book/subclass-sandbox.markdown

@@ -459,8 +459,8 @@ particle system object, how would it get one?
     in the state that the base class needs before it needs it. That places the
     burden of initialization on the surrounding code. Another option is to let
     the base class handle it by pulling in the state it needs. One way to do
-    that is by using a <a class="pattern" href="service-locator.html">Service
-    Locator</a>:
+    that is by using the <a class="pattern" href="service-locator.html">Service
+    Locator</a> pattern:
 
     ^code 12