From 1393586d1e5639ac8f1e9fc8183644050dd54165 Mon Sep 17 00:00:00 2001
From: Charles <Charles@92bb83a3-7c8f-8a45-bc97-515c4e399668>
Date: Tue, 13 Apr 2010 05:12:26 +0000
Subject: [PATCH] Map drawing implemented. Test map API's implemented.

git-svn-id: https://bd85.net/svn/cs3505_group@67 92bb83a3-7c8f-8a45-bc97-515c4e399668
---
 CarFire/CarFire/CarFire.suo                   | Bin 45568 -> 50176 bytes
 .../CarFire/Content/Content.contentproj       |   7 +
 CarFire/CarFire/CarFire/Map.cs                | 324 +++++++++++++++++-
 CarFire/CarFire/CarFire/MapReader.cs          | 215 +++++++-----
 CarFire/CarFire/CarFire/Parse.cs              |  13 +-
 CarFire/CarFire/CarFire/XnaGame.cs            |  17 +
 6 files changed, 472 insertions(+), 104 deletions(-)

diff --git a/CarFire/CarFire/CarFire.suo b/CarFire/CarFire/CarFire.suo
index 153a3e4100f5796d979125a3bce9213fc1c94218..a29eeb84ea67b47fa78dc58d715ab8b38e6d701d 100644
GIT binary patch
delta 3171
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

delta 2431
zcmb7_dr(w$6vyxH?%joj<smMJxEm}WiXsmoUZyUBqJX=LINIQvt0LlKjG-kFB^KWi
z8FDONB`?!VOXH@Jq;7&e%yMk}Lz||i8UJt^%bHmyrYX1YZ`n=!qlxa$XV1CkckcO}
z-}${9yA_VR;u(j?4Adm1%zfl`yORY$NC8~;JzSpw8-LG)%mUdU2jqfj;2AI-L<1TW
ztLSz{)m~e6n^eLg$Pf?{l(;4I`#aZ|0`10hs+X>@$@JsQXiAkr$>}dqow8Uhj6!P&
zkI=C&1}*;N2$pD2X_I&gWL1?gJDpICW3SLv)k+OFa^~|dGW=}el~7iLDzFBu1w<$O
z%u*vX`A@$>Q7t4vjpPl!KI{Qz>X*{Up+;W;#cDPMt^QAV1bRGVSK!xTh+1F_jov4S
zmWPbikHMQ7e04G-?7^d7+}tA-@4PzU+(W759v&?S8iTe(84gX)ZPXH?BWK7qHS>c>
z2_7dGYM}usm0Y1WL>A<$SYQc!_6Oq+uFk$Z*%+n}`5;uIVfjv=dTo(EPe{WZd;@i9
z%_0l)#UOjQ#UIsk^G|#}vMbyysXepAv-6o%yd>X>R3BAD16pJgb%Xjlp7uKx1v}iD
z#!jPLT?EfuXr@x#WZ9t$Q-*gv(%<3HRe<-zAAxQbj3uYR>2aP%r4`f28Eec^4VCpC
zUm!xb@U!BG7{I^!NfdnL&R*In@>c%DSh+5W@^N`Ri*Hp8{--zP1#9KvvsM;AlGq;a
zAI^<p<e1=~U(c6~ypPSjRu=hh8Ie12z_Z$1lPoOu@mx%92^<=jXJov03c1iJJCn9E
z7W~*P+2Sw3ZzAx`4Y^<($4fHYXisslc6yj{M_E#F`i~HAgy3#toT9M_j$6StupR6G
zJHaln8@vpf0pD9KkgtM0;5E<+_5$AaKIA^|I(P%@2M54Ga0na*Z-TeL5pWK42tuRK
z355sfhCJ%kk3k;y>L(!I_3Eb}-}CCHA<uaA&mm>-Avo)`ormlNAAt*?4}1(Rf=l2s
zaPs5r6DU_eKNtX4!KdIez!UqzE5C%iPB$~2-)pOojR{6Zmas6gMg+*ZiMcFs3O0GF
zkO%T{7^VtyJimM)U1$)Jg$iM#P$t-g<w6amsr8hyZWgvTL&!teA}Lg@kA$s&DyJUf
zi=H|Y$54o@qWe<=NZe?owDf$Mxh|9xeRU&Wd~%<C<lBLkT`ZNI(~Tk}%}+oMvD7eS
z8|_)6p<d%r`AXg`#<tRL*4bn-C()j|2y#SkRp2O~#%E<Vp4#hokXYZ`Hm65D>g<8O
z6*%6_bhBk0RnODW{PV$NDGX4}PAFVkdt0^@cBn>gKrL1atArX<XQl801|3I+&A(IE
zmT%BSyv!_aM()xAzCl<Q)h;me(}ulG4;PrIUz^6>q1rN&nqh|AI$kpG$;M8~56euV
zn(1LQ3~y+o+C}()-)iy0?BrTx@sEQ6N6bG_R7H4^aCR;(Vk+O3lU<8j7?oz}F`$)g
z<#Q!|ko)>2d%0N@#`=88RqnYblpnz70Bu^bS#u2<-va!h()2hgyHq{m$)t9tiymD5
zAG6=?tYXxbl-Og#Qnjs0pb}Fy8TDN(iJDBi$dR?1#ZdIJd8oFr&Cn*Fs$9sZI>ty_
zx5SWr=^V1=KSlRU8amRTqaKrqF4P8-BPX8jTW?WKQMp`Rb&Rp?#0(8I!xlv=+9%Si
z)payzi>EM$mZ}>=$++IZ(qvXp$XKgq@oZQXIifsL4JO&NzEVNXoK_{D$!20Xo2c%&
z2&C4`>OH}dYjP=e*-rMNH*_Z3M@^YKDAul}yEVP64fZm**<L4l#)DNw8e<IhlfCDq
zL5*_bLFsz2{8w{esPdjFIdZWabU0I~7ABy#@qCJWSEaoJGpS7@SI5vDIq8YUPV>+j
jOc-u;bz1!Sb;z$MUmV%qB{8hpP2FZGbhzEstqJ}cICssr

diff --git a/CarFire/CarFire/CarFire/Content/Content.contentproj b/CarFire/CarFire/CarFire/Content/Content.contentproj
index 077c9a1..59b77ca 100644
--- a/CarFire/CarFire/CarFire/Content/Content.contentproj
+++ b/CarFire/CarFire/CarFire/Content/Content.contentproj
@@ -115,6 +115,13 @@
       <Name>sandbox</Name>
     </Compile>
   </ItemGroup>
+  <ItemGroup>
+    <Compile Include="default.png">
+      <Name>default</Name>
+      <Importer>TextureImporter</Importer>
+      <Processor>TextureProcessor</Processor>
+    </Compile>
+  </ItemGroup>
   <Import Project="$(MSBuildExtensionsPath)\Microsoft\XNA Game Studio\v3.0\Microsoft.Xna.GameStudio.ContentPipeline.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/CarFire/CarFire/CarFire/Map.cs b/CarFire/CarFire/CarFire/Map.cs
index ed8c39f..b61f2bb 100644
--- a/CarFire/CarFire/CarFire/Map.cs
+++ b/CarFire/CarFire/CarFire/Map.cs
@@ -2,11 +2,11 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
-using Microsoft.Xna.Framework;
 using System.IO;
-using System.Text.RegularExpressions;
 using System.Runtime.Serialization;
 using System.Diagnostics;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
 
 namespace CarFire
 {
@@ -18,20 +18,21 @@ namespace CarFire
     /// </summary>
     public class Map
     {
-        #region Types
+        // DEBUG: Tilesets not implemented at all.
+        public static Texture2D DefaultTile;
 
-        public class Data
-        {
-            public string Author;
-            public string Name;
-            public int MinNumPlayers;
-            public int MaxNumPlayers;
-            public Point Dimensions;
-            public string Tileset;        // TODO: this should be a tilemap object
-            public Type Type;
-            public char[,] Grid;
-        }
-        
+        #region Public Constants
+
+        public const float PixelsToUnitSquares = 64.0f;
+
+        #endregion
+
+
+        #region Public Types
+
+        /// <summary>
+        /// The type of a map helps determine how the map is intended to be used.
+        /// </summary>
         public enum Type
         {
             None,
@@ -39,12 +40,301 @@ namespace CarFire
             Battle
         }
 
+        /// <summary>
+        /// The container class for map metadata.
+        /// </summary>
+        public class Metadata
+        {
+            public string Name;
+            public Type Type;
+            public string Author;
+            public HashSet<int> NumPlayers = new HashSet<int>();
+            public string Tileset;
+            public int GridWidth;
+            public int GridHeight;
+        }
+
+        #endregion
+
+
+        #region Public Attributes
+
+        /// <summary>
+        /// Get the name of the map.
+        /// </summary>
+        public string Name { get { return mData.Metadata.Name; } }
+
+        /// <summary>
+        /// Get the type of the map.
+        /// </summary>
+        //public Type Type { get { return mData.mMetadata.Type; } }
+
+        /// <summary>
+        /// Get the author of the map.
+        /// </summary>
+        public string Author { get { return mData.Metadata.Author; } }
+
+        /// <summary>
+        /// Get a set of integers containing each allowable number of players.
+        /// </summary>
+        public HashSet<int> NumPlayers { get { return mData.Metadata.NumPlayers; } }
+
+        /// <summary>
+        /// Get the width of the map, in grid units.
+        /// </summary>
+        public int Width { get { return mData.Metadata.GridWidth; } }
+
+        /// <summary>
+        /// Get the height of the map, in grid units.
+        /// </summary>
+        public int Height { get { return mData.Metadata.GridHeight; } }
+
+        // TODO: This should return whatever object we end up using for tilesets.
+        public string Tileset { get { return mData.Metadata.Tileset; } }
+
+
+        public Vector2 CenterCell
+        {
+            get { return mView.CenterCell; }
+            set { mView.CenterCell = value; }
+        }
+
+        #endregion
+
+
+        #region Public Methods
+
+        /// <summary>
+        /// Construct a map with the provided map data.
+        /// </summary>
+        /// <param name="data">Map data.</param>
+        public Map(Metadata metadata, char[,] grid, Dictionary<char, Dictionary<string, string>> entities)
+        {
+            mData = new Modal(metadata, grid, entities);
+            mView = new View(mData);
+        }
+
+
+        /// <summary>
+        /// Draw a representation of the map to the screen.
+        /// </summary>
+        /// <param name="spriteBatch">The jeewiz.</param>
+        public void Draw(SpriteBatch spriteBatch)
+        {
+            mView.Draw(spriteBatch);
+        }
+
+
+        /// <summary>
+        /// Get a point in screen-space from a coordinate in gridspace.
+        /// </summary>
+        /// <param name="x">X-coordinate.</param>
+        /// <param name="y">Y-coordinate.</param>
+        /// <returns>Transformed point.</returns>
+        public Point GetPointFromCoordinates(float x, float y)
+        {
+            return mView.GetPointFromCoordinates(x, y);
+        }
+
+        /// <summary>
+        /// Get a point in screen-space from a coordinate in gridspace.
+        /// </summary>
+        /// <param name="point">X,Y-coordinates.</param>
+        /// <returns>Transformed point.</returns>
+        public Point GetPointFromCoordinates(Vector2 point)
+        {
+            return mView.GetPointFromCoordinates(point.X, point.Y);
+        }
+
+        /// <summary>
+        /// Get a rectangle in screen-space centered around a coordinate in gridspace.
+        /// </summary>
+        /// <param name="x">X-coordinate.</param>
+        /// <param name="y">Y-coordinate.</param>
+        /// <returns>Transformed rectangle.</returns>
+        public Rectangle GetRectangleFromCoordinates(float x, float y)
+        {
+            return mView.GetRectangleFromCoordinates(x, y);
+        }
+
+        /// <summary>
+        /// Get a rectangle in screen-space centered around a coordinate in gridspace.
+        /// </summary>
+        /// <param name="point">X,Y-coordinates.</param>
+        /// <returns>Transformed rectangle.</returns>
+        public Rectangle GetRectangleFromCoordinates(Vector2 point)
+        {
+            return mView.GetRectangleFromCoordinates(point.X, point.Y);
+        }
+
+
+        /// <summary>
+        /// Determine whether or not a cell can be occupied by a game entity.
+        /// </summary>
+        /// <param name="x">X-coordinate.</param>
+        /// <param name="y">Y-coordinate.</param>
+        /// <returns>True if cell can be occupied, false otherwise.</returns>
+        public bool IsCellOpen(int x, int y)
+        {
+            return mData.IsCellOpen(x, y);
+        }
+
+        /// <summary>
+        /// Determine whether or not a cell can be occupied by a game entity.
+        /// </summary>
+        /// <param name="x">X,Y-coordinates.</param>
+        /// <returns>True if cell can be occupied, false otherwise.</returns>
+        public bool IsCellOpen(Point point)
+        {
+            return mData.IsCellOpen(point.X, point.Y);
+        }
+
+
+        /// <summary>
+        /// Get the entities loaded from the map file.
+        /// </summary>
+        /// <returns>Dictionary of entities.  The keys are the entity
+        /// identifiers and the value is a dictionary of key-value pairs
+        /// associated with that entity.</returns>
+        public Dictionary<char, Dictionary<string, string>> GetEntities()
+        {
+            return mData.Entities;
+        }
+
         #endregion
 
 
-        public Map(Data data)
+        #region Private Types
+
+        class Modal
+        {
+            Metadata mMetadata;
+            char[,] mGrid;
+            Dictionary<char, Dictionary<string, string>> mEntities;
+
+            public Modal(Metadata metadata, char[,] grid, Dictionary<char, Dictionary<string, string>> entities)
+            {
+                Debug.Assert(metadata != null);
+                Debug.Assert(grid != null);
+                Debug.Assert(entities != null);
+                Debug.Assert(metadata.GridWidth * metadata.GridHeight == grid.Length);
+
+                mMetadata = metadata;
+                mGrid = grid;
+                mEntities = entities;
+
+#if DEBUG
+                Console.WriteLine("Loaded map {0} of type {1} written by {2}.",
+                    metadata.Name,
+                    metadata.Type,
+                    metadata.Author);
+#endif
+            }
+
+
+            public Metadata Metadata { get { return mMetadata; } }
+            public Dictionary<char, Dictionary<string, string>> Entities { get { return mEntities; } }
+
+
+            public bool IsCellOpen(int x, int y)
+            {
+                // TODO: Still need to define characters for types of scenery.
+                return mGrid[x, y] == ' ';
+            }
+        }
+
+        class View
         {
-            Console.WriteLine("Read map " + data.Name + " of type " + data.Type + " written by " + data.Author);
+            Modal mData;
+
+            public Vector2 CenterCell;
+            Viewport mViewport;
+
+
+            public View(Modal data)
+            {
+                Debug.Assert(data != null);
+                mData = data;
+            }
+
+            public void Draw(SpriteBatch spriteBatch)
+            {
+                mViewport = spriteBatch.GraphicsDevice.Viewport;
+
+                // TODO: There is no culling yet, but it runs so fast that it probably won't ever need it.
+                for (int y = 0; y < mData.Metadata.GridHeight; y++)
+                {
+                    for (int x = 0; x < mData.Metadata.GridWidth; x++)
+                    {
+                        if (mData.IsCellOpen(x, y))
+                        {
+                            spriteBatch.Draw(Map.DefaultTile, GetRectangleFromCoordinates(x, y), Color.White);
+                        }
+                        else
+                        {
+                            spriteBatch.Draw(Map.DefaultTile, GetRectangleFromCoordinates(x, y), Color.DarkBlue);
+                        }
+                    }
+                }
+            }
+
+            /// <summary>
+            /// Get a matrix to transform a point from grid-space to screen coordinates.  This
+            /// method uses the viewport to bound the edges of the map such that the camera
+            /// will not show anything outside of the grid.
+            /// </summary>
+            /// <param name="center">The point to put in the center.</param>
+            /// <returns>The transformation matrix.</returns>
+            Matrix GetTransformation(Vector2 center)
+            {
+                float halfRatio = PixelsToUnitSquares * 0.5f;
+                Matrix transform = Matrix.CreateTranslation(-center.X, -center.Y, 0.0f);
+                transform *= Matrix.CreateScale(PixelsToUnitSquares);
+                transform *= Matrix.CreateTranslation(mViewport.Width * 0.5f - halfRatio,
+                    mViewport.Height * 0.5f - halfRatio, 0.0f);
+
+                Vector2 topLeft = Vector2.Transform(new Vector2(0.0f, 0.0f), transform);
+                topLeft.X = Math.Max(mViewport.X, topLeft.X);
+                topLeft.Y = Math.Max(mViewport.Y, topLeft.Y);
+                transform *= Matrix.CreateTranslation(-topLeft.X, -topLeft.Y, 0.0f);
+
+                Vector2 bottomRight = Vector2.Transform(new Vector2((float)mData.Metadata.GridWidth,
+                    (float)mData.Metadata.GridHeight), transform);
+                float right = mViewport.X + mViewport.Width;
+                float bottom = mViewport.Y + mViewport.Height;
+                bottomRight.X = Math.Min(right, bottomRight.X) - right;
+                bottomRight.Y = Math.Min(bottom, bottomRight.Y) - bottom;
+                transform *= Matrix.CreateTranslation(-bottomRight.X, -bottomRight.Y, 0.0f);
+
+                return transform;
+            }
+
+
+            public Point GetPointFromCoordinates(float x, float y)
+            {
+                Matrix transform = GetTransformation(CenterCell);
+                Vector2 point = Vector2.Transform(new Vector2(x, y), transform);
+
+                return new Point((int)point.X, (int)point.Y);
+            }
+
+            public Rectangle GetRectangleFromCoordinates(float x, float y)
+            {
+                Matrix transform = GetTransformation(CenterCell);
+                Vector2 point = Vector2.Transform(new Vector2(x, y), transform);
+                
+                return new Rectangle((int)point.X, (int)point.Y, (int)PixelsToUnitSquares, (int)PixelsToUnitSquares);
+            }
         }
+
+        #endregion
+
+
+        #region Private Variables
+
+        Modal mData;
+        View mView;
+
+        #endregion
     }
 }
diff --git a/CarFire/CarFire/CarFire/MapReader.cs b/CarFire/CarFire/CarFire/MapReader.cs
index 35089ba..fbae4df 100644
--- a/CarFire/CarFire/CarFire/MapReader.cs
+++ b/CarFire/CarFire/CarFire/MapReader.cs
@@ -2,7 +2,6 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.Serialization;
-using System.Text.RegularExpressions;
 using Microsoft.Xna.Framework;
 using Microsoft.Xna.Framework.Content;
 using Microsoft.Xna.Framework.Graphics;
@@ -15,61 +14,51 @@ namespace CarFire
     /// </summary>
     public class MapReader : ContentTypeReader<Map>
     {
+        #region Public Exceptions
+
+        /// <summary>
+        /// This exception is thrown during the loading of a map if any
+        /// part of the map file is inconsistent with the expected format
+        /// and order.
+        /// </summary>
         public class ParserException : System.ApplicationException
         {
-            public ParserException()
-            {
-            }
+            public ParserException() {}
 
             public ParserException(string message) :
-                base(message)
-            {
-            }
+                base(message) {}
 
             public ParserException(string message, System.Exception inner) :
-                base(message, inner)
-            {
-            }
+                base(message, inner) {}
 
             protected ParserException(SerializationInfo info, StreamingContext context) :
-                base(info, context)
-            {
-            }
+                base(info, context) {}
         }
 
-        ContentReader mInput;
-        int mLineNumber = 0;
-        int mExpectedNumberOfLines;
+        #endregion
 
-        Map.Data mData;
 
+        #region Protected Methods
 
         protected override Map Read(ContentReader input, Map existingInstance)
         {
-            mInput = input;
-            mExpectedNumberOfLines =  mInput.ReadInt32();
-
-            ReadData();
-
-            return new Map(mData);
+            mInput = new LineReader(input);
+            ReadSectionHeaders();
+            return new Map(mMetadata, mGrid, mEntities);
         }
 
+        #endregion
 
-        #region Private Reading Methods
-        
-        string ReadLine()
-        {
-            return mInput.ReadString();
-        }
 
-        void ReadData()
+        #region Private Methods
+
+        void ReadSectionHeaders()
         {
-            mData = new Map.Data();
+            mMetadata = new Map.Metadata();
 
-            while (mLineNumber < mExpectedNumberOfLines)
+            while (!mInput.End)
             {
-                string line = ReadLine();
-                mLineNumber++;
+                string line = mInput.ReadLine();
 
                 while (line != null)
                 {
@@ -92,12 +81,12 @@ namespace CarFire
                         }
                         else
                         {
-                            ThrowException("Unknown section", section);
+                            throw new ParserException("Unexpected section on line " + mInput.LineNumber + ": " + section);
                         }
                     }
                     else
                     {
-                        ThrowException("Unexpected text", line);
+                        throw new ParserException("Unexpected text on line " + mInput.LineNumber + ": " + line);
                     }
                 }
             }
@@ -105,11 +94,9 @@ namespace CarFire
 
         string ReadMetadataSection()
         {
-            while (mLineNumber < mExpectedNumberOfLines)
+            while (!mInput.End)
             {
-                string line = ReadLine();
-                mLineNumber++;
-
+                string line = mInput.ReadLine();
                 if (!IsLineSignificant(line)) continue;
 
                 string[] pair = Parse.KeyValuePair(line);
@@ -117,14 +104,14 @@ namespace CarFire
                 {
                     if (pair[0] == "type")
                     {
-                        object type = Parse.Constant<Map.Type>(pair[1]);
-                        if (type != null)
+                        Map.Type type = Parse.Constant<Map.Type>(pair[1]);
+                        if (type != default(Map.Type))
                         {
-                            mData.Type = (Map.Type)type;
+                            mMetadata.Type = type;
                         }
                         else
                         {
-                            ThrowException("Invalid type", pair[1]);
+                            throw new ParserException("Unexpected type on line " + mInput.LineNumber + ": " + pair[1]);
                         }
                     }
                     else if (pair[0] == "dimensions")
@@ -132,15 +119,16 @@ namespace CarFire
                         Point? dimensions = Parse.Coordinates(pair[1]);
                         if (dimensions != null)
                         {
-                            mData.Dimensions = dimensions.Value;
-                            if (mData.Dimensions.X <= 0 || mData.Dimensions.Y <= 0)
+                            mMetadata.GridWidth = dimensions.Value.X;
+                            mMetadata.GridHeight = dimensions.Value.Y;
+                            if (mMetadata.GridWidth <= 0 || mMetadata.GridHeight <= 0)
                             {
-                                ThrowException("Invalid dimensions", pair[1]);
+                                throw new ParserException("Invalid dimensions on line " + mInput.LineNumber + ": " + pair[1]);
                             }
                         }
                         else
                         {
-                            ThrowException("Invalid value", pair[1]);
+                            throw new ParserException("Unexpected value on line " + mInput.LineNumber + ": " + pair[1]);
                         }
                     }
                     else if (pair[0] == "tileset")
@@ -148,29 +136,46 @@ namespace CarFire
                         string tileset = Parse.String(pair[1]);
                         if (tileset != null)
                         {
-                            mData.Tileset = tileset;
+                            mMetadata.Tileset = tileset;
                         }
                         else
                         {
-                            ThrowException("Invalid tileset", pair[1]);
+                            throw new ParserException("Unexpected tileset on line " + mInput.LineNumber + ": " + pair[1]);
                         }
                     }
                     else if (pair[0] == "numplayers")
                     {
-                        int[] numPlayers = Parse.Range(pair[1]);
-                        if (numPlayers != null)
+                        string[] list = Parse.List(pair[1]);
+                        if (list != null)
                         {
-                            mData.MinNumPlayers = numPlayers[0];
-                            mData.MaxNumPlayers = numPlayers[1];
-                            if (mData.MinNumPlayers <= 0 || mData.MaxNumPlayers <= 0 ||
-                                mData.MinNumPlayers > mData.MaxNumPlayers)
+                            foreach (string atom in list)
+                            {
+                                int[] range = Parse.Range(atom);
+                                if (range != null)
+                                {
+                                    for (int i = range[0]; i <= range[1]; i++)
+                                    {
+                                        mMetadata.NumPlayers.Add(i);
+                                    }
+                                    continue;
+                                }
+                                int? integer = Parse.Integer(atom);
+                                if (integer != null)
+                                {
+                                    mMetadata.NumPlayers.Add(integer.Value);
+                                    continue;
+                                }
+
+                                throw new ParserException("Unexpected atom on line " + mInput.LineNumber + ": " + atom);
+                            }
+                            if (mMetadata.NumPlayers.Count == 0)
                             {
-                                ThrowException("Invalid range", pair[1]);
+                                throw new ParserException("No numbers given on line " + mInput.LineNumber + ": " + pair[1]);
                             }
                         }
                         else
                         {
-                            ThrowException("Invalid value", pair[1]);
+                            throw new ParserException("Unexpected value on line " + mInput.LineNumber + ": " + pair[1]);
                         }
                     }
                     else if (pair[0] == "author")
@@ -178,11 +183,11 @@ namespace CarFire
                         string author = Parse.String(pair[1]);
                         if (author != null)
                         {
-                            mData.Author = author;
+                            mMetadata.Author = author;
                         }
                         else
                         {
-                            ThrowException("Invalid value", pair[1]);
+                            throw new ParserException("Unexpected value on line " + mInput.LineNumber + ": " + pair[1]);
                         }
                     }
                     else if (pair[0] == "levelname")
@@ -190,16 +195,16 @@ namespace CarFire
                         string level = Parse.String(pair[1]);
                         if (level != null)
                         {
-                            mData.Name = level;
+                            mMetadata.Name = level;
                         }
                         else
                         {
-                            ThrowException("Invalid value", pair[1]);
+                            throw new ParserException("Unexpected value on line " + mInput.LineNumber + ": " + pair[1]);
                         }
                     }
                     else
                     {
-                        Console.WriteLine("Unimplemented key: " + pair[0]);
+                        throw new ParserException("Unexpected key on line " + mInput.LineNumber + ": " + pair[0]);
                     }
                 }
                 else
@@ -213,33 +218,35 @@ namespace CarFire
 
         string ReadMapTableSection()
         {
-            if (mData.Dimensions.X == 0 || mData.Dimensions.Y == 0)
+            if (mMetadata == null || mMetadata.GridWidth == 0 || mMetadata.GridHeight == 0)
             {
-                ThrowException("Unexpected section", "You must define the map dimensions before this section.");
+                throw new ParserException("Unexpected section on line " + mInput.LineNumber +
+                    ": You must define the map dimensions before this section.");
             }
 
-            mData.Grid = new char[mData.Dimensions.X, mData.Dimensions.Y];
+            mGrid = new char[mMetadata.GridWidth, mMetadata.GridHeight];
 
             int y;
-            for (y = 0; y < mData.Dimensions.Y && mLineNumber < mExpectedNumberOfLines; y++)
+            for (y = 0; y < mMetadata.GridHeight && !mInput.End; y++)
             {
-                string line = ReadLine();
-                mLineNumber++;
+                string line = mInput.ReadLine();
 
-                if (line.Length < mData.Dimensions.X)
+                if (line.Length < mMetadata.GridWidth)
                 {
-                    ThrowException("Not enough characters", "Expecting " + mData.Dimensions.X + " characters.");
+                    throw new ParserException("Unexpected EOL on line " + mInput.LineNumber +
+                        ": The number of characters should match the width dimension (" + mMetadata.GridWidth + ").");
                 }
 
-                for (int x = 0; x < mData.Dimensions.X; x++)
+                for (int x = 0; x < mMetadata.GridWidth; x++)
                 {
-                    mData.Grid[x, y] = line[x];
+                    mGrid[x, y] = line[x];
                 }
             }
 
-            if (y < mData.Dimensions.Y)
+            if (y < mMetadata.GridHeight)
             {
-                ThrowException("Unexpected ", "");
+                throw new ParserException("Unexpected EOF on line " + mInput.LineNumber +
+                    ": The number of lines in this section should match the height dimension (" + mMetadata.GridHeight + ").");
             }
 
             return null;
@@ -247,15 +254,17 @@ namespace CarFire
 
         string ReadEntitySection(char entity)
         {
-            while (mLineNumber < mExpectedNumberOfLines)
+            Dictionary<string, string> pairs = new Dictionary<string, string>();
+            mEntities[entity] = pairs;
+
+            while (!mInput.End)
             {
-                string line = ReadLine();
-                mLineNumber++;
+                string line = mInput.ReadLine();
 
                 string[] pair = Parse.KeyValuePair(line);
                 if (pair != null)
                 {
-                    // TODO
+                    pairs[pair[0]] = pair[1];
                 }
                 else
                 {
@@ -266,22 +275,56 @@ namespace CarFire
             return null;
         }
 
-        #endregion
-
-
-        #region Private Methods
 
         bool IsLineSignificant(string line)
         {
-            if (line.Length == 0 || Regex.IsMatch(line, @"^;|^\s*$")) return false;
+            if (line.Trim().Length == 0 || Parse.IniComment(line) != null) return false;
             return true;
         }
 
-        void ThrowException(string problem, string text)
+        #endregion
+
+
+        #region Private Types
+
+        /// <summary>
+        /// This private class wraps around ContentReader to make it more
+        /// convenient to use it as an input stream reader.
+        /// </summary>
+        class LineReader
         {
-            throw new ParserException(problem + " on line " + mLineNumber + ": " + text);
+            ContentReader mInput;
+            int mLineNumber = 0;
+            int mExpectedNumberOfLines;
+
+            public LineReader(ContentReader input)
+            {
+                mInput = input;
+                mExpectedNumberOfLines = mInput.ReadInt32();
+            }
+
+            public string ReadLine()
+            {
+                mLineNumber++;
+                return mInput.ReadString();
+            }
+
+            public int LineNumber { get { return mLineNumber; } }
+
+            public bool End { get { return mLineNumber >= mExpectedNumberOfLines; } }
         }
 
         #endregion
+
+
+        #region Private Variables
+
+        Map.Metadata mMetadata;
+        char[,] mGrid;
+        Dictionary<char, Dictionary<string, string>> mEntities = new Dictionary<char, Dictionary<string, string>>();
+
+        LineReader mInput;
+
+        #endregion
     }
 }
diff --git a/CarFire/CarFire/CarFire/Parse.cs b/CarFire/CarFire/CarFire/Parse.cs
index 169cf30..b932077 100644
--- a/CarFire/CarFire/CarFire/Parse.cs
+++ b/CarFire/CarFire/CarFire/Parse.cs
@@ -25,6 +25,18 @@ namespace CarFire
             return null;
         }
 
+        /// <summary>
+        /// Parses a comment of an INI file.
+        /// </summary>
+        /// <param name="line">Text.</param>
+        /// <returns>The comment.</returns>
+        public static string IniComment(string line)
+        {
+            Match match = Regex.Match(line, @"^;\s*(.*)\s*$");
+            if (match.Success) return match.Groups[1].Value;
+            return null;
+        }
+
         /// <summary>
         /// Parses a key-value pair.
         /// </summary>
@@ -182,7 +194,6 @@ namespace CarFire
             // FIXME: This may barf all over itself if there are nested parentheses, doublequotes, brackets, etc.
             foreach (Match match in matches)
             {
-                Console.WriteLine("matched: " + match.Value);
                 list.Add(match.Value);
             }
 
diff --git a/CarFire/CarFire/CarFire/XnaGame.cs b/CarFire/CarFire/CarFire/XnaGame.cs
index 0623ae9..6f8a421 100644
--- a/CarFire/CarFire/CarFire/XnaGame.cs
+++ b/CarFire/CarFire/CarFire/XnaGame.cs
@@ -1,3 +1,7 @@
+
+// DEBUG: for map testing
+//#define MAP_TESTING
+
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -25,6 +29,10 @@ namespace CarFire
         IScreenManager screenManager;
         IDeterministicGame deterministicGame;
 
+#if MAP_TESTING
+        Map map;
+#endif
+
         public XnaGame()
         {
             graphics = new GraphicsDeviceManager(this);
@@ -67,6 +75,12 @@ namespace CarFire
 
             screenManager.LoadContent(Content, graphics);
             deterministicGame.LoadContent(Content);
+
+#if MAP_TESTING
+            map = Content.Load<Map>("Maps/sandbox");
+            Map.DefaultTile = Content.Load<Texture2D>("default");
+            map.CenterCell = new Vector2(7, 7);
+#endif
         }
 
         /// <summary>
@@ -101,6 +115,9 @@ namespace CarFire
 
             spriteBatch.Begin();
             networkGame.Draw(gameTime, spriteBatch);
+#if MAP_TESTING
+            map.Draw(spriteBatch);
+#endif
             spriteBatch.End();
 
             base.Draw(gameTime);
-- 
2.43.0