Develop Reference

My LoadContent Function does not load my sprites(Building a Pacman Game)

Alright so Im following a tutorial on youtube about creating a Pacman game using XNA here is the link https://www.youtube.com/watch?v=TN3NYT_glmg. I have watched up to 3 tutorials and have encountered a problem.
I follow exactly what the guy does but there is a problem, my sprites dont draw in my screen, I back traced the tutorial trying to figure out what I was missing but, I cant find anything that I missed.
Id be grateful for your help, I need to complete this game in order to understand how game programming actually works.
Here is the code
Object Class
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
namespace WindowsGame1
{
class Obj
{
public Texture2D Texture = null; //texture of object;
public string TextureName = string.Empty;//name of texture
public Vector2 center = Vector2.Zero;//Center of texture
public Vector2 position = Vector2.Zero;//Postion of object
public float Rotation = 0.0f; //Rotation of Object
public float scale = 1.0f; //Scale of the object
public float speed = 0.0f; //speed of the object
public bool isAlive = true;
public Obj(Vector2 pos)
{
position = pos;
}
public Obj()
{
}
public virtual void LoadContent(ContentManager Content)//Loads Content
{
Texture = Content.Load<Texture2D>("Sprites/"+this.TextureName);
center = new Vector2(Texture.Width / 2, Texture.Height / 2);
}
public virtual void Update(GameTime gameTime)//Updates the gametime
{
}
public virtual void Draw(SpriteBatch spriteBatch)//Draws object/sprites
{
if (isAlive)
return;
spriteBatch.Draw(Texture, position, null, Color.White, MathHelper.ToRadians(Rotation), center, scale,SpriteEffects.None, 0);
}
}
}
Items Class
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
namespace WindowsGame1
{
class Items
{
public static List<Obj> Objlist = new List<Obj>();//Create list of objects
public static Pacman Pacman;
public static void Initialize()
{
Objlist.Add(Pacman=new Pacman(new Vector2(250,250), "Pacman1"));
}
}
}
Pacman Class
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
namespace WindowsGame1
{
class Pacman:Obj
{
public Pacman(Vector2 pos, string textureName)
{
TextureName = textureName;
position = pos;
isAlive = true;
}
}
}
And Finally
Game Class
using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;
namespace WindowsGame1
{
/// <summary>
/// This is the main type for your game
/// </summary>
public class Game1 : Microsoft.Xna.Framework.Game
{
GraphicsDeviceManager graphics;
SpriteBatch spriteBatch;
public Game1()
{
graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";
}
/// <summary>
/// Allows the game to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
Items.Initialize();
base.Initialize();
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
spriteBatch = new SpriteBatch(GraphicsDevice);
foreach (Obj o in Items.Objlist)
{
o.LoadContent(Content);
}
}
/// <summary>
/// UnloadContent will be called once per game and is the place to unload
/// all content.
/// </summary>
protected override void UnloadContent()
{
// TODO: Unload any non ContentManager content here
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Update(GameTime gameTime)
{
foreach (Obj o in Items.Objlist)
{
o.Update(gameTime);//updates all ojects
}
base.Update(gameTime);
}
/// <summary>
/// This is called when the game should draw itself.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Draw(GameTime gameTime)//Used to draw the game
{
GraphicsDevice.Clear(Color.SkyBlue);//This line here is used to change the color of the screen
spriteBatch.Begin();
foreach (Obj o in Items.Objlist)
{
o.Draw(spriteBatch);
}
spriteBatch.End();
base.Draw(gameTime);
}
}
}

Look at your Draw code:
public virtual void Draw(SpriteBatch spriteBatch)//Draws object/sprites
{
if (isAlive)
return;
spriteBatch.Draw(Texture, position, null, Color.White, MathHelper.ToRadians(Rotation), center, scale,SpriteEffects.None, 0);
}
If the object is alive you don't draw it....
It should be:
public virtual void Draw(SpriteBatch spriteBatch)//Draws object/sprites
{
if (!isAlive)
return;
spriteBatch.Draw(Texture, position, null, Color.White, MathHelper.ToRadians(Rotation), center, scale,SpriteEffects.None, 0);
}

Drawing many of one sprite will smudge the sprite

I am making a tile-based game. I have my "playfield" that is 30*20 Tiles (each is 32x32 pixels). The first Tile that is drawn (at BlockPos (0,0)) is drawn correctly, but the other Tiles are drawn incorrectly. That is, the texture is "smudged". Here is the main class code:
#region Using Statements
using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Storage;
using Microsoft.Xna.Framework.GamerServices;
using Texert.Content;
using Texert.Logic;
#endregion
namespace Texert
{
/// <summary>
/// This is the main type for your game
/// </summary>
public class MainGame : Game
{
private FrameCounter _frameCounter = new FrameCounter();
GraphicsDeviceManager graphics;
SpriteBatch spriteBatch;
public MainGame()
: base()
{
graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";
}
/// <summary>
/// Allows the game to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
// TODO: Add your initialization logic here
Vars.Textures = new List<Texture2D>();
Vars.Tiles = new List<Tile>();
for (var i = 0; i < 20; i++)
{
for (var k = 0; k < 30; k++)
{
Vars.Tiles.Add(new TileDirt(new BlockPos(k, i)));
}
}
// Set window size
graphics.IsFullScreen = false;
graphics.PreferredBackBufferHeight = Tile.TILE_SIZE*20;
graphics.PreferredBackBufferWidth = Tile.TILE_SIZE*30;
graphics.ApplyChanges();
base.Initialize();
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
spriteBatch = new SpriteBatch(GraphicsDevice);
Vars.Textures.Add(Content.Load<Texture2D>("dirt"));
// TODO: use this.Content to load your game content here
}
/// <summary>
/// UnloadContent will be called once per game and is the place to unload
/// all content.
/// </summary>
protected override void UnloadContent()
{
// TODO: Unload any non ContentManager content here
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Update(GameTime gameTime)
{
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape))
Exit();
// TODO: Add your update logic here
// Update FPS
var deltaTime = (float) gameTime.ElapsedGameTime.TotalSeconds;
_frameCounter.Update(deltaTime);
Window.Title = "Texert - " + Math.Floor(_frameCounter.AverageFramesPerSecond) + " FPS";
base.Update(gameTime);
}
/// <summary>
/// This is called when the game should draw itself.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Draw(GameTime gameTime)
{
GraphicsDevice.Clear(Color.CornflowerBlue);
spriteBatch.Begin();
foreach (var tile in Vars.Tiles)
{
spriteBatch.Draw(Vars.Textures[tile.textureIndex],
tile.pos.GetRealPos().GetVector2(),
new Rectangle(tile.pos.GetRealPos().X, tile.pos.GetRealPos().Y,
Tile.TILE_SIZE, Tile.TILE_SIZE),
Color.White); // draw the fucking tile
}
spriteBatch.End();
base.Draw(gameTime);
}
}
}
Here is a screenshot of the game in action. I have no idea why it is drawn this way. How can I fix this?
Edit: Here's the Tile.cs file that contains Pos, BlockPos and Tile!
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;
namespace Texert.Logic
{
public class Tile
{
public static int TILE_SIZE = 32;
public int textureIndex;
public string tileName;
public BlockPos pos;
public Tile()
{
textureIndex = 0;
tileName = "null";
pos = new BlockPos(0, 0);
}
public Tile(int index, string name, BlockPos pos)
{
textureIndex = index;
tileName = name;
this.pos = pos;
}
}
public class BlockPos
{
public Pos actualPos;
public int X;
public int Y;
public BlockPos(int x, int y)
{
X = x;
Y = y;
}
public Pos GetRealPos()
{
return new Pos(X*Tile.TILE_SIZE, Y*Tile.TILE_SIZE);
}
/// <summary>
/// Returns blockpos of pos, rounded down to nearest multiple of TILE_SIZE
/// </summary>
/// <param name="pos">The position to convert to BlockPos</param>
/// <returns>The BlockPos</returns>
static BlockPos GetBlockPosFromPos(Pos pos)
{
return new BlockPos(pos.X % Tile.TILE_SIZE, pos.Y % Tile.TILE_SIZE);
}
}
public class Pos
{
public int X;
public int Y;
public Pos(int x, int y)
{
X = x;
Y = y;
}
public Vector2 GetVector2()
{
return new Vector2(X, Y);
}
}
}

How to make a sprite change to another sprite from the sprite sheet?

i am working on a game, and i want the speceship to change to another spaceship from the sprite sheet when the player presses Tab key. so its like switching between the spaceships.
i have been trying with GetSourceRectangle from the class and setting one, and updating that in game, but its not working.
here is the code fro the Spaceship class:
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace SpaceShooterTest1
{
class Spaceship
{
public int xPos = 0;
public int yPos = 0;
private int width = 128;
private int height = 128;
private Texture2D texture;
public Rectangle currentSourceRect { get; set; } //determines which part of sprite sheet to show
public Spaceship(Texture2D tex)
{
texture = tex;
currentSourceRect = new Rectangle(0, 0, 128, 128);
}//end Spaceship
// // //
public void MoveToPosition(int x, int y)
{
xPos = x;
yPos = y;
}//end MoveToPosition
public void Update(GameTime gametime)
{
currentSourceRect = GetSourceRectangle(2, 0); // this could be getting the fiery weapons
//currentSourceRect = SetSourceRectangle(2, 0);
}
public void Draw(GameTime gameTime, SpriteBatch spriteBatch)
{
spriteBatch.Draw(texture, new Rectangle(xPos, yPos, width, height), currentSourceRect, Color.White);
}//end Draw
public Rectangle GetSourceRectangle(int row, int col)
{
Rectangle r;
//TODO: Make custom based on row and col
r = new Rectangle(0, 128, width, height);
return r;
}//end GetSourseRectangle
//public Rectangle SetSourceRectangle(int row, int col)
//{
// Rectangle r;
// //TODO: Make custom based on row and col
// r = new Rectangle(0, 128, width, height);
// return r;
//}//end GetSourseRectangle
}
}
and here is the code for the Game:
using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;
namespace SpaceShooterTest1
{
/// <summary>
/// This is the main type for your game
/// </summary>
public class Game1 : Microsoft.Xna.Framework.Game
{
//Game State Enum
enum GameState { GScreen, Playing, Won, Lost };
GraphicsDeviceManager graphics;
SpriteBatch spriteBatch;
Random rand;
int playerScore = 0;
//Textures
Texture2D galaxyScreen;
Texture2D texShip;
GameState currentState = GameState.Playing;
//GameState currentState = GameState.GScreen; /// use after
//ship
Spaceship spaceShip;
public Game1()
{
graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";
}
/// <summary>
/// Allows the game to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
// TODO: Add your initialization logic here
base.Initialize();
rand = new Random();
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
spriteBatch = new SpriteBatch(GraphicsDevice);
texShip = Content.Load<Texture2D>(#"Images\ships_sm");
spaceShip = new Spaceship(texShip);
spaceShip.xPos = 0;
spaceShip.yPos = Window.ClientBounds.Height - 128;
//galaxyScreen = Content.Load<Texture2D>(#"Images\galaxy");
// TODO: use this.Content to load your game content here
}
/// <summary>
/// UnloadContent will be called once per game and is the place to unload
/// all content.
/// </summary>
protected override void UnloadContent()
{
// TODO: Unload any non ContentManager content here
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Update(GameTime gameTime)
{
// Allows the game to exit
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
this.Exit();
KeyboardState keyboardState = Keyboard.GetState();
if (Keyboard.GetState().IsKeyDown(Keys.Tab))
{
spaceShip.GetSourceRectangle(2, 0);
}
if (Keyboard.GetState().IsKeyDown(Keys.D))
{
spaceShip.xPos += 5;
}
else if (Keyboard.GetState().IsKeyDown(Keys.A))
{
spaceShip.xPos -= 5;
}
if (spaceShip.xPos < 0)
spaceShip.xPos = 0;
if (spaceShip.xPos + 128 > Window.ClientBounds.Width)
{
spaceShip.xPos = Window.ClientBounds.Width - 128;
}
/*if (currentState == GameState.GScreen && keyboardState.IsKeyDown(Keys.Space))
{
currentState = GameState.Playing;
}
spaceShip.Update(gameTime);
*/
base.Update(gameTime);
}
/// <summary>
/// This is called when the game should draw itself.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Draw(GameTime gameTime)
{
GraphicsDevice.Clear(Color.CornflowerBlue);
//draw ship
spriteBatch.Begin();
if (currentState == GameState.Playing)
{
spaceShip.Draw(gameTime, spriteBatch);
}
//800 wide x 400 high
else if (currentState == GameState.GScreen)
{
spriteBatch.Draw(galaxyScreen, new Rectangle(0, 0, Window.ClientBounds.Width, Window.ClientBounds.Height), Color.White);
}
spriteBatch.End();
base.Draw(gameTime);
}
}
}
apparently i cant post the spritesheet because i dont have enough reputation (seriously stack?) but i hope you guys understand what i mean.

With what you gave, what I can think of is:
Have 2 Vector2 (or Rectangle, whichever object you use on your Draw method) objects on the Spaceship class, one for the coordinates of spaceship when the Tab is not pressed, another one for when the key is pressed on the tilesheet.
Then you can have a bool value on the Game class to specify which texture to use.
On the Update method, update the bool value.
On the Draw method, draw the texture according the bool value.
So basically on the Spaceship class:
Texture2D spaceship;
Vector2 spaceship1, spaceship2;
bool tabPressed;
On the Update method of the Game class:
tabPressed = Keyboard.GetState().IsKeyDown(Keys.Tab);
Now you can either pass the bool value to your Spaceship Draw method and draw accordingly, or access a property/method of the class to signal the change in the desired drawing behavior.

This method does not accept null for this parameter. But the texture is programmed as loaded, in my view?

I'm going to create a game for myself to learn, but I ran into a problem, and I really don't know how to fix it.
The error is:
This method does not accept null for this parameter.
I've searched and it tells me I have not loaded the texture correctly, which I think I did. Because it's before the Draw command.
Heres my Game1.cs:
using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;
namespace Eggt_Fast
{
/// <summary>
/// This is the main type for your game
/// </summary>
public class Game1 : Microsoft.Xna.Framework.Game
{
GraphicsDeviceManager graphics;
SpriteBatch spriteBatch;
Player player = new Player();
public Game1()
{
graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";
graphics.PreferredBackBufferHeight = 600;
graphics.PreferredBackBufferWidth = 800;
this.Window.Title = "Eggt Fast";
graphics.ApplyChanges();
}
/// <summary>
/// Allows the game to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
// TODO: Add your initialization logic here
base.Initialize();
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
spriteBatch = new SpriteBatch(GraphicsDevice);
// TODO: use this.Content to load your game content here
}
/// <summary>
/// UnloadContent will be called once per game and is the place to unload
/// all content.
/// </summary>
protected override void UnloadContent()
{
// TODO: Unload any non ContentManager content here
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Update(GameTime gameTime)
{
// Allows the game to exit
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
this.Exit();
// TODO: Add your update logic here
player.Update(gameTime);
base.Update(gameTime);
}
/// <summary>
/// This is called when the game should draw itself.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Draw(GameTime gameTime)
{
GraphicsDevice.Clear(Color.CornflowerBlue);
// TODO: Add your drawing code here
spriteBatch.Begin();
player.Draw(spriteBatch);
spriteBatch.End();
base.Draw(gameTime);
}
}
}
And here's my Player.cs:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
namespace Eggt_Fast
{
class Player
{
public Texture2D texture;
public Vector2 position;
public int speed;
public Rectangle boundingBox;
public bool isColliding;
public Player()
{
texture = null;
position = new Vector2(300, 300);
speed = 14;
isColliding = false;
}
public void LoadContent(ContentManager Content)
{
texture = Content.Load<Texture2D>("Player");
}
public void Draw(SpriteBatch spriteBatch)
{
spriteBatch.Draw(texture, position, Color.White); //THE ERROR IS HERE.
}
public void Update(GameTime gameTime)
{
}
}
}

I think your problem may be that you never call Player.LoadContent(). Since you don't call this from your Game1.LoadContent(), the texture is never loaded, which is what is causing the error. To fix your problem you could try something like this:
In Game1
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
spriteBatch = new SpriteBatch(GraphicsDevice);
// TODO: use this.Content to load your game content here
player.LoadContent(Content);
}
This will call the LoadContent void in your player class, which is what I think you initially had in mind would happen automatically. LoadContent() won't be called automatically like Game1's LoadContent is, because Player is just a regular class and doesn't inherit from other classes, like Game1 does.

C# XNA SpriteBatch is null?

Hey guys I really need some help here my spriteBatch keeps returning a NullReference Exception and I don't know what I am doing wrong!? (I am making a brickbreaker game) and whenever my bricks are created inside Game1.cs it works fine but when I move it to Wall.cs (which is where I want to display a pattern of bricks) the game just crashes and gives a NullReference exception. Heres my code:
using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;
namespace BrickBreaker
{
/// <summary>
/// This is the main type for your game
/// </summary>
public class Game1 : Microsoft.Xna.Framework.Game
{
GraphicsDeviceManager graphics;
SpriteBatch spriteBatch;
private Paddle paddle;
private Ball ball;
private Texture2D background;
private static int screenWidth = 750;
private static int screenHeight = 600;
private int leftBorder = 20;
private int rightBorder = 28;
private int topBorder = 20;
private readonly int normalBrickResist = 2;
private readonly int normalBrickPoints = 10;
private Wall wall;
//DELETE this shit
private Brick brick;
/// <summary>
/// Contructor for the Game1 class.
/// </summary>
public Game1()
{
graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";
}
/// <summary>
/// Read only property for the screen height.
/// </summary>
public static int ScreenHeight
{
get { return screenHeight; }
}
/// <summary>
/// Read only property for the screen width.
/// </summary>
public static int ScreenWidth
{
get { return screenWidth; }
}
/// <summary>
/// Allows the game to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize() will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
graphics.PreferredBackBufferHeight = screenHeight;
graphics.PreferredBackBufferWidth = screenWidth;
graphics.ApplyChanges();
paddle = new Paddle(this);
Components.Add(paddle);
wall = new Wall(this);
Components.Add(wall);
ball = new Ball(this, paddle, leftBorder, rightBorder, topBorder, brick);
Components.Add(ball);
base.Initialize();
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
spriteBatch = new SpriteBatch(GraphicsDevice);
background = Content.Load<Texture2D>("background");
}
/// <summary>
/// UnloadContent will be called once per game and is the place to unload
/// all content.
/// </summary>
protected override void UnloadContent()
{
// TODO: Unload any non ContentManager content here
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Update(GameTime gameTime)
{
// Allows the game to exit
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
this.Exit();
base.Update(gameTime);
}
/// <summary>
/// This is called when the game should draw itself.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Draw(GameTime gameTime)
{
GraphicsDevice.Clear(Color.CornflowerBlue);
spriteBatch.Begin();
Vector2 position = new Vector2(0, 0);
spriteBatch.Draw(background, position, Color.White);
spriteBatch.End();
base.Draw(gameTime);
}
public void RemoveComponent(IGameComponent obj)
{
this.Components.Remove(obj);
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;
namespace BrickBreaker
{
/// <summary>
/// This is a game component that implements IUpdateable.
/// </summary>
public class Wall : Microsoft.Xna.Framework.DrawableGameComponent
{
private Brick brick;
private Brick[,] brickLayout = new Brick[5, 8];
private Game game;
SpriteBatch spriteBatch;
private Texture2D brickImg;
public Wall(Game game)
: base(game)
{
this.game = game;
}
/// <summary>
/// Allows the game component to update itself.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Draw(GameTime gameTime)
{
foreach (var item in brickLayout)
{
if (item != null)
{
item.Draw(gameTime);
}
}
base.Draw(gameTime);
}
/// <summary>
/// Allows the game component to update itself.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Update(GameTime gameTime)
{
foreach (Brick item in brickLayout)
{
item.Update(gameTime);
}
base.Update(gameTime);
}
/// <summary>
/// Allows the game component to perform any initialization it needs to before starting
/// to run. This is where it can query for any required services and load content.
/// </summary>
public override void Initialize()
{
// TODO: Add your initialization code here
foreach (var item in brickLayout)
{
if (item != null)
{
item.Initialize();
}
}
base.Initialize();
}
protected override void LoadContent()
{
int x = 0;
int y = 0;
Vector2 startPosition;
for (int i = 0; i < brickLayout.GetLength(0); i++)
{
for (int j = 0; j < brickLayout.GetLength(1); j++)
{
startPosition = new Vector2(x, y);
brickLayout[i, j] = new Brick(game, 20, 1, startPosition);
x += 20;
}
y += 20;
}
base.LoadContent();
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;
namespace BrickBreaker
{
/// <summary>
/// This is a game component that implements IUpdateable.
/// </summary>
public class Brick : Microsoft.Xna.Framework.DrawableGameComponent
{
enum brickType
{
Regular1,
Regular2,
Regular3,
Regular4,
Regular5,
PowerUp,
Unbreakable
}
private Texture2D brick;
private SpriteBatch spriteBatch;
private Game game;
private int brickValue;
private Vector2 startPosition, position;
private Rectangle collisionBox;
private int brickWidth;
private bool isBroken = false;
private int resistance;
public Brick(Game game, int brickValue, int resistance, Vector2 startPosition)
: base(game)
{
this.brickValue = brickValue;
this.game = game;
this.resistance = resistance;
this.startPosition = startPosition;
}
public Boolean IsBroken
{
get
{
return this.isBroken;
}
set
{
this.isBroken = value;
}
}
/// <summary>
/// Property for the paddle collision box.
/// </summary>
public Rectangle CollisionBox
{
get { return collisionBox; }
}
/// <summary>
/// Read only property for the paddle width.
/// </summary>
public int BrickWidth
{
get { return brickWidth; }
}
/// <summary>
/// Allows the game component to perform any initialization it needs to before starting
/// to run. This is where it can query for any required services and load content.
/// </summary>
public override void Initialize()
{
// TODO: Add your initialization code here
base.Initialize();
}
/// <summary>
/// Allows the game component to update itself.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Update(GameTime gameTime)
{
// TODO: Add your update code here
base.Update(gameTime);
}
/// <summary>
/// Allows the game component to update itself.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Draw(GameTime gameTime)
{
if (isBroken == false)
{
spriteBatch.Begin();
spriteBatch.Draw(brick, this.position, Color.White);
spriteBatch.End();
}
base.Draw(gameTime);
}
/// <summary>
/// Comment
/// </summary>
protected override void LoadContent()
{
spriteBatch = new SpriteBatch(GraphicsDevice);
brick = game.Content.Load<Texture2D>("brick");
collisionBox = new Rectangle(0, 0, brick.Width, brick.Height);
position = startPosition;
collisionBox.X = (int)position.X;
collisionBox.Y = (int)position.Y;
base.LoadContent();
}
public void TakeHit()
{
resistance--;
if (resistance == 0)
IsBroken = true;
}
}
}
Edit: Fixed the old problem by adding this in wall.cs
for (int i = 0; i < brickLayout.GetLength(0); i++)
{
for (int j = 0; j < brickLayout.GetLength(1); j++)
{
startPosition = new Vector2(x, y);
brickLayout[i, j] = new Brick(game, 20, 1, startPosition);
//Added this line:
brickLayout[i, j].Initialize();
x += 45;
}
x = 150;
y += 25;
}
BUT now the collision box isn't working at all.

Look closer at your Brick class. In your wall class you're not initializing spriteBatch, and you're not calling Begin and End
Your LoadContent method needs this:
spriteBatch = new SpriteBatch(GraphicsDevice);
And you need to be sure to call this is your Draw method:
spriteBatch.Begin();
and
spriteBatch.End();
EDIT: You're never calling LoadContent on your brick class which is why spriteBatch never gets initialized. Try:
protected override void LoadContent()
{
int x = 0;
int y = 0;
Vector2 startPosition;
for (int i = 0; i < brickLayout.GetLength(0); i++)
{
for (int j = 0; j < brickLayout.GetLength(1); j++)
{
startPosition = new Vector2(x, y);
brickLayout[i, j] = new Brick(game, 20, 1, startPosition);
// This new line...
brickLayout[i, j].LoadContent();
x += 20;
}
y += 20;
}
base.LoadContent();
}

It's giving NullReferenceException in the Brick class at the SpriteBatch.Begin() line in the Draw method.