upgradelogic.cpp

原子,棋牌游戏源代码,功能齐全,稳定,适合用于棋牌游戏开发

	
	if (GetCardNum(m_iDaoCard) == first && count > 0) return FALSE;//王和刀牌不共存
	if (iCardCount == 4 && count == 4) return 3;//王单独使用只能当3
	return first;
}

//是否同花
BOOL CUpGradeGameLogic::IsSameHua(BYTE iCardList[], int iCardCount)
{
	if (iCardCount <= 0) return FALSE;
	int firsths = -1;
	for (int i = 0;i < iCardCount;i++)
	{
		if (firsths < 0)
		{
			firsths = GetCardHuaKind(iCardList[i]);
			continue;
		}
		if (firsths != GetCardHuaKind(iCardList[i])) return FALSE;
	}
	return TRUE;
}

//
void CUpGradeGameLogic::SetCard(BYTE iCardList[], int iCardCount)
{
	if (iCardCount <= 0) return;
	ClearPSInfo();
	
	//add node
	for (int i = 0;i < iCardCount;i++)
	{
		int pd = GetCardNum(iCardList[i]);
		bool flag = false;

		for (POSITION pos = m_ptrPSList.GetHeadPosition();pos != NULL;)
		{
			PSTypeNode * ps = (PSTypeNode *) m_ptrPSList.GetNext(pos);
			if (!ps) continue;
			if (pd == ps->mps)
			{
				ps->mcount++;
				flag = true;
				break;
			}
		}

		if (!flag)
		{
			PSTypeNode * pn = new PSTypeNode();
			pn->mps = pd;
			pn->mcount = 1;
			m_ptrPSList.AddTail(pn);
		}
	}

	CPtrList temp;
	bool Is2In = false;

	for (POSITION pos = m_ptrPSList.GetHeadPosition();pos != NULL;)
	{
		PSTypeNode * pi = (PSTypeNode *) m_ptrPSList.GetNext(pos);
		if (!pi) continue;
		PSTypeNode *pn = new PSTypeNode();
		pn->mps = pi->mps;
		pn->mcount = pi->mcount;
		temp.AddTail(pn);
		if (pn->mps == 2) Is2In = true;
	}

	ClearPSInfo();
	//sort
	for (POSITION pos = temp.GetHeadPosition();pos != NULL;)
	{
		PSTypeNode *pi = (PSTypeNode *) temp.GetNext(pos);
		if (!pi) continue;
		PSTypeNode *pn = new PSTypeNode();
		pn->mps = pi->mps;
		pn->mcount = pi->mcount;

		if (m_ptrPSList.IsEmpty())
		{
			m_ptrPSList.AddTail(pn);
			continue;
		}

		bool bAdd = false;
		for (POSITION pos1 = m_ptrPSList.GetHeadPosition();pos1 != NULL;)
		{	
			POSITION tp = pos1;
			PSTypeNode *pii = (PSTypeNode *) m_ptrPSList.GetNext(pos1);
			if (!pii) continue;

			if ((pn->mcount > pii->mcount) || ((pn->mcount == pii->mcount) && (pn->mps > pii->mps))) 
			{
				m_ptrPSList.InsertBefore(tp,pn);
				bAdd = true;
				continue;
			}

		}

		if (!bAdd)
		{
			m_ptrPSList.AddTail(pn);
		}
	}

	while (!temp.IsEmpty())
	{
		PSTypeNode *ps = (PSTypeNode *) temp.RemoveHead();
		//delete ps;
	}
	temp.RemoveAll();

	if (Is2In)
	{
		PSTypeNode *pii = (PSTypeNode *) m_ptrPSList.RemoveHead();
		if (!pii) return;
		if (pii->mps == 14)//14为A
		{
			m_ptrPSList.AddTail(pii);
		}
		else
		{
			m_ptrPSList.AddHead(pii);
		}
	}

	return;
}

//
void CUpGradeGameLogic::ClearPSInfo()
{
	while (!m_ptrPSList.IsEmpty())
	{
		PSTypeNode *ps = (PSTypeNode *) m_ptrPSList.RemoveHead();
		//delete ps;
	}
	m_ptrPSList.RemoveAll();

	return;
}

//获取牌型
BYTE CUpGradeGameLogic::GetCardShape(BYTE iCardList[], int iCardCount)
{
	if (IsOnlyOne(iCardList,iCardCount)) return UG_ONLY_ONE;//单牌
	if (IsDouble(iCardList,iCardCount)) return UG_DOUBLE;//对牌
	if (IsDWAtom(iCardList,iCardCount)) return UG_DW_ATOM;//大王原子
	if (IsXWAtom(iCardList,iCardCount)) return UG_XW_ATOM;//小王原子
	if (IsDaoAtom(iCardList,iCardCount)) return UG_DAO_ATOM;//刀原子
	if (IsAtom(iCardList,iCardCount)) return UG_ATOM;//普通原子
	if (IsThree(iCardList,iCardCount)) return UG_THREE;//三同张
	if (IsDaoHydrogenBomb(iCardList,iCardCount)) return UG_DAO_HYDROGEN_BOMB;//刀氢弹
	if (IsHydrogenBomb(iCardList,iCardCount)) return UG_HYDROGEN_BOMB;//普通氢弹
	if (IsBomb(iCardList,iCardCount)) return UG_BOMB;//炸弹

	return UG_ERROR_KIND;
}

//对比单牌
BOOL CUpGradeGameLogic::CompareOnlyOne(int iFirstCard, int iNextCard)
{
	//int iFirstNum = GetCardNum(iFirstCard);//上手牌
	//int iNextNum  = GetCardNum(iNextCard);//本家牌
	
	if (iFirstCard == GetCardNum(m_iDaoCard)) return FALSE;
	if (iNextCard == GetCardNum(m_iDaoCard)) return TRUE;
	
	if (iFirstCard == 2) return FALSE;//2
	if (iNextCard == 2) return TRUE;

	return ((iNextCard - iFirstCard) > 0 ? TRUE : FALSE);//其他
	
}

//自动出牌函数
BOOL CUpGradeGameLogic::AutoOutCard(BYTE iHandCard[], int iHandCardCount, BYTE iBaseCard[], int iBaseCardCount,
									BYTE iResultCard[], int & iResultCardCount, BOOL bFirstOut)
{
	if (bFirstOut == TRUE)
	{
		iResultCard[0] = iHandCard[iHandCardCount-1];
		iResultCardCount = 1;
	}
	return TRUE;
}

//清除 0 位扑克
int CUpGradeGameLogic::RemoveNummCard(BYTE iCardList[], int iCardCount)
{
	int iRemoveCount=0;
	for (int i=0;i<iCardCount;i++)
	{
		if (iCardList[i]!=0) iCardList[i-iRemoveCount]=iCardList[i];
		else iRemoveCount++;
	}
	return iRemoveCount;
}

//混乱扑克
BYTE CUpGradeGameLogic::RandCard(BYTE iCard[], int iCardCount)
{
	static const BYTE m_CardArray[54]={
			0x01, 0x02 ,0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,		//方块 2 - A
			0x11, 0x12 ,0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D,		//梅花 2 - A
			0x21, 0x22 ,0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D,		//红桃 2 - A
			0x31, 0x32 ,0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D,		//黑桃 2 - A
			0x4E, 0x4F};																		//小鬼，大鬼

	BYTE iSend=0,iStation=0,iCardList[162];
	srand((unsigned)time(NULL));
	
	for (int i=0;i<iCardCount;i+=54)
		::CopyMemory(&iCardList[i],m_CardArray,sizeof(m_CardArray));
	do
	{
		iStation=rand()%(iCardCount-iSend);
		iCard[iSend]=iCardList[iStation];
		iSend++;
		iCardList[iStation]=iCardList[iCardCount-iSend];
	} while (iSend<iCardCount);

	return iCardCount;
}

//删除扑克
int CUpGradeGameLogic::RemoveCard(BYTE iRemoveCard[], int iRemoveCount, BYTE iCardList[], int iCardCount)
{
	//检验数据
	if ((iRemoveCount>iCardCount)) return 0;

	//把要删除的牌置零
	int iDeleteCount=0;
	for (int i=0;i<iRemoveCount;i++)
	{
		for (int j=0;j<iCardCount;j++)
		{
			if (iRemoveCard[i]==iCardList[j])
			{
				iDeleteCount++;
				iCardList[j]=0;
				break;
			}
		}
	}
	RemoveNummCard(iCardList,iCardCount);
	if (iDeleteCount!=iRemoveCount) return 0;

	return iDeleteCount;
}

//是否可以出牌
BOOL CUpGradeGameLogic::CanOutCard(BYTE iOutCard[], int iOutCount, BYTE iBaseCard[], 
								   int iBaseCount, BYTE iHandCard[], int iHandCount)
{
	//获取扑克类型
	BYTE iBaseKind = GetCardShape(iBaseCard,iBaseCount);//上家所出牌
	BYTE iOutKind  = GetCardShape(iOutCard,iOutCount);//本家所出牌
	
	//判断是否与这轮的出牌参数敏合
	//刀氢弹
	if (iBaseKind == UG_DAO_HYDROGEN_BOMB && iOutKind == UG_DAO_HYDROGEN_BOMB) return FALSE;
	if (iBaseKind == UG_DAO_HYDROGEN_BOMB) return FALSE;
	if (iOutKind == UG_DAO_HYDROGEN_BOMB) return TRUE;
	//普通氢弹
	if (iBaseKind == UG_HYDROGEN_BOMB && iOutKind == UG_HYDROGEN_BOMB)
	{
		return CompareOnlyOne(GetCardNum(iBaseCard[0]),GetCardNum(iOutCard[0]));
	}
	if (iBaseKind == UG_HYDROGEN_BOMB) return FALSE;
	if (iOutKind == UG_HYDROGEN_BOMB) return TRUE;

	//刀原子
	if (iBaseKind == UG_DAO_ATOM && iOutKind == UG_DAO_ATOM)
	{
		return GetCardHuaKind(iOutCard[0]) > GetCardHuaKind(iBaseCard[0]) ? TRUE : FALSE;
	}
	if (iBaseKind == UG_DAO_ATOM) return FALSE;
	if (iOutKind == UG_DAO_ATOM) return TRUE;
	//大王原子
	if (iBaseKind == UG_DW_ATOM) return FALSE;
	if (iOutKind == UG_DW_ATOM) return TRUE;
	//小王原子
	if (iBaseKind == UG_XW_ATOM) return FALSE;
	if (iOutKind == UG_XW_ATOM) return TRUE;
	//普通原子
	if (iBaseKind == UG_ATOM && iOutKind == UG_ATOM)
	{
		if (GetCardNum(iBaseCard[0]) != GetCardNum(iOutCard[0]))
		{
			return CompareOnlyOne(GetCardNum(iBaseCard[0]),GetCardNum(iOutCard[0]));
		}
		return GetCardHuaKind(iOutCard[0]) > GetCardHuaKind(iBaseCard[0]) ? TRUE : FALSE;
	}
	if (iBaseKind == UG_ATOM) return FALSE;
	if (iOutKind == UG_ATOM) return TRUE;

	//炸弹
	if ((iBaseKind == UG_BOMB) && (iOutKind == iBaseKind))//都出炸弹
	{	
		if (iOutCount < iBaseCount) return FALSE;
		if (iOutCount > iBaseCount) return TRUE;
		int iOutPd = IsBomb(iOutCard,iOutCount),
			iBasePd = IsBomb(iBaseCard,iBaseCount);
		return CompareOnlyOne(iBasePd,iOutPd);
	}
	if (iBaseKind == UG_BOMB) return FALSE;
	if (iOutKind == UG_BOMB) return TRUE;
		
	//其他类型
	if (iOutKind != iBaseKind) return FALSE;
	switch(iBaseKind)
	{
	case UG_ONLY_ONE:
		{
			int iBasePd = GetCardNum(iBaseCard[0]),
				iOutPd = GetCardNum(iOutCard[0]);
			if (iBaseCard[0] == 0x4E || iBaseCard[0] == 0x4F) iBasePd = 3;
			if (iOutCard[0] == 0x4E || iOutCard[0] == 0x4F) iOutPd = 3;
			return CompareOnlyOne(iBasePd,iOutPd);
		}

	case UG_DOUBLE:
		{
			int iBasePd = IsDouble(iBaseCard,iBaseCount),
				iOutPd = IsDouble(iOutCard,iOutCount);
			return CompareOnlyOne(iBasePd,iOutPd);
		}
	case UG_THREE:
		{
			int iBasePd = IsThree(iBaseCard,iOutCount),
				iOutPd = IsThree(iOutCard,iOutCount);
			return CompareOnlyOne(iBasePd,iOutPd);
		}
	}
	
	return FALSE;

}

//查找分数
int CUpGradeGameLogic::FindPoint(BYTE iCardList[], int iCardCount)
{
	int iPoint=0,iNum=0;
	for (int i=0;i<iCardCount;i++)
	{
		iNum=GetCardNum(iCardList[i]);
		if (iNum==5) iPoint+=5;
		else if ((iNum==10)||(iNum==13)) iPoint+=10;
	}
	return iPoint;
}