C and C++ Programming Resources

Custom Search

Brick Game

This is the complete source code of the most favourite flash game ‘Web Breaker’. The source code is written completely in C/C++ programming language. The game runs in DOS graphics mode. You can use either Turbo C++ compiler or Dev C++ compiler to compile and run this code.

/*******************************************************
*     MYCPLUS Sample Code - http://www.mycplus.com
*   This code is made available as a service to our
*      visitors and is provided strictly for the
*               purpose of illustration.
*
* Please direct all inquiries to saqib at mycplus.com *
*******************************************************/

# include "process.h"
# include "dos.h"
# include "stdlib.h"
# include "graphics.h"
# include "stdio.h"

# define NULL 0
# define YES 1
# define NO 0

int maxx, maxy, midx, midy ;
int bri[5][20] ;

main()
{
	union REGS ii, oo ;
	int ballx, bally, paddlex, paddley, dx = 1, dy = -1, oldx, oldy ;
	int gm = CGAHI, gd = CGA, playerlevel ;
	int i, flag = 0, speed = 25, welldone = NO, score = 0, chance = 4, area ;
	int layer[5] = { 10, 20, 30, 40, 50 }, limit = 50, currentlayer = 4 ;
	char *p1, *p2 ;

	/* initialise the graphics system */
	initgraph ( &gd, &gm, "D:\\TC\\BGI" ) ;

	/* get the maximum x and y screen coordinates */
	maxx = getmaxx() ;
	maxy = getmaxy() ;

	/* calculate center of screen */
	midx = maxx / 2 ;
	midy = maxy / 2 ;

	/* display opening screen and receive player's level */
	playerlevel = mainscreen() ;

	/* set speed of ball as per the level chosen */
	switch ( playerlevel )
	{
		case 'A' :
		case 'a' :
			speed = 15 ;
			break ;

		case 'E' :
		case 'e' :
			speed = 10 ;
	}

	/* draw the bricks, the paddle and the ball */
	rectangle ( 0, 0, maxx, maxy - 12 ) ;
	bricks() ;
	rectangle ( midx - 25, maxy - 7 - 12, midx + 25, maxy - 12 ) ;
	floodfill ( midx, maxy - 1 - 12, 1 ) ;
	circle ( midx, maxy - 13 - 12, 12 ) ;
	floodfill ( midx, maxy - 10 - 12, 1 ) ;

	/* allocate memory for storing the image of the paddle */
	area = imagesize ( midx - 12, maxy - 18, midx + 12, maxy - 8 ) ;
	p1 = malloc ( area ) ;

	/* allocate memory for storing the image of the ball */
	area = imagesize ( midx - 25, maxy - 7, midx + 25, maxy - 1 ) ;
	p2 = malloc ( area ) ;

	/* if memory allocation unsuccessful */
	if ( p1 == NULL || p2 == NULL )
	{
		puts ( "Insufficient memory!!" ) ;
		exit ( 1 ) ;
	}

	/* store the image of the paddle and the ball into allocated memory */
	getimage ( midx - 12, maxy - 7 - 12 - 12 + 1, midx + 12, maxy - 8 - 12, p1 ) ;
	getimage ( midx - 25, maxy - 7 - 12, midx + 25, maxy - 1 - 12, p2 ) ;

	/* store current position of the paddle and ball */
	paddlex = midx - 25 ;
	paddley = maxy - 7 - 12 ;
	ballx = midx - 12 ;
	bally = maxy - 7 - 12 + 1 - 12 ;

	/* display balls in hand ( initially 3 ) */
	gotoxy ( 45, 25 ) ;
	printf ( "Balls Remaining:" ) ;
	for ( i = 0 ; i < 3 ; i++ )
	{
		circle ( 515 + i * 35, maxy - 5, 12 ) ;
		floodfill ( 515 + i * 35, maxy - 5, 1 ) ;
	}

	/* display initial score */
	gotoxy ( 1, 25 ) ;
	printf ( "Your Score:   %4d", score ) ;

	/* select font and alignment for displaying text */
	settextjustify ( CENTER_TEXT, CENTER_TEXT ) ;
	settextstyle ( SANS_SERIF_FONT, HORIZ_DIR, 4 ) ;

	while ( 1 )
	{
		flag = 0 ;

		/* save the current x and y coordinates of the ball */
		oldx = ballx ;
		oldy = bally ;

		/* update ballx and bally to move the ball in appropriate direction */
		ballx = ballx + dx ;
		bally = bally + dy ;

		/* as per the position of ball determine the layer of bricks to check */
		if ( bally > 40 )
		{
			limit = 50 ;
			currentlayer = 4 ;
		}
		else
		{
			if ( bally > 30 )
			{
				limit = 40 ;
				currentlayer = 3 ;
			}
			else
			{
				if ( bally > 20 )
				{
					limit = 30 ;
					currentlayer = 2 ;
				}
				else
				{
					if ( bally > 10 )
					{
						limit = 20 ;
						currentlayer = 1 ;
					}
					else
					{
						limit = 10 ;
						currentlayer = 0 ;
					}
				}
			}
		}

		/* if the ball hits the left boundary, deflect it to the right */
		if ( ballx < 1 )
		{
			music ( 5 ) ;
			ballx = 1 ;
			dx = -dx ;
		}

		/* if the ball hits the right boundary, deflect it to the left */
		if ( ballx > ( maxx - 24 - 1 ) )
		{
			music ( 5 ) ;
			ballx = maxx - 24 - 1 ;
			dx = -dx ;
		}

		/* if the ball hits the top boundary, deflect it down */
		if ( bally < 1 )
		{
			music ( 5 ) ;
			bally = 1 ;
			dy = -dy ;
		}

		/* if the ball is in the area occupied by the bricks */
		if ( bally < limit )
		{
			/* if there is no brick present exactly at the top of the ball */
			if ( bri[currentlayer][ ( ballx + 10 ) / 32 ] == 1 )
			{
				/* determine if the boundary of the ball touches a brick */
				for ( i = 1 ; i <= 6 ; i++ )
				{
					/* check whether there is a brick to the right of the ball */
					if ( bri[currentlayer][ ( ballx + i + 10 ) / 32 ] == 0 )
					{
						/* if there is a brick */
						ballx = ballx + i ;
						flag = 1 ;
						break ;
					}

					/* check whether there is a brick to the left of the ball */
					if ( bri[currentlayer][ ( ballx - i + 10 ) / 32 ] == 0 )
					{
						ballx = ballx - i ;
						flag = 1 ;
						break ;
					}
				}

				/* if the ball does not touch a brick at the top, left or right */
				if ( !flag )
				{
					/* check if the ball has moved above the current layer */
					if ( bally < layer[currentlayer - 1] )
					{
						/* if so, change current layer appropriately */
						currentlayer-- ;
						limit = layer[currentlayer] ;
					}

					/* put the image of the ball at the old coordinates */
					putimage ( oldx, oldy, p1, OR_PUT ) ;

					/* erase the image at the old coordinates */
					putimage ( oldx, oldy, p1, XOR_PUT ) ;

					/* place the image of the ball at the new coordinates */
					putimage ( ballx, bally, p1, XOR_PUT ) ;

					/* introduce delay */
					delay ( speed ) ;

					/* carry on with moving the ball */
					continue ;
				}
			}

			/* control comes to this point only if the ball is touching a brick */
			music ( 4 ) ;  /* play music */

			/* erase the brick hit by the ball */
			erasebrick ( ( ballx + 10 ) / 32, currentlayer ) ;

			/* if the brick hit happens to be on the extreme right */
			if ( ( ballx + 10 ) / 32 == 19 )
				line ( maxx, 0, maxx, 50 ) ;  /* redraw right boundary */

			/* if the brick hit happens to be on the extreme left */
			if ( ( ballx + 10 ) / 32 == 0 )
				line ( 0, 0, 0, 50 ) ;  /* redraw left boundary */

			/* if the brick hit happens to be in the topmost layer */
			if ( currentlayer == 0 )
				line ( 0, 0, maxx, 0 ) ;  /* redraw top boundary */

			/* set appropriate array element to 1 to indicate absence of brick */
			bri[currentlayer][ ( ballx + 10 ) / 32 ] = 1 ;

			bally = bally + 1 ;  /* update the y coordinate */
			dy = -dy ;  /* change the direction of the ball */
			score += 5 ;  /* increment score */
			gotoxy ( 16, 25 ) ;
			printf ( "%4d", score ) ;  /* print latest score */

			/* if the first brick is hit during a throw */
			if ( welldone == NO )
				welldone = YES ;
			else
			{
				/* for the consecutive bricks hit during the same throw */
				outtextxy ( midx, midy, "Well done!" ) ;
				music ( 1 ) ;
			}
		}

		/* clear part of the screen used for displaying Well done message */
		if ( bally > 50 && welldone == YES )
		{
			setviewport ( midx - 32 * 2.5, midy - 32 / 2, midx + 32 * 2.5, midy + 32 / 2, 1 ) ;
			clearviewport() ;
			setviewport ( 0, 0, maxx, maxy, 1 ) ;
			welldone = NO ;
		}

		/* if the ball has reached the bottom */
		if ( bally > 180 - 12 )
		{
			welldone = NO ;

			/* if the paddle has missed the ball */
			if ( ballx < paddlex - 20 || ballx > paddlex + 50 )
			{
				/* continue the descent of the ball */
				while ( bally < 177 )
				{
					/* erase the image of the ball at the old coordinates */
					putimage ( oldx, oldy, p1, XOR_PUT ) ;

					/* put the image of the ball at the updated coordinates */
					putimage ( ballx, bally, p1, XOR_PUT ) ;

					/* introduce delay */
					delay ( speed ) ;

					/* save the current x and y coordinates of the ball */
					oldx = ballx ;
					oldy = bally ;

					/* update ballx and bally to move the ball in appropriate direction */
					ballx = ballx + dx ;
					bally = bally + dy ;
				}

				chance-- ;  /* decrement the number of chances */
				score -= 20 ;  /* decrement 20 points for each ball lost */
				gotoxy ( 16, 25 ) ;
				printf ( "%4d", score ) ;  /* print latest score */
				music ( 2 ) ;

				/* erase one out of the available balls */
				if ( chance )
					putimage ( 515 + ( chance - 1 ) * 35 - 12 , maxy - 10, p1, XOR_PUT ) ;

				/* if the last ball is being played */
				if ( chance == 1 )
				{
					gotoxy ( 45, 25 ) ;
					printf ( "Your last ball... Be careful!" ) ;
				}

				/* if all the balls are lost */
				if ( !chance )
				{
					gotoxy ( 45, 25 ) ;
					printf ( "Press any key...              " ) ;
					outtextxy ( midx, midy, "I warned you! Try again" ) ;
					music ( 3 ) ;

					closegraph() ;
					restorecrtmode() ;
					exit ( 0 ) ;
				}
			}

			/* if ball is collected on paddle */
			music ( 5 ) ;
			bally = 180 - 12 ;  /* restore the y coordinate of ball */
			dy = -dy ;  /* deflect the ball upwards */
		}

		/* put the image of the ball at the old coordinates */
		putimage ( oldx, oldy, p1, OR_PUT ) ;

		/* erase the image of the ball at the old coordinates */
		putimage ( oldx, oldy, p1, XOR_PUT ) ;

		/* put the image of the ball at the upadted coordinates */
		putimage ( ballx, bally, p1, XOR_PUT ) ;

		/* if all the bricks have been destroyed */
		if ( score == 500 - ( ( 4 - chance ) * 20 ) )
		{
			outtextxy ( midx, midy, "You win !!!" ) ;

			if ( score < 500 )
				outtextxy ( midx, midy + 30, "Try scoring 500" ) ;
			else
				outtextxy ( midx, midy + 30, "You are simply GREAT!" ) ;

			music ( 3 ) ;

			closegraph() ;
			restorecrtmode() ;
			exit ( 0 ) ;
		}

		/* introduce delay */
		delay ( speed ) ;

		/* if the user has pressed a key to move the paddle */
		if ( kbhit() )
		{
			/* issue interrupt to obtain the ascii and scan codes of key hit */
			ii.h.ah = 0 ;
			int86 ( 22, &ii, &oo ) ;

			/* put the image of the paddle at the old coordinates */
			putimage ( paddlex, paddley, p2, OR_PUT ) ;

			/* erase the image of the paddle at the old coordinates */
			putimage ( paddlex, paddley, p2, XOR_PUT ) ;

			/* if Esc key has been pressed */
			if ( oo.h.ah == 1 )
				exit ( 0 ) ;

			/* right arrow key */
			if ( oo.h.ah == 75 )
				paddlex = paddlex - 20 ;

			/* left arrow key */
			if ( oo.h.ah == 77 )
				paddlex = paddlex + 20 ;

			/* if paddle goes beyond left boundary */
			if ( paddlex < 0 )
				paddlex = 0 ;

			/* if paddle goes beyond right boundary */
			if ( paddlex > 589 )
				paddlex = 589 ;

			/* put the image of the paddle at the proper position */
			putimage ( paddlex, paddley, p2, XOR_PUT ) ;
		}
	}
}

/* creates opening screen */
mainscreen()
{
	/* array showing the positions where a brick is needed to form the figure BRICKS */
	int ff[12][40] = {
	1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,1,0,0,0,1,1,1,0,0,1,0,0,0,0,1,0,0,0,1,1,1,0,
	1,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,1,0,0,0,1,
	1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,
	1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,
	1,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,1,0,0,0,0,0,
	1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,1,0,0,
	1,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,
	1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,
	1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,
	1,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,1,0,0,0,0,1,
	1,1,1,1,0,0,0,1,0,0,0,0,1,0,1,1,1,1,1,0,0,0,1,1,1,0,0,1,0,0,0,0,1,0,0,1,1,1,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,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	} ;
	int i, j, lx = 0, ly = 0, ch ;

	/* draw boundary */
	rectangle ( 0, 0, maxx, maxy ) ;

	/* form the word BRICKS */
	for ( i = 0 ; i < 12 ; i++ )
	{
		for ( j = 0 ; j < 40 ; j++ )
		{
			if ( ff[i][j] )
				rectangle ( lx, ly, lx + 15, ly + 9 ) ;
			lx = lx + 16 ;
		}
		lx = 0 ;
		ly = ly + 10 ;
	}

	/* draw pattern at the bottom of the screen */
	line ( 0, maxy - 12, maxx, maxy - 12 ) ;
	setfillstyle ( XHATCH_FILL, WHITE ) ;
	floodfill ( 2, maxy - 2, WHITE ) ;

	/* draw the paddle and the ball */
	setfillstyle ( SOLID_FILL, WHITE ) ;
	rectangle ( midx - 25, maxy - 7 - 12, midx + 25, maxy - 12 ) ;
	floodfill ( midx, maxy - 1 - 12, 1 ) ;
	circle ( midx, maxy - 13 - 12, 12 ) ;
	floodfill ( midx, maxy - 10 - 12, 1 ) ;

	music ( 3 ) ;  /* play music */

	/* display menu */
	while ( 1 )
	{
		/* clear the region below the word BRICKS */
		setviewport ( 1, 125 - 12, maxx - 1, maxy - 1, 1 ) ;
		clearviewport() ;

		setviewport ( 0, 0, maxx, maxy, 1 ) ;
		outtextxy ( 20, 135, "Select any of the following:" ) ;
		outtextxy ( 20, 155, "Play ( P )" ) ;
		outtextxy ( 20, 165, "Instructions ( I )" ) ;
		outtextxy ( 20, 175, "Exit ( E )" ) ;

		ch = 0 ;

		/* continue till the correct choice is made */
		while ( ! ( ch == 'E' || ch == 'I' || ch == 'P' ) )
		{
			fflush ( stdin ) ;

			/* if a special key is hit, flush the keyboard buffer */
			if ( ( ch = getch() ) == 0 )
				getch() ;
			else
				ch = toupper ( ch ) ;
		}

		if ( ch == 'P' )
			break ;

		switch ( ch )
		{
			case 'I' :
				setviewport ( 1, 125 - 12, maxx - 1, maxy - 1, 1 ) ;
				clearviewport() ;

				setviewport ( 0, 0, maxx, maxy, 1 ) ;
				settextstyle ( DEFAULT_FONT, HORIZ_DIR, 1 ) ;
				outtextxy ( 20, 125, "         Instructions        " ) ;
				settextstyle ( DEFAULT_FONT, HORIZ_DIR, 0 ) ;
				outtextxy ( 20, 140, "Use left and right arrow keys to move paddle." ) ;
				outtextxy ( 20, 150, "If you don't collect the ball on the paddle, you lose the ball." ) ;
				outtextxy ( 20, 160, "On loosing a ball you loose 20 points." ) ;
				outtextxy ( 20, 170, "On taking a brick you gain 5 points." ) ;
				outtextxy ( 20, 185, "Press any key..." ) ;
				fflush ( stdin ) ;
				if ( getch() == 0 )
					getch() ;
				break ;

			case 'E' :
				closegraph() ;
				restorecrtmode() ;
				exit ( 0 ) ;
		}
	}

	setviewport ( 1, 125 - 12, maxx - 1, maxy - 1, 1 ) ;
	clearviewport() ;

	/* prompt the user for the level desired */
	setviewport ( 0, 0, maxx, maxy, 1 ) ;
	outtextxy ( 20, 135, "Select any of the following levels:" ) ;
	outtextxy ( 20, 155, "Novice ( N )" ) ;
	outtextxy ( 20, 165, "Advanced ( A )" ) ;
	outtextxy ( 20, 175, "Expert ( E )" ) ;

	/* get user's choice */
	fflush ( stdin ) ;
	if ( ( ch = getch() ) == 0 )
		getch() ;

	clearviewport() ;

	/* return the choice made by the user */
	return ( ch ) ;
}

/* draws bricks at the start of the game */
bricks()
{
	int i, j, lx = 0, ly = 0 ;

	for ( i = 0 ; i < 5 ; i++ )  /* 5 rows */
	{
		for ( j = 0 ; j < 20 ; j++ )  /* 20 columns */
		{
			/* draw a brick at appropriate coordinates */
			drawbrick ( lx, ly ) ;

			lx = lx + 32 ;
		}

		lx = 0 ;
		ly = ly + 10 ;
	}
}

/* draws a brick at the proper position */
drawbrick ( int lx, int ly )
{
	rectangle ( lx, ly, lx + 31, ly + 9 ) ;
	rectangle ( lx + 2, ly - 2, lx + 31 - 2, ly + 9 - 2 ) ;
	floodfill ( lx + 1, ly + 1, 2 ) ;
}

/* erases the specified brick */
erasebrick ( int b, int l )
{
	/* b - brick number, l - layer */

	setcolor ( BLACK ) ;
	rectangle ( b * 32, l * 10, ( b * 32 ) + 31 , ( l * 10 ) + 9 ) ;
	rectangle ( b * 32 + 1, l * 10, ( b * 32 ) + 31 - 1, ( l * 10 ) + 9 - 1 ) ;
	rectangle ( b * 32 + 2, l * 10, ( b * 32 ) + 31 - 2, ( l * 10 ) + 9 - 2 ) ;
	setcolor ( WHITE ) ;
}

/* plays different types of music */
music ( int type )
{
	/* natural frequencies of 7 notes */
	float octave[7] = { 130.81, 146.83, 164.81, 174.61, 196, 220, 246.94 } ;
	int n, i ;

	switch ( type )
	{
		case 1 :
			for ( i = 0 ; i < 7 ; i++ )
			{
				sound ( octave[i] * 8 ) ;
				delay ( 30 ) ;
			}
			nosound() ;
			break ;

		case 2 :
			for ( i = 0 ; i < 15 ; i++ )
			{
				n = random ( 7 ) ;
				sound ( octave[n] * 4 ) ;
				delay ( 100 ) ;
			}
			nosound() ;
			break ;

		case 3 :
			while ( !kbhit() )
			{
				n = random ( 7 ) ;
				sound ( octave[n] * 4 ) ;
				delay ( 100 ) ;
			}
			nosound() ;

			/* flush the keyboard buffer */
			if ( getch() == 0 )
				getch() ;

			break ;

		case 4 :
			for ( i = 4 ; i >= 0 ; i-- )
			{
				sound ( octave[i] * 4 ) ;
				delay ( 15 ) ;
			}
			nosound() ;
			break ;

		case 5 :
			sound ( octave[6] * 2 ) ;
			delay ( 50 ) ;
			nosound() ;
	}
}

Tags: , ,

There are 5 Comments to this post. You can follow any responses to this entry through the RSS 2.0 feed. You can skip to the end and leave a response or TrackBack from your own site.


Leave a Reply

You must be logged in to post a comment.