rusblock.c

ATmega64+12864液晶

#include <stdlib.h>
#include <string.h>
#include  <avr/io.h>
#include <avr/eeprom.h>

#include "lcm.h"
#include  "key.h"
#include "sigtimer.h"


#define PlotColSize   22  /* 3 dummy 2 on top 1 on bottom*/

#define PlotRowSize   14  /* with 2 dummy*/
//typedef uint16  PlotMap[PlotColSize];



typedef struct tagPosition{
uint8 vert;
uint8 hor;
}Position;

typedef Position BaseOffset[4]; 
//typedef struct 


typedef struct tagMoveObject{
uint8 ShapeIndex;
Position BasePoint;
BaseOffset Transform;
uint8 TransformIndex;
}MoveObject;


typedef struct tagShape{
uint8 Index;
BaseOffset Transform[4];
}Shape;


#define TRANSFORM(v0,h0,v1,h1,v2,h2,v3,h3)  {{v0,h0},{v1,h1},{v2,h2},{v3,h3}}




#define SHAPENUM   7

uint8 NextShapeOffset[SHAPENUM][2]={
{37+2,95+3},
{37+4,95},
{37+4,95},
{37+4,95},
{37+4,95},
{37+7,95},
{37+4,95}
};

Shape __PGM ShapeLib[SHAPENUM]={
/*
####
*/
{0,
{
TRANSFORM(1,0,1,1,1,2,1,3),
TRANSFORM(0,1,1,1,2,1,3,1),
TRANSFORM(1,0,1,1,1,2,1,3),
TRANSFORM(0,1,1,1,2,1,3,1)
}
},
/*
#
###
*/
{1,
{
TRANSFORM(2,0,1,0,1,1,1,2),
TRANSFORM(2,2,2,1,1,1,0,1),
TRANSFORM(0,2,1,0,1,1,1,2),
TRANSFORM(0,0,2,1,1,1,0,1)
}
},
/*
     #
###
*/
{2,{
TRANSFORM(2,2,1,0,1,1,1,2),
TRANSFORM(0,2,2,1,1,1,0,1),
TRANSFORM(0,0,1,0,1,1,1,2),
TRANSFORM(2,0,2,1,1,1,0,1)}
},
/*
   ##
##
*/
{3,{
TRANSFORM(1,0,1,1,2,1,2,2),
TRANSFORM(2,1,1,1,1,2,0,2),
TRANSFORM(1,0,1,1,2,1,2,2),
TRANSFORM(2,1,1,1,1,2,0,2)}
},
/*
##
  ##
*/
{4,{
TRANSFORM(2,0,2,1,1,1,1,2),
TRANSFORM(0,0,1,0,1,1,2,1),
TRANSFORM(2,0,2,1,1,1,1,2),
TRANSFORM(0,0,1,0,1,1,2,1)}
},
/*
##
##
*/
{5,{
TRANSFORM(2,0,1,0,1,1,2,1),
TRANSFORM(2,0,1,0,1,1,2,1),
TRANSFORM(2,0,1,0,1,1,2,1),
TRANSFORM(2,0,1,0,1,1,2,1)}
},
/*
  #
###
*/
{6,{
TRANSFORM(2,1,1,0,1,1,1,2),
TRANSFORM(2,1,1,1,0,1,1,2),
TRANSFORM(0,1,1,0,1,1,1,2),
TRANSFORM(2,1,1,1,0,1,1,0)}
}
};



void DrawBlock(uint8 hor,uint8 vert);
void EraseBlock(uint8 hor,uint8 vert);
void DrawShape(MoveObject *pmo);
void DrawNextShape(uint8 shapeindex);
#define  EraseNextShape()  LcmDRect(37,100,24,10, RECT_CLR|RECT_FILL)
void EraseShape(MoveObject *pmo);
void FlushPlotMap(uint16 *ppm);


void PlotMapInit(uint16 *ppm){
uint8 i;
*ppm++=(1<<PlotRowSize)-1;
for(i=0;i<PlotColSize-3;i++){
	*ppm++=0x01|(1<<(PlotRowSize-1));
	}
*ppm++=(1<<PlotRowSize)-1;
*ppm=(1<<PlotRowSize)-1;
}

/*
运行对象重叠?
重叠返回1
否则返回0
*/
signed char ProbeOverlap(MoveObject * pmo,uint16 *ppm){
Position Point[4];
uint16 line;
uint8 i;
for(i=0;i<4;i++){
	Point[i].hor=pmo->BasePoint.hor+pmo->Transform[i].hor;
	Point[i].vert=pmo->BasePoint.vert+pmo->Transform[i].vert;
	}
for(i=0;i<4;i++){
	line=ppm[Point[i].vert];
	if(line>>Point[i].hor&0x01)
		return 1;
	}
return 0;
}

/*
探测运动对象所经过的行是否有整行
并设置full标志位
返回1 表示有整行
否则返回0
*/
signed char  FindFullLine(MoveObject * pmo,uint16 *ppm){
uint8  vert;
uint8 i;
uint8 rv=0;
for(i=0;i<4;i++){
	vert=pmo->BasePoint.vert+pmo->Transform[i].vert;
	if(ppm[vert]==(1<<PlotRowSize)-1){//full line
		ppm[vert]|=(1<<PlotRowSize);//set the full flag bit
		rv++;
		}	
	}
return rv;
}


void SparkleFullLine(uint16 *ppm,uint8 ctrl){
uint8 i,j;
for(i=1;i<PlotColSize-2;i++){
	if(ppm[i]&(1<<PlotRowSize)){//is a full line
		for(j=1;j<PlotRowSize-1;j++){
			if(ctrl>0)
				DrawBlock(j, i);
			else 
				EraseBlock(j, i);
			}
		}
	}

}

signed char  DeleteFullLine(uint16  *ppm){
uint8 i,j,rv=0;
for(i=1;i<PlotColSize-2;i++){
	if(ppm[i]&(1<<PlotRowSize)){//is a full line
		for(j=i;j<PlotColSize-3;j++){
			ppm[j]=ppm[j+1];
			}
		ppm[j]=(0x01|1<<(PlotRowSize-1));
		i--;//recheck
		rv++;
		}
	}
return rv;
}

void UpdatePlotMap(MoveObject *pmo,uint16 *ppm){
uint8 hor,vert;
uint8 i;
for(i=0;i<4;i++){
	hor=pmo->BasePoint.hor+pmo->Transform[i].hor;
	vert=pmo->BasePoint.vert+pmo->Transform[i].vert;
	ppm[vert]|=(1<<hor);
	}

}

/*
首先判断有无路走
若有路走,向前移动一行,返回0
若无路走,判断有无整行,
       若有整行,删除整行,直到无整行为止
	返回1
*/
signed char Forward(MoveObject * pmo,uint16 *ppm){
//uint8 line;
pmo->BasePoint.vert--;//move forward

if(!ProbeOverlap(pmo, ppm)){//return 0 can forward;
	pmo->BasePoint.vert++;
	EraseShape(pmo);
	pmo->BasePoint.vert--;
	DrawShape(pmo);
	return 0;
	}
//overlap
pmo->BasePoint.vert++;
UpdatePlotMap(pmo,ppm);
/*
line=FindFullLine(pmo, ppm);
if(line>0){//have full line
	//sparkle the delete line
	DeleteFullLine(ppm);
	FlushPlotMap(ppm);
	*score+=line;
	}
	*/
return 1;
}



//lr 0: left 1:right
//
signed  char LeftRight(MoveObject * pmo,uint16 *ppm,uint8 lr){
uint8 hor=pmo->BasePoint.hor;
if(!lr){//left
	pmo->BasePoint.hor--;
	}else pmo->BasePoint.hor++;
if(!ProbeOverlap(pmo, ppm)){//return 0 can forward;
      pmo->BasePoint.hor=hor;
	EraseShape(pmo);
	if(!lr){//left
	pmo->BasePoint.hor--;
	}else pmo->BasePoint.hor++;
	DrawShape(pmo);
	return 0;
	}
pmo->BasePoint.hor=hor;
return 1;
}

/*
首先旋转,判断可行与否
可行,return 0
否则,恢复并return 1
*/
signed char Transform(MoveObject *pmo,uint16 *ppm){
uint8 index;
MoveObject  MO;

memcpy(&MO,pmo,sizeof(MoveObject));

index=pmo->TransformIndex;
if(++pmo->TransformIndex>=4)

	pmo->TransformIndex=0;

memcpy_P(pmo->Transform,ShapeLib[pmo->ShapeIndex].Transform[pmo->TransformIndex],sizeof(BaseOffset));
if(ProbeOverlap(pmo, ppm)==0){//no overlap return 0;
      	EraseShape(&MO);
	DrawShape(pmo);
	return 0;
	}
memcpy(pmo,&MO,sizeof(MoveObject));
return 1;
}





/*
获取下一个形状
*/

uint8  GetNextShape(uint16 seed){
//srand(seed);
//return (uint8)((SHAPENUM)*rand())/(RANDOM_MAX+1.0);
return (uint8)(rand()%SHAPENUM);
}



/*
画图操作
*/




void DrawBlock(uint8 hor,uint8 vert){
if(hor==0||vert==0)return;
if(hor>=PlotRowSize-1||vert>=PlotColSize-2)return ;
hor=2+(hor-1)*5;
vert=1+(vert-1)*5;
LcmDRect(hor,vert, 5,5,0x0);

LcmDot(hor+2,vert+2,1);
LcmDot(hor+2,vert+1,1);

}


void EraseBlock(uint8 hor,uint8 vert){
if(hor==0||vert==0)return;
if(hor>=PlotRowSize-1||vert>=PlotColSize-2)return ;
hor=2+(hor-1)*5;
vert=1+(vert-1)*5;
LcmDRect(hor,vert, 5,5,RECT_CLR|RECT_FILL);
}



void DrawShape(MoveObject *pmo){
uint8 i;
for(i=0;i<4;i++){
	DrawBlock(pmo->BasePoint.hor+pmo->Transform[i].hor, 
	pmo->BasePoint.vert+pmo->Transform[i].vert);
	}
}



void DrawNextShape(uint8 shapeindex){
uint8 i;
BaseOffset point;
uint8 rw,cl;
memcpy_P(point,ShapeLib[shapeindex].Transform[0],sizeof(BaseOffset));
for(i=0;i<4;i++){
	rw=NextShapeOffset[shapeindex][0]+5*point[i].hor;
	cl=NextShapeOffset[shapeindex][1]+5*point[i].vert;
	LcmDRect(rw,cl, 5,5,0x0);
	LcmDot(rw+2,cl+2,1);
	LcmDot(rw+2,cl+1,1);
	}

}

//#define  EraseNextShape()  LcmDRect(37,100,24,10, RECT_CLR|RECT_FILL)


void EraseShape(MoveObject *pmo){
uint8 i;
for(i=0;i<4;i++){
	EraseBlock(pmo->BasePoint.hor+pmo->Transform[i].hor,pmo->BasePoint.vert+pmo->Transform[i].vert);
	}
}

void FlushPlotMap(uint16 *ppm){
uint8  i,j;
uint16 line;
for(i=1;i<PlotColSize-2;i++){
	line=ppm[i];
	for(j=1;j<PlotRowSize-1;j++){
		if((line>>j)&0x01)
			DrawBlock(j, i);
			else 
				EraseBlock(j, i);
		}
	}
}




/////////////////////////////////////////////////////////////////////////
// Bitmap点阵数据表                                                    //
// 图片: D:\..s\rushead.bmp,纵向取模下高位,数据排列:从左到右从上到下   //
// 图片尺寸: 31 * 64                                                   //
/////////////////////////////////////////////////////////////////////////
BITMAP RusHead[] =                  // 数据表
{	64,31,
      0xFF,0xFF,0xFF,0x43,0x5B,0x5B,0x5B,0x43,0xFF,0xFF,0xFF,0xFF,0xFF,0x7F,0xFF,0xFF,
      0xFF,0x43,0x5F,0x43,0x7B,0x43,0xFF,0xFF,0x43,0x5F,0x43,0x7B,0x43,0xFF,0xFF,0xFF,
      0xFF,0xFF,0x38,0xAB,0xBB,0xAB,0x38,0xFF,0x3D,0x7D,0x7D,0x7D,0x30,0xFF,0xFF,0xFF,
      0x0F,0xEF,0x08,0xEB,0x08,0xFF,0xFF,0x08,0x6F,0x6F,0x6F,0x08,0xFF,0xFF,0xFF,0xFF,
      0xFF,0x84,0xB5,0xB5,0xB5,0x84,0xFF,0x76,0x77,0x57,0x27,0x76,0xFF,0xFF,0xFF,0x21,
      0xBD,0xA1,0xBD,0x21,0xFF,0xFF,0x2D,0xB5,0x21,0xAD,0x21,0xFF,0xFF,0xFF,0xFF,0xFF,
      0x43,0x5A,0x5B,0x5A,0x43,0xFF,0xC1,0xFD,0xE1,0xFD,0xC1,0xFF,0xFF,0xFF,0x1E,0xD5,
      0xDD,0xD5,0x1E,0xFF,0xFF,0x1C,0xD7,0xDE,0xD7,0x1C,0xFF,0xFF,0xFF,0xFF,0x0F,0x08,
      0x0B,0x0B,0x0B,0x08,0x0F,0x0F,0x0F,0x0F,0x0F,0x0F,0xEF,0xAF,0xAF,0xAE,0x2E,0xAE,
      0xEE,0x0E,0xFF,0xFF,0x42,0x5A,0x5A,0x5A,0x42,0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x00,
      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0x0B,0xE9,0x0A,0xEB,0x0B,0xFF,
      0x00,0xFF,0xFF,0x08,0x6B,0x6B,0x6B,0x08,0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00,
      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xDD,0xEB,0xF7,0xEB,0x5D,0xFF,0x00,
      0xFF,0xFF,0x21,0xAD,0xAD,0xAD,0x21,0xFF,0xFF,0xFF,0xFF,0xC0,0xC0,0xC0,0xC0,0xC0,
      0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xDF,0xDD,0xDD,0xDD,0xDD,0xD0,0xDF,0xC0,0xFF,
      0xFF,0xFC,0xFD,0xFD,0xFD,0xFC,0xFF,0xFF
};



BITMAP Letter[] =                  // 数据表
{
      0x11,0x1F,0x11,0x0A,0x04,/*-A-*/
      0x0F,0x11,0x0F,0x11,0x0F,/*-B-*/
      0x0E,0x11,0x01,0x11,0x0E,/*-C-*/
      0x0F,0x11,0x11,0x11,0x0F,/*-D-*/
      0x1F,0x01,0x0F,0x01,0x1F,/*-E-*/
      0x01,0x01,0x0F,0x01,0x1F,/*-F-*/
      0x1E,0x11,0x19,0x01,0x1E,/*-G-*/
      0x11,0x11,0x1F,0x11,0x11,/*-H-*/
      0x0E,0x04,0x04,0x04,0x0E,/*-I-*/
      0x06,0x04,0x04,0x04,0x0E,/*-J-*/
      0x11,0x0B,0x05,0x09,0x11,/*-K-*/
      0x1F,0x01,0x01,0x01,0x01,/*-L-*/
      0x11,0x11,0x15,0x1B,0x11,/*-M-*/
      0x11,0x19,0x15,0x13,0x11,/*-N-*/