Game Algorithms

2D sidescrolling, land on ground/objects

Glaucuos — Thu, 19 Nov 2009 18:15:35 GMT

Hello.

I'm working on a 2D sidescrolling game, quite simple, and so far is working quite good. Let me explain some basics, which probably are somewhat common.

I have a player, fixed in the middle of the screen, and moving the backgrounds around him (depending on the speed).
The layer which the player is walking on, has got a lot of WayPoints, which are vectors, which I use to calculate slopes and where the ground is. This is some basic math, and there's nothing wrong in that part.

There are two problems here. The first one being that the way I check if the player landed on the ground probably isn't the best. And then we have the fact that I can't have platforms ABOVE waypoints, or, well I probably could, but I'd have to use multiple Lists of waypoints and it probably wouldn't work out.

The way to check if the player lands on the ground should be quite simple, it's easy to calculate where the ground Y-point is, by using the player's X-point. However, since the speed is around 0-30, this means that the player won't hit the ground perfectly, almost never at least. So the way I do it right now is by checking if the player is at the ground +/- 6 pixels, and then calculate the speed which I need in order to hit that exact Y-point. This is working, as long as the speed isn't too high.

I tried to understand how it was done in the Platformer game which ships with XNA GS 3.1, but I'm not sure how it works.
Any tips how to do it, tried/trying to find something by Googling, but it isn't that easy to find.

Minesweeper uncovering blocks..

Egad — Fri, 20 Nov 2009 01:59:04 GMT

I am attempting to make a minesweeper game but I'm not sure how to get past this. When you uncover a block with 0 mines around it, the region of uncovered blocks grows until it hits a block that has mines around it, or the edge of the grid. That's my best shot at explaining it, so I'm hoping you've played minesweeper before. I need an algorithm to do this, and would very much appreciate it if someone could help me. Thanks!

Texture 2D Block Tranfer. Exists?

Onidsouza — Fri, 16 Oct 2009 22:36:09 GMT

Well, let's supose i have a spritesheet like this:

thanks for that example bonzai. Well, i won't use that one, is just a example. Well, i have this spritesheet imported in XNA and loaded as a Texture 2D. But i want to get only a part of that image, so that i can do a animation. I have the x and y coordinates and the width and height of the part that i want. The thing is, can i create another texture 2D with that part that i want? Like a block transfer. I give the Texture, a rectangle of the part that i want, and it returs me a new Texture containing the part that i trasfered. Thanks for the help!

Distance between Vector3 and BoundingBox

Semei — Fri, 14 Sep 2007 16:09:05 GMT

Can someone please help me to write such a function?

combine multiple models at load time and rotate, translate as one

mysdn — Fri, 20 Nov 2009 13:12:03 GMT

Hi,
I would like to ask a new question, I still couldn't find a solution to my other problem "building a kitchen cabinet" after 2 days.
So here is the new question, how can we combine multiple pieces of objects (models) to act as a single model for translation (rotate, position) purposes?

that's it , if I can find the answer to this question, I will have my problem solved? Appreciate all help, thank you.

PS : I'm using ModelViewerControl from Shawn's sample. Combining must be done at load time or run time, not in 3ds max cause model accesories will be decided by the app's user.

Matrices Sux.

Teh1337Bix — Thu, 19 Nov 2009 11:24:06 GMT

Right now I am using matrices to rotate vectors, but they seem to not be working as I would understand them to.
Here is some code.

Matrix transform = Matrix.CreateRotationZ((float)Math.Atan2(endToBall.Y, endToBall.X));
Vector2 newSpeed = Vector2.Transform(ballSpeed, Matrix.Invert(transform));

If endToBall X = 0 and Y = -1 then the matrix = CreateRotationZ(Whatever negative half of pi is).
In this example ballSpeed X = 0 and Y = 0.766666blah blah blah.
Then I transform the speed (so I can do a bit of advanced reflection) and newSpeed X ends up to = negative ballSpeed.Y and newSpeed Y = -3.351213E-07. WTF!!?!?

Can some explain what is happening?

PC Gamepad D-Pad problem

skyrider — Fri, 20 Nov 2009 16:54:07 GMT

Hi guys, I'm using the Soopah.Xna dll for making PC gamepads work. So far everything
works great except for the directional pad. I keep getting errors

Line 19 is where I'm getting the error and it says
- Cannot implicitly convert type 'Microsoft.Xna.Framework.Input.ButtonState' to 'bool'

Any thoughts on how to fix this?

    
            1
            #region GAMEPAD 
        
            2
                        // PC Gamepad Controls Logic added here 
        
            3
                         
            4
                        lastGamePadState = currentGamePadState; 
        
            5
                        currentGamePadState = TestingGrounds.PCGamePad.GetState(PlayerIndex.One); 
        
            6
                         
            7
                        // Allows the game to exit 
        
            8
                        if (TestingGrounds.PCGamePad.GetState(PlayerIndex.One).Buttons.Start == ButtonState.Pressed) 
        
            9
                            this.Exit(); 
        
            10
                         
            11
                        // Allows the game to exit 
        
            12
                        if (lastGamePadState.Buttons.Select == ButtonState.Released && 
        
            13
                            currentGamePadState.Buttons.Select == ButtonState.Pressed) 
        
            14
                        { 
        
            15
                            this.Exit(); 
        
            16
                        } 
        
            17
             
            18
                        // Change the sprite 2 position using the D-Pad 
        
            19
                        if (TestingGrounds.PCGamePad.GetState(PlayerIndex.One).DPad.Up) 
        
            20
                            Smiley2.position += new Vector2(0, -5); 
        
            21
                         
            22
                        // Change the sprite 2 position using the left thumbstick 
        
            23
                        Vector2 LeftThumb = TestingGrounds.PCGamePad.GetState(PlayerIndex.One).Thumbsticks.Left; 
        
            24
                        Smiley2.position += new Vector2(LeftThumb.X, LeftThumb.Y) * 10;   // # represents the speed of movement 
        
            25
            
            26
                      #endregion

Can someone give me some feedback on my object manager

Angel Oblivion — Mon, 09 Nov 2009 04:18:32 GMT

Hey everyone,

I am writing my object manager right now and got the basics added in there, i.e. Add, Remove and update. The draw code will actually be handled through a render er as it stands right now.

The way my objects work is that each object has a reference to a specific renderstate. Inside this renderstate is, a integer value, and a spritebatch with settings specific to that renderstate. The reason the renderstate has a value is that the object manager can sort the objects as they are added to to the object manager based upon their render state.

When discussing this setup it makes me want to force the object manager to handle the drawing itself. However, part of me feels like this a bad practice, am I right? Any feed back on this would be a great help.

Lastly, I am kind of unsure of what to do about a collision system I know I want to implement a bsp tree, or maybe do an AABB collision system instead. In order to reduce collision checks. By the way if anyone has a good tutorial for one of these on XNA that would be awesome. However, I am confusing my self a little bit when thinking about how this works. Collision systems in general I mean. Any general input would be a valueable insight.

So you know the game I will be making is a 2.5D geomtery wars style game that takes place in a randomly generated maze.

Below I have posted my code. I welcome all criticism and ask that you try to keep it constructive. Thanks you guys and have a nice night.

    
            1
            using System;  
        
            2
            using System.Collections.Generic;  
        
            3
            using System.Linq;  
        
            4
            using System.Text;  
        
            5
             
            6
            namespace Labryinth_Hunter  
        
            7
            {  
        
            8
                class CObjectManager  
        
            9
                {  
        
            10
                    private List<CBaseObject> m_lAllObjects;  
        
            11
             
            12
             
            13
                    public void Update(float fGameTime)  
        
            14
                    {  
        
            15
                        foreach (CBaseObject Obj in m_lAllObjects)  
        
            16
                        {  
        
            17
                            Obj.Update(fGameTime);   
        
            18
                              
            19
                            //More should go in here it seemes most likley the collision   
        
            20
                            //code itself. I am considering creating  a bsp for the   
        
            21
                            //collision system, and then sending a message to The specified   
        
            22
                            //object if thier is a collision.  I am not entiely sure how many   
        
            23
                            //objects Should be checked for collisions. My gut instict  
        
            24
                            //tells me all of them.  However I know this is wrong.    
        
            25
                            //If I remember correctly you check the player against the    
        
            26
                            //objects that are in the bso tree with them.    
        
            27
                        }  
        
            28
                    }  
        
            29
             
            30
                    private bool AddObject(ref CBaseObject PassedInObj)  
        
            31
                    {  
        
            32
                        //Search for the object in our existing list of all objects   
        
            33
                        try 
        
            34
                        {  
        
            35
                            foreach (CBaseObject CurrentObj in m_lAllObjects)  
        
            36
                            {  
        
            37
                                if (CurrentObj.Equals(PassedInObj))  
        
            38
                                    throw new System.InvalidOperationException(" The object  
        
            39
                                    is already in the arry and was there for not added.");   
        
            40
                            }  
        
            41
                        }  
        
            42
                        catch(System.InvalidOperationException ex)  
        
            43
                        {  
        
            44
                            System.Console.WriteLine(ex);  
        
            45
                            return false;  
        
            46
                        }  
        
            47
                        //Since the object was not in our list of objects to begin with we   
        
            48
                        //can add it to our list of objects in the game  
        
            49
                        m_lAllObjects.Add(PassedInObj);  
        
            50
                        m_lAllObjects.Sort(delegate(CBaseObject Obj1, CBaseObject Obj2)   
        
            51
                        { return Obj1.ObjRenderState.nValue.CompareTo  
        
            52
                          (Obj2.ObjRenderState.nValue); });  
        
            53
                        return true;   
        
            54
                    }  
        
            55
                    private bool RemoveObject(ref CBaseObject PassedInObj)  
        
            56
                    {  
        
            57
                        //Search for the object in our existing list of all objects   
        
            58
                        try 
        
            59
                        {  
        
            60
                            foreach (CBaseObject CurrentObj in m_lAllObjects)  
        
            61
                            {  
        
            62
                                if (CurrentObj.Equals(PassedInObj))  
        
            63
                                    throw new System.InvalidOperationException(" The object  
        
            64
                                    is not in the array.");  
        
            65
                            }  
        
            66
                        }  
        
            67
                        catch (System.InvalidOperationException ex)  
        
            68
                        {  
        
            69
                            System.Console.WriteLine(ex);  
        
            70
                            return false;  
        
            71
                        }  
        
            72
             
            73
                        //We can now remove the passed in object since we have clarified it   
        
            74
                        //is in our list.  
        
            75
             
            76
                        m_lAllObjects.Remove(PassedInObj);              
        
            77
                        return true;  
        
            78
                    }  
        
            79
                }  
        
            80
            }  
        
            81

Track cube rotation

RyuMaster — Thu, 19 Nov 2009 15:37:36 GMT

Hi! I'm dealing with fairly simple task, but for some reason I'm stuck fo a long time, all my approaches fails, so I'm asking for an advice...

I have simple cube, witch has 6 textures assigned to every side of it. This cube rotates around X and Y axises.

I need to track, which side faces the camera mostly, and highligth that side.

Is there any way to find, which side is nearest to the camera, without involving tracking rotations and comparing them to hardcoded values (like, if rotated by bla bla degrees, and bla bla degrees, then side facing == 3 and e.t.c)

Cube is XnaModel, but I can't see any way to extra side's vertex position, for sample, and compare it to the camera or e.t.c Hmm...

Interactive water not rendering correctly.

JHow — Fri, 20 Nov 2009 06:22:16 GMT

I am working on a game that takes place in a pool so good water is a must. My problem is that the water is not rendering correctly. I used BEPU Physics for the collision and the WaterComponentDemo to draw the water. I create a grid of tiny spheres and use springs to connect them. This allows the water to be interactive. That's where my problem starts. I had to rewrite the way the water component sets up its mesh. Instead i set the vertex positions the position of each spher in the watervertex list. I think my problem has to do with the fact that i rebuild the waters drawable mesh every frame so that it moves with the waters collision vertices. It may have something to do with the vertices moving on their y axis which they don't in the water component demo.

Here is a video of it.
http://www.youtube.com/user/HaloRiderJHOW#p/a/u/0/Bv3ybjX6D6k

This one may or may not be visible to some people because it is on facebook but it shows the water grid before i added the shader.
It should be visible because it is set to public but sorry if it isn't.
PS. Once this is finished i will release it because there is nothing on such a cool topic.

http://www.facebook.com/profile.php?v=app_2392950137&ref=name&id=100000029795138#/video/video.php?v=105089136168746

And some code where the problem may lie.

The first block sets up the render mesh using the water grid positions.
And the second is the collision part of the water.

    
            public void BuildWater(Vector3 position, int width, int length, GraphicsDevice graphics) 
        
                    { 
        
                        myPosition = position; 
        
                        this.width = width; 
        
                        this.length = length; 
        
                        // Vertices 
        
                        myVertices = new VertexMultitextured[width * length]; 
        
                        mDecl = new VertexDeclaration(graphics, VertexMultitextured.VertexElements); 
        
                            for (int j = 0; j < vertexPositions.Count; ++j) 
        
                            { 
        
                                // Negate the depth coordinate to put in quadrant four.   
        
                                // Then offset to center about coordinate system. 
        
                                myVertices[j].Position = vertexPositions[j].GetPosition(); 
        
                                myVertices[j].Normal = new Vector3(0, -1, 0); 
        
                                //myVertices[j].TextureCoordinate.X = vertexPositions[j].GetPosition().X / width; 
        
                                //myVertices[j].TextureCoordinate.Y = vertexPositions[j].GetPosition().Z / length; 
        
                            } 
        
                            for (int i = 0; i < width; ++i) 
        
                            { 
        
                                for (int j = 0; j < length; ++j) 
        
                                { 
        
                                    int index = i * width + j; 
        
                                    myVertices[index].TextureCoordinate = new Vector2((float)j / width, (float)i / length); 
        
                                } 
        
                            } 
        
                        vb = new VertexBuffer(graphics, VertexMultitextured.SizeInBytes * width * length, BufferUsage.WriteOnly); 
        
                        vb.SetData(myVertices); 
        
                        short[] terrainIndices = new short[(width - 1) * (length - 1) * 6]; 
        
                        for (short x = 0; x < width - 1; x++) 
        
                        { 
        
                            for (short y = 0; y < length - 1; y++) 
        
                            { 
        
                                terrainIndices[(x + y * (width - 1)) * 6] = (short)((x + 1) + (y + 1) * width); 
        
                                terrainIndices[(x + y * (width - 1)) * 6 + 1] = (short)((x + 1) + y * width); 
        
                                terrainIndices[(x + y * (width - 1)) * 6 + 2] = (short)(x + y * width); 
        
                                terrainIndices[(x + y * (width - 1)) * 6 + 3] = (short)((x + 1) + (y + 1) * width); 
        
                                terrainIndices[(x + y * (width - 1)) * 6 + 4] = (short)(x + y * width); 
        
                                terrainIndices[(x + y * (width - 1)) * 6 + 5] = (short)(x + (y + 1) * width); 
        
                            } 
        
                        } 
        
                        ib = new IndexBuffer(graphics, typeof(short), (width - 1) * (length - 1) * 6, BufferUsage.WriteOnly); 
        
                        ib.SetData(terrainIndices); 
        
                    } 

                        using System; 
                    
                        using System.Collections.Generic; 
                    
                        using Microsoft.Xna.Framework; 
                    
                        using Microsoft.Xna.Framework.Audio; 
                    
                        using Microsoft.Xna.Framework.Content; 
                    
                        using Microsoft.Xna.Framework.Graphics; 
                    
                        using Microsoft.Xna.Framework.Input; 
                    
                        using Microsoft.Xna.Framework.Storage; 
                    
                        using BEPUphysics; 
                    
                        using System.Diagnostics; 
                    
                        using System.Threading; 
                    
                        using BEPUphysics.BroadPhases; 
                    
                        using BEPUphysics.Entities; 
                    
                        using BEPUphysics.Constraints; 
                    
                        using BEPUphysics.ForceFields; 
                    
                        using BEPUphysics.DataStructures; 
                    
                        using System.Collections; 
                    
                        namespace BlockTanx 
                    
                        { 
                    
                            public class Water 
                    
                            { 
                    
                                public List<Spring> surfaceTensionSprings; 
                    
                                public List<Spring> densitySprings; 
                    
                                public float surfaceTension = 0.006f; 
                    
                                public float density = 0.6f; 
                    
                                public List<Entity> waterTris; 
                    
                                public List<WaterVertex> waterVertices; 
                    
                                public int wLength = 25; 
                    
                                public int wWidth = 25; 
                    
                                float radius = 0.0001f; 
                    
                                float waterDensity = 5; 
                    
                                float strength = float.MaxValue; 
                    
                                Spring spring; 
                    
                                Sphere sphere; 
                    
                                Space space; 
                    
                                public Water(Space space) 
                    
                                {    
                    
                                    this.space = space; 
                    
                                    BuildWater(); 
                    
                                } 
                    
                                public void BuildWater() 
                    
                                { 
                    
                                    waterVertices = new List<WaterVertex>(); 
                    
                                    waterTris = new List<Entity>(); 
                    
                                    surfaceTensionSprings = new List<Spring>(); 
                    
                                    densitySprings = new List<Spring>(); 
                    
                                    generateWaterGrid(); 
                    
                                    setupSprings(); 
                    
                                } 
                    
                                float scale = 1f; 
                    
                                public void generateWaterGrid() 
                    
                                { 
                    
                                    float xOffset = -wWidth * 0.5f; 
                    
                                    float zOffset = -wLength * 0.5f; 
                    
                                    for (int i = 0; i < wWidth; i+= Convert.ToInt32(scale)) 
                    
                                    { 
                    
                                        for (int j = 0; j < wLength; j += Convert.ToInt32(scale)) 
                    
                                        { 
                    
                                            sphere = new Sphere(new Vector3(i + xOffset, 0, j + zOffset), radius,waterDensity); 
                    
                                            WaterVertex vertex = new WaterVertex(sphere); 
                    
                                            space.add(sphere); 
                    
                                            waterVertices.Add(vertex); 
                    
                                        } 
                    
                                    } 
                    
                                } 
                    
                                public void setupSprings() 
                    
                                { 
                    
                                    int counter = 0; 
                    
                                    for (int i = 0; i < wWidth; i++) 
                    
                                    { 
                    
                                        for (int j = 0; j < wLength; j++) 
                    
                                        { 
                    
                                            if (j != 0 && j < wLength - 1) 
                    
                                            { 
                    
                                                spring = new Spring(waterVertices[counter].sphere, waterVertices[counter - 1].sphere, 
                    
                                                new Vector3(waterVertices[counter].sphere.worldTransform.M41, waterVertices[counter].sphere.worldTransform.M42, waterVertices[counter].sphere.worldTransform.M43), 
                    
                                                new Vector3(waterVertices[counter - 1].sphere.worldTransform.M41, waterVertices[counter - 1].sphere.worldTransform.M42, waterVertices[counter - 1].sphere.worldTransform.M43), 
                    
                                                5000, surfaceTension, strength, strength, strength); 
                    
                                                space.add(spring); 
                    
                                                surfaceTensionSprings.Add(spring); 
                    
                                            } 
                    
                                            if (j < wLength - 1) 
                    
                                            { 
                    
                                                spring = new Spring(waterVertices[counter].sphere, waterVertices[counter + 1].sphere, 
                    
                                                new Vector3(waterVertices[counter].sphere.worldTransform.M41, waterVertices[counter].sphere.worldTransform.M42, waterVertices[counter].sphere.worldTransform.M43), 
                    
                                                new Vector3(waterVertices[counter + 1].sphere.worldTransform.M41, waterVertices[counter + 1].sphere.worldTransform.M42, waterVertices[counter + 1].sphere.worldTransform.M43), 
                    
                                                5000, surfaceTension, strength, strength, strength); 
                    
                                                space.add(spring); 
                    
                                                surfaceTensionSprings.Add(spring); 
                    
                                            } 
                    
                                            if ((counter + wLength) <  waterVertices.Count)  
                    
                                            { 
                    
                                                spring = new Spring(waterVertices[counter].sphere, waterVertices[counter + wLength].sphere, 
                    
                                                new Vector3(waterVertices[counter].sphere.worldTransform.M41, waterVertices[counter].sphere.worldTransform.M42, waterVertices[counter].sphere.worldTransform.M43), 
                    
                                                new Vector3(waterVertices[counter + wLength].sphere.worldTransform.M41, waterVertices[counter + wLength].sphere.worldTransform.M42, waterVertices[counter + wLength].sphere.worldTransform.M43),  
                    
                                                5000, surfaceTension, strength, strength, strength); 
                    
                                                space.add(spring); 
                    
                                                surfaceTensionSprings.Add(spring); 
                    
                                            } 
                    
                                            spring = new Spring(null, waterVertices[counter].sphere, 
                    
                                                new Vector3(waterVertices[counter].sphere.worldTransform.M41, waterVertices[counter].sphere.worldTransform.M42, waterVertices[counter].sphere.worldTransform.M43), 
                    
                                                new Vector3(waterVertices[counter].sphere.worldTransform.M41, waterVertices[counter].sphere.worldTransform.M42, waterVertices[counter].sphere.worldTransform.M43),  
                    
                                                160, density, strength, strength, strength); 
                    
                                            space.add(spring); 
                    
                                            densitySprings.Add(spring); 
                    
                                            /*
                    
                                            if ((counter + wLength) <  waterVertices.Count && j != 0 && j < wLength - 1)
                    
                                            {
                    
                                                tri = new Triangle(new Vector3( waterVertices[counter].worldTransform.M41,  waterVertices[counter].worldTransform.M42,  waterVertices[counter].worldTransform.M43),
                    
                                                    new Vector3( waterVertices[counter + 1].worldTransform.M41,  waterVertices[counter + 1].worldTransform.M42,  waterVertices[counter + 1].worldTransform.M43),
                    
                                                    new Vector3( waterVertices[counter + wLength].worldTransform.M41,  waterVertices[counter + wLength].worldTransform.M42,  waterVertices[counter + wLength].worldTransform.M43),10);
                    
                                                space.add(tri);
                    
                                                waterTris.Add(tri);
                    
                                            }
                    
                                            */ 
                    
                                            counter++; 
                    
                                        } 
                    
                                    } 
                    
                                } 
                    
                            } 
                    
                        }

Fast method for obtaining intersecting grid elements from 2D ray cast (with code)

xenite — Thu, 19 Nov 2009 05:35:34 GMT

We had a problem where an inner loop for our AI was dog slow. We were basically trying to determine visibility for various grid locations, but the code to search the grid was doing lots of list management and unnecessary work. I came across this page that had a neat little algorithm for determining the set of grid squares intersected by a ray cast from A to B. I coded it up and tested it in XNA/C#, and now I'm sharing it with you.

    
                public class GridUtil  
        
                {  
        
                    /// <summary>  
        
                    /// Converts a point in a window to a grid location  
        
                    /// </summary>  
        
                    /// <param name="windowPosition"></param>  
        
                    /// <param name="playArea"></param>  
        
                    /// <param name="gridSquareSize"></param>  
        
                    /// <returns></returns>  
        
                    public static Point GridFromWindowPosition(Point windowPosition, ref Rectangle playArea, int gridSquareSize)  
        
                    {  
        
                        Point p = new Point(windowPosition.X - playArea.X, windowPosition.Y - playArea.Y);  
        
                        if (p.X < 0 || p.Y < 0 || p.X > playArea.Width || p.Y > playArea.Height)  
        
                        {  
        
                            return new Point(-1, -1);  
        
                        }  
        
                        // it's inside the play area.  divide by the size of a grid square to get the grid position  
        
                        Point gridPoint = new Point(p.X / gridSquareSize, p.Y / gridSquareSize);  
        
                        return gridPoint;  
        
                    }  
        
                    /// <summary>  
        
                    /// Given a line segment, returns a list of points that comprise all of the grid squares intersected by  
        
                    /// the line segment, including the destination, but NOT including the source square  
        
                    /// </summary>  
        
                    /// <param name="start"></param>  
        
                    /// <param name="end"></param>  
        
                    /// <param name="gridSquareSize"></param>  
        
                    /// <returns></returns>  
        
                    public static ICollection<Point> IntersectingPoints(Point start, Point end, int gridSquareSize)  
        
                    {  
        
                        // convert to vectors for greater precision  
        
                        Vector2 sightOrigin = new Vector2(start.X, start.Y);  
        
                        Vector2 sightDest = new Vector2(end.X, end.Y);  
        
                        // this is the vector between the two points.  We'll need to know the angle  
        
                        Vector2 toTarget = sightDest - sightOrigin;  
        
                        // find the horizontal and vertical intersections.  we have to look both ways to ensure we catch  
        
                        // all the boundaries we might encounter  
        
                        double alpha = Math.Atan2(toTarget.Y, toTarget.X);  // yes, the Y parameter goes FIRST!  
        
                        HashSet<Point> intersections = new HashSet<Point>();    // use HashSet to avoid duplicate entries  
        
                        // doesn't matter which one we do first  
        
                        IntersectingPointsHorizontal(ref sightOrigin, ref sightDest, alpha, gridSquareSize, intersections);  
        
                        IntersectingPointsVertical(ref sightOrigin, ref sightDest, alpha, gridSquareSize, intersections);  
        
                        // add destination  
        
                        intersections.Add(end);  
        
                        // return the list  
        
                        return intersections;  
        
                    }  
        
                    private static void IntersectingPointsHorizontal(ref Vector2 sightOrigin, ref Vector2 sightDest, double alpha,   
        
                        int gridSquareSize, HashSet<Point> intersections)  
        
                    {  
        
                        bool rayUp = sightDest.Y < sightOrigin.Y;  
        
                        float Xa = 0;  
        
                        float Ya = 0;  
        
                        Vector2 v = new Vector2(0, 0);  
        
                        // special case first point to get out of current grid square  
        
                        if (rayUp)  
        
                        {  
        
                            Ya = -gridSquareSize;  
        
                            Xa = (float)(Ya / Math.Tan(alpha));  
        
                            v.Y = (float)(Math.Floor((double)sightOrigin.Y / (double)gridSquareSize) * gridSquareSize - 1);  
        
                            v.X = sightOrigin.X + (v.Y - sightOrigin.Y) / (float)(Math.Tan(alpha));  
        
                            if (v.Y > sightDest.Y)  
        
                            {  
        
                                intersections.Add(new Point((int)v.X, (int)v.Y));  
        
                            }  
        
                        }  
        
                        else 
        
                        {  
        
                            Ya = gridSquareSize;  
        
                            Xa = (float)((double)gridSquareSize / Math.Tan(alpha));  
        
                            v.Y = (float)(Math.Floor((double)sightOrigin.Y / (double)gridSquareSize) * gridSquareSize + gridSquareSize);  
        
                            v.X = sightOrigin.X + (v.Y - sightOrigin.Y) / (float)(Math.Tan(alpha));  
        
                            if (v.Y < sightDest.Y)  
        
                            {  
        
                                intersections.Add(new Point((int)v.X, (int)v.Y));  
        
                            }  
        
                        }  
        
                        // iterate over remaining squares  
        
                        while (v.Y != sightDest.Y)  
        
                        {  
        
                            v.X += Xa;  
        
                            v.Y += Ya;  
        
                            if (rayUp)  
        
                            {  
        
                                // if we go past the dest, we're done  
        
                                if (v.Y < sightDest.Y)  
        
                                    break;  
        
                            }  
        
                            else 
        
                            {  
        
                                // if we go past the dest, we're done  
        
                                if (v.Y > sightDest.Y)  
        
                                    break;  
        
                            }  
        
                            intersections.Add(new Point((int)v.X, (int)v.Y));  
        
                        }  
        
                    }  
        
                    private static void IntersectingPointsVertical(ref Vector2 sightOrigin, ref Vector2 sightDest, double alpha,   
        
                        int gridSquareSize, HashSet<Point> intersections)  
        
                    {  
        
                        bool rayRight = sightDest.X > sightOrigin.X;  
        
                        float Xa = 0;  
        
                        float Ya = 0;  
        
                        Vector2 v = new Vector2(0, 0);  
        
                        // special case first point to get out of current grid square  
        
                        if (rayRight)  
        
                        {  
        
                            Xa = gridSquareSize;  
        
                            Ya = (float)((double)gridSquareSize * Math.Tan(alpha));  
        
                            v.X = (float)(Math.Floor((double)sightOrigin.X / (double)gridSquareSize) * gridSquareSize + gridSquareSize);  
        
                            v.Y = (float)(sightOrigin.Y - (sightOrigin.X - v.X) * (float)Math.Tan(alpha));  
        
                            if (v.X < sightDest.X)  
        
                            {  
        
                                intersections.Add(new Point((int)v.X, (int)v.Y));  
        
                            }  
        
                        }  
        
                        else 
        
                        {  
        
                            Xa = -gridSquareSize;  
        
                            Ya = (float)((double)-gridSquareSize * Math.Tan(alpha));  
        
                            v.X = (float)(Math.Floor((float)sightOrigin.X / (float)gridSquareSize) * gridSquareSize - 1);  
        
                            v.Y = (float)(sightOrigin.Y - (sightOrigin.X - v.X) * (float)Math.Tan(alpha));  
        
                            if (v.X > sightDest.X)  
        
                            {  
        
                                intersections.Add(new Point((int)v.X, (int)v.Y));  
        
                            }  
        
                        }  
        
                        // iterate over remaining squares  
        
                        while (sightOrigin.X != sightDest.X)  
        
                        {  
        
                            v.X += Xa;  
        
                            v.Y += Ya;  
        
                            if (rayRight)  
        
                            {  
        
                                // if we go past the dest, we're done  
        
                                if (v.X > sightDest.X)  
        
                                {  
        
                                    break;  
        
                                }  
        
                            }  
        
                            else 
        
                            {  
        
                                // if we go past the dest, we're done  
        
                                if (v.X < sightDest.X)  
        
                                {  
        
                                    break;  
        
                                }  
        
                            }  
        
                            intersections.Add(new Point((int)v.X, (int)v.Y));  
        
                        }  
        
                    }  
        
                }

Here's a little quick and dirty debugging code I used to test it. Note that the following will not just compile. You need to modify it for your own purposes.

    
                    Point startRay = new Point(0,0);  
        
                    Point endRay = new Point(0,0);  
        
                    bool rayChanged = false;  
        
                    ICollection<Point> debugPoints;  
        
                    private void DrawDebug(GameTime gameTime, SpriteBatch spriteBatch)  
        
                    {  
        
                        if (this.dungeonFinished)  
        
                        {  
        
                            if (rayChanged)  
        
                            {  
        
                                debugPoints = GridUtil.IntersectingPoints(startRay, endRay, DungeonSquare.GridSize);  
        
                                rayChanged = false;  
        
                            }  
        
                            if (debugPoints != null && debugPoints.Count > 0)  
        
                            {  
        
                                foreach (Point s in debugPoints)  
        
                                {  
        
                                    Rectangle rect = new Rectangle(s.X - 4, s.Y - 4, 8, 8);  
        
                                    spriteBatch.Draw(ScreenManager.blankTexture, rect, new Color(128, 0, 0, 0.8f));  
        
                                    DungeonSquare sq = dungeon.SquareFromCoordinates(s.X, s.Y);  
        
                                    if (sq != null)  
        
                                    {  
        
                                        Rectangle srect = new Rectangle(  
        
                                            sq.GridX * GridThing.GridSize,  
        
                                            sq.GridY * GridThing.GridSize,  
        
                                            GridThing.GridSize,  
        
                                            GridThing.GridSize);  
        
                                        spriteBatch.Draw(ScreenManager.blankTexture, srect, new Color(23, 45, 128, 200));  
        
                                    }  
        
                                }  
        
                            }  
        
                            spriteBatch.Draw(aimReticle, new Vector2(startRay.X - 28, startRay.Y - 28), Color.Green);  
        
                            spriteBatch.Draw(aimReticle, new Vector2(endRay.X - 28, endRay.Y - 28), Color.Blue);  
        
                        }  
        
                    }

Hope this helps!

Collision Detection in Car Racing Game??

Ayush Chaudhary — Thu, 19 Nov 2009 14:38:17 GMT

Hello everybody,
I am developing a game in XNA by importing models from 3ds MAX in .X format. I have developed huge highways and flyovers (although low poly) but now I can't figure out how to detect whether the car collides with highway sidebar. The car don't stick to the road as highways change their y-axis so I cannot create bounding box. So is there any other way to detect the car collision and the car sticks to the road. Please help.
Thanks..

problems with creating a dual shot

Lebasp — Wed, 18 Nov 2009 17:37:59 GMT

Hi guys, i gotta a math program help ><
what i want to do:
when i click somewhere the player shots one shot for each side of the pointer, like:

               /
             /
(player) / (click)
           \
            \
             \

so the last code i used was:

    
            shotDirection = Vector2.Normalize((new Vector2(mouseCursor.bounds.X + MathHelper.ToRadians(30), mouseCursor.bounds.Y + MathHelper.ToRadians(30)) - getPosition())); 
        
            shotRotation = (float)Math.Atan2(shotDirection.Y, shotDirection.X); 
        
            Shots shot = new Shots(Content.Load<Texture2D>("images\\shot"), this, weaponSpeed, shotDirection, shotRotation); 
        
            shotList.Add(shot); 
        
            shotDirection = Vector2.Normalize((new Vector2(mouseCursor.bounds.X - MathHelper.ToRadians(30), mouseCursor.bounds.Y - MathHelper.ToRadians(30)) - getPosition())); 
        
            shotRotation = (float)Math.Atan2(shotDirection.Y, shotDirection.X); 
        
            Shots shot2 = new Shots(Content.Load<Texture2D>("images\\shot"), this, weaponSpeed, shotDirection); 
        
            shotList.Add(shot2);

my problem if i get the mouse pointer near or further the shot source, the angle changes, like if i get the mouse near the player, the angle increase and if i get further the angle decrease, i've tried a lot of things, i dunno anymore how to fix the angle.

ty in advance.

Line Rectangle Intersection Help!

Travis134 — Thu, 19 Nov 2009 07:53:49 GMT

Hello there! I ran into a problem recently, which I would much appreciate any help with.

My group and I are developing a simple RPG game, and we need to allow the player to interact with a multitude of objects.

Currently, we just draw every object with a rectangle that simply bounds the sprite (our collision rectangle) and for every object except for the player object we draw another rectangle (an "interaction" rectangle) which is centered around the object, and increased in width and height by 2X the player's width and height.

We can determine where our player is looking via which sprite it is currently using (up, down, left, right, etc)

We began by simply running the built in rectangle intersection method between the player's collision rectangle and every game object's interaction rectangle. The only problem with this is that it doesn't take into consideration which direction the player is facing. So if you are facing to the left; standing against the right edge of a lake, you can still fish (This shouldn't be possible)

The next step I took to fix this seems like it is a bit overkill.
-I first check to see if the player's collision rectangle intersects the target object's interaction rectangle
-I then figure out where the player is in relationship with the target object
-If the player is to the right of the target object, I check to see if the sprite of the player facing left is being used
-Then, I check to see if the top of the player's collision rectangle is less then the top of the target objects rectangle's top
-I do the same for the bottoms

If all of these check out then I can confirm that the
A) The player is within the interaction bounding box
B) The player is facing the right direction
C) The player is somewhere along the target sprite's height/width

Here's the code:

    
            public Boolean lookingAt(GameObject sourceObject, GameObject targetObject) 
        
                    { 
        
                        Vector2 relativeDirection = sourceObject.position - targetObject.position; 
        
                        Boolean lookingAtFlag = false; 
        
                        if ((relativeDirection.X < 0) && ((sourceObject.position.Y) > (targetObject.position.Y)) && ((sourceObject.position.Y + sourceObject.collision.Height < ((targetObject.collision.Height) + targetObject.position.Y)))) 
        
                        { 
        
                            if ((sourceObject.currentSpriteIndex == 3) || (sourceObject.currentSpriteIndex == 11)) 
        
                            { 
        
                                lookingAtFlag = true; 
        
                            } 
        
                        } 
        
                        else if ((relativeDirection.X > 0) && ((sourceObject.position.Y) > (targetObject.position.Y)) && ((sourceObject.position.Y + sourceObject.collision.Height < ((targetObject.collision.Height) + targetObject.position.Y)))) 
        
                        { 
        
                            if ((sourceObject.currentSpriteIndex == 2) || (sourceObject.currentSpriteIndex == 10)) 
        
                            { 
        
                                lookingAtFlag = true; 
        
                            } 
        
                        } 
        
                        if ((relativeDirection.Y < 0) && ((sourceObject.position.X) > (targetObject.position.X)) && ((sourceObject.position.X + sourceObject.collision.Width < ((targetObject.collision.Width) + targetObject.position.X)))) 
        
                        { 
        
                            if ((sourceObject.currentSpriteIndex == 1) || (sourceObject.currentSpriteIndex == 9)) 
        
                            { 
        
                                lookingAtFlag = true; 
        
                            } 
        
                        } 
        
                        else if ((relativeDirection.Y > 0) && ((sourceObject.position.X) > (targetObject.position.X)) && ((sourceObject.position.X + sourceObject.collision.Width < ((targetObject.collision.Width) + targetObject.position.X)))) 
        
                        { 
        
                            if ((sourceObject.currentSpriteIndex == 0) || (sourceObject.currentSpriteIndex == 8)) 
        
                            { 
        
                                lookingAtFlag = true; 
        
                            } 
        
                        } 
        
                        return lookingAtFlag; 
        
                    }

The problem with this is that some of our objects will not have a collision rectangle (Because the player is supposed to be able to walk over/through them)
Also, if an object is smaller then the player, the code fails as well.

I've been searching high and low and have found no simple solution for a line rectangle intersection detection method, which sounds like it would be exactly what I want.

The best way to go about this, in my opinion, would be to use the player's velocity vector in order to calculate a new "line of sight" vector, then check if that vector is intersecting with a target object's collision/interaction rectangle.

Here is an image illustrating what we're doing now, and what we want:

Image

If anyone could please help me with this, I would be very grateful. My game development professor is even having a tough time finding a simple solution for me.

*NOTE: I don't want any 3D examples, because they really just end up confusing me, and to be honest, learning is important to me, but I'm sure someone who is reading this has encountered this very same problem and has this method buried somewhere in their libraries; if you could dig it up and post it here, I would be extremely grateful.

A* / Manhattan pathfinding optimisation problems

Xerx3s — Thu, 19 Nov 2009 16:50:46 GMT

Hi,

I'm just doing some research for a project that I'm working on. To do that, I've build a little TD game that continuesly spawns enemies and allows the player to keep on placing turrets (so everything is realtime). I've done quite a bit of reading on the basics of A* and such both on this forum and places such as this. I get the basics and have written a class (based on said article) that returns the next step to the enemy. The class works pretty well but the problem is not one enemy. The problem is when I have 5,10 or more enemies. Every extra enemy severely slows down the game.

Currently I only call the next target from the A* class when the enemy enters a new grid coordinate but I've tried several other approaches as well such as only recalculating the path when a new obstacle is placed but that slows down placing obstacles.
I currently have a couple of linq elements in the class but I doubt that rewriting that will give me a fluid game with 50 - 100+ enemies. Currently the grid is roughly 50*30 points, which is not small but I don't want to make that smaller either.

I've been thinking about minimising the call the the A* class by using the same path for enemies that are on the same grid coordinate but theoretically that still wouldn't solve the problem (i.e. when all enemies are on a different position).

I've also been thinking about using arrays instead of lists but that could give problems. What if the number of steps is larger than the array? The only way that I could account for that is to make the array really big but that kind of nullifies the switch from list to array (?). Besides, that is more of a memory solution and this seems more of a processing problem (?).

Sooooo..... Any suggestions how a lot of enemies can use an independent A* routine without any serious slowdown?

My A* method:

    
            1
                    public static Vector2 FindPathAstarBasic(Vector2 _coordinateCurrent, Vector2 _coordinateExit) 
        
            2
                    { 
        
            3
                        Vector2 _return = Vector2.Zero; 
        
            4
             
            5
                        #region AI 
        
            6
                        #region Step 0 
        
            7
                        List<Instance_Path> List_OpenList = new List<Instance_Path>(); 
        
            8
                        List<Instance_Path> List_ClosedList = new List<Instance_Path>(); 
        
            9
             
            10
                        Vector2 PositionCurrent = _coordinateCurrent; 
        
            11
                        Vector2 PositionExit = _coordinateExit; 
        
            12
             
            13
                        Instance_Path TempPathContainer; 
        
            14
             
            15
                        Vector2 TempPathCoordinateCurrent; 
        
            16
                        Vector2 TempPathCoordinateAdjacent; 
        
            17
                        int TempPathMovementCostG; 
        
            18
                        int TempPathMovementCostH; 
        
            19
             
            20
                        bool ExitNotReached = true; 
        
            21
                        bool NextStepNotFound = true; 
        
            22
                        bool FinalStepFirstMoveNotSet = true; 
        
            23
                        bool StepDoesntExist = true; 
        
            24
             
            25
                        Vector2 ReturnStepParent = Vector2.Zero; 
        
            26
                        Vector2 ReturnStepCurrent = Vector2.Zero; 
        
            27
                        #endregion 
        
            28
                        #region Step 1 
        
            29
                        List_OpenList.Add(new Instance_Path(PositionCurrent, PositionCurrent, 0, 0)); 
        
            30
                        #endregion 
        
            31
                        #region Step 2 
        
            32
                        while (ExitNotReached) 
        
            33
                        { 
        
            34
                            #region Step 2a 
        
            35
                            TempPathContainer = new Instance_Path(Vector2.Zero, Vector2.Zero, 999999, 999999); 
        
            36
                            foreach (Instance_Path _path in List_OpenList) 
        
            37
                            { 
        
            38
                                if (_path.MovementCostG + _path.MovementCostH < TempPathContainer.MovementCostG + TempPathContainer.MovementCostH) 
        
            39
                                { 
        
            40
                                    TempPathContainer = _path; 
        
            41
                                } 
        
            42
                            } 
        
            43
                            #endregion 
        
            44
                            #region Step 2b 
        
            45
                            List_OpenList.Remove(TempPathContainer); 
        
            46
                            List_ClosedList.Add(TempPathContainer); 
        
            47
                            #endregion 
        
            48
                            #region Step 2c 
        
            49
                            #region Up 
        
            50
                            TempPathCoordinateCurrent = TempPathContainer.ElementGridCoordinate; 
        
            51
                            TempPathCoordinateAdjacent = TempPathCoordinateCurrent - new Vector2(0, 1); 
        
            52
                            TempPathMovementCostG = TempPathContainer.MovementCostG + 10; 
        
            53
                            TempPathMovementCostH = CalculateHeuristicManhattan(TempPathCoordinateAdjacent, PositionExit); 
        
            54
             
            55
                            if (TempPathCoordinateAdjacent.X >= Game.Manage_Players.List_Players[0].GridBoundaries.X && 
        
            56
                                TempPathCoordinateAdjacent.X <= Game.Manage_Players.List_Players[0].GridBoundaries.Z - 1 && 
        
            57
                                TempPathCoordinateAdjacent.Y >= Game.Manage_Players.List_Players[0].GridBoundaries.Y && 
        
            58
                                TempPathCoordinateAdjacent.Y <= Game.Manage_Players.List_Players[0].GridBoundaries.W - 1) 
        
            59
                            { 
        
            60
                                if (Game.Manage_Obstructions.CheckObstruction(TempPathCoordinateAdjacent)) 
        
            61
                                { 
        
            62
                                    if (!List_ClosedList.Exists(delegate(Instance_Path I) { return I.ElementGridCoordinate == TempPathCoordinateAdjacent; })) 
        
            63
                                    { 
        
            64
                                        StepDoesntExist = true; 
        
            65
                                        foreach (Instance_Path _path in List_OpenList) 
        
            66
                                        { 
        
            67
                                            if (_path.ElementGridCoordinate == TempPathCoordinateAdjacent) 
        
            68
                                            { 
        
            69
                                                if (TempPathMovementCostG < _path.MovementCostG) 
        
            70
                                                { 
        
            71
                                                    _path.MovementCostG = TempPathMovementCostG; 
        
            72
                                                    _path.MovementCostH = TempPathMovementCostH; 
        
            73
                                                    _path.ParentGridCoordinate = TempPathCoordinateCurrent; 
        
            74
                                                } 
        
            75
             
            76
                                                StepDoesntExist = false; 
        
            77
                                            } 
        
            78
                                        } 
        
            79
             
            80
                                        if (StepDoesntExist) 
        
            81
                                        { 
        
            82
                                            List_OpenList.Add(new Instance_Path(TempPathCoordinateAdjacent, TempPathCoordinateCurrent, TempPathMovementCostG, TempPathMovementCostH)); 
        
            83
                                        } 
        
            84
                                    } 
        
            85
                                } 
        
            86
                            } 
        
            87
                            #endregion 
        
            88
            [SNIP FOR SPACE, SAME AS UP BLOCK ABOVE] 
        
            89
                            #endregion 
        
            90
                            #region Step 2d 
        
            91
                            foreach (Instance_Path _path in List_ClosedList) 
        
            92
                            { 
        
            93
                                if (_path.ElementGridCoordinate == PositionExit)//Vector2.Distance(_path.ElementGridCoordinate, PositionExit) < 1) 
        
            94
                                { 
        
            95
                                    ExitNotReached = !ExitNotReached; 
        
            96
                                    break; 
        
            97
                                } 
        
            98
                            } 
        
            99
             
            100
                            if (List_OpenList.Count() <= 0) 
        
            101
                                ExitNotReached = !ExitNotReached; 
        
            102
                            #endregion 
        
            103
                        } 
        
            104
                        #endregion 
        
            105
                        #region Step 3 
        
            106
                        while (NextStepNotFound) 
        
            107
                        { 
        
            108
                            foreach (Instance_Path _path in List_ClosedList) 
        
            109
                            { 
        
            110
                                if (FinalStepFirstMoveNotSet) 
        
            111
                                { 
        
            112
                                    if (_path.ElementGridCoordinate == PositionExit) 
        
            113
                                    { 
        
            114
                                        //_return.Add(_path.ElementGridCoordinate); 
        
            115
                                         
            116
                                        ReturnStepCurrent = _path.ElementGridCoordinate; 
        
            117
                                        ReturnStepParent = _path.ParentGridCoordinate; 
        
            118
                                        FinalStepFirstMoveNotSet = false; 
        
            119
                                    } 
        
            120
                                } 
        
            121
                                else if (_path.ElementGridCoordinate == _path.ParentGridCoordinate && _path.ElementGridCoordinate == ReturnStepParent) 
        
            122
                                { 
        
            123
                                    _return = ReturnStepCurrent; 
        
            124
                                    NextStepNotFound = false; 
        
            125
                                    break; 
        
            126
                                } 
        
            127
                                else if (_path.ElementGridCoordinate == ReturnStepParent) 
        
            128
                                { 
        
            129
                                    //_return.Add(_path.ElementGridCoordinate); 
        
            130
             
            131
                                    ReturnStepCurrent = _path.ElementGridCoordinate; 
        
            132
                                    ReturnStepParent = _path.ParentGridCoordinate; 
        
            133
                                } 
        
            134
                            } 
        
            135
                        } 
        
            136
                        #endregion 
        
            137
                        #endregion 
        
            138
             
            139
                        return _return; 
        
            140
                    }

EDIT: Needless to say that I've tried several of the suggestions of the article but none really got me anywhere near the numbers where I want to be.

Moving a model in circular rotation with correction Y rotation

Fjotsee — Tue, 17 Nov 2009 13:42:46 GMT

Hi everyone
I am currently stuck on a simple problem. I am moving a model in a circular rotation and need to adjust the facing direction accordingly. Right now i am using this code:

    
            private void UpdateFacingDirection(Vector2 newPos)  
        
            {  
        
                Vector2 normal = Vector2.Transform(newPos, Matrix.CreateRotationZ(MathHelper.ToRadians(90)));  
        
                normal.Normalize();  
        
                float dotP = Vector2.Dot(normal, Vector2.UnitX);              
        
                float calc = (float)Math.Acos((double)dotP);  
        
                this.RotationY = -1.5f + calc;  
        
            }

The 1.5f offset is needed to rotate the model into the right facing direction.

Its working, however when reaching a certain position, it starts to reverse the facing direction, and messing up the rotation.

Any hints to fix this are welcome...

Properties

DualOpAmp29 — Mon, 02 Nov 2009 01:14:57 GMT

Okay, I used to love Access modifiers like "public vector2 getPosition()" But, because XNA uses it so often, I switched to properties, and all my code is written in properties.

Properties are supposed to be better, but I have a persistant problem. When I try to access properties like a vector2, and try to access their variables, I get this error.

error CS1612: Cannot modify the return value of 'XNALibrary.Camera2D.Position' because it is not a variable

It's quite irritating, is there any way to access these variables? Because, otherwise I might switch back to access modifiers.

Here's an example:

    
                public Vector2 Position  
        
                    {  
        
                        get { return this.position; }  
        
                        set { this.position = value; }  
        
                    }

putting together a kitchen cabinet, then translating, rotating

mysdn — Wed, 18 Nov 2009 09:05:36 GMT

Hello, I am designing an interior design application using xna for realtime 3D rendering and Povray for raytracing. In povray I can build a kitchen cabinet as shown in the below skeleton sample. The advantage is, cabinet can be translated as a single entity if it's put together like this. I would like to ask, what would be the best approach to build a cabinet in xna? Is there some way to recreate (in native xna code, not workarounds) the below povray script that will work in xna? Or do I simply have to put all pieces in their correct position and rotation in 3D space? Thank you for reading, any help is appreciated.

//sample, build cabinet in povray,
//could something like this be done in xna?

union{
object{case} scale , rotate, translate
object{door}             "
object{handle}          "
object{ etc.}            "

translate } // as a whole
rotate }    //rotate as a whole

Multiple Random values in one update()/gametime possible?

Glaucuos — Tue, 17 Nov 2009 21:32:27 GMT

I'm creating a 2D Game. I create different creatures, and at some points there will spawn multiple creatures at the same time. In the constructor, I create this following code:

Random Color = new Random();
base._Color = new Color((byte)Color.Next(0, 255), (byte)Color.Next(0, 255), (byte)Color.Next(0, 255), 255);

What this does is that it creates a Random color, which I then use in the SpriteBatch drawing. However, since the seed of a Random class is the current time, all the creatures that spawn at that time will have the same color - because it happens in the same Update().

Is it possible to generate different random values, at the same GameTime?

Edit: My temporary fix, which works quite good, is by creating a seed (which I just understood how to use) from the Position.X of the creature.

Transformed Per-Pixel Collision Detection With Sprite Frame.

DualOpAmp29 — Tue, 17 Nov 2009 14:21:54 GMT

Alright, I'm following along with the 3rd collision detection series (the transformed per-pixel collision detection) I've done the other 2 properly, and they work. But, now I'm having trouble with the transformed collison detection. I've mimmicked the tutorial's code as close as I can see, but it's still not working. The sprite is rotating every frame, but it collides as if there's no rotation in the sprite.

    
            using System;  
        
            using Microsoft.Xna.Framework;  
        
            using Microsoft.Xna.Framework.Graphics;  
        
            using FarseerGames.FarseerPhysics.Dynamics;  
        
            using FarseerGames.FarseerPhysics.Factories;  
        
            using FarseerGames.FarseerPhysics.Collisions;  
        
            namespace XNALibrary  
        
            {  
        
                public static class Collision  
        
                {  
        
                    public static bool PerPixelCollision(Sprite spriteA, Sprite spriteB)  
        
                    {  
        
                        // Data for each pixel.  
        
                        Color[] spriteAData = new Color[spriteA.texture.Width * spriteA.texture.Height];  
        
                        spriteA.texture.GetData(spriteAData);  
        
                        Color[] spriteBData = new Color[spriteB.texture.Width * spriteB.texture.Height];  
        
                        spriteB.texture.GetData(spriteBData);  
        
                        // Transform A.  
        
                        Matrix spriteAMatrix = Matrix.CreateTranslation(new Vector3(-spriteA.Origin, 0.0f)) *  
        
                            //Matrix.CreateScale(spriteA.Scale.X, spriteA.Scale.Y, 1.0f) *  
        
                            Matrix.CreateRotationZ(spriteA.Rotation) *  
        
                            Matrix.CreateTranslation(new Vector3(spriteA.Position, 0.0f));  
        
                        // Transform B.  
        
                        Matrix spriteBMatrix = Matrix.CreateTranslation(new Vector3(-spriteB.Origin, 0.0f)) *  
        
                            //Matrix.CreateScale(spriteB.Scale.X, spriteB.Scale.Y, 1.0f) *  
        
                            Matrix.CreateRotationZ(spriteB.Rotation) *  
        
                            Matrix.CreateTranslation(new Vector3(spriteB.Position, 0.0f));  
        
                        Matrix transformAtoB = spriteAMatrix * Matrix.Invert(spriteBMatrix);  
        
                        for (int yA = 0; yA < spriteA.texture.Height; yA++)  
        
                        {  
        
                            for (int xA = 0; xA < spriteB.texture.Width; xA++)  
        
                            {  
        
                                Vector2 positionInB = Vector2.Transform(new Vector2(xA, yA), transformAtoB);  
        
                                int xB = (int)Math.Round(positionInB.X);  
        
                                int yB = (int)Math.Round(positionInB.Y);  
        
                                if (0 <= xB && xB < spriteB.texture.Width &&  
        
                                    0 <= yB && yB < spriteB.texture.Height)  
        
                                {  
        
                                    // Get the colors of the overlapping pixels  
        
                                    Color colorA = spriteAData[xA + yA * spriteA.texture.Width];  
        
                                    Color colorB = spriteBData[xA + yA * spriteB.texture.Width];  
        
                                    if (colorA.A > 0 && colorB.A > 0)  
        
                                    {  
        
                                        // Collision occured.  
        
                                        return true;  
        
                                    }  
        
                                }  
        
                            }  
        
                        }  
        
                        //}  
        
                        return false;  
        
                    }  
        
                }  
        
            }

Here's the image I'm using for rotation:

My sprite class is a tried-and-tested class, that doesn't seem to have any problems, which is why I think the problem lies here.

Can anyone help?

Remove a list of indexes from list?

UberGeekGames — Mon, 16 Nov 2009 15:50:54 GMT

This is probably something really simple but I haven't been able to find the answer. (one of those "too general of keywords makes searching neraly impossible" problems ;) )

What I have is a list of indexes that I need to remove from a list. My problem is that once I start removing them, it changes the objects that the other indexes point at. For example:

    
            List<Object> objects =new List<Objects>();

            List<int> removalIndexes = new List<int>(); 
        
            for(int i=0;i<objects.Count;i++) 
        
            { 
        
                if(objects[i].MeetsRemovalConditions) 
        
                { 
        
                    removalIndexes.Add(i); 
        
                } 
        
            } 
        
            foreach(int removeIndex in removalIndexes) 
        
            { 
        
                objects.RemoveAt(removeIndex); 
        
            }

Note that this is highly, highly simplified - the first loop is huge and other things are done to the objects inbetween the setting and actual removing so I can't remove the objects in the first loop like I normally would.

Anyway, as you can imagine in the second loop, as soon as it starts iterating the indexes change. I'm guessing there's another, better way of doing this; possibly with a lambda expression? I tried searching for that but couldn't find a way to check based on its index in the list.

I may just have to add a flag to the object itself to check if it needs to be removed, but I'd still like to know if there's a way to do this the way I originally intended, because I like cool C# tricks like this. ;D

Random Number Generator

George Dimitrov — Sat, 07 Nov 2009 23:00:18 GMT

Hi im new to c# and im trying to get the random number generator working, in c++ its done differently and im having trouble finding out how to do it in c# the code the get the variable is:

    
            System.Random RandomEnemyLocationX = new Random(); 
        
            int EnemyLocationX = RandomEnemyLocationX.Next(0,800);

please help thanks :)

QuadTerrain LOD: Finished

Qu — Thu, 07 Aug 2008 02:15:17 GMT

The QuadTerrain LOD (Quadtree Terrain Level of Detail Algorithm) is finished! Actually it's been finished for a while, but the official announcement is this thread. The original thread is over here.

Those who have been following the original thread know what I've been up to, but I'll reiterate and explain this project here in tutorial format.

For those not interested, the summary is this: you can use the downloadable files at the bottom of the page to create a massive terrain complete with Quadtree LOD and easily import it as the ground for your game! Multitexturing, normal mapping and detail mapping are all included in the shader.

The Basics
A terrain is an object or mesh which represents the 'ground' in an outdoor environment. Because it's normally orientated along a flat plane, most terrains can be represented by a heightmap or heightfield, and it is fairly usual to generate the terrain mesh from the heightmap itself.

This is exactly what is done in the Generated Geometry Sample, and in Riemers Series 1 and Series 4.

But a terrain is a very large and complex object. Generating one from a 1024x1024 heightmap results in over a million vertices, which is far too many for an efficient real-time game element.

This is where Level Of Detail (LOD) algorithms come in. An LOD algorithm renders distant objects with less detail, and thus fewer vertices, than close objects. After all, there's no point rendering every rock on a distant cliff face!

There are many different styles of terrain LOD: ROAM, Quadtree, Geomipmapping... even Brute Force (where you just render everything) is a valid method for a good graphics card and a low detail terrain.

This project makes use of a Quadtree method.

The QuadTree
A quadtree is a hierarchical data structure where every object in the structure has 4 children. In 2D space, this translates to a square cut into 4 squares, each of which is cut into 4 more squares, and so on.

In the context of a terrain, suppose you were to accompany each square (quad-nodes) with a mesh, which covers the same area that the square covers. Larger quadnodes would cover large areas, but would have low detail, while small nodes would only cover the immediate area but would render with lots of detail. You could then start at the top 'root' node, and sink down through the tree, sinking further where more detail is needed.

By only rendering the meshes associated with the nodes we sink to (known as 'leaf' nodes), we can cut the detail level of nodes very quickly, especially since we don't need to check any nodes below a leaf node.

The Stitching
Of course, nothing is perfect. Two same sized quadnode meshes next to each other will fit seamlessly, but imagine a high detail node next to a low detail node. The result will be artifacts known as gaps.

This can be fixed by 'stitching', where you either add or remove edge vertices from the nodes so that they match each other. In this case, I removed vertices from the higher detail node, creating a triangle pattern which connects to the lower detail node. In this screenshot, you can see it applied to every edge of every quadnode. In this one, it is applied correctly.

Of course, this isn't as simple as it sounds: each quadnode is now accompanied by 9 meshes, 1 for no stitching, 4 for a single edge stitched, and another 4 for two stitched edges. Since these are generated at runtime, however, they aren't a problem.

The Bounding Frustrums
It isn't only distant objects need to be LODd. Nearby nodes which are not in view because you are looking in the opposite direction need not be rendered at all.

By doing a collision test between the camera's "Bounding Frustrum" (a 3d shape representing the cameras viewport) and a quadnodes bounding box, we can determine which nodes are outside the view and quickly cut a whole heap of geometry from the render. By combining this with the distance testing, we can stop that from sinking further into off-screen nodes as well!

The Multiple Vertex Buffers
One of the things I spent a lot of time on was converting the terrain to run with more than one vertex buffer.

The vertex buffer contains all the vertices read off of the heightmap. In general, it's best to use a single buffer, because each buffer must be rendered with a separate Draw call. Unfortunately, there is a maximum limit to the number of vertices that can be rendered at once on the graphics card, and going above this limit will force the call to be rendered on the CPU (resulting in death by frame rate).

This limit varies, but on my home computer over a million vertices (a 1024x1024 terrain) is just a bit too much.

So, I implemented a nasty and complex algorithm to separate the terrain into a number of vertex buffers, based on the idea that each quadnode could be entirely contained within a parent vertex buffer if we split it correctly. This (eventually) came out well: it is now possible to split your terrain based on a size value. A 1024x1024 terrain split by 512 vertex buffers will come out as 4, 512x512 vertex buffers, with a fifth for all quadnodes which cover an area greater than 512 (only the root node, in this case).

It's worth noting that I may have managed this whilst drunk, tired or otherwise incapacitated, as I cannot remember actually coding it, and have no really idea how or why it works. But it does, and seems to be bug free.

The Global Normal Map
This shader was my first attempt at HLSL (High Level Shader Language), and came out brilliantly in my opinion.

Dynamically changing the geometry can have a nasty effect: although the shape of a low detail node may be very similar to that of a high detail node, the shading can result in a fairly large difference in appearance if done per vertex.

To solve this, I took advantage of the power of HLSL, and told the terrain shader to use a global normal texture rather than per vertex normals. The advantage was twofold: My vertex buffers halved in size, and more importantly shading no longer changes between high and low detail quadnodes.

The Detail Normal Map
Initially, I didn't understand the mathematics behind normal mapping, and thought that by simply adding a detail normal map value to my global value in the shader I could create detail normal mapping. The result looked OK, but it wasn't accurate: the detail normal 'pulled' the global normal upwards. When I tested with a high strength value for the detail normal, this was instantly apparent: the entire terrain was shaded as if it was a lot flatter than it truly was.

It wasn't until after I'd finished the multitexturing that I worked out how to fix this, but when I did the difference was apparent (see below).

The Multitexuring
Using a single texture for the entire terrain has two problems: the terrain is too big to be covered with a single texture with a high enough resolution, and tiling the same ground texture over the entire terrain is very bland. Therefore, I went for a multitexturing approach that made use of a blend texture.

In short, mutitexturing is using more than one texture on the same object, and a blend texture uses it's red, green and blue channels to define the amount of each texture to show. In the sample, Blue represents sand, Green - grass, Red - Foliage and Black displays as Rock.

Quickly back on the subject of Detail Normal Mapping: you can see the difference between my original method, and my final method.

The Versatility
I've done my best to make the QuadTerrain class as versatile as possible, and as a result the different features and the reason for them may take a bit of explaining.

The constructor looks like this:

    
            QuadTerrain q = new QuadTerrain(GraphicsDevice, Effect, HeightMap, QuadNodeSize, VertexBufferSize, XZScale, YScale);

GraphicsDevice - speaks for itself. Plug the Graphics device into this field to provide the Quadterrain a link to it.
Effect - You will need to load the TerrainShader with Content.Load, and provide the resulting effect as this parameter to establish a link between the two.
Heightmap - Load your Heightmap as a Texture2D, and provide it as this parameter.
- IMPORTANT: To create the quadtree structure, your heightmap's dimensions must be square, and of the format 2ⁿ+1.
  - Examples of good dimensions are 257x257, 513x513 and 1025x1025.
QuadNodeSize - The most important versatility element of the class, QuadNodeSize sets the number of vertices along each edge of each Quadnode.
- Increasing the size of this value will decrease the aggressiveness of the LOD, resulting in less CPU work (because the quadtree is not as deep) and a shorter loading time, at the expense of more GPU work (because there will be more polygons to render). A good idea if you are CPU bound.
- Decreasing the size will increase the aggressiveness of the LOD, and will decrease the amount of work being performed on the GPU. The trade-off, as you may have guessed, will be CPU work and a longer loading time. A good idea if you are GPU bound.
- The absolute minimum value for this field is 5: any less will result in an error. The absolute maximum was never tested, but it kind of ruins the whole point of LOD to use a value close to the size of the terrain.
- IMPORTANT: Like the heightmaps dimensions, this value must be of the format 2ⁿ+1.
  - Examples of good values include 17, 33 and 64.
VertexBufferSize - If this value is less than the size of the heightmap, the quad terrain will be split into several vertex buffers, each of which will be rendered with a different draw call.
- In general, a value the same size as the heightmap is recommended, but for a large heightmap it may be necessary to split the Vertex buffer.
- You can get the number of vertices supported on your graphics card with:
  - device.GraphicsDeviceCapabilitie.MaxVertexIndex
- IMPORTANT: Like the last one, this value must be of the format 2ⁿ+1.
  - Examples of good values include the size of your heightmap. :D
XZScale - This is simply the number of distance units between the horisontal positions of consecutive vertices.
- Terrain scaling is a great way to increase the size of the terrain without adding extra load. Consider using a smaller heightmap and increasing this value to compensate if you're having trouble milking good performance out of your game.
YScale - This is the terrain height scaling factor.
- Making this larger will increase the height of your hills and mountains, but be wary: because the heightmap colour can only be an integer between 0 and 255, making this value too high might make smooth changes between hills and flat area's impossible.

The Update command also has a few important fields:

    
            q.UpdateTerrain(CameraPosition, BoundingFrustrum, LODLevel);

CameraPosition - You must plug in a Vector3 representing the XYZ co-ordinates of your camera to allow the terrain to update. This is because the LOD has to know which quadnodes are distant and which ones are near to status them ready for rendering.
BoundingFrustrum - For the frustrum tests, the terrain needs to know the BoundingFrustrum for the camera. Plug it into this field.
LODLevel - A scaling factor which is applied to the distance checks which determine the distance a node must be away from the camera to be considered 'not detailed enough'.
- This value is contained in the update command because, unlike the values in the constructor, the terrain is capable of changing it at runtime. Thus, if your game is running slowly (or if you don't have any performance issues at all), you can dynamically change it to gain performance or improve the visual quality of the terrain.

The Final

Yippy Skippy, the Evil!

The sample is below. To use it in your own game, copy QuadTerrain.cs and TerrainShader.fx into your project, Load the shader, some textures of your own, and add the constructor and update methods! I highly recommend you don't try to build up off of the sample, because it's not great code.

If you want to go into the QuadTerrain.cs code and mess about, go for it! This is my first 'proper' XNA project, so there's no reason to assume I got it all right. Any feedback you can give will be considered and appreciated.

If you use this class (or a modification of it) in your game, give a post in this thread and let me know! I'd love to see what people are doing with it! Mentioning me in your game credits would be nice too, given the time and effort it took me to build this, but you don't have to. :)

And for my final point: The QuadTerrain class is not an excuse to avoid learning how to use Vertex and Index Buffers! Visit Riemers XNA tutorials, Ziggyware, Shawns Blog and all the other sites I can't remember off the top of my head, go though the samples, read and participate in the forums and learn everything you can, and the games you create will be so much better for it!

Download QuadTerrain

Cheers!
Quasar.

Post your JigLibX Vehicle modifications added custom vehicle class

nikescar — Sat, 18 Apr 2009 10:46:25 GMT

I have done quite a few but none better than this ultra simple one that adds rotational friction to the wheels. Before, if you were on level ground, you could coast forever after letting off the throttle.

                            if (driveTorque == 0)         
                {         
                    angVel *= .97f;         
                }            
                       

Put this in Update() in the Wheels.cs right above angVel += driveTorque * dt / inertia. If you want more friction multiply by a smaller number. Less friction use a bigger number that's less than 1.

I have a lot more that I'll add tomorrow.

In the meantime post your mods!

edit:

I know there is a going to be a better way than to multiply angVel by a fraction of one but I'll figure that out after I get some sleep.

edit again:

So, I couldn't sleep. Looking at it again just proves that I should've gone to college.

Here's the updated one:

                                            if (driveTorque == 0)         
                            {         
                                float axleFriction = 5; // higher number = more rotational friction         
                                if (angVel > axleFriction)         
                                {         
                                    if (angVel > 0) angVel -= axleFriction;         
                                    else angVel += axleFriction;         
                                }         
                                else angVel = 0;         
                            }         
                     
                     

Struggling with transformed 2d collision detection

okacat — Sun, 15 Nov 2009 13:28:26 GMT

Hello,

I am trying to get transformed 2d collision detection work for my simple paddle-ball type of game. I used both Remiers tutorials and Collision detection series on this site, both are working with similar results. For testing purposes I set the ball to stop when it collides. I got the collision detection "working" but the point of collision is not where it should be(sometimes above the paddle, sometimes moves right through the paddle,...). I think it has something to do with my matrices. By playing with the matrices I get different collision results but they are never right. Here are my collision parts of the code taken from the Collision detection series.

Part of the Load() code:

    
            //extract collision data 
        
                        ballTextureData = 
        
                            new Color[ball.sprite.Width * ball.sprite.Height]; 
        
                        ball.sprite.GetData(ballTextureData); 
        
                        paddleTextureData = 
        
                            new Color[paddle.sprite.Width * paddle.sprite.Height]; 
        
                        paddle.sprite.GetData(paddleTextureData);

From Update()

    
                        // Build the ball's transform 
        
                        Matrix ballTransform = 
        
                            Matrix.CreateTranslation(new Vector3(-ball.center, 0.0f)) *  

                            Matrix.CreateScale(spriteSize) *   
        
                            Matrix.CreateRotationZ(ball.rotation) * 
        
                            Matrix.CreateTranslation(new Vector3(ball.position, 0.0f)); 
        
                        // Build the paddle's transform 
        
                        Matrix paddleTransform = 
        
                            Matrix.CreateTranslation(new Vector3(-paddle.center, 0.0f)) *  

                            Matrix.CreateScale(spriteSize) *   
        
                            Matrix.CreateRotationZ(paddle.rotation) * 
        
                            Matrix.CreateTranslation(new Vector3(paddle.position, 0.0f)); 
        
                        if (IntersectPixels(paddleTransform, paddle.sprite.Width, 
        
                                                    paddle.sprite.Height, paddleTextureData, 
        
                                                    ballTransform, ball.sprite.Width, 
        
                                                    ball.sprite.Height, ballTextureData)) 
        
                        { 
        
                            ball.velocity = new Vector2(0, 0); 
        
                        }

The Draw() code:

    
            spriteBatch.Draw(paddle.sprite, 
        
                            paddle.position, 
        
                            null, 
        
                            Color.White, 
        
                            paddle.rotation, 
        
                            paddle.center, spriteSize, 
        
                            SpriteEffects.None, 0); 
        
                        spriteBatch.Draw(ball.sprite, 
        
                            ball.position, 
        
                            null, 
        
                            Color.White, 
        
                            0.0f, //rotation 
        
                            paddle.center, spriteSize, 
        
                            SpriteEffects.None, 0);

I calculate the origin the same way as in the collision series tutorial, by dividing sprite height and sprite width.

Any help would be greatly appreciated.

1	#region GAMEPAD
2	// PC Gamepad Controls Logic added here
3
4	lastGamePadState = currentGamePadState;
5	currentGamePadState = TestingGrounds.PCGamePad.GetState(PlayerIndex.One);
6
7	// Allows the game to exit
8	if (TestingGrounds.PCGamePad.GetState(PlayerIndex.One).Buttons.Start == ButtonState.Pressed)
9	this.Exit();
10
11	// Allows the game to exit
12	if (lastGamePadState.Buttons.Select == ButtonState.Released &&
13	currentGamePadState.Buttons.Select == ButtonState.Pressed)
14	{
15	this.Exit();
16	}
17
18	// Change the sprite 2 position using the D-Pad
19	if (TestingGrounds.PCGamePad.GetState(PlayerIndex.One).DPad.Up)
20	Smiley2.position += new Vector2(0, -5);
21
22	// Change the sprite 2 position using the left thumbstick
23	Vector2 LeftThumb = TestingGrounds.PCGamePad.GetState(PlayerIndex.One).Thumbsticks.Left;
24	Smiley2.position += new Vector2(LeftThumb.X, LeftThumb.Y) * 10; // # represents the speed of movement
25
26	#endregion

1	using System;
2	using System.Collections.Generic;
3	using System.Linq;
4	using System.Text;
5
6	namespace Labryinth_Hunter
7	{
8	class CObjectManager
9	{
10	private List<CBaseObject> m_lAllObjects;
11
12
13	public void Update(float fGameTime)
14	{
15	foreach (CBaseObject Obj in m_lAllObjects)
16	{
17	Obj.Update(fGameTime);
18
19	//More should go in here it seemes most likley the collision
20	//code itself. I am considering creating a bsp for the
21	//collision system, and then sending a message to The specified
22	//object if thier is a collision. I am not entiely sure how many
23	//objects Should be checked for collisions. My gut instict
24	//tells me all of them. However I know this is wrong.
25	//If I remember correctly you check the player against the
26	//objects that are in the bso tree with them.
27	}
28	}
29
30	private bool AddObject(ref CBaseObject PassedInObj)
31	{
32	//Search for the object in our existing list of all objects
33	try
34	{
35	foreach (CBaseObject CurrentObj in m_lAllObjects)
36	{
37	if (CurrentObj.Equals(PassedInObj))
38	throw new System.InvalidOperationException(" The object
39	is already in the arry and was there for not added.");
40	}
41	}
42	catch(System.InvalidOperationException ex)
43	{
44	System.Console.WriteLine(ex);
45	return false;
46	}
47	//Since the object was not in our list of objects to begin with we
48	//can add it to our list of objects in the game
49	m_lAllObjects.Add(PassedInObj);
50	m_lAllObjects.Sort(delegate(CBaseObject Obj1, CBaseObject Obj2)
51	{ return Obj1.ObjRenderState.nValue.CompareTo
52	(Obj2.ObjRenderState.nValue); });
53	return true;
54	}
55	private bool RemoveObject(ref CBaseObject PassedInObj)
56	{
57	//Search for the object in our existing list of all objects
58	try
59	{
60	foreach (CBaseObject CurrentObj in m_lAllObjects)
61	{
62	if (CurrentObj.Equals(PassedInObj))
63	throw new System.InvalidOperationException(" The object
64	is not in the array.");
65	}
66	}
67	catch (System.InvalidOperationException ex)
68	{
69	System.Console.WriteLine(ex);
70	return false;
71	}
72
73	//We can now remove the passed in object since we have clarified it
74	//is in our list.
75
76	m_lAllObjects.Remove(PassedInObj);
77	return true;
78	}
79	}
80	}
81

1	public static Vector2 FindPathAstarBasic(Vector2 _coordinateCurrent, Vector2 _coordinateExit)
2	{
3	Vector2 _return = Vector2.Zero;
4
5	#region AI
6	#region Step 0
7	List<Instance_Path> List_OpenList = new List<Instance_Path>();
8	List<Instance_Path> List_ClosedList = new List<Instance_Path>();
9
10	Vector2 PositionCurrent = _coordinateCurrent;
11	Vector2 PositionExit = _coordinateExit;
12
13	Instance_Path TempPathContainer;
14
15	Vector2 TempPathCoordinateCurrent;
16	Vector2 TempPathCoordinateAdjacent;
17	int TempPathMovementCostG;
18	int TempPathMovementCostH;
19
20	bool ExitNotReached = true;
21	bool NextStepNotFound = true;
22	bool FinalStepFirstMoveNotSet = true;
23	bool StepDoesntExist = true;
24
25	Vector2 ReturnStepParent = Vector2.Zero;
26	Vector2 ReturnStepCurrent = Vector2.Zero;
27	#endregion
28	#region Step 1
29	List_OpenList.Add(new Instance_Path(PositionCurrent, PositionCurrent, 0, 0));
30	#endregion
31	#region Step 2
32	while (ExitNotReached)
33	{
34	#region Step 2a
35	TempPathContainer = new Instance_Path(Vector2.Zero, Vector2.Zero, 999999, 999999);
36	foreach (Instance_Path _path in List_OpenList)
37	{
38	if (_path.MovementCostG + _path.MovementCostH < TempPathContainer.MovementCostG + TempPathContainer.MovementCostH)
39	{
40	TempPathContainer = _path;
41	}
42	}
43	#endregion
44	#region Step 2b
45	List_OpenList.Remove(TempPathContainer);
46	List_ClosedList.Add(TempPathContainer);
47	#endregion
48	#region Step 2c
49	#region Up
50	TempPathCoordinateCurrent = TempPathContainer.ElementGridCoordinate;
51	TempPathCoordinateAdjacent = TempPathCoordinateCurrent - new Vector2(0, 1);
52	TempPathMovementCostG = TempPathContainer.MovementCostG + 10;
53	TempPathMovementCostH = CalculateHeuristicManhattan(TempPathCoordinateAdjacent, PositionExit);
54
55	if (TempPathCoordinateAdjacent.X >= Game.Manage_Players.List_Players[0].GridBoundaries.X &&
56	TempPathCoordinateAdjacent.X <= Game.Manage_Players.List_Players[0].GridBoundaries.Z - 1 &&
57	TempPathCoordinateAdjacent.Y >= Game.Manage_Players.List_Players[0].GridBoundaries.Y &&
58	TempPathCoordinateAdjacent.Y <= Game.Manage_Players.List_Players[0].GridBoundaries.W - 1)
59	{
60	if (Game.Manage_Obstructions.CheckObstruction(TempPathCoordinateAdjacent))
61	{
62	if (!List_ClosedList.Exists(delegate(Instance_Path I) { return I.ElementGridCoordinate == TempPathCoordinateAdjacent; }))
63	{
64	StepDoesntExist = true;
65	foreach (Instance_Path _path in List_OpenList)
66	{
67	if (_path.ElementGridCoordinate == TempPathCoordinateAdjacent)
68	{
69	if (TempPathMovementCostG < _path.MovementCostG)
70	{
71	_path.MovementCostG = TempPathMovementCostG;
72	_path.MovementCostH = TempPathMovementCostH;
73	_path.ParentGridCoordinate = TempPathCoordinateCurrent;
74	}
75
76	StepDoesntExist = false;
77	}
78	}
79
80	if (StepDoesntExist)
81	{
82	List_OpenList.Add(new Instance_Path(TempPathCoordinateAdjacent, TempPathCoordinateCurrent, TempPathMovementCostG, TempPathMovementCostH));
83	}
84	}
85	}
86	}
87	#endregion
88	[SNIP FOR SPACE, SAME AS UP BLOCK ABOVE]
89	#endregion
90	#region Step 2d
91	foreach (Instance_Path _path in List_ClosedList)
92	{
93	if (_path.ElementGridCoordinate == PositionExit)//Vector2.Distance(_path.ElementGridCoordinate, PositionExit) < 1)
94	{
95	ExitNotReached = !ExitNotReached;
96	break;
97	}
98	}
99
100	if (List_OpenList.Count() <= 0)
101	ExitNotReached = !ExitNotReached;
102	#endregion
103	}
104	#endregion
105	#region Step 3
106	while (NextStepNotFound)
107	{
108	foreach (Instance_Path _path in List_ClosedList)
109	{
110	if (FinalStepFirstMoveNotSet)
111	{
112	if (_path.ElementGridCoordinate == PositionExit)
113	{
114	//_return.Add(_path.ElementGridCoordinate);
115
116	ReturnStepCurrent = _path.ElementGridCoordinate;
117	ReturnStepParent = _path.ParentGridCoordinate;
118	FinalStepFirstMoveNotSet = false;
119	}
120	}
121	else if (_path.ElementGridCoordinate == _path.ParentGridCoordinate && _path.ElementGridCoordinate == ReturnStepParent)
122	{
123	_return = ReturnStepCurrent;
124	NextStepNotFound = false;
125	break;
126	}
127	else if (_path.ElementGridCoordinate == ReturnStepParent)
128	{
129	//_return.Add(_path.ElementGridCoordinate);
130
131	ReturnStepCurrent = _path.ElementGridCoordinate;
132	ReturnStepParent = _path.ParentGridCoordinate;
133	}
134	}
135	}
136	#endregion
137	#endregion
138
139	return _return;
140	}