游戏软件设计说明

XXXXXX游戏软件设计说明
1引言
1.1标识
本文档是棋牌游戏XXXXXXXXXXXX游戏软件设计说明文档，阅读对象是产品开发，测试和维护人员。

1.2范围
本文档包括软件产品的系统设计和详细设计两大部分，系统设计部分主要描述产品的模块划分，相互依赖关系和交互接口，详细设计部分通过包图、类图、状态图等描述系统功能的具体实现方法和流程。

1.3定义和缩写
1.“本软件”或“本产品”指：
(1)XXXXXXXXXXXX游戏软件V1.0。

(2)相关的说明性书面材料、说明书以及电子文档（如果有的话）。

(3)XXXXXX公司许可您使用的本软件的相关的更新程序，或者修改版（如果有的话）。

2.“使用”指对本软件安装、设置或者以其他方式对本软件做功能性使用。

3.“用途”指您使用本软件的限制和范围。

4.“XXXXXXXXXXXX游戏软件”缩写“XXXXXXXXXXXX”。

2参考献文
【1】软件设计说明：Survivor之新东方客栈软件设计说明来源于。

3 结构设计
3.1 服务端模块分解
XXXXXXXXXXXX服务端共分为四个模块：游戏棋盘模块（Chessboard），棋盘服务模块（ChessboardSink2pSuper）游戏桌子模块（TableFrameSink），游戏服务器管理模块（Gam
eServerManager
）。

图 3-1-1-1 服务端模块划分
3.1.1 模块1 游戏棋盘模块 说明
本模块定义了棋子数组和各个子的走法，包括车、马、炮这几个特殊棋子的走法和吃子规则（CanRookMove 、CanHorseMove 、CanCannonEat ）并提供一个对外部游戏判断棋子是否可行可吃的总接口Action ，针对车、马、炮这三个特殊的棋子，还分别提供了SearchRoo kPath 、 SearchHorsePath 、SearchCannonEatPath 这三个搜寻可走路径的函数
3.1.2 模块 2 棋盘服务模块 说明
本模块接手了模块3的功能，定义了服务端游戏控制流程，包括游戏初始化、等待、属性、开始游戏，游戏结束和结算，分别有各自的控制逻辑和交互界面。

3.1.3 模块 3 游戏桌子模块 说明
本模定义了棋盘服务的建立，使用棋盘服务控制游戏流程。

3.1.4模块 4游戏服务器管理模块 说明
本模块定义了服务端的建立，主要成员函数包括：创建游戏桌（CreateTableFrameSink ）。

XXXXXXXXX 游戏软件V1.0
3 / 27
3.2 客户端模块分解
XXXXXXXXXXXX 客户端共分四个模块：游戏对话框模块（GameClientDlg ），游戏视图模块（CGameView ），游戏棋盘模块（ChessboardView ），猜拳模块（GuessView
）
图 3-2-1-1 客户端模块划分
3.2.1 模块 1游戏对话框模块 说明
本模块定义了客户端游戏控制流程，如：游戏设置（OnGameOptionSet ）用于功能设置，网络消息（OnGameMessage ）用于发送用户游戏消息，游戏场景（OnGameSceneMess age ）用于发送游戏过程状态
3.2.2 模块 2 游戏场景模块 说明
本模块定义了游戏进行时的场景，游戏场景包括区域的绘制、场景信息贴图，走棋动画。

3.2.3 模块 3游戏逻辑模块 说明
本模块定义了棋子数组和各个子的走法，包括车、马、炮这几个特殊棋子的走法和吃子规则（CanRookMove 、CanHorseMove 、CanCannonEat ）并提供一个对外部游戏判断棋子是否可行可吃的总接口Action ，针对车、马、炮这三个特殊的棋子，还分别提供了SearchRoo kPath 、 SearchHorsePath 、SearchCannonEatPath 这三个搜寻可走路径的函数
3.2.4 模块4猜拳模块说明
本模块定义了猜拳游戏场景的渲染，猜拳动画，用于决定哪个玩家先行棋
3.3全局数据结构说明
3.3.1 常量
(1) 服务端常量
WORD g_wGamePlayer; //游戏人数WORD g_wGameMode; //游戏模式
ITableFrame * m_pITableFrame; //框架接口const tagGameServiceOption * m_pGameServiceOption; //配置参数static const enStartMode m_GameStartMode; //开始模式ChessboardSink * m_pChessboardSink;
//棋盘服务（服务端的网络消息处理和其他变量都交给棋盘服务）
棋盘服务常量：
static const BYTE m_cbBuyPropsBaseCoin[5]; //购买道具的基数static const BYTE m_cbPropsLimitBuyCount[5]; //限制购买道具数量 (2) 客户端常量
CGameView * g_pGameView; //游戏视图CGuessView * g_pGuessView; //猜拳视图
3.3.2 变量
(1) 服务端变量(棋盘服务变量)
所在类：ChessboardSink2pSuper
Chessboard2pSuper m_chessboard; //棋盘LONG m_lPropsCostCoin[5]; //道具花费LONG m_lBuyPropsCoin[2]; //各个玩家购买道具的金币数bool m_isBoughtProps[2][5]; //玩家是否购买了某个道具BYTE m_cbBoughtPropsCount[2][5]; //购买了某个道具的数量BYTE m_cbFreePropsCount[2][5]; //玩家获得某个免费道具的数量WORD m_wBeLimitedCount[2]; //玩家被人使用了禁锢道具的数量BYTE m_cbPeepCount[2]; //玩家使用马灯的数量PEEP *m_pPeep[2];
//玩家拥有的马灯结构(包括透视周围三颗棋子的坐标)
WORD m_wFreePropsUsedCount[2][5]; //免费道具使用数量bool m_isUsedBoughtProps[2]; //是否使用了购买的道具WORD m_wBuyPropsUsedCount[2][5]; //购买道具使用数量
XXXXXXXXX游戏软件V1.0
WORD m_wBeUsedPropsCount[2][5]; //被道具作用次数LONG m_lUserUsedPropsCoin[2]; //各个玩家使用道具的金币数CMD_S_Guess m_guess; //猜谁先行Chess m_clientChessArr[6][6]; //对应的客户端的棋盘数组Chess m_seizeChessArr[2][16]; //玩家吃子数组BYTE m_cbSeizeChessCount[2]; //玩家吃子数BYTE m_cbPromisePeaceCount[2]; //玩家被答应和棋的数量BYTE m_cbPromiseGiveupCount[2]; //玩家被答应认输的数量WORD m_wBegPeaceStatus[2]; //玩家求和状态WORD m_wBegGiveupStatus[2]; //请求认输状态WORD m_wTimeOutCount[2]; //玩家超时次数WORD m_wThinkTime[2]; //思考时间（可变）bool m_isOver[2]; //玩家是否被吃光棋子或者主动认输bool m_isRevokeOffLine[2]; //是否掉线后回来BYTE m_cbColor[2]; //玩家所执的棋子颜色WORD m_wCurrentUser; //当前玩家WORD m_wStepCount; //当前游戏步数WORD m_wTimeUsed; //每步已用时WORD m_wMoveToNullCount; //空步（只是单纯的移动棋子）数，用于判断和棋WORD m_wFirstRunUser; //先行者BYTE m_cbPlayStatus; //游戏开始后的状态 (2) 客户端变量
所在类：CGameView
WORD m_wGamePlayer; //游戏人数WORD m_wCurrentUser; //当前玩家WORD m_wLimitTime; //总时间WORD m_wStepLimitTime; //离超时还剩余的时间WORD m_wTimeOutCount; //超时次数bool m_isLimitTime; //是否限时bool m_isDrawTime; //是否画限时WORD m_wPeaceReqGapTime; //求和间隔时间WORD m_wGiveUpReqGapTime; //认输间隔时间WORD m_wStepCount; //游戏步数bool m_isLookon; //是否旁观bool m_isPeaceAnswered; //求和是否回应了bool m_isGiveUpAnswered; //认输是否回应了所在类：CgameView2pS(派生自CGameView)
ChessboardView2pS m_chessboardView; //棋盘视图BYTE m_cbColor[2]; //玩家执子颜色COLORREF m_textColor; //聊天文字颜色bool m_isOver[2]; //玩家是否完了WORD m_wThinkTime[2]; //玩家思考时间PEEP_3INFO *m_pPeep; //马灯结构指针WORD m_wPeepCount; //马灯数量
5 / 27
WORD m_wOtherPeepCount; //其他人的马灯数量WORD m_wTrapCount; //陷阱数量BYTE m_cbPropsCount[5]; //各个道具可用数量
3.3.3消息结构
本软件消息结构包括游戏服务端消息结构和客户端消息结构，数据结构如下：
(1)服务端消息结构设计
服务端消息结构分为主要分两部分定义，服务端消息定义和消息结构。

消息定义
#define SUB_S_GAME_START 100//游戏开始#define SUB_S_MOVE_CHESS 101//移动棋子#define SUB_S_REGRET_REQ 102//悔棋请求#define SUB_S_REGRET_FAILE 103//悔棋失败#define SUB_S_REGRET_RESULT 104 //悔棋结果#define SUB_S_PEACE_REQ 105 //和棋请求#define SUB_S_PEACE_ANSWER 106 //和棋应答#define SUB_S_GAME_END 107 //游戏结束#define SUB_S_CHESS_MANUAL 108 //棋谱信息#define SUB_S_REQ_SET_RULE 109 //请求设置#define SUB_S_REQ_AGREE_RULE 110 //请求同意
#define SUB_S_OPEN_CHESS 111 //翻开棋子#define SUB_S_FIRSTOPEN_CHESS 112 //未确定颜色时，第一次翻开棋子#define SUB_S_CLOSE 114 //强退#define SUB_S_GIVEUP_REQ 115 //认输#define SUB_S_GIVEUP_ANSWER 116 //认输应答#define SUB_S_CURRENT_USER 117 //指派谁走棋#define SUB_S_GUESS 118 //猜谁先走#define SUB_S_START_GUESS 119 //开始猜先#define SUB_S_SOMEONEGUESS 120 //某人已经出手了#define SUB_S_BREAK_END 121 //强退结束#define SUB_S_PEACE_END 122 //和棋结束#define SUB_S_NORMAL_END 123 //正常结束#define SUB_S_GUESSING_END 124 //猜拳状态下结束#define SUB_S_TIME_OUT 125 //玩家超时#define SUB_S_MOVE_STILL 127
#define SUB_S_OPEN_PROPS 130 //翻开道具#define SUB_S_USER_OVER 135 //玩家被吃光了#define SUB_S_PROPS_RESTART 140 //重开#define SUB_S_PROPS_BOMB 141 //炸弹#define SUB_S_PROPS_PEEP 142 //走马灯#define SUB_S_PROPS_TRAP 143 //陷阱#define SUB_S_PROPS_LIMIT 144 //禁锢
XXXXXXXXX游戏软件V1.0
#define SUB_S_PROPS_WINLOST 145 //胜负道具#define SUB_S_OTHER_USER_PEEP 149 //其他玩家设置了马灯
#define SUB_S_NOT_ENOUGH_COIN 150 //金币不足#define SUB_S_BUY_SUCCESS 151 //购买成功#define SUB_S_REMOVE_LIMIT 160 //消除禁锢#define SUB_S_IN_TRAP 161 //中陷阱#define SUB_S_NO_EFFECT 162
#define SUB_S_MOVING_FOUND_TRAP 163 //移动棋子发现陷阱而无法移动#define SUB_S_LAYPROPS_FOUND_TRAP 164 //放置道具发现陷阱而无法移动 消息结构
struct ChessWithCoord
{
BYTE iBePeeped;
BYTE jBePeeped;
Chess chess;
};
struct CHESS_COORD //棋子数组坐标
{
BYTE i;
BYTE j;
};
struct TRAP
{
BYTE iTrap;
BYTE jTrap;
WORD wTrapUser;
};
struct CMD_S_FirstOpenChess
{
BYTE i; //棋子数组下标BYTE j;
Chess chess; //棋子WORD wCurrentUser; //当前玩家WORD wOpenUser;
WORD wOpenUserThinkTime; //翻棋玩家思考时间};
struct CMD_S_OpenChess
{
BYTE i; //棋子数组下标BYTE j;
Chess chess; //棋子
WORD wCurrentUser; //当前玩家WORD wOpenUser;
7 / 27
WORD wOpenUserThinkTime; //翻棋玩家思考时间};
struct CMD_S_OpenProps
{
BYTE i; //
BYTE j; //
Chess chess; //
WORD wCurrentUser; //
WORD wOpenUserThinkTime; //翻棋玩家思考时间};
struct CMD_S_MoveChess
{
WORD wMoveUser; //移动棋子的玩家BYTE iSrc; //
BYTE jSrc; //
BYTE iDst; //
BYTE jDst; //
WORD wCurrentUser; //当前玩家WORD wMoveUserThinkTime; //翻棋玩家思考时间};
struct CMD_S_StartGuess
{
WORD wGuessUser1; //猜先玩家一WORD wGuessUser2; //猜先玩家二};
struct CMD_S_SomeoneGuess
{
WORD wGuessUser; //已出手的玩家};
struct CMD_S_Close
{
WORD wCloseUser; //强退玩家};
struct CMD_S_PeaceRequest
{
WORD wPeaceRequestUser; //求和玩家};
struct CMD_S_GiveUp
{
WORD wGiveupUser; //认输玩家};
struct CMD_S_CurrentUser
XXXXXXXXX游戏软件V1.0
{
WORD wCurrentUser; //服务器指定谁走下一步};
typedef struct tagSystemAction
{
BYTE cbActionType; //系统帮走类型BYTE iSrc;
BYTE jSrc;
BYTE iDst; //若cbActionType不等于ACTION_MOVE，此值作废BYTE jDst;
} SYSTEMACTION;
struct CMD_S_TimeOut
{
WORD wTimeOutUser;
WORD wThinkTime;
WORD wCurrentUser;
};
struct CMD_S_Guess
{
WORD wGuessUser1; //玩家一WORD wGuessUser2; //玩家二BYTE cbGuessUser1Type; //石头剪刀布其中之一BYTE cbGuessUser2Type; //石头剪刀布其中之一};
struct CMD_S_GuessResult
{
CMD_S_Guess guess; // WORD wWinner; //赢家椅子号};
struct CMD_S_Over
{
WORD wOverUser; //被吃光棋子的玩家};
struct CMD_S_BuySuccess
{
BYTE cbPropsType; //道具类型};
struct CMD_S_Props_Restart
{
WORD wCurrentUser; //当前玩家};
struct CMD_S_Props_Bomb
{
BYTE i; //被炸棋子数组下标
9 / 27
BYTE j;
bool isNoBomb; //是否没有炸弹道具了WORD wCurrentUser; //当前玩家WORD wBombUser; //扔炸弹玩家WORD wBeBombedUser; //被炸玩家};
struct CMD_S_Props_Trap
{
BYTE iTrap; //陷阱下标BYTE jTrap;
bool isNoTrapProps; //是否没有陷阱道具了WORD wTrapUser; //设置陷阱的玩家WORD wCurrentUser;
};
struct CMD_S_InTrap
{
WORD wMoveUser; //移动棋子的玩家WORD wTrapUser; //设置陷阱的玩家BYTE iSrc; //
BYTE jSrc; //
BYTE iDst; //
BYTE jDst; //
WORD wCurrentUser;//当前玩家WORD wMoveUserThinkTime; //移动玩家思考时间};
struct CMD_S_Props_Limit
{
bool isNoLimitProps; //是否没有禁锢道具了WORD wLimitUser; //使用限制道具的玩家WORD wBeLimitUser; //被限制玩家WORD wCurrentUser; //当前玩家};
struct CMD_S_RemoveLimit
{
WORD wBeLimitUser; //被限制玩家};
struct CMD_S_No_Effect
{
BYTE cbPropsType;
};
/****************************************************************************** *****/
struct tagGameAwardData
XXXXXXXXX游戏软件V1.0
{
//奖券奖励条件(局数)
WORD wGameNumberOfCrystalAward[CRYSTALAWARD_CONDICTION_COUNT];
//服务费的百分比作为奖券奖励
BYTE cbPercentOfService[CRYSTALAWARD_CONDICTION_COUNT];
//积分等级
short sScoreForLevel[SCORE_LEVEL_COUNT];
//奖券加成百分比
BYTE cbPercentOfCrystalAward[SCORE_LEVEL_COUNT];
};
struct CMD_S_Guessing_GameEnd
{
WORD wBreakUser; //猜拳状态下强退的玩家};
struct CMD_S_Break_GameEnd_2p
{
WORD wBreakUser; //强退玩家LONG lFleeGoldCoin; //强退玩家被扣除金币数LONG lFleeScore; //强退玩家被扣除分数LONG lWinnerGameGoldCoin;//赢家赢得的游戏金币LONG lGameRevenue; //服务费用LONG lWinnerGameScore; //赢家游戏分数LONG lWinnerGameExp; //赢家经验值BYTE cbSeizeChessCount[2]; //玩家吃子数};
struct CMD_S_Peace_GameEnd_2p
{
LONG lGameRevenue;
BYTE cbSeizeChessCount[GAME_PLAYER_2P];
};
struct CMD_S_Normal_GameEnd_2p
{
WORD wWinner; //其中之一赢家LONG lWinnerGameGoldCoin;//赢家赢得的游戏金币LONG lGameRevenue; //服务费用（金币）LONG lWinnerGameScore; //赢家赢得的游戏分数LONG lWinnerGameExp; //赢家经验值LONG lLoserGameExp; //输家经验值BYTE cbSeizeChessCount[2]; //玩家吃子数};
struct PEEP
{
BYTE iPeep;
11 / 27
BYTE jPeep;
WORD wPeepUser;
ChessWithCoord chessWithCoord[3];
};
struct OTHER_PEEP
{
BYTE iPeep;
BYTE jPeep;
WORD wPeepUser;
};
struct CMD_S_Props_Peep
{
BYTE iPeep; //走马灯所在数组下标BYTE jPeep;
bool isNoPeepProps; //是否没有马灯道具了WORD wCurrentUser; //当前玩家ChessWithCoord chesswithcoord[3];//走马灯透视周围三颗棋子};
struct CMD_S_OtherUser_Peep
{
BYTE iPeep;
BYTE jPeep;
WORD wPeepUser; //使用马灯的玩家WORD wCurrentUser; //当前玩家};
struct CMD_S_StatusFree_2p_Super
{
WORD wGamePlayer; //玩家数量WORD wGameMode;//游戏模式，0为经典场，1为超级场tagGameRuleInfo GameRuleInfo; //游戏规则tagGameAwardData GameAwardData; //奖券奖励数据LONG lCellScore; //房间倍数void *pServerData; //服务器端的数据BYTE cbBuyPropsBaseCoin[5];//道具购买基数，乘以房间倍率就是道具价格BYTE
cbPropsLimitBuyCount[5];//道具限制购买数量
};
struct CMD_S_StatusGuess_2p_Super
{
WORD wGamePlayer;
WORD wGameMode; //游戏模式，0为经典场，1为超级场tagGameRuleInfo GameRuleInfo; //游戏规则tagGameAwardData GameAwardData; //奖券奖励数据LONG lCellScore; //房间倍数
XXXXXXXXX游戏软件V1.0
bool isUser1Guess; //玩家数量bool isUser2Guess;
bool isRevokeOffLine; //是否是断线重连BYTE cbBuyPropsBaseCoin[5];//道具购买基数，乘以房间倍率就是道具价格BYTE cbPropsLimitBuyCount[5]; //道具限制购买数量};
struct CMD_S_StatusPlay_2p_Super
{
WORD wGamePlayer; //玩家数量WORD wGameMode;//游戏模式，超级场为1，普通场为0 tagGameRuleInfo GameRuleInfo; //游戏规则tagGameAwardData GameAwardData; //奖券奖励数据LONG lCellScore; //房间倍数WORD wCurrentUser;//当前玩家WORD wStepCount; //走棋步数BYTE cbColor[GAME_PLAYER_2P];
Chess ChessArr[V_COUNT_2P_S][H_COUNT_2P_S];
Chess lostChessArr[GAME_PLAYER_2P][SEIZE_CHESS_COUNT_2P];
WORD wThinkTime[GAME_PLAYER_2P]; //思考时间WORD wTimeRemaining;
bool isRevokeOffLine; //是否是断线重连bool isLimited[GAME_PLAYER_2P];
BYTE cbPeepCount; //马灯数量BYTE cbOtherPeepCount; //其他人的马灯数量BYTE cbTrapCount; //陷阱数量BYTE cbPropsCount[5]; //道具数量
BYTE cbBoughtPropsCount[5];//购买过的道具数量bool isOver[GAME_PLAYER_2P];
BYTE
cbBuyPropsBaseCoin[5];//道具购买基数，乘以房间倍率就是道具价格
BYTE
cbPropsLimitBuyCount[5];//道具限制购买数量
};
(2)客户端消息结构设计
客户端消息结构主要也分两部分定义，客户端消息定义和消息结构。

消息定义
#define SUB_C_MOVE_CHESS1//移动棋子
#define SUB_C_TIME_OUT2//走棋超时#define SUB_C_REGRET_REQ3//悔棋请求#define SUB_C_REGRET_ANSWER4//悔棋应答
13 / 27
#define SUB_C_PEACE_REQ5//和棋请求#define SUB_C_PEACE_ANSWER6//和棋应答
#define SUB_C_GIVEUP_REQ7//认输请求#define SUB_C_GIVEUP_ANSWER 8 //认输应答#define SUB_C_OPEN_CHESS 10 //翻开棋子#define SUB_C_GUESS 12 //猜谁先行#define SUB_C_GUESS_TIMEOUT 13 //猜棋超时#define SUB_C_BUY_PROPS 25 //购买道具#define SUB_C_PROPS_RESTART 30 //使用重开#define SUB_C_PROPS_BOMB 31 //使用炸弹#define SUB_C_PROPS_PEEP 32 //使用走马灯#define SUB_C_PROPS_TRAP 33 //使用陷阱#define SUB_C_PROPS_LIMIT 34 //使用禁锢#define SUB_C_PROPS_WINLOST 35 //胜负道具 消息结构
//翻开棋子
struct CMD_C_OpenChess
{
BYTE i;
BYTE j;
};
struct CMD_C_Guess
{
BYTE cbGuessType; //石头剪刀布其中之一};
struct CMD_C_TimeOut
{
SYSTEMACTION systemAction; //系统帮走};
//移动棋子
struct CMD_C_MoveChess
{
BYTE iSrc; //棋子数组下标BYTE jSrc; //棋子数组下标BYTE iDst; //棋子数组下标BYTE jDst; //棋子数组下标};
typedef CMD_C_MoveChess CMD_C_PropsToProps, CMD_C_PropsToChess;
//悔棋响应
struct CMD_C_RegretAnswer
{
XXXXXXXXX游戏软件V1.0
BYTE cbApprove;
//同意标志
};
//和棋响应
struct CMD_C_PeaceAnswer
{
WORD wPeaceRequestUser; //求和玩家BYTE cbApprove; //同意标志};
struct CMD_C_GiveUpAnswer
{
WORD wGiveupUser; //认输玩家bool isAgree; //是否同意};
//定制规则
struct CMD_C_CustomizeRult
{
tagGameRuleInfo GameRuleInfo; //游戏规则};
//购买道具
struct CMD_C_BuyProps
{
BYTE cbPropsType; //道具类型};
struct CMD_C_Props_Bomb
{
BYTE i; //被炸棋子棋盘下标BYTE j;
};
struct CMD_C_Props_Peep
{
BYTE i; //走马灯棋盘下标BYTE j;
};
struct CMD_C_Props_Trap
{
BYTE i; //陷阱棋盘下标BYTE j;
};
struct CMD_C_Props_Limit
{
WORD wBeLimitedUser; //被限制的玩家};
15 / 27
4 依赖关系说明
4.1模块间的依赖关系
4.1.1 服务端
模块3（游戏桌子模块）依赖于模块4（游戏服务器管理模块），模块3（游戏桌子模块）初始化工作在模块 4（游戏服务器管理模块）中完成。

模块 2 （棋盘服务模块）依赖于模块 3（游戏桌子类），接手模块3的游戏控制流程。

模块2（游戏桌子类）依赖于模块
1（棋盘模块），主要反映在游戏过程中的行棋规则，如棋的大小比较，用户能不能行棋。

模块2（棋盘服务模块）和模块4（游戏服务器管理模块）没有直接依赖关系，也没有消息传递和调用的关系。

模块1（棋盘模块）和模块4（游戏服务器管理模块）没有直接依赖关系，也没有消息传递和调用的关系。

4.1.2 客户端
模块1（游戏对话框模块）依赖于模块2（游戏视图模块），主要反映在游戏主界面，背景区域的贴图，以及行棋时的动画。

模块1（游戏对话框模块）依赖于模块4（猜拳模块），主要反映在猜拳界面，背景区域的贴图，以及猜拳时的动画。

模块2（游戏视图模块）依赖于模块3（棋盘视图模块），主要反映在游戏过棋盘界面的描绘，游戏界面的点击，棋盘规则和死子的绘画。

模块1（游戏对话框模块）和模块3（游戏视图模块）有没有直接依赖关系。

两者通过模块2间接的有消息传递和调用。

当用户通过猜拳界面进入游戏界面时，模块2（游戏视图模块）依赖与模块4（猜拳模块），主要体现在猜拳结果决定游戏进行时谁先翻棋
4.2 进程间的依赖关系
4.2.1 服务端
进程4创建进程3，进程3创建进程2，进程2需要调用进程1中的方法获取当前状态和属性，来完成自身一些功能，。

如判断客户端发过来的游戏规则信息是否符合规定的。

XXXXXXXXX游戏软件V1.0
4.2.2 客户端
掉线情况下进程1创建进程2，正常情况下进程1创建进程4，进程4创建进程2，进程2创建进程3，.进程1的网络逻辑交给进程2或进程4处理，如道具的使用，进程2的行棋逻辑交给进程3处理，如行棋的判断。

进程2作为进程1的视图模块，负责显示界面与动画。

进程3作为进程2的附属显示模块，负责棋盘的显示，棋子动画和死子的显示。

进程4作为游戏入口模块，负责进程2游戏开始时的行棋次序
5接口说明
5.1 服务端模块接口
♦GetGameStartMode();
开始模式
♦IsUserPlaying(WORD wChairID);
游戏状态
♦OnEventGameStart();
游戏开始
♦OnEventGameEnd(WORD wChairID, IServerUserItem * pIServerUserItem, BYTE cbReason);
游戏结束
♦SendGameScene(WORD wChiarID, IServerUserItem * pIServerUserItem, BYTE bGameStatus, bool bSendSecret);
游戏状态消息处理。

♦OnGameMessage(WORD wSubCmdID, const void * pDataBuffer, WORD wDataSize, IServerUserItem * pIServerUserItem);
游戏过程消息。

5.2 客户端模块接口
♦OnGameOptionSet();
游戏设置
♦OnGameMessage(WORD wSubCmdID, const void * pBuffer, WORD wDataSize);
游戏网络消息
17 / 27
♦OnGameSceneMessage(BYTE cbGameStatus, bool bLookonOther, const void * pBuffer, WORD wDataSize);
游戏状态消息
♦OnSubGameStart(const void * pBuffer, WORD wDataSize);
开始游戏
♦OnSubFirstOpenChess( const void *pBuffer, WORD wDataSize );
未确定颜色时，第一次翻开棋子
♦OnSubOpenChess( const void *pBuffer, WORD wDataSize );
翻开棋子
♦OnSubMoveChess( const void *pBuffer, WORD wDataSize );
移动棋子
♦OnSubOpenProps( const void *pBuffer, WORD wDataSize );
翻开道具
♦OnSubPeaceReq( const void *pBuffer, WORD wDataSize );
和棋请求
♦OnSubCurrentUser( const void *pBuffer, WORD wDataSize );
指派玩家走棋
♦OnSubMoveStill();
仍然是自己走棋
♦OnSubTimeOut( const void *pBuffer, WORD wDataSize );
玩家超时
♦OnSubPeaceAnswer( const void *pBuffer, WORD wDataSize );
和棋应答
♦OnSubUserGiveUpReq( const void *pBuffer, WORD wDataSize );
认输请求
♦OnSubUserGiveUpAnswer( const void *pBuffer, WORD wDataSize );
认输应答
♦OnSubBreakEnd( const void *pBuffer, WORD wDataSize );
强退结束
♦OnSubPeaceEnd( const void *pBuffer, WORD wDataSize );
和棋结束
♦OnSubNormalEnd( const void *pBuffer, WORD wDataSize );
正常结束
♦OnSubGFUserOffline( const void *pBuffer, WORD wDataSize );
玩家掉线
♦OnSubUserOver( const void *pBuffer, WORD wDataSize );
玩家完了
♦OnSubNotEnoughCoin();
金币不足
♦OnSubBuySuccess( const void *pBuffer, WORD wDataSize );
购买道具成功
XXXXXXXXX游戏软件V1.0♦OnSubPropsPeep( const void *pBuffer, WORD wDataSize );
自己使用马灯道具
♦OnSubOtherUserPeep( const void *pBuffer, WORD wDataSize );
其他玩家使用马灯道具
♦OnSubPropsRestart( const void *pBuffer, WORD wDataSize );
使用重开道具
♦OnSubPropsBomb( const void *pBuffer, WORD wDataSize );
使用炸弹道具
♦OnSubPropsTrap( const void *pBuffer, WORD wDataSize );
使用陷阱道具
♦OnSubInTrap( const void *pBuffer, WORD wDataSize );
中陷阱
♦OnSubPropsLimit( const void *pBuffer, WORD wDataSize );
使用禁锢道具
♦OnSubRemoveLimit( const void *pBuffer, WORD wDataSize );
移除禁锢道具
♦OnSubNoEffect( const void *pBuffer, WORD wDataSize );
操作无效
♦OnMovingFoundTrap();
移动棋子时发现陷阱
♦OnLayPropsFoundTrap( const void *pBuffer, WORD wDataSize );
放置道具时发现陷阱
6详细设计
6.1 游戏逻辑设计
本节我们将详细描述斗地主游戏的逻辑设计。

首先，斗地主的整个游戏逻辑图如下：
19 / 27
XXXXXXXXX游戏软件V1.0
XXXXXX游戏棋子数据我们定义如下：
棋子数据定义
//棋子颜色
#define COLOR_UNKNOWN 0xFF //未知方
#define COLOR_NULL 0x00 //空棋子
#define COLOR_RED 0x01 //红方(帅、仕、相、车、马、炮、兵)
#define COLOR_GREEN 0x02 //绿方(帅、仕、相、车、马、炮、兵)
#define COLOR_BLUE 0x03 //蓝方(将、士、象、车、马、炮、卒)
#define COLOR_PURPLE 0x04 //紫方(将、士、象、车、马、炮、卒)
//道具棋子颜色
#define COLOR_PROPS 0x05
#define CHESS_UNKNOWN 0xFF //棋子未翻转（未知）(与COLOR_UNKNOWN相对应)
#define CHESS_NULL 0x00 //没有棋子(与COLOR_NULL相对应)
//棋子定义
#define CHESS_GENERAL 0x07 //将(帅)
#define CHESS_KAVASS 0x06 //士(仕)
#define CHESS_ELEPHANT 0x05 //象(相)
#define CHESS_ROOK 0x04 //車
#define CHESS_HORSE 0x03 //马
#define CHESS_CANNON 0x02 //炮
#define CHESS_SOLDIER 0x01 //卒(兵)
//道具棋子
#define CHESS_BOMB 0x10 //限制对手走棋
#define CHESS_PEEP 0x20 //透视（周围三颗棋子）
#define CHESS_TRAP 0x30 //陷阱
#define CHESS_LIMIT 0x40 //毁灭陷阱的道具
//道具因子
#define PROPS_ONLY 0xF0 //11110000最高的四位表示道具
#define PROPS_NO_USER 0xF8 //11111000
#define PROPS_USED 0x08 //00001000第四位表示是否已经使用过
#define PROPS_USER 0x07 //00000111前三位表示玩家ID
对于XXXXXX游戏而言走棋判断是整个游戏算法中最为关键的一环，因此我们封装了一个函数
bool Action( BYTE iDst, BYTE jDst, BYTE iSrc, BYTE jSrc )用于走棋判断，该函数有四个输入参数，原棋子位置BYTE iSrc, BYTE jSrc走到目标位置BYTE
21 / 27
iDst, BYTE jDst。

下面我们详细描述一下走棋的算法。

Action函数详细设计
Step1. 判断是否越界
if( !(iDst < 6 && jDst < 6 && iSrc < 6 && jSrc < 6) )//防止溢出
return false;
Step2. 判断是否同颜色或原子为空
Chess &dstChess = m_chessArr[iDst][jDst];//简化名字
Chess &srcChess = m_chessArr[iSrc][jSrc];
if( dstChess.m_cbColor == srcChess.m_cbColor )
return false;
if( srcChess.IsNull() )//同类或原子为空
return false;
Step3. 目标棋子为空格时，能否走
if( dstChess.IsNull() )//目标地点为空格，则是移动棋子行为
return CanMove( iDst, jDst, iSrc, jSrc );
Step4. 目标不为空，看能否吃
if( srcChess.m_cbChess == CHESS_CANNON )//炮打吃
return CanCannonEat( iDst, jDst, iSrc, jSrc );
if( srcChess.m_cbChess == CHESS_HORSE ) //马吃
return CanHorseMove( iDst, jDst, iSrc, jSrc );
if( IsMoveOneGrid( iDst, jDst, iSrc, jSrc ) ) //若只移动一格
{
if( srcChess.m_cbChess == CHESS_CANNON )
return false;
return srcChess.CanEat( dstChess );
}
if( srcChess.m_cbChess == CHESS_ROOK
)//车吃棋的判断要放在移动单个格子的判断之后，因为车与相邻棋子的吃棋要按照大小吃return CanRookMove( iDst, jDst, iSrc, jSrc );
6.2服务端模块详细设计
6.2.1模块 1 棋盘模块详细设计
游戏中各种游戏规则主要由一个类实现的。

（1）C hessboard2pSuper类
实现游戏中，用户走棋判断，大小比较等功能。

LineObstacleCount
直线障碍数量
XXXXXXXXX游戏软件V1.0
♦CanCannonEat
炮能否打吃
♦CanRookMove
车能否行走
♦CanHorseMove
马能否行走
♦IsMoveOneGrid
是否移动了一格
♦CanMove
所有棋子的移动
♦Action
能否移动或吃棋
♦SearchHorsePath
寻找马当前可走路径
♦SearchRookPath
寻找车当前可走路径
♦SearchCannonEatPath
寻找炮当前可走路径
6.2.2 模块 2 棋盘服务模块详细设计
♦OnUserOpenChess
玩家翻棋
♦OnUserMoveChess
玩家移动棋子
♦MoveChessToProps
玩家移动棋子到道具
♦FoundEnemyTrap
发现敌人的陷阱
♦OnUserTimeOut
玩家超时
23 / 27
♦OnUserPeaceReq
玩家求和
♦OnUserPeaceAnswer
玩家求和应答
♦OnUserGiveUpReq
玩家认输
♦OnUserGiveUpAnswer
玩家认输应答
♦OnUserGuess
玩家猜拳
♦OnUserGuessTimeOut
玩家猜拳超时
♦OnUserBuyProps
玩家购买道具
♦OnUserPropsPeep
玩家使用马灯道具
♦OnUserPropsRestart
玩家使用重开道具
♦OnUserPropsBomb
玩家使用炸弹道具
♦OnUserPropsTrap
玩家设置陷阱道具
♦OnUserPropsLimit
玩家使用禁锢道具
6.2.3 模块 3 游戏桌子模块详细设计
除了以下函数，其他函数完全被棋盘服务模块接手（1）CTableFrameSink类
♦CTableFrameSink（）
构造函数，初始化相关成员变量。

XXXXXXXXX游戏软件V1.0
♦GetGameStartMode（）
开始模式，桌子满人满人后自动开始游戏。

♦IsUserPlaying（）
游戏状态，当用户按下开始或者满人后此函数返回ture。

♦OnEventGameStart（）
游戏开始，设置游戏状态为开始状态。

♦OnEventGameEnd（）
游戏结束，发送结束游戏信息，并将游戏数据请零。

♦SendGameScene（）
发送场景，发送游戏过程状态。

♦OnGameMessage（）
游戏消息处理。

6.2.3 模块 3 游戏服务器管理模块详细设计
（1）CGameServerManager类
♦CGameServerManager（）
构造函数，初始化相关成员变量。

♦CreateTableFrameSink（）
创建桌子。

6.3 客户端模块详细设计
6.3.1 模块 1 游戏对话框模块详细设计
（1）CGameClientDlg类
♦InitGameFrame（）
初始化函数，初始化相关成员函数。

♦OnGameOptionSet（）
游戏相关功能设置。

♦OnGameMessage（）
网络消息，游戏过程消息处理。

♦OnGameSceneMessage（）
25 / 27
游戏场景，发送游戏过程状态。

♦OnEventUserLeave（）
用户离开。

♦OnSubGameStart（）
游戏开始。

6.3.2 模块 2 游戏场景模块详细设计
（1）CGameView类
♦CGameView
构造函数，初始化相关成员函数。

♦Update
游戏逻辑函数
♦draw
绘画游戏场景
♦OnTimer
接替对话框模块进行计时器消息处理
♦OnGameMessage
接替对话框模块负责网络消息处理
6.3.3 模块 3 棋盘模块详细设计
（1）ChessboardView2pS类
♦ChessboardView2pS（）
构造函数，初始化相关成员变量。

♦LineObstacleCount（）
搜索直线上的障碍
♦CanCannonEat（）
判断炮能否打吃
♦CanRookMove（）
判断车能否移动
♦CanHorseMove（）
XXXXXXXXX游戏软件V1.0判断马能否移动
♦IsMoveOneGrid（）
判断是否是移动了一格
♦CanMove（）
判断所有棋子能否移动
♦Action（）
判断所有棋子能否移动或吃棋
♦SearchHorsePath（）
搜索马当前的移动路径
♦SearchRooklPath（）
搜索车当前的移动路径
♦SearchCannonlPath（）
搜索炮当前的吃子路径
6.3.4 模块 4猜拳模块详细设计
（1）CGuessView类
♦CGuessView
构造函数，初始化相关成员函数。

♦Update
游戏逻辑函数
♦draw
绘画猜拳场景
♦OnTimer
接替对话框模块进行计时器消息处理
♦OnGameMessage
接替对话框模块负责网络消息处理
27 / 27。