landmine.cpp

一个扫雷小游戏

// LandMine.cpp: implementation of the CLandMine class.

#include "stdafx.h"
#include "mine.h"
#include "LandMine.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

// Construction/Destruction
void CLandMine::Create(int nRow,int nCol,int nMineNum,int nX,int nY,CWnd *pParent)
{
	m_pParent = pParent;
	m_nX = nX;
	m_nY = nY;
	Reset(nRow,nCol,nMineNum);
}	
void CLandMine::ReDraw(BOOL bFail)
{
int nI;
	for(nI=0;nI<m_nRow*m_nCol;nI++)
		m_aLandMine[nI]->DrawItem(bFail);
}
void CLandMine::Reset(int nRow,int nCol,int nMineNum)
{
	int nI;
	RECT rect;
	for(nI=0;nI<m_nRow*m_nCol;nI++)
	{
		if (m_aLandMine[nI]!=NULL)
			delete m_aLandMine[nI];
	}
	for(nI=0;nI<nRow*nCol;nI++)
	{
		
		rect.left = m_nX+nI%nCol*16+1;
		rect.top = m_nY+nI/nCol*16+1;
		//rect.right = m_nX+nI/nCol*16+15;
		//rect.bottom = m_nY+nI%nCol*16+15;
		m_aLandMine[nI] = new CMineButton;
		m_aLandMine[nI]->Create(m_pParent,rect.left,rect.top);
		m_aLandMine[nI]->SetStatus(MS_NORMAL);
	//	m_aLandMine[nI]->SetMineNum(0);
	}
	m_nRow = nRow;
	m_nCol = nCol;
	m_nMineNum = nMineNum;
	
	int nCurMines=0;
	int nCurMine;
	srand( (unsigned)time( NULL ));
//	srand(1);
	while(nCurMines<m_nMineNum)
	{
		nCurMine=rand()%(m_nRow*m_nCol);
		if(m_aLandMine[nCurMine]->GetMineNum() != -1)
		{
			m_aLandMine[nCurMine]->SetMineNum(-1);
			int nMineRound,nMineRound1;
			//right;
			nMineRound = GetRight(nCurMine);
			if(nMineRound>=0)
			{
				if (m_aLandMine[nMineRound]->GetMineNum() != -1)
					++(*m_aLandMine[nMineRound]);
				//right top
				nMineRound1 = GetTop(nMineRound);
				if(nMineRound1>=0 && m_aLandMine[nMineRound1]->GetMineNum() != -1)
				{
					++(*m_aLandMine[nMineRound1]);
				}
				//right bottom
				nMineRound1 = GetBot(nMineRound);
				if(nMineRound1>=0 && m_aLandMine[nMineRound1]->GetMineNum() != -1)
				{
					++(*m_aLandMine[nMineRound1]);
				}
			}			
			//left
			nMineRound = GetLeft(nCurMine);
			if(nMineRound>=0)
			{
				if(m_aLandMine[nMineRound]->GetMineNum() != -1)
					++(*m_aLandMine[nMineRound]);
		
				//Left top
				nMineRound1 = GetTop(nMineRound);
				if(nMineRound1>=0 && m_aLandMine[nMineRound1]->GetMineNum() != -1)
				{
					++(*m_aLandMine[nMineRound1]);
				}
				
				//Left bottom
				nMineRound1 = GetBot(nMineRound);
				if(nMineRound1>=0 && m_aLandMine[nMineRound1]->GetMineNum() != -1)
				{
					++(*m_aLandMine[nMineRound1]);
				}
			}
			//Top
			nMineRound = GetTop(nCurMine);
			if(nMineRound>=0 && m_aLandMine[nMineRound]->GetMineNum() != -1)
			{
				++(*m_aLandMine[nMineRound]);
			}

			//Bottom
			nMineRound = GetBot(nCurMine);
			if(nMineRound>=0 && m_aLandMine[nMineRound]->GetMineNum() != -1)
			{
				++(*m_aLandMine[nMineRound]);
			}
			nCurMines++;
		}
	}
}
void CLandMine::LButtonDown(CPoint point)
{
	int nCol=(point.x-m_nX)/16;
	int nRow=(point.y-m_nY)/16;
	int nCurMine = nCol+nRow*m_nCol;
	if (nRow >= m_nRow || nCol>=m_nCol || point.x<m_nX || point.y<m_nY )
	{
		m_nOldMine = -1;
		return;
	}
	if(nCol<m_nCol && nRow<m_nRow 
		&& (m_aLandMine[nCurMine]->GetStatus()==MS_NORMAL || m_aLandMine[nCurMine]->GetStatus()==MS_QUEST))
	{
		m_aLandMine[nCurMine]->ButtonDown(1);
		m_nOldMine = nCurMine;
	}
};
int CLandMine::LButtonUp(CPoint point)
{
	int nCol=(point.x-m_nX)/16;
	int nRow=(point.y-m_nY)/16;
	int nCurMine = nCol+nRow*m_nCol;
	if (nRow >= m_nRow || nCol>=m_nCol || point.x<m_nX || point.y<m_nY)
		return 0;
	BOOL nStatus = OpenMine(nCurMine);
	if(nStatus==FALSE)
	{	int nI;
		for(nI=0;nI<m_nRow*m_nCol;nI++)
		{
			if(m_aLandMine[nI]->GetMineNum() == -1)
				m_aLandMine[nI]->DrawItem(TRUE);
			if(m_aLandMine[nI]->GetStatus() == MS_FLAG)
				m_aLandMine[nI]->DrawItem(TRUE);
		}
		return -1;
	}
	return 1;

}
BOOL CLandMine::OpenMine(int nCurMine)
{
	int nRoundMine,nRoundMine1;
	int aMine[500];
	int nTop=0,nTail=0;
	
	aMine[nTop++] = nCurMine;
	
	while(nTop!=nTail)
	{
		int nCurrent=aMine[nTail];
		nTail = (nTail+1)%500;
		switch(m_aLandMine[nCurrent]->OpenMine())
		{
		case 0:		// Mine number is zero
			nRoundMine = GetLeft(nCurrent);
			if(nRoundMine!=-1)
			{
				aMine[nTop] = nRoundMine;
				nTop = (nTop+1)%500;
				nRoundMine1 = GetTop(nRoundMine);
				if(nRoundMine1!=-1)
				{
					aMine[nTop] = nRoundMine1;
					nTop = (nTop+1)%500;
					nRoundMine1 = GetTop(nRoundMine);
				}
				nRoundMine1 = GetBot(nRoundMine);
				if(nRoundMine1!=-1)
				{
					aMine[nTop] = nRoundMine1;
					nTop = (nTop+1)%500;
					nRoundMine1 = GetTop(nRoundMine);
				}
			}
			nRoundMine = GetRight(nCurrent);
			if(nRoundMine!=-1)
			{	
				aMine[nTop] = nRoundMine;
				nTop = (nTop+1)%500;
				nRoundMine1 = GetTop(nRoundMine);
				if(nRoundMine1!=-1)
				{
					aMine[nTop] = nRoundMine1;
					nTop = (nTop+1)%500;
					nRoundMine1 = GetTop(nRoundMine);
				}
				nRoundMine1 = GetBot(nRoundMine);
				if(nRoundMine1!=-1)
				{
					aMine[nTop] = nRoundMine1;
					nTop = (nTop+1)%500;
					nRoundMine1 = GetTop(nRoundMine);
				}
			}
			nRoundMine = GetTop(nCurrent);
			if(nRoundMine!=-1)
			{	
				aMine[nTop] = nRoundMine;
				nTop = (nTop+1)%500;
			}
			nRoundMine = GetBot(nCurrent);
			if(nRoundMine!=-1)
			{
				aMine[nTop] = nRoundMine;
				nTop = (nTop+1)%500;
			}
			break;
		case 1:
			break;
		case -1:
			return FALSE;		// fail
		}
	}
	return TRUE;
}

BOOL CLandMine::IsSuccess()
{
	int nI,nStatus,bi=0,mi=0;
	for(nI=0;nI<m_nRow*m_nCol;nI++)
	{
		nStatus = m_aLandMine[nI]->GetStatus();
		if(nStatus != MS_OPEN)
		{
			if(!(nStatus==MS_FLAG && m_aLandMine[nI]->GetMineNum()==-1))
				mi++;			// not finish
			else bi++;
		}
		
	}
	if (mi+bi!=m_nMineNum)	return 0;
		for(nI=0;nI<m_nRow*m_nCol;nI++)
		{
			if(m_aLandMine[nI]->GetMineNum() == -1)
				m_aLandMine[nI]->DrawItem(TRUE);
			if(m_aLandMine[nI]->GetStatus() == MS_FLAG)
				m_aLandMine[nI]->DrawItem(TRUE);
		}
	return 1;		// success
}
void CLandMine::MouseMove(CPoint point,int bBothDown)
{
	int nCol=(point.x-m_nX)/16;
	int nRow=(point.y-m_nY)/16;
	int nCurMine = nCol+nRow*m_nCol;
	if(nRow>=m_nRow || nCol>=m_nCol || point.x<m_nX || point.y<m_nY)
	{
		nCurMine = -1;
	}
	if(bBothDown==0)
	{
		if (m_nOldMine != nCurMine)
		{
			if (m_nOldMine>=0)
				m_aLandMine[m_nOldMine]->ButtonDown(0);
			if (nCurMine>=0)
			{
				m_aLandMine[nCurMine]->ButtonDown(1);
				
			}
			m_nOldMine = nCurMine;
		}
	}
	else
		if(bBothDown==2)		
		{
			if (m_nOldMine != nCurMine)
			{
				int aOldMineTest[9],nOldMineTest=m_nMineTest;
				int nI,nJ;
				for(nI=0;nI<m_nMineTest;nI++)
				{
					aOldMineTest[nI] = m_aMineTest[nI];
				}
				if(nCurMine>=0)
				{
					BOOL bFound;							
					RndBtShdDn(nCurMine);
					
					for(nI=0;nI<m_nMineTest;nI++)
					{
						bFound = FALSE;
						for(nJ=0;nJ<nOldMineTest;nJ++)
						{
							if(m_aMineTest[nI] <= aOldMineTest[nJ])
							{
								if(m_aMineTest[nI] == aOldMineTest[nJ])
								{
									aOldMineTest[nJ] = -1;
									bFound = TRUE;
								}
								break;
							}
							
						}
						if(!bFound)
							m_aLandMine[m_aMineTest[nI]]->ButtonDown(1);
					};
				}
				else
					m_nMineTest = 0;
				if(m_nOldMine>=0)
				{
					for(nI=0;nI<nOldMineTest;nI++)
					{
						if(aOldMineTest[nI] != -1)
							m_aLandMine[aOldMineTest[nI]]->ButtonDown(0);
					}
				}
				m_nOldMine = nCurMine;
			}
		}
		
}
void CLandMine::BothButtonDown(CPoint point)
{
	int nCol=(point.x-m_nX)/16;
	int nRow=(point.y-m_nY)/16;
	int nCurMine = nCol+nRow*m_nCol;
	if (nRow >= m_nRow || nCol>=m_nCol || point.x<m_nX || point.y<m_nY )
		return;
	if(nCol<m_nCol && nRow<m_nRow)
	{
		RndBtShdDn(nCurMine);
		if(m_nMineTest>0)
		{
			int nI;
			for(nI=0;nI<m_nMineTest;nI++)
			{
				m_aLandMine[m_aMineTest[nI]]->ButtonDown(1);
			}
		}
		m_nOldMine = nCurMine;
	}
	else
		m_nOldMine = -1;
}
int CLandMine::BothButtonUp(CPoint point)
{
	int nCol=(point.x-m_nX)/16;
	int nRow=(point.y-m_nY)/16;
	int nCurMine = nCol+nRow*m_nCol;
	if (nRow >= m_nRow || nCol>=m_nCol || point.x<m_nX || point.y<m_nY )
		return 0;
	if (m_aLandMine[nCurMine]->GetStatus()==MS_OPEN)
	{
		
		int nMineRound,nMineRound1,nMineLeft=0,nNotOpen=0;
		int aMineWillOpen[8];
		nMineRound = GetLeft(nCurMine);
		if(nMineRound>=0)
		{
			if(m_aLandMine[nMineRound]->GetStatus()==MS_FLAG)
				nMineLeft++;
			aMineWillOpen[nNotOpen++] = nMineRound;
			nMineRound1 = GetTop(nMineRound);
			if(nMineRound1>=0)
			{
				if(m_aLandMine[nMineRound1]->GetStatus()==MS_FLAG)
					nMineLeft++;
				aMineWillOpen[nNotOpen++] = nMineRound1;
			}
			nMineRound1 = GetBot(nMineRound);
			if(nMineRound1>=0)
			{
				if(m_aLandMine[nMineRound1]->GetStatus()==MS_FLAG)
					nMineLeft++;
				aMineWillOpen[nNotOpen++] = nMineRound1;
			}
		}
		nMineRound = GetRight(nCurMine);
		if(nMineRound>=0)
		{
			if(m_aLandMine[nMineRound]->GetStatus()==MS_FLAG)
				nMineLeft++;
			aMineWillOpen[nNotOpen++] = nMineRound;
			nMineRound1 = GetTop(nMineRound);
			if(nMineRound1>=0)
			{
				if(m_aLandMine[nMineRound1]->GetStatus()==MS_FLAG)
					nMineLeft++;
				aMineWillOpen[nNotOpen++] = nMineRound1;
			}
			nMineRound1 = GetBot(nMineRound);
			if(nMineRound1>=0)
			{
				if(m_aLandMine[nMineRound1]->GetStatus()==MS_FLAG)
					nMineLeft++;
				aMineWillOpen[nNotOpen++] = nMineRound1;
			}
		}
		nMineRound = GetTop(nCurMine);
		if(nMineRound>=0)
		{
			if(nMineRound>=0 && m_aLandMine[nMineRound]->GetStatus()==MS_FLAG)
				nMineLeft++;
			aMineWillOpen[nNotOpen++] = nMineRound;
		}
		nMineRound = GetBot(nCurMine);
		if(nMineRound>=0)
		{
			
			if(nMineRound>=0 && m_aLandMine[nMineRound]->GetStatus()==MS_FLAG)
				nMineLeft++;
			aMineWillOpen[nNotOpen++] = nMineRound;
		}
		if (nMineLeft>=m_aLandMine[nCurMine]->GetMineNum())
		{
			int nI,nStatus;
			for(nI=0;nI<nNotOpen;nI++)
			{
				nStatus = OpenMine(aMineWillOpen[nI]);
				if(nStatus==FALSE)
				{
					
					int nI;
					for(nI=0;nI<m_nRow*m_nCol;nI++)
					{
						if(m_aLandMine[nI]->GetMineNum() == -1)
							m_aLandMine[nI]->DrawItem(TRUE);
						if(m_aLandMine[nI]->GetStatus() == MS_FLAG)
							m_aLandMine[nI]->DrawItem(TRUE);
					}
					return -1;
				}

			}
		}
		else
		{
			int nI;
			for(nI=0;nI<m_nMineTest;nI++)
			{
				m_aLandMine[m_aMineTest[nI]]->ButtonDown(0);
			}
		}
	}
	else
	{
		int nI;
		for(nI=0;nI<m_nMineTest;nI++)
		{
			m_aLandMine[m_aMineTest[nI]]->ButtonDown(0);
		}
	}
	return 0;
}
int CLandMine::RButtonDown(CPoint point)
{
	int nCol=(point.x-m_nX)/16;
	int nRow=(point.y-m_nY)/16;
	int nCurMine = nCol+nRow*m_nCol;
	if (nRow >= m_nRow || nCol>=m_nCol || point.x<m_nX || point.y<m_nY )
		return 0;
	if(m_aLandMine[nCurMine]->GetStatus() != MS_OPEN)
	{
		MINESTATUS nStatus;
		nStatus = m_aLandMine[nCurMine]->GetStatus();
		switch(nStatus)
		{
		case MS_FLAG:
			m_aLandMine[nCurMine]->SetStatus(MS_QUEST);
			m_aLandMine[nCurMine]->DrawItem(FALSE);
			return 1;
		case MS_QUEST:
			m_aLandMine[nCurMine]->SetStatus(MS_NORMAL);
			m_aLandMine[nCurMine]->DrawItem(FALSE);
			return 0;
		case MS_NORMAL:
			m_aLandMine[nCurMine]->SetStatus(MS_FLAG);
			m_aLandMine[nCurMine]->DrawItem(FALSE);
			return -1;
		}
		
	}
	return 0;
}


void CLandMine::RndBtShdDn(int nCurMine)
{
	m_nMineTest = 0;
	int nMineRound,nMineRound1,nMineRound2;
	
	nMineRound1 = GetLeft(nCurMine);
	nMineRound2 = GetRight(nCurMine);
	if(nMineRound1>=0)
	{
		nMineRound = GetTop(nMineRound1);
		if(nMineRound>=0 && (m_aLandMine[nMineRound]->GetStatus()==MS_NORMAL || m_aLandMine[nMineRound]->GetStatus()==MS_QUEST))
		{
			m_aMineTest[m_nMineTest++] = nMineRound;		//left top
		}
	}
	nMineRound = GetTop(nCurMine);
	if(nMineRound>=0 && (m_aLandMine[nMineRound]->GetStatus()==MS_NORMAL || m_aLandMine[nMineRound]->GetStatus()==MS_QUEST))
	{
		m_aMineTest[m_nMineTest++] = nMineRound;		//top
	}
	
	if(nMineRound2>=0)
	{
		nMineRound = GetTop(nMineRound2);
		if(nMineRound>=0 && (m_aLandMine[nMineRound]->GetStatus()==MS_NORMAL || m_aLandMine[nMineRound]->GetStatus()==MS_QUEST))
		{
			m_aMineTest[m_nMineTest++] = nMineRound;		//right top
		}
	}
	if(nMineRound1>=0 && (m_aLandMine[nMineRound1]->GetStatus()==MS_NORMAL || m_aLandMine[nMineRound1]->GetStatus()==MS_QUEST))
		m_aMineTest[m_nMineTest++] = nMineRound1;		//left
	if(m_aLandMine[nCurMine]->GetStatus() == MS_NORMAL ||m_aLandMine[nCurMine]->GetStatus() == MS_QUEST)
		m_aMineTest[m_nMineTest++] = nCurMine;			//current
	if(nMineRound2>=0 && (m_aLandMine[nMineRound2]->GetStatus()==MS_NORMAL || m_aLandMine[nMineRound2]->GetStatus()==MS_QUEST))
		m_aMineTest[m_nMineTest++] = nMineRound2;		//right
	
	if(nMineRound1>=0)
	{
		nMineRound = GetBot(nMineRound1);
		if(nMineRound>=0 && (m_aLandMine[nMineRound]->GetStatus()==MS_NORMAL || m_aLandMine[nMineRound]->GetStatus()==MS_QUEST))
		{
			m_aMineTest[m_nMineTest++] = nMineRound;		//left bot
		}
		
	}
	
	nMineRound = GetBot(nCurMine);
	if(nMineRound>=0 && (m_aLandMine[nMineRound]->GetStatus()==MS_NORMAL || m_aLandMine[nMineRound]->GetStatus()==MS_QUEST))
	{
		m_aMineTest[m_nMineTest++] = nMineRound;		//bot
	}
	
	if(nMineRound2>=0)
	{
		nMineRound = GetBot(nMineRound2);
		if(nMineRound>=0 && (m_aLandMine[nMineRound]->GetStatus()==MS_NORMAL || m_aLandMine[nMineRound]->GetStatus()==MS_QUEST))
		{
			m_aMineTest[m_nMineTest++] = nMineRound;		//right bot
		}
	}
		
};