zhujimajiang_redis/游戏服务器/Poker/GameLogic_poker.h

#ifndef GAME_LOGICPoker_HEAD_FILE
#define GAME_LOGICPoker_HEAD_FILE
#pragma pack(1)
#include "stdafx.h"
#include "Poker\消息定义\CMD_Poker_Sparrow.h"
//////////////////////////////////////////////////////////////////////////
#include <vector>
//排序类型
#define ST_ORDER					0									//大小排序
#define ST_COUNT					1									//数目排序
#define ST_VALUE					2									//数值排序
#define ORDERBY_ASE					0									//升序
#define ORDERBY_DES					1									//降序
#define BomoTypeXian				1									//N付M线
#define BomoTypeLian				2									//N同M连
//////////////////////////////////////////////////////////////////////////
#include <vector>
using namespace  std;
//分析结构
struct tagAnalyseResult_Poker
{
	// 10个位置 分别记录拥有同样牌的个数 [12/12/2018 Zoro]
	/*
	例如：
	33 44 66  cbBlockCount[sameCont-1]=3  标示 手牌中 对子的个数
	333 34567 cbBlockCount[0]=5 cbBlockCount[sameCont-1]=1		表示 单牌有5张 3张1个 
	*/
	BYTE 							cbBlockCount[12];					//扑克数目 
	BYTE							cbCardData[12][MAX_COUNT_Poker];			//扑克数据 记录具体数据
};

//出牌结果
struct tagOutCardResult
{
	BYTE							cbCardCount;						//扑克数目
	BYTE							cbResultCard[MAX_COUNT_Poker];			//结果扑克
};

//分布信息
struct tagDistributing
{
	BYTE							cbCardCount;						//扑克数目
	//  [12/12/2018 Zoro]
	/*
	第一维度 保存了 3-K A 2 大王 小王的位置 对应的数据 0表示3 依此类推
	第二维度 6个 前4个[0-4] 表示 方片 梅花  红桃 黑桃 王花色 第6[5]个 标示此牌的张数

	*/
	BYTE							cbDistributing[15][6];				//分布信息
};

//////////////////////////////////////////////////////////////////////////
typedef struct _BomoType_{
	BYTE fu;	//N付M线
	BYTE xian;
	BYTE tong;//N同M连
	BYTE lian;
	BYTE Level;//线级5-11
	BYTE BomoTypes;
	BYTE CbBomoCount;
	_BomoType_(){
		fu = 0;
		xian = 0;
		tong = 0;
		lian = 0;
		BomoTypes = 0;
		CbBomoCount = 0;
		Level = 0;
	}
	_BomoType_ operator=(_BomoType_ & bomo){
		this->fu = bomo.fu;
		this->xian = bomo.xian ;
		this->tong = bomo.tong ;
		this->lian = bomo.lian ;
		this->Level = bomo.Level;
		this->BomoTypes = bomo.BomoTypes;
		this->CbBomoCount = bomo.CbBomoCount;
		return *this;
	}
}BomoType;

typedef struct _LastOutCardInfo_{
	BYTE cbCards[MAX_COUNT_Poker] ;
	BYTE cbCardCount;
	BYTE CardType;
	BomoType BomoInfo;
	_LastOutCardInfo_(){
		ZeroMemory(cbCards, sizeof(cbCards));
	}
}LastCardsInfo;
//游戏逻辑类
class CGameLogic_Poker
{
	//变量定义
protected:
	static const BYTE				m_cbCardData[FULL_COUNT_Poker];			//扑克数据
	BYTE							m_GameMagicMode;//2 双癞子 1单癞子（仅大王） 0 无癞子
	//函数定义
public:
	//构造函数
	CGameLogic_Poker();
	//析构函数
	virtual ~CGameLogic_Poker();

	//属性函数
public:
	//获取数值
	BYTE GetCardValue(BYTE cbCardData) { return cbCardData&MASK_VALUE; }
	//获取花色
	BYTE GetCardColor(BYTE cbCardData) { return cbCardData&MASK_COLOR; }

	//类型函数
public:
	//获取类型
	BYTE GetCardType(const BYTE cbCardData[], BYTE cbCardCount, BYTE &cbStarLevel, BomoType&BomoInfo);

	//控制函数
public:
	//混乱扑克
	VOID RandCardList(BYTE cbCardBuffer[], BYTE cbBufferCount,byte OutCardType,WORD wRoomId);
	//排列扑克
	//ase 升序  0
	//des降序   1
	VOID SortCardList(BYTE cbCardData[], BYTE cbCardCount, BYTE cbSortType = ST_ORDER, BYTE OrderByType = ORDERBY_ASE);
	//删除扑克
	bool RemoveCard(const BYTE cbRemoveCard[], BYTE cbRemoveCount, BYTE cbCardData[], BYTE cbCardCount);

	//逻辑函数
public:
	//有效判断
	bool IsValidCard(BYTE cbCardData);
	//逻辑数值
	BYTE GetCardLogicValue(BYTE cbCardData);
	//只支持 2-A 的转换
	BYTE TagIndexToNoColorCardValue(BYTE cbCardData);
	BYTE GetMaxLogicValue(const BYTE cbCarddata[], BYTE cbCardCount);
	CString LogicValueToString(BYTE cbCardData);
	//对比扑克
	bool CompareCard( BYTE cbFirstCard[],  BYTE cbNextCard[], BYTE cbFirstCount, BYTE cbNextCount);
	//对比扑克
	bool CompareCard( const BYTE cbFirstCard,const BYTE cbNextCard );
	//查找指定牌拥有的个数 包括花色
	BYTE FindHaveCardCount(const BYTE cbCardBuffer[], BYTE cbCardCount,BYTE cbCardData ,BYTE cbCardPosition[2]);
	//功能函数
public:
	//变幻扑克
	bool MagicCardData(BYTE cbCardData[], BYTE cbCardCount, BYTE cbResultCard[MAX_COUNT_Poker]);
	//将王替换成 前端要的牌
	BOOL ReplaceWangCards(BYTE OldCards[], BYTE cbCount, BYTE ReplacCards[4], OUT BYTE cbNoMagicCards[MAX_COUNT_Poker]);

	//分析扑克
	VOID AnalysebCardData(const BYTE cbCardData[], BYTE cbCardCount, tagAnalyseResult_Poker & AnalyseResult);
	//分析分布  返回的索引是 3-KA2方式
	VOID AnalysebDistributing(const BYTE cbCardData[], BYTE cbCardCount, tagDistributing & Distributing);
	//分析分布  返回的是 A23-K 方式
	VOID AnalyseRealDistributing(const BYTE cbCardData[], BYTE cbCardCount, tagDistributing & Distributing);
	//出牌搜索
	bool SearchOutCard(const BYTE cbHandCardData[], BYTE cbHandCardCount, const BYTE cbTurnCardData[], BYTE cbTurnCardCount, tagOutCardResult & OutCardResult);
	//搜索顺子
	bool SearchLinkCard( const BYTE cbHandCardData[],BYTE cbHandCardCount,const BYTE cbFirstCardData,const BYTE cbLastCardData,tagOutCardResult &OutCardResult );
	//设置癞子模式  2 双癞子 1 单癞子 0 无癞子
	void  SetMagicType(BYTE nMode);
	BYTE  GetMagicType();
	BYTE  GetCardCount(const BYTE cbCardData[], BYTE MAX_CardNum = MAX_COUNT_Poker);
	BYTE  GetCardMagicCount(const BYTE cbCardData[], BYTE CardCount);
	//判断是否要得起上家的牌 
	/*
	cbCardData 上次出的牌
	UserCards 当前玩家手牌
	*/
	BOOL bCanOutCard(const BYTE cbCardData[], BYTE cbCount, const BYTE UserCards[], BYTE cbUserCount, std::vector<HitStruct> &ListHit);
	//递归寻找 是否有比当前牌大是同排  22  333  4444 55555 666666
	BOOL HaveCanOutCard(BYTE cbCardLogicValue, BYTE SameCardCount, const BYTE UserCards[], BYTE cbUserCount,std::vector<HitStruct> &ListHit);
	// 根据bomoinfo 计算线级
	void SetBomoLevel(BomoType & BomoInfo);

	//内部函数
private:
	//构造扑克
	BYTE MakeCardData(BYTE cbValueIndex, BYTE cbColorIndex);
	//构造扑克
	BYTE MakeRealCardData(BYTE cbValueIndex,BYTE cbColorIndex);
	//是否连牌
	bool IsStructureLink(const BYTE cbCardData[], BYTE cbCardCount, BYTE cbCellCount,bool bSpecial=false);
	bool IsStructureLink_zhengxu(const BYTE cbCardData[], BYTE cbCardCount, BYTE cbCellCount, bool bSpecial = false);


	//提示
	//备注 提示牌 不用拆排炸
	void HintSignle(const BYTE cbCardData[], BYTE cbCount, const BYTE UserCards[], BYTE cbUserCount, std::vector<HitStruct> &ListHit);
	// 只负责 2 张 3张的同牌
	void HintSameCardCount(const BYTE cbCardData[], BYTE cbCount,BYTE FindCount, const BYTE UserCards[], BYTE cbUserCount, std::vector<HitStruct> &ListHit, BOOL IsAll);
	//从3 -8张中 找指定张数
	void HintSameCardCount_WithFindCount(const BYTE cbCardData[], BYTE cbCount, BYTE nFindCount, const BYTE UserCards[], BYTE cbUserCount, std::vector<HitStruct> &ListHit);
	//只负责连对 556677
	void HintDOUBLE_LINK(const BYTE cbCardData[], BYTE cbCount, const BYTE UserCards[], BYTE cbUserCount, std::vector<HitStruct> &ListHit);
	//只负责连三张 555666777
	void HintTHREE_LINK(const BYTE cbCardData[], BYTE cbCount, const BYTE UserCards[], BYTE cbUserCount, std::vector<HitStruct> &ListHit);
	//只负责顺子
	void HintSHUNZI(const BYTE cbCardData[], BYTE cbCount, const BYTE UserCards[], BYTE cbUserCount, std::vector<HitStruct> &ListHit);
	//只负责 4张 基础炸弹 WithJoker 是否计算王提示
	void HintBoom(const BYTE cbCardData[], BYTE cbCount,BYTE cbCardType, const BYTE UserCards[], BYTE cbUserCount, std::vector<HitStruct> &ListHit,BOOL WithJoker);
	void AllSameBomos(const BYTE cbCardData[], BYTE cbCount,BYTE SameFromCount, BYTE cbCardType, const BYTE UserCards[], BYTE cbUserCount, std::vector<HitStruct> &ListHit, BOOL WithJoker);
	//负责特殊牌 按照线 计算
	void HintBomoWithXian(const BYTE cbCardData[], BYTE cbCount, BYTE type, BomoType BomoInfo, const BYTE UserCards[], BYTE cbUserCount, std::vector<HitStruct> &ListHit);
	void HintBomoWithLian(const BYTE cbCardData[], BYTE cbCount, BYTE type, BomoType BomoInfo, const BYTE UserCards[], BYTE cbUserCount, std::vector<HitStruct> &ListHit);
	//获取王的个数
	BYTE  GetMagicJokerCount(const BYTE cbCardData[], BYTE cbCount,BYTE MagicCards[4]);
	BYTE  GetMagicJokerCount(tagDistributing tag, BYTE MagicCards[4]);
	BOOL CardIsMagicJoker(BYTE cbCard);
	//获取 同牌的X想炸弹
	BOOL FindSameXianBomo(const BYTE cbCardData[], BYTE cbCount, BomoType bomoinfo, tagDistributing tagDsit, std::vector<HitStruct> &ListHit);
	BOOL FindSameXianBomoWithJoker(const BYTE cbCardData[], BYTE cbCount,BYTE xian, BYTE type, BomoType bomoinfo, tagDistributing tagDsit, tagAnalyseResult_Poker tagReslt, std::vector<HitStruct> &ListHit);
	BOOL Find4Fu4xian(const BYTE cbCardData[], BYTE cbCount, BYTE xian, BYTE type, BomoType bomoinfo, tagDistributing tagDsit, tagAnalyseResult_Poker tagReslt, std::vector<HitStruct> &ListHit);
	BOOL Find4Fu4xianWithJoker(const BYTE cbCardData[], BYTE cbCount, BYTE xian, BYTE type, BomoType bomoinfo, tagDistributing tagDsit, tagAnalyseResult_Poker tagReslt, std::vector<HitStruct> &ListHit);
	BOOL FindNFuMxian(const BYTE cbCardData[], BYTE cbCount,BYTE fU, BYTE xian, BYTE type, BomoType bomoinfo, tagDistributing tagDsit, tagAnalyseResult_Poker tagReslt, std::vector<HitStruct> &ListHit);
	//获取所有5线炸弹
	BOOL FindAll5XianBomo(const BYTE cbCardData[], BYTE cbCount, BYTE type, BomoType bomoinfo, tagDistributing tagDsit, tagAnalyseResult_Poker tagReslt, std::vector<HitStruct> &ListHit, const BYTE cbUserCardData[], BYTE cbUserCount);


	void FindShunZI(const BYTE cbCardData[], BYTE bCount, BYTE nFindCount,vector<vector<BYTE>>& result);

	BOOL HintShunWithJoker(const BYTE cbCardData[], BYTE cbCount, BYTE type, const BYTE UserCards[], BYTE cbUserCount, std::vector<HitStruct> &ListHit);
	//计算顺子 连对 连三张 需要几个magic 能够组成
	/*
	tagindex 从第几张牌开始取
	liancount 取几张
	typecount 每个牌需要几张
	*/
	BYTE CalcuTagDistStructureLinkNeedMagicCount(tagDistributing tag, BYTE tagIndex, BYTE LianCount, BYTE TypeCount, BYTE cbOutCards[MAX_COUNT_Poker],BYTE cbOutCardsNoJoker[MAX_COUNT_Poker]);

	//查找到所有特殊牌
	BYTE FindAllPaiBomoCards(tagDistributing tagDsit, tagAnalyseResult_Poker tagReslt, LastCardsInfo stLastCardsInfo, std::vector<HitStruct> &ListHit);

public:
	//从 cards中 选择 几个字符串 进行组合
	vector<vector<BYTE>> CardSecret(const BYTE Cards[], BYTE cbCount, int nLen, BYTE LastMaxCard);
	void CardPerm(const BYTE str[], BYTE strCount, int nLen, vector<BYTE>& ve, vector<vector<BYTE>>& result, BYTE LastMaxCard);
	//根据cbCardIndexFormTag 计算当前手牌是否能够组成特殊牌
	BOOL FromIndexToHitList(vector<BYTE> cbCardIndexFormTag, BYTE nTongCardCount, tagDistributing tagDsit, LastCardsInfo stLastCardsInfo, std::vector<HitStruct> &ListHit);
	BOOL CompareCardBigLastCards(BomoType lastUserBomoInfo, BYTE cbLastCards[],BYTE cbLastCardCount, BomoType MyBomoTypeFInfo,BYTE cbCards[],BYTE cbCardCount);
	//获取大于某个 线级的 所有X 相炸弹
	BOOL GetAllSameCards(BYTE StartLevel, std::vector<HitStruct> &ListHit, tagDistributing tagDsit);
	//给一个数组 赋值相同的牌
	void CopyOneCardToArry(BYTE cbDstCards[], BYTE CopyCount, BYTE cbCard);
	void CopyJokerCardToArry(BYTE cbDstCards[],BYTE cbCopyCount, BYTE cbJokerCards[4]);


	BOOL NoJokerBigUserCards(BYTE TagIndex, BYTE cbCardCount,const BYTE cbUserCards[], BYTE cbcCount);

	//写一个函数 查看其4种牌的组合+王 是否能够组成4付4线
	BOOL CanZuCheng44(vector<BYTE> vIndex,tagDistributing tagDsit,std::vector<HitStruct> &ListHit);
	//获取3W炸弹
	BOOL Find3WBomo(const BYTE cbCardData[], BYTE cbCount, BYTE type, BomoType BomoInfo, tagDistributing tag, const BYTE UserCards[], BYTE cbUserCount, std::vector<HitStruct> &ListHit);
	//获取4W炸弹
	BOOL Find4WBomo(const BYTE cbCardData[], BYTE cbCount, BYTE type, BomoType BomoInfo, tagDistributing tag, const BYTE UserCards[], BYTE cbUserCount, std::vector<HitStruct> &ListHit);
	//自由 提示所有一样的牌 单张 2张 3张 当没有123时 提示4张 -8张 双王 然后N付N线 N线N连
	//
	BOOL FindAllHit(const BYTE UserCards[], BYTE cbUserCount, std::vector<HitStruct> &ListHit);
	//
	int  rand9xianInfo(BomoType &info);

	BOOL bFind9xianCards(vector<vector<BYTE>> &AllCards, BYTE cbCardBuffer[], BYTE& cbBufferCount, BomoType& Bomo,BOOL isXian);
	//随机取一个值 并把index删掉
	BYTE RandIndexAndDelIt(vector<BYTE>& CardIndex);
};

//////////////////////////////////////////////////////////////////////////
#pragma pack()
#endif