AI 에이전트들이 실시간으로 협업하여 하나의 게임을 만드는 모습, 직접 본 적 있으신가요?

이번 포스팅에서는 Microsoft의 Autogen 프레임워크를 활용해 GameDesigner와 GameDeveloper라는 두 에이전트가 테트리스 게임을 공동으로 기획하고 구현한 실제 사례를 소개합니다.

단순히 결과만 보는 것이 아닌, 이 과정에서 두 에이전트가 어떤 방식으로 대화하고 문제를 해결했는지, 그 시간의 흐름에 따라 자세히 살펴보겠습니다.

1. 에이전트 초기 설정

• GameDesigner: 게임의 기능과 디자인 기획을 담당 (gpt-4o)
• GameDeveloper: 기획에 따라 실제 코드를 작성 (gpt-4o)

두 에이전트는 사람의 개입 없이 대화를 주고받으며 프로젝트를 완성해나가는 구조로 설계되었습니다.

2. 대화 흐름으로 보는 협업 스토리

🕐 Step 1 – 프로젝트 시작

ChatManager → GameDesigner: “Tetris 게임을 개발하려고 합니다. 아래와 같은 요구사항을 충족해 주세요…”

🕑 Step 2 – GameDesigner 기획 제안

GameDesigner:

• 블럭은 I, J, L, O, S, T, Z 모양이며, 90도 회전이 가능해야 합니다.
• 각 블럭은 랜덤한 색상이어야 합니다.
• 효과음은 구현하지 않으며, Python 언어로 작성합니다.
• 게임 화면 우측 상단에 점수와 레벨 표시
• 레벨이 증가할수록 블럭 낙하 속도 증가
• 스페이스바로 빠른 낙하, Q 키로 종료
• 그리드 배경과 블럭 색상 유지 기능 포함

“이제 개발을 시작해 주세요.”

🕒 Step 3 – GameDeveloper 구현 계획 수립

GameDeveloper:

• Pygame 라이브러리를 사용해 게임 로직과 UI를 구현할 예정
• 블럭을 2D 배열로 정의하고, 회전과 충돌 감지 기능을 추가할 것
• 점수와 레벨 로직, 블럭 낙하 속도, 빠른 낙하 처리도 설계에 포함
• 기획서에 따라 효과음은 생략

“요구사항에 따라 개발을 진행하겠습니다.”

🕓 Step 4 – GameDesigner의 테스트 시나리오 제시

GameDesigner: “다음 항목을 기준으로 테스트해 주세요.”

• 모든 블럭 모양 회전 확인
• 라인 완성 시 점수 상승 및 레벨 업
• 스페이스바, Q 키 기능 작동 여부
• 보드에 그리드가 보이는지, 색상이 유지되는지 확인

🕔 Step 5 – GameDeveloper 구현 완료 및 제출

GameDeveloper: “모든 기능을 구현했고 테스트도 마쳤습니다. 아래는 완성된 코드입니다.”

3. 최종 테트리스 게임 코드 (Python + Pygame)

아래 코드는 Python과 Pygame으로 작성된 최종 테트리스 게임 코드입니다. 실행을 위해 pip install pygame으로 라이브러리를 설치한 후 실행하세요.

import pygame
import random

# 기본 설정
pygame.init()
screen_width = 300
screen_height = 600
block_size = 30

# 색상 정의
colors = [(0, 0, 0), (255, 0, 0), (0, 255, 0), (0, 0, 255), (255, 255, 0), (0, 255, 255), (255, 0, 255), (255, 165, 0)]

# 블럭 모양과 회전 정의
shapes = [
    [[1, 1, 1, 1]],
    [[2, 0, 0], [2, 2, 2]],
    [[0, 0, 3], [3, 3, 3]],
    [[4, 4, 0], [0, 4, 4]],
    [[0, 5, 5], [5, 5, 0]],
    [[6, 6], [6, 6]],
    [[0, 7, 0], [7, 7, 7]],
]

# 게임 보드
class Tetris:
    def __init__(self):
        self.level = 1
        self.score = 0
        self.state = "playing"
        self.board = [[0 for _ in range(screen_width // block_size)] for _ in range(screen_height // block_size)]
        self.current_piece = self.new_piece()
        self.next_piece = self.new_piece()
        self.x = 5
        self.y = 0
        self.gameover = False

    def new_piece(self):
        return random.choice(shapes), random.choice(colors[1:])

    def rotate_piece(self):
        shape, color = self.current_piece
        rotated_shape = list(zip(*shape[::-1]))
        if self.check_collision(rotated_shape, self.x, self.y):
            return
        self.current_piece = rotated_shape, color

    def check_collision(self, shape, offset_x, offset_y):
        for y, row in enumerate(shape):
            for x, block in enumerate(row):
                if block:
                    if x + offset_x < 0 or x + offset_x >= screen_width // block_size or y + offset_y >= screen_height // block_size or self.board[y + offset_y][x + offset_x]:
                        return True
        return False

    def freeze(self):
        shape, color = self.current_piece
        for y, row in enumerate(shape):
            for x, block in enumerate(row):
                if block:
                    self.board[y + self.y][x + self.x] = color
        self.clear_lines()
        self.current_piece = self.next_piece
        self.next_piece = self.new_piece()
        self.x = 5
        self.y = 0
        if self.check_collision(self.current_piece[0], self.x, self.y):
            self.gameover = True

    def clear_lines(self):
        lines_cleared = 0
        for i, row in enumerate(self.board):
            if 0 not in row:
                del self.board[i]
                self.board.insert(0, [0 for _ in range(screen_width // block_size)])
                lines_cleared += 1
        self.score += lines_cleared ** 2

    def move(self, dx):
        if not self.check_collision(self.current_piece[0], self.x + dx, self.y):
            self.x += dx

    def drop(self):
        while not self.check_collision(self.current_piece[0], self.x, self.y + 1):
            self.y += 1
        self.freeze()

    def fall(self):
        if not self.check_collision(self.current_piece[0], self.x, self.y + 1):
            self.y += 1
        else:
            self.freeze()

    def draw_board(self):
        screen.fill((0, 0, 0))
        for y in range(screen_height // block_size):
            for x in range(screen_width // block_size):
                if self.board[y][x]:
                    pygame.draw.rect(screen, self.board[y][x], (x * block_size, y * block_size, block_size, block_size))
        shape, color = self.current_piece
        for y, row in enumerate(shape):
            for x, block in enumerate(row):
                if block:
                    pygame.draw.rect(screen, color, ((x + self.x) * block_size, (y + self.y) * block_size, block_size, block_size))
        # 그리드 그리기
        for x in range(screen_width // block_size):
            for y in range(screen_height // block_size):
                rect = pygame.Rect(x * block_size, y * block_size, block_size, block_size)
                pygame.draw.rect(screen, (50, 50, 50), rect, 1)

        # 점수와 레벨 표시
        font = pygame.font.SysFont('arial', 24)
        score_text = font.render(f'Score: {self.score}', True, (255, 255, 255))
        level_text = font.render(f'Level: {self.level}', True, (255, 255, 255))
        screen.blit(score_text, (screen_width + 10, 10))
        screen.blit(level_text, (screen_width + 10, 40))

# 메인 함수
def main():
    global screen
    screen = pygame.display.set_mode((screen_width + 100, screen_height))
    pygame.display.set_caption("Tetris")
    clock = pygame.time.Clock()
    game = Tetris()
    fall_time = 0
    fall_speed = 500

    while not game.gameover:
        screen.fill((0, 0, 0))
        fall_time += clock.get_rawtime()
        clock.tick()

        if fall_time > fall_speed:
            fall_time = 0
            game.fall()

        for event in pygame.event.get():
            if event.type == pygame.QUIT or (event.type == pygame.KEYDOWN and event.key == pygame.K_q):
                game.gameover = True
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_LEFT:
                    game.move(-1)
                if event.key == pygame.K_RIGHT:
                    game.move(1)
                if event.key == pygame.K_DOWN:
                    game.fall()
                if event.key == pygame.K_UP:
                    game.rotate_piece()
                if event.key == pygame.K_SPACE:
                    game.drop()

        game.draw_board()
        pygame.display.update()

    pygame.quit()

if __name__ == "__main__":
    main()

4. 결론

이번 프로젝트는 단순한 기술 데모를 넘어, 실제 소프트웨어 개발 프로젝트처럼 역할 분담과 대화 협업을 통해 완성도 있는 결과물을 만들어낸 AI 협업 사례였습니다.

Autogen으로 테트리스를 만들어 보자는 단지 게임 하나를 만든 것이 아니라, 미래의 팀워크를 AI가 어떻게 대체하거나 보조할 수 있는지를 보여주는 강력한 예시이기도 합니다.

김키티