snakeview.cpp

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

		}
	
		KillTimer(1);
		if(isRunning)
		{
			isRunning=false;
		}		

		GetDlgItem(IDC_BUTTON_DOWN)->EnableWindow(0);
		GetDlgItem(IDC_BUTTON_UP)->EnableWindow(0);
		GetDlgItem(IDC_BUTTON_LEFT)->EnableWindow(0);
		GetDlgItem(IDC_BUTTON_RIGHT)->EnableWindow(0);
		GetDlgItem(IDC_BUTTON_TONGUE)->EnableWindow(0);

		CLevelUpDlg levelUpDlg;
		levelUpDlg.DoModal();

		m_nStartSpeed=snake->speed;
		SetTimer(1,m_nStartSpeed,NULL);

		if(!isRunning)
		{
			isRunning=true;
		}

		GetDlgItem(IDC_BUTTON_DOWN)->EnableWindow(1);
		GetDlgItem(IDC_BUTTON_UP)->EnableWindow(1);
		GetDlgItem(IDC_BUTTON_LEFT)->EnableWindow(1);
		GetDlgItem(IDC_BUTTON_RIGHT)->EnableWindow(1);
		GetDlgItem(IDC_BUTTON_TONGUE)->EnableWindow(1);
	}
	else 
	{
		AfxMessageBox(_T("OnTimer return value error!"));
	}		

	ReleaseDC(pDC);

	CFormView::OnTimer(nIDEvent);
}

void CSnakeView::Read()
{
	CFile file1;
	CFile file2;

	if(file1.Open(_T("\\Settings.dat"),CFile::modeRead))
	{
		file1.Read(&Settings,sizeof(Settings));
		file1.Close();
	}
	else
	{
		loadDefoultSettings();
	}	

	if(file2.Open(_T("\\Savings.dat"),CFile::modeRead))
	{
		file2.Read(&Savings,sizeof(Savings));
		file2.Close();
	}
	else
	{
		Savings.haveSaved=false;
	}
}

void CSnakeView::Write()
{
	CFile file1;
	CFile file2;

	if(file1.Open(_T("\\Settings.dat"),CFile::modeWrite|CFile::modeCreate))
	{
		file1.Write(&Settings,sizeof(Settings));
		file1.Close();
	}
	else
	{
		AfxMessageBox(_T("Can not write file!"));
	}	

	if(isRunning||isPaused)
	{
		Savings.haveSaved=true;

		Savings.food.x=snake->food.x;
		Savings.food.y=snake->food.y;
		
		Savings.extFood.x=snake->extFood.x;
		Savings.extFood.y=snake->extFood.y;

		Savings.stone.x=snake->stone.x;
		Savings.stone.y=snake->stone.y;

		Savings.movFood.x=snake->movFood.x;
		Savings.movFood.y=snake->movFood.y;

		for(int i=0;i<MAXLEN;i++)
		{
			Savings.body[i].x=snake->body[i].x;
			Savings.body[i].y=snake->body[i].y;
		}

		for(int j=0;j<MAX;j++)
		{
			for(int k=0;k<MAX;k++)
			{
				Savings.matrix[j][k]=snake->matrix[j][k];
			}
		}

	    Savings.canChangeDirection=snake->canChangeDirection;
	    Savings.snakeLan=snake->snakeLan;
        Savings.direction=snake->direction;                          
        Savings.score=snake->score; 
	    Savings.numFood=snake->numFood;
	    Savings.speed=snake->speed;
		Savings.extModeLevel=snake->extModeLevel;
		Savings.mfDirection=snake->mfDirection;
		Savings.efType=snake->efType;
		Savings.step=snake->step;

	}
	if(file2.Open(_T("\\Savings.dat"),CFile::modeWrite|CFile::modeCreate))
	{
		file2.Write(&Savings,sizeof(Savings));
		file2.Close();
	}
	else
	{
		AfxMessageBox(_T("Can not write file!"));
	}
	
}
void CSnakeView::loadDefoultSettings()
{
	Settings.level=5;
	Settings.mazes=1;
	Settings.mode=1;
}

void CSnakeView::AppendRecord()
{
	CPlayerInfoDlg playerInfoDlg;
	playerInfoDlg.DoModal();

	if(playerInfoDlg.m_name.IsEmpty())
	{
		return;
	}

	m_PlayerName=playerInfoDlg.m_name;
	m_Score=(ULONG)snake->score;

	m_pValProp[0]=CCeDBProp((LPWSTR)(LPCTSTR)m_PlayerName,PROP_NAME);
	m_pValProp[1]=CCeDBProp(m_Score,PROP_SCORE);

	if(!m_Record.AddProps(m_pValProp,2))
	{
		AfxMessageBox(_T("add props unsuccess!"));
	}

	if(!m_DBPlayer.AddRecord(&m_Record))
	{
		AfxMessageBox(_T("add record unsuccess!"));
	}

	m_Record.DeleteAllProps();

	snake->score=0;
	paintScore();
}

void CSnakeView::OnInitialUpdate() 
{
	CFormView::OnInitialUpdate();

	//CE数据库初始化:
	m_pValProp[0]=NULL;
	m_pValProp[1]=NULL;
	m_PlayerName=_T("No Name");
	m_Score=0;

	m_pSortProp[0]=CCeDBProp(CCeDBProp::Type_String,PROP_NAME, CCeDBProp::Sort_Descending);
	m_pSortProp[1]=CCeDBProp(CCeDBProp::Type_ULong ,PROP_SCORE,CCeDBProp::Sort_Descending);
		
	//打开游戏数据库:
	if(!CCeDBDatabase::Exists(_T("\\Snake_Player.cd")))
	{
		m_DBPlayer.Create(_T("\\Snake_Player.cd"),19830213,2,m_pSortProp);
	}
	if(!m_DBPlayer.Open(_T("\\Snake_Player.cd"),&m_pSortProp[1],NULL))
	{
		if(AfxMessageBox(_T("open database error,\ncontinue?"),MB_YESNO)==IDNO)
		{
			SendMessage(WM_CLOSE);
		}
	}

	GetDlgItem(IDC_BUTTON_DOWN)->EnableWindow(0);
	GetDlgItem(IDC_BUTTON_UP)->EnableWindow(0);
	GetDlgItem(IDC_BUTTON_LEFT)->EnableWindow(0);
	GetDlgItem(IDC_BUTTON_RIGHT)->EnableWindow(0);
	GetDlgItem(IDC_BUTTON_TONGUE)->EnableWindow(0);
}

void CSnakeView::paintScore()
{
	char buffer[5];
	_itoa(snake->score,buffer,10);
	m_diplayScore=buffer;
	UpdateData(false);
}

void CSnakeView::erase(CDC *pDC,POINT point)
{
	CRect rect1(FRMWIDTH+point.x*BODYWIDTH,
				FRMHEIGHT+point.y*BODYWIDTH,
				FRMWIDTH+point.x*BODYWIDTH+BODYWIDTH,
				FRMHEIGHT+point.y*BODYWIDTH+BODYWIDTH);

	pDC->FillRect(&rect1,&blackBrush);	
}

void CSnakeView::paintTongue(CDC *pDC)
{
	CDC memDC;
	CBitmap bmpTongue;

	if(!bmpTongue.LoadBitmap(IDB_TONGUE))
	{
		AfxMessageBox(_T("Cann't load bitmap!"));
		return;
	}

	memDC.CreateCompatibleDC(pDC);
	CBitmap* pbmpOld=memDC.SelectObject(&bmpTongue);

	int xx=snake->body[0].x;
	int yy=snake->body[0].y;
	POINT tongue[3];
	//舌头长3格
	for(int i=0;i<3;i++)
	{
		// 根据方向增减坐标值
		switch(snake->direction) 
		{
		case UP:
			yy--;
			if(yy<0)
			{
				yy+= MAX;
			}
			break;
		case DOWN:
			yy++;
			if(yy>=MAX)
			{
				yy-=MAX;
			}
			break;
		case LEFT:
			xx--;
			if(xx<0)
			{
				xx+=MAX;
			}
			break;
		case RIGHT:
			xx++;
			if(xx>=MAX)
			{
				xx-=MAX;
			}
			break;
		}

		tongue[i].x=xx;
		tongue[i].y=yy;

		if(!snake->matrix[xx][yy])
		{
			pDC->BitBlt(FRMWIDTH+xx*BODYWIDTH+2,FRMHEIGHT+yy*BODYWIDTH+2,
						6,6,&memDC,0,0,SRCCOPY);
		}
	}

	Sleep(10);

	for(int j=2;j>=0;j--)
	{
		if(!snake->matrix[tongue[j].x][tongue[j].y])
		{
			CRect blackRect;

			blackRect.left=FRMWIDTH+tongue[j].x*BODYWIDTH;
			blackRect.right=FRMWIDTH+tongue[j].x*BODYWIDTH+BODYWIDTH;
			blackRect.top=FRMHEIGHT+tongue[j].y*BODYWIDTH;
			blackRect.bottom=FRMHEIGHT+tongue[j].y*BODYWIDTH+BODYWIDTH;

			pDC->FillRect(&blackRect,&blackBrush);
		}
	}

	memDC.SelectObject(pbmpOld);
	bmpTongue.DeleteObject();

}

void CSnakeView::paint(CDC *pDC,int status)
{
	CDC memDC;
	CBitmap bmpBody;
	CBitmap bmpHead;

	if(!bmpBody.LoadBitmap(IDB_BODY))
	{
		AfxMessageBox(_T("Cann't load bitmap!"));
		return;
	}
	if(!bmpHead.LoadBitmap(IDB_HEAD))
	{
		AfxMessageBox(_T("Cann't load bitmap!"));
		return;
	}

	memDC.CreateCompatibleDC(pDC);
	CBitmap* pbmpOld=memDC.SelectObject(&bmpHead);

	pDC->BitBlt(FRMWIDTH+snake->body[0].x*BODYWIDTH,FRMHEIGHT+snake->body[0].y*BODYWIDTH,
				BODYWIDTH,BODYWIDTH,&memDC,0,0,SRCCOPY);
		
	memDC.SelectObject(&bmpBody);
	pDC->BitBlt(FRMWIDTH+snake->body[1].x*BODYWIDTH,FRMHEIGHT+snake->body[1].y*BODYWIDTH,
				BODYWIDTH,BODYWIDTH,&memDC,0,0,SRCCOPY);
	
	if(status==1)
	{	
		CBitmap bmpFood;

		if(!bmpFood.LoadBitmap(IDB_FOOD))
		{
			AfxMessageBox(_T("Cann't load bitmap!"));
			return;
		}

		memDC.SelectObject(&bmpFood);
		pDC->BitBlt(FRMWIDTH+snake->food.x*BODYWIDTH,FRMHEIGHT+snake->food.y*BODYWIDTH,
					BODYWIDTH,BODYWIDTH,&memDC,0,0,SRCCOPY);

		bmpFood.DeleteObject();
	}

	if(snake->extFood.x!=-1&&snake->extFood.y!=-1
		&&extFood.x!=snake->extFood.x&&extFood.y!=snake->extFood.y)
	{
		CBitmap bmpExtFood;

		if(!bmpExtFood.LoadBitmap(IDB_LIFE))
		{
			AfxMessageBox(_T("Cann't load bitmap!"));
			return;
		}

		memDC.SelectObject(&bmpExtFood);
		pDC->BitBlt(FRMWIDTH+snake->extFood.x*BODYWIDTH,FRMHEIGHT+snake->extFood.y*BODYWIDTH,
					BODYWIDTH,BODYWIDTH,&memDC,0,0,SRCCOPY);

		bmpExtFood.DeleteObject();
	}

	if(snake->movFood.x!=-1&&snake->movFood.y!=-1)
	{
		CBitmap bmpMovFood;

		if(!bmpMovFood.LoadBitmap(IDB_YELLOW))
		{
			AfxMessageBox(_T("Cann't load bitmap!"));
			return;
		}

		memDC.SelectObject(&bmpMovFood);
		pDC->BitBlt(FRMWIDTH+snake->movFood.x*BODYWIDTH,FRMHEIGHT+snake->movFood.y*BODYWIDTH,
					BODYWIDTH,BODYWIDTH,&memDC,0,0,SRCCOPY);

		bmpMovFood.DeleteObject();
	}

	if(snake->stone.x!=-1&&snake->stone.y!=-1
		&&stone.x!=snake->stone.x&&stone.y!=snake->stone.y)
	{
		CBitmap bmpStone;

		if(!bmpStone.LoadBitmap(IDB_STONE))
		{
			AfxMessageBox(_T("Cann't load bitmap!"));
			return;
		}

		memDC.SelectObject(&bmpStone);
		pDC->BitBlt(FRMWIDTH+snake->stone.x*BODYWIDTH,FRMHEIGHT+snake->stone.y*BODYWIDTH,
					BODYWIDTH,BODYWIDTH,&memDC,0,0,SRCCOPY);

		bmpStone.DeleteObject();
	}

	memDC.SelectObject(pbmpOld);
	bmpBody.DeleteObject();
	bmpHead.DeleteObject();
	
}

void CSnakeView::OnDraw(CDC* pDC) 
{
	// TODO: Add your specialized code here and/or call the base class

	pDC->FillRect(&rect,&blackBrush);
	
	CDC memDC;

	memDC.CreateCompatibleDC(pDC);

	if(!begining)
	{		
		CBitmap bmpStone;
		CBitmap bmpBody;
		CBitmap bmpHead;
		CBitmap bmpFood;
		CBitmap bmpExtFood;
		CBitmap bmpMovFood;

		if(!bmpStone.LoadBitmap(IDB_STONE))
		{
			AfxMessageBox(_T("Cann't load bitmap!"));
			return;
		}

		if(!bmpFood.LoadBitmap(IDB_FOOD))
		{
			AfxMessageBox(_T("Cann't load bitmap!"));
			return;
		}

		if(!bmpBody.LoadBitmap(IDB_BODY))
		{
			AfxMessageBox(_T("Cann't load bitmap!"));
			return;
		}

		if(!bmpHead.LoadBitmap(IDB_HEAD))
		{
			AfxMessageBox(_T("Cann't load bitmap!"));
			return;
		}

		if(!bmpExtFood.LoadBitmap(IDB_LIFE))
		{
			AfxMessageBox(_T("Cann't load bitmap!"));
			return;
		}	

		if(!bmpMovFood.LoadBitmap(IDB_YELLOW))
		{
			AfxMessageBox(_T("Cann't load bitmap!"));
			return;
		}

		CBitmap* pbmpOld=memDC.SelectObject(&bmpStone);

		for(int x=0;x<MAX;x++)
		{
			for(int y=0;y<MAX;y++)
			{
				if(snake->matrix[x][y])
				{
					pDC->BitBlt(FRMWIDTH+x*BODYWIDTH,FRMHEIGHT+y*BODYWIDTH,
								BODYWIDTH,BODYWIDTH,&memDC,0,0,SRCCOPY);
				}
			}
		}

		memDC.SelectObject(&bmpHead);

		pDC->BitBlt(FRMWIDTH+snake->body[0].x*BODYWIDTH,FRMHEIGHT+snake->body[0].y*BODYWIDTH,
					BODYWIDTH,BODYWIDTH,&memDC,0,0,SRCCOPY);

		memDC.SelectObject(&bmpBody);

		for(int i=1;i<snake->snakeLan;i++)
		{
			pDC->BitBlt(FRMWIDTH+snake->body[i].x*BODYWIDTH,FRMHEIGHT+snake->body[i].y*BODYWIDTH,
						BODYWIDTH,BODYWIDTH,&memDC,0,0,SRCCOPY);
		}

		memDC.SelectObject(&bmpFood);

		pDC->BitBlt(FRMWIDTH+snake->food.x*BODYWIDTH,FRMHEIGHT+snake->food.y*BODYWIDTH,
					BODYWIDTH,BODYWIDTH,&memDC,0,0,SRCCOPY);

		if(snake->extFood.x!=-1&&snake->extFood.y!=-1)
		{
			memDC.SelectObject(&bmpExtFood);

			pDC->BitBlt(FRMWIDTH+snake->extFood.x*BODYWIDTH,FRMHEIGHT+snake->extFood.y*BODYWIDTH,
						BODYWIDTH,BODYWIDTH,&memDC,0,0,SRCCOPY);
		}

		if(snake->movFood.x!=-1&&snake->movFood.y!=-1)
		{
			memDC.SelectObject(&bmpMovFood);

			pDC->BitBlt(FRMWIDTH+snake->movFood.x*BODYWIDTH,FRMHEIGHT+snake->movFood.y*BODYWIDTH,
						BODYWIDTH,BODYWIDTH,&memDC,0,0,SRCCOPY);
		}

		if(snake->stone.x!=-1&&snake->stone.y!=-1)
		{
			memDC.SelectObject(&bmpStone);

			pDC->BitBlt(FRMWIDTH+snake->stone.x*BODYWIDTH,FRMHEIGHT+snake->stone.y*BODYWIDTH,
						BODYWIDTH,BODYWIDTH,&memDC,0,0,SRCCOPY);
		}

		memDC.SelectObject(pbmpOld);
		bmpBody.DeleteObject();
		bmpHead.DeleteObject();
		bmpFood.DeleteObject();
		bmpStone.DeleteObject();
		bmpExtFood.DeleteObject();
		bmpMovFood.DeleteObject();
	}
	else
	{		
		CBitmap bmpSnake;
		CBitmap* pbmpOld=memDC.SelectObject(&bmpSnake);

		if(!bmpSnake.LoadBitmap(IDB_SNAKE))
		{
			AfxMessageBox(_T("Cann't load bitmap!"));
			return;
		}

		memDC.SelectObject(&bmpSnake);

		pDC->BitBlt(60,45,128,128,&memDC,0,0,SRCCOPY);

		memDC.SelectObject(pbmpOld);
		bmpSnake.DeleteObject();
	}	
}
/*
//键盘接口
void CSnakeView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
{
	switch(nChar)
	{
	case VK_LEFT:
		OnButtonLeft();
		break;
	case VK_RIGHT:
		OnButtonRight();
		break;
	case VK_DOWN:
		OnButtonDown();
		break;
	case VK_UP:
		OnButtonUp();
		break;
	default:
		break;
	}
	CFormView::OnKeyDown(nChar, nRepCnt, nFlags);
}
*/
void CSnakeView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
{
	if(nChar==(UINT)g_gxkl.vkLeft)
		OnButtonLeft();
	else if(nChar==(UINT)g_gxkl.vkRight)
		OnButtonRight();
	else if(nChar==(UINT)g_gxkl.vkDown)
		OnButtonDown();
	else if(nChar==(UINT)g_gxkl.vkUp)
		OnButtonUp();
	else
		;

	CFormView::OnKeyDown(nChar, nRepCnt, nFlags);
}
BOOL CSnakeView::PreTranslateMessage(MSG* pMsg) 
{
	if(pMsg->message==WM_KEYDOWN)
	{
		OnKeyDown((UINT)pMsg->wParam,(UINT)pMsg->lParam,(UINT)pMsg->lParam);
		return TRUE;
	}		

	return CFormView::PreTranslateMessage(pMsg);
}