cardrule.cpp

无聊的时候编写的

#include "StdAfx.h"
#include "CardRule.h"

inline	size_t	__SortIndex(const CCards& left,const CCards& right)
{
	return	left.m_iIndex < right.m_iIndex;
}

inline	size_t	__SortValue(const CCards& left,const CCards& right)
{
	return	left.m_iValue < right.m_iValue;
}

CCardRule::CCardRule() 
{
	
}

CCardRule::~CCardRule(void)
{
}
CARDTYPE CCardRule::GetCardsType(ArrayCards& arCards)
{
	std::sort(arCards.begin(),arCards.end(),__SortValue);
	if (arCards.size() == 1)
	{
		return	CARDS_SINGLE;
	}
	else if (Is3_0(arCards))
	{
		return	CARDS_3_0;
	}
	else if (Is3_1(arCards))
	{
		return	CARDS_3_1;
	}
	else if (Is3_2(arCards))
	{
		return	CARDS_3_2;
	}
	else if (Is4_1(arCards))
	{
		return	CARDS_4_1;
	}
	else if (Is4_2(arCards))
	{
		return	CARDS_4_2;
	}
	else if (Is6_0(arCards))
	{
		return	CARDS_6_0;
	}
	else if (Is6_2(arCards))
	{
		return	CARDS_6_2;
	}
	else if (Is6_4(arCards))
	{
		return	CARDS_6_4;
	}
	else if( IsPair(arCards))
	{
		return	CARDS_PAIR;
	}
	else if (IsList(arCards))
	{
		return	CARDS_LIST;
	}
	else if (IsBomb(arCards))
	{
		return	CARDS_BOMB;
	}
	else if(IsPairList(arCards))
	{
		return	CARDS_PAIRLIST;
	}
	else if (Is9_0(arCards))
	{
		return CARDS_9_0;
	}
	else if (Is9_3(arCards))
	{

		return CARDS_9_3;
	}
	else if (Is9_6(arCards))
	{
		return CARDS_9_6;
	}
	return	CARDS_UNKNOW;
}
//!	比较两个派的大小
size_t	CCardRule::CheckIfCanOut(ArrayCards& arPrev,ArrayCards& arNext)
{
	std::sort(arPrev.begin(),arPrev.end(),__SortValue);
	std::sort(arNext.begin(),arNext.end(),__SortValue);

	CARDTYPE	prev	=	GetCardsType(arPrev);
	switch(prev)
	{
	case CARDS_SINGLE:
		{
			if (IsBomb(arNext))
			{
				return	true;
			}
			if (arNext.size() != 1)
			{
				return	false;
			}
			return	arPrev[0].m_iValue < arNext[0].m_iValue;
		}
		break;
	case CARDS_PAIR:
		{
			if (IsBomb(arNext))
			{
				return true;
			}
			size_t 	iPrev	=	IsPair(arPrev);
			size_t	iNext	=	IsPair(arNext);
			if (iNext > iPrev)
			{
				return	true;
			}
			return	false;
		}
		break;
		//!	如果是3个
	case CARDS_PAIRLIST:
		{
			if (IsBomb(arNext))
			{
				return	true;
			}
			size_t	iPrev	=	IsPairList(arPrev);
			size_t	iNext	=	IsPairList(arNext);
			if (iNext > iPrev)
			{
				return	true;
			}
			return	false;
		}
		break;
	case	CARDS_3_0:
		{
			if (IsBomb(arNext))
			{
				return	true;
			}
			size_t	iPrev	=	Is3_0(arPrev);
			size_t	iNext	=	Is3_0(arNext);
			if (iNext > iPrev)
			{
				return	true;
			}
			return	false;
		}
		break;
	case	CARDS_3_1:
		{
			if (IsBomb(arNext))
			{
				return	true;
			}
			size_t	iPrev	=	Is3_1(arPrev);
			size_t	iNext	=	Is3_1(arNext);
			if (iNext > iPrev)
			{
				return	true;
			}
			return	false;
		}
		break;
	case	CARDS_3_2:
		{
			if (IsBomb(arNext))
			{
				return	true;
			}
			size_t	iPrev	=	Is3_2(arPrev);
			size_t	iNext	=	Is3_2(arNext);
			if (iNext > iPrev)
			{
				return	true;
			}
			return	false;
		}
		break;
	case	CARDS_4_1:
		{
			if (IsBomb(arNext))
			{
				return	true;
			}
			size_t	iPrev	=	Is4_1(arPrev);
			size_t	iNext	=	Is4_1(arNext);
			if (iNext > iPrev)
			{
				return	true;
			}
			return	false;
		}
		break;
	case	CARDS_4_2:
		{
			if (IsBomb(arNext))
			{
				return	true;
			}
			size_t	iPrev	=	Is4_2(arPrev);
			size_t	iNext	=	Is4_2(arNext);
			if (iNext > iPrev)
			{
				return	true;
			}
			return	false;
		}
		break;
	case	CARDS_6_0:
		{
			if (IsBomb(arNext))
			{
				return	true;
			}
			size_t	iPrev	=	Is6_0(arPrev);
			size_t	iNext	=	Is6_0(arNext);
			if (iNext > iPrev)
			{
				return	true;
			}
			return	false;
		}
		break;
	case	CARDS_6_2:
		{
			if (IsBomb(arNext))
			{
				return	true;
			}
			size_t	iPrev	=	Is6_2(arPrev);
			size_t	iNext	=	Is6_2(arNext);
			if (iNext > iPrev)
			{
				return	true;
			}
			return	false;
		}
		break;
	case	CARDS_6_4:
		{
			if (IsBomb(arNext))
			{
				return	true;
			}
			if (arNext.size() != arPrev.size())
			{
				return	false;
			}
			size_t	iPrev	=	Is6_4(arPrev);
			size_t	iNext	=	Is6_4(arNext);
			if (iNext > iPrev)
			{
				return	true;
			}
			return	false;
		}
		break;
	case	CARDS_9_0:
		{
			if (IsBomb(arNext))
			{
				return	true;
			}
			if (arNext.size() != arPrev.size())
			{
				return	false;
			}
			size_t	iPrev	=	Is9_0(arPrev);
			size_t	iNext	=	Is9_0(arNext);
			if (iNext > iPrev)
			{
				return	true;
			}
			return	false;
		}
		break;
	case	CARDS_9_3:
		{
			if (IsBomb(arNext))
			{
				return	true;
			}
			if (arNext.size() != arPrev.size())
			{
				return	false;
			}
			size_t	iPrev	=	Is9_3(arPrev);
			size_t	iNext	=	Is9_3(arNext);
			if (iNext > iPrev)
			{
				return	true;
			}
			return	false;
		}
		break;
	case	CARDS_9_6:
		{
			if (IsBomb(arNext))
			{
				return	true;
			}
			if (arNext.size() != arPrev.size())
			{
				return	false;
			}
			size_t	iPrev	=	Is9_6(arPrev);
			size_t	iNext	=	Is9_6(arNext);
			if (iNext > iPrev)
			{
				return	true;
			}
			return	false;
		}
		break;
	case	CARDS_LIST:
		{
			if (IsBomb(arNext))
			{
				return	true;
			}
			if (arNext.size() != arPrev.size())
			{
				return	false;
			}
			size_t	iPrev	=	IsList(arPrev);
			size_t	iNext	=	IsList(arNext);
			if (iNext > iPrev)
			{
				return	true;
			}
			return	false;
		}
		break;
	case	CARDS_BOMB:
		{
			size_t	iPrev	=	IsBomb(arPrev);
			size_t	iNext	=	IsBomb(arNext);
			return	iNext > iPrev;
		}
		break;
	}
}
size_t	CCardRule::IsSingle(ArrayCards& arCards)
{
	if (arCards.size() != 1)
	{
		return	0;
	}
	return	arCards[0].m_iValue;
}
size_t	CCardRule::Is3_0(ArrayCards& arCards)
{
	if (arCards.size() != 3)
	{
		return	0;
	}
	bool bOk =	arCards[0].m_iValue == arCards[1].m_iValue &&
				arCards[2].m_iValue == arCards[1].m_iValue;
	if (bOk)
	{
		return	arCards[0].m_iValue;
	}
	return	0;
}

//----------------------------------------------------------
// ###*
// *###
//----------------------------------------------------------
size_t	CCardRule::Is3_1(ArrayCards& arCards)
{
	if (arCards.size() != 4)
	{
		return	0;
	}
	bool	bFirst	=	arCards[0].m_iValue == arCards[1].m_iValue &&
						arCards[2].m_iValue == arCards[1].m_iValue;
	if (bFirst)
	{
		return	arCards[0].m_iValue;
	}
	bool	bSecond =	arCards[2].m_iValue == arCards[3].m_iValue &&
						arCards[2].m_iValue == arCards[1].m_iValue;
	if (bSecond)
	{
		return	arCards[2].m_iValue;
	}
	return	0;
}
//----------------------------------------------------------
// ###**
// **###
//----------------------------------------------------------
size_t	CCardRule::Is3_2(ArrayCards& arCards)
{
	if (arCards.size() != 5)
	{
		return	0;
	}
	bool	bFirst	=	arCards[0].m_iValue == arCards[1].m_iValue &&
						arCards[1].m_iValue == arCards[2].m_iValue && 
						arCards[3].m_iValue == arCards[4].m_iValue;
	if (bFirst)
	{
		return arCards[0].m_iValue;
	}
	bool	bSecond =	arCards[0].m_iValue == arCards[1].m_iValue &&
						arCards[2].m_iValue == arCards[3].m_iValue &&
						arCards[3].m_iValue == arCards[4].m_iValue;
	if (bSecond)
	{
		return arCards[2].m_iValue;
	}
	return	(bFirst | bSecond);
}
//----------------------------------------------------------
// ####*
// *####
//----------------------------------------------------------
size_t	CCardRule::Is4_1(ArrayCards& arCards)
{
	if (arCards.size() != 5)
	{
		return	0;
	}
	size_t	bFirst	=	arCards[0].m_iValue == arCards[1].m_iValue &&
						arCards[1].m_iValue == arCards[2].m_iValue &&
						arCards[2].m_iValue == arCards[3].m_iValue ;