2015华为软件精英挑战赛 客户端源码 德州扑克

2015华为软件精英挑战赛于4月29日正式启动！请登录大赛官网：http://career-elite.huawei.com获取详细信息。
 2015华为软件精英挑战赛（2015 Huawei Software Elite Challenge）是华为公司面向全国高校学生举办的大型软件竞赛，致力于让参赛学生充分感受软件设计和写好代码的魅力，验证用软件设计和编程解决问题的能力，并通过比赛增强实战实践和与人沟通、协作的能力。
本次大赛口号“万码奔腾战江湖”，将在全国设8个赛区同时开展。大赛分区域线上初赛、区域现场复赛和全国总决赛共三轮，选手采用组队方式（1-3人）参赛。
本次大赛赛题于5月5日正式发布，题型将充满乐趣和挑战，我们期待和你共同感受coding的魔力。

一、参赛人员
只要你是
1、 全日制在校大学生（本、硕）
2、 喜爱写软件，满怀激情与梦想
3、 对自己和小伙伴有足够的信心
你就可以参与大赛报名！
你可以选择单枪匹马闯大赛（1人参赛），也可以选择强强联手（2人或3人组队参赛，可跨校组队，以组长所在学校所属区域作为参赛区域），英雄不问出处，竞技场上见分晓。

二、奖项设置
全国总决赛：
至尊天下奖（一等奖），1队，20万现金大奖
笑傲江湖奖（二等奖），2队，10万现金大奖
蟾宫折桂奖（三等奖），5队，5万现金大奖
区域现场复赛：
每区域前4名队伍获雄霸一方奖，晋级全国总决赛，并获得华为最新款手机，加入优才计划
区域线上初赛：
1、每区域前32名队伍获横扫千军奖，晋级本区域现场复赛，获得晋级奖品和证书
2、每区域前64名队伍获得独一无二的精美纪念品

三、赛程设置
4月底（预计4月29日）   启动报名
5月5日                  赛题发布
5月底（预计5月30日）   区域线上初赛
6月初（预计6月7日）    区域现场复赛
6月底或7月上旬（预计7月11日）   全国总决赛
具体日期以正式通知为准，大赛组委会对赛事日程保留最后解释权

四、优才计划
1、面试绿卡：免技术面，通过终面后给予高薪Special Offer
2、应届生实习直通车：国内实习机会任选、岗位工作地任选
3、精英导师贴身辅导：配备首席技术专家和人力资源主管进行一对一的技术指导和职业生涯指导

4、职业快车道：入职后高级主管、首席技术专家担任导师，有机会进入专家或管理者梯队培养计划

五、赛题示例代码

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<errno.h>
#include<errno.h>
#include<string>
#include<sstream>

#include<iostream>
#include<vector>

using namespace std;

enum Color
{
	SPADES,//黑桃
	HEARTS,//红桃
	CLUBS,//梅花
	DIAMONDS//方片
};
enum HandPattern//牌型大小枚举类型
{
	HIGH_CARD,
	ONE_PAIR,
	TWO_PAIR,
	THREE_OF_A_KIND,
	STRAIGHT,
	FLUSH,
	FULL_HOUSE,
	FOUR_OF_A_KIND,
	STRAIGHT_FLUSH
};
enum TypeofMsg
{
	REG_MSG,//注册消息
	SEAT_MSG,//座次消息
	GAME_OVER_MSG,//游戏结束消息
	BLIND_MSG,//盲注消息
	HOLD_CARDS_MSG,//手牌消息
	INQUIRE_MSG,//询问消息
	ACTION_MSG,//行动消息
	FLOP_MSG,//公牌消息
	TURN_MSG,//转牌消息
	RIVER_MSG,//河牌消息
	SHOWDOWN_MSG,//摊牌消息
	POT_WIN_MSG//彩池分配消息
};
struct Poker
{
	int color;//花色
	int point;//点数
};
struct basicInfoforPlayer
{
	int id;//ID号
	int jetton;//筹码
	int money;//金币
};
struct SeatInfoMsg//座次表信息
{
	int totalNumofPlayer;//玩家数量
	struct basicInfoforPlayer button;//庄家
	struct basicInfoforPlayer smallBlind;//小盲注
	struct basicInfoforPlayer bigBlind;//大盲注
	struct basicInfoforPlayer otherPlayer[5];//其它玩家
};

enum ActionType//行动消息
{
	BLIND_DO,
	CHECK_DO,
	CALL_DO,
	RAISE_DO,
	ALL_IN_DO,
	FOLD_DO
};
struct InquireMsg//询问消息
{
	int pid;//ID号
	int jetton;//筹码
	int money;//金币
	int bet;//赌注
	int actionType;//行动消息
};
struct PokerClass//存放我的牌与公共牌取出5张牌的大小
{
	int keyBig;//记录组成最大牌型的最大点数
	int keySmall;//记录组成最大牌型的最小点数
	int varClass;//牌型类型
};
class Player
{
private:
	int PlayerID;
	int SocketID;
	struct sockaddr_in PlayerAddr;
	struct sockaddr_in ServerAddr;
	bool IsConnectSuccess;
	char varGetBuf[1024];
	bool varIsBufNull;//消息接收缓冲区是否有数据
	int rec_len;//接收的字符长度
	struct SeatInfoMsg varSeatInfo;//座次表信息
	struct Poker myPoker[7];//玩家扑克牌
	struct InquireMsg oneReturnMsg[8];//返回消息
	int stageofGame;//游戏所处阶段
	struct basicInfoforPlayer myMoney;//我的钱在这里
	struct PokerClass myPokerClass;//记录我的牌型大小
	bool varIsFold[8];//记录其它选手是否弃牌
public:
	Player(char *argv[])
	{
		/*******Player相关的IP、端口初始化********************/
		bzero(&PlayerAddr,sizeof(PlayerAddr));
		PlayerAddr.sin_family=AF_INET;
		PlayerAddr.sin_addr.s_addr=inet_addr(argv[3]);//IP
		PlayerAddr.sin_port=htons(atoi(argv[4]));//PORT
		/*******Server相关的IP、端口初始化********************/
		bzero(&ServerAddr,sizeof(ServerAddr));
		ServerAddr.sin_family=AF_INET;
		ServerAddr.sin_addr.s_addr=inet_addr(argv[1]);//Server IP
		ServerAddr.sin_port=htons(atoi(argv[2]));//Server Port
		
		PlayerID=atoi(argv[5]);//Player ID
		SocketID=-1;//
		IsConnectSuccess=false;
		
		for(int i=0;i<8;i++)
			bzero(&oneReturnMsg[i],sizeof(InquireMsg));
		
		stageofGame=REG_MSG;//游戏所处阶段初始化
		varIsBufNull=true;//消息接收缓冲区是否有数据
		rec_len=0;//接收的字符长度
	}
	
	~Player()//析构函数
	{
		if(SocketID>0)//关闭Socket连接
		{
			close(SocketID);
		}
			
	}
	
	/********************
	函数名称：DisplayInfo
	函数功能：用于调试输出
	********************/
	void DisplayInfo(void)
	{
		cout<<PlayerID<<endl;
	}
	
	/****************************************************
	函数名称：ConnecttoServer
	函数功能：用于Player连接Server服务器,发送注册消息
	****************************************************/
	bool ConnecttoServer()
	{
		int connect_max_num=5;//最大连接次数
		SocketID =socket(AF_INET,SOCK_STREAM,0);
		if(SocketID<0)
		{
			printf("init socket failed\n");
			return false;
		}
		int is_reuse_addr=1;
		setsockopt(SocketID,SOL_SOCKET,SO_REUSEADDR,(const char*)&is_reuse_addr,sizeof(is_reuse_addr));
		if(bind(SocketID,(struct sockaddr*)&PlayerAddr,sizeof(PlayerAddr))<0)
		{
			printf("blind failed ! \n");
			return false;
		}
		
		while(connect(SocketID,(struct sockaddr*)&ServerAddr,sizeof(ServerAddr))<0 && (connect_max_num--)>0)
		{
			usleep(100*1000);//睡眠100ms继续连接
			if(connect_max_num<=0)
			{
				printf("connect failed!\n");
				printf("connect error: %s(errno: %d)\n", strerror(errno), errno); 
				return false;
			}
		}
		
		char reg_msg[50] = {'\0'};
		snprintf(reg_msg, sizeof(reg_msg) - 1, "reg: %d %s \n",PlayerID, "tt"); 
		if( send(SocketID, reg_msg, strlen(reg_msg)+1, 0) < 0)//向服务器发送注册消息
		{  
			printf("send msg error: %s(errno: %d)\n", strerror(errno), errno);  
			exit(0);  
		} 
		IsConnectSuccess=true;
		return true;
		
	}
	
	/***********************************
	函数名称：GetServerMessage
	函数功能：用于接收并处理服务器消息
	返回值：消息类型
	***********************************/
	int GetServerMessage()
	{
		int varMsgNuminSocket=0;
		string varMsgKind;
		int charStart,charEnd;
		int varMsgLength=0;//记录一个消息长度
		if(varIsBufNull)//消息缓冲区为空，准备接收数据
		{
			if((rec_len = recv(SocketID, varGetBuf, 1024,0)) == -1) 
			{  
				perror("recv error");  
				//continue;  
			}
			varGetBuf[rec_len]='\0';
		}
		
		string one_message(varGetBuf);
			
		
		//获取消息种类
		charStart=0;	charEnd=one_message.find('\n',0);
		varMsgKind=one_message.substr(charStart,charEnd);
		if(varMsgKind=="seat/ ")//座次消息
		{
			varSeatInfo.totalNumofPlayer=0;//将选手个数情况为零
			int lastEnd=one_message.find("/seat ",charStart);
			charStart=charEnd;	charEnd=one_message.find('\n',charStart+1);
			if(charEnd!=string::npos)
			{
				struct basicInfoforPlayer tmp_player;
				int spacepos=0;
				charStart=one_message.find("button: ",charStart+1);
				charStart+=8;
				spacepos=one_message.find(' ',charStart);
				tmp_player.id=atoi(one_message.substr(charStart,spacepos-charStart).c_str());
				charStart=spacepos+1;
				spacepos=one_message.find(' ',charStart);
				tmp_player.jetton=atoi(one_message.substr(charStart,spacepos-charStart).c_str());
				charStart=spacepos+1;
				spacepos=one_message.find(' ',charStart);
				tmp_player.money=atoi(one_message.substr(charStart,spacepos-charStart).c_str());
				varSeatInfo.button=tmp_player;//庄家信息
				varSeatInfo.totalNumofPlayer++;
				
				if(PlayerID==tmp_player.id)//获取我的money
				{
					myMoney=tmp_player;
				}
				charStart=charEnd;
			}
			
			charEnd=one_message.find('\n',charStart+1);
			if(charEnd!=string::npos)
			{
				struct basicInfoforPlayer tmp_player;
				int spacepos=0;
				charStart=one_message.find("small blind: ",charStart+1);
				charStart+=13;
				spacepos=one_message.find(' ',charStart);
				tmp_player.id=atoi(one_message.substr(charStart,spacepos-charStart).c_str());
				charStart=spacepos+1;
				spacepos=one_message.find(' ',charStart);
				tmp_player.jetton=atoi(one_message.substr(charStart,spacepos-charStart).c_str());
				charStart=spacepos+1;
				spacepos=one_message.find(' ',charStart);
				tmp_player.money=atoi(one_message.substr(charStart,spacepos-charStart).c_str());
				varSeatInfo.smallBlind=tmp_player;//小盲注信息
				varSeatInfo.totalNumofPlayer++;
				
				if(PlayerID==tmp_player.id)//获取我的money
				{
					myMoney=tmp_player;
				}
				charStart=charEnd;
			}
			
			charEnd=one_message.find('\n',charStart+1);
			if(charEnd!=string::npos && charEnd<lastEnd)
			{
				struct basicInfoforPlayer tmp_player;
				int spacepos=0;
				charStart=one_message.find("big blind: ",charStart+1);
				charStart+=11;
				spacepos=one_message.find(' ',charStart);
				tmp_player.id=atoi(one_message.substr(charStart,spacepos-charStart).c_str());
				charStart=spacepos+1;
				spacepos=one_message.find(' ',charStart);
				tmp_player.jetton=atoi(one_message.substr(charStart,spacepos-charStart).c_str());
				charStart=spacepos+1;
				spacepos=one_message.find(' ',charStart);
				tmp_player.money=atoi(one_message.substr(charStart,spacepos-charStart).c_str());
				varSeatInfo.bigBlind=tmp_player;//大盲注信息
				varSeatInfo.totalNumofPlayer++;
				
				if(PlayerID==tmp_player.id)//获取我的money
				{
					myMoney=tmp_player;
				}
				charStart=charEnd;
				
			}
			
			for(int i=0;i<5;i++)
			{
				charEnd=one_message.find('\n',charStart+1);
				if(charEnd!=string::npos && charEnd<lastEnd)
				{
					struct basicInfoforPlayer tmp_player;
					int spacepos=0;
					charStart+=1;
					spacepos=one_message.find(' ',charStart);
					tmp_player.id=atoi(one_message.substr(charStart,spacepos-charStart).c_str());
					charStart=spacepos+1;
					spacepos=one_message.find(' ',charStart);
					tmp_player.jetton=atoi(one_message.substr(charStart,spacepos-charStart).c_str());
					charStart=spacepos+1;
					spacepos=one_message.find(' ',charStart);
					tmp_player.money=atoi(one_message.substr(charStart,spacepos-charStart).c_str());
					varSeatInfo.otherPlayer[i]=tmp_player;//其它玩家信息
					varSeatInfo.totalNumofPlayer++;
					
					if(PlayerID==tmp_player.id)//获取我的money
					{
						myMoney=tmp_player;
					}
					charStart=charEnd;
				}
			}
			/*********获取该消息长度********/
			varMsgLength=one_message.find("/seat \n",charStart+1);
			if(varMsgLength!=string::npos)
			{
				varMsgLength+=7;
				//cout<<"该消息长度："<<varMsgLength<<" 总消息长度："<<rec_len<<endl;
			}
			if(varMsgLength<rec_len)//不只包含一条消息，丢弃已查询消息
			{
				for(int i=0;i<(rec_len-varMsgLength);i++)
				{
					varGetBuf[i]=varGetBuf[varMsgLength+i];
				}
				rec_len=rec_len-varMsgLength;//更新消息长度
				varIsBufNull=false;//消息非空
			}
			else
			{
				rec_len=0;//消息长度置零
				varIsBufNull=true;//设置标志位，消息为空
			}
			/************分配座次后，清空自己的牌，防止牌混*************/
			struct Poker varNullPoker;	varNullPoker.color=-1;varNullPoker.point=-1;
			for(int i=0;i<7;i++)
			{
				myPoker[i]=varNullPoker;
			}
			/****************分配座次后，清空返回的询问信息***********************/
			ClearAskMsg();
			/****************分配座次后，所有选手都为正常状态********************/
			/*varIsFold[varSeatInfo.button.id%10-1]=false;
			varIsFold[varSeatInfo.smallBlind.id%10-1]=false;
			if(varSeatInfo.totalNumofPlayer>=3)
			{
				varIsFold[varSeatInfo.bigBlind.id%10-1]=false;
				for(int i=0;i<(varSeatInfo.totalNumofPlayer-3);i++)
					varIsFold[varSeatInfo.otherPlayer[i].id%10-1]=false;
			}*/
			
			/************记录消息所处阶段**************/
			stageofGame=SEAT_MSG;//记录游戏所处阶段
			return SEAT_MSG;
		}//seat
		
		if(varMsgKind=="blind/ ")//强制压盲注消息
		{
			/*********获取该消息长度********/
			varMsgLength=one_message.find("/blind \n",charStart+1);
			if(varMsgLength!=string::npos)
			{
				varMsgLength+=8;
				//cout<<"该消息长度："<<varMsgLength<<" 总消息长度："<<rec_len<<endl;
			}
			if(varMsgLength<rec_len)//不只包含一条消息，丢弃已查询消息
			{
				for(int i=0;i<(rec_len-varMsgLength);i++)
				{
					varGetBuf[i]=varGetBuf[varMsgLength+i];
				}
				rec_len=rec_len-varMsgLength;//更新消息长度
				varIsBufNull=false;//消息非空
			}
			else
			{
				rec_len=0;//消息长度置零
				varIsBufNull=true;//设置标志位，消息为空
			}
			/************记录消息所处阶段**************/
			//cout<<one_message<<endl<<endl;
			stageofGame=BLIND_MSG;//记录游戏所处阶段
			return BLIND_MSG;
		}//blind
		
		if(varMsgKind=="hold/ ")//手牌信息
		{
			for(int i=0;i<2;i++)
			{
				charStart=charEnd;	charEnd=one_message.find('\n',charStart+1);
				if(charEnd!=string::npos)
				{
					struct Poker tmpPoker;
					int spacepos=0;
					charStart+=1;
					spacepos=one_message.find(' ',charStart);
					string tmp_color(one_message.substr(charStart,spacepos-charStart).c_str());
					if(tmp_color=="SPADES")
						tmpPoker.color=SPADES;
					else if(tmp_color=="HEARTS")
						tmpPoker.color=HEARTS;
					else if(tmp_color=="CLUBS")
						tmpPoker.color=CLUBS;
					else
						tmpPoker.color=DIAMONDS;
					charStart=spacepos+1;
					spacepos=one_message.find(' ',charStart);
					string tmp_point=one_message.substr(charStart,spacepos-charStart).c_str();
					if(tmp_point=="J")
						tmpPoker.point=11;
					else if(tmp_point=="Q")
						tmpPoker.point=12;
					else if(tmp_point=="K")
						tmpPoker.point=13;
					else if(tmp_point=="A")
						tmpPoker.point=14;
					else
						tmpPoker.point=atoi(tmp_point.c_str());
					myPoker[i]=tmpPoker;//手牌信息
					charStart=charEnd;
				}
			}
			/*********获取该消息长度********/
			varMsgLength=one_message.find("/hold \n",charStart+1);
			if(varMsgLength!=string::npos)
			{
				varMsgLength+=7;
				//cout<<"该消息长度："<<varMsgLength<<" 总消息长度："<<rec_len<<endl;
			}
			if(varMsgLength<rec_len)//不只包含一条消息，丢弃已查询消息
			{
				for(int i=0;i<(rec_len-varMsgLength);i++)
				{
					varGetBuf[i]=varGetBuf[varMsgLength+i];
				}
				rec_len=rec_len-varMsgLength;//更新消息长度
				varIsBufNull=false;//消息非空
			}
			else
			{
				rec_len=0;//消息长度置零
				varIsBufNull=true;//设置标志位，消息为空
			}
			/************记录消息所处阶段**************/
			stageofGame=HOLD_CARDS_MSG;//记录游戏所处阶段
			return HOLD_CARDS_MSG;
		}//hold
		
		if(varMsgKind=="inquire/ ")//询问消息
		{
			int lastEnd=one_message.find("total pot: ",charStart+9);
			for(int i=0;i<8;i++)
			{
				charStart=charEnd;	charEnd=one_message.find('\n',charStart+1);
				if(charEnd!=string::npos && charEnd<lastEnd)
				{
					struct InquireMsg tmpInqMsg;
					int spacepos=0;
					charStart+=1;
					spacepos=one_message.find(' ',charStart);
					tmpInqMsg.pid=atoi(one_message.substr(charStart,spacepos-charStart).c_str());
					charStart=spacepos+1;
					spacepos=one_message.find(' ',charStart);
					tmpInqMsg.jetton=atoi(one_message.substr(charStart,spacepos-charStart).c_str());
					charStart=spacepos+1;
					spacepos=one_message.find(' ',charStart);
					tmpInqMsg.money=atoi(one_message.substr(charStart,spacepos-charStart).c_str());
					charStart=spacepos+1;
					spacepos=one_message.find(' ',charStart);
					tmpInqMsg.bet=atoi(one_message.substr(charStart,spacepos-charStart).c_str());
					
					charStart=spacepos+1;
					spacepos=one_message.find(' ',charStart);
					string tmp_action_type=one_message.substr(charStart,spacepos-charStart).c_str();
					
					if(tmp_action_type=="blind")
						tmpInqMsg.actionType=BLIND_DO;
					else if(tmp_action_type=="fold")
						tmpInqMsg.actionType=FOLD_DO;
					else if(tmp_action_type=="check")
						tmpInqMsg.actionType=CHECK_DO;
					else if(tmp_action_type=="call")
						tmpInqMsg.actionType=CALL_DO;
					else if(tmp_action_type=="raise")
						tmpInqMsg.actionType=RAISE_DO;
					else
						tmpInqMsg.actionType=ALL_IN_DO;
					
					oneReturnMsg[i]=tmpInqMsg;//返回消息
					
					charStart=charEnd;
					
				}
				else
				{
					break;
				}
			}
			
			/*********获取该消息长度********/
			varMsgLength=one_message.find("/inquire \n",charStart+1);
			if(varMsgLength!=string::npos)
			{
				varMsgLength+=10;
				//cout<<"该消息长度："<<varMsgLength<<" 总消息长度："<<rec_len<<endl;
			}
			if(varMsgLength<rec_len)//不只包含一条消息，丢弃已查询消息
			{
				for(int i=0;i<(rec_len-varMsgLength);i++)
				{
					varGetBuf[i]=varGetBuf[varMsgLength+i];
				}
				rec_len=rec_len-varMsgLength;//更新消息长度
				varIsBufNull=false;//消息非空
			}
			else
			{
				rec_len=0;//消息长度置零
				varIsBufNull=true;//设置标志位，消息为空
			}
			/************记录消息所处阶段**************/
			return INQUIRE_MSG;
		}//inquire
		
		if(varMsgKind=="flop/ ")//公牌消息
		{
			int lastEnd=one_message.find("/flop ",charStart+7);
			for(int i=2;i<5;i++)
			{
				charStart=charEnd;	charEnd=one_message.find('\n',charStart+1);
				if(charEnd!=string::npos && charEnd<lastEnd)
				{
					struct Poker tmpPoker;
					int spacepos=0;
					charStart+=1;
					spacepos=one_message.find(' ',charStart);
					string tmp_color(one_message.substr(charStart,spacepos-charStart).c_str());
					if(tmp_color=="SPADES")
						tmpPoker.color=SPADES;
					else if(tmp_color=="HEARTS")
						tmpPoker.color=HEARTS;
					else if(tmp_color=="CLUBS")
						tmpPoker.color=CLUBS;
					else
						tmpPoker.color=DIAMONDS;
					charStart=spacepos+1;
					spacepos=one_message.find(' ',charStart);
					string tmp_point=one_message.substr(charStart,spacepos-charStart).c_str();
					if(tmp_point=="J")
						tmpPoker.point=11;
					else if(tmp_point=="Q")
						tmpPoker.point=12;
					else if(tmp_point=="K")
						tmpPoker.point=13;
					else if(tmp_point=="A")
						tmpPoker.point=14;
					else
						tmpPoker.point=atoi(tmp_point.c_str());
					myPoker[i]=tmpPoker;//公牌信息
					charStart=charEnd;
				}
			}
			/*********获取该消息长度********/
			varMsgLength=one_message.find("/flop \n",charStart+1);
			if(varMsgLength!=string::npos)
			{
				varMsgLength+=7;
				//cout<<"该消息长度："<<varMsgLength<<" 总消息长度："<<rec_len<<endl;
			}
			if(varMsgLength<rec_len)//不只包含一条消息，丢弃已查询消息
			{
				for(int i=0;i<(rec_len-varMsgLength);i++)
				{
					varGetBuf[i]=varGetBuf[varMsgLength+i];
				}
				rec_len=rec_len-varMsgLength;//更新消息长度
				varIsBufNull=false;//消息非空
			}
			else
			{
				rec_len=0;//消息长度置零
				varIsBufNull=true;//设置标志位，消息为空
			}
			/************记录消息所处阶段**************/
			stageofGame=FLOP_MSG;//记录游戏所处阶段
			return FLOP_MSG;
		}//flop
		
		if(varMsgKind=="turn/ ")//转牌消息
		{
				charStart=charEnd;	charEnd=one_message.find('\n',charStart+1);
				if(charEnd!=string::npos)
				{
					struct Poker tmpPoker;
					int spacepos=0;
					charStart+=1;
					spacepos=one_message.find(' ',charStart);
					string tmp_color(one_message.substr(charStart,spacepos-charStart).c_str());
					if(tmp_color=="SPADES")
						tmpPoker.color=SPADES;
					else if(tmp_color=="HEARTS")
						tmpPoker.color=HEARTS;
					else if(tmp_color=="CLUBS")
						tmpPoker.color=CLUBS;
					else
						tmpPoker.color=DIAMONDS;
					charStart=spacepos+1;
					spacepos=one_message.find(' ',charStart);
					string tmp_point=one_message.substr(charStart,spacepos-charStart).c_str();
					if(tmp_point=="J")
						tmpPoker.point=11;
					else if(tmp_point=="Q")
						tmpPoker.point=12;
					else if(tmp_point=="K")
						tmpPoker.point=13;
					else if(tmp_point=="A")
						tmpPoker.point=14;
					else
						tmpPoker.point=atoi(tmp_point.c_str());
					myPoker[5]=tmpPoker;//转牌信息
					charStart=charEnd;
				}
				
				/*********获取该消息长度********/
			varMsgLength=one_message.find("/turn \n",charStart+1);
			if(varMsgLength!=string::npos)
			{
				varMsgLength+=7;
				//cout<<"该消息长度："<<varMsgLength<<" 总消息长度："<<rec_len<<endl;
			}
			if(varMsgLength<rec_len)//不只包含一条消息，丢弃已查询消息
			{
				for(int i=0;i<(rec_len-varMsgLength);i++)
				{
					varGetBuf[i]=varGetBuf[varMsgLength+i];
				}
				rec_len=rec_len-varMsgLength;//更新消息长度
				varIsBufNull=false;//消息非空
			}
			else
			{
				rec_len=0;//消息长度置零
				varIsBufNull=true;//设置标志位，消息为空
			}
			/************记录消息所处阶段**************/
				stageofGame=TURN_MSG;//记录游戏所处阶段
				return TURN_MSG;
		}
		
		if(varMsgKind=="river/ ")//河牌消息
		{
				charStart=charEnd;	charEnd=one_message.find('\n',charStart+1);
				if(charEnd!=string::npos)
				{
					struct Poker tmpPoker;
					int spacepos=0;
					charStart+=1;
					spacepos=one_message.find(' ',charStart);
					string tmp_color(one_message.substr(charStart,spacepos-charStart).c_str());
					if(tmp_color=="SPADES")
						tmpPoker.color=SPADES;
					else if(tmp_color=="HEARTS")
						tmpPoker.color=HEARTS;
					else if(tmp_color=="CLUBS")
						tmpPoker.color=CLUBS;
					else
						tmpPoker.color=DIAMONDS;
					charStart=spacepos+1;
					spacepos=one_message.find(' ',charStart);
					string tmp_point=one_message.substr(charStart,spacepos-charStart).c_str();
					if(tmp_point=="J")
						tmpPoker.point=11;
					else if(tmp_point=="Q")
						tmpPoker.point=12;
					else if(tmp_point=="K")
						tmpPoker.point=13;
					else if(tmp_point=="A")
						tmpPoker.point=14;
					else
						tmpPoker.point=atoi(tmp_point.c_str());
					myPoker[6]=tmpPoker;//转牌信息
					charStart=charEnd;
				}
				/*********获取该消息长度********/
			varMsgLength=one_message.find("/river \n",charStart+1);
			if(varMsgLength!=string::npos)
			{
				varMsgLength+=8;
				//cout<<"该消息长度："<<varMsgLength<<" 总消息长度："<<rec_len<<endl;
			}
			if(varMsgLength<rec_len)//不只包含一条消息，丢弃已查询消息
			{
				for(int i=0;i<(rec_len-varMsgLength);i++)
				{
					varGetBuf[i]=varGetBuf[varMsgLength+i];
				}
				rec_len=rec_len-varMsgLength;//更新消息长度
				varIsBufNull=false;//消息非空
			}
			else
			{
				rec_len=0;//消息长度置零
				varIsBufNull=true;//设置标志位，消息为空
			}
			/************记录消息所处阶段**************/
				stageofGame=RIVER_MSG;//记录游戏所处阶段
				return RIVER_MSG;
		}
		
		if(varMsgKind=="showdown/ ")//摊牌消息消息
		{
			/*********获取该消息长度********/
			varMsgLength=one_message.find("/showdown \n",charStart+1);
			if(varMsgLength!=string::npos)
			{
				varMsgLength+=11;
				//cout<<"该消息长度："<<varMsgLength<<" 总消息长度："<<rec_len<<endl;
			}
			if(varMsgLength<rec_len)//不只包含一条消息，丢弃已查询消息
			{
				for(int i=0;i<(rec_len-varMsgLength);i++)
				{
					varGetBuf[i]=varGetBuf[varMsgLength+i];
				}
				rec_len=rec_len-varMsgLength;//更新消息长度
				varIsBufNull=false;//消息非空
			}
			else
			{
				rec_len=0;//消息长度置零
				varIsBufNull=true;//设置标志位，消息为空
			}
			/************记录消息所处阶段**************/
			stageofGame=SHOWDOWN_MSG;//记录游戏所处阶段
			return SHOWDOWN_MSG;
		}
		
		if(varMsgKind=="pot-win/ ")//彩池分配消息
		{
			/*********获取该消息长度********/
			varMsgLength=one_message.find("/pot-win \n",charStart+1);
			if(varMsgLength!=string::npos)
			{
				varMsgLength+=10;
				//cout<<"该消息长度："<<varMsgLength<<" 总消息长度："<<rec_len<<endl;
			}
			if(varMsgLength<rec_len)//不只包含一条消息，丢弃已查询消息
			{
				for(int i=0;i<(rec_len-varMsgLength);i++)
				{
					varGetBuf[i]=varGetBuf[varMsgLength+i];
				}
				rec_len=rec_len-varMsgLength;//更新消息长度
				varIsBufNull=false;//消息非空
			}
			else
			{
				rec_len=0;//消息长度置零
				varIsBufNull=true;//设置标志位，消息为空
			}
			/************记录消息所处阶段**************/
			//cout<<one_message<<endl;
			//cout<<"My money: "<<myMoney.id<<" "<<myMoney.jetton<<" "<<myMoney.money<<endl;
			stageofGame=POT_WIN_MSG;//记录游戏所处阶段
			return POT_WIN_MSG;
		}
		if(varMsgKind=="game-over ")//游戏结束
		{
			/*********获取该消息长度********/
			varMsgLength=one_message.find("game-over \n",charStart+1);
			if(varMsgLength!=string::npos)
			{
				varMsgLength+=11;
				//cout<<"该消息长度："<<varMsgLength<<" 总消息长度："<<rec_len<<endl;
			}
			if(varMsgLength<rec_len)//不只包含一条消息，丢弃已查询消息
			{
				for(int i=0;i<(rec_len-varMsgLength);i++)
				{
					varGetBuf[i]=varGetBuf[varMsgLength+i];
				}
				rec_len=rec_len-varMsgLength;//更新消息长度
				varIsBufNull=false;//消息非空
			}
			else
			{
				rec_len=0;//消息长度置零
				varIsBufNull=true;//设置标志位，消息为空
			}
			/************记录消息所处阶段**************/
			cout<<PlayerID<<": game over!"<<endl;
			
			stageofGame=GAME_OVER_MSG;//记录游戏所处阶段
			return GAME_OVER_MSG;
		}
		
		rec_len=0;//消息长度置零
		varIsBufNull=true;//设置标志位，消息为空
		return -1;//没有接收到消息
	}
	
	/***************************************************
	函数功能：发送消息给服务器
	函数名称：SendMsgtoServer
	传递参数：int actionNowType,int actionNowValue
	****************************************************/
	bool SendMsgtoServer(int actionNowType,int actionNowValue)
	{
		char varSendMsg[50] = {'\0'};
		
		if(IsConnectSuccess)
		{
			switch(actionNowType)//消息生成
			{
				case CHECK_DO:
					snprintf(varSendMsg, sizeof(varSendMsg) - 1, "check \n"); 
					break;
				case CALL_DO:
					snprintf(varSendMsg, sizeof(varSendMsg) - 1, "call \n"); 
					break;
				case RAISE_DO:
					snprintf(varSendMsg, sizeof(varSendMsg) - 1, "raise %d \n",actionNowValue); 
					break;
				case ALL_IN_DO:
					snprintf(varSendMsg, sizeof(varSendMsg) - 1, "all_in \n"); 
					break;
				case FOLD_DO:
					snprintf(varSendMsg, sizeof(varSendMsg) - 1, "fold \n"); 
					break;
				default:
					break;
			}//switch
			
			if( send(SocketID, varSendMsg, strlen(varSendMsg)+1, 0) < 0) 
			{
				cout<<"Send Msg Faild!"<<endl;
				return false;
			}
			return true;
		}
		return false;
	}
	/********************************************
	函数功能：获取牌型大小
	函数名称：GetPokerPattern
	*********************************************/
	int GetPokerPattern(int var_stage)
	{
		int varPokerKind=-1;
		/************清空自己牌型大小记录数据************/
			myPokerClass.varClass=-1;//牌型大小初始化为非正常值
			
		if(var_stage==HOLD_CARDS_MSG)//手牌阶段只有两张牌
		{
			if(myPoker[0].point==myPoker[1].point)
				varPokerKind=ONE_PAIR;
			else if(myPoker[0].color==myPoker[1].color)
				varPokerKind=FLUSH;
			else
				varPokerKind=-1;
		}
		else if(var_stage==FLOP_MSG)//发出公共牌三张，翻牌圈阶段
		{
			if(myPoker[4].color!=-1)//牌型获取是否正确
			{
				struct Poker tmp_Poker;
				struct Poker varRankPoker[5];
				int m=0,tag,j;
				bool varIsFlush=false;//判断当前牌是否为同花
				for(int i=0;i<5;i++)
					varRankPoker[i]=myPoker[i];
				do
				{
					tag=0;
					for(j=4;j>m;j--)
						if(varRankPoker[j].point<varRankPoker[j-1].point)
						{
							tmp_Poker=varRankPoker[j];varRankPoker[j]=varRankPoker[j-1];
							varRankPoker[j-1]=tmp_Poker;
							tag=1;
						}
						m++;
				}while(tag==1 && m<=4);
				if(varRankPoker[0].color==varRankPoker[1].color && varRankPoker[0].color==varRankPoker[2].color && varRankPoker[0].color==varRankPoker[3].color && varRankPoker[0].color==varRankPoker[4].color)
					varIsFlush=true;//判断当前牌是否为同花
				else
					varIsFlush=false;
				if(varIsFlush)
				{
					int flagStraight=0;
					for(int i=0;i<4;i++)
					{
						if((varRankPoker[i+1].point-varRankPoker[i].point)==1)
							flagStraight++;
					}
					if(flagStraight==4)//同花顺
					{
						myPokerClass.varClass=STRAIGHT_FLUSH;
						myPokerClass.keyBig=varRankPoker[4].point;
						myPokerClass.keySmall=varRankPoker[0].point;
						varPokerKind=STRAIGHT_FLUSH;
						return varPokerKind;
					}
					else//only FLUSH
					{
						myPokerClass.varClass=FLUSH;
						myPokerClass.keyBig=varRankPoker[4].point;
						myPokerClass.keySmall=varRankPoker[0].point;
						varPokerKind=FLUSH;
						return varPokerKind;
					}
					
				}
				else
				{
					int flag[4];
					int zeroNum=0;
					int oneNum=0;
					for(int i=0;i<4;i++)
					{
						flag[i]=varRankPoker[i+1].point-varRankPoker[i].point;
						if(flag[i]==0)
							zeroNum++;
						if(flag[i]==1)
							oneNum++;
					}
					if((flag[0]==0 && flag[1]==0 && flag[2]==0) || (flag[1]==0 && flag[2]==0 && flag[3]==0))//FOUR_OF_A_KIND
					{
						myPokerClass.varClass=FOUR_OF_A_KIND;
						if(flag[0]==0)
						{
							myPokerClass.keyBig=varRankPoker[0].point;
							myPokerClass.keySmall=varRankPoker[0].point;
						}
						else
						{
							myPokerClass.keyBig=varRankPoker[1].point;
							myPokerClass.keySmall=varRankPoker[1].point;
						}
						varPokerKind=FOUR_OF_A_KIND;
						/*for(int i=0;i<5;i++)
							cout<<varRankPoker[i].point<<" ";
						cout<<"FOUR_OF_A_KIND"<<endl;*/
						return varPokerKind;
					}//FOUR_OF_A_KIND
					else if((flag[0]==0 && flag[1]==0 && flag[3]==0) || (flag[0]==0 && flag[2]==0 && flag[3]==0))//FULL_HOUSE
					{
						myPokerClass.varClass=FULL_HOUSE;
						if(flag[1]==0)
						{
							myPokerClass.keyBig=varRankPoker[2].point;
							myPokerClass.keySmall=varRankPoker[0].point;
						}
						else
						{
							myPokerClass.keyBig=varRankPoker[0].point;
							myPokerClass.keySmall=varRankPoker[3].point;
						}
						varPokerKind=FULL_HOUSE;
						return varPokerKind;
					}//FULL_HOUSE
					else if(zeroNum==2)//TWO_PAIR THREE_OF_A_KIND
					{
						bool isThree=false;//是否为三条
						for(int i=0;i<3;i++)
						{
							if(flag[i]==0)
							{
								if(flag[i+1]==0)
									isThree=true;
								break;
							}
						}
						if(isThree)
						{
							myPokerClass.varClass=THREE_OF_A_KIND;
							for(int i=0;i<4;i++)
								if(flag[i]==0)
								{
									myPokerClass.keyBig=varRankPoker[i].point;
									myPokerClass.keySmall=varRankPoker[i].point;
								}
							varPokerKind=THREE_OF_A_KIND;
							return varPokerKind;
									
						}
						else
						{
							bool isSmallGet=false;
							myPokerClass.varClass=TWO_PAIR;
							for(int i=0;i<4;i++)
							{
								if(flag[i]==0)
								{
									if(!isSmallGet)
									{
										myPokerClass.keySmall=varRankPoker[i].point;
										isSmallGet=true;
									}
									else
									{
										myPokerClass.keyBig=varRankPoker[i].point;
									}
									
								}
									
							}
							varPokerKind=TWO_PAIR;
							return varPokerKind;
						}
						
					}//TWO_PAIR THREE_OF_A_KIND
					else if(zeroNum==1)//ONE_PAIR
					{
						myPokerClass.varClass=ONE_PAIR;
						for(int i=0;i<4;i++)
						{
							if(flag[i]==0)
								myPokerClass.keyBig=varRankPoker[i].point;
							if(i==3)
								myPokerClass.keySmall=varRankPoker[2].point;
							else
								myPokerClass.keySmall=varRankPoker[3].point;
						}
						varPokerKind=ONE_PAIR;
						
						return varPokerKind;
					}//ONE_PAIR
					else if(oneNum==4)//STRAIGHT
					{
						myPokerClass.varClass=STRAIGHT;
						myPokerClass.keyBig=varRankPoker[4].point;
						myPokerClass.keySmall=varRankPoker[0].point;
						varPokerKind=STRAIGHT;
						return varPokerKind;
					}//STRAIGHT
					else//HIGH_CARD
					{
						myPokerClass.varClass=HIGH_CARD;
						myPokerClass.keyBig=varRankPoker[4].point;
						myPokerClass.keySmall=varRankPoker[0].point;
						varPokerKind=HIGH_CARD;
						return varPokerKind;
					}//HIGH_CARD
				}
				
			}
			else//获取牌型不正确
			{
				varPokerKind=-1;
			}
		}
		else if(var_stage==TURN_MSG)//转牌阶段判断牌型大小：6张选5张
		{
			int var5PokerClass[6];
			int bestClass=-1,position=0;
			struct Poker tmpTurnPoker[5];
			int varSlectPoker[6][5]={{1,2,3,4,5},{0,2,3,4,5},{0,1,3,4,5},{0,1,2,4,5},{0,1,2,3,5},{0,1,2,3,4}};
			for(int i=0;i<6;i++)
			{
				for(int j=0;j<5;j++)
					tmpTurnPoker[j]=myPoker[varSlectPoker[i][j]];
				var5PokerClass[i]=Get5PokersKind(tmpTurnPoker);
			}
			for(int i=0;i<6;i++)
			{
				if(bestClass<var5PokerClass[i])
				{
					bestClass=var5PokerClass[i];
					position=i;
				}
			}
			for(int j=0;j<5;j++)
				tmpTurnPoker[j]=myPoker[varSlectPoker[position][j]];
			Get5PokersKind(tmpTurnPoker);
			
			return bestClass;
		}
		else if(var_stage==RIVER_MSG)//河牌阶段判断牌型大小，7张中选5张
		{
			int var5PokerClass[21];
			int bestClass=-1,position=0;
			struct Poker tmpTurnPoker[5];
			int varSlectPoker[21][5]={{2,3,4,5,6},{1,3,4,5,6},{1,2,4,5,6},{1,2,3,5,6},{1,2,3,4,6},{1,2,3,4,5},
				{0,3,4,5,6},{0,2,4,5,6},{0,2,3,5,6},{0,2,3,4,6},{0,2,3,4,5},{0,1,4,5,6},{0,1,3,5,6},{0,1,3,4,6},
					{0,1,3,4,5},{0,1,2,5,6},{0,1,2,4,6},{0,1,2,4,5},{0,1,2,3,6},{0,1,2,3,5},{0,1,2,3,4}};
			for(int i=0;i<21;i++)
			{
				for(int j=0;j<5;j++)
					tmpTurnPoker[j]=myPoker[varSlectPoker[i][j]];
				var5PokerClass[i]=Get5PokersKind(tmpTurnPoker);
			}
			for(int i=0;i<21;i++)
			{
				if(bestClass<var5PokerClass[i])
				{
					bestClass=var5PokerClass[i];
					position=i;
				}
			}
			for(int j=0;j<5;j++)
				tmpTurnPoker[j]=myPoker[varSlectPoker[position][j]];
			Get5PokersKind(tmpTurnPoker);
			
			return bestClass;
		}
		return varPokerKind;
	}
	/**************************************
	函数名称：
	函数功能：判断5张牌的牌型大熊
	***************************************/
	int Get5PokersKind(struct Poker tmpmyPoker[])
	{
		int varPokerKind=-1;
		if(tmpmyPoker[4].color!=-1)//牌型获取是否正确
			{
				struct Poker tmp_Poker;
				struct Poker varRankPoker[5];
				int m=0,tag,j;
				bool varIsFlush=false;//判断当前牌是否为同花 
				for(int i=0;i<5;i++)
					varRankPoker[i]=tmpmyPoker[i];
				do
				{
					tag=0;
					for(j=4;j>m;j--)
						if(varRankPoker[j].point<varRankPoker[j-1].point)
						{
							tmp_Poker=varRankPoker[j];varRankPoker[j]=varRankPoker[j-1];
							varRankPoker[j-1]=tmp_Poker;
							tag=1;
						}
						m++;
				}while(tag==1 && m<=4);
				if(varRankPoker[0].color==varRankPoker[1].color && varRankPoker[0].color==varRankPoker[2].color && varRankPoker[0].color==varRankPoker[3].color && varRankPoker[0].color==varRankPoker[4].color)
					varIsFlush=true;//判断当前牌是否为同花
				else
					varIsFlush=false;
				if(varIsFlush)
				{
					int flagStraight=0;
					for(int i=0;i<4;i++)
					{
						if((varRankPoker[i+1].point-varRankPoker[i].point)==1)
							flagStraight++;
					}
					if(flagStraight==4)//同花顺
					{
						myPokerClass.varClass=STRAIGHT_FLUSH;
						myPokerClass.keyBig=varRankPoker[4].point;
						myPokerClass.keySmall=varRankPoker[0].point;
						varPokerKind=STRAIGHT_FLUSH;
						return varPokerKind;
					}
					else//only FLUSH
					{
						myPokerClass.varClass=FLUSH;
						myPokerClass.keyBig=varRankPoker[4].point;
						myPokerClass.keySmall=varRankPoker[0].point;
						varPokerKind=FLUSH;
						return varPokerKind;
					}
					
				}
				else
				{
					int flag[4];
					int zeroNum=0;
					int oneNum=0;
					for(int i=0;i<4;i++)
					{
						flag[i]=varRankPoker[i+1].point-varRankPoker[i].point;
						if(flag[i]==0)
							zeroNum++;
						if(flag[i]==1)
							oneNum++;
					}
					if((flag[0]==0 && flag[1]==0 && flag[2]==0) || (flag[1]==0 && flag[2]==0 && flag[3]==0))//FOUR_OF_A_KIND
					{
						myPokerClass.varClass=FOUR_OF_A_KIND;
						if(flag[0]==0)
						{
							myPokerClass.keyBig=varRankPoker[0].point;
							myPokerClass.keySmall=varRankPoker[0].point;
						}
						else
						{
							myPokerClass.keyBig=varRankPoker[1].point;
							myPokerClass.keySmall=varRankPoker[1].point;
						}
						varPokerKind=FOUR_OF_A_KIND;
						/*for(int i=0;i<5;i++)
							cout<<varRankPoker[i].point<<" ";
						cout<<"FOUR_OF_A_KIND"<<endl;*/
						return varPokerKind;
					}//FOUR_OF_A_KIND
					else if((flag[0]==0 && flag[1]==0 && flag[3]==0) || (flag[0]==0 && flag[2]==0 && flag[3]==0))//FULL_HOUSE
					{
						myPokerClass.varClass=FULL_HOUSE;
						if(flag[1]==0)
						{
							myPokerClass.keyBig=varRankPoker[2].point;
							myPokerClass.keySmall=varRankPoker[0].point;
						}
						else
						{
							myPokerClass.keyBig=varRankPoker[0].point;
							myPokerClass.keySmall=varRankPoker[3].point;
						}
						varPokerKind=FULL_HOUSE;
						return varPokerKind;
					}//FULL_HOUSE
					else if(zeroNum==2)//TWO_PAIR THREE_OF_A_KIND
					{
						bool isThree=false;//是否为三条
						for(int i=0;i<3;i++)
						{
							if(flag[i]==0)
							{
								if(flag[i+1]==0)
									isThree=true;
								break;
							}
						}
						if(isThree)
						{
							myPokerClass.varClass=THREE_OF_A_KIND;
							for(int i=0;i<4;i++)
								if(flag[i]==0)
								{
									myPokerClass.keyBig=varRankPoker[i].point;
									myPokerClass.keySmall=varRankPoker[i].point;
								}
							varPokerKind=THREE_OF_A_KIND;
							return varPokerKind;
									
						}
						else
						{
							bool isSmallGet=false;
							myPokerClass.varClass=TWO_PAIR;
							for(int i=0;i<4;i++)
							{
								if(flag[i]==0)
								{
									if(!isSmallGet)
									{
										myPokerClass.keySmall=varRankPoker[i].point;
										isSmallGet=true;
									}
									else
									{
										myPokerClass.keyBig=varRankPoker[i].point;
									}
									
								}
									
							}
							varPokerKind=TWO_PAIR;
							return varPokerKind;
						}
						
					}//TWO_PAIR THREE_OF_A_KIND
					else if(zeroNum==1)//ONE_PAIR
					{
						myPokerClass.varClass=ONE_PAIR;
						for(int i=0;i<4;i++)
						{
							if(flag[i]==0)
								myPokerClass.keyBig=varRankPoker[i].point;
							if(i==3)
								myPokerClass.keySmall=varRankPoker[2].point;
							else
								myPokerClass.keySmall=varRankPoker[3].point;
						}
						varPokerKind=ONE_PAIR;
						
						return varPokerKind;
					}//ONE_PAIR
					else if(oneNum==4)//STRAIGHT
					{
						myPokerClass.varClass=STRAIGHT;
						myPokerClass.keyBig=varRankPoker[4].point;
						myPokerClass.keySmall=varRankPoker[0].point;
						varPokerKind=STRAIGHT;
						return varPokerKind;
					}//STRAIGHT
					else//HIGH_CARD
					{
						myPokerClass.varClass=HIGH_CARD;
						myPokerClass.keyBig=varRankPoker[4].point;
						myPokerClass.keySmall=varRankPoker[0].point;
						varPokerKind=HIGH_CARD;
						return varPokerKind;
					}//HIGH_CARD
				}
				
			}
			return varPokerKind;
	}
	/**************************************
	函数名称：BeatAllPlayer
	函数功能：根据手中牌型大小决策动作
	**************************************/
	bool BeatAllPlayer(int var_stage)
	{
		int varPokerKind=-1;
		bool varIsSendSuccess=true;
		if(var_stage==HOLD_CARDS_MSG)//手牌决策
		{
			varPokerKind=GetPokerPattern(HOLD_CARDS_MSG);
			if((varPokerKind==ONE_PAIR) || (varPokerKind==FLUSH))
			{
				if(GetAllOtherPlayerActionFold())
				{
					varIsSendSuccess=SendMsgtoServer(ALL_IN_DO,0);
					return varIsSendSuccess;
				}
				if(GetOtherPlayerBet()<=200)//当前赌注小，可以跟
				{
					varIsSendSuccess=SendMsgtoServer(CALL_DO,0);
				}
				else if(GetOtherPlayerBet()>200 && myPoker[0].point>=13 && myPoker[1].point>=13)//防止其他牌手所有all_in
				{
					varIsSendSuccess=SendMsgtoServer(CALL_DO,0);
				}
				else
				{
					if(varSeatInfo.totalNumofPlayer<=3 && GetOtherPlayerBet()<=200)//当玩家数量比较小的时候，可以继续跟牌
						varIsSendSuccess=SendMsgtoServer(RAISE_DO,10);
					else if(varSeatInfo.totalNumofPlayer<=3 && GetOtherPlayerBet()>200)
						varIsSendSuccess=SendMsgtoServer(CHECK_DO,10);
					else
						varIsSendSuccess=SendMsgtoServer(FOLD_DO,0);
				}
				return varIsSendSuccess;
			}
			else if(myPoker[0].point>=10 && myPoker[1].point>=10)
			{
				if(GetAllOtherPlayerActionFold())
				{
					varIsSendSuccess=SendMsgtoServer(ALL_IN_DO,0);
					return varIsSendSuccess;
				}
				if(GetOtherPlayerBet()<=200 || GetAllOtherPlayerActionFold())//当前赌注小，可以跟
				{
					varIsSendSuccess=SendMsgtoServer(CALL_DO,0);
				}
				else
				{
					
					if(varSeatInfo.totalNumofPlayer<=3 && GetOtherPlayerBet()<=200)//当玩家数量比较小的时候，可以继续跟牌
						varIsSendSuccess=SendMsgtoServer(CALL_DO,10);
					else if(varSeatInfo.totalNumofPlayer<=3 && GetOtherPlayerBet()>200)
						varIsSendSuccess=SendMsgtoServer(CHECK_DO,10);
					else
						varIsSendSuccess=SendMsgtoServer(FOLD_DO,0);
				}
				return varIsSendSuccess;
			}
			else
			{
				if(GetAllOtherPlayerActionFold())
					varIsSendSuccess=SendMsgtoServer(ALL_IN_DO,0);
				else
					varIsSendSuccess=SendMsgtoServer(FOLD_DO,0);
				return varIsSendSuccess;
			}
		}
		else if(var_stage==FLOP_MSG)//公牌阶段决策
		{
			if(GetAllOtherPlayerActionFold())
			{
				varIsSendSuccess=SendMsgtoServer(ALL_IN_DO,0);
				return varIsSendSuccess;
			}
			varPokerKind=GetPokerPattern(FLOP_MSG);
			if((varPokerKind==STRAIGHT_FLUSH) || (varPokerKind==FOUR_OF_A_KIND))//同花顺、四条全下
			{
				varIsSendSuccess=SendMsgtoServer(ALL_IN_DO,0);
			}
			else if(varPokerKind==FULL_HOUSE)//葫芦
			{
				if(GetOtherPlayerBet()<=500)//当前赌注小，可以跟
				{
					varIsSendSuccess=SendMsgtoServer(RAISE_DO,200);
				}
				else
				{
					if(varSeatInfo.totalNumofPlayer<=3)//当玩家数量比较小的时候，可以继续跟牌
						varIsSendSuccess=SendMsgtoServer(RAISE_DO,100);
					else
						varIsSendSuccess=SendMsgtoServer(CHECK_DO,0);
				}
			}
			else if(varPokerKind==FLUSH)//同花
			{
				if(GetOtherPlayerBet()<=500)//当前赌注小，可以跟
				{
					varIsSendSuccess=SendMsgtoServer(RAISE_DO,100);
				}
				else
				{
					if(varSeatInfo.totalNumofPlayer<=3)//当玩家数量比较小的时候，可以继续跟牌
						varIsSendSuccess=SendMsgtoServer(RAISE_DO,50);
					else
						varIsSendSuccess=SendMsgtoServer(CHECK_DO,0);
				}
			}
			else if(varPokerKind==STRAIGHT)//顺子
			{
				if(GetOtherPlayerBet()<=300)//当前赌注小，可以跟
				{
					varIsSendSuccess=SendMsgtoServer(CALL_DO,0);
				}
				else
				{
					if(varSeatInfo.totalNumofPlayer<=3)//当玩家数量比较小的时候，可以继续跟牌
						varIsSendSuccess=SendMsgtoServer(RAISE_DO,10);
					else
						varIsSendSuccess=SendMsgtoServer(CHECK_DO,0);
				}
			}
			else if(varPokerKind==THREE_OF_A_KIND)//三条
			{
				if(GetOtherPlayerBet()<=300)//当前赌注小，可以跟
				{
					varIsSendSuccess=SendMsgtoServer(CALL_DO,0);
				}
				else
				{
					if(varSeatInfo.totalNumofPlayer<=3 && GetOtherPlayerBet()<=600)//当玩家数量比较小的时候，可以继续跟牌
						varIsSendSuccess=SendMsgtoServer(RAISE_DO,10);
					else if(varSeatInfo.totalNumofPlayer<=3 && GetOtherPlayerBet()>600)
						varIsSendSuccess=SendMsgtoServer(CHECK_DO,0);
					else
						varIsSendSuccess=SendMsgtoServer(CHECK_DO,0);
				}
			}
			else if(varPokerKind==TWO_PAIR)//两对
			{
				if(GetOtherPlayerBet()<=200)//当前赌注小，可以跟
				{
					varIsSendSuccess=SendMsgtoServer(CALL_DO,0);
				}
				else
				{
					if(varSeatInfo.totalNumofPlayer<=3 && GetOtherPlayerBet()<=300)//当玩家数量比较小的时候，可以继续跟牌
						varIsSendSuccess=SendMsgtoServer(RAISE_DO,5);
					else if(varSeatInfo.totalNumofPlayer<=3 && GetOtherPlayerBet()>300)
						varIsSendSuccess=SendMsgtoServer(CHECK_DO,0);
					else
						varIsSendSuccess=SendMsgtoServer(FOLD_DO,0);
				}
			}
			else if(varPokerKind==ONE_PAIR)//一对
			{
				if(GetOtherPlayerBet()<=200 && myPokerClass.keyBig>10)//当前赌注小，可以跟
				{
					varIsSendSuccess=SendMsgtoServer(CALL_DO,0);
				}
				else
				{
					if(varSeatInfo.totalNumofPlayer<=3 && GetOtherPlayerBet()<=200)//当玩家数量比较小的时候，可以继续跟牌
						varIsSendSuccess=SendMsgtoServer(CHECK_DO,0);
					else if(varSeatInfo.totalNumofPlayer<=3 && GetOtherPlayerBet()>200)
						varIsSendSuccess=SendMsgtoServer(CHECK_DO,0);
					else
						varIsSendSuccess=SendMsgtoServer(FOLD_DO,0);
				}
			}
			else
			{
				varIsSendSuccess=SendMsgtoServer(FOLD_DO,0);
			}
		}//公牌阶段决策
		else if(var_stage==TURN_MSG)//转牌阶段决策
		{
			if(GetAllOtherPlayerActionFold())
			{
				varIsSendSuccess=SendMsgtoServer(ALL_IN_DO,0);
				return varIsSendSuccess;
			}
			varPokerKind=GetPokerPattern(TURN_MSG);
			if((varPokerKind==STRAIGHT_FLUSH) || (varPokerKind==FOUR_OF_A_KIND))//同花顺、四条全下
			{
				varIsSendSuccess=SendMsgtoServer(ALL_IN_DO,0);
			}
			else if(varPokerKind==FULL_HOUSE)//葫芦
			{
				if(GetOtherPlayerBet()<=800)//当前赌注小，可以跟
				{
					varIsSendSuccess=SendMsgtoServer(RAISE_DO,200);
				}
				else
				{
					if(varSeatInfo.totalNumofPlayer<=3)//当玩家数量比较小的时候，可以继续跟牌
						varIsSendSuccess=SendMsgtoServer(RAISE_DO,200);
					else
						varIsSendSuccess=SendMsgtoServer(CHECK_DO,0);
				}
			}
			else if(varPokerKind==FLUSH)//同花
			{
				if(GetOtherPlayerBet()<=500)//当前赌注小，可以跟
				{
					varIsSendSuccess=SendMsgtoServer(RAISE_DO,100);
				}
				else
				{
					if(varSeatInfo.totalNumofPlayer<=3 && GetOtherPlayerBet()<=800)//当玩家数量比较小的时候，可以继续跟牌
						varIsSendSuccess=SendMsgtoServer(RAISE_DO,100);
					else if(varSeatInfo.totalNumofPlayer<=3 && GetOtherPlayerBet()>800)
						varIsSendSuccess=SendMsgtoServer(CHECK_DO,0);
					else
						varIsSendSuccess=SendMsgtoServer(CHECK_DO,0);
				}
			}
			else if(varPokerKind==STRAIGHT)//顺子
			{
				if(GetOtherPlayerBet()<=300)//当前赌注小，可以跟
				{
					varIsSendSuccess=SendMsgtoServer(RAISE_DO,100);
				}
				else
				{
					if(varSeatInfo.totalNumofPlayer<=3 && GetOtherPlayerBet()<=400)//当玩家数量比较小的时候，可以继续跟牌
						varIsSendSuccess=SendMsgtoServer(RAISE_DO,50);
					else if(varSeatInfo.totalNumofPlayer<=3 && GetOtherPlayerBet()>400)
						varIsSendSuccess=SendMsgtoServer(CHECK_DO,0);
					else
						varIsSendSuccess=SendMsgtoServer(CHECK_DO,0);
				}
			}
			else if(varPokerKind==THREE_OF_A_KIND)//三条
			{
				if(GetOtherPlayerBet()<=300)//当前赌注小，可以跟
				{
					varIsSendSuccess=SendMsgtoServer(RAISE_DO,20);
				}
				else
				{
					if(varSeatInfo.totalNumofPlayer<=3 && GetOtherPlayerBet()<=300)//当玩家数量比较小的时候，可以继续跟牌
						varIsSendSuccess=SendMsgtoServer(CALL_DO,0);
					else if(varSeatInfo.totalNumofPlayer<=3 && GetOtherPlayerBet()>300)
						varIsSendSuccess=SendMsgtoServer(CHECK_DO,0);
					else
						varIsSendSuccess=SendMsgtoServer(CHECK_DO,0);
				}
			}
			else if(varPokerKind==TWO_PAIR)//两对
			{
				if(GetOtherPlayerBet()<=200)//当前赌注小，可以跟
				{
					varIsSendSuccess=SendMsgtoServer(CALL_DO,0);
				}
				else
				{
					if(varSeatInfo.totalNumofPlayer<=3 && GetOtherPlayerBet()<=200)//当玩家数量比较小的时候，可以继续跟牌
						varIsSendSuccess=SendMsgtoServer(RAISE_DO,5);
					else if(varSeatInfo.totalNumofPlayer<=3 && GetOtherPlayerBet()>200)
						varIsSendSuccess=SendMsgtoServer(CHECK_DO,0);
					else
						varIsSendSuccess=SendMsgtoServer(FOLD_DO,0);
				}
			}
			else if(varPokerKind==ONE_PAIR)//一对
			{
				if(GetOtherPlayerBet()<=200 && myPokerClass.keyBig>12)//当前赌注小，可以跟
				{
					varIsSendSuccess=SendMsgtoServer(CALL_DO,0);
				}
				else
				{
					if(varSeatInfo.totalNumofPlayer<=3 && GetOtherPlayerBet()<=200)//当玩家数量比较小的时候，可以继续跟牌
						varIsSendSuccess=SendMsgtoServer(CALL_DO,0);
					else if(varSeatInfo.totalNumofPlayer<=3 && GetOtherPlayerBet()>200)
						varIsSendSuccess=SendMsgtoServer(CHECK_DO,0);
					else
						varIsSendSuccess=SendMsgtoServer(FOLD_DO,0);
				}
			}
			else
			{
				varIsSendSuccess=SendMsgtoServer(FOLD_DO,0);
			}
		}//转牌阶段决策
		else if(var_stage==RIVER_MSG)//河牌阶段决策
		{
			if(GetAllOtherPlayerActionFold())
			{
				varIsSendSuccess=SendMsgtoServer(ALL_IN_DO,0);
				return varIsSendSuccess;
			}
			varPokerKind=GetPokerPattern(RIVER_MSG);
			if((varPokerKind==STRAIGHT_FLUSH) || (varPokerKind==FOUR_OF_A_KIND))//同花顺、四条全下
			{
				varIsSendSuccess=SendMsgtoServer(ALL_IN_DO,0);
			}
			else if(varPokerKind==FULL_HOUSE)//葫芦
			{
				if(GetOtherPlayerBet()<=600)//当前赌注小，可以跟
				{
					varIsSendSuccess=SendMsgtoServer(ALL_IN_DO,0);
				}
				else
				{
					if(varSeatInfo.totalNumofPlayer<=3 && GetOtherPlayerBet()<=400)//当玩家数量比较小的时候，可以继续跟牌
						varIsSendSuccess=SendMsgtoServer(RAISE_DO,200);
					else if(varSeatInfo.totalNumofPlayer<=3 && GetOtherPlayerBet()>400)
						varIsSendSuccess=SendMsgtoServer(CHECK_DO,0);
					else
						varIsSendSuccess=SendMsgtoServer(CHECK_DO,0);
				}
			}
			else if(varPokerKind==FLUSH)//同花
			{
				if(GetOtherPlayerBet()<=500)//当前赌注小，可以跟
				{
					varIsSendSuccess=SendMsgtoServer(RAISE_DO,100);
				}
				else
				{
					if(varSeatInfo.totalNumofPlayer<=3 && GetOtherPlayerBet()<=300)//当玩家数量比较小的时候，可以继续跟牌
						varIsSendSuccess=SendMsgtoServer(RAISE_DO,100);
					else if(varSeatInfo.totalNumofPlayer<=3 && GetOtherPlayerBet()>300)
						varIsSendSuccess=SendMsgtoServer(CHECK_DO,0);
					else
						varIsSendSuccess=SendMsgtoServer(CHECK_DO,0);
				}
			}
			else if(varPokerKind==STRAIGHT)//顺子
			{
				if(GetOtherPlayerBet()<=200)//当前赌注小，可以跟
				{
					varIsSendSuccess=SendMsgtoServer(RAISE_DO,20);
				}
				else
				{
					if(varSeatInfo.totalNumofPlayer<=3 && GetOtherPlayerBet()<=200)//当玩家数量比较小的时候，可以继续跟牌
						varIsSendSuccess=SendMsgtoServer(RAISE_DO,50);
					else if(varSeatInfo.totalNumofPlayer<=3 && GetOtherPlayerBet()>200)
						varIsSendSuccess=SendMsgtoServer(CHECK_DO,0);
					else
						varIsSendSuccess=SendMsgtoServer(CHECK_DO,0);
				}
			}
			else if(varPokerKind==THREE_OF_A_KIND)//三条
			{
				if(GetOtherPlayerBet()<=150)//当前赌注小，可以跟
				{
					varIsSendSuccess=SendMsgtoServer(CALL_DO,0);
				}
				else
				{
					if(varSeatInfo.totalNumofPlayer<=3 && GetOtherPlayerBet()<=100)//当玩家数量比较小的时候，可以继续跟牌
						varIsSendSuccess=SendMsgtoServer(RAISE_DO,5);
					else if(varSeatInfo.totalNumofPlayer<=3 && GetOtherPlayerBet()>100)
						varIsSendSuccess=SendMsgtoServer(CHECK_DO,0);
					else
						varIsSendSuccess=SendMsgtoServer(CHECK_DO,0);
				}
			}
			else if(varPokerKind==TWO_PAIR)//两对
			{
				if(GetOtherPlayerBet()<=100)//当前赌注小，可以跟
				{
					varIsSendSuccess=SendMsgtoServer(CALL_DO,0);
				}
				else
				{
					if(varSeatInfo.totalNumofPlayer<=3 && GetOtherPlayerBet()<=200)//当玩家数量比较小的时候，可以继续跟牌
						varIsSendSuccess=SendMsgtoServer(RAISE_DO,5);
					else if(varSeatInfo.totalNumofPlayer<=3 && GetOtherPlayerBet()>200)
						varIsSendSuccess=SendMsgtoServer(CHECK_DO,0);
					else
						varIsSendSuccess=SendMsgtoServer(FOLD_DO,0);
				}
			}
			else if(varPokerKind==ONE_PAIR)//一对
			{
				if(GetOtherPlayerBet()<=100 && myPokerClass.keyBig>13)//当前赌注小，可以跟
				{
					varIsSendSuccess=SendMsgtoServer(CALL_DO,0);
				}
				else
				{
					if(varSeatInfo.totalNumofPlayer<=3 && GetOtherPlayerBet()<=200)//当玩家数量比较小的时候，可以继续跟牌
						varIsSendSuccess=SendMsgtoServer(CALL_DO,0);
					else if(varSeatInfo.totalNumofPlayer<=3 && GetOtherPlayerBet()>200)
						varIsSendSuccess=SendMsgtoServer(CHECK_DO,0);
					else
						varIsSendSuccess=SendMsgtoServer(FOLD_DO,0);
				}
			}
			else
			{
				varIsSendSuccess=SendMsgtoServer(FOLD_DO,0);
			}
		}
		return varIsSendSuccess;
	}
	/***************************************
	函数名称：GetOtherPlayerAction
	函数功能：获取其它对手最大赌注
	***************************************/
	int GetOtherPlayerBet()
	{
		if(oneReturnMsg[0].pid>0)
			return oneReturnMsg[0].bet;
		else
			return 0;
	}
	/***************************************
	函数名称：
	函数功能：清空返回的消息缓冲区
	***************************************/
	void ClearAskMsg()
	{
		struct InquireMsg tmp_inquire_msg;
		tmp_inquire_msg.pid=-1;tmp_inquire_msg.jetton=-1;tmp_inquire_msg.money=-1;
		tmp_inquire_msg.bet=-1;tmp_inquire_msg.actionType=-1;
		for(int i=0;i<8;i++)
			oneReturnMsg[i]=tmp_inquire_msg;
	}
	/**************************************
	函数名称：
	函数功能：获取当前游戏状态
	**************************************/
	int GetGameStage()
	{
		return stageofGame;
	}
	/*************************************
	函数名称：GetAllOtherPlayerActionFold
	函数功能：获取其它选手是否全部弃牌
	*************************************/
	bool GetAllOtherPlayerActionFold()
	{
		int varFoldNum=0;
		for(int i=0;i<8;i++)
		{
			if(oneReturnMsg[i].pid!=-1)
			{
				if(oneReturnMsg[i].actionType==FOLD_DO)
					varFoldNum++;
			}
			else
			{
				break;
			}
		}
		if(varFoldNum==(varSeatInfo.totalNumofPlayer-1))
			return true;
		else
			return false;
	}
} ;//class Player


int main(int argc,char *argv[])
{
	Player player1(argv);
	if(player1.ConnecttoServer())
	{
		int varGetMsgType=-1;
		while(1)
		{
			varGetMsgType=player1.GetServerMessage();
			if(varGetMsgType==INQUIRE_MSG)
			{
				/*if(!player1.SendMsgtoServer(CALL_DO,0))
					cout<<"Send Msg failed"<<endl;*/
				if(player1.GetGameStage()==HOLD_CARDS_MSG)
				{
					player1.BeatAllPlayer(HOLD_CARDS_MSG);
				}
				else if(player1.GetGameStage()==FLOP_MSG)
				{
					player1.BeatAllPlayer(FLOP_MSG);
				}
				else if(player1.GetGameStage()==TURN_MSG)
				{
					player1.BeatAllPlayer(TURN_MSG);
				}
				else if(player1.GetGameStage()==RIVER_MSG)
				{
					player1.BeatAllPlayer(RIVER_MSG);
				}
				else
				{
					
				}
				player1.ClearAskMsg();//行动后，清空返回询问消息
			}
			else if(varGetMsgType==GAME_OVER_MSG)//游戏结束，则退出消息循环，关闭程序
			{
				break;
			}
		}
	}
	
	return 0;
		
}