VioletaBabel

15일 : 파일 입출력, 오디오, 러닝게임 완성 본문

BCA/2. Cocos2d-x
15일 : 파일 입출력, 오디오, 러닝게임 완성
Beabletoet 2018. 2. 28. 09:29
1
2
3
4
5
6
7
8
9
10
//코코스 파일 입출력
    int score = 100;
    Data data;
    data.copy((const unsigned char*)&score, sizeof(int));
    std::string fileName = FileUtils::getInstance()->getWritablePath();
    fileName += "highscore.txt";
    Data d = FileUtils::getInstance()->getDataFromFile(fileName);
    unsigned char* ddd = d.getBytes();
    int re = (int)*ddd;
    FileUtils::getInstance()->writeDataToFile(data, fileName);
cs


1
2
3
4
5
6
#include <AudioEngine.h>
using namespace cocos2d::experimental;
 
    //...
    AudioEngine::preload("res/aaaaa.mp3");
    AudioEngine::play2d("res/aaaaa.mp3");
cs




====러닝게임


1
2
3
4
5
6
7
8
9
10
11
12
13
14
//GameScene.h
#pragma once
#include <cocos2d.h>
USING_NS_CC;
class GameScene : public Scene
{
public:
    GameScene();
    ~GameScene();
    bool init();
    void StartP();
    void GameP();
    CREATE_FUNC(GameScene);
};
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
//GameScene.cpp
#include "GameScene.h"
#include "BackGround.h"
#include "MenuLayer.h"
#include "GameLayer.h"
 
 
GameScene::GameScene()
{
}
 
 
GameScene::~GameScene()
{
}
 
bool GameScene::init()
{
    BackGround *pBack1 = BackGround::create();
    addChild(pBack1, 5, "Scene_Back");
    StartP();
    return true;
}
 
void GameScene::StartP()
{
    MenuLayer *pMenu = MenuLayer::create();
    addChild(pMenu, 100, "Scene_Menu");
}
 
void GameScene::GameP()
{
    GameLayer *pLayer = GameLayer::create();
    addChild(pLayer, 10, "Scene_Game");
}
 
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
//MenuLayer.h
#pragma once
#include<cocos2d.h>
USING_NS_CC;
class MenuLayer : public Layer
{
public:
    MenuLayer();
    ~MenuLayer();
    bool init();
    void StartGame(Object *sender);
    void GameExit(Object *sender);
    CREATE_FUNC(MenuLayer);
};
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
//MenuLayer.cpp
#include "MenuLayer.h"
#include "GameScene.h"
 
 
MenuLayer::MenuLayer()
{
}
 
 
MenuLayer::~MenuLayer()
{
}
 
bool MenuLayer::init()
{
    auto mStart = MenuItemImage::create("res/start.png", "res/start.png", CC_CALLBACK_1(MenuLayer::StartGame, this));
    auto mEnd = MenuItemImage::create("res/end.png", "res/end.png", CC_CALLBACK_1(MenuLayer::GameExit, this));
    mStart->setScale(0.5f);
    auto menu = Menu::create(mStart, mEnd, NULL);
    menu->alignItemsVertically();
    this->addChild(menu);
    return true;
}
 
void MenuLayer::StartGame(Object * sender)
{
    auto a = (GameScene*)getParent();
    a->GameP();
    removeFromParent();
    auto item = (MenuItem*)sender;
}
 
void MenuLayer::GameExit(Object * sender)
{
    Director::getInstance()->end();
}
 
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//BackGround.h
#pragma once
#include<cocos2d.h>
USING_NS_CC;
class BackGround : public Layer
{
private:
    const int Back_X_Size = 1280;
public:
    BackGround();
    ~BackGround();
    bool init();
    void update(float dt);
    CREATE_FUNC(BackGround);
};
 
 
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
//BackGround.cpp
#include "BackGround.h"
#include "GameLayer.h"
 
 
BackGround::BackGround()
{
}
 
 
BackGround::~BackGround()
{
}
 
bool BackGround::init()
{
    Sprite* pSky1 = Sprite::create("res/sky.png");
    Sprite* pSky2 = Sprite::create("res/sky.png");
    addChild(pSky1, 0, "Back_Sky1");
    addChild(pSky2, 0, "Back_Sky2");
    pSky1->setPosition(0, 360);
    pSky2->setPosition(Back_X_Size, 360);
    scheduleUpdate();
    return true;
}
 
void BackGround::update(float dt)
{
 
    auto gl = (GameLayer*)(getParent()->getChildByName("Scene_Game"));
    if (gl)
        if (gl->getChildByName("Game_Player"))
        {
 
            Node* pSky[2];
            for (int i = 0; i < 2; ++i)
            {
                std::string name = StringUtils::format("Back_Sky%d", i + 1);
                pSky[i] = getChildByName(name);
            }
            for (int i = 1; i > -1; --i)
            {
                pSky[i]->setPositionX(pSky[i]->getPositionX() - 500.0f*dt);
                if (pSky[i]->getPositionX() < Back_X_Size / (-2))
                    pSky[i]->setPositionX(pSky[i]->getPositionX() + (Back_X_Size * 2));
            }
 
        }
}
 
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
//GameLayer.h
#pragma once
#include<cocos2d.h>
USING_NS_CC;
class GameLayer : public Layer
{
private : 
    int jump, jumpcount; // jump는 점프 가산치
    float move, t; // move는 캐릭터 이동 속력, t는 땅 생성 시간
    bool gameover = 0; // 게임오버시 1
    bool meetGround = 0; // 땅 위에 있는가
    bool gameoverButton = 0; // 게임오버 버튼이 보이는가
public:
    GameLayer();
    ~GameLayer();
    bool init();
    virtual bool onTouchBegan(Touch *touch, Event *unuserd_event);
    void GameLayer::RestartGame(Object * sender);
    void update(float dt);
    void makePlayer();
    void MGOn();
    void MGOff();
    int getJump();
    void GameLayer::GameExit(Object * sender);
    CREATE_FUNC(GameLayer);
};
 
 
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
//GameLayer.cpp
#include "GameLayer.h"
#include "GroundLayer.h"
#include "CharacterAni.h"
#include "StartGround.h"
#include "GameScene.h"
#include "ScoreLayer.h"
 
GameLayer::GameLayer()
{
    jump = 1;
    jumpcount = 0;
    t = 1;
    move = 0;
    srand(time(NULL));
}
 
 
GameLayer::~GameLayer()
{
}
 
bool GameLayer::init()
{
    makePlayer();
 
    auto listener = EventListenerTouchOneByOne::create();
    listener->setSwallowTouches(true);
    listener->onTouchBegan = CC_CALLBACK_2(GameLayer::onTouchBegan, this);
    _eventDispatcher->addEventListenerWithSceneGraphPriority(listener, this);
 
    StartGround *SG = StartGround::create();
    addChild(SG, 15, "Game_StartGround");
 
    ScoreLayer *SL = ScoreLayer::create();
    addChild(SL, 2000, "Game_ScoreBoard");
 
    scheduleUpdate();
    return true;
}
 
bool GameLayer::onTouchBegan(Touch * touch, Event * unuserd_event)
{
    if (jumpcount++ < 2)
    {
        MGOff();
        jump = -30;
    }
    return false;
}
 
void GameLayer::RestartGame(Object * sender)
{
    gameover = 0;
    auto a = (GameScene*)getParent();
    a->StartP();
    removeFromParent();
    auto item = (MenuItem*)sender;
}
 
void GameLayer::update(float dt)
{
    Node* pPlayer = getChildByName("Game_Player");
    t += dt;
    if (pPlayer)
    {
        if (t >= 1.0f)
        {
            GroundLayer *pGd = GroundLayer::create();
            addChild(pGd, 15);
            t -= 1.0f;
        }
        if (meetGround)
        {
            move = 0;
        }
        else if (pPlayer->getPositionY() > 660)
            move = 250.0f*dt;
        else
            move = 250.0f*dt*jump;
        
        pPlayer->setPositionY(pPlayer->getPositionY() - move);
        if (jump != 0)
            jump /= 2;
        else
            jump = 1;
        if (pPlayer->getPositionY() < 0)
        {
            pPlayer->removeFromParent();
            ++gameover;
        }
    }
    if (gameover && !gameoverButton)
    {
        auto mreStart = MenuItemImage::create("res/restart.png", "res/restart.png", CC_CALLBACK_1(GameLayer::RestartGame, this));
        auto mEnd = MenuItemImage::create("res/end.png", "res/end.png", CC_CALLBACK_1(GameLayer::GameExit, this));
        mreStart->setScale(0.5f);
        auto menu = Menu::create(mreStart, mEnd, NULL);
        menu->alignItemsVertically();
        this->addChild(menu, 1000);
 
        auto scLayer = (ScoreLayer*)getChildByName("Game_ScoreBoard");
        Data data;
        std::string fileName = FileUtils::getInstance()->getWritablePath() + "highscore.txt";
        int a = scLayer->getHignPo();
        data.copy((const unsigned char*)&a, sizeof(int));
        FileUtils::getInstance()->writeDataToFile(data, fileName);
    }
}
 
void GameLayer::makePlayer()
{
    CharacterAni* pPlayer = CharacterAni::create();
    addChild(pPlayer, 0, "Game_Player");
    pPlayer->setPosition(160, 160);
 
}
 
void GameLayer::MGOn()
{
    ++meetGround;
    jumpcount = 0;
}
 
void GameLayer::MGOff()
{
    meetGround = 0;
}
 
int GameLayer::getJump()
{
    return jump;
}
 
void GameLayer::GameExit(Object * sender)
{
    Director::getInstance()->end();
}
 
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
//CharacterAni.h
#pragma once
#include<cocos2d.h>
USING_NS_CC;
class CharacterAni : public Node
{
public:
    CharacterAni();
    ~CharacterAni();
    bool init();
    CREATE_FUNC(CharacterAni);
};
 
 
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
//CharacterAni.cpp
#include "CharacterAni.h"
CharacterAni::CharacterAni()
{
}
CharacterAni::~CharacterAni()
{
}
 
bool CharacterAni::init()
{
    FileUtils::getInstance()->addSearchPath("res"); //이걸 하면 이제 경로의 res를 입력 안해도 된다.
    Rect rt(0, 0, 109, 52);//x,y,이미지사이즈
    SpriteFrame* pSpriteFrame1 = SpriteFrame::create("y1.png", rt);
    SpriteFrame* pSpriteFrame2 = SpriteFrame::create("y2.png", rt);
    SpriteFrame* pSpriteFrame3 = SpriteFrame::create("y3.png", rt);
 
    Animation* ani = Animation::create();
    ani->addSpriteFrame(pSpriteFrame1);
    ani->addSpriteFrame(pSpriteFrame2);
    ani->addSpriteFrame(pSpriteFrame3);
    ani->setLoops(true); // 시작
    ani->setDelayPerUnit(0.032f); //2프레임당 바뀌게 함(너무 빠르지만 일단 테스트니까)
    
    Animate* animate = Animate::create(ani); // 애니메이트라는 액션을 만들어준다.
 
    Sprite* pChar = Sprite::create("y1.png"); // 애니메이트를 실행해 줄 스프라이트를 만든다.
    RepeatForever* pRF = RepeatForever::create(animate); //Repeat라는 함수도 따로 있다. 이건 무한반복
    pChar->runAction(pRF);//pChar->StopAllAction(); // 이건 모든 액션 중지
    addChild(pChar, 0, "Ani_Player");
    return true;
}
 
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//GroundLayer.h
#pragma once
#include <cocos2d.h>
USING_NS_CC;
class GroundLayer : public Node
{
private:
    const int Back_X_Size = 1280;
    bool p = 1;
    bool madeGM = 0;
public:
    GroundLayer();
    ~GroundLayer();
    bool init();
    void update(float dt);
    void makeGM();
    CREATE_FUNC(GroundLayer);
};
 
 
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
//GroundLayer.cpp
#include "GroundLayer.h"
#include "GameLayer.h"
#include "CharacterAni.h"
#include "ItemLayer.h"
#include<stdlib.h>
 
 
GroundLayer::GroundLayer()
{
}
 
 
GroundLayer::~GroundLayer()
{
}
 
bool GroundLayer::init()
{
    
    Sprite *pGd = Sprite::create("res/ground.png");
    addChild(pGd, 0, "Ground_Ground");
    int i = rand() % 3;
    pGd->setPositionY(10+(150*i));
    setPositionX(1400);
 
    scheduleUpdate();
    return true;
}
 
void GroundLayer::update(float dt)
{
    if (!madeGM++)
    {
        makeGM();
    }
    auto gl = (GameLayer*)getParent();
    auto pPlayer = (CharacterAni*)(getParent()->getChildByName("Game_Player"));
    auto gd = getChildByName("Ground_Ground");
    if (pPlayer&&gd)
    {
        Rect pRect = pPlayer->getChildByName("Ani_Player")->getBoundingBox();
        Rect gdRect = gd->getBoundingBox();
        pRect.origin += pPlayer->getPosition();
        gdRect.origin += getPosition();
        if (pRect.intersectsRect(gdRect) || gdRect.intersectsRect(pRect))
        {
            if (pRect.origin.y >= gdRect.origin.y+32 && gl->getJump() == 1)
                gl->MGOn();
        }
        else if(pRect.origin.x > gdRect.origin.x)
            gl->MGOff();
        setPositionX(getPositionX() - 200.0f*dt);
        if (getPositionX() < -250)
            removeFromParent();
    }
}
 
void GroundLayer::makeGM()
{
    ItemLayer *pGm1 = ItemLayer::create();
    addChild(pGm1, 15, "Ground_LeftMedal");
    pGm1->setPositionX(pGm1->getPositionX() - 32);
    ItemLayer *pGm2 = ItemLayer::create();
    addChild(pGm2, 15, "Ground_RightMedal");
    pGm2->setPositionX(pGm2->getPositionX() + 32);
}
 
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//StartGround.h
#pragma once
#include<cocos2d.h>
USING_NS_CC;
class StartGround : public Layer
{
public:
    StartGround();
    ~StartGround();
    bool init();
    void update(float dt);
    CREATE_FUNC(StartGround);
};
 
 
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
//StartGround.cpp
#include "StartGround.h"
#include "GameLayer.h"
#include "CharacterAni.h"
StartGround::StartGround()
{
}
StartGround::~StartGround()
{
}
 
bool StartGround::init()
{
    Sprite *pGd[7];
    for (int i = 0; i < 7; ++i)
    {
        pGd[i] = Sprite::create("res/ground.png");
        std::string name = StringUtils::format("StartGround_Ground%d", i);
        addChild(pGd[i], 0, name);
        pGd[i]->setPositionY(10);
        pGd[i]->setPositionX(i * 192 + 96);
    }
    scheduleUpdate();
    return true;
}
 
void StartGround::update(float dt)
{
    auto gl = (GameLayer*)getParent();
    auto pPlayer = (CharacterAni*)(getParent()->getChildByName("Game_Player"));
    Node *gd[7];
    for (int i = 0; i < 7; ++i)
    {
        std::string name = StringUtils::format("StartGround_Ground%d", i);
        gd[i] = getChildByName(name);
    }
    if (pPlayer&&gd)
    {
        Rect pRect = pPlayer->getChildByName("Ani_Player")->getBoundingBox();
        pRect.origin += pPlayer->getPosition();
        Rect gdRect[7];
        for (int i = 0; i < 7; ++i)
        {
            if (gd[i])
            {
                gdRect[i] = gd[i]->getBoundingBox();
                gdRect[i].origin += getPosition();
 
                if (pRect.intersectsRect(gdRect[i]) || gdRect[i].intersectsRect(pRect))
                {
                    if (pRect.origin.y >= gdRect[i].origin.y && gl->getJump() == 1)
                        gl->MGOn();
                }
                else if (pRect.origin.x > gdRect[i].origin.x && gdRect[7].origin.x >= pRect.origin.x)
                {
                    gl->MGOff();
                }
            }
        }
        setPositionX(getPositionX() - 200.0f*dt);
        if (getPositionX() < -1350)
            removeFromParent();
    }
}
 
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//ItemLayer.h
#pragma once
#include<cocos2d.h>
USING_NS_CC;
class ItemLayer : public Node
{
private:
    //bool setedPosGM = 0;
public:
    bool init();
    void update(float dt);
    ItemLayer();
    ~ItemLayer();
    //void setPosGM();
 
    CREATE_FUNC(ItemLayer);
};
 
 
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
//ItemLayer.cpp
#include "ItemLayer.h"
#include"GroundLayer.h"
#include "GameLayer.h"
#include "CharacterAni.h"
#include "ScoreLayer.h"
#include<stdlib.h>
 
ItemLayer::ItemLayer()
{
}
 
 
ItemLayer::~ItemLayer()
{
}
bool ItemLayer::init()
{
    int r = rand() % 2;
    int _y = (r * 150) + 10;
    Sprite* pGM = Sprite::create("res/goldmedal.png");
    addChild(pGM, 0, "Item_GM");
    pGM->setPosition(0, _y);
    pGM->setScale(0.8f);
    scheduleUpdate();
    return true;
}
 
void ItemLayer::update(float dt)
{
    auto gl = (GameLayer*)(getParent()->getParent());
    auto pPlayer = (CharacterAni*)(gl->getChildByName("Game_Player"));
    auto gm = getChildByName("Item_GM");
    auto gdLayer = (GroundLayer*)getParent();
    auto ScLayer = (ScoreLayer*)(getParent()->getParent()->getChildByName("Game_ScoreBoard"));
    if (pPlayer&&gm)
    {
        
        setPositionY(80 + gdLayer->getChildByName("Ground_Ground")->getPositionY());
        Rect pRect = pPlayer->getChildByName("Ani_Player")->getBoundingBox();
        Rect gmRect = gm->getBoundingBox();
        pRect.origin += pPlayer->getPosition();
        gmRect.origin += getParent()->getPosition() + getPosition();
        if (pRect.intersectsRect(gmRect) || gmRect.intersectsRect(pRect))
        {
            ScLayer->poPlus();
            removeFromParent();
        }
    }
}
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
//ScoreLayer.h
#pragma once
#include <cocos2d.h>
USING_NS_CC;
class ScoreLayer : public Layer
{
private:
    std::string fileName = FileUtils::getInstance()->getWritablePath() + "highscore.txt";
    int highpo;
    int po;
    int poCount = 0;
    int highpoCount = 0;
    int high[3];
    int sc[3];
    Sprite *pHighScore[3];
    Sprite *pScore[3];
public:
    ScoreLayer();
    ~ScoreLayer();
    bool init();
    void update();
    void highScore();
    void Score();
    int getPo();
    int getHignPo();
    void poPlus();
    void highPlus();
    CREATE_FUNC(ScoreLayer);
};
 
 
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
//ScoreLayer.cpp
#include "ScoreLayer.h"
ScoreLayer::ScoreLayer()
{
    po = 0;
}
 
 
ScoreLayer::~ScoreLayer()
{
}
 
bool ScoreLayer::init()
{
    Data d = FileUtils::getInstance()->getDataFromFile(fileName);
    unsigned char* highpoString = d.getBytes();
    highpo = (int)*highpoString;
 
 
    Sprite *pHighScoreString1 = Sprite::create("res/high.png");
    Sprite *pHighScoreString2 = Sprite::create("res/score.png");
    Sprite *pScoreString = Sprite::create("res/score.png");
        
    addChild(pHighScoreString1, 60, "Score_HighScoreString1");
    addChild(pHighScoreString2, 60, "Score_HighScoreString2");
    addChild(pScoreString, 60, "Score_ScoreString");
    pHighScoreString1->setPosition(50, 695);
    pHighScoreString1->setScale(0.8f);
    pHighScoreString2->setPosition(165, 695);
    pHighScoreString2->setScale(0.8f);
    pScoreString->setPosition(1100, 695);
    pScoreString->setScale(0.8f);
 
    highScore();
    Score();
    
    return true;
}
 
void ScoreLayer::update()
{
 
}
 
void ScoreLayer::highScore()
{
    for (int i = 0, copyH = highpo, hun = 100; i < 3; ++i, hun/=10, ++highpoCount)
    {
        if (highpoCount > 2)
            pHighScore[i]->removeFromParent();
        high[i] = copyH / hun;
        copyH %= hun;
        std::string highScoreName = StringUtils::format("res/%d.png", high[i]);
        pHighScore[i] = Sprite::create(highScoreName);
        std::string name = StringUtils::format("Score_HighScore%d", i + 1);
        addChild(pHighScore[i], 60, name);
        pHighScore[i]->setPosition(255 + (i * 35), 689);
        pHighScore[i]->setScale(0.5f);
    }
}
 
void ScoreLayer::Score()
{
    for (int i = 0, copyS = po, hun = 100; i < 3; ++i, hun/=10, ++poCount)
    {
        if(poCount > 2)
            pScore[i]->removeFromParent();
        sc[i] = copyS / hun;
        copyS %= hun;
        std::string scoreName = StringUtils::format("res/%d.png", sc[i]);
        pScore[i] = Sprite::create(scoreName);
        std::string name = StringUtils::format("Score_Score%d", i + 1);
        addChild(pScore[i], 60, name);
        pScore[i]->setPosition(1190 + (i * 35), 689);
        pScore[i]->setScale(0.5f);
    }
}
 
int ScoreLayer::getPo()
{
    return po;
}
 
int ScoreLayer::getHignPo()
{
    return highpo;
}
 
void ScoreLayer::poPlus()
{
    ++po;
    Score();
    if (po > highpo)
    {
        highPlus();
    }
}
 
void ScoreLayer::highPlus()
{
    ++highpo;
    highScore();
}
 
cs


저작자표시 비영리 변경금지

'BCA > 2. Cocos2d-x' 카테고리의 다른 글

16일 : 오디오, 3:3 AI 탱크게임  (0) 2018.03.08
16일 : 파일 입출력 - 바이너리 저장, JSON  (0) 2018.03.02
14일 : 애니메이션  (0) 2018.02.27
13일 : 복습 겸 아주 자잘한 팁  (0) 2018.02.26
12일 : 플래피 버드 완성하기  (0) 2018.02.23
'BCA/2. Cocos2d-x' Related Articles more
Comments