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
{
/// <summary>
/// This is the main type for your game
/// </summary>
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";
}
/// <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()
{
ConfigureScreen(); //This method establishes screen configuration
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);
//Load the game's graphic files into memory
ballTexture = Content.Load<Texture2D>("ball");
paddleTexture = Content.Load<Texture2D>("paddle");
brickTexture = Content.Load<Texture2D>("redbrick");
splash.spriteTexture = Content.Load<Texture2D>("splash");
//Call method that configures the game's ball and paddle
ConfigureBallAndPaddle();
//Load the game's audio files into memory
collisionWave = Content.Load<SoundEffect>("collision");
missWave = Content.Load<SoundEffect>("miss");
//Load the game's font
font = Content.Load<SpriteFont>("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
}
/// <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();
//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);
}
/// <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);
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));
}
}
}