二人牛牛(库存+前控+多人控制)0829【源码】

woaidaima2016

#include "StdAfx.h"
#include "GameLogic.h"

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

//扑克数据
BYTE CGameLogic::m_cbCardListData[52] =
{
    //0x1C,0x1D,0x3B,0x3C,0x3D,0x09,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x0A,0x0B,0x0C,0x0D,    //方块 A - K
    //0x3A,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,    //梅花 A - K
    //0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,    //红桃 A - K
    //0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39    //黑桃 A - K
    0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,    //方块 A - K
    0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D,    //梅花 A - K
    0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D,    //红桃 A - K
    0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D    //黑桃 A - K

};

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

//构造函数
CGameLogic::CGameLogic()
{
}

//析构函数
CGameLogic::~CGameLogic()
{
}

//获取类型
BYTE CGameLogic::GetCardType(BYTE cbCardData[], BYTE cbCardCount)
{
    ASSERT(cbCardCount == MAX_COUNT);

    ////炸弹牌型
    //BYTE bSameCount = 0;
    //SortCardList(cbCardData,cbCardCount);
    //BYTE bSecondValue = GetCardValue(cbCardData[MAX_COUNT/2]);
    //for(BYTE i=0;i<cbCardCount;i++)
    //{
    //    if(bSecondValue == GetCardValue(cbCardData))
    //    {
    //        bSameCount++;
    //    }
    //}
    //if(bSameCount==4)return OX_FOUR_SAME;

    BYTE bKingCount = 0,bTenCount = 0;
    for (BYTE i = 0; i < cbCardCount; i++)
    {
        if (GetCardValue(cbCardData) > 10)
        {
            bKingCount++;
        }
        else if (GetCardValue(cbCardData) == 10)
        {
            bTenCount++;
        }
    }
    if (bKingCount == MAX_COUNT)
        return OX_FIVEKING;
    else if (bKingCount == MAX_COUNT - 1 && bTenCount == 1)
        return OX_FOURKING;

    ////葫芦牌型
    //if(bSameCount==3)
    //{
    //    if((bSecondValue!=GetCardValue(cbCardData[3]) && GetCardValue(cbCardData[3])==GetCardValue(cbCardData[4]))
    //    ||(bSecondValue!=GetCardValue(cbCardData[1]) && GetCardValue(cbCardData[1])==GetCardValue(cbCardData[0])))
    //        return OX_THREE_SAME;
    //}

    BYTE bTemp[MAX_COUNT];
    BYTE bSum = 0;
    for (BYTE i = 0; i < cbCardCount; i++)
    {
        bTemp = GetCardLogicValue(cbCardData);
        bSum += bTemp;
    }

    for (BYTE i = 0; i < cbCardCount - 1; i++)
    {
        for (BYTE j = i + 1; j < cbCardCount; j++)
        {
            if ((bSum - bTemp - bTemp[j]) % 10 == 0)
            {
                return ((bTemp + bTemp[j]) > 10) ? (bTemp + bTemp[j] - 10) : (bTemp + bTemp[j]);
            }
        }
    }

    return OX_VALUE0;
}

//获取倍数
BYTE CGameLogic::GetTimes(BYTE cbCardData[], BYTE cbCardCount)
{
    if (cbCardCount != MAX_COUNT)
        return 0;

    BYTE bTimes = GetCardType(cbCardData, MAX_COUNT);
    if (bTimes < 7)
        return 1;
    else if (bTimes == 7)
        return 2;
    else if (bTimes == 8)
        return 3;
    else if (bTimes == 9)
        return 4;
    else if (bTimes == 10)
        return 5;
    else if (bTimes == OX_THREE_SAME)
        return 5;
    else if (bTimes == OX_FOUR_SAME)
        return 5;
    else if (bTimes == OX_FOURKING)
        return 5;
    else if (bTimes == OX_FIVEKING)
        return 5;

    return 0;
}

//获取牛牛
bool CGameLogic::GetOxCard(BYTE cbCardData[], BYTE cbCardCount)
{
    ASSERT(cbCardCount == MAX_COUNT);

    //设置变量
    BYTE bTemp[MAX_COUNT], bTempData[MAX_COUNT];
    CopyMemory(bTempData, cbCardData, sizeof(bTempData));
    BYTE bSum = 0;
    for (BYTE i = 0; i < cbCardCount; i++)
    {
        bTemp = GetCardLogicValue(cbCardData);
        bSum += bTemp;
    }

    //查找牛牛
    for (BYTE i = 0; i < cbCardCount - 1; i++)
    {
        for (BYTE j = i + 1; j < cbCardCount; j++)
        {
            if ((bSum - bTemp - bTemp[j]) % 10 == 0)
            {
                BYTE bCount = 0;
                for (BYTE k = 0; k < cbCardCount; k++)
                {
                    if (k != i && k != j)
                    {
                        cbCardData[bCount++] = bTempData[k];
                    }
                }ASSERT(bCount == 3);

                cbCardData[bCount++] = bTempData;
                cbCardData[bCount++] = bTempData[j];

                return true;
            }
        }
    }

    return false;
}

//获取整数
bool CGameLogic::IsIntValue(BYTE cbCardData[], BYTE cbCardCount)
{
    BYTE sum = 0;
    for (BYTE i = 0; i < cbCardCount; i++)
    {
        sum += GetCardLogicValue(cbCardData);
    }
    ASSERT(sum > 0);
    return (sum % 10 == 0);
}

//排列扑克
void CGameLogic::SortCardList(BYTE cbCardData[], BYTE cbCardCount)
{
    //转换数值
    BYTE cbLogicValue[MAX_COUNT];
    for (BYTE i = 0; i < cbCardCount; i++)
        cbLogicValue = GetCardValue(cbCardData);   

    //排序操作
    bool bSorted = true;
    BYTE cbTempData,bLast = cbCardCount - 1;
    do
    {
        bSorted = true;
        for (BYTE i = 0; i < bLast; i++)
        {
            if ((cbLogicValue < cbLogicValue[i + 1]) ||
             ((cbLogicValue == cbLogicValue[i + 1]) && (cbCardData < cbCardData[i + 1])))
            {
                //交换位置
                cbTempData = cbCardData;
                cbCardData = cbCardData[i + 1];
                cbCardData[i + 1] = cbTempData;
                cbTempData = cbLogicValue;
                cbLogicValue = cbLogicValue[i + 1];
                cbLogicValue[i + 1] = cbTempData;
                bSorted = false;
            }
        }
        bLast--;
    }
    while (bSorted == false);

    return;
}

//混乱扑克
void CGameLogic::RandCardList(BYTE cbCardBuffer[], BYTE cbBufferCount)
{
    //CopyMemory(cbCardBuffer,m_cbCardListData,cbBufferCount);
    //混乱准备
    BYTE cbCardData[CountArray(m_cbCardListData)];
    CopyMemory(cbCardData, m_cbCardListData, sizeof(m_cbCardListData));

    //混乱扑克
    BYTE bRandCount = 0,bPosition = 0;
    do
    {
        bPosition = rand() % (CountArray(m_cbCardListData) - bRandCount);
        cbCardBuffer[bRandCount++] = cbCardData[bPosition];
        cbCardData[bPosition] = cbCardData[CountArray(m_cbCardListData) - bRandCount];
    }
    while (bRandCount < cbBufferCount);

    return;
}

//逻辑数值
BYTE CGameLogic::GetCardLogicValue(BYTE cbCardData)
{
    //扑克属性
    BYTE bCardColor = GetCardColor(cbCardData);
    BYTE bCardValue = GetCardValue(cbCardData);

    //转换数值
    return (bCardValue > 10) ? (10) : bCardValue;
}

//对比扑克
bool CGameLogic::CompareCard(BYTE cbFirstData[], BYTE cbNextData[], BYTE cbCardCount, BOOL FirstOX, BOOL NextOX)
{
    if (FirstOX != NextOX)
        return (FirstOX > NextOX);

    //比较牛大小
    if (FirstOX == TRUE)
    {
        //获取点数
        BYTE cbNextType = GetCardType(cbNextData, cbCardCount);
        BYTE cbFirstType = GetCardType(cbFirstData, cbCardCount);

        //点数判断
        if (cbFirstType != cbNextType)
            return (cbFirstType > cbNextType);

        switch (cbNextType)
        {
        case OX_FOUR_SAME:
            //炸弹牌型   
        case OX_THREE_SAME:
            //葫芦牌型
            {
                //排序大小
                BYTE bFirstTemp[MAX_COUNT], bNextTemp[MAX_COUNT];
                CopyMemory(bFirstTemp, cbFirstData, cbCardCount);
                CopyMemory(bNextTemp, cbNextData, cbCardCount);
                SortCardList(bFirstTemp, cbCardCount);
                SortCardList(bNextTemp, cbCardCount);

                return GetCardValue(bFirstTemp[MAX_COUNT / 2]) > GetCardValue(bNextTemp[MAX_COUNT / 2]);

                break;
            }
        }
    }

    //排序大小
    BYTE bFirstTemp[MAX_COUNT], bNextTemp[MAX_COUNT];
    CopyMemory(bFirstTemp, cbFirstData, cbCardCount);
    CopyMemory(bNextTemp, cbNextData, cbCardCount);
    SortCardList(bFirstTemp, cbCardCount);
    SortCardList(bNextTemp, cbCardCount);

    //比较数值
    BYTE cbNextMaxValue = GetCardValue(bNextTemp[0]);
    BYTE cbFirstMaxValue = GetCardValue(bFirstTemp[0]);
    if (cbNextMaxValue != cbFirstMaxValue)
        return cbFirstMaxValue > cbNextMaxValue;

    //比较颜色
    return GetCardColor(bFirstTemp[0]) > GetCardColor(bNextTemp[0]);

    return false;
}

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