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

2023-11-07 20:40
文章标签 设计 开发 逻辑 游戏 转载 win32 棋局 黑白棋

本文主要是介绍转载-游戏开发（三）——WIN32 黑白棋（一）——棋局逻辑的设计，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

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

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

分3部分介绍。

1、棋局的现实

2、AI的现实

3、游戏画面的现实

提供一下完整项目下载


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

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

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

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

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


第二部分主要为了写AI：

黑白棋的AI其实蛮复杂，有专门的研究黑白棋的AI的算法文章，这里只介绍一下，然后简单实现了一个AI，主要是最大最小算法，以及枝剪算法。


第三部分主要是游戏画面的显示：

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

阅读第三部分前，读者可以先行阅读《windows程序设计》一书打个基础。也可以看完博文之后，再将涉及到的图形API，消息机制等windows程序设计中涉及到的点带回到书中去详细了解。


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

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

  1. const int REVERSI_MAX_ROW = 8;
  2. const int REVERSI_MAX_COLUMN = 8;

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

  1. enum EnumReversiPiecesType
  2. {
  3. enum_ReversiPieces_Null = 0x00,
  4. enum_ReversiPieces_Black = 0x01,
  5. enum_ReversiPieces_White = 0x02,
  6. };

这三种情况，其实用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);
是否可以吃子的伪代码： 

  1. 定义一个坐标对象point，初值为当前点row_y, column_x
  2. 记录该方向上的搜索次数search，初值为0
  3. point向forward方向移动
  4. 搜索次数search++
  5. while (point是一个合法的坐标，不能移出棋盘外面去了)
  6. {
  7. 取point当前位置的棋子类型
  8. （此时已经是forward移动一次之后的位置了，不是row_y, column_x了）
  9. 	if (当前位置有棋子)
  10. {
  11. 		if (当前位置的棋子类型等于传入参数type，type就是要下的棋子类型)
  12. {
  13. 			if (搜索次数search大于1次)
  14. {
  15. 说明找到的同色棋子与当前棋子坐标差超过1，point至少移动了2次
  16. 则两子之间夹有不同色的棋子
  17. 符合翻转规则，return true
  18. }
  19. 			else
  20. {
  21. 说明找到的同色棋子与当前棋子，两子是紧挨着的
  22. 该方向两子之间无子可以翻转
  23. 不符合翻转规则，return false
  24. }
  25. }
  26. 		else
  27. {
  28. 说明找到的是不同色的棋子，继续向下一个位置搜
  29. point向forward方向移动
  30. 搜索次数search++
  31. }
  32. }
  33. 	else
  34. {
  35. 一直找到空位也没找到，该方向没有同色棋子，无法翻转
  36. }
  37. }
  38. 超出棋盘范围都没有找到同色棋子，该方向没有同色棋子，无法翻转

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

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

伪代码实现 

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

有了上面两个基本函数

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、最后，判断游戏是否结束的逻辑，即双方都无子可下，则游戏结束


先给个游戏截图吧


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

ReversiCommon.h

  1. #ifndef _ReversiCommon_h_
  2. #define _ReversiCommon_h_
  3.  
  4. #include <windows.h>
  5.  
  6. //棋盘大小
  7. const int REVERSI_MAX_ROW = 8;
  8. const int REVERSI_MAX_COLUMN = 8;
  9.  
  10. enum EnumReversiPiecesType
  11. {
  12. enum_ReversiPieces_Null = 0x00,
  13. enum_ReversiPieces_Black = 0x01,
  14. enum_ReversiPieces_White = 0x02,
  15. };
  16.  
  17. EnumReversiPiecesType SwapType(EnumReversiPiecesType type);
  18.  
  19. enum EnumReversiResult
  20. {
  21. enum_Reversi_Playing = 0,
  22. enum_Reversi_Draw,
  23. enum_Reversi_Win_Black,
  24. enum_Reversi_Win_White,
  25. };
  26.  
  27. //权值表
  28. const int g_Weight[REVERSI_MAX_ROW][REVERSI_MAX_COLUMN] = {
  29. {0x1 << 24, 0x1,       0x1 << 20, 0x1 << 16,0x1 << 16,0x1 << 20, 0x1,       0x1 << 24},
  30. {0x1,       0x1,       0x1 << 16, 0x1 << 4, 0x1 << 4, 0x1 << 16, 0x1,       0x1     },
  31. {0x1 << 20, 0x1 << 16, 0x1 << 12, 0x1 << 8, 0x1 << 8, 0x1 << 12, 0x1 << 16, 0x1 << 20},
  32. {0x1 << 16, 0x1 << 4,  0x1 << 8,  0,        0,        0x1 << 8,  0x1 << 4,  0x1 << 16},
  33. {0x1 << 16, 0x1 << 4,  0x1 << 8,  0,        0,        0x1 << 8,  0x1 << 4,  0x1 << 16},
  34. {0x1 << 20, 0x1 << 16, 0x1 << 12, 0x1 << 8, 0x1 << 8, 0x1 << 12, 0x1 << 16, 0x1 << 20},
  35. {0x1,       0x1,       0x1 << 16, 0x1 << 4, 0x1 << 4, 0x1 << 16, 0x1,       0x1     },
  36. {0x1 << 24, 0x1,       0x1 << 20, 0x1 << 16,0x1 << 16,0x1 << 20, 0x1,       0x1 << 24}
  37. };
  38.  
  39. //按权值表降序排列的坐标顺序表
  40. const BYTE g_WeightOrder[REVERSI_MAX_ROW * REVERSI_MAX_COLUMN - 4][2] = {
  41. { 0, 0}, { 0, 7}, { 7, 0}, { 7, 7},//0x01000000
  42. { 0, 2}, { 0, 5}, { 2, 0}, { 2, 7},//0x00100000
  43. { 7, 2}, { 7, 5}, { 5, 0}, { 5, 7},
  44. { 0, 3}, { 0, 4}, { 1, 2}, { 1, 5},//0x00010000
  45. { 2, 1}, { 2, 6}, { 3, 0}, { 3, 7},
  46. { 4, 0}, { 4, 7}, { 5, 1}, { 5, 6},
  47. { 6, 2}, { 6, 5}, { 7, 3}, { 7, 4},
  48. { 2, 2}, { 2, 5}, { 5, 2}, { 5, 5},//0x00001000
  49. { 2, 3}, { 2, 4}, { 3, 2}, { 3, 5},//0x00000100
  50. { 4, 2}, { 4, 5}, { 5, 3}, { 5, 4},
  51. { 1, 3}, { 1, 4}, { 3, 1}, { 3, 6},//0x00000010
  52. { 4, 1}, { 4, 6}, { 6, 3}, { 6, 4},
  53. { 0, 1}, { 0, 6}, { 1, 0}, { 1, 7},//0x00000001
  54. { 6, 0}, { 6, 7}, { 7, 1}, { 7, 6},
  55. { 1, 1}, { 1, 6}, { 6, 1}, { 6, 6} //0x00000001
  56. 	//{ 3, 3}, { 3, 4}, { 4, 3}, { 4, 4}, 初始4个位置不用判断
  57. };
  58.  
  59. #endif


ReversiCommon.cpp

  1. #include "ReversiCommon.h"
  2.  
  3. EnumReversiPiecesType SwapType(EnumReversiPiecesType type)
  4. {
  5. 	if (enum_ReversiPieces_Black == type)
  6. {
  7. 		return enum_ReversiPieces_White;
  8. }
  9. 	else if (enum_ReversiPieces_White == type)
  10. {
  11. 		return enum_ReversiPieces_Black;
  12. }
  13. 	else
  14. {
  15. 		return enum_ReversiPieces_Null;
  16. }
  17. }


ReversiPoint.h

  1. #ifndef _ReversiPoint_h_
  2. #define _ReversiPoint_h_
  3.  
  4. #include "ReversiCommon.h"
  5.  
  6. typedef struct ReversiPoint
  7. {
  8. 	char m_row_y;
  9. 	char m_column_x;
  10.  
  11. ReversiPoint& operator= (const ReversiPoint& temp)
  12. {
  13. m_row_y = temp.m_row_y;
  14. m_column_x = temp.m_column_x;
  15. 		return *this;
  16. }
  17.  
  18. 	bool operator!= (const ReversiPoint& temp)
  19. {
  20. 		if (m_row_y == temp.m_row_y &&
  21. m_column_x == temp.m_column_x)
  22. {
  23. 			return false;
  24. }
  25. 		else
  26. {
  27. 			return true;
  28. }
  29. }
  30.  
  31. 	bool IsValid()
  32. {
  33. 		if (0 <= m_row_y &&
  34. 			0 <= m_column_x &&
  35. m_row_y < REVERSI_MAX_ROW &&
  36. m_column_x < REVERSI_MAX_COLUMN)
  37. {
  38. 			return true;
  39. }
  40. 		else
  41. {
  42. 			return false;
  43. }
  44. }
  45.  
  46. 	void UL()
  47. {
  48. m_row_y--;
  49. m_column_x--;
  50. }
  51.  
  52. 	void U()
  53. {
  54. m_row_y--;
  55. }
  56.  
  57. 	void UR()
  58. {
  59. m_row_y--;
  60. m_column_x++;
  61. }
  62.  
  63. 	void L()
  64. {
  65. m_column_x--;
  66. }
  67.  
  68. 	void R()
  69. {
  70. m_column_x++;
  71. }
  72.  
  73. 	void DL()
  74. {
  75. m_row_y++;
  76. m_column_x--;
  77. }
  78.  
  79. 	void D()
  80. {
  81. m_row_y++;
  82. }
  83.  
  84. 	void DR()
  85. {
  86. m_row_y++;
  87. m_column_x++;
  88. }
  89. }ReversiPoint;
  90.  
  91. typedef void (ReversiPoint::*ReversiPointForward)();
  92.  
  93. #endif


ReversiBitBoard.h

  1. #ifndef _ReversiBitBoard_h_
  2. #define _ReversiBitBoard_h_
  3.  
  4. #include <Windows.h>
  5.  
  6. #include "TArray.h"
  7.  
  8. #include "ReversiCommon.h"
  9. #include "ReversiPoint.h"
  10.  
  11. class ReversiBitBoard
  12. {
  13. public:
  14. ReversiBitBoard();
  15. ~ReversiBitBoard();
  16.  
  17. 	void Init();
  18.  
  19. ReversiBitBoard& operator= (const ReversiBitBoard& temp);
  20.  
  21. 	void SetPieces(EnumReversiPiecesType type, char row_y, char column_x);
  22.  
  23. 	EnumReversiPiecesType GetPieces(char row_y, char column_x);
  24.  
  25. 	EnumReversiResult IsGameOver();
  26. 	
  27. 	bool CanPlay(EnumReversiPiecesType type);
  28. 	
  29. 	bool CanPlay(EnumReversiPiecesType type, char row_y, char column_x);
  30.  
  31. 	bool ReversiCheck(EnumReversiPiecesType type, char row_y, char column_x);
  32.  
  33. 	void DoReversi(EnumReversiPiecesType type, char row_y, char column_x);
  34.  
  35. 	int GetCount(EnumReversiPiecesType type);
  36.  
  37. 	void SwapPlayer();
  38.  
  39. 	EnumReversiPiecesType GetCurrType();
  40.  
  41. private:
  42. 	void DoReversi(EnumReversiPiecesType type, char row_y, char column_x, 
  43. 		ReversiPointForward forward);
  44.  
  45. 	bool ReversiCheck(EnumReversiPiecesType type, char row_y, char column_x, 
  46. 		ReversiPointForward forward);
  47.  
  48. TArray1<WORD, REVERSI_MAX_ROW> m_Map;
  49. 	
  50. EnumReversiPiecesType m_CurrType;
  51. };
  52.  
  53. #endif


ReversiBitBoard.cpp

  1. #include "ReversiBitBoard.h"
  2.  
  3. ReversiBitBoard::ReversiBitBoard()
  4. {
  5. 	
  6. }
  7.  
  8. ReversiBitBoard::~ReversiBitBoard()
  9. {
  10.  
  11. }
  12.  
  13. void ReversiBitBoard::Init()
  14. {
  15. m_CurrType = enum_ReversiPieces_Black;//规定黑先
  16.  
  17. 	for (int i = 0; i < REVERSI_MAX_ROW; i++)
  18. {
  19. m_Map[i] = 0;
  20. }
  21. SetPieces(enum_ReversiPieces_White, 3, 3);
  22. SetPieces(enum_ReversiPieces_Black, 3, 4);
  23. SetPieces(enum_ReversiPieces_Black, 4, 3);
  24. SetPieces(enum_ReversiPieces_White, 4, 4);
  25. }
  26.  
  27. ReversiBitBoard& ReversiBitBoard::operator=(const ReversiBitBoard& temp)
  28. {
  29. m_Map = temp.m_Map;
  30. m_CurrType = temp.m_CurrType;
  31. 	return *this;
  32. }
  33.  
  34. void ReversiBitBoard::SetPieces(EnumReversiPiecesType type, char row_y, char column_x)
  35. {
  36. m_Map[row_y] = m_Map[row_y] & (~(0x0003 << (column_x * 2)));
  37. m_Map[row_y] = m_Map[row_y] | (type << (column_x * 2));
  38. }
  39.  
  40. EnumReversiPiecesType ReversiBitBoard::GetPieces(char row_y, char column_x)
  41. {
  42. WORD value = m_Map[row_y] & (0x0003 << (column_x * 2));
  43. value = value >> (column_x * 2);
  44. EnumReversiPiecesType type = static_cast<EnumReversiPiecesType>(value);
  45. 	return type;
  46. }
  47.  
  48. int ReversiBitBoard::GetCount(EnumReversiPiecesType type)
  49. {
  50. 	int count = 0;
  51. 	for (int i = 0; i < REVERSI_MAX_ROW; i++)
  52. {
  53. 		for (int j = 0; j < REVERSI_MAX_COLUMN; j++)
  54. {
  55. 			if (type == GetPieces(i, j))
  56. {
  57. count++;
  58. }
  59. }
  60. }
  61. 	return count;
  62. }
  63.  
  64. EnumReversiResult ReversiBitBoard::IsGameOver()
  65. {
  66. 	if (!CanPlay(enum_ReversiPieces_Black) && 
  67. !CanPlay(enum_ReversiPieces_White))
  68. {
  69. 		int black = GetCount(enum_ReversiPieces_Black);
  70. 		int white = GetCount(enum_ReversiPieces_White);
  71.  
  72. 		if (black > white)
  73. {
  74. 			return enum_Reversi_Win_Black;
  75. }
  76. 		else if (black < white)
  77. {
  78. 			return enum_Reversi_Win_White;
  79. }
  80. 		else
  81. {
  82. 			return enum_Reversi_Draw;
  83. }
  84. }
  85. 	else
  86. {
  87. 		return enum_Reversi_Playing;
  88. }
  89. }
  90.  
  91. bool ReversiBitBoard::CanPlay(EnumReversiPiecesType type)
  92. {
  93. 	for (int i = 0; i < REVERSI_MAX_ROW; i++)
  94. {
  95. 		for (int j = 0; j < REVERSI_MAX_COLUMN; j++)
  96. {
  97. 			if (CanPlay(type, i, j))
  98. {
  99. 				return true;
  100. }
  101. }
  102. }
  103.  
  104. 	return false;
  105. }
  106.  
  107. bool ReversiBitBoard::CanPlay(EnumReversiPiecesType type, char row_y, char column_x)
  108. {
  109. 	if (enum_ReversiPieces_Null == GetPieces(row_y, column_x))
  110. {
  111. 		if (ReversiCheck(type, row_y, column_x))
  112. {
  113. 			return true;
  114. }
  115. }
  116.  
  117. 	return false;
  118. }
  119.  
  120. bool ReversiBitBoard::ReversiCheck(EnumReversiPiecesType type, 
  121. 	char row_y, char column_x)
  122. {
  123. 	if (ReversiCheck(type, row_y, column_x, &ReversiPoint::UL) ||
  124. ReversiCheck(type, row_y, column_x, &ReversiPoint::U) ||
  125. ReversiCheck(type, row_y, column_x, &ReversiPoint::UR) ||
  126. ReversiCheck(type, row_y, column_x, &ReversiPoint::L) ||
  127. ReversiCheck(type, row_y, column_x, &ReversiPoint::R) ||
  128. ReversiCheck(type, row_y, column_x, &ReversiPoint::DL) ||
  129. ReversiCheck(type, row_y, column_x, &ReversiPoint::D) ||
  130. ReversiCheck(type, row_y, column_x, &ReversiPoint::DR))
  131. {
  132. 		return true;
  133. }
  134.  
  135. 	return false;
  136. }
  137.  
  138. bool ReversiBitBoard::ReversiCheck(EnumReversiPiecesType type, 
  139. 	char row_y, char column_x, 
  140. ReversiPointForward forward)
  141. {
  142. ReversiPoint point = {row_y, column_x};
  143. EnumReversiPiecesType currType;
  144. 	int search = 0;
  145.  
  146. (point.*forward)();//向某方向搜寻
  147. search++;
  148. 	while(point.IsValid())
  149. {
  150. currType = GetPieces(point.m_row_y, point.m_column_x);
  151. 		if (enum_ReversiPieces_Null != currType)
  152. {
  153. 			if (type == currType)
  154. {
  155. 				if (search > 1)
  156. {
  157. 					//找到的同色棋子与当前棋子坐标差超过1，则两子之间夹有不同色的棋子
  158. 					return true;
  159. }
  160. 				else
  161. {
  162. 					//否则两子是紧挨着的，该方向两子之间无子可以翻转
  163. 					return false;
  164. }
  165. }
  166. 			else
  167. {
  168. 				//找到的是不同色的棋子，继续
  169. (point.*forward)();
  170. search++;
  171. }
  172. }
  173. 		else
  174. {
  175. 			//一直找到空位也没找到，该方向没有同色棋子，无法翻转
  176. 			return false;
  177. }
  178. }
  179.  
  180. 	//超出棋盘范围都没有找到同色棋子，该方向没有同色棋子，无法翻转
  181. 	return false;
  182. }
  183.  
  184. void ReversiBitBoard::DoReversi(EnumReversiPiecesType type, 
  185. 	char row_y, char column_x)
  186. {
  187. 	if (ReversiCheck(type, row_y, column_x, &ReversiPoint::UL))
  188. {
  189. DoReversi(type, row_y, column_x, &ReversiPoint::UL);
  190. }
  191. 	if (ReversiCheck(type, row_y, column_x, &ReversiPoint::U))
  192. {
  193. DoReversi(type, row_y, column_x, &ReversiPoint::U);
  194. }
  195. 	if (ReversiCheck(type, row_y, column_x, &ReversiPoint::UR))
  196. {
  197. DoReversi(type, row_y, column_x, &ReversiPoint::UR);
  198. }
  199. 	if (ReversiCheck(type, row_y, column_x, &ReversiPoint::L))
  200. {
  201. DoReversi(type, row_y, column_x, &ReversiPoint::L);
  202. }
  203. 	if (ReversiCheck(type, row_y, column_x, &ReversiPoint::R))
  204. {
  205. DoReversi(type, row_y, column_x, &ReversiPoint::R);
  206. }
  207. 	if (ReversiCheck(type, row_y, column_x, &ReversiPoint::DL))
  208. {
  209. DoReversi(type, row_y, column_x, &ReversiPoint::DL);
  210. }
  211. 	if (ReversiCheck(type, row_y, column_x, &ReversiPoint::D))
  212. {
  213. DoReversi(type, row_y, column_x, &ReversiPoint::D);
  214. }
  215. 	if (ReversiCheck(type, row_y, column_x, &ReversiPoint::DR))
  216. {
  217. DoReversi(type, row_y, column_x, &ReversiPoint::DR);
  218. }
  219. }
  220.  
  221. void ReversiBitBoard::DoReversi(EnumReversiPiecesType type, 
  222. 	char row_y, char column_x,
  223. ReversiPointForward forward)
  224. {
  225. ReversiPoint point = {row_y, column_x};
  226.  
  227. (point.*forward)();
  228. 	while(point.IsValid())
  229. {
  230. 		if (type != GetPieces(point.m_row_y, point.m_column_x))
  231. {
  232. SetPieces(type, point.m_row_y, point.m_column_x);
  233. (point.*forward)();
  234. }
  235. 		else
  236. {
  237. 			break;
  238. }
  239. }
  240. }
  241.  
  242. void ReversiBitBoard::SwapPlayer()
  243. {
  244. EnumReversiPiecesType nexttype = SwapType(m_CurrType);
  245. 	if (CanPlay(nexttype))
  246. {
  247. m_CurrType = nexttype;
  248. }
  249. }
  250.  
  251. EnumReversiPiecesType ReversiBitBoard::GetCurrType()
  252. {
  253. 	return m_CurrType;
  254. }


这篇关于转载-游戏开发（三）——WIN32 黑白棋（一）——棋局逻辑的设计的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/366181。

相关文章

基于Python开发电脑定时关机工具

基于Python开发电脑定时关机工具

《基于Python开发电脑定时关机工具》这篇文章主要为大家详细介绍了如何基于Python开发一个电脑定时关机工具,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 目录1. 简介2. 运行效果3. 相关源码1. 简介这个程序就像一个“忠实的管家”，帮你按时关掉电脑，而且全程不需要你多做
阅读更多...
Java中的Opencv简介与开发环境部署方法

Java中的Opencv简介与开发环境部署方法

《Java中的Opencv简介与开发环境部署方法》OpenCV是一个开源的计算机视觉和图像处理库,提供了丰富的图像处理算法和工具,它支持多种图像处理和计算机视觉算法,可以用于物体识别与跟踪、图像分割与... 目录1.Opencv简介Opencv的应用2.Java使用OpenCV进行图像操作opencv安装j
阅读更多...
Python中的可视化设计与UI界面实现

Python中的可视化设计与UI界面实现

《Python中的可视化设计与UI界面实现》本文介绍了如何使用Python创建用户界面（UI）,包括使用Tkinter、PyQt、Kivy等库进行基本窗口、动态图表和动画效果的实现,通过示例代码,展示... 目录从像素到界面：python带你玩转UI设计示例：使用Tkinter创建一个简单的窗口绘图魔法：用
阅读更多...
基于Qt开发一个简单的OFD阅读器

基于Qt开发一个简单的OFD阅读器

《基于Qt开发一个简单的OFD阅读器》这篇文章主要为大家详细介绍了如何使用Qt框架开发一个功能强大且性能优异的OFD阅读器,文中的示例代码讲解详细,有需要的小伙伴可以参考一下... 目录摘要引言一、OFD文件格式解析二、文档结构解析三、页面渲染四、用户交互五、性能优化六、示例代码七、未来发展方向八、结论摘要
阅读更多...
在 VSCode 中配置 C++ 开发环境的详细教程

在 VSCode 中配置 C++ 开发环境的详细教程

《在VSCode中配置C++开发环境的详细教程》本文详细介绍了如何在VisualStudioCode（VSCode）中配置C++开发环境,包括安装必要的工具、配置编译器、设置调试环境等步骤,通... 目录如何在 VSCode 中配置 C++ 开发环境：详细教程1. 什么是 VSCode？2. 安装 VSCo
阅读更多...
C#图表开发之Chart详解

C#图表开发之Chart详解

《C#图表开发之Chart详解》C#中的Chart控件用于开发图表功能,具有Series和ChartArea两个重要属性,Series属性是SeriesCollection类型,包含多个Series对... 目录OverviChina编程ewSeries类总结OverviewC#中，开发图表功能的控件是Char
阅读更多...
鸿蒙开发搭建flutter适配的开发环境

鸿蒙开发搭建flutter适配的开发环境

《鸿蒙开发搭建flutter适配的开发环境》文章详细介绍了在Windows系统上如何创建和运行鸿蒙Flutter项目,包括使用flutterdoctor检测环境、创建项目、编译HAP包以及在真机上运... 目录环境搭建创建运行项目打包项目总结环境搭建1.安装 DevEco Studio NEXT IDE
阅读更多...
Python开发围棋游戏的实例代码（实现全部功能）

Python开发围棋游戏的实例代码（实现全部功能）

《Python开发围棋游戏的实例代码（实现全部功能）》围棋是一种古老而复杂的策略棋类游戏,起源于中国,已有超过2500年的历史,本文介绍了如何用Python开发一个简单的围棋游戏,实例代码涵盖了游戏的... 目录1. 围棋游戏概述1.1 游戏规则1.2 游戏设计思路2. 环境准备3. 创建棋盘3.1 棋盘类
阅读更多...
不懂推荐算法也能设计推荐系统

不懂推荐算法也能设计推荐系统

本文以商业化应用推荐为例，告诉我们不懂推荐算法的产品，也能从产品侧出发， 设计出一款不错的推荐系统。 相信很多新手产品，看到算法二字，多是懵圈的。 什么排序算法、最短路径等都是相对传统的算法（注：传统是指科班出身的产品都会接触过）。但对于推荐算法，多数产品对着网上搜到的资源，都会无从下手。特别当某些推荐算法 和 “AI”扯上关系后，更是加大了理解的难度。 但，不了解推荐算法，就无法做推荐系
阅读更多...
这15个Vue指令，让你的项目开发爽到爆

这15个Vue指令，让你的项目开发爽到爆

1. V-Hotkey 仓库地址: github.com/Dafrok/v-ho… Demo: 戳这里 https://dafrok.github.io/v-hotkey 安装: npm install --save v-hotkey 这个指令可以给组件绑定一个或多个快捷键。你想要通过按下 Escape 键后隐藏某个组件，按住 Control 和回车键再显示它吗？小菜一碟： <template
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2