So let’s look at the code for our main Class that our First Person will inherit from.

using System;

using Microsoft.Xna.Framework;

using GameEngine;
using GameEngine.Utilities;

using GameEngine.Components;

namespace GameEngine.Cameras

{

  public class Camera : Component, I3DComponent
    {

  Vector3 position = Vector3.Zero;
  Matrix rotationMatrix = Matrix.Identity;
  Vector3 target = new Vector3(0, 0, -1);
  Vector3 up = Vector3.Up;
        Matrix view;

        Matrix projection;

        /// <summary>

        /// Gets or sets the target.

        /// </summary>

        /// <value>

        /// The target.

        /// </value>

  public virtual Vector3 Target
        { get { return target; } set { target = value; } }

        /// <summary>

        /// Gets or sets the view.

        /// </summary>

        /// <value>

        /// The view.

        /// </value>

        public virtual Matrix View

        { get { return view; } set { view = value; } }

        /// <summary>

        /// Gets or sets the projection.

        /// </summary>

        /// <value>

        /// The projection.

        /// </value>

        public virtual Matrix Projection

        { get { return projection; } set { projection = value; } }

        /// <summary>

        /// Gets or sets up.

        /// </summary>

        /// <value>

        /// Up.

        /// </value>

  public virtual Vector3 Up
        { get { return up; } set { up = value; } }

        /// <summary>

  /// Gets or sets the position.
        /// </summary>

        /// <value>

  /// The position.
        /// </value>

  public virtual Vector3 Position { get { return position; } set { position = value; } } 

        /// <summary>

        /// Gets or sets the scale.

        /// </summary>

        /// <value>

        /// The scale.

        /// </value>

  public virtual Vector3 Scale { get { return Vector3.One; } set { } } 

        /// <summary>

        /// Gets or sets the rotation.

        /// </summary>

        /// <value>

        /// The rotation.

        /// </value>

        public virtual Matrix Rotation

        {

  get { return rotationMatrix;}
  set{rotationMatrix = value;}
        }

        /// <summary>

  /// Gets or sets the euler rotation.
        /// </summary>

        /// <value>

  /// The euler rotation.
        /// </value>

  public Vector3 EulerRotation
        {

            get{return MathUtil.MatrixToVector3(Rotation);}

            set { rotationMatrix = MathUtil.Vector3ToMatrix(value);}

        }

        /// <summary>

        /// Gets the bounding box.

        /// </summary>

  public virtual BoundingBox BoundingBox
  {get {return new BoundingBox(Position - Vector3.One, Position + Vector3.One);}} 

        /// <summary>

  /// Initializes a new instance of the class.
        /// </summary>

        /// <param name="Parent">The parent.</param>

  public Camera(GameScreen Parent) : base(Parent) { }
        /// <summary>

  /// Initializes a new instance of the class.
        /// </summary>

        public Camera() : base() { }

        /// <summary>

        /// Updates this instance.

        /// </summary>

        public override void Update()

        {

  Vector3 newForward = Target - Position;
            newForward.Normalize();

  Matrix rotationMatrixCopy = this.Rotation;
            rotationMatrixCopy.Forward = newForward;

  Vector3 referenceVector = Vector3.Up;
  if (rotationMatrixCopy.Forward.Y == referenceVector.Y || rotationMatrixCopy.Forward.Y == -referenceVector.Y)
  referenceVector = Vector3.Backward; 

            rotationMatrixCopy.Right = Vector3.Cross(this.Rotation.Forward, referenceVector);

            rotationMatrixCopy.Up = Vector3.Cross(this.Rotation.Right, this.Rotation.Forward);

            this.Rotation = rotationMatrixCopy;

            Up = Rotation.Up;

            View = Matrix.CreateLookAt(Position, Target, Up);

            Projection = MathUtil.CreateProjectionMatrix();

        }

    }

}

So next lets look at our First Person Camera this class is very simple really as most of the work is done in the Camera Class.

using Microsoft.Xna.Framework;

using System;

using GameEngine.Components;

using GameEngine.Utilities;

namespace GameEngine.Cameras{

    // A simple first person camera. Accepts rotation and translation

  public class FPSCamera : Camera
    {

        // Keeps track of the rotation and translation that have been

  // added via RotateTranslate()
        Vector3 rotation;        

        Vector3 translation;  

  public FPSCamera(GameScreen Parent) : base(Parent) { }
  public FPSCamera() : base() { } 

        // This adds to rotation and translation to change the camera view

  public void RotateTranslate(Vector3 Rotation, Vector3 Translation)
        {

            translation += Translation;

            rotation += Rotation;

        }

        public override void Update()

        {

            // Update the rotation matrix using the rotation vector

            Rotation = MathUtil.Vector3ToMatrix(rotation);

  // Update the position in the direction of rotation
            translation = Vector3.Transform(translation, Rotation);

            Position += translation;

            // Reset translation

            translation = Vector3.Zero;

            // Calculate the new target

            Target = Vector3.Add(Position, Rotation.Forward);

            // Have the base Camera update all the matrices, etc.

            base.Update();

        }

    }

}

So that our Main camera class and our First Person Camera created
Will try and get the next post up a bit sooner that this one.

So Lets have a look at out first new class it’s called MathUtil.

The Class will have the following function,

• CreateProjectionMatrix  - Generates a projection matrix for a draw call
• CreateWorldMatrix – Creates a world matrix
• Vector3ToMatrix – Converts a rotation vector into a rotation matrix
• MatrixToVector3 – Converts a rotation matrix into a rotation vector

So here the code for our MathUtil class.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;
using GameEngine;

namespace GameEngine.Utilities
{
    public static class MathUtil
    {

        /// <summary>
        /// Creates the projection matrix.
        /// </summary>
        /// <returns></returns>
        public static Matrix CreateProjectionMatrix()
        {
            return Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver4,
                (float)Engine.GraphicsDevice.Viewport.Width / (float)Engine.GraphicsDevice.Viewport.Height,
                .01f,
                1000000);
        }

        /// <summary>
        /// Creates the world matrix.
        /// </summary>
        /// <param name="Translation">The translation.</param>
        /// <returns></returns>
        public static Matrix CreateWorldMatrix(Vector3 Translation)
        {
            return CreateWorldMatrix(Translation, Matrix.Identity);
        }

        /// <summary>
        /// Creates the world matrix.
        /// </summary>
        /// <param name="Translation">The translation.</param>
        /// <param name="Rotation">The rotation.</param>
        /// <returns></returns>
        public static Matrix CreateWorldMatrix(Vector3 Translation, Matrix Rotation)
        {
            return CreateWorldMatrix(Translation, Rotation, Vector3.One);
        }

        /// <summary>
        /// Creates the world matrix.
        /// </summary>
        /// <param name="Translation">The translation.</param>
        /// <param name="Rotation">The rotation.</param>
        /// <param name="Scale">The scale.</param>
        /// <returns></returns>
        public static Matrix CreateWorldMatrix(Vector3 Translation, Matrix Rotation, Vector3 Scale)
        {
            return Matrix.CreateScale(Scale) * Rotation * Matrix.CreateTranslation(Translation);
        }

        /// <summary>
        /// Vector3s to matrix.
        /// </summary>
        /// <param name="Rotation">The rotation.</param>
        /// <returns></returns>
        public static Matrix Vector3ToMatrix(Vector3 Rotation)
        {
            return Matrix.CreateFromYawPitchRoll(Rotation.Y, Rotation.X, Rotation.Z);
        }

        /// <summary>
        /// Matrixes to vector3.
        /// </summary>
        /// <param name="Rotation">The rotation.</param>
        /// <returns></returns>
        public static Vector3 MatrixToVector3(Matrix Rotation)
        {
            Quaternion q = Quaternion.CreateFromRotationMatrix(Rotation);
            return new Vector3(q.X, q.Y, q.Z);
        }
    }
}

Next we are going to Add a Class to help with some graphic stuff, can you guess what we are going to call it? thats right GraphicsUtil

The Class will have the following function,

• CreateRenderTarget – This function is going to have multiple signatures within out Class

So here’s the code.

using Microsoft.Xna.Framework.Graphics;
using GameEngine;

namespace GameEngine.Utilities
{
    public static class GraphicsUtil
    {

        /// <summary>
        /// Creates the render target.
        /// </summary>
        /// <returns></returns>
        public static RenderTarget2D CreateRenderTarget()
        {
            return CreateRenderTarget(Engine.GraphicsDevice.Viewport.Width,
                Engine.GraphicsDevice.Viewport.Height);
        }

        /// <summary>
        /// Creates the render target.
        /// </summary>
        /// <param name="Width">The width.</param>
        /// <param name="Height">The height.</param>
        /// <returns></returns>
        public static RenderTarget2D CreateRenderTarget(int Width, int Height)
        {
            return CreateRenderTarget(Width, Height,
                Engine.GraphicsDevice.DisplayMode.Format);
        }

        /// <summary>
        /// Creates the render target.
        /// </summary>
        /// <param name="Width">The width.</param>
        /// <param name="Height">The height.</param>
        /// <param name="Format">The format.</param>
        /// <returns></returns>
        public static RenderTarget2D CreateRenderTarget(int Width, int Height,
            SurfaceFormat Format)
        {
            return CreateRenderTarget(Width, Height, Format,
                Engine.GraphicsDevice.PresentationParameters.MultiSampleCount,
                Engine.GraphicsDevice.PresentationParameters.DepthStencilFormat);
        }

        /// <summary>
        /// Creates the render target.
        /// </summary>
        /// <param name="Width">The width.</param>
        /// <param name="Height">The height.</param>
        /// <param name="Format">The format.</param>
        /// <param name="MultiSampleQuality">The multi sample quality.</param>
        /// <param name="SampleType">Type of the sample.</param>
        /// <returns></returns>
        public static RenderTarget2D CreateRenderTarget(int Width, int Height,
            SurfaceFormat Format, int MultiSampleQuality, DepthFormat SampleType)
        {
            return new RenderTarget2D(Engine.GraphicsDevice, Width,
                Height, false, Format, SampleType, MultiSampleQuality,
                RenderTargetUsage.DiscardContents);
        }

        /// <summary>
        /// Creates the resolve texture.
        /// </summary>
        /// <returns></returns>
        public static RenderTarget2D CreateResolveTexture()
        {
            return new RenderTarget2D(Engine.GraphicsDevice,
                Engine.GraphicsDevice.Viewport.Width,
                Engine.GraphicsDevice.Viewport.Height, false,
                Engine.GraphicsDevice.DisplayMode.Format,
                Engine.GraphicsDevice.PresentationParameters.DepthStencilFormat,
                Engine.GraphicsDevice.PresentationParameters.MultiSampleCount,
                RenderTargetUsage.DiscardContents);
        }
    }
}

That’s it for this post.

I have my engine 90% complete now after a hard push over the holidays, so am hoping to get some more posts written this week and get them up.

Well let’s jump right in, Finite State Machines or FSMs have for many years been the AI coder’s first choice to create the illusion of intelligence but FSMs are not just used in games AI I have even found then in database APIs.

Here is the best description of a FSM I have found.

If you looking for more information on FMS then I really recommend the book Programming Game AI by Example, this book is based on C++ but the code can easily be transferred to C#.

So let’s start writing some code in Visual Studio creates two projects one Console Application called OrcTest and one Class Library called Ai.

So we are going to start by creating a class called StateTransitionTable.cs in the Ai project.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Text;

namespace Ai
{
    abstract public class StateTransitionTable
    {
        protected Dictionary<object, IState> table = new Dictionary<object, IState>();

        public void SetState(object evt, IState state)
        {
            table.Add(evt, state);
        }

        public IState GetState(object evt)
        {
            Ai.IState i = null;

            try
            {
                i = table[evt];

            }
            catch (KeyNotFoundException)
            {
                return null;
            }

            return i;
        }
    }
}

Next we are going to create a new class file with our Interface code that each state will inherit from and I called the file IState.cs

using System;
using System.Collections.Generic;
using System.Text;

namespace Ai
{
    public interface IState
    {
         void Enter(Entity e);
         void Execute(Entity e);
         void Exit(Entity e);
    }
}

And last but not least we will create one more file called Entity.

using System;
using System.Collections.Generic;
using System.Text;

namespace Ai
{
    abstract public class Entity
    {
        protected static Ai.StateTransitionTable transitionTable = null;
        protected IState currentState = null;

        public void UpdateState()
        {
            if (currentState != null)
                currentState.Execute(this);
            else
                System.Diagnostics.Trace.WriteLine("zero state");
        }

        public object Event
        {
            set
            {
                if (value == null)
                {
                    currentState.Exit(this);
                    currentState = null;
                    return;
                }

                IState i = transitionTable.GetState(value);

                if (i != null)
                {
                    if (currentState != null)
                        currentState.Exit(this);

                    currentState = i;
                    currentState.Enter(this);
                }
            }
        }
    }
}

Now we have our base code it’s time to write our State, in this system am going to create 4 states.

• AttackState
• FleeState
• IdleState
• PatrolState

I am only going to show you one state file as all 4 States are the same.

using System;
using System.Collections.Generic;
using System.Text;

namespace Ai
{
    public class AttackState : Ai.IState
    {
        public virtual void Enter(Entity e)
        {
            throw new NotImplementedException();
        }

        public virtual void Execute(Entity e)
        {
            throw new NotImplementedException();
        }

        public virtual void Exit(Entity e)
        {
            throw new NotImplementedException();
        }
    }
}

So that’s our FSM setup next we are going to use is it in our OrcTest application.

So we will start by creating a class call Orc.css and add this code

using System;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;
using Ai;

namespace OrcTest
{
    enum OrcEvent
    {
        Idle,
        Patrol,
        Attack,
        Flee,
    }

    class OrcTransitionTable : Ai.StateTransitionTable
    {
        public OrcTransitionTable()
        {
            base.table.Add(OrcEvent.Idle, new IdleState());
            base.table.Add(OrcEvent.Patrol, new PatrolState());
            base.table.Add(OrcEvent.Attack, new AttackState());
            base.table.Add(OrcEvent.Flee, new FleeState());
        }
    }

    class Orc : Ai.Entity
    {
        private int _piss;

        public int Piss
        {
            get { return _piss; }
            set { _piss = value; }
        }
        static Orc()
        {
            transitionTable = new OrcTransitionTable();
        }
    }
}

Next we will modify the Program.cs file with the following code.

using System;
using System.Collections.Generic;
using System.Text;

namespace OrcTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Orc o = new Orc();

            o.Event = OrcEvent.Idle;
            o.UpdateState();

            o.Event = OrcEvent.Patrol;
            o.UpdateState();

            o.Event = OrcEvent.Attack;
            o.UpdateState();

            o.Event = OrcEvent.Flee;
            o.UpdateState();

            o.Event = null;
            o.UpdateState();

            Console.ReadLine();
        }
    }

}

So next we are going to override the states we created earlier will Orc states

Again I will just show you one as they are all basically the same.

using System;
using System.Collections.Generic;
using System.Text;
using Ai;

namespace OrcTest
{
    class AttackState: Ai.AttackState
    {
            public override void Enter(Ai.Entity e)
            {
                Console.WriteLine("Enter Attack State");
            }

            public override void Execute(Ai.Entity e)
            {
                Console.WriteLine("In Attack State");
            }

            public override void Exit(Ai.Entity e)
            {
                Console.WriteLine("Exit Attack State");
            }
        }
    }

And that’s it we have a basic FSM.

Hope you liked to post feel free to comment

But dont fear I have a Part 6  in the pipeline and a mini tutorial on Finite-state machine coming up this week.

I am using mstest that comes built into visual studio 2010, you could also use nunit if you wished or any unit test framework that works with .net.

Am normally very lazy with it comes to unit tests at work I never write them unless I am made to which is really bad of me I know this and every other programmer know it as well that we should be using unit test to make our coding better but its hard to fit them in when your working to a deadline.

So I thought  I would include some in this.

Lets Start by creating a new unit test project and calling it EngineTests

Lest remane the Class UnitTest1.cs to EngineTest.cs and add the following code.

using Engine;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using Microsoft.Xna.Framework;
using Engine.Components;
using Microsoft.Xna.Framework.Graphics;

namespace EngineTests
{

    /// <summary>
    ///This is a test class for EngineTest and is intended
    ///to contain all EngineTest Unit Tests
    ///</summary>
    [TestClass()]
    public class EngineTest : Game
    {

        private TestContext testContextInstance;

        /// <summary>
        ///Gets or sets the test context which provides
        ///information about and functionality for the current test run.
        ///</summary>
        public TestContext TestContext
        {
            get
            {
                return testContextInstance;
            }
            set
            {
                testContextInstance = value;
            }
        }
        Game game = new Game();
        GraphicsDeviceManager graphics;
        GraphicsDevice device;

        //Use TestInitialize to run code before running each test
        [TestInitialize()]
        public void EngineSetup()
        {
            graphics = new GraphicsDeviceManager(game);
            graphics.PreferredBackBufferWidth = 500;
            graphics.PreferredBackBufferHeight = 500;
            graphics.IsFullScreen = false;
            graphics.ApplyChanges();
            device = graphics.GraphicsDevice;
            device.Clear(Color.CornflowerBlue);
            Engine.Engine.SetupEngine(graphics);
        }
    }
}

So this will set up a new engine that the rest of our test will use to run.

Next we will add some tests for the GameScreen class.

using Engine.GameScreens;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using Engine.Components;

namespace EngineTests
{

    /// <summary>
    ///This is a test class for GameScreenTest and is intended
    ///to contain all GameScreenTest Unit Tests
    ///</summary>
    [TestClass()]
    public class GameScreenTest
    {

        private TestContext testContextInstance;

        /// <summary>
        ///Gets or sets the test context which provides
        ///information about and functionality for the current test run.
        ///</summary>
        public TestContext TestContext
        {
            get
            {
                return testContextInstance;
            }
            set
            {
                testContextInstance = value;
            }
        }

        /// <summary>
        ///A test for GameScreen Constructor
        ///</summary>
        [TestMethod()]
        public void GameScreenConstructorTest()
        {
            string Name = "TESTSCREEN";
            GameScreen target = new GameScreen(Name);
            Assert.IsNotNull(target);
        }

        /// <summary>
        ///A test for Disable
        ///</summary>
        [TestMethod()]
        public void DisableTest()
        {
            string Name = "TESTSCREEN1";
            GameScreen target = new GameScreen(Name);
            target.Disable();
            Assert.IsNotNull(target);
        }

        /// <summary>
        ///A test for Initialize
        ///</summary>
        [TestMethod()]
        public void InitializeTest()
        {
            string Name = "TESTSCREEN3";
            GameScreen target = new GameScreen(Name);
            target.Initialize();
            Assert.AreEqual(target.Initialized, true);
        }

        /// <summary>
        ///A test for ToString
        ///</summary>
        [TestMethod()]
        public void ToStringTest()
        {
            string Name = "TESTSCREEN4";
            GameScreen target = new GameScreen(Name);
            string expected = "TESTSCREEN4";
            string actual;
            actual = target.ToString();
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///A test for Initialized
        ///</summary>
        [TestMethod()]
        public void InitializedTest()
        {
            string Name = "TESTSCREEN6";
            GameScreen target = new GameScreen(Name);
            bool expected = true;
            bool actual;
            target.Initialized = expected;
            actual = target.Initialized;
            Assert.AreEqual(expected, actual);
        }
    }
}

Next some test for the GameSceenCollection

using Engine.GameScreens;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;

namespace EngineTests
{

    /// <summary>
    ///This is a test class for GameScreenCollectionTest and is intended
    ///to contain all GameScreenCollectionTest Unit Tests
    ///</summary>
    [TestClass()]
    public class GameScreenCollectionTest
    {

        private TestContext testContextInstance;

        /// <summary>
        ///Gets or sets the test context which provides
        ///information about and functionality for the current test run.
        ///</summary>
        public TestContext TestContext
        {
            get
            {
                return testContextInstance;
            }
            set
            {
                testContextInstance = value;
            }
        }

        /// <summary>
        ///A test for GameScreenCollection Constructor
        ///</summary>
        [TestMethod()]
        public void GameScreenCollectionConstructorTest()
        {
            GameScreenCollection target = new GameScreenCollection();
            Assert.IsNotNull(target);
        }

        /// <summary>
        ///A test for GetKeyForItem
        ///</summary>
        [TestMethod()]
        [DeploymentItem("Engine.dll")]
        public void GetKeyForItemTest()
        {
            GameScreenCollection_Accessor target = new GameScreenCollection_Accessor();
            GameScreen item = new GameScreen("TESTSCREEN7");
            string expected = "TESTSCREEN7";
            string actual;
            actual = target.GetKeyForItem(item);
            Assert.AreEqual(expected, actual);
        }
    }
}

And finally our Component class tests

using Engine.Components;

using Microsoft.VisualStudio.TestTools.UnitTesting;

using System;

using Engine.GameScreens;

using Microsoft.Xna.Framework;

using Microsoft.Xna.Framework.Graphics;

namespace EngineTests

{

    /// <summary>

    ///This is a test class for ComponentTest and is intended

    ///to contain all ComponentTest Unit Tests

    ///</summary>

    [TestClass()]

    public class ComponentTest

    {
        private TestContext testContextInstance;
        /// <summary>

        ///Gets or sets the test context which provides

        ///information about and functionality for the current test run.

        ///</summary>

        public TestContext TestContext

        {

            get

            {

                return testContextInstance;

            }

            set

            {

                testContextInstance = value;

            }

        }
        Game game = new Game();

        GraphicsDeviceManager graphics;

        GraphicsDevice device;
        //Use TestInitialize to run code before running each test

        [TestInitialize()]

        public void MyTestInitialize()

        {

            graphics = new GraphicsDeviceManager(game);

            graphics.PreferredBackBufferWidth = 500;

            graphics.PreferredBackBufferHeight = 500;

            graphics.IsFullScreen = false;

            graphics.ApplyChanges();

            device = graphics.GraphicsDevice;

            device.Clear(Color.CornflowerBlue);

            Engine.Engine.SetupEngine(graphics);

        }
        /// <summary>

        ///A test for InitializeComponent

        ///</summary>

        [TestMethod()]

        [DeploymentItem("Engine.dll")]

        public void InitializeComponentTest()

        {

            Component_Accessor target = new Component_Accessor(new GameScreen("TESTSCREEN8"));

            GameScreen Parent = new GameScreen("TESTSCREEN9");
]]>
			http://spinneretdesign.com/2011/11/26/part-5-adding-unit-tests/feed/
		0
		
		
		
		http://spinneretdesign.com/2011/11/26/part-4-the-engine/
		http://spinneretdesign.com/2011/11/26/part-4-the-engine/#comments
		Sat, 26 Nov 2011 18:16:00 +0000
		Jardeth56
				
		

		http://spinneretdesign.com/?p=688
		
			Well I know its only been a couple of hours since my last post but since we haven’t really got anything working yet and there is errors in the code due to missing classes, I thought I would get this one up as soon as possible.

 
So lets get started.
The Engine Class this is the main class of the engine so I have named it Engine as I thought that was the most logical name.
Lets start by adding a new class called engine to the root of our folder structure.
Here is the starting code
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Engine.Components;
using Engine.Services;
using Engine.GameScreens;

namespace Engine
{
    public static class Engine
    {

        public static GraphicsDevice GraphicsDevice;
        public static SpriteBatch SpriteBatch;
        public static GameScreenCollection GameScreens = new GameScreenCollection();
        public static GameTime GameTime;
        public static bool IsInitialized = false;
        public static IEServiceContainer Services;
        public static IEContentManager Content;
        public static GameScreen BackgroundScreen;
        public static GameScreen DefaultScreen;

        /// <summary>
        /// Setups the engine.
        /// </summary>
        /// <param name="GraphicsDeviceService">The graphics device service.</param>
        public static void SetupEngine(IGraphicsDeviceService GraphicsDeviceService)
        {

            Engine.GraphicsDevice = GraphicsDeviceService.GraphicsDevice;
            Engine.SpriteBatch = new SpriteBatch(GraphicsDeviceService.GraphicsDevice);

            Engine.IsInitialized = true;

            Engine.Services = new IEServiceContainer();
            Engine.Services.AddService(typeof(IGraphicsDeviceService), GraphicsDeviceService);

            Engine.Content = new IEContentManager(Services);

            BackgroundScreen = new GameScreen("Engine.BackgroundScreen");
            BackgroundScreen.OverrideUpdateBlocked = true;
            BackgroundScreen.OverrideDrawBlocked = true;
            BackgroundScreen.OverrideInputBlocked = true;

            DefaultScreen = BackgroundScreen;
        }

        /// <summary>
        /// Updates the specified game time.
        /// </summary>
        /// <param name="gameTime">The game time.</param>
        public static void Update(GameTime gameTime)
        {
            Engine.GameTime = gameTime;
            List<GameScreen> updating = new List<GameScreen>();
            foreach (GameScreen screen in GameScreens)
                updating.Add(screen);
            for (int i = GameScreens.Count - 1; i >= 0; i--)
                if (GameScreens[i].BlocksUpdate)
                {
                    if (i > 0)
                        for (int j = i - 1; j >= 0; j--)
                            if (!GameScreens[j].OverrideUpdateBlocked)
                                updating.Remove(GameScreens[j]);

                    break;
                }

            foreach (GameScreen screen in updating)
                if (screen.Initialized)
                    screen.Update();

            updating.Clear();

            foreach (GameScreen screen in GameScreens)
                updating.Add(screen);

            for (int i = GameScreens.Count - 1; i >= 0; i--)
                if (GameScreens[i].BlocksInput)
                {
                    if (i > 0)
                        for (int j = i - 1; j >= 0; j--)
                            if (!GameScreens[j].OverrideInputBlocked)
                                updating.Remove(GameScreens[j]);

                    break;
                }

            foreach (GameScreen screen in GameScreens)
                if (!screen.InputDisabled)
                    screen.IsInputAllowed = updating.Contains(screen);
                else
                    screen.IsInputAllowed = false;
        }

        /// <summary>
        /// Draws the specified game time.
        /// </summary>
        /// <param name="gameTime">The game time.</param>
        /// <param name="RenderType">Type of the render.</param>
        public static void Draw(GameTime gameTime, ComponentType RenderType)
        {
            Engine.GameTime = gameTime;
            List<GameScreen> drawing = new List<GameScreen>();

            GraphicsDevice.Clear(Color.CornflowerBlue);

            foreach (GameScreen screen in GameScreens)
                if (screen.Visible)
                    drawing.Add(screen);

            for (int i = GameScreens.Count - 1; i >= 0; i--)
                if (GameScreens[i].BlocksDraw)
                {
                    if (i > 0)
                        for (int j = i - 1; j >= 0; j--)
                        {
                            if (!GameScreens[j].OverrideDrawBlocked)
                                drawing.Remove(GameScreens[j]);
                        }

                    break;
                }

            foreach (GameScreen screen in drawing)
                if (screen.Initialized)
                    screen.Draw(RenderType);
        }
    }
}
So by adding this code to our engine we have got ride of all our error and got 8 new ones but that’s ok we will get rid of then by the end of this tutorial.

The main difference  between this class and the other class we have created so far is that we don’t have to instantiate it, instead we can get its members using Engine.MemberName.

Next we will add a new class that Implements IServiceProvider. This is a object that will keep track Service providers by inheriting from IServiceProvider.
So with in the Services folder in our solution add a new class called IEServiceContainer.
So here is the code
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;

namespace Engine.Services
{
    public class IEServiceContainer : IServiceProvider
    {

        Dictionary<Type, object> services = new Dictionary<Type, object>();

        /// <summary>
        /// Adds the service.
        /// </summary>
        /// <param name="Service">The service.</param>
        /// <param name="Provider">The provider.</param>
        public void AddService(Type Service, object Provider)
        {
            if (services.ContainsKey(Service))
                throw new Exception("The service container already has a service provider of type " + Service.Name);
            this.services.Add(Service, Provider);
        }

        /// <summary>
        /// Gets the service.
        /// </summary>
        /// <param name="Service">The service.</param>
        /// <returns></returns>
        public object GetService(Type Service)
        {
            foreach (Type type in services.Keys)
                if (type == Service)
                    return services[type];

            throw new Exception("The service container does not contain "
            + "a service provider of type " + Service.Name);
        }

        /// <summary>
        /// Gets the service.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public T GetService<T>()
        {
            object result = GetService(typeof(T));

            if (result != null)
                return (T)result;

            return default(T);
        }

        /// <summary>
        /// Removes the service.
        /// </summary>
        /// <param name="Service">The service.</param>
        public void RemoveService(Type Service)
        {
            if (services.ContainsKey(Service))
                services.Remove(Service);
        }

        /// <summary>
        /// Determines whether the specified service contains service.
        /// </summary>
        /// <param name="Service">The service.</param>
        /// <returns>
        ///   <c>true</c> if the specified service contains service; otherwise, <c>false</c>.
        /// </returns>
        public bool ContainsService(Type Service)
        {
            return services.ContainsKey(Service);
        }
    }
}
Next we are going to create a custom content manager expanding on the XNA’s base content manager, the main reason for this is so we can use cached content and also allow us to unload content insted of unloading everything.
So add a new class to services folder and call it IEContentManager
using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework.Content;

namespace Engine.Services
{
    public class IEContentManager : ContentManager
    {

        public IEContentManager(IServiceProvider serviceProvider)
            : base(serviceProvider) { }

        public bool PreserveAssets = true;

        List<IDisposable> disposable = new List<IDisposable>();
        Dictionary<string, object> loaded = new Dictionary<string, object>();

       public override T Load<T>(string assetName)
        {

            T r = this.ReadAsset<T>(assetName, RecordIDisposable);
            if (PreserveAssets && !loaded.ContainsKey(assetName))
                loaded.Add(assetName, r);
            return r;
        }

        void RecordIDisposable(IDisposable asset)
        {
            if (PreserveAssets)
                disposable.Add(asset);
        }

        public override void Unload()
        {
            foreach (IDisposable disp in disposable)
                disp.Dispose();
            loaded.Clear();
            disposable.Clear();
        }

        public void Unload(string assetName)
        {
            if (loaded.ContainsKey(assetName))
            {

                if (loaded[assetName] is IDisposable && disposable.Contains((IDisposable)loaded[assetName]))
                {
                    IDisposable obj = disposable[disposable.IndexOf((IDisposable)loaded[assetName])];
                    obj.Dispose();
                    disposable.Remove(obj);
                }
                loaded.Remove(assetName);
            }
        }
    }
}
Last but not least we are going to add a game screen collection class so we can have multiple game screens in our engine.
So we need to add a new class to our GameScreen folder and call it can you guess that’s right GameScreenCollection
using System.Collections.ObjectModel;

namespace Engine.GameScreens
{
    public class GameScreenCollection : KeyedCollection<string, GameScreen>
    {

        /// <summary>
        /// When implemented in a derived class, extracts the key from the specified element.
        /// </summary>
        /// <param name="item">The element from which to extract the key.</param>
        /// <returns>
        /// The key for the specified element.
        /// </returns>
        protected override string GetKeyForItem(GameScreen item)
        {
            return item.Name;
        }

        /// <summary>
        /// Removes the element at the specified index of the <see cref="T:System.Collections.ObjectModel.KeyedCollection`2"/>.
        /// </summary>
        /// <param name="index">The index of the element to remove.</param>
        protected override void RemoveItem(int index)
        {
            GameScreen screen = Items[index];
            if (Engine.DefaultScreen == screen)
                Engine.DefaultScreen = Engine.BackgroundScreen;

            base.RemoveItem(index);
        }
    }
}
]]>
			http://spinneretdesign.com/2011/11/26/part-4-the-engine/feed/
		1
		
		
		
		http://spinneretdesign.com/2011/11/25/part-3-starting-coding-the-engine/
		http://spinneretdesign.com/2011/11/25/part-3-starting-coding-the-engine/#comments
		Fri, 25 Nov 2011 17:28:00 +0000
		Jardeth56
				
		

		https://jardeth56.wordpress.com/?p=643
		
			So in this tutorial we are going start our engine, we will be making 3 classes and a interface,


Component Class
Component Interface
GameScreen Class
Component Collection Class

So we are going to start with our component class this is the basis for all objects managed by the engine.
using Microsoft.Xna.Framework;
using System;
using Engine.GameScreens;

namespace Engine.Components
{
    public class Component
    {
        public GameScreen Parent;
        public bool Initialized = false;
        public bool Visible = true;

        /// <summary>
        /// Initializes a new instance of the  class.
        /// </summary>
        /// <param name="Parent">The parent.</param>
        public Component(GameScreen Parent)
        {
            InitializeComponent(Parent);
        }

        /// <summary>
        /// Initializes a new instance of the  class.
        /// </summary>
        public Component()
        {
            InitializeComponent(Engine.DefaultScreen);
        }

        /// <summary>
        /// Initializes the component.
        /// </summary>
        /// <param name="Parent">The parent.</param>
        protected virtual void InitializeComponent(GameScreen Parent)
        {
            if (!Engine.IsInitialized)
                throw new Exception("Engine must be initialized with SetupEngine() before components can be initialized");

            Parent.Components.Add(this);
            Initialized = true;
        }

        /// <summary>
        /// Updates this instance.
        /// </summary>
        public virtual void Update()
        {
        }

        /// <summary>
        /// Draws this instance.
        /// </summary>
        public virtual void Draw()
        {
        }

        /// <summary>
        /// Disables the component.
        /// </summary>
        public virtual void DisableComponent()
        {
            Parent.Components.Remove(this);
        }
    }
}
This should be pretty self explantory.
The main think to note is that the component is owned by a Game Screen who calls the component’s update and draw methods every frame.
If you engine is made up of a lot of differently formatted classes, then you will have problems when it comes to updating and drawing objects, having a base class means that all we have to do is inherit from it, change the update adn draw a little and the engine will do everything for us.
The next thing we are going to do is define some inferfaces for out components.
using System;
using Microsoft.Xna.Framework;

namespace Engine.Components
{

    public interface I3DComponent
    {

        ///
 /// Gets or sets the position. /// 

        ///
        /// The position.
        ///
        Vector3 Position { get; set; }

        ///
 /// Gets or sets the euler rotation. /// 

        ///
        /// The euler rotation.
        ///
        Vector3 EulerRotation { get; set; }

        ///
 /// Gets or sets the rotation. /// 

        ///
        /// The rotation.
        ///
        Matrix Rotation { get; set; }

        ///
 /// Gets or sets the scale. /// 

        ///
        /// The scale.
        ///
        Vector3 Scale { get; set; }

        ///
 /// Gets the bounding box. /// 

        BoundingBox BoundingBox { get; }
    }

    public interface I2DComponent
    {
        Rectangle Rectangle { get; set; }
    }

    public enum ComponentType
    {
        Component2D,
        Component3D,
        Both,
        All
    }
}
Over time we will expand on this adding additional functioality but this gives us a good starting place.
Next we will move on to the GameScreen class, The GameScreen class contains a goup of components, and heandles thier update, draw and input.

We will add the ability to block drawing, update and input this is great is we are making a pause screen or such like.

The bast way to think about this is a stack where if the top screen is paused then all other screens under it are paused.
While this kind of state management could be inculded the final game and not managed by the engine, we are trying to make our engine as flexible as possable.
So heres the code
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Engine.Components;
using Engine.GameScreens;

namespace Engine.GameScreens
{
    public class GameScreen
    {
        public ComponentCollection Components;

        public bool Visible = true;

        public bool BlocksUpdate = false;

        public bool OverrideUpdateBlocked = false;

        public bool BlocksDraw = false;

        public bool OverrideDrawBlocked = false;

        public bool BlocksInput = false;

        public bool OverrideInputBlocked = false;

        public bool InputDisabled = false;

        public bool IsInputAllowed = true;

        public string Name;

        /// <summary>
        /// Occurs when [on initialized].
        /// </summary>
        public event EventHandler OnInitialized;

        bool inititalized = false;
        /// <summary>
        /// Gets or sets a value indicating whether this GameScreen"/> is initialized.
        /// </summary>
        /// <value>
        ///   <c>true</c> if initialized; otherwise, <c>false</c>.
        /// </value>
        public bool Initialized
        {
            get { return inititalized; }
            set
            {
                inititalized = value;
                if (OnInitialized != null)
                {
                    OnInitialized(this, new EventArgs());
                }
            }
        }

        /// <summary>
        /// Initializes a new instance of the  class.
        /// </summary>
        /// <param name="Name">The name.</param>
        public GameScreen(string Name)
        {
            Components = new ComponentCollection(this);

            this.Name = Name;
            Engine.GameScreens.Add(this);

            if (!Initialized)
                Initialize();
        }

        /// <summary>
        /// Initializes this instance.
        /// </summary>
        public virtual void Initialize()
        {
            this.Initialized = true;
        }

        /// <summary>
        /// Updates this instance.
        /// </summary>
        public virtual void Update()
        {
            List<Component> updating = new List<Component>();

            foreach (Component c in Components)
                updating.Add(c);

            foreach (Component Component in updating)
                if (Component.Initialized)
                    Component.Update();
        }

        /// <summary>
        /// Draws the specified render type.
        /// </summary>
        ///RenderType">Type of the render.
        public virtual void Draw(ComponentType RenderType)
        {
            List<Component> drawing = new List<Component>();

            foreach (Component component in Components)
            {
                if (RenderType == ComponentType.Both)
                {
                    if (component is I2DComponent || component is I3DComponent)
                        drawing.Add(component);
                }
                else if (RenderType == ComponentType.Component2D)
                {
                    if (component is I2DComponent)
                        drawing.Add(component);
                }
                else if (RenderType == ComponentType.Component3D)
                {
                    if (component is I3DComponent)
                        drawing.Add(component);
                }
                else
                {
                    drawing.Add(component);
                }
            }

            List defer2D = new List();

            foreach (Component component in drawing)
                if (component.Visible && component.Initialized)
                {
                    if (component is I2DComponent)
                    {
                        defer2D.Add(component);
                    }
                    else
                    {
                        component.Draw();
                    }
                }
            foreach (Component component in defer2D)
                component.Draw();
        }

        /// <summary>
        /// Disables this instance.
        /// </summary>
        public virtual void Disable()
        {
            Components.Clear();
            Engine.GameScreens.Remove(this);
            if (Engine.DefaultScreen == this)
                Engine.DefaultScreen = Engine.BackgroundScreen;
        }

        /// <summary>
        /// Returns a <see cref="System.String"/> that represents this instance.
        /// </summary>
        /// <returns>
        /// A <see cref="System.String"/> that represents this instance.
        /// </returns>
        public override string ToString()
        {
            return Name;
        }
    }
}
Note: We don’t want to limit our input by forcing it all into one function on the GameScreen, because we want to take advantage fo things like key press events, mouse events, and gamepad events.
Next we need to set up our ComponentCollection. This is a custom collection that handles the management of the Parent value for components when it is moved around various screens.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections.ObjectModel;
using Engine.GameScreens;

namespace Engine.Components
{
    public class ComponentCollection : Collection
    {
        GameScreen owner;

        /// <summary>
        /// Initializes a new instance of the  class.
        /// </summary>
        /// <param name="Owner">The owner.</param>
        public ComponentCollection(GameScreen Owner)
        {
            owner = Owner;
        }

        /// <summary>
        /// Inserts an element into the <see cref="T:System.Collections.ObjectModel.Collection`1"/> at the specified index.
        /// </summary>
        ///The zero-based index at which <paramref name="item"/> should be inserted.
        ///The object to insert. The value can be null for reference types.
        /// <paramref name="index"/> is less than zero.-or- is greater than .
        protected override void InsertItem(int index, Component item)
        {
            if (item.Parent != null && item.Parent != owner)
                item.Parent.Components.Remove(item);

            item.Parent = owner;

            base.InsertItem(index, item);
        }

        /// <summary>
        /// Removes the element at the specified index of the <see cref="T:System.Collections.ObjectModel.Collection`1"/>.
        /// </summary>
        /// <param name="index">The zero-based index of the element to remove.</param>
        /// <paramref name="index"/> is less than zero.-or- is equal to or greater than .
        protected override void RemoveItem(int index)
        {
            Items[index].Parent = null;

            base.RemoveItem(index);
        }
    }
}
Well that’s it for this post we will be covering more next time.
]]>
			http://spinneretdesign.com/2011/11/25/part-3-starting-coding-the-engine/feed/
		1
		
		
		
		http://spinneretdesign.com/2011/11/25/part-2-engine-design/
		http://spinneretdesign.com/2011/11/25/part-2-engine-design/#comments
		Fri, 25 Nov 2011 12:56:49 +0000
		Jardeth56
				
		
		

		http://jardeth56.wordpress.com/?p=633
		
			So in this part of my tutorials we are going to talk about the engines design and structure.

The image below shows how we are going to layout the basic folder structure for our engine.



As we work thought this series we will build up the engine so it is a good idea to build the folder  structure to start will.
Defining the folder structure right off the bat will allow us to keep our engine as clean as possible.
So to get started launch Visual Studio (Am using 2010), we need to create tow projects in our solution, one for the engine its self and one as a demo project.
Am assuming you already have Xna 4.0 installed on your computer.
Am not going to talk you thought all the stages of setting up you projects in VS, just know we need an Xna Windows Games Library and a Xna Windows Game.
Hit F5 and make sure you new project runs and you should see a blue screen, very interesting.
So Create a new Class file and call it Engine, this is the main class  for the engine and create the folder structure about note that the Engine  in the Folder structure about is not a folder its the class we have just created.
So now we have all that it place its time to start building our engine, so in my next post I will cover some of the basic elements of our engine and we can start writing code.
]]>
			http://spinneretdesign.com/2011/11/25/part-2-engine-design/feed/
		1
		
		
		
		http://spinneretdesign.com/2011/11/22/part-1-what-is-a-games-engine/
		http://spinneretdesign.com/2011/11/22/part-1-what-is-a-games-engine/#comments
		Tue, 22 Nov 2011 17:40:32 +0000
		Jardeth56
				
		
		

		https://jardeth56.wordpress.com/?p=515
		
			Well this blog will document me creating a game engine using Microsoft xna framework.

So lets start with a little background, Wikipedia defines a game engine as “a system designed for creation and development of video games” thanks Wikipedia that it in a nut shell.



All games have an engine in one form or another, look at batman arkham city this is built on the unreal engine.
GTA 4 had a custom-made engine just for Rockstar.
So in this blog we are going to cover how to make our own engine, if your only interested in making games then I recommend that you look online of an engine that meets you needs this is more designed for developers wanting to understand how games work.
So that’s some information about engine now to cover the Microsoft Xna framework.
Microsoft XNA is a set of tools with a managed runtime environment  provided by Microsoft that facilitates video game development and management. XNA attempts to free game developers from writing “repetitive boilerplate code” and to bring different aspects of game production into a single system.
Thanks again Wikipedia!
One of my main reasons for using Xna is its cross-platform ability with minimum effort the same code can run on window and xbox 360.
Well thats the background covered in my next post I will be covering designing our engine.
]]>
			http://spinneretdesign.com/2011/11/22/part-1-what-is-a-games-engine/feed/
		0