63ed26deed977cd5993c8844496f1f26dfac6852
[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 = (bool[,])State.Map.Grid.Clone();
229 foreach (IEntity entity in State.Entities)
230 {
231 Point coordinates = entity.Coordinates;
232 grid[coordinates.X, coordinates.Y] = false;
233 }
234 foreach (Player player in State.mCharacters)
235 {
236 if (player == null) continue;
237 Point coordinates = player.Coordinates;
238 grid[coordinates.X, coordinates.Y] = false;
239 }
240 return grid;
241 }
242 }
243
244 #endregion
245
246
247 #region Public Methods
248
249 /// <summary>
250 /// Get an entity at a certain place on the map.
251 /// </summary>
252 /// <param name="point">The coordinates.</param>
253 /// <returns>The entity, or null if none is at that location.</returns>
254 public IEntity GetEntityAtCoordinates(Point point)
255 {
256 foreach (IEntity entity in State.Entities)
257 {
258 if (entity.Coordinates == point) return entity;
259 }
260 return null;
261 }
262
263 /// <summary>
264 /// Get a player at a certain place on the map.
265 /// </summary>
266 /// <param name="point">The coordinates.</param>
267 /// <returns>The player, or null if none is at that location.</returns>
268 public Player GetPlayerAtCoordinates(Point point)
269 {
270 foreach (Player player in State.mCharacters)
271 {
272 if (player != null && player.Coordinates == point) return player;
273 }
274 return null;
275 }
276
277 /// <summary>
278 /// Determine if a cell is open, depending on the static scenery
279 /// of the map and if there are any collidable entities.
280 /// </summary>
281 /// <param name="point">The coordinates.</param>
282 /// <returns>True if the cell is open; false otherwise.</returns>
283 public bool IsCellOpen(Point point)
284 {
285 if (!State.Map.IsCellOpen(point)) return false;
286 IEntity entity = GetEntityAtCoordinates(point);
287 if (entity != null && entity.IsCollidable) return false;
288 Player player = GetPlayerAtCoordinates(point);
289 if (player != null) return false;
290 return true;
291 }
292
293 /// <summary>
294 /// Remove a specific entity from the game. The entity can still
295 /// be tracked some other way, but it won't included when the game is
296 /// updating and drawing stuff.
297 /// </summary>
298 /// <param name="entity">The entity.</param>
299 /// <returns>The entity that was removed, or null if no entity was removed.</returns>
300 public IEntity RemoveEntity(IEntity entity)
301 {
302 if (State.Entities.Remove(entity)) return entity;
303 return null;
304 }
305
306 /// <summary>
307 /// Move on to the next map, and advance the level.
308 /// </summary>
309 public void AdvanceLevel()
310 {
311 // TODO: Load the next map, etc...
312 //TODO somehow get next map
313 State.Entities.Clear();
314 String nextMap = State.Map.Next;
315 State.Map = mContentManager.Load<Map>("Maps/"+nextMap);
316 for (int i = 0; i < State.mCharacters.Length; i++)
317 {
318 State.mCharacters[i].Coordinates = State.Map.GetStartingPositionForPlayer(i + 1);
319 }
320 State.Entities = State.Map.GetAllEntities(this);
321 }
322
323 /// <summary>
324 /// Restart the current level.
325 /// </summary>
326 public void Reset()
327 {
328 State.Map.Reset();
329 // TODO: Do other stuff to reset everything.
330 }
331
332
333 public Game()
334 {
335
336 }
337 public void LoadContent(ContentManager contentManager)
338 {
339 mContentManager = contentManager;
340 menu = mContentManager.Load<SpriteFont>("menuFont");
341
342 }
343
344 public void UnloadContent()
345 {
346 }
347
348 private int GetPlayerNumber(Object playerIdentifier)
349 {
350 for (int i = 0; i < mPlayerIdentifiers.Length; i++)
351 {
352 if (mPlayerIdentifiers[i] == playerIdentifier) return i;
353 }
354 throw new Exception("Illegal player identifier" + playerIdentifier);
355 }
356
357 public Vector2 PreferredScreenSize
358 {
359 get { return new Vector2(800, 600); }
360 }
361
362 public int MinimumSupportedPlayers
363 {
364 get { return 1; }
365 }
366
367 public int MaximumSupportedPlayers
368 {
369 get { return 4; }
370 }
371
372 public void ResetGame(object[] playerIdentifiers, object thisPlayer)
373 {
374 int numPlayers = playerIdentifiers.Count();
375
376 mPlayerIdentifiers = new object[numPlayers];
377 for (int i = 0; i < numPlayers; i++) mPlayerIdentifiers[i] = playerIdentifiers[i];
378
379 mThisPlayerID = GetPlayerNumber(thisPlayer);
380
381 State = new GameState(numPlayers);
382 mInputs = new NextInputs(numPlayers);
383 State.mDisplay = new Display(this);
384 State.mDisplay.LoadContent(mContentManager);
385
386 // Load the tilemap.
387 Texture2D mapTiles = mContentManager.Load<Texture2D>("graphics/wallAndFloorTilesNoEdgeScale");
388 Tilemap tilemap = new Tilemap(mapTiles, 10, 7);
389 tilemap.SetTile('`', new Point(0, 2), TileFlags.Closed | TileFlags.Wall);
390 tilemap.SetTile('~', new Point(1, 2), TileFlags.Closed | TileFlags.Wall);
391 tilemap.SetTile('!', new Point(2, 2), TileFlags.Closed | TileFlags.Wall);
392 tilemap.SetTile('@', new Point(3, 2), TileFlags.Closed | TileFlags.Wall);
393 tilemap.SetTile('#', new Point(4, 2), TileFlags.Closed | TileFlags.Wall);
394 tilemap.SetTile('$', new Point(5, 2), TileFlags.Closed | TileFlags.Wall);
395 tilemap.SetTile('%', new Point(6, 2), TileFlags.Closed | TileFlags.Wall);
396 tilemap.SetTile('^', new Point(8, 2), TileFlags.Closed | TileFlags.Wall);
397 tilemap.SetTile('&', new Point(9, 2), TileFlags.Closed | TileFlags.Wall);
398 tilemap.SetTile('*', new Point(0, 3), TileFlags.Closed | TileFlags.Wall);
399 tilemap.SetTile('(', new Point(1, 3), TileFlags.Closed | TileFlags.Wall);
400 tilemap.SetTile(')', new Point(2, 3), TileFlags.Closed | TileFlags.Wall);
401 tilemap.SetTile('-', new Point(3, 3), TileFlags.Closed | TileFlags.Wall);
402 tilemap.SetTile('=', new Point(4, 3), TileFlags.Closed | TileFlags.Wall);
403 tilemap.SetTile('_', new Point(5, 3), TileFlags.Closed | TileFlags.Wall);
404 tilemap.SetTile('+', new Point(6, 3), TileFlags.Closed | TileFlags.Wall);
405 tilemap.SetTile('|', new Point(8, 3), TileFlags.Closed | TileFlags.Wall);
406 tilemap.SetTile('[', new Point(0, 4), TileFlags.Default);
407 tilemap.SetTile(']', new Point(1, 4), TileFlags.Default);
408 tilemap.SetTile('{', new Point(2, 4), TileFlags.Default);
409 tilemap.SetTile('}', new Point(3, 4), TileFlags.Default);
410 tilemap.SetTile('?', new Point(4, 4), TileFlags.Default);
411 tilemap.SetTile(',', new Point(7, 4), TileFlags.Default);
412 tilemap.SetTile('.', new Point(8, 4), TileFlags.Default);
413 tilemap.SetTile('\\', new Point(9, 4), TileFlags.Default);
414 tilemap.SetTile(';', new Point(0, 5), TileFlags.Default);
415 tilemap.SetTile(':', new Point(1, 5), TileFlags.Default);
416 tilemap.SetTile('\'', new Point(2, 5), TileFlags.Default);
417 tilemap.SetTile('"', new Point(3, 5), TileFlags.Default);
418 tilemap.SetTile(' ', new Point(4, 5), TileFlags.Default);
419 tilemap.SetTile('<', new Point(7, 5), TileFlags.Default);
420 tilemap.SetTile('>', new Point(8, 5), TileFlags.Default);
421 tilemap.SetTile('/', new Point(9, 5), TileFlags.Default);
422 Map.Tilemap = tilemap;
423
424 // Load the first map.
425 State.Map = mContentManager.Load<Map>("Maps/colosseum");
426 State.Entities = State.Map.GetAllEntities(this);
427
428 //State.AIData = new AI(this);
429
430 /*
431 mPlayers.Clear();
432 for (int i = 0; i < PlayerIdentifiers.Length; i++)
433 {
434 Human player = new Human(mMap, "");
435 mPlayers.Add(player);
436 mDisplay.AddCharacters(player);
437 mPlayers.Add(player);
438 mDisplay.AddCharacters(player);
439 }
440 this.playerIdentifiers = PlayerIdentifiers;
441 for (int i = 0; i < mPlayers.Count; i++)
442 {
443 Point starting = mMap.GetStartingPositionForPlayer(i + 1);
444 mPlayers[i].Spawn(new Vector2(starting.X, starting.Y));
445 }
446 */
447 }
448
449 public long CurrentFrameNumber
450 {
451 get { return State.FrameNumber; }
452 }
453
454 public long CurrentChecksum
455 {
456 get { return 0; }
457 }
458
459 public void ApplyKeyInput(object playerIdentifier, Keys key, bool isKeyPressed)
460 {
461 //code from Prof Jensen's TestHarness
462 int player = GetPlayerNumber(playerIdentifier);
463
464 if (isKeyPressed && !mInputs.KeysPressed[player].Contains(key))
465 mInputs.KeysPressed[player].Add(key);
466
467 if (!isKeyPressed && !mInputs.KeysReleased[player].Contains(key))
468 mInputs.KeysReleased[player].Add(key);
469
470 }
471
472 public void ApplyMouseLocationInput(object playerIdentifier, int x, int y)
473 {
474
475 }
476
477 public void ApplyMouseButtonInput(object playerIdentifier, bool isButtonPressed)
478 {
479
480 }
481
482 public bool IsGameOver(object playerIdentifier)
483 {
484 return false;
485 }
486
487 public bool IsTerminated(object playerIdentifier)
488 {
489 return false;
490 }
491
492 public long Update(TimeSpan elapsedTime)
493 {
494 State.AdvanceFrame(mInputs, elapsedTime.Milliseconds); // Apply the inputs, advance game state.
495 State.mDisplay.Update(elapsedTime, mThisPlayerID);
496 State.Entities.ForEach(delegate(IEntity e) { e.Update(elapsedTime); });
497 mInputs = new NextInputs(State.NumberOfPlayers); // Start with inputs cleared on the next frame.
498 //mDisplay.Update(elapsedTime);
499 return State.FrameNumber;
500
501 }
502
503 public long Draw(SpriteBatch spriteBatch)
504 {
505 bool allCharactersSelected = true;
506 for (int i = 0; i < State.NumberOfPlayers; i++)
507 {
508 //If player has not selected a player yet let them select one.
509 if (State.mCharacters[i] == null)
510 {
511 allCharactersSelected = false;
512 if (State.GetKeysDown(i).Contains(Keys.M))
513 {
514 State.mCharacters[i] = new Melee(this, "", State.Map.GetStartingPositionForPlayer(i + 1), i);
515 State.mCharacters[i].LoadContent(mContentManager);
516 }
517 else if (State.GetKeysDown(i).Contains(Keys.R))
518 {
519 State.mCharacters[i] = new Ranged(this, "", State.Map.GetStartingPositionForPlayer(i + 1), i);
520 State.mCharacters[i].LoadContent(mContentManager);
521 }
522 }
523 }
524 if (allCharactersSelected)
525 {
526
527 State.mDisplay.Draw(spriteBatch);
528 }
529 else
530 {
531 spriteBatch.GraphicsDevice.Clear(Color.Black);
532 spriteBatch.DrawString(menu, "Press R to select a Ranged Character and M to select a Melee Character", new Vector2(30, 30), Color.RosyBrown);
533 }
534 return CurrentFrameNumber;
535 }
536
537 #endregion
538
539
540 #region Private Variables
541
542 SpriteFont menu;
543
544 ContentManager mContentManager;
545 NextInputs mInputs;
546
547 Object[] mPlayerIdentifiers;
548 int mThisPlayerID;
549
550 #endregion
551 }
552 }
This page took 0.072065 seconds and 3 git commands to generate.