基于Pierre Dellacherie的俄罗斯方块-04背景和操作-02

已于 2023-03-16 11:36:22 修改
阅读量43 收藏
点赞数
文章标签： c++ 开发语言
于 2023-03-16 00:31:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014604753/article/details/129574738
版权

基于Pierre Dellacherie的俄罗斯方块-04背景和操作-02

  1. 完善剩下的上下左右的操作

  2. 设置定时器

  3. 消除bug

#pragma once
#include "CBlock.h"
#include "CBackGround.h"
#include <wtypes.h>


class CTetris
{
public:
	CTetris();
	~CTetris();
public:
	//初始化
	void InitGame();
	//显示
	void ShowGame(HDC hdc);

	//显示背景
	void DrawALlBack(HDC hdc);
	//显示大背景下的图形
	void DrawMaxLeft(HDC hdc); 
	//显示小背景下的图形
	void DrawMinRight(HDC hdc);

	//操作小方块
	// 旋转 rotate
	void BlockRotate();
	// 下
	int BlockDown();
	// 左
	void BlockLeft();
	// 右
	void BlockRight();

private:
	//是否可以移动
	bool IsCanMove();
	//结束
	bool IsGameOver();

	CBlock m_cBlock;
	CBackGround m_cBackGround;

	size_t m_nRow;	//小方块的行
	size_t m_nCol;	//小方块的列

	int m_nScore = 0;
};



#include "CTetris.h"

CTetris::CTetris()
{

}

CTetris::~CTetris()
{

}

void CTetris::InitGame()
{
	//初始化小方块
	m_cBlock.RandCreateBlock();
	m_cBlock.RandCreateBlock();

	//初始化背景
	m_cBackGround.InitBackGround();

	m_nRow = 0;
	m_nCol = COL / 2 - 2;

	//把小方块写进大的背景中
	m_cBackGround.WriteBlock2BackGround(m_cBlock, m_nRow, m_nCol, BLOCK_MOVE, BLOCK_MOVE);

}

//显示
void CTetris::ShowGame(HDC hdc)
{
	//显示背景
	DrawALlBack(hdc);
	//显示大背景下的图形
	DrawMaxLeft(hdc);
	//显示小背景下的图形
	DrawMinRight(hdc);
}

void CTetris::DrawALlBack(HDC hdc)
{
	//COL* WIDTH, ROW* HEIGHT
	HGDIOBJ hPenNull = GetStockObject(NULL_PEN);
	HGDIOBJ hBrushGray = GetStockObject(GRAY_BRUSH);

	SelectObject(hdc, hPenNull);
	SelectObject(hdc, hBrushGray);

	//Rectangle(hdc, 0, 0, COL * WIDTH, ROW * HEIGHT);

	Rectangle(hdc, WIDTH, WIDTH * 4, (COL - 1) * WIDTH, ROW * HEIGHT);
	//Rectangle(hdc, 0, 0, COL * WIDTH, ROW * HEIGHT);

	Rectangle(hdc, (COL + 1) * WIDTH, WIDTH * 4, (COL + 9) * WIDTH, ROW * HEIGHT);

	DeleteObject(hBrushGray);
	DeleteObject(hPenNull);

}

//画大背景下的小方块和固定方块

void CTetris::DrawMaxLeft(HDC hdc)
{
	HGDIOBJ hPenBlaCk = GetStockObject(BLACK_PEN);
	HGDIOBJ hBrushWhite = GetStockObject(WHITE_BRUSH);

	SelectObject(hdc, hPenBlaCk);
	SelectObject(hdc, hBrushWhite);


	//获取背景数据
	BACKGROUND BcakGround = m_cBackGround.GetBackGround();
	for (size_t y = 0; y < ROW; y++)
	{
		for (size_t x = 0; x < COL; x++)
		{
			if (BcakGround[y][x] != BLOCK_SPACE && BcakGround[y][x] != BLOCK_WAll)
			{
				//画每一个小方块
				Rectangle(hdc, x * WIDTH, y * HEIGHT, x * WIDTH + WIDTH, y * HEIGHT + HEIGHT);
			}
		}
	}


	DeleteObject(hBrushWhite);
	DeleteObject(hPenBlaCk);
}

void CTetris::DrawMinRight(HDC hdc)
{
	HGDIOBJ hPenBlaCk = GetStockObject(BLACK_PEN);
	HGDIOBJ hBrushWhite = GetStockObject(WHITE_BRUSH);

	SelectObject(hdc, hPenBlaCk);
	SelectObject(hdc, hBrushWhite);


	//画右边的下一个方块
	BLOCKDATE BlockDate = m_cBlock.GetNextBlock();

	for (size_t y = 0; y < BLOCK_ROW; y++)
	{
		for (size_t x = 0; x < BLOCK_COL; x++)
		{
			if (BlockDate[y][x] == BLOCK_MOVE)
			{
				//画每一个小方块
				Rectangle(hdc, (COL + 3 + x) * WIDTH, (y + 6) * HEIGHT, (COL + 3 + x) * WIDTH + WIDTH, (y + 6) * HEIGHT + HEIGHT);
			}
		}
	}


	DeleteObject(hBrushWhite);
	DeleteObject(hPenBlaCk);
}

void CTetris::BlockRotate()
{
	m_cBackGround.ClearBlock2BackGround(m_cBlock, m_nRow, m_nCol, BLOCK_MOVE);

	//record
	size_t nIndex = m_cBlock.GetShape();

	m_cBlock.RotateBlock();
	//判断可不可以  Rotate
	if (!IsCanMove())
	{
		m_cBlock.SetShape(nIndex);
	}

	m_cBackGround.WriteBlock2BackGround(m_cBlock, m_nRow, m_nCol, BLOCK_MOVE, BLOCK_MOVE);

}

int CTetris::BlockDown()
{
	m_cBackGround.ClearBlock2BackGround(m_cBlock, m_nRow, m_nCol, BLOCK_MOVE);
	m_nRow++;

	//判断可不可以移动
	if (!IsCanMove())
	{
		m_nRow--;
		m_cBackGround.WriteBlock2BackGround(m_cBlock, m_nRow, m_nCol, BLOCK_MOVE, BLOCK_FIXED);

		//消行 0-4
		m_cBackGround.RemoveRows();

		//有没有结束
		if (IsGameOver())
		{
			return -1;
		}
		m_cBlock.RandCreateBlock();

		m_nRow = 0;
		m_nCol = COL / 2 - 2;

	}
	m_cBackGround.WriteBlock2BackGround(m_cBlock, m_nRow, m_nCol, BLOCK_MOVE, BLOCK_MOVE);

	return 0;
}

void CTetris::BlockLeft()
{
	m_cBackGround.ClearBlock2BackGround(m_cBlock, m_nRow, m_nCol, BLOCK_MOVE);
	m_nCol--;
	//判断可不可以移动
	if (!IsCanMove())
	{
		m_nCol++;

	}

	m_cBackGround.WriteBlock2BackGround(m_cBlock, m_nRow, m_nCol, BLOCK_MOVE, BLOCK_MOVE);
}

void CTetris::BlockRight()
{
	m_cBackGround.ClearBlock2BackGround(m_cBlock, m_nRow, m_nCol, BLOCK_MOVE);
	m_nCol++;
	//判断可不可以移动
	if (!IsCanMove())
	{
		m_nCol--;

	}

	m_cBackGround.WriteBlock2BackGround(m_cBlock, m_nRow, m_nCol, BLOCK_MOVE, BLOCK_MOVE);

}

bool CTetris::IsCanMove()
{
	//获取背景数据
	BACKGROUND BcakGround = m_cBackGround.GetBackGround();

	//画右边的下一个方块
	BLOCKDATE BlockDate = m_cBlock.GetCurrentBlock();

	for (size_t y = 0; y < BLOCK_ROW; y++)
	{
		for (size_t x = 0; x < BLOCK_COL; x++)
		{
			if (BlockDate[y][x] == BLOCK_MOVE && (BcakGround[y + m_nRow][x + m_nCol] == BLOCK_WAll || BcakGround[y + m_nRow][x + m_nCol] == BLOCK_FIXED))
			{
				return false;
			}
		}
	}
	return true;
}

bool CTetris::IsGameOver()
{
	//获取背景数据
	BACKGROUND BcakGround = m_cBackGround.GetBackGround();

	for (size_t x = 1; x < COL -1 ; x++)
	{
		if (BcakGround[3][x] == BLOCK_FIXED)
		{
			return true;
		}
	}

	return false;
}



// Project1.cpp : 定义应用程序的入口点。
//

#include "framework.h"
#include "Project1.h"
#include "resource.h"
#include "CBlock.h"
#include "CTetris.h"


#define BLOCK_DOWN_TIMER 1
#define BLOCK_AI_TIMER	2
#define BLOCK_DOWN_SPEED 500


#define MAX_LOADSTRING 100

// 全局变量:


CTetris* pTetris = nullptr;
HINSTANCE hInst;                                // 当前实例
WCHAR szTitle[MAX_LOADSTRING];                  // 标题栏文本
WCHAR szWindowClass[MAX_LOADSTRING];            // 主窗口类名

// 此代码模块中包含的函数的前向声明:
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);

int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
	_In_opt_ HINSTANCE hPrevInstance,
	_In_ LPWSTR    lpCmdLine,
	_In_ int       nCmdShow)
{
	UNREFERENCED_PARAMETER(hPrevInstance);
	UNREFERENCED_PARAMETER(lpCmdLine);

	// TODO: 在此处放置代码。
	//srand((unsigned)time(NULL));



	// 初始化全局字符串
	LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
	LoadStringW(hInstance, IDC_PROJECT1, szWindowClass, MAX_LOADSTRING);
	MyRegisterClass(hInstance);

	// 执行应用程序初始化:
	if (!InitInstance(hInstance, nCmdShow))
	{
		return FALSE;
	}

	HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_PROJECT1));

	MSG msg;

	// 主消息循环:
	while (GetMessage(&msg, nullptr, 0, 0))
	{
		if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
	}

	return (int)msg.wParam;
}



//
//  函数: MyRegisterClass()
//
//  目标: 注册窗口类。
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
	WNDCLASSEXW wcex;

	wcex.cbSize = sizeof(WNDCLASSEX);

	wcex.style = CS_HREDRAW | CS_VREDRAW;
	wcex.lpfnWndProc = WndProc;
	wcex.cbClsExtra = 0;
	wcex.cbWndExtra = 0;
	wcex.hInstance = hInstance;
	wcex.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_PROJECT1));
	wcex.hCursor = LoadCursor(nullptr, IDC_ARROW);
	wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
	wcex.lpszMenuName = MAKEINTRESOURCEW(IDC_PROJECT1);
	wcex.lpszClassName = szWindowClass;
	wcex.hIconSm = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

	return RegisterClassExW(&wcex);
}

//
//   函数: InitInstance(HINSTANCE, int)
//
//   目标: 保存实例句柄并创建主窗口
//
//   注释:
//
//        在此函数中，我们在全局变量中保存实例句柄并
//        创建和显示主程序窗口。
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
	hInst = hInstance; // 将实例句柄存储在全局变量中

	HWND hWnd = CreateWindowW(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
		600, 300, (COL + 11) * WIDTH, (ROW + 2) * HEIGHT, nullptr, nullptr, hInstance, nullptr);

	if (!hWnd)
	{
		return FALSE;
	}

	ShowWindow(hWnd, nCmdShow);
	UpdateWindow(hWnd);

	return TRUE;
}

//
//  函数: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  目标: 处理主窗口的消息。
//
//  WM_COMMAND  - 处理应用程序菜单
//  WM_PAINT    - 绘制主窗口
//  WM_DESTROY  - 发送退出消息并返回
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	switch (message)
	{
	case WM_TIMER:
	{
		switch (wParam)
		{
		case BLOCK_DOWN_TIMER:
		{
			if (pTetris)
			{
				if (pTetris->BlockDown() == -1)
				{
					PostQuitMessage(0);
				}
			}
			InvalidateRect(hWnd, NULL, TRUE);
			return 0;
		}
		break;

		case BLOCK_AI_TIMER:
		{
			return 0;

		}
		break;
		}
	}
	break;
	case WM_KEYDOWN:
	{
		int wmId = LOWORD(wParam);
		switch (wmId)
		{
		case VK_UP:
		{

			if (pTetris)
			{
				pTetris->BlockRotate();
			}
			InvalidateRect(hWnd, NULL, TRUE);
		}
		break;
		case VK_DOWN:
		{

			if (pTetris)
			{
				if (pTetris->BlockDown() == -1)
				{
					PostQuitMessage(0);
				}
			}
			InvalidateRect(hWnd, NULL, TRUE);
		}
		break;
		case VK_LEFT:
		{
			if (pTetris)
			{
				pTetris->BlockLeft();
			}
			InvalidateRect(hWnd, NULL, TRUE);
		}
		break;
		case VK_RIGHT:
		{

			if (pTetris)
			{
				pTetris->BlockRight();
			}
			InvalidateRect(hWnd, NULL, TRUE);
		}
		break;
		default:
			return DefWindowProc(hWnd, message, wParam, lParam);
		}
	}
	break;
	case WM_COMMAND:
	{
		int wmId = LOWORD(wParam);
		// 分析菜单选择:
		switch (wmId)
		{
		case IDM_ABOUT:
			DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
			break;
		case IDM_EXIT:
			DestroyWindow(hWnd);
			break;
		case MENU_START:
		{
			if (pTetris)
			{
				delete pTetris;
				pTetris = nullptr;
			}
			pTetris = new CTetris();
			if (pTetris)
			{
				pTetris->InitGame();
				SetTimer(hWnd, BLOCK_DOWN_TIMER, BLOCK_DOWN_SPEED, NULL);

			}
			InvalidateRect(hWnd, NULL, TRUE);
		}
		break;
		case MENU_PAUSE:
		{
			MessageBox(0, "MENU_PAUSE", "Menu", MB_OKCANCEL);
		}
		break;
		case MENU_EXIT:
		{
			DestroyWindow(hWnd);
			break;
		}
		break;
		case MENU_AI:
		{
			MessageBox(0, "MENU_AI", "Menu", MB_OK);
		}
		break;
		default:
			return DefWindowProc(hWnd, message, wParam, lParam);
		}
	}
	break;
	case WM_PAINT:
	{
		PAINTSTRUCT ps;
		HDC hdc = BeginPaint(hWnd, &ps);
		// TODO: 在此处添加使用 hdc 的任何绘图代码...
		if (pTetris)
		{
			pTetris->ShowGame(hdc);
		}
		EndPaint(hWnd, &ps);
	}
	break;
	case WM_DESTROY:
	{
		KillTimer(hWnd, BLOCK_DOWN_TIMER);
		KillTimer(hWnd, BLOCK_AI_TIMER);
		PostQuitMessage(0);

	}
	break;
	default:
		return DefWindowProc(hWnd, message, wParam, lParam);
	}
	return 0;
}

// “关于”框的消息处理程序。
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
	UNREFERENCED_PARAMETER(lParam);
	switch (message)
	{
	case WM_INITDIALOG:
		return (INT_PTR)TRUE;

	case WM_COMMAND:
		if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
		{
			EndDialog(hDlg, LOWORD(wParam));
			return (INT_PTR)TRUE;
		}
		break;
	}
	return (INT_PTR)FALSE;
}
饮冰1992
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于Pierre Dellacherie算法实现俄罗斯方块的人工智能（python实现）《三》
charming的博客
04-19 1万+
基于Pierre Dellacherie算法实现俄罗斯方块的人工智能（python实现）《三》 本章主要讲述人工智能的实现。先讲解Pierre Dellacherie算法的基本知识，再讲解我是怎么实现的。 一些有趣的背景知识 为啥叫俄罗斯方块？：首先俄罗斯方块是一个俄罗斯人做的，这个无聊的人就是前苏联科学家阿列克谢·帕基特诺夫（铭记前辈） 游戏规则就不说了，不懂的人都是没有童年...
基于Pierre Dellacherie算法实现俄罗斯方块的人工智能.zip
03-18
人工智能（Artificial Intelligence，简称AI）是一种前沿的计算机科学技术，其核心目标是通过模拟、延伸和拓展人类智能来构建智能机器与系统。它融合了计算机科学、数学、统计学、心理学、神经科学等多个学科的知识...
基于Pierre Dellacherie的俄罗斯方块-04背景和操作-01
饮冰的博客
03-14 74
【代码】基于Pierre Dellacherie的俄罗斯方块-04背景和操作-01。
基于Pierre Dellacherie的俄罗斯方块-05Pierre Dellacherie算法
饮冰的博客
03-16 457
下落后的高度，方块最后不能下落之后，方块的重心（也就是中心点的高度），相当于高度越低越安全，我这里并没有记录每一个图形的中心点，统一为高度减去1，如图小方块Z下落之后高度为4，我这里需要重心，我就选择重心 - 1 = 3：消除贡献值=消除行数该方块参与消除的格子数。例如，该情况下消除了2行，该方块提供了2个单位的格子。那么贡献值=2*2=4：行变换数。按行遍历，从哪一行有方块开始计算，边界定义为有方块，从方块到空记作一次变换，从空到有方块在记作一次变化，如图。
基于Pierre Dellacherie的俄罗斯方块-02小方块
饮冰的博客
03-12 98
俄罗斯方块AI
基于Pierre Dellacherie的俄罗斯方块-05Pierre Dellacherie算法02
饮冰的博客
03-16 116
【代码】基于Pierre Dellacherie的俄罗斯方块-05Pierre Dellacherie算法02。
基于Pierre Dellacherie的俄罗斯方块-03背景
饮冰的博客
03-13 58
基于Pierre Dellacherie的俄罗斯方块
基于Pierre Dellacherie算法的俄罗斯方块机器人
wjl_zyl_1314的博客
08-10 3137
主题：基于Pierre Dellacherie算法的俄罗斯方块机器人 前言 有的人说这算是AI，有的人说不算是。我个人认为最多算作是一个轻人工智能。因为我觉得这个机器人的算法写的比较死，不能完全意义上算作人工智能。 背景 做这个机器人的原因，是因为接触到了一个企业（西安葡萄城）举办的趣味比赛。在这个比赛中需要制作一个机器人去玩俄罗斯方块，过程中也会根据自己的得分有攻击的机会（将自己消除的俄罗斯方块添加到对手的棋盘底部），最终存活时间久的玩家获胜。 方法 在这个比赛中，要求玩家制作出的机器人能做到以下两点：
基于PierreDellacherie算法MFC俄罗斯方块
MrGong123的博客
01-24 1572
文章目录一、 系统分析二、 主要函数代码说明三、程序运行界面截图四、程序调试心得体会参考文档： 一、 系统分析 简要概括： 基于对话框实现俄罗斯方块小游戏。可以玩家亲自下，也可以由算法控制自动下。并且能够连接数据库，记录玩家的得分情况以及查看得分记录。 类图： 主要由五个类组成 图1 项目结构图 CGJXDlg类 图 2 GJXDlg类图 表1 CGJXDlg类成员变量 变量类型 变量名 功能描述 Game game; Game类成员变量，用于控制游戏的进行以及调用Game类方法。实现游戏的可视化
TetrisAI--AI玩俄罗斯方块--基于Pierre Dellacherie算法
学习随笔
11-14 3150
摆放一个板块的策略是：板块放置的位置越靠下越好，方块之间越紧密越好，自身对消除行的方块贡献数量越多越好。 不可为了追求消除行数，而去造成过多的空洞，这样也是不合理的。 参数： landingHeight:指当前板块放置之后，板块重心距离游戏区域底部的距离。（也就是小方块的海拔高度） erodedPieceCellsMetric:这是消除参数的体现，他代表的是消除的行数与当前摆放的板块中被...
人工智能大作业，一个俄罗斯方块，采用了pierre dellacherie算法实现电脑智能堆积俄罗斯方块
03-09
人工智能大作业，一个俄罗斯方块，采用了pierre dellacherie算法实现电脑智能堆积俄罗斯方块，具体情况参考文档
VC6.0 SDK 俄罗斯方块 Pierre Dellacherie AI 人工智能
12-13
SDK 写的俄罗斯方块，人工智能部分参照 Pierre Dellacherie 的 AI。
Qt俄罗斯方块AI版
08-18
C/C++/Qt编写的俄罗斯方块，参考Pierre Dellacherie算法实现的AI功能。支持自定义方块。
harmonyos2-Tetris-DQN:带有深Q网络的俄罗斯方块
07-01
和声2 俄罗斯方块 带有深 Q 网络的俄罗斯方块。...奖励基于原始的俄罗斯方块游戏，但也会在演员活着时给予奖励并在失败时获得奖励。 名称 报酬 活 +1 清除 1 行 +40 清除 2 行 +100 清除 3 行 +300 清除 4 行 +1200
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 987
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 140
BCSP-X 11题 C++代码详解
LeetCode 算法：轮转数组c++
小金牛来了
06-09 666
LeetCode 算法：轮转数组c++
手搓顺序表（C语言）
最新发布
m0_62646213的博客
06-12 1102
顺序表头插头删，尾插尾删，任意位置插入删除的实现和优劣分析
pierre dellacherie
03-16
Pierre Dellacherie是一位法国数学家和概率论家，他在概率论和统计学领域做出了重要贡献。他的研究重点是随机过程和随机分析，他的工作对金融数学和风险管理领域有着重要的影响。他还是法国科学院的成员，并曾担任巴黎第六大学的教授。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值