我的俄罗斯方块,WI32,GDI

#include <Windows.h>
#include <time.h>
#include <iostream>
using namespace std;

HWND hwnd;
#define UUMLINES ((int)(sizeof devcaps/sizeof devcaps[0]))//注意加空格
#define W 12
#define H 20
#define CELL 30
#if(1)
//block_shap ,0--19,1+2+8+4+5
#define BLOCKS_NUM 19
#define BLOCK_SHAPE_O   0
#define BLOCK_SHAPE_I_1 1
#define BLOCK_SHAPE_I_2 2
#define BLOCK_SHAPE_L_0 3
#define BLOCK_SHAPE_L_1 4
#define BLOCK_SHAPE_L_2 5
#define BLOCK_SHAPE_L_3 6
#define BLOCK_SHAPE_L_4 7
#define BLOCK_SHAPE_L_5 8
#define BLOCK_SHAPE_L_6 9
#define BLOCK_SHAPE_L_7 10
#define BLOCK_SHAPE_S_0 11
#define BLOCK_SHAPE_S_1 12
#define BLOCK_SHAPE_S_2 12
#define BLOCK_SHAPE_S_3 14
#define BLOCK_SHAPE_T_0 15
#define BLOCK_SHAPE_T_1 16
#define BLOCK_SHAPE_T_2 17
#define BLOCK_SHAPE_T_3 18
#endif

#define MAP_NONE 0
#define MAP_LAND 1
#define MAP_BLOCK 2

#define MOVE_TIME 200
#define REFRESH_TIME 33
#define CHANGE_TIME  150

#define STATE_DOWN 0
#define STATE_LEFT 1
#define STATE_RIGHT 2
#define STATE_LAND 3
#define STATE_CHANGESHAPE 4

#define SCORE_EACH 5
#define COLOR_BK RGB(255,255,255)
#define COLOR_BLOCK RGB(0,0,0)
class Clock
{
public:
void Init()
{
curtime = GetTickCount();
pretime = curtime;
premovetime = curtime;
curmovetime = curtime;
curchangtime = curtime;
prechangetime = curtime;
}
bool isRefresh()
{
curtime = GetTickCount();
if (curtime - pretime > REFRESH_TIME)
{
pretime = curtime;
return true;
}
else
return false;
}
bool isChangeShape()
{
curchangtime = GetTickCount();
if (curchangtime - prechangetime > CHANGE_TIME)
{
prechangetime = curchangtime;
return true;
}
else
return false;
}
bool isMove()
{
curmovetime = GetTickCount();
if (curmovetime - premovetime > MOVE_TIME)
{
premovetime = curmovetime;
return true;
}
else
return false;
}
private:
clock_t curtime;
clock_t pretime;
clock_t curmovetime;
clock_t premovetime;
clock_t curchangtime;
clock_t prechangetime;
};
void VerCpy(int dest[BLOCKS_NUM][4][4], int source[BLOCKS_NUM][4][4])
{
memcpy(dest, source, 4 * 4 * BLOCKS_NUM*sizeof(int));
}
class Point
{
public:
int x;
int y;
};
class Block
{
private:
int shape_num;//0-18,共19个
int shape_num_width[BLOCKS_NUM];//记录每种状态的宽度
int shape_num_height[BLOCKS_NUM];
int shape_state_size[5];//分别为1,2,8,4,4,共19
int blocks[BLOCKS_NUM][4][4];
Point pos;
enum block_state
{
DOWN,LEFT,RIGHT,LAND,CHANGESHAPE
}blockstate;
public:
void BlockDistribute()
{
pos.x = W / 2;
pos.y = -4;
srand((unsigned int)time(NULL));
shape_num = rand()%BLOCKS_NUM;///0-19
ChangeBlockState(STATE_DOWN);
}
void Init()
{
#if(1)
int temp_blocks[BLOCKS_NUM][4][4]=
{
{
{1,1,0,0},
{1,1,0,0},
{0,0,0,0},
{0,0,0,0}
},//1
{
{ 1, 0, 0, 0 },
{ 1, 0, 0, 0 },
{ 1, 0, 0, 0 },
{ 1, 0, 0, 0 }
},//2
{
{ 1, 1, 1, 1 },
{ 0, 0, 0, 0 },
{ 0, 0, 0, 0 },
{ 0, 0, 0, 0 }
},//3
{
{ 1, 0, 0, 0 },
{ 1, 0, 0, 0 },
{ 1, 1, 0, 0 },
{ 0, 0, 0, 0 }
},//4
{
{ 0, 0, 1, 0 },
{ 1, 1, 1, 0 },
{ 0, 0, 0, 0 },
{ 0, 0, 0, 0 }
},//5
{
{ 1, 1, 0, 0 },
{ 0, 1, 0, 0 },
{ 0, 1, 0, 0 },
{ 0, 0, 0, 0 }
},//6
{
{ 1, 1, 1, 0 },
{ 1, 0, 0, 0 },
{ 0, 0, 0, 0 },
{ 0, 0, 0, 0 }
},//7
{
{ 0, 1, 0, 0 },
{ 0, 1, 0, 0 },
{ 1, 1, 0, 0 },
{ 0, 0, 0, 0 }
},//8
{
{ 1, 1, 1, 0 },
{ 0, 0, 1, 0 },
{ 0, 0, 0, 0 },
{ 0, 0, 0, 0 }
},//9
{
{ 1, 1, 0, 0 },
{ 1, 0, 0, 0 },
{ 1, 0, 0, 0 },
{ 0, 0, 0, 0 }
},//10
{
{ 1, 0, 0, 0 },
{ 1, 1, 1, 0 },
{ 0, 0, 0, 0 },
{ 0, 0, 0, 0 }
},//11
{
{ 0, 1, 1, 0 },
{ 1, 1, 0, 0 },
{ 0, 0, 0, 0 },
{ 0, 0, 0, 0 }
},//12
{
{ 1, 0, 0, 0 },
{ 1, 1, 0, 0 },
{ 0, 1, 0, 0 },
{ 0, 0, 0, 0 }
},//13
{
{ 1, 1, 0, 0 },
{ 0, 1, 1, 0 },
{ 0, 0, 0, 0 },
{ 0, 0, 0, 0 }
},//14
{
{ 0, 1, 0, 0 },
{ 1, 1, 0, 0 },
{ 1, 0, 0, 0 },
{ 0, 0, 0, 0 }
},//15
{
{ 0, 1, 0, 0 },
{ 1, 1, 1, 0 },
{ 0, 0, 0, 0 },
{ 0, 0, 0, 0 }
},//16
{
{ 0, 1, 0, 0 },
{ 1, 1, 0, 0 },
{ 0, 1, 0, 0 },
{ 0, 0, 0, 0 }
},//17
{
{ 1, 1, 1, 0 },
{ 0, 1, 0, 0 },
{ 0, 0, 0, 0 },
{ 0, 0, 0, 0 }
},//18
{
{ 1, 0, 0, 0 },
{ 1, 1, 0, 0 },
{ 1, 0, 0, 0 },
{ 0, 0, 0, 0 }
},//19
};
#endif
memcpy(blocks,temp_blocks, 4 * 4 * BLOCKS_NUM*sizeof(int));
int temp_num_width[BLOCKS_NUM] = { 2, 1, 4, 2, 3, 2, 3, 2, 3, 2, 3, 3, 2, 3, 2, 3, 2, 3, 2 };
memcpy(shape_num_width, temp_num_width, BLOCKS_NUM*sizeof(int));
int temp_shape_state_size[5] = { 0, 2, 10, 14, 18 };
memcpy(shape_state_size, temp_shape_state_size, 5 * sizeof(int));
int temp_shape_state_heigth[BLOCKS_NUM] = { 2, 4, 1, 3, 2, 3, 2, 3, 2, 3, 2, 2, 3, 2, 3, 2, 3, 2, 3 };
memcpy(shape_num_height, temp_shape_state_heigth, BLOCKS_NUM*sizeof(int));
pos.x = W / 2;
pos.y = -4;
blockstate = DOWN;
srand((unsigned int)time(NULL));
shape_num = rand() % BLOCKS_NUM ;
}
void ChangeShape()
{
if (shape_num > BLOCK_SHAPE_O)
{
int key;
//	int minnum;
for (key = 0; key < 5; key++)
{
if (shape_state_size[key] >= shape_num)
break;
}
if ((++shape_num)>shape_state_size[key])
shape_num = shape_state_size[key - 1] + 1;
}
else
return;

}
int GetNextShapeNum()
{
if (shape_num > BLOCK_SHAPE_O)
{
int key;
//	int minnum;
for (key = 0; key < 5; key++)
{
if (shape_state_size[key] >= shape_num)
break;
}
if ((shape_num + 1)>shape_state_size[key])
return shape_state_size[key - 1] + 1;
else
return shape_num + 1;
}
else
return shape_num;
}

void ChangeBlockState(int STATE)
{
switch (STATE)
{
case STATE_DOWN:
blockstate = DOWN;
break;
case STATE_LEFT:
blockstate = LEFT;
break;
case STATE_RIGHT:
blockstate = RIGHT;
break;
case STATE_CHANGESHAPE:
blockstate = CHANGESHAPE;
break;
case STATE_LAND:
blockstate = LAND;
break;
}
}
int GetBlockState()
{
switch (blockstate)
{
case DOWN:
return STATE_DOWN;
break;
case LEFT:
return STATE_LEFT;
break;
case RIGHT:
return STATE_RIGHT;
break;
case LAND:
return STATE_LAND;
break;
case CHANGESHAPE:
return STATE_CHANGESHAPE;
break;
}
return DOWN;
}
int GetShapenum()
{
return shape_num;
}
int GetShapeWidth(int num)
{
return shape_num_width[num];
}
int GetShapeHeigt(int num)
{
return shape_num_height[num];
}
void GetBlockShape(int m[4][4],int number)
{
memcpy(m, blocks[number], 16 * sizeof(int));
}
Point GetPos()
{
return pos;
}
void LeftMove()
{
pos.x--;
///	if (pos.x <= 0)
//	pos.x = 0;
}
void RightMove()
{
pos.x++;
//	if (pos.x >=W-1)
//	pos.x = W-1;
}
void DownMove()
{
pos.y++;
//	if (pos.y >= H - 1)
//	pos.y = H - 1;
}

};
class GameSystem
{
private:
int map[H][W];
int color[2];//背景,砖块
int score;//line的可次方,linescore  = 5
int speed;//特指砖块移动速度,定义为1,即没0.5s移动1格
Block block;
Clock clock;
WCHAR strings[100];
public:
void Init()
{
for (int i = 0; i < H; i++)
{
for (int j = 0; j < W; j++)
{
map[i][j] = MAP_NONE;
}
}
color[0] = 0;
color[1] = 1;
score = 0;
int speed = 1;
clock.Init();
block.Init();

Render();
}

void InsertBlock()
{
int shapenum = block.GetShapenum();
int shape[4][4] = { 0 };
Point pos = block.GetPos();
int hidelen = ((pos.y < 0) ? -pos.y : 0);

if (hidelen == 4)
return;

block.GetBlockShape(shape, shapenum);

for (int i = hidelen; i < 4; i++)
{
for (int j = 0; j < 4; j++)
{
if (shape[i][j])
map[pos.y + i][pos.x + j] = MAP_BLOCK;
}
}
//gai
if (block.GetBlockState() == STATE_LAND)
{
FixMap();
score += Checkline() * 10;
block.BlockDistribute();
}
}
void RefreshMap()
{
for (int i = 0; i < H; i++)
{
for (int j = 0; j < W; j++)
{
if (map[i][j] == MAP_BLOCK)
map[i][j] = MAP_NONE;
}
}
}
void FixMap()
{
//经过判断砖块应该插入地图,成为地图一部分
for (int i = 0; i < H; i++)
{
for (int j = 0; j < W; j++)
{
if (map[i][j] == MAP_BLOCK)
map[i][j] = MAP_LAND;
}
}
}
bool isOkToDo(int state)
{
//准备阶段
Point pos = block.GetPos();
int shape[4][4] = { 0 };
int shapenum = block.GetShapenum();
int shapewidth ;
int shapeheight;
int nextshapenum;
switch (state)//先判断特殊,再一起判断常规--碰撞
{
case STATE_DOWN:
//先判断底部
shapeheight = block.GetShapeHeigt(shapenum);
shapewidth = block.GetShapeHeigt(shapenum);
if (shapeheight + pos.y >= H)
return false;
block.GetBlockShape(shape, shapenum);
pos.y++;//gai
break;

case STATE_LEFT:
//需要修改pos.x,获取当前shape
if (pos.x <= 0)
return false;
else
pos.x--;

shapeheight = block.GetShapeHeigt(shapenum);
shapewidth = block.GetShapeHeigt(shapenum);
block.GetBlockShape(shape, shapenum);
break;
case STATE_RIGHT://与右边墙壁
shapewidth= block.GetShapeWidth(shapenum);

if (pos.x + shapewidth >= W)
return false;
else
pos.x++;
shapeheight = block.GetShapeHeigt(shapenum);
block.GetBlockShape(shape, shapenum);
break;
case STATE_CHANGESHAPE://右,下特殊
//右
nextshapenum = block.GetNextShapeNum();
shapewidth = block.GetShapeWidth(nextshapenum);
shapeheight = block.GetShapeHeigt(nextshapenum);

if (nextshapenum == BLOCK_SHAPE_O)
return false;
if (pos.x + shapewidth >= W)
return false;
//下
else if (pos.y + shapeheight > H)
return false;
else
shapenum = nextshapenum;

block.GetBlockShape(shape,shapenum);
break;
}
//根据地图判断一般情况--砖块碰撞

int hidelen = ((pos.y < 0) ? -pos.y : 0);

if (hidelen == 4)
return true;

block.GetBlockShape(shape, shapenum);
for (int i = hidelen; i < shapeheight; i++)
{
for (int j = 0; j < 4; j++)
{
if (map[pos.y + i][pos.x + j] + shape[i][j] >= 2)
return false;
}
}

return true;
}
int Checkline()
{
int lines = 0;
//经过判断砖块应该插入地图,成为地图一部分
for (int i = H-1; i >=0; i--)
{
int count = 0;
for (int j = 0; j < W; j++)
{
count += map[i][j];
}
if (count == W)
{
lines++;
for (int k = i; k > 0; k--)
{
for (int j = 0; j < W; j++)
{
if (k == 0)
map[k][j] = 0;
else
map[k][j] = map[k - 1][j];
}
}
i++;
}
}
return lines;
}
void Chargeblock()
{
//	int temp_block[4][4] = { 0 };
switch (block.GetBlockState())
{
case STATE_DOWN:
if (clock.isMove())
{
if (isOkToDo(STATE_DOWN))
{
block.DownMove();
}
else
block.ChangeBlockState(STATE_LAND);
}
break;
case STATE_LAND:
//	FixMap();
//score += Checkline() * 10;
//block.BlockDistribute();

break;
case STATE_LEFT:
//判断是否可以左,可以则左移,否则,不变,状态也要做出相应的改变
if (clock.isMove())
{
if (isOkToDo(STATE_LEFT))
{
block.LeftMove();
}
}
block.ChangeBlockState(STATE_DOWN);
break;
case STATE_RIGHT:
if (clock.isMove())
{
if (isOkToDo(STATE_RIGHT))
{
block.RightMove();
}
}
block.ChangeBlockState(STATE_DOWN);
break;
case STATE_CHANGESHAPE:
if (isOkToDo(STATE_CHANGESHAPE)&&clock.isChangeShape())
{
block.ChangeShape();
}
block.ChangeBlockState(STATE_DOWN);
break;
}
}

void DrawRectangle(int x1, int y1, int x2, int y2, COLORREF c)
{
HDC hdc;
HBRUSH hbrush;
RECT rect;
SetRect(&rect, x1, y1, x2, y2);

hbrush = CreateSolidBrush((COLORREF)c);
hdc = GetDC(hwnd);
FillRect(hdc, &rect, hbrush);
ReleaseDC(hwnd, hdc);
DeleteObject(hbrush);
}
void DrawText(TCHAR* text, int x, int y, COLORREF c)
{
HDC hdc;
hdc = GetDC(hwnd);
SetTextColor(hdc,(COLORREF)c);
SetBkMode(hdc, TRANSPARENT);
TextOut(hdc, x, y, text, lstrlen(text));
ReleaseDC(hwnd, hdc);
}
void Render()
{
for (int i = 0; i < H; i++)
{
for (int j = 0; j < W; j++)
{
int y = i*CELL;
int x = j*CELL;

switch (map[i][j])
{
case MAP_NONE:
DrawRectangle(x, y, x + CELL, y + CELL,RGB(0,0,0));
break;
case MAP_BLOCK:
DrawRectangle(x, y, x + CELL, y + CELL, RGB(255,0,0));
break;
case MAP_LAND:
DrawRectangle(x, y, x + CELL, y + CELL, RGB(255, 0, 0));
break;
}
}
}
wsprintf(strings, TEXT("score:%d"), score);
DrawText(strings, CELL , CELL, RGB(0, 255, 0));
}
void Sendstate(int state)
{
//if ((state!=-1)&&clock.isMove())
if (state!=-1)
block.ChangeBlockState(state);
}
void Gamemain(int state)
{
RefreshMap();
Sendstate(state);
Chargeblock();
InsertBlock();

if (clock.isRefresh())
{
Render();
}
}

};
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE prevInstance, PSTR szCmdLine, int iCmdShow)
{
static TCHAR szAppName[] = TEXT("DevCaps1");
GameSystem game;
MSG msg = { 0 };
WNDCLASS wndclass;
wndclass.style = CS_HREDRAW | CS_VREDRAW;// | CS_OWNDC;
wndclass.lpfnWndProc = WndProc;
wndclass.cbClsExtra = 0;
wndclass.cbWndExtra = 0;
wndclass.hInstance = hInstance;
wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
wndclass.hCursor = LoadCursor(NULL, IDC_APPSTARTING);
wndclass.hbrBackground = (HBRUSH)(GetStockObject(WHITE_BRUSH));
wndclass.lpszMenuName = NULL;
wndclass.lpszClassName = szAppName;

if (!RegisterClass(&wndclass))
{
MessageBox(NULL, TEXT("窗口创建需要WINNT"), szAppName, MB_ICONERROR);
return 0;
}
hwnd = CreateWindow(szAppName, TEXT("eluosifangkuai"), WS_DLGFRAME | WS_POPUP,200,20, W*CELL,H*CELL, NULL, NULL, NULL, NULL);
ShowWindow(hwnd, iCmdShow);
UpdateWindow(hwnd);

game.Init();
int state = -1;
while (msg.message != WM_QUIT)
{
if (PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
else
{
if (GetAsyncKeyState(VK_UP))
state = STATE_CHANGESHAPE;
if (GetAsyncKeyState(VK_LEFT))
state = STATE_LEFT;
if (GetAsyncKeyState(VK_RIGHT))
state = STATE_RIGHT;

game.Gamemain(state);
state = -1;

}

}
return msg.wParam;
}

LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
static int cxChar, cxCaps, cyChar;

//	int status;
//	TCHAR szBuffer[10];
HDC hdc;
//	int i;
PAINTSTRUCT ps;
//	TEXTMETRIC tm;
//	RECT rect;

switch (message)
{
case WM_CREATE:
hdc = GetDC(hwnd);

ReleaseDC(hwnd, hdc);
return 0;
case WM_KEYDOWN:
switch (VK_UP)
{
case VK_UP :
SendMessage(hwnd, WM_KEYDOWN, VK_UP, 0);
break;

case VK_DOWN:
SendMessage(hwnd, WM_KEYDOWN, VK_DOWN, 0);
break;

case VK_LEFT:
SendMessage(hwnd, WM_KEYDOWN, VK_LEFT, 0);
break;

case VK_RIGHT:
SendMessage(hwnd, WM_KEYDOWN, VK_RIGHT, 0);
break;
}
case WM_PAINT:

hdc = BeginPaint(hwnd, &ps);
//	SelectObject(ps.hdc, GetStockObject(DC_BRUSH));
EndPaint(hwnd, &ps);
return 0;
case WM_DESTROY:
PostQuitMessage(0);
return 0;

}
return DefWindowProc(hwnd, message, wParam, lParam);
}