We Keep Coding

program crashes (white screen) when using gamestates

I'm pretty new to programming. I'm developing a 2D game using monogame where you have to run around killing enemies and jumping from one moving tile to another trying not to fall on the spikes and die.
I almost have everything of the mechanics, collision. I want to start making multiple levels, a beginscreen where you have to press s to start and when you die a gameover screen.
I have implemented gamestates. the program starts on the first state(menu) where you get a picture that says press S to start but when i press S to start the program crashes and I get a null reference exeption... but if I don't use the menu state as the first state and instead I use the level1 gamestate the game works so there is no null reference exeption (but you don't get the menuscreen of course).
I'm doing something wrong but i cant find it. I will paste my game1.cs below. I think that's where the problem is. if you need something else please ask.
please help, thanks in advance. ps: sorry for the large amount of code but the problem could be everywhere
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using System.Collections.Generic;
namespace ninjaprincess
{
/// <summary>
/// This is the main type for your game.
/// </summary>
public class Game1 : Game
{
//Game states http://community.monogame.net/t/switch-scenes-in-monogame/2605
enum GameState
{
Menu,
GamePlayLevel1,
EndGame
}
GameState _state;
GraphicsDeviceManager graphics;
SpriteBatch spriteBatch;
Hero ninja;
private Texture2D ninjasprite;
private Texture2D background;
private LevelDesign level;
private Texture2D StartScreen;
Camera camera;
bool start;
List<Knife> knives = new List<Knife>();
KeyboardState pastkey;
public Game1()
{
graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";
/// dit toevoegen voor fullscreen////
graphics.PreferredBackBufferHeight = 1080;
graphics.PreferredBackBufferWidth = 1920;
graphics.IsFullScreen = true;
}
protected override void Initialize()
{
camera = new Camera(GraphicsDevice.Viewport);
base.Initialize();
}
protected override void LoadContent()
{
spriteBatch = new SpriteBatch(GraphicsDevice);
level = new LevelDesign();
background = Content.Load<Texture2D>("background");
ninja = new Hero(ninjasprite, new Vector2(10, 20));
ninja.Content(Content);
level.content = Content;
StartScreen = Content.Load<Texture2D>("Startscherm");
Block.Content = Content;
level.tileArray = new byte[,]
{
{ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{ 0,0,0,0,0,0,0,0,0,0,0,3,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{ 0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0},
{ 0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,4,4,0,4,4,4,0,0,0,0},
{ 0,0,0,0,0,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0},
{ 0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0},
{ 0,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{ 0,0,1,1,1,0,0,0,0,0,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,0,0,0,0,0,0}
};
level.CreateWorld(105);
ninja.controllers = new KeyboardArrows();
}
/// <summary>
/// UnloadContent will be called once per game and is the place to unload
/// game-specific content.
/// </summary>
protected override void UnloadContent()
{
// TODO: Unload any non ContentManager content here
}
/// <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();
if (_state == GameState.GamePlayLevel1)
{
camera.Update(ninja.Position, level.Width + 400, 1080);
ninja.Update(gameTime);
if (ninja.controllers.shooting && pastkey.IsKeyUp(Keys.Space))
{
ShootKnife();
}
pastkey = Keyboard.GetState();
UpdateKnife();
foreach (Block block in level.blockArray)
{
if (block is Grass)
{
ninja.CollideOnGrass(block.Rectangle);
}
if (block is Spikes)
{
ninja.CollideOnSpikes(block.Rectangle);
}
if (block is MovingGrassLeft)
{
ninja.CollideOnGrass(block.Rectangle);
block.Update(gameTime);
}
}
foreach (Enemy enemy in level.enemyArray)
{
if (enemy is Enemy)
{
ninja.CollideOnEnemy(enemy.EnemyRectangle, 2840, 1080, level.enemyArray, (enemy.EnemyRectangle.X - (enemy.EnemyRectangle.Width / 3)), enemy.EnemyRectangle.Y + (enemy.EnemyRectangle.Height / 2));
enemy.Update(gameTime);
}
}
if (ninja.isAlive == false)
{
_state = GameState.EndGame;
}
}
base.Update(gameTime);
switch (_state)
{
case GameState.Menu:
UpdateMenu(gameTime);
break;
case GameState.GamePlayLevel1:
UpdateGameplay(gameTime);
break;
case GameState.EndGame:
UpdateEndGame(gameTime);
break;
}
}
void UpdateMenu(GameTime gametime)
{
KeyboardState keyState = Keyboard.GetState();
if (keyState.IsKeyDown(Keys.S))
_state = GameState.GamePlayLevel1;
else if (keyState.IsKeyDown(Keys.Q))
Exit();
}
void UpdateGameplay(GameTime gametime)
{
KeyboardState keyState = Keyboard.GetState();
if (keyState.IsKeyDown(Keys.Escape))
_state = GameState.Menu;
}
void UpdateEndGame(GameTime gametime)
{
KeyboardState keyState = Keyboard.GetState();
if (keyState.IsKeyDown(Keys.Q))
Exit();
if (keyState.IsKeyDown(Keys.S))
_state = GameState.GamePlayLevel1;
}
public void UpdateKnife()
{
foreach (Knife knife in knives)
{
knife.position.X += 25f;
for (int i = 1; i < knives.Count; i++)
{
if (knives[i].isVisible == false)
{
knives.RemoveAt(i);
i--;
}
}
}
}
public void ShootKnife()
{
Knife newKnife = new Knife(Content.Load<Texture2D>("KunaiRight"));
newKnife.isVisible = true;
newKnife.velocity.X = 3f;
newKnife.position = new Vector2(ninja.Position.X, ninja.Position.Y + (ninja.PlayerRectangle.Height / 2));
if (knives.Count < 50)
{
knives.Add(newKnife);
}
}
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Draw(GameTime gameTime)
{
GraphicsDevice.Clear(Color.White);
switch (_state)
{
case GameState.Menu:
DrawMenu(gameTime);
break;
case GameState.GamePlayLevel1:
DrawGamePlayLevel1(gameTime);
break;
case GameState.EndGame:
DrawEndGame(gameTime);
break;
}
base.Draw(gameTime);
}
void DrawMenu(GameTime GameTime)
{
spriteBatch.Begin();
spriteBatch.Draw(StartScreen, new Rectangle(0, 0, 1920, 1080), Color.AliceBlue);
spriteBatch.End();
}
void DrawGamePlayLevel1(GameTime GameTime)
{
GraphicsDevice.Clear(Color.White);
spriteBatch.Begin();
spriteBatch.Draw(background, new Rectangle(0, 0, 1920, 1080), Color.White);
spriteBatch.End();
spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, null, null, null, null, camera.Transform);
level.DrawLevel(spriteBatch);
ninja.Draw(spriteBatch);
foreach (Knife knife in knives)
{
knife.Draw(spriteBatch);
}
spriteBatch.End();
}
void DrawEndGame(GameTime GameTime)
{
spriteBatch.Begin();
spriteBatch.Draw(StartScreen, new Rectangle(0, 0, 1920, 1080), Color.White);
spriteBatch.End();
}
}
}

If the problem is only a nullreference Exception, then try debugging your code by looking where the exception happens. I also recommend reading this: What is a NullReferenceException, and how do I fix it?
In a nutshell: Nullreference exceptions happens because the game's expecting a value in a variable, but that variable is not set. (and the standard value of 'not set' is null).
I think it's because your _state isn't set, and your Switch statements doesn't have a default case. So if It reads something that's not defined in the cases, it'll crash.
That's just my assumption though. To know the exact problem, you have to try debugging it and find where and when the exception occurs.

Monogame children update method lag

So I'm pretty new to computer programming, but I know the basics of C#.
I'm working on a Monogame project and was making an update method for my sprites. Since my sprites are terraria based (I mean that every sprite is a different bodypart) I made a children list. In that list I put all the body sprites and I attach the list to a parent (center sprite of the player).
This is my basic sprite update method: (not only for player)
public virtual void Update(GameTime gameTime, Rectangle clientBounds)
{
timeSinceLastFrame += gameTime.ElapsedGameTime.Milliseconds;
if (timeSinceLastFrame > millisecondsPerFrame)
{
timeSinceLastFrame = 0;
++currentFrame.X;
if (currentFrame.X >= sheetSize.X)
{
currentFrame.X = 0;
++currentFrame.Y;
if (currentFrame.Y >= sheetSize.Y)
{
currentFrame.Y = 0;
}
}
}
}
This is my player sprite update method in another class:
public override void Update(GameTime gameTime, Rectangle clientBounds)
{
position += direction;
// If sprite moves off screen
if (position.X < 0)
{
position.X = 0;
}
if (position.Y < 0)
{
position.Y = 0;
}
if (position.X > clientBounds.Width - frameSize.X)
{
position.X = clientBounds.Width - frameSize.X;
}
if (position.Y > clientBounds.Height - frameSize.Y)
{
position.Y = clientBounds.Height - frameSize.Y;
}
// Continue base update method
base.Update(gameTime, clientBounds);
}
And this is the draw method, wich works just fine:
public override void Draw(GameTime gameTime)
{
spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend, SamplerState.PointClamp, DepthStencilState.Default, RasterizerState.CullCounterClockwise);
player.Draw(gameTime, spriteBatch);
player.children.ForEach(c => c.Draw(gameTime, spriteBatch));
spriteBatch.End();
base.Draw(gameTime);
}
But the update method is lagging:
public override void Update(GameTime gameTime)
{
player.children.Add(playerDeux);
float millisecondsRunning = 30;
float millisecondsWalking = millisecondsRunning * 2f;
if (player.running == true)
{
player.millisecondsPerFrame = millisecondsRunning;
}
else if (player.running == false)
{
player.millisecondsPerFrame = 65;
playerDeux.millisecondsPerFrame = 30;
}
if (player.walking == false)
{
player.textureImage = Game.Content.Load<Texture2D>(#"Images/" + s1[1]);
}
player.Update(gameTime, Game.Window.ClientBounds);
player.children.ForEach(c => c.Update(gameTime, Game.Window.ClientBounds));
base.Update(gameTime);
}
So when I call the draw method on all the children it works just fine, but when I call the Update method on the children it lags very much and the program even stops working.
Is there a better way to do this?
EDIT: also note that this class is not done yet, it's just a test where I draw 2 sprites and update (animation plays) them.
+ The s1[1] in player.textureImage = Game.Content.Load(#"Images/" + s1[1]); is just a string name in an array.

There are some oddities with your code, but I think the main culprit is the player.children.Add(playerDeux). The way it is right now, you're adding playerDeux to the children list every single update, and then updating playerDeux once for every time Update has already run. It looks like you want to move this line of code to your Initialize or LoadContent methods.
Also, you should probably load the texture only once in the LoadContent method and only reference the in-memory texture in the Update method. This isn't the main reason the game is this much laggy, but it is an unnecessary overhead.

XNA spawning multiple enemies

Ok, I'm sure that i am just missing something really easy because i just can't find the answer ANYWHERE. I am making an infinite runner game(2d), but i can get one enemy spawning right at the start, and that's it. What the heck am i missing? Here's the 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 WindowsGame1
{
/// <summary>
/// This is the main type for your game
/// </summary>
public class Game1 : Microsoft.Xna.Framework.Game
{
static Random enemyspawner = new Random();
int enemyloc = enemyspawner.Next(500) + 500;
/*GraphicsDeviceManager, SpriteBatch, Texture2D and Vector2 may be found only in XNA. They are just used for drawing objects and defining locations.*/
GraphicsDeviceManager graphic;
SpriteBatch SpriteBatch;
Texture2D charr;
int enemyspeed = 1;
Vector2 charPos;
bool jumping; //Is the character jumping?
float startY, jumpspeed = 0; //startY to tell us //where it lands, jumpspeed to see how fast it jumps
GraphicsDeviceManager graphics;
SpriteBatch spriteBatch;
Texture2D grass;
Texture2D enemy;
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
charr = Content.Load<Texture2D>(#"dog_jump"); //Load image
charPos = new Vector2(230, 415);//Char loc, X/Y
grass = Content.Load<Texture2D>(#"grass1");
enemy = Content.Load<Texture2D>(#"fire hydrant");
startY = charPos.Y;//Starting position
jumping = false;//Init jumping to false
jumpspeed = 0;//Default no speed
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)
{
for (int x = 0; x == 1000; x++ )
{
enemyspeed++;
}
for (int x = 0; x == 75; x++)
{
x = 0;
spriteBatch.Begin();
spriteBatch.Draw(enemy, new Vector2(enemyloc, 450), Color.White);
spriteBatch.End();
enemyloc = enemyspawner.Next(500);
}
enemyloc -= enemyspeed;
//Init keyboard
KeyboardState keyState = Keyboard.GetState();
if (jumping)
{
charPos.Y += jumpspeed;//Making it go up
jumpspeed += 1;//Some math (explained later)
if (charPos.Y >= startY)
//If it's farther than ground
{
charPos.Y = startY;//Then set it on
jumping = false;
}
}
else
{
if (keyState.IsKeyDown(Keys.Space))
{
jumping = true;
jumpspeed = -12;//Give it upward thrust
}
}
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();
spriteBatch.Draw(grass, new Vector2(0, 450), Color.White);
spriteBatch.Draw(charr, charPos, Color.White);
spriteBatch.End();
Spawner();
base.Draw(gameTime);
}
public void Spawner()
{
spriteBatch.Begin();
spriteBatch.Draw(enemy, new Vector2(enemyloc, 450 - 50), Color.White);
spriteBatch.End();
}
}
}
Also, yes i did get te gravity code off the internet, nothing that i tried was working

In the second for loop in the update method you are setting x to zero every time. That will prevent it from getting outside of that loop and that would explain the behaviour you have seen

first of all, this doesn't make any sense:
for (int x = 0; x == 1000; x++ )
{
enemyspeed++;
}
This only increases the speed if x equals 1000.
You will get the same result if you remove the for loop, but you probably want this: for (int x = 0; x <1000; x++ )//increases speed 1000 times
You also got a problem here:
for (int x = 0; x == 75; x++)//same here as mentioned above
{
x = 0;
spriteBatch.Begin();
spriteBatch.Draw(enemy, new Vector2(enemyloc, 450), Color.White);
spriteBatch.End();
enemyloc = enemyspawner.Next(500);
}
Also, you keep setting x to 0, so this loop will run forever.
EDIT:
for (int x = 0; x == 1000; x++ )
I looked at it again and I coudn't find any reason why you would increase the speed 1000 times, by using a for loop. So I believe/assume you want to update the speed after 1000 updates? In that case, this is what you want:
//Add a atrubit count to your class:
int count = 0;
//Update method:
protected override void Update(GameTime gameTime)
{
count++;//update count
if(count % 1000 == 0){
enemyspeed++;//update speed after 1000 updates
}
if(count % 75 == 0){//draw after 75 updates
spriteBatch.Begin();
spriteBatch.Draw(enemy, new Vector2(enemyloc, 450), Color.White);
spriteBatch.End();
enemyloc = enemyspawner.Next(500);
}
//do your other stuff
}

XNA 4.0 Collision Detection causes sprite to bounce

My collision detection seems to be working, all be it some of the collisions it is detecting are odd as in it'll say that the collision was on the bottom of the platform when it isn't. However that isn't the main problem.
When the player collides with the platform, instead of moving to the surface of the platform he moves above it and with my gravity in place it looks like he is constantly bouncing. I can't figure out why.
If you guys could help it would be much appreciated. It could be something very simple I'm missing since I'm new to XNA and C#.
I will list my Game1, Player and Platoform classes below. (My collision detection is in the player class)
Thanks
Game1 Class
public class Game1 : Microsoft.Xna.Framework.Game
{
GraphicsDeviceManager graphics;
SpriteBatch spriteBatch;
Texture2D background;
Movement character;
Platform[] platforms;
//private Vector2 SnapePosition = Vector2.Zero;
public Game1()
{
graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";
graphics.PreferredBackBufferHeight = 440;
graphics.PreferredBackBufferWidth = 782;
}
/// <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
platforms = new Platform[15];
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);
for (int i = 0; i < platforms.Length; i++)
{
platforms[i] = new Platform(
Content.Load<Texture2D>("Platforms/lvl2_platform"), new Rectangle(i*100, 410, 100, 30));
}
character = new Movement(Content.Load<Texture2D>("snape"), new Rectangle(0, 360, 50, 50), platforms);
// TODO: use this.Content to load your game content here
background = Content.Load<Texture2D>("Backgrounds/lvl2_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();
//Allows the player to move
character.Update();
// 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
spriteBatch.Begin();
spriteBatch.Draw(background, Vector2.Zero, Color.White);
character.Draw(spriteBatch);
foreach (Platform platform in platforms)
{
platform.Draw(spriteBatch);
}
spriteBatch.End();
base.Draw(gameTime);
}
}
Player Class
class Player
{
public Texture2D Snape;
public Rectangle SnapePosition;
public enum CollisionPosition { None, Top, Bottom, Left, Right };
public CollisionPosition collisionType;
public bool inCollision;
public int collisionDepth;
public Platform[] plat;
public int num;
public virtual void Update()
{
}
public void Draw(SpriteBatch spriteBatch)
{
spriteBatch.Draw(Snape, SnapePosition, Color.White);
}
}
class Movement : Player
{
public Movement(Texture2D newSnape, Rectangle newSnapePosition, Platform[] a)
{
Snape = newSnape;
SnapePosition = newSnapePosition;
plat = a;
}
public override void Update()
{
// Check for collision
Collisions();
// Determine collision type
//DetermineCollisionType();
// Separate snape
//SeparateSnape();
KeyboardState keyBoard = Keyboard.GetState();
if (keyBoard.IsKeyDown(Keys.A))
{
SnapePosition.X -= 5;
}
if (keyBoard.IsKeyDown(Keys.D))
{
SnapePosition.X += 5;
}
if (keyBoard.IsKeyDown(Keys.W))
{
SnapePosition.Y -= 5;
}
//if (keyBoard.IsKeyDown(Keys.S))
//{
SnapePosition.Y += 5;
// }
// if (SnapePosition.X < 0)
// SnapePosition.X = 0;
// if (SnapePosition.Y < 0)
// SnapePosition.Y = 0;
// if (SnapePosition.X > GraphicsDevice.Viewport.Width - Snape.Width)
// SnapePosition.X = GraphicsDevice.Viewport.Width - Snape.Width;
// if (SnapePosition.Y > GraphicsDevice.Viewport.Height - Snape.Height)
// SnapePosition.Y = GraphicsDevice.Viewport.Height - Snape.Height;
}
public void Collisions()
{
for (int i = 0; i < plat.Length; i++)
{
if (plat[i].rectangle.Intersects(SnapePosition))
{
inCollision = true;
num = i;
DetermineCollisionType();
}
}
}
public void DetermineCollisionType()
{
if (inCollision == false)
{
collisionType = CollisionPosition.None;
collisionDepth = 0;
}
else
{
// Determine the side of *least intersection* for snape
int minColDepth = int.MaxValue;
// Check the top side
int tColDepth = (plat[num].rectangle.Y + plat[num].texture.Height / 2) - (SnapePosition.Y - Snape.Height / 2);
if (tColDepth > 0 && tColDepth < minColDepth)
{
collisionType = CollisionPosition.Top;
minColDepth = tColDepth;
}
// Check the bottom side
int bColDepth = (SnapePosition.Y + Snape.Height / 2) - (plat[num].rectangle.Y - plat[num].texture.Height / 2);
if (bColDepth > 0 && bColDepth < minColDepth)
{
collisionType = CollisionPosition.Bottom;
minColDepth = bColDepth;
}
// Check the right overlap
int rColDepth = (SnapePosition.X + Snape.Width / 2) - (plat[num].rectangle.X - plat[num].texture.Width / 2);
if (rColDepth > 0 && rColDepth < minColDepth)
{
collisionType = CollisionPosition.Right;
minColDepth = rColDepth;
}
// Check the left overlap
int lColDepth = (plat[num].rectangle.X + plat[num].texture.Width / 2) - (SnapePosition.X - Snape.Width / 2);
if (lColDepth > 0 && lColDepth < minColDepth)
{
collisionType = CollisionPosition.Left;
minColDepth = lColDepth;
}
// Update the collision depth
collisionDepth = minColDepth;
SeparateSnape();
}
}
public void SeparateSnape()
{
switch (collisionType)
{
case CollisionPosition.None:
break;
case CollisionPosition.Top:
SnapePosition.Y += (collisionDepth);
break;
case CollisionPosition.Bottom:
SnapePosition.Y -= collisionDepth;
break;
case CollisionPosition.Right:
SnapePosition.X -= collisionDepth;
break;
case CollisionPosition.Left:
SnapePosition.X += collisionDepth;
break;
}
}
}
Platform Class
class Platform
{
public Texture2D texture;
public Rectangle rectangle;
public Platform(Texture2D newTexture, Rectangle newRectangle)
{
texture = newTexture;
rectangle = newRectangle;
}
public void Update()
{
}
public void Draw(SpriteBatch spriteBatch)
{
spriteBatch.Draw(texture, rectangle, Color.White);
}
}

I fixed up your collision.
All of your depth calculations were incorrect. You were doing them based upon the center of the entity (player/platform) and using their texture sizes instead of their rectangle sizes.
You may have been thinking that everything draws from the middle, but by default it draws from the top left in XNA.
Here are the new depth calculations located in your "Movement" class under the "DetermineCollisionType()" function.
The top depth needs to work on the top of the platform (Y), and on the bottom of snape (Y + Height).
int tColDepth =
(SnapePosition.Y + SnapePosition.Height) - (plat[num].rectangle.Y);
The bottom depth needs to work on the bottom of the playform (Y + Height) and on the top of snape (Y).
int bColDepth =
(plat[num].rectangle.Y + plat[num].rectangle.Height) - (SnapePosition.Y);
The right depth needs to work on the left of the platform (X) and the right of snape (X + Width).
int rColDepth =
(SnapePosition.X + SnapePosition.Width) - (plat[num].rectangle.X);
The left depth needs to work on the right of the platform (X + Width) and on the left of Snape (X).
int lColDepth =
(plat[num].rectangle.X + plat[num].rectangle.Width) - (SnapePosition.X);
This will work from now on in. However you may want to use lists for your platform. Lists are easier for when/if you do a level editor as you don't have to say "I want 15 platforms".

XNA 4.0 Collision Detection not working

I've managed to get the values where I think they need to be getting so that the collision detection between snape and the platform bounding boxes takes place in the platform class. However it isn't working. There are no errors and I can't see where I'm going wrong.
Your help would be much appreciated. My 3 classes are below.
Game1 Class
public class Game1 : Microsoft.Xna.Framework.Game
{
GraphicsDeviceManager graphics;
SpriteBatch spriteBatch;
Texture2D background;
Movement character;
Platform[] platforms;
//private Vector2 SnapePosition = Vector2.Zero;
public Game1()
{
graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";
graphics.PreferredBackBufferHeight = 440;
graphics.PreferredBackBufferWidth = 782;
}
protected override void Initialize()
{
// TODO: Add your initialization logic here
platforms = new Platform[15];
base.Initialize();
}
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
spriteBatch = new SpriteBatch(GraphicsDevice);
character = new Movement(Content.Load<Texture2D>("snape"), new Rectangle(0, 350, 50, 50));
for (int i = 0; i < platforms.Length; i++)
{
platforms[i] = new Platform(
Content.Load<Texture2D>("Platforms/lvl2_platform"), new Rectangle(i*100, 410, 100, 30), character.Snape, character.SnapePosition);
}
// TODO: use this.Content to load your game content here
background = Content.Load<Texture2D>("Backgrounds/lvl2_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();
//Allows the player to move
character.Update();
// 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
spriteBatch.Begin();
spriteBatch.Draw(background, Vector2.Zero, Color.White);
character.Draw(spriteBatch);
foreach (Platform platform in platforms)
{
platform.Draw(spriteBatch);
}
spriteBatch.End();
base.Draw(gameTime);
}
}
}
Player Class
class Player
{
public Texture2D Snape;
public Rectangle SnapePosition;
public virtual void Update()
{
}
public void Draw(SpriteBatch spriteBatch)
{
spriteBatch.Draw(Snape,SnapePosition,Color.White);
}
}
class Movement : Player
{
public Movement(Texture2D newSnape, Rectangle newSnapePosition)
{
Snape = newSnape;
SnapePosition = newSnapePosition;
}
public override void Update()
{
KeyboardState keyBoard = Keyboard.GetState();
if (keyBoard.IsKeyDown(Keys.A))
{
SnapePosition.X -= 5;
}
if (keyBoard.IsKeyDown(Keys.D))
{
SnapePosition.X += 5;
}
if (keyBoard.IsKeyDown(Keys.W))
{
SnapePosition.Y -= 5;
}
if (keyBoard.IsKeyDown(Keys.S))
{
SnapePosition.Y += 5;
}
}
}
}
Platform Class
class Platform
{
Texture2D texture;
Rectangle rectangle;
Texture2D snape;
Rectangle snapePosition;
public Rectangle test;
public enum CollisionPosition { None, Top, Bottom, Left, Right };
public CollisionPosition collisionType;
public bool inCollision;
public int collisionDepth;
public Platform(Texture2D newTexture, Rectangle newRectangle, Texture2D newSnape, Rectangle newSnapePos)
{
texture = newTexture;
rectangle = newRectangle;
snapePosition = newSnapePos;
snape = newSnape;
}
public void Draw(SpriteBatch spriteBatch)
{
spriteBatch.Draw(texture, rectangle, Color.White);
}
public void Collisions()
{
if (rectangle.Intersects(snapePosition))
inCollision = true;
}
public void DetermineCollisionType()
{
if (inCollision == false)
{
collisionType = CollisionPosition.None;
collisionDepth = 0;
}
else
{
// Determine the side of *least intersection* for snape
int minOverlap = int.MaxValue;
// Check the top side
int tOverlap =
(rectangle.Y + texture.Height / 2)
- (snapePosition.Y - snape.Height / 2);
if (tOverlap > 0 && tOverlap < minOverlap)
{
collisionType = CollisionPosition.Top;
minOverlap = tOverlap;
}
// Check the bottom side
int bOverlap =
(snapePosition.Y + snape.Height / 2)
- (rectangle.Y - texture.Height / 2);
if (bOverlap > 0 && bOverlap < minOverlap)
{
collisionType = CollisionPosition.Bottom;
minOverlap = bOverlap;
}
// Check the right overlap
int rOverlap =
(snapePosition.X + snape.Width / 2)
- (rectangle.X - texture.Width / 2);
if (rOverlap > 0 && rOverlap < minOverlap)
{
collisionType = CollisionPosition.Right;
minOverlap = rOverlap;
}
// Check the left overlap
int lOverlap =
(rectangle.X + texture.Width / 2)
- (snapePosition.X - snape.Width / 2);
if (lOverlap > 0 && lOverlap < minOverlap)
{
collisionType = CollisionPosition.Left;
minOverlap = lOverlap;
}
// Update the collision depth
collisionDepth = minOverlap;
}
}
public void SeparateSnape()
{
switch (collisionType)
{
case CollisionPosition.None:
break;
case CollisionPosition.Top:
snapePosition.Y += collisionDepth;
break;
case CollisionPosition.Bottom:
snapePosition.Y -= collisionDepth;
break;
case CollisionPosition.Right:
snapePosition.X -= collisionDepth;
break;
case CollisionPosition.Left:
snapePosition.X += collisionDepth;
break;
}
}
public void Update()
{
// Check for collision
Collisions();
// Determine collision type
DetermineCollisionType();
// Separate snape
SeparateSnape();
}
public Rectangle getSnapePos
{
get { return snapePosition; }
}
}
}

protected override void Update(GameTime gameTime)
{
// Allows the game to exit
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
this.Exit();
//Allows the player to move
character.Update();
// TODO: Add your update logic here
base.Update(gameTime);
}
I do not see any updates regarding your platforms.
try adding
foreach (Platform platform in platforms)
{
platform.Update();
}

Part of your problem appears to be that you don't know what the difference between a class and a struct is. A rectangle is a struct, meaning that when you pass it as an argument into any method it gets passed 'by value' meaning a copy of the value is made and it lives for as long as the method is running, after which it no longer exists. Classes on the other hand are reference types, so if you passed a class as an argument, you'd be passing it 'by reference' meaning the method would get a value telling it where to access the class. The difference here is that although the reference gets destroyed when the method ends, it is just a reference, not the value itself, unlike the struct.
On top of this, even if you were giving the platforms a reference to snape's position instead of just a value, when you move snape, you change the entire value of his position, not just parts of it, so it would be overwriting snape's reference, making the platform's references outdated anyway.
To be honest I think you would be better rethinking your design a bit.
Firstly, try moving the keyboard management outside of the character, so the game essentially hooks onto one character and controls the movement of that one character. This is important because it means that the game itself knows who the main character is, what platforms the character can collide with and thus can perform collision checking with the platforms and the character. If the platforms can't change the character's position and the player doesn't know what all the platforms on the map are, then it seems more sensible to have the game itself monitoring that.
Here's an example:
protected override void Update()
{
KeyboardState keyboardState = Keyboard.GetState();
Rectangle oldBounds = player.Bounds;
if (keyboardState.IsKeyDown(Keys.W)) { player.Y--; }
if (keyboardState.IsKeyDown(Keys.A)) { player.X--; }
if (keyboardState.IsKeyDown(Keys.X)) { player.Y++; }
if (keyboardState.IsKeyDown(Keys.D)) { player.X++; }
foreach (Platform platform in platforms)
{
if (player.Bounds.Intersects(platform.Bounds))
{
player.Bounds = oldBounds;
break;
}
}
}
You'll want to make it a bit more sophisticated, but that's probably the most basic collision system available. Obviously if you're doing a platformer, you're probably going to want to be a bit more clever. I suggest you do as much research and experimentation as you can, also be sure to look up how to add breakpoints into your code and run your code line by line, as well as using the local and watch boxes to figure out exactly what's going on when your code runs. If you can identify what is happening and what should be happening, it will make things much easier to fix and understand.