minearea.cpp

一个机器自己学习玩扫雷游戏的程序！快试试！

			if( DRAW_NUMBER_1 - pMines[pos].uDraw +1 == flag) 
			{
//				sndPlaySound((LPCSTR)LockResource(pBlastWavMem),
//					SND_MEMORY | SND_ASYNC | SND_NODEFAULT);
				uGameState = DEAD;
				
				CRect rectButton(uButtonPos[1],15,uButtonPos[2],42);
				uButtonState = BUTTON_DEAD;
				InvalidateRect(rectButton);
				
                for( i=0; i<errorNum; i++)
				{
					pMines[error[i]].uDraw = DRAW_BLAST;
				}
				FlagAllMine();  // 
			}
			else // 
			{
				SetMineUpEx(around,around[8]-1);
			}
		}        
	}
	else
	{	
		int num = around[8];
		around[num] = nNewPos;
		SetMineUpEx(around,num);		
    }
}

void CMineArea::SetMineUpEx( int posArray[], int num )
{	
	RECT rectClick;
	for(int i=0; i<=num; i++)
	{
		if(pMines[posArray[i]].uDraw == DRAW_EMPTY && 
			pMines[posArray[i]].uState != STATE_OPENED)  //
		{
			pMines[posArray[i]].uDraw =  DRAW_NOT_OPEN;
		}
		else if(pMines[posArray[i]].uDraw == DRAW_QUESTION_MARK)
		{
			pMines[posArray[i]].uDraw = DRAW_QUESTION_MARK_FLAG;
		}
		MyInvalidateRect( rectClick, posArray[i] );			
	}		
}

BOOL CMineArea::Victory()
{
	if( ClickNumber == uTotle-theApp.uCustomMineNum )
	{
		uGameState = VICTORY;
		
		uButtonState = BUTTON_VICTORY;
		CRect rectButton(uButtonPos[1],15,uButtonPos[2],42);
		InvalidateRect( rectButton );
		
		theApp.uRemainMines = 0;
        CRect rectMineNum(17,16,55,38);
        InvalidateRect( rectMineNum );

		RECT rectClick;
		for(UINT i=0; i<uTotle; i++)
		{
			if(pMines[i].uState == STATE_MINE && 
				pMines[i].uDraw != DRAW_FLAG )
			{  
				pMines[i].uDraw = DRAW_FLAG;
				MyInvalidateRect( rectClick, i );
			}				
		}
		return TRUE;
	}	
	return FALSE;	
}

void CMineArea::ProcessLeftButtonUp( int pos )
{ 
	if( bFirstClick ) // first clicked
	{
		bFirstClick = FALSE;
		SetMine( pos );
		SetNumbers();
		GetEmptyAreas(); // set empty area flag
	}
	if( pMines[pos].uState >= STATE_NUMBER_8 &&	pMines[pos].uState <= STATE_NUMBER_1 &&
		pMines[pos].uDraw != DRAW_FLAG ) // flag number
	{  
		ClickNumber++;
		pMines[pos].uDraw = pMines[pos].uState;	
        pMines[pos].uState = STATE_OPENED;
		
		RECT rectClick;	
		MyInvalidateRect( rectClick, nNewPos );				
	}
	else if( pMines[pos].uState == STATE_MINE )
	{
		if( pMines[pos].uDraw == DRAW_QUESTION_MARK || pMines[pos].uDraw == DRAW_EMPTY) // dead
		{
			uGameState = DEAD;
			
			CRect rectButton(uButtonPos[1],15,uButtonPos[2],42);
			uButtonState = BUTTON_DEAD;
			InvalidateRect(rectButton);
			
			pMines[pos].uDraw = DRAW_BLAST;
			FlagAllMine(); 
		}		
	}
	else if( pMines[pos].uState >= EMPTY_AREA_START )	
	{	
		DrawEmptyArea( pMines[pos].uState );	//  flag empty area 
		Victory(); // is victory
	}/**/
}

void CMineArea::FlagAllMine()
{
	RECT rectClick;	
	for(UINT i=0; i<uTotle; i++)
	{	
		if(pMines[i].uState == STATE_MINE && 
			pMines[i].uDraw == DRAW_BLAST )
		{		
		}
		else if(pMines[i].uState == STATE_MINE &&
			pMines[i].uDraw != DRAW_FLAG )
		{  
			pMines[i].uDraw = DRAW_MINE;			
		}
		else if( pMines[i].uState != STATE_MINE
			&& pMines[i].uDraw == DRAW_FLAG) // flag error
		{
			pMines[i].uDraw = DRAW_ERROR_FLAG;		
		}	
		else
		{
			continue;			
		}
		MyInvalidateRect( rectClick, i );	
	}
}

void CMineArea::DrawEmptyArea( UINT areaFlag )
{
	RECT rectClick;
	int around[9];
	for(UINT i=0; i<uTotle; i++)
	{   
		if( pMines[i].uState == areaFlag ) // flag the same empty area 
		{
			pMines[i].uDraw = DRAW_EMPTY;			
			pMines[i].uState = STATE_OPENED;
			ClickNumber++;
			MyInvalidateRect( rectClick, i );
			
            GetAroundPos( i, around );
			for(int j=0; j<around[8]; j++)
			{
				if( pMines[around[j]].uState >= STATE_NUMBER_8 && pMines[around[j]].uState <= STATE_NUMBER_1 &&
					pMines[around[j]].uState != STATE_OPENED)
				{
					pMines[around[j]].uDraw = pMines[around[j]].uState;
					pMines[around[j]].uState = STATE_OPENED;
					ClickNumber++;
					MyInvalidateRect( rectClick, around[j] );					
					AddEquations(around[j]/uWidth,around[j]%uWidth);
				}
//				if (pMines[around[j]].uDraw>=STATE_NUMBER_8 && pMines[around[j]].uDraw<=STATE_NUMBER_1)
				else// if (pMines[around[j]].uState==areaFlag) 
					AlertEquas(around[j]/uWidth,around[j]%uWidth);
			}
		}
	}
}

int CMineArea::GetStation(int x,int y)  // 
{
	int	m = x - MINE_AREA_X;
	int	n = y - MINE_AREA_Y;	
	
	if( m<0 || (UINT)m>uWidth*16 ||
		n<0 || (UINT)n>uHeight*16 )
	{
		return -1;
	}
	m = m/16;
	n = n/16;
	return m+n*uWidth;      
}

void CMineArea::SetMineDown( int pos )
{
	RECT rectClick;
	
	if(pMines[pos].uDraw == DRAW_NOT_OPEN)
	{
		pMines[pos].uDraw = DRAW_EMPTY;
	}
	else if(pMines[pos].uDraw == DRAW_QUESTION_MARK_FLAG)
	{
		pMines[pos].uDraw = DRAW_QUESTION_MARK;
	}	
	MyInvalidateRect( rectClick, pos );
}

void CMineArea::SetMineDownEx( int posArray[], int num )
{
	RECT rectClick;
	for(int i=0; i<=num; i++)
	{
		if(pMines[posArray[i]].uDraw == DRAW_NOT_OPEN)
		{
			pMines[posArray[i]].uDraw = DRAW_EMPTY ;
		}
		else if(pMines[posArray[i]].uDraw == DRAW_QUESTION_MARK_FLAG)
		{
			pMines[posArray[i]].uDraw = DRAW_QUESTION_MARK;
		}
		MyInvalidateRect( rectClick, posArray[i] );	
	}
}

void CMineArea::SetMineUp(int pos)
{
	RECT rectClick;
	if(pMines[pos].uDraw == DRAW_EMPTY &&
		pMines[pos].uState != STATE_OPENED)
	{
		pMines[pos].uDraw =  DRAW_NOT_OPEN;
	}
	else if(pMines[pos].uDraw == DRAW_QUESTION_MARK)
	{
		pMines[pos].uDraw = DRAW_QUESTION_MARK_FLAG;
	}
	MyInvalidateRect( rectClick, pos );
}

void CMineArea::LButtonDown(UINT nFlags, CPoint point)
{
	bRBUPOutMineArea = FALSE;
    CRect rectButton(uButtonPos[1],15,uButtonPos[2],42);
	CRect rectMineArea(MINE_AREA_X, MINE_AREA_Y,
		MINE_AREA_X+uWidth*MINE_WIDTH, MINE_AREA_Y+uHeight*MINE_HEIGHT);	
	if (rectButton.PtInRect(point)) // clicked button
	{
		bHitButton = TRUE; 
		bInButtonRect = TRUE;
		
		uButtonState = BUTTON_DOWN;
		InvalidateRect(rectButton);
	}
	else if(rectMineArea.PtInRect(point))  // clicked mine area
	{
		if( uGameState == WAIT || uGameState == RUN )
		{
			nNewPos = GetStation(point.x,point.y);			
			SetMineDown( nNewPos );  // down			
			nOldPos = nNewPos;
			
			uButtonState = BUTTON_CLICK;
			InvalidateRect( rectButton );	
			
			if( nFlags == (MK_LBUTTON|MK_RBUTTON) ) 
			{
				int around[9];
				GetAroundPos( nNewPos, around );
				SetMineDownEx(around,around[8]-1);	// down	
				bDoubleClick = TRUE;
			}	
		}		
	}
	else // clicked other area
	{
		if( uGameState == WAIT || uGameState == RUN )
		{
			uButtonState = BUTTON_CLICK;
			InvalidateRect(rectButton);
		}		
	}

}

void CMineArea::LButtonUp(UINT nFlags, CPoint point)
{
	CRect rectButton(uButtonPos[1],15,uButtonPos[2],42);	
	CRect rectMineArea(MINE_AREA_X, MINE_AREA_Y,
		MINE_AREA_X+uWidth*MINE_WIDTH, MINE_AREA_Y+uHeight*MINE_HEIGHT);

	if( bHitButton && rectButton.PtInRect(point) ) 
	{		
		GameInit();  // reset 
		Invalidate();
		return;
	}
	else if( rectMineArea.PtInRect(point) )
	{
		if( (uGameState == WAIT || uGameState == RUN) )
		{
			if( uGameState == WAIT && !bRBUPOutMineArea )
			{
				if( (bDoubleClick && nFlags == MK_RBUTTON) || !bDoubleClick )
				{
					uGameState = RUN;
				}
			}	
			if(	bDoubleClick )
			{				
				ProcessLeftRightButtonUp( nNewPos );
				bDoubleClick = FALSE;
			}
			else if( !bRBUPOutMineArea )
			{
				ProcessLeftButtonUp( nNewPos );
			}
		}
	}		
	bHitButton = FALSE;
	bInButtonRect = FALSE;
	if( (uGameState == WAIT || uGameState == RUN) && uButtonState == BUTTON_CLICK )
	{
		uButtonState = BUTTON_NORMAL;
		InvalidateRect(rectButton);		
	}

	if (pMines[GetStation(point.x,point.y)].uDraw>=STATE_NUMBER_8 && pMines[GetStation(point.x,point.y)].uDraw<=STATE_NUMBER_1)
		AddEquations(GetStation(point.x,point.y)/uWidth,GetStation(point.x,point.y)%uWidth);
	else
		AlertEquas(GetStation(point.x,point.y)/uWidth,GetStation(point.x,point.y)%uWidth);
}

void CMineArea::MouseMove(UINT nFlags, CPoint point)
{
	bInMineArea = FALSE;
	if((nFlags == MK_LBUTTON)||(nFlags == (MK_LBUTTON|MK_RBUTTON))) 
	{
		SetCapture();	// Capture mouse
		
		CRect rectButton(uButtonPos[1],15,uButtonPos[2],42);
		CRect rectMineArea(MINE_AREA_X, MINE_AREA_Y,
			MINE_AREA_X+uWidth*MINE_WIDTH, MINE_AREA_Y+uHeight*MINE_HEIGHT);
		
		if (rectButton.PtInRect(point))
		{	
			// get into the button area, button down
			if( bHitButton && !bInButtonRect )
			{ 
				bInButtonRect = TRUE;
				uButtonState = BUTTON_DOWN;
				InvalidateRect(rectButton);			
			}
		}
		else if(rectMineArea.PtInRect(point))
		{
			bInMineArea = TRUE;
			if( uGameState == WAIT || uGameState == RUN )
			{
				nNewPos = GetStation(point.x,point.y);				
				if( nNewPos != nOldPos)
				{					
					if( nFlags == (MK_LBUTTON|MK_RBUTTON))
					{	
						int around[10];
						int num;						
						if(nOldPos > -1)
						{
							GetAroundPos( nOldPos, around );
							num = around[8];
							around[num] = nOldPos;
							SetMineUpEx(around,num); // up
						}						
						GetAroundPos( nNewPos, around );
						num = around[8];
						around[num] = nNewPos;
						SetMineDownEx(around,num);	// down	
					}			
					else if( nFlags == MK_LBUTTON && !bRBUPOutMineArea ) 
					{
						SetMineDown( nNewPos);// down						
						if(nOldPos > -1) 
						{
							SetMineUp( nOldPos );//up
						}
					}					
				}
				nOldPos = nNewPos;
			}
		}
		else  // at orther area
		{
			if( bInButtonRect ) // leave the button area, button up
			{
				bInButtonRect = FALSE;
				
				if( uGameState == WAIT || uGameState == RUN )
				{
					uButtonState = BUTTON_NORMAL;					
				}
				else if(  uGameState == DEAD )
				{
					uButtonState = BUTTON_DEAD;				
				}
				else
				{
					uButtonState = BUTTON_VICTORY;					
				}				
				InvalidateRect(rectButton);
			}
			if( uGameState == WAIT || uGameState == RUN )
			{
				// the mine area is up when mouse is leave
				if(  nOldPos > -1 )  
				{
					if( nFlags == MK_LBUTTON )// up
					{
						SetMineUp( nOldPos );
					}
					else if( nFlags == (MK_LBUTTON|MK_RBUTTON))
					{						
						int around[10];
						int num;
						if(nOldPos > -1) // up
						{
							GetAroundPos( nOldPos, around );
							num = around[8];
							around[num] = nOldPos;
							SetMineUpEx(around,num);
						}
					}
					nNewPos = -1;
					nOldPos = -1;
				}
			}
		}
	}
	else 		
	{
		ReleaseCapture();	
	}
	CWnd::OnMouseMove(nFlags, point);
}

void CMineArea::RButtonDown(UINT nFlags, CPoint point)
{
	bRBUPOutMineArea = FALSE;
	CRect rectMineArea(MINE_AREA_X, MINE_AREA_Y,
		MINE_AREA_X+uWidth*MINE_WIDTH, MINE_AREA_Y+uHeight*MINE_HEIGHT);
	if( rectMineArea.PtInRect(point) )
	{
		if( uGameState == WAIT || uGameState == RUN )
		{			
			if( nFlags == (MK_LBUTTON|MK_RBUTTON) ) // down
			{				
				int around[10];
				GetAroundPos( nNewPos, around );
				int num = around[8];
				around[num] = nNewPos;
				SetMineDownEx(around,num);
				bDoubleClick = TRUE;
			}
			else //  chang flag
			{
				int pos	= GetStation(point.x,point.y);