Develop Reference

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.

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.

How to prevent player object from clipping through walls in a 2d environment

The player box is continuing through walls in an undesired fashion, I have tried making it so that the player moves in 0.1f(u) increments at a time, but this severely drops the performance of the game. Is there any way I can detect if the player is hitting a wall, what side they hit it on and how can I prevent them from clipping into the wall?
Here is the code that I am running (this is minimalistic of course)
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 Platformer
{
public class Player
{
double terminalVelocity;
//AnimatedTexture texture;
public Texture2D texture;
public Vector2 Position, Velocity;
public Rectangle boundingBox;
public Player(Texture2D tex, Vector2 pos, Vector2 vel, Rectangle bb)
{
texture = tex;
Position = pos;
Velocity = vel;
boundingBox = bb;
terminalVelocity = Math.Sqrt((2*bb.Width*bb.Height*Game1.gravity)/-9.8*2);
}
public void updateBoundingBoxes()
{
boundingBox.X = (int)Position.X;
boundingBox.Y = (int)Position.Y;
}
public void onUpdate()
{
updateBoundingBoxes();
Position.X += Velocity.X;
Position.Y += Velocity.Y;
//Velocity = Vector2.Zero;
Velocity.Y += Game1.gravity / 60;
Velocity.X /= 1.2f;
}
public void Draw(SpriteBatch sb)
{
updateBoundingBoxes();
sb.Begin();
sb.Draw(texture,boundingBox,GameLighting.currentColour());
sb.End();
}
}
public enum GameLightingState
{
Red, Dark, Orange, Blue, White
}
public class Platform : Object
{
Texture2D text;
public Rectangle rect;
public Platform(Texture2D t, Vector2 p, int sizeX, int sizeY)
{
text = t;
rect = new Rectangle((int)p.X, (int)p.Y, sizeX, sizeY);
}
public void onPlayerCollision(Player p)
{
p.Velocity.X = -p.Velocity.X / 2;
p.Velocity.Y = -p.Velocity.Y / 2;
}
public void Draw(SpriteBatch sb)
{
sb.Begin();
sb.Draw(text, rect, GameLighting.currentColour());
sb.End();
}
public void onUpdate()
{
}
}
public class GameLighting
{
public static Color currentColour()
{
return eToColour(Game1.currentLightingState);
}
public static Color eToColour(GameLightingState gls)
{
switch (gls)
{
case(GameLightingState.Red):
return Color.Red;
case (GameLightingState.Blue):
return Color.Blue;
case (GameLightingState.Orange):
return Color.Orange;
case (GameLightingState.Dark):
return Color.DarkGray;
case (GameLightingState.White):
return Color.White;
}
return Color.White;
}
}
/// <summary>
/// This is the main type for your game
/// </summary>
public class Game1 : Microsoft.Xna.Framework.Game
{
public static float gravity = 9.80665f;
public static GameLightingState currentLightingState;
GraphicsDeviceManager graphics;
SpriteBatch spriteBatch;
List<Platform> platforms;
List<Player> players;
int controlledPlayerIndex = 0;
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
currentLightingState = GameLightingState.White;
platforms = new List<Platform>();
players = new List<Player>();
players.Add(new Player(this.Content.Load<Texture2D>("Images/dirt"), new Vector2(300,0), new Vector2(0,0), new Rectangle(300,0,20,20)));
platforms.Add(new Platform(this.Content.Load<Texture2D>("Images/dirt"),new Vector2(300,450),200,20));
platforms.Add(new Platform(this.Content.Load<Texture2D>("Images/dirt"), new Vector2(20,20), 20, 200));
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();
foreach (Player p in players)
{
Boolean intersects = false;
Rectangle tempRectangle = new Rectangle((int)(p.Position.X + p.Velocity.X),(int) (p.Position.Y + p.Velocity.Y), p.boundingBox.Width, p.boundingBox.Height);
foreach (Platform pl in platforms)
{
intersects = intersects || tempRectangle.Intersects(pl.rect);
}
if (!intersects)
{
p.onUpdate();
}
}
if (Keyboard.GetState().IsKeyDown(Keys.Space))
{
players[controlledPlayerIndex].Velocity.Y -= 0.75f;
}
if (Keyboard.GetState().IsKeyDown(Keys.A))
{
players[controlledPlayerIndex].Velocity.X -= 0.75f;
}
if (Keyboard.GetState().IsKeyDown(Keys.D))
{
players[controlledPlayerIndex].Velocity.X += 0.75f;
}
// TODO: Add your update logic here
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
foreach (Platform p in platforms)
{
p.Draw(spriteBatch);
}
foreach (Player p in players)
{
p.Draw(spriteBatch);
}
base.Draw(gameTime);
}
}
}
*Updated Source Code based on first comments
One note about this code, you need to run it in XNA and use an icon called dirt.png in a folder called Images, it doesn't matter what the picture looks like, you just need it to fully understand what is happening

Had a similar problem recently myself. Here is what I did.
//variables needed
public bool follow = true;
public Vector2D startpoint;
//puts the startpoint value equal
//to the inital location of the player
public Player()
{
startpoint.X = rectangle.X;
startpoint.Y = rectangle.Y;
}
//if any of the collision tests fail
if(collision occurs)
{
collision();
}
//else update startpoint to new valid location
else
{
startpoint.X = rectangle.X;
startpoint.Y = rectangle.Y;
follow = true;
}
if(follow == true)
{
//movement commands occur
}
else
{
follow = true;
}
//if a condition fails set player
//too last valid location
public void collision()
{
rectangle.X = startpoint.X;
rectangle.Y = startpoint.Y;
follow = false;
}
This worked well enough for me hope it helps.

Pong - Collisions with paddles not working and score

I am trying to make a simple pong game and i am stuck on the collisions with the paddles and the adding onto the score. Here is my code for the ball class:
namespace Pong
{
class Ball
{
Game1 game;
Player player;
Computer computer;
public Texture2D Texture;
public Vector2 Position;
public Vector2 Motion;
float Speed;
Rectangle ballRectangle;
Rectangle playerPaddle;
Rectangle computerPaddle;
Random random = new Random();
public void Initialize()
{
game = new Game1();
player = new Player();
computer = new Computer();
Start();
}
public void Start()
{
Motion = Vector2.Zero;
Position = new Vector2(391, 215);
Speed = 0.8f;
Motion = new Vector2(random.Next(-1, 1), random.Next(-1, 1));
}
public void Update()
{
Position += Motion * Speed;
CheckForCollision();
}
public void CheckForCollision()
{
ballRectangle = new Rectangle((int)Position.X, (int)Position.Y, 20, 20);
playerPaddle = new Rectangle((int)player.Position.X, (int)player.Position.Y, 25, 105);
computerPaddle = new Rectangle((int)computer.Position.X, (int)computer.Position.Y, 25, 105);
if (ballRectangle.Intersects(playerPaddle))
{
Motion.X *= -1;
}
if (ballRectangle.Intersects(computerPaddle))
{
Motion.X *= -1;
}
if (Position.Y < 0)
{
Motion.Y *= -1;
}
if (Position.Y > 450)
{
Motion.Y *= -1;
}
if (Position.X < 0)
{
game.computerScore += 1;
Start();
}
if (Position.X > 800)
{
game.playerScore += 1;
Start();
}
}
public void LoadContent(ContentManager Content)
{
Texture = Content.Load<Texture2D>("ball");
}
public void Draw(SpriteBatch spriteBatch)
{
spriteBatch.Draw(Texture, Position,Color.White);
}
}
}
In the rectangle I have used the actual pixels of the image instead of player.texture.width
and here is my game class:
namespace Pong
{
/// <summary>
/// This is the main type for your game
/// </summary>
public class Game1 : Microsoft.Xna.Framework.Game
{
GraphicsDeviceManager graphics;
SpriteBatch spriteBatch;
Texture2D bgtexture;
Vector2 BGpos = new Vector2(0, 0);
Ball ball;
Player player;
Computer computer;
SpriteFont Score;
Vector2 scorePosition = new Vector2(375, 5);
public int playerScore;
public int computerScore;
string scoreOutput;
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()
{
ball = new Ball();
player = new Player();
computer = new Computer();
ball.Initialize();
player.Initialze();
computer.Initialize();
this.graphics.PreferredBackBufferHeight = 450;
this.graphics.PreferredBackBufferWidth = 800;
this.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);
bgtexture = Content.Load<Texture2D>("PongBG");
Score = Content.Load<SpriteFont>("Score");
ball.LoadContent(this.Content);
player.LoadContent(this.Content);
computer.LoadContent(this.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)
{
// Allows the game to exit
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
this.Exit();
scoreOutput = playerScore + " " + computerScore;
ball.Update();
player.Update();
computer.Update();
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.Black);
spriteBatch.Begin();
spriteBatch.Draw(bgtexture, BGpos, Color.White);
ball.Draw(this.spriteBatch);
player.Draw(this.spriteBatch);
computer.Draw(this.spriteBatch);
spriteBatch.DrawString(Score, scoreOutput, scorePosition, Color.AntiqueWhite);
spriteBatch.End();
base.Draw(gameTime);
}
}
}
The ball bounces off the edge of the screen at the top and bottom fine but it just goes straight through the paddles. Also once it has hit the the edge behind the paddle it goes to the beginning like it should but it doesn't add the points onto the score for the player and the computer.

There's always the possibility that, because you're doing per-pixel collision, that the ball is moving faster than the update method can work out a collision. If the ball is moving too fast, then it could always be that the frame before collision, the ball sits before the paddle, and in the next update, the speed is applied and the ball's new position is behind the paddle. Just a thought - it's happened to me a couple of times.