zhujimajiang_redis/游戏服务器/GameLogic_dcs.h

#ifndef GAME_LOGIC_HEAD_FILE_DSC
#define GAME_LOGIC_HEAD_FILE_DSC

#pragma once
#include "Stdafx.h"
#include "data.h"
#include <vector>
class CTableFrameSink_dcs;
enum MaxTaiHuFa{
	WIK_Hu_NULL,
	TwoMagic,
	OneMagic_left,
	OneMagic_Center,
	OneMagic_Right
};
struct qg_taiNums{
	byte nTaiNum;
	CChiHuRight chiHuRight;
	qg_taiNums(){
		nTaiNum = 0;
	}
};
//游戏逻辑类
class CGameLogic_dcs
{

	enum CardColor
	{
		Color_Wan = 0,
		Color_Tiao,
		Color_Bing,
		Color_Feng,
		Color_cai,
	};
	enum MagicType{
		MagicType_TwoMagic = 0,
		MagicType_OneMagic,
		MagicType_NoMagic
	};
	//变量定义
protected:
	static const BYTE				m_cbCardDataArray_ZJ[MAX_REPERTORY_ZJ];	//
	static const BYTE				m_cbCardDataArray_ZJ_Two[MAX_REPERTORY_ZJ_Two];
	BYTE							m_cbMagicIndexFirst;						// 都叫财神
	BYTE							m_cbMagicIndexSecond;						// 都叫财神
	MagicType						m_MagicType;// 0 1 2 无财神 1财神 2财神

	CTableFrameSink_dcs*				m_pTableFramSink;

	//函数定义
public:
	//构造函数
	CGameLogic_dcs(CTableFrameSink_dcs* pTableFramSink);
	//析构函数
	virtual ~CGameLogic_dcs();

	//控制函数
public:
	//混乱扑克
	BYTE RandCardData(BYTE cbCardData[]);
	BYTE RandCardData_Two(BYTE cbCardData[]);
	//删除扑克
	bool RemoveCard(BYTE cbCardIndex[MAX_INDEX], BYTE cbRemoveCard);
	//删除扑克
	bool RemoveCard(BYTE cbCardIndex[MAX_INDEX], const BYTE cbRemoveCard[], BYTE cbRemoveCount);
	//删除扑克
	bool RemoveCard(BYTE cbCardData[], BYTE cbCardCount, const BYTE cbRemoveCard[], BYTE cbRemoveCount);
	//设置钻牌
	void SetMagicIndex(BYTE CaiFirstIndex, BYTE CaiSecondIndex);
	//钻牌
	bool IsMagicCard( BYTE cbCardData );

	//辅助函数
public:
	//获取麻将花色
	BYTE GetCardColor(BYTE cbCardData) { return (cbCardData&MASK_COLOR) >> 4 ;}
	//有效判断
	bool IsValidCard(BYTE cbCardData);
	//扑克数目
	BYTE GetCardCount(const BYTE cbCardIndex[MAX_INDEX]);
	//组合扑克
	BYTE GetWeaveCard(int cbWeaveKind, BYTE cbCenterCard,const BYTE cbMargicOffset[4], BYTE cbCardBuffer[4]);
	//获取财神牌个数
	BYTE GetMaigcCardCount(const BYTE cbCardIndex[MAX_INDEX]);
	//等级函数
	BYTE GetCardValue(BYTE cbCardDat){
		ASSERT(IsValidCard(cbCardDat));
		return (cbCardDat&MASK_VALUE);
	}
public:
	//动作等级
	BYTE GetUserActionRank(int cbUserAction);
	//胡牌等级
	//WORD GetChiHuActionRank(const CChiHuRight & ChiHuRight);

	//动作判断
public:
	//吃牌判断,一脚耐油不需要
	int EstimateEatCard(const BYTE cbCardIndex[MAX_INDEX], BYTE cbCurrentCard);
	//碰牌判断
	int EstimatePengCard(const BYTE cbCardIndex[MAX_INDEX], BYTE cbCurrentCard);
	//杠牌判断
	int EstimateGangCard(const BYTE cbCardIndex[MAX_INDEX], BYTE cbCurrentCard);

	//动作判断
public:
	//杠牌分析
	int AnalyseGangCard(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, tagGangCardResult & GangCardResult);
	//胡牌分析，bFlag默认false表示正常胡牌，true标示杠上花
	int AnalyseChiHuCard(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BYTE cbCurrentCard, CChiHuRight &ChiHuRight, BYTE& nHuTai, bool bFlag = false,bool bQiangGangFlag=false);
	
	bool AnalyseCardNew(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount);
	//
	//bool isHaveMaigc(const BYTE cardMagicIndex[4]);
	//
	bool HaveMagic(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount);
	//
	bool IsPengPengHu(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount);
	//
	bool IsQuanShun(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount);
	//
	bool IsCardsIsHunYiSe(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BOOL HaveFengKe);
	//
	bool TestHu(const BYTE cbCardIndex[MAX_INDEX], int nCurrentMagicCount ,const tagWeaveItem WeaveItem[], BYTE cbWeaveCount);
	//
	bool GetOneColorCards(const BYTE cbCardIndex[MAX_INDEX], BYTE nColor, BYTE cbCardData[MAX_COUNT], int&CardCount);
	//
	bool OneCardsCanHu(const BYTE cbCardData[MAX_COUNT], int nCardCount, int nMagicCount,bool isQuanShun=false);
	//
	int PrintCards(const BYTE cbCardData[MAX_COUNT], int nCout);
	//
	int DeleteCardDataFromCardDatas(const BYTE vDeletIndex[MAX_COUNT], int DeleteCount, const BYTE cbCardData[MAX_COUNT], BYTE nCount, BYTE cbOutCardDatas[MAX_COUNT]);
	//
	int AnalyseCardTaiNum(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount,BOOL bDingStart=FALSE);
	//判断是否是全字胡
	int AnalyseCardTaiNum_IsQuanZi(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount);
	//判断是否是无财胡
	int AnalyseCardTaiNum_IsWuMagic(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount);
	//判断是否是独财胡
	int AnalyseCardTaiNum_IsDuMagic(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount);
	
	//听牌分析
	bool AnalyseTingCard(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BYTE *m_cbTingPaiData, const BYTE FanHui[MAX_INDEX], BYTE wChairID);
	
	//是否听牌
	//bool IsTingCard(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, const BYTE FanHui[MAX_INDEX]);

	//转换函数
public:
	//扑克转换
	BYTE SwitchToCardData(BYTE cbCardIndex);
	//扑克转换
	BYTE SwitchToCardIndex(BYTE cbCardData);
	//扑克转换
	BYTE SwitchToCardData(const BYTE cbCardIndex[MAX_INDEX], BYTE cbCardData[MAX_COUNT]);
	//扑克转换
	BYTE SwitchToCardIndex(const BYTE cbCardData[], BYTE cbCardCount, BYTE cbCardIndex[MAX_INDEX]);
	//获取手牌癞子个数,同时去掉癞子牌
	BYTE DeleteMagicCards(BYTE cbCardIndex[MAX_INDEX]);
	BYTE DeleteMagicCards(BYTE cbCardIndex[MAX_INDEX],int nDeleteCount);
	//获取条万筒风
	BYTE GetOneColorCards(const BYTE cbCardIndex[MAX_INDEX], const BYTE nColor, BYTE cbCardData[MAX_COUNT]);
	//获取牌值需要财神牌几个 bFlag默认true为扑
	int GetOneColorNeedMagicCards(const BYTE cbCardData[MAX_COUNT], int DataCount, int nNeedNum,bool isShun=FALSE);
	
	//财神牌可变牌扫描
	void IsCanChangCardAndCount(const BYTE cbCardIndex[MAX_INDEX], BYTE Fanhui[MAX_INDEX]);
	//获取牌个数
	WORD GetValue(BYTE uNum, BYTE fanshu, WORD PaiZhi);
	//解码加密的牌
	BYTE DeCodeCard(const WORD cbCardData);
	//解码翻数
	BYTE DeCodeFanshu(const WORD cbCardData);
	//获取手牌最后牌值
	BYTE GetEndCard(BYTE cbCardIndex[MAX_INDEX]);

	bool PeiPai(BYTE cbCardData[MAX_REPERTORY_ZJ]);
	//胡法分析
protected:
	//碰碰胡
	bool IsPengPeng(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], const BYTE cbItemCount);
	//清一色牌
	bool IsQingYiSe(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], const BYTE cbItemCount);
	//门前清
	bool IsMenQianQing(const tagWeaveItem WeaveItem[], const BYTE cbWeaveCount);
	//计算手牌是否包含东风刻字
	bool HaveFengKe(BYTE cbCardIndex[MAX_INDEX], tagWeaveItem WeaveItem[], BYTE &cbItemCount,int nCardIndex);
	//内部函数
private:
	//分析扑克
	bool AnalyseCard(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, CAnalyseItemArray & AnalyseItemArray);
	public:

	//排序,根据牌值排序
	bool SortCardList( BYTE cbCardData[MAX_COUNT], BYTE cbCardCount );
	bool test2Combine(const BYTE cbCard1, const BYTE cbCard2);
	bool test3Combine(const BYTE cbCard1, const BYTE cbCard2, const BYTE cbCard3);	
	bool test3combineToShun(const BYTE cbCard1, const BYTE cbCard2, const BYTE cbCard3);
	//一局中只有8个财神牌（其中一个无效），将这7个财神牌给玩家手牌去匹配能否成整扑，然后剩下多少，将剩下的数和可用财神数比较
public:	
	int mNeedMinMagicNum;
	BYTE m_cbHuCard;
public:
	CChiHuRight mChiHuRight;
	DWORD mTaiRight;//计算台数的权值
	int mJiangInColor;
	int mSunTaiJiangInColor;
//接下来尝试修改 在判断胡牌时 记录一下财神变成了什么。
	BYTE mMagicData[1024];

	BYTE mMagicDataCount;
	void ShowMagicData();
	void ShowMagicReplaceData();
	BYTE mMagicReplaceCard[MAX_INDEX];

//删除数组中的牌
	void DeleteCards(const BYTE* pSrc, int nCount, const BYTE* pDeleteCards, int nDelCount, BYTE  Cards[14]);
	BYTE mMagicNeedCardArray[4];

 	//int  mIsBaoMjType;	//0翻财神 1 包麻将 2 定财神
// 	void SetGameLogicMjType(int mjType){
// 		mIsBaoMjType = mjType;
// 	}

	BOOL IsCanHuAllCards(BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount);

	BYTE mJiangCard;

	//计算抢杠胡时 如果删除一个财神，此时那种组合 台数最高。
	int AnalyseChiHuCard_DeleteMagic(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BYTE cbCurrentCard,
		CChiHuRight &ChiHuRight, BYTE& nHuTai, bool bFlag, bool bQiangGangFlag);
	int GetTaiNumAndChihuRight(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, CChiHuRight &ChiHuRight, BYTE& nHuTai, bool bFlag, bool bQiangGangFlag);
	//计算抢杠胡时 如果删除2个财神 此时那种组合台数最高

	BOOL CardIsOne(BYTE cbCard);
	BOOL CardIsTwo(BYTE cbCard);
	BOOL CardIsNine(BYTE cbCard);
	BOOL CardIsEight(byte cbCard);

	BOOL AnalyseQiangGangTaiNumInfo(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BYTE cbCurrentCard, int Offset, BYTE cbWeaveKind, std::vector<qg_taiNums>& TempVerTaiNum);
	//不用财神与抢杠的牌进行组合
	BOOL AnalyseQiangGangTaiNumInfo_WithNoMagic(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BYTE cbCurrentCard, int Offset, int Offset2, BYTE cbWeaveKind, std::vector<qg_taiNums>& TempVerTaiNum);
};

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

#endif