1. *

2. 지금까지

3. 만든것은

4. 게임

5. 오브젝트를

6. 터치로

7. 이동시켜서

8. 게임

9. 오브젝트
를

10. 교환하는

11. 부분밖에

12. 없음
*

13. 7-1에서는

14. 게임

15. 오브젝트를

16. 이동시켰을

17. 때

18. 같은

19. 색상의

20. 게임

21. 오브젝트
가

22. 3개

23. 이상

24. 나열되어

25. 매칭되면

26. 오브젝트를

27. 삭제하는

28. 기능

29. 구현
void

30. GameObject::SlidingCompleteHandler()
{

34. int

35. x1

36. =

37. m_prevBoardX;

41. int

42. y1

43. =

44. m_prevBoardY;

48. int

49. x2

50. =

51. m_targetBoardX;

55. int

56. y2

57. =

58. m_targetBoardY;

66. m_pGameLayer-SlidingFinished(x1,

67. y1,

68. x2,

69. y2);
}
void

70. GameObject::SetGameLayer(GameLayer*

71. pGameLayer)
{

75. m_pGameLayer

76. =

77. pGameLayer;
}
void

78. GameLayer::StartGame()
{

82. srand(time(NULL));

90. for

91. (int

92. x=0;

93. xCOLUMN_COUNT;

94. ++x)

95. {

103. for

104. (int

105. y=0;

106. yROW_COUNT;

107. ++y)

108. {

120. int

121. type

122. =

123. rand()

124. %

125. TYPE_COUNT;

149. GameObject*

150. pGameObject

151. =

152. GameObject::Create(type);

164. m_pBoard[x][y]

165. =

166. pGameObject;

190. pGameObject-setAnchorPoint(ccp(0,

191. 1));

203. pGameObject-setPosition(Common::ComputeXY(x,

204. y));

216. pGameObject-SetGameLayer(this);

228. addChild(pGameObject,

229. zGameObject);

237. }

241. }

249. m_bTouchStarted

250. =

251. false;

255. m_numOfSlidingObjects

256. =

257. 0;
}
*

258. 이제

259. 실제로

260. 게임

261. 오브젝트가

262. 이동을

263. 완료했을

264. 때의

265. 처리를

266. 구현
class

267. GameLayer

268. :

269. public

270. CCLayer
{
public:

274. void

275. SlidingFinished(int

276. x1,

277. int

278. y1,

279. int

280. x2,

281. int

282. y2);
protected:

286. //

287. 이동

288. 중인

289. 오브젝트의

290. 수

294. int

295. m_numOfSlidingObjects;
*

296. 이동중인

297. 오브젝트의

298. 수는

299. 왜

300. 저장하는걸까?

301. 게임오브젝트를

302. 이동시키
면

303. 하나만

304. 이동되는게

305. 아니고

306. 2개의

307. 오브젝트가

308. 이동함.

309. 하지만

310. 한번의

311.
이벤트만

312. 처리하면

313. 되기

314. 때문에

315. 모든

316. 오브젝트의

317. 이동이

318. 완료된

319. 후

320. 한번
만

321. 이벤트를

322. 처리하기

323. 위해서.
void

324. GameLayer::SlidingFinished(int

325. x1,

326. int

327. y1,

328. int

329. x2,

330. int

331. y2)
{

335. --m_numOfSlidingObjects;

339. if

340. (m_numOfSlidingObjects

341. ==

342. 0)

343. {

356. }
}
void

357. GameLayer::SwapObjects(int

358. x1,

359. int

360. y1,

361. int

362. x2,

363. int

364. y2)
{

368. m_numOfSlidingObjects

369. =

370. 2;

374. ...
}
*

375. 오브젝트

376. 이동이

377. 완료되면

378. 한번만

379. 매칭

380. 로직이

381. 수행되도록

382. 만들었음.

383.
실제

384. 매칭

385. 로직을

386. 계속

387. 만들어보자.
void

388. GameLayer::SlidingFinished(int

389. x1,

390. int

391. y1,

392. int

393. x2,

394. int

395. y2)
{

399. --m_numOfSlidingObjects;

403. if

404. (m_numOfSlidingObjects

405. ==

406. 0)

411. {

419. if

420. (IsStreak(x1,

421. y1)

422. ||

423. IsStreak(x2,

424. y2))

434. {

446. //

447. 매칭된

448. 줄은

449. 삭제한다.

461. if

462. (IsStreak(x1,

463. y1))

476. {

492. RemoveObject(x1,

493. y1);

505. }

529. if

530. (IsStreak(x2,

531. y2))

544. {

560. RemoveObject(x2,

561. y2);

573. }

581. }

585. }
}
bool

586. GameLayer::IsStreak(int

587. x,

588. int

589. y)
{

593. return

594. StreakHorz(x,

595. y)

597. 2

598. ||

599. StreakVert(x,

600. y)

602. 2;
}
int

603. GameLayer::StreakHorz(int

604. x,

605. int

606. y)
{

610. if

611. (x

613. 0

614. ||

615. x

616. =

617. COLUMN_COUNT)

618. {

626. return

627. 0;

631. }

639. if

640. (y

642. 0

643. ||

644. y

645. =

646. ROW_COUNT)

647. {

655. return

656. 0;

660. }

668. GameObject*

669. pCurrentGameObject

670. =

671. m_pBoard[x][y];

675. if

676. (pCurrentGameObject

677. ==

678. NULL)

679. {

687. return

688. 0;

692. }

700. int

701. streak

702. =

703. 1;

707. int

708. temp

709. =

710. x;

718. //

719. 왼쪽으로

720. 검사해나감

724. while

725. (CheckType(pCurrentGameObject-GetType(),

726. temp

727. -

728. 1,

729.
y))

730. {

738. --temp;

746. ++streak;

750. }

758. temp

759. =

760. x;

764. //

765. 오른쪽으로

766. 검사해나감

770. while

771. (CheckType(pCurrentGameObject-GetType(),

772. temp

773. +

774. 1,

775.
y))

776. {

784. ++temp;

792. ++streak;

796. }

804. return

805. streak;
}
bool

806. GameLayer::CheckType(int

807. type,

808. int

809. x,

810. int

811. y)
{

815. if

816. (x

818. 0

819. ||

820. x

821. =

822. COLUMN_COUNT)

823. {

831. return

832. false;

836. }

844. if

845. (y

847. 0

848. ||

849. y

850. =

851. ROW_COUNT)

852. {

860. return

861. false;

865. }

873. if

874. (m_pBoard[x][y]

875. ==

876. NULL)

877. {

885. return

886. false;

890. }

898. return

899. type

900. ==

901. m_pBoard[x][y]-GetType();
}
int

902. GameLayer::StreakVert(int

903. x,

904. int

905. y)
{

909. if

910. (x

912. 0

913. ||

914. x

915. =

916. COLUMN_COUNT)

917. {

925. return

926. 0;

930. }

938. if

939. (y

941. 0

942. ||

943. y

944. =

945. ROW_COUNT)

946. {

954. return

955. 0;

959. }

967. GameObject*

968. pCurrentGameObject

969. =

970. m_pBoard[x][y];

974. if

975. (pCurrentGameObject

976. ==

977. NULL)

978. {

986. return

987. 0;

991. }

999. int

1000. streak

1001. =

1002. 1;

1006. int

1007. temp

1008. =

1009. y;

1017. //

1018. 위쪽으로

1019. 검사해나감

1023. while

1024. (CheckType(pCurrentGameObject-GetType(),

1025. x,

1026. temp

1027. -

1028.
1))

1029. {

1037. --temp;

1045. ++streak;

1049. }

1057. temp

1058. =

1059. y;

1067. //

1068. 아래쪽으로

1069. 검사해나감

1073. while

1074. (CheckType(pCurrentGameObject-GetType(),

1075. x,

1076. temp

1077. +

1078.
1))

1079. {

1087. ++temp;

1095. ++streak;

1099. }

1107. return

1108. streak;
}
*

1109. 매칭을

1110. 검사하는

1111. 함수는

1112. 만들었으니,

1113. 이제

1114. 게임

1115. 오브젝트를

1116. 제거하는

1117.
함수인

1118. RemoveObject

1119. 함수를

1120. 만들어

1121. 보겠음.
void

1122. GameLayer::RemoveObject(int

1123. x,

1124. int

1125. y)
{

1129. int

1130. currentType

1131. =

1132. m_pBoard[x][y]-GetType();

1136. int

1137. temp;

1145. std::vectorGameObject*

1146. removedObjects;

1154. GameObject*

1155. pGameObject

1156. =

1157. m_pBoard[x][y];

1161. removedObjects.push_back(pGameObject);

1169. if

1170. (StreakHorz(x,

1171. y)

1173. 2)

1174. {

1182. temp

1183. =

1184. x;

1192. while

1193. (CheckType(currentType,

1194. temp-1,

1195. y))

1196. {

1208. pGameObject

1209. =

1210. m_pBoard[temp-1][y];

1222. removedObjects.push_back(pGameObject);

1234. --temp;

1242. }

1258. temp

1259. =

1260. x;

1276. while

1277. (CheckType(currentType,

1278. temp+1,

1279. y))

1280. {

1292. pGameObject

1293. =

1294. m_pBoard[temp+1][y];

1306. removedObjects.push_back(pGameObject);

1318. ++temp;

1326. }

1330. }

1338. if

1339. (StreakVert(x,

1340. y)

1342. 2)

1343. {

1351. temp

1352. =

1353. y;

1361. while

1362. (CheckType(currentType,

1363. x,

1364. temp-1))

1365. {

1377. pGameObject

1378. =

1379. m_pBoard[x][temp-1];

1391. removedObjects.push_back(pGameObject);

1403. --temp;

1411. }