rusian.c

基于S3C2440开发板mini2440的俄罗斯方块程序

	
	for(j=0;j<4;j++)											//Four cubes for each block. 
	{
		for(cube_InitM=save_InitM;cube_InitM<16;cube_InitM++)
		{
			cube_M++;
			cube[cube_M]=cube_Init[tuch][cube_InitM];			//16 points X&Y-poseasion infomations from the Initioned "cube_Init" Array.
			if(cube_M==4)
			{
				save_InitM=cube_InitM+1;
				break;											//4 points for one cube.
			}
		}
		cube_M=0;
		sc++;
		save_cubey[sc]=cube[2];									//Save Y-poseasion infomation for each cube.
		sc++;
		save_cubey[sc]=cube[4];
			if(save_cubeymin>cube[2])							//Save the Max-point of Y-poseasion for each cube.
				save_cubeymin=cube[2];
			if(save_cubeymin>cube[4])
				save_cubeymin=cube[4];
			if(save_cubeymax<cube[2])
				save_cubeymax=cube[2];
			if(save_cubeymax<cube[4])
				save_cubeymax=cube[4];

		Glib_FilledRectangle(cube[1],cube[2],cube[3],cube[4],cube_color[clr]);
	}
Uart_Printf("drupcount+save_cubeymax=%d,%d,%d\n",drupcount+save_cubeymax,drupcount,save_cubeymax);
	sc=0;
	cube_InitM=0;
	cube_M=0;
	save_InitM=0;
	
	/********************************************************Draw the block until reach the end line*******************************/
	while(((drupcount+save_cubeymax)<320)&cube_stopMark)
	{
		Get_Rtc();
		Lcd_printf(162,65,0xf800,RGB( 0xFF,0xFF,0xFF),0,"%4d-%02d-%02d \n",rYear, rMonth, rDay);
		Lcd_printf(182,82,0xf800,RGB( 0xFF,0xFF,0xFF),0,"星期 %d\n",rDayOfWeek);
		Lcd_printf(167,99,0xf800,RGB( 0xFF,0xFF,0xFF),0,"%02d:%02d:%02d\n", rHour, rMinute, rSecond);
		
		Lcd_printf(162,136,0xf800,RGB( 0xFF,0xFF,0xFF),0,"分数:%d\n", score);
		Lcd_printf(162,117,0xf800,RGB( 0xFF,0xFF,0xFF),0,"难度等级:%d\n", hard);
		if(drup_mark)
			switch(hard)
			{
				case(1) :	time=180; break;
				case(2) :	time=270; break;
				case(3) :	time=470; break;
				case(4) :	time=600; break;
				case(5) :	time=700; break;
				default :	break;
			}
			
			
			
		
/**********************************************Draw the 4 cubes of each block when paused*************************************/		
		while(pause)
		{
			Glib_FilledRectangle(193,258,207,272,RGB( 0xFF,0xFF,0xFF));
			for(x=195;x<209;x++)
				for(y=256+(x-193)/2;y<274-(x-193)/2;y++)
					PutPixel( x, y,0x001f );
			while(pause)		
			{
				Clearn_Block();
				delay2();
				cube_InitM=0;
				save_InitM=0;
				cube_M=0;
				sc=0;
				for(j=0;j<4;j++)										
				{

					for(cube_InitM=save_InitM;cube_InitM<16;cube_InitM++)
					{
						cube_M++;
						cube[cube_M]=cube_Init[tuch][cube_InitM];
						if(cube_M==4)
						{
							save_InitM=cube_InitM+1;
							break;
						}
					}
					cube_M=0;
					clr=randomnumber()%5;
						if(clr<0)
							clr=-clr;
					Glib_FilledRectangle(cube[1],cube[2]+drupcount,cube[3],cube[4]+drupcount,cube_color[clr]);
				}
				delay2();
			}
			Glib_FilledRectangle(193,257,208,272,RGB( 0xFF,0xFF,0xFF));
			Glib_FilledRectangle(193,258,198,272,0xf800);
			Glib_FilledRectangle(202,258,207,272,0xf800);
		}
		
		Clearn_Block();
		
		cube_InitM=0;
		save_InitM=0;
		cube_M=0;
		sc=0;		
		if(tuchmask)											//Block trun-Mark,Seted by the INT which Produced by Screem-tuch.
		{	
			Move_Mask();										//Chang the "cubeInit" Array by MoveR&MoveL.
			MoveR=0;
			MoveL=0;
			if(tuch<3)
				tuch++;
			else tuch=0;
				for(j=0;j<8;j++)
				{
					save_cubey[j]=0;
	  	 		}
			Getsave_cubey();
			tuchmask=0;
			MoveR=0;
			MoveL=0;
		}
		cube_InitM=0;
		save_InitM=0;
		cube_M=0;
		sc=0;
	/******************************************************Draw the 4 cubes of each block normally*************************************/
		for(j=0;j<4;j++)										
		{

			for(cube_InitM=save_InitM;cube_InitM<16;cube_InitM++)
			{
				cube_M++;
				cube[cube_M]=cube_Init[tuch][cube_InitM];
				if(cube_M==4)
				{
					save_InitM=cube_InitM+1;
					break;
				}
			}
			cube_M=0;
			sc++;
			save_cubey[sc]+=5;									//Add 5 points to Y-poseasion
			cube[2]=save_cubey[sc];
			sc++;
			save_cubey[sc]+=5;
			cube[4]=save_cubey[sc];
			if((drupcount+save_cubeymax)<=320)
			Glib_FilledRectangle(cube[1],cube[2],cube[3],cube[4],cube_color[j]);		
		}
		delay1();
		ti=time;
		drupcount+=5;
		sc=0;
		cube_InitM=0;
		save_InitM=0;
		cube_M=0;
		Getsave_cubey();
		Getsave_cubexmax();
		Cube_stop();											//Reach the end line or has a cube below?
		if(!cube_stopMark)
		{
			cube_stopMark=1;
			break;
		}		
//		Uart_Printf("drupcount+save_cubeymax=%d,%d,%d\n",drupcount+save_cubeymax,drupcount,save_cubeymax);
//		while(1);		
	}
//		while(1);
		Lcd_printf(162,152,RGB( 0xFF,0xFF,0xFF),RGB( 0xFF,0xFF,0xFF),0,"Nice work!\n");
		Cube_delet();
		
}
///////////////////////
/*************************************************Main Progeram******************************************/
//////////////////////
void Game_Test(void)
{
	Lcd_Tft_NEC35_Init1( );
	 /********************************************TuchPanel Inition**************************************/  
    rADCDLY=50000;                 				 //Normal conversion mode delay about (1/3.6864M)*50000=13.56ms
    rADCCON=(1<<14)+(ADCPRS<<6);  		 		//ADCPRS En, ADCPRS Value
    rADCTSC=0xd3;  								//Wfait,XP_PU,XP_Dis,XM_Dis,YP_Dis,YM_En

    pISR_ADC = (int)AdcTsAuto1;
	rINTMSK=~BIT_ADC;       					//ADC Touch Screen Mask bit clear
	rINTSUBMSK=~(BIT_SUB_TC);
	
	
    /***********************************************The beagining of the Main Progeram.**********************/	
	hard=3;
	times=0;
	while(1)
	{
	
		 if((time_count<3)&times)						//Game off mark.
		 {		 	
			for(j=0;j<32;j++)
			{
				X_count[j]=0;
				X_countsaved[j]=0;
			}
			for(j=0;j<16;j++)
			{
				Y_count[j]=0;
				Y_countsaved[j]=0;
			}	
			for(j=0;j<16;j++)
				for(i=0;i<32;i++)
					Screem_map[j][i]=0;
			score=0;
			game_offmark=1;
		 }
		 while(game_offmark)
		 {
		 	Lcd_printf(163,167,0xf800,RGB( 0xFF,0xFF,0xFF),0,"Game Off!!\n");
		 	delay2();
		 	Lcd_printf(163,167,RGB( 0xFF,0xFF,0xFF),RGB( 0xFF,0xFF,0xFF),0,"难度等级:%d\n", hard);
		 	delay2();
		 }
		 if(time_count<3)
		 	Lcd_ClearScr( (0x1f<<11) | (0x3f<<5) | (0x1f)  )  ;
		 	
		 Get_randseed();						//Generat a randomnumber seed.
		 Total_Init();
		 Cube_Inition();						//Init the "cube_Init" Array according to the randomnumber. 		  	
		 Clear_window();						//Clear the Pre-view Window.
		 init=randomnumber()%7;					//Get two randomnumbers.
		 tuchag=randomnumber()%4;
		 clr=randomnumber()%5;
		 if(init<0)
		 	init=-init;
		 if(tuchag<0)
		 	tuchag=-tuchag;
		 if(clr<0)
		 	clr=-clr;
		 window=1;								//The mark of drawing the pre-view window.
		 Cube_Inition();
		 Paint_window();
		 drup_mark=1;
		 BlockGame();
		 times=1;
	}	
}
////////////////
/*****************************************************INT TuchPanel IRQ_service*******************************************/
///////////////
void __irq AdcTsAuto1(void)
{
	/*****************************************************TuchPanel control***************************************************/	
	U32 saveAdcdly;
    if(rADCDAT0&0x8000)
    {
		//Uart_Printf("\nStylus Up!!\n");
		rADCTSC&=0xff;	// Set stylus down interrupt bit
    }
   	//else 
		//Uart_Printf("\nStylus Down!!\n");

	rADCTSC=(1<<3)|(1<<2);        						 //Pull-up disable, Seq. X,Y postion measure.
	saveAdcdly=rADCDLY;
	rADCDLY=40000;                 						//Normal conversion mode delay about (1/50M)*40000=0.8ms

	rADCCON|=0x1;                 	 	 				//	start ADC
	while(rADCCON & 0x1);									//check if Enable_start is low
	while(!(rADCCON & 0x8000));  						//check if EC(End of Conversion) flag is high, This line is necessary~!!		
    while(!(rSRCPND & (BIT_ADC)));  					//check if ADC is finished with interrupt bit
    xdata1=(rADCDAT0&0x3ff);
    ydata1=(rADCDAT1&0x3ff);
	yy=(xdata1-95)*320/830;								//chang the TuchPanel data to screem point.
	xx=(ydata1-95)*240/825;	 														 
	 rSUBSRCPND|=BIT_SUB_TC;
	ClearPending(BIT_ADC);
	rINTSUBMSK=~(BIT_SUB_TC);
	rINTMSK=~(BIT_ADC);			 
	rADCTSC =0xd3;    								//Waiting for interrupt
	rADCTSC=rADCTSC|(1<<8); 						// Detect stylus up interrupt signal.
	while(1)										//to check Pen-up state
	{
		if(rSUBSRCPND & (BIT_SUB_TC))			 //check if ADC is finished with interrupt bit
												//Uart_Printf("Stylus Up Interrupt~!\n");
		break;									//if Stylus is up(1) state
	}	
		save_cubexmaxagn=save_cubexmax;
		save_cubeymaxagn=save_cubeymax;
		save_cubexminagn=save_cubexmin;
		save_cubeyminagn=save_cubeymin;
		Getsave_cubexmax();
	/*****************************************************Turn_Mark*******************************************/		
	if((((320-yy)>=(save_cubeymin+drupcount-20))&((320-yy)<=(save_cubeymax+drupcount+20))&((xx>=(save_cubexmin-20))&(xx<=(save_cubexmax+20)))) | ((xx>=195)&(yy>=68)&(xx<=205)&(yy<=88)))
	{
		
		Uart_Printf("tuch=%d\n",tuch);
		if(save_cubexmax<=turn_mark_eag[0][tuch])
			tuchmask=1;
		
		Uart_Printf("save_cubexmax=%d\n",save_cubexmax);
		Uart_Printf("save_cubexmin=%d\n",save_cubexmin);
		Uart_Printf("turn_markmax[0][tuch]=%d\n",turn_mark_eag[0][tuch]);
		Uart_Printf("turn_markmin[0][tuch]=%d\n",turn_mark_eag[1][tuch]);
		Uart_Printf("tuchmask=%d\n",tuchmask);
		
	}
		save_cubexmax=save_cubexmaxagn;
		save_cubeymax=save_cubeymaxagn;
		save_cubexmin=save_cubexminagn;
		save_cubeymin=save_cubeyminagn;
	if((193<=xx)&(xx<=207)&(yy<=72)&(yy>=48))
	{
		if(pause_tuch==1)
		{
			pause=1;
			pause_tuch=0;
		}
		else 
		{
			pause_tuch=1;
			pause=0;
		}
	}

	/***********************************************************Move_Right**************************************/
	if((213<=xx)&(yy>=50)&(xx<=233)&(yy<=60)&(cube[4]<320))
	{
		Blockcenter[0]+=10;
		save_cubexmaxagn=save_cubexmax;
		save_cubeymaxagn=save_cubeymax;
		save_cubexminagn=save_cubexmin;
		save_cubeyminagn=save_cubeymin;
		Getsave_cubexmax();
		if((save_cubexmax<160)&((drupcount+save_cubeymax)<320)&cube_stopMark)
		{
			Move_mark=1;			
			cube_InitM=0;
			save_InitM=0;
			for(j=0;j<4;j++)								//Scan the cube eag.判断其右侧是否存在立方体，如果有则不能移动。
			{
				for(cube_InitM=save_InitM;cube_InitM<16;cube_InitM++)
				{
					cube_M++;
					cube[cube_M]=cube_Init[tuch][cube_InitM];
					if(cube_M==4)
					{
						save_InitM=cube_InitM+1;
						break;
					}
				}
				cube_M=0;

				if(((cube[1]+cube[3])/2)>cube[1])
				{	
					if((((cube[2]+cube[4])/2)>cube[2])&(Screem_map[cube[3]/10][(cube[4]+drupcount)/10]>0))
						{
							Move_mark=0;
							break;
						}
						if((((cube[2]+cube[4])/2)<cube[2])&(Screem_map[cube[3]/10][(cube[2]+drupcount)/10]>0))
						{
							Move_mark=0;
							break;
						}
				}
				if(((cube[1]+cube[3])/2)<cube[1])
				{	 
					if((((cube[2]+cube[4])/2)>cube[2])&(Screem_map[cube[1]/10][(cube[4]+drupcount)/10]>0))
						{
					 		Move_mark=0;
					 		break;
					 	}
					if((((cube[2]+cube[4])/2)>cube[2])&(Screem_map[cube[1]/10][(cube[4]+drupcount)/10]>0))
						{
					 		Move_mark=0;
					 		break;
					 	}
				}
			}
				
			if(Move_mark)	
			{
				cube_Move=0;
				Clearn_Block();
				for(j=0;j<8;j++)
				{
					cube_Init[tuch][cube_Move]+=10;
					cube_Move+=2;
				}
				if(save_cubexmin<=10)
				save_cubexmin+=30;
				MoveR++;
			}
		}
			save_cubexmax=save_cubexmaxagn;
			save_cubeymax=save_cubeymaxagn;
			save_cubexmin=save_cubexminagn;
			save_cubeymin=save_cubeyminagn;
			Uart_Printf("MoveR=%d\n",MoveR);
		}

	/*********************************************************************Move_Left******************************************/		
	if((167<=xx)&(yy>=50)&(xx<=187)&(yy<=60)&(cube[4]<320)&cube_stopMark)
	{
		Blockcenter[0]+=10;
		save_cubexmaxagn=save_cubexmax;
		save_cubeymaxagn=save_cubeymax;
		save_cubexminagn=save_cubexmin;
		save_cubeyminagn=save_cubeymin;
		Getsave_cubexmax();
		Uart_Printf("save_cubexmin=%d\n",save_cubexmin);
		if((save_cubexmin>=10)&((drupcount+save_cubeymax)<320))
		{
			
				
			Move_mark=1;			
			cube_InitM=0;
			save_InitM=0;
			for(j=0;j<4;j++)								//判断方块的每个立方体左侧是否存在立方体，如有则不能移动。
			{
				for(cube_InitM=save_InitM;cube_InitM<16;cube_InitM++)
				{
					cube_M++;
					cube[cube_M]=cube_Init[tuch][cube_InitM];
					if(cube_M==4)
					{
						save_InitM=cube_InitM+1;
						break;
					}
				}
				cube_M=0;

				if(((cube[1]+cube[3])/2)>cube[1])
				{	
					if((((cube[2]+cube[4])/2)>cube[2])&(Screem_map[(cube[3]-20)/10][(cube[4]+drupcount)/10]>0))
						{
							Move_mark=0;
							break;
						}
						if((((cube[2]+cube[4])/2)<cube[2])&(Screem_map[(cube[3]-20)/10][(cube[2]+drupcount)/10]>0))
						{
							Move_mark=0;
							break;
						}
				}
				if(((cube[1]+cube[3])/2)<cube[1])
				{	 
					if((((cube[2]+cube[4])/2)>cube[2])&(Screem_map[(cube[1]-20)/10][(cube[4]+drupcount)/10]>0))
						{
					 		Move_mark=0;
					 		break;
					 	}
					if((((cube[2]+cube[4])/2)>cube[2])&(Screem_map[(cube[1]-20)/10][(cube[4]+drupcount)/10]>0))
						{
					 		Move_mark=0;
					 		break;
					 	}
				}
			}
			if(Move_mark)
			{	
				cube_Move=0;
				Clearn_Block();
				for(j=0;j<8;j++)
				{
					cube_Init[tuch][cube_Move]-=10;
					cube_Move+=2;
				}
				if(save_cubexmax>=160)
				save_cubexmax-=30;
				MoveL++;
				Uart_Printf("MoveL=%d\n",MoveL);
			}
	}
			save_cubexmax=save_cubexmaxagn;
			save_cubeymax=save_cubeymaxagn;
			save_cubexmin=save_cubexminagn;
			save_cubeymin=save_cubeyminagn;
	}
	/******************************************************************Drupspeed UP******************************************/
	if((xx>=195)&(yy>=22)&(xx<=205)&(yy<=42))
	{
		time=100;
		drup_mark=0;
	}
	
	if((xx>=162)&(yy>=188)&(xx<=240)&(yy<=203))
	{
		if(hard>1)
			hard--;
		else hard=5;
	}
		

	if((xx>=170)&(yy>=138)&(xx<=240)&(yy<=153))
		game_offmark=0;
//    Uart_Printf("count=%03d  XP=%04d, YP=%04d\n", count1++, xdata1, ydata1);    //X-position Conversion data            

	rADCDLY=saveAdcdly; 
	rADCTSC=rADCTSC&~(1<<8); 						// Detect stylus Down interrupt signal.
    rSUBSRCPND|=BIT_SUB_TC;
    rINTSUBMSK=~(BIT_SUB_TC);						// Unmask sub interrupt (TC)     
    ClearPending(BIT_ADC);
}