Code example

#include "Game.h"

CDeckOfCards                g_Deck;
CGameField                  g_Game;

HRESULT InitDeck()
{
    HRESULT hr;
    V_RETURN(g_Deck.InitDeck());

    for (int i = 0; i < CARD_SUIT_COUNT; i++)
    {
        for (int j = 0; j < CARD_RANK_COUNT; j++)
        {
            g_Deck.GetCard((CARD_SUIT)i, (CARD_RANK)j)->SetCardEndPos(CARD_SIZE);
        }
    }

    return S_OK;
}

void InitField()
{
    g_Game.InitField();
}

void ProcessAndRender(ID3D11DeviceContext *pImmediateContext, ID3D11RenderTargetView *pRenderTargetView)
{
    g_Game.GameProcess();
    g_Game.Render(pImmediateContext, pRenderTargetView);
}

CCard *const GetTrump()
{
    return g_Game.GetTrump();
}

int GetNumFreeCards()
{
    int dwNum = 0;
    for (int i = 0; i < CARD_SUIT_COUNT; i++)
    {
        for (int j = 0; j < CARD_RANK_COUNT; j++)
        {
            if (g_Deck.GetCard((CARD_SUIT)i, (CARD_RANK)j)->GetCardState() == CARD_STATE_IN_DECK)
                dwNum++;
        }
    }

    return dwNum;
}

void DestroyDeck()
{
    g_Deck.Clear();
}

void DestroyField()
{
    g_Game.Clear();
}

void CGameField::InitField()
{
    Clear();

    for (int i = 0; i < COUNT_PLAYERS; i++)
    {
        m_ppPlayers[i] = new CPlayer;
    }

    if (COUNT_PLAYERS > 2)
    {
        m_ppPlayers[1]->InitPlayer(PLAYER_PLACE_RIGHT_UPPER_CORNER);

        if (COUNT_PLAYERS == 4)
            m_ppPlayers[2]->InitPlayer(PLAYER_PLACE_RIGHT_BOTTOM_CORNER);
    }

    m_ppPlayers[0]->InitPlayer(PLAYER_PLACE_LEFT_UPPER_CORNER);
    m_ppPlayers[COUNT_PLAYERS - 1]->InitPlayer(PLAYER_PLACE_LEFT_BOTTOM_CORNER);

    if (!GetNumFreeCards())
    {
        m_pTrump = m_ppPlayers[COUNT_PLAYERS - 1]->GetCards().at(6 - 1);
    } else {
        while (!m_pTrump)
        {
            CARD_SUIT Suit = (CARD_SUIT)(rand() % CARD_SUIT_COUNT);
            CARD_RANK Rank = (CARD_RANK)(rand() % CARD_RANK_COUNT);

            if (g_Deck.GetCard(Suit, Rank)->GetCardState() == CARD_STATE_IN_DECK)
            {
                m_pTrump = const_cast<CCard *>(g_Deck.GetCard(Suit, Rank));
            }
        }
    }

    CCard *pLowerTrump = nullptr;

    int nLayingPlayer = 0;
    for (int i = 0; i < COUNT_PLAYERS; i++)
    {
        vector<CCard *> Cards = m_ppPlayers[i]->GetCards();

        for (int j = 0; j < m_ppPlayers[i]->GetNumCards(); j++)
        {
            if (Cards[j]->GetCardSuit() == m_pTrump->GetCardSuit() && (!pLowerTrump || pLowerTrump->GetCardRank() > Cards[j]->GetCardRank()))
            {
                pLowerTrump = Cards[j];

                nLayingPlayer = i;
            }
        }
    }

    m_nCoversPlayer = (nLayingPlayer + 1) % COUNT_PLAYERS;

    if (!pLowerTrump)
        m_nCoversPlayer = rand() % COUNT_PLAYERS;

    //m_nCoversPlayer = 0;

    m_ppPlayers[m_nCoversPlayer]->SetPlayerState(PLAYER_STATE_WAITING_NEXT_MOVE);


    m_GameState = GAME_STATE_LOADED;
};

void CPlayer::InitPlayer(PLAYER_PLACE const _Place)
{
    Clear();

    m_Place = _Place;

    m_nNumCardOnHands = 0;

    m_PlayerState = PLAYER_STATE_INITIALIZED;

    while (m_nNumCardOnHands != 6)
    {
        CARD_SUIT Suit = (CARD_SUIT)(rand() % CARD_SUIT_COUNT);
        CARD_RANK Rank = (CARD_RANK)(rand() % CARD_RANK_COUNT);

        if (g_Deck.GetCard(Suit, Rank)->GetCardState() == CARD_STATE_IN_DECK)
        {
            PushCard(const_cast<CCard *>(g_Deck.GetCard(Suit, Rank)));

            m_Cards.back()->SetCardState(CARD_STATE_ON_HANDS);
            m_Cards.back()->SetPlayer(this);
        }
    }
};

// Is C1 greater than C2?
bool IsGreaterCard(CCard const *const pC1, CCard const *const pC2)
{
    if (pC1->GetCardSuit() == g_Game.GetTrump()->GetCardSuit())
    {
        if (pC2->GetCardSuit() == g_Game.GetTrump()->GetCardSuit())
            return pC1->GetCardRank() > pC2->GetCardRank();

        return true;
    }

    if (pC2->GetCardSuit() == g_Game.GetTrump()->GetCardSuit())
        return false;

    if (pC1->GetCardSuit() != pC2->GetCardSuit())
        return false;

    return pC1->GetCardRank() > pC2->GetCardRank();
}

void CPlayer::SortCards() const
{
    auto IsGreaterCardForSort = [](CCard const *const pC1, CCard const *const pC2) -> bool
    {
        if (pC1->GetCardSuit() == g_Game.GetTrump()->GetCardSuit())
        {
            if (pC2->GetCardSuit() == g_Game.GetTrump()->GetCardSuit())
                return pC1->GetCardRank() > pC2->GetCardRank();

            return true;
        }

        if (pC2->GetCardSuit() == g_Game.GetTrump()->GetCardSuit())
            return false;

        if (pC1->GetCardSuit() < pC2->GetCardSuit())
            return true;

        if (pC1->GetCardSuit() == pC2->GetCardSuit())
            return pC1->GetCardRank() > pC2->GetCardRank();

        return false;
    };

    for (int i = 0; i < (int)m_Cards.size(); i++)
    {
        CCard const *const *ppTrueCard = &m_Cards[i];

        for (int j = i + 1; j < (int)m_Cards.size(); j++)
        {
            if (m_Cards[j] != m_Cards[i] && IsGreaterCardForSort(m_Cards[j], *ppTrueCard))
                ppTrueCard = &m_Cards[j];
        }

        if (m_Cards[i] != *ppTrueCard)
        {
            CCard const *const pValue = m_Cards[i];
            memcpy((void *)(&m_Cards[i]), (void *)ppTrueCard, 4);
            memcpy((void *)ppTrueCard, (void *)(&pValue), 4);
        }
    }
};

void CPlayer::DrawCards(ID3D11DeviceContext *pImmediateContext, ID3D11RenderTargetView *pRenderTargetView) const
{
#define Cards m_Cards
    //vector<CCard *> Cards = m_Cards;
    //Cards.assign(m_Cards.begin(), m_Cards.end());

    SortCards();

    static ID3D11ShaderResourceView *pSRVNull[100] = { NULL };

    CCBPerBatch *cbPerBatch = AUTGetCBPerBatch();

    // 1024, 768
    if (m_Place == PLAYER_PLACE_LEFT_UPPER_CORNER)
        cbPerBatch->vStart = XMFLOAT2(50.0f, 20.0f);
    else if (m_Place == PLAYER_PLACE_RIGHT_UPPER_CORNER)
        cbPerBatch->vStart = XMFLOAT2(400.0f, 20.0f);
    else if (m_Place == PLAYER_PLACE_RIGHT_BOTTOM_CORNER)
        cbPerBatch->vStart = XMFLOAT2(400.0f, 340.0f);
    else
        cbPerBatch->vStart = XMFLOAT2(50.0f, 340.0f);

    CCard *pOldCard = nullptr;

    cbPerBatch->vStart.x -= 30.0f;

    for (CCard *pCard : Cards)
    {
        if (pOldCard && pOldCard->GetCardSuit() != pCard->GetCardSuit())
        {
            cbPerBatch->vStart.x += 15.0f;
            cbPerBatch->vStart.y += 5.0f;
        }

        cbPerBatch->vStart.x += 30.0f;

        cbPerBatch->vEnd = CARD_SIZE;

        pCard->SetCardStartPos(cbPerBatch->vStart);

        //AUTSetCBPerBatch(cbPerBatch);
        AUTUpdateD3DCBPerBatch(pImmediateContext);

        ID3D11ShaderResourceView *pSRV = pCard->GetSRV();
        pImmediateContext->PSSetShaderResources(0, 1, &pSRV);
        pImmediateContext->Draw(1, 0);
        pImmediateContext->PSSetShaderResources(0, 1, pSRVNull);

        pOldCard = pCard;
    }
#undef Cards
};

void CGameField::Render(ID3D11DeviceContext *pImmediateContext, ID3D11RenderTargetView *pRenderTargetView) const
{
    static ID3D11ShaderResourceView *pSRVNull[100] = { NULL };
    static ID3D11RenderTargetView *pRTVNull[100] = { NULL };

    pImmediateContext->OMSetRenderTargets(1, &pRenderTargetView, NULL);

    AUTSetPShader(AUTMapIDsGet("PS_CardRenderer"), pImmediateContext);
    AUTSetGShader(AUTMapIDsGet("GS_CardRenderer"), pImmediateContext);
    AUTSetVShader(AUTMapIDsGet("VS_CardRenderer"), pImmediateContext);

    AUTSetPSSampler(AUTMapIDsGet("SamplerAnisotropic"), 0, pImmediateContext);

    pImmediateContext->IASetInputLayout(NULL);
    pImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_POINTLIST);

    CCBPerBatch *cbPerBatch = AUTGetCBPerBatch();

    for (CCard *pCard : m_CardsOnField)
    {
        cbPerBatch->vStart = *pCard->GetCardStartPos();
        cbPerBatch->vEnd = CARD_SIZE;
        AUTUpdateD3DCBPerBatch(pImmediateContext);

        ID3D11ShaderResourceView *pSRV = pCard->GetSRV();
        pImmediateContext->PSSetShaderResources(0, 1, &pSRV);
        pImmediateContext->Draw(1, 0);
        pImmediateContext->PSSetShaderResources(0, 1, pSRVNull);
    }

    for (CCard *pCard : m_CoverCardsOnField)
    {
        cbPerBatch->vStart = *pCard->GetCardStartPos();
        cbPerBatch->vEnd = CARD_SIZE;
        AUTUpdateD3DCBPerBatch(pImmediateContext);

        ID3D11ShaderResourceView *pSRV = pCard->GetSRV();
        pImmediateContext->PSSetShaderResources(0, 1, &pSRV);
        pImmediateContext->Draw(1, 0);
        pImmediateContext->PSSetShaderResources(0, 1, pSRVNull);
    }

    for (int i = 0; i < COUNT_PLAYERS; i++)
    {
        m_ppPlayers[i]->DrawCards(pImmediateContext, pRenderTargetView);
    }

    pImmediateContext->PSSetShaderResources(0, 1, pSRVNull);
    pImmediateContext->OMSetRenderTargets(1, pRTVNull, NULL);
    pImmediateContext->PSSetShader(NULL, NULL, 0);
    pImmediateContext->GSSetShader(NULL, NULL, 0);
    pImmediateContext->VSSetShader(NULL, NULL, 0);
};

/*
enum PLAYER_STATE
{
    PLAYER_STATE_NON_INITIALIZED = 0,
    PLAYER_STATE_INITIALIZED,
    PLAYER_STATE_CHOOSING_CARD, // if choosing finished, goto PLAYER_STATE_WAITING_NEXT_MOVE
    PLAYER_STATE_COVERING_CARD, // if covering finished, goto PLAYER_STATE_WAITING_NEXT_MOVE
    PLAYER_STATE_WAITING_NEXT_MOVE,
    PLAYER_STATE_TAKING_CARDS_FROM_FIELD, // if taking finished, goto PLAYER_STATE_WAITING_NEXT_MOVE
    PLAYER_STATE_GETTING_CARDS_FROM_DECK, // if getting finished, goto PLAYER_STATE_WAITING_NEXT_MOVE
    PLAYER_STATE_LEFT
};

enum GAME_STATE
{
    GAME_STATE_NON_LOADED = 0,
    GAME_STATE_LOADED,
    GAME_STATE_PUSHING_FIRST_CARD, // if pushing finished, goto GAME_STATE_PUSHED_FIRST_CARD
    GAME_STATE_PUSHED_FIRST_CARD,
    GAME_STATE_ADDING_CARD, // if adding finished, goto GAME_STATE_ADDED_CARD
    GAME_STATE_ADDED_CARD,
    GAME_STATE_COVERING_CARD, // if covering finished, goto GAME_STATE_COVERED_CARD
    GAME_STATE_COVERED_CARD,
    GAME_STATE_TAKING_CARDS_FROM_FIELD, // if taking finished, goto GAME_STATE_TAKED_CARDS_FROM_FIELD
    GAME_STATE_TAKED_CARDS_FROM_FIELD,
    GAME_STATE_GETTING_CARDS_FROM_DECK, // if getting finished, goto GAME_STATE_GETTED_CARDS_FROM_DECK
    GAME_STATE_GETTED_CARDS_FROM_DECK,
    GAME_STATE_FINISH
};
*/

void CGameField::GameProcess()
{
    /*
    static DWORD dwCount = 0;
    if (GAME_STATE_ADDED_CARD == m_GameState)
    {
        if (dwCount < 500)
        {
            dwCount++;
            return;
        }
    }
    */

    switch(m_GameState)
    {
    case GAME_STATE_LOADED:
        {
            int nPushingCardPlayer = (m_nCoversPlayer - 1);

            if (nPushingCardPlayer < 0)
                nPushingCardPlayer = COUNT_PLAYERS - 1;

            nPushingCardPlayer %= COUNT_PLAYERS;

            CPlayer *const pPlayer = m_ppPlayers[nPushingCardPlayer];
            CCard const *const pChoosedCard = pPlayer->GetChoosedCard();
            CCard *pMinCard = nullptr;

            //pPlayer->SetPlayerState(PLAYER_STATE_CHOOSING_CARD);
            //m_GameState = GAME_STATE_ADDING_CARD;

            if (nPushingCardPlayer == (COUNT_PLAYERS - 1) && pPlayer->GetPlayerState() != PLAYER_STATE_CHOOSED_CARD)
                break;

            if (nPushingCardPlayer != COUNT_PLAYERS - 1)
            {
                vector<CCard *> const Cards = pPlayer->GetCards();

                for (CCard *pCard : Cards)
                {
                    if (pCard->GetCardSuit() == m_pTrump->GetCardSuit())
                    {
                        pMinCard = pCard;
                        break;
                    }
                }

                if (!pMinCard)
                {
                    pMinCard = Cards[0];
                    for (CCard *pCard : Cards)
                    {
                        if (pCard->GetCardRank() > pMinCard->GetCardRank())
                            pMinCard = pCard;
                    }
                } else {
                    for (CCard *pCard : Cards)
                    {
                        if (pCard->GetCardRank() < pMinCard->GetCardRank() && pCard->GetCardSuit() != m_pTrump->GetCardSuit())
                            pMinCard = pCard;
                    }
                }
            } else {
                pMinCard = pPlayer->GetChoosedCard();
            }

            pMinCard->SetPlayer(nullptr);
            pMinCard->SetCardState(CARD_STATE_ON_FIELD);
            pMinCard->SetCardStartPos(XMFLOAT2(200.0f + m_nLastCoveredCard * 10.0f, 180.0f + m_nLastCoveredCard * 1.0f));

            m_CardsOnField.push_back(pMinCard);

            pPlayer->RemoveCard(pMinCard);

            pPlayer->SetPlayerState(PLAYER_STATE_WAITING_NEXT_MOVE);
            m_ppPlayers[m_nCoversPlayer]->SetPlayerState(PLAYER_STATE_COVERING_CARD);

            //m_nLastCoveredCard++;
            m_nLastCoveredCard = 0;

            m_GameState = GAME_STATE_ADDED_CARD;

            break;
        }
    case GAME_STATE_ADDED_CARD:
        {
            CPlayer *const pPlayer = m_ppPlayers[m_nCoversPlayer];
            CCard *pChoosedCard = pPlayer->GetChoosedCard();

            // выбираем карту, которой будем покрывать карту, лежащую на столе
            if (m_nCoversPlayer != (COUNT_PLAYERS - 1) && pPlayer->GetPlayerState() != PLAYER_STATE_TAKING_CARDS_FROM_FIELD)
            {
                for (CCard *pCard : pPlayer->GetCards())
                {
                    if (pCard->GetCardSuit() == m_pTrump->GetCardSuit() &&
                        m_CardsOnField[m_nLastCoveredCard]->GetCardSuit() != m_pTrump->GetCardSuit() &&
                        m_CardsOnField[m_nLastCoveredCard]->GetCardRank() == pCard->GetCardRank())
                    {
                        pChoosedCard = pCard;
                        break;
                    }

                    if (IsGreaterCard(pCard, m_CardsOnField[m_nLastCoveredCard]) && (!pChoosedCard || IsGreaterCard(pChoosedCard, pCard)))
                        pChoosedCard = pCard;
                }

                if (!pChoosedCard)
                {
                    pPlayer->SetPlayerState(PLAYER_STATE_TAKING_CARDS_FROM_FIELD);
                    break;
                }

                pChoosedCard->SetPlayer(nullptr);
            }

            // если это игрок и он выбрал карту
            // если это любой чувак и он уже покрывает
            if (m_nCoversPlayer == (COUNT_PLAYERS - 1) && pPlayer->GetPlayerState() == PLAYER_STATE_CHOOSED_CARD ||
                m_nCoversPlayer != (COUNT_PLAYERS - 1) && pPlayer->GetPlayerState() == PLAYER_STATE_COVERING_CARD)
            {
                if (IsGreaterCard(pChoosedCard, m_CardsOnField[m_nLastCoveredCard]))
                {
                    pChoosedCard->SetCardState(CARD_STATE_ON_FIELD);
                    pChoosedCard->SetCardStartPos(XMFLOAT2(215.0f + m_nLastCoveredCard * 10.0f, 200.0f + m_nLastCoveredCard * 1.0f));

                    m_CoverCardsOnField.push_back(pChoosedCard);

                    pPlayer->RemoveCard(pChoosedCard);

                    pPlayer->SetPlayerState(PLAYER_STATE_WAITING_NEXT_MOVE);

                    m_nLastCoveredCard = 0;
                    //m_nLastCoveredCard++;

                    m_GameState = GAME_STATE_COVERED_CARD;
                } else {
                    class CFakeClass {};

                    typedef void (CFakeClass::*Func)(PLAYER_STATE);
                    Func pFunc = (Func)&CPlayer::SetPlayerState;

                    void *pPl = const_cast<void *>(pChoosedCard->GetPlayer());

                    _asm
                    {
                        // this pointer
                        mov ecx, pPl
                        push PLAYER_STATE_COVERING_CARD
                        call pFunc
                    };

                    ((CFakeClass *)pPl->*pFunc)(PLAYER_STATE_COVERING_CARD);

                    pChoosedCard = nullptr;
                }
            }
            else if (pPlayer->GetPlayerState() == PLAYER_STATE_TAKING_CARDS_FROM_FIELD)
            {
                for (CCard *pCard : m_CardsOnField)
                {
                    pCard->SetCardState(CARD_STATE_ON_HANDS);
                    pPlayer->PushCard(pCard);
                    pCard = nullptr;
                }

                m_CardsOnField.clear();

                for (CCard *pCard : m_CoverCardsOnField)
                {
                    pCard->SetCardState(CARD_STATE_ON_HANDS);
                    pPlayer->PushCard(pCard);
                    pCard = nullptr;
                }

                m_nLastCoveredCard = 0;

                m_CoverCardsOnField.clear();

                m_GameState = GAME_STATE_TAKED_CARDS_FROM_FIELD;

                pPlayer->SetPlayerState(PLAYER_STATE_WAITING_NEXT_MOVE);
            }

            break;
        }
    case GAME_STATE_TAKED_CARDS_FROM_FIELD:
        {
            m_GameState = GAME_STATE_GETTED_CARDS_FROM_DECK;
        break;
        }
    default:
        break;
    }
}

void CGameField::ProcessPlayerInput(int const _nPlayerID, XMFLOAT2 const &_vPos, bool const _bTaking, bool const _bNextMove)
{
    return m_ppPlayers[_nPlayerID]->ProcessPlayerInput(_vPos, _bTaking, _bNextMove);
}

void ProcessPlayerInput(XMFLOAT2 const &_vPos, bool const _bTaking, bool const _bNextMove)
{
    return g_Game.ProcessPlayerInput(COUNT_PLAYERS - 1, _vPos, _bTaking, _bNextMove);
}

void CPlayer::ProcessPlayerInput(XMFLOAT2 const &_vPos, bool const _bTaking, bool const _bNextMove)
{
    if (_bTaking)
        m_PlayerState = PLAYER_STATE_TAKING_CARDS_FROM_FIELD;

    if (_bNextMove)
        m_PlayerState = PLAYER_STATE_WAITING_NEXT_MOVE;

    if (m_PlayerState == PLAYER_STATE_CHOOSED_CARD)
        return;

    //SortCards();

    for (int i = (int)m_Cards.size() - 1; i >= 0; i--)
    {
        CCard *const pCard = m_Cards[i];
        XMFLOAT2 const *const vStartPos = pCard->GetCardStartPos();
        XMFLOAT2 vEndPos = *vStartPos;
        XMStoreFloat2(&vEndPos, XMVectorAdd(XMLoadFloat2(&vEndPos), XMLoadFloat2(pCard->GetCardEndPos())));

        if (vStartPos->x <= _vPos.x && vEndPos.x >= _vPos.x && vStartPos->y <= _vPos.y && vEndPos.y >= _vPos.y)
        {
            m_PlayerState = PLAYER_STATE_CHOOSED_CARD;
            m_pChoosedCard = pCard;

            return;
        }
    }
}