git-svn-id: https://bd85.net/svn/cs3505_group@152 92bb83a3-7c8f-8a45-bc97-515c4e399668
[chaz/carfire] / CarFire / CarFire / CarFire / Map.cs
1 ´╗┐using System;
2 using System.Collections.Generic;
3 using System.Linq;
4 using System.Text;
5 using System.IO;
6 using System.Runtime.Serialization;
7 using System.Diagnostics;
8 using Microsoft.Xna.Framework;
9 using Microsoft.Xna.Framework.Graphics;
10 using System.Reflection;
11
12 namespace CarFire
13 {
14 /// <summary>
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.
19 /// </summary>
20 public class Map
21 {
22 #region Public Constants
23
24 public const float PixelsToUnitSquares = 64.0f;
25
26 #endregion
27
28
29 #region Public Types
30
31 /// <summary>
32 /// The type of a map helps determine how the map is intended to be used.
33 /// </summary>
34 public enum Mode
35 {
36 None,
37 Campaign,
38 Battle
39 }
40
41 /// <summary>
42 /// The container class for map metadata.
43 /// </summary>
44 public class Metadata
45 {
46 public string Name;
47 public Mode Type;
48 public string Author;
49 public HashSet<int> NumPlayers = new HashSet<int>();
50 public string Tileset;
51 public int GridWidth;
52 public int GridHeight;
53 }
54
55 /// <summary>
56 /// The container class for information about an entity defined in the map.
57 /// </summary>
58 public class RawEntity
59 {
60 public char Id;
61 public Point Position;
62 public Dictionary<string, string> Attributes = new Dictionary<string, string>();
63 }
64
65 #endregion
66
67
68 #region Public Properties
69
70 /// <summary>
71 /// Get the name of the map.
72 /// </summary>
73 public string Name { get { return mData.Metadata.Name; } }
74
75 /// <summary>
76 /// Get the type of the map.
77 /// </summary>
78 public Mode Type { get { return mData.Metadata.Type; } }
79
80 /// <summary>
81 /// Get the author of the map.
82 /// </summary>
83 public string Author { get { return mData.Metadata.Author; } }
84
85 /// <summary>
86 /// Get a set of integers containing each allowable number of players.
87 /// </summary>
88 public HashSet<int> NumPlayers { get { return mData.Metadata.NumPlayers; } }
89
90 /// <summary>
91 /// Get the width of the map, in grid units.
92 /// </summary>
93 public int Width { get { return mData.Metadata.GridWidth; } }
94
95 /// <summary>
96 /// Get the height of the map, in grid units.
97 /// </summary>
98 public int Height { get { return mData.Metadata.GridHeight; } }
99
100 /// <summary>
101 /// Get the name of the tileset.
102 /// </summary>
103 public string Tileset { get { return mData.Metadata.Tileset; } }
104
105 /// <summary>
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.
111 /// </summary>
112 public bool[,] Grid { get { return mData.Grid; } }
113
114 /// <summary>
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.
118 /// </summary>
119 public List<RawEntity> RawEntities { get { return mData.Entities; } }
120
121
122 /// <summary>
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.
127 /// </summary>
128 public Vector2 CenterCell
129 {
130 get { return mView.CenterCell; }
131 set { mView.CenterCell = value; }
132 }
133
134 /// <summary>
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.
138 /// </summary>
139 public static Tilemap Tilemap;
140
141 /// <summary>
142 /// Get and set the zoom of the map view. The default zoom is
143 /// Map.PixelsToUnitSquares.
144 /// </summary>
145 public float Zoom
146 {
147 get { return mView.Zoom; }
148 set { mView.Zoom = value; }
149 }
150
151 #endregion
152
153
154 #region Public Methods
155
156 /// <summary>
157 /// Construct a map with the provided map data.
158 /// </summary>
159 /// <param name="metadata">The metadata.</param>
160 /// <param name="grid">The grid.</param>
161 /// <param name="entities">The entities.</param>
162 public Map(Metadata metadata, char[,] grid, char defaultTile,
163 List<RawEntity> entities, Point[] playerPositions)
164 {
165 mData = new Model(metadata, grid, defaultTile, entities, playerPositions);
166 mView = new View(mData);
167 }
168
169
170 /// <summary>
171 /// Draw a representation of the map to the screen.
172 /// </summary>
173 /// <param name="spriteBatch">The jeewiz.</param>
174 public void Draw(SpriteBatch spriteBatch)
175 {
176 mView.Draw(spriteBatch);
177 }
178
179
180 /// <summary>
181 /// Get a point in screen-space from a coordinate in gridspace.
182 /// </summary>
183 /// <param name="x">X-coordinate.</param>
184 /// <param name="y">Y-coordinate.</param>
185 /// <returns>Transformed point.</returns>
186 public Point GetPointFromCoordinates(float x, float y)
187 {
188 return mView.GetPointFromCoordinates(x, y);
189 }
190
191 /// <summary>
192 /// Get a point in screen-space from a coordinate in gridspace.
193 /// </summary>
194 /// <param name="point">X,Y-coordinates.</param>
195 /// <returns>Transformed point.</returns>
196 public Point GetPointFromCoordinates(Vector2 point)
197 {
198 return mView.GetPointFromCoordinates(point.X, point.Y);
199 }
200
201 /// <summary>
202 /// Get a rectangle in screen-space centered around a coordinate in gridspace.
203 /// </summary>
204 /// <param name="x">X-coordinate.</param>
205 /// <param name="y">Y-coordinate.</param>
206 /// <returns>Transformed rectangle.</returns>
207 public Rectangle GetRectangleFromCoordinates(float x, float y)
208 {
209 return mView.GetRectangleFromCoordinates(x, y);
210 }
211
212 /// <summary>
213 /// Get a rectangle in screen-space centered around a coordinate in gridspace.
214 /// </summary>
215 /// <param name="point">X,Y-coordinates.</param>
216 /// <returns>Transformed rectangle.</returns>
217 public Rectangle GetRectangleFromCoordinates(Vector2 point)
218 {
219 return mView.GetRectangleFromCoordinates(point.X, point.Y);
220 }
221
222
223 /// <summary>
224 /// Determine whether or not a cell can be occupied by a game entity.
225 /// </summary>
226 /// <param name="x">X-coordinate.</param>
227 /// <param name="y">Y-coordinate.</param>
228 /// <returns>True if cell can be occupied, false otherwise.</returns>
229 public bool IsCellOpen(int x, int y)
230 {
231 return mData.IsCellOpen(x, y);
232 }
233
234 /// <summary>
235 /// created by Brady for AI precalculations
236 /// </summary>
237 /// <param name="x">X-coordinate.</param>
238 /// <param name="y">Y-coordinate.</param>
239 public bool IsWall(int x, int y)
240 {
241 return mData.IsWall(x, y);
242 }
243
244 /// <summary>
245 /// Determine whether or not a cell can be occupied by a game entity.
246 /// </summary>
247 /// <param name="point">X,Y-coordinates.</param>
248 /// <returns>True if cell can be occupied, false otherwise.</returns>
249 public bool IsCellOpen(Point point)
250 {
251 return mData.IsCellOpen(point.X, point.Y);
252 }
253
254
255 /// <summary>
256 /// Get the starting position of a player.
257 /// </summary>
258 /// <param name="playerNumber">The number of the player (i.e. 1-4).
259 /// This number must be a valid player number.</param>
260 /// <returns>The starting position of the player.</returns>
261 public Point GetStartingPositionForPlayer(int playerNumber)
262 {
263 Debug.Assert(1 <= playerNumber && playerNumber <= NumPlayers.Max());
264 return mData.PlayerPositions[playerNumber];
265 }
266
267
268 /// <summary>
269 /// Get all the entities loaded from the map file. Exceptions could be
270 /// thrown if there are entities without associated classes.
271 /// </summary>
272 /// <param name="game">The game reference to be passed to entities.</param>
273 /// <returns>List of entity objects loaded.</returns>
274 public List<IEntity> GetAllEntities(Game game)
275 {
276 return mData.GetAllEntities(game);
277 }
278
279 /// <summary>
280 /// Get the entities of a certain type loaded from the map file. Exceptions
281 /// could be thrown if there are entities without associated classes.
282 /// </summary>
283 /// <param name="game">The game reference to be passed to entities.</param>
284 /// <typeparam name="T">Type of the entity you want a list of.</typeparam>
285 /// <returns>List of entity objects loaded.</returns>
286 public List<T> GetEntities<T>(Game game)
287 {
288 return mData.GetEntities<T>(game);
289 }
290
291
292 /// <summary>
293 /// Set the tile of a cell.
294 /// </summary>
295 /// <param name="x">X-coordinate.</param>
296 /// <param name="y">Y-coordinate.</param>
297 /// <param name="tile">The character representing the tile.</param>
298 public void SetCell(int x, int y, char tile)
299 {
300 mData.SetCell(x, y, tile);
301 }
302
303 /// <summary>
304 /// Set the tile of a cell.
305 /// </summary>
306 /// <param name="point">X,Y-coordinates.</param>
307 /// <param name="tile">The character representing the tile.</param>
308 public void SetCell(Point point, char tile)
309 {
310 mData.SetCell(point.X, point.Y, tile);
311 }
312
313
314 /// <summary>
315 /// Clear a cell to the default tile.
316 /// </summary>
317 /// <param name="x">X-coordinate.</param>
318 /// <param name="y">Y-coordinate.</param>
319 public void ClearCell(int x, int y)
320 {
321 mData.ClearCell(x, y);
322 }
323
324 /// <summary>
325 /// Clear a cell to the default tile.
326 /// </summary>
327 /// <param name="point">X,Y-coordinates.</param>
328 public void ClearCell(Point point)
329 {
330 mData.ClearCell(point.X, point.Y);
331 }
332
333
334 /// <summary>
335 /// Reset the map to the state it was at right after loading.
336 /// </summary>
337 public void Reset()
338 {
339 mData.Reset();
340 mView.Reset();
341 }
342
343 #endregion
344
345
346 #region Private Types
347
348 class Model
349 {
350 public Metadata Metadata { get { return mMetadata; } }
351 public List<RawEntity> Entities { get { return mEntities; } }
352 public Point[] PlayerPositions { get { return mPlayerPositions; } }
353 public bool[,] Grid { get { return mBooleanGrid; } }
354
355
356 public Model(Metadata metadata, char[,] grid, char defaultTile,
357 List<RawEntity> entities, Point[] playerPositions)
358 {
359 Debug.Assert(metadata != null);
360 Debug.Assert(grid != null);
361 Debug.Assert(entities != null);
362 Debug.Assert(metadata.GridWidth * metadata.GridHeight == grid.Length);
363 Debug.Assert(Tilemap != null);
364
365 mMetadata = metadata;
366 mCleanGrid = grid;
367 mDefaultTile = defaultTile;
368 mEntities = entities;
369 mPlayerPositions = playerPositions;
370
371 Reset();
372
373 #if DEBUG
374 Console.WriteLine("Loaded map {0} of type {1} written by {2}.",
375 metadata.Name,
376 metadata.Type,
377 metadata.Author);
378 #endif
379 }
380
381
382 public void Reset()
383 {
384 mGrid = (char[,])mCleanGrid.Clone();
385
386 mBooleanGrid = new bool[mMetadata.GridWidth, mMetadata.GridHeight];
387 for (int x = 0; x < mMetadata.GridWidth; x++)
388 {
389 for (int y = 0; y < mMetadata.GridHeight; y++)
390 {
391 mBooleanGrid[x, y] = IsCellOpen(x, y);
392 }
393 }
394 }
395
396
397 public bool IsCellOpen(int x, int y)
398 {
399 if (!IsOnMap(x, y)) return false;
400 return (Tilemap.GetTileFlags(mGrid[x, y]) & TileFlags.Open) == TileFlags.Open;
401 }
402
403 //created by Brady for AI precalculations
404 public bool IsWall(int x, int y)
405 {
406 if (!IsOnMap(x, y)) return false;
407 return (Tilemap.GetTileFlags(mGrid[x, y]) & TileFlags.Wall) == TileFlags.Wall;
408 }
409
410 public void SetCell(int x, int y, char tile)
411 {
412 if (IsOnMap(x, y))
413 {
414 mGrid[x, y] = tile;
415 mBooleanGrid[x, y] = IsCellOpen(x, y);
416 }
417 }
418
419 public char GetCell(int x, int y)
420 {
421 if (IsOnMap(x, y)) return mGrid[x, y];
422 return mDefaultTile;
423 }
424
425 public void ClearCell(int x, int y)
426 {
427 SetCell(x, y, mDefaultTile);
428 }
429
430 public bool IsOnMap(int x, int y)
431 {
432 return 0 <= x && x < Metadata.GridWidth && 0 <= y && y < Metadata.GridHeight;
433 }
434
435
436 public List<IEntity> GetAllEntities(Game game)
437 {
438 List<IEntity> list = new List<IEntity>();
439
440 foreach (RawEntity raw in mEntities)
441 {
442 if (raw.Attributes.ContainsKey("type"))
443 {
444 string typename = raw.Attributes["type"];
445
446 object[] args = new object[4];
447 args[0] = raw.Id;
448 args[1] = raw.Position;
449 args[2] = raw.Attributes;
450 args[3] = game;
451
452 try
453 {
454 IEntity entity = (IEntity)Activator.CreateInstance(System.Type.GetType("CarFire." + typename), args);
455 if (entity != null)
456 {
457 entity.LoadContent(game.ContentManager);
458 list.Add(entity);
459 }
460 else throw new Exception();
461 }
462 #pragma warning disable 0168
463 catch (System.Exception ex)
464 #pragma warning restore 0168
465 {
466 throw new Exception("Entity of type " + typename + " not loaded because an entity class can't be found.");
467 }
468 }
469 else
470 {
471 Console.WriteLine("Ignoring entity with identifier " + raw.Id + " since it has no type key.");
472 }
473 }
474
475 return list;
476 }
477
478 public List<T> GetEntities<T>(Game game)
479 {
480 System.Type type = typeof(T);
481 List<T> list = new List<T>();
482
483 string typename = typeof(T).Name;
484 foreach (RawEntity raw in mEntities)
485 {
486 if (raw.Attributes.ContainsKey("type") && typename == raw.Attributes["type"])
487 {
488 object[] args = new object[4];
489 args[0] = raw.Id;
490 args[1] = raw.Position;
491 args[2] = raw.Attributes;
492 args[3] = game;
493
494 T entity = (T)Activator.CreateInstance(type, args);
495 if (entity != null)
496 {
497 ((IEntity)entity).LoadContent(game.ContentManager);
498 list.Add(entity);
499 }
500 else throw new Exception("Entity of type " + typename + " not loaded because an entity class can't be found.");
501 }
502 }
503
504 return list;
505 }
506
507
508 Metadata mMetadata;
509 char[,] mGrid;
510 char[,] mCleanGrid;
511 bool[,] mBooleanGrid;
512 char mDefaultTile;
513 List<RawEntity> mEntities;
514 Point[] mPlayerPositions;
515 }
516
517 class View
518 {
519 public Vector2 CenterCell;
520 public float Zoom;
521
522
523 public View(Model data)
524 {
525 Debug.Assert(data != null);
526 mData = data;
527
528 Reset();
529 }
530
531
532 public void Reset()
533 {
534 CenterCell = Vector2.Zero;
535 Zoom = PixelsToUnitSquares;
536 }
537
538
539 public void Draw(SpriteBatch spriteBatch)
540 {
541 if (Tilemap == null) throw new Exception("Cannot draw map without first setting the tilemap.");
542 mViewport = spriteBatch.GraphicsDevice.Viewport;
543
544 for (int y = 0; y < mData.Metadata.GridHeight; y++)
545 {
546 for (int x = 0; x < mData.Metadata.GridWidth; x++)
547 {
548 Tilemap.Draw(spriteBatch, mData.GetCell(x, y), GetRectangleFromCoordinates(x, y));
549 }
550 }
551 }
552
553
554 public Point GetPointFromCoordinates(float x, float y)
555 {
556 Matrix transform = GetTransformation(CenterCell);
557 Vector2 point = Vector2.Transform(new Vector2(x, y), transform);
558
559 return new Point((int)point.X, (int)point.Y);
560 }
561
562 public Rectangle GetRectangleFromCoordinates(float x, float y)
563 {
564 Matrix transform = GetTransformation(CenterCell);
565 Vector2 point = Vector2.Transform(new Vector2(x, y), transform);
566
567 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));
568 }
569
570
571
572 Matrix GetTransformation(Vector2 center)
573 {
574 float halfRatio = Zoom * 0.5f;
575 Matrix transform = Matrix.CreateTranslation(-center.X, -center.Y, 0.0f);
576 transform *= Matrix.CreateScale(Zoom);
577 transform *= Matrix.CreateTranslation(mViewport.Width * 0.5f - halfRatio,
578 mViewport.Height * 0.5f - halfRatio, 0.0f);
579
580 Vector2 topLeft = Vector2.Transform(new Vector2(0.0f, 0.0f), transform);
581 topLeft.X = Math.Max(mViewport.X, topLeft.X);
582 topLeft.Y = Math.Max(mViewport.Y, topLeft.Y);
583 transform *= Matrix.CreateTranslation(-topLeft.X, -topLeft.Y, 0.0f);
584
585 Vector2 bottomRight = Vector2.Transform(new Vector2((float)mData.Metadata.GridWidth,
586 (float)mData.Metadata.GridHeight), transform);
587 float right = mViewport.X + mViewport.Width;
588 float bottom = mViewport.Y + mViewport.Height;
589 bottomRight.X = Math.Min(right, bottomRight.X) - right;
590 bottomRight.Y = Math.Min(bottom, bottomRight.Y) - bottom;
591 transform *= Matrix.CreateTranslation(-bottomRight.X, -bottomRight.Y, 0.0f);
592
593 return transform;
594 }
595
596
597 Model mData;
598 Viewport mViewport;
599 }
600
601 #endregion
602
603
604 #region Private Variables
605
606 Model mData;
607 View mView;
608
609 #endregion
610 }
611 }
This page took 0.078992 seconds and 4 git commands to generate.