Godot 게임 개발 실제 순서 가이드

이 문서는 특정 게임이 아니라, 어떤 장르의 게임이라도 Godot에서 실제로 개발할 때 따라갈 수 있는 표준 개발 순서를 정리한 문서입니다.

        핵심 원칙
        처음부터 완성형 게임을 만들려고 하지 않는다.
먼저 실행되는 최소 게임을 만든다.
그 다음 기능을 하나씩 추가한다.
항상 작은 단위로 만들고 실행해서 확인한다.

    

0. 개발 전에 먼저 정해야 할 것

Godot을 열기 전에 아래 내용을 먼저 정해야 한다.

1. 게임 장르

예:

2D 플랫포머
2D RPG
탑다운 액션
퍼즐 게임
생존 게임
카드 게임
3D 액션
3D 어드벤처
시뮬레이션
전략 게임

2. 화면 방식

예:

2D 횡스크롤
2D 탑다운
2D 아이소메트릭
3D 1인칭
3D 3인칭
3D 고정 카메라

3. 조작 방식

예:

키보드
마우스
게임패드
터치

4. 게임의 최소 목표

예:

플레이어가 움직인다.
적이 등장한다.
공격할 수 있다.
점수를 얻는다.
스테이지를 클리어한다.
죽으면 다시 시작한다.

5. 첫 번째 빌드 목표

처음부터 모든 시스템을 만들지 않는다.
첫 번째 빌드는 반드시 작아야 한다.

예:
게임 실행 → 시작 화면 → 플레이어 등장 → 이동 → 기본 상호작용 → 실패 또는 클리어 조건 확인

1. Godot 프로젝트 생성

Godot 실행
New Project 선택
프로젝트 이름 입력
저장 폴더 선택
Renderer 선택

2D 게임: Compatibility 또는 Forward+ (가벼운 2D 게임이면 Compatibility도 충분하다.)
3D 게임: Forward+ 권장 (저사양 목표라면 Mobile 또는 Compatibility 고려)

프로젝트를 만든 뒤 바로 해야 할 것 (Project Settings에서 설정):

Display > Window > Size
Stretch Mode
Stretch Aspect
Input Map
Autoload
Physics 설정

2. 기본 폴더 구조 만들기

Godot 프로젝트 안에 먼저 폴더를 정리한다.

추천 구조:

res://
 ├ assets/
 │   ├ sprites/
 │   ├ models/
 │   ├ audio/
 │   ├ fonts/
 │   ├ ui/
 │   └ effects/
 │
 ├ scenes/
 │   ├ main/
 │   ├ ui/
 │   ├ player/
 │   ├ enemies/
 │   ├ world/
 │   ├ items/
 │   └ systems/
 │
 ├ scripts/
 │   ├ autoload/
 │   ├ player/
 │   ├ enemies/
 │   ├ ui/
 │   ├ world/
 │   ├ items/
 │   └ systems/
 │
 ├ data/
 │   ├ json/
 │   ├ xml/
 │   ├ csv/
 │   └ save/
 │
 └ resources/

처음부터 폴더를 정리해야 나중에 파일이 많아져도 무너지지 않는다.

3. 메인 씬 만들기

모든 게임에는 시작점이 필요하다.

기본 메인 씬: scenes/main/Main.tscn

추천 노드 구조:

Main
 ├ SceneContainer
 ├ UIContainer
 ├ AudioManager
 └ GameRoot

역할:

Main은 게임 전체의 루트
SceneContainer는 실제 게임 씬이 들어갈 자리
UIContainer는 메뉴, HUD, 팝업이 들어갈 자리
AudioManager는 배경음, 효과음을 관리
GameRoot는 현재 게임 상태를 관리

처음에는 복잡하게 만들 필요 없다.

Main 씬이 실행되고 빈 화면이라도 정상 실행되는지 확인한다.

4. 시작 화면 만들기

거의 모든 게임은 시작 화면이 필요하다.

씬 이름: scenes/ui/MainMenu.tscn

기본 노드 구조:

MainMenu
 ├ TitleLabel
 ├ StartButton
 ├ ContinueButton
 ├ OptionsButton
 ├ CreditsButton
 └ ExitButton

처음 구현할 기능:

StartButton 누르면 테스트 게임 씬으로 이동
OptionsButton 누르면 설정 패널 표시
ExitButton 누르면 게임 종료

중요: 처음부터 멋진 디자인을 만들지 않는다. 기능이 먼저다. 디자인은 나중에 정리한다.

5. 입력 설정 만들기

Project Settings > Input Map에서 입력을 먼저 정의한다.

2D 게임 기본 입력:
move_up, move_down, move_left, move_right, jump, attack, interact, dash, pause

3D 게임 기본 입력:
move_forward, move_backward, move_left, move_right, look_left, look_right, jump, attack, interact, pause

예시 키:
– move_up: W, ↑
– move_down: S, ↓
– move_left: A, ←
– move_right: D, →
– jump: Space
– attack: Mouse Left
– interact: E
– pause: Escape

중요: 코드에서 직접 키보드 키를 검사하지 말고 Input Map을 사용한다.

6. 플레이어 씬 만들기

게임에서 가장 먼저 만들어야 할 실제 대상은 플레이어다.

2D 플레이어 기본 씬: Player.tscn

Player
 ├ Sprite2D 또는 AnimatedSprite2D
 ├ CollisionShape2D
 ├ Camera2D
 └ AnimationPlayer

루트 노드:

2D 액션: CharacterBody2D
2D 물리 오브젝트: RigidBody2D
3D 캐릭터: CharacterBody3D

처음 구현할 기능:

이동
충돌
카메라 추적
애니메이션 전환
체력 변수

처음부터 공격, 스킬, 장비, 인벤토리를 넣지 않는다. 먼저 이동과 충돌을 완성한다.

7. 플레이어 이동 구현

2D 탑다운 기본 이동 예시:

extends CharacterBody2D

@export var speed: float = 120.0

func _physics_process(delta):
    var direction = Vector2.ZERO

    direction.x = Input.get_action_strength(“move_right”) – Input.get_action_strength(“move_left”)
    direction.y = Input.get_action_strength(“move_down”) – Input.get_action_strength(“move_up”)

    velocity = direction.normalized() * speed
    move_and_slide()

2D 플랫포머는 중력과 점프가 필요하다.

기본 흐름: 방향 입력 확인 → 속도 계산 → 중력 적용 → 점프 처리 → move_and_slide 실행

이 단계에서 확인할 것:

캐릭터가 움직이는가?
벽을 통과하지 않는가?
카메라가 따라오는가?
입력이 즉각 반응하는가?

8. 테스트 월드 만들기

플레이어를 테스트할 맵이 필요하다.

2D 게임: TileMapLayer 또는 TileMap 사용, 바닥 타일 배치, 벽 충돌 설정, 간단한 테스트 장애물 배치
3D 게임: Plane 또는 MeshInstance3D 배치, StaticBody3D로 바닥 충돌 설정, 벽 또는 큐브 배치, 조명과 카메라 설정

씬 이름: scenes/world/TestWorld.tscn

추천 구조:

TestWorld
 ├ Map
 ├ PlayerSpawnPoint
 ├ Objects
 ├ Enemies
 ├ Items
 └ WorldUI

중요: 처음 맵은 작아야 한다. 기능 테스트용 공간이면 충분하다.

9. 씬 전환 시스템 만들기

게임은 여러 씬을 오가야 한다.

예: MainMenu → TestWorld → GameOver → MainMenu

처음에는 간단히 get_tree().change_scene_to_file()을 사용해도 된다. 하지만 규모가 커지면 SceneManager를 만드는 것이 좋다.

SceneManager 역할:

씬 변경
로딩 화면 표시
현재 씬 추적
이전 씬 저장
씬 전환 효과 처리

Autoload로 등록할 수 있다. (scripts/autoload/SceneManager.gd)

10. GameManager 만들기

GameManager는 게임의 전체 흐름을 관리한다.

역할: 게임 시작, 게임 정지, 게임 오버, 게임 클리어, 현재 상태 관리, 점수 관리, 시간 관리

예시 상태:
enum GameState { MAIN_MENU, PLAYING, PAUSED, GAME_OVER, CLEAR }

중요: 플레이어 코드 안에 모든 게임 규칙을 넣지 않는다. 플레이어는 플레이어 행동만 담당한다. 전체 게임 흐름은 GameManager가 담당한다.

11. UI / HUD 만들기

게임 중 표시되는 UI를 만든다.

기본 HUD:

HUD
 ├ HealthBar
 ├ StaminaBar
 ├ ScoreLabel
 ├ ItemSlotContainer
 └ MessageLabel

처음 표시할 것: 체력, 점수, 현재 상태 메시지

중요: UI는 게임 로직과 분리한다. 플레이어 HP가 변하면 UI가 직접 HP를 계산하지 않고, 신호나 함수로 갱신만 한다.

12. 신호 구조 정리

Godot에서는 Signal을 잘 쓰는 것이 중요하다.

예: 플레이어가 피해를 입음, 체력이 바뀜, 아이템을 획득함, 적이 죽음, 점수가 증가함, 스테이지가 끝남

예시:
signal health_changed(current_hp, max_hp)

func take_damage(amount):
    hp -= amount
    health_changed.emit(hp, max_hp)

좋은 구조: Player → health_changed 신호 발생 → HUD가 받아서 체력바 갱신
나쁜 구조: Player가 직접 HUD 노드를 찾아서 체력바를 조작

13. 충돌과 상호작용 만들기

게임에는 오브젝트와 상호작용이 필요하다.

예: 문 열기, 아이템 줍기, NPC 대화, 상자 열기, 버튼 누르기

기본 구조:

InteractableObject
 ├ Sprite2D
 ├ Area2D
 └ CollisionShape2D

필요 변수: interaction_name, interaction_type, can_interact

플레이어가 Area2D에 들어오면 상호작용 가능 상태로 만든다. E 키를 누르면 interact() 함수 실행. 처음에는 메시지만 출력해도 된다.

14. 아이템 시스템 만들기

게임에 따라 아이템은 필요할 수도 있고 아닐 수도 있다.

기본 아이템 데이터:
{
    “id”: “potion_small”,
    “name”: “Small Potion”,
    “type”: “consumable”,
    “value”: 10
}

처음 구현: 아이템 줍기, 인벤토리에 추가, UI에 표시
나중에 확장: 사용, 장착, 판매, 제작, 등급, 내구도

중요: 처음부터 복잡한 인벤토리 시스템을 만들지 않는다. 먼저 아이템 하나를 줍고 목록에 표시하는 것부터 한다.

15. 적 또는 장애물 만들기

게임 장르에 따라 적 또는 장애물이 필요하다.

Enemy.tscn 기본 구조:

Enemy
 ├ Sprite2D
 ├ CollisionShape2D
 ├ Area2D
 └ AnimationPlayer

처음 적 기능: 정지 상태, 플레이어에게 닿으면 피해, 체력 보유, 사망 처리
그 다음: 순찰, 추적, 공격, 회피, 상태머신

적 AI는 처음부터 어렵게 만들지 않는다. 먼저 피해를 주고 죽을 수 있으면 된다.

16. 전투 시스템 만들기

전투가 있는 게임이라면 공격 구조를 만든다.

기본 흐름:

플레이어가 공격 입력
공격 판정 생성
적이 공격 범위에 들어옴
데미지 계산
적 HP 감소
적 사망 처리

중요 개념: 공격자, 피격자, 데미지, 공격 범위, 쿨타임, 무적 시간

처음에는 단순하게 만든다. 예: 마우스 클릭 → 앞쪽 Area2D 활성화 → 닿은 적에게 10 데미지

17. 상태머신 만들기

캐릭터나 적 행동이 많아지면 상태머신이 필요하다.

예시 상태: idle, move, attack, hurt, dead
플레이어 상태: idle, run, jump, fall, attack, dash
적 상태: idle, patrol, chase, attack, return, dead

상태머신을 사용하면 코드가 덜 꼬인다. 중요: 처음부터 모든 상태를 만들 필요 없다. idle, move, attack 정도부터 시작한다.

18. 애니메이션 연결

움직임과 전투가 어느 정도 되면 애니메이션을 연결한다.

사용 노드: AnimatedSprite2D, AnimationPlayer, AnimationTree
처음 연결할 애니메이션: idle, walk, attack, hurt, death

중요: 애니메이션은 기능보다 나중이다. 기능이 안 되는 상태에서 애니메이션만 먼저 만들면 디버깅이 어려워진다.

19. 사운드 시스템 만들기

사운드는 게임의 체감을 크게 바꾼다.

기본 사운드: 버튼 클릭음, 공격음, 피격음, 아이템 획득음, 배경음악

추천 구조:

AudioManager
 ├ BGMPlayer
 ├ SFXPlayer
 └ UIPlayer

AudioManager를 Autoload로 등록하면 편하다. 기능: BGM 재생, 효과음 재생, 볼륨 조절, 음소거, 설정 저장

20. 일시정지 시스템 만들기

대부분의 게임에는 일시정지가 필요하다.

입력: Escape 또는 Space
기능: 게임 정지, PauseMenu 표시, 계속하기, 설정, 메인 메뉴로 돌아가기
구현: get_tree().paused = true

주의: 일시정지 중에도 UI는 작동해야 한다. PauseMenu의 Process Mode를 Always로 설정해야 한다.

21. 설정 화면 만들기

Options 또는 Settings 화면을 만든다.

기본 설정: 전체 화면, 해상도, 마스터 볼륨, BGM 볼륨, SFX 볼륨, 언어, 조작키

처음에는 아래 3개만 만들어도 충분하다.

전체 화면
사운드 볼륨
언어 선택

설정값은 ConfigFile 또는 JSON으로 저장할 수 있다.

22. 저장 / 불러오기 시스템 만들기

게임에 진행 상태가 있다면 저장 시스템이 필요하다.

처음 저장할 것: 현재 씬, 플레이어 위치, 플레이어 체력, 점수, 인벤토리, 진행 상태

저장 위치: user://save_001.json

중요: 처음부터 완벽한 저장 시스템을 만들지 않는다. 먼저 플레이어 위치와 체력 저장부터 한다.

23. 데이터 구조 정리

게임 규모가 커지면 데이터 파일이 필요하다.

사용 가능한 데이터 형식: JSON, CSV, XML, Resource, SQLite, 자체 텍스트 포맷

초보자 추천: 간단한 게임(JSON), 표 형태 데이터(CSV), Godot 친화 구조(Resource), 복잡한 데이터베이스(SQLite)
데이터 예: 아이템, 적 정보, 스킬, 대화, 퀘스트, 상점, 맵 정보

중요: 코드 안에 모든 데이터를 하드코딩하지 않는다.

24. 스테이지 / 레벨 시스템 만들기

스테이지 기반 게임이라면 레벨 구조가 필요하다.

예: Level_01.tscn, Level_02.tscn, Level_03.tscn

각 레벨 구조:

Level
 ├ TileMap 또는 Map
 ├ PlayerSpawnPoint
 ├ EnemySpawnPoints
 ├ Items
 ├ Goal
 └ Triggers

기능: 레벨 시작, 클리어 조건 확인, 다음 레벨 이동, 실패 시 재시작

처음에는 Level_01 하나만 만든다.

25. 게임 오버와 클리어 만들기

게임은 실패와 성공 조건이 있어야 매끄럽게 돌아간다.

게임 오버 조건 예: 플레이어 HP 0, 제한 시간 초과, 목표 방어 실패, 낙사
클리어 조건 예: 목적지 도착, 모든 적 처치, 아이템 획득, 퍼즐 해결, 보스 처치

게임 오버 화면:
GameOverScreen
 ├ GameOverLabel
 ├ RetryButton
 └ MainMenuButton

클리어 화면:
ClearScreen
 ├ ClearLabel
 ├ NextStageButton
 └ MainMenuButton

26. 디버그 도구 만들기

개발 중에는 디버그 기능이 필요하다.

예: FPS 표시, 현재 위치 표시, 현재 상태 표시, 적 수 표시, 충돌 확인, 강제 클리어, 강제 저장, 강제 아이템 획득

디버그 도구는 개발 시간을 크게 줄인다.

DebugOverlay.tscn 예:

DebugOverlay
 ├ FPSLabel
 ├ PositionLabel
 ├ StateLabel
 └ ObjectCountLabel

27. 기능별 테스트 순서

새 기능을 만들 때마다 아래 순서로 확인한다.

씬이 열리는가?
노드 이름이 맞는가?
스크립트가 붙어 있는가?
에러 없이 실행되는가?
입력이 작동하는가?
충돌이 작동하는가?
UI가 갱신되는가?
저장 데이터가 깨지지 않는가?
다른 씬으로 이동해도 유지되는가?
게임을 다시 실행해도 정상인가?

이 과정을 무시하면 나중에 오류가 쌓인다.

28. 최소 플레이 가능 버전 만들기

최소 플레이 가능 버전은 게임의 첫 번째 핵심 목표다.

장르별 예:

2D 플랫포머: 시작 화면, 플레이어 이동, 점프, 장애물, 목적지, 클리어
탑다운 RPG: 시작 화면, 플레이어 이동, NPC 대화, 아이템 줍기, 간단한 전투, 저장
슈팅 게임: 시작 화면, 플레이어 이동, 총알 발사, 적 등장, 점수, 게임 오버
퍼즐 게임: 시작 화면, 퍼즐 조작, 정답 판정, 다음 스테이지, 재시작
생존 게임: 시작 화면, 플레이어 이동, 자원 수집, 체력 감소, 제작, 저장

이 단계가 끝나기 전까지는 대형 시스템을 만들지 않는다.

29. 콘텐츠 확장

최소 플레이 가능 버전이 완성된 뒤 콘텐츠를 늘린다.

확장 순서:

스테이지 추가
적 종류 추가
아이템 추가
UI 개선
사운드 추가
이펙트 추가
난이도 조정
저장 확장
옵션 확장
튜토리얼 추가

중요: 콘텐츠는 시스템이 안정된 뒤 늘린다. 시스템이 불안정한데 콘텐츠를 늘리면 수정이 지옥이 된다.

30. 폴리싱

폴리싱은 게임의 완성도를 올리는 단계다.

작업: UI 디자인 개선, 버튼 효과, 화면 전환 효과, 카메라 흔들림, 피격 이펙트, 사운드 타이밍, 애니메이션 보정, 텍스트 정리, 튜토리얼 문구 개선, 난이도 조정

중요: 폴리싱은 기능 완성 후에 한다. 처음부터 예쁘게 만들려 하면 개발이 느려진다.

31. 최적화

게임이 느려지면 최적화가 필요하다.

확인할 것: FPS, 노드 수, 충돌체 수, 이미지 크기, 사운드 파일 크기, 불필요한 _process 사용, 너무 많은 실시간 연산, 너무 많은 인스턴스 생성

Godot 최적화 기본:

필요 없는 노드는 비활성화
보이지 않는 오브젝트는 처리 중지
큰 이미지는 적절히 압축
반복 생성되는 오브젝트는 풀링 고려
_process보다 _physics_process를 필요한 곳에만 사용
신호 연결 중복 주의

32. 빌드 / 내보내기

Export Templates 설치 후 플랫폼별로 내보낸다.

플랫폼: Windows, macOS, Linux, Android, iOS, Web

내보내기 전에 확인: 메인 씬 설정, 아이콘 설정, 해상도 설정, 입력 설정, 저장 경로, 파일 포함 여부, 외부 데이터 포함 여부

Project > Export에서 프리셋을 만든다.

33. 테스트

빌드 후 반드시 실제 실행 파일로 테스트한다.

테스트 항목: 새 게임, 저장, 불러오기, 옵션 변경, 해상도 변경, 게임 오버, 클리어, 종료, 다시 실행, 조작키, 사운드, 성능

에디터에서 잘 되더라도 Export 빌드에서 안 되는 경우가 있다.

34. 버그 수정

버그 수정은 기록하면서 해야 한다.

버그 기록 예:

[버그] 플레이어가 벽에 끼임
[발생 조건] Level_01 오른쪽 벽에서 대시 사용
[원인] 대시 중 충돌 검사 누락
[수정] 대시 이동에도 move_and_slide 적용
[확인] 3회 재현 테스트 통과

버그를 감으로 고치면 같은 문제가 반복된다.

35. 버전 관리

게임 프로젝트는 반드시 백업해야 한다.

추천: Git 사용, GitHub 또는 GitLab 저장, 중요한 단계마다 ZIP 백업, 빌드 버전명 관리

버전 예:
v0.1.0 – 프로젝트 생성, 플레이어 이동 완성
v0.2.0 – 전투 시스템 추가
v0.3.0 – 저장 시스템 추가
v1.0.0 – 첫 정식 빌드

중요: 큰 수정 전에는 반드시 백업한다.

36. 실제 개발 추천 순서 요약

실제로는 아래 순서대로 진행하면 된다.

게임 장르 결정
최소 플레이 목표 결정
Godot 프로젝트 생성
폴더 구조 생성
Main.tscn 생성
MainMenu.tscn 생성
Input Map 설정
Player.tscn 생성
플레이어 이동 구현
TestWorld.tscn 생성
플레이어를 월드에 배치
카메라 연결
충돌 테스트
씬 전환 구현
GameManager 생성
HUD 생성
체력 또는 점수 표시
상호작용 시스템 구현
아이템 또는 목표 오브젝트 추가
적 또는 장애물 추가
공격 또는 회피 기능 추가
게임 오버 구현
클리어 조건 구현
일시정지 구현
설정 화면 구현
사운드 추가
저장 / 불러오기 구현
레벨 추가
콘텐츠 확장
디버그 도구 추가
폴리싱
최적화
Export 빌드
실제 실행 파일 테스트
버그 수정
버전 백업
배포

37. 절대 피해야 할 개발 방식

처음부터 거대한 시스템 만들기
이동도 안 되는데 인벤토리부터 만들기
저장도 안 되는데 콘텐츠만 늘리기
모든 코드를 한 파일에 넣기
노드 이름을 계속 바꾸기
테스트하지 않고 계속 코드 추가하기
백업 없이 대규모 수정하기
UI와 게임 로직을 섞기
플레이어 스크립트에 모든 기능 넣기
에러 메시지를 무시하기

이 방식으로 개발하면 프로젝트가 쉽게 망가진다.

38. 가장 좋은 개발 방식

하나 만들고 실행한다. 작동하면 저장한다. 다음 기능을 만든다. 다시 실행한다. 문제가 없으면 백업한다.

반복 순서:
기능 하나 작성 → 실행 → 오류 확인 → 수정 → 다시 실행 → 정상 작동 확인 → 백업 → 다음 기능 진행

이 방식이 가장 안전하다.

39. 초보자에게 가장 추천하는 첫 목표

처음 Godot 게임을 만든다면 아래 목표부터 완성한다.

첫 번째 목표:
게임 실행 → 시작 화면 표시 → Start 버튼 클릭 → 테스트 맵 진입 → 플레이어 표시 → WASD 이동 → 장애물 충돌 → 목표 지점 도착 → 클리어 화면 표시 → 다시 시작 가능

이것이 완성되면 이미 게임의 기본 구조는 만들어진 것이다. 그 다음부터 장르에 맞게 확장하면 된다.

40. 최종 결론

Godot 게임 개발의 핵심 순서는 다음과 같다.

작은 목표를 정한다.
프로젝트 구조를 만든다.
메인 씬을 만든다.
플레이어를 만든다.
테스트 월드를 만든다.
조작과 충돌을 완성한다.
UI와 게임 흐름을 만든다.
실패와 성공 조건을 만든다.
저장과 설정을 만든다.
콘텐츠를 늘린다.
최적화한다.
빌드하고 테스트한다.

가장 중요한 원칙: 작게 만들고, 자주 실행하고, 자주 백업하고, 하나씩 완성한다.

이 원칙을 지키면 어떤 장르의 게임이든 Godot에서 안정적으로 개발할 수 있다.