bool check(struct shape temp, int i, int a, int b, int p)
{
	int temp1[100][100];
	int m, n;
	switch(p)
	{
	case 1:
		for(m=0;m<100;m++)
		{
			for(n=0;n<100;n++)
			{
				temp1[n][m] = player1.play[n][m];
			}
		}
		break;
		
	case 2:
		for(m=0;m<100;m++)
		{
			for(n=0;n<100;n++)
			{
				temp1[n][m] = player2.play[n][m];
			}
		}
		break;
	default:
		for(m=0;m<100;m++)
		{
			for(n=0;n<100;n++)
			{
				temp1[n][m] = player1.play[n][m];
			}
		}
		break;
	}

	for(int y=0;y<4;y++)
	{
		for(int x=0;x<4;x++)
		{
			if(temp1[x+a][y+b-1] > 0 && temp.rotation[i][y][x]>0 || ((y+b-1==height)&&(temp.rotation[i][y][x]==1)))
			{
				return false;
			}
		}
	}
	return true;
}

void box(int x1, int y1, int x2, int y2, int c, int fill, int type)
{
	char c1, c2, c3, c4, h, v;
	char shadow = shadow_char;
	

	switch(type)
	{
	case 1:
		c1 = char(218);
		c2 = char(191);
		c3 = char(192);
		c4 = char(217);
		h = char(196);
		v = char(179);
		break;
	case 2:
		c1 = char(201);
		c2 = char(187);
		c3 = char(200);
		c4 = char(188);
		h = char(205);
		v = char(186);
		break;
	default:
		c1 = char(218);
		c2 = char(191);
		c3 = char(192);
		c4 = char(217);
		h = char(196);
		v = char(179);
		break;
	}

	put(c1, x1, y1, c);
	put(c2, x2, y1, c);
	put(c3, x1, y2, c);
	put(c4, x2, y2, c);

	for(int i=x1+1;i<x2;i++)
	{
		put(h, i, y1, c);
		put(h, i, y2, c);
	}
	for(i=y1+1;i<y2;i++)
	{
		put(v, x1, i, c);
		put(v, x2, i, c);
	}

	if(type>0)
	{
		for(i=x1+1;i<x2+2;i++)
		{
			put(shadow, i, y2+1, shadow_col);
		}
		for(i=y1+1;i<y2+2;i++)
		{
			put(shadow, x2+1, i, shadow_col);
		}
	}
	if(fill>0)
	{
		for(int y=y1+1;y<y2;y++)
		{
			for(int x=x1+1;x<x2;x++)
			{
				put(fill, x, y, play_colour);
			}
		}
	}
}

void text_box(char text[], int x1, int y1, int x2, int y2, int c, int c1, int fill, int type) 
{
	int length=0;
	while(text[length] != 0){length++;}
	box(x1, y1, x2, y2, c1, fill, type);
	print(text, ((x2-x1)/2)-(length/2)+x1,y1+(y2-y1)/2, c);
	

}

void init_game()
{
	screensize();
	for(int b=-1;b<100;b++)
	{
		for(int a=-1;a<100;a++)
		{
		player1.play[a][b]=0;
		player2.play[a][b]=0;
		}
	}

	load_font("font.dat");
	srand(time(0));
	setup.speed = 1;
	setup.players = 1;
	setup.size = 1;
	setup.width = width;
	setup.player1.rotate = 72;
	setup.player1.drop = 80;
	setup.player1.left = 75;
	setup.player1.right = 77;

	setup.player2.rotate = 'w';
	setup.player2.drop = 's';
	setup.player2.left = 'a';
	setup.player2.right = 'd';

}


void reset_play()
{
	for(int y1=0;y1<100;y1++)
	{

		for(int x1=0;x1<100;x1++)
		{
			player1.play[x1][y1]=0;
			player2.play[x1][y1]=0;
		}
	}
}
int line()
{
	return 0;
}

bool to_play(struct shape blocks, int rot, int col, int oldx, int oldy, int p)
{
	int temp1[100][100];
	int m, n;

	switch(p)
	{
	case 1:
		for(m=0;m<100;m++)
		{
			for(n=0;n<100;n++)
			{
				temp1[n][m] = player1.play[n][m];
			}
		}
		break;
	case 2:
		for(m=0;m<100;m++)
		{
			for(n=0;n<100;n++)
			{
				temp1[n][m] = player2.play[n][m];
			}
		}
		break;
	default:
		for(m=0;m<100;m++)
		{
			for(n=0;n<100;n++)
			{
				temp1[n][m] = player1.play[n][m];
			}
		}
		break;
	}
	
	for(int b=0;b<4;b++)
	{
		for(int a=0;a<4;a++)
		{
			if(blocks.rotation[rot][b][a]==1)
			{
				temp1[oldx+a][oldy+b-2] = col;
			}
		}
	}

	switch(p)
	{
	case 1:
		for(m=0;m<100;m++)
		{
			for(n=0;n<100;n++)
			{
				player1.play[n][m]=temp1[n][m];
			}
		}
		break;
	case 2:
		for(m=0;m<100;m++)
		{
			for(n=0;n<100;n++)
			{
				player2.play[n][m]=temp1[n][m];
			}
		}
		break;
	default:
		for(m=0;m<100;m++)
		{
			for(n=0;n<100;n++)
			{
				player1.play[n][m]=temp1[n][m];
			}
		}
		break;
	}
	
	for(int z=0;z<width;z++)
	{
		if(temp1[z][0]>0)
		{
			return true;
		}
	}

	return false;
}

int check_line(int p)
{
	int temp1[100][100];
	int m, n;

	switch(p)
	{
	case 1:
		for(m=0;m<100;m++)
		{
			for(n=0;n<100;n++)
			{
				temp1[n][m] = player1.play[n][m+1];
			}
		}
		break;
	case 2:
		for(m=0;m<100;m++)
		{
			for(n=0;n<100;n++)
			{
				temp1[n][m] = player2.play[n][m];
			}
		}
		break;
	default:
		for(m=0;m<100;m++)
		{
			for(n=0;n<100;n++)
			{
				temp1[n][m] = player1.play[n][m];
			}
		}
		break;
	}
	int lines=0;
	bool line = true;
	int x=0, y=0, a=0, b=0;

	for(y=0;y<height+3;y++)
	{
		line = true;
		for(x=0;x<width+3;x++)
		{
			if(temp1[x][y]<1)
				line = false;
		}
		if(line)
		{
			lines++;
			for(b=y;b>-1;b--)
			{
				for(a=0;a<width+3;a++)
				{
					temp1[a][b] = temp1[a][b-1];
				}
			}
		}
	}
	switch(p)
	{
	case 1:
		for(m=0;m<100;m++)
		{
			for(n=0;n<100;n++)
			{
				player1.play[n][m]=temp1[n][m-1];
			}
		}
		break;
	case 2:
		for(m=0;m<100;m++)
		{
			for(n=0;n<100;n++)
			{
				player2.play[n][m]=temp1[n][m];
			}
		}
		break;
	default:
		for(m=0;m<100;m++)
		{
			for(n=0;n<100;n++)
			{
				player1.play[n][m]=temp1[n][m];
			}
		}
		break;
	}
	return lines;
}

bool collision(struct shape one, int x1, int y1, int rot1, struct shape two, int x2, int y2, int rot2)
{
	for(int b=0;b<4;b++)
	{
		for(int a=0;a<4;a++)
		{
			if(one.rotation[rot1][a+x1][b+y1] == 1 && two.rotation[rot2][a+x2][b+y2])
			{
				locate(0, 0, 3, 10);
				cout<<a+x1<<" "<<b+y2<<" "<<a+x2<<" "<<b+y2<<endl;
				return true;
			}
		}
	}
	return false;
}

void game(int players)
{

	struct shape p1[no_blocks];
	struct shape p2[no_blocks];

	bool game_over = false;
	bool p1_block_down = false;
	bool p2_block_down = false;

	double speed = setup.speed;
	
	double p1_time1=0;
	double p1_time2=0;

	double p2_time1=0;
	double p2_time2=0;
	
	double p1_difference=0.000001;
	double p2_difference=0.000001;

	int p1_x = width/2;
	int p2_x = width/2;

	int limit=1000;
	
	int p1_y=0;
	int p2_y=0;
	
	int p1_block = rand()%no_blocks;
	int p2_block = rand()%no_blocks;

	int p1_next = rand()%no_blocks;
	int p2_next = rand()%no_blocks;

	int p1_rot = rand()%4;
	int p2_rot = rand()%4;

	int p1_nextrot = rand()%4;
	int p2_nextrot = rand()%4;

	int a=0, b=0;
	
	int p1_col = 1+rand()%15;
	int p2_col = 1+rand()%15;

	int p1_lines=0;
	int p2_lines=0;
	
	int p1_blockstart=0;
	int p1_blockstop=0;
	int p2_blockstart=0;
	int p2_blockstop=0;
	
	for(int i=0;i<no_blocks;i++)
	{
		p1[i] = p2[i] = init_blocks().matrix[i];
	}
	
	
	reset_play();

	
	if(players>2)
		width = 17;
	else
		width = setup.width;
	
	if(players==1)
		draw_screen(0);
	else
		if(players==3)
			draw_screen(3);
		else
			draw_screen(2);



	if(players==2)
	{
		draw_play(1);
		draw_play(2);
	}
	else
	{
		if(players==3)
		{
			draw_play(3);	
		}
		else
			draw_play(0);
	}
	
	
		
	speed = 1-((speed)/10);
	
	bool p1_ok=false;
	if(players>1)
		bool p2_ok=false;

	p1_block_down=false;
	if(players>1)
		p2_block_down=false;

	do
	{
		if(players>1&&players<3)
		{
			draw(p2[p2_next], p2_nextrot+4, -8, 2, p2[p2_next].colour, 2);
			draw(p1[p1_next], p1_nextrot+4, -8, 2, p1[p1_next].colour, 1);
		}
		
		if(players>2)
		{
			draw(p2[p2_next], p2_nextrot+4, width+21, 2, p2[p2_next].colour, 1);
			draw(p1[p1_next], p1_nextrot+4, 6, 2, p1[p1_next].colour, 1);
		}
		if(players==1)
			draw(p1[p1_next], p1_nextrot+4, 4, 2, p1[p1_next].colour, 1);

		if(p1_block_down)
		{
			p1_block_down = false;
			p1_y=0;
			p1_block = p1_next;
			p1_next = rand()%no_blocks;
			p1_rot = p1_nextrot;
			p1_nextrot = rand()%4;
			if(players>2)
				p1_x=(width/3);
			else
				p1_x=(width/2);
		}
		if(players>1)
		{
			if(p2_block_down)
		{
			p2_block_down = false;
			p2_y=0;
			p2_block = p2_next;
			p2_next = rand()%no_blocks;
			p2_rot = p2_nextrot;
			p2_nextrot = rand()%4;
			if(players>2)
				p2_x=((2*width)/3);
			else
				p2_x=(width/2);
		}

		}

		a=0, b=0;
		
		
		p1_col = p1[p1_block].colour;
		if(players>1)
			p2_col = p2[p2_block].colour;
		
		
		
		if(players>1&&players<3)
		{
			draw(p2[p2_next], p2_nextrot, -8, 2, p2[p2_next].colour, 2);
			draw(p1[p1_next], p1_nextrot, -8, 2, p1[p1_next].colour, 1);
		}
		if(players>2)
		{
			draw(p2[p2_next], p2_nextrot, width+21, 2, p2[p2_next].colour, 1);
			draw(p1[p1_next], p1_nextrot, 6, 2, p1[p1_next].colour, 1);
		}
		if(players==1)
			draw(p1[p1_next], p1_nextrot, 4, 2, p1[p1_next].colour, 1);

		//p1_time1=clock();
		//if(players>1)
		//	p2_time1=clock();
		
		p1_blockstart=clock();
		
//		if(players>1)
			p2_blockstart=clock();
		
		if(players>2)
		{
		print("Lines: ", 30, 9, text_colour|background_colour);
		locate(37, 9, text_colour|background_colour, 5);
		cout<<player1.lines<<endl;
		print("Score: ", 30, 11, text_colour|background_colour);
		locate(37, 11, text_colour|background_colour, 5);
		cout<<player1.score<<endl;
		}
		if(players==2)
		{
		print("Lines:", 27, 9, text_colour|background_colour);
		print("Lines:", 50, 9, text_colour|background_colour);
		locate(34, 9, text_colour|background_colour, 3);
		cout<<player1.lines<<endl;
		locate(57, 9, text_colour|background_colour, 3);
		cout<<player2.lines<<endl;
		print("Score: ", 27, 11, text_colour|background_colour);
		print("Score: ", 50, 11, text_colour|background_colour);
		locate(34, 11, text_colour|background_colour, 5);
		cout<<player1.score<<endl;
		locate(57, 11, text_colour|background_colour, 5);
		cout<<player2.score<<endl;
		}
		if(players==1)
		{
		print("Lines: ", 38, 9, text_colour|background_colour);
		locate(45, 9, text_colour|background_colour, 5);
		cout<<player1.lines<<endl;
		print("Score: ", 38, 11, text_colour|background_colour);
		locate(45, 11, text_colour|background_colour, 5);
		cout<<player1.score<<endl;
		}
		game_over = false;
	
		while(_kbhit()){_getch();}
		do
		{
			p1_time2=clock();
			if(players>1)
				p2_time2=clock();

			p1_difference = (p1_time2-p1_time1)/CLOCKS_PER_SEC;		
			if(players>1)
				p2_difference = (p2_time2-p2_time1)/CLOCKS_PER_SEC;		
			
			if(p1_difference>speed)
			{
				
								
				if(check(p1[p1_block], p1_rot, p1_x, p1_y, 0))
				{
				
					if(p1_y>0)
					{
						if(players==2)
							draw(p1[p1_block],p1_rot+4,p1_x,p1_y, p1_col, 1);
						else
							if(players>2)
								draw(p1[p1_block],p1_rot+4,p1_x,p1_y, p1_col, 3);
							else
								draw(p1[p1_block],p1_rot+4,p1_x,p1_y, p1_col, 0);
					}
//					if(!collision(p1[p1_block],p1_x,p1_y+1,p1_rot,p2[p2_block], p2_x,p2_y,p2_rot))
						p1_y++;
					
					if(players==2)
						draw(p1[p1_block], p1_rot, p1_x, p1_y, p1_col, 1);
					else
						if(players>2)
							draw(p1[p1_block],p1_rot,p1_x,p1_y, p1_col, 3);
						else
							draw(p1[p1_block], p1_rot, p1_x, p1_y, p1_col, 0);
					
					p1_time1=clock();
				}

				else
				{
						
						if(players>1&&players<3)
							game_over = to_play(p1[p1_block], p1_rot, p1_col, p1_x, p1_y, 1);
						else
							game_over = to_play(p1[p1_block], p1_rot, p1_col, p1_x, p1_y, 0);
												
							p1_lines = check_line(1);

						player1.lines += p1_lines;
						player1.score += int((pow(p1_lines,2))*5*width);
//						print("P1 lines: ", 0, 11, text_colour|background_colour);
//						locate(10, 11, text_colour|background_colour, 3);
//						cout<<player1.lines<<endl;
						if(p1_lines>0)
						{
							MessageBeep(MB_ICONASTERISK);
							if(players==1)
							{
								draw_play(0);
							}
							else
							{
								if(players==2)
								{
									draw_play(1);
								}
								else
								{
									draw_play(3);
								}
							}

						}
						
						
						if(players==2)
						{
						}
//							draw_play(1);
						else
						{
						//draw_play(0);
						if(players>2)
						{
							draw(p2[p2_block], p2_rot, p2_x, p2_y, p2_col, 3);
							//draw_play(3);
						}
						}
						p1_block_down=true;
				}
			}


		
		int p=0;
		if(players>1)
		{
				if(p2_difference>speed)
			{
				
				if(players<3)
					p=2;
				else
					p=3;

				if(check(p2[p2_block], p2_rot, p2_x, p2_y, p))
				{
					if(p2_y>0)
						draw(p2[p2_block],p2_rot+4,p2_x,p2_y, p2_col, p);
//					if(!collision(p1[p1_block],p1_x,p1_y,p1_rot,p2[p2_block], p2_x,p2_y+1,p2_rot))
					p2_y++;
					draw(p2[p2_block], p2_rot, p2_x, p2_y, p2_col, p);
					
					p2_time1=clock();
				}
				else
				{
						
						game_over = to_play(p2[p2_block], p2_rot, p2_col, p2_x, p2_y, p);
						
						//game_over = false;						
						if(p>0)
						p2_lines = check_line(2);
						else
							p2_lines = check_line(0);
						
						if(players==3)
						{
						player1.lines += p2_lines;
						player1.score += int((pow(p2_lines,2))*5*width);
//						print("Lines: ", 0, 11, text_colour|background_colour);
//						locate(10, 11, text_colour|background_colour, 3);
//						cout<<player1.lines<<endl;
						if(p2_lines>0)
						{
							MessageBeep(MB_ICONASTERISK);
							draw_play(0);
						}
						
						p2_block_down=true;
						//draw_play(0);
						draw(p1[p1_block], p1_rot, p1_x, p1_y, p1_col, 3);
						}
						else
						{
						player2.lines += p2_lines;
						player2.score += int((pow(p2_lines,2))*5*width);
//						print("P2 lines: ", 0, 12, text_colour|background_colour);
//						locate(10, 12, text_colour|background_colour, 3);
//						cout<<player2.lines<<endl;
						if(p2_lines>0)
						{
							MessageBeep(MB_ICONASTERISK);
							draw_play(2);
						}
						if(players>2)
							draw(p1[p1_block],p1_rot+4,p1_x,p1_y, p1_col, 0);
						p2_block_down=true;
						//draw_play(2);
						}
				}
				
			
			}
			
		}
			int thing=1;
			bool p1_yes=true;
			bool p2_yes;
			if(players==2)
			{
				p2_yes=true;
				thing = 1;
			}
			else
				if(players>2)
					thing=3;
				else
				thing = 0;
			

			if(kbhit()&&!game_over)
			{
////////////////////////EXPERIMENTAL IF'S///////////////////////

				int typed=_getch();
				
				
				if(typed==setup.player1.left)
				{
			for(b=0;b<4;b++)
					{
						for(a=0;a<4;a++)
						{
							if(p1[p1_block].rotation[p1_rot][b][a]==1 && p1_x+a-1<0)
								p1_yes=false;
						}
					}
					if(p1_yes&&check(p1[p1_block], p1_rot, p1_x-1, p1_y-1, 1))
					{
						draw(p1[p1_block], p1_rot+4, p1_x,p1_y, p1_col, thing);
//						if(!collision(p1[p1_block],p1_x-2,p1_y,p1_rot,p2[p2_block], p2_x,p2_y,p2_rot))
							p1_x--;
						draw(p1[p1_block], p1_rot, p1_x, p1_y, p1_col,thing);			
																	
					}

				}
				
				if(typed==setup.player1.right)
				{
				for(b=0;b<4;b++)
					{
						for(a=0;a<4;a++)
						{
						
							if(p1[p1_block].rotation[p1_rot][b][a]==1 && p1_x+a-1>width)
								p1_yes=false;
						}
					}
					if(p1_yes&&check(p1[p1_block], p1_rot, p1_x+1, p1_y-1,1))
					{
						draw(p1[p1_block], p1_rot+4, p1_x,p1_y, p1_col, thing);
//						if(!collision(p1[p1_block],p1_x,p1_y,p1_rot,p2[p2_block], p2_x-1,p2_y,p2_rot));
							p1_x++;
						draw(p1[p1_block], p1_rot, p1_x, p1_y, p1_col, thing);			
					}

				}
				if(typed==setup.player1.rotate)
				{
									if(p1_rot<3)
					{
						for(b=0;b<4;b++)
						{
							for(a=0;a<4;a++)
							{
								if((p1[p1_block].rotation[p1_rot+1][b][a]==1 && p1_x+a<0) || (p1[p1_block].rotation[p1_rot+1][b][a]==1 && p1_x+a>width+2))
									p1_yes=false;
							}
						}
						if(p1_yes&&check(p1[p1_block], p1_rot+1, p1_x, p1_y, 1))
						{
							draw(p1[p1_block], p1_rot+4, p1_x,p1_y, p1_col, thing);
//							if(!collision(p1[p1_block],p1_x,p1_y,p1_rot+1,p2[p2_block], p2_x,p2_y,p2_rot));
								p1_rot++;
							draw(p1[p1_block], p1_rot, p1_x, p1_y, p1_col, thing);			
						}
					}
					else
					{
						for(b=0;b<4;b++)
						{
							for(a=0;a<4;a++)
							{
								if((p1[p1_block].rotation[0][b][a]==1 && p1_x+a<0) || (p1[p1_block].rotation[0][b][a]==1 && p1_x+a>width+2))
									p1_yes=false;
							}
						}
						if(p1_yes&&check(p1[p1_block], 0, p1_x, p1_y, 1))
						{
							draw(p1[p1_block], p1_rot+4, p1_x,p1_y, p1_col, thing);			
//							if(!collision(p1[p1_block],p1_x+1,p1_y,0,p2[p2_block], p2_x,p2_y,p2_rot));
								p1_rot=0;
							draw(p1[p1_block], p1_rot, p1_x, p1_y, p1_col, thing);			
						}
					}
				}
									if(typed==setup.player1.drop)
					{
//					if(!collision(p1[p1_block],p1_x-1,p1_y-1,p1_rot,p2[p2_block], p2_x,p2_y,p2_rot));
					p1_time1=10/CLOCKS_PER_SEC;

					}
//			}
					if(players>1)
					{
//			if(kbhit()&&!game_over)
//			{		
//				int typed=_getch();
						if(players>2)
							thing=3;
						else
							thing=2;
				if(typed==setup.player2.left)
				{
			for(b=0;b<4;b++)
					{
						for(a=0;a<4;a++)
						{
							if(p2[p2_block].rotation[p2_rot][b][a]==1 && p2_x+a-1<0)
								p2_yes=false;
						}
					}
					if(p2_yes&&check(p2[p2_block], p2_rot, p2_x-1, p2_y-1, thing))
					{
						draw(p2[p2_block], p2_rot+4, p2_x,p2_y, p2_col, thing);
//						if(!collision(p1[p1_block],p1_x-2,p1_y,p1_rot,p2[p2_block], p2_x,p2_y,p2_rot))
							p2_x--;
						draw(p2[p2_block], p2_rot, p2_x, p2_y, p2_col,thing);			
																	
					}

				}
				
				if(typed==setup.player2.right)
				{
				for(b=0;b<4;b++)
					{
						for(a=0;a<4;a++)
						{
						
							if(p2[p2_block].rotation[p2_rot][b][a]==1 && p2_x+a-1>width)
								p2_yes=false;
						}
					}
					if(p2_yes&&check(p2[p2_block], p2_rot, p2_x+1, p2_y-1,thing))
					{
						draw(p2[p2_block], p2_rot+4, p2_x,p2_y, p2_col, thing);
//						if(!collision(p1[p1_block],p1_x,p1_y,p1_rot,p2[p2_block], p2_x-1,p2_y,p2_rot));
							p2_x++;
						draw(p2[p2_block], p2_rot, p2_x, p2_y, p2_col, thing);			
					}

				}
				if(typed==setup.player2.rotate)
				{
									if(p2_rot<3)
					{
						for(b=0;b<4;b++)
						{
							for(a=0;a<4;a++)
							{
								if((p2[p2_block].rotation[p2_rot+1][b][a]==1 && p2_x+a<0) || (p2[p2_block].rotation[p2_rot+1][b][a]==1 && p2_x+a>width+2))
									p2_yes=false;
							}
						}
						if(p2_yes&&check(p2[p2_block], p2_rot+1, p2_x, p2_y, thing))
						{
							draw(p2[p2_block], p2_rot+4, p2_x,p2_y, p2_col, thing);
//							if(!collision(p1[p1_block],p1_x,p1_y,p1_rot+1,p2[p2_block], p2_x,p2_y,p2_rot));
								p2_rot++;
							draw(p2[p2_block], p2_rot, p2_x, p2_y, p2_col, thing);			
						}
					}
					else
					{
						for(b=0;b<4;b++)
						{
							for(a=0;a<4;a++)
							{
								if((p2[p2_block].rotation[0][b][a]==1 && p2_x+a<0) || (p2[p2_block].rotation[0][b][a]==1 && p2_x+a>width+2))
									p2_yes=false;
							}
						}
						if(p2_yes&&check(p2[p2_block], 0, p2_x, p2_y, thing))
						{
							draw(p2[p2_block], p2_rot+4, p2_x,p2_y, p2_col, thing);			
//							if(!collision(p1[p1_block],p1_x+1,p1_y,0,p2[p2_block], p2_x,p2_y,p2_rot));
								p2_rot=0;
							draw(p2[p2_block], p2_rot, p2_x, p2_y, p2_col, thing);			
						}
					}
				}
									if(typed==setup.player2.drop)
					{
//					if(!collision(p1[p1_block],p1_x-1,p1_y-1,p1_rot,p2[p2_block], p2_x,p2_y,p2_rot));
					p2_time1=10/CLOCKS_PER_SEC;

					}



					}
				
				
////////////////////////EXPERIMENTAL IF'S///////////////////////
///////////////////// START KEYBOARD SWITCH//////////////////////				
/*				
				switch(_getch())
				{
				case 75:
					for(b=0;b<4;b++)
					{
						for(a=0;a<4;a++)
						{
							if(p1[p1_block].rotation[p1_rot][b][a]==1 && p1_x+a-1<0)
								p1_yes=false;
						}
					}
					if(p1_yes&&check(p1[p1_block], p1_rot, p1_x-1, p1_y-1, 1))
					{
						draw(p1[p1_block], p1_rot+4, p1_x,p1_y, p1_col, thing);
//						if(!collision(p1[p1_block],p1_x-2,p1_y,p1_rot,p2[p2_block], p2_x,p2_y,p2_rot))
							p1_x--;
						draw(p1[p1_block], p1_rot, p1_x, p1_y, p1_col,thing);			
																	
					}
					break;
				case 77:
					for(b=0;b<4;b++)
					{
						for(a=0;a<4;a++)
						{
						
							if(p1[p1_block].rotation[p1_rot][b][a]==1 && p1_x+a-1>width)
								p1_yes=false;
						}
					}
					if(p1_yes&&check(p1[p1_block], p1_rot, p1_x+1, p1_y-1,1))
					{
						draw(p1[p1_block], p1_rot+4, p1_x,p1_y, p1_col, thing);
//						if(!collision(p1[p1_block],p1_x,p1_y,p1_rot,p2[p2_block], p2_x-1,p2_y,p2_rot));
							p1_x++;
						draw(p1[p1_block], p1_rot, p1_x, p1_y, p1_col, thing);			
					}
					break;
				case 72:
					if(p1_rot<3)
					{
						for(b=0;b<4;b++)
						{
							for(a=0;a<4;a++)
							{
								if((p1[p1_block].rotation[p1_rot+1][b][a]==1 && p1_x+a<0) || (p1[p1_block].rotation[p1_rot+1][b][a]==1 && p1_x+a>width+2))
									p1_yes=false;
							}
						}
						if(p1_yes&&check(p1[p1_block], p1_rot+1, p1_x, p1_y, 1))
						{
							draw(p1[p1_block], p1_rot+4, p1_x,p1_y, p1_col, thing);
//							if(!collision(p1[p1_block],p1_x,p1_y,p1_rot+1,p2[p2_block], p2_x,p2_y,p2_rot));
								p1_rot++;
							draw(p1[p1_block], p1_rot, p1_x, p1_y, p1_col, thing);			
						}
					}
					else
					{
						for(b=0;b<4;b++)
						{
							for(a=0;a<4;a++)
							{
								if((p1[p1_block].rotation[0][b][a]==1 && p1_x+a<0) || (p1[p1_block].rotation[0][b][a]==1 && p1_x+a>width+2))
									p1_yes=false;
							}
						}
						if(p1_yes&&check(p1[p1_block], 0, p1_x, p1_y, 1))
						{
							draw(p1[p1_block], p1_rot+4, p1_x,p1_y, p1_col, thing);			
//							if(!collision(p1[p1_block],p1_x+1,p1_y,0,p2[p2_block], p2_x,p2_y,p2_rot));
								p1_rot=0;
							draw(p1[p1_block], p1_rot, p1_x, p1_y, p1_col, thing);			
						}
					}
				
				break;
				case 80:
//					if(!collision(p1[p1_block],p1_x-1,p1_y-1,p1_rot,p2[p2_block], p2_x,p2_y,p2_rot));
						p1_time1=10/CLOCKS_PER_SEC;
					break;
				default:
					break;
				}
*/				
////////////////////////END KEYBOARD SWITCH///////////////////			


				
				
			}
		
	
		}while(!p1_block_down&&!p2_block_down&&!game_over);
		
		
		if(p1_block_down)
		{
			p1_blockstop=clock();
			player1.score += int(20- (1.2*((p1_blockstop-p1_blockstart)/CLOCKS_PER_SEC)));		
		}
		
		if(p2_block_down)
		{
			p2_blockstop=clock();
			player2.score += int(20-(1.2*((p2_blockstop-p2_blockstart)/CLOCKS_PER_SEC)));
			if(players>2)
				player1.score += int(20- (1.2*((p2_blockstop-p2_blockstart)/CLOCKS_PER_SEC)));
		}

		if (players==1)
		{
		if(player1.score>limit||player2.score>limit)
		{
			setup.speed++;
			speed=setup.speed;
			speed = 1-((speed)/10);
			background_colour+=16;
			fill_area(23, 7, 76, 42, char(1), background_colour/16);
			draw_screen(0);
			draw_play(0);
			limit=limit*2;
			char spee[] = "LEVEL 1 ";
			switch(setup.speed)
			{
			case 1:
				spee[6]='1';
				break;
			case 2:
				spee[6]='2';
				break;
			case 3:
				spee[6]='3';
				break;
			case 4:
				spee[6]='4';
				break;
			case 5:
				spee[6]='5';
				break;
			case 6:
				spee[6]='6';
				break;
			case 7:
				spee[6]='7';
				break;
			case 8:
				spee[6]='8';
				break;
			case 9:
				spee[6]='9';
				break;
			case 10:
				spee[6]='1';
				spee[7]='0';
				break;
				
			}
			int temp=background_colour;
			background_colour=0;
			fill_area(1, 1, 78, 6, char(0), background_colour);
			print_font(spee, (screen_width/2)-4*4, 1, 4+8, 177);
			background_colour=temp;
		}
		}
	}while(!game_over);
	player1.score=0;
	player1.lines=0;
}