扑克类游戏斗地主、蜘蛛纸牌源码_开源纸牌小游戏

11号，硬着头皮吃水饺，不知道馅是什么肉做的，应该没有三会火腿肠好吧.....

这是移植自网上搜索到的两个扑克类游戏，原游戏是MFC做的，移植到了OpenGL中。两者的渲染方式不同，架构有所改变。总共没花几天时间，如果自己从头写估计至少要用几个月。

扑克类游戏主要是数据结构要列好，算法都是初级的入门算法，繁琐但是并不困难。

继续给游戏添加了联机和自动出牌功能，出牌智商有点弱。

抽象出一些基类PokerGame，PokerPlayer方便派生出多种类型的游戏。斗地主游戏PokerDouDiZhu或其它的出牌类游戏比如‘’红心大战‘’都可以继承自PokerGame类。斗地主玩家基类DouDizhuPlayer也继承自PokerPlayer。

还是原先的小游戏架构分三种类型的玩家： （Player、Robot、Role） 

DouDizhuPlayer             继承自PokerPlayer是斗地主玩家基类，只有被动出牌功能（只响应出牌消息，不主动发送出牌消息给主机和其它玩家）。

DouDizhuPlayerRobot   继承自DouDizhuPlayer是AI玩家类，具有自动出牌功能（主动发送出牌消息）。

DouDizhuPlayerRole     继承自DouDizhuPlayerRobot是实体玩家类，具有自动出牌功能的同时也可以手选出牌。

对于蜘蛛纸牌游戏，结构上和斗地主类出牌的游戏应该算是两种不同的类型了。这个蜘蛛纸牌游戏只加了提示出牌功能，没有做联机和自动出牌。

定义纸牌ID：

//========================================================
//  @Date:     2016.05
//  @File:     SourceDemoClient/Poker/PokerGame.h
//  @Brief:     PokerGame
//  @Author:     LouLei
//  @Email:  twopointfive@163.com
//  @Copyright (Crapell) - All Rights Reserved
//========================================================
 
#if !defined(PokerCard_h__)
#define PokerCard_h__
 
//扑克牌ID
enum CardID
{
	MEIH2=0,
	MEIH3,
	MEIH4,
	MEIH5,
	MEIH6,
	MEIH7,
	MEIH8,
	MEIH9,
	MEIH10,
	MEIHJ,
	MEIHQ,
	MEIHK,
	MEIHA,
	FANGK2,  
	FANGK3,  
	FANGK4,  
	FANGK5,  
	FANGK6,  
	FANGK7,  
	FANGK8,  
	FANGK9,  
	FANGK10, 
	FANGKJ,  
	FANGKQ,  
	FANGKK,  
	FANGKA,  
	HEIT2,
	HEIT3,
	HEIT4,
	HEIT5,
	HEIT6,
	HEIT7,
	HEIT8,
	HEIT9,
	HEIT10,  
	HEITJ,
	HEITQ,
	HEITK,
	HEITA,
	HONGT2,  
	HONGT3,  
	HONGT4,  
	HONGT5,  
	HONGT6,  
	HONGT7,  
	HONGT8,  
	HONGT9,  
	HONGT10, 
	HONGTJ,  
	HONGTQ,  
	HONGTK,  
	HONGTA,  
	JokerSmall,      
	JokerBig,
	CardNum
};
 
 
//单张牌
class Card
{
public:	
	Card();
	int  Color();           //牌的花色
 
	bool   bClicked;	    //是否被左键选中待出牌
	int    cardValue;		//牌面值
	CardID cardID;	
};
 
#endif 

出牌型游戏基类：

//========================================================
//  @Date:     2016.05
//  @File:     SourceDemoClient/Poker/PokerGame.h
//  @Brief:     PokerGame
//  @Author:     LouLei
//  @Email:  twopointfive@163.com
//  @Copyright (Crapell) - All Rights Reserved
//========================================================
 
#if !defined(PokerGame_h__)
#define PokerGame_h__
 
#include "Render/Texture.h"
#include "Poker/PokerCard.h"
#include "Rpg/MiniGame.h"
 
#define MaxPlayerCard		20  //玩家最多持牌数
#define RenderShiftX		20  //牌之间距离
#define RenderShiftY		20
 
#define RenderLeftRightSpace	10  //牌距离屏幕左右留空
#define RenderUpDownSpace	    10   //牌距离屏幕上下留空
#define RenderUpDownDistance	25   //上下第二排牌距离第一排留空
#define RenderClickedAddDistance	20 //点选后牌高出的长度
 
#define Board2DCen (G_PokerGame->BoardRect2D.GetCen())
 
//显示座位：不同的客户端看到的不一样（不是每个客户端都是坐北朝南）
enum ChairPostion
{
	SP_Down,
	SP_Right,
	SP_Up,
	SP_Left,
};
 
//网络消息
enum MiniPokerCmd
{
	CMD_ShuffleCard,  //洗牌
	CMD_BeLord     ,  //叫地主
	CMD_NotBeLord  ,  //不叫地主
	CMD_OutCard    ,  //出牌
	CMD_Pass       ,  //过
	CMD_GameOver   ,  //结束
	CMD_Restart    ,  //重新开始
};
const char* PokerCmdToString(int enumeration);
 
class SoundChannel;
class GuiMovieCtrl;
class PokerGame;
//玩家的数据结构
class PokerPlayer:public MiniPlayer
{
public:
	PokerPlayer();
	virtual~PokerPlayer();
	virtual bool Start();
	virtual bool Stop();
	virtual void Update();
	virtual void Render();
 
	virtual void RecvCard(CardID cardID);
	virtual void SortCard();   //整牌
 
	//出牌
	virtual void OutCard();	
 
	//张数
	int CountCard(int value);
	//
	int MinCard(int temp[], int num);
	//分析牌 各value值的张数
	void AnalyseCard();
 
	bool ClickCards(int cardValue[],int num);		//改变牌状态,标记待出
	bool ClickCardsID(int cardID[],int num);		//改变牌状态,标记待出
	int  ClickCard(const vec2& pos);
 
	ChairPostion  m_screenPos;			//显示座位：上下左右
	bool m_workingWithAI;		
 
	Card m_cards[MaxPlayerCard];	
	int	 m_cardNum;				
	int  m_turn;                        //统一座位：东西南北
 
	int  m_outNum;		        //出到桌面的牌数
	bool m_notOut;				//不出牌的标记
	int  ValueCount[18];	    //各value值的张数
 
	int  m_totalScore;			//记录总分
	int  m_turnScore;			//记录这回合得分
 
	int CardY;					//south myplayer第一张牌左上角 xy
	int CardX;					 
	int m_clickedNum;			//点击待出的牌数
 
	bool  m_bBaoPai;
 
	PokerGame*  m_game;
 
	SoundChannel*  m_sound;
	GuiMovieCtrl*  m_movieCtrl;
};
 
//准备要出的牌
class ToOutCards
{
public:
	ToOutCards();
	Card m_cards[MaxPlayerCard];	
	int	 m_cardNum;	
	//张数
	int CountCard(int value);
	//最小的牌
	int MinCard();
};
 
//游戏状态
enum PokerGameStatus
{
	Waiting,  //准备
	Dealing,  //发牌
	Preparing,//叫地主中
	Playing,  //进行中
	Resulting,//显示结果
};
 
//牌的状态
enum CardFlag
{
	NotDeal = 0,//未发的牌
	InHand,     //已发牌未出的牌
	BeOut,      //已出的牌
};
 
class PacketBase;
class PokerGame
{
public:
	PokerGame();
	virtual ~PokerGame();
 
	virtual bool Start();
	virtual bool Stop();
	virtual bool Render();
	virtual bool Update();
	virtual bool Free();
	
	virtual bool CheckRoundEnd();				//回合结束判断
	virtual void FirstOut();					//游戏开始首次出牌	
 
	virtual void StateDealCard();				//发牌
	virtual void SignCard(Card *card);		//标记牌分值
	virtual void NextTurn();
 
	void ShuffleCard();        //洗牌
	virtual void OutCard(PokerPlayer*player);	//出牌
 
	PokerPlayer* GetTurnPlayer();		
 
	//处理游戏网络命令包
	virtual int  ProcessPacketCmd(PacketBase* packet);
	//virtual const char* CmdToString(const char* stream,int len);
 
 
	PokerGameStatus m_gameStatus;
	CardFlag m_cardFlag[CardNum];		//出牌标记
	/*CardID*/char   m_cardShuffle[CardNum];    //洗牌结果
	PokerPlayer*  m_players[4];			
	PokerPlayer*  m_myPlayer;
	int  m_playerNum;				
	int  m_turn;				//出牌位置
	int  m_lastOutTurn;		    //上次出牌位置
	float m_turnTime;           //换手时间
 
	int   m_dealCardNum;
	float m_dealAccumTime;
					
	int CardHeight;				//牌长
	int CardWidth;				//牌宽
 
	bool m_openPoker;
 
	bool m_bHost;
 
	TexturePtr m_texBack;
	TexturePtr m_cardTexture[CardNum];
	TexturePtr m_cardBackTexture;
	TexturePtr m_thinkTexture[4];
	TexturePtr m_passTexture[4];
	TexturePtr m_passButtonTexture;
};
 
#endif 
 
//========================================================
//  @Date:     2016.05
//  @File:     SourceDemoClient/Poker/PokerGame.cpp
//  @Brief:     PokerGame
//  @Author:     LouLei
//  @Email:  twopointfive@163.com
//  @Copyright (Crapell) - All Rights Reserved
//========================================================
 
#include "General/Pch.h"
#include "General/Window.h"
#include "General/Timer.h"
#include "Poker/PokerGame.h"
#include "Render/RendDriver.h"
#include "Render/Texture.h"
#include "Render/Font.h"
#include "Packet/PacketMiniGame.h"
#include "Sound/ChannelSound.h"
#include "Rpg/MiniGame.h"
#include <stdlib.h>
#include "General/Pce.h"
#include "MiniGamePoker.h"
#include "Rpg/SyncGameInfo.h"
 
 
PokerGame::PokerGame()
{
	m_gameStatus = Dealing;
	m_openPoker = false;
	for (int i=0;i<4;i++)
	{
		 m_players[i] = NULL;
	}
}
 
PokerGame::~PokerGame()
{
	Free();
}
 
void PokerGame::StateDealCard()
{
}
 
 
void PokerGame::OutCard(PokerPlayer*player)
{
	G_PokerGame->PlaySound__("data/sound/step_foot.wav");
	for(int i = 0; i < player->m_cardNum; i++)
	{
		if(player->m_cards[i].bClicked == true)
		{
			m_cardFlag[player->m_cards[i].cardID] = BeOut;
		}
	}
	player->OutCard();
}
 
void PokerGame::FirstOut()
{
}
 
 
 
bool PokerGame::CheckRoundEnd()
{
	return false;
}
 
bool PokerGame::Render()
{
	G_RendDriver->Color4f(1,1,1,1);
	G_RendDriver->SetRenderStateEnable(RS_BLEND,true);
	G_RendDriver->BlendFunc(Blend_Filter);
 
	//if(m_gameStatus == Playing)
	{
		for(int i = 0; i < m_playerNum; i++)
		{
			m_players[i]->Render();
		}
	}
	return true;
}
 
bool PokerGame::Start()
{  
	m_gameStatus = Dealing;
	m_dealCardNum = 0;
	m_dealAccumTime = 0;
	m_turn = 0;
	m_lastOutTurn = -1;
 
	for(int i = 0; i < CardNum; i++)
		m_cardFlag[i] = NotDeal;
 
	G_TextureMgr->AddTexture(m_texBack, "data/minigame/poker/back.png");
 
	const char* cardTexName[] = 
	{
		"data/minigame/poker/mei2.png",
		"data/minigame/poker/mei3.png",
		"data/minigame/poker/mei4.png",
		"data/minigame/poker/mei5.png",
		"data/minigame/poker/mei6.png",
		"data/minigame/poker/mei7.png",
		"data/minigame/poker/mei8.png",
		"data/minigame/poker/mei9.png",
		"data/minigame/poker/mei10.png",
		"data/minigame/poker/meiJ.png",
		"data/minigame/poker/meiQ.png",
		"data/minigame/poker/meiK.png",
		"data/minigame/poker/meiA.png",
 
		"data/minigame/poker/fang2.png",
		"data/minigame/poker/fang3.png",
		"data/minigame/poker/fang4.png",
		"data/minigame/poker/fang5.png",
		"data/minigame/poker/fang6.png",
		"data/minigame/poker/fang7.png",
		"data/minigame/poker/fang8.png",
		"data/minigame/poker/fang9.png",
		"data/minigame/poker/fang10.png",
		"data/minigame/poker/fangJ.png",
		"data/minigame/poker/fangQ.png",
		"data/minigame/poker/fangK.png",
		"data/minigame/poker/fangA.png",
 
		"data/minigame/poker/hei2.png",
		"data/minigame/poker/hei3.png",
		"data/minigame/poker/hei4.png",
		"data/minigame/poker/hei5.png",
		"data/minigame/poker/hei6.png",
		"data/minigame/poker/hei7.png",
		"data/minigame/poker/hei8.png",
		"data/minigame/poker/hei9.png",
		"data/minigame/poker/hei10.png",
		"data/minigame/poker/heiJ.png",
		"data/minigame/poker/heiQ.png",
		"data/minigame/poker/heiK.png",
		"data/minigame/poker/heiA.png",
 
		"data/minigame/poker/hong2.png",
		"data/minigame/poker/hong3.png",
		"data/minigame/poker/hong4.png",
		"data/minigame/poker/hong5.png",
		"data/minigame/poker/hong6.png",
		"data/minigame/poker/hong7.png",
		"data/minigame/poker/hong8.png",
		"data/minigame/poker/hong9.png",
		"data/minigame/poker/hong10.png",
		"data/minigame/poker/hongJ.png",
		"data/minigame/poker/hongQ.png",
		"data/minigame/poker/hongK.png",
		"data/minigame/poker/hongA.png",
 
		"data/minigame/poker/xiaowang.png",
		"data/minigame/poker/dawang.png",
	};
	for (int i=0;i<CardNum;i++)
	{
		G_TextureMgr->AddTexture(m_cardTexture[i],cardTexName[i]);
	}
	G_TextureMgr->AddTexture(m_cardBackTexture,"data/minigame/poker/cardback01.png");
	G_TextureMgr->AddTexture(m_passTexture[0],"data/minigame/poker/donotout00.png");
	G_TextureMgr->AddTexture(m_passTexture[1],"data/minigame/poker/donotout01.png");
	G_TextureMgr->AddTexture(m_passTexture[2],"data/minigame/poker/donotout02.png");
	G_TextureMgr->AddTexture(m_passTexture[3],"data/minigame/poker/donotout03.png");
 
	G_TextureMgr->AddTexture(m_thinkTexture[0],"data/minigame/poker/think00.png");
	G_TextureMgr->AddTexture(m_thinkTexture[1],"data/minigame/poker/think01.png");
	G_TextureMgr->AddTexture(m_thinkTexture[2],"data/minigame/poker/think02.png");
	G_TextureMgr->AddTexture(m_thinkTexture[3],"data/minigame/poker/think03.png");
	G_TextureMgr->AddTexture(m_passButtonTexture,"data/minigame/poker/donotoutbutton.png");
 
	CardHeight = 96;
	CardWidth = 71;
	
	if (m_bHost)
	{
		ShuffleCard();
		C2SPacketMiniGameCmd packet;
		packet.WriteHeader();
		packet.WriteValue(CMD_ShuffleCard);  //todo每个人只发各自的牌，地主牌叫过另发。防止外挂作弊。
		packet.WriteValue(m_cardShuffle);    //seed即可
		G_MiniGame->SendPacketToOther(&packet);
	}
	else
	{
		for (int i = 0; i < CardNum; i++)
		{
			m_cardShuffle[i] = -1;
		}
	}
	return true;
}
bool PokerGame::Stop()
{  
	Free();
	return true;
}
PokerPlayer* PokerGame::GetTurnPlayer()
{
	return m_players[m_turn];
}
 
void PokerGame::SignCard(Card *card)
{
 
}
 
bool PokerGame::Update()
{
	m_turnTime += G_Timer->GetStepTimeLimited();
	if (m_gameStatus == Preparing
		||m_gameStatus == Playing)
	{
		GetTurnPlayer()->Update();
	}
	return true;
}
 
bool PokerGame::Free()
{
	for (int i=0;i<4;i++)
	{
		SafeDelete(m_players[i]);
	}
	return true;
}
 
void PokerGame::NextTurn()
{
	int nextTurn = (++m_turn) % m_playerNum;
	m_turn = nextTurn;
	m_players[nextTurn]->m_outNum = 0;
	m_players[nextTurn]->m_notOut = 0;
 
	//m_players[(1+m_turn) % m_playerNum]->m_notOut = 0;
	m_turnTime = 0;
}
 
void PokerGame::ShuffleCard() //洗牌
{
	for (int i = 0; i < CardNum; i++)
	{
		m_cardShuffle[i] = (CardID)i;
	}
	// 随机i-1中的任意一个数与i交换
	for (int i = 2; i < CardNum; i++)
	{
		int ran = Rand()%i;
		char temp = m_cardShuffle[ran];
		m_cardShuffle[ran] = m_cardShuffle[i];
		m_cardShuffle[i] = temp;
	}
}
 
int  PokerGame::ProcessPacketCmd(PacketBase* packet)
{
	int cmd;
	packet->ReadValue(cmd);
	switch(cmd)
	{
	case CMD_ShuffleCard:
		{
			//todo 只发自己的牌
			packet->ReadValue(m_cardShuffle);
		}
		return 1;
	}
 
	return 0;
}
 
 
 
Card::Card()
{
	bClicked = false;
}
 
int Card::Color()
{
	if(cardID == JokerSmall)
	{
		return 4; //小王 黑桃&&梅花
	}
	else if(cardID == JokerBig)
	{
		return 5;
	}
	else if(cardID >= 0 && cardID < JokerSmall)
	{
		return cardID / 13;
	}
	return 0;
}
 
 
PokerPlayer::PokerPlayer()
:m_workingWithAI(false)
,m_clickedNum(0)
,m_movieCtrl(NULL)
{
	m_sound = new SoundChannel;
}
 
PokerPlayer::~PokerPlayer()
{
	SafeDelete(m_sound);
}
 
void PokerPlayer::AnalyseCard()
{
	for(int i = 0; i < 18; i++)
	{
		ValueCount[i] = CountCard(i);
	}
}
 
int  PokerPlayer::MinCard(int temp[], int num)
{
	int i, min = temp[0];
	for(i = 1; i < num; i++)
	{
		if(temp[i] < min)
		{
			min = temp[i];
		}
	}
	return min;
}
 
int  PokerPlayer::CountCard(int value)
{
	int n = 0; 
	for(int i = 0 ; i < m_cardNum ; i++)
	{
		if(m_cards[i].cardValue == value)
			n++;
	}
	return n;
}
 
void PokerPlayer::RecvCard(CardID cardID)
{
	m_cards[m_cardNum].cardID = cardID;
	m_cards[m_cardNum].bClicked = false;
	m_game->SignCard(&m_cards[m_cardNum]);
	m_cardNum++;
 
	m_sound->PlaySound__("data/sound/chess_duk.wav");
}
 
bool PokerPlayer::Start()
{
	for(int j = 0; j < MaxPlayerCard; j++)
	{
		m_cards[j].cardID = (CardID)0;
		m_cards[j].cardValue = -1;
		m_cards[j].bClicked = false;
	}
	m_cardNum = 0;
	m_outNum = 0;
	m_screenPos = SP_Up;
	m_totalScore = 0;
	m_turnScore = 0;
	m_bBaoPai = false;
	return true;
}
 
bool PokerPlayer::Stop()
{
	Free();
	return true;
}
 
void PokerPlayer::OutCard()
{
	Card card;
	int outNum = 0;
	int i = 0;
	while(i < m_cardNum)
	{
		if(m_cards[i].bClicked == true)
		{
			card = m_cards[i];
 
			//把被选中的牌挪到最后（显示出牌用），后面依次前移
			for(int j = i; j < MaxPlayerCard; j++)
				m_cards[j] = m_cards[j+1];
 
			card.bClicked = false;
 
			m_cards[MaxPlayerCard - 1] = card;
			m_cardNum--;
			outNum++;
		}
		else
			i++;
	}
	m_outNum = outNum;
	m_clickedNum = 0;
}
 
void PokerPlayer::SortCard()
{
 
}
 
void PokerPlayer::Update()
{
 
}
 
void PokerPlayer::Render()
{
	int CardHeight=m_game->CardHeight;				
	int CardWidth=m_game->CardWidth;	
 
	///显示名字
	if (GetPlayerInfo())
	{
		if(m_screenPos == SP_Down)
		{
			G_FontMgr->TextAtPos(vec2(Board2DCen.x - 33,  G_PokerGame->BoardRect2D.GetBottom()-RenderUpDownSpace), GetPlayerInfo()->playerName);
		}
		else if(m_screenPos == SP_Up)
		{
			G_FontMgr->TextAtPos(vec2(Board2DCen.x - 33,  G_PokerGame->BoardRect2D.y+RenderUpDownSpace), GetPlayerInfo()->playerName);
		}
		else if(m_screenPos == SP_Right)
		{
			G_FontMgr->TextAtPos(vec2(G_Window->m_iWidth - 66 - 5, Board2DCen.y), GetPlayerInfo()->playerName);
		}
		else if(m_screenPos == SP_Left)
		{
			G_FontMgr->TextAtPos(vec2(5, Board2DCen.y), GetPlayerInfo()->playerName);
		}
	}
 
	G_RendDriver->Color3f(1,1,1);
	///显示未出的牌
	bool canSee = m_game->m_openPoker;//明牌
	switch(m_screenPos)
	{
	case SP_Down:
		{
			CardX = Board2DCen.x - ((m_cardNum - 1) * RenderShiftX + CardWidth)/2;
			CardY = G_PokerGame->BoardRect2D.GetBottom()-RenderUpDownSpace - CardHeight;
			for(int i = 0; i < m_cardNum; i++)
			{
				if(m_cards[i].bClicked == false)
				{
					m_game->m_cardTexture[m_cards[i].cardID]->Bind();
					G_RendDriver->DrawTextureRect(RectF(CardX+i* RenderShiftX, CardY, CardWidth, CardHeight));
				}
				else
				{
					m_game->m_cardTexture[m_cards[i].cardID]->Bind();
					G_RendDriver->DrawTextureRect(RectF(CardX+i * RenderShiftX, CardY -RenderClickedAddDistance, CardWidth, CardHeight));
				}
			}
		}
		break;
 
	case SP_Right:
		{
			int x = G_PokerGame->BoardRect2D.GetRight() - RenderLeftRightSpace- CardWidth;
			int y = Board2DCen.y - (m_cardNum * RenderShiftY + CardHeight)/2;
			for(int i = 0; i < m_cardNum; i++)
			{
				if (canSee) 
					m_game->m_cardTexture[m_cards[i].cardID]->Bind();
				else
					m_game->m_cardBackTexture->Bind();
				G_RendDriver->DrawTextureRect(RectF(x, y + i * RenderShiftY, CardWidth, CardHeight));
			}
		}
		break;
	case SP_Up:
		{
			int x = Board2DCen.x - ((m_cardNum - 1) * RenderShiftX + CardWidth)/2; 
			int y = G_PokerGame->BoardRect2D.y + RenderUpDownSpace;
			for(int i = 0; i < m_cardNum; i++)
			{
				if (canSee) 
					m_game->m_cardTexture[m_cards[i].cardID]->Bind();
				else
					m_game->m_cardBackTexture->Bind();
				G_RendDriver->DrawTextureRect(RectF(x + i * RenderShiftX, y, CardWidth, CardHeight));
			}
		}
		break;
	case SP_Left:
		{
			int x = G_PokerGame->BoardRect2D.x + RenderLeftRightSpace;
			int y = Board2DCen.y - (m_cardNum * RenderShiftY + CardHeight)/2;
			for(int i = 0; i < m_cardNum; i++)
			{
				if (canSee) 
					m_game->m_cardTexture[m_cards[i].cardID]->Bind();
				else
					m_game->m_cardBackTexture->Bind();
				G_RendDriver->DrawTextureRect(RectF(x, y + i * RenderShiftY, CardWidth, CardHeight));
			}
		}
		break;
	}
	
 
	显示所出的牌
	{
		int outX, outY;
		int i, j;
		if(m_screenPos == SP_Down)
		{
			outX = Board2DCen.x - m_outNum * RenderShiftX/2 - RenderShiftX;
			outY = G_PokerGame->BoardRect2D.GetBottom()-RenderUpDownSpace - CardHeight * 2 - RenderUpDownDistance;
			for(i = MaxPlayerCard - m_outNum, j=0; i < MaxPlayerCard; i++, j++)
			{
				m_game->m_cardTexture[m_cards[i].cardID]->Bind();
				G_RendDriver->DrawTextureRect(RectF( outX+j * RenderShiftX, outY, CardWidth,CardHeight));
			}
		}
		if(m_screenPos == SP_Right)
		{
			outX = G_PokerGame->BoardRect2D.GetRight() - RenderLeftRightSpace - CardWidth*2.8f; 
			outY = Board2DCen.y - ((m_outNum - 1) * RenderShiftY + CardHeight)/2;
			for(i = MaxPlayerCard - m_outNum, j = 0; i < MaxPlayerCard; i++, j++)
			{
				m_game->m_cardTexture[m_cards[i].cardID]->Bind();
				G_RendDriver->DrawTextureRect(RectF(outX, outY+j * RenderShiftY, CardWidth,CardHeight ));
			}
		}
		if(m_screenPos == SP_Up)
		{
			outX = Board2DCen.x - ((m_outNum - 1) * RenderShiftX + CardWidth)/2;
			outY = G_PokerGame->BoardRect2D.y + RenderUpDownSpace + CardHeight + RenderUpDownDistance;
			for(i = MaxPlayerCard - m_outNum, j=0; i < MaxPlayerCard; i++, j++)
			{
				m_game->m_cardTexture[m_cards[i].cardID]->Bind();
				G_RendDriver->DrawTextureRect(RectF( outX+j * RenderShiftX, outY , CardWidth,CardHeight ));
			}
		}
		if(m_screenPos == SP_Left)
		{
			outX = G_PokerGame->BoardRect2D.x + RenderLeftRightSpace + CardWidth*1.8f; 
			outY = Board2DCen.y - ((m_outNum - 1) * RenderShiftY + CardHeight)/2;
			for(i = MaxPlayerCard - m_outNum, j = 0; i < MaxPlayerCard; i++, j++)
			{
				m_game->m_cardTexture[m_cards[i].cardID]->Bind();
				G_RendDriver->DrawTextureRect(RectF(outX, outY+j * RenderShiftY, CardWidth,CardHeight));
			}
		}
	}
}
//标记要出牌
bool PokerPlayer::ClickCards(int cardValue[],int num)
{
	int find = 0;
	for(int i = 0; i < num; i++)
	{
		for(int j = 0; j < m_cardNum; j++)
		{
			if(m_cards[j].cardValue == cardValue[i] 
			&& m_cards[j].bClicked == false //有可能两张相同value
				)
			{
				find++;
				m_cards[j].bClicked = true;
				break;
			}
		}
	}
	assert(find == num);
	return (find == num);
}
//标记要出牌
bool PokerPlayer::ClickCardsID(int cardID[],int num)
{
	int find = 0;
	for(int i = 0; i < num; i++)
	{
		for(int j = 0; j < m_cardNum; j++)
		{
			if(m_cards[j].cardID == cardID[i] 
			&& m_cards[j].bClicked == false //有可能两张相同value
				)
			{
				find++;
				m_cards[j].bClicked = true;
				break;
			}
		}
	}
	assert(find == num);
	return (find == num);
}
 
int  PokerPlayer::ClickCard(const vec2& mousePos)
{
	int x1, y1, x2, y2;
	x1 = CardX;
	y1 = CardY - RenderClickedAddDistance;
	x2 = (m_cardNum - 1) * RenderShiftX + m_game->CardWidth + CardX;
	y2 = CardY + m_game->CardHeight;
 
	if((mousePos.x < x2) && (mousePos.x > x1) 
		&& (mousePos.y > y1) && (mousePos.y < y2))
	{
		if(m_cardNum != 0)
		{	
			int n;
			n = (mousePos.x - CardX) / RenderShiftX;
			if(n >= m_cardNum)
				n = m_cardNum - 1;
			if(m_cards[n].bClicked == false)
			{
				m_cards[n].bClicked = true;
				m_clickedNum++;
			}
			else if(m_cards[n].bClicked == true)
			{
				m_cards[n].bClicked = false;
				m_clickedNum--;
			}
			m_sound->PlaySound__("data/sound/chess_duk.wav");
		}
	}
	return 0;
}
 
 
ToOutCards::ToOutCards()
{
	for(int i = 0; i < MaxPlayerCard; i++)
	{
		m_cards[i].cardID = (CardID)0;
		m_cards[i].cardValue = -1;
	}
	m_cardNum = 0;
}
 
int  ToOutCards::MinCard()
{
	int min = m_cards[0].cardValue;
	for(int i = 1; i < m_cardNum; i++)
	{
		if(m_cards[i].cardValue < min)
		{
			min = m_cards[i].cardValue;
		}
	}
	return min;
}
 
int  ToOutCards::CountCard(int value)
{
	int n = 0; 
	for(int i = 0 ; i < m_cardNum ; i++)
		if(m_cards[i].cardValue == value)
			n++;
	return n;
}
 
const char* PokerCmdToString(int enumeration)
{
	switch(enumeration)
	{
	case CMD_ShuffleCard:return "CMD_ShuffleCard";		
	case CMD_BeLord     :return "CMD_BeLord     ";		
	case CMD_NotBeLord  :return "CMD_NotBeLord  ";		
	case CMD_OutCard    :return "CMD_OutCard    ";		
	case CMD_Pass       :return "CMD_Pass       ";	
	case CMD_GameOver   :return "CMD_GameOver   ";		
	case CMD_Restart    :return "CMD_Restart    ";		
	default             :return "CMD_unknow";
	}
	return "CMD_unknow";
}

斗地主游戏派生类：

//========================================================
//  @Date:     2016.05
//  @File:     SourceDemoClient/Poker/PokerDouDiZhu.h
//  @Brief:     PokerDouDiZhu
//  @Author:     LouLei
//  @Email:  twopointfive@163.com
//  @Copyright (Crapell) - All Rights Reserved
//========================================================
 
#if !defined(DouDiZhu_h__)
#define DouDiZhu_h__
 
#include "PokerGame.h"
 
//准备要出的牌
class ToOutCardsDouDizhu:public ToOutCards
{
public:
						
};
 
enum OutType
{
	None = -1,
	GZ = 0, //单张
	DZ    , //对子
	SZ    , //顺子
	SGBD  , //三张不带
	SD1   , //三带一
	SD2   , //三带二
	SD2G  , //四带二
	SD2D  , //四带二对
	LD3   , //三连对
	LD4   ,
	LD5   ,
	LD6   ,
	LD7   ,
	FJBD  , //飞机不带
	FJD2G , //飞机带二个
	FJD2D , //飞机带两对
	SFJBD , //三飞机不带
	SFJDSG, //三飞机带三个
	SFJDSD, //三飞机带三对
	ZD    , //炸弹
	SW    , //双王
};
struct CurOutCards
{
	int  value;
	OutType type;
	//char type[10];
	int  num;
	int  min;
};
class DouDizhuPlayerRobot;
class DouDizhuPlayerRole;
 
class PokerDouDiZhu:public PokerGame
{
public:
	enum CardValue
	{
		Value3 = 3,
		Value4,
		Value5,
		Value6,
		Value7,
		Value8,
		Value9,
		Value10,
		ValueJ,
		ValueQ,
		ValueK,
		ValueA = 14,
		Value2 = 15,
		ValueJokerSmall = 16,      
		ValueJokerBig = 17,
	};
	PokerDouDiZhu();
	virtual ~PokerDouDiZhu();
 
	virtual bool Start();
	virtual bool Stop();
	virtual bool Render();
	virtual bool Update();
	virtual bool CheckRoundEnd();				//结束判断
 
	virtual void StateDealCard();			    //发牌
	void StateDecideLord();	                    //选地主
 
	//注意：不要循环发送，比如主机发过来，调用了几层函数又发回去
	void SendDecideLord(int turn);                  //
	void DecideLord(int turn);                  //选出地主
 
	virtual void SignCard(Card *card);		    //标记牌分值
 
	virtual void FirstOut();					//首次出牌		
 
	//没出的最大单牌
	int MaxCard();							
 
	void OnRButtonDown();
 
	bool Button_NotBeLord();
	bool Button_BeLord();
	bool Button_Pass();
 
	//处理游戏网络命令包
	virtual int  ProcessPacketCmd(PacketBase* packet);
	//virtual const char* CmdToString(const char* stream,int len);
 
 
	int  m_winnerTurn;				//标记哪个是赢家
	int  m_lordTurn;			    //地主位置
	Card m_lordCard[3];			    //三张地主牌
 
 
	CurOutCards         m_curOutCards;
	ToOutCardsDouDizhu  m_toOutCards;		//准备要出的牌
	
	DouDizhuPlayerRole* m_myRolePlayer;	
 
	TexturePtr m_lordTexture;
	TexturePtr m_notbeLordTexture;
	TexturePtr m_notbeLordButtonTexture;
	TexturePtr m_sanfenButtonTexture;
 
	TexturePtr m_winTexture;
	TexturePtr m_loseTexture;
 
	//炸弹倍数
	int m_zhadanNum;
 
 
};
extern PokerDouDiZhu* G_PokerDouDiZhu;
 
#endif
 
//========================================================
//  @Date:     2016.05
//  @File:     SourceDemoClient/Poker/PokerDouDiZhu.cpp
//  @Brief:     PokerDouDiZhu
//  @Author:     LouLei
//  @Email:  twopointfive@163.com
//  @Copyright (Crapell) - All Rights Reserved
//========================================================
 
#include "General/Pch.h"
#include "General/Timer.h"
#include "General/Window.h"
#include "Input/InputMgr.h"
#include "Poker/PokerDoudizhu.h"
#include "Poker/PokerGame.h"
#include "Poker/DouDiZhuPlayer.h"
#include "Poker/MiniGamePoker.h"
#include "Poker/MiPoker_PlayGui.h"
#include "Net/PacketList.h"
#include "Gui/MiniGuis.h"
#include "Gui/GuiMgr.h"
#include "Gui/GuiControlMisc.h"
#include "Rpg/MiniGame.h"
#include "Rpg/SyncGameInfo.h"
#include "Packet/PacketMiniGame.h"
#include "Render/RendDriver.h"
#include "Render/Texture.h"
#include "Sound/ChannelSound.h"
#include "General/Pce.h"
 
PokerDouDiZhu* G_PokerDouDiZhu = NULL;
 
PokerDouDiZhu::PokerDouDiZhu()
{
	m_lastOutTurn = -1;
	m_lordTurn = -1;
	m_winnerTurn = -1;
	G_PokerDouDiZhu = this;
 
}
 
PokerDouDiZhu::~PokerDouDiZhu()
{
 
}
 
bool PokerDouDiZhu::Start()
{
	m_myRolePlayer = NULL;//?
	PokerGame::Start();
 
	G_TextureMgr->AddTexture(m_notbeLordTexture,"data/minigame/poker/bujiao.png");
	G_TextureMgr->AddTexture(m_notbeLordButtonTexture,"data/minigame/poker/bujiaobutton.png");
	G_TextureMgr->AddTexture(m_lordTexture,"data/minigame/poker/islord.png");
	G_TextureMgr->AddTexture(m_sanfenButtonTexture,"data/minigame/poker/sanfen.png");
	G_TextureMgr->AddTexture(m_winTexture,"data/minigame/poker/win.png");
	G_TextureMgr->AddTexture(m_loseTexture,"data/minigame/poker/lose.png");
 
	m_turnTime = 0;
	m_lordTurn = -1;
	m_myPlayer = NULL;
	
	//
	m_playerNum = 3;
	for(int i = 0; i < m_playerNum; i++)
	{
		MyRoomPlayerInfo* playerInfo = G_SyncMyRoomInfo->GetPlayerFromIndex(i);
 
		if (playerInfo)
		{
			//roomSlot 不一定连续，但已经排序
			if (playerInfo->roomSlot == G_SyncMyRoomInfo->m_myRoomSlot)
			{
				m_players[i] = m_myRolePlayer = new DouDizhuPlayerRole;
				m_myPlayer = m_myRolePlayer;
			}
			else
			{
				if (G_PokerGame->IsHost()==false ||
					playerInfo->isAI==false)
				{
					//非主机上ai表现同实体玩家
					m_players[i] = new DouDizhuPlayer;
				}
				else
				{
					//主机负责ai玩家的模拟
					m_players[i] = new DouDizhuPlayerRobot;
				}
			}
			m_players[i]->SetPlayerInfo(playerInfo);
		}
		else
		{
			return false;
		}
	}
 
	//
	if (m_myRolePlayer)
	{
		m_myRolePlayer->m_toOutCard = &m_toOutCards;
	}
	else
	{
		return false;
	}
	for(int i = 0; i < m_playerNum; i++)
	{
		dynamic_cast<DouDizhuPlayer*>(m_players[i])->g_curOutCards = &m_curOutCards;
		m_players[i]->m_turn = i;
		m_players[i]->m_game = this;
		m_players[i]->Start();
	}
 
	//
	MiPoker_PlayGui* playGui = G_GuiMgr->GetGui<MiPoker_PlayGui>();
	if (playGui && playGui->IsAwake())
	{
		//自动出牌
		if(m_myPlayer)
			m_myPlayer->m_workingWithAI = playGui->m_textButtonOption[2]->GetState()==GCS_CLICK;
		//明牌
		m_openPoker = playGui->m_textButtonOption[3]->GetState()==GCS_CLICK;
	}
 
	//
	int myTurn = m_myRolePlayer?m_myRolePlayer->m_turn:0;
	m_players[myTurn]->m_screenPos = SP_Down;
	m_players[++myTurn%m_playerNum]->m_screenPos = SP_Right;
	m_players[++myTurn%m_playerNum]->m_screenPos = SP_Left;
 
	//进入miniplaygui，（选人、选关卡都已在房间里进行完毕)。
	//if(GetStyle()) G_GuiMgr->PushGui(GetStyle()->playGUI.c_str(),GL_DIALOG);
 
	return true;
}
bool PokerDouDiZhu::Stop()
{
	Free();
	return true;
}
bool PokerDouDiZhu::Update()
{
	PokerGame::Update();
 
	switch(m_gameStatus)
	{
	case Dealing:
		StateDealCard();
		break;
	case Preparing:
		{
			//call back
			if (G_Mouse->IsButtonDowning(MOUSE_LEFT))
			{
				if(Button_BeLord()) 
					return true;
				if(Button_NotBeLord()) 
					return true;
			}
		}
		break;
	case Playing:
		{
			CheckRoundEnd();
			
			if (G_Mouse->IsButtonDowning(MOUSE_LEFT))
			{
				//todo set ui visible  + call back
				if(Button_Pass()) 
					return true;
			}
 
			//call back
			if (G_Mouse->IsButtonDowning(MOUSE_RIGHT))
			{
				OnRButtonDown();
			}
		}
		break;
	case Resulting:
		{
			if (m_turnTime > 5)
			{
				if (m_bHost)
				{
					C2SPacketMiniGameCmd packet;
					packet.WriteHeader();
					packet.WriteValue(CMD_Restart);  
					G_MiniGame->SendPacketToOther(&packet);
				}
 
				Free();
				Start(); //send shuffle
			}
		}
		break;
	}
 
 
	return true;
}
bool PokerDouDiZhu::Render()
{
	PokerGame::Render();
 
	//if(m_gameStatus == Playing || m_gameStatus == Preparing)
	{
		//显示地主牌
		{
			int x, y;
			x =	Board2DCen.x - CardWidth * 5/2;
			y = G_PokerGame->BoardRect2D.y + RenderUpDownDistance;
			if(m_gameStatus == Playing)
			{
				for(int i = 0; i < 3; i++)
				{
					m_cardTexture[m_lordCard[i].cardID]->Bind();
					G_RendDriver->DrawTextureRect(RectF( x+i * 2 * CardWidth, y, CardWidth,CardHeight));
				}
			}
			else
			{
				//未叫显示背面
				for(int i = 0; i < 3; i++)
				{
					m_cardBackTexture->Bind();
					G_RendDriver->DrawTextureRect(RectF(x + i * 2 * CardWidth, y, CardWidth, CardHeight));
				}
			}
		}
	}
 
	if (m_gameStatus == Resulting)
	{
		if (m_myRolePlayer==NULL
			|| m_winnerTurn == m_myRolePlayer->m_turn
			|| (m_winnerTurn!=m_lordTurn && m_myRolePlayer->IsLord()==false) )
		{
			m_winTexture->Bind();
			G_RendDriver->DrawTextureRect(vec2(Board2DCen.x-m_winTexture->GetWidth()/2, Board2DCen.y-m_winTexture->GetHeight()/2));
		}
		else
		{
			m_loseTexture->Bind();
			G_RendDriver->DrawTextureRect(vec2(Board2DCen.x-m_loseTexture->GetWidth()/2, Board2DCen.y-m_loseTexture->GetHeight()/2));
		}
 
	}
 
	return true;
}
 
 
 
 
bool PokerDouDiZhu::CheckRoundEnd()
{
	//if(m_players[m_turn]->m_cardNum == 0)
	//{
	//	m_winnerTurn = m_turn;
	//	GameOver();
	//	return true;
	//}
 
	bool gameOver = false;
	for(int i = 0; i < m_playerNum; i++)
	{
		if(m_players[i]->m_cardNum == 0)
		{
			m_winnerTurn = i;
			gameOver = true;
		}
	}
 
	if(gameOver&&m_bHost)
	{
		int fen = 3;
		if(m_winnerTurn == m_lordTurn)
			fen = -3;
		//fen *= zhadan;
		for(int i = 0; i < m_playerNum; i++)
		{
			if(i!=m_lordTurn)
				m_players[i]->m_totalScore += fen ;
			else
				m_players[i]->m_totalScore -= fen*2;
		}
 
 
		char sound[256];
		if (m_winnerTurn == m_lordTurn)
		{
			sprintf(sound,"data/sound/poker/play_lord_win");
		}
		else
		{
			sprintf(sound,"data/sound/poker/play_farmer_win");
		}
		if (m_winnerTurn%2) //
			strcat(sound,"_femail.wav");
		else
			strcat(sound,".wav");
		m_players[m_winnerTurn]->m_sound->PlaySound__(sound);
 
 
 
		C2SPacketMiniGameCmd packet;
		packet.WriteHeader();
		packet.WriteValue(CMD_GameOver);  
		packet.WriteValue(m_winnerTurn); 
		G_MiniGame->SendPacketToOther(&packet);
 
		m_gameStatus = Resulting;
		m_turnTime = 0;
	}
 
	return gameOver;
}
 
 
//标记牌值
void PokerDouDiZhu::SignCard(Card *card)
{
	int id = card->cardID;
	if(id == JokerSmall)
	{
		card->cardValue = 16;
	}
	else if(id == JokerBig)
	{
		card->cardValue =  17;
	}
	else if(id >= 0 && id < JokerSmall)
	{
		card->cardValue = (id + 12) %13 + 3;
	}
}
 
 
void PokerDouDiZhu::StateDealCard()
{
	//另外三张决定地主后再发
	if (m_dealCardNum>=51)
	{
		for(int i = 0; i < m_playerNum; i++)
			m_players[i]->SortCard();
		m_gameStatus = Preparing;
		return;
	}
 
	m_dealAccumTime += G_Timer->GetStepTime();
	//0.1秒发一张
	if (m_dealAccumTime > m_dealCardNum*0.1f)
	{
		CardID cardID = (CardID)m_cardShuffle[m_dealCardNum];
		if (cardID>=0)
		{
			m_cardFlag[cardID] = InHand;
			int playerIndex = m_dealCardNum % m_playerNum;
			m_players[playerIndex]->RecvCard(cardID);
			m_dealCardNum++;
		}
		else
		{
			//host洗牌还没发下来
		}
	}
}
 
 
void PokerDouDiZhu::SendDecideLord(int turn)
{
	C2SPacketMiniGameCmd packet;
	packet.WriteHeader();
	packet.WriteValue(CMD_BeLord);  
	packet.WriteValue(m_turn); 
	//todo给lord发三张地主牌，目前是洗牌时已经发送
	G_MiniGame->SendPacketToOther(&packet);
}
void PokerDouDiZhu::DecideLord(int turn)
{
	m_lordTurn = turn;
	m_lastOutTurn = turn;
	m_turn = turn;
	m_turnTime = 0;
	m_gameStatus = Playing;
 
	for(int i = 0; i < 3; i++)
	{
		m_lordCard[i].cardID = (CardID)m_cardShuffle[i+CardNum-3];
	}
	//给地主发三张牌
	for(int i = 0; i < 3; i++)
		m_players[m_lordTurn]->RecvCard(m_lordCard[i].cardID);
 
	m_players[m_lordTurn]->SortCard();
 
	char sound[256];
	sprintf(sound,"data/sound/poker/call_jiaofeng_3");
	if (m_turn%2) //
		strcat(sound,"_femail.wav");
	else
		strcat(sound,".wav");
	if(m_myRolePlayer)
		m_myRolePlayer->m_sound->PlaySound__(sound);
 
}
//决定地主
void PokerDouDiZhu::StateDecideLord()
{
}
 
void PokerDouDiZhu::FirstOut()
{
 
}
 
//现存最大单牌
int  PokerDouDiZhu::MaxCard()
{
	if(m_cardFlag[JokerBig] != BeOut)
		return 17;
	if(m_cardFlag[JokerSmall] != BeOut)
		return 16;
 
	int max = 0;
	for(int i = 0; i < JokerSmall; i++)
	{
		if(m_cardFlag[i] != BeOut && max < (i +12) % 13)
			max = (i + 12) % 13 + 3;
	}
	return max;
}
 
 
 
 
 
void PokerDouDiZhu::OnRButtonDown()
{
	if(m_myRolePlayer==NULL
		||m_turn != m_myRolePlayer->m_turn)
		return;
	if(m_gameStatus != Playing)
		return;
	m_myRolePlayer->m_notOut = 0;//?
	if(m_gameStatus == Playing && m_myRolePlayer->TryOutCard())
	{
		OutCard(m_myRolePlayer);
		//if (CheckRoundEnd()==false)
		{
			C2SPacketMiniGameCmd packet;
			packet.WriteHeader();
			packet.WriteValue(CMD_OutCard);  
			packet.WriteValue(m_myRolePlayer->m_turn); 
			packet.WriteValue(m_curOutCards); 
			//
			packet.WriteValue(m_myRolePlayer->m_outNum); 
			for(int i = MaxPlayerCard - m_myRolePlayer->m_outNum; i < MaxPlayerCard; i++)
			{
				packet.WriteValue(m_myRolePlayer->m_cards[i].cardID);
			}
			G_MiniGame->SendPacketToOther(&packet);
 
			m_lastOutTurn = m_myRolePlayer->m_turn;
			NextTurn();
		}
	}
}
 
 
 
//人当地主
bool PokerDouDiZhu::Button_BeLord()
{
	if(m_myRolePlayer==NULL
		||m_turn != m_myRolePlayer->m_turn)
		return false;
	if(m_gameStatus != Preparing)
		return false;
	int ClickX = G_PokerGame->GetMousePos().x;
	int ClickY = G_PokerGame->GetMousePos().y;
	int buttonX = Board2DCen.x - 80;
	int buttonY = G_PokerGame->BoardRect2D.GetBottom()-RenderUpDownSpace-CardHeight-32;
	if(ClickX>buttonX  && ClickX<buttonX+m_sanfenButtonTexture->GetWidth() 
		&& ClickY>buttonY && ClickY < buttonY+m_sanfenButtonTexture->GetHeight())
	{
		G_PokerDouDiZhu->SendDecideLord(m_turn);
		DecideLord(m_myRolePlayer->m_turn);
		return true;
	}
	return false;
}
 
//人不当地主
bool PokerDouDiZhu::Button_NotBeLord()
{
	if(m_myRolePlayer==NULL
		||m_turn != m_myRolePlayer->m_turn)
		return false;
	if(m_gameStatus != Preparing)
		return false;
	int ClickX = G_PokerGame->GetMousePos().x;
	int ClickY = G_PokerGame->GetMousePos().y;
	int buttonX = G_Window->m_iWidth/2 + 20;
	int buttonY = G_PokerGame->BoardRect2D.GetBottom()-RenderUpDownSpace-CardHeight-32;
	if(ClickX>buttonX  && ClickX<buttonX+m_notbeLordButtonTexture->GetWidth() 
		&& ClickY>buttonY && ClickY < buttonY+m_notbeLordButtonTexture->GetHeight())
	{
		C2SPacketMiniGameCmd packet;
		packet.WriteHeader();
		packet.WriteValue(CMD_NotBeLord);  
		packet.WriteValue(m_myRolePlayer->m_turn); 
		G_MiniGame->SendPacketToOther(&packet);
 
		m_turn = (m_myRolePlayer->m_turn+1) % m_playerNum;
		m_turnTime = 0;
		//NextTurn()
 
		char sound[256];
		sprintf(sound,"data/sound/poker/call_bujiao");
		if (m_turn%2) //
			strcat(sound,"_femail.wav");
		else
			strcat(sound,".wav");
		m_myRolePlayer->m_sound->PlaySound__(sound);
		return true;
	}
	return false;
}
bool PokerDouDiZhu::Button_Pass()
{
	if(m_myRolePlayer==NULL
		||m_lastOutTurn == m_myRolePlayer->m_turn)
		return false;
	if(m_turn != m_myRolePlayer->m_turn)
		return false;
	if(m_gameStatus != Playing)
		return false;
	int ClickX = G_PokerGame->GetMousePos().x;
	int ClickY = G_PokerGame->GetMousePos().y;
	int buttonX = Board2DCen.x - 30;
	int buttonY = G_PokerGame->BoardRect2D.GetBottom()-RenderUpDownSpace-CardHeight-32;
	if(ClickX>buttonX  && ClickX<buttonX+m_passButtonTexture->GetWidth() 
		&& ClickY>buttonY && ClickY < buttonY+m_passButtonTexture->GetHeight())
	{
		C2SPacketMiniGameCmd packet;
		packet.WriteHeader();
		packet.WriteValue(CMD_Pass);  
		packet.WriteValue(m_myRolePlayer->m_turn); 
		G_MiniGame->SendPacketToOther(&packet);
 
		m_myRolePlayer->m_notOut = 1;
		NextTurn();
 
		char sound[256];
		sprintf(sound,"data/sound/poker/play_guo_%d",Rand()%2);
		if (m_turn%2) //
			strcat(sound,"_femail.wav");
		else
			strcat(sound,".wav");
		m_myRolePlayer->m_sound->PlaySound__(sound);
		return true;
	}
	return false;
}
 
int  PokerDouDiZhu::ProcessPacketCmd(PacketBase* packet)
{
	PokerGame::ProcessPacketCmd(packet);
 
	packet->SeekPos(PacketBase::HeadSize);
	int cmd;
	packet->ReadValue(cmd);
	switch(cmd)
	{
	case CMD_BeLord:
		{
			int turn = 0;
			packet->ReadValue(turn);
			DecideLord(turn);
		}
		break;
	case CMD_NotBeLord:
		{
			int turn = 0;
			packet->ReadValue(turn);
			m_turn = turn;
			NextTurn();
 
			char sound[256];
			sprintf(sound,"data/sound/poker/call_bujiao");
			if (m_turn%2) //
				strcat(sound,"_femail.wav");
			else
				strcat(sound,".wav");
			m_myRolePlayer->m_sound->PlaySound__(sound);
		}
		break;
	case CMD_Pass:
		{
			int turn = 0;
			packet->ReadValue(turn);
			m_turn = turn;
			m_players[m_turn]->m_notOut = true;
			NextTurn();
 
			char sound[256];
			sprintf(sound,"data/sound/poker/play_guo_%d",Rand()%2);
			if (m_turn%2) //
				strcat(sound,"_femail.wav");
			else
				strcat(sound,".wav");
			m_players[m_turn]->m_sound->PlaySound__(sound);
		}
		break;
	case CMD_OutCard:
		{
			int turn = 0;
			packet->ReadValue(turn);
			packet->ReadValue(m_curOutCards); 
 
			//
			int outNum;
			int cardID[MaxPlayerCard];
			packet->ReadValue(outNum); 
			for(int i = 0; i < outNum; i++)
			{
				packet->ReadValue(cardID[i]);
			}
 
			dynamic_cast<DouDizhuPlayer*>(m_players[turn])->ClickCardsID(cardID,outNum);
 
			m_turn = turn;
			m_lastOutTurn = turn;
			m_players[turn]->m_notOut = false;
			OutCard(m_players[turn]);
 
			NextTurn();
		}
		break;
	case CMD_GameOver:
		{
			int turn = 0;
			packet->ReadValue(turn);
			m_winnerTurn = turn;
			m_turnTime = 0;
			m_gameStatus = Resulting;
 
			char sound[256];
			if (m_winnerTurn == m_lordTurn)
			{
				sprintf(sound,"data/sound/poker/play_lord_win");
			}
			else
			{
				sprintf(sound,"data/sound/poker/play_farmer_win");
			}
			if (m_winnerTurn%2) //
				strcat(sound,"_femail.wav");
			else
				strcat(sound,".wav");
			m_players[m_winnerTurn]->m_sound->PlaySound__(sound);
 
		}
		break;
	case CMD_Restart:
		Free();
		Start();
		break;
	}
	return 0;
}