WIN32 俄罗斯方块

最新推荐文章于 2018-12-24 21:52:35 发布
最新推荐文章于 2018-12-24 21:52:35 发布
阅读量1.6k 收藏 29
点赞数 6
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wwxy1995/article/details/84194599
版权

WIN32 主程序

#include<Windows.h>
#include"Tetris.h"


LRESULT CALLBACK WndProc(HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam);      // 回调函数

// WINAPI 调用约定
// 当前窗口句柄 HINSTANCE hInstance
// 前一个窗口句柄 HINSTANCE hPreInstance
// 指定命令行参数 LPTSTR lpCmdLine
// 窗口显示方式
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPreInstance, LPTSTR lpCmdLine, int nCmdShow)
{
	WNDCLASSEX wc;                           // 初始化窗口类
	wc.cbClsExtra = 0;
	wc.cbSize = sizeof(WNDCLASSEX);
	wc.cbWndExtra = 0;
	wc.hbrBackground = (HBRUSH)COLOR_WINDOW; // 窗口背景颜色
	wc.hCursor = NULL;                       // 鼠标光标
	wc.hIcon = NULL;                         // 窗口大图标
	wc.hIconSm = NULL;                       // 窗口的小图标
	wc.hInstance = hInstance;                // 窗口句柄
	wc.lpfnWndProc = WndProc;                // 回调函数地址
	wc.lpszClassName = "Tetris";             // 窗口名字，给操作系统看的
	wc.lpszMenuName = NULL;                  // 菜单名字
	wc.style = CS_HREDRAW | CS_VREDRAW;      // 窗口风格(垂直刷新和水平刷新)

	// 12个成员
	

	if (RegisterClassEx(&wc) == 0)              // 注册窗口对象
		return 0;
	HWND hWnd = CreateWindowEx(WS_EX_TOPMOST,"Tetris", "俄罗斯方块",
		WS_OVERLAPPEDWINDOW,100,100,500,650,NULL,
		NULL, hInstance,NULL);                  // 创建窗口
	if (hWnd == NULL)
		return 0;

	ShowWindow(hWnd, nCmdShow);                 // 显示窗口
		
	MSG mSg;                                    // 消息结构体
	
	while (GetMessage(&mSg, NULL, 0, 0))        // 消息循环
	{
		TranslateMessage(&mSg);                 // 翻译消息
		DispatchMessage(&mSg);                  // 分发消息
	}
	
	return 0;
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam)       // 回调函数
{
	PAINTSTRUCT pt;
	HDC hDC;          
	switch (nMsg)
	{
	case WM_CREATE:   // 窗口创建初期只产生一次、
		// 初始化数据
		OnCreate();
		break;

	case WM_PAINT:
		hDC = BeginPaint(hWnd,&pt);       // 窗口可操作区域的标识
		OnPaint(hDC);                     // 绘制界面

		EndPaint(hWnd, &pt);
		break;

	case WM_TIMER:
		OnTimer(hWnd);                    // 定时器相应函数
		break;

	case WM_KEYDOWN:
		switch (wParam)
		{
		case VK_RETURN:
			OnReturn(hWnd);                      // 回车响应函数
			break;
		case VK_LEFT:
			OnLeft(hWnd);                        // 左键响应函数
			break;
		case VK_RIGHT:
			OnRight(hWnd);                       // 右键响应函数
			break;
		case VK_UP:
			OnChangeSquare(hWnd);                // 上键响应函数
			break;
		case VK_DOWN:                            // 下键响应函数
			OnDown(hWnd);
			break;
		}
		break;

	case WM_DESTROY:
		KillTimer(hWnd, DEF_TIMER);                      // 关闭定时器
		PostQuitMessage(0);
		break;


	}
	return DefWindowProc(hWnd, nMsg, wParam, lParam);     // 让系统自动处理一些消息
}

俄罗斯方块声明函数

#pragma once
#include<Windows.h>
#include<stdio.h>
#include<time.h>

#define DEF_TIMER 1234        // 定时器id

void OnPaint(HDC hDc);          //  显示界面
void PaintSquare(HDC hDc);      //  画方块
void CreateRandomSquare();      // 创建随机块
void CopySquareToBack();        // 随机快贴背景
void Change1To2();              // 方块落到最底部将1变为2
void ShowSquare2(HDC  hMemDC);  // 显示底部方块


void OnCreate();                // 创建背景随机块
void OnReturn(HWND hWnd);       // 处理回车按键
void OnTimer(HWND hWnd);        // 定时器响应函数
void OnLeft(HWND hWnd);         // 处理左键
void OnRight(HWND hWnd);        // 处理右键
void OnDown(HWND hWnd);         // 处理下键
void OnChangeSquare(HWND hWnd); // 处理按上键方块变形


int CanSquareDown();           // 0代表方块不可以下落，1代表方块可以下落
int CanSquareDown2();          // 方块下落遇到障碍判断
int CanSquareLeft();           // 判断方块是否能左移
int CanSquareLeft2();          // 判断方块向左移动与存在方块碰撞
int CanSquareRight();          // 判断方块与右墙壁的碰撞
int CanSquareRight2();         // 检查方块与右方块的碰撞
int CanSquareChangeShape();    // 判断方块是否能变形
int CanLineSquareChange();     // 判断长条是否能变形


void SquareDown();             // 方块下落
void SquareLeft();             // 方块左移
void SquareRight();            // 方块右动

void ChangeSquare();           // 方块变形函数
void ChangeLineSquare();       // 长条变形
void DestroyOneLineSquare();   // 消除一行方块
void ShowScore(HDC hHemDC);    // 显示分数
int CanGameOver();             // 游戏结束弹窗

 

具体函数实现

#include "Tetris.h"


char g_arrBackGround[20][10] = { 0 };                   // 背景数组
char g_arrSquare[2][4] = { 0 };                         // 方块类型的小数组
int g_nSquareID;                                        // 方块的类型编号
int g_nLine = -1;                                       // 方块包围盒的左上角行
int g_nList = -1;                                       // 方块包围盒的左上角列
int g_nScore = 0;                                       // 计分

void OnPaint(HDC hDc)
{
	HDC hMemDC = CreateCompatibleDC(hDc);               // 创建兼容性DC
	HBITMAP hBitmapBack = CreateCompatibleBitmap(hDc, 500, 600);    // 创建一张纸
	SelectObject(hMemDC, hBitmapBack);                     // 窗口和纸关联在一起

	PaintSquare(hMemDC);                                // 画方块
	ShowSquare2(hMemDC);                                // 落到底部的方块，画颜色
	ShowScore(hMemDC);                                  // 界面显示分数
	BitBlt(hDc, 0, 0, 500, 600, hMemDC, 0, 0, SRCCOPY); // 内存DC复制到窗口
	

	DeleteObject(hBitmapBack);                          // 释放内存
	DeleteDC(hMemDC);
}

void OnCreate()
{
	srand((unsigned int)time(NULL));                   // 当前系统时间作为随机数种子
	CreateRandomSquare();                              // 创建随机方块
	CopySquareToBack();                                // 将随机方块贴到背景
}

void PaintSquare(HDC hMemDC)
{
	Rectangle(hMemDC, 0, 0, 300, 600);                  // 画矩形框    

	HGDIOBJ hOldBrush;
	HGDIOBJ hNewBrush = CreateSolidBrush(RGB(63, 191, 49));
	hOldBrush = SelectObject(hMemDC, hNewBrush);
	for (int i = 0; i < 20; i++)
	{
		for (int j = 0; j < 10; j++)
		{
			if (g_arrBackGround[i][j] == 1)
			{
				Rectangle(hMemDC, j * 30, i * 30, (j + 1) * 30, (i + 1) * 30);
			}
		}
	}
	hNewBrush = SelectObject(hMemDC, hOldBrush);
	DeleteObject(hNewBrush);

}

void CreateRandomSquare()
{
	int n;
	n = rand() % 7;
	switch (n)
	{
	case 0:
		g_arrSquare[0][0] = 1, g_arrSquare[0][1] = 1, g_arrSquare[0][2] = 0, g_arrSquare[0][3] = 0;
		g_arrSquare[1][0] = 0, g_arrSquare[1][1] = 1, g_arrSquare[1][2] = 1, g_arrSquare[1][3] = 0;
		g_nLine = 0;
		g_nList = 3;
		break;
	case 1:
		g_arrSquare[0][0] = 0, g_arrSquare[0][1] = 1, g_arrSquare[0][2] = 1, g_arrSquare[0][3] = 0;
		g_arrSquare[1][0] = 1, g_arrSquare[1][1] = 1, g_arrSquare[1][2] = 0, g_arrSquare[1][3] = 0;
		g_nLine = 0;
		g_nList = 3;
		break;
	case 2:
		g_arrSquare[0][0] = 1, g_arrSquare[0][1] = 0, g_arrSquare[0][2] = 0, g_arrSquare[0][3] = 0;
		g_arrSquare[1][0] = 1, g_arrSquare[1][1] = 1, g_arrSquare[1][2] = 1, g_arrSquare[1][3] = 0;
		g_nLine = 0;
		g_nList = 3;
		break;
	case 3:
		g_arrSquare[0][0] = 0, g_arrSquare[0][1] = 0, g_arrSquare[0][2] = 1, g_arrSquare[0][3] = 0;
		g_arrSquare[1][0] = 1, g_arrSquare[1][1] = 1, g_arrSquare[1][2] = 1, g_arrSquare[1][3] = 0;
		g_nLine = 0;
		g_nList = 3;
		break;
	case 4:
		g_arrSquare[0][0] = 0, g_arrSquare[0][1] = 1, g_arrSquare[0][2] = 0, g_arrSquare[0][3] = 0;
		g_arrSquare[1][0] = 1, g_arrSquare[1][1] = 1, g_arrSquare[1][2] = 1, g_arrSquare[1][3] = 0;
		g_nLine = 0;
		g_nList = 3;
		break;
	case 5:
		g_arrSquare[0][0] = 0, g_arrSquare[0][1] = 1, g_arrSquare[0][2] = 1, g_arrSquare[0][3] = 0;
		g_arrSquare[1][0] = 0, g_arrSquare[1][1] = 1, g_arrSquare[1][2] = 1, g_arrSquare[1][3] = 0;
		g_nLine = 0;
		g_nList = 4;
		break;
	case 6:
		g_arrSquare[0][0] = 1, g_arrSquare[0][1] = 1, g_arrSquare[0][2] = 1, g_arrSquare[0][3] = 1;
		g_arrSquare[1][0] = 0, g_arrSquare[1][1] = 0, g_arrSquare[1][2] = 0, g_arrSquare[1][3] = 0;
		g_nLine = 0;
		g_nList = 4;
		break;
	}

	g_nSquareID = n;

}

void CopySquareToBack()
{
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			g_arrBackGround[i][j+3] = g_arrSquare[i][j];
		}
	}
}

void OnReturn(HWND hWnd)
{
	SetTimer(hWnd, DEF_TIMER, 400, NULL);       // 直接调用定时器函数
}

void SquareDown()
{
	for (int i = 19; i >= 0; i--)
	{
		for (int j = 0; j < 10; j++)
		{
			if (g_arrBackGround[i][j] == 1)
			{
				g_arrBackGround[i + 1][j] = g_arrBackGround[i][j];
				g_arrBackGround[i][j] = 0;
			}
		}
	}
}

void OnTimer(HWND hWnd)
{
	HDC hDc = GetDC(hWnd);
	if (CanSquareDown() == 1 && CanSquareDown2() == 1)
	{
		SquareDown();             // 如果方块能下落,方块下落
		g_nLine++;
	}
	else
	{              
		Change1To2();             // 当方块落到底部时，将1变为2
		DestroyOneLineSquare();   // 消除方块
		if (CanGameOver() == 0)
		{
			KillTimer(hWnd, DEF_TIMER);
			return;
		}
		CanGameOver();            // 判断游戏结束
		CreateRandomSquare();     // 如果方块落到底部，产生新的方块
		CopySquareToBack();
	}
       
	OnPaint(hDc);
	ReleaseDC(hWnd, hDc);  // 释放

}

int CanSquareDown()
{
	for (int i = 0; i < 10; i++)
	{
		if (g_arrBackGround[19][i] == 1)
		{
			return 0;
		}
	}
	return 1;
}

void Change1To2()
{
	for (int i = 0; i < 20; i++)
	{
		for (int j = 0; j < 10; j++)
		{
			if (g_arrBackGround[i][j] == 1)
			{
				g_arrBackGround[i][j] = 2;
			}
		}
	}
}

void ShowSquare2(HDC  hMemDC)
{
	HGDIOBJ hOldBrush;
	HGDIOBJ hNewBrush = CreateSolidBrush(RGB(233, 27, 182));  // 创建一个画刷
	hOldBrush = SelectObject(hMemDC, hNewBrush);
	for (int i = 0; i < 20; i++)
	{
		for (int j = 0; j < 10; j++)
		{
			if (g_arrBackGround[i][j] == 2)
			{
				Rectangle(hMemDC, j * 30, i * 30, (j + 1) * 30, (i + 1) * 30);
			}
		}
	}
	hNewBrush = SelectObject(hMemDC, hOldBrush);
	DeleteObject(hNewBrush);
}

int CanSquareDown2()
{
	for (int i = 19; i >=0; i--)
	{
		for (int j = 0; j < 10; j++)
		{
			if (g_arrBackGround[i][j] == 1 && g_arrBackGround[i+1][j] == 2)
			{
				return 0;
			}
		}
	}
	return 1;
}

void OnLeft(HWND hWnd)
{
	
	if (CanSquareLeft() == 1 && CanSquareLeft2()==1)
	{
		HDC hDc = GetDC(hWnd);
		SquareLeft();          // 方块向左移
		g_nList--;
		OnPaint(hDc);
		ReleaseDC(hWnd, hDc);
	}
	
}

void SquareLeft()
{
	for (int i = 0; i < 20; i++)
	{
		for (int j = 0; j < 10; j++)
		{
			if (g_arrBackGround[i][j] == 1)
			{
				g_arrBackGround[i][j-1] = g_arrBackGround[i][j];
				g_arrBackGround[i][j] = 0;
			}
		}
	}
}

int CanSquareLeft()
{
	for (int i = 0; i < 20; i++)
	{
		if (1 == g_arrBackGround[i][0])
		{
			return 0;
		}
	}
	return 1;
}

int CanSquareLeft2()
{
	for (int i = 0; i < 20; i++)
	{
		for (int j = 0; j < 10; j++)
		{
			if (g_arrBackGround[i][j] == 1 && g_arrBackGround[i][j - 1] == 2)
				return 0;
		}
	}
	return 1;
}

void OnRight(HWND hWnd)
{
	
	
	if (CanSquareRight() == 1 && CanSquareRight2()==1)
	{
		HDC hDc = GetDC(hWnd);
		SquareRight();
		g_nList++;
		OnPaint(hDc);
		ReleaseDC(hWnd, hDc);
	}
	
}

void SquareRight()
{
	for (int i = 0; i < 20; i++)
	{
		for (int j = 9; j >= 0; j--)
		{
			if (g_arrBackGround[i][j] == 1)
			{
				g_arrBackGround[i][j + 1] = g_arrBackGround[i][j];
				g_arrBackGround[i][j] = 0;
			}
		}
	}
}

int CanSquareRight()
{
	for (int i = 0; i < 20; i++)
	{
		if (g_arrBackGround[i][9] == 1)
		{
			return 0;
		}
	}
	return 1;
}

int CanSquareRight2()
{
	for (int i = 0; i < 20; i++)
	{
		for (int j = 9; j >= 0; j--)
		{
			if (g_arrBackGround[i][j] == 1 && g_arrBackGround[i][j+1]==2)
			{
				return 0;
			}
		}
	}
	return 1;
}

void OnDown(HWND hWnd)
{
	OnTimer(hWnd);
}

void OnChangeSquare(HWND hWnd)
{
	HDC hDc = GetDC(hWnd);
	switch (g_nSquareID)
	{
	case 0:
	case 1:
	case 2:
	case 3:
	case 4:
		if (CanSquareChangeShape() == 1)
			ChangeSquare();
		else
			return;
		break;
	case 5:
		return;          // 正方形不变形
	case 6:
		if (CanLineSquareChange() == 1)
			ChangeLineSquare();

		
		break;
	}

	OnPaint(hDc);
	ReleaseDC(hWnd, hDc);
}

void ChangeSquare()
{
	char arrSquare[3][3] = { 0 };
	
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 3; j++)          // 背景块复制出来
		{
			arrSquare[i][j] = g_arrBackGround[g_nLine + i][g_nList + j];      
		}
	}

	int nTemp;
	for (int i = 0; i < 3; i++)
	{
		nTemp = 2;
		for (int j = 0; j < 3; j++)
		{
			g_arrBackGround[g_nLine + i][g_nList + j] = arrSquare[nTemp][i];
			nTemp--;
		}
	}
}

int CanSquareChangeShape()
{
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			if (g_arrBackGround[g_nLine + i][g_nList + j] == 2)
				return 0;
		}
	}

	if (g_nList < 0)
		g_nList = 0;
	else if (g_nList > 7)
		g_nList = 7;
	return 1;
}

void ChangeLineSquare()
{
	if (g_arrBackGround[g_nLine][g_nList - 1] == 1)
	{
		// 清零
		g_arrBackGround[g_nLine][g_nList - 1] = 0;
		g_arrBackGround[g_nLine][g_nList + 1] = 0;
		g_arrBackGround[g_nLine][g_nList + 2] = 0;

		if (g_arrBackGround[g_nLine + 1][g_nList] == 2)
		{
			g_arrBackGround[g_nLine - 3][g_nList] = 1;
			g_arrBackGround[g_nLine - 2][g_nList] = 1;
			g_arrBackGround[g_nLine - 1][g_nList] = 1;
			//g_nLine -= 2;
			
		}
		else if(g_arrBackGround[g_nLine + 2][g_nList] == 2)
		{
			g_arrBackGround[g_nLine + 1][g_nList] = 1;
			g_arrBackGround[g_nLine - 1][g_nList] = 1;
			g_arrBackGround[g_nLine - 2][g_nList] = 1;
			//g_nLine--;
		
		}
		else
		{
			// 元素赋值
			g_arrBackGround[g_nLine - 1][g_nList] = 1;
			g_arrBackGround[g_nLine + 1][g_nList] = 1;
			g_arrBackGround[g_nLine + 2][g_nList] = 1;
		}
		
	}
	else
	{
		// 清零
		g_arrBackGround[g_nLine - 1][g_nList] = 0;
		g_arrBackGround[g_nLine + 1][g_nList] = 0;
		g_arrBackGround[g_nLine + 2][g_nList] = 0;
		if (g_arrBackGround[g_nLine][g_nList + 1] == 2 || g_nList==9)
		{
			g_arrBackGround[g_nLine][g_nList - 1] = 1;
			g_arrBackGround[g_nLine][g_nList - 2] = 1;
			g_arrBackGround[g_nLine][g_nList - 3] = 1;
			g_nList -= 2;
		}
		else if (g_arrBackGround[g_nLine][g_nList + 2] == 2|| g_nList ==8)
		{
			g_arrBackGround[g_nLine][g_nList + 1] = 1;
			g_arrBackGround[g_nLine][g_nList - 1] = 1;
			g_arrBackGround[g_nLine][g_nList - 2] = 1;
			g_nList -= 2;
		}
		else if (g_arrBackGround[g_nLine][g_nList - 1] == 2 || g_nList == 0)
		{
			g_arrBackGround[g_nLine][g_nList + 1] = 1;
			g_arrBackGround[g_nLine][g_nList + 2] = 1;
			g_arrBackGround[g_nLine][g_nList + 3] = 1;
			g_nList++;
		}

		else
		{
			g_arrBackGround[g_nLine][g_nList - 1] = 1;
			g_arrBackGround[g_nLine][g_nList + 1] = 1;
			g_arrBackGround[g_nLine][g_nList + 2] = 1;
		}
	
		
	}
}

int CanLineSquareChange()
{
	int i, j;
	for (i = 1; i < 4; i++)
	{
		if (g_arrBackGround[g_nLine][g_nList + i] == 2
			|| g_nList+i>9)
		{
			break;
		}
	}
	for (j = 1; j < 4; j++)
	{
		if (g_arrBackGround[g_nLine][g_nList - j] == 2 || g_nList - j < 0)
		{
			break;
		}
	}

	if (i - 1 + j - 1 < 3)
		return 0;
	
	return 1;
	
}

void DestroyOneLineSquare()
{
	int nSum = 0;
	for (int i = 19; i >= 0; i--)
	{
		for (int j = 0; j < 10; j++)
		{
			nSum += g_arrBackGround[i][j];
		}
		if (nSum == 20)
		{
			g_nScore += 10;
			for (int k = i - 1; k >= 0; k--)
			{
				for (int l = 0; l < 10; l++)
				{
					g_arrBackGround[k + 1][l] = g_arrBackGround[k][l];
				}
			}
			i = 20;
		}
		nSum = 0;
	}

}

void ShowScore(HDC hMemDC)
{
	char strScore[10] = { 0 };                                     // 分数字符串
	Rectangle(hMemDC, 300, 0, 500, 600);
	sprintf_s(strScore, "%d", g_nScore, strlen(strScore));
	TextOut(hMemDC, 400, 100, strScore, strlen(strScore));
}

int CanGameOver()
{
	for (int i = 0; i < 10; i++)
	{
		if (g_arrBackGround[0][i] == 2)
		{
			MessageBox(NULL,"GameOver","提示",MB_OK);           // 游戏结束
			return 0;
		}
	}
	return 1;
}

 

 

wwxy261
关注
  • 6
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Win32自制俄罗斯方块，简单易学
qq_52836416的博客
06-16 1131
基于Win32编写俄罗斯方块
win32编程之俄罗斯方块
一蓑烟雨任平生
05-29 3304
因为把目标定在了游戏上，最近在学习win32编程 经过一段时间的学习，开始进行编程实现俄罗斯方块，记录一下其中遇到的一些问题 一开始是看网上的教程学习的，但是做完一部分之后发现   会有闪屏的情况   所以又去网上搜索了一下发现要用到双缓冲。 注意：这段开始正确性有待考证！ 我一开始的时候是把 drawTeris(); drawBackGround(); drawBlocke
win32-c语言实现俄罗斯方块
renaway的博客
02-15 2115
这是我跟着一个视频教程做的。先看效果，后上代码，核心是二维数组(矩阵)的遍历和win32的一些基础，有时间谈谈细节。我使用的是vc++6.0，更高版本也可以，vc++6.0下载地址： http://download.csdn.net/download/richard1997/102522491.打开vs，新建项目：右上角依次打开File-&gt;选择New...      或者直接Ctr+N；2....
VC++ Win32俄罗斯方块游戏源码(新)
08-06
为了挑战一个新的高度，作者原创了他从事WEB编程以来的第一个Win32 API应用，之所以编写一个游戏，是因为游戏考察的知识面很综合，之所以选择俄罗斯方块，一是自己曾被瘾过，二是发现这款游戏几乎包含了Widows入门的很多知识，比如窗口、消息、菜单、工具栏、资源、对话框、计时器、自绘按钮、GDI位图操作、Windows目录操作、INI文件操作等等，拿来练手会收获不少。本游戏是带有背景音乐的，一边玩游戏一边欣赏音乐的感觉相信很舒服。
Win32 API编程入门——俄罗斯方块
05-10
一个经典的小游戏，使用VC6 API开发
WIN32 俄罗斯方块.7z
05-23
《深入解析WIN32平台C++实现的俄罗斯方块游戏》 在计算机编程的世界里，经典的游戏总是能激发初学者的学习兴趣，而俄罗斯方块无疑是其中的佼佼者。本项目是一个基于WIN32 API的C++实现的俄罗斯方块游戏，它为我们...
win32俄罗斯方块
11-29
《win32俄罗斯方块：MFC与Win32 API的编程实践》 "win32俄罗斯方块"是一款基于Microsoft Foundation Classes (MFC) 和Win32 API开发的双人对战版俄罗斯方块游戏，它为初学者提供了一个很好的学习平台，深入理解...
Win32俄罗斯方块
06-07
*这个程序改编[深入体验C语言项目开发].薛小龙. *为方便新同学学习理解我尽量照着原书代码改编成可以在vs2015 vc6.0上运行的程序 就一个源文件直接复制即可运行 程序设计思想都是一样的，其他只要学会windows编程前5...
Win32实现俄罗斯方块
11-15
《Win32实现俄罗斯方块》是一款基于Windows操作系统平台，使用C++编程语言，并通过Win32 API（应用程序接口）开发的小型游戏。Win32 API是微软为开发者提供的一个低级别的接口，允许程序员直接控制操作系统的核心...
C语言 WIN32 窗口实现 俄罗斯方块 Tetris 源代码 第三版
08-29
C语言 WIN32窗口实现 俄罗斯方块Tetris 源代码 游戏支持开始(包括从暂停恢复和结束后重新开始)、暂停、空格键落地及基本功能，玩起来会更好一些。 全部游戏代码都在.c文件，编译即可，windows xp ，VS2010 WIN32下，C编译通过 不想下载代码的同学，可以直接到博客复制代码，放入VS2010 WIN32工程即可：http://blog.csdn.net/goldentimes1/article/details/7987501 第三版： 取消列对齐辅助线，仿照俄罗斯方块流行游戏功能，替换为指示当前方块下落位置，动态，更直观。
win32 实现俄罗斯方块
06-07
win32 用GDI实现俄罗斯方块　源代码
WIN32 工程下的俄罗斯方块
05-28
win32工程创建的俄罗斯方块，此处仅提供必要的文件，其他新建项目自动出现而无更改的头文件，cpp文件等未上传。
Win32汇编写的俄罗斯方块小程序
12-03
Win32汇编写的俄罗斯方块小程序,感兴趣的就下下
俄罗斯方块win32+C语言
03-16
俄罗斯方块，运用win32+C语言实现，内含课件，代码，视频教程
Win32汇编实现俄罗斯方块
06-30
在一个群里面找到的。在一个群里面找到的。在一个群里面找到的。在一个群里面找到的。在一个群里面找到的。
windows下实现win32俄罗斯方块练手，编程的几点心得
weixin_33994444的博客
03-05 479
编程珠玑2阅读笔记： 1.使用c语言性能监视器，完成对代码的调优工作 2.关联数组： 拓扑排序算法，可以用于当存在遮挡的时候决定三维场景的绘制顺序。 3.小型算法中的测试与调试工具 脚手架程序：《人月神话》一个软件产品中应该有一半的代码都是脚手架。 类似，小型的代码库 4.自描述数据 每个程序员都知道破解神秘数据的挫折与艰辛。 5.劈开戈...
基于win32 的俄罗斯方块游戏
Lavener_Love的博客
12-24 910
Windows软件开发大作业——基于win32 的俄罗斯方块游戏 作业要求： 一、将本代码仓库clone到本地 二、运行MyTetris/Tetris.sln代码，开发环境为visual studio 2017 三、参照example/Tetris.cpp来按照如下步骤来完善Tetris.cpp，对如下每一步编译通过，然后commit一次，commit信息填写对应的步骤 1、在项目中动态添加菜单...
c++ win32 API实现方块联机游戏历程.pdf
最新发布
03-10
本文档记录了一位作者通过自学C++和Win32 API实现俄罗斯方块联机游戏的过程。作者从自己的学习背景出发，讲述了如何从一个对C++一知半解的新手逐渐发展到能够独立编写游戏的历程。在大专毕业后，作者在北京接受软件...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值