First.txt

# 설리번 프로젝트 
- (게임, 이제 만들어서 하자! ) By Team 하이바

## 개요
### 교육 개요
- 주제 : 게임 제작
- 대상 : 코딩을 처음 접해보는 중학생 - 고등학생
- 난이도 : 중하

### 수업 개요
- 수업 장소 : 경기도 하남시
- 수업 차시 : 10차시
- 소요 시간 : 2시간 (쉬는시간 15분)
- 목표
  - 수업 이후에도 지속적인 개발에 대한 관심을 가진다.
  - 배운 내용으로 게임이외에 다른것을 만들 수 있다.
  - 게임이 작동되는 기본적인 원리를 이해한다.
- 강의 방법
- 설리번 선생님들이 만든 게임들을  소개하여 수업에 대한 의욕 유발
- 필요한 준비물
  - 코딩이 가능한 노트북  
- 최종 목표
  - 기본 문법을 이해하여 자신만의 게임 만들기
## 차시 개요
### 1차시
- 수업 목표
  - 오리엔테이션 & 아이스브레이킹
  - 학생이 만들고자 하는 게임 알기
- 수업 진행
  - 오리엔테이션
  - 자기소개시간
  - 아이스브레이킹
  - 자신이 만들고 싶은 게임에 대해 생각후 발표
  - C++에 대하여 알아보기
    - C++ 설치
    - C++에 대하여 설명
  - Cocos에 대하여 알아보기
    - Cocos 설치
    - Cocos에 대하여 설명
### 2차시
- 수업 목표
 - C++의 기본 입출력 익히기
 - 함수와 변수 익히기
- 수업 진행
- cout,cin
- 함수 오버로딩, 디폴트 매개변수, 인라인 함수
### 3차시
- 수업 목표
- 참조자 익히기
- New&Delete 익히기
- 클래스(기초) 익히기
- 수업 진행
- 클래스에 대한 이해
### 4차시
- 수업 목표
- 콘솔게임 만들기(1) & 클래스 심화
- 수업 진행
- 클래스에 대한 이해
### 5차시
- 수업 목표
- 콘솔게임 만들기(2)
- 수업 진행
- 클래스에 대한 이해
### 6차시
- 수업 목표
- Cocos의 기본 입출력 익히기
- 그림이동 익히기
- 사진 출력 익히기
- 수업 진행
-  Cocos에 대한 전반적인 지식 습득과 이해하기
[설리번 프로젝트 6차시.pptx - Google 드라이브](https://drive.google.com/open?id=1aRDuuS1ZWuCgdfsaLQTzzV51teYfriV3)
### 7차시
- 수업 목표
- 게임에 필요한 여러가지 기능들 사용하기 예)함수, 스프라이트 등등
- 수업 진행
- 스프라이트, 액션 사용법 익히기
- [설리번 프로젝트 7차시.pptx - Google 드라이브](https://drive.google.com/open?id=16dj91Zt0u3NBt10im66pI8k9MD68lHTq)
### 8차시
- 수업 목표
- 비슷한 게임 예제와 대조하여 차이점 분석 예)플래피버드 소스코드 분석
- 게임제작시작(Ex.주제,컨셉)
- 수업 진행
- 소스코드에 대한 이해와 자신감 증진


- 플래피버드 소스코드에 사용된 함수나 클래스들의 사용방법이나 효과를 설명
- 소스코드를 분석하면서 게임 제작에 대한 감을 익히게 함
- 소스코드 분석이 끝나면 자신이 생각해 온 게임의 주제와 컨셉에 따라 게임제작을 시작


### 9차시
- 수업 목표
- 게임제작마무리
- 수업 진행
- Cocos문법을 사용하여 원하는 게임을 만들고, 디버깅을 한다

### 10차시
- 수업 목표
- 게임 제작 마무리 및 미완성한 학생 도움
- 학생들이 제작한 게임 발표 및 피드백
- + 쫑파티
- 수업 진행
- 수업 이후에도 게임 제작및 개발을 지속적으로 할 수 있도록 함

- 게임제작을 할때 필요한 자료들을 구할 수 있는 사이트들이나 독학하는 방법이나 노하우등을 알려주고 관련 대회들에 대한 정보를 알려줌

## 코드및 수업내용
// cout 으로 자기 학번 이름 출력하기

// ex) std::cout << "1415 이예준";

/*
 cin으로 자기 나이 입력받고 출력하기

ex) 
 int age; 
 std::cin >> age;
 std::cout << age << "살";
 
설명 :  c언어에 printf()가 있다면 c++에는 cout이 있는데 앞에 std::은 네임스페이스라고한다.
      이것은 추후에 설명할테니 현재는 이와같은 형식으로 쓴다는 정도로만 이해하자
      cout의 장점이라면 c언어에서 변수를 출력해주는 서식문자를 쓰지 않아도 자동으로 출력해준다는것
      동일하게 c언어에도 scanf()가 있으면 c++에는 cin이있다
      cin역시 서식문자가 필요없어 편리하다
       
//학생들에게 제출할 문제 :  cout 한개와 cin하나로 5개의 숫자를 입력받고 출력해보자!

int a,b,c,d,e; //혹은 a[5]; 

std::cin >> a >> b >> c >> d >> e;
std::cout << a << b << c << d << e;

*/

// 간단한 오버로딩된 함수 만들어보기
/*
ex)

int add(int a, int b)
{
   return a + b;
}

float add(float a, float c) 
{
   return a + c;
}


int main()
{
   std::cout << add(3.0f, 3.0f);
} 

설명 :  오버로딩이란 간단히 말해 이미 만들어진 함수에 새기능을 부여한다고 할 수 있다
       이때 오버로딩할 내용은 기존의 함수와 다른 매개변수를 가져야만 한다
      매개변수의 갯수가 다르거나 자료형이 다른 경우에만 오버로딩을 할 수 있다 

//학생들에게 제출할 문제 :  함수 하나로 어떤 변수든지 출력해보자!

정답 : 

void Print(int a) {
   std::cout << a;
   
   return;
}

void Print(char a[]) {
   std::cout << a;
   
   return;
}

void double(int a) {
   std::cout << a;
   
   return;
}

*/

// 디폴트 매개변수에 대해 알아보고 사용해보기
/*
ex)

int add(int a, int b = 10)
{
   return a + b;
}

int main()
{
   std::cout << add(10,12);
}

//학생들에게 제출할 문제 :  숫자를 출력하는 함수를 만들어라,단 아무것도 입력하지 않으면
                     "no number"라는 문자열을 출력하라
                     
정답:

   void printN(int num=0,char a[]="no number"){
      if(!num)
         std::cout << a;
      else
         std::cout << num;
      
      return;   
   } 

설명 :  디폴트 매개변수란 함수를 호출할때 함수에 아무값도 넣지 않는다면 자동으로 들어가는 값이라고 생각하면 된다.
       이때 디폴트매개 변수는 반드시 맨오른쪽부터  써야하는데 이유는 함수가 매개변수를 읽는 순서때문이다.

*/

- 9차시 수업시 코드
- Block C++ Source File
- #include "Block.h"
#include "SimpleAudioEngine.h"
#include "numeric"

USING_NS_CC;

Block::Block() {}
Block::~Block() {}

Block* Block::Create(const std::string path) {
	Block* newBlock = new Block();
	newBlock->blockSpr = Sprite::create(path);
	newBlock->isBreak = false;
	return newBlock;
}

Block* Block::Create(Vec2 pos, int bCode, bool moved) {
	Block* newBlock = new Block();
	std::string path;
	switch (bCode)
	{
	case (int)BlockCode::Normal:
	case (int)BlockCode::Goal:
	case (int)BlockCode::Start:
		path = "baseblock.png";
		break;
	case (int)BlockCode::JumpUp:
		path = "jumpupblock.png";
		break;
	case (int)BlockCode::JumpDown:
		path = "jumpdownblock.png";
		break;
	case (int)BlockCode::Break:
		path = "breakstone.png";
		break;
	case (int)BlockCode::Move:
		path = "moveblock.png";
		break;
	case (int)BlockCode::Arrive:
		path = "arriveblock.png";
		break;
	case (int)BlockCode::GoalOpen:
		path = "Keyblock.png";
		break;
	}
	newBlock->blockSpr = Sprite::create(path);
	newBlock->SetPosition(pos);
	newBlock->SetBlockCode(bCode);
	newBlock->blockSpr->setScale(0.3f);
	newBlock->isBreak = false;
	return newBlock;
}

void Block::Draw(Scene* scene) {
	scene->addChild(blockSpr,3);
}

void Block::SetPosition(cocos2d::Vec2 pos) {
	blockSpr->setPosition(pos);
}

void Block::SetVisible(bool v) {
	blockSpr->setVisible(v);	
}

bool Block::GetVisible() const {
	return blockSpr->isVisible();
}

void Block::SetBlockCode(int bCode) {
	blockCode = bCode;
}

int Block::GetBlockCode() {
	return blockCode;
}

void Block::SetIsMoved(bool moved) {
	isBreak = moved;
}

bool Block::GetIsMoved() {
	return isBreak;
}

Sprite* Block::GetBlockSpr() {
	return blockSpr;
}

- Block C Header File
- #pragma once
#ifndef __BLOCK_SCENE_H__
#define __BLOCK_SCENE_H__

#include "cocos2d.h"

enum class BlockCode {
	Start = 1,
	Normal,
	JumpUp,
	JumpDown,
	Break,
	Move,
	Arrive,
	GoalOpen,
	Goal
};

class Block {
	cocos2d::Sprite* blockSpr;
	bool isBreak;
	int blockCode;
public:
	Block();
	~Block();
public:
	static Block* Create(const std::string);
	static Block* Create(cocos2d::Vec2, int, bool);
	void Draw(cocos2d::Scene*);
public:
	void SetPosition(cocos2d::Vec2);
	cocos2d::Vec2 GetPosition();
	void SetVisible(bool);
	bool GetVisible() const;
	void SetBlockCode(int);
	int GetBlockCode();
	void SetIsMoved(bool);
	bool GetIsMoved();
	cocos2d::Sprite* GetBlockSpr();
};

#endif // __HELLOWORLD_SCENE_H__

- Character C++ Source File
- #pragma once
#ifndef __BLOCK_SCENE_H__
#define __BLOCK_SCENE_H__

#include "cocos2d.h"

enum class BlockCode {
	Start = 1,
	Normal,
	JumpUp,
	JumpDown,
	Break,
	Move,
	Arrive,
	GoalOpen,
	Goal
};

class Block {
	cocos2d::Sprite* blockSpr;
	bool isBreak;
	int blockCode;
public:
	Block();
	~Block();
public:
	static Block* Create(const std::string);
	static Block* Create(cocos2d::Vec2, int, bool);
	void Draw(cocos2d::Scene*);
public:
	void SetPosition(cocos2d::Vec2);
	cocos2d::Vec2 GetPosition();
	void SetVisible(bool);
	bool GetVisible() const;
	void SetBlockCode(int);
	int GetBlockCode();
	void SetIsMoved(bool);
	bool GetIsMoved();
	cocos2d::Sprite* GetBlockSpr();
};

#endif // __HELLOWORLD_SCENE_H__

- Character C Header File

#pragma once
#ifndef __CHARACTER_SCENE_H__
#define __CHARACTER_SCENE_H__

#include "cocos2d.h"
#include "Block.h"

#define JUMPPOWER 50
#define GRAVITY 10
#define XSPEED 22
#define SLOW 3

class Character {
private:
	float jumpPower = JUMPPOWER;
	int xSpeed = XSPEED;
	cocos2d::Sprite* characterSpr;
	BlockCode blockCode = BlockCode::Start;
	bool isJumping = false;
	bool isClear = false;
public:
	Character();
	~Character();
public:
	static Character* Create(const std::string);
	void Draw(cocos2d::Scene*);
public:
	void SetPosition(cocos2d::Vec2);
	cocos2d::Vec2 GetPosition();
	cocos2d::Sprite* GetSprite();
public:
	void C_SetXSpeed(cocos2d::Vec2);
	void C_Jump();
	bool C_Crash(Block&);
	void Start_B();
	void JumpUp_B();
	void JumpDown_B();
	void Break_B(Block&);
	void Teleport_B();
	void GoalOpen_B();
	void Goal_B();
	int GetPlus(int);
	float GetRoot(int);
	bool GetIsJumping();
	bool GetIsClear();
};
#endif
#pragma once

- MoveScene C++ Source File
- #include "MoveScene.h"
//#include "SimpleAudioEngine.h"

USING_NS_CC;

Block *block = new Block[24];
int rear;
bool *_isClear;

Scene* MoveScene::createScene(Block _block[24], int _rear, bool *isClear)
{
	_isClear = isClear;
	for (int i = 0; i < _rear; i++)
		block[i] = *Block::Create(_block[i].GetBlockSpr()->getPosition(),_block[i].GetBlockCode(),true);
	rear = _rear;
	return MoveScene::create();
}

bool MoveScene::init()
{
	if (!Scene::init())
	{
		return false;
	}

	auto visibleSize = Director::getInstance()->getVisibleSize();
	Vec2 origin = Director::getInstance()->getVisibleOrigin();

	//터치하는거
	auto listener = EventListenerTouchOneByOne::create();
	listener->onTouchBegan = CC_CALLBACK_2(MoveScene::onTouchBegan, this);
	listener->onTouchMoved = CC_CALLBACK_2(MoveScene::onTouchMoved, this);
	listener->onTouchEnded = CC_CALLBACK_2(MoveScene::onTouchEnded, this);
	Director::getInstance()->getEventDispatcher()->addEventListenerWithSceneGraphPriority(listener, this);

	//배경화면
	auto background = Sprite::create("background.jpg");
	background->setPosition(Point(0, 0));
	background->setAnchorPoint(Point(0.0f, 0.0f));
	background->setContentSize(visibleSize);
	addChild(background, 0);

	//근경
	auto frontground = Sprite::create("frontground.png");
	frontground->setPosition(Point(0, 0));
	frontground->setAnchorPoint(Point(0.0f, 0.0f));
	frontground->setContentSize(visibleSize);
	addChild(frontground, 1);

	//이전버튼
	back_button = Sprite::create("back_button.png");
	back_button->setPosition(Vec2(1280 - 50, 50));
	back_button->setAnchorPoint(Vec2(0.5f, 0.5f));
	back_button->setScale(0.5f);
	addChild(back_button, 3);

	MakeMap();

	this->schedule(schedule_selector(MoveScene::Update));

	return true;
}

bool MoveScene::onTouchBegan(Touch *touch, Event *unused_event) {
	Vec2 touchPos = touch->getLocation();

	//이전버튼이 눌렸는지 확인
	if (back_button->getBoundingBox().containsPoint(touchPos))
	{
		Director::getInstance()->popScene();
	}
	else if(!isTouch&& !character->GetIsJumping())
	{
		isTouch = true;
		if ((touchPos.x - character->GetSprite()->getPosition().x) < 0)
			character->GetSprite()->setTexture(Director::getInstance()->getTextureCache()->addImage("character_stand_1.png"));
		else
			character->GetSprite()->setTexture(Director::getInstance()->getTextureCache()->addImage("character_stand.png"));
	}
	return true;
}

void MoveScene::onTouchMoved(Touch *touch, Event *usused_event) {
	Vec2 pos = touch->getLocation();
	if (isTouch&&!character->GetIsJumping())
	{
		if ((pos.x - character->GetSprite()->getPosition().x) < 0)
			character->GetSprite()->setTexture(Director::getInstance()->getTextureCache()->addImage("character_stand_1.png"));
		else
			character->GetSprite()->setTexture(Director::getInstance()->getTextureCache()->addImage("character_stand.png"));
	}
}

void MoveScene::onTouchEnded(Touch *touch, Event *usused_event) {
	Vec2 pos = touch->getLocation();
	if (isTouch&&!character->GetIsJumping())
	{
		character->C_SetXSpeed(pos);	

		for (int i = 0; i < rear; i++) {
			if (!breakedBlock[i])
				if (block[i].GetIsMoved())
				{
					block[i].GetBlockSpr()->runAction(RemoveSelf::create());
					breakedBlock[i] = true;
				}
		}
	}

}

void MoveScene::MakeMap() {
	//블럭 그리기
	for (int i = 0; i < rear; i++)
	{
		block[i].Draw(this);
		breakedBlock[i] = false;
	}	
	//캐릭터 그리기
	character = Character::Create("character_stand.png");
	character->GetSprite()->setPosition(Vec2(block[0].GetBlockSpr()->getPosition().x, block[0].GetBlockSpr()->getPosition().y + 105));
	character->GetSprite()->setScale(0.1f);
	character->GetSprite()->setAnchorPoint(Vec2(0.5f, 0.5f));
	character->Draw(this);
	//도착지점 그리기
	goal_door = Sprite::create("goal_door.png");
	goal_door->setScale(0.4f);
	goal_door->setPosition(Vec2(block[1].GetBlockSpr()->getPosition().x, block[1].GetBlockSpr()->getPosition().y + 90));
	goal_door->setAnchorPoint(Vec2(0.5f, 0.5f));
	addChild(goal_door, 3);
}

void MoveScene::Update(float dt) {
	if (isTouch)
	{
		character->C_Jump();
	}
	for (int i = 0; i < rear; i++)
	{
		if (!block[i].GetIsMoved())
		{
			Rect b = character->GetSprite()->getBoundingBox();
			Rect a = block[i].GetBlockSpr()->getBoundingBox();
			if (a.intersectsRect(b) && character->GetSprite()->getPosition().y > block[i].GetBlockSpr()->getPosition().y)
			{
				isTouch = character->C_Crash(block[i]);

				switch (block[i].GetBlockCode())
				{
				case (int)BlockCode::JumpUp:
					character->JumpUp_B();
					break;
				case (int)BlockCode::JumpDown:
					character->JumpDown_B();
					break;
				case (int)BlockCode::Break:
					character->Break_B(block[i]);
					break;
				case (int)BlockCode::Move:

					break;
				case (int)BlockCode::Arrive:

					break;
				case (int)BlockCode::Goal:
					character->Goal_B();
					break;
				}
			}
		}
	}
	if (character->GetIsClear())
	{
		gameClear = Sprite::create("GameClear.png");
		gameClear->setPosition(Point(640, 360));
		gameClear->setAnchorPoint(Point(0.5f,0.5f));
		addChild(gameClear,4);
		count++;
	}
	if (count == 200)
	{
		*_isClear = true;
		Director::getInstance()->popScene();
	}
}

- MoveScene C Header File
- #ifndef __MoveScene_H__
#define __MoveScene_H__

#include "cocos2d.h"
#include "Character.h"
#include "Block.h"

class MoveScene : public cocos2d::Scene
{
public:
	cocos2d::Sprite *back_button;	//이전버튼 스프라이트

	bool isTouch = false;

	int count = 0;

	bool breakedBlock[24];

	cocos2d::Sprite *goal_door;
	cocos2d::Sprite *gameClear;
	Character *character;

	static cocos2d::Scene* createScene(Block[], int, bool*);

	virtual bool init();

	CREATE_FUNC(MoveScene);

	bool onTouchBegan(cocos2d::Touch *touch, cocos2d::Event *unused_event);
	void onTouchMoved(cocos2d::Touch *touch, cocos2d::Event *unused_event);
	void onTouchEnded(cocos2d::Touch *touch, cocos2d::Event *unused_event);

	void MakeMap();
	void Update(float);
};

#endif // __MoveScene_SCENE_H__

- PlayScene C++ Source File
- #include "PlayScene.h"
//#include "SimpleAudioEngine.h"

USING_NS_CC;

static int _stage;

int stage1[8][4] = { { (int)BlockCode::Start,200,360,1 },{ (int)BlockCode::Goal,1280 - 200,360,1 },{ (int)BlockCode::Normal,0,0,3 } };
int stage2[8][4] = { { (int)BlockCode::Start,200,360,1 },{ (int)BlockCode::Goal,1280 - 200,260,1 },{ (int)BlockCode::Break,0,0,3 } };
int stage3[8][4] = { { (int)BlockCode::Start,200,260,1 },{ (int)BlockCode::Goal,1280 - 200,560,1 },{ (int)BlockCode::Break,0,0,1 },{ (int)BlockCode::JumpUp,0,0,1 } };

Scene* PlayScene::createScene(int stage)
{
	_stage = stage;
	return PlayScene::create();
}

bool PlayScene::init()
{
	if (!Scene::init())
	{
		return false;
	}

	auto visibleSize = Director::getInstance()->getVisibleSize();
	Vec2 origin = Director::getInstance()->getVisibleOrigin();

	//터치하는거
	auto listener = EventListenerTouchOneByOne::create();
	listener->onTouchBegan = CC_CALLBACK_2(PlayScene::onTouchBegan, this);
	listener->onTouchMoved = CC_CALLBACK_2(PlayScene::onTouchMoved, this);
	listener->onTouchEnded = CC_CALLBACK_2(PlayScene::onTouchEnded, this);
	Director::getInstance()->getEventDispatcher()->addEventListenerWithSceneGraphPriority(listener, this);

	//배경화면
	auto background = Sprite::create("background.jpg");
	background->setPosition(Point(0, 0));
	background->setAnchorPoint(Point(0.0f, 0.0f));
	background->setContentSize(visibleSize);
	addChild(background, 0);

	//근경
	auto frontground = Sprite::create("frontground.png");
	frontground->setPosition(Point(0, 0));
	frontground->setAnchorPoint(Point(0.0f, 0.0f));
	frontground->setContentSize(visibleSize);
	addChild(frontground, 1);

	//인벤토리
	blockInventory = Sprite::create("blockInventory.png");
	blockInventory->setPosition(Point(visibleSize.width/2, 0));
	blockInventory->setAnchorPoint(Point(0.5f, 0.0f));
	blockInventory->setScale(0.7f);
	addChild(blockInventory, 2);

	//이전버튼
	back_button = Sprite::create("back_button.png");
	back_button->setPosition(Vec2(1280 - 50, 50));
	back_button->setAnchorPoint(Vec2(0.5f, 0.5f));
	back_button->setScale(0.5f);
	addChild(back_button,3);

	//플레이버튼
	play_button = Sprite::create("play_button.png");
	play_button->setPosition(Vec2(1280 - 150, 50));
	play_button->setAnchorPoint(Vec2(0.5f, 0.5f));
	play_button->setScale(0.5f);
	addChild(play_button, 3);

	//몇스테이지인지 왼쪽상단 출력
	std::string s;
	switch (_stage)
	{
	case 1:
		s = "STAGE1";
		break;
	case 2:
		s = "STAGE2";
		break;
	case 3:
		s = "STAGE3";
		break;
	}
	auto stage = Label::create(s, "Arial", 50);
	stage->setPosition(Vec2(0, visibleSize.height));
	stage->setAnchorPoint(Vec2(0, 1));
	addChild(stage,2);

	//각스테이지에 따른 정해진 맵 생성
	switch (_stage)
	{
	case 1:
		MakeMap(stage1);
		break;
	case 2:
		MakeMap(stage2);
		break;
	case 3:
		MakeMap(stage3);
		break;
	}

	this->schedule(schedule_selector(PlayScene::Update));

	return true;
}

bool PlayScene::onTouchBegan(Touch *touch, Event *unused_event) {
	Vec2 touchPos = touch->getLocation();

	//인벤토리의 블럭이 선택됬는지 확인
	for (int i = 0; i < inven_rear; i++)
	{
		if (inven_b[i].GetBlockSpr()->getBoundingBox().containsPoint(touchPos)&&inven_c[i]>0)
		{
			now_b = i;
			isTouch = true;
			previous = Block::Create(touchPos, inven_b[i].GetBlockCode(), false);
			previous->Draw(this);
		}
	}

	//이전버튼이 눌렸는지 확인
	if (back_button->getBoundingBox().containsPoint(touchPos))
	{
		delete[] block;
		delete[] inven_b;
		Director::getInstance()->popScene();
	}

	//플레이버튼이 눌렸는지 확인
	if (play_button->getBoundingBox().containsPoint(touchPos))
	{
		isClear = false;
		auto Scene = TransitionCrossFade::create(0.5f, MoveScene::createScene(block, block_rear,&isClear));
		Director::getInstance()->pushScene(Scene);
	}
	return true;
}

void PlayScene::onTouchMoved(Touch *touch, Event *usused_event) {
	Vec2 touchPos = touch->getLocation();
	//설치할 블럭 이동
	if (isTouch)
		previous->SetPosition(touchPos);
}

void PlayScene::onTouchEnded(Touch *touch, Event *usused_event) {
	Vec2 touchPos = touch->getLocation();

	//블럭을 놓을때
	if (isTouch)
	{
		//블럭이 다른블럭과 충돌시 설치를 취소
		if (!isCrash(*previous))
		{
			block[block_rear] = *Block::Create(touchPos,inven_b[now_b].GetBlockCode(),true);
			block[block_rear++].Draw(this);
			inven_c[now_b]--;//인벤에 블럭의 갯수 줄이기
			invenCount[now_b]->setString("X" + IntToString(inven_c[now_b]));
		}
		previous->GetBlockSpr()->runAction(RemoveSelf::create());
		isTouch = false;
	}
}

void PlayScene::MakeMap(int MapArr[8][4]) {
	//시작블럭
	block[block_rear] = *Block::Create(Vec2(MapArr[0][1], MapArr[0][2]), MapArr[0][0], true);
	block[block_rear++].Draw(this);
	//캐릭터표시
	character = Character::Create("character_stand.png");
	character->GetSprite()->setPosition(Vec2(block[block_rear - 1].GetBlockSpr()->getPosition().x, block[block_rear - 1].GetBlockSpr()->getPosition().y + 105));
	character->GetSprite()->setScale(0.1f);
	character->GetSprite()->setAnchorPoint(Vec2(0.5f, 0.5f));
	character->Draw(this);
	//도착블럭
	block[block_rear] = *Block::Create(Vec2(MapArr[1][1], MapArr[1][2]), MapArr[1][0], true);
	block[block_rear++].Draw(this);
	//골표시
	goal_door = Sprite::create("goal_door.png");
	goal_door->setScale(0.4f);
	goal_door->setPosition(Vec2(block[block_rear - 1].GetBlockSpr()->getPosition().x, block[block_rear - 1].GetBlockSpr()->getPosition().y+90));
	goal_door->setAnchorPoint(Vec2(0.5f, 0.5f));
	addChild(goal_door,3);

	//인벤에 블럭추가
	for (int i = 2; i < 8; i++)
	{
		if (MapArr[i][0])
		{
			inven_b[inven_rear] = *Block::Create(Vec2(289 + inven_rear * 136, 69), MapArr[i][0], false);
			inven_c[inven_rear] = MapArr[i][3];
			invenCount[inven_rear] = Label::create("X" + IntToString(inven_c[inven_rear]),"Arial",20);
			invenCount[inven_rear]->setPosition(Vec2(289 + inven_rear * 136, 129));
			invenCount[inven_rear]->setColor(Color3B(0, 0, 0));
			addChild(invenCount[inven_rear],3);
			inven_b[inven_rear++].Draw(this);
		}
	}
}

bool PlayScene::isCrash(Block previous) {
	Rect b = previous.GetBlockSpr()->getBoundingBox();
	//설치된 블럭과 충돌확인
	for (int i = 0; i < block_rear; i++)
	{
		Rect a = block[i].GetBlockSpr()->getBoundingBox();
		if (a.intersectsRect(b))
			return true;
	}
	//인벤토리와 충돌확인
	if (blockInventory->getBoundingBox().intersectsRect(b))
		return true;
	//캐릭터와 충돌확인
	if (character->GetSprite()->getBoundingBox().intersectsRect(b))
		return true;
	//도착지점과 충돌확인
	if (goal_door->getBoundingBox().intersectsRect(b))
		return true;
	//플레이버튼과 충돌확인
	if (play_button->getBoundingBox().intersectsRect(b))
		return true;
	//이전버튼과 충돌확인
	if (back_button->getBoundingBox().intersectsRect(b))
		return true;
	return false;
}

std::string PlayScene::IntToString(int num) {
	std::string s;
	int n = num % 10;
	s = n + 48;
	if (num / 10)
		return IntToString(num / 10) + s;
	return s;
}

void PlayScene::Update(float dt) {
	if (isClear)
		Director::getInstance()->popScene();
}

- PlayScene C Header File
- #ifndef __PlayScene_H__
#define __PlayScene_H__

#include "cocos2d.h"
#include "MoveScene.h"
#include "Character.h"
#include "Block.h"



class PlayScene : public cocos2d::Scene
{
public:
	int inven_rear = 0;	//인벤토리의 마지막공간위치
	int block_rear = 0; //블럭의 마지막공간위치
	int now_b = 0;		//현재 선택된 블럭의 위치
	bool isTouch = false;//인벤토리의 블럭을 눌렀는지 확인
	bool isClear = false;

	cocos2d::Sprite *blockInventory;//인벤토리 스프라이트
	cocos2d::Sprite *back_button;	//이전버튼 스프라이트
	cocos2d::Sprite *play_button;	//플레이버튼 스프라이트
	cocos2d::Sprite *goal_door;

	Block *previous;	//블럭 설치시 선택된 블럭

	Block *block = new Block[24];	//설치된 블럭

	Block *inven_b = new Block[6];	//인벤토리 블럭
	int inven_c[6];					//인벤토리 블럭의 갯수
	cocos2d::Label *invenCount[6];	//블럭의 갯수 라벨
	
	Character *character;

	static cocos2d::Scene* createScene(int);

	virtual bool init();

	CREATE_FUNC(PlayScene);

	bool onTouchBegan(cocos2d::Touch *touch, cocos2d::Event *unused_event);
	void onTouchMoved(cocos2d::Touch *touch, cocos2d::Event *unused_event);
	void onTouchEnded(cocos2d::Touch *touch, cocos2d::Event *unused_event);

	void MakeMap(int [8][4]);	//맵생성
	bool isCrash(Block);		//블럭끼리 충돌확인
	std::string IntToString(int num);//int형을 string형으로
	void Update(float);
};

#endif // __PlayScene_SCENE_H__

- stage C++ Source File
- #include "Stage.h"
#include "PlayScene.h"
#include "SimpleAudioEngine.h"

USING_NS_CC;
int stage;

Scene* StageScene::createScene(int _stage)
{
	stage = _stage;
	return StageScene::create();
}

bool StageScene::init()
{
	if (!Scene::init())
	{
		return false;
	}

	auto visibleSize = Director::getInstance()->getVisibleSize();
	Vec2 origin = Director::getInstance()->getVisibleOrigin();

	auto listener = EventListenerTouchOneByOne::create();
	listener->onTouchBegan = CC_CALLBACK_2(StageScene::onTouchBegan, this);
	listener->onTouchMoved = CC_CALLBACK_2(StageScene::onTouchMoved, this);
	listener->onTouchEnded = CC_CALLBACK_2(StageScene::onTouchEnded, this);
	Director::getInstance()->getEventDispatcher()->addEventListenerWithSceneGraphPriority(listener, this);
	if (stage == 1)
	{
		stage1 = Sprite::create("stage1.png");
		stage1->setPosition(Point(visibleSize.width / 2 - 400, visibleSize.height / 2));
		stage1->setAnchorPoint(Point(0.5f, 0.5f));
		this->addChild(stage1);

		stage2 = Sprite::create("stage2.png");
		stage2->setPosition(Point(visibleSize.width / 2, visibleSize.height / 2));
		stage2->setAnchorPoint(Point(0.5f, 0.5f));
		this->addChild(stage2);

		stage3 = Sprite::create("stage3.png");
		stage3->setPosition(Point(visibleSize.width / 2 + 400, visibleSize.height / 2));
		stage3->setAnchorPoint(Point(0.5f, 0.5f));
		this->addChild(stage3);
	}
	//이전버튼
	back_button = Sprite::create("back_button.png");
	back_button->setPosition(Vec2(1280 - 50, 50));
	back_button->setAnchorPoint(Vec2(0.5f, 0.5f));
	back_button->setScale(0.5f);
	addChild(back_button, 3);
	if (stage == 2)
	{
		auto ComingSoon = Sprite::create("ComingSoon.png");
		ComingSoon->setPosition(Point(visibleSize.width / 2, visibleSize.height / 2));
		ComingSoon->setAnchorPoint(Point(0.5f, 0.5f));
		addChild(ComingSoon,3);
	}
	return true;
}

bool StageScene::onTouchBegan(Touch *touch, Event *unused_event) {
	Vec2 location = touch->getLocation();
	if (back_button->getBoundingBox().containsPoint(location))
	{
		Director::getInstance()->popScene();
	}
	if (stage == 1)
	{
		if (stage1->getBoundingBox().containsPoint(location))
		{
			auto Scene = TransitionCrossFade::create(0.5f, PlayScene::createScene(1));
			Director::getInstance()->pushScene(Scene);
		}
		if (stage2->getBoundingBox().containsPoint(location))
		{
			auto Scene = TransitionCrossFade::create(0.5f, PlayScene::createScene(2));
			Director::getInstance()->pushScene(Scene);
		}
		if (stage3->getBoundingBox().containsPoint(location))
		{
			auto Scene = TransitionCrossFade::create(0.5f, PlayScene::createScene(3));
			Director::getInstance()->pushScene(Scene);
		}
	}
	return true;
}

void StageScene::onTouchMoved(Touch *touch, Event *usused_event) {
	
}

void StageScene::onTouchEnded(Touch *touch, Event *usused_event) {

}

- stage C Header File
- #pragma once
#ifndef __STAGEScene_H__
#define __STAGEScene_H__

#include "cocos2d.h"

class StageScene : public cocos2d::Scene
{
public:
	static cocos2d::Scene* createScene(int);

	virtual bool init();

	CREATE_FUNC(StageScene);

	cocos2d::Sprite *stage1;
	cocos2d::Sprite *stage2;
	cocos2d::Sprite *stage3;

	cocos2d::Sprite *back_button;

	bool onTouchBegan(cocos2d::Touch *touch, cocos2d::Event *unused_event);
	void onTouchMoved(cocos2d::Touch *touch, cocos2d::Event *unused_event);
	void onTouchEnded(cocos2d::Touch *touch, cocos2d::Event *unused_event);
};

#endif // __StageScene_H__

- StageScene C++ Source File
- #include "StageScene.h"
#include "SimpleAudioEngine.h"
#include <iostream>
#include <string>
USING_NS_CC;

Scene* Stage::createScene()
{
	return Stage::create();
}

bool Stage::init()
{

	if (!Scene::init())	
	{
		return false;
	}


	auto visibleSize = Director::getInstance()->getVisibleSize();
	Vec2 origin = Director::getInstance()->getVisibleOrigin();

	auto listener = EventListenerTouchOneByOne::create();
	
	listener->onTouchBegan = CC_CALLBACK_2(Stage::OnTouchBegan, this);
	listener->onTouchMoved = CC_CALLBACK_2(Stage::OnTouchMoved, this);
	listener->onTouchEnded = CC_CALLBACK_2(Stage::OnTouchEnded, this);

	stage1 = Sprite::create("stage.png");
	stage1->setPosition(Point(visibleSize.width / 2 - 360, visibleSize.height / 2+130));
	stage1->setAnchorPoint(Point(0.5f, 0.5f));
	this->addChild(stage1,13);

	stage2 = Sprite::create("stage.png");
	stage2->setPosition(Point(visibleSize.width / 2 + 80, visibleSize.height / 2 - 130));
	stage2->setAnchorPoint(Point(0.5f, 0.5f));
	this->addChild(stage2,13);

	stage3 = Sprite::create("stage.png");
	stage3->setPosition(Point(visibleSize.width / 2 + 510, visibleSize.height / 2+150));
	stage3->setAnchorPoint(Point(0.5f, 0.5f));
	this->addChild(stage3,13);

	_eventDispatcher->addEventListenerWithSceneGraphPriority(listener, this);

	map = Sprite::create("traveler_map.jpg");
	map->setContentSize(Size(visibleSize.width*1.5f, visibleSize.height));
	map->setPosition(0, visibleSize.height / 2);
	map->setAnchorPoint(Point(0.0f, 0.5f));
	addChild(map, 10);
	map->setVisible(false);
	//log(std::to_string(GameScreen.getMaxX()).c_str());
	title = Sprite::create("traveler_title.jpg");
	title->setContentSize(visibleSize);
	title->setAnchorPoint(Point(0,0));
	addChild(title, 11);
	this->scheduleOnce(schedule_selector(Stage::Intro), 0.1f);

	return true;
}

bool Stage::OnTouchBegan(Touch* touch, Event *e) {
	Vec2 touchPosition = touch->getLocation();
	if (map->getBoundingBox().containsPoint(touchPosition)) {
		istouch = true;
	}
	if (stage1->getBoundingBox().containsPoint(touchPosition))
		stageTouch[0] = true;
	if (stage2->getBoundingBox().containsPoint(touchPosition))
		stageTouch[1] = true;
	if (stage3->getBoundingBox().containsPoint(touchPosition))
		stageTouch[2] = true;
	return true;
	return false;
}

void Stage::OnTouchMoved(Touch* touch, Event *e) {

	int res = touch->getPreviousLocation().x - touch->getLocation().x;
	if (istouch) {
		if (map->getPosition().x > 0 || map->getPosition().x < -640) {
			if (map->getPosition().x > 0)
			{
				stage1->setPosition(640 - 360, stage1->getPosition().y);
				stage2->setPosition(640 + 80, stage2->getPosition().y);
				stage3->setPosition(640 + 510, stage3->getPosition().y);
				map->setPosition(0, map->getPosition().y);
			}
			else
			{
				map->setPosition(-640, map->getPosition().y);
				stage1->setPosition(0 - 360, stage1->getPosition().y);
				stage2->setPosition(0 + 80, stage2->getPosition().y);
				stage3->setPosition(0 + 510, stage3->getPosition().y);
			}
		}
		map->setPosition(map->getPosition().x - res, map->getPosition().y);
		stage1->setPosition(stage1->getPosition().x - res, stage1->getPosition().y);
		stage2->setPosition(stage2->getPosition().x - res, stage2->getPosition().y);
		stage3->setPosition(stage3->getPosition().x - res, stage3->getPosition().y);
	}
}	

void Stage::OnTouchEnded(Touch* touch, Event *e) {
	Vec2 location = touch->getLocation();
	istouch = false;
	if (stage1->getBoundingBox().containsPoint(location)&&stageTouch[0])
	{
		auto Scene = TransitionCrossFade::create(0.5f, StageScene::createScene(1));
		Director::getInstance()->pushScene(Scene);
	}
	if (stage2->getBoundingBox().containsPoint(location) && stageTouch[1])
	{
		auto Scene = TransitionCrossFade::create(0.5f, StageScene::createScene(2));
		Director::getInstance()->pushScene(Scene);
	}
	if (stage3->getBoundingBox().containsPoint(location) && stageTouch[2])
	{
		//auto Scene = TransitionCrossFade::create(0.5f, PlayScene::createScene(3));
		//Director::getInstance()->pushScene(Scene);
	}
	stageTouch[0] = false;
	stageTouch[1] = false;
	stageTouch[2] = false;
}

void Stage::Intro(float dt) {

	/*for (; Opacity != 0;) {
		this->runAction(action_1->clone());
		title->setOpacity(Opacity--);
	}

	this->removeChild(title, true);*/

	title->runAction(Sequence::create(
		FadeOut::create(3.0f),
		RemoveSelf::create(),
		nullptr
	));
	map->runAction(Sequence::create(
		DelayTime::create(3.0f),
		Show::create(),
		nullptr
	));
}
  
- StageScene C Header File
- #ifndef __STAGE_SCENE_H__
#define __STAGE_SCENE_H__

#include "cocos2d.h"
#include "stage.h"

class Stage : public cocos2d::Scene
{
public:

	static cocos2d::Scene* createScene();

	virtual bool init();
	bool OnTouchBegan(cocos2d::Touch*, cocos2d::Event*);
	void OnTouchMoved(cocos2d::Touch*, cocos2d::Event*);
	void OnTouchEnded(cocos2d::Touch*, cocos2d::Event*);
	void Intro(float);
	
	//void OverMoved(float);

	bool stageTouch[3] = { false,false,false };

	cocos2d::Sprite *stage1;
	cocos2d::Sprite *stage2;
	cocos2d::Sprite *stage3;

	bool istouch;
	cocos2d::Sprite *map;
	cocos2d::Sprite *title;
	CREATE_FUNC(Stage);
};

#endif
  
- StartScene C++ Source File
- #include "StartScene.h"
#include "SimpleAudioEngine.h"
#include <numeric>
#include "StageScene.h"	

USING_NS_CC;

Scene* StartScene::createScene()
{
	return StartScene::create();
}

bool StartScene::init()
{
	
	if (!Scene::init())
	{
		return false;
	}

	auto visibleSize = Director::getInstance()->getVisibleSize();
	//Vec2 origin = Director::getInstance()->getVisibleOrigin();

	auto title = Sprite::create("traveler_title.jpg");
	title->setAnchorPoint(Vec2(0.5, 0.5));
	title->setPosition(visibleSize.width / 2, visibleSize.height / 2);
	title->setContentSize(visibleSize);
	this->addChild(title);

	this->scheduleOnce(schedule_selector(StartScene::ChangeScene), 0.0f);
	return true;
}

void StartScene::ChangeScene(float dt) {
	auto scene = TransitionFade::create(3.0f, Stage::createScene());
	Director::getInstance()->replaceScene(scene);
}
  
- StartScene C Header File
- #ifndef __START_SCENE_H__
#define __START_SCENE_H__

#include "cocos2d.h"

class StartScene : public cocos2d::Scene
{
public:
	static cocos2d::Scene* createScene();

	virtual bool init();
	//void Replace();

	CREATE_FUNC(StartScene);
	void ChangeScene(float);
};

#endif