New property IEntity.IsCollidable so entities can let the collision code know whether...
[chaz/carfire] / CarFire / CarFire / CarFire / Game.cs
1 ´╗┐using System;
2 using System.Collections.Generic;
3 using System.Linq;
4 using System.Text;
5 using Microsoft.Xna.Framework;
6 using Microsoft.Xna.Framework.Content;
7 using Microsoft.Xna.Framework.Graphics;
8 using Microsoft.Xna.Framework.Input;
9
10 namespace CarFire
11 {
12 /// <summary>
13 /// Container class for the whole state of the game.
14 /// </summary>
15 public class GameState
16 {
17 #region Public Properties
18 private const int hitMonsterScore = 20;
19 private const int killMonsterScore = 100;
20 public int HitMonsterScore { get { return hitMonsterScore; } }
21 public int KillMonsterScore { get { return killMonsterScore; } }
22
23 public long FrameNumber { get { return mFrameNumber; } }
24
25 public long Checksum { get { return mChecksum; } }
26
27 public int NumberOfPlayers { get { return mNumberOfPlayers; } }
28
29 public Map Map;
30 public List<IEntity> Entities = new List<IEntity>();
31 public List<Projectile> mProjectiles = new List<Projectile>();
32 public Player[] mCharacters;
33 public Display mDisplay;
34 public AI AIData;
35 #endregion
36
37
38 #region Public Methods
39
40 /// <summary>
41 /// Construct a game state container with the number of players.
42 /// </summary>
43 /// <param name="numPlayers">Number of players.</param>
44 public GameState(int numPlayers)
45 {
46 mNumberOfPlayers = numPlayers;
47 mFrameNumber = 0;
48
49 mCharacters = new Player[numPlayers];
50
51 mIsGameOver = new bool[numPlayers];
52 mIsTerminated = new bool[numPlayers];
53
54 mMouseLocation = new Point[numPlayers];
55 mMouseButton = new bool[numPlayers];
56 mKeysDown = new List<Keys>[numPlayers];
57 for (int i = 0; i < numPlayers; i++) mKeysDown[i] = new List<Keys>();
58
59 mKeypressCount = new int[numPlayers];
60 mElapsedTime = 0;
61 mChecksum = 0;
62 }
63
64
65 /// <summary>
66 /// Should be called by the Game class to advance the state
67 /// to the next frame.
68 /// </summary>
69 /// <param name="inputs">The inputs that occurred to be
70 /// applied this coming frame.</param>
71 /// <param name="milliseconds">Milliseconds; used for the checksum.</param>
72 public void AdvanceFrame(NextInputs inputs, long milliseconds)
73 {
74 mFrameNumber++;
75 mElapsedTime += milliseconds;
76
77 for (int player = 0; player < NumberOfPlayers; player++)
78 {
79 if (inputs.IsMousePressedChanged[player])
80 {
81 mMouseButton[player] = inputs.MousePressed[player];
82 }
83
84 if (inputs.IsMouseLocationChanged[player])
85 {
86 mMouseLocation[player] = inputs.MouseLocation[player];
87 }
88
89 foreach (Keys k in inputs.KeysPressed[player])
90 {
91 if (!mKeysDown[player].Contains(k))
92 {
93 mKeysDown[player].Add(k);
94 mKeypressCount[player]++;
95 }
96 }
97
98 foreach (Keys k in inputs.KeysReleased[player]) mKeysDown[player].Remove(k);
99 }
100
101 ComputeChecksum();
102 }
103
104
105 /// <summary>
106 /// Get the mouse location for a player.
107 /// </summary>
108 /// <param name="playerNum">Player Number.</param>
109 /// <returns>Mouse location.</returns>
110 public Point GetMouseLocation(int playerNum)
111 {
112 return mMouseLocation[playerNum];
113 }
114
115 /// <summary>
116 /// Get the mouse button state for a player.
117 /// </summary>
118 /// <param name="playerNum">Player number.</param>
119 /// <returns>Mouse button state..</returns>
120 public bool GetMouseButton(int playerNum)
121 {
122 return mMouseButton[playerNum];
123 }
124
125 /// <summary>
126 /// Get the keyboard state for a player.
127 /// </summary>
128 /// <param name="playerNum">Player number.</param>
129 /// <returns>Keyboard state.</returns>
130 public List<Keys> GetKeysDown(int playerNum)
131 {
132 return mKeysDown[playerNum];
133 }
134
135 #endregion
136
137
138 #region Private Methods
139
140 // Calculates a checksum for debugging network synchronization issues.
141 long ComputeChecksum()
142 {
143 mChecksum += FrameNumber;
144 for (int i = 0; i < NumberOfPlayers; i++)
145 {
146 mChecksum = mChecksum + mKeypressCount[i];
147 mChecksum = mChecksum * 3 + (mIsGameOver[i] ? 1 : 2);
148 mChecksum = mChecksum * 3 + (mIsTerminated[i] ? 1 : 2);
149 foreach (Keys k in mKeysDown[i])
150 mChecksum = mChecksum * 257 + (int)k;
151 mChecksum = mChecksum * 25789 + mMouseLocation[i].X * 259 + mMouseLocation[i].Y + 375;
152 mChecksum = mChecksum * 3 + (mMouseButton[i] ? 1 : 2);
153
154 }
155 mChecksum += mElapsedTime;
156
157 return mChecksum;
158 }
159
160 #endregion
161
162
163 #region Private Variables
164
165 int mNumberOfPlayers;
166 public Point[] mMouseLocation;
167 public bool[] mMouseButton;
168 public List<Keys>[] mKeysDown;
169
170 long mFrameNumber;
171
172 bool[] mIsGameOver;
173 bool[] mIsTerminated;
174
175 int[] mKeypressCount;
176 long mElapsedTime;
177 long mChecksum;
178
179 #endregion
180 }
181
182 /// <summary>
183 /// Container class for all the inputs for a single frame.
184 /// </summary>
185 public class NextInputs
186 {
187 public List<Keys>[] KeysPressed;
188 public List<Keys>[] KeysReleased;
189 public Point[] MouseLocation;
190 public bool[] IsMouseLocationChanged;
191 public bool[] MousePressed;
192 public bool[] IsMousePressedChanged;
193
194 public NextInputs(int numPlayers)
195 {
196 KeysPressed = new List<Keys>[numPlayers];
197 KeysReleased = new List<Keys>[numPlayers];
198 IsMouseLocationChanged = new bool[numPlayers];
199 MousePressed = new bool[numPlayers];
200 IsMousePressedChanged = new bool[numPlayers];
201 for (int i = 0; i < numPlayers; i++) KeysPressed[i] = new List<Keys>();
202 for (int i = 0; i < numPlayers; i++) KeysReleased[i] = new List<Keys>();
203 }
204 }
205
206
207 /// <summary>
208 /// The big kahuna.
209 /// </summary>
210 public class Game : IDeterministicGame
211 {
212 #region Public Properties
213
214 /// <summary>
215 /// Get the content manager associated with this game.
216 /// </summary>
217 public ContentManager ContentManager { get { return mContentManager; } }
218
219 /// <summary>
220 /// Get the state.
221 /// </summary>
222 public GameState State;
223
224 public bool[,] Grid
225 {
226 get
227 {
228 bool[,] grid = State.Map.Grid;
229 foreach (IEntity entity in State.Entities)
230 {
231 Point coordinates = entity.Coordinates;
232 if (State.Map.IsCellOpen(coordinates)) grid[coordinates.X, coordinates.Y] = false;
233 }
234 return grid;
235 }
236 }
237
238 #endregion
239
240
241 #region Public Methods
242
243 public IEntity GetEntityAtCoordinates(Point point)
244 {
245 foreach (IEntity entity in State.Entities)
246 {
247 if (entity.Coordinates == point) return entity;
248 }
249 return null;
250 }
251
252 public Player GetPlayerAtCoordinates(Point point)
253 {
254 foreach (Player player in State.mCharacters)
255 {
256 if (player != null && player.Coordinates == point) return player;
257 }
258 return null;
259 }
260
261 public bool IsCellOpen(Point point)
262 {
263 if (!State.Map.IsCellOpen(point)) return false;
264 IEntity entity = GetEntityAtCoordinates(point);
265 if (entity != null && entity.IsCollidable) return false;
266 return true;
267 }
268
269 public Game()
270 {
271
272 }
273 /// <summary>
274 /// This method should be called whenever the players want to move to a new map.
275 /// Not implemented yet. Need some way to get next map.
276 /// </summary>
277 public void startNewMap()
278 {
279 //TODO somehow get next map
280 State.Entities.Clear();
281 //State.Map = State.Map.getNextMap();
282 for (int i = 0; i < State.mCharacters.Length; i++)
283 {
284 State.mCharacters[i].Coordinates = State.Map.GetStartingPositionForPlayer(i + 1);
285 }
286 State.Entities = State.Map.GetAllEntities(this);
287 }
288 public void LoadContent(ContentManager contentManager)
289 {
290 mContentManager = contentManager;
291 menu = mContentManager.Load<SpriteFont>("menuFont");
292
293 }
294
295 public void UnloadContent()
296 {
297 }
298
299 private int GetPlayerNumber(Object playerIdentifier)
300 {
301 for (int i = 0; i < mPlayerIdentifiers.Length; i++)
302 {
303 if (mPlayerIdentifiers[i] == playerIdentifier) return i;
304 }
305 throw new Exception("Illegal player identifier" + playerIdentifier);
306 }
307
308 public Vector2 PreferredScreenSize
309 {
310 get { return new Vector2(800, 600); }
311 }
312
313 public int MinimumSupportedPlayers
314 {
315 get { return 1; }
316 }
317
318 public int MaximumSupportedPlayers
319 {
320 get { return 4; }
321 }
322
323 public void ResetGame(object[] playerIdentifiers, object thisPlayer)
324 {
325 int numPlayers = playerIdentifiers.Count();
326
327 mPlayerIdentifiers = new object[numPlayers];
328 for (int i = 0; i < numPlayers; i++) mPlayerIdentifiers[i] = playerIdentifiers[i];
329
330 mThisPlayerID = GetPlayerNumber(thisPlayer);
331
332 State = new GameState(numPlayers);
333 mInputs = new NextInputs(numPlayers);
334 State.mDisplay = new Display(this);
335 State.mDisplay.LoadContent(mContentManager);
336
337 // Load the tilemap.
338 Texture2D mapTiles = mContentManager.Load<Texture2D>("graphics/wallAndFloorTilesNoEdgeScale");
339 Tilemap tilemap = new Tilemap(mapTiles, 10, 7);
340 tilemap.SetTile(' ', new Point(4, 5), TileFlags.Default);
341 tilemap.SetTile('`', new Point(0, 1), TileFlags.Closed | TileFlags.Wall);
342 tilemap.SetTile('~', new Point(1, 1), TileFlags.Closed | TileFlags.Wall);
343 tilemap.SetTile('!', new Point(3, 1), TileFlags.Closed | TileFlags.Wall);
344 tilemap.SetTile('@', new Point(4, 1), TileFlags.Closed | TileFlags.Wall);
345 tilemap.SetTile('#', new Point(5, 1), TileFlags.Closed | TileFlags.Wall);
346 tilemap.SetTile('$', new Point(6, 1), TileFlags.Closed | TileFlags.Wall);
347 tilemap.SetTile('%', new Point(8, 1), TileFlags.Closed | TileFlags.Wall);
348 tilemap.SetTile('^', new Point(9, 1), TileFlags.Closed | TileFlags.Wall);
349 tilemap.SetTile('&', new Point(0, 2), TileFlags.Closed | TileFlags.Wall);
350 tilemap.SetTile('=', new Point(1, 2), TileFlags.Closed | TileFlags.Wall);
351 tilemap.SetTile('*', new Point(2, 2), TileFlags.Closed | TileFlags.Wall);
352 tilemap.SetTile('(', new Point(4, 2), TileFlags.Closed | TileFlags.Wall);
353 tilemap.SetTile(')', new Point(0, 3), TileFlags.Closed | TileFlags.Wall);
354 tilemap.SetTile('_', new Point(2, 3), TileFlags.Closed | TileFlags.Wall);
355 tilemap.SetTile('-', new Point(9, 3), TileFlags.Closed | TileFlags.Wall);
356 tilemap.SetTile(',', new Point(1, 4), TileFlags.Default);
357 tilemap.SetTile('+', new Point(2, 4), TileFlags.Default);
358 tilemap.SetTile('[', new Point(3, 4), TileFlags.Default);
359 tilemap.SetTile(']', new Point(4, 4), TileFlags.Default);
360 tilemap.SetTile('{', new Point(5, 4), TileFlags.Default);
361 tilemap.SetTile('}', new Point(6, 4), TileFlags.Default);
362 tilemap.SetTile('\\', new Point(8, 4), TileFlags.Default);
363 tilemap.SetTile('|', new Point(9, 4), TileFlags.Default);
364 tilemap.SetTile(';', new Point(0, 5), TileFlags.Default);
365 tilemap.SetTile(':', new Point(1, 5), TileFlags.Default);
366 tilemap.SetTile('\'', new Point(2, 5), TileFlags.Default);
367 tilemap.SetTile('"', new Point(3, 5), TileFlags.Default);
368 tilemap.SetTile('.', new Point(5, 5), TileFlags.Default);
369 tilemap.SetTile('<', new Point(6, 5), TileFlags.Default);
370 tilemap.SetTile('>', new Point(7, 5), TileFlags.Default);
371 tilemap.SetTile('/', new Point(8, 5), TileFlags.Default);
372 tilemap.SetTile('?', new Point(9, 5), TileFlags.Default);
373 Map.Tilemap = tilemap;
374
375 // Load the first map.
376 State.Map = mContentManager.Load<Map>("Maps/level1");
377 State.Entities = State.Map.GetAllEntities(this);
378
379 //State.AIData = new AI(this);
380
381 /*
382 mPlayers.Clear();
383 for (int i = 0; i < PlayerIdentifiers.Length; i++)
384 {
385 Human player = new Human(mMap, "");
386 mPlayers.Add(player);
387 mDisplay.AddCharacters(player);
388 mPlayers.Add(player);
389 mDisplay.AddCharacters(player);
390 }
391 this.playerIdentifiers = PlayerIdentifiers;
392 for (int i = 0; i < mPlayers.Count; i++)
393 {
394 Point starting = mMap.GetStartingPositionForPlayer(i + 1);
395 mPlayers[i].Spawn(new Vector2(starting.X, starting.Y));
396 }
397 */
398 }
399
400 public long CurrentFrameNumber
401 {
402 get { return State.FrameNumber; }
403 }
404
405 public long CurrentChecksum
406 {
407 get { return 0; }
408 }
409
410 public void ApplyKeyInput(object playerIdentifier, Keys key, bool isKeyPressed)
411 {
412 //code from Prof Jensen's TestHarness
413 int player = GetPlayerNumber(playerIdentifier);
414
415 if (isKeyPressed && !mInputs.KeysPressed[player].Contains(key))
416 mInputs.KeysPressed[player].Add(key);
417
418 if (!isKeyPressed && !mInputs.KeysReleased[player].Contains(key))
419 mInputs.KeysReleased[player].Add(key);
420
421 }
422
423 public void ApplyMouseLocationInput(object playerIdentifier, int x, int y)
424 {
425
426 }
427
428 public void ApplyMouseButtonInput(object playerIdentifier, bool isButtonPressed)
429 {
430
431 }
432
433 public bool IsGameOver(object playerIdentifier)
434 {
435 return false;
436 }
437
438 public bool IsTerminated(object playerIdentifier)
439 {
440 return false;
441 }
442
443 public long Update(TimeSpan elapsedTime)
444 {
445 State.AdvanceFrame(mInputs, elapsedTime.Milliseconds); // Apply the inputs, advance game state.
446 State.mDisplay.Update(elapsedTime, mThisPlayerID);
447 State.Entities.ForEach(delegate(IEntity e) { e.Update(elapsedTime); });
448 mInputs = new NextInputs(State.NumberOfPlayers); // Start with inputs cleared on the next frame.
449 //mDisplay.Update(elapsedTime);
450 return State.FrameNumber;
451
452 }
453
454 public long Draw(SpriteBatch spriteBatch)
455 {
456 bool allCharactersSelected = true;
457 for (int i = 0; i < State.NumberOfPlayers; i++)
458 {
459 //If player has not selected a player yet let them select one.
460 if (State.mCharacters[i] == null)
461 {
462 allCharactersSelected = false;
463 if (State.GetKeysDown(i).Contains(Keys.M))
464 {
465 State.mCharacters[i] = new Melee(this, "", State.Map.GetStartingPositionForPlayer(i + 1), i);
466 State.mCharacters[i].LoadContent(mContentManager);
467 }
468 else if (State.GetKeysDown(i).Contains(Keys.R))
469 {
470 State.mCharacters[i] = new Ranged(this, "", State.Map.GetStartingPositionForPlayer(i + 1), i);
471 State.mCharacters[i].LoadContent(mContentManager);
472 }
473 }
474 }
475 if (allCharactersSelected)
476 {
477
478 State.mDisplay.Draw(spriteBatch);
479 }
480 else
481 {
482 spriteBatch.GraphicsDevice.Clear(Color.Black);
483 spriteBatch.DrawString(menu, "Press R to select a Ranged Character and M to select a Melee Character", new Vector2(30, 30), Color.RosyBrown);
484 }
485 return CurrentFrameNumber;
486 }
487
488 #endregion
489
490
491 #region Private Variables
492
493 SpriteFont menu;
494
495 ContentManager mContentManager;
496 NextInputs mInputs;
497
498 Object[] mPlayerIdentifiers;
499 int mThisPlayerID;
500
501 #endregion
502 }
503 }
This page took 0.070001 seconds and 4 git commands to generate.