Fix #234.

Author: munificent

book/spatial-partition.markdown

@@ -139,10 +139,10 @@ spatial partitions used in games.
 
 ### A sheet of graph paper
 
-Here's the basic idea: imagine the entire field of battle. Now superimpose a
-grid of fixed-size squares onto it like a sheet of graph paper. Instead of
-storing our units in a single array, we put them in the cells of this grid. Each
-cell stores the list of units whose positions are within that cell's boundary.
+Imagine the entire field of battle. Now superimpose a grid of fixed-size squares
+onto it like a sheet of graph paper. Instead of storing our units in a single
+array, we put them in the cells of this grid. Each cell stores the list of units
+whose positions are within that cell's boundary.
 
 <img src="images/spatial-partition-grid.png" alt="A grid with Units occupying different cells. Some cells have multiple Units." />
 
@@ -474,7 +474,7 @@ to solve.
         performance, but *consistent* performance: if each partition has the
         same number of objects, you ensure that all queries in the world will
         take about the same amount of time. When you need to maintain a stable
-        frame-rate, this consistency may be more important than raw performance.
+        frame rate, this consistency may be more important than raw performance.
 
      *  *It's more efficient to partition an entire set of objects at once.*
         When the *set* of objects affects where boundaries are, it's best to
@@ -491,8 +491,8 @@ to solve.
 
     <aside name="quad">
 
-    A quadtree partitions 2D space. Its 3D analogue is the *octree*: it takes a
-    *volume* and partitions it into eight *cubes*. Aside from the extra
+    A quadtree partitions 2D space. Its 3D analogue is the *octree*, which takes
+    a *volume* and partitions it into eight *cubes*. Aside from the extra
     dimension, it works the same as its flatter sibling.
 
     </aside>

code/cpp/spatial-partition.h

@@ -164,17 +164,7 @@ namespace SpatialPartition
     class Unit
     {
     public:
-      //^unit-ctor
-      Unit(Grid* grid, double x, double y)
-      : grid_(grid),
-        x_(x),
-        y_(y),
-        prev_(NULL),
-        next_(NULL)
-      {
-        grid_->add(this);
-      }
-      //^unit-ctor
+      Unit(Grid* grid, double x, double y);
 
       // Previous code...
       //^omit
@@ -190,6 +180,18 @@ namespace SpatialPartition
       //^omit
     };
 
+    //^unit-ctor
+    Unit::Unit(Grid* grid, double x, double y)
+    : grid_(grid),
+      x_(x),
+      y_(y),
+      prev_(NULL),
+      next_(NULL)
+    {
+      grid_->add(this);
+    }
+    //^unit-ctor
+
     //^add
     void Grid::add(Unit* unit)
     {
@@ -389,9 +391,9 @@ namespace SpatialPartition
     //^grid-melee
     void Grid::handleMelee()
     {
-      for (int y = 0; y < NUM_CELLS; y++)
+      for (int x = 0; x < NUM_CELLS; x++)
       {
-        for (int x = 0; x < NUM_CELLS; x++)
+        for (int y = 0; y < NUM_CELLS; y++)
         {
           handleCell(cells_[x][y]);
         }

html/bytecode.html

@@ -1199,7 +1199,7 @@ <h3><a href="#how-is-the-bytecode-generated" name="how-is-the-bytecode-generated
 <p>When you&#8217;re building a UI, you have to choose which framework to use,
 and many of those are specific to one OS. There are cross-platform UI
 toolkits too, but those often get ubiquity at the expense of
-familiarity&#8202;&mdash;&#8202;they feel equally weird on all of platforms.</p>
+familiarity&#8202;&mdash;&#8202;they feel equally foreign on all of platforms.</p>
 </li>
 </ul>
 </li>

html/spatial-partition.html

@@ -148,10 +148,10 @@ <h2><a href="#sample-code" name="sample-code">Sample Code</a></h2>
 </aside>
 
 <h3><a href="#a-sheet-of-graph-paper" name="a-sheet-of-graph-paper">A sheet of graph paper</a></h3>
-<p>Here&#8217;s the basic idea: imagine the entire field of battle. Now superimpose a
-grid of fixed-size squares onto it like a sheet of graph paper. Instead of
-storing our units in a single array, we put them in the cells of this grid. Each
-cell stores the list of units whose positions are within that cell&#8217;s boundary.</p>
+<p>Imagine the entire field of battle. Now superimpose a grid of fixed-size squares
+onto it like a sheet of graph paper. Instead of storing our units in a single
+array, we put them in the cells of this grid. Each cell stores the list of units
+whose positions are within that cell&#8217;s boundary.</p>
 <p><img src="images/spatial-partition-grid.png" alt="A grid with Units occupying different cells. Some cells have multiple Units." /></p>
 <p>When we handle combat, we only consider units within the same cell. Instead of
 comparing each unit in the game with every other unit, we&#8217;ve <em>partitioned</em> the
@@ -242,7 +242,7 @@ <h3><a href="#entering-the-field-of-battle" name="entering-the-field-of-battle">
 <p>The first thing we need to do is make sure new units are actually placed into
 the grid when they are created. We&#8217;ll make <code>Unit</code> handle this in its
 constructor:</p>
-<div class="codehilite"><pre><span class="n">Unit</span><span class="p">(</span><span class="n">Grid</span><span class="o">*</span> <span class="n">grid</span><span class="p">,</span> <span class="kt">double</span> <span class="n">x</span><span class="p">,</span> <span class="kt">double</span> <span class="n">y</span><span class="p">)</span>
+<div class="codehilite"><pre><span class="n">Unit</span><span class="o">::</span><span class="n">Unit</span><span class="p">(</span><span class="n">Grid</span><span class="o">*</span> <span class="n">grid</span><span class="p">,</span> <span class="kt">double</span> <span class="n">x</span><span class="p">,</span> <span class="kt">double</span> <span class="n">y</span><span class="p">)</span>
 <span class="o">:</span> <span class="n">grid_</span><span class="p">(</span><span class="n">grid</span><span class="p">),</span>
   <span class="n">x_</span><span class="p">(</span><span class="n">x</span><span class="p">),</span>
   <span class="n">y_</span><span class="p">(</span><span class="n">y</span><span class="p">),</span>
@@ -291,9 +291,9 @@ <h3><a href="#a-clash-of-swords" name="a-clash-of-swords">A clash of swords</a><
 this:</p>
 <div class="codehilite"><pre><span class="kt">void</span> <span class="n">Grid</span><span class="o">::</span><span class="n">handleMelee</span><span class="p">()</span>
 <span class="p">{</span>
-  <span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">y</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">y</span> <span class="o">&lt;</span> <span class="n">NUM_CELLS</span><span class="p">;</span> <span class="n">y</span><span class="o">++</span><span class="p">)</span>
+  <span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">x</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">x</span> <span class="o">&lt;</span> <span class="n">NUM_CELLS</span><span class="p">;</span> <span class="n">x</span><span class="o">++</span><span class="p">)</span>
   <span class="p">{</span>
-    <span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">x</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">x</span> <span class="o">&lt;</span> <span class="n">NUM_CELLS</span><span class="p">;</span> <span class="n">x</span><span class="o">++</span><span class="p">)</span>
+    <span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">y</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">y</span> <span class="o">&lt;</span> <span class="n">NUM_CELLS</span><span class="p">;</span> <span class="n">y</span><span class="o">++</span><span class="p">)</span>
     <span class="p">{</span>
       <span class="n">handleCell</span><span class="p">(</span><span class="n">cells_</span><span class="p">[</span><span class="n">x</span><span class="p">][</span><span class="n">y</span><span class="p">]);</span>
     <span class="p">}</span>
@@ -646,7 +646,7 @@ <h3><a href="#does-the-partitioning-depend-on-the-set-of-objects" name="does-the
     performance, but <em>consistent</em> performance: if each partition has the
     same number of objects, you ensure that all queries in the world will
     take about the same amount of time. When you need to maintain a stable
-    frame-rate, this consistency may be more important than raw performance.</p>
+    frame rate, this consistency may be more important than raw performance.</p>
 </li>
 <li>
 <p><em>It&#8217;s more efficient to partition an entire set of objects at once.</em>
@@ -665,8 +665,8 @@ <h3><a href="#does-the-partitioning-depend-on-the-set-of-objects" name="does-the
 name="quad">quadtrees</span>.</p>
 <aside name="quad">
 
-<p>A quadtree partitions 2D space. Its 3D analogue is the <em>octree</em>: it takes a
-<em>volume</em> and partitions it into eight <em>cubes</em>. Aside from the extra
+<p>A quadtree partitions 2D space. Its 3D analogue is the <em>octree</em>, which takes
+a <em>volume</em> and partitions it into eight <em>cubes</em>. Aside from the extra
 dimension, it works the same as its flatter sibling.</p>
 </aside>