X-Git-Url: https://git.dogcows.com/gitweb?p=chaz%2Fcarfire;a=blobdiff_plain;f=CarFire%2FCarFire%2FCarFire%2FGame.cs;h=1486e6572a66eb31db5b6413620342eb58efe85b;hp=38d86b8eb111e1f100f4f03934a6031575290f96;hb=60d05271b295d2ca94a0028059add525c1bbffb1;hpb=c5daf1d9adca0c3a826dfa2ac7b6d4f8a64c84a3

diff --git a/CarFire/CarFire/CarFire/Game.cs b/CarFire/CarFire/CarFire/Game.cs
index 38d86b8..1486e65 100644
--- a/CarFire/CarFire/CarFire/Game.cs
+++ b/CarFire/CarFire/CarFire/Game.cs
@@ -9,18 +9,302 @@ using Microsoft.Xna.Framework.Input;
 
 namespace CarFire
 {
+    /// <summary>
+    /// Container class for the whole state of the game.
+    /// </summary>
+    public class GameState
+    {
+        #region Public Properties
+        private const int hitMonsterScore = 20;
+        private const int killMonsterScore = 100;
+        public int HitMonsterScore { get { return hitMonsterScore; } }
+        public int KillMonsterScore { get { return killMonsterScore; } }
+
+        public long FrameNumber { get { return mFrameNumber; } }
+
+        public long Checksum { get { return mChecksum; } }
+
+        public int NumberOfPlayers { get { return mNumberOfPlayers; } }
+
+        public Map Map;
+        public List<IEntity> Entities = new List<IEntity>();
+        public List<Projectile> mProjectiles = new List<Projectile>();
+        public Player[] mCharacters;
+        public Display mDisplay;
+        public AI AIData;
+        #endregion
+
+
+        #region Public Methods
+
+        /// <summary>
+        /// Construct a game state container with the number of players.
+        /// </summary>
+        /// <param name="numPlayers">Number of players.</param>
+        public GameState(int numPlayers)
+        {
+            mNumberOfPlayers = numPlayers;
+            mFrameNumber = 0;
+
+            mCharacters = new Player[numPlayers];
+
+            mIsGameOver = new bool[numPlayers];
+            mIsTerminated = new bool[numPlayers];
+
+            mMouseLocation = new Point[numPlayers];
+            mMouseButton = new bool[numPlayers];
+            mKeysDown = new List<Keys>[numPlayers];
+            for (int i = 0; i < numPlayers; i++) mKeysDown[i] = new List<Keys>();
+
+            mKeypressCount = new int[numPlayers];
+            mElapsedTime = 0;
+            mChecksum = 0;
+        }
+
+        
+        /// <summary>
+        /// Should be called by the Game class to advance the state
+        /// to the next frame.
+        /// </summary>
+        /// <param name="inputs">The inputs that occurred to be
+        /// applied this coming frame.</param>
+        /// <param name="milliseconds">Milliseconds; used for the checksum.</param>
+        public void AdvanceFrame(NextInputs inputs, long milliseconds)
+        {
+            mFrameNumber++;
+            mElapsedTime += milliseconds;
+
+            for (int player = 0; player < NumberOfPlayers; player++)
+            {
+                if (inputs.IsMousePressedChanged[player])
+                {
+                    mMouseButton[player] = inputs.MousePressed[player];
+                }
+
+                if (inputs.IsMouseLocationChanged[player])
+                {
+                    mMouseLocation[player] = inputs.MouseLocation[player];
+                }
+
+                foreach (Keys k in inputs.KeysPressed[player])
+                {
+                    if (!mKeysDown[player].Contains(k))
+                    {
+                        mKeysDown[player].Add(k);
+                        mKeypressCount[player]++;
+                    }
+                }
+
+                foreach (Keys k in inputs.KeysReleased[player]) mKeysDown[player].Remove(k);
+            }
+
+            ComputeChecksum();
+        }
+
+
+        /// <summary>
+        /// Get the mouse location for a player.
+        /// </summary>
+        /// <param name="playerNum">Player Number.</param>
+        /// <returns>Mouse location.</returns>
+        public Point GetMouseLocation(int playerNum)
+        {
+            return mMouseLocation[playerNum];
+        }
+
+        /// <summary>
+        /// Get the mouse button state for a player.
+        /// </summary>
+        /// <param name="playerNum">Player number.</param>
+        /// <returns>Mouse button state..</returns>
+        public bool GetMouseButton(int playerNum)
+        {
+            return mMouseButton[playerNum];
+        }
+
+        /// <summary>
+        /// Get the keyboard state for a player.
+        /// </summary>
+        /// <param name="playerNum">Player number.</param>
+        /// <returns>Keyboard state.</returns>
+        public List<Keys> GetKeysDown(int playerNum)
+        {
+            return mKeysDown[playerNum];
+        }
+
+        #endregion
+
+
+        #region Private Methods
+
+        // Calculates a checksum for debugging network synchronization issues.
+        long ComputeChecksum()
+        {
+            mChecksum += FrameNumber;
+            for (int i = 0; i < NumberOfPlayers; i++)
+            {
+                mChecksum = mChecksum + mKeypressCount[i];
+                mChecksum = mChecksum * 3 + (mIsGameOver[i] ? 1 : 2);
+                mChecksum = mChecksum * 3 + (mIsTerminated[i] ? 1 : 2);
+                foreach (Keys k in mKeysDown[i])
+                    mChecksum = mChecksum * 257 + (int)k;
+                mChecksum = mChecksum * 25789 + mMouseLocation[i].X * 259 + mMouseLocation[i].Y + 375;
+                mChecksum = mChecksum * 3 + (mMouseButton[i] ? 1 : 2);
+
+            }
+            mChecksum += mElapsedTime;
+
+            return mChecksum;
+        }
+
+        #endregion
+
+
+        #region Private Variables
+
+        int mNumberOfPlayers;
+        public Point[] mMouseLocation;
+        public bool[] mMouseButton;
+        public List<Keys>[] mKeysDown;
+
+        long mFrameNumber;
+
+        bool[] mIsGameOver;
+        bool[] mIsTerminated;
+
+        int[] mKeypressCount;
+        long mElapsedTime;
+        long mChecksum;
+
+        #endregion
+    }
+
+    /// <summary>
+    /// Container class for all the inputs for a single frame.
+    /// </summary>
+    public class NextInputs
+    {
+        public List<Keys>[] KeysPressed;
+        public List<Keys>[] KeysReleased;
+        public Point[] MouseLocation;
+        public bool[] IsMouseLocationChanged;
+        public bool[] MousePressed;
+        public bool[] IsMousePressedChanged;
+
+        public NextInputs(int numPlayers)
+        {
+            KeysPressed = new List<Keys>[numPlayers];
+            KeysReleased = new List<Keys>[numPlayers];
+            IsMouseLocationChanged = new bool[numPlayers];
+            MousePressed = new bool[numPlayers];
+            IsMousePressedChanged = new bool[numPlayers];
+            for (int i = 0; i < numPlayers; i++) KeysPressed[i] = new List<Keys>();
+            for (int i = 0; i < numPlayers; i++) KeysReleased[i] = new List<Keys>();
+        }
+    }
+
+
+    /// <summary>
+    /// The big kahuna.
+    /// </summary>
     public class Game : IDeterministicGame
     {
-        #region IDeterministicGame Members
+        #region Public Properties
+
+        /// <summary>
+        /// Get the content manager associated with this game.
+        /// </summary>
+        public ContentManager ContentManager { get { return mContentManager; } }
+
+        /// <summary>
+        /// Get the state.
+        /// </summary>
+        public GameState State;
+
+        public bool[,] Grid
+        {
+            get
+            {
+                bool[,] grid = State.Map.Grid;
+                foreach (IEntity entity in State.Entities)
+                {
+                    Point coordinates = entity.Coordinates;
+                    if (State.Map.IsCellOpen(coordinates)) grid[coordinates.X, coordinates.Y] = false;
+                }
+                return grid;
+            }
+        }
+
+        #endregion
+
 
+        #region Public Methods
+
+        public IEntity GetEntityAtCoordinates(Point point)
+        {
+            foreach (IEntity entity in State.Entities)
+            {
+                if (entity.Coordinates == point) return entity;
+            }
+            return null;
+        }
+
+        public Player GetPlayerAtCoordinates(Point point)
+        {
+            foreach (Player player in State.mCharacters)
+            {
+                if (player != null && player.Coordinates == point) return player;
+            }
+            return null;
+        }
+
+        public bool IsCellOpen(Point point)
+        {
+            if (!State.Map.IsCellOpen(point)) return false;
+            IEntity entity = GetEntityAtCoordinates(point);
+            if (entity != null && entity.IsCollidable) return false;
+            return true;
+        }
+
+        public Game()
+        {
+           
+        }
+        /// <summary>
+        /// This method should be called whenever the players want to move to a new map.
+        /// Not implemented yet.  Need some way to get next map.
+        /// </summary>
+        public void startNewMap()
+        {
+            //TODO somehow get next map
+            State.Entities.Clear();
+            //State.Map = State.Map.getNextMap();
+            for (int i = 0; i < State.mCharacters.Length; i++)
+            {
+                State.mCharacters[i].Coordinates = State.Map.GetStartingPositionForPlayer(i + 1);
+            }
+            State.Entities = State.Map.GetAllEntities(this);
+        }
         public void LoadContent(ContentManager contentManager)
         {
+            mContentManager = contentManager;
+            menu = mContentManager.Load<SpriteFont>("menuFont");
+            
         }
 
         public void UnloadContent()
         {
         }
 
+        private int GetPlayerNumber(Object playerIdentifier)
+        {
+            for (int i = 0; i < mPlayerIdentifiers.Length; i++)
+            {
+                if (mPlayerIdentifiers[i] == playerIdentifier) return i;
+            }
+            throw new Exception("Illegal player identifier" + playerIdentifier);
+        }
+
         public Vector2 PreferredScreenSize
         {
             get { return new Vector2(800, 600); }
@@ -38,11 +322,84 @@ namespace CarFire
 
         public void ResetGame(object[] playerIdentifiers, object thisPlayer)
         {
+            int numPlayers = playerIdentifiers.Count();
+
+            mPlayerIdentifiers = new object[numPlayers];
+            for (int i = 0; i < numPlayers; i++) mPlayerIdentifiers[i] = playerIdentifiers[i];
+
+            mThisPlayerID = GetPlayerNumber(thisPlayer);
+
+            State = new GameState(numPlayers);
+            mInputs = new NextInputs(numPlayers);
+            State.mDisplay = new Display(this);
+            State.mDisplay.LoadContent(mContentManager);
+
+            // Load the tilemap.
+            Texture2D mapTiles = mContentManager.Load<Texture2D>("graphics/wallAndFloorTilesNoEdgeScale");
+            Tilemap tilemap = new Tilemap(mapTiles, 10, 7);
+            tilemap.SetTile(' ', new Point(4, 5), TileFlags.Default);
+            tilemap.SetTile('`', new Point(0, 1), TileFlags.Closed | TileFlags.Wall);
+            tilemap.SetTile('~', new Point(1, 1), TileFlags.Closed | TileFlags.Wall);
+            tilemap.SetTile('!', new Point(3, 1), TileFlags.Closed | TileFlags.Wall);
+            tilemap.SetTile('@', new Point(4, 1), TileFlags.Closed | TileFlags.Wall);
+            tilemap.SetTile('#', new Point(5, 1), TileFlags.Closed | TileFlags.Wall);
+            tilemap.SetTile('$', new Point(6, 1), TileFlags.Closed | TileFlags.Wall);
+            tilemap.SetTile('%', new Point(8, 1), TileFlags.Closed | TileFlags.Wall);
+            tilemap.SetTile('^', new Point(9, 1), TileFlags.Closed | TileFlags.Wall);
+            tilemap.SetTile('&', new Point(0, 2), TileFlags.Closed | TileFlags.Wall);
+            tilemap.SetTile('=', new Point(1, 2), TileFlags.Closed | TileFlags.Wall);
+            tilemap.SetTile('*', new Point(2, 2), TileFlags.Closed | TileFlags.Wall);
+            tilemap.SetTile('(', new Point(4, 2), TileFlags.Closed | TileFlags.Wall);
+            tilemap.SetTile(')', new Point(0, 3), TileFlags.Closed | TileFlags.Wall);
+            tilemap.SetTile('_', new Point(2, 3), TileFlags.Closed | TileFlags.Wall);
+            tilemap.SetTile('-', new Point(9, 3), TileFlags.Closed | TileFlags.Wall);
+            tilemap.SetTile(',', new Point(1, 4), TileFlags.Default);
+            tilemap.SetTile('+', new Point(2, 4), TileFlags.Default);
+            tilemap.SetTile('[', new Point(3, 4), TileFlags.Default);
+            tilemap.SetTile(']', new Point(4, 4), TileFlags.Default);
+            tilemap.SetTile('{', new Point(5, 4), TileFlags.Default);
+            tilemap.SetTile('}', new Point(6, 4), TileFlags.Default);
+            tilemap.SetTile('\\', new Point(8, 4), TileFlags.Default);
+            tilemap.SetTile('|', new Point(9, 4), TileFlags.Default);
+            tilemap.SetTile(';', new Point(0, 5), TileFlags.Default);
+            tilemap.SetTile(':', new Point(1, 5), TileFlags.Default);
+            tilemap.SetTile('\'', new Point(2, 5), TileFlags.Default);
+            tilemap.SetTile('"', new Point(3, 5), TileFlags.Default);
+            tilemap.SetTile('.', new Point(5, 5), TileFlags.Default);
+            tilemap.SetTile('<', new Point(6, 5), TileFlags.Default);
+            tilemap.SetTile('>', new Point(7, 5), TileFlags.Default);
+            tilemap.SetTile('/', new Point(8, 5), TileFlags.Default);
+            tilemap.SetTile('?', new Point(9, 5), TileFlags.Default);
+            Map.Tilemap = tilemap;
+
+            // Load the first map.
+            State.Map = mContentManager.Load<Map>("Maps/level1");
+            State.Entities = State.Map.GetAllEntities(this);
+
+            //State.AIData = new AI(this);
+
+            /*
+            mPlayers.Clear();
+            for (int i = 0; i < PlayerIdentifiers.Length; i++)
+            {
+                Human player = new Human(mMap, "");
+                mPlayers.Add(player);
+                mDisplay.AddCharacters(player);
+                mPlayers.Add(player);
+                mDisplay.AddCharacters(player);
+            }
+            this.playerIdentifiers = PlayerIdentifiers;
+            for (int i = 0; i < mPlayers.Count; i++) 
+            {
+                Point starting = mMap.GetStartingPositionForPlayer(i + 1);
+                mPlayers[i].Spawn(new Vector2(starting.X, starting.Y));
+            }
+            */
         }
 
         public long CurrentFrameNumber
         {
-            get { return 0; }
+            get { return State.FrameNumber; }
         }
 
         public long CurrentChecksum
@@ -52,36 +409,95 @@ namespace CarFire
 
         public void ApplyKeyInput(object playerIdentifier, Keys key, bool isKeyPressed)
         {
+            //code from Prof Jensen's TestHarness
+            int player = GetPlayerNumber(playerIdentifier);
+
+            if (isKeyPressed && !mInputs.KeysPressed[player].Contains(key))
+                mInputs.KeysPressed[player].Add(key);
+
+            if (!isKeyPressed && !mInputs.KeysReleased[player].Contains(key))
+                mInputs.KeysReleased[player].Add(key);
+           
         }
 
         public void ApplyMouseLocationInput(object playerIdentifier, int x, int y)
         {
+
         }
 
         public void ApplyMouseButtonInput(object playerIdentifier, bool isButtonPressed)
         {
+
         }
 
         public bool IsGameOver(object playerIdentifier)
         {
-            return true;
+            return false;
         }
 
         public bool IsTerminated(object playerIdentifier)
         {
-            return true;
+            return false;
         }
 
-        public long Update(TimeSpan timespan)
+        public long Update(TimeSpan elapsedTime)
         {
-            return CurrentFrameNumber;
+            State.AdvanceFrame(mInputs, elapsedTime.Milliseconds);  // Apply the inputs, advance game state.
+            State.mDisplay.Update(elapsedTime, mThisPlayerID);
+            State.Entities.ForEach(delegate(IEntity e) { e.Update(elapsedTime); });
+            mInputs = new NextInputs(State.NumberOfPlayers);  // Start with inputs cleared on the next frame.
+            //mDisplay.Update(elapsedTime);
+            return State.FrameNumber;
+           
         }
 
         public long Draw(SpriteBatch spriteBatch)
         {
+            bool allCharactersSelected = true;
+            for (int i = 0; i < State.NumberOfPlayers; i++)
+            {
+                //If player has not selected a player yet let them select one.
+                if (State.mCharacters[i] == null)
+                {
+                    allCharactersSelected = false;
+                    if (State.GetKeysDown(i).Contains(Keys.M))
+                    {
+                        State.mCharacters[i] = new Melee(this, "", State.Map.GetStartingPositionForPlayer(i + 1), i);
+                        State.mCharacters[i].LoadContent(mContentManager);
+                    }
+                    else if (State.GetKeysDown(i).Contains(Keys.R))
+                    {
+                        State.mCharacters[i] = new Ranged(this, "", State.Map.GetStartingPositionForPlayer(i + 1), i);
+                        State.mCharacters[i].LoadContent(mContentManager);
+                    }
+                }
+            }
+            if (allCharactersSelected)
+            {
+                
+                State.mDisplay.Draw(spriteBatch);
+            }
+            else
+            {
+                spriteBatch.GraphicsDevice.Clear(Color.Black);
+                spriteBatch.DrawString(menu, "Press R to select a Ranged Character and M to select a Melee Character", new Vector2(30, 30), Color.RosyBrown);
+            }
             return CurrentFrameNumber;
         }
 
         #endregion
+
+
+        #region Private Variables
+
+        SpriteFont menu;
+
+        ContentManager mContentManager;
+        NextInputs mInputs;
+
+        Object[] mPlayerIdentifiers;
+        int mThisPlayerID;
+
+        #endregion
     }
 }