Code Storage

1654. 랜선 자르기 (C#)

코드봇 — Wed, 3 Sep 2025 17:26:11 +0900

문제

랜선 자르기 | 실버II (2025년 9월 3일 기준)
알고리즘 분류
- 이분 탐색
- 매개 변수 탐색

접근

이 문제는 길이가 제각각인 랜선을 잘라내어 길이가 모두 N으로 동일한 랜선을 필요한 만큼 만들때 N의 최대값을 구하는 문제다.

Parametric Search (매개 변수 탐색)

매개 변수 탐색은 최적화 문제를 결정 문제로 변경하여, 이분탐색을 이용해 문제를 해결하는 것이다. 이 문제에서는 문제에서 주어지는 랜선의 최대 길이가 int 최대값으로 주어지기 때문에 단순히 랜선의 길이를 1 늘리고 줄여 탐색하는 방법으로는 제한시간으로 인해 문제를 해결하기 어렵다. 여기에 '이분 탐색'의 개념을 이용해 보는 것이다.

Parametric Search 적용하기

예제 입력을 생각해보자. 갖고있는 랜선의 최대 길이는 802이다. 이때 만들수 있는 랜선 길이 N의 범위는 1-802 라고 생각해 볼 수 있다. 여기서 가장 많은 랜선을 만들 수 있는 랜선의 길이 N의 최대값을 이분 탐색을 이용해 찾는 것이다.

802의 절반인 401부터 시작해본다.401cm 랜선은 몇개를 만들 수 있는가? 5개다. (802에서 2개 + 743에서 1개 + 457에서 1개 + 539에서 1개) 이는 필요한 랜선의 개수인 11개 보다 적으므로 답이 아니다. 그러므로 401보다 긴 랜선은 정답이 아니라는 것을 알 수 있다!

401의 절반인 200을 고려해본다. 4개 + 3개 + 2개 + 2개 로 정확히 11개의 랜선을 만들 수 있다. 문제의 답은 200이 맞지만 여기서 단정할 수 있을까? 단정하기는 어려워 보인다. 하지만 200보다 짧은 랜선은 정답이 아니라는 것을 알 수 있다!

200과 401의 중간인 300을 고려해본다. 2 + 2 + 1 + 1 = 6개로 필요한 랜선의 개수인 11개 보다 작다. 그러므로 300보다 긴 랜선은 정답이 아니라는 것을 알 수 있다

이런식으로 마치 이분탐색을 하는 것 처럼 점차 정답의 범위를 좁혀 나가 최종적으로 최대값 N을 구할 수 있을 것으로 보인다. 이것이 바로 이분탐색의 응용인 매개 변수 탐색이다.

풀이

static void Main(string[] args)
{
    /* 문제의 입력
     * 첫째 줄 : 랜선의 개수 K, 필요한 랜선의 개수 N
     * K 줄에 걸쳐 이미 가지고 있는 각 랜선의 길이가 정수로 입력(<=2^31 -1)
     */
    string[] input = Console.ReadLine().Split(' ');
    long numOfUTP = int.Parse(input[0]); //가지고 있는 랜선의개수
    long numOfReq = int.Parse(input[1]); //필요한 랜선의 개수
    long[] UTPs = new long[numOfUTP]; //가지고 있는 랜선들의 길이

    long start = 1; //parametric search
    long end = 0; //parametric search

    for (int i = 0; i < numOfUTP; i++)
    {
        UTPs[i] = int.Parse(Console.ReadLine());
        end = Math.Max(end, UTPs[i]);
    }

    //Parametric Search
    //최적화 문제 -> 결정 문제
    //이분탐색
    long unit = 0;
    long sum = 0;
    long ans = 0; //answer 변수 추가
    while (start <= end)// while (lo + 1 < hi) 동안
    {
        unit = (start + end) / 2; //mid = (lo + hi) / 2
        sum = 0;
        for(long i = 0; i< numOfUTP; i++) {
            sum += calcUTPCutting(UTPs[i], unit);
        }
        if (sum < numOfReq)
        {
            end = unit - 1;
        }
        else
        {
            start = unit + 1;
            ans = Math.Max(ans, unit); //쵀대값 기록
        }
    }
    System.Console.WriteLine(ans);
}

sum(만들 수 있는 랜선의 개수) 가 문제에서 주어진 필요한 개수(numOfReq)보다 적은 경우 end를 mid-1로 조정한다. 아닌 경우 start를 mid + 1로 조정하고 현재까지 최대 길이를 기록해둔다. 이분 탐색에서는 start, end, mid, 반복 조건을 잘 생각해야 한다. 어느하나라도 잘못될 경우 정답이 나오지 않거나 루프를 탈출하지 못해 시간초과가 날 수 있다.

// 랜선을 단위 길이로 잘라서 몇개가 나오는지 구하는 함수
static long calcUTPCutting(long length,long unit)
{
    return length / unit;
}

11559. 뿌요뿌요 (C#)

코드봇 — Wed, 3 Sep 2025 13:47:39 +0900

문제

뿌요뿌요 | 골드IV (2025년 9월 2일 기준)
알고리즘 분류
- 구현
- 그래프 이론
- 그래프 탐색
- 시뮬레이션
- 너비 우선 탐색

접근

뿌요뿌요의 규칙

상하좌우로 4개 이상 같은 색상으로 연결된 뿌요가 있다면 연결된 뿌요가 한번에 삭제된다. 뿌요가 삭제되면 위에 있던 뿌요들은 중력의 영향을 받아 떨어지게 된다. 떨어지고 난 뒤 다시 같은 색의 뿌요가 4개 이상 연결된 경우 뿌요가 터지게 되는데, 뿌요들이 내려와서 다시 터짐을 반복할 때 마다 1연쇄씩 늘어난다.

연결된 뿌요 찾기
- BFS로 탐색할 수 있을 것 같다.
4개 이상 연결된 경우에만 뿌요를 삭제
- BFS로 탐색하면서 좌표를 저장해 두었다가 4개 이상 연결된 경우에만 해당 좌표에 있는 뿌요를 삭제하자
뿌요에 중력 적용
- 뿌요 사이의 빈공간이 없이 바닥부터 쌓여 있도록 해야 한다
4개 이상 연결된 뿌요가 없을 때 까지 반복
- 뿌요 그룹 삭제(연쇄+1) -> 중력적용 -> 그룹삭제(연쇄+1) -> 중력 적용 -> ... (반복)
연쇄 카운트 출력

풀이

Main() : 뿌요뿌요 필드를 입력받고 결과를 출력한다

static void Main(string[] args)
{
    /* 입력
     * 12개의 줄에 필드의 정보가 주어짐
     * 각 줄에는 6개의 문자가 있다
     * . 은 빈공간
     * . 이 아닌 것은 각각의 색깔의 뿌요(R,G,B,P,Y)
     * 뿌요 아래에 빈 칸이 있는 경우는 없다
     */

    char[,] map = new char[12, 6];
    for (int i = 0; i < 12; i++)
    {
        string input = Console.ReadLine();

        int colIndex = 0;
        foreach (char item in input.ToCharArray())
        {
            map[i, colIndex] = item;
            colIndex++;
        }


    }
    Console.WriteLine(calcChain(map));
}

calcChain(char[,]) : 뿌요뿌요 맵을 받아서 연쇄를 계산하여 반환한다

static int calcChain(char[,] map)
{
    int result = 0;
    /*1. 상하좌우로 연결된 뿌요 확인 및 삭제
     * -> 4개 이상 연결된 뿌요가 있으면 삭제, result++
     *2. 각 뿌요에 중력 적용 -> 공중에 떠있는 뿌요가 없을 때 까지
     *3. 4개 이상 연결된 뿌요가 없을때 까지 반복
     */
    while (removeGroup(map))
    {
        result++;
        applyGravity(map);
    }
    return result;
}

removeGroup(char[,]) 4개 이상 인접한 뿌요를 BFS로 탐색하고 제거한다. 제거한 뿌요가 있는 경우 true를 반환한다

static bool removeGroup(char[,] map)
{
    bool result = false;
    bool[,] visited = new bool[12, 6];

    //4개 이상 그룹된 뿌요가 있는지 확인 및 그룹 삭제
    //BFS로 탐색
    for (int i = 0; i < 12; i++)
    {
        for (int j = 0; j < 6; j++)
        {
            if (map[i, j] == '.' || visited[i, j]) continue;

            int count = 0;
            char color = map[i, j]; //시작 지점 색상

            //BFS
            Queue<Point> queue = new Queue<Point>();
            Stack<Point> stack = new Stack<Point>();

            queue.Enqueue(new Point(i, j));
            visited[i, j] = true;
            stack.Push(new Point(i, j));
            while (queue.Any())
            {
                Point curr = queue.Dequeue();

                count++;

                Point[] cardinates = new Point[4]
                {
                    new Point(curr.row + 1, curr.col),
                    new Point(curr.row - 1, curr.col),
                    new Point(curr.row, curr.col + 1),
                    new Point(curr.row, curr.col - 1)
                };
                foreach (Point p in cardinates)
                {
                    if (p.row >= 0 && p.col >= 0 && p.row < 12 && p.col < 6 && !visited[p.row, p.col] && map[p.row, p.col] == color) //유효한 좌표 & 방문하지 않은 좌표 & 같은 색상의 좌표
                    {
                        queue.Enqueue(p);
                        visited[p.row,p.col] = true;
                        stack.Push(p);
                    }
                }

            }
            //4개 이상 그룹이면 그룹 삭제
            if (count >= 4)
            {
                result = true; //삭제한 그룹이 있으면 true
                foreach (Point p in stack)
                {
                    //그룹의 뿌요 삭제
                    map[p.row, p.col] = '.';
                }
            }
        }
    }

    return result; //삭제한 그룹이 있으면 true
}

applyGravity() : 뿌요에 중력 적용 (빈 공간 제거)

static void applyGravity(char[,] map)
{
    //뿌요에 중력을 적용
    //각 열의 모든 색상을 스택에 쌓고
    //열을 날린 다음 맨 아래부터 재배치
    Stack<char> stack = new Stack<char>();
    for (int col = 0; col < 6; col++)
    {
        for (int row = 0; row < 12; row++)
        {
            if (map[row, col] != '.')
            {
                stack.Push(map[row, col]);
                map[row, col] = '.';
            }
        }

        //맨 아래부터 재배치
        int rowIndex = 11;
        while (stack.Count > 0)
        {
            char puyo = stack.Pop(); // 스택에서 요소를 꺼냄
            map[rowIndex, col] = puyo;
            rowIndex--;
        }
    }
}

2573. 빙산 (C#)

코드봇 — Tue, 2 Sep 2025 00:08:19 +0900

문제

빙산 | 골드 IV (2025년 9월 1일 기준)
알고리즘 분류
- 구현
- 그래프 이론
- 그래프 탐색
- 너비 우선 탐색
- 깊이 우선 탐색

접근

한 해가 지날 때 마다 빙산이 녹는 양은 인접한 바다 타일의 개수다. 이를 인접하지 않은 두 빙산으로 쪼개질 때 까지 걸린 햇수(위 상황에선 2가 정답)을 출력하는 것이 이 문제의 요구사항이다. 만약 빙산이 완전히 녹아 없어질 때 까지 쪼개지지 않았다면(빙산이 1조각인 상태를 유지했다면) 0을 출력한다. 인접의 기준은 상, 하 , 좌, 우 만 해당된다.

풀이

메인 함수에서 문제 풀이를 위한 기본 뼈대를 세우고 점점 작은 함수로 쪼개면서 문제를 풀었다.

입력 처리

static void Main(string[] args)
{
    /* 입력
     * 1. 이차원 배열의 행의 개수와 열의 개수 row col
     * 2. 3 <= row , col <= 300
     * 3. 빙산의 높이 -> 0 이상 10 이하
     */
    int[,] iceberg; //빙산 데이터
    string[] input = Console.ReadLine().Split(' ');
    int row = int.Parse(input[0]);
    int col = int.Parse(input[1]);
    iceberg = new int[row, col]; //동적배열 생성

    for (int i = 0; i < row; i++)
    {
        input = Console.ReadLine().Split(' ');
        for (int j = 0; j < col; j++)
        {
            iceberg[i, j] = int.Parse(input[j]);
        }
    }

    Console.WriteLine(calcDivide(iceberg, row, col));
}

메인 함수에서 문제의 입력과 정답 출력을 위한 뼈대를 먼저 작성했다. calcDivide 메서드에 빙산 데이터, 행, 열 변수를 매개변수로 전달하고 내부에서 계산한 햇수(문제의 정답)을 콘솔에 출력하는 구조로 접근했다.

빙산이 쪼개진 햇수 구하기

static int calcDivide(int[,] iceberg, int row, int col)
{
    int result = 0;

    while (countIsland(iceberg, row, col) == 1)
    {
        applyMelt(iceberg, row, col);
        result++;
    }

    if (countIsland(iceberg, row, col) == 0)
    {
        return 0;
    }
    else
    {
        return result;
    }
}

calcDivide에서는 빙산이 1조각인 동안 반복해서 applyMelt를 실행해서 빙산을 녹이면서 햇수를 기록한다. 빙산이 1조각이 아니게 되었을 때, 만약 빙산이 0조각인 경우(모든 빙산이 녹아 없어진 경우) 0을 반환하고 아닌 경우 햇수를 반환한다.

빙산의 조각 세기

static int countIsland(int[,] iceberg, int row, int col)
{
    int result = 0; //섬의 개수
    bool[,] visited = new bool[row, col]; //방문 기록

    for (int i = 0; i < row; i++)
    {
        for (int j = 0; j < col; j++)
        {
            if (visited[i, j] || iceberg[i, j] == 0)
            {
                //이미 방문한 지점이거나 바다라면 pass
                continue;
            }
            //BFS
            Queue<Point> queue = new Queue<Point>();
            queue.Enqueue(new Point(i, j));
            visited[i, j] = true;
            while (queue.Count > 0)
            {
                Point curr = queue.Dequeue();
                Point[] cardinates = new Point[]
                {
                    new Point(curr.row + 1, curr.col),
                    new Point(curr.row - 1, curr.col),
                    new Point(curr.row, curr.col + 1),
                    new Point(curr.row, curr.col - 1)
                };
                foreach (Point p in cardinates)
                {
                    if (p.row >= 0 && p.col >= 0 && p.row < row && p.col < col && !visited[p.row, p.col] && iceberg[p.row, p.col] > 0)
                    {
                        queue.Enqueue(p);
                        visited[p.row, p.col] = true;
                    }
                }
            }
            result++;
        }
    }
    return result;
}

빙산의 조각을 세는것은 BFS로 구현할 수 있었다. 빙산 데이터의 모든 좌표를 순회하면서 아직 방문하지 않은 빙산을 발견하면 인접한 빙산을 BFS로 모두 찾아서 방문처리하고 result를 1증가 시킨다. 이렇게 하면 인접하지 않은 빙산의 갯수를 알아낼 수 있다.

빙산 녹이기

static void applyMelt(int[,] iceberg, int row, int col)
{
    int[,] meltPower = new int[row, col];
    Stack<Point> stack = new Stack<Point>();

    for (int i = 0; i < row; i++) //녹는 정도 계산하기
    {
        for (int j = 0; j < col; j++)
        {
            if (iceberg[i, j] == 0) continue; //바다라면 pass

            Point[] cardinates = new Point[4] //상하좌우 후보위치
                {
                    new Point(i + 1, j),
                    new Point(i - 1, j),
                    new Point(i, j + 1),
                    new Point(i, j - 1)
                };


            int count = 0;
            foreach (Point p in cardinates)
            {
                if (p.row >= 0 && p.col >= 0 && p.row < row && p.col < col)
                {
                    if (iceberg[p.row, p.col] == 0)
                    {
                        count++;
                    }
                }

            }
            if (count > 0)
            {
                meltPower[i, j] = count; //녹는 정도 계산
                stack.Push(new Point(i, j)); //녹는 위치 기록
            }

        }
    }

    while (stack.Any()) //녹이기
    {
        Point p = stack.Pop();
        iceberg[p.row, p.col] -= meltPower[p.row, p.col];
        if (iceberg[p.row, p.col] < 0) iceberg[p.row, p.col] = 0; //음수가 되지 않게 cap
    }

    printIceberg(iceberg, row, col);
}

빙산은 한 번에 녹는다. 즉, 빙산이 녹는 사이클 중간에 바다가 된 타일은 빙산이 녹는 정도에 영향을 주지 않는 다는 것이다. 만약 빙산을 녹이는 과정중에 녹아서 바다가 된 타일이 다른 빙산 타일의 녹는 정도에 영향을 준다면 오답이 될 가능성이 있다. 그래서 빙산이 녹는 정도를 기록하는 meltPower 배열을 만들고, 각 빙산의 좌표를 모두 순회한 다음 한 번에 빙산이 녹는 정도를 적용했다. 추가로, 녹는 위치를 stack에 기록해서 시간 복잡도가 증가하지 않도록 했다.

코드를 살펴보니 메서드 이름이 죄다 소문자로 시작하고 있는데, 이 문제를 해결할 당시에는 이게 맞는 명명규칙인줄 알았던 것 같다.

0x00 리버스 엔지니어링이란?

코드봇 — Sun, 7 Jul 2024 23:04:25 +0900

들어가며

군생활 동안 제작했던 "사지방 해제기"에는 사실 특별한 기법이 사용되지 않았다. Windows API에서 제공하는 프로세스 일시중지, 죽이기 기능을 이용해 MaestroWeb Agent의 특정 프로세스를 일시중지/죽이거나 맘아이 솔루션에서 맘아이 프로세스가 죽었을 때 다시 살리는 프로세스를 일시중지하고 (죽이는 것은 권한 부족 문제로 수행할 수 없었으나, 프로세스 일시중지는 가능했다) 맘아이에서 실질적으로 사이트를 인식하고 차단하는 프로세스를 죽이는 것으로(별다른 문제없이 프로세스 kill을 수행할 수 있었는데, 이것도 상식적으로 권한으로 막아야 하지 않았을까 하는 것은 여전히 의문) 사지방 우회기의 기능을 구현할 수 있었다.

그때 당시에는 리버싱에 대해 자세히 알 지 못했었고, 사지방을 이용하면서 알아낸 몇가지 편법들을 본가의 PC에서 C#을 이용하여 자동화한 것이 현재 블로그에 작성해둔 "사지방 우회기" 이다. 그런 과정에서 리버싱에 대해 관심이 생겼고 리버싱을 좀더 본격적으로 배우고자 하여 병자기개발비 지원금을 이용해 리버싱 관련 문헌을 몇권 구매했다.

리버스 엔지니어링의 의미?

리버스 엔지니어링은 컴파일된 프로그램을 연구하는 일이다. 개발자가 C/C++ 등의 언어로 프로그램을 작성하면 컴파일러는 해당 코드를 해석하여 이를 바이너리로 빌드하는데 이를 "컴파일" 이라고 한다. 컴파일된 프로그램(바이너리)에서는 원래의 C/C++ 코드가 담겨있지 않다. 리버스 엔지니어링은 이러한 바이너리 코드를 분석하여 원래의 코드 구조와 동작을 이해하려는 시도이다. 바이너리 코드를 어셈블리어로 변환(디스어셈블리) 하거나 더 높은 수준의 언어로 변환(디컴파일) 하는 것 모두 리버스 엔지니어링에 포함된다.

어셈블리어란?

어셈블리어는 특정 CPU 아키텍처의 기계어 명령을 사람이 이해할 수 있는 형태로 표현한 것이다. 프로그래밍 언어는 고급 언어와 저급 언어로 구분할 수 있는데, 어셈블리 언어는 저급 언어에 해당하며 인간의 언어보다 기계의 언어에 더 가까우며 어셈블리어의 명령어는 기계어 코드와 1:1 대응한다. 즉, 기계어를 그저 사람이 읽을 수 있는 형태로 변환한것에 불과한 언어이다.

어셈블리어를 배워야 하는 이유

요즘의 일반적인 개발자는 어셈블리어로 코드를 작성할 일은 거의 없다. C, C++, C#, JAVA, Java Script, Python등의 코드를 비교하는 유튜브 영상에서 어셈블리어 코드에 대해 "시급을 받으며 일하는 개발자에게 적합" 한 언어라고 소개할 정도이다. 어셈블리어는 같은 동작을 수행하기 위해 고급 언어 대비 더 복잡하고 긴 코드를 작성하게 된다. 심지어 최신 컴파일러는 사람이 직접 최적화를 수행하는 것 보다 최적화 수행 능력이 좋다.

어셈블리에 대한 이해가 도움이 되는 경우는 보안/악성 프로그램을 연구하거나 디버깅 하는 동안 컴파일된 코드를 확인하는 경우이다. 이미 바이너리로 빌드된 프로그램을 분석할 때에는 어셈블리어 외에는 방도가 없으며 어셈블리어를 이해하는 능력이 필수적이다.

어셈블리어 학습에 유용한 사이트 - godbolt.org

여러가지 언어로 작성한 프로그램 코드를 다양한 컴파일러를 이용해 어셈블리어로 변환하여 확인해볼 수 있는 사이트가 있다. https://godbolt.org/ 에 접속하면 온라인 환경에서 코드를 작성해보고 이를 컴파일러를 이용해 어셈블리어로 변환해볼 수 있다.

int형 정수를 입력받아 그대로 반환하는 간단한 함수를 작성하였다. 실시간으로 어셈블리어로 변환해주고 있다.

num:
        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR [rbp-4], edi
        mov     eax, DWORD PTR [rbp-4]
        pop     rbp
        ret

동일한 코드라도 CPU 아키텍처의 명령어 집합에 따라 조금씩 어셈블리어가 달라질 수 있다. 또한 어셈블리언어는 인텔 구문과 AT&T 구문의 두 가지 문법을 가지고 있다. 위 구문은 인텔 구문의 문법으로 작성되어 있다. 어셈블리어에 대한 내용은 추후 포스트에서 더 자세히 다루겠으나 일단 위의 명령어를 간단하게 살펴보자면

push rbp
push : 오퍼랜드(피연산자, 즉 연산에 사용할 데이터 / 포인터)의 내용을 스택에 쌓는다.
rbp : 베이스 포인터 레지스터로, 스택의 바닥을 가르키는 포인터이다. 스택프레임으로 관리하기 위해 사용되는 포인터이다

mov rbp, rsp
mov A, B: A를 B값으로 덮어씌운다, 즉 rbp를 rsp의 값으로 덮어씌운다.
rsp : 스택 포인터 레지스터로 스택의 맨 꼭대기를 가르키는 포인터이다.

여기 까지 했을 때, rbp는 현재 함수의 스택프레임을 가리키게 된다.

mov DWORD PTR [rbp-4], edi
edi : x86-64 호출 규약에 따라 함수의 첫번째 인수(int a)가 전달되는 32비트 레지스터다.
rbp-4 위치에 edi의 값을 저장한다

mov eax, DWORD PTR [rbp-4]
eax: 함수의 반환값을 저장하는데 사용되는 32비트 레지스터다.

pop rbp
pop : 스택으로부터 값을 뽑아낸다. 여기서는 스택 맨 위의 값을 뽑아서 rbp에 집어 넣는다. 스택 프레임을 정리하는 과정 중 일부다.

ret
호출된 함수에서 호출한 함수로 복귀한다.

컴퓨터 구조 개론

코드봇 — Mon, 27 Apr 2020 19:33:07 +0900

이 포스트에서는 컴퓨터 구조를 본격적으로 들어가기 전에 우선 컴퓨터 그 자체에 대해 다뤄볼 예정입니다. 컴퓨터의 종류와 부팅과정, 그리고 보통 "컴퓨터"라고 불리는 것들의 기본적인 내부 구조를 알아봅시다.

컴퓨터의 종류

ABC(Atanasoff-Berry Computer)는 1942년에 개발된 컴퓨터로 세계 최초의 전자식 컴퓨터로 알려져 있습니다. 이 ABC 컴퓨터는 지금의 컴퓨터와는 다르게 정해진 제한된 기능만을 수행하였습니다.

에니악(ENIAC, Electronic Numerical Intergrator And Computer)은 1947년에 개발된 다용도 컴퓨터로 제한된 기능만을 수행하던 ABC와는 다르게 일반적인 다양한 계산이 가능한 컴퓨터입니다.

보통 세계 최초의 컴퓨터(전자식 계산기)라고 하면, 에니악으로 알고 계신분들이 많으실것 같은데요. 1973년 소송에서 ABC가 세계 최초의 전자식 계산기로 인정받았다고 합니다.

에니악의 모습 (사진 출처 : 위키피디아)

위의 에니악 사진을 보시면 지금의 컴퓨터와는 다르게 매우 큰 모습을 하고 있는 것을 보실 수 있습니다. 그런데 지금 사용하고 계신 컴퓨터는 그 크기가 이와 비교하면 매우 작아진것을 알 수 있는데요.

이와같은 컴퓨터가 처음 만들어지기 시작했던 1940년대 부터 처음 개인을 위한 컴퓨터가 보급되던 1980년대 중반까지의 약 30년 동안 컴퓨터의 발전 속도는 상당히 빨랐습니다. 그리고 1990년대에는 인터넷이 등장하였죠

컴퓨터의 부팅과정

컴퓨터의 전원버튼을 누른 순간부터 컴퓨터의 화면이 들어오기 까지 컴퓨터는 어떤 일들을 수행하여 부팅을 완료할까요?

1. 컴퓨터에 전원을 넣게되면 공급되는 전원의 전압을 컴퓨터의 각종 부품들이 사용할 수 있는 전압으로 바꾸어 우선 CPU(중앙 처리 장치)로 공급하게 됩니다. CPU는 CPU 레지스터인 PC(Program Counter)레지스터를 메인보드의 ROM BIOS 부트 프로그램의 주소 값으로 초기화합니다.

2. 부트 프로그램은 POST(Power On Self-Test)작업을 수행합니다. POST는 시스템 버스, RTC, 비디오 구성 요소들, RAM, 키보드, 연결된 모드 드라이브(CD, 하드디스크 등의 저장장치)에 신호를 보내 각 부품들이 정상적으로 동작하는 지 확인하는 작업입니다.

3.부트 프로그램은 OS(Operating System, 운영체제)를 로드하기 위해 디스크의 첫 번째 섹터를 메인 메모리로 읽어 들이는데 이는 디스크의 첫번째 섹터에 저장되어 있는 MBR(Mast Boot Record)의 정보를 바탕으로 디스크에서 운영 체제를 찾기 위함입니다. 운영 체제를 찾았다면 이 내용을 기억 장치(메모리)에 저장합니다. 이때부터는 더이상 기계적인 부팅이 아닌 운영 체제가 시스템을 준비하는 과정이 시작됩니다.

4.운영 체제는 'init'과 같은 첫 번째 프로세스를 실행하고, 사용자로 부터 요청이 발생하기를 기다립니다. 요청은 하드웨어나 소프트웨어의 interrupt의 형태로 발생됩니다. 하드웨어는 시스템 버스로 CPU에 신호를 보내고 소프트웨어는 시스템 호출이라 불리는 명령을 실행해 인터럽트를 발생시킵니다.

컴퓨터 운영체제에서 init은 컴퓨터 부팅 과정중에서 최초의 프로세스 이며 컴퓨터가 종료될때까지 계속 실행되는 데몬 프로세스 입니다.

인터럽트는 CPU가 프로그램을 처리하고 있을때 입출력 장치의 제어 혹은 예외상황이 발생하여 처리가 필요할때, 이를 CPU에게 알려 처리할 수 있도록 하는 것을 말합니다.

컴퓨터 구조 개괄

컴퓨터의 종류는 다양하지만 이들 컴퓨터의 내부 구조는 거의 동일합니다.

컴퓨터는 기본적으로 하드웨어(hardware)와 소프트웨어(software)로 이루어져 있는데요, 하드웨어는 각종 전자 회로와 물리적인 장치로 이루어진 기계 부분을 의미하며 소프트웨어는 하드웨어를 활용할 수 있도록 해주는 프로그램을 의미합니다.

컴퓨터 시스템의 계층적 구조

(1) 하드웨어

하드웨어(hardware)는 다양한 기계, 전자 기기, 반도체 등이 사용되는 부분으로 눈에 보이며 만질 수 있는 전기 기계적인 장치를 의미합니다. 하드웨어는 소프트웨어와는 다르게 한번 제작되면 변경이 쉽지 않습니다. 기본적인 하드웨어 부품들로는 CPU(중앙처리장치), 메모리(주기억 장치), I/O(입출력) 장치 등이 있습니다.

(2) 시스템 소프트웨어

시스템 소프트웨어는 사용자를 위해 다양한 응용 프로그램간의 하드웨어 사용을 제어 및 통제 조정하는 기능을 수행하는 소프트웨어를 지칭하는데요. 컴퓨터 시스템의 구성 요소를 적절하게 사용할 수 있도록 해주는 운영 체제(OS, Operating System), 컴퓨터를 관리하기 위한 소프트웨어, 또는 사용자에게 편의 기능을 제공하는 소프트웨어 등의 프로그램을 의미합니다. 대표적으로 운영 체제와 컴파일러 등을 예로 들 수 있습니다.

(3) 응용 프로그램

응용 프로그램은 사용자의 여러 요구 사항을 해결하기 위한 프로그램으로 사용자가 직접 사용하는 프로그램입니다. 대표적으로 웹브라우저, 워드 나 한글과 같은 워드프로세서, 엑셀과 같은 스프레드시트등이 있습니다.

자료의 정렬과 탐색 - 3. 자료의 탐색(1)

코드봇 — Sun, 13 Oct 2019 23:15:10 +0900

탐색이란?

탐색(Search)는 주어진 원소들 중에서 특정 조건을 만족하는 원소를 찾는 것을 의미합니다. (탐색과 검색은 같은 의미로 사용되곤 합니다.) 원소가 가진 속성중 탐색 대상이 되는 속성(properties)를 키(key)값이라고 합니다.

탐색과 정렬은 자료의 처리 및 분석에 관련된 대부분의 문제 해결에 이용되는 기본 연산이며, 실제로 데이터를 처리하는 데 걸리는 시간보다 데이터를 검색하는데 걸리는 시간이 길어진다면 전체적인 작업 속도가 늦어지므로 효율적인 탐색에 대한 필요성이 강화되었습니다.

탐색은 대부분의 데이터 처리 작업에서 임계 경로에 포함되는 핵심적인 작업인데, 임계 경로란 작업을 해결하는데 있어 가장 긴 경로(처리 시간이 가장 오래 걸리는 경로) 를 말합니다. 따라서 임계 경로의 길이(수행 시간)을 줄이게 된다면 작업의 전체 시간이 짧아지게 됩니다. 이 임계 경로는 추후에 알고리즘의 효율성을 평가하는데에도 이용하게 됩니다.

비록 탐색이 컴퓨터의 빠르고 정확한 계산 능력을 기반으로 한다고 하더라도, 자료의 양이 매우 많거나 크기가 클경우 컴퓨터를 사용해도 오랜 시간이 걸릴 수 있습니다. 따라서 이러한 자료의 양과 종류에 따라 적합한 탐색 전략이 존재합니다.

이 글에서는 다양한 탐색 알고리즘(탐색 전략) 중 몇가지를 알아보도록 하겠습니다.

순차 탐색(Sequential Search)

순차탐색이란 주어진 원소의 첫번째부터 끝까지 차례대로 모든 요소를 비교해 자료를 찾는 탐색 알고리즘 입니다. 탐색의 수행 방향이 한쪽 방향으로만 흘러 탐색을 수행하기 때문에 선형 탐색(Linear Search)라고도 합니다.

탐색 알고리즘중 가장 단순한 형태를 가진 알고리즘이라고 할 수 있습니다. 순서대로 하나씩 찾다보면 언젠가는 찾고자 하는 Key값을 찾을 수 있을것이고, 주어진 원소를 모두 탐색했는데도 해당하는 값이 없다면 단순히 찾고자 하는 원소가 목록에 없었던 것이라고 판단하면 됩니다.

순차 탐색 알고리즘으로 탐색을 수행하게 된다면, 운이 좋다면 한번에도 원하는 값을 찾을 수 있을지도 모르지만, 최악의 상황(맨 마지막에 찾고자 하는 원소가 있거나 혹은 목록에 원소가 없는 경우) 목록을 모두 한번씩 탐색해야 하기 때문에 목록의 크기만큼 탐색을 수행해야 할 수도 있습니다. 따라서 효율성이 좋은 알고리즘이라고 보기는 어렵습니다.

#include <stdio.h>

int main()
{
    int d[5], key;
    
    for(int i=0; i<5; i++){  //배열에 5개의 정수를 입력받습니다
        scanf("%d", &d[i]);
    }
        
    printf("Key = ");       //탐색할 키 값을 입력받습니다
    scanf("%d", &key);
    
    int loc=0;
    while(loc<=5 && d[loc] != key) 
        loc++; //첫번째 자리부터 비교를 시작해, 탐색할 값과 불일치할 경우 loc변수에 1씩 더합니다
    
    if(loc > 5)
        loc = -1;  //변수의 크기를 초과할경우 -1을 loc에 저장합니다.
    
    if(loc == -1){
        printf("목록에 없음!");  //loc가 -1인 경우 목록에 없는 것으로 판단합니다.
    }
    else
    {
        printf("%d번째에 %d존재", loc+1, key); //찾은 원소의 위치와 값을 출력합니다.
    }			//이때 loc에는 배열의 인덱스가 저장되어 있으므로 +1하여 출력합니다.
    return 0;
}

효율성이 좋은 알고리즘은 아니지만 설계 및 구현이 용이하고 리스트 내부의 자료를 구조화할 필요가 없기에 자료수가 적을때 편리하게 이용할 수 있는 알고리즘입니다. (하지만 자료의 양이 많은 인터넷 검색등의 작업에는 탐색 속도때문에 한계가 명확하게 드러납니다.)

단계	d[1]	d[2]	d[3]	d[4]	d[5]
초기	3	7	10	22	44
key 값	22
1 단계	3 != 22
2단계		7 != 22
3단계			10 != 22
4단계				22 == 22
완료	22는 d[4]에 존재

2진 탐색(Binary Serach)

2진 탐색이란 주어진 원소들을 탐색이 필요한 영역과 불필요한 영역으로 나누어 가며 수행하는 알고리즘입니다. 한번 탐색을 수행할때 마다 리스트의 원소들이 둘로 분할되기 때문에 2진 탐색(또는 2분 탐색)이라는 이름이 붙게 되었습니다.

2진 탐색은 목록을 둘로 나누며 탐색을 진행합니다. 이는 업 앤 다운 게임(*임의의 숫자를 정해놓고, 어떤 수보다 큰지 작은지를 말해주며 임의의 수가 무엇인지 맞추는 게임)과 비슷하게 진행되게 되는데, 해봤다면 알겠지만 범위를 크게 정해두어도 대게 10번의 질문 안에 숫자를 맞출 수 있습니다. 이처럼 2진 탐색은 자료의 수가 많아질수록 순차 탐색에 비해 매우 높은 효율을 보이게 되는데, 리스트의 원소들이 미리 정렬되어 있어야 적용할 수 있는 방법입니다.

단계	d[1]	d[2]	d[3]	d[4]	d[5]	d[6]	d[7]	d[8]	d[9]
초기	1	3	4	10	20	22	33	68	76
key 값	68
1단계	탐색이 필요 없음				20 < 68	22	33	68	76
2단계	탐색이 필요 없음						33 < 68	68	76
3단계	탐색이 필요 없음							68 = 68	탐색X
완료	68은 d[8]에 존재

*c언어 코드는 작성 예정

자료의 정렬과 탐색 - 2. 자료의 정렬(2)

코드봇 — Sat, 12 Oct 2019 00:14:16 +0900

삽입 정렬

삽입 정렬(insertion sort)는 리스트에 원소를 하나씩 삽입하는 과정을 반복해 정렬을 수행하는 알고리즘입니다. 선택 정렬 처럼 리스트의 앞쪽부터 정렬되며 삽입의 원리는 일상생활 속에서도 쉽게 발견할 수 있는데, 과제등을 학번순으로 정렬할때 순서에 맞게 중간에 끼워가는 식으로 정렬하는 것이 일반적이기 때문입니다.

//삽입정렬
#include <stdio.h>

main()
{
	int j, i, k, key;
	int a[10];
	j = -1;
	
	do {
		j++;
		scanf("%d", &a[j]);
	} while( j<9 );  //do~while 을 이용해 배열에 10개의 숫자를 입력받는다.
	for(i = 1; i<=9; i++) {
		key = a[i];
		for(k = i-1; k >= 0; k--) {
			if(a[k] > key){
				a[k + 1] = a[k];
			}
			else{
				break;
			}
		}
		a[k + 1] = key; 
	}
	for(i = 0; i <= 9; i++){ //배열에 저장된 10개의 수를 모두 출력
		printf("%d ", a[i]); 
	}
}

//입력:
1 3 5 7 9 2 4 6 8 10
//출력:
1 2 3 4 5 6 7 8 9 10

퀵 정렬

퀵 정렬(Quick sort)는 찰스 앤터니 리처드 호어(Charles Antony Richard Hoare)가 개발한 정렬 알고리즘으로, 주어진 배열의 원소 중 하나를 피벗(기준값)으로 선택하여 이 원소와의 크기 비교를 통해 나머지 원소들을 분할하는 과정을 재귀적으로 수행하는 정렬 알고리즘 입니다. 평균적으로 매우 빠른 수행 속도를 자랑하는 정렬 방법으로 가장 빠른 알고리즘 이라는 것이 증명되었습니다.

객체지향 프로그래밍 (JAVA) - 접근제한자와 Getter, Setter

코드봇 — Fri, 11 Oct 2019 23:44:16 +0900

문제상황:
다음은 전화번호부 프로그램의 일부입니다. Friend 클래스와 Main 클래스는 모두 같은 패키지(main) 안에서 구현되어 있으며, 프로그램 실행시 오류가 발생합니다.

package main;


import java.util.ArrayList;
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		ArrayList<Friend> list = new ArrayList<Friend>();
		Scanner in = new Scanner(System.in);

		int menuNo = 0;
		while(menuNo != 3) {
			System.out.println("< 기능을 선택하세요 > ");
			System.out.println("1. 전화번호부에 추가");
			System.out.println("2. 저장된 번호 보기");
			System.out.println("3. 종료");
			menuNo = in.nextInt();
			
			if(menuNo == 1 ) {
				Friend user = new Friend();
				System.out.println("사용자 이름을 입력하세요");
				String name = in.next();
				user.name = name;
				
				System.out.println("전화번호를 입력하세요");
				String phone = in.next();
				user.phone = phone;
				
				list.add(user);
				System.out.println("성공적으로 추가되었습니다.");
				
			}
			
			if(menuNo == 2) {
				for(Friend f : list) {
					System.out.println(f.name + "\n" + f.phone);
					System.out.println("-");
				}
			}
		}

	}

}

package main;

public class Friend {
	private String name;
	private String phone;
	
	public String getName() {
		return this.name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public String getPhone() {
		return this.phone;
	}
	
	public void setPhone(String phone) {
		this.phone = phone;
	}

}

에러의 이유:
위 프로그램에서 에러가 발생하는 이유는 Friend 클래스에서 "private" 접근제한자로 선언된 멤버변수를 Main 클래스에서 직접적으로 접근하려 했기 때문에 발생합니다.

private로 선언된 멤버변수는 다른 클래스에서 접근 및 수정할 수 없으며, 자식 클래스에게 상속되지도 않고 오직 부모 클래스에서만 사용이 가능합니다. 이때문에 Main 클래스에서는 Friend의 name과 phone 클래스가 감추어져 있기 때문에 에러가 발생하는 것입니다.

에러의 해결:
(1) 간단하게 Friend 클래스에서 private가 아닌 public으로 멤버변수를 선언하면 에러가 해결됩니다. 하지만 이는 권장되지 않습니다. 대규모 프로젝트나 다수가 참여하는 프로젝트에서 각각의 클래스에서 어떤 이름으로 변수를 선언했는지 기억하는 것은 무리이기 때문에 접근 제한자와 Getter, Setter를 이용하는 것인데, public을 사용하면 그 의미가 없기 때문입니다.

(2) Getter (Friend클래스에서 public으로 정의된 getName, getPhone 메서드)와 Setter (setName, setPhone 메서드)를 이용하여 값에 접근하도록 수정합니다. 메인클래스의 코드중에 user.name = name; 처럼 멤버변수에 직접 접근하는 코드들을 모두 user.setName(name); 와 같은 Getter와 Setter를 사용하도록 수정합니다.

//수정된 Main 클래스

package main;


import java.util.ArrayList;
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		ArrayList<Friend> list = new ArrayList<Friend>();
		Scanner in = new Scanner(System.in);

		int menuNo = 0;
		while(menuNo != 3) {
			System.out.println("< 기능을 선택하세요 > ");
			System.out.println("1. 전화번호부에 추가");
			System.out.println("2. 저장된 번호 보기");
			System.out.println("3. 종료");
			menuNo = in.nextInt();
			
			if(menuNo == 1 ) {
				Friend user = new Friend();
				System.out.println("사용자 이름을 입력하세요");
				String name = in.next();
				user.setName(name);
				
				System.out.println("전화번호를 입력하세요");
				String phone = in.next();
				user.setPhone(phone);
				
				list.add(user);
				System.out.println("성공적으로 추가되었습니다.");
				
			}
			
			if(menuNo == 2) {
				for(Friend f : list) {
					System.out.println(f.getName() + "\n" + f.getPhone());
					System.out.println("-");
				}
			}
		}

	}

}

//수정된 Friend 클래스
package main;

public class Friend {
	private String name;
	private String phone;
	
	public String getName() {
		return this.name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public String getPhone() {
		return this.phone;
	}
	
	public void setPhone(String phone) {
		this.phone = phone;
	}

}

#14 - 3번을 누르면 프로그램 종료기 때문에 3이 아닌 동안에 계속 반복하여 메뉴를 출력하고, 사용자로 부터 메뉴 선택을 입력받습니다.

#21~32 - 저장될 사용자의 이름과 전화번호를 사용자로 부터 입력받고, Friend 클래스 형으로 선언된 user에 이름과 전화번호를 저장, 마지막에는 Friend 클래스 자료형을 갖는 리스트에 저장하여 마칩니다.

#37~39 - 리스트에 저장된 모든 정보를 출력합니다. 사용자와 사용자의 구분은 "-"를 출력하여 구분하고, 이름과 전화번호를 출력합니다.

자료의 정렬과 탐색 - 1. 자료의 정렬 (1)

코드봇 — Tue, 1 Oct 2019 23:45:42 +0900

정렬의 개념

정렬(sort)이란, 특정 집합(목록, list)의 원소들을 일정한 순서에 따라 배치하는 것을 말합니다. 정렬의 대상이 되는 원소가 가진 속성 중 정렬의 기준이 되는 값을 Key(키) 값이라고 하며, 일반적으로 원소를 키값이 커지는 순으로 배치하는 것이 정렬입니다. 정렬중에는 새로운 원소가 추가되거나 기존의 원소가 삭제되면 안되며, 이를 무결성 이라고 합니다.

정렬의 사전적 정의는 비교적 간단하지만, 정렬을 효율적으로 수행하기 위한 과정은 다양하고 복잡합니다. 지금까지 다양한 정렬 알고리즘이 연구 및 개발되었으며 버블 정렬, 퀵 정렬, 삽입 정렬, 선택 정렬등의 알고리즘이 대표적입니다.

버블 정렬(Bubble sort)

버블 정렬은 간단히 말해서 두 인접한 원소를 비교하여 교환하는 과정을 반복하는 정렬 알고리즘 입니다. 배열(리스트)의 맨 앞에 있는 원소부터 시작해서 해당 원소와 그 다음 원소를 비교하고, 큰 값을 뒤로 보내는 과정을 반복하게 됩니다. 이것을 마지막 원소까지 반복하게 되면 가장 큰 원소가 맨 뒤에 위치하게 되며 이후 정렬되지 않은 원소들에도 같은 방법으로 반복하면 모든 원소에 대해 정렬이 완료됩니다.

단계	s[1]	s[2]	s[3]	s[4]	s[5]
초기	9	5	6	2	3
1단계	5	6	2	3	9
2단계	5	2	3	6	9
3단계	2	3	5	6	9
4단계	2	3	5	6	9
완료	2	3	5	6	9

위 표는 리스트의 처음 상태가 {9, 5, 6, 2, 3} 일때의 상황에서 버블정렬 하는 과정을 단계적으로 나타낸 표입니다. 버블 정렬이라는 이름은 정렬 수행 과정에서 키값이 큰 원소가 뒤로 가는 모습이 거품이 커지는 모습과 유사하다고 하여 붙여진 이름입니다. 버블 정렬은 정렬 알고리즘 중에서 최초로 연구 및 개발된 알고리즘으로, 다른 알고리즘들에 비해 쉽게 이해할 수 있고 구현이 간단하지만 비교와 교환하는 횟수가 많아 수행 속도가 느립니다.

#include <stdio.h>

int main(void) {
  int s[10];
  int n=-1;

  do{
    n++;
    scanf("%d", &s[n]);
  }while(n < 9);
  for (int i = 1; i <= 9; i++){
    for(int j = 0; j <= 9 - i; j++){
      if(s[j] > s[j+1]){
        int temp = s[j];
        s[j] = s[j+1];
        s[j+1] = temp;
      }
    }
  }

  for(int m = 0; m<10; m++){
    printf("%d ", s[m]);
  }
}

입력: 1 3 5 7 9 2 4 6 8 10
출력: 1 2 3 4 5 6 7 8 9 10

선택 정렬(Selection sort)

선택 정렬은 간단히 말해서 리스트의 원소중 최솟값을 선택하여 맨 앞에 위치한 원소와 교체하는 과정을 반복하는 정렬 알고리즘 입니다.

첫 번째 자료를 두 번째 자료부터 마지막 자료까지 차례대로 비교하여 가장 작은 값을 찾아 맨 앞에 위치시키고, 다시 두 번째 자료를 세 번째 자료부터 마지막 자료까지 차례대로 비교하여 가장 작은 값을 찾아 두 번째 자리에 위치하는 이러한 과정들을 반복하여 정렬을 수행하게 됩니다.

단계	s[1]	s[2]	s[3]	s[4]	s[5]
초기	9	5	6	2(최솟값, 선택됨)	3
1단계	2	5	6	9	3(최솟값, 선택됨)
2단계	2	3	6	9	5(최솟값, 선택됨)
3단계	2	3	5	9	6(최솟값, 선택됨)
4단계	2	3	5	6	9(최솟값, 선택됨)
완료	2	3	5	6	9

위 표는 리스트의 처음 상태가 {9, 5, 6, 2, 3} 일때의 상황에서 선택정렬 하는 과정을 단계적으로 나타낸 표입니다. 선택 정렬이라는 이름은 정렬 수행 과정에서 가장 작은 수를 선택하는 연산이 수행되기 때문에 붙은 이름입니다. 선택 정렬은 일상생활 속에서 쉽게 찾을 수 있는 형태의 정렬인데, 바닥에 흩어진 카드를 순서대로 정리할때 눈에 보이는 수 중에 가장 작은 수부터 집어들어서 정리하는게 일반적인 방법이기 때문입니다.

선택 정렬은 버블 정렬과 같이 설계 및 구현이 간단하지만, 효율적인 정렬 알고리즘은 아닙니다. 원소의 개수가 적은 경우 적합한 알고리즘이며 버블 정렬은 큰 수부터 시작해 뒤쪽 부터 정렬되었지만, 선택 정렬은 작은 수 부터 시작해 앞쪽부터 정렬되는 특징이 있습니다.

//선택정렬 코드
#include <stdio.h>
int main()
{
	int i,m,j,temp;
	int s[10];
	for(m = 0; m <= 9; m++){   
	    scanf("%d", &s[m]);     //배열 s[]에 10개의 값을 입력받는 과정입니다. 
	}
    for(i = 0; i <= 8; i++){        //배열의 첫번째 자리부터 마지막-1번째 자리까지의 원소를
        for(j = i + 1; j <= 9; j++) //그 다음 위치의 원소부터 마지막 원소까지 반복하며
        {
            if(s[i] > s[j])         //최솟값을 찾는 비교를 수행합니다.
            {
                temp=s[i];
                s[i] = s[j];
                s[j] = temp;  //원소의 자리를 바꾸는 코드로, 한 원소의 값을 임시로 저장해놓고, 바꾸는 방법을 사용합니다.
            }
        }
    }
    
    for(int k=0; k<=9; k++){
        printf("%d ", s[k]);
    }
	
}

입력 : 2 10 9 8 7 4 5 6 1 3
출력 : 1 2 3 4 5 6 7 8 9 10

Unity 게임프로그래밍 - 4. 본격적으로 게임 만들기

코드봇 — Sun, 15 Sep 2019 23:01:29 +0900

이번 강의에선 지금 까지 배운 내용을 바탕으로 직접 게임을 만들어 보려고 합니다. 강의를 따라하면서 게임을 만들어 본 뒤에는 직접 자신의 입맛대로 응용해서 변화를 줘보는 것도 잊지 마세요. 결국 자신이 직접 하는 것만큼 더 효과적인 학습은 없습니다.

게임 설계하기

게임을 만든다고 해서 무턱대고 만들 수는 없을겁니다. 게임 화면은 어떻게 꾸밀것인지, 무슨 게임을 만들지, 게임이 어떻게 동작하게 할지 등을 먼저 간단하게 기획하고 시작해보도록 하겠습니다. 이러한 과정들을 프로그래밍에서는 "모델링" 과 "추상화"라고 합니다.

우선 이번에 만들어볼 게임은 간단한 추첨 룰렛 게임을 만들어 보도록 하겠습니다. 룰렛 게임에는 어떤 것들이 들어가야 하는지 단계적으로 생각해 봅시다.

[1] 게임의 장면 (Scene)

프로젝트와 씬에대한 설명은 2강에서 먼저 다룬적이 있습니다. 어느정도 게임같은 모습은 갖출 수 있도록 시작화면과 본 게임 화면으로 나누어 만들어보도록 하겠습니다. 그리고 이렇게 씬을 나누었으니 씬 전환 기능도 넣어야 하겠네요.

만들어야 할 게임의 장면 (Scene)
1. 타이틀 (게임 제목)과 시작버튼이 있는 시작화면
2. 룰렛이 있는 게임화면

완성했을때의 게임화면은 아래와 같습니다.

[2] 게임의 리소스

리소스란 게임에서 사용되는 자원으로 그림, 영상, 그래픽, 3D 모델링, 소스코드 등등을 모두 포괄하는 개념입니다. 룰렛 게임을 만들때는 어떤 리소스가 필요할까요?

우선 가장 중요한 룰렛 이미지가 필요하고, 룰렛을 돌릴 스크립트, 시작화면에 나타날 타이틀 이미지, 장면 전환 스크립트 정도가 필요하겠네요.

이미지 파일들은 리소스로 활용하실 수 있도록 사진파일과 PSD파일을 압축파일로 올려놓도록 하겠습니다.

Resource.zip

3.44MB

* 주의 : 리소스 이미지는 Codingbot.kr에서 제작되었습니다. 상업적 이용및 학습 목적 외의 무단 사용은 불가함을 알려드립니다. *

본격적으로 게임 제작 시작하기

프로젝트 만들기

먼저 프로젝트 부터 만들겠습니다. 유니티 시작화면에서 New를 누르거나, 유니티 에디터에서 File > New Project를 누릅니다. 프로젝트 이름은 Roulette, 템플릿은 2D로 합니다.

리소스 추가하기

유니티 에디터가 실행되면 게임에 사용될 이미지 리소스 파일들을 불러옵니다. 직접 리소스를 만들어도 좋고, 아니면 위의 압축 파일을 다운로드 받아 리소스로 활용해도 좋습니다.

리소스를 추가하려면 파일들을 드래그 & 드롭으로 프로젝트 창에 끌어 놓거나, 프로젝트창에서 우클릭 후 Import 를 선택해 파일을 불러올 수도 있습니다.

씬에 오브젝트 추가하기

우선 시작 화면부터 오브젝트를 배치해보겠습니다. 프로젝트 창에 추가해 둔 roulette 이미지를 Scene뷰로 드래그&드롭합니다.

타이틀이 화면의 정 가운데에 오도록 위치를 조절하겠습니다. 계층구조 창에서 title을 선택하고 Inspector 창의 Transform 항목의 position을 0, 0, 0 으로 설정합니다.

씬 저장하기

타이틀 화면 씬을 저장하고 게임 씬을 다시 작성하기 위해 우선 타이틀 화면 씬부터 저장하도록 합니다. 도구 바에서 File > Save Scene as 를 선택하거나 계층구조 창의 SampleScene 글자 위에서 우클릭해 Save Scene as 를 선택합니다. 씬 이름은 TitleScene으로 하겠습니다.

저장을 완료하면 위와같은 상태가 됩니다.

게임 씬을 따로 작성하기 위해 새로운 씬을 만들겠습니다. File > New Scene 을 선택하고 씬 이름은 Game 으로 하겠습니다.

씬을 만들게 되면 위와같은 모습이 됩니다.

이제 아까와 같은 방법으로 룰렛과 바늘을 추가하고 위치를 조절하겠습니다.

룰렛의 위치는 0, 0, 0 Scale은 0.38, 0.38, 0.38로 설정합니다.

바늘의 위치는 0, 4, -1 Scale은 0.5, 0.5, 0.5로 합니다.

게임을 실행하고 게임 화면을 확인합니다.

칙칙한 파란 배경색이 마음에 들지 않는다면 카메라의 속성에서 바꿀 수 있습니다. 계층구조 창에서 Main Camera 를 선택하고 Background 색을 바꿀 수 있습니다.

타이틀 화면도 색상을 바꾸어 줍시다.

시작 버튼도 추가하도록 하겠습니다. 타이틀 씬의 계층구조 창에서 Create > UI > Button 을 선택합니다.

계층구조 창에서 생성된 Button 을 선택하고 Inspector 창에서 위치를 조절합니다.

Pos X는 45, Y는 -350, Z는 0으로 설정하고 Width는 500, Heigh는 80으로 설정합니다.

텍스트를 수정하기 위해서는 계층구조 창에서 Button의 자식 개체로 포함된 Text를 선택하고 Inspector창에서 텍스트를 수정합니다.

Text는 Start! Font Size는 50으로 설정합니다.

스크립트 작성하기

우선 씬 전환을 위한 준비부터 하겠습니다. 씬 전환을 위해선 빌드 옵션에서 씬들을 추가해주어야 합니다.

TitleScene을 편집하고 있는 상태에서 File > Build Settings.. 을 선택합니다.

빌드 설정 창이 뜨면 Add Open Scenes 버튼을 눌러 씬을 빌드하도록 추가합니다. 추가하고 난 뒤에는 아래 사진과 같은 상태가 됩니다.

Game 씬도 이와 같은 방법으로 추가합니다. Game 씬을 편집하고 있는 상태에서 빌드 설정을 열고 Add Open Scene를 눌러 씬을 추가합니다.

Scenes In Build에 TitleScene과 Game이 있다면 완료입니다.

이제 씬 전환을 위한 스크립트를 작성하도록 하겠습니다. 프로젝트 창에서 우클릭 하고 Create > C# Script를 선택합니다. 이름은 SceneChanger 로 하겠습니다.

스크립트 파일을 프로젝트 창에서 더블클릭해 열고, 아래와 같이 코드를 작성합니다.

using System.Collections;
using System.Collections.Generic;
using UnityEngine.SceneManagement;
using UnityEngine;

public class SceneChanger : MonoBehaviour
{
    public void LoadGame()
    {
        SceneManager.LoadScene("Game");
    }
}

씬 전환을 하기 위해서는 "SceneManager"라는 함수를 사용합니다. 이 함수를 이용하기 위해서 코드 상단에 "using UnityEngine.SceneManagement;" 라고 참조해주었습니다.

public void LoadGame() 의 의미는 LoadGame이라는 메서드를 선언하겠다는 의미입니다. 시작 버튼을 누르게 되면 이 스크립트의 LoadGame 메서드를 호출하도록 하여 씬이 전환되도록 하기 위해 이렇게 작성하였습니다.

작성한 스크립트는 계층 구조 창의 Main Camera에 드래그 & 드롭하여 스크립트를 인스턴스화 합니다. 스크립트를 오브젝트에 적용하여 게임 내에서 사용할 수 있도록 하는 과정을 "인스터스 화"라고 합니다.

이제 아까 생성했던 버튼을 계층구조 창에서 선택합니다. Inspector 창을 보게되면 On Click () 이라고 해서 버튼이 클릭됐을때 어떤 이벤트를 발동할것인지 추가하는 창이 있습니다. + 버튼을 누르고 None 이라고 되어있는 상자 옆의 작은 원을 누릅니다. 오브젝트 선택창이 뜨면 Scene 탭에서 Main Camera를 선택합니다.

그 뒤에는 왼쪽의 드롭다운 매뉴를 누르고 SceneChanger > LoadGame()을 선택합니다. 이렇게 하면 버튼을 클릭했을때 메인카메라에 적용된 스크립트 "SceneChanger"의 "LoadGame()" 메서드를 호출하게 되어 씬이 전환되게 됩니다.

이제 회전판을 회전시켜주는 Spin 스크립트를 작성하겠습니다. 프로젝트 창에서 우클릭하고 Create > C# Script 를 선택합니다. 스크립트 이름은 Spin 으로 하겠습니다.

Spin 스크립트에는 아래와 같이 작성하겠습니다.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Spin : MonoBehaviour
{
    float speed = 0;
    void Start()
    {
        
    }

    // Update is called once per frame
    void Update()
    {
        if(Input.GetMouseButtonDown(0))
        {
            this.speed = Random.Range(10, 100);
        }

        transform.Rotate(0, 0, this.speed);

        this.speed *= 0.97f;
    }
}

speed 의 초기값을 0 으로 설정하고 화면을 클릭할때 speed에 10 ~ 100 사이의 임의의 정수가 대입됩니다. transform.Rotate는 오브젝트의 회전에 변화를 주는 함수입니다. speed의 크기만큼 z축으로 회전하게 됩니다. 시간이 지날수록 속도가 점점 줄어들어 정지할 수 있도록 마지막 줄에 this.speed *= 0.97f 으로 해주었습니다. 매 프레임마다 속도에 0.97 만큼 곱해져 속도가 점차 감소하게 됩니다. 완전히 0이 되지는 않지만 값이 매우 작아져 거의 움직이지 않는것처럼 보이게 됩니다.

이제 Spin 스크립트를 회전판에 드래그 & 드롭해 스크립트를 적용합니다. 적용한 뒤에는 실행 버튼을 눌러 정상적으로 작동하는지 확인합니다.

끝맺으며

긴글 읽고 따라하시느라 수고 많이하셨습니다. 혹시라도 궁금하거나 막히는 부분이 있다면 댓글 달아 주시면 답변해드리겠습니다. 마지막으로, 조금씩 응용해 자신만의 게임으로 탈바꿈 시키는 것도 잊지 마세요. 완성 게임 빌드 파일을 글 마지막에 첨부해놓도록 하겠습니다.

https://drive.google.com/file/d/1t8oEXc368RSOhd0_U70xd6Wy3QR8XkwP/view?usp=sharing