퍼즐 게임 만들기11 - 비매칭 시 복귀

먼저 한가지 문제부터 해결하고 시작한다

 게임이 시작했을 때 이미 3개이상 연결되 있는 블록들이 존재한다.

일단 이 블록들을 매칭시켜 제거하는 것 부터 시작하겠다.

 

CGameLayer.h

void startGame()  {
        for (int x = 0; x < COLUMN_COUNT+1; x++) {
            for (int y = 0; y < ROW_COUNT+1; y++) {
                m_pBoard[x][y] = NULL;
            }
        }
 
        srand(time(NULL));
        for (int x = 0; x < COLUMN_COUNT; x++) {
            for (int y = 0; y < ROW_COUNT; y++) {
                if (x == COLUMN_COUNT - 1 && y % 2 != 0) continue;
 
                int type = rand() % TYPE_COUNT;
 
                Sprite* pGameObjectBack = Sprite::create("blockBack.png");
                CGameObject* pGameObject = CGameObject::Create(type);
                m_pBoard[x][y] = pGameObject;
 
 
                // debug --------------------------------------------------------------
                // 각 블록의 좌표를 출력
                std::string str, str2, str3;
                str = std::to_string(x);
                str2 = ",";
                str3 = std::to_string(y);
                str.append(str2);
                str.append(str3);
                auto label = LabelTTF::create(str, "Arial", 50);
                Point pos; pos.set(Common::ComputeXY(x, y));
                label->setPosition(pos);
                // end of debug -------------------------------------------------------
 
 
                pGameObjectBack->setAnchorPoint(ccp(0.5f, 0.5f));
                pGameObjectBack->setPosition(Common::ComputeXY(x, y));
                pGameObject->setAnchorPoint(ccp(0.5f, 0.5f));
                pGameObject->setPosition(Common::ComputeXY(x, y));
                pGameObject->SetGameLayer(this);
 
                addChild(pGameObjectBack, 1);
                addChild(pGameObject, 2);
                addChild(label, 3);
            }
        }
 
        searchMacthedStreak();
        clearRemovealObject();
 
        // 변수 초기화
        m_bTouchStarted = false;
    }

 빨간색으로 표시된 부분이 변경된 부분이다.

startGame()에서 미리 '매칭->제거'를 해버렸다.

시작하자마자 위와 같이 매칭되는 블록들이 모두 사라졌다.

저 빈칸을 채우는 것은 다음 게시물에서 언급하겠다.

 

블록이 매칭되지 않았을 때 원래 자리로 복귀

CGameLayer.h

#ifndef PuzzleGame_GameLayer
#define PuzzleGame_GameLayer
 
#include "Common.h"
#include "GameObject.h"
#include <stdio.h>
#include <string.h>
 
#define NONE        false
#define ROLLBACK    true
 
class CGameLayer : public cocos2d::Layer {
public:
    // [ 기본 ]
    // ==============================================================================================================
    static cocos2d::Scene* createScene()  {
        auto pScene = Scene::create();
        auto pLayer = CGameLayer::create();
 
        pScene->addChild(pLayer);
 
        return pScene;
    }
 
    virtual bool init() {
        if (!Layer::init()) { return false; }
 
        // 배경 이미지 출력
        cocos2d::Sprite* pBackgroundSprite = cocos2d::Sprite::create("background.png");
        pBackgroundSprite->setPosition(cocos2d::CCPointZero);
        pBackgroundSprite->setAnchorPoint(ccp((float)0, (float)0));
        addChild(pBackgroundSprite);
 
 
        // 터치 초기화
        EventListenerTouchAllAtOnce* listener = EventListenerTouchAllAtOnce::create();
        listener->onTouchesBegan = CC_CALLBACK_2(CGameLayer::onTouchesBegan, this);
        listener->onTouchesMoved = CC_CALLBACK_2(CGameLayer::onTouchesMoved, this);
        listener->onTouchesEnded = CC_CALLBACK_2(CGameLayer::onTouchesEnded, this);
        _eventDispatcher->addEventListenerWithSceneGraphPriority(listener, this);
 
 
        m_winSize = Director::sharedDirector()->getWinSize();
        startGame();
        return true;
    }
 
    void startGame()  {
        for (int x = 0; x < COLUMN_COUNT+1; x++) {
            for (int y = 0; y < ROW_COUNT+1; y++) {
                m_pBoard[x][y] = NULL;
            }
        }
 
        srand(time(NULL));
        for (int x = 0; x < COLUMN_COUNT; x++) {
            for (int y = 0; y < ROW_COUNT; y++) {
                if (x == COLUMN_COUNT - 1 && y % 2 != 0) continue;
 
                int type = rand() % TYPE_COUNT;
 
                Sprite* pGameObjectBack = Sprite::create("blockBack.png");
                CGameObject* pGameObject = CGameObject::Create(type);
                m_pBoard[x][y] = pGameObject;
 
 
                // debug --------------------------------------------------------------
                // 각 블록의 좌표를 출력
                std::string str, str2, str3;
                str = std::to_string(x);
                str2 = ",";
                str3 = std::to_string(y);
                str.append(str2);
                str.append(str3);
                auto label = LabelTTF::create(str, "Arial", 50);
                Point pos; pos.set(Common::ComputeXY(x, y));
                label->setPosition(pos);
                // end of debug -------------------------------------------------------
 
 
                pGameObjectBack->setAnchorPoint(ccp(0.5f, 0.5f));
                pGameObjectBack->setPosition(Common::ComputeXY(x, y));
                pGameObject->setAnchorPoint(ccp(0.5f, 0.5f));
                pGameObject->setPosition(Common::ComputeXY(x, y));
                pGameObject->SetGameLayer(this);
 
                addChild(pGameObjectBack, 1);
                addChild(pGameObject, 2);
                addChild(label, 3);
            }
        }
 
        searchMacthedStreak();
        clearRemovealObject();
 
        // 변수 초기화
        m_bTouchStarted = false;
    }
    CREATE_FUNC(CGameLayer);
 
protected:
    int m_score;
 
 
    // ==============================================================================================================
 
    // [ 터치 제어 ]
    // ==============================================================================================================
    void onTouchesBegan(const std::vector<cocos2d::Touch*>&pTouches, cocos2d::Event* pEvent) {
        if (!m_bTouchStarted) {
            Touch* pTouch = (Touch*)pTouches.back();
            Point point = pTouch->getLocation();
 
            m_gestureStartBoardX = Common::ComputeBoardX(point);
            m_gestureStartBoardY = Common::ComputeBoardY(point);
 
            m_bTouchStarted = true;
        }
    }
    void onTouchesMoved(const std::vector<cocos2d::Touch*>&pTouches, cocos2d::Event* pEvent) {
        if (m_bTouchStarted) {
            Touch* pTouch = (Touch*)pTouches.back();
            Point point = pTouch->getLocation();
 
            int boardX = Common::ComputeBoardX(point);
            int boardY = Common::ComputeBoardY(point);
 
            if (m_gestureStartBoardX != boardX || m_gestureStartBoardY != boardY)
            if (isAdjacent(m_gestureStartBoardX, m_gestureStartBoardY, boardX, boardY)) {
                swapObjects(m_gestureStartBoardX, m_gestureStartBoardY, boardX, boardY);
                m_bTouchStarted = false;
            }
        }
    }
    void onTouchesEnded(const std::vector<cocos2d::Touch*>&pTouches, cocos2d::Event* pEvent) {
        if (m_bTouchStarted) {
            Touch* pTouch = (Touch*)pTouches.back();
            Point point = pTouch->getLocation();
        }
    }
 
protected:
    CGameObject* m_pBoard[COLUMN_COUNT+1][ROW_COUNT+1];
    Size m_winSize;
 
    bool m_bTouchStarted;    // 터치가 시작되었는지
    int m_gestureStartBoardX;
    int m_gestureStartBoardY; // 터치가 시작된 블록이 어느 블록인지
    // ==============================================================================================================
 
 
 
 
    // [ 제어 - 블록 매칭 ]
    // ==============================================================================================================
public:
    bool isAdjacent(int x1, int y1, int x2, int y2) {
        if (y1 % 2 == 0) {
            if ((x1 == x2) && (y1 - 2 == y2 || y1 - 1 == y2 || y1 + 1 == y2 || y1 + 2 == y2))
                return true;
            if ((x1 - 1 == x2) && (y1 - 1 == y2 || y1 + 1 == y2))
                return true;
        }
        else {
            if ((x1 == x2) && (y1 - 2 == y2 || y1 - 1 == y2 || y1 + 1 == y2 || y1 + 2 == y2))
                return true;
            if ((x1 + 1 == x2) && (y1 - 1 == y2 || y1 + 1 == y2))
                return true;
        }
        return false;
    }    // 두 블록이 서로 인접한 블록인지
    void swapObjects(int x1, int y1, int x2, int y2, bool bRoolBack = NONE) {
        CGameObject* pTemp = m_pBoard[x1][y1];
        m_pBoard[x1][y1] = m_pBoard[x2][y2];
        m_pBoard[x2][y2] = pTemp;
 
        m_pBoard[x1][y1]->SetTargetBoardX(x1);
        m_pBoard[x1][y1]->SetTargetBoardY(y1);
        m_pBoard[x2][y2]->SetTargetBoardX(x2);
        m_pBoard[x2][y2]->SetTargetBoardY(y2);
 
        if (!bRoolBack) {
            m_pBoard[x1][y1]->ProcessSliding();
            m_pBoard[x2][y2]->ProcessSliding();
        }
        else {
            m_pBoard[x1][y1]->RollBack();
            m_pBoard[x2][y2]->RollBack();
        }
    }
 
    // 블록 swap완료 이벤트 핸들러
    void SlidingCompleteEventHandler(int x1, int y1, int x2, int y2) {
        static int count = 0;
        count++;
 
        if (count % 2 == 0) {
            if (!searchMacthedStreak()) swapObjects(x1, y1, x2, y2, ROLLBACK);
 
            clearRemovealObject();
        }
 
    }
 
protected:
    // 매칭된 블록이 있는지 검사하고 제거대상으로 설정
    bool searchMacthedStreak() {
        bool isAnyMatched = false;
        int x = 0, y = 0;
 
        // 1행에서 검사 (0,0 / 1,0, / 2,0 / 3,0 / 4,0)
        while (true) {
            if (x < 0 || x >= COLUMN_COUNT) break;
            if (y < 0 || y >= ROW_COUNT) break;
            if (!m_pBoard[x][y]) break;
 
            if (streakWay1(x, y)) isAnyMatched = true;
            if (streakWay2(x, y)) isAnyMatched = true;
            if (streakWay3(x, y)) isAnyMatched = true;
            x++;
        }
 
        // 2행에서 검사(0,1 / 1,1 / 2,1 / 3, 1)
        x = 0; y = 1;
        while (true) {
            if (x < 0 || x >= COLUMN_COUNT) break;
            if (y < 0 || y >= ROW_COUNT) break;
            if (!m_pBoard[x][y]) break;
 
            if (streakWay2(x, y)) isAnyMatched = true;
            x++;
        }
 
        // 좌측 열에서 검사
        x = 0; y = 2;
        while (true) {
            if (x < 0 || x >= COLUMN_COUNT) break;
            if (y < 0 || y >= ROW_COUNT) break;
            if (!m_pBoard[x][y]) break;
 
            if (streakWay1(x, y)) isAnyMatched = true;
 
            y += 2;
        }
 
        // 우측 열에서 검사
        x = COLUMN_COUNT - 1; y = 2;
        while (true) {
            if (x < 0 || x >= COLUMN_COUNT) break;
            if (y < 0 || y >= ROW_COUNT) break;
            if (!m_pBoard[x][y]) break;
 
            if (streakWay3(x, y)) isAnyMatched = true;
            y += 2;
        }
 
        return isAnyMatched;
    }
    // 제거 대상 블록을 처리
    void clearRemovealObject() {
        for (int x = 0; x < COLUMN_COUNT; x++) {
            for (int y = 0; y < ROW_COUNT; y++) {
                if (x == COLUMN_COUNT - 1 && y % 2 != 0) continue;
                if (m_pBoard[x][y]->isRemovalObject()) {
                    m_pBoard[x][y]->setVisible(false);
                }
            }
        }
    }
 
    // 매칭 라인 - 좌대각↘ 1줄 검사
    bool streakWay1(int x, int y) {
        int i = 0;
        int countMatch = 1;
        bool isAnyMatched = false;
 
        while (true) {
            if (x < 0 || x >= COLUMN_COUNT) break;
            if (y < 0 || y >= ROW_COUNT) break;
            if (!m_pBoard[x][y]) break;
 
            int nextX = x;
            int nextY = y + 1;
            i = 1 - i;
            if (i % 2 == 0) nextX = x + 1;
 
            if (countMatch > 2) {
                m_pBoard[x][y]->setRemovalObject();
                m_pBoard[(i % 2 == 0) ? x : x - 1][y - 1]->setRemovalObject();
                m_pBoard[(i % 2 == 0) ? x-1 : x - 1][y - 2]->setRemovalObject();
                isAnyMatched = true;
            }
 
            if (checkType(m_pBoard[x][y]->GetType(), nextX, nextY)) {
                if (m_pBoard[nextX][nextY]->isVisible())
                    countMatch++;
            }
            else countMatch = 1;
 
            x = nextX;
            y = nextY;
        }
        return isAnyMatched;
    }
    // 매칭 라인 - 수직↓ 1줄 검사
    bool streakWay2(int x, int y) {
        int i = 1;
        int countMatch = 1;
        bool isAnyMatched = false;
        while (true) {
            if (x < 0 || x >= COLUMN_COUNT) break;
            if (y < 0 || y >= ROW_COUNT) break;
            if (!m_pBoard[x][y]) break;
 
            int nextX = x;
            int nextY = y + 2;
 
            if (countMatch > 2) {
                m_pBoard[x][y]->setRemovalObject();
                m_pBoard[x][y - 2]->setRemovalObject();
                m_pBoard[x][y - 4]->setRemovalObject();
                isAnyMatched = true;
            }
 
            if (checkType(m_pBoard[x][y]->GetType(), nextX, nextY)) {
                if (m_pBoard[nextX][nextY]->isVisible())
                    countMatch++;
            }
            else countMatch = 1;
 
            x = nextX;
            y = nextY;
        }
        return isAnyMatched;
    }
    // 매칭 라인 - 우대각↙ 1줄 검사
    bool streakWay3(int x, int y) {
        int i = 1;
        int countMatch = 1;
        bool isAnyMatched = false;
        while (true) {
            if (x < 0 || x >= COLUMN_COUNT) break;
            if (y < 0 || y >= ROW_COUNT) break;
            if (!m_pBoard[x][y]) break;
 
            int nextX = x;
            int nextY = y + 1;
            i = 1 - i;
            if (i % 2 == 0) nextX = x - 1;
 
            if (countMatch > 2) {
                m_pBoard[x][y]->setRemovalObject();
                m_pBoard[(i % 2 == 0) ? x : x + 1][y - 1]->setRemovalObject();
                m_pBoard[(i % 2 == 0) ? x + 1 : x + 1][y - 2]->setRemovalObject();
                isAnyMatched = true;
            }
 
            if (checkType(m_pBoard[x][y]->GetType(), nextX, nextY)) {
                if (m_pBoard[nextX][nextY]->isVisible())
                    countMatch++;
            }
            else countMatch = 1;
 
            x = nextX;
            y = nextY;
        }
        return isAnyMatched;
    }
    // 블록 타입 검사
    bool checkType(int type, int x, int y) {
        if (x < 0 || x >= COLUMN_COUNT) return false;
        if (y < 0 || y >= ROW_COUNT) return false;
        if (!m_pBoard[x][y]) return 0;
 
        return (type == m_pBoard[x][y]->GetType());
    }
    // ==============================================================================================================
 
 
    // [ 제어 - 블록 채우기 ]
    // ==============================================================================================================
public:
 
 
protected:
 
    // ==============================================================================================================
};
#endif

 

172행 - swapObjects()에 원래 자리로 복귀하는 기능을 추가했다.

           기존에 쓰던 CGameObject::ProcessSliding()에서 이동 전 좌표를 저장해뒀기

           때문에 가능한 일이다.

 

193행 - static int i를 사용해 짝수 번 호출될 때만 아래 코드를 실행하게 했다.

          swapObject()에서 ProcessSliding()을 두 번 사용하기 때문에

          이벤트 핸들러도 두 번 실행되기 때문이다.

 

CGameObject.cpp

#include "GameObject.h"
#include "GameLayer.h"
 
USING_NS_CC;
 
CGameObject* CGameObject::Create(int type) {
    static std::string objectNames[TYPE_COUNT] = {
        "blockBlue.png",
        "blockBrown.png",
        "blockGreen.png",
        "blockPink.png",
        "blockWhite.png",
        "blockYellow.png"
    };
    if (type<0 || type>TYPE_COUNT - 1) return NULL;
    CGameObject* pGameObject = CGameObject::create(objectNames[type].c_str(),
        CCRectMake(0.0f, 0.0f, OBJECT_WIDTH, OBJECT_HEIGHT));
    pGameObject->SetType(type);
    return pGameObject;
}
 
CGameObject* CGameObject::create(const char* pszFileName, const CCRect& rect) {
    CGameObject* pSprite = new CGameObject();
    if (pSprite && pSprite->initWithFile(pszFileName, rect)) {
        pSprite->autorelease();
        return pSprite;
    }
    CC_SAFE_DELETE(pSprite);
    return NULL;
}
 
 
void CGameObject::ProcessSliding() {
    Point position = getPosition();
 
    m_prevBoardX = Common::ComputeBoardX(position);
    m_prevBoardY = Common::ComputeBoardY(position);
    Point targetPosition = Common::ComputeXY(m_targetBoardX, m_targetBoardY);
    MoveBy* pMoveBy = MoveBy::create(0.15f, ccp(targetPosition.x - position.x, targetPosition.y - position.y));
 
    FiniteTimeAction* pAction = Sequence::create(pMoveBy,
        CallFunc::create(this, callfunc_selector(CGameObject::SlidingCompleteEvent)), NULL);
    runAction(pAction);
}
 
void CGameObject::RollBack() {
    Point position = getPosition();
 
    Point targetPosition = Common::ComputeXY(m_targetBoardX, m_targetBoardY);
    MoveBy* pMoveBy = MoveBy::create(0.15f, ccp(targetPosition.x - position.x, targetPosition.y - position.y));
 
    FiniteTimeAction* pAction = Sequence::create(pMoveBy, NULL);
    runAction(pAction);
}
 
 
 
void CGameObject::SlidingCompleteEvent(){
    m_pGameLayer->SlidingCompleteEventHandler(m_prevBoardX, m_prevBoardY, m_targetBoardX, m_targetBoardY);
};
 

 

 

빨간 색으로 표시한 부분 이 외에도 버그 수정을 많이 했지만 그건 언급하지 않겠다.