[Unity3D] 헥사게임 만들기 세 번째 - 블럭 처리.

※ 소스 출처 : 네이버 카페 - 유니티 허브 - 햐얀바람님.

0. 리소스 준비하기.

1). 배경 이미지.

2). 블럭보드의 배경 이미지.

3). UI테두리 이미지.

4). 블럭 이미지.

1. 캔버스 크기 설정하기.

- 게임뷰어 및 캔버스 크기 설정.

2.  블럭보드 만들기.

1). 블럭 프리팹 만들기.

2). 배경 이미지 깔기.

3). 블럭배경 이미지 깔기.

4). 스크립트로 블럭 만들기.

3.  블럭 처리.

1). 가로 및 세로 체크 함수 만들기.

2). 매치된 블럭이 있는지 없는지 체크하는 함수 만들기.

3). 블럭 삭제 함수 만들기.

4). 떨어지는 블럭 함수 만들기.

4.  마우스 처리.

1). 마우스 클릭처리 함수 만들기.

2). 마우스 방향에 따른 블럭 가져오는 함수 만들기.

3). 선택된 블럭을 마우스가 이동한 방향에 있는 블럭과 교환(이동)시키는 함수 만들기.

4). 선택된 블럭과 이동 방향에 존재하는 블럭의 위치 교환 및 타입교환하는 함수 만들기.

5). 블럭 교환 후 매치된 블럭이 없을 때 다시 교환 시켜주는 함수 만들기.

-------------------------------------------------------------------------------------------

3.  블럭 처리.

이번 글에서 하고자하는 내용은 체크 및 삭제 입니다.

3개이상의 연속된 블럭이 있는지 체크하고 그 블럭을 삭제하는 것입니다.

이번에 짤 스크립트는 그에 관한 내용입니다.

1,2) 블럭체크 및 블럭매치 함수 코딩.

3). 블럭삭제 함수 코딩.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
public class GameManager : MonoBehaviour {
 
    public GameObject OriginBlock;      // 블럭의 원본.
    public Sprite[] BlockType;          // 블럭 이미지 배열.
    
    public int iBlockX, iBlockY;        // 블럭보드의 가로 세로 크기.
    public int[][] BlockBoard;          // 블럭보드.
 
    void Awake()
    {
        BlockBoard = new int[iBlockX][];
        for (int i = 0; i < iBlockX; i++)
            BlockBoard[i] = new int[iBlockY];
 
        CreateBlock();
    }
 
    // 블럭을 만들어주는 함수.
    void CreateBlock()
    {
        for (int y = 0; y < iBlockY; y++)
        {
            for (int x = 0; x < iBlockX; x++)
            {
                GameObject block = Instantiate(OriginBlock, new Vector3(x, y, 0), Quaternion.identity);
                block.transform.SetParent(transform);
 
                int iType = Random.Range(0, BlockType.Length);
 
                Block sBlock = block.GetComponent<Block>();
                sBlock.iX = x;
                sBlock.iY = y;
                sBlock.iType = iType;
                sBlock.SetBlockImg(BlockType[iType]);
 
                BlockBoard[x][y] = iType;
            }
        }
 
        StartCoroutine(BlockCheck());
    }
 
    IEnumerator BlockCheck()
    {
        // 가로체크.
        for (int y = 0; y < iBlockY; y++)
        {
            for (int x = 0; x < iBlockX - 2; x++)
            {
                if (BlockBoard[x][y] == BlockBoard[x + 1][y])
                {
                    if (BlockBoard[x][y] == BlockBoard[x + 2][y])
                    {
                        GameObject[] blocks = GameObject.FindGameObjectsWithTag("BLOCK");
 
                        foreach (GameObject block in blocks)
                        {
                            Block sBlock = block.GetComponent<Block>();
 
                            if (sBlock.iY != y)
                                continue;
 
                            if (sBlock.iX == x && sBlock.iY == y)
                            {
                                sBlock.bDead = true;
                                continue;
                            }
 
                            if (sBlock.iX == x + 1 && sBlock.iY == y)
                            {
                                sBlock.bDead = true;
                                continue;
                            }
 
                            if (sBlock.iX == x + 2 && sBlock.iY == y)
                                sBlock.bDead = true;
                        }
                    }
                }
            }
        }
 
        // 세로체크.
        for (int x = 0; x < iBlockX; x++)
        {
            for (int y = 0; y < iBlockY - 2; y++)
            {
                if (BlockBoard[x][y] == BlockBoard[x][y + 1])
                {
                    if (BlockBoard[x][y] == BlockBoard[x][y + 2])
                    {
                        GameObject[] blocks = GameObject.FindGameObjectsWithTag("BLOCK");
 
                        foreach (GameObject block in blocks)
                        {
                            Block sBlock = block.GetComponent<Block>();
 
                            if (sBlock.iX != x)
                                continue;
 
                            if (sBlock.iX == x && sBlock.iY == y)
                            {
                                sBlock.bDead = true;
                                continue;
                            }
 
                            if (sBlock.iX == x && sBlock.iY == y + 1)
                            {
                                sBlock.bDead = true;
                                continue;
                            }
 
                            if (sBlock.iX == x && sBlock.iY == y + 2)
                                sBlock.bDead = true;
                        }
                    }
                }
            }
        }
 
        // 매치된 블럭이 없으면.
        if (!NoMatch())
        {
            Debug.Log("매치된게 없음.");
 
        }
        // 매치된 블럭이 있으면.
        else
        {
            // 요 위치에서 애니메이션 실행.
            yield return new WaitForSeconds(0.2f);
            // 매치된 블럭을 체크하여 삭제.
            Debug.Log("매치된게 있음.");
        }
    }
 
    // 블럭중 매치된 블럭이 있는지.
    bool NoMatch()
    {
        GameObject[] blocks = GameObject.FindGameObjectsWithTag("BLOCK");
 
        foreach (GameObject block in blocks)
        {
            if (block.GetComponent<Block>().bDead)
                return true;
        }
 
        return false;
    }
}

1. 블럭보드 전체를 체크하면서 3개 이상의 연속된 블럭이 있는지 찾고, 연속된 블럭이면 체크(삭제해야할 블럭이라고 마킹(bDead))한다.

=> BlockCheck() 코루틴.

블럭체크 코루틴에서는 가로체크와 세로체크의 기능을 따로 분리해서 체크했습니다.

그 편이 가독성이 좋기 때문이죠.

우선 가로체크부터 보도록 합시다.

// 가로체크.
for (int y = 0; y < iBlockY; y++)
{
    for (int x = 0; x < iBlockX - 2; x++)
    {   // 기준칸과 기준칸 + 1칸을 비교 검사.
        if (BlockBoard[x][y] == BlockBoard[x + 1][y])
        {   // 기준칸과 기준칸 + 2칸을 비교 검사.
            if (BlockBoard[x][y] == BlockBoard[x + 2][y])
            {
                GameObject[] blocks = GameObject.FindGameObjectsWithTag("BLOCK");
 
                foreach (GameObject block in blocks)
                {
                    Block sBlock = block.GetComponent<Block>();
 
                    if (sBlock.iY != y)
                        continue;
 
                    if (sBlock.iX == x && sBlock.iY == y)
                    {
                        sBlock.bDead = true;
                        continue;
                    }
 
                    if (sBlock.iX == x + 1 && sBlock.iY == y)
                    {
                        sBlock.bDead = true;
                        continue;
                    }
 
                    if (sBlock.iX == x + 2 && sBlock.iY == y)
                        sBlock.bDead = true;
                }
            }
        }
    }
}

x는 열, y는 행으로 으로 보시면 되겠습니다.

0번째 행 0번째 열에는 2라는 값이 있습니다.

이 2라는 값이 연속되는지 확인하기 위해 위치(0,0) 기준으로 +1칸 +2칸째를 검사하도록 하겠습니다.

이런식으로 한칸 한칸을 기준칸으로 해서 +1칸 +2칸째를 검사하고

같다면 3개가 연속되므로 3개의 블럭의 스크립트의 bool변수인 bDead 변수를 true로 변환 합니다.

이렇게 모든 칸들의 블럭들을 체크 해주고, 체크가 끝나면 모든 블럭을 가져와 블럭의 bDead변수를 검사해 true인 블럭들을 삭제해주면 됩니다.

P.S 

연속된 칸이 3칸이 아닌 4칸 이상 이여도 문제 없습니다.

왜냐하면 기준칸이 게속 달라지기 때문입니다. 

한 번 체크가 끝난 칸이라고 해서 체크를 안하는게 아닙니다. 

세로체크도 가로체크와 크게 다르지 않기 때문에 설명을 생략하겠습니다.

2. 전체 블럭을 가져와 체크(마킹)된 블럭이 있는지 찾는다.

=> NoMatch() 함수.

3. 마킹된 블럭 있다면 블럭을 삭제한다.

=> DeleteBlock() 함수.