首页 > 代码库 > 游戏开发（三）——WIN32 黑白棋（一）——棋局逻辑的设计

游戏开发（三）——WIN32 黑白棋（一）——棋局逻辑的设计

2024-07-14 14:44:13   224人阅读

今天以黑白棋为例，开始给一个win32的小游戏设计，

这里打算分3部分介绍

1、棋盘，棋局的现实

2、玩家、AI的现实（且听下回分解）

3、游戏画面的现实（且听下下回分解）


其中第一部分为黑白棋游戏的主要逻辑：

1、棋盘，以及棋盘上的棋子的存储形式。这里用到了位图。

2、是否可以落子的判断（黑白棋是只有你落子的位置，在横竖斜八个方向中任意一个方向，能吃掉对方的子，你才可以落在该位置，八个方向都吃不掉对方子的位置是不能下的），以及吃子的逻辑（吃子的逻辑同样是八个方向，两个己方棋子之间夹住的对方棋子，可以被吃掉，翻转为己方棋子）。这里为了使得代码简介一点，使用了函数指针（不同方向上坐标的变化逻辑不一样）。

3、某一方下了一个子之后，交换手的判断（黑白棋中存在可能，一方下了一个子，并吃掉对方的子，之后对方无子可下，没有一个位置能使得对方能吃掉己方的棋子，所以黑白棋并不一定始终是一人一步来的，它可能存在一方连续落子的情况）。

4、记录玩家每一步下棋的步骤，使得可以悔棋（只悔玩家，不悔AI）。

5、游戏是否结束的判断（由于存在无子可下的情况，有可能双方都无子可以下，即一方将另一方全部吃光，所以黑白棋不一定是下满棋盘才分出胜负）。


第二部分主要为了写AI：

黑白棋的AI其实蛮复杂，有专门的研究黑白棋的AI的算法文章，这里只简单介绍一下，也涉及到几个概念：稳定子、行动力、等，具体在第二部分介绍。


第三部分主要是游戏画面的显示，涉及到windows消息机制，鼠标事件，键盘事件，菜单事件，定时器事件；以及简单的图形、文字绘制，涉及到画笔、画刷填充、绘图层HDC、画线、画圆、显示文字、双缓冲的位图拷贝。

阅读第三部分前，读者可以先行阅读《windows程序设计》一书打个基础。

也可以看完博文之后，再将涉及到的图形API，消息机制等windows程序设计中涉及到的点带回到书中去详细了解。


ps：只看1、3部分，同样可以实现一个黑白棋，只是没有AI，就只能人跟人下


黑白棋游戏在设计中需要注意的几点：

1、惯例，首先要定义好棋盘的坐标，定义为左上角那一格为（0，0），向右为x正方向，向下为y正方向，黑白棋棋盘是一个8*8的棋盘，所以定义两个常量表示：

const int REVERSI_MAX_ROW = 8;
const int REVERSI_MAX_COLUMN = 8;

2、棋盘上棋子的类型分三种：黑子，白子，空白无子，枚举表示

enum EnumReversiPiecesType
{
	enum_ReversiPieces_Null = 0x00,
	enum_ReversiPieces_Black = 0x01,
	enum_ReversiPieces_White = 0x02,
};

这三种情况，其实用2位2进制即可表示，一行8个位置就是16位2进制，就是一个WORD就足够了，所以：

3、棋盘的表示，位图

TArray1<WORD, REVERSI_MAX_ROW> m_Map;

位图是8行，每行是一个WORD，这个TArray1是之前实现的一维数组模板直接用的

4、棋盘上一个位置的设计，因为这里涉及到位置（即坐标）的八方向移动的逻辑，因此将坐标位置单独抽象出来，实现坐标的上下左右以及斜的四方向的坐标变化，然后将其重定义为函数指针，使得后面在坐标变化时，不用switch...case八种情况，而是可以将方向当成参数。 

typedef void (ReversiPoint::*ReversiPointForward)();

5、某一方的棋子，在某一坐标位置，向某一方向，是否可以吃掉对方的棋子的判断

bool ReversiCheck(EnumReversiPiecesType type, char row_y, char column_x, ReversiPointForward forward);
是否可以吃子的伪代码：

定义一个坐标对象point，初值为当前点row_y, column_x
记录该方向上的搜索次数search，初值为0
point向forward方向移动
搜索次数search++
while (point是一个合法的坐标，不能移出棋盘外面去了)
{
	取point当前位置的棋子类型
	（此时已经是forward移动一次之后的位置了，不是row_y, column_x了）
	if (当前位置有棋子)
	{
		if (当前位置的棋子类型等于传入参数type，type就是要下的棋子类型)
		{
			if (搜索次数search大于1次)
			{
				说明找到的同色棋子与当前棋子坐标差超过1，point至少移动了2次
				则两子之间夹有不同色的棋子
				符合翻转规则，return true
			}
			else
			{
				说明找到的同色棋子与当前棋子，两子是紧挨着的
				该方向两子之间无子可以翻转
				不符合翻转规则，return false
			}
		}
		else
		{
			说明找到的是不同色的棋子，继续向下一个位置搜
			point向forward方向移动
			搜索次数search++
		}
	}
	else
	{
		一直找到空位也没找到，该方向没有同色棋子，无法翻转
	}
}
超出棋盘范围都没有找到同色棋子，该方向没有同色棋子，无法翻转

6、某一方的棋子，在某一坐标位置，向某一方向，吃掉对方的棋子

void DoReversi(EnumReversiPiecesType type, char row_y, char column_x, ReversiPointForward forward);

伪代码实现

定义一个坐标对象point，初值为当前点row_y, column_x
point向forward方向移动
while (point是一个合法的坐标，不能移出棋盘外面去了)
{
	取point当前位置的棋子类型
	（此时已经是forward移动一次之后的位置了，不是row_y, column_x了）
	if (当前位置的棋子类型不等于传入参数type，type就是下的棋子类型)
	{
		将该位置的棋子类型翻转为type一方的棋子
		point向forward方向移动
		因为在翻转之前做了ReversiCheck的判断
		即这个方向肯定是符合翻转规则，有子可吃的
		所以这里不再判断当前位置的棋子类型是否为空
	}
}

有了上面两个基本函数

7、判断某个位置是否可以落子

bool ReversiCheck(EnumReversiPiecesType type, char row_y, char column_x);

则是分别调用上面的ReversiCheck，然后forward传入不同的方向

8、判断某一方是否可以落子

bool CanPlay(EnumReversiPiecesType type);
即遍历棋盘每一个位置，任意一个位置可以落子，则该方可以落子

9、落一个子之后的吃子

void DoReversi(EnumReversiPiecesType type, char row_y, char column_x);
则是分别调用上面的DoReversi，然后forward传入不同的方向

10、下棋的步骤，为了可以悔棋

typedef struct ReversiStep
{
	ReversiBitBoard m_LastMap;
	EnumReversiPiecesType m_CurrType;

	ReversiStep& operator= (const ReversiStep& temp)
	{
		m_CurrType = temp.m_CurrType;
		m_LastMap = temp.m_LastMap;

		return *this;
	}
}ReversiStep;

这里直接记录落子之前的棋盘状态，以及当前这一步是谁落得子就可以了，悔棋的时候就是恢复棋盘状态到这个人落子之前的状态，然后仍然由该玩家重新落子

落子的时候，填一下ReversiStep，存入链表，悔棋的时候，从链表尾退出一个节点，并将棋盘状态恢复为这个尾节点的状态，即实现了悔棋

一盘棋总共60步下满，这里用了一个对象池，一次性申请好60步所需内存，这样避免在频繁的落子悔棋的过程中，频繁的申请内存

11、最后，判断游戏是否结束的逻辑，即双方都无子可下，则游戏结束


先给个游戏截图吧


下面先贴出第一部分的代码

ReversiCommon.h

#ifndef _ReversiCommon_h_
#define _ReversiCommon_h_

//棋盘大小
const int REVERSI_MAX_ROW = 8;
const int REVERSI_MAX_COLUMN = 8;

enum EnumReversiPiecesType
{
	enum_ReversiPieces_Null = 0x00,
	enum_ReversiPieces_Black = 0x01,
	enum_ReversiPieces_White = 0x02,
};

enum EnumReversiResult
{
	enum_Reversi_Playing = 0,
	enum_Reversi_Draw,
	enum_Reversi_Win_Black,
	enum_Reversi_Win_White,
};

#endif

ReversiPoint.h

#ifndef _ReversiPoint_h_
#define _ReversiPoint_h_

#include "ReversiCommon.h"

typedef struct ReversiPoint
{
	char m_row_y;
	char m_column_x;

	ReversiPoint& operator= (const ReversiPoint& temp)
	{
		m_row_y = temp.m_row_y;
		m_column_x = temp.m_column_x;
		return *this;
	}

	bool operator!= (const ReversiPoint& temp)
	{
		if (m_row_y == temp.m_row_y &&
			m_column_x == temp.m_column_x)
		{
			return false;
		}
		else
		{
			return true;
		}
	}

	bool IsValid()
	{
		if (0 <= m_row_y &&
			0 <= m_column_x &&
			m_row_y < REVERSI_MAX_ROW &&
			m_column_x < REVERSI_MAX_COLUMN)
		{
			return true;
		}
		else
		{
			return false;
		}
	}

	void UL()
	{
		m_row_y--;
		m_column_x--;
	}

	void U()
	{
		m_row_y--;
	}

	void UR()
	{
		m_row_y--;
		m_column_x++;
	}

	void L()
	{
		m_column_x--;
	}

	void R()
	{
		m_column_x++;
	}

	void DL()
	{
		m_row_y++;
		m_column_x--;
	}

	void D()
	{
		m_row_y++;
	}

	void DR()
	{
		m_row_y++;
		m_column_x++;
	}
}ReversiPoint;

typedef void (ReversiPoint::*ReversiPointForward)();

#endif

ReversiBitBoard.h

#ifndef _ReversiBitBoard_h_
#define _ReversiBitBoard_h_

#include <Windows.h>

#include "TArray.h"

#include "ReversiCommon.h"

class ReversiBitBoard
{
public:
	ReversiBitBoard();
	~ReversiBitBoard();

	ReversiBitBoard& operator= (const ReversiBitBoard& temp);

	void SetPieces(EnumReversiPiecesType type, char row_y, char column_x);

	EnumReversiPiecesType GetPieces(char row_y, char column_x);

	BYTE GetBlackCount();
	BYTE GetWhiteCount();

private:
	TArray1<WORD, REVERSI_MAX_ROW> m_Map;
	BYTE m_BlackCount;
	BYTE m_WhiteCount;
};



#endif

ReversiBitBoard.cpp

#include "ReversiBitBoard.h"

ReversiBitBoard::ReversiBitBoard()
{
	for (int i = 0; i < REVERSI_MAX_ROW; i++)
	{
		m_Map[i] = 0;
	}
	m_BlackCount = 0;
	m_WhiteCount = 0;
}

ReversiBitBoard::~ReversiBitBoard()
{

}

ReversiBitBoard& ReversiBitBoard::operator=(const ReversiBitBoard& temp)
{
	m_Map = temp.m_Map;
	m_BlackCount = temp.m_BlackCount;
	m_WhiteCount = temp.m_WhiteCount;
	return *this;
}

void ReversiBitBoard::SetPieces(EnumReversiPiecesType type, char row_y, char column_x)
{
	WORD oldtype = (m_Map[row_y] & (0x0003 << (column_x * 2))) >> (column_x * 2);
	if (enum_ReversiPieces_Black == oldtype)
	{
		m_BlackCount--;
	}
	else if (enum_ReversiPieces_White == oldtype)
	{
		m_WhiteCount--;
	}

	m_Map[row_y] = m_Map[row_y] & (~(0x0003 << (column_x * 2)));
	m_Map[row_y] = m_Map[row_y] | (type << (column_x * 2));
	if (enum_ReversiPieces_Black == type)
	{
		m_BlackCount++;
	}
	else if (enum_ReversiPieces_White == type)
	{
		m_WhiteCount++;
	}
}

EnumReversiPiecesType ReversiBitBoard::GetPieces(char row_y, char column_x)
{
	WORD value = http://www.mamicode.com/m_Map[row_y] & (0x0003 << (column_x * 2));>
Reversi.h
#ifndef _Reversi_
#define _Reversi_

#include "TBDLinkList.h"
#include "TObjectPool.h"

#include "ReversiCommon.h"
#include "ReversiBitBoard.h"
#include "ReversiPoint.h"

typedef struct ReversiStep
{
	ReversiBitBoard m_LastMap;
	EnumReversiPiecesType m_CurrType;

	ReversiStep& operator= (const ReversiStep& temp)
	{
		m_CurrType = temp.m_CurrType;
		m_LastMap = temp.m_LastMap;

		return *this;
	}
}ReversiStep;

class Reversi
{
public:
	Reversi();
	~Reversi();

	void Init();

	bool CanPlay(EnumReversiPiecesType type);

	bool CanPlay(EnumReversiPiecesType type, char row_y, char column_x);

	void DoReversi(EnumReversiPiecesType type, char row_y, char column_x);

	bool ReversiCheck(EnumReversiPiecesType type, char row_y, char column_x);

	void AddReversiStep();

	void Cancel();

	void SwapPlayer();

	EnumReversiResult IsGameOver();

	EnumReversiPiecesType GetCurrType();

	ReversiBitBoard& GetMap();

private:
	void DoReversi(EnumReversiPiecesType type, char row_y, char column_x, 
		ReversiPointForward forward);

	bool ReversiCheck(EnumReversiPiecesType type, char row_y, char column_x, 
		ReversiPointForward forward);

	EnumReversiPiecesType m_CurrType;

	ReversiBitBoard m_ReversiMap;

	TBDLinkList<ReversiStep> m_ReversiStepList;
	TObjectPool<TBDLinker<ReversiStep>> m_ReversiStepPool;
};

#endif

Reversi.cpp
#include "Reversi.h"

Reversi::Reversi()
{
	
}

Reversi::~Reversi()
{

}

void Reversi::Init()
{
	m_CurrType = enum_ReversiPieces_Black;//规定黑先

	m_ReversiStepList.Init(enum_DisableLock);
	m_ReversiStepPool.Init(REVERSI_MAX_ROW * REVERSI_MAX_COLUMN,
		0,
		enum_DisableLock_ObjPool,
		enum_DisableAssign_ObjPool);

	for (int i = 0; i < REVERSI_MAX_ROW; i++)
	{
		for (int j = 0; j < REVERSI_MAX_COLUMN; j++)
		{
			m_ReversiMap.SetPieces(enum_ReversiPieces_Null, i, j);
		}
	}

	m_ReversiMap.SetPieces(enum_ReversiPieces_Black, 3, 3);
	m_ReversiMap.SetPieces(enum_ReversiPieces_White, 3, 4);
	m_ReversiMap.SetPieces(enum_ReversiPieces_White, 4, 3);
	m_ReversiMap.SetPieces(enum_ReversiPieces_Black, 4, 4);
}

bool Reversi::CanPlay(EnumReversiPiecesType type)
{
	for (int i = 0; i < REVERSI_MAX_ROW; i++)
	{
		for (int j = 0; j < REVERSI_MAX_COLUMN; j++)
		{
			if (CanPlay(type, i, j))
			{
				return true;
			}
		}
	}

	return false;
}

bool Reversi::CanPlay(EnumReversiPiecesType type, char row_y, char column_x)
{
	if (enum_ReversiPieces_Null == m_ReversiMap.GetPieces(row_y, column_x))
	{
		if (ReversiCheck(type, row_y, column_x))
		{
			return true;
		}
	}
	return false;
}

bool Reversi::ReversiCheck(EnumReversiPiecesType type, 
	char row_y, char column_x)
{
	if (ReversiCheck(type, row_y, column_x, &ReversiPoint::UL) ||
		ReversiCheck(type, row_y, column_x, &ReversiPoint::U) ||
		ReversiCheck(type, row_y, column_x, &ReversiPoint::UR) ||
		ReversiCheck(type, row_y, column_x, &ReversiPoint::L) ||
		ReversiCheck(type, row_y, column_x, &ReversiPoint::R) ||
		ReversiCheck(type, row_y, column_x, &ReversiPoint::DL) ||
		ReversiCheck(type, row_y, column_x, &ReversiPoint::D) ||
		ReversiCheck(type, row_y, column_x, &ReversiPoint::DR))
	{
		return true;
	}

	return false;
}

bool Reversi::ReversiCheck(EnumReversiPiecesType type, 
	char row_y, char column_x, 
	ReversiPointForward forward)
{
	ReversiPoint point = {row_y, column_x};
	EnumReversiPiecesType currType;
	int search = 0;

	(point.*forward)();//向某方向搜寻
	search++;
	while(point.IsValid())
	{
		currType = m_ReversiMap.GetPieces(point.m_row_y, point.m_column_x);
		if (enum_ReversiPieces_Null != currType)
		{
			if (type == currType)
			{
				if (search > 1)
				{
					//找到的同色棋子与当前棋子坐标差超过1，则两子之间夹有不同色的棋子
					return true;
				}
				else
				{
					//否则两子是紧挨着的，该方向两子之间无子可以翻转
					return false;
				}
			}
			else
			{
				//找到的是不同色的棋子，继续
				(point.*forward)();
				search++;
			}
		}
		else
		{
			//一直找到空位也没找到，该方向没有同色棋子，无法翻转
			return false;
		}
	}

	//超出棋盘范围都没有找到同色棋子，该方向没有同色棋子，无法翻转
	return false;
}

void Reversi::DoReversi(EnumReversiPiecesType type, 
	char row_y, char column_x)
{
	if (ReversiCheck(type, row_y, column_x, &ReversiPoint::UL))
	{
		DoReversi(type, row_y, column_x, &ReversiPoint::UL);
	}
	if (ReversiCheck(type, row_y, column_x, &ReversiPoint::U))
	{
		DoReversi(type, row_y, column_x, &ReversiPoint::U);
	}
	if (ReversiCheck(type, row_y, column_x, &ReversiPoint::UR))
	{
		DoReversi(type, row_y, column_x, &ReversiPoint::UR);
	}
	if (ReversiCheck(type, row_y, column_x, &ReversiPoint::L))
	{
		DoReversi(type, row_y, column_x, &ReversiPoint::L);
	}
	if (ReversiCheck(type, row_y, column_x, &ReversiPoint::R))
	{
		DoReversi(type, row_y, column_x, &ReversiPoint::R);
	}
	if (ReversiCheck(type, row_y, column_x, &ReversiPoint::DL))
	{
		DoReversi(type, row_y, column_x, &ReversiPoint::DL);
	}
	if (ReversiCheck(type, row_y, column_x, &ReversiPoint::D))
	{
		DoReversi(type, row_y, column_x, &ReversiPoint::D);
	}
	if (ReversiCheck(type, row_y, column_x, &ReversiPoint::DR))
	{
		DoReversi(type, row_y, column_x, &ReversiPoint::DR);
	}
}

void Reversi::DoReversi(EnumReversiPiecesType type, 
	char row_y, char column_x,
	ReversiPointForward forward)
{
	ReversiPoint point = {row_y, column_x};

	(point.*forward)();
	while(point.IsValid())
	{
		if (type != m_ReversiMap.GetPieces(point.m_row_y, point.m_column_x))
		{
			m_ReversiMap.SetPieces(type, point.m_row_y, point.m_column_x);
			(point.*forward)();
		}
		else
		{
			break;
		}
	}
}

void Reversi::AddReversiStep()
{
	TBDLinker<ReversiStep> *pLinker = m_ReversiStepPool.Malloc();
	if (NULL != pLinker)
	{
		pLinker->m_Value.m_LastMap = m_ReversiMap;
		pLinker->m_Value.m_CurrType = m_CurrType;

		pLinker->m_pLinkList = NULL;

		m_ReversiStepList.PushTail(pLinker);
	}
}

void Reversi::Cancel()
{
	TBDLinker<ReversiStep> *pLinker = m_ReversiStepList.PopTail();
	if (NULL != pLinker)
	{
		m_ReversiMap = pLinker->m_Value.m_LastMap;
		m_CurrType = pLinker->m_Value.m_CurrType;

		m_ReversiStepPool.Free(pLinker);
	}
}

void Reversi::SwapPlayer()
{
	EnumReversiPiecesType nexttype;
	if (enum_ReversiPieces_Black == m_CurrType)
	{
		nexttype = enum_ReversiPieces_White;
	} 
	else
	{
		nexttype = enum_ReversiPieces_Black;
	}
	if (CanPlay(nexttype))
	{
		m_CurrType = nexttype;
	}
}

EnumReversiResult Reversi::IsGameOver()
{
	if (!CanPlay(enum_ReversiPieces_Black) && !CanPlay(enum_ReversiPieces_White))
	{
		BYTE black = m_ReversiMap.GetBlackCount();
		BYTE white = m_ReversiMap.GetWhiteCount();

		if (black > white)
		{
			return enum_Reversi_Win_Black;
		}
		else if (black < white)
		{
			return enum_Reversi_Win_White;
		}
		else
		{
			return enum_Reversi_Draw;
		}
	}
	else
	{
		return enum_Reversi_Playing;
	}
}

EnumReversiPiecesType Reversi::GetCurrType()
{
	return m_CurrType;
}

ReversiBitBoard& Reversi::GetMap()
{
	return m_ReversiMap;
}


联系
我们