linecolorview.cpp

可爱的你喜欢吗？中国连珠啊！

// LineColorView.cpp : implementation of the CLineColorView class
//

#include "stdafx.h"
#include "LineColor.h"

#include "LineColorDoc.h"
#include "LineColorView.h"

#include "uMyStruct.h"

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


CLineColorView	*g_View = NULL;
bool			g_bRun = false;
CWinThread		*g_pThread = NULL;


#define WM_JUMP_BALL	WM_USER + 2001

UINT ThreadProc(LPVOID param)
{
	if (g_View == NULL)
	{
		return false;
	}

	int i = 0;

	while (g_bRun)
	{
		g_View->SendMessage(WM_JUMP_BALL, (WPARAM)i);

		if (i >=4 )
		{
			i = 0;
		}

		i++;

		Sleep(70);
	}

	return true;
}

/////////////////////////////////////////////////////////////////////////////
// CLineColorView

IMPLEMENT_DYNCREATE(CLineColorView, CView)

BEGIN_MESSAGE_MAP(CLineColorView, CView)
	//{{AFX_MSG_MAP(CLineColorView)
	ON_WM_CREATE()
	ON_WM_LBUTTONDOWN()
	ON_COMMAND(IDM_FILE_NEW, OnFileNew)
	ON_WM_DESTROY()
	ON_COMMAND(IDM_FILE_HISTROY, OnFileHistroy)
	ON_WM_ERASEBKGND()
	//}}AFX_MSG_MAP

	ON_MESSAGE(WM_JUMP_BALL, OnMessageJumpBall)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CLineColorView construction/destruction

CLineColorView::CLineColorView()
{
	ReadFile();

	m_nSrcWidth = 600;
	m_nSrcHeight = 405;

	m_nSorce = 0;
}

CLineColorView::~CLineColorView()
{
}

BOOL CLineColorView::PreCreateWindow(CREATESTRUCT& cs)
{
	// TODO: Modify the Window class or styles here by modifying
	//  the CREATESTRUCT cs

	return CView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CLineColorView drawing

void CLineColorView::OnDraw(CDC* pDC)
{
	CLineColorDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);

//	pDC->FillRect(CRect(0, 0, m_nSrcWidth, m_nSrcHeight), &blackBrush);

	pDC->BitBlt(0, 0, m_rectWindow.Width(), m_rectWindow.Height(), &m_virDCSrc,
		0, 0, SRCCOPY);
}

/////////////////////////////////////////////////////////////////////////////
// CLineColorView diagnostics

#ifdef _DEBUG
void CLineColorView::AssertValid() const
{
	CView::AssertValid();
}

void CLineColorView::Dump(CDumpContext& dc) const
{
	CView::Dump(dc);
}

CLineColorDoc* CLineColorView::GetDocument() // non-debug version is inline
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CLineColorDoc)));
	return (CLineColorDoc*)m_pDocument;
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CLineColorView message handlers

int CLineColorView::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
	if (CView::OnCreate(lpCreateStruct) == -1)
	{
		return -1;
	}
	
	if (!m_gdi.CreateGdiObject())
	{
		return -1;
	}

	InitIcon();

	InitSrc();
	InitData();

	if (!CreateMemDC())
	{
		return -1;
	}

	g_bRun = true;
	DWORD dwThreadID = 1;
	g_pThread = AfxBeginThread(ThreadProc, NULL,
		NULL, THREAD_PRIORITY_NORMAL, NULL);

	if (g_pThread == NULL)
	{
		return -1;
	}

	g_pThread->SuspendThread();


	MoveWindow(0, 0, m_nSrcWidth, m_nSrcHeight);

	g_View = this;

	InitPage();

	return 0;
}

BOOL CLineColorView::CreateMemDC()
{
	CClientDC dc(this);

	//整个虚拟屏

	if (!m_virDCSrc.CreateCompatibleDC(&dc))
	{
		return FALSE;
	}

	if (!m_bmpSrc.CreateCompatibleBitmap(
		&dc, m_rectWindow.Width(), m_rectWindow.Height()))
	{
		return FALSE;
	}

	m_virDCSrc.SelectObject(&m_bmpSrc);


	//顶部虚拟屏

	if (!m_virDCTop.CreateCompatibleDC(&dc))
	{
		return FALSE;
	}

	if (!m_bmpTop.CreateCompatibleBitmap(
		&dc, m_rectTop.Width(), m_rectTop.Height()))
	{
		return FALSE;
	}

	m_virDCTop.SelectObject(&m_bmpTop);


	//表格虚拟屏

	if (!m_virDCGrid.CreateCompatibleDC(&dc))
	{
		return FALSE;
	}

	if (!m_bmpGrid.CreateCompatibleBitmap(
		&dc, m_rectGrid.Width(), m_rectGrid.Height()))
	{
		return FALSE;
	}

	m_virDCGrid.SelectObject(&m_bmpGrid);


	//表格左部虚拟屏

	if (!m_virDCLeft.CreateCompatibleDC(&dc))
	{
		return FALSE;
	}

	if (!m_bmpLeft.CreateCompatibleBitmap(
		&dc, m_rectLeft.Width(), m_rectLeft.Height()))
	{
		return FALSE;
	}

	m_virDCLeft.SelectObject(&m_bmpLeft);


	//表格右部虚拟屏

	if (!m_virDCRight.CreateCompatibleDC(&dc))
	{
		return FALSE;
	}

	if (!m_bmpRight.CreateCompatibleBitmap(
		&dc, m_rectRight.Width(), m_rectRight.Height()))
	{
		return FALSE;
	}

	m_virDCRight.SelectObject(&m_bmpRight);

	return TRUE;
}

void CLineColorView::OnLButtonDown(UINT nFlags, CPoint point) 
{
	int nRet = GetGridPos(point.x, point.y);

	if (nRet != 0)
	{
		int nX = nRet%10 - 1;
		int nY = nRet/10 - 1;

		int nActive = m_ball.GetActiveBall();
		int nActiveX = nActive%10;
		int nActiveY = nActive/10;

		if (nActiveX >= 0 && nActiveY >= 0)
		{
			if (nX == nActiveX && nY == nActiveY)
			{
				return;
			}

			if (m_ball.IsExistBall(nX, nY))
			{
				m_ball.SwapActiveBall(nX, nY);
				SwapActiveBall(nX, nY, nActiveX, nActiveY);
			}
			else
			if (m_ball.IsCanMoveBall(nX, nY))
			{
				g_pThread->SuspendThread();
				m_ball.MoveBall(nX, nY);
				MoveBall(nX, nY, nActiveX, nActiveY);

				if (m_ball.CheckCanClear())
				{
					UpdateSorce();
				}
				else
				{
					if (!GrowBall(3))
					{
						GameOver();
					}
					else
					{		
						if (m_ball.CheckCanClear())
						{
							UpdateSorce();
						}

						this->DrawPreBall();
					}
				}
			}
		}
		else
		{
			if (m_ball.IsExistBall(nX, nY))
			{
				m_ball.SetActiveBall(nX, nY);
				SetActiveBall(nX, nY);
			}
		}
	}
	else
	{
		;
	}

	this->UpdatePage();

	CView::OnLButtonDown(nFlags, point);
}




void CLineColorView::OnFileNew() 
{
	m_ball.Init();

	m_nSorce = 0;

	InitPage();
}

void CLineColorView::OnDestroy() 
{
	g_bRun = false;
	g_pThread->ResumeThread();

	m_gdi.DeleteGidObject();

	while (1)
	{
		DWORD dwExitCode = 0;
		
		if (::GetExitCodeThread(g_pThread->m_hThread, &dwExitCode) ==0)
		{
			break;
		}

		if (dwExitCode != STILL_ACTIVE)
		{
			break;
		}

		Sleep(1);
	}

	WriteFile();

	CView::OnDestroy();
}


void CLineColorView::DrawGrid()
{
	m_virDCGrid.FillRect(&m_rectGrid, m_gdi.GetBrush(DARK_GRAY));

	for (int x=0; x<MAX_GRIDX; x++)
	{
		m_virDCGrid.SelectObject(m_gdi.GetPen(BLACK));

		m_virDCGrid.MoveTo(m_rectGrid.left+x*GRIDWIDTH, m_rectGrid.top);
		m_virDCGrid.LineTo(m_rectGrid.left+x*GRIDWIDTH, m_rectGrid.bottom);

		m_virDCGrid.SelectObject(m_gdi.GetPen(WHITE));

		m_virDCGrid.MoveTo(m_rectGrid.left+x*GRIDWIDTH+2, m_rectGrid.top);
		m_virDCGrid.LineTo(m_rectGrid.left+x*GRIDWIDTH+2, m_rectGrid.bottom);
	}

	m_virDCGrid.SelectObject(m_gdi.GetPen(BRIGHT_GRAY));
	m_virDCGrid.MoveTo(m_rectGrid.left+x*GRIDWIDTH, m_rectGrid.top);
	m_virDCGrid.LineTo(m_rectGrid.left+x*GRIDWIDTH, m_rectGrid.bottom);

	for (int y=0; y<MAX_GRIDY; y++)
	{
		m_virDCGrid.SelectObject(m_gdi.GetPen(BLACK));
		m_virDCGrid.MoveTo(m_rectGrid.left, m_rectGrid.top+y*GRIDWIDTH);
		m_virDCGrid.LineTo(m_rectGrid.right, m_rectGrid.top+y*GRIDWIDTH);

		m_virDCGrid.SelectObject(m_gdi.GetPen(WHITE));
		m_virDCGrid.MoveTo(m_rectGrid.left+1, m_rectGrid.top+y*GRIDWIDTH+1);
		m_virDCGrid.LineTo(m_rectGrid.right, m_rectGrid.top+y*GRIDWIDTH+1);
	}
}


void CLineColorView::InitSrc()
{
	m_rectWindow.left = 0;
	m_rectWindow.top = 0;
	m_rectWindow.right = m_nSrcWidth;
	m_rectWindow.bottom = m_nSrcHeight;

	m_rectTop.left = 0;
	m_rectTop.top = 0;
	m_rectTop.right = m_rectWindow.right;
	m_rectTop.bottom = (m_rectWindow.bottom-MAX_GRIDY*GRIDWIDTH)/2;

	m_rectHigher.left = 20;
	m_rectHigher.top = m_rectTop.bottom/2 - 8;
	m_rectHigher.right = m_rectHigher.left + 41;
	m_rectHigher.bottom = m_rectTop.bottom/2 + 8;

	m_rectPlayer.left = m_rectTop.right - 70;
	m_rectPlayer.top = m_rectTop.bottom/2 - 8;
	m_rectPlayer.right = m_rectPlayer.left + 41;
	m_rectPlayer.bottom = m_rectTop.bottom/2 + 8;

	m_rectLeft.left = 0;
	m_rectLeft.top = 0;//(m_rectWindow.bottom-MAX_GRIDY*GRIDWIDTH)/2+1;
	m_rectLeft.right = (m_rectWindow.right-MAX_GRIDX*GRIDWIDTH)/2;
	m_rectLeft.bottom = MAX_GRIDY*GRIDWIDTH;

	m_rectGrid.left = 0;//m_rectLeft.right;
	m_rectGrid.top = 0;//m_rectTop.bottom + 1;
	m_rectGrid.right = MAX_GRIDX*GRIDWIDTH;
	m_rectGrid.bottom = MAX_GRIDY*GRIDWIDTH;

	m_rectRight.left = 0;
	m_rectRight.top = 0;
	m_rectRight.right = (m_rectWindow.right-MAX_GRIDX*GRIDWIDTH)/2;
	m_rectRight.bottom = MAX_GRIDY*GRIDWIDTH;
}

void CLineColorView::DrawFirst()
{
	m_ball.GrowPreBall(3);
	DrawPreBall();

	for (int i=0; i<5; i++)
	{
		int x =0, y = 0, color = 0;

		if (m_ball.GrowBallForFirst(x, y, color))
		{
			DrawOneBall(x, y, color);
		}
	}
}


void CLineColorView::InitData()
{
	m_ball.Init();
}


bool CLineColorView::GrowBall(int nNum)
{
	m_ball.GrowPreBall(3);

	for (int i=0; i<nNum; i++)
	{
		int x =0, y = 0, color=0;

		if (!m_ball.GrowBall(x, y, color, i))
		{
			return false;
		}
		
		DrawOneBall(x, y, color);
	}

	return m_ball.IsOver();
}


void CLineColorView::DrawPreBall()
{
	int nLeft = (m_rectWindow.Width()-TOPGRIDWIDTH*3)/2;

	for (int i=0; i<3; i++)
	{
		CRect rect;

		rect.left = nLeft + i*30+3;
		rect.right = rect.left + 30-3;
		rect.top = 5+2;
		rect.bottom = rect.top + 30-2;

		m_virDCTop.FillRect(&rect, m_gdi.GetBrush(DARK_GRAY));

		int color = m_ball.GetPreBallColor(i);

		HICON hIcon = this->GetIcon(color);

		::DrawIconEx(m_virDCTop.m_hDC, rect.left+6, rect.top+6, 
			hIcon, 16, 16, NULL, NULL, DI_NORMAL);
	}
}

void CLineColorView::DrawOneBall(int x, int y, int color)
{
	CRect rect;
	rect.left = m_rectGrid.left + x*GRIDWIDTH + 3;
	rect.right = m_rectGrid.left + x*GRIDWIDTH + 20;
	rect.top = m_rectGrid.top + y*GRIDWIDTH + 3;
	rect.bottom = m_rectGrid.top + y*GRIDWIDTH + 20;


	HICON hIcon = this->GetIcon(color);

	for (int i=1; i<=4; i++)
	{
		::DrawIconEx(m_virDCGrid.m_hDC, rect.left+16-4*i, 
			rect.top+16-4*i, hIcon, i*8, i*8, NULL, NULL, DI_NORMAL);

		this->UpdatePage();
	}
}


void CLineColorView::DrawTopInfo()
{
	m_virDCTop.FillRect(&m_rectTop, m_gdi.GetBrush(BRIGHT_GRAY));

	m_virDCTop.FillRect(&m_rectHigher, m_gdi.GetBrush(BLACK));
	m_virDCTop.SelectObject(m_gdi.GetPen(WHITE));
	m_virDCTop.MoveTo(m_rectHigher.left-2, m_rectHigher.top-2);
	m_virDCTop.LineTo(m_rectHigher.right, m_rectHigher.top-2);