/*
 * Title: Breakout
 * Author: Popcorn
 * Version 3
*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

#define SCREENWIDTH 50
#define SCREENHEIGHT 20

#define BLOCKWIDTH  5
#define BLOCKHEIGHT 2

#define BALLWIDTH 2
#define BALLHEIGHT 2
#define BALLSPEED 1

#define BATWIDTH  8
#define BATHEIGHT 2
#define BATSPEED 2

#define LIVES 3

#define TRUE 1
#define FALSE 0

typedef int bool;

//block structure
typedef struct block
{
  SMALL_RECT srBlockRect;
  bool bCanCollide;
}block;

typedef struct ball
{
  SMALL_RECT srBallRect;
  SMALL_RECT srBlankBallRect;
  CHAR_INFO ciBallSprite[BALLWIDTH * BALLHEIGHT];
  CHAR_INFO ciBlankBallSprite[BALLWIDTH * BALLHEIGHT];
  int iBallSpeed;
  int iDirectionX;
  int iDirectionY;
  COORD start;
  COORD old;
  COORD gridSize;
  COORD zeroZero;
}ball;

typedef struct bat
{
  SMALL_RECT srBatRect;
  SMALL_RECT srBlankBatRect;
  CHAR_INFO ciBatSprite[BATWIDTH * BATHEIGHT];
  CHAR_INFO ciBlankBatSprite[BATWIDTH * BATHEIGHT];
  int iBatSpeed;
  COORD start;
  COORD old;
  COORD gridSize;
  COORD zeroZero;
}bat;

void initializeBall(ball *);
bool moveBall(HANDLE, ball *, int *);
void initializeBlocks(block *, int);
void drawBlocks(HANDLE, block *, int);
bool collision(SMALL_RECT, SMALL_RECT);
void initializeBat(bat *);
void moveBat(HANDLE, HANDLE, bat *);
void restartGame(HANDLE, ball *, bat *);	

int main(int argc, char *argv[])
{
  //Windows console variables
  HANDLE hOut;										
  HANDLE hIn;
  
  hIn = GetStdHandle(STD_INPUT_HANDLE);												
  hOut = GetStdHandle(STD_OUTPUT_HANDLE);
  
  CHAR_INFO ciBlankBlockSprite[BLOCKWIDTH * BLOCKHEIGHT];//memory to hold the  replacement 'sprite'
  
  //game variables
  bool bRunGame = TRUE;//the variable for
  int iCount = 0;//counts the number of blocks that have been hit
  int iLives = LIVES;
  	
  block blocks[30];
  ball ball;
  bat bat;
  
  int i;//looping variable
  int x, y;//looping variables for blankblocksprite
  COORD gridSize = {BLOCKWIDTH , BLOCKHEIGHT};
  COORD zeroZero = {0, 0};
  
  //create a small rectangle containing ' ' characters
  for(y = 0; y < gridSize.Y; y++)						
  {
    for(x = 0; x < gridSize.X; x++)				
    {												
      ciBlankBlockSprite[x + y * BLOCKWIDTH].Char.AsciiChar = ' ';
      ciBlankBlockSprite[x + y * BLOCKWIDTH].Attributes = FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_RED;
    }
  }
  
  //seed the randam number function
  srand((unsigned)time(NULL));
  
  //game initialization
  initializeBlocks(blocks, 30);
  initializeBall(&ball);
  initializeBat(&bat);
  
  drawBlocks(hOut, blocks, 30);
  
  //game loop  
  while(bRunGame)
  {
    if(!moveBall(hOut, &ball, &iLives))
      restartGame(hOut, &ball, &bat);
    
    for(i = 0; i < 30; i++)
    {
      if(collision(ball.srBallRect, blocks.srBlockRect) && blocks.bCanCollide)
      {
        WriteConsoleOutput(hOut, ciBlankBlockSprite, gridSize, zeroZero, &blocks.srBlockRect);
        blocks.bCanCollide = FALSE;
        ball.iDirectionY = 1;
        iCount++;
      }
      if(iCount == 30)
        bRunGame = FALSE;
    }
    
    //check if there is any collision between bat and ball   
    if(collision(ball.srBallRect, bat.srBatRect))
      ball.iDirectionY = -1;//change the direction of the ball in the y-axis
    
    moveBat(hOut, hIn, &bat);
    
    //the player has run out of lives so end the game
    if(iLives == 0)
      bRunGame = FALSE;
    
    COORD test2 = {0, 22};
    SetConsoleCursorPosition(hOut, test2);
    printf("Lives Left: %d\n", iLives);
    
    sleep(100);
  }
  
  system("PAUSE");	
  return 0;
}

//function to create the ball
void initializeBall(ball *ball)
{
  int x, y;//looping variables
  
  ball->gridSize.X = BALLWIDTH;
  ball->gridSize.Y = BALLHEIGHT;
  
  ball->zeroZero.X = 0;
  ball->zeroZero.Y = 0;
  
  ball->start.X = 10;
  ball->start.Y = 10;
  
  ball->old.X = ball->start.X;
  ball->old.Y = ball->start.Y;
  	
  //create a small rectangle containing '*' characters
  for(y = 0; y < ball->gridSize.Y; y++)						
  {
    for(x = 0; x < ball->gridSize.X; x++)				
    {												
      ball->ciBallSprite[x + y * BALLWIDTH].Char.AsciiChar = '*';
      ball->ciBallSprite[x + y * BALLWIDTH].Attributes = FOREGROUND_BLUE;
    }
  }
  
  //create a small rectangle containing ' ' characters
  for(y = 0; y < ball->gridSize.Y; y++)						
  {
    for(x = 0; x < ball->gridSize.X; x++)				
    {												
      ball->ciBlankBallSprite[x + y * BALLWIDTH].Char.AsciiChar = ' ';
      ball->ciBlankBallSprite[x + y * BALLWIDTH].Attributes = FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_RED;
    }
  }
  
  ball->iBallSpeed = BALLSPEED;
  ball->iDirectionX = 1;
  ball->iDirectionY = 1;
}

//function to move and draw the ball and check for collision with screen
bool moveBall(HANDLE hOut, ball *ball, int *iLives)
{
  //define rectangle to draw onto the screen
  ball->srBallRect.Left = ball->start.X;
  ball->srBallRect.Top = ball->start.Y;
  ball->srBallRect.Right = ball->start.X + BALLWIDTH;
  ball->srBallRect.Bottom = ball->start.Y + BALLHEIGHT;
  
  //rectangle to hold the old coordinates to draw the blank ball sprite to
  ball->srBlankBallRect.Left = ball->old.X;
  ball->srBlankBallRect.Top = ball->old.Y;
  ball->srBlankBallRect.Right = ball->old.X + BALLWIDTH;
  ball->srBlankBallRect.Bottom = ball->old.Y + BALLHEIGHT;
  
  //check for collision with the screen
  if(ball->srBallRect.Right == SCREENWIDTH - 1)
    ball->iDirectionX = -1;
        
  if(ball->srBallRect.Bottom > SCREENHEIGHT - 1)
  {
    (*iLives)--;
    return FALSE;//the ball fell off the screen
  }
      
  if(ball->srBallRect.Left <= 0)
    ball->iDirectionX = 1;
      
  if(ball->srBallRect.Top <= 0)
    ball->iDirectionY = 1;
    
  ball->old.X = ball->start.X;
  ball->old.Y = ball->start.Y;
  
  //increase the ball co-ordinate in the appropriate direction
  ball->start.X = ball->start.X + (ball->iDirectionX * ball->iBallSpeed);
  ball->start.Y = ball->start.Y + (ball->iDirectionY * ball->iBallSpeed);
   
  //draw over the old ball with the blank sprite
  WriteConsoleOutput(hOut, ball->ciBlankBallSprite, ball->gridSize, ball->zeroZero, &ball->srBlankBallRect);    
  //draw the new ball to the screen
  WriteConsoleOutput(hOut, ball->ciBallSprite, ball->gridSize, ball->zeroZero, &ball->srBallRect);
  
  //the ball was bounced back
  return TRUE;
}

//function to create the blocks
void initializeBlocks(block *blocks, int iNumOfBlocks)
{ 
  int i; //looping variable
  
  //The starting coordinates for the first rectangle
  COORD leftTop = {0, -2};
  COORD rightBottom = {BLOCKWIDTH, BLOCKHEIGHT};
   
  //create the rectangles for the blocks
  for(i = 0; i < iNumOfBlocks; i++)
  {
    if(i % 10 == 0)
    {
      leftTop.X = 0;
      rightBottom.X = BLOCKWIDTH;
      leftTop.Y = leftTop.Y + BLOCKHEIGHT;
      rightBottom.Y = rightBottom.Y + BLOCKHEIGHT;
    }
    else
    {
      leftTop.X = leftTop.X + BLOCKWIDTH;
      rightBottom.X = rightBottom.X + BLOCKWIDTH;
    }
    
    //store the values in the blocks array
    blocks.srBlockRect.Left = leftTop.X;
    blocks.srBlockRect.Top = leftTop.Y;
    blocks.srBlockRect.Right = rightBottom.X;
    blocks.srBlockRect.Bottom = rightBottom.Y;
    
  //set collide status
  blocks.bCanCollide = TRUE; 
  }
}

//function to draw the blocks to the screen
void drawBlocks(HANDLE hOut, block *blocks, int iNumOfBlocks)
{
  CHAR_INFO ciBlockSprite[BLOCKWIDTH * BLOCKHEIGHT];//memory to hold the 'sprite'
  COORD gridSize = {BLOCKWIDTH , BLOCKHEIGHT};
  COORD zeroZero = {0, 0};					
  int iColour;
  int i, x, y;//looping variables

  //fill in the CHAR_INFO structure that makes up a block
  for(i = 0; i < iNumOfBlocks; i++)
  {
    iColour = rand() % 7;//select a random colour for each block
    while(iColour == 0)
      iColour = rand() % 7;//select a random colour for each block
    for(y = 0; y < gridSize.Y; y++)						
    {
      for(x = 0; x < gridSize.X; x++)				
      {												
        ciBlockSprite[x + y * BLOCKWIDTH].Char.AsciiChar = '*';
        ciBlockSprite[x + y * BLOCKWIDTH].Attributes = iColour;
      }
    }
  //draw the block to the screen
  WriteConsoleOutput(hOut, ciBlockSprite, gridSize, zeroZero, &blocks.srBlockRect);
  }
}

//function to check for collision
bool collision(SMALL_RECT srRectangle1, SMALL_RECT srRectangle2)
{
  if((srRectangle1.Top == (srRectangle2.Bottom + 1)
    || srRectangle1.Bottom == (srRectangle2.Top - 1))
    && srRectangle1.Right >= srRectangle2.Left 
    && srRectangle1.Left <= srRectangle2.Right)
  {
    return TRUE;
  }
  else
  {
    return FALSE;
  } 
}

//creates the bat
void initializeBat(bat *bat)
{
  int x, y;//looping variables
  
  bat->gridSize.X = BATWIDTH;
  bat->gridSize.Y = BATHEIGHT;
  
  bat->zeroZero.X = 0;
  bat->zeroZero.Y = 0;
  
  bat->start.X = 20;
  bat->start.Y = 17;
  
  bat->old.X = bat->start.X;
  bat->old.Y = bat->start.Y;
  	
  //create a small rectangle containing '*' characters
  for(y = 0; y < bat->gridSize.Y; y++)						
  {
    for(x = 0; x < bat->gridSize.X; x++)				
    {												
      bat->ciBatSprite[x + y * BATWIDTH].Char.AsciiChar = '*';
      bat->ciBatSprite[x + y * BATWIDTH].Attributes = FOREGROUND_RED;
    }
  }
  
  //create a small rectangle containing ' ' characters
  for(y = 0; y < bat->gridSize.Y; y++)						
  {
    for(x = 0; x < bat->gridSize.X; x++)				
    {												
      bat->ciBlankBatSprite[x + y * BATWIDTH].Char.AsciiChar = ' ';
      bat->ciBlankBatSprite[x + y * BATWIDTH].Attributes = FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_RED;
    }
  }
  
  bat->iBatSpeed = BATSPEED;
  
  //define the rectangle to draw to the screen
  bat->srBatRect.Left = bat->start.X;
  bat->srBatRect.Top = bat->start.Y;
  bat->srBatRect.Right = bat->start.X + BATWIDTH;
  bat->srBatRect.Bottom = bat->start.Y + BATHEIGHT;
  
  //define the rectangle to draw the 'blank sprite' to the screen  
  bat->srBlankBatRect.Left = bat->start.X;
  bat->srBlankBatRect.Top = bat->start.Y;
  bat->srBlankBatRect.Right = bat->start.X + BATWIDTH;
  bat->srBlankBatRect.Bottom = bat->start.Y + BATHEIGHT;
}

//function to move the bat
void moveBat(HANDLE hOut, HANDLE hIn, bat *bat)
{
  char userchoice;//holds the key user has pressed
  
  //draw the 'sprite over new position
  WriteConsoleOutput(hOut, bat->ciBatSprite, bat->gridSize, bat->zeroZero, &bat->srBatRect);
                    
  if(kbhit())
  {
    userchoice = getch();
    switch(userchoice)
    {
      case 'a': if(bat->srBatRect.Left == 0)
                {
                  bat->srBatRect.Left = bat->old.X;
                  bat->srBatRect.Top = bat->old.Y;
                  bat->srBatRect.Right = bat->old.X + BATWIDTH;
                  bat->srBatRect.Bottom = bat->old.Y + BATHEIGHT;
                  
                  bat->start.X = 2;
                }
                else
                {
                  bat->srBatRect.Left = bat->start.X;
                  bat->srBatRect.Top = bat->start.Y;
                  bat->srBatRect.Right = bat->start.X + BATWIDTH;
                  bat->srBatRect.Bottom = bat->start.Y + BATHEIGHT;
    
                  bat->srBlankBatRect.Left = bat->old.X;
                  bat->srBlankBatRect.Top = bat->old.Y;
                  bat->srBlankBatRect.Right = bat->old.X + BATWIDTH;
                  bat->srBlankBatRect.Bottom = bat->old.Y + BATHEIGHT;
                  
                  bat->old.X = bat->start.X;
                  bat->start.X = bat->start.X - BATSPEED;
                }
                break;
                  
      case 'd': if(bat->srBatRect.Right == SCREENWIDTH - 1)
                {
                  bat->srBatRect.Left = bat->old.X;
                  bat->srBatRect.Top = bat->old.Y;
                  bat->srBatRect.Right = bat->old.X + BATWIDTH;
                  bat->srBatRect.Bottom = bat->old.Y + BATHEIGHT;
                  
                  bat->start.X = 40;
                }
                else
                {
                  bat->srBatRect.Left = bat->start.X;
                  bat->srBatRect.Top = bat->start.Y;
                  bat->srBatRect.Right = bat->start.X + BATWIDTH;
                  bat->srBatRect.Bottom = bat->start.Y + BATHEIGHT;
    
                  bat->srBlankBatRect.Left = bat->old.X;
                  bat->srBlankBatRect.Top = bat->old.Y;
                  bat->srBlankBatRect.Right = bat->old.X + BATWIDTH;
                  bat->srBlankBatRect.Bottom = bat->old.Y + BATHEIGHT;
                  
                  bat->old.X = bat->start.X;
                  bat->start.X = bat->start.X + BATSPEED;
                }
                break;
                       
        default: printf("Please select a or d\n");
    }
      
    //draw the 'blank sprite over old position
    WriteConsoleOutput(hOut, bat->ciBlankBatSprite, bat->gridSize, bat->zeroZero, &bat->srBlankBatRect);
    //draw the 'sprite over new position
    WriteConsoleOutput(hOut, bat->ciBatSprite, bat->gridSize, bat->zeroZero, &bat->srBatRect);   
  }
}

//if the player loses a life this function sets the ball back to its original position
void restartGame(HANDLE hOut, ball *ball, bat *bat)
{
  //draw over the old ball with the blank sprite
  WriteConsoleOutput(hOut, ball->ciBlankBallSprite, ball->gridSize, ball->zeroZero, &ball->srBlankBallRect); 
  
  ball->start.X = 10;
  ball->start.Y = 10;
  
  ball->old.X = ball->start.X;
  ball->old.Y = ball->start.Y;
  
  ball->iDirectionX = 1;
  ball->iDirectionY = 1;
  
  sleep(800);//pause the game for a brief period
}




[\source]