main.cpp

俄罗斯方块程序源码

#include "windows.h"
#include "main.h"
#include "resource.h"

int __stdcall WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,
					  LPSTR lpCmdLine,int nShowCmd)
{
	MSG  msg;
    BOOL bQuit;
    
	hInst = hInstance;
	hWnd = CreateDialogParam(hInstance,
		              (LPCTSTR)DLG_MAIN,
					  NULL,DlgProc,0);
	if (!InitApplication())
	{
		MessageBox(hWnd,"InitApplication Error",szAppName,MB_ICONINFORMATION);
	    DestroyWindow(hWnd);
		return FALSE;
	}
    ShowWindow(hWnd,SW_SHOW);
	UpdateWindow(hWnd);
	bQuit = FALSE;
	//bActive = TRUE;
	while(!bQuit)
	{
		if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
		{  
			if (msg.message == WM_QUIT)
				bQuit = TRUE;
			else{
		        TranslateMessage(&msg);
		        DispatchMessage(&msg);
			}
		}
		else // None Message
		{
			if (bActive)
			{
				// Game Loop
				GameLoop();
			}
			else WaitMessage();
		}
	}

	if (!FreeApplication())
	{
		MessageBox(NULL,"FreeApplication Error!",szAppName,MB_ICONINFORMATION);
		return FALSE;
	}
	return TRUE;
}

//=======================
BOOL CALLBACK DlgProc(HWND hDlg,UINT uMsg,WPARAM wParam,LPARAM lParam)
{
	long uid;

	switch(uMsg)
	{
	case WM_CLOSE:
		//EndDialog(hDlg,0);
		DestroyWindow(hWnd);
		return TRUE;

	case WM_DESTROY:
		PostQuitMessage(0);
		return TRUE;

	case WM_COMMAND:
		uid = LOWORD(wParam);
		switch(uid)
		{
		case IDM_NEW:
            NewGame();
            break;

		case IDM_SUSPEND:
            SuspendGame();
            break;

		case IDM_RESUME:
            ResumeGame();
			break;
		}
		return TRUE;
	}
	return FALSE;
}

//===========================
BOOL InitApplication()
{
	SheetsAddrTab[0]=Sheet1;
	SheetsAddrTab[1]=Sheet2;
	SheetsAddrTab[2]=Sheet3;
	SheetsAddrTab[3]=Sheet4;
	SheetsAddrTab[4]=Sheet5;
	SheetsAddrTab[5]=Sheet6;
	SheetsAddrTab[6]=Sheet7;

	hDc = GetDC(hWnd);
	hBackDc = CreateCompatibleDC(hDc);
	hBackBmp = CreateCompatibleBitmap(hDc,SCENE_WIDTH,SCENE_HEIGHT);
	DeleteObject(SelectObject(hBackDc,hBackBmp));

	hImagesDc = CreateCompatibleDC(hDc);
	//hImagesBmp = CreateCompatibleBitmap(hImagesDc,GRAIN_WIDTH*(MAX_COLOR+1),GRAIN_HEIGHT);
    hImagesBmp = LoadBitmap(hInst,(LPCTSTR) IDB_IMAGES);
    if (hImagesBmp == NULL)
    {
        MessageBox(hWnd,"LoadBitmap Faild!","fds",MB_OK);
    }
	SelectObject(hImagesDc,hImagesBmp);

    hNextDc = CreateCompatibleDC(hDc);
    hNextBmp = CreateCompatibleBitmap(hDc,64,64);
    SelectObject(hNextDc,hNextBmp);
	bActive = TRUE;
	return TRUE;
}

//===========================
BOOL FreeApplication()
{
	ReleaseDC(hWnd ,hDc);
	DeleteDC(hBackDc);
	DeleteObject(hBackBmp);
	DeleteDC(hImagesDc);
	DeleteObject(hImagesBmp);
    DeleteObject(hNextBmp);
    DeleteDC(hNextDc);
	return TRUE;
}

//==================
int Flip()
{
	BitBlt(hDc,MAGRIN_LEFT,MAGRIN_TOP,SCENE_WIDTH,SCENE_HEIGHT,
		hBackDc,0,0,SRCCOPY);

    BitBlt(hDc, MAGRIN_LEFT+ 12*16+ 10,MAGRIN_TOP+ 20,
           64,64,hNextDc,0,0,SRCCOPY);
	return 0;
}

//================
int GameLoop()
{
    DWORD dwTime;

	if(GameState == GS_PLAY){
		KeyProc();
        dwTime = GetTickCount();
        if ((dwTime - Player.dwTimeLamp)>500){
            Player.dwTimeLamp = dwTime;
		    CheckDrop();
        }
	}
    DrawMap();
	Flip();
	return 0;
}

//============
int KeyProc()
{
    
	if (GetAsyncKeyState(VK_UP)>0x80000000)
    {
        if (!KeyState.KeyUpDown ) 
        {
            // Key Up Down
            //MessageBox(hWnd,"Key Up Down","Hello!",MB_OK);
            ShiftSheet();
            KeyState.KeyUpDown = TRUE;
          }
    }
    else {
        KeyState.KeyUpDown = FALSE;
    }

    if (GetAsyncKeyState(VK_LEFT)>0x80000000)
    {
        if (!KeyState.KeyLeftDown )
        {
            if (Player.x >0 )
            {
                Player.x--;
                if (!CheckCurrSheet())
                    Player.x++;
            }
            KeyState.KeyLeftDown = TRUE;
            KeyState.dwTimeLeftDown = GetTickCount();
        }
        else if((GetTickCount()-KeyState.dwTimeLeftDown )>TIME_MOVE){
            KeyState.KeyLeftDown = FALSE;
        }
    }
    else{
        KeyState.KeyLeftDown = FALSE;
    }

    if (GetAsyncKeyState(VK_RIGHT)>0x80000000)
    {
        if (!KeyState.KeyRightDown ){
            if (Player.x <11)
            {
                Player.x++;
                if (!CheckCurrSheet())
                    Player.x--;

            }
            KeyState.KeyRightDown = TRUE;
            KeyState.dwTimeRightDown = GetTickCount();
        }
        else if((GetTickCount()-KeyState.dwTimeRightDown )>TIME_MOVE){
            KeyState.KeyRightDown = FALSE;
        }
    }
    else{
        KeyState.KeyRightDown = FALSE;
    }

    if (GetAsyncKeyState(VK_DOWN)>0x80000000)
    {
        if (!KeyState.KeyDownDown ){
            // Key Right Down
            //MessageBox(hWnd,"Key Down Down","Hello!",MB_OK);
            Player.y++;
            if (!CheckCurrSheet())
                Player.y--;
            KeyState.KeyDownDown = TRUE;
            KeyState.dwTimeDDown = GetTickCount();
        }
        else if((GetTickCount()-KeyState.dwTimeDDown )>KEY_PROC_TIME_INTERVAL){
            KeyState.KeyDownDown = FALSE;
        }
    }
    else{
        KeyState.KeyDownDown = FALSE;
    }

    return 0;
}

//============
int CheckDrop()
{
    int i,j,x,y;

    Player.y++;
    if (!CheckCurrSheet()){
        Player.y--;
        for(j=0;j<4;j++){
            for(i=0;i<4;i++){
                if(Player.CurrSheet[i][j]!=0)
                {
                    x = Player.x +i;
                    y = Player.y +j;
                    Map[x][y]= Player.CurrColor;
                }// end if
            }// end for j
        }// end for i
        
        ClearRow();
        if (CheckOver()){
            GameState = GS_GAMEOVER;
            MessageBox(hWnd,"Game Over!",";-)",MB_ICONINFORMATION);
            return 0;
        }

        x = Player.NextSheet;
        CopyMemory(&Player.CurrSheet,SheetsAddrTab[x],16);
        Player.CurrColor = Player.NextColor;
        Player.NextSheet = rand() % MAX_SHEET;
        Player.NextColor = (rand() % MAX_COLOR) +1;
        Player.x = 4;
        Player.y = 0;
        DrawNext();
    }

	return 0;
}

//======================
int NewGame()
{
	int n;

	ZeroMemory(Map,12*20);
	ZeroMemory(&Player ,sizeof(CPlayer));
	
    n = rand() % MAX_SHEET; // 0 to 6
    CopyMemory(Player.CurrSheet ,SheetsAddrTab[n],16 );

    Player.CurrColor = (rand() % MAX_COLOR)+1; // 1 to 4
    Player.NextSheet = rand() % MAX_SHEET;
    Player.NextColor = (rand() % MAX_COLOR)+1; // 1 to 4
    Player.x = 4;
    Player.y = 0;
    Player.dwScore1 = 0;
    Player.dwScore2 = 0;
    Player.dwTimeLamp = GetTickCount();

    GameState = GS_PLAY;
    DrawNext();
	return 0;
}

//=============================
int SuspendGame()
{
	return 0;
}
//=============================
int ResumeGame()
{
	return 0;
}
//=============================

int DrawMap()
{
    int i,j,x,y,n;

    //BitBlt(hBackDc,0,0,80,16,hImagesDc,0,0,SRCCOPY);

    for(j= 0;j<20;j++)
    {
        x = 0;
        for(i= 0;i<12;i++)
        {
            n = Map[i][j];
            n *= 16;
            x = i*16;
            y = j*16;
            BitBlt(hBackDc,x,y,16,16,hImagesDc,n,0,SRCCOPY);
        }// end for i
    }// end for j

    // Draw CurrSheet
    //if (GameState != GS_PLAY) return 0;

    n = Player.CurrColor *16;
    for(j= 0;j<4;j++)
    {
        for(i= 0;i<4;i++)
        {
            if (Player.CurrSheet[i][j]!= 0)
            {
                x = (Player.x +i) * 16;
                y = (Player.y +j) * 16;
                BitBlt(hBackDc,x,y,16,16,hImagesDc,n,0,SRCCOPY);
            }
        }
    }

    //TextOut(hBackDc,0,0,"fdsafdsafd\0",-1);

    return 0;

}

//===================================

int ShiftSheet()
{
    BYTE tmpSheet[4][4];
    int i,j,n,x,y;

    for(j=0;j<4;j++){
        for(i=0;i<4;i++){
            tmpSheet[i][j]= Player.CurrSheet[j][3-i];
        }
    }
    
    n=0;
    for(i=0;i<4;i++){
        for(j= 0;j<4;j++)
            if (tmpSheet[i][j]!= 0) goto ExitFor;
        
        n++;
    }
ExitFor:
    // Left Clear
    if (n!= 0){
        for(i=n;i<4;i++){
            for(j=0;j<4;j++){
                tmpSheet[i-n][j]= tmpSheet[i][j];
                tmpSheet[i][j]= 0;
            }
        }
    }
    
    // Check Can Shift
    for(j=0;j<4;j++){
        for(i=0;i<4;i++){
            if(tmpSheet[i][j]!= 0)
            {
                x = Player.x +i;
                y = Player.y +j;
                if((x>11)||(y>19)) return 1;
                if(Map[x][y]!= 0) return 1;
            }
        }
    }

    CopyMemory(Player.CurrSheet ,tmpSheet,16);

    return 0;
}

//=================
BOOL CheckCurrSheet()
{
    int x,y,i,j;

    for(j=0;j<4;j++){
        for(i=0;i<4;i++){
            if (Player.CurrSheet[i][j]!=0)
            {
                x = Player.x +i;
                y = Player.y +j;
                if ((x >11)||(y>19) ) return FALSE;
                if (Map[x][y]!= 0) return FALSE;
            }
        }
    }

    return TRUE;
}

//======================================
int ClearRow()
{
    int y,y1,i,bOk;
    char Buf[256];

    y = y1 = 19;
    for(y=19;y>=0;y--){
        bOk = TRUE;
        for(i=0;i<12;i++){
            if (Map[i][y]==0) bOk = FALSE;
        }

        if(bOk){ // Delete Row
            for(y1= y;y1>0;y1--){
                for(i=0;i<12;i++){
                    Map[i][y1]= Map[i][y1-1];
                }
            }
            Player.dwScore1 ++;
            Player.dwScore2 +=100;
            wsprintf(Buf,"%d",Player.dwScore2 );
            SetDlgItemText(hWnd,IDC_SCORE1,Buf);
            wsprintf(Buf,"%d",Player.dwScore1 );
            SetDlgItemText(hWnd,IDC_SCORE2,Buf);
            wsprintf(Buf,"%d",Player.Level );
            SetDlgItemText(hWnd,IDC_SPEED,Buf);
            y++;
        }
       
    }// end for y
    return 0;
}

//=======================================
BOOL CheckOver()
{
    BOOL bResult;
    int x;

    bResult = FALSE;
    for(x= 0;x<12;x++){
        if (Map[x][0]!=0) bResult = TRUE;
    }
    return bResult;
}

//=======================
int DrawNext()
{
    int i,j;
    int n;
    BYTE tmpSheet[4][4];
    RECT R;
    HBRUSH hNewBrush;

    hNewBrush = CreateSolidBrush(0x0);
    R.left = 0;
    R.top = 0;
    R.right = 64;
    R.bottom = 64;
    FillRect(hNextDc,&R,hNewBrush);
    DeleteObject(hNewBrush);

    n = Player.NextColor *16;
    CopyMemory(tmpSheet,SheetsAddrTab[Player.NextSheet],16);

    for(i=0;i<4;i++){
        for(j=0;j<4;j++){
            if(tmpSheet[i][j]!= 0){
                BitBlt(hNextDc,i*16,j*16,16,16,hImagesDc,n,0,SRCCOPY);
            }
        }
    }

    return 0;
}