2 using System.Collections.Generic;
6 using System.Runtime.Serialization;
7 using System.Diagnostics;
8 using Microsoft.Xna.Framework;
9 using Microsoft.Xna.Framework.Graphics;
10 using System.Reflection;
15 /// A map object represents the map or virtual world where players and other
16 /// game entities exist. The map consists of a grid where each grid space can
17 /// contain static scenery and/or game entities which can move and interact
18 /// with other game entities.
22 #region Public Constants
24 public const float PixelsToUnitSquares = 64.0f;
32 /// The type of a map helps determine how the map is intended to be used.
42 /// The container class for map metadata.
49 public HashSet<int> NumPlayers = new HashSet<int>();
50 public string Tileset;
52 public int GridHeight;
56 /// The container class for information about an entity defined in the map.
58 public class RawEntity
61 public Point Position;
62 public Dictionary<string, string> Attributes = new Dictionary<string, string>();
68 #region Public Properties
71 /// Get the name of the map.
73 public string Name { get { return mData.Metadata.Name; } }
76 /// Get the type of the map.
78 public Mode Type { get { return mData.Metadata.Type; } }
81 /// Get the author of the map.
83 public string Author { get { return mData.Metadata.Author; } }
86 /// Get a set of integers containing each allowable number of players.
88 public HashSet<int> NumPlayers { get { return mData.Metadata.NumPlayers; } }
91 /// Get the width of the map, in grid units.
93 public int Width { get { return mData.Metadata.GridWidth; } }
96 /// Get the height of the map, in grid units.
98 public int Height { get { return mData.Metadata.GridHeight; } }
101 /// Get the name of the tileset.
103 public string Tileset { get { return mData.Metadata.Tileset; } }
106 /// Get the current grid of open cells. On the grid, true means
107 /// the cell is open (i.e. an entity can occupy that cell), and false
108 /// means the cell is closed. Note that, just like Map.IsCellOpen,
109 /// only static scenery is considered; the grid cannot tell you
110 /// whether or not an entity is already occupying the cell.
112 public bool[,] Grid { get { return mData.Grid; } }
115 /// Get a list of the raw entity containers loaded with the map. If you
116 /// want to get the actual entity objects, use Map.GetEntities and
117 /// Map.GetAllEntities instead.
119 public List<RawEntity> RawEntities { get { return mData.Entities; } }
123 /// Get and set the coordinate of the grid cell that should be in
124 /// the center of the screen when the map is drawn. Setting this
125 /// will change the viewport of the map and will effect the return
126 /// values of Map.GetPointFromCoordinates and Map.GetRectangleFromCoordinates.
128 public Vector2 CenterCell
130 get { return mView.CenterCell; }
131 set { mView.CenterCell = value; }
135 /// Get and set the tilemap with its associated texture and tile
136 /// character to coordinate mappings. This effects what the map looks
137 /// like when it is drawn. You will need to reset any map instances
138 /// after setting a new tilemap. You should also set a tilemap before
139 /// instantiating any maps.
141 public static Tilemap Tilemap;
144 /// Get and set the zoom of the map view. The default zoom is
145 /// Map.PixelsToUnitSquares.
149 get { return mView.Zoom; }
150 set { mView.Zoom = value; }
156 #region Public Methods
159 /// Construct a map with the provided map data.
161 /// <param name="metadata">The metadata.</param>
162 /// <param name="grid">The grid.</param>
163 /// <param name="entities">The entities.</param>
164 public Map(Metadata metadata, char[,] grid, char defaultTile,
165 List<RawEntity> entities, Point[] playerPositions)
167 mData = new Model(metadata, grid, defaultTile, entities, playerPositions);
168 mView = new View(mData);
173 /// Draw a representation of the map to the screen.
175 /// <param name="spriteBatch">The jeewiz.</param>
176 public void Draw(SpriteBatch spriteBatch)
178 mView.Draw(spriteBatch);
183 /// Get a point in screen-space from a coordinate in gridspace.
185 /// <param name="x">X-coordinate.</param>
186 /// <param name="y">Y-coordinate.</param>
187 /// <returns>Transformed point.</returns>
188 public Point GetPointFromCoordinates(float x, float y)
190 return mView.GetPointFromCoordinates(x, y);
194 /// Get a point in screen-space from a coordinate in gridspace.
196 /// <param name="point">X,Y-coordinates.</param>
197 /// <returns>Transformed point.</returns>
198 public Point GetPointFromCoordinates(Vector2 point)
200 return mView.GetPointFromCoordinates(point.X, point.Y);
204 /// Get a rectangle in screen-space centered around a coordinate in gridspace.
206 /// <param name="x">X-coordinate.</param>
207 /// <param name="y">Y-coordinate.</param>
208 /// <returns>Transformed rectangle.</returns>
209 public Rectangle GetRectangleFromCoordinates(float x, float y)
211 return mView.GetRectangleFromCoordinates(x, y);
215 /// Get a rectangle in screen-space centered around a coordinate in gridspace.
217 /// <param name="point">X,Y-coordinates.</param>
218 /// <returns>Transformed rectangle.</returns>
219 public Rectangle GetRectangleFromCoordinates(Vector2 point)
221 return mView.GetRectangleFromCoordinates(point.X, point.Y);
226 /// Determine whether or not a cell can be occupied by a game entity.
228 /// <param name="x">X-coordinate.</param>
229 /// <param name="y">Y-coordinate.</param>
230 /// <returns>True if cell can be occupied, false otherwise.</returns>
231 public bool IsCellOpen(int x, int y)
233 return mData.IsCellOpen(x, y);
237 /// created by Brady for AI precalculations
239 /// <param name="x">X-coordinate.</param>
240 /// <param name="y">Y-coordinate.</param>
241 public bool IsWall(int x, int y)
243 return mData.IsWall(x, y);
247 /// Determine whether or not a cell can be occupied by a game entity.
249 /// <param name="point">X,Y-coordinates.</param>
250 /// <returns>True if cell can be occupied, false otherwise.</returns>
251 public bool IsCellOpen(Point point)
253 return mData.IsCellOpen(point.X, point.Y);
258 /// Get the starting position of a player.
260 /// <param name="playerNumber">The number of the player (i.e. 1-4).
261 /// This number must be a valid player number.</param>
262 /// <returns>The starting position of the player.</returns>
263 public Point GetStartingPositionForPlayer(int playerNumber)
265 Debug.Assert(1 <= playerNumber && playerNumber <= NumPlayers.Max());
266 return mData.PlayerPositions[playerNumber];
271 /// Get all the entities loaded from the map file. Exceptions could be
272 /// thrown if there are entities without associated classes.
274 /// <param name="game">The game reference to be passed to entities.</param>
275 /// <returns>List of entity objects loaded.</returns>
276 public List<IEntity> GetAllEntities(Game game)
278 return mData.GetAllEntities(game);
282 /// Get the entities of a certain type loaded from the map file. Exceptions
283 /// could be thrown if there are entities without associated classes.
285 /// <param name="game">The game reference to be passed to entities.</param>
286 /// <typeparam name="T">Type of the entity you want a list of.</typeparam>
287 /// <returns>List of entity objects loaded.</returns>
288 public List<T> GetEntities<T>(Game game)
290 return mData.GetEntities<T>(game);
295 /// Set the tile of a cell.
297 /// <param name="x">X-coordinate.</param>
298 /// <param name="y">Y-coordinate.</param>
299 /// <param name="tile">The character representing the tile.</param>
300 public void SetCell(int x, int y, char tile)
302 mData.SetCell(x, y, tile);
306 /// Set the tile of a cell.
308 /// <param name="point">X,Y-coordinates.</param>
309 /// <param name="tile">The character representing the tile.</param>
310 public void SetCell(Point point, char tile)
312 mData.SetCell(point.X, point.Y, tile);
317 /// Clear a cell to the default tile.
319 /// <param name="x">X-coordinate.</param>
320 /// <param name="y">Y-coordinate.</param>
321 public void ClearCell(int x, int y)
323 mData.ClearCell(x, y);
327 /// Clear a cell to the default tile.
329 /// <param name="point">X,Y-coordinates.</param>
330 public void ClearCell(Point point)
332 mData.ClearCell(point.X, point.Y);
337 /// Reset the map to the state it was at right after loading.
348 #region Private Types
352 public Metadata Metadata { get { return mMetadata; } }
353 public List<RawEntity> Entities { get { return mEntities; } }
354 public Point[] PlayerPositions { get { return mPlayerPositions; } }
355 public bool[,] Grid { get { return mBooleanGrid; } }
358 public Model(Metadata metadata, char[,] grid, char defaultTile,
359 List<RawEntity> entities, Point[] playerPositions)
361 Debug.Assert(metadata != null);
362 Debug.Assert(grid != null);
363 Debug.Assert(entities != null);
364 Debug.Assert(metadata.GridWidth * metadata.GridHeight == grid.Length);
365 Debug.Assert(Tilemap != null);
367 mMetadata = metadata;
369 mDefaultTile = defaultTile;
370 mEntities = entities;
371 mPlayerPositions = playerPositions;
376 Console.WriteLine("Loaded map {0} of type {1} written by {2}.",
386 mGrid = (char[,])mCleanGrid.Clone();
388 mBooleanGrid = new bool[mMetadata.GridWidth, mMetadata.GridHeight];
389 for (int x = 0; x < mMetadata.GridWidth; x++)
391 for (int y = 0; y < mMetadata.GridHeight; y++)
393 mBooleanGrid[x, y] = IsCellOpen(x, y);
399 public bool IsCellOpen(int x, int y)
401 if (!IsOnMap(x, y)) return false;
402 return (Tilemap.GetTileFlags(mGrid[x, y]) & TileFlags.Open) == TileFlags.Open;
405 //created by Brady for AI precalculations
406 public bool IsWall(int x, int y)
408 if (!IsOnMap(x, y)) return false;
409 return (Tilemap.GetTileFlags(mGrid[x, y]) & TileFlags.Wall) == TileFlags.Wall;
412 public void SetCell(int x, int y, char tile)
417 mBooleanGrid[x, y] = IsCellOpen(x, y);
421 public char GetCell(int x, int y)
423 if (IsOnMap(x, y)) return mGrid[x, y];
427 public void ClearCell(int x, int y)
429 SetCell(x, y, mDefaultTile);
432 public bool IsOnMap(int x, int y)
434 return 0 <= x && x < Metadata.GridWidth && 0 <= y && y < Metadata.GridHeight;
438 public List<IEntity> GetAllEntities(Game game)
440 List<IEntity> list = new List<IEntity>();
442 foreach (RawEntity raw in mEntities)
444 if (raw.Attributes.ContainsKey("type"))
446 string typename = raw.Attributes["type"];
448 object[] args = new object[4];
450 args[1] = raw.Position;
451 args[2] = raw.Attributes;
456 IEntity entity = (IEntity)Activator.CreateInstance(System.Type.GetType("CarFire." + typename), args);
459 entity.LoadContent(game.ContentManager);
462 else throw new Exception();
464 #pragma warning disable 0168
465 catch (System.Exception ex)
466 #pragma warning restore 0168
468 throw new Exception("Entity of type " + typename + " not loaded because an entity class can't be found.");
473 Console.WriteLine("Ignoring entity with identifier " + raw.Id + " since it has no type key.");
480 public List<T> GetEntities<T>(Game game)
482 System.Type type = typeof(T);
483 List<T> list = new List<T>();
485 string typename = typeof(T).Name;
486 foreach (RawEntity raw in mEntities)
488 if (raw.Attributes.ContainsKey("type") && typename == raw.Attributes["type"])
490 object[] args = new object[4];
492 args[1] = raw.Position;
493 args[2] = raw.Attributes;
496 T entity = (T)Activator.CreateInstance(type, args);
499 ((IEntity)entity).LoadContent(game.ContentManager);
502 else throw new Exception("Entity of type " + typename + " not loaded because an entity class can't be found.");
513 bool[,] mBooleanGrid;
515 List<RawEntity> mEntities;
516 Point[] mPlayerPositions;
521 public Vector2 CenterCell;
525 public View(Model data)
527 Debug.Assert(data != null);
536 CenterCell = Vector2.Zero;
537 Zoom = PixelsToUnitSquares;
541 public void Draw(SpriteBatch spriteBatch)
543 if (Tilemap == null) throw new Exception("Cannot draw map without first setting the tilemap.");
544 mViewport = spriteBatch.GraphicsDevice.Viewport;
546 for (int y = 0; y < mData.Metadata.GridHeight; y++)
548 for (int x = 0; x < mData.Metadata.GridWidth; x++)
550 Tilemap.Draw(spriteBatch, mData.GetCell(x, y), GetRectangleFromCoordinates(x, y));
556 public Point GetPointFromCoordinates(float x, float y)
558 Matrix transform = GetTransformation(CenterCell);
559 Vector2 point = Vector2.Transform(new Vector2(x, y), transform);
561 return new Point((int)point.X, (int)point.Y);
564 public Rectangle GetRectangleFromCoordinates(float x, float y)
566 Matrix transform = GetTransformation(CenterCell);
567 Vector2 point = Vector2.Transform(new Vector2(x, y), transform);
569 return new Rectangle((int)Math.Round(point.X, 0), (int)Math.Round(point.Y, 0), (int)Math.Round(Zoom, 0), (int)Math.Round(Zoom, 0));
574 Matrix GetTransformation(Vector2 center)
576 float halfRatio = Zoom * 0.5f;
577 Matrix transform = Matrix.CreateTranslation(-center.X, -center.Y, 0.0f);
578 transform *= Matrix.CreateScale(Zoom);
579 transform *= Matrix.CreateTranslation(mViewport.Width * 0.5f - halfRatio,
580 mViewport.Height * 0.5f - halfRatio, 0.0f);
582 Vector2 topLeft = Vector2.Transform(new Vector2(0.0f, 0.0f), transform);
583 topLeft.X = Math.Max(mViewport.X, topLeft.X);
584 topLeft.Y = Math.Max(mViewport.Y, topLeft.Y);
585 transform *= Matrix.CreateTranslation(-topLeft.X, -topLeft.Y, 0.0f);
587 Vector2 bottomRight = Vector2.Transform(new Vector2((float)mData.Metadata.GridWidth,
588 (float)mData.Metadata.GridHeight), transform);
589 float right = mViewport.X + mViewport.Width;
590 float bottom = mViewport.Y + mViewport.Height;
591 bottomRight.X = Math.Min(right, bottomRight.X) - right;
592 bottomRight.Y = Math.Min(bottom, bottomRight.Y) - bottom;
593 transform *= Matrix.CreateTranslation(-bottomRight.X, -bottomRight.Y, 0.0f);
606 #region Private Variables