mythread.cpp

一个用vc编写的俄罗斯方块和贪吃蛇游戏的源代码

// MyThread.cpp: implementation of the CMyThread class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "games.h"
#include "MyThread.h"

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

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////





CMyThread::CMyThread()
{
}

CMyThread::~CMyThread()
{

}

UINT CMyThread::AutoRun(LPVOID pParam )
{
	CElsGame* pGame = (CElsGame*)pParam;
	
	while(pGame->m_nTimer != 0 && pGame->m_hWnd != NULL)
	{
		AutoMove(pGame);
		Sleep(150);
	}

	AfxEndThread(0);
	return 0;
}

void CMyThread::AutoMove(CElsGame * pGame)
{
	//static int xOff = 0;
		int xOff = 0;
//		pGame->m_bNew = FALSE;
//		xOff = 0;
		Move mv[2];

		CEls els = *(pGame->m_pEls);

		mv[0] = GetMove(&els, pGame->m_nRowsHigh);
		
		els.SetMoveType(1);
		mv[1] = GetMove(&els, pGame->m_nRowsHigh);
		
		//els = *(pGame->m_pNext);
		//mv2[0] = GetMove(&els, pGame->m_nRowsHigh);
		//els.m_Hotp = CPoint(120, 0);
		//els.SetMoveType(1);
		//mv2 = GetMove(&els, pGame->m_nRowsHigh);

		if(mv[0].bFind && mv[1].bFind)
		{
			if(pGame->m_nRowsHigh[mv[0].min[0]] <= pGame->m_nRowsHigh[mv[1].min[0]])
			{
				xOff = mv[0].xoff[0];
			}
			else
			{
				pGame->SendMessage(WM_KEYDOWN, 38,0);
				xOff = mv[1].xoff[0];
			}
		}
		else if(mv[0].bFind && !mv[1].bFind)
		{
			xOff = mv[0].xoff[0];
		}
		else if(mv[1].bFind && !mv[0].bFind)
		{
			pGame->SendMessage(WM_KEYDOWN, 38,0);
			xOff = mv[1].xoff[0];
		}
		else if(!mv[0].bFind && !mv[1].bFind)
		{
			if(mv[0].xyz[0] <= mv[1].xyz[0])
			{
				xOff = mv[0].xoff[0];
			}
			else
			{
				pGame->SendMessage(WM_KEYDOWN, 38,0);
				xOff = mv[1].xoff[0];
			}
		}
//	}
	/*
	CDC* pDC = pGame->GetDC();
	CString s;
	for(int i =0; i< Xnum; i++)
	{
		s.Format("%d : %.2d", i, pGame->m_nRowsHigh[i]);
		pDC->TextOut(24* Xnum + 24, 20*i + 180, s);

	}
	s.Format("Off: %d", xOff);
	pDC->TextOut(24* Xnum + 24, 20*(i) + 180, s);
	s.Format("%d: %d: %d", mv[0].xyz[0], mv[0].xyz[1],mv[0].xyz[2]);
	pDC->TextOut(24* Xnum + 24, 20*(i + 1) + 180, s);
	pGame->ReleaseDC(pDC);
	*/
	if(xOff > 0)
	{
		pGame->SendMessage(WM_KEYDOWN, 39,0);
		xOff --;
	}
	else if(xOff < 0)
	{
		pGame->SendMessage(WM_KEYDOWN, 37,0);
		xOff ++;
	}
	else if(xOff == 0)
	{
		pGame->SendMessage(WM_KEYDOWN, 40,0);
		pGame->SendMessage(WM_KEYDOWN, 40,0);
	}
}

Move CMyThread::GetMove(CEls* pEls, const int Rows[])
{
	Move move;

	int nM = 10;

	int xX = 1, xY = 0, yY = 0, xY2 = 0, xY3 = 0;
	int nPoint;
	CPoint pBase;

	int xM = 0;
	int xLower[Xnum] = {0};
	int xLower2[Xnum] = {0};

	int xOff = 0, xOff2 = 0;

	nPoint = pEls->GetPointNum();
	pBase = pEls->GetPoint(0);

	for(int i=1; i<nPoint; i++)
	{
		CPoint p = pEls->GetPoint(i);
		int xOf = (p.x - pBase.x) / 24;
		int yOf = (p.y - pBase.y) / 24;
		if(yOf == 0)
			xX ++;
		if(yOf > 0)
		{
			pBase = p;
			xX = 1;
		}
		else if(p.x < pBase.x && yOf == 0)
			pBase = p;
	}
	for(i=0; i<nPoint; i++)
	{
		CPoint p = pEls->GetPoint(i);
		int xOf = (p.x - pBase.x) / 24;
		int yOf = (p.y - pBase.y) / 24;
		if(yOf == 0)
			continue;
		if(xY < -yOf)
				xY = -yOf;
		if(xOf == 0)
		{
			xY2 ++;
		}
		else if(xOf - xX == 0)
		{
			xY3 ++;
		}
		if(xOf > 0)
		{
			if((xOf - xX + 1) > yY)
				yY = (xOf - xX + 1);
		}
		else
		{
			if(xOf < yY)
				yY = xOf;
		}
	}

	if(xY > xY2 && xY2 > 0)
		xY = xY2;
	if(xY > xY3 && xY3 > 0)
		xY = xY3;

	move.xyz[0] = xX;
	move.xyz[1] = xY;
	move.xyz[2] = yY;

	move.bFind = FALSE;

	for(i = 0; i < Xnum; i ++)
	{
		for(int j=0; j<xX; j ++)
		{
			if(i + j >= Xnum)
				goto NOT;
			if(Rows[i] != Rows[i + j])
				goto NOT;
		}
		if(yY > 0)
		{
			for(j=0; j < yY; j++)
			{
				if(i+ xX-1 >= Xnum || i+xX+j >= Xnum)
					goto NOT;
				if(Rows[i + xX - 1] - Rows[i + xX + j] != -xY)
					goto NOT;
			}
		}
		else
		{
			for(j=0; j > yY; j--)
			{
				if(i-1+j<= 0)
					goto NOT;
				if(Rows[i] - Rows[i - 1 + j] != -xY)
					goto NOT;
			}
		}
		xLower[xM] = i;
		xM ++;
	NOT:;
	}

	BOOL bH = FALSE;
	int xL = 0, xS = 1;
	if(xM > 0)
	{
		for(i = 2; i <xM; i ++)
		{
			if(Rows[xLower[xL]] > Rows[xLower[xS]])
			{
				int d = xL;
				xL = xS;
				xS = d;
			}
			if(Rows[xLower[xS]] > Rows[xLower[i]])
			{
				xS = i;
			}
		}
		if(xM == 1)
		{
			xS = -1;
			xL = 0;
		}
		else
		{
			if(Rows[xLower[xL]] > Rows[xLower[xS]])
			{
				int d = xL;
				xL = xS;
				xS = d;
			}
		}

		if(Rows[xLower[xL]] > nM)
			bH = TRUE;
	}
	int j;
	
	int xM2 = 0;
	if(bH || xM == 0)
	{
		if(yY > 0)
		{
			for(i = 0; i < Xnum - yY - xX; i ++)
			{
				for(j=0; j< xX + yY; j ++)
				{
					if(Rows[i + j] > Rows[i])
						goto NF;
				}
				xLower2[xM2] = i;
				xM2 ++;
			NF:;
			}
		}
		else
		{
			for(i = -yY; i < Xnum - xX + 1; i ++)
			{
				for(j=0; j< xX - yY; j ++)
				{
					if(Rows[i + yY + j] > Rows[i])
						goto NF2;
				}
				xLower2[xM2] = i;
				xM2 ++;
			NF2:;
			}
		}
	}

	int xL2 = 0, xS2 = 1;
	if(xM2 > 0)
	{
		for(i = 2; i <xM2; i ++)
		{
			if(Rows[xLower2[xL2]] > Rows[xLower2[xS2]])
			{
				int d = xL2;
				xL2 = xS2;
				xS2 = d;
			}
			if(Rows[xLower2[xS2]] > Rows[xLower2[i]])
			{
				xS2 = i;
			}
		}
		if(xM2 == 1)
		{
			xS2 = -1;
			xL2 = 0;
		}
		else
		{
			if(Rows[xLower2[xL2]] > Rows[xLower2[xS2]])
			{
				int d = xL2;
				xL2 = xS2;
				xS2 = d;
			}
		}
	}

	if(xM > 0 && xM2 > 0)
	{
		if(Rows[xLower[xL]] - Rows[xLower2[xL2]] > 2)
		{
			xOff = xLower2[xL2] - pBase.x / 24;
			move.min[0] = xLower2[xL2];
			//if(xS2 > 0)
			//{
			//	xOff2 = xLower2[xS2] - pBase.x / 24;
			//	move.min[1] = xLower2[xS2];
			//}
		}
		else
		{
			xOff = xLower[xL] - pBase.x / 24;
			move.min[0] = xLower[xL];
			move.bFind = TRUE;
			//if(xS > 0)
			//{
			//	xOff2 = xLower[xS] - pBase.x / 24;
			//	move.min[1] = xLower[xS];
			//}
		}
	}
	else if(xM >0)
	{
		xOff = xLower[xL] - pBase.x / 24;
		move.min[0] = xLower[xL];
		move.bFind = TRUE;
		//if(xS > 0)
		//{
		//	xOff2 = xLower[xS] - pBase.x / 24;
		//	move.min[1] = xLower[xS];
		//}
	}
	else if(xM2 >0)
	{
		xOff = xLower2[xL2] - pBase.x / 24;
		move.min[0] = xLower2[xL2];
		//if(xS2 > 0)
		//{
		//	xOff2 = xLower2[xS2] - pBase.x / 24;
		//	move.min[1] = xLower2[xS2];
		//}
	}
	else
	{
		xOff = xLower[xL] - pBase.x / 24;
		move.min[0] = xLower[xL];
	}
	
	move.basex = pBase.x / 24;
	move.xoff[0] = xOff;
	//move.xoff[1] = xOff2;
	
	return move;
}