From a716edefa6148bb1847b7029356d610a1886821f Mon Sep 17 00:00:00 2001
From: brady <brady@92bb83a3-7c8f-8a45-bc97-515c4e399668>
Date: Tue, 27 Apr 2010 06:32:44 +0000
Subject: [PATCH] Adding AI to monsters. AI still has some bugs to be worked
 out. Put it should compile and run.

git-svn-id: https://bd85.net/svn/cs3505_group@159 92bb83a3-7c8f-8a45-bc97-515c4e399668
---
 CarFire/CarFire/CarFire/AI.cs                 |   5 +-
 .../CarFire/Content/Content.contentproj       |  19 +-
 .../Content/Maps/colosseumClosed.cfmap        |  76 +++++
 CarFire/CarFire/CarFire/Game.cs               |  25 +-
 CarFire/CarFire/CarFire/IPlayer.cs            |   3 +
 CarFire/CarFire/CarFire/SaberMonster.cs       |  10 +-
 CarFire/CarFire/CarFire/SaberMonster2.cs      | 305 ++++++++++++++++++
 7 files changed, 429 insertions(+), 14 deletions(-)
 create mode 100644 CarFire/CarFire/CarFire/Content/Maps/colosseumClosed.cfmap
 create mode 100644 CarFire/CarFire/CarFire/SaberMonster2.cs

diff --git a/CarFire/CarFire/CarFire/AI.cs b/CarFire/CarFire/CarFire/AI.cs
index 8b8a25f..716b978 100644
--- a/CarFire/CarFire/CarFire/AI.cs
+++ b/CarFire/CarFire/CarFire/AI.cs
@@ -63,7 +63,10 @@ namespace CarFire
         {
             return regionList[regions[curX, curY]].VisibleRegions.Contains(regions[testX, testY]);
         }
-
+        public bool spaceVisible(Point Monster, Point Player )
+        {
+            return regionList[regions[Monster.X, Monster.Y]].VisibleRegions.Contains(regions[Player.X, Player.Y]);
+        }
         //find regions in map. these regions will be large groups of connected grid squares.
         public int setUpRegions()
         {
diff --git a/CarFire/CarFire/CarFire/Content/Content.contentproj b/CarFire/CarFire/CarFire/Content/Content.contentproj
index 971b516..ef3c88e 100644
--- a/CarFire/CarFire/CarFire/Content/Content.contentproj
+++ b/CarFire/CarFire/CarFire/Content/Content.contentproj
@@ -143,13 +143,6 @@
       <Processor>PassThroughProcessor</Processor>
     </Compile>
   </ItemGroup>
-  <ItemGroup>
-    <Compile Include="Maps\colosseum.cfmap">
-      <Name>colosseum</Name>
-      <Importer>MapImporter</Importer>
-      <Processor>PassThroughProcessor</Processor>
-    </Compile>
-  </ItemGroup>
   <ItemGroup>
     <Compile Include="graphics\blueDemonAttackDieStand.png">
       <Name>blueDemonAttackDieStand</Name>
@@ -302,6 +295,18 @@
       <Processor>TextureProcessor</Processor>
     </Compile>
   </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Maps\colosseum.cfmap">
+      <Name>colosseum</Name>
+      <Importer>MapImporter</Importer>
+      <Processor>PassThroughProcessor</Processor>
+    </Compile>
+    <Compile Include="Maps\colosseumClosed.cfmap">
+      <Name>colosseumClosed</Name>
+      <Importer>MapImporter</Importer>
+      <Processor>PassThroughProcessor</Processor>
+    </Compile>
+  </ItemGroup>
   <Import Project="$(MSBuildExtensionsPath)\Microsoft\XNA Game Studio\v3.0\Microsoft.Xna.GameStudio.ContentPipeline.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/CarFire/CarFire/CarFire/Content/Maps/colosseumClosed.cfmap b/CarFire/CarFire/CarFire/Content/Maps/colosseumClosed.cfmap
new file mode 100644
index 0000000..306e2ab
--- /dev/null
+++ b/CarFire/CarFire/CarFire/Content/Maps/colosseumClosed.cfmap
@@ -0,0 +1,76 @@
+; This map should load and function just fine.
+
+[metadata]
+	author = Chaz McGarvey
+	levelname = Colosseum
+	type = Battle
+	dimensions = [41,41]
+	tileset = FuturisticBuilding
+	numplayers = <1,4>
+
+[a]
+	type = SaberMonster2
+	speed = 7
+	create = [20,20] [31,31] [2,34] [22,4] [5,7] [18,18] [34,34] [4,20] [37,4] [6,37] [21,21] [21,30] [35,20]
+
+[b]
+	type = SaberMonster2
+	speed = 23
+	create = [0,4] [4,0]
+
+[e]
+	type = SaberMonster2
+	speed = 16
+	create = [40,4]
+
+[c]
+	type = SaberMonster2
+	speed = 5
+	create = [2,2] [20,20] [5,35] [21,34] [34,37] [37,15] [31,31] [2,34] [22,4]
+
+[d]
+	type = SaberMonster2
+
+[maptable]
++---------------------------------------+
+|"""               __              """  |
+|"1"              _  _             "2"  |
+|"""             _    _            """  |
+|   """""""""   _      _          "     |
+|d           "          _        "      |
+|             "          _      "       |
+|              "          _     "       |
+|           _   "          _    "       |
+|          _     "          _   "       |
+|         _       "          _  "       |
+|        _         "            "       |
+|       _           "          "        |
+|      _             "        "         |
+|     _               "      "   _      |
+|    _                 "    "     _     |
+|   _                   "  "       _    |
+|  _                     ""         _   |
+| _                      "           _  |
+|_                      "            _  |
+|_                     "            _   |
+| _                   ""           _    |
+|  _                 "  "         _     |
+|     """""""""""""""    "       _      |
+|    "                    "     _       |
+|   "                      "   _        |
+|   "  _                    "           |
+|   "   _                    "          |
+|   "    _                    "         |
+|   "     _                _   "        |
+|   "      _              _     "       |
+|   "       _            _       "      |
+|   "        _          _         "     |
+|   "         _        _          "     |
+|   "          _      _           "     |
+|"""            _    _             """  |
+|"4"             _  _              "3"  |
+|"""              __               """  |
+|                                       |
+|                                       |
++---------------------------------------+
+; vi:ft=dosini
diff --git a/CarFire/CarFire/CarFire/Game.cs b/CarFire/CarFire/CarFire/Game.cs
index 63ed26d..06aa494 100644
--- a/CarFire/CarFire/CarFire/Game.cs
+++ b/CarFire/CarFire/CarFire/Game.cs
@@ -31,7 +31,6 @@ namespace CarFire
         public List<Projectile> mProjectiles = new List<Projectile>();
         public Player[] mCharacters;
         public Display mDisplay;
-        public AI AIData;
         #endregion
 
 
@@ -422,10 +421,10 @@ namespace CarFire
             Map.Tilemap = tilemap;
 
             // Load the first map.
-            State.Map = mContentManager.Load<Map>("Maps/colosseum");
+            State.Map = mContentManager.Load<Map>("Maps/colosseumClosed");
             State.Entities = State.Map.GetAllEntities(this);
 
-            //State.AIData = new AI(this);
+            mAIData = new AI(this);
 
             /*
             mPlayers.Clear();
@@ -493,7 +492,23 @@ namespace CarFire
         {
             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); });
+            State.Entities.ForEach(delegate(IEntity e) 
+            {
+                IMonster m = e as IMonster;
+                if (m != null)
+                {
+                    if (State.mCharacters[0] != null && mAIData.spaceVisible(e.Coordinates, State.mCharacters[0].Coordinates))
+                    {
+                        m.Chasing(State.mCharacters[0].Coordinates);
+                    }
+                    else
+                    {
+                        m.DefaultAction();
+                    }
+                }
+                e.Update(elapsedTime); 
+            });
+            //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;
@@ -540,7 +555,7 @@ namespace CarFire
         #region Private Variables
 
         SpriteFont menu;
-
+        AI mAIData;
         ContentManager mContentManager;
         NextInputs mInputs;
 
diff --git a/CarFire/CarFire/CarFire/IPlayer.cs b/CarFire/CarFire/CarFire/IPlayer.cs
index 6f56cef..f858d1a 100644
--- a/CarFire/CarFire/CarFire/IPlayer.cs
+++ b/CarFire/CarFire/CarFire/IPlayer.cs
@@ -29,6 +29,9 @@ namespace CarFire
 
     public interface IMonster : ICharacter
     {
+        void DefaultAction();
+        void Chasing(Point Chase);
+        void StartPacing();
         bool visible { get; }
     }
 }
diff --git a/CarFire/CarFire/CarFire/SaberMonster.cs b/CarFire/CarFire/CarFire/SaberMonster.cs
index 69b42ca..a2b5aae 100644
--- a/CarFire/CarFire/CarFire/SaberMonster.cs
+++ b/CarFire/CarFire/CarFire/SaberMonster.cs
@@ -8,6 +8,7 @@ using Microsoft.Xna.Framework.Graphics;
 
 namespace CarFire
 {
+    /*
     /// <summary>
     /// A type for the states of an artificually intelligent entity.
     /// </summary>
@@ -20,7 +21,7 @@ namespace CarFire
         Fighting,
         Retreating
     }
-
+    */
 
     /// <summary>
     /// An example monster.  This can serve as a starting place for
@@ -72,7 +73,14 @@ namespace CarFire
             // Start doing something...
             StartPacing();
         }
+        public void DefaultAction()
+        {
+
+        }
+        public void Chasing(Point Chase)
+        {
 
+        }
 
         /// <summary>
         /// Call this to switch the monster AI state to pacing and set up
diff --git a/CarFire/CarFire/CarFire/SaberMonster2.cs b/CarFire/CarFire/CarFire/SaberMonster2.cs
new file mode 100644
index 0000000..f522ab4
--- /dev/null
+++ b/CarFire/CarFire/CarFire/SaberMonster2.cs
@@ -0,0 +1,305 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Content;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace CarFire
+{
+    /// <summary>
+    /// A type for the states of an artificually intelligent entity.
+    /// </summary>
+    public enum AiState
+    {
+        Standing,
+        Pacing,
+        Chasing,
+        Dazed,
+        Fighting,
+        Retreating
+    }
+
+
+    /// <summary>
+    /// An example monster.  This can serve as a starting place for
+    /// creating other monsters.  This one just follows a path.
+    /// </summary>
+    public class SaberMonster2 : IMonster
+    {
+        //starting health
+        int health = 100;
+        /// <summary>
+        /// Construct this type of monster.  This constructor is called
+        /// by the map when the game requests entities.
+        /// </summary>
+        /// <param name="identifier">The single character ID.</param>
+        /// <param name="position">The initial position on the map.</param>
+        /// <param name="info">More parameters.</param>
+        /// <param name="game">The game object reference.</param>
+        public SaberMonster2(char identifier, Point position, Dictionary<string, string> info, Game game)
+        {
+            mId = identifier;
+            mMotion = new MovementManager(position);
+
+            // We need to keep the game reference in order to get the grid when we
+            // need to find paths.
+            mGame = game;
+
+            pathFinder = null;
+
+            // Get the speed of the monster.  If not set in the map, it defaults to
+            // whatever the default of MovementManager is... 1 I think.
+            string speedString;
+            if (info.TryGetValue("speed", out speedString))
+            {
+                int? speed = Parse.Integer(speedString);
+                if (speed != null) mMotion.Speed = speed.Value;
+            }
+
+            // Get the "idle path" coordinates loaded from the map.
+            string idlePath;
+            if (info.TryGetValue("path", out idlePath))
+            {
+                string[] idlePathPoints = Parse.List(idlePath);
+                foreach (string pathPoint in idlePathPoints)
+                {
+                    Point? point = Parse.Coordinates(pathPoint);
+                    if (point != null) mIdlePath.Add(point.Value);
+                }
+            }
+            // Start doing something...
+            //StartPacing();
+        }
+
+        public void DefaultAction()
+        {
+            mState = AiState.Standing;
+        }
+
+        public void Chasing(Point Chase)
+        {
+            Chasing(Chase.X, Chase.Y);
+        }
+
+        /// <summary>
+        /// Call this to switch the monster AI state to Chasing and set up
+        /// the initial paths.  A path to .
+        /// </summary>
+        public void Chasing(int X, int Y)
+        {
+            mState = AiState.Chasing;
+
+            // Determine the best (closest) waypoint to start at.
+            // We may not be on the path, so we have to walk to get on it.
+            /*
+            mIdlePathIndex = 0;
+            int closest = int.MaxValue;
+            for (int i = 0; i < mIdlePath.Count; i++)
+            {
+                int distance = PathFinder.GetManhattanDistance(Coordinates, mIdlePath[i]);
+                if (distance < closest)
+                {
+                    mIdlePathIndex = i;
+                    closest = distance;
+                }
+            }
+             */
+
+            // Find the path to get to the closest waypoint.
+            if (pathFinder == null)
+                pathFinder = new PathFinder(mGame.Grid);
+
+            mPath = new List<Point>(32);
+            mPath.Add(Coordinates);
+            List<Point> path = pathFinder.GetPath(mMotion.Coordinates, new Point(X,Y));
+            if (path != null)
+            {
+                mPath.AddRange(path);
+                //mPath.Add(mIdlePath[mIdlePathIndex]);
+            }
+            mPathIndex = 0;
+        }
+
+        /// <summary>
+        /// Call this to switch the monster AI state to pacing and set up
+        /// the initial paths.  The monster will start following the path it
+        /// was defined with in the map file.
+        /// </summary>
+        public void StartPacing()
+        {
+            mState = AiState.Pacing;
+
+            if (mIdlePath.Count == 0) return;
+
+            // Determine the best (closest) waypoint to start at.
+            // We may not be on the path, so we have to walk to get on it.
+            mIdlePathIndex = 0;
+            int closest = int.MaxValue;
+            for (int i = 0; i < mIdlePath.Count; i++)
+            {
+                int distance = PathFinder.GetManhattanDistance(Coordinates, mIdlePath[i]);
+                if (distance < closest)
+                {
+                    mIdlePathIndex = i;
+                    closest = distance;
+                }
+            }
+
+            // Find the path to get to the closest waypoint.
+            PathFinder pathFinder = new PathFinder(mGame.Grid);
+            mPath = new List<Point>(32);
+            mPath.Add(Coordinates);
+            List<Point> path = pathFinder.GetPath(mMotion.Coordinates, mIdlePath[mIdlePathIndex]);
+            if (path != null)
+            {
+                mPath.AddRange(path);
+                mPath.Add(mIdlePath[mIdlePathIndex]);
+            }
+            mPathIndex = 0;
+        }
+
+        Direction GetDirectionToNextCell()
+        {
+            if (mPathIndex >= mPath.Count)
+            {
+                mState = AiState.Standing;
+            }
+
+            // We need to make sure out direction is set to the next cell
+            // we want to be.  If our current coordinates match that, we need
+            // to change our direction to get to the next cell.
+            if (mPath[mPathIndex % mPath.Count] == mMotion.Coordinates)
+            {
+                mPathIndex++;
+                mPathDirection = MovementManager.GetDirection(mMotion.Coordinates, mPath[mPathIndex % mPath.Count]);
+            }
+
+            return mPathDirection;
+        }
+
+
+        #region IMonster Members
+
+        /// <summary>
+        /// I don't know what this is for.
+        /// </summary>
+        public bool visible
+        {
+            get { throw new NotImplementedException(); }
+        }
+
+        #endregion
+
+
+        #region ICharacter Members
+
+        /// <summary>
+        /// Load the monster's content.  This is called by the map when
+        /// the game requests the entities.
+        /// </summary>
+        /// <param name="contentManager">The zaphnod.</param>
+        public void LoadContent(ContentManager contentManager)
+        {
+            mTexture = contentManager.Load<Texture2D>("menuItem");
+        }
+
+        /// <summary>
+        /// Update the monster's state.  This should be called by the game
+        /// every "frame" (whenever the game is updating its state).  In this
+        /// simple monster, all we need to do is update the motion manager.
+        /// </summary>
+        /// <param name="timeSpan"></param>
+        public void Update(TimeSpan timeSpan)
+        {
+            switch (mState)
+            {
+                case AiState.Pacing:
+                case AiState.Chasing:
+                    mMotion.Update(timeSpan, GetDirectionToNextCell());
+                    break;
+                case AiState.Standing:
+                case AiState.Dazed:
+                case AiState.Fighting:
+                case AiState.Retreating:
+                    break;
+                    
+            }
+        }
+
+        /// <summary>
+        /// Draw the monster.  We just ask the map for our screen position,
+        /// passing it the position which the motion manager keeps track of.
+        /// </summary>
+        /// <param name="spriteBatch">The </param>
+        public void Draw(SpriteBatch spriteBatch)
+        {
+            Rectangle position = mGame.State.Map.GetRectangleFromCoordinates(mMotion.Position);
+            spriteBatch.Draw(mTexture, position, Color.White);
+        }
+
+        /// <summary>
+        /// A monster should keep track of its health.  This one doesn't.
+        /// </summary>
+        public int Health
+        {
+            get { return this.health; }
+            
+        }
+
+        /// <summary>
+        /// This monster is invincible.
+        /// </summary>
+        /// <param name="amount"></param>
+        public void causeDamageTo(int amount)
+        {
+            this.health -= amount;
+        }
+
+        public bool IsCollidable { get { return true; } }
+
+        /// <summary>
+        /// Get the smoothed position.
+        /// </summary>
+        public Vector2 Position { get { return mMotion.Position; } }
+
+        /// <summary>
+        /// Get the grid coordinates.
+        /// </summary>
+        public Point Coordinates {
+            get { return mMotion.Coordinates; }
+            set { mMotion = new MovementManager(value, mMotion.Speed); }
+        }
+
+        /// <summary>
+        /// Get the entity identifier.
+        /// </summary>
+        public char Identifier { get { return mId; } }
+
+        #endregion
+
+
+        #region Private Variables
+
+        Game mGame;
+
+        char mId;
+        MovementManager mMotion;
+
+        PathFinder pathFinder;
+        List<Point> mIdlePath = new List<Point>();      // List of waypoints that we got from the map.
+        int mIdlePathIndex;                             // Index to the waypoint we're heading for.
+
+        List<Point> mPath;              // List of cells in the path between the position between where
+                                        // we started and the waypoint we're heading for.
+        int mPathIndex;                 // Index to the cell we're heading for.
+        Direction mPathDirection;       // The direction between our current position and the place we're going.
+
+        AiState mState;                 // What is the monster doing?
+
+        Texture2D mTexture;             // Obvious.
+
+        #endregion
+    }
+}
-- 
2.43.0