자바 언어 : 보드 게임 만들기

보드 게임을 만들어 봅시다. 아래 그림의 말판에서 각 칸에 도착하면 점수를 더하거나 뺍니다. 출발 위치의 칸에 도착했을 때는 점수가 없습니다. 햄스터 로봇의 앞에 손을 가져가면 이동하는 칸 수가 결정됩니다.

햄스터 로봇의 앞에 손을 가져가면 숫자 하나를 선택하도록 해봅시다. 빠르게 변하는 숫자를 눈으로 보고 선택할 수 있도록 숫자 1은 빨간색 LED, 2는 초록색 LED, 3은 파란색 LED로 표시합시다.

import org.roboid.hamster.Hamster;
import org.roboid.runtime.Runner;

public class Controller {
    private final Hamster hamster = new Hamster();

    private int selectNumber(int seed) {
        int number = seed;
        // 손을 가져갈 때까지 반복한다.
        while(hamster.leftProximity() < 40 && hamster.rightProximity() < 40) {
            number = number % 3 + 1; // 1 ~ 3까지 계속 바뀐다.
            if(number == 1) {
                hamster.leds(Hamster.LED_RED);
            } else if(number == 2) {
                hamster.leds(Hamster.LED_GREEN);
            } else {
                hamster.leds(Hamster.LED_BLUE);
            }
            Runner.wait(200); // 0.2초마다 값을 바꾼다.
        }

        // 선택된 숫자를 화면에 표시한다.
        System.out.println("move " + number + " spaces");

        // 손을 치울 때까지 기다린다.
        while(hamster.leftProximity() > 40 || hamster.rightProximity() > 40) {
            Runner.wait(20);
        }
        return number;
    }

    public void run() {
        int number = 0; // 후보 숫자 1 ~ 3
        while(true) {
            number = selectNumber(number);
        }
    }

    public static void main(String[] args) {
        new Controller().run();
    }
}

아래 그림과 같이 각 칸을 0부터 9까지의 번호로 표시하였을 때 현재 위치에서 선택된 칸 수만큼 이동해 봅시다.

import org.roboid.hamster.Hamster;
import org.roboid.runtime.Runner;

public class Controller {
    private final Hamster hamster = new Hamster();
    private int position; // 현재 위치

    private int selectNumber(int seed) {
        int number = seed;
        // 손을 가져갈 때까지 반복한다.
        while(hamster.leftProximity() < 40 && hamster.rightProximity() < 40) {
            number = number % 3 + 1; // 1 ~ 3까지 계속 바뀐다.
            if(number == 1) {
                hamster.leds(Hamster.LED_RED);
            } else if(number == 2) {
                hamster.leds(Hamster.LED_GREEN);
            } else {
                hamster.leds(Hamster.LED_BLUE);
            }
            Runner.wait(200); // 0.2초마다 값을 바꾼다.
        }

        // 선택된 숫자를 화면에 표시한다.
        System.out.println("move " + number + " spaces");

        // 손을 치울 때까지 기다린다.
        while(hamster.leftProximity() > 40 || hamster.rightProximity() > 40) {
            Runner.wait(20);
        }
        return number;
    }

    // 한 칸 이동한다.
    private void move() {
        hamster.boardForward();
        ++ position;
        if(position > 9) {
            position = 0;
        }
    }

    public void run() {
        int number = 0; // 후보 숫자 1 ~ 3
        while(true) {
            number = selectNumber(number);

            // 선택된 숫자만큼 이동한다.
            for(int i = 0; i < number; ++i) {
                move();
                System.out.println("position: " + position); // 현재 위치 표시
            }
        }
    }

    public static void main(String[] args) {
        new Controller().run();
    }
}

이제 점수를 계산하여 코드를 완성하도록 합시다.

import org.roboid.hamster.Hamster;
import org.roboid.runtime.Runner;

public class Controller {
    private final Hamster hamster = new Hamster();
    private int position; // 현재 위치
    private int score; // 현재 점수
    private static final int[] POINTS = { 0, 1, -1, 2, -2, 3, -3, 2, -2, 1 }; // 위치에 따른 점수

    private int selectNumber(int seed) {
        int number = seed;
        // 손을 가져갈 때까지 반복한다.
        while(hamster.leftProximity() < 40 && hamster.rightProximity() < 40) {
            number = number % 3 + 1; // 1 ~ 3까지 계속 바뀐다.
            if(number == 1) {
                hamster.leds(Hamster.LED_RED);
            } else if(number == 2) {
                hamster.leds(Hamster.LED_GREEN);
            } else {
                hamster.leds(Hamster.LED_BLUE);
            }
            Runner.wait(200); // 0.2초마다 값을 바꾼다.
        }

        // 선택된 숫자를 화면에 표시한다.
        System.out.println("move " + number + " spaces");

        // 손을 치울 때까지 기다린다.
        while(hamster.leftProximity() > 40 || hamster.rightProximity() > 40) {
            Runner.wait(20);
        }
        return number;
    }

    // 한 칸 이동한다.
    private void move() {
        hamster.boardForward();
        ++ position;
        if(position > 9) {
            position = 0;
        }
    }

    public void run() {
        int number = 0; // 후보 숫자 1 ~ 3
        while(true) {
            number = selectNumber(number);

            // 선택된 숫자만큼 이동한다.
            for(int i = 0; i < number; ++i) {
                move();
                System.out.println("position: " + position); // 현재 위치 표시
            }

            // 점수를 계산한다.
            score += POINTS[position]; // 이동한 위치의 점수를 더한다.
            System.out.println("score: " + score + "\n"); // 현재 점수 표시
        }
    }

    public static void main(String[] args) {
        new Controller().run();
    }
}

이번에는 아래 그림과 같이 모퉁이에도 칸이 있습니다. 모퉁이는 회전해서 이동해야 합니다. 출발 위치의 칸에 도착했을 때는 1부터 3까지의 무작위 점수가 더해지도록 합시다.

우선 아래 그림과 같이 각 칸을 0부터 13까지의 번호로 표시하고 현재 위치에서 선택된 칸 수만큼 이동하도록 해봅시다. move() 메소드를 수정하여 모퉁이에서는 회전하도록 해야 합니다.

import org.roboid.hamster.Hamster;
import org.roboid.runtime.Runner;

public class Controller {
    private final Hamster hamster = new Hamster();
    private int position; // 현재 위치
    private boolean started; // 출발한 이후인가?

    private int selectNumber(int seed) {
        int number = seed;
        // 손을 가져갈 때까지 반복한다.
        while(hamster.leftProximity() < 40 && hamster.rightProximity() < 40) {
            number = number % 3 + 1; // 1 ~ 3까지 계속 바뀐다.
            if(number == 1) {
                hamster.leds(Hamster.LED_RED);
            } else if(number == 2) {
                hamster.leds(Hamster.LED_GREEN);
            } else {
                hamster.leds(Hamster.LED_BLUE);
            }
            Runner.wait(200); // 0.2초마다 값을 바꾼다.
        }

        // 선택된 숫자를 화면에 표시한다.
        System.out.println("move " + number + " spaces");

        // 손을 치울 때까지 기다린다.
        while(hamster.leftProximity() > 40 || hamster.rightProximity() > 40) {
            Runner.wait(20);
        }
        return number;
    }

    private boolean isOnCorner() {
        if(started) { // 처음 출발할 때는 모퉁이가 아니다.
            switch(position) {
                case 0:
                case 4:
                case 7:
                case 11:
                    return true;
            }
        } else {
            started = true; // 출발하였다.
        }
        return false;
    }

    // 한 칸 이동한다.
    // 위치가 모퉁이인 경우 왼쪽으로 회전한 후 앞으로 한 칸 이동
    // 아니면 그냥 앞으로 한 칸 이동
    private void move() {
        if(isOnCorner()) {
            hamster.boardLeft();
        }

        hamster.boardForward();
        ++ position;
        if(position > 13) {
            position = 0;
        }
    }

    public void run() {
        int number = 0; // 후보 숫자 1 ~ 3
        while(true) {
            number = selectNumber(number);

            // 선택된 숫자만큼 이동한다.
            for(int i = 0; i < number; ++i) {
                move();
                System.out.println("position: " + position); // 현재 위치 표시
            }
        }
    }

    public static void main(String[] args) {
        new Controller().run();
    }
}

이제 점수를 계산하여 코드를 완성하도록 합시다. 출발 위치의 칸에 도착했을 때는 무작위의 점수가 더해져야 합니다.

import java.util.Random;

import org.roboid.hamster.Hamster;
import org.roboid.runtime.Runner;

public class Controller {
    private final Hamster hamster = new Hamster();
    private final Random random = new Random();
    private int position; // 현재 위치
    private boolean started; // 출발한 이후인가?
    private int score; // 현재 점수
    private static final int[] POINTS = { 0, 1, -1, 2, -2, 3, -3, 2, -2, 1, -1, 2, -2, 3 }; // 위치에 따른 점수

    private int selectNumber(int seed) {
        int number = seed;
        // 손을 가져갈 때까지 반복한다.
        while(hamster.leftProximity() < 40 && hamster.rightProximity() < 40) {
            number = number % 3 + 1; // 1 ~ 3까지 계속 바뀐다.
            if(number == 1) {
                hamster.leds(Hamster.LED_RED);
            } else if(number == 2) {
                hamster.leds(Hamster.LED_GREEN);
            } else {
                hamster.leds(Hamster.LED_BLUE);
            }
            Runner.wait(200); // 0.2초마다 값을 바꾼다.
        }

        // 선택된 숫자를 화면에 표시한다.
        System.out.println("move " + number + " spaces");

        // 손을 치울 때까지 기다린다.
        while(hamster.leftProximity() > 40 || hamster.rightProximity() > 40) {
            Runner.wait(20);
        }
        return number;
    }

    private boolean isOnCorner() {
        if(started) { // 처음 출발할 때는 모퉁이가 아니다.
            switch(position) {
                case 0:
                case 4:
                case 7:
                case 11:
                    return true;
            }
        } else {
            started = true; // 출발하였다.
        }
        return false;
    }

    // 한 칸 이동한다.
    // 위치가 모퉁이인 경우 왼쪽으로 회전한 후 앞으로 한 칸 이동
    // 아니면 그냥 앞으로 한 칸 이동
    private void move() {
        if(isOnCorner()) {
            hamster.boardLeft();
        }

        hamster.boardForward();
        ++ position;
        if(position > 13) {
            position = 0;
        }
    }

    public void run() {
        int number = 0; // 후보 숫자 1 ~ 3
        while(true) {
            number = selectNumber(number);

            // 선택된 숫자만큼 이동한다.
            for(int i = 0; i < number; ++i) {
                move();
                System.out.println("position: " + position); // 현재 위치 표시
            }

            // 점수를 계산한다.
            if(position == 0) { // 출발 위치에 있으면
                score += random.nextInt(3) + 1; // 1 ~ 3까지의 무작위 점수를 더한다.
            } else {
                score += POINTS[position]; // 이동한 위치의 점수를 더한다.
            }

            System.out.println("score: " + score + "\n"); // 현재 점수 표시
        }
    }

    public static void main(String[] args) {
        new Controller().run();
    }
}

두 사람이 번갈아 숫자를 선택하여 누가 많은 점수를 얻는지 대전 게임을 만들어 봅시다. 점수를 따로 계산하면 됩니다.

import java.util.Random;

import org.roboid.hamster.Hamster;
import org.roboid.runtime.Runner;

public class Controller {
    private final Hamster hamster = new Hamster();
    private final Random random = new Random();
    private int position; // 현재 위치
    private boolean started; // 출발한 이후인가?
    private int user; // 현재 누구의 차례인가? 0 또는 1
    private int[] scores = { 0, 0 }; // 두 사람의 현재 점수
    private static final int[] POINTS = { 0, 1, -1, 2, -2, 3, -3, 2, -2, 1, -1, 2, -2, 3 }; // 위치에 따른 점수

    private int selectNumber(int seed) {
        int number = seed;
        // 손을 가져갈 때까지 반복한다.
        while(hamster.leftProximity() < 40 && hamster.rightProximity() < 40) {
            number = number % 3 + 1; // 1 ~ 3까지 계속 바뀐다.
            if(number == 1) {
                hamster.leds(Hamster.LED_RED);
            } else if(number == 2) {
                hamster.leds(Hamster.LED_GREEN);
            } else {
                hamster.leds(Hamster.LED_BLUE);
            }
            Runner.wait(200); // 0.2초마다 값을 바꾼다.
        }

        // 선택된 숫자를 화면에 표시한다.
        System.out.println("move " + number + " spaces");

        // 손을 치울 때까지 기다린다.
        while(hamster.leftProximity() > 40 || hamster.rightProximity() > 40) {
            Runner.wait(20);
        }
        return number;
    }

    private boolean isOnCorner() {
        if(started) { // 처음 출발할 때는 모퉁이가 아니다.
            switch(position) {
                case 0:
                case 4:
                case 7:
                case 11:
                    return true;
            }
        } else {
            started = true; // 출발하였다.
        }
        return false;
    }

    // 한 칸 이동한다.
    // 위치가 모퉁이인 경우 왼쪽으로 회전한 후 앞으로 한 칸 이동
    // 아니면 그냥 앞으로 한 칸 이동
    private void move() {
        if(isOnCorner()) {
            hamster.boardLeft();
        }

        hamster.boardForward();
        ++ position;
        if(position > 13) {
            position = 0;
        }
    }

    public void run() {
        int number = 0; // 후보 숫자 1 ~ 3
        while(true) {
            System.out.println("=== user " + (user + 1) + " ==="); // 누구 차례인지 표시

            number = selectNumber(number);

            // 선택된 숫자만큼 이동한다.
            for(int i = 0; i < number; ++i) {
                move();
                System.out.println("position: " + position); // 현재 위치 표시
            }

            // 점수를 계산한다.
            if(position == 0) { // 출발 위치에 있으면
                scores[user] += random.nextInt(3) + 1; // 1 ~ 3까지의 무작위 점수를 더한다.
            } else {
                scores[user] += POINTS[position]; // 이동한 위치의 점수를 더한다.
            }
            user = 1 - user; // 사람을 바꾼다. 0을 1로, 1을 0으로.

            System.out.println("score 1: " + scores[0]); // 첫 번째 사람의 현재 점수 표시
            System.out.println("score 2: " + scores[1] + "\n"); // 두 번째 사람의 현재 점수 표시
        }
    }

    public static void main(String[] args) {
        new Controller().run();
    }
}

아래 그림과 같이 갈림길에 도착하면 다른 길로 이동할 수 있도록 해봅시다. 다른 방법으로 선택하게 할 수도 있지만 여기서는 무작위 수에 따라 선택되도록 합시다.

갈림길로 이동하는 것을 구분하기 위한 변수를 추가해도 되지만, 갈림길이 많아지면 경우의 수가 많아져서 복잡해집니다. 아래 그림과 같이 갈림길에 대한 번호를 추가하여 현재 위치 값으로 판단하는 것이 더 간단합니다.

import java.util.Random;

import org.roboid.hamster.Hamster;
import org.roboid.runtime.Runner;

public class Controller {
    private final Hamster hamster = new Hamster();
    private final Random random = new Random();
    private int position; // 현재 위치
    private boolean started; // 출발한 이후인가?
    private int user; // 현재 누구의 차례인가? 0 또는 1
    private int[] scores = { 0, 0 }; // 두 사람의 현재 점수
    private static final int[] POINTS = { 0, 1, -1, 2, -2, 3, -3, 2, -2, 1, -1, 2, -2, 3, 0, -1, 2, -2, 1, 1, -2, 2, -1 }; // 위치에 따른 점수

    private int selectNumber(int seed) {
        int number = seed;
        // 손을 가져갈 때까지 반복한다.
        while(hamster.leftProximity() < 40 && hamster.rightProximity() < 40) {
            number = number % 3 + 1; // 1 ~ 3까지 계속 바뀐다.
            if(number == 1) {
                hamster.leds(Hamster.LED_RED);
            } else if(number == 2) {
                hamster.leds(Hamster.LED_GREEN);
            } else {
                hamster.leds(Hamster.LED_BLUE);
            }
            Runner.wait(200); // 0.2초마다 값을 바꾼다.
        }

        // 선택된 숫자를 화면에 표시한다.
        System.out.println("move " + number + " spaces");

        // 손을 치울 때까지 기다린다.
        while(hamster.leftProximity() > 40 || hamster.rightProximity() > 40) {
            Runner.wait(20);
        }
        return number;
    }

    private boolean isOnCorner() {
        if(started) { // 처음 출발할 때는 모퉁이가 아니다.
            switch(position) {
                case 0:
                case 4:
                case 7:
                case 11:
                    return true;
            }
        } else {
            started = true; // 출발하였다.
        }
        return false;
    }

    private boolean isOnFork() {
        switch(position) {
            case 15: // 15와 19는 갈림길로 진입하는 경우이므로 왼쪽으로 회전
            case 19:
                return true;
            case 18: // 18은 다시 원래 길로 가야하므로 왼쪽으로 회전하고 위치를 9로 바꾼다.
                position = 9;
                return true;
            case 22: // 22는 다시 원래 길로 가야하므로 왼쪽으로 회전하고 위치를 2로 바꾼다.
                position = 2;
                return true;
        }
        return false;
    }

    // 한 칸 이동한다.
    // 위치가 모퉁이인 경우 왼쪽으로 회전한 후 앞으로 한 칸 이동
    // 아니면 그냥 앞으로 한 칸 이동
    private void move() {
        if(isOnCorner() || isOnFork()) {
            hamster.boardLeft();
        }

        hamster.boardForward();
        ++ position;
        // 위치가 14일 때만 0으로 바꾼다.
        if(position == 14) {
            position = 0;
        }
    }

    // 2나 9에 도착했으면 무작위 수에 따라 갈림길로 바꾼다.
    private void checkFork() {
        if(position == 2 || position == 9) {
            if(random.nextInt(2) < 1) {
                if(position == 2) {
                    position = 15;
                } else {
                    position = 19;
                }
            }
        }
    }

    public void run() {
        int number = 0; // 후보 숫자 1 ~ 3
        while(true) {
            System.out.println("=== user " + (user + 1) + " ==="); // 누구 차례인지 표시

            number = selectNumber(number);

            // 선택된 숫자만큼 이동한다.
            for(int i = 0; i < number; ++i) {
                move();
                System.out.println("position: " + position); // 현재 위치 표시
            }

            checkFork();

            // 점수를 계산한다.
            if(position == 0) { // 출발 위치에 있으면
                scores[user] += random.nextInt(3) + 1; // 1 ~ 3까지의 무작위 점수를 더한다.
            } else {
                scores[user] += POINTS[position]; // 이동한 위치의 점수를 더한다.
            }
            user = 1 - user; // 사람을 바꾼다. 0을 1로, 1을 0으로.

            System.out.println("score 1: " + scores[0]); // 첫 번째 사람의 현재 점수 표시
            System.out.println("score 2: " + scores[1] + "\n"); // 두 번째 사람의 현재 점수 표시
        }
    }

    public static void main(String[] args) {
        new Controller().run();
    }
}

1. Hamster robot
2. USB dongle

1. Software installation
2. Robot to PC connection
3. Run example files

1. Create a new project
2. Work in the cloud PC environment (optional)
3. Move on a board #1 (sequence, repetition)
4. Move and turn
5. Turn on LEDs and make a sound
6. Command in order repeatedly
7. Use proximity sensors
8. Move on a board #2 (repeat while)
9. Use floor sensors
10. Use light and acceleration sensors
11. Braitenberg's robot

1. Create a board game
2. Keyboard events
3. Graphical interface
4. Line following with one sensor
5. Line following with two sensors
6. Follow hamster friends (2 people 1 pair)
7. Follow a wall
8. Imitating a robot cleaner
9. Line following at intersection
10. Escape a maze

1. Assembling
2. Pin/socket layout
3. Digital input - Press button to beep
4. Digital output - LED is on when it is dark
5. Digital output - flashing twinkling LED
6. Digital output - LED is on in tilting direction
7. Analog input - Rotating the potentiometer changes the pitch.
8. Analog input - please do not let it get hot
9. Analog Input - Move along the light
10. PWM output - LED light gently brighter and darker
11. PWM output - LED candle shakes in the wind
12. Analog servo output - hamster robot has tail

1. Behavior based robot control
2. Path navigation
3. Swap