一：目的
就是为了熟悉Python语法
二：效果
三：使用方式
1.用Python3运行里面的main.py即可；
2.wdsa和上右下左键控制光标移动；空格键选中棋子，再按则是相当于移动棋子，如果在原地再按空格键取消选中；
3.按q结束游戏，或者吃了主帅后结束游戏
四：源码
https://github.com/silentdoer/chinese_chess_python3
支持Linux和Windows（我这边用ubuntu18.04和Win10 Powershell测试的，如果是其他终端不能保证布局会像GIF中的那样整齐，但是功能肯定是没问题的）
五：源码介绍
1.首先需要一个能够实时获取按键的工具方法/工具类，否则每次按完上下左右等功能按键后都要按Enter键太不方便，代码如下：
class Getch(): """ 用来实现不需要按enter键读取输入字符 """ def __init__(self): import platform system_name = platform.system() if system_name == 'Windows': self.impl = GetchWindows() else: # 默认是Linux（目前就支持Windows和Linux即可） self.impl = GetchUnix() def __call__(self): return self.impl() class GetchUnix: def __init__(self): pass def __call__(self): # 不要用import sys, tty这种逗号的方式导入 import sys import tty import termios fd = sys.stdin.fileno() old_settings = termios.tcgetattr(fd) try: tty.setraw(sys.stdin.fileno()) ch = sys.stdin.read(1) finally: termios.tcsetattr(fd, termios.TCSADRAIN, old_settings) return ch class GetchWindows: def __init__(self): pass def __call__(self): import msvcrt return msvcrt.getch()
通过getch()就能实时获取按下的按键
2.通过一个公共模块来实现清屏和打印颜色文本的操作，代码如下：
def printc(new_line, content, forecolor='', backcolor=''): if forecolor != '': forecolor = ';' + forecolor if backcolor != '': backcolor = ';' + backcolor flag = '' if new_line: flag = '\n' print('\033[0' + forecolor + backcolor + 'm' + content + '\033[0m', end=flag) def clear_console(): import platform import os system_name = platform.system() if system_name == 'Windows': os.system("cls") else: # 默认是Linux（目前就支持Windows和Linux即可） os.system("clear")
3.定义一些常量，主要用于描述阵营，棋子类型（如象，馬，車等），颜色常量，代码如下：
CAMP_RED = '红方' CAMP_WHITE = '白方' CAMP_NONE = 'NONE' CAMP_CURSOR = 'CURSOR' FORE_RED = '31' FORE_YELLOW = '33' FORE_BLUE = '34' FORE_WHITE = '37' BACK_BLACK = '40' CHESS_CHE = 1 CHESS_MA = 2 CHESS_XIANG = 3 CHESS_SHI = 4 CHESS_BOSS = 5 CHESS_PAO = 6 CHESS_BING = 7 # 普通的＊ CHESS_PIECE = 8 CHESS_CURSOR = 9
4.然后我们需要定义棋子类，这里因为想熟悉Python语法，所以拆成了Chess和ChineseChess来做用来熟悉继承，代码如下：
class Piece: """ 定义棋子基类 """ def __init__(self, pic): self._pic = pic def show(self, new_line=False): if new_line: print(self._pic) else: print(self._pic, end='')
# coding:utf-8 import piece import constants import common class ChessPiece(piece.Piece): """ 定义象棋棋子 """ __camp = '' __type = '' def __init__(self, pic, camp): piece.Piece.__init__(self, pic) self.__camp = camp def get_camp(self): return self.__camp def get_pic(self): return self._pic def set_camp(self, camp): self.__camp = camp def set_pic(self, pic): self._pic = pic def set_type(self, chess_type): self.__type = chess_type def get_type(self): return self.__type def show(self, new_line=False): if self.__camp == constants.CAMP_RED: common.printc(new_line, self._pic, constants.FORE_RED) elif self.__camp == constants.CAMP_WHITE: common.printc(new_line, self._pic, constants.FORE_WHITE) elif self.__camp == constants.CAMP_CURSOR: common.printc(new_line, self._pic, constants.FORE_YELLOW) else: common.printc(new_line, self._pic, constants.FORE_BLUE)
5.接下来就是游戏环境类了，这个类比较大，也是关键，线上代码后面会讲一下思路：
# coding:utf-8 import sys from chess_piece import ChessPiece import constants from getch import Getch import chess_strategy import common class GameContext: """ 游戏环境类 """ game_over = False winner = '' # 是否已经选中棋子 piece_checked = False # 红方先行 firster = constants.CAMP_RED _pieces = [] _width = 9 _height = 10 _getch = Getch() # 字符串默认值可以是''，数组默认值是[]，字典默认值是{}，数值默认值是0，而对象默认值是None _cursor_original_backup = None _cursor_loc = {'x': 4, 'y': 1} # 用于记录checked后，被checked的piece的坐标，用于判定是否是取消checked _checked_loc = {} _checked = False CURSOR_CHECKED = ' 〠 ' CURSOR_UNCHECKED = ' 〄 ' PIECE_NONE = ' ＊ ' strategies = None def __init__(self, camp=constants.CAMP_RED): if camp == constants.CAMP_WHITE: self._cursor_loc['y'] = 8 elif camp != constants.CAMP_RED: print('阵营参数错误，游戏退出') exit() self.firster = camp # init pieces # init NONE Camp for y in range(self._height): line = [] for x in range(self._width): tmp = ChessPiece(self.PIECE_NONE, constants.CAMP_NONE) tmp.set_type(constants.CHESS_PIECE) line.append(tmp) self._pieces.append(line) del line # init RED Camp and Pic for idx in range(self._width): self._pieces[0][idx].set_camp(constants.CAMP_RED) self._pieces[0][0].set_pic(' 車 ') self._pieces[0][0].set_type(constants.CHESS_CHE) self._pieces[0][1].set_pic(' 馬 ') self._pieces[0][1].set_type(constants.CHESS_MA) self._pieces[0][2].set_pic(' 象 ') self._pieces[0][2].set_type(constants.CHESS_XIANG) self._pieces[0][3].set_pic(' 士 ') self._pieces[0][3].set_type(constants.CHESS_SHI) self._pieces[0][4].set_pic(' 將 ') self._pieces[0][4].set_type(constants.CHESS_BOSS) self._pieces[0][5].set_pic(' 士 ') self._pieces[0][5].set_type(constants.CHESS_SHI) self._pieces[0][6].set_pic(' 象 ') self._pieces[0][6].set_type(constants.CHESS_XIANG) self._pieces[0][7].set_pic(' 馬 ') self._pieces[0][7].set_type(constants.CHESS_MA) self._pieces[0][8].set_pic(' 車 ') self._pieces[0][8].set_type(constants.CHESS_CHE) # 上面的camp已经通过循环统一设置过了 self._pieces[2][1].set_pic(' 炮 ') self._pieces[2][1].set_type(constants.CHESS_PAO) self._pieces[2][1].set_camp(constants.CAMP_RED) self._pieces[2][7].set_pic(' 炮 ') self._pieces[2][7].set_type(constants.CHESS_PAO) self._pieces[2][7].set_camp(constants.CAMP_RED) self._pieces[3][0].set_pic(' 卒 ') self._pieces[3][0].set_type(constants.CHESS_BING) self._pieces[3][0].set_camp(constants.CAMP_RED) self._pieces[3][2].set_pic(' 卒 ') self._pieces[3][2].set_type(constants.CHESS_BING) self._pieces[3][2].set_camp(constants.CAMP_RED) self._pieces[3][4].set_pic(' 卒 ') self._pieces[3][4].set_type(constants.CHESS_BING) self._pieces[3][4].set_camp(constants.CAMP_RED) self._pieces[3][6].set_pic(' 卒 ') self._pieces[3][6].set_type(constants.CHESS_BING) self._pieces[3][6].set_camp(constants.CAMP_RED) self._pieces[3][-1].set_pic(' 卒 ') self._pieces[3][-1].set_type(constants.CHESS_BING) self._pieces[3][-1].set_camp(constants.CAMP_RED) # init WHITE Camp and Pic for idx in range(self._width): self._pieces[-1][idx].set_camp(constants.CAMP_WHITE) self._pieces[-1][0].set_pic(' 車 ') self._pieces[-1][0].set_type(constants.CHESS_CHE) self._pieces[-1][1].set_pic(' 馬 ') self._pieces[-1][1].set_type(constants.CHESS_MA) self._pieces[-1][2].set_pic(' 相 ') self._pieces[-1][2].set_type(constants.CHESS_XIANG) self._pieces[-1][3].set_pic(' 仕 ') self._pieces[-1][3].set_type(constants.CHESS_SHI) self._pieces[-1][4].set_pic(' 帥 ') self._pieces[-1][4].set_type(constants.CHESS_BOSS) self._pieces[-1][5].set_pic(' 仕 ') self._pieces[-1][5].set_type(constants.CHESS_SHI) self._pieces[-1][6].set_pic(' 相 ') self._pieces[-1][6].set_type(constants.CHESS_XIANG) self._pieces[-1][7].set_pic(' 馬 ') self._pieces[-1][7].set_type(constants.CHESS_MA) self._pieces[-1][8].set_pic(' 車 ') self._pieces[-1][8].set_type(constants.CHESS_CHE) # 上面的camp已经通过循环统一设置过了 self._pieces[-3][1].set_pic(' 砲 ') self._pieces[-3][1].set_type(constants.CHESS_PAO) self._pieces[-3][1].set_camp(constants.CAMP_WHITE) self._pieces[-3][7].set_pic(' 砲 ') self._pieces[-3][7].set_type(constants.CHESS_PAO) self._pieces[-3][7].set_camp(constants.CAMP_WHITE) self._pieces[-4][0].set_pic(' 兵 ') self._pieces[-4][0].set_type(constants.CHESS_BING) self._pieces[-4][0].set_camp(constants.CAMP_WHITE) self._pieces[-4][2].set_pic(' 兵 ') self._pieces[-4][2].set_type(constants.CHESS_BING) self._pieces[-4][2].set_camp(constants.CAMP_WHITE) self._pieces[-4][4].set_pic(' 兵 ') self._pieces[-4][4].set_type(constants.CHESS_BING) self._pieces[-4][4].set_camp(constants.CAMP_WHITE) self._pieces[-4][6].set_pic(' 兵 ') self._pieces[-4][6].set_type(constants.CHESS_BING) self._pieces[-4][6].set_camp(constants.CAMP_WHITE) self._pieces[-4][8].set_pic(' 兵 ') self._pieces[-4][8].set_type(constants.CHESS_BING) self._pieces[-4][8].set_camp(constants.CAMP_WHITE) # init cursor 〄 〠 self._cursor_original_backup: ChessPiece = self._pieces[self._cursor_loc['y']][self._cursor_loc['x']] tmp = ChessPiece(self.cursor_pic(), constants.CAMP_CURSOR) tmp.set_type(constants.CHESS_CURSOR) self._pieces[self._cursor_loc['y']][self._cursor_loc['x']] = tmp del tmp self.strategies = chess_strategy.ChessStrategy(self._pieces, True) def show_map(self): for y in range(self._height): for x in range(self._width): self._pieces[y][x].show() if y == 4: print() # 楚汉分割线 print('***********************************') else: print('\n') def clear_map(self): return common.clear_console() def cursor_move(self, p_target): self._pieces[self._cursor_loc['y']][self._cursor_loc['x']] = self._cursor_original_backup self._cursor_original_backup = self._pieces[p_target['y']][p_target['x']] tmp = ChessPiece(self.cursor_pic(), constants.CAMP_CURSOR) tmp.set_type(constants.CHESS_CURSOR) self._pieces[p_target['y']][p_target['x']] = tmp self._cursor_loc = p_target # 刷新地图 self.clear_map() self.show_map() # 参数类型限定和返回值类型限定可以不要【类似ts里可以不要】 def can_move(self, direct: str) -> bool: if direct == 'w': if self._cursor_loc['y'] - 1 < 0: return False elif direct == 'd': if self._cursor_loc['x'] + 1 >= self._width: return False elif direct == 's': if self._cursor_loc['y'] + 1 >= self._height: return False elif direct == 'a': if self._cursor_loc['x'] - 1 < 0: return False else: return False return True def cursor_pic(self) -> str: if self._checked: return self.CURSOR_CHECKED else: return self.CURSOR_UNCHECKED """ Python3里可以手动指定返回值类型，而且参数类型也是可以指定的 """ def control(self) -> None: while True: ch = self._getch() # 清空之前的显示状态 self.clear_map() # 重新绘制象棋布局 self.show_map() if ch == 'w' or ch == 'A' or ch == b'w' or ch == b'H': if self.can_move('w'): self.cursor_move({'x': self._cursor_loc['x'], 'y': self._cursor_loc['y'] - 1}) print('↑', end='') elif ch == 'd' or ch == 'C' or ch == b'd' or ch == b'M': if self.can_move('d'): self.cursor_move({'x': self._cursor_loc['x'] + 1, 'y': self._cursor_loc['y']}) print('→', end='') elif ch == 's' or ch == 'B' or ch == b's' or ch == b'P': if self.can_move('s'): self.cursor_move({'x': self._cursor_loc['x'], 'y': self._cursor_loc['y'] + 1}) print('↓', end='') elif ch == 'a' or ch == 'D' or ch == b'a' or ch == b'K': if self.can_move('a'): self.cursor_move({'x': self._cursor_loc['x'] - 1, 'y': self._cursor_loc['y']}) print('←', end='') elif ch.lower() == 'q' or ch == b'q': print('game quit!') sys.stdout.flush() break elif ch == ' ' or ch == b' ': if not self._checked: self.do_check() print('选中', end='') else: self.do_release() print('释放', end='') # 判定游戏是否结束 if self.game_over: print('\ngame over!, 胜利方是:' + self.winner) sys.stdout.flush() break else: print('无效按键', end='') # 立刻刷新输入流，否则getch()获取的字符不会立刻显示 sys.stdout.flush() def can_check(self): tmp = self._cursor_original_backup.get_camp() if tmp != constants.CAMP_RED and tmp != constants.CAMP_WHITE: return False if self.firster == constants.CAMP_RED and tmp == constants.CAMP_WHITE: return False if self.firster == constants.CAMP_WHITE and tmp == constants.CAMP_RED: return False return True def do_check(self): if self.can_check(): self._checked = ~self._checked self._pieces[self._cursor_loc['y']][self._cursor_loc['x']].set_pic(self.cursor_pic()) # 复制一份，和Java一样基础类型是值赋值，而对象是引用赋值 self._checked_loc = self._cursor_loc.copy() self.clear_map() self.show_map() def do_release(self): # 判定是否是取消，是取消则不翻转当前选手 if self._cursor_loc['x'] == self._checked_loc['x'] and self._cursor_loc['y'] == self._checked_loc['y']: self._checked = ~self._checked self._pieces[self._cursor_loc['y']][self._cursor_loc['x']].set_pic(self.cursor_pic()) self.clear_map() self.show_map() return if self.can_release(): self._checked = ~self._checked # 判断游戏是否结束 if self._cursor_original_backup.get_camp() != constants.CAMP_NONE and self._cursor_original_backup.get_type() == constants.CHESS_BOSS: self.game_over = True self.winner = self.firster # 切换释放棋子后的布局 self._cursor_original_backup = self._pieces[self._checked_loc['y']][self._checked_loc['x']] tmp = ChessPiece(self.PIECE_NONE, constants.CAMP_NONE) tmp.set_type(constants.CHESS_PIECE) self._pieces[self._checked_loc['y']][self._checked_loc['x']] = tmp self._pieces[self._cursor_loc['y']][self._cursor_loc['x']].set_pic(self.cursor_pic()) self.clear_map() self.show_map() # 切换选手 self.reverse_role() """ 策略层，TODO 待完善 """ def can_release(self): # 初步判定，至少不能吃自己这边的子【Python里函数调用太坑了吧，刚才self._cursor_original_backup.get_camp这种方式居然不报错。。】 if self._cursor_original_backup.get_camp() == self.firster: return False # 其他规则 tmp = self._pieces[self._checked_loc['y']][self._checked_loc['x']] if tmp.get_type() == constants.CHESS_BING: return self.strategies.bing(tmp, self._checked_loc, self._cursor_loc) if tmp.get_type() == constants.CHESS_CHE: return self.strategies.che(self._checked_loc, self._cursor_loc) if tmp.get_type() == constants.CHESS_PAO: return self.strategies.pao(self._cursor_original_backup, self._checked_loc, self._cursor_loc) if tmp.get_type() == constants.CHESS_MA: return self.strategies.ma(self._checked_loc, self._cursor_loc) if tmp.get_type() == constants.CHESS_XIANG: return self.strategies.xiang(tmp, self._checked_loc, self._cursor_loc) if tmp.get_type() == constants.CHESS_SHI: return self.strategies.shi(tmp, self._checked_loc, self._cursor_loc) if tmp.get_type() == constants.CHESS_BOSS: return self.strategies.boss(tmp, self._cursor_original_backup, self._checked_loc, self._cursor_loc) return True def reverse_role(self): if self.firster == constants.CAMP_RED: self.firster = constants.CAMP_WHITE else: self.firster = constants.CAMP_RED def start(self): self.clear_map() self.show_map() self.control() # 和类定义相关的代码就要求空两行，上面是类结束，所以这里需要空两行（当然不是强制的） if __name__ == '__main__': game = GameContext() game.clear_map() game.show_map() game.control()
6.接下来是策略模块，用于对各类棋子的移动和吃子进行限制，这个没啥好讲的，根据象棋规则看代码即可：
import math from chess_piece import ChessPiece import constants # 好吧，Python规范里要求类和其他代码之间空两行，而且要求整个文件最后一行是空行，然后#和前面的代码空两个空格 class ChessStrategy: pieces: [] _height = 0 _width = 0 _red_up = True _red_line = 4 _white_line = 5 _boss_x_left = 3 _boss_x_right = 5 _boss_y_red = 2 _boss_y_white = 7 # [ChessPiece]限定列表元素类型为ChessPiece def __init__(self, pieces: [ChessPiece], red_up: bool = True): self.pieces = pieces self._height = len(pieces) self._height = len(pieces[0]) # 红方是否在地图上方，这关乎到兵不能后退等问题 self._red_up = red_up # 红方和白方的楚河汉界线 if red_up: self._red_line = 4 self._white_line = 5 self._boss_y_red = 2 self._boss_y_white = 7 else: self._red_line = 5 self._white_line = 4 self._boss_y_red = 7 self._boss_y_white = 2 """ 是否直着走 """ def is_straight(self, origin: {}, dest: {}) -> bool: if (origin['x'] - dest['x']) * (origin['y'] - dest['y']) == 0: return True """ 兵的阵营，象棋地图，待移动兵的坐标 """ def bing(self, active: ChessPiece, origin: {}, dest: {}): # 存在斜着走判定 if not self.is_straight(origin, dest): return False # 存在移动超过多步判定 if abs(origin['x'] - dest['x']) > 1 or abs(origin['y'] - dest['y']) > 1: return False # 不能后退判定和过了河才能左右移动判定 if self._red_up: if active.get_camp() == constants.CAMP_RED: if dest['y'] - origin['y'] < 0: return False # 过河才能左右移动 if abs(dest['x'] - origin['x']) > 0: if origin['y'] <= self._red_line: return False else: if dest['y'] - origin['y'] > 0: return False # 过了河才能左右移动 if abs(dest['x'] - origin['x']) > 0: if origin['y'] >= self._white_line: return False else: # 红方在下面 if active.get_camp() == constants.CAMP_RED: if dest['y'] - origin['y'] > 0: return False # 过了河才能左右移动 if abs(dest['x'] - origin['x']) > 0: if origin['y'] >= self._white_line: return False else: if dest['y'] - origin['y'] < 0: return False # 过了河才能左右移动 if abs(dest['x'] - origin['x']) > 0: if origin['y'] <= self._white_line: return False return True """ 車 """ def che(self, origin: {}, dest: {}): if not self.is_straight(origin, dest): return False if abs(origin['x'] - dest['x']) == 1 or abs(origin['y'] - dest['y']) == 1: return True # 横着走 if origin['x'] - dest['x'] != 0: for idx in range(min(origin['x'], dest['x']) + 1, max(origin['x'], dest['x'])): if self.pieces[dest['y']][idx].get_type() != constants.CHESS_PIECE: return False else: # 竖着走 for idx in range(min(origin['y'], dest['y']) + 1, max(origin['y'], dest['y'])): if self.pieces[idx][dest['x']].get_type() != constants.CHESS_PIECE: return False return True """ 炮 """ def pao(self, dest_piece: ChessPiece, origin: {}, dest: {}): if not self.is_straight(origin, dest): return False middle_count = 0 if origin['x'] - dest['x'] != 0: # 横着走 for idx in range(min(origin['x'], dest['x']) + 1, max(origin['x'], dest['x'])): if self.pieces[dest['y']][idx].get_type() != constants.CHESS_PIECE: middle_count += 1 else: # 竖着走 for idx in range(min(origin['y'], dest['y']) + 1, max(origin['y'], dest['y'])): if self.pieces[idx][dest['x']].get_type() != constants.CHESS_PIECE: middle_count += 1 if middle_count > 1: return False if middle_count == 1 and dest_piece.get_camp() == constants.CAMP_NONE: return False if middle_count == 0 and dest_piece.get_camp() != constants.CAMP_NONE: return False return True def ma(self, origin: {}, dest: {}): # 走日字判断 if abs((origin['x'] - dest['x']) * (origin['y'] - dest['y'])) != 2: return False # 拗马脚判断 tmpy = math.trunc((dest['y'] - origin['y'])/2) tmpx = math.trunc((dest['x'] - origin['x'])/2) middlex = origin['x'] + tmpx middley = origin['y'] + tmpy if self.pieces[middley][middlex].get_camp() != constants.CAMP_NONE: return False return True def xiang(self, active: ChessPiece, origin: {}, dest: {}): # 判断是否是田字走法 if abs(origin['x'] - dest['x']) != 2 or abs(origin['y'] - dest['y']) != 2: return False # 判断是否拗象脚 tmpx = (dest['x'] - origin['x'])//2 + origin['x'] tmpy = (dest['y'] - origin['y'])//2 + origin['y'] if self.pieces[tmpy][tmpx].get_camp() != constants.CAMP_NONE: return False # 象不能过河的判断 if self._red_up: if active.get_camp() == constants.CAMP_RED: if dest['y'] > self._red_line: return False else: if dest['y'] < self._white_line: return False else: # 红方在下面 if active.get_camp() == constants.CAMP_RED: if dest['y'] < self._red_line: return False else: if dest['y'] > self._white_line: return False return True def shi(self, active: ChessPiece, origin: {}, dest: {}): # 判断是否走的斜线且距离为1 if abs((dest['x'] - origin['x']) * (dest['y'] - origin['y'])) != 1: return False # 判断是否移出左右边界 if dest['x'] < self._boss_x_left or dest['x'] > self._boss_x_right: return False # 判断是否移出Y轴边界 if self._red_up: if active.get_camp() == constants.CAMP_RED: if dest['y'] > self._boss_y_red: return False else: if dest['y'] < self._boss_y_white: return False else: # 红方在下面 if active.get_camp() == constants.CAMP_RED: if dest['y'] < self._boss_y_red: return False else: if dest['y'] > self._boss_y_white: return False return True def boss(self, active: ChessPiece, dest_piece: ChessPiece, origin: {}, dest: {}): # 判断是否将帅见面，这种情况下可以移动到对方大本营里吃对方主将 if active.get_type() == constants.CHESS_BOSS and dest_piece.get_type() == constants.CHESS_BOSS and origin['x'] == dest['x']: middle_count = 0 for idx in range(min(origin['y'], dest['y']) + 1, max(origin['y'], dest['y'])): if self.pieces[idx][dest['x']].get_type() != constants.CHESS_PIECE: middle_count += 1 break if middle_count == 0: return True # 判断是否走的直线且距离为1 if abs(dest['x'] - origin['x']) + abs(dest['y'] - origin['y']) != 1: return False # 判断是否移出左右边界 if dest['x'] < self._boss_x_left or dest['x'] > self._boss_x_right: return False # 判断是否移出Y轴边界 if self._red_up: if active.get_camp() == constants.CAMP_RED: if dest['y'] > self._boss_y_red: return False else: if dest['y'] < self._boss_y_white: return False else: # 红方在下面 if active.get_camp() == constants.CAMP_RED: if dest['y'] < self._boss_y_red: return False else: if dest['y'] > self._boss_y_white: return False return True
7.最后就是main模块，其实就是创建个游戏环境类然后运行游戏的作用：
# coding:utf-8 import platform import sys if __name__ == '__main__': system = platform.system() if system == 'Windows': print('请使用Linux系统，最好是Ubuntu18.x版本，否则其他的控制台输出的布局可能会不整齐') # exit() if sys.version_info < (3, 0) or sys.version_info >= (4, 0): print('请使用Python3.x') exit() print("Game started.") import game_context import constants game = game_context.GameContext(constants.CAMP_WHITE) game.start()
六：源码分析
这里主要分析游戏环境类，这个是整个游戏的关键；
1.象棋的地图是通过二维的ChessPiece数组来实现管理的；通过二维数组来实现打印出棋子、光标、空白，这三种都是ChessPiece，不过是它们的阵营，pic等不同
2.在游戏环境类里通过类属性，记录由谁先行，游戏是否结束，胜利方是谁，是否选中棋子，当前光标位置，选中棋子的位置等数据，用于后续的逻辑判定
3.在init方法里初始化象棋地图，然后每个棋子都自我实现了printc方法来打印自己（包括颜色，文本/pic），以及初始化光标等参数
4.这里实现光标移动原理其实就是getch()获得移动按键后，然后修改_pieces，接着清屏和show_map()，这些方法都在类里可以找到；
5.游戏的控制逻辑在control(self)方法里实现，通过循环调用getch()不断的监听按键输入，然后判断按键类型，如果是方向键则通过cursor_move()方法来实现移动光标，内部通过can_move()来判断是否可以进行方向移动
，比如肯定不能越界；然后判断如果是空格键，表示是要选中棋子或者释放棋子，这里则通过判断当前光标是释放状态还是选中状态来分别执行do_check()和do_release()，在do_check()里通过can_check()来判断是否可以
选中某个piece（因为象棋地图里每个元素都是piece，所以肯定需要判断当前光标所在位置的piece是不是象棋棋子还是空白棋子），选中后光标的图案也会改变；
在do_release()里也是通过can_release()来判断是否可以释放棋子，比如咱们选中了白方棋子，那么释放棋子的地方肯定不能是另一个白方棋子，因为自己人不能吃自己人。。；然后在can_release()里调用策略模块里的策略
，分别对不同类型的棋子进行规则判断，比如炮吃子的话只能隔一个子吃，馬走日且不能拗马脚等等；
6.总结：重要的方法为control()，cursor_move()，can_move()，do_check()，can_check()，do_release()，can_release()，__init()__这些都是主要的业务逻辑判断；
七：其他
这里还有个我用Rust写的俄罗斯方块，不过文章没有写的很全但是代码啥的都在github里了，大家有兴趣可以去看看：https://www.cnblogs.com/silentdoer/p/12160871.html