From: Charles <Charles@92bb83a3-7c8f-8a45-bc97-515c4e399668>
Date: Tue, 13 Apr 2010 05:12:26 +0000 (+0000)
Subject: Map drawing implemented.
X-Git-Url: https://git.dogcows.com/gitweb?p=chaz%2Fcarfire;a=commitdiff_plain;h=1393586d1e5639ac8f1e9fc8183644050dd54165

Map drawing implemented.
Test map API's implemented.

git-svn-id: https://bd85.net/svn/cs3505_group@67 92bb83a3-7c8f-8a45-bc97-515c4e399668
---

diff --git a/CarFire/CarFire/CarFire.suo b/CarFire/CarFire/CarFire.suo
index 153a3e4..a29eeb8 100644
Binary files a/CarFire/CarFire/CarFire.suo and b/CarFire/CarFire/CarFire.suo differ
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);