snakemodel.cpp

一个在Pocket PC上运行的贪食蛇游戏

				movFood.y=movFood.y-1;
				if(movFood.y<0)
				{
					movFood.y=movFood.y+MAX;
				}
				break;
			case DOWN:
				movFood.y=movFood.y+1;
				if(movFood.y>=MAX)
				{
					movFood.y=movFood.y-MAX;
				}
				break;
			case LEFT:
				movFood.x=movFood.x-1;
				if(movFood.x<0)
				{
					movFood.x=movFood.x+MAX;
				}
				break;
			case RIGHT:
				movFood.x=movFood.x+1;
				if(movFood.x>=MAX)
				{
					movFood.x=movFood.x-MAX;
				}
				break;
			}
			
			matrix[movFood.x][movFood.y]=true;
		}
		//其他情况反向运动2格
		else
		{
			mfDirection=(mfDirection+1)%4+1;

			switch(mfDirection) 
			{
			case UP:
				movFood.y=movFood.y-2;
				if(movFood.y<0)
				{
					movFood.y=movFood.y+MAX;
				}
				break;
			case DOWN:
				movFood.y=movFood.y+2;
				if(movFood.y>=MAX)
				{
					movFood.y=movFood.y-MAX;
				}
				break;
			case LEFT:
				movFood.x=movFood.x-2;
				if(movFood.x<0)
				{
					movFood.x=movFood.x+MAX;
				}
				break;
			case RIGHT:
				movFood.x=movFood.x+2;
				if(movFood.x>=MAX)
				{
					movFood.x=movFood.x-MAX;
				}
				break;
			}
			//反向两格上有东西,再次反相运动一格,相当于没动
			if(matrix[movFood.x][movFood.y])
			{
				mfDirection=(mfDirection+1)%4+1;

				switch(mfDirection) 
				{
				case UP:
					movFood.y=movFood.y-1;
					if(movFood.y<0)
					{
						movFood.y=movFood.y+MAX;
					}
					break;
				case DOWN:
					movFood.y=movFood.y+1;
					if(movFood.y>=MAX)
					{
						movFood.y=movFood.y-MAX;
					}
					break;
				case LEFT:
					movFood.x=movFood.x-1;
					if(movFood.x<0)
					{
						movFood.x=movFood.x+MAX;
					}
					break;
				case RIGHT:
					movFood.x=movFood.x+1;
					if(movFood.x>=MAX)
					{
						movFood.x=movFood.x-MAX;
					}	
					break;
				}	
			}	
			matrix[movFood.x][movFood.y]=true;
		}
	}
	else
	{
		matrix[movFood.x][movFood.y]=true;
	}
}

void CSnakeModel::changeDirection(int newDirection)
{
	// 改变的方向不能与原来方向同向或反向
    if (direction%2!=newDirection%2) 
	{
        direction=newDirection;
    }
}

POINT CSnakeModel::createFood()
{
	int x=0;
    int y=0;
	POINT food;

    // 随机获取一个有效区域内的与蛇体,食物和边框不重叠的位置
    do 
	{
//		srand((unsigned)time(NULL));
        x=rand()%MAX;
        y=rand()%MAX;
    }while(matrix[x][y]);

	matrix[x][y]=true;

	food.x=x;
	food.y=y;		

	numFood++;

	return food;
}

POINT CSnakeModel::createExtFood()
{
	int x=0;
	int y=0;
	POINT extFood;

	do
	{
		x=rand()%MAX;
		y=rand()%MAX;
	}while(matrix[x][y]);

	matrix[x][y]=true;

	extFood.x=x;
	extFood.y=y;
	efType=rand()%3;

	return extFood;
}

POINT CSnakeModel::createMovFood()
{
	int x=0;
	int y=0;
	POINT movFood;

	do
	{
		x=rand()%MAX;
		y=rand()%MAX;
	}while(matrix[x][y]);

	matrix[x][y]=true;

	movFood.x=x;
	movFood.y=y;
	mfDirection=(rand()%4)+1;

	return movFood;
}

POINT CSnakeModel::createStone()
{
	int x=0;
	int y=0;
	POINT stone;

	do
	{
		x=rand()%MAX;
		y=rand()%MAX;
	}while(matrix[x][y]);

	matrix[x][y]=true;

	stone.x=x;
	stone.y=y;

	return stone;
}

void CSnakeModel::addBody()
{
	int x=body[0].x;
	int y=body[0].y;

	switch(direction) 
	{
	case UP:
		y--;
		if(y<0)
		{
			y+= MAX;
		}
		break;
	case DOWN:
		y++;
		if(y>=MAX)
		{
			y-=MAX;
		}
		break;
	case LEFT:
		x--;
		if(x<0)
		{
			x+=MAX;
		}
		break;
	case RIGHT:
		x++;
		if(x>=MAX)
		{
			x-=MAX;
		}
		break;
	}

	for(int i=snakeLan-1;i>=0;i--)
	{
		body[i+1].x=body[i].x;
		body[i+1].y=body[i].y;
	}

	body[0].x=x;
	body[0].y=y;
	matrix[x][y]=true;
	snakeLan++;
}

void CSnakeModel::moveBody()
{
	int x=body[0].x;
	int y=body[0].y;

	switch(direction) 
	{
	case UP:
		y--;
		if(y<0)
		{
			y+= MAX;
		}
		break;
	case DOWN:
		y++;
		if(y>=MAX)
		{
			y-=MAX;
		}
		break;
	case LEFT:
		x--;
		if(x<0)
		{
			x+=MAX;
		}
		break;
	case RIGHT:
		x++;
		if(x>=MAX)
		{
			x-=MAX;
		}
		break;
	}

	matrix[body[snakeLan-1].x][body[snakeLan-1].y]=false;
	for(int i=snakeLan-2;i>=0;i--)
	{
		body[i+1].x=body[i].x;
		body[i+1].y=body[i].y;
	}

	body[0].x=x;
	body[0].y=y;
	matrix[body[0].x][body[0].y]=true;
}

bool CSnakeModel::isBody(int x,int y)
{
	for(int i=snakeLan-1;i>=0;i--)
		if(body[i].x==x&&body[i].y==y)
			return true;
	return false;
}

void CSnakeModel::setMazes()
{
    // 初始化 matirx, 全部清0
    for (int i=0;i<MAX;i++)
		for(int j=0;j<MAX;j++)
			matrix[i][j]=false;

	switch(Settings.mazes)
	{
	case 1:
		noMazes();
		break;
	case 2:
		box();
		break;
	case 3:
		tunnel();
		break;
	case 4:
		spiral();
		break;
	case 5:
		blockade();
		break;
	case 6:
		twisted();
		break;
	}
}

void CSnakeModel::setMazes(int num)
{
    // 初始化 matirx, 全部清0
    for (int i=0;i<MAX;i++)
		for(int j=0;j<MAX;j++)
			matrix[i][j]=false;

	switch(num)
	{
	case 1:
		noMazes();
		break;
	case 2:
		box();
		break;
	case 3:
		tunnel();
		break;
	case 4:
		spiral();
		break;
	case 5:
		blockade();
		break;
	case 6:
		twisted();
		break;
	}
}

void CSnakeModel::noMazes()
{

}

void CSnakeModel::box()
{
	for(int i=0;i<20;i++)
	{
		matrix[i][0]=true;
		matrix[i][19]=true;
	}
	for(int j=1;j<19;j++)
	{
		matrix[0][j]=true;
		matrix[19][j]=true;
	}
}

void CSnakeModel::tunnel()
{
	for(int i=5;i<15;i++)
	{
		matrix[i][6]=true;
		matrix[i][13]=true;
	}
	matrix[0][0]=true;
	matrix[0][1]=true;
	matrix[1][0]=true;
	matrix[19][19]=true;
	matrix[19][18]=true;
	matrix[18][19]=true;
	matrix[19][0]=true;
	matrix[18][0]=true;
	matrix[19][1]=true;
	matrix[0][19]=true;
	matrix[1][19]=true;
	matrix[0][18]=true;
}

void CSnakeModel::spiral()
{
	for(int i=0;i<9;i++)
	{
		matrix[i][6]=true;
		matrix[19-i][13]=true;
		matrix[13][i]=true;
		matrix[6][19-i]=true;
	}
}

void CSnakeModel::blockade()
{
	for(int i=0;i<20;i++)
	{
		matrix[i][0]=true;
		matrix[i][19]=true;
	}
	for(int j=0;j<7;j++)
	{
		matrix[0][j+1]=true;
		matrix[0][18-j]=true;
		matrix[19][j+1]=true;
		matrix[19][18-j]=true;
	}
	for(int m=7;m<13;m++)
	{
		matrix[m][5]=true;
		matrix[m][14]=true;
	}
	for(int n=3;n<9;n++)
	{
		matrix[5][n]=true;
		matrix[5][19-n]=true;
		matrix[14][n]=true;
		matrix[14][19-n]=true;
	}
}

void CSnakeModel::twisted()
{
	matrix[0][0]=true;
	matrix[0][1]=true;
	matrix[1][0]=true;
	matrix[0][2]=true;
	for(int i=5;i<20;i++)
	{
		matrix[i][0]=true;
	}
	for(int j=0;j<8;j++)
	{
		matrix[j][7]=true;
	}
	for(int k=11;k<20;k++)
	{
		matrix[k][7]=true;
	}
	for(int m=1;m<7;m++)
	{
		matrix[7][m]=true;
	}
	for(int n=0;n<20;n++)
	{
		matrix[n][12]=true;
	}
	for(int l=13;l<20;l++)
	{
		matrix[12][l]=true;
	}
}

void CSnakeModel::setSpeed(int num)
{
	speed=1000-num*100;
}

void CSnakeModel::setSpeed()
{
	speed=1000-Settings.level*100;
}

void CSnakeModel::levelUp()
{
	if(extModeLevel>0&&extModeLevel<6)
	{
		extModeLevel++;
		canChangeDirection=true;
		direction=LEFT;                          
		snakeLan=0;
		numFood=0;
		efType=-1;
		step=0;		
		hasTongue=false;

		extFood.x=-1;
		extFood.y=-1;

		stone.x=-1;
		stone.y=-1;

		movFood.x=-1;
		movFood.y=-1;
		//设置速度
		setSpeed(extModeLevel);

		//设置迷宫
		setMazes(extModeLevel);

		// 初始化蛇体
		initSnake();

		// 创建食物
		food=createFood();
	}
}