rusblock.c

ATmega64+12864液晶

      0x0E,0x11,0x11,0x11,0x0E,/*-O-*/
      0x01,0x01,0x0F,0x11,0x0F,/*-P-*/
      0x16,0x09,0x11,0x11,0x0E,/*-Q-*/
      0x11,0x09,0x0F,0x11,0x0F,/*-R-*/
      0x0F,0x10,0x0E,0x01,0x1E,/*-S-*/
      0x04,0x04,0x04,0x04,0x1F,/*-T-*/
      0x0E,0x11,0x11,0x11,0x11,/*-U-*/
      0x04,0x0A,0x11,0x11,0x11,/*-V-*/
      0x11,0x1B,0x15,0x11,0x11,/*-W-*/
      0x11,0x0A,0x04,0x0A,0x11,/*-X-*/
      0x04,0x04,0x0A,0x11,0x11,/*-Y-*/
      0x1F,0x02,0x04,0x08,0x1F /*-Z-*/
};



BITMAP Number[] =                  // 数据表
{
      0x00,0x06,0x06,0x06,0x00,//0
      0x01,0x0B,0x0B,0x0B,0x09,// 1
      0x00,0x0E,0x00,0x07,0x00,// 2
      0x00,0x07,0x00,0x07,0x00,// 3
      0x0B,0x00,0x0A,0x0A,0x0A,// 4
      0x00,0x07,0x00,0x0E,0x00,//5
      0x00,0x06,0x00,0x0E,0x00,//6
      0x07,0x07,0x07,0x07,0x00,//7
      0x00,0x06,0x00,0x06,0x00,//8
      0x00,0x07,0x00,0x06,0x00//9
};



/*
7 keys define 
*/


#define RUSKEY_PLAY   KEY_NUM8
#define RUSKEY_EXIT   KEY_ESC
#define RUSKEY_LEFT   KEY_NUM4
#define RUSKEY_RIGHT   KEY_NUM0
#define RUSKEY_TRANS   KEY_NUM2
#define RUSKEY_INC    KEY_NUM1
#define RUSKEY_DIR   KEY_NUM7
#define RUSKEY_SET   KEY_NUMP
#define RUSKEY_ESC   KEY_NUM8



void DispLetter(uint8 row,uint8 col,char ch){
BITMAP *pbmp=(BITMAP*)&Letter[0];
if(ch<'A'||ch>'Z')return ;
ch=ch-'A';
pbmp+=5*ch;
LcmDPic(row, col, 5,5, 0,pbmp);
}

void DispString(uint8 row,uint8 col,char *str){
while(*str!=0){
	DispLetter(row,col,*str++);
	row+=6;
	}
}


uint8 MainMenu(void){
#define ROWBASE  17
#define COLBASE  61
#define CLRSELECTRECT(r)  LcmDRect(ROWBASE-2, COLBASE-2-r*8,33, 9,RECT_CLR)
#define SETSELECTRECT(r)  LcmDRect(ROWBASE-2, COLBASE-2-r*8,33, 9,0)

uint8 i=0;
uint8 bstop=0;
uint8 key;
DispString(ROWBASE,COLBASE, "START");
DispString(ROWBASE,COLBASE-8, "SPEED");
DispString(ROWBASE,COLBASE-8*2, "ABOUT");
DispString(ROWBASE+3,COLBASE-8*3, "EXIT");

SETSELECTRECT(i);

do{
	key =GetKey();
if(key==RUSKEY_SET){
	bstop=1;
	}else if(key ==RUSKEY_LEFT){
	CLRSELECTRECT(i);
	if(i==0)
		i=3;
	else i--;
	SETSELECTRECT(i);
	}else if(key==RUSKEY_RIGHT){
	CLRSELECTRECT(i);
	if(i>=3)
		i=0;
	else i++;
	SETSELECTRECT(i);
	}
}while(!bstop);
return i;
}


#define MENU_START  0
#define MENU_SPEED  1
#define MENU_ABOUT   2
#define MENU_EXIT   3

#define  CLRMainMenu()  LcmDRect(17-2, 61-3*8,33, 33,RECT_CLR|RECT_FILL)
#define  CLRSPMenu()  LcmDRect(15-2,28,37,49,RECT_CLR|RECT_FILL)

void DispNumber(uint8 row,uint8 col,uint8 num);

uint8 SpeedMenu(uint8 speed){
#define SPROWBASE  15
#define SPCOLBASE  28
#define DSCENTRERECT()    LcmDRect(SPROWBASE+15,SPCOLBASE+2,3,30,0)
#define CLRSPRECT(sp)   LcmDRect(SPROWBASE+11,SPCOLBASE+2+sp*3,11,3,RECT_CLR)
#define SETSPRECT(sp)   LcmDRect(SPROWBASE+11,SPCOLBASE+2+sp*3,11,3,0);\
	LcmDLine((1<<7)|(SPROWBASE+12), SPCOLBASE+3+sp*3,SPROWBASE+20, SPCOLBASE+3+sp*3)
#define DSSPEED(sp)   DispNumber((1<<7)|45,SPCOLBASE+44,sp)
//uint8 bstop=0;
uint8 key=0;
uint8 sp=speed;
DispString(SPROWBASE-2,SPCOLBASE+44, "SPEED");
LcmDRect(SPROWBASE,SPCOLBASE,33,41,0);
DSCENTRERECT();
SETSPRECT(speed);
DSSPEED(speed);
	
do{
 key =GetKey();
if(key==RUSKEY_SET){
	return speed;
	}else if(key ==RUSKEY_LEFT){
	CLRSPRECT(speed);
	DSCENTRERECT();
	if(speed<9)
		speed++;
	SETSPRECT(speed);
	DSSPEED(speed);
	}else if(key==RUSKEY_RIGHT){
	CLRSPRECT(speed);
	DSCENTRERECT();
	if(speed>0)
		speed--;
	SETSPRECT(speed);
	DSSPEED(speed);
	}else if(key==RUSKEY_ESC){
		return sp;
	}
}while(1);

return speed;
}


BITMAP PauseCup[] =                  // 数据表
{
	19,13,
      0xE0,0x10,0x08,0x04,0x02,0x01,0xFF,0x00,
      0x10,0x88,0x10,0x88,0x10,0x07,0xF8,0x10,
      0x20,0x40,0x80,0xFF,0x00,0x11,0x08,0x11,
      0x08,0x11,0x00,0x03,0x04,0x04,0x04,0x03,
      0x00,0x00,0x00,0x00,0x00,0x00,0x00
};

void DispPause(void){
LcmDRect(12,41,39,29,RECT_FILL|RECT_CLR);
LcmDRect(13,42,37,27,0);
DispString(17,45, "PAUSE");
LcmDBmp(22,52, (BITMAP *)&PauseCup[0]);
}


#define  CLRPausePic()  LcmDRect(12,41,39,29,RECT_FILL|RECT_CLR)

void DispGameover(void){
LcmDRect(5,50,55,16,RECT_FILL|RECT_CLR);
LcmDRect(6,51,53,14,0);
DispString(8,55, "GAME");
DispString(33,55, "OVER");
}


void DispNumber(uint8 row,uint8 col,uint8 num){
BITMAP *pbmp=(BITMAP*)&Number[0];
if(num>9)return;
pbmp+=5*num;
LcmDPic(row&0x7F, col, 4,5, (row>>7),pbmp);
}


void UpdateScore(uint16 score){
uint8 i, buf[6];
uint8 row,col;
buf[0]=(score%10000)/1000;
buf[1]=(score%1000)/100;
buf[2]=(score%100)/10;
buf[3]=score%10;
buf[4]=0;
buf[5]=0;
row=29,col=121;
for(i=0;i<6;i++,row+=5){
	DispNumber(row,col,buf[i]);
	}
}

#define UpdateSpeed(speed)   DispNumber(29,114,speed)

typedef struct tagTime{
uint8 hour;
uint8 minute;
uint8 second;
}Time;


void UpdateTime(Time * ptime){
uint8 i,j,buf[6];
uint8 row,col;
buf[0]=ptime->hour/10;
buf[1]=ptime->hour%10;
buf[2]=ptime->minute/10;
buf[3]=ptime->minute%10;
buf[4]=ptime->second/10;
buf[5]=ptime->second%10;
i=0;
row=2;
col=100;
for(j=0;j<3;j++){
DispNumber(row,col,buf[i++]);
row+=5;
DispNumber(row,col,buf[i++]);
row+=7;
}
}

void DrawFace(void ){
LcmDLine(0,0,0, 95);
LcmDLine(1,0,1, 95);
LcmDLine(62,0,62, 95);
LcmDLine(63,0,63, 95);
LcmDLine(0,0,63, 0);
//LcmDLine(0,1,63, 1);

//draw headmap
LcmDBmp(0, 97, (BITMAP *)&RusHead[0]);

}






enum RusState{RUS_IDLE,RUS_START,RUS_PLAY,RUS_PLAY2,RUS_PAUSE,RUS_STOP,RUS_EXIT};




void MoveObjectInit(MoveObject * pmo,uint8 shapeindex){
}

void ClockCount(timerid id,Time* ptime){
if(SoftTimerTest(id)){
	if(++ptime->second==60){
		ptime->second=0;
		if(++ptime->minute==60){
			ptime->minute=0;
			if(++ptime->hour==100)
				ptime->hour=0;
			}
		}
	SoftTimerRestart(id,1);
	UpdateTime(ptime);
	}
}

//return 1 game end
signed char  NewShapeStart(MoveObject *pmo,uint16 *ppm,uint8 *pnext){
pmo->BasePoint.hor=5;
pmo->BasePoint.vert=17;
if(*pnext==0){//长条起点调速
	pmo->BasePoint.vert++;
	}
pmo->ShapeIndex=*pnext;
pmo->TransformIndex=0;
memcpy_P(pmo->Transform,ShapeLib[pmo->ShapeIndex].Transform[pmo->TransformIndex],sizeof(BaseOffset));

if(ProbeOverlap(pmo,ppm)>0)
	return 1;

DrawShape(pmo);
*pnext=GetNextShape(SP);
EraseNextShape();
DrawNextShape(*pnext);

return 0;
}


#define RandSeedAddr   0x00  


void RusBlockMain(void){
timerid spt;
timerid rt;
timerid del;
Time time;
enum RusState state=RUS_IDLE;
uint8 next;
uint16 tmp;
uint8 bstop=0;
uint8 key;
uint16 speed=0;
uint16 score=0;
uint16 *ppm=(uint16 *)malloc(2*PlotColSize);
const uint16 spbuf[10]={1000,900,800,700,600,500,400,300,200,100};
MoveObject  *pmo =(MoveObject*)malloc(sizeof(MoveObject));
memset(pmo,0,sizeof(MoveObject));

tmp=eeprom_read_word((const uint16_t *)RandSeedAddr);
srand(tmp);
tmp<<=2;
eeprom_write_word(RandSeedAddr,tmp);


next=GetNextShape(tmp);

spt=SoftTimerAdd(0);
rt=SoftTimerAdd(0);
del=SoftTimerAdd(0);
DrawFace();
DrawNextShape(next);


PlotMapInit(ppm);
FlushPlotMap(ppm);
		
do{
switch(state){
	case RUS_IDLE:
		tmp=MainMenu();
		if(tmp==MENU_START){
			//CLRMainMenu();
			state=RUS_START;
			}else if(tmp==MENU_SPEED){
			CLRMainMenu();
			speed=SpeedMenu(speed);
			UpdateSpeed(speed);
			}
			CLRSPMenu();
		break;
	case RUS_START:
		NewShapeStart(pmo,ppm,&next);
		//speed=1000;//ms
		SoftTimerRestartMS(spt, spbuf[speed]);
		SoftTimerRestart(rt,1);
		time.second=0;
		time.minute=0;
		time.hour=0;
		score=0;
		UpdateTime(&time);
		UpdateScore(score);
		state=RUS_PLAY;		
		break;
	case RUS_PLAY:
		key=GetKeyMsgNoWait(KEYMSGDOWN);
		if(key>0){//have key	
			if(key==RUSKEY_LEFT||key==RUSKEY_RIGHT){
				LeftRight(pmo, ppm,key==RUSKEY_LEFT?0:1);
				}else if(key==RUSKEY_TRANS){
				Transform(pmo,ppm);
				}else if(key==RUSKEY_INC){
				if(Forward(pmo,ppm)>0){
					state=RUS_PLAY2;
					}				
				}else if(key==RUSKEY_DIR){
					while(Forward(pmo, ppm)==0);
					state=RUS_PLAY2;	
				}else if(key==RUSKEY_ESC){
					state=RUS_STOP;
					break;
				}else if(key==RUSKEY_SET){
				//GetKeyMsgNoWait(KEYMSGUP);//
				state=RUS_PAUSE;
				}
			}
		if(SoftTimerTest(spt)){
			if(Forward(pmo,ppm)>0){
				state=RUS_PLAY2;
				}
			SoftTimerRestartMS(spt, spbuf[speed]);
			}
			//
		ClockCount(rt,&time);
		break;
	case RUS_PLAY2:
		if(FindFullLine(pmo, ppm)>0){
			//sparkle the delete line
			SoftTimerRestartMS(del,200);
			SparkleFullLine(ppm,0);
			while(SoftTimerTest(del)==0){
				ClockCount(rt,&time);
				}
			SoftTimerRestartMS(del,200);
			SparkleFullLine(ppm,1);
			while(SoftTimerTest(del)==0){
				ClockCount(rt,&time);
				}				
			tmp=DeleteFullLine(ppm);
			FlushPlotMap(ppm);
			score+=tmp;
			if(score>9999)
				score-=9999;
			UpdateScore(score);
			}
		if(NewShapeStart(pmo,ppm,&next)>0){
			state=RUS_STOP;
			}else {
			state=RUS_PLAY;
			SoftTimerRestartMS(spt, spbuf[speed]);
			}
		break;
	case RUS_STOP:
		DispGameover();
		SoftTimerRestart(del,3);
		GetKey();//dummy get
		while((SoftTimerTest(del)==0)&&(GetKeyMsgNoWait(KEYMSGUP)!=RUSKEY_ESC));
		PlotMapInit(ppm);
		FlushPlotMap(ppm);
		state=RUS_IDLE;
		break;
	case RUS_PAUSE:
		DispPause();
		GetKey();//dummy get
		while(GetKey()!=RUSKEY_SET);
		CLRPausePic();
		FlushPlotMap(ppm);
		DrawShape(pmo);
		state=RUS_PLAY;		
		break;
	case RUS_EXIT:
		break;
	}

}while(!bstop);

SoftTimerRemove(spt);
SoftTimerRemove(rt);
SoftTimerRemove(del);
free(ppm);
free(pmo);
}