XNA Tutorial:2D Shooting Part 2

A while ago I created a tutorial for shooting bullets out of a rocket in nay direction. The method used, while functional, is not very re-usable. In this tutorial we are going to re-factor the previous shooting tutorial. It is recommended that you finish this previous tutorial as we will be using that project.

Firstly you need to create a new game component. Call it ProjectileManager. This will be the place where we will manage our bullets.

public class ProjectileManager : DrawableGameComponent

view raw ProjectileManager.cs hosted with ❤ by GitHub

You need to ensure that instead of just inheriting from Microsoft.Xna.Framework.GameComponent change it to DrawableGameComponent as this will allow us to add a draw method to this game component.

You must then add a draw method to the game component just like the following.

	public override void Draw(GameTime gameTime)
	{
	base.Draw(gameTime);
	}

view raw ProjectileManager.cs hosted with ❤ by GitHub

In here we will draw our bullets.

Next we will add a few variables and instantiate them in the constructor.

	static List<Bullet> bullets = new List<Bullet>();
	static Texture2D playerBulletTexture;
	SpriteBatch spriteBatch;
	public ProjectileManager(Game game, SpriteBatch spriteBatch)
	: base(game)
	{
	game.Components.Add(this);
	playerBulletTexture = game.Content.Load<Texture2D>("Bullet");
	this.spriteBatch = spriteBatch;
	}

view raw ProjectileManager.cs hosted with ❤ by GitHub

As you can see, the list of bullets and the texture are both static. This is because we will be referencing them later is a static method. I'll explain further later.

Now we need to add an enum for bullet types. Enums are types that allow you to assign names to integer values. Add the following line to Bullet.cs file. Add is so that it is outside the bullet class.

	public enum BulletType { Player, Enemy }
	public class Bullet
	{

view raw Bullet.cs hosted with ❤ by GitHub

Next we will need to add a new property to the bullet class. This will be of type BulletType. We will need this if at some point in the future we create enemies that are capable of shooting back at the player.

public BulletType Type { get; set; }

view raw Bullet.cs hosted with ❤ by GitHub

With this new property we will need to modify the constructor for the bullet class. We need to add a new parameter for the bullet type. Modify the constructor so it looks like this:

	public Bullet(Texture2D texture, Vector2 position, Vector2 direction, float speed, int activeTime, BulletType type)
	{
	this.DrawTexture = texture;
	this.Position = position;
	this.Direction = direction;
	this.Speed = speed;
	this.ActiveTime = activeTime;
	this.Type = type;
	this.TotalActiveTime = 0;
	}

view raw Bullet.cs hosted with ❤ by GitHub

Go back to the ProjectileManager. The next thing we need to do is add a public static method to add a new bullet to the bullet list. A public static method allows us to be able to access this method anywhere in the code. In this case by just typing ProjectileManager.AddBullet(methodParameters). Create a new method and make sure it looks like the following code.

	public static void AddBullet(Vector2 position, Vector2 direction, float speed, int activeTime, BulletType type)
	{
	bullets.Add(new Bullet(playerBulletTexture, position, direction, speed, activeTime, type));
	}

view raw ProjectileManager.cs hosted with ❤ by GitHub

Next we need to be able to update the bullets in the projectile manager. We have pretty much already written this code in the rocket class all you really need to do is cut and paste the bullet update loop code over to the update loop of the projectile manager. Within the update for the projectile manager you should have to following code.

	for(int i = 0; i < bullets.Count; i++)
	{
	bullets[i].Update(gameTime);
	if (bullets[i].TotalActiveTime > bullets[i].ActiveTime)
	bullets.RemoveAt(i);
	}

view raw ProjectileManager.cs hosted with ❤ by GitHub

Make sure you have also removed this code from the rocket class.

The exact same needs to be done for the drawing loop. Cut and paste the bullet drawing loop from the rocket class to the projectile manager draw method. The following code should now be in your draw method for the projectile manager.

	foreach (Bullet b in bullets)
	{
	b.Draw(spriteBatch);
	}

view raw ProjectileManager.cs hosted with ❤ by GitHub

Before we continue make sure you no longer have code in the rocket class for updating and drawing bullets. You may also remove the list of bullets and bulletTex from the rocket class. You must also remove the bulletTex parameter from the rocket constructor and any other bulletTex code from the constructor. The constructor should now look like the following.

	public Rocket(Texture2D texture, Vector2 position, Vector2 direction, float rotation, float Speed)
	{
	this.DrawTexture = texture;
	this.Position = position;
	this.Direction = direction;
	this.Rotation = rotation;
	this.Speed = Speed;
	this.IsShooting = false;
	}

view raw Rocket.cs hosted with ❤ by GitHub

next we need to use the new method we created in the ProjectileManager class. The rocket update method should now look like this:

	public void Update(GameTime gameTime)
	{
	this.Position += Direction * Speed;
	if (IsShooting)
	{
	shotTimer += gameTime.ElapsedGameTime.Milliseconds;
	if (shotTimer > timeBetweenShots)
	{
	shotTimer = 0;
	ProjectileManager.AddBullet(this.Position, this.Direction, 12, 2000, BulletType.Player);
	}
	}
	}

view raw Rocket.cs hosted with ❤ by GitHub

You may have notices that if you build your project you are still getting a few errors. We will work on fixing these next.

Go to the Game1 class. Go to the load content method to where we are instantiating the rocket. Remove the parameter for the bullet texture. It should now look like this.

	rocket = new Rocket(
	Content.Load<Texture2D>("rocket"),
	new Vector2(200, 200),
	Vector2.Zero,
	0f,
	0f);

view raw Game1.cs hosted with ❤ by GitHub

Next just above this line of code, still within the load content method, Create a new instance of the projectile manager.

ProjectileManager pj = new ProjectileManager(this, spriteBatch);

view raw Game1.cs hosted with ❤ by GitHub

Now go down to the draw method in the Game1 class and move the spritebatch.end so that is appears after the base.Draw(). We do this to allow our projectile manager to draw with the same spritebatch. The base.Draw() updated the draw method of all the game components.

You should now be able to run the game. You may have noticed that the bullets are being drawn on top of the rocket. To fix this go back to your code. We must change the draw order. Go to the bullet class and to the draw method. change the last parameter to be less that 1.0f. I put it to 0.8f.

	spriteBatch.Draw(
	DrawTexture,
	Position,
	null,
	Color.White,
	0f,
	new Vector2(
	DrawTexture.Width / 2,
	DrawTexture.Height / 2),
	1.0f,
	SpriteEffects.None,
	0.8f);

view raw Bullet.cs hosted with ❤ by GitHub

Then go to the Game1 draw method and modify the spritebatch.begin method to look like the following.

spriteBatch.Begin(SpriteSortMode.FrontToBack, BlendState.AlphaBlend);

view raw game1.cs hosted with ❤ by GitHub

Now run the game and it should work perfectly.

Now the code is set up in such a way as to allow us to add enemies at some stage in the future. If you see any typos or mistakes please let me know.

Here is the source for the finished project.