XNA 101 .Net

This blog is moving... and being updated to XNA 3.0

Thu, 09 Oct 2008 23:16:43 GMT

I've been asked for a while now to update these tutorials to a more recent version of XNA, and I've finally decided with the release of XNA 3.0 Beta to go ahead and do that. The new posts will be at the following address:

http://www.bluerosegames.com/xna101

and the RSS feed is at:

http://feeds.feedburner.com/xna101

I'll leave these posts here for reference but all of these tutorials will eventually be available at the new site.

XNA Community Games on the 360, and coming to a Zune near you!

Wed, 20 Feb 2008 20:37:47 GMT

Microsoft just had their GDC keynote address, and boy was it big for XNA.

Microsoft has announced plans to let XNA Creators Club developers write games that any XBox Live subscriber can play, and it's community based. Games developed by the community, peer reviewed by the community, and distributed to the community. I've been dying for a viable distribution mechanism to the masses for XNA, and it looks like we are going to have one.

Add to this Scott Guthrie's post yesterday about the .Net product roadmap:

http://weblogs.asp.net/scottgu/archive/2008/02/19/net-3-5-client-product-roadmap.aspx

where packaging of applications using the .NET framework is going to get a lot easier, and it's all good news for XNA.

Add on top of that a surprise announcement of Zune game development using XNA Game Studio, and it's pretty exciting.

More details here, http://creators.xna.com/whatsnew.aspx, looks like we're supposed to see a beta of a lot of this "in the spring" of 2008.

Announcing the new Farseer Physics Engine for XNA Game Studio and Silverlight 1.1

Wed, 03 Oct 2007 17:52:13 GMT

I've had the pleasure of working with Jeff Weber over the last couple of weeks porting the new release of his Farseer Physics Engine to Silverlight 1.1 and I'm happy to announce that Jeff released the new XNA and Silverlight versions this morning.

Just to be completely clear, Jeff did most of the work on this, I was just happy to help out by doing the Silverlight port.

You can get the code here: http://www.codeplex.com/FarseerPhysics/Release/ProjectReleases.aspx

and you can see the Silverlight demos here: http://www.bluerosegames.com/farseersilverlightdemos

Introduction

The Farseer Physics Engine is an easy to use 2D physics engine designed for Microsoft’s XNA and Silverlight platforms. The Farseer Physics Engine focuses on simplicity, useful features, and enabling the creation of fun, dynamic games.

Features

General
- Easy To Use!
- Support for XNA (XBOX 360 and Windows)
- Support for Silverlight (1.1 and above)
- Support for Managed .Net Languages In General
Collison
- Concave and Convex Polygons Supported
- Multiple Collision Geometries Per Body
- Collision Categories For Complex Interaction Between Physics Objects
- Collision Callback Mechanism
Dynamics
- Joints
  - Revolute Joint (body to body or fixed to world)
  - Angle Joint (body to body or fixed to world)
  - Slider (Prismatic) Joint
  - Pin (Distance) Joint
- Force Controllers
  - Linear Spring
  - Angular Spring
  - Easy To Build Custom Force Controllers (Explosions, Steering Behaviors, etc.)
Support and Debugging
- Samples Framework With Samples Covering Most Major Engine Features. (XNA and Silverlight versions)
- Debug Viewer To View All Major Physics Objects (part of samples framework)
- User Manual (in progress)

GameFest videos now available

Sun, 26 Aug 2007 19:30:01 GMT

For those who weren't able to watch the webcasts live from the first day of GameFest, they are now available here:

http://creators.xna.com/Headlines/presentations/

There is some good information on the next release of XNA Game Studio, especially Networking support.

Relaunch of my Blue Rose Games web site

Fri, 10 Aug 2007 03:29:24 GMT

I've been working on consolidating all of my various game related materials into a single site, and I still have a bit to go, but I have updated my Blue Rose Games site at http://www.bluerosegames.com with a fresh look and more information. I'll be adding the rest of my content over the next couple of weeks.

As for new XNA related information, I have a few tutorials in the works as well as a couple of other projects I can't disclose at this point, and I'll be at GameFest 2007 next week so I'm sure I'll have some information to share after that.

Using Origin with SpriteBatch.Draw (Part 2)

Tue, 10 Apr 2007 20:02:46 GMT

Completed source code for this tutorial: http://www.bluerosegames.com/brg/OriginTutorial2.zip

In part 1 of this tutorial, I covered how to use the origin parameter of the SpriteBatch.Draw call to draw a sprite around its center and to rotate around that point. I also showed how the origin values are independent of the destination scale of the drawing. This tutorial will build upon the project from part 1.

Part 2 covers another use for the origin parameter.

Let's say we want to create a complex sprite, or a sprite composed of overlaying multiple textures. Ideally we would want to control the position of all of these sprites with a single position field, so that if we update that position, all drawing calls for the sprite will be updated to reflect this position. A good example of this would be if you had a warrior in a 2D RPG game, and wanted to allow the warrior to hold many different types of weapons, and you didn't want to have a separate texture of the warrior for each weapon.

You could create a texture for each weapon with whitespace or padding around it so that it lines up properly with the warrior texture, but this padding takes up video memory and can make it more difficult to create the weapon textures. By giving the weapon draw call a different origin from the warrior, we can handle the offset of the overlay.

In our case, I would like to overlay a shadow on the soccer ball. An overlay makes sense in this case since I don't want the shadow to rotate as the soccer ball rotates. Here is the shadow image:

Save the shadow image as soccer_ball_shadow.png and add it to the project. Now in the Ball class, add the following fields:

    public static Texture2D ShadowTexture;
    public static Vector2 ShadowOrigin;

These fields will store the texture and the origin for the shadow. Now in the Ball.Draw() method, add the following after the other Draw call:

    spriteBatch.Draw(ShadowTexture, Position, null, Color.White, 0, ShadowOrigin, Scale, SpriteEffects.None, 0);

It needs to be after the other Draw call so that it is drawn on top of the other texture. So now we just need to initialize these new fields in the Game1.LoadGraphicsContent method, as follows:

    Ball.ShadowTexture = content.Load<Texture2D>("soccer_ball_shadow");
    Ball.ShadowOrigin = Ball.Origin + new Vector2(-30, -60);

Note that the shadow's origin is offset from the ball's origin by 30 pixels on the X axis and 60 pixels on the Y axis. This is because the shadow image is smaller than the ball image and needs to be shifted to the left and down to line up properly.

Now if you run the program again, you should see the shadow show up on both soccer balls in the proper position.

Thank you for your support

Mon, 09 Apr 2007 00:38:52 GMT

I am pleased to announce that because of my work here as well as my other work in the XNA community that I have been named a Microsoft Most Valuable Professional (MVP) for XNA. Microsoft MVPs are people who are recognized for their contributions in the community. You can read more about the MVP program here:

https://mvp.support.microsoft.com/default.aspx

Thank you for your continued support and I hope that this award can help me provide better support to the community going forward.

Using Origin with SpriteBatch.Draw (Part 1)

Sat, 07 Apr 2007 00:21:33 GMT

Source code for finished tutorial: http://www.bluerosegames.com/brg/origintutorial1.zip

There are seven variations of the SpriteBatch.Draw method, and three of them accept an origin as one of the parameters. This tutorial explains some of the useful behaviors of the origin parameter and how it can help you write your game.

For this tutorial, we'll create a new project called "Origin" of type "Windows Game".

Now let's say we want to draw a ball on the screen. This is pretty straightforward, and is one of the first programs most people will write in XNA. Here is a simple class for drawing a ball using one of the Draw methods that accepts an origin as one of the parameters:

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;

class Ball
{
    public Vector2 Position;
    public Vector2 Scale = Vector2.One;
    public float Rotation;
    public static Texture2D BallTexture;
    public static Vector2 Origin = Vector2.Zero;

    public void Draw(SpriteBatch spriteBatch)
    {
        spriteBatch.Draw(BallTexture, Position, null, Color.White, Rotation, Origin, Scale, SpriteEffects.None, 0);
    }
}

Notice that the Origin field defaults to Vector2.Zero, which will make this class, by default, behave as if an origin value wasn't specified.

For the ball texture, I was playing a little bit with Microsoft's new Expression Design software which is a drawing program. I was going for a cartoony-type look for the soccer ball. Save this ball image as soccer_ball.png and add it to your project.

Now to call this class from our Game class. Add the following to the Game1 declarations:

SpriteBatch spriteBatch;
Ball ball1 = new Ball();

In the Game1.LoadGraphicsContent method, inside the loadAllContent block, add the following:

Ball.BallTexture = content.Load<Texture2D>("soccer_ball");
ball1.Position = new Vector2(150, 150);
spriteBatch = new SpriteBatch(graphics.GraphicsDevice);

And then in the Game1.Draw method, add this:

spriteBatch.Begin();
ball1.Draw(spriteBatch);
spriteBatch.End();

Run the program. It should look something like this:

Now what if we want to rotate the ball so that it looks like it's spinning? Add the following line to the Update method:

ball1.Rotation += (float)(gameTime.ElapsedGameTime.TotalSeconds * 3);

And run the program again. You should notice that this isn't really the effect we were looking for. The ball is rotating around its top left corner intead of around its center. In order to make the ball rotate around its center, we can set its origin to half of its width and half of its height. In the Game1.LoadGraphicsContent method, add the following:

Ball.Origin = new Vector2(Ball.BallTexture.Width / 2, Ball.BallTexture.Height / 2);

Now run the program again. The ball should now rotate about its center. The ball is also being drawn higher and more to the left of the screen, since by setting the origin, the position of the ball also takes the origin into account, so the position of the origin is at the position specified in the draw call.

OK so now for a second ball that's scaled by a power of 2. Declare a ball2 in the Game1 class as follows:

Ball ball2 = new Ball();

In the Game1.LoadGraphicsContent method add the following:

ball2.Position = new Vector2(500, 300);
ball2.Scale = new Vector2(2, 2);

And in the Game1.Update method add this:

ball2.Rotation += (float)(gameTime.ElapsedGameTime.TotalSeconds * 4);

And finally in the Game1.Draw method, add the draw call for the second ball.

ball2.Draw(spriteBatch);

Run the program again, is this surprising? We didn't scale the origin but the ball still spins around its center. This is because the origin parameter is specified in source pixels. This is a bit confusing at first, but is nice because no matter how we scale the destination, the origin will stay in the same relative position. This is very useful if we're scaling our sprites based on game surface resolution to fill the screen.

Moving Forward

Sat, 10 Mar 2007 02:45:29 GMT

I've been having a problem with how I have been doing this blog so far, because I kind of painted myself into a corner by adding on to the current project with each lesson. So when I haven't been ready to add a new feature to the current game, I had to wait to post a new entry. This resulted in a long delay between blog entries.

So going forward, this is how I'm going to try to manage the blog. If I have one-off topics to post about, like the enhancement to the Font Sample, I'll post them without a lesson number. When I post the final few tutorials in the Air Hockey sequence, I'll number them so that it is clear as to the order of those tutorials.

Thank you for your continued support, and I hope that these changes will allow me to post about unrelated topics while preparing the final lessons in the Air Hockey game.

Improving the Font Sample on Creators Club Online

Fri, 09 Mar 2007 18:50:38 GMT

One of the new samples on the XNA Creators Club Online (http://creators.xna.com) is a sample for rendering text in your game. I had created something very similar to this myself, as have a few others, since it's a pretty common need.

The Font Sample allows you to create a bitmapped font or import a font from the fonts on your computer and then use it to draw text. This functionality is going to be in the April XNA update, but for now it's a good alternative.

There was one thing, however, that was missing from the Font Sample that I had in my text rendering code that I thought would be useful, and that is a way to rotate the text. If you add the following method to the Font class in the Font sample, you will then be able to pass a rotation value (in radians) into the Draw method.

public void Draw(string text, Vector2 position, float scale, float rotation, Color color, SpriteBatch spriteBatch)
{
   Vector2 origin = Vector2.Zero;
   Vector2 curOrigin = Vector2.Zero;
   foreach (char ch in text)
   {
      // Look up what font glyph corresponds to this Unicode character.
      int index;
      if (!characterMap.TryGetValue(ch, out index))
         index = glyphData.Count - 1;

      // Look up what part of the texture represents this character.
      Rectangle glyph = glyphData[index];
      Rectangle cropping = croppingData[index];
      curOrigin.X = origin.X - cropping.X;
      curOrigin.Y = origin.Y - cropping.Y;
      // Draw the character.
      spriteBatch.Draw(textureValue, position, glyph, color, rotation,
            curOrigin, scale, SpriteEffects.None, 0);

      // Move the origin further to the left, because the origin is relative to the current letter.
      origin.X -= cropping.Width;
   }
}

If you wanted to rotate around a different point, you could create a new method which would take the origin as one of the parameters and use that instead of Vector2.Zero as your starting origin.

Here is a screen shot of a modified FontSample program with some text rotated:

XNA Creators Club Online

Fri, 09 Mar 2007 18:47:36 GMT

There is a new web site from the XNA team called XNA Creators Club Online. The url is http://creators.xna.com and it includes code samples, forums, links to resources, a new Starter Kit, and more.

Go check it out!

Sorry for the Hiatus

Sat, 27 Jan 2007 13:28:56 GMT

It's been a while since I've posted here and I just wanted to let everyone know that I haven't abandoned this blog.

Real life (work) has gotten in the way a bit (wish I could do this full time but something has to pay the bills) and I've been spending all of my free time creating an XNA project called XNAStage. You can find the XNAStage project at http://www.codeplex.com/xnastage and it basically came from the need to do splash intro screens and dialog boxes in an easier way.

Basically what XNAStage does is let you give a start state and an end state and a start time and an end time for a sprite and XNAStage will fill in the gaps. This is typically called "tweening" in Flash or other similar technologies. For example, you can give a starting position and an ending position for a sprite and it will move smoothly between the positions and stop once it gets there. The same can be done with color tinting and fading, and pretty much anything else you can think of a tween for. You can get some samples of XNAStage here: http://www.bluerosegames.com/brg/XnaStageSamples.zip

The next lesson will incorporate the XNAStage library into the air hockey game and we will use it for a game over screen.

South Florida .NET Code Camp 2007

Tue, 09 Jan 2007 21:08:26 GMT

Just a quick note letting everyone know that I'll be doing a session at the South Florida .NET Code Camp on February 10, 2007 in Miramar, Florida. If you've never been to a Code Camp, it's an unusual event in that local speakers (especially those with little or no speaking experience) are given first choice, followed by regional and big name speakers, and finally the regular Microsoft speakers. I'll post up my presentation materials and samples afterward.

For more information and registration, go to http://codecamp07.fladotnet.com/codecamp.aspx, hope to see you there!

Lesson 26: Mixing 2D and 3D

Sun, 07 Jan 2007 04:01:33 GMT

Source for this lesson: http://www.bluerosegames.com/brg/XnaLesson26.zip

When developing a 3D game, there will be occasions where some visuals you want to display are easier done with 2D graphics. It may be a scoreboard, a heads-up-display, a health meter, or crosshairs for a gun, or something totally different. In XNA, 2D and 3D graphics can be displayed simultaneously as long as certain care is taken.

For the air hockey game, let's use 2D sprites to display the score. I have generated this image which is meant to look like numbers on an LED display:

The image has a trasparent background. Save the image to your computer as lednumbers.png and add it to your project.

Notice that all of the numbers are in the same image. This technique is one of the easiest and best ways to implement sprite animation. Each part of the image could just as easily be different positions of a running plumber in a red hat or the frames of an explosion.

So just like in our 2D examples previously, we need a SpriteBatch object. In the Game1 Field declarations add the following:

SpriteBatch spriteBatch;

and then in the Game1.Initialize() method, we can instantiate the SpriteBatch object as follows:

spriteBatch = new SpriteBatch(graphics.GraphicsDevice);

Now we need the logic to draw the numbers. As we did with the BouncingBall class, let's create a class to hold the logic related to drawing the numbers. Create a new class called LedDisplay. The code for the LedDisplay class should look as follows:

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;

namespace AirHockey
{
   class LedDisplay
   {
      public static Texture2D Texture;
      private int _value;
      public Vector2 Position;
      Rectangle _sourceRect;

      public int Value
      {
         set
         {
            _value = value;
            _sourceRect = new Rectangle(_value * 60, 0, 60, 90);
         }
      }

      public void Update(int value)
      {
         Value = value;
      }

      public void Draw(SpriteBatch spriteBatch)
      {
         spriteBatch.Draw(Texture, Position, _sourceRect, Color.White);
      }
   }
}

Some of this code should look familiar. There are a couple of differences, we are using a different variation of the SpriteBatch.Draw() method which accepts a source rectangle which defines what portion of the source texture we want to draw. The source rectangle is determined by the value of Value, which will control which number is displayed. Since each "frame" in our animation is 60 pixels wide and 90 pixels high, the X value of the top left corner of the source rectangle is equal to the width of a frame times the value to display. When Value is 0, X is 0. When Value is 1, X is 60, and so on. So from the Game1 class, by simply setting the Value property, the source rect parameters will be automatically set to the correct values.

Now in the Game1 class, we need two LedDisplay objects, one for each score. In the Game1 Field declarations add the following:

LedDisplay playerScoreDisplay;
LedDisplay computerScoreDisplay;

and then we need to instantiate and initialize these objects. In the Game1.Initialize() method, add the following:

playerScoreDisplay = new LedDisplay();
playerScoreDisplay.Position = new Vector2(25, 25);
playerScoreDisplay.Value = 0;
computerScoreDisplay = new LedDisplay();
computerScoreDisplay.Position = new Vector2(715, 25);
computerScoreDisplay.Value = 0;

And in the Game1.LoadGraphicsContent() method, we need to load the Texture that contains the number and associate it with the LedDisplay class. Since it's a static Field in the class, we only have to associate it with the class and not a specific instance of the class. So in the Game1.LoadGraphicsContent() method, inside the conditional block, add the following statement:

LedDisplay.Texture = content.Load<Texture2D>("lednumbers");

Now to draw the scores. In the Game1.Draw() method, just before the base.Draw(gameTime); statement, add this:

spriteBatch.Begin();
playerScoreDisplay.Draw(spriteBatch);
computerScoreDisplay.Draw(spriteBatch);
spriteBatch.End();

We haven't yet added the logic to tie the actual scores to these objects, but we can at least see how it looks dsiplaying zeroes. Run the program and see how it looks.

Well the numbers look good, but what happened to our paddles and table? The answer is that the SpriteBatch uses render state settings that are very efficient for drawing 2D sprites but are not capable of correctly rendering 3D models. When spriteBatch.Begin() is called, the spriteBatch object set the render state settings to what it likes best, and then leaves them that way. Fortunately we can tell the SpriteBatch to set things back the way they were after it's done (when SpriteBatch.End() is called).

To do this, change the SpriteBatch.Begin(); statement in the Game1.Draw() method to look like this:

spriteBatch.Begin(SpriteBlendMode.AlphaBlend, SpriteSortMode.Deferred, SaveStateMode.SaveState);

The first two arguments are just set to the defaults, the important one is the third. It tells the SpriteBatch to save off the current render settings and then restore them when done. Now run it again and it should look better.

So now to update the scores when someone scores. In the Game1.CheckForScore() method, just after the computerScore++; statement add the following:

computerScoreDisplay.Value = computerScore % 10;

The % sign is a "mod" operator where the value is divided by the number specified and the result is set to the remainder of the division. Since we only have a single digit display, we can only display 0 to 9. By doing this mod operator, the display will start over at 0 when it gets greater than 9. This won't matter later since the first player to 7 will win, but for now this will keep the display from displaying invalid results. Now do the same for the player's score by adding the following line after the playerScore++; statement:

playerScoreDisplay.Value = playerScore % 10;

Now when you score a goal (or the computer scores) you should see the score get updated. The final result should look something like this:

Lesson 25: Improving the Collision Handling

Fri, 05 Jan 2007 03:53:10 GMT

Source code for this lesson: http://www.bluerosegames.com/brg/XnaLesson25.zip

Sometimes (actually pretty regularly) you get to a point in a program where you're just not happy with how something works. In my effort to keep the collision handling simple, I had the unfortunate side effect of the puck getting jammed frequently against the wall by the paddle. The code in this lesson will attempt to alleviate some of this. The changes are just a few lines of code, but sometimes a small change can make a big difference.

In the Game1.Update() method, add the lines in red:

if (CollisionHandler.CheckForCollisionXZ(roPuck, roPlayerPaddle) == false)
{
   playerPaddle.Position = roPlayerPaddle.Position;
}
else
{
   playerPaddle.TargetPosition = playerPaddle.Position;
}
if (CollisionHandler.CheckForCollisionXZ(roPuck, roComputerPaddle) == false)
{
   computerPaddle.Position = roComputerPaddle.Position;
}
else
{
   computerPaddle.TargetPosition = computerPaddle.Position;
}

These new lines make it so that if there will be an overlap by repositioning the paddle, we will instead set the paddle's TargetPosition to the current position. By doing this, we give the puck the rest of the Update cycle to get out of the way. If we're near the end of the Update cycle, we may need the next cycle as well to clear the puck, but it's quick enough that the player won't notice.

Lesson 24: Controlling the Computer Paddle

Wed, 03 Jan 2007 03:12:42 GMT

Source code for lesson 24: http://www.bluerosegames.com/brg/XnaLesson24.zip

In Lesson 21, we added code to control the player's paddle based on mouse movements. In this lesson, we will add some simple logic to control the computer's paddle based on the puck's position.

Artificial Intelligence (AI) is a general term which is used to describe the logic put in place to make the computer exhibit behaviors that mimic the behaviors of living creatures. In our case, we need to mimic the behavior of an air hockey player. First, we need to come up with a set of rules that we can turn into code. These rules can be very complex based on how intricate the behvior that we are trying to mimic is. If we wanted to mimic a professional air hockey player, we would have to research all of the advanced techniques involved in air hockey and write code to perform these techniques. For this beginner game, we'll keep the rules much simpler. These are the rules we will use:

1. If the center of the puck is anywhere on the player's side of the table or in the first 10 inches of the computer's side, set computer paddle's target position to its "home defensive position" at (0, 0, -23).

2. Otherwise if the puck is in the area 10 inches away from center ice to 20 inches away from center ice, set the computer paddle's target position to the puck's center position.

3. Otherwise do the following:

a. If the puck is to the left (from the player's perspective) of the "left defensive position" at (-hockeyTable.GoalRadius, 0, -32f) set the computer paddle's target position to its "left defensive position".

b. Otherwise if the puck is to the right (again from the player's perspective) of the "right defensive position" at (hockeyTable.GoalRadius, 0, -32f) set the computer paddle's target position to its "right defensive position".

c. Otherwise set the puck's target position to the "home defensive position".

Now to implement these rules. First let's define 3 new Vector3 Fields in the Game1 class to hold the home, left, and right defensive positions. In the Game1 declarations, add the following:

Vector3 computerHomePosition;
Vector3 computerLeftPosition;
Vector3 computerRightPosition;

and in the Game1.Initialize() method add the following to initialize the values of the computer defensive positions:

computerLeftPosition = new Vector3(-hockeyTable.GoalRadius, 0, -32f);
computerRightPosition = new Vector3(hockeyTable.GoalRadius, 0, -32f);
computerHomePosition = new Vector3(0, 0, -23f);

Now that we have these positions defined and initialized, we can add a method to the Game1 class which will execute the rules we defined above. Let's call the method DoComputerAI() and it will look like this:

void DoComputerAI()
{
   Vector3 targetPosition;
   if (puck.Position.Z > -10f)
   {
      targetPosition = computerHomePosition;
   }
   else if (puck.Position.Z > -20f)
   {
      targetPosition = puck.Position;
   }
   else
   {
      if (puck.Position.X < computerLeftPosition.X)
      {
         targetPosition = computerLeftPosition;
      }
      else if (puck.Position.X > computerRightPosition.X)
      {
         targetPosition = computerRightPosition;
      }
      else
      {
         targetPosition = computerHomePosition;
      }
   }
   // make sure that the computer paddle's target position is still on the table and not jamming the puck against a wall.
   float maxX = (hockeyTable.Width / 2f) - computerPaddle.Radius - puck.Radius - 2f;
   float minX = - maxX;
   if (targetPosition.X > maxX)
   {
      targetPosition.X = maxX;
   }
   else if (targetPosition.X < minX)
   {
      targetPosition.X = minX;
   }
   computerPaddle.TargetPosition = targetPosition;
}

Notice the extra code at the end of the method. Instead of checking throughout the method to make sure that the target position is valid, we can check it once at the end and fix it appropriately.

Now to call this method. In the Game1.Update() method, after the HandleMouse(); statement, add the following:

DoComputerAI();

So now every time we enter the Update loop, the target position of the computer paddle will be recalculated. Run the program. You will probably notice a problem. It looks like the computer's AI rules are a bit too good, and you will have a hard time scoring a goal. To make it a bit easier to play, let's slow down the computer's paddle. If you look in the Paddle class, you'll see the following:

public static float MaxVelocity = 200f;

Since the MaxVelocity is static, both paddles have the same max velocity. Remove the "static" keyword from the above line. Now we will be able to set the max velocities of the paddles independently. In the Game1.Initialize() method, add the following statement:

computerPaddle.MaxVelocity = 50f;

This should give you a fighting chance. Run the program again and try your luck. One last thing...we had some test code in the Game1.HandleMouse() method to reset the puck if we right clicked the mouse. We don't need that code any more so you can remove it. Just delete the "if" statement and its accompanying conditional block.

Share what you're working on and what you'd like to hear about

Fri, 15 Dec 2006 03:46:22 GMT

I'm going out of town until Christmas, so no new entries for a while, but in the meantime, I'd like to know if there are any games you're working on. I strongly believe that the best way to learn any programming is to come up with a program you want to write and then start working through it. As you hit roadblocks, you learn new things. I haven't really done any 3D before this blog, so I have learned a lot so far and I'm looking forward to digging into shaders and effects.

Also if there are any topics that you would like me to cover, let me know and I'll try my best to work it in.

Happy Holidays and I wanted to say I'm thankful for everyone who follows this blog and enjoys it, it has exceeded my expectations thus far and I plan on continuing heading into the new year and in 2007.

Some great information about SpriteBatches

Thu, 14 Dec 2006 20:52:42 GMT

Shawn Hargreaves of the XNA development team has posted a very informative blog entry of what you can do to improve the performance of drawing 2D sprites in your game. You can read the post here: http://blogs.msdn.com/shawnhar/archive/2006/12/13/spritebatch-and-spritesortmode.aspx

He also gives a very useful piece of advice..."remember that optimizing is only worth doing after you really do run into performance problems".

I encourage you to check it out and to read the other informative posts he has on XNA.

UPDATE: This has turned into a 3 part series by Shawn and it really gives good insight into how SpriteBatches work and can be optimized. Great reading.

Lesson 23: He shoots, he scores!

Wed, 13 Dec 2006 03:24:46 GMT

This lesson focuses on adding collision handling for the goal mouth and goal scoring logic.

Source code for this lesson: http://www.bluerosegames.com/brg/XnaLesson23.zip

I promise this will be easier to follow that the last one, since we will be using the existing collision routines to handle the goal areas. To handle the goal areas, we need some new logic. This new logic needs to:

Detect if the puck is in the goal area so that we can override the wall collision logic.
Allow the puck to pass through the goal area if it doesn't collide with any walls.
Handle the goal post collisions
Detect if the puck has completely left the playing surface, increasing the score for the scoring player, and putting the puck back on the playing surface.

It's a common practice in programming in general and game programming in particular to do less processor intensive comparisons on big chunks first and then get into finer detail if necessary. The goal mouth is 16 inches wide, and so when the center of the puck is anywhere in the 16 inch strip down the middle of the table, we can do something else instead of the default wall collision checking. In this collision checking for the middle strip of the table can first check to see if the puck is close enough to either goal mouth to be in danger of colliding with part of the goal by doing a simple check on the Z component of the position, and if it's not, we're done with the wall collision checks.

If it is close enough on the Z axis to potentially collide with part of the goal, we can then do a collision check with the "goal posts" which are actually just the corners of the wall on either side of the goal mouth. Now this is where it gets interesting. Since the puck is round, and only a single point of its exterior will hit the goal post, we can treat each goal post as a rigid round object of radius 0 and do exactly the same calls into the CollisionHandler class that we did for the paddle-puck collisions.

In order to not hard-code the width of the goal mouth, let's add a Field to the HockeyTable class to store the value. We will actually store the radius of the goal mouth (half the width) to make calculations simpler. Add the declaration to the HockeyTable class as follows:

public float GoalRadius = 8f;

Now let's declare the RoundObjects for the goal posts. Since they do not move or change, we can declare and initialize them once in the Game1 class and then reference them where needed. There are four goal posts but there are really two groups of two. The groups are the posts for the player goal and for the computer goal, and there are two goal posts for each goal. In lesson 15 http://xna101.spaces.live.com/blog/cns!77EE4BD533D8ECAE!159.entry we discussed arrays and loops. The arrays were actually one dimensional arrays. In C# you can have multi-dimensional arrays, where it takes more than one index to point to a single array element. For the goal post RoundObjects it makes sense to store them in a two dimensional array of size 2 by 2. We will declare the array as a Field of the Game1 class as follows:

RoundObject[,] goalPosts = new RoundObject[2,2];

Notice the slightly different format for declaring a multidimensional array. Now in the Game1.Initialize() method, add the following at the end just before the base.Initialize() call:

goalPosts[0, 0] = new RoundObject(new Vector3(hockeyTable.GoalRadius, 0, hockeyTable.Depth / 2), Vector3.Zero, 0f, 0f, true); // player goal post 1
goalPosts[0, 1] = new RoundObject(new Vector3(-hockeyTable.GoalRadius, 0, hockeyTable.Depth / 2), Vector3.Zero, 0f, 0f, true); // player goal post 2
goalPosts[1, 0] = new RoundObject(new Vector3(hockeyTable.GoalRadius, 0, -hockeyTable.Depth / 2), Vector3.Zero, 0f, 0f, true); // computer goal post 1
goalPosts[1, 1] = new RoundObject(new Vector3(-hockeyTable.GoalRadius, 0, -hockeyTable.Depth / 2), Vector3.Zero, 0f, 0f, true); // computer goal post 2

So all of the goal posts RoundObjects are initialized based on their respective positions and with a velocity of 0, weight of 0, and IsRigid=true. The weight can be 0 or any other number because the post is rigid and unmoving so only the puck figures into the conservation of momentum.

Instead of adding a whole new chunk of code to the Game1.CheckForCollisions() method to handle the goal mouth collisions, let's create a new method in the Game1 class that we can call from the Game1.CheckForCollisions() method:

bool CheckForGoalMouthCollisions(float seconds, RoundObject roPuck)
{
   Vector3 p = roPuck.Position;
   float goalCollisionDepth = hockeyTable.Depth / 2f - puck.Radius;
   float goalRadius = hockeyTable.GoalRadius;
   int goalIndex;
   if (p.Z > goalCollisionDepth)
   {
      // set index to 0 for player's goal posts
      goalIndex = 0;
   }
   else if (p.Z < -goalCollisionDepth)
   {
      // set index to 1 for computer's goal posts
      goalIndex = 1;
   }
   else
   {
      return false;
   }
   for (int i = 0; i < 2; i++)
   {
      if (CollisionHandler.CheckForCollisionXZ(roPuck, goalPosts[goalIndex, i]) == true)
      {
         CollisionHandler.HandleCollisionXZ(ref roPuck, ref goalPosts[goalIndex, i]);
         puck.Velocity = roPuck.Velocity;
         return true;
      }
   }
   return false;
}

So first we calculate the "safe zone" of the table, where there is no chance for a goal mouth collision. This is stored in goalCollisionDepth and is equal to half of the depth of the table minus the puck radius. Then based on this number, we can tell if it's close enough to the player's goal to collide, then the computer's goal, then if neither of those are true, we know that there wasn't a wall collision, and we can return false. Now in the goalPosts array, the player's goal posts have a first array index of 0, and the computer's goal posts have a first array index of 1. So by setting the array indexer variable appropriately we can use the same code to handle checking and handling both goal's collisions. Then we have a for loop. The first time through the loop, i will be 0, and the second time i will be 1. So by doing this loop and using i as our second array indexer, we can check for collisions with both goal posts an handle them appropriately. If there is a collision with a goal post, we don't need to check the other, since it is physically impossible to collide with both goal posts at the same time. If there is a collision, we return true to indicate there was a collision.

Now to modify Game1.CheckForCollisions() to call this method. Remember that we only want to call it if we are in the middle 16 inches of the table, or X values of -8 to 8. The new CheckForCollisions method will look as follows (changes are in red):

CollisionStates CheckForCollisions(float seconds, RoundObject roPuck, RoundObject roPlayerPaddle, RoundObject roComputerPaddle)
{
   CollisionStates collision = CollisionStates.None;
   float maxX = (hockeyTable.Width / 2) - puck.Radius;
   float minX = -maxX;
   float maxZ = (hockeyTable.Depth / 2) - puck.Radius;
   float minZ = -maxZ;
   Vector3 p = roPuck.Position;
   if (CollisionHandler.CheckForCollisionXZ(roPuck, roPlayerPaddle) == true)
   {
      CollisionHandler.HandleCollisionXZ(ref roPlayerPaddle, ref roPuck);
      puck.Velocity = roPuck.Velocity;
      collision |= CollisionStates.PlayerPaddle;
   }
   if (CollisionHandler.CheckForCollisionXZ(roPuck, roComputerPaddle) == true)
   {
      CollisionHandler.HandleCollisionXZ(ref roComputerPaddle, ref roPuck);
      puck.Velocity = roPuck.Velocity;
      collision |= CollisionStates.ComputerPaddle;
   }
   p = puck.Position + puck.Velocity * seconds;
   roPuck.Position = p;
   if (p.X < hockeyTable.GoalRadius && p.X > -hockeyTable.GoalRadius)
   {
      if (CheckForGoalMouthCollisions(seconds, roPuck) == true)
      {
         collision |= CollisionStates.Wall;
      }
   }
   else
   {
      if (p.X < minX || p.X > maxX)
      {
         collision |= CollisionStates.Wall;
         puck.Velocity.X = -puck.Velocity.X;
      }
      if (p.Z < minZ || p.Z > maxZ)
      {
         collision |= CollisionStates.Wall;
         puck.Velocity.Z = -puck.Velocity.Z;
      }
   }
   if (puck.Velocity.Length() > 125f)
   {
      puck.Velocity *= 125f / puck.Velocity.Length();
   }
   return collision;
}

Notice the new conditional logic which checks to see if the puck is in the middle of the table, and if so, calls our new method and if it returns true, we know there was a goal mouth collision and we can set the collision variable appropriately. If the puck is not in the middle of the table, we do what we always did before.

Now if you run the program, if the puck goes into a goal, it will never come out. We need logic to determine if a goal was scored, and to act appropriately. Even though we're not displaying the score yet, we can get ready for it. In the Game1 class, declare the following Fields:

int playerScore = 0;
int computerScore = 0;

Now for the code to check if a goal has taken place and if so, to handle it. Let's put this code in a new method called Game1.CheckForGoal() like this:

bool CheckForGoal(Vector3 puckPosition)
{
   float scoringDistance = hockeyTable.Depth / 2f + puck.Radius;
   bool scored = false;
   if (puckPosition.Z > scoringDistance)
   {
      computerScore++;
      ResetPuck(true);
      scored = true;
   }
   else if (puckPosition.Z < -scoringDistance)
   {
      playerScore++;
      ResetPuck(false);
      scored = true;
   }
   if (scored==false) return scored;
   return scored;
}

So if the center of the puck is further away from the center of the table along the Z axis than half of the table depth plus the radius of the puck, then we know a goal hs occurred. Based on whether it's negative or positive, we know which goal was scored upon and can update the score appropriately. We then need to get the puck back on the table so we can play some more. For this, we'll create a Game1.ResetPuck method, which will be passed a 0 if we want the puck to be placed on the player's side and 1 if we want it to be placed on the computer's side.

void ResetPuck(bool player)
{
   puck.Velocity = Vector3.Zero;
   if (player == true)
   {
      puck.Position = new Vector3(0f, 0f, hockeyTable.Depth / 5f);
   }
   else
   {
      puck.Position = new Vector3(0f, 0f, -hockeyTable.Depth / 5f);
   }
   if (Vector3.Distance(puck.Position, playerPaddle.Position) < puck.Radius + playerPaddle.CollisionRadius)
   {
      puck.Position += new Vector3(0, 0, -playerPaddle.Radius * 2.5f);
   }
   if (Vector3.Distance(puck.Position, computerPaddle.Position) < puck.Radius + computerPaddle.CollisionRadius)
{
      puck.Position += new Vector3(0, 0, computerPaddle.Radius * 2.5f);
   }
}

So we're setting the puck's velocity to 0, and then putting the puck on one side or the other. There is, however, one problem. The place we're putting the puck may already be occupied by the paddle. So the loast 2 conditionals check to see if the distance between the centers of the puck and the paddle is less than the combined radius of the puck and the paddle indicating an overlap, and if so, reposition the puck to a position 2.5 paddle radius' away along the Z axis.

Now in the Game1.Update(), in the loop after we declare and initialize the next puck position, add the following:

if (CheckForGoal(p) == true)
{
break;
}

if we have a goal scored, we get out of the update loop and start all over again next time Update is called. The break statement says that we want to exit the loop immediately and continue execution with the next statement after the loop.

Now in the Game1.Initialize() method, for testing purposes a few lessons ago, we added some code which positioned the puck at center ice and gave it a velocity. This was so that we could test out the wall bouncing logic since we couldn't hit the puck with the paddle yet. Now we can replace that code with a call to ResetPuck, passing 0 to position the puck on the player's side to start. Replace the code in Game1.Initialize() that sets the puck's position and velocity with the following:

ResetPuck(true);

Run the program again. You should now be able to score goals. One problem. Once we score on the computer's goal, we have no way to keep playing right now since the computer paddle doesn't move. As a temporary fix, add the following to the Game1.HandleMouse() method just after the MouseState ms = Mouse.GetState(); call:

if (ms.RightButton == ButtonState.Pressed)
{
ResetPuck(true);
}

where if we right click the mouse, the puck will be put back on our side so we can keep playing. Run the program again and see how it behaves.

XNA 1.0 Has Arrived!

Mon, 11 Dec 2006 14:27:25 GMT

David Weller has announced on his blog http://letskilldave.com/archive/2006/12/11/XNA-Launch-Day-is-here_2100_.aspx that XNA 1.0 is now available for download. I have tested Dr. Popper against XNA 1.0 and it required a rebuild but no other changes. I have also tested the sample code for the lessons to make sure they all work as well. Everything looks fine, let me know if you have any issues. Enjoy!

Custom List: Links

Thu, 17 Jul 2008 14:37:32 GMT

Links

Free Lunch Design
Download great free games (not XNA) for the PC
Dr. Popper Game for XNA 1.0
Download the game and source code free
Silverlight Games 101
Beginning Game Programming in Silverlight 1.1
Tampa Divorce Lawyer
The Law Offices of Roberta Kohn, PA provides service in the areas of divorce, family and real estate law for the Tampa Bay area and the state of Florida.
Free Team Websites
Create a community for your team or group. Share information, schedule, photos, and videos at this free team management site.

Book List: Books

Wed, 08 Aug 2007 16:04:20 GMT

Books

Custom List: XNA Community

Thu, 15 Feb 2007 02:27:00 GMT

XNA Community

XNA Links.Net
Mega List of XNA helpful links.