wnmj-normal/Classes/Define/CMD_LogonServer.h

#ifndef CMD_LONGON_HEAD_FILE
#define CMD_LONGON_HEAD_FILE

#include "../Define/DataStream.h"
#include "cocos2d.h"

//////////////////////////////////////////////////////////////////////////
#pragma pack(1)

//////////////////////////////////////////////////////////////////////////////////
//登录命令

#define MDM_GP_LOGON				1									//广场登录

//登录模式
#define SUB_GP_LOGON_GAMEID			1									//I D 登录
#define SUB_GP_LOGON_ACCOUNTS		2									//帐号登录
#define SUB_GP_REGISTER_ACCOUNTS	3									//注册帐号
#define SUB_GP_LOGON_VISITOR		5									//游客登录

//登录结果
#define SUB_GP_LOGON_SUCCESS		100									//登录成功
#define SUB_GP_LOGON_FAILURE		101									//登录失败
#define SUB_GP_LOGON_FINISH			102									//登录完成
#define SUB_GP_VALIDATE_MBCARD		103                                 //登录失败
#define SUB_GP_VALIDATE_PASSPORT	104									//登录失败  
#define SUB_GP_VERIFY_RESULT		105									//验证结果
#define SUB_GP_MATCH_SIGNUPINFO		106									//报名信息
#define SUB_GP_GROWLEVEL_CONFIG		107									//等级配置

//升级提示
#define SUB_GP_UPDATE_NOTIFY		200									//升级提示

//////////////////////////////////////////////////////////////////////////////////
//

#define MB_VALIDATE_FLAGS           0x01                                //效验密保
#define LOW_VER_VALIDATE_FLAGS      0x02                                //效验低版本
//

//////////////////////////////////////////////////////////////////////////////////
//携带信息 CMD_GP_LogonSuccess

#define DTP_GP_GROUP_INFO			1									//社团信息
#define DTP_GP_MEMBER_INFO			2									//会员信息
#define	DTP_GP_UNDER_WRITE			3									//个性签名
#define DTP_GP_STATION_URL			4									//主页信息

//////////////////////////////////////////////////////////////////////////////////
//列表命令

#define MDM_GP_SERVER_LIST			2									//列表信息

//获取命令
#define SUB_GP_GET_LIST				1									//获取列表
#define SUB_GP_GET_SERVER			2									//获取房间
#define SUB_GP_GET_ONLINE			3									//获取在线
#define SUB_GP_GET_COLLECTION		4									//获取收藏

//获取在线
struct CMD_GP_GetOnline
{
	uint16							wServerCount;						//房间数目
	uint16							wOnLineServerID[MAX_SERVER];		//房间标识
};

//类型在线
struct CMD_GP_KindOnline
{
	uint16							wKindCount;							//类型数目
	tagOnLineInfoKind				OnLineInfoKind[MAX_KIND];			//类型在线
};

//房间在线
struct CMD_GP_ServerOnline
{
	uint16							wServerCount;						//房间数目
	tagOnLineInfoServer				OnLineInfoServer[MAX_SERVER];		//房间在线
};


//列表信息
#define SUB_GP_LIST_TYPE			100									//类型列表
#define SUB_GP_LIST_KIND			101									//种类列表
#define SUB_GP_LIST_NODE			102									//节点列表
#define SUB_GP_LIST_PAGE			103									//定制列表
#define SUB_GP_LIST_SERVER			104									//房间列表
#define SUB_GP_LIST_MATCH			105									//比赛列表
#define SUB_GP_VIDEO_OPTION			106									//视频配置
	
//完成信息
#define SUB_GP_LIST_FINISH			200									//发送完成
#define SUB_GP_SERVER_FINISH		201									//房间完成

//在线信息
#define SUB_GR_KINE_ONLINE			300									//类型在线
#define SUB_GR_SERVER_ONLINE		301									//房间在线
#define SUB_GR_ONLINE_FINISH		302									//在线完成


//////////////////////////////////////////////////////////////////////////////////
//服务命令

#define MDM_GP_USER_SERVICE			3									//用户服务

//账号服务
#define SUB_GP_MODIFY_MACHINE		100									//修改机器
#define SUB_GP_MODIFY_LOGON_PASS	101									//修改密码
#define SUB_GP_MODIFY_INSURE_PASS	102									//修改密码
#define SUB_GP_MODIFY_UNDER_WRITE	103									//修改签名
#define SUB_GP_MODIFY_ACCOUNTS		104									//修改帐号
#define SUB_GP_MODIFY_SPREADER		105									//修改推荐人

//修改密码
struct CMD_GP_ModifyLogonPass
{
	uint32							dwUserID;							//用户 I D
	char							szDesPassword[LEN_PASSWORD];		//用户密码
	char							szScrPassword[LEN_PASSWORD];		//用户密码
};

//修改密码
struct CMD_GP_ModifyInsurePass
{
	uint32							dwUserID;							//用户 I D
	char							szDesPassword[LEN_PASSWORD];		//用户密码
	char							szScrPassword[LEN_PASSWORD];		//用户密码
};


//修改推荐人
struct CMD_GP_ModifySpreader
{
	uint32							dwUserID;							//用户 I D
	char							szPassword[LEN_PASSWORD];		//用户密码
	char							szSpreader[LEN_NICKNAME];		//用户密码
};

//修改头像
#define SUB_GP_USER_FACE_INFO		120									//头像信息
#define SUB_GP_SYSTEM_FACE_INFO		121									//系统头像
#define SUB_GP_CUSTOM_FACE_INFO		122									//自定头像

//修改头像
struct CMD_GP_CustomFaceInfo
{
	uint32							dwUserID;							//用户 I D
	char							szPassword[LEN_PASSWORD];			//用户密码
	char							szMachineID[LEN_MACHINE_ID];		//机器序列
	uint32							dwCustomFace[FACE_CX*FACE_CY];		//图片信息
};

//比赛服务
#define SUB_GP_MATCH_SIGNUP			200									//比赛报名
#define SUB_GP_MATCH_UNSIGNUP		201									//取消报名
#define SUB_GP_MATCH_SIGNUP_RESULT	202									//报名结果
#define SUB_GP_MATCH_AWARD_LIST		203									//比赛奖励

//签到服务
#define SUB_GP_CHECKIN_QUERY      220									//查询签到
#define SUB_GP_CHECKIN_INFO       221									//签到信息
#define SUB_GP_CHECKIN_DONE       222									//执行签到
#define SUB_GP_CHECKIN_RESULT     223									//签到结果
#define SUB_GP_CHECKIN_AWARD	  224									//签到奖励

//新手引导
#define SUB_GP_BEGINNER_QUERY		240								//新手引导签到
#define SUB_GP_BEGINNER_INFO		241								//新手引导信息
#define SUB_GP_BEGINNER_DONE		242								//新手引导执行
#define SUB_GP_BEGINNER_RESULT		243								//新手引导结果

//低保服务
#define SUB_GP_BASEENSURE_LOAD      260									//加载低保
#define SUB_GP_BASEENSURE_TAKE      261									//领取低保
#define SUB_GP_BASEENSURE_PARAMETER   262								//低保参数
#define SUB_GP_BASEENSURE_RESULT    263									//低保结果


//个人资料
#define SUB_GP_USER_INDIVIDUAL		301									//个人资料
#define	SUB_GP_QUERY_INDIVIDUAL		302									//查询信息
#define SUB_GP_MODIFY_INDIVIDUAL	303									//修改资料
#define SUB_GP_QUERY_ACCOUNTINFO	304									//个人信息
#define SUB_GP_QUERY_INGAME_SEVERID	305									//游戏状态
#define SUB_GP_WXSHARE_SUCCESS		306									//微信分享成功
#define SUB_GP_WXSHARE_REWARD		307									//微信分享成功奖励
#define SUB_GP_QUERY_IN_UNION		309									//是否在工会;
#define SUB_GP_GET_UNION_LIST		310									//获取工会列表;
#define SUB_GP_UNION_GAME_LIST		311									//获取工会列表;
#define SUB_GP_GET_UNION_ROOM_LIST	312									//获取工会房间列表;
#define SUB_GP_GET_AUTO_ROOM_LIST	313									//获取自动房间列表;

//银行服务
#define SUB_GP_USER_SAVE_SCORE		400									//存款操作
#define SUB_GP_USER_TAKE_SCORE		401									//取款操作
#define SUB_GP_USER_TRANSFER_SCORE	402									//转账操作
#define SUB_GP_USER_INSURE_INFO		403									//银行资料
#define SUB_GP_QUERY_INSURE_INFO	404									//查询银行
#define SUB_GP_USER_INSURE_SUCCESS	405									//银行成功
#define SUB_GP_USER_INSURE_FAILURE	406									//银行失败
#define SUB_GP_QUERY_USER_INFO_REQUEST	407								//查询用户
#define SUB_GP_QUERY_USER_INFO_RESULT	408								//用户信息

//////////////////////////////////////////////////////////////////////////////////

//银行资料
struct CMD_GP_UserInsureInfo
{
	uint16							wRevenueTake;						//税收比例
	uint16							wRevenueTransfer;					//税收比例
	uint16							wServerID;							//房间标识
	SCORE							lUserScore;							//用户金币
	SCORE							lUserInsure;						//银行金币
	SCORE							lTransferPrerequisite;				//转账条件
};

//存入金币
struct CMD_GP_UserSaveScore
{
	uint32							dwUserID;							//用户 I D
	SCORE							lSaveScore;							//存入金币
	char							szMachineID[LEN_MACHINE_ID];		//机器序列
};

//提取金币
struct CMD_GP_UserTakeScore
{
	uint32							dwUserID;							//用户 I D
	SCORE							lTakeScore;							//提取金币
	char							szPassword[LEN_MD5];				//银行密码
	char							szMachineID[LEN_MACHINE_ID];		//机器序列
};

//转账金币
struct CMD_GP_UserTransferScore
{
	uint32							dwUserID;							//用户 I D
	uint8                            cbByNickName;                       //昵称赠送 0:GAMEID, 1:昵称
	SCORE							lTransferScore;						//转账金币
	char							szPassword[LEN_MD5];				//银行密码
	char							szNickName[LEN_NICKNAME];			//目标用户
	char							szMachineID[LEN_MACHINE_ID];		//机器序列
};

//银行成功
struct CMD_GP_UserInsureSuccess
{
	uint32							dwUserID;							//用户 I D
	SCORE							lUserScore;							//用户金币
	SCORE							lUserInsure;						//银行金币
	char							szDescribeString[128];				//描述消息
};

//银行失败
struct CMD_GP_UserInsureFailure
{
	unsigned int					lResultCode;						//错误代码
	char							szDescribeString[128];				//描述消息
};

//提取结果
struct CMD_GP_UserTakeResult
{
	uint32							dwUserID;							//用户 I D
	SCORE							lUserScore;							//用户金币
	SCORE							lUserInsure;						//银行金币
};

//查询银行
struct CMD_GP_QueryInsureInfo
{
	uint32							dwUserID;							//用户 I D
};

//查询用户
struct CMD_GP_QueryUserInfoRequest
{
	uint8                            cbByNickName;                       //昵称赠送
	char							szNickName[LEN_NICKNAME];			//目标用户
};

//用户信息
struct CMD_GP_UserTransferUserInfo
{
	uint32							dwTargetGameID;						//目标用户
	char							szNickName[LEN_NICKNAME];			//目标用户
};
//个人信息
struct CMD_GP_UserAccountInfo
{
	//属性资料
	uint16							wFaceID;							//头像标识
	uint32							dwUserID;							//用户标识
	uint32							dwGameID;							//游戏标识
	uint32							dwGroupID;							//社团标识
	uint32							dwCustomID;							//自定索引
	uint32							dwUserMedal;						//用户奖牌
	uint32							dwExperience;						//经验数值
	uint32							dwLoveLiness;						//用户魅力
	uint32							dwSpreaderID;						//推广ID
	char							szPassword[LEN_MD5];				//登录密码
	char							szAccounts[LEN_ACCOUNTS];			//登录帐号
	char							szNickName[LEN_NICKNAME];			//用户昵称
	char							szGroupName[LEN_GROUP_NAME];		//社团名字
	char							szLogonIp[LEN_ACCOUNTS];			//登录IP

	//用户成绩
	SCORE							lUserScore;							//用户游戏币
	SCORE							lUserInsure;						//用户银行
	SCORE							lGrade;								//私人场经验

	//用户资料
	uint8							cbGender;							//用户性别
	uint8							cbMoorMachine;						//锁定机器
	char							szUnderWrite[LEN_UNDER_WRITE];		//个性签名

	//会员资料
	uint8							cbMemberOrder;						//会员等级
	systemtime						MemberOverDate;						//到期时间
};
//游戏状态
struct CMD_GP_UserInGameServerID
{
	uint32							dwUserID;							//用户 I D
};

//操作成功
struct CMD_GP_InGameSeverID
{
	uint32							LockKindID;			
	uint32							LockServerID;			
};

//游戏状态
struct CMD_GP_UserInUnion
{
	uint32							dwUserID;							//用户 I D
	uint32							dwUnionCode;							//用户 I D
};

struct CMD_GP_InUnion
{
	uint8							cbResultCode;
	uint32							dwUnionCode;
	char							szDescribeString[128];				//错误消息
};

//获取工会列表
struct CMD_GP_GetUnionList
{
	uint32							dwUserID;							//用户 I D
};

//获取自动开房列表
struct CMD_GP_GetAutoRoomList
{
	uint32							dwUserID;							//用户 I D
};

//删除代开信息
struct CMD_GP_DelAutoRoomInfo
{
	uint32							dwIndex;							//用户 I D
	uint16							wServerID;
};

//微信分享成功
struct CMD_GP_WXShareSuccess
{
	uint32							dwUserID;
	char							szPassword[LEN_PASSWORD];			//用户密码
};

//微信分享成功奖励
struct CMD_GP_WXShareReward
{
	uint8							cbFKCount;
};
//////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////
//比赛报名
struct CMD_GP_MatchSignup
{
	//比赛信息
	uint16							wServerID;							//房间标识
	uint32							dwMatchID;							//比赛标识
	uint32							dwMatchNO;							//比赛场次

	//用户信息
	uint32							dwUserID;							//用户标识
	char							szPassword[LEN_MD5];				//登录密码

	//机器信息
	char							szMachineID[LEN_MACHINE_ID];		//机器序列
};

//取消报名
struct CMD_GP_MatchUnSignup
{
	//比赛信息
	uint16							wServerID;							//房间标识
	uint32							dwMatchID;							//比赛标识
	uint32							dwMatchNO;							//比赛场次

	//用户信息
	uint32							dwUserID;							//用户标识
	char							szPassword[LEN_MD5];				//登录密码

	//机器信息
	char							szMachineID[LEN_MACHINE_ID];		//机器序列
};

//报名结果
struct CMD_GP_MatchSignupResult
{
	bool							bSignup;							//报名标识
	bool							bSuccessed;							//成功标识
	char							szDescribeString[128];				//描述信息
};
//报名结果
struct CMD_GP_MatchGetAward
{
	uint32							dwUserID;	
	uint32							dwMatchID;		//比赛标识
	uint32							dwMatchNO;		//比赛场次	
};

//排行信息
struct tagMatchAwardkInfo
{
	uint16							MatchRank;							//比赛名次
	SCORE							RewardGold;							//奖励金币
	uint32							RewardMedal;						//奖励元宝
	uint32							RewardExperience;					//奖励经验
	void StreamValue(DataStream& kData, bool bSend)
	{
		Stream_VALUE(MatchRank);
		Stream_VALUE(RewardGold);
		Stream_VALUE(RewardMedal);
		Stream_VALUE(RewardExperience);
	}
};

//比赛奖励
struct CMD_GR_MatchAwardList
{
	uint32							dwMatchID;							//比赛标识
	uint32							dwMatchNO;							//比赛场次
	std::vector<tagMatchAwardkInfo> kAwards;

	void StreamValue(DataStream& kData, bool bSend)
	{
		Stream_VALUE(dwMatchID);
		Stream_VALUE(dwMatchNO);
		StructVecotrMember(tagMatchAwardkInfo,kAwards);
	}
};
//////////////////////////////////////////////////////////////////////////////////


//自定义字段查询 公告
#define SUB_GP_QUERY_PUBLIC_NOTICE	500									//自定义字段查询
#define	SUB_GP_PUBLIC_NOTICE		501

//设置推荐人结果
#define SUB_GP_SPREADER_RESOULT		520									//设置推荐人结果

//赚金排行榜
#define SUB_GP_ADDRANK_GET_AWARD_INFO	540									//获得奖励信息
#define SUB_GP_ADDRANK_BACK_AWARD_INFO	541									//返回奖励信息
#define SUB_GP_ADDRANK_GET_RANK			542									//获得排行
#define SUB_GP_ADDRANK_BACK_RANK		543									//返回排行

//游戏记录
#define SUB_GP_GAME_RECORD_LIST			550			
#define SUB_GP_GAME_RECORD_TOTAL		551		
#define SUB_GP_GAME_RECORD_CHILD		552

//客服信息
#define SUB_GP_KEFU					600									//客服信息
#define SUB_GP_KEFU_RESULT			601									//客服信息结果

//邮件信息
#define SUB_GP_MESSAGE_LIST			700									//邮件列表
#define SUB_GP_MESSAGE_LIST_RESULT	701									//邮件列表返回
#define SUB_GP_MESSAGE_AWARD		702									//获取排行榜奖励
#define SUB_GP_MESSAGE_AWARD_RESULT	703									//获取排行榜结果

//操作结果
#define SUB_GP_OPERATE_SUCCESS		900									//操作成功
#define SUB_GP_OPERATE_FAILURE		901									//操作失败

//话费兑换
#define  SUB_GP_EXCHANGEHUAFEI_GET_LIST_INFO    1000                     //获取兑换话费列表
#define  SUB_GP_EXCHANGEHUAFEI_BACK				1001						//兑换话费列表返回
//游戏记录
struct CMD_GP_GetGameRecordList
{
	uint32							dwUserID;
	uint16							wKindID;
};

//商城数据
#define  SUB_GP_SHOPINFO_GET_LIST_INFO    1100                     //获取商城列表
#define  SUB_GP_SHOPINFO_BACK				1101						//商城列表返回

struct CMD_GP_BackAddBankAwardInfo
{
	int							kRewardGold[3][LEN_ADDRANK];				
	int							kRewardType[3][LEN_ADDRANK];				
};

struct CMD_GP_GetAddBank
{
	uint32							dwUserID;							//用户 I D
	char							szPassword[LEN_PASSWORD];			//用户密码
	int								iRankIdex;
};

struct CMD_GP_BackAddBank
{
	int iRankIdex;
	std::vector<std::string>		kNickName;
	std::vector<int>				kUserID;
	std::vector<int>				kFaceID;
	std::vector<int>				kCustomID;
	std::vector<int>				kUserPoint;

	void StreamValue(DataStream& kData, bool bSend)
	{
		Stream_VALUE(iRankIdex);
		Stream_VALUE(kNickName);
		Stream_VALUE(kUserID);
		Stream_VALUE(kFaceID);
		Stream_VALUE(kCustomID);
		Stream_VALUE(kUserPoint);
	}
};

struct CMD_GP_GetExchangeHuaFei
{
	uint32						dwUserID;						//用户 I D
	char							szPassword[LEN_PASSWORD];			//用户密码
};

struct CMD_GP_BackExchangeHuaFei
{
	std::vector<int>				kExchangeID;				//兑换id
	std::vector<int>				kUseType;					//兑换道具类型
	std::vector<int>				kUseNum;				    //兑换道具个数
	std::vector<int>				kGetType;					//兑换商品类型
	std::vector<int>				kGetNum;				    //兑换商品个数
	std::vector<std::string>		kGoodsName;					//兑换商品名称
	std::vector<std::string>		kExchangeDesc;				//兑换描述
	std::vector<std::string>		kImgIcon;					//图标名称
	std::vector<int>				kFlag;						//标记

	void StreamValue(DataStream& kData, bool bSend)
	{
		Stream_VALUE(kExchangeID);
		Stream_VALUE(kUseType);
		Stream_VALUE(kUseNum);
		Stream_VALUE(kGetType);
		Stream_VALUE(kGetNum);
		Stream_VALUE(kGoodsName);
		Stream_VALUE(kExchangeDesc);
		Stream_VALUE(kImgIcon);
		Stream_VALUE(kFlag);
	}
};
struct CMD_GP_GetShopInfo
{
	uint32						dwUserID;						//用户 I D
	char						szPassword[LEN_PASSWORD];		//用户密码
};

struct CMD_GP_BackShopInfo
{
	std::vector<int>				kItemID;					//商品id
	std::vector<int>				kItemType;					//商品类型
	std::vector<int>				kOrderID_IOS;				//商品订单号 苹果
	std::vector<int>				kOrderID_Android;			//商品订单号 安卓
	std::vector<int>				kPrice;						//商品价格
	std::vector<int>				kGoodsNum;					//商品数量
	std::vector<std::string>		kItemTitle;					//标题
	std::vector<std::string>		kItemDesc;					//描述
	std::vector<std::string>		kItemIcon;					//图标名称
	std::vector<std::string>		kItemName;					//商品名称

	void StreamValue(DataStream& kData, bool bSend)
	{
		Stream_VALUE(kItemID);
		Stream_VALUE(kItemType);
		Stream_VALUE(kOrderID_IOS);
		Stream_VALUE(kOrderID_Android);
		Stream_VALUE(kPrice);
		Stream_VALUE(kGoodsNum);
		Stream_VALUE(kItemTitle);
		Stream_VALUE(kItemDesc);
		Stream_VALUE(kItemIcon);
		Stream_VALUE(kItemName);
	}
};

//////////////////////////////////////////////////////////////////////////////////
//携带信息 CMD_GP_UserIndividual

#define DTP_GP_UI_NICKNAME			1									//用户昵称
#define DTP_GP_UI_USER_NOTE			2									//用户说明
#define DTP_GP_UI_UNDER_WRITE		3									//个性签名
#define DTP_GP_UI_QQ				4									//Q Q 号码
#define DTP_GP_UI_EMAIL				5									//电子邮件
#define DTP_GP_UI_SEAT_PHONE		6									//固定电话
#define DTP_GP_UI_MOBILE_PHONE		7									//移动电话
#define DTP_GP_UI_COMPELLATION		8									//真实名字
#define DTP_GP_UI_DWELLING_PLACE	9									//联系地址
#define DTP_GP_UI_HEAD_HTTP			10									//头像
#define DTP_GP_UI_IP				11									//IP
#define DTP_GP_UI_CHANNEL			12									//渠道号
//////////////////////////////////////////////////////////////////////////////////

//查询信息
struct CMD_GP_QueryIndividual
{
	uint32							dwUserID;							//用户 I D
};
//查询信息
struct CMD_GP_QueryAccountInfo
{
	uint32							dwUserID;							//用户 I D
};

//个人资料
struct CMD_GP_UserIndividual
{
	uint32							dwUserID;							//用户 I D
};

//修改资料
struct CMD_GP_ModifyIndividual
{
	uint8							cbGender;							//用户性别
	uint32							dwUserID;							//用户 I D
	char							szPassword[LEN_PASSWORD];			//用户密码
};
//操作成功
struct CMD_GP_SpreaderResoult
{
	unsigned int					lResultCode;						//操作代码
	SCORE							lScore;
	char							szDescribeString[128];				//成功消息
};
//操作成功
struct CMD_GP_OperateSuccess
{
	unsigned int					lResultCode;						//操作代码
	char							szDescribeString[128];				//成功消息
};
//操作失败
struct CMD_GP_OperateFailure
{
	unsigned int					lResultCode;						//错误代码
	char							szDescribeString[128];				//描述消息
};

//签到奖励
struct DBO_GP_CheckInReward
{
	SCORE							lRewardGold[LEN_SIGIN];				//奖励金额
	uint8							lRewardType[LEN_SIGIN];				//奖励类型 1金币 2道具
	uint8							lRewardDay[LEN_SIGIN];				//奖励天数 
};
//查询签到
struct CMD_GP_CheckInQueryInfo
{
	uint32							dwUserID;							//用户标识
	char							szPassword[LEN_PASSWORD];			//登录密码
};

//签到信息
struct CMD_GP_CheckInInfo
{	
	uint16							wSeriesDate;						//连续日期
	uint16							wAwardDate;							//物品日期
	bool							bTodayChecked;						//签到标识
	SCORE							lRewardGold[LEN_SIGIN];				//奖励金额
	uint8							lRewardType[LEN_SIGIN];				//奖励类型 1金币 2道具
	uint8							lRewardDay[LEN_SIGIN];				//奖励天数 
};

//执行签到
struct CMD_GP_CheckInDone
{
	uint32							dwUserID;							//用户标识
	char							szPassword[LEN_PASSWORD];			//登录密码
	char							szMachineID[LEN_MACHINE_ID];		//机器序列
};

//签到结果
struct CMD_GP_CheckInResult
{
	bool							bType;								//是否是达到天数领取物品
	bool							bSuccessed;							//成功标识
	SCORE							lScore;								//当前金币
	char							szNotifyContent[128];				//提示内容
};

//////////////////////////////////////////////////////////////////////////////////
//新手活动

struct CMD_GP_BeginnerQueryInfo
{
	uint32							dwUserID;							//用户标识
	char							szPassword[LEN_PASSWORD];			//登录密码
};
struct CMD_GP_BeginnerInfo
{	
	enum AwardType
	{
		Type_Gold = 1,
		Type_Phone = 2,
	};
	uint16							wSeriesDate;						//连续日期
	bool							bTodayChecked;						//签到标识
	bool							bLastCheckIned;						//签到标识
	SCORE							lRewardGold[LEN_BEGINNER];			//奖励金额
	uint8							lRewardType[LEN_BEGINNER];			//奖励类型 1金币 2道具
};
struct CMD_GP_BeginnerDone
{
	uint32							dwUserID;							//用户标识
	char							szPassword[LEN_PASSWORD];			//登录密码
	char							szMachineID[LEN_MACHINE_ID];		//机器序列
};
struct CMD_GP_BeginnerResult
{
	bool							bSuccessed;							//成功标识
	SCORE							lAwardCout;							//奖励数量
	SCORE							lAwardType;							//奖励类型
	char							szNotifyContent[128];				//提示内容
};
//领取低保
struct CMD_GP_BaseEnsureTake
{
	uint32							dwUserID;							//用户 I D
	char							szPassword[LEN_PASSWORD];			//登录密码
	char							szMachineID[LEN_MACHINE_ID];		//机器序列
};

//低保参数
struct CMD_GP_BaseEnsureParamter
{
	SCORE							lScoreCondition;					//游戏币条件
	SCORE							lScoreAmount;						//游戏币数量
	uint8							cbTakeTimes;						//领取次数	
};
//低保结果
struct CMD_GP_BaseEnsureResult
{
	bool							bSuccessed;							//成功标识
	SCORE							lGameScore;							//当前游戏币
	char							szNotifyContent[128];				//提示内容
};

//自定义字段查询 公告
struct CMD_GP_QueryNotice
{
	char							szKeyName[LEN_NICKNAME];			//关键字
};
struct CMD_GP_PublicNotice
{
	unsigned int					lResultCode;						//操作代码
	char							szDescribeString[512];				//成功消息
};
//////////////////////////////////////////////////////////////////////////////////
//远程服务

#define MDM_GP_REMOTE_SERVICE		4									//远程服务

//查找服务
#define SUB_GP_C_SEARCH_DATABASE	100									//数据查找
#define SUB_GP_C_SEARCH_CORRESPOND	101									//协调查找

//时间奖励
#define SUB_GP_C_TIME_AWARD_CHECK	110									//时间奖励信息查询
#define SUB_GP_C_TIME_AWARD_GET		111									//时间奖励领取

//查找服务
#define SUB_GP_S_SEARCH_DATABASE	200									//数据查找
#define SUB_GP_S_SEARCH_CORRESPOND	201									//协调查找


//时间奖励
#define SUB_GP_S_TIME_AWARD_CHECK	210									//时间奖励信息查询结果
#define SUB_GP_S_TIME_AWARD_GET		211									//时间奖励领取结果



//登录模式
#define SUB_MB_LOGON_GAMEID			2									//I D 登录
#define SUB_MB_REGISTER_ACCOUNTS	3									//注册帐号

//登录结果
#define SUB_MB_LOGON_SUCCESS		100									//登录成功
#define SUB_MB_LOGON_FAILURE		101									//登录失败

//升级提示
#define SUB_MB_UPDATE_NOTIFY		200									//升级提示

//////////////////////////////////////////////////////////////////////////////////

//帐号登录
struct CMD_GP_LogonAccounts
{
	//登录信息
	uint32							dwPlazaVersion;						//广场版本
	char							szMachineID[LEN_MACHINE_ID];		//机器序列

	char							szPassword[LEN_MD5];				//登录密码
	char							szAccounts[LEN_ACCOUNTS];			//登录帐号
	char							szOpenId[LEN_OPENID];				//
	char							szUnionid[LEN_UNIONID];
	uint32							cbValidateFlags;			        //校验标识
};

//登录失败
struct DBR_GP_LogonError
{
	unsigned int					lErrorCode;							//错误代码
	char							szErrorDescribe[128];				//错误消息
};


//I D登录
struct CMD_GP_LogonByUserID
{
	//登录信息
	uint32							dwGameID;							//游戏 I D
	char							szPassword[LEN_MD5];				//登录密码
	uint8							cbValidateFlags;			        //校验标识
};

//注册帐号
struct CMD_GP_RegisterAccounts
{
	//系统信息
	uint32							dwPlazaVersion;						//广场版本
	char							szMachineID[LEN_MACHINE_ID];		//机器序列
	char							szOpenId[LEN_OPENID];				//
	char							szUnionid[LEN_UNIONID];

	//密码变量
	char							szLogonPass[LEN_MD5];				//登录密码
	char							szInsurePass[LEN_MD5];				//银行密码

	//注册信息
	uint16							wFaceID;							//头像标识
	uint8							cbGender;							//用户性别
	char							szAccounts[LEN_ACCOUNTS];			//登录帐号
	char							szNickName[LEN_NICKNAME];			//用户昵称
	char							szSpreader[LEN_ACCOUNTS];			//推荐帐号
	char							szPassPortID[LEN_PASS_PORT_ID];		//证件号码
	char							szCompellation[LEN_COMPELLATION];	//真实名字
	uint8							cbValidateFlags;			        //校验标识
};

//游客登录
struct CMD_GP_VisitorLogon
{
	uint16								wFaceID;						//头像标识
	uint8								cbGender;						//用户性别
	uint32								dwPlazaVersion;					//广场版本
	uint8								cbValidateFlags;			        //校验标识
	char								szNickName[LEN_NICKNAME];		//用户昵称
	char								szSpreader[LEN_NICKNAME];		//推广人名
	char								szPassWord[LEN_PASSWORD];		//登录密码
	char								szPassWordBank[LEN_PASSWORD];	//登录密码
};


//登陆成功
struct CMD_GP_LogonSuccess
{
	uint16								wFaceID;							//头像标识
	uint32								dwUserID;							//用户 I D
	uint32								dwGameID;							//游戏 I D
	uint32								dwGroupID;							//社团标识
	uint32								dwCustomID;							//自定标识
	uint32								dwUserMedal;						//用户奖牌
	uint32								dwExperience;						//经验数值
	uint32								dwLoveLiness;						//用户魅力
	uint32								dwSpreaderID;						//推广ID
	uint8								cbInsureEnabled;					//银行开通

	//用户成绩
	SCORE							lUserScore;							//用户金币
	SCORE							lUserInsure;						//用户银行
	SCORE							lGrade;								//私人场经验
	bool							isLottery;							//今天是否参与摇奖;

	//用户信息
	uint8								cbGender;							//用户性别
	uint8								cbMoorMachine;						//锁定机器
	char								szAccounts[LEN_ACCOUNTS];			//登录帐号
	char								szNickName[LEN_ACCOUNTS];			//用户昵称
	char								szGroupName[LEN_GROUP_NAME];		//社团名字

	//配置信息
	uint8								cbShowServerStatus;                 //显示服务器状态
	uint8								cbWXShareTimes;						//微信分享次数
	
};

//列表配置
struct CMD_GP_ListConfig
{
	uint8		bShowOnLineCount;				//显示人数
};

//////////////////////////////////////////////////////////////////////////////////
//列表命令

#define MDM_MB_SERVER_LIST			101									//列表信息

//列表信息
#define SUB_MB_LIST_TYPE			100									//游戏类型
#define SUB_MB_LIST_KIND			101									//种类列表
#define SUB_MB_LIST_NODE			102									//节点列表
#define SUB_MB_LIST_PAGE			103									//定制列表
#define SUB_MB_LIST_SERVER			104									//房间列表
#define SUB_MB_LIST_MATCH			105									//比赛列表
#define SUB_MB_LIST_FINISH			200									//列表完成

//////////////////////////////////////////////////////////////////////////////////

// Restore default alignment for structs containing std::vector.
// CMD_GF_Private_Room_Info uses DataStream field-by-field serialization,
// so memory layout does not need to match network byte order.
#pragma pack()

//私人场房间信息
struct CMD_GF_Private_Room_Info
{
	uint8			bPlayCoutIdex;		//玩家局数
	uint8			bGameTypeIdex;		//游戏类型
	uint32			bGameRuleIdex;		//游戏规则

	uint8			bStartGame;
	uint32			dwPlayCout;			//游戏局数
	uint32			dwRoomNum;
	uint32			dwCreateUserID;
	uint32			dwUnionCode;
	uint32			dwPlayTotal;		//总局数
	uint32			dwPlayCost;			// 消耗点数

	uint8			cbRoomType;

	// 工会开房欢乐场;
	uint8			cbUnionGoldOpen;	//是否开启欢乐场
	SCORE			lScoreMultiple;		//倍数
	SCORE			lGameGold;			//佣金
	uint8			cbBaseScore;		//底分

	std::vector<int>	kWinLoseScore;

	CMD_GF_Private_Room_Info()
	{
		bPlayCoutIdex = 0;
		bGameTypeIdex = 0;
		bGameRuleIdex = 0;

		bStartGame = 0;
		dwPlayCout = 0;
		dwRoomNum = 0;
		dwCreateUserID = 0;
		dwPlayTotal = 0;
		dwPlayCost = 0;
		cbRoomType = 0;

		cbUnionGoldOpen = 0;
		lScoreMultiple = 0;
		lGameGold = 0;
		cbBaseScore = 0;

		kWinLoseScore.clear();
	}

	CMD_GF_Private_Room_Info(const CMD_GF_Private_Room_Info& refInfo)
	{
		bPlayCoutIdex = refInfo.bPlayCoutIdex;
		bGameTypeIdex = refInfo.bGameTypeIdex;
		bGameRuleIdex = refInfo.bGameRuleIdex;

		bStartGame = refInfo.bStartGame;
		dwPlayCout = refInfo.dwPlayCout;
		dwRoomNum = refInfo.dwRoomNum;
		dwCreateUserID = refInfo.dwCreateUserID;
		dwPlayTotal = refInfo.dwPlayTotal;
		dwPlayCost = refInfo.dwPlayCost;
		cbRoomType = refInfo.cbRoomType;

		cbUnionGoldOpen = refInfo.cbUnionGoldOpen;
		lScoreMultiple = refInfo.lScoreMultiple;
		lGameGold = refInfo.lGameGold;
		cbBaseScore = refInfo.cbBaseScore;

		kWinLoseScore.assign(refInfo.kWinLoseScore.begin(), refInfo.kWinLoseScore.end());
	}

	CMD_GF_Private_Room_Info& operator=(const CMD_GF_Private_Room_Info& refInfo)
	{
		if (this == &refInfo)
		{
			return *this;
		}
		bPlayCoutIdex = refInfo.bPlayCoutIdex;
		bGameTypeIdex = refInfo.bGameTypeIdex;
		bGameRuleIdex = refInfo.bGameRuleIdex;

		bStartGame = refInfo.bStartGame;
		dwPlayCout = refInfo.dwPlayCout;
		dwRoomNum = refInfo.dwRoomNum;
		dwCreateUserID = refInfo.dwCreateUserID;
		dwPlayTotal = refInfo.dwPlayTotal;
		dwPlayCost = refInfo.dwPlayCost;
		cbRoomType = refInfo.cbRoomType;

		cbUnionGoldOpen = refInfo.cbUnionGoldOpen;
		lScoreMultiple = refInfo.lScoreMultiple;
		lGameGold = refInfo.lGameGold;
		cbBaseScore = refInfo.cbBaseScore;

		kWinLoseScore.assign(refInfo.kWinLoseScore.begin(), refInfo.kWinLoseScore.end());
		return *this;
	}

	void StreamValue(DataStream& kData, bool bSend)
	{
		Stream_VALUE(bPlayCoutIdex);
		Stream_VALUE(bGameTypeIdex);
		Stream_VALUE(bGameRuleIdex);
		Stream_VALUE(bStartGame);
		Stream_VALUE(dwPlayCout);
		Stream_VALUE(dwRoomNum);
		Stream_VALUE(dwCreateUserID);
		Stream_VALUE(dwPlayTotal);
		Stream_VALUE(dwPlayCost);
		Stream_VALUE(cbRoomType);
		Stream_VALUE(cbUnionGoldOpen);
		Stream_VALUE(lScoreMultiple);
		Stream_VALUE(lGameGold);
		Stream_VALUE(cbBaseScore);
		StructVecotr(int, kWinLoseScore);
	}
};

// Restore pack(1) for remaining structs
#pragma pack(1)

//游戏记录
struct CMD_GP_GetGameTotalRecord
{
	uint32							dwUserID;
	uint32							dwRecordID;
};

//欢乐场积分信息
struct CMD_GF_Private_Score_Info
{
	uint8			cbPlayerCount;		//玩家数
	std::vector<SCORE>  kScoreInfoArray;//欢乐积分

	CMD_GF_Private_Score_Info()
	{
		cbPlayerCount = 0;
		kScoreInfoArray.clear();
	}

	CMD_GF_Private_Score_Info(const CMD_GF_Private_Score_Info& refInfo)
	{
		cbPlayerCount = refInfo.cbPlayerCount;
		kScoreInfoArray.assign(refInfo.kScoreInfoArray.begin(), refInfo.kScoreInfoArray.end());
	}

	CMD_GF_Private_Score_Info& operator=(const CMD_GF_Private_Score_Info& refInfo)
	{
		if (this == &refInfo)
		{
			return *this;
		}
		cbPlayerCount = refInfo.cbPlayerCount;
		kScoreInfoArray.assign(refInfo.kScoreInfoArray.begin(), refInfo.kScoreInfoArray.end());
		return *this;
	}

	void StreamValue(DataStream& kData, bool bSend)
	{
		Stream_VALUE(cbPlayerCount);
		StructVecotr(SCORE, kScoreInfoArray);
	}
};

///////////////////////////// 注释: 参与网络传输的数据包需要字节对齐 /////////////////////////////////////////////
// 此次开房的每局游戏记录;
struct tagPrivateRandRecordChild
{
	uint32						dwKindID;
	uint32						dwVersion;
	int							iRecordID;
	int							iRecordChildID;
	std::vector<int>			kScore;
	systemtime					kPlayTime;
	DataStream					kRecordGame;
	std::string					kUserDefine;
	tagPrivateRandRecordChild()
	{
		dwKindID = 0;
		dwVersion = 0;
		iRecordID = 0;
		iRecordChildID = 0;

		kScore.clear();
		kRecordGame.clear();
		kUserDefine.clear();
	}

	tagPrivateRandRecordChild(const tagPrivateRandRecordChild& refInfo)
	{
		dwKindID = refInfo.dwKindID;
		dwVersion = refInfo.dwVersion;
		iRecordID = refInfo.iRecordID;
		iRecordChildID = refInfo.iRecordChildID;
		kScore.assign(refInfo.kScore.begin(), refInfo.kScore.end());
		kPlayTime = refInfo.kPlayTime;
		kRecordGame.assign(refInfo.kRecordGame.begin(), refInfo.kRecordGame.end());
		kUserDefine = refInfo.kUserDefine;
	}

	tagPrivateRandRecordChild& operator=(const tagPrivateRandRecordChild& refInfo)
	{
		if (this == &refInfo)
		{
			return *this;
		}
		dwKindID = refInfo.dwKindID;
		dwVersion = refInfo.dwVersion;
		iRecordID = refInfo.iRecordID;
		iRecordChildID = refInfo.iRecordChildID;
		kScore.assign(refInfo.kScore.begin(), refInfo.kScore.end());
		kPlayTime = refInfo.kPlayTime;
		kRecordGame.assign(refInfo.kRecordGame.begin(), refInfo.kRecordGame.end());
		kUserDefine = refInfo.kUserDefine;

		return *this;
	}

	void StreamValue(DataStream& kData, bool bSend)
	{
		Stream_VALUE(dwKindID);
		Stream_VALUE(dwVersion);
		Stream_VALUE(iRecordID);
		Stream_VALUE(iRecordChildID);
		StructVecotr(int, kScore);
		Stream_VALUE_SYSTEMTIME(kPlayTime);
		Stream_VALUE(kRecordGame);
		Stream_VALUE(kUserDefine);
	}
};

// 每次开房统计;
struct tagPrivateRandTotalRecord
{
	tagPrivateRandTotalRecord()
	{
		dwKindID = 0;
		dwVersion = 0;
		iRoomNum = 0;
		iRecordID = 0;
		cbGameCount = 0;

		kScore.clear();
		kUserID.clear();
		kNickName.clear();
		kHeadHttp.clear();

		kUserDefine.clear();
	}
	DWORD						dwKindID;			// 游戏ID;
	DWORD						dwVersion;			// 版本号;
	int							iRoomNum;			// 房间号;
	int							iRecordID;			// 记录ID;
	BYTE						cbGameCount;		// 游戏局数;
	std::vector<int>			kScore;				// 玩家积分;
	std::vector<int>			kUserID;			// 玩家ID;
	std::vector<std::string>	kNickName;			// 玩家昵称;
	std::vector<std::string>	kHeadHttp;			// 微信头像;
	systemtime					kPlayTime;			// 游戏时间;
	std::string					kUserDefine;		// 其他信息;

	std::vector<tagPrivateRandRecordChild>	kRecordChild;

	tagPrivateRandTotalRecord(const tagPrivateRandTotalRecord& refInfo)
	{
		dwKindID = refInfo.dwKindID;
		dwVersion = refInfo.dwVersion;
		iRoomNum = refInfo.iRoomNum;
		iRecordID = refInfo.iRecordID;
		cbGameCount = refInfo.cbGameCount;

		kScore.assign(refInfo.kScore.begin(), refInfo.kScore.end());
		kUserID.assign(refInfo.kUserID.begin(), refInfo.kUserID.end());
		kNickName.assign(refInfo.kNickName.begin(), refInfo.kNickName.end());
		kHeadHttp.assign(refInfo.kHeadHttp.begin(), refInfo.kHeadHttp.end());

		kPlayTime = refInfo.kPlayTime;
		kUserDefine = refInfo.kUserDefine;

		kRecordChild.assign(refInfo.kRecordChild.begin(), refInfo.kRecordChild.end());
	}
	tagPrivateRandTotalRecord& operator=(const tagPrivateRandTotalRecord& refInfo)
	{
		if (this == &refInfo)
		{
			return *this;
		}

		dwKindID = refInfo.dwKindID;
		dwVersion = refInfo.dwVersion;
		iRoomNum = refInfo.iRoomNum;
		iRecordID = refInfo.iRecordID;
		cbGameCount = refInfo.cbGameCount;

		kScore.assign(refInfo.kScore.begin(), refInfo.kScore.end());
		kUserID.assign(refInfo.kUserID.begin(), refInfo.kUserID.end());
		kNickName.assign(refInfo.kNickName.begin(), refInfo.kNickName.end());
		kHeadHttp.assign(refInfo.kHeadHttp.begin(), refInfo.kHeadHttp.end());

		kPlayTime = refInfo.kPlayTime;
		kUserDefine = refInfo.kUserDefine;

		kRecordChild.assign(refInfo.kRecordChild.begin(), refInfo.kRecordChild.end());
		return *this;
	}


	void StreamValue(DataStream& kData, bool bSend)
	{
		Stream_VALUE(dwKindID);
		Stream_VALUE(dwVersion);
		Stream_VALUE(iRoomNum);
		Stream_VALUE(iRecordID);
		Stream_VALUE(cbGameCount);
		StructVecotr(int, kScore);
		StructVecotr(int, kUserID);
		Stream_VALUE(kNickName);
		Stream_VALUE(kHeadHttp);
		Stream_VALUE_SYSTEMTIME(kPlayTime);
		Stream_VALUE(kUserDefine);
		StructVecotrMember(tagPrivateRandRecordChild, kRecordChild);
	}
};

// 总开房记录;
struct tagPrivateRandTotalRecordList
{
	uint32		dwUserID;
	std::vector<tagPrivateRandTotalRecord> kList;

	tagPrivateRandTotalRecordList()
	{
		dwUserID = 0;
		kList.clear();
	}

	tagPrivateRandTotalRecordList(const tagPrivateRandTotalRecordList& refInfo)
	{
		dwUserID = refInfo.dwUserID;
		kList.assign(refInfo.kList.begin(), refInfo.kList.end());
	}

	tagPrivateRandTotalRecordList& operator=(const tagPrivateRandTotalRecordList& refInfo)
	{
		if (this == &refInfo)
		{
			return *this;
		}
		dwUserID = refInfo.dwUserID;
		kList.assign(refInfo.kList.begin(), refInfo.kList.end());
		return *this;
	}

	void StreamValue(DataStream& kData, bool bSend)
	{
		Stream_VALUE(dwUserID);
		StructVecotrMember(tagPrivateRandTotalRecord, kList);
	}
};

// 以下结构体包含STL容器，需要恢复默认对齐以避免ARM平台SIGBUS错误
#pragma pack()

// 玩家信息;
struct  tagGameRecordPlayer
{
	uint32					dwUserID;			//用户ID;
	uint32					dwGameID;			//游戏标识;
	uint16					wChairID;			//游戏标识;
	BYTE					cbSex;				//性别;
	SCORE					lScore;				//当前分数;
	std::string				strHead;			//头像url;
	std::string				strNickName;		//昵称;
	std::vector<BYTE>		cbCardData;			//牌值数据;

	tagGameRecordPlayer()
	{
		dwUserID = 0;
		dwGameID = 0;
		wChairID = 0;
		cbSex = 0;
		lScore = 0;
		strHead.clear();
		strNickName.clear();
		cbCardData.clear();
	}

	tagGameRecordPlayer(const tagGameRecordPlayer& refInfo)
	{
		dwUserID = refInfo.dwUserID;
		dwGameID = refInfo.dwGameID;
		wChairID = refInfo.wChairID;
		cbSex = refInfo.cbSex;
		lScore = refInfo.lScore;
		strHead = refInfo.strHead;
		strNickName = refInfo.strNickName;
		cbCardData.assign(refInfo.cbCardData.begin(), refInfo.cbCardData.end());
	}

	tagGameRecordPlayer& operator=(const tagGameRecordPlayer& refInfo)
	{
		if (this == &refInfo)
		{
			return *this;
		}

		dwUserID = refInfo.dwUserID;
		dwGameID = refInfo.dwGameID;
		wChairID = refInfo.wChairID;
		cbSex = refInfo.cbSex;
		lScore = refInfo.lScore;
		strHead = refInfo.strHead;
		strNickName = refInfo.strNickName;
		cbCardData.assign(refInfo.cbCardData.begin(), refInfo.cbCardData.end());

		return *this;
	}

	void StreamValue(DataStream& kData, bool bSend)
	{
		Stream_VALUE(dwUserID);
		Stream_VALUE(dwGameID);
		Stream_VALUE(wChairID);
		Stream_VALUE(cbSex);
		Stream_VALUE(lScore);
		Stream_VALUE(strHead);
		Stream_VALUE(strNickName);
		Stream_VALUE(cbCardData);
	}
};

// 操作结果;
struct  tagGameRecordOperateResult
{
	uint16			wSubCmdID;			//消息类型;
	DataStream		subMessageData;		//消息内容;

	tagGameRecordOperateResult()
	{
		wSubCmdID = 0;
		subMessageData.clear();
	}
	tagGameRecordOperateResult(const tagGameRecordOperateResult& refInfo)
	{
		wSubCmdID = refInfo.wSubCmdID;
		subMessageData.assign(refInfo.subMessageData.begin(), refInfo.subMessageData.end());
	}

	tagGameRecordOperateResult& operator=(const tagGameRecordOperateResult& refInfo)
	{
		if (this == &refInfo)
		{
			return *this;
		}

		wSubCmdID = refInfo.wSubCmdID;
		subMessageData.assign(refInfo.subMessageData.begin(), refInfo.subMessageData.end());
		return *this;
	}

	void StreamValue(DataStream& kData, bool bSend)
	{
		Stream_VALUE(wSubCmdID);
		Stream_VALUE(subMessageData);
	}
};

// 一局游戏信息;
struct  tagGameRecord
{
	uint16									wBankerUser;		//庄家用户;
	uint16									wEastUser;			//首次东家;
	CMD_GF_Private_Room_Info				roomInfo;			//游戏基本信息;
	std::vector<tagGameRecordPlayer>		playersVec;			//每个玩家的基本信息;
	std::vector<tagGameRecordOperateResult> actionVec;			//用户操作;

	tagGameRecord()
	{
		wBankerUser = 0;
		wEastUser = 0;

		playersVec.clear();
		actionVec.clear();
	}

	tagGameRecord(const tagGameRecord& refGameRecord)
	{
		wBankerUser = refGameRecord.wBankerUser;
		wEastUser = refGameRecord.wEastUser;

		roomInfo = refGameRecord.roomInfo;

		playersVec.assign(refGameRecord.playersVec.begin(), refGameRecord.playersVec.end());
		actionVec.assign(refGameRecord.actionVec.begin(), refGameRecord.actionVec.end());
	}

	bool StreamValue(DataStream& kData, bool bSend)
	{
		try
		{
			Stream_VALUE(wBankerUser);
			Stream_VALUE(wEastUser);
			roomInfo.StreamValue(kData, bSend);
			StructVecotrMember(tagGameRecordPlayer, playersVec);
			StructVecotrMember(tagGameRecordOperateResult, actionVec);

			return true;
		}
		catch (...)
		{
			return false;
		}
	}
};

//工会列表;
#pragma pack(1)
struct tagUnionItem
{
	uint32	dwUserID;								//会长ID;
	uint32	dwUnionCode;							//工会码;
	uint8	cbUnionGoldOpen;						//1开启欢乐豆模式,0不开启;
	uint8	cbUnionOpen;							//是否有开房权限 0 无 1 有;
	SCORE	lPeople;								//工会人数;
	SCORE	lUnionCard;								//工会房卡;
	char	szUnionName[32];						//工会名称;

	void StreamValue(DataStream& kData, bool bSend)
	{
		if (bSend)
		{
			kData.pushValue(this, sizeof(tagUnionItem));
		}
		else
		{
			kData.popValue(this, sizeof(tagUnionItem));
		}
	}
};
#pragma pack()
struct tagUnionItemList
{
	std::vector<tagUnionItem> kList;

	tagUnionItemList()
	{
		kList.clear();
	}

	tagUnionItemList(const tagUnionItemList& refInfo)
	{
		kList.assign(refInfo.kList.begin(), refInfo.kList.end());
	}

	tagUnionItemList& operator=(const tagUnionItemList& refInfo)
	{
		if (this == &refInfo)
		{
			return *this;
		}
		kList.assign(refInfo.kList.begin(), refInfo.kList.end());
		return *this;
	}

	void StreamValue(DataStream& kData, bool bSend)
	{
		StructVecotrMember(tagUnionItem, kList);
	}
};
#pragma pack(1)
struct tagUnionGameItem
{
	uint32 dwUnionCode;							//工会码;
	uint8 wKindID;								//游戏ID;

	void StreamValue(DataStream& kData, bool bSend)
	{
		if (bSend)
		{
			kData.pushValue(this, sizeof(tagUnionGameItem));
		}
		else
		{
			kData.popValue(this, sizeof(tagUnionGameItem));
		}
	}
};
#pragma pack()
struct tagUnionGameList
{
	std::vector<tagUnionGameItem> kList;

	tagUnionGameList()
	{
		kList.clear();
	}

	tagUnionGameList(const tagUnionGameList& refInfo)
	{
		kList.assign(refInfo.kList.begin(), refInfo.kList.end());
	}

	tagUnionGameList& operator=(const tagUnionGameList& refInfo)
	{
		if (this == &refInfo)
		{
			return *this;
		}
		kList.assign(refInfo.kList.begin(), refInfo.kList.end());
		return *this;
	}

	void StreamValue(DataStream& kData, bool bSend)
	{
		StructVecotrMember(tagUnionGameItem, kList);
	}
};

struct tagUnionAndGameList
{
	std::vector<tagUnionItem> kUnionList;
	//std::vector<tagUnionGameItem> kGameList;

	tagUnionAndGameList()
	{
		kUnionList.clear();
		//kGameList.clear();
	}

	tagUnionAndGameList(const tagUnionAndGameList& refInfo)
	{
		kUnionList.assign(refInfo.kUnionList.begin(), refInfo.kUnionList.end());
		//kGameList.assign(refInfo.kGameList.begin(), refInfo.kGameList.end());
	}

	tagUnionAndGameList& operator=(const tagUnionAndGameList& refInfo)
	{
		if (this == &refInfo)
		{
			return *this;
		}

		kUnionList.assign(refInfo.kUnionList.begin(), refInfo.kUnionList.end());
		//kGameList.assign(refInfo.kGameList.begin(), refInfo.kGameList.end());

		return *this;
	}

	void StreamValue(DataStream& kData, bool bSend)
	{
		StructVecotrMember(tagUnionItem, kUnionList);
		//StructVecotrMember(tagUnionGameItem, kGameList);
	}
};

//房间列表;
#pragma pack(1)
struct tagRoomItem 
{
	uint16	wKindID;								//游戏ID;
	uint32	dwUnionCode;							//工会码;
	uint8	cbUnionGoldOpen;						//1开启欢乐豆模式,0不开启;
	uint8	cbGameOK;								//房间状态 1 初始 2 游戏中 8结束
	uint32	dwRoomID;								//房间ID;
	uint32  dwGameRule;								//游戏规则;
	uint8	cbPlayCout;								//已游戏局数;
	uint8	cbPlayCoutIdex;							//游戏局数;
	uint8	cbBaseScore;							//底分;
	DWORD	dwUserIDs[5];
	systemtime InsertTime;							//开始时间
	char	szUnionName[32];						//工会名称;

	void StreamValue(DataStream& kData, bool bSend)
	{
		if (bSend)
		{
			kData.pushValue(this, sizeof(tagRoomItem));
		}
		else
		{
			kData.popValue(this, sizeof(tagRoomItem));
		}
	}
};
#pragma pack()
struct tagRoomItemList
{
	uint8 cbPlayRoomCount;
	std::vector<tagRoomItem> kList;

	tagRoomItemList()
	{
		cbPlayRoomCount = 0;
		kList.clear();
	}

	tagRoomItemList(const tagRoomItemList& refInfo)
	{
		cbPlayRoomCount = refInfo.cbPlayRoomCount;
		kList.assign(refInfo.kList.begin(), refInfo.kList.end());
	}

	tagRoomItemList& operator=(const tagRoomItemList& refInfo)
	{
		if (this == &refInfo)
		{
			return *this;
		}

		cbPlayRoomCount = refInfo.cbPlayRoomCount;
		kList.assign(refInfo.kList.begin(), refInfo.kList.end());
		return *this;
	}

	void StreamValue(DataStream& kData, bool bSend)
	{
		Stream_VALUE(cbPlayRoomCount);
		StructVecotrMember(tagRoomItem, kList);
	}
};

//自动房间列表;
#pragma pack(1)
struct tagAutoRoomItem
{
	uint32  dwIndex;
	uint16	wKindID;								//游戏ID;
	uint16  wServerID;
	uint32	dwUnionCode;							//工会码;
	uint8	cbUnionGoldOpen;						//1开启欢乐豆模式,0不开启;
	uint32  dwGameRule;								//游戏规则;
	uint8	cbPlayCoutIdex;							//游戏局数;
	uint8	cbPlayCout;								//游戏局数;
	uint8	cbBaseScore;							//底分;
	char	szUnionName[32];						//工会名称;
	char    szCreateTime[32];						//创建时间;

	void StreamValue(DataStream& kData, bool bSend)
	{
		if (bSend)
		{
			kData.pushValue(this, sizeof(tagAutoRoomItem));
		}
		else
		{
			kData.popValue(this, sizeof(tagAutoRoomItem));
		}
	}
};
#pragma pack()
struct tagAutoRoomItemList
{
	std::vector<tagAutoRoomItem> kList;

	tagAutoRoomItemList()
	{
		kList.clear();
	}

	tagAutoRoomItemList(const tagAutoRoomItemList& refInfo)
	{
		kList.assign(refInfo.kList.begin(), refInfo.kList.end());
	}

	tagAutoRoomItemList& operator=(const tagAutoRoomItemList& refInfo)
	{
		if (this == &refInfo)
		{
			return *this;
		}
		kList.assign(refInfo.kList.begin(), refInfo.kList.end());
		return *this;
	}

	void StreamValue(DataStream& kData, bool bSend)
	{
		StructVecotrMember(tagAutoRoomItem, kList);
	}
};

// 自由模式玩家准备开始状态;
struct tagAutoUserStatus
{
	bool bStartGame;					// 桌子上人状态;
};

#pragma pack()

#endif