Help with blocks in Breakout XNA C#

I've stuck on creating multiple rows of block, any help will be appreciated

i've uploaded the source code

Thanks in advance

code preview:

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;

using Microsoft.Xna.Framework.Net;

using Microsoft.Xna.Framework.Storage;

namespace XNA_Breakout

{

///

/// This is the main type for your game

///

public class Game1 : Microsoft.Xna.Framework.Game

{

GraphicsDeviceManager graphics;

SpriteBatch spriteBatch;

//Game world data

//Application windows data

float windowWidth;

float windowHeight;

float overScan = 10.0f;

float windowMinX;

float windowMaxX;

float windowMinY;

float windowMaxY;

//Data for the application's ball

Texture2D ballTexture;

Rectangle ballRect;

float ballX;

float ballXSpeed;

float ballY;

float ballYSpeed;

float ballSize = 0.04f;

//Data for the application's paddle

Texture2D paddleTexture;

Rectangle paddleRect;

float paddleX;

float paddleXSpeed;

float paddleY;

float paddleSize = 0.15f;

//Data for the application's bricks

Texture2D brickTexture;

GameSpriteStruct[] bricks; //Define bricks array

int noOfBricks = 10; //Number of bricks to be displayed

//These variables represent audio files

SoundEffect collisionWave;

SoundEffect missWave;

//Define variables of type Font to be used to display text

SpriteFont font;

//Various game variables

int plays = 3; //A game consists of 3 plays

int noObVisibleBricks; //Tracks the number of visisble bricks

int playerScore = 0; //Tracks player score

bool stateOfGame = false; //Tracks game state

float space; //Used to determine space between bricks

//This structure defines data for the game's bricks

struct GameSpriteStruct

{

public Texture2D spriteTexture;

public Rectangle spriteRect;

public float X;

public float Y;

public float WidthFactor;

public bool Visible;

}

GameSpriteStruct splash;

public Game1()

{

graphics = new GraphicsDeviceManager(this);

this.graphics.PreferredBackBufferWidth = 1280;

this.graphics.PreferredBackBufferHeight = 720;

this.graphics.IsFullScreen = false;

Content.RootDirectory = "Content";

}

///

/// 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.

///

protected override void Initialize()

{

ConfigureScreen(); //This method establishes screen configuration

base.Initialize();

}

///

/// LoadContent will be called once per game and is the place to load

/// all of your content.

///

protected override void LoadContent()

{

// Create a new SpriteBatch, which can be used to draw textures.

spriteBatch = new SpriteBatch(GraphicsDevice);

//Load the game's graphic files into memory

ballTexture = Content.Load("ball");

paddleTexture = Content.Load("paddle");

brickTexture = Content.Load("redbrick");

splash.spriteTexture = Content.Load("splash");

//Call method that configures the game's ball and paddle

ConfigureBallAndPaddle();

//Load the game's audio files into memory

collisionWave = Content.Load("collision");

missWave = Content.Load("miss");

//Load the game's font

font = Content.Load("SpriteFont1");

//Instantiate a bricks object

bricks = new GameSpriteStruct[noOfBricks];

ConfigureBricks(); //Call on method that configures the bricks

DisplaySplashScreen(); //Call on method that displays the splash screen

}

///

/// UnloadContent will be called once per game and is the place to unload

/// all content.

///

protected override void UnloadContent()

{

// TODO: Unload any non ContentManager content here

}

///

/// Allows the game to run logic such as updating the world,

/// checking for collisions, gathering input, and playing audio.

///

/// Provides a snapshot of timing values.

protected override void Update(GameTime gameTime)

{

// Allows the game to exit

if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)

this.Exit();

//Retrieve gamepad state data

GamePadState gamePad1 = GamePad.GetState(PlayerIndex.One);

//Start game play when the player presses the gamepad's A button

if (gamePad1.Buttons.A == ButtonState.Pressed)

{

StartGame(); //This method starts game play

}

if (stateOfGame == true) //A value of true indicates active game play

{

//Determine the paddle's location

paddleX = paddleX + (paddleXSpeed * gamePad1.ThumbSticks.Left.X);

ProcessPaddleMovement();

ProcessBallMovement();

KeepTrackOfBricks();

}

base.Update(gameTime);

}

///

/// This is called when the game should draw itself.

///

/// Provides a snapshot of timing values.

protected override void Draw(GameTime gameTime)

{

GraphicsDevice.Clear(Color.CornflowerBlue);

Vector2 textVector1 = new Vector2(40, 30);

spriteBatch.Begin();

spriteBatch.Draw(ballTexture, ballRect, Color.White);

spriteBatch.Draw(paddleTexture, paddleRect, Color.White);

spriteBatch.DrawString(font, "Lives: " + plays.ToString() +

" Points: " + playerScore.ToString(), textVector1, Color.Black);

switch (stateOfGame)

{

case false: //A alue of false means its time to display the splash screen

spriteBatch.Draw(splash.spriteTexture, splash.spriteRect, Color.White);

break;

//A value of true indicates active game play

//Draw the ball, paddle and score

//Draw only visible bricks

for (int i = 0; i < noOfBricks; i++)

{

if (bricks[i].Visible)

{

spriteBatch.Draw(bricks[i].spriteTexture, bricks[i].spriteRect, Color.White);

}

for (int k = 0; k < noOfBricks; k++)

{

if (bricks[k].Visible)

{

spriteBatch.Draw(bricks[k].spriteTexture, bricks[k].spriteRect, Color.White);

}

break;

}

spriteBatch.End();

base.Draw(gameTime);

}

//This method establishes screen configuration

private void ConfigureScreen()

{

//Set window width and height

windowWidth = graphics.GraphicsDevice.Viewport.Width;

windowHeight = graphics.GraphicsDevice.Viewport.Height;

//Calculate the over scan margin (for Xbox 360)

float xOverscanMargin = (windowWidth * overScan) / 100;

float yOverscanMargin = (windowHeight * overScan) / 100;

//Use the over scan margin to set the game's boarders

windowMinX = xOverscanMargin;

windowMinY = yOverscanMargin;

windowMaxX = windowWidth - xOverscanMargin;

windowMaxY = windowHeight - yOverscanMargin;

//Position the paddle at the bottom of the window

paddleY = windowMaxY - 20;

}

void ConfigureBallAndPaddle()

{

//Set ball size

ballRect.Width = (int)((windowWidth * ballSize) + 0.5f);

float ratio = (float)ballTexture.Width / ballTexture.Height;

ballRect.Height = (int)((ballRect.Width / ratio) + 0.5f);

//Position the ball at the bottom center of the window just

//above the paddle

ballY = windowMaxY - 80;

ballX = (windowWidth - ballRect.Width) / 2;

ballXSpeed = windowWidth / 140.0f; //Set ball's horizontal speed

ballYSpeed = ballXSpeed * -1; //Set ball's vertical speed

//Set paddle size

paddleRect.Width = (int)((windowWidth * paddleSize) + 0.5f);

ratio = (float)paddleTexture.Width / paddleTexture.Height;

paddleRect.Height = (int)((paddleRect.Width / ratio) + 0.5f);

//Position the paddle at the bottom center of the window

paddleX = (windowWidth - paddleRect.Width) / 2;

paddleXSpeed = windowWidth / 100.0f; //Set speed the paddle can move

}

//This method start game play

private void StartGame()

{

stateOfGame = true; //A value of true initiates game play

plays = 3; //Reset the player's lives

playerScore = 0; //Reset the player's score

ConfigureBricks(); //This method reconfigures a new screen of bricks

}

private void ProcessPaddleMovement()

{

paddleRect.X = (int)paddleX; //Set the paddle's horizontal location

paddleRect.Y = (int)paddleY; //Set the paddle's vertical location

//Halt paddle when it reaches the right edge of the display area

if (paddleX + paddleRect.Width >= windowMaxX)

{

paddleRect.X = (int)windowMaxX - paddleRect.Width;

}

//Halt paddle when it reaches the left edge of the display area

if (paddleX <= windowMinX) paddleRect.X = (int)windowMinX;

}

private void ProcessBallMovement()

{

//Determine the ball's location

ballX = ballX + ballXSpeed;

ballY = ballY + ballYSpeed;

ballRect.X = (int)(ballX + 0.5f); //Set the ball's horizontal location

ballRect.Y = (int)(ballY + 0.5f); //Set the ball's vertical location

//Reverse ball direction along the X-axis when it reaches the right

//hand side of the display area

if (ballX + ballRect.Width >= windowMaxX)

{

ballXSpeed = ballXSpeed * -1;

collisionWave.Play(); //Play sound effect

}

//Reverse ball direction along the X-axis when it reaches the

//left hand side of the display area

if (ballX <= windowMinX)

{

ballXSpeed = ballXSpeed * -1;

collisionWave.Play(); //Play sound effect

}

//Halt the current round of play if the ball reaches the bottom

//of the display area

if (ballY + ballRect.Height >= windowMaxY)

{

missWave.Play(); //Play sound effect

plays = plays - 1; //Take away one of the player's lives

ConfigureBallAndPaddle();

//Mark the game as over when the player lives are gone

if (plays == 0) stateOfGame = false;

}

//Reverse ball direction along the Y-axis when the ball reaches the

//top of the display area

if (ballY <= windowMinY)

{

ballYSpeed = ballYSpeed * -1;

collisionWave.Play(); //Play sound effect

}

//Reverse ball direction along the Y-axis when it collides

//with the paddle

if (ballRect.Intersects(paddleRect))

{

ballYSpeed = ballYSpeed * -1;

collisionWave.Play(); //Play sound effect

}

private void KeepTrackOfBricks()

{

//Iterate once for evey brick

for (int i = 0; i < noOfBricks; i++)

{

//Check to see if the brick is visible

if (bricks[i].Visible)

{

//Process a collision between the ball and a brick

if (ballRect.Intersects(bricks[i].spriteRect))

{

bricks[i].Visible = false; //Mark the brick as invisible

noObVisibleBricks = noObVisibleBricks - 1; //Update brick count

playerScore = playerScore + 10; //Increase the player's score

ballYSpeed = ballYSpeed * -1; //Reverse the movement of the ball

collisionWave.Play(); //Play sound effect

break; //Exit the loop

}

//Set the X and Y coordinates for the brick

bricks[i].spriteRect.X = (int)bricks[i].X;

bricks[i].spriteRect.Y = (int)bricks[i].Y;

}

//If there are not more bricks left then redisplay them again

if (noObVisibleBricks == 0) ConfigureBricks();

}

//This methods configures the display of red bricks across the top

//of the game window

private void ConfigureBricks()

{

//Calculate the spacing betwen the bricks

space = (windowMaxX - windowMinX) / noOfBricks;

//Set variable equal to the total number of bricks

noObVisibleBricks = noOfBricks;

//This loop populates the bricks array with bricks, configure them and

//marks them as visible

for (int i = 0; i < noOfBricks; i++)

{

bricks[i].spriteTexture = brickTexture;

bricks[i].WidthFactor = 0.08f;

bricks[i].spriteRect.Width = (int)((windowWidth * 0.08f) + 0.5f);

float ratio =

(float)bricks[i].spriteTexture.Width / bricks[i].spriteTexture.Height;

bricks[i].spriteRect.Height =

(int)((bricks[i].spriteRect.Width / ratio) + 0.5f);

bricks[i].X = windowMinX + (i * space);

bricks[i].Y = windowMinY + 50;

bricks[i].Visible = true;

}

private void DisplaySplashScreen()

{

//Display the game's splash screen

splash.spriteRect = new Rectangle((int)windowMinX, (int)windowMinY,

(int)(windowMaxX - windowMinX), (int)(windowMaxY - windowMinY));

}