uhiyamaLab

前回の記事ではGodotの基礎学習についてまとめましたが、今回はその続編として、より実践的な2Dアクションアドベンチャーゲームの開発に挑戦しました。Udemyの「Godot4: Build a 2D Action-Adventure Game」というコースを完走し、基礎編では触れられなかった多くの実用的な機能を学ぶことができました。

このコースは、基本的なプレイヤー操作から始まり、NPCとの対話、パズル要素、敵との戦闘システムまで、2Dゲーム開発に必要な要素が体系的に網羅されています。具体的な内容はコース本編で学んでもらうとして、ここではコースを通して学んだGodotの重要機能や概念を復習します。

コース概要：2Dアクションアドベンチャーゲーム開発を通して学ぶ

今回受講した「Godot4: Build a 2D Action-Adventure Game」は、2Dアクションアドベンチャーゲームをゼロから作り上げることで、Godotの実践的な機能を体系的に学べる非常に優れた英語コースでした。具体的には以下のような内容を学びます。

• プレイヤーの8方向移動とアニメーション
• Terrains機能を使ったオートタイルによる環境構築
• Y-Sortによるキャラクターとオブジェクトの重なり順制御
• RigidBody2Dを使った物理パズル（ブロック押し）
• NPCとのダイアログシステムとポーズ制御
• Autoloadを使ったデータ永続化（宝箱の開封状態など）
• 敵AI、ノックバックを含む戦闘システム
• パーティクルエフェクトによる視覚効果

前回の記事で紹介した「Godot Engineで気軽に2Dゲームを作ろう」よりも難易度が少し上がりますが、簡易的な敵AI&戦闘システム&ダイアログシステムの構築方法が学べるのでとても有益です。

• どうやってエリア移動するの？
• どうやってモノを押すの？
• 発見済みの宝箱の状態をどのように維持するの？
• NPCとの会話をどうやって管理するの？
• 複数のスイッチを押したら開く扉はどのように実装する？
• 被ダメ時のホワイトフラッシュはどこで操作できる？

上記のような「ゲーム開発で本当に必要な知識」が詰まっており、Godotへの理解を一段階引き上げるのに役立ちます。

興味があれば、下記のUdemyサイトからコースを受講してみてください。

※Udemyは頻繁に90%OFFセールを開催しているので、お気に入りに登録して、セール時に購入することをおすすめします。英語に慣れていない場合でも、画面のコードを写経しつつ、ドキュメントを調べたりChatGPTやGeminiなどに質問をすれば、問題なく内容を理解できるはずです。難しかったら返金申請もできるので気軽にチャレンジしてみてください。

▶︎ Godot4: Build a 2D Action-Adventure Game (Udemy)

Godotの重要機能・概念の深堀りノート

ここからは、コースの学習を通して特に重要だと感じたGodotの機能や概念について、自身の理解を深めるためにまとめたノートを共有します。

NodeのProcess Mode：ポーズ機能の賢い使い方

Godotでは、各ノードのProcess Modeを設定することで、ゲームがポーズした際の動作を細かく制御できます。これは非常に強力な機能です。

例えば「NPCと会話中は背景の敵やプレイヤーは止めたいが、ダイアログウィンドウの操作は続けたい」という場面で活躍します。

• Pausable (停止可能): デフォルト。get_tree().paused = trueになると、_processや_physics_processが停止します。プレイヤーや敵など、ゲーム世界のオブジェクトに適しています。
• Always (常に実行): ポーズ状態を無視して常に動作します。会話中のNPCやUI、ポーズ中も流れ続けるBGMなどに使います。
• When Paused (ポーズ中のみ実行): ポーズ中だけ動作します。「PAUSE」と表示する画面など、ポーズメニュー専用のUIに適しています。

この仕組みにより、特定のノードだけポーズの影響を受けないように設定できます。

実装例: ダイアログ表示中にゲームをポーズする

※会話中はシーンが停止(get_tree().paused = true)されて、会話終了と同時に解除される

# NPC.gd

# このNPCノードのProcess Modeをインスペクターで "Always" に設定しておく

func _process(delta):
    # (プレイヤーが近くにいて、かつインタラクトキーが押されたら)
    if Input.is_action_just_pressed("interact") and can_talk:
        if is_dialog_active():
            # ダイアログを閉じてポーズ解除
            close_dialog()
            get_tree().paused = false
        else:
            # ダイアログを開いてゲームをポーズ
            open_dialog()
            get_tree().paused = true

このように、NPC自身の動作は止めずにゲーム全体をポーズすることで、安全にダイアログの開閉処理を行えます。

CharacterBody2DのMotion Mode：トップダウンと横スクロールの使い分け

CharacterBody2Dには、キャラクターの物理挙動を決定するMotion Modeという重要な設定があります。ゲームのジャンルに合わせて正しく設定することが肝心です。

• Grounded (接地): デフォルト。重力が自動で適用され、is_on_floor()などの床判定が機能します。ジャンプや落下があるプラットフォーマーや横スクロールアクションに最適です。
• Floating (浮遊): 重力の影響を受けず、床の概念もありません。トップダウン（見下ろし型）のアクションゲームやシューティングゲームなど、キャラクターがXY平面を自由に動き回るゲームに適しています。

実装例: トップダウン型の移動

# Player.gd (Motion Modeを "Floating" に設定)
extends CharacterBody2D

@export var speed: float = 200.0

func _physics_process(delta):
    var direction = Input.get_vector("move_left", "move_right", "move_up", "move_down")
    velocity = direction * speed
    move_and_slide()

Motion Modeを正しく設定しないと、意図しない重力が発生したり、床判定がうまく機能しなかったりするため、プロジェクト開始時に必ず確認すべき項目です。

InputMap：キーバインドの効率的な管理

GodotのInput Map（プロジェクト設定 → Input Map）は、キーボードのキーやゲームパッドのボタンに「アクション名」を割り当てる機能です。これにより、コード内では具体的なキー名（”Aキー”など）ではなく、抽象的なアクション名（”move_left”など）で入力を扱えるようになります。

利点:

• 複数のキーを同じアクションに割り当て可能（例: “move_left”に「A」と「左矢印キー」を登録）。
• キーコンフィグ機能の実装が容易になる。
• コードの可読性が向上する。

実装例: InputMapを使った入力取得

func _process(delta):
    # 単発の入力（ボタンが押された瞬間）
    if Input.is_action_just_pressed("interact"):
        open_chest()
    
    # 継続的な入力（ボタンが押され続けている間）
    if Input.is_action_pressed("dash"):
        speed = DASH_SPEED
    else:
        speed = NORMAL_SPEED
    
    # 2軸のアナログ的な入力（非常に便利）
    var direction = Input.get_vector("move_left", "move_right", "move_up", "move_down")
    velocity = direction * speed
    move_and_slide()

特にInput.get_vector()は、4つのアクションから正規化されたVector2を返してくれるため、トップダウンの移動処理を非常に簡潔に記述できます。

Godotの基本的な入力処理：just_pressed、pressed、releasedの使い分け

[Godot公式ドキュメント Inputについて – Godot Doc]

InputMapでアクションを定義した後は、実際のゲーム内でその入力を適切に処理する必要があります。Godotでは入力の状態に応じて複数のメソッドが用意されており、用途に合わせて使い分けることが重要です。

入力状態の種類

• is_action_just_pressed()：ボタンが押された瞬間のみtrue
• is_action_pressed()：ボタンが押されている間ずっとtrue
• is_action_just_released()：ボタンが離された瞬間のみtrue

実用的な使い分け例

func _process(delta):
    # 1回限りのアクション（ジャンプ、攻撃、メニュー開閉など）
    if Input.is_action_just_pressed("jump"):
        if is_on_floor():
            velocity.y = JUMP_VELOCITY
    
    if Input.is_action_just_pressed("attack"):
        perform_attack()
    
    if Input.is_action_just_pressed("pause"):
        toggle_pause_menu()
    
    # 継続的なアクション（移動、ダッシュ、チャージなど）
    if Input.is_action_pressed("dash"):
        current_speed = dash_speed
    else:
        current_speed = normal_speed
    
    # チャージ系の処理
    if Input.is_action_pressed("charge"):
        charge_power += charge_rate * delta
        charge_power = min(charge_power, max_charge)
    
    # ボタンを離した瞬間の処理（チャージ攻撃の発動など）
    if Input.is_action_just_released("charge"):
        fire_charged_shot(charge_power)
        charge_power = 0.0

よくある間違いと対策

間違いの例：連続発動してしまう処理

# 悪い例：is_action_pressed()を使うと毎フレーム弾が発射される
func _process(delta):
    if Input.is_action_pressed("shoot"):  # 間違い
        fire_bullet()  # 毎フレーム実行されてしまう

# 良い例：is_action_just_pressed()で1回限りの発動
func _process(delta):
    if Input.is_action_just_pressed("shoot"):  # 正しい
        fire_bullet()  # ボタンを押した瞬間のみ実行

高度な入力処理：get_action_strength()とアナログ入力

ゲームパッドのアナログスティックやトリガーのような、0.0〜1.0の範囲で値が変化する入力にはget_action_strength()を使用します。

func _process(delta):
    # アナログ入力の取得（0.0〜1.0の値）
    var move_strength = Input.get_action_strength("move_forward")
    var brake_strength = Input.get_action_strength("brake")
    
    # 車の加速処理例
    if move_strength > 0.0:
        velocity += forward_direction * acceleration * move_strength * delta
    
    # ブレーキ処理例
    if brake_strength > 0.0:
        velocity = velocity.move_toward(Vector2.ZERO, brake_force * brake_strength * delta)

処理関数の使い分け指針

この使い分けを理解することで、プレイヤーにとって自然で反応の良い操作感を実現できます。

移動系組み込み関数：move_and_slideとmove_towardの使い分け

Godotには移動に関する便利な関数が多数用意されていますが、特にmove_and_slide()とmove_toward()の使い分けは重要です。

• move_and_slide(): CharacterBody2Dの主力関数。現在のvelocity（速度）に基づいてオブジェクトを移動させ、壁や床との衝突を自動で処理し、適切にスライドさせてくれます。物理挙動の基本はこれに任せるのが定石です。
• move_toward(target_velocity, delta): 現在の速度を、目標の速度に向かって指定した量（delta）だけ変化させます。急な速度変化を避け、滑らかな加速・減速を表現するのに役立ちます。

なぜ移動処理とノックバック処理の両立にmove_towardが必要だったのか？
コース内でノックバック機能を実装する際、通常の移動処理とノックバック処理を両立させる必要がありました。最初は単純にvelocityを直接設定していましたが、これではノックバック効果が一瞬で消えてしまう問題が発生しました。

move_towardのdeltaパラメータの役割
move_toward(target_velocity, delta)の第2引数deltaは、「現在の速度から目標速度に向かって、今回のフレームでどれだけ移動するか」を指定します。通常はacceleration * deltaの形で使用します。

# 問題のあるコード例（直接代入）
func move_player():
    var move_vector = Input.get_vector("move_left", "move_right", "move_up", "move_down")
    # 直接代入：入力があると即座に目標速度になる
    velocity = move_vector * move_speed
    # ノックバック後に入力があると、ノックバック効果が瞬時に消える

# 改善されたコード：move_towardを使用
@export var acceleration: float = 500.0  # 1秒間に500ピクセル/秒の加速

func move_player():
    var move_vector = Input.get_vector("move_left", "move_right", "move_up", "move_down")
    var target_velocity = move_vector * move_speed
    # 段階的変化：現在の速度から目標速度へ少しずつ近づく
    velocity = velocity.move_toward(target_velocity, acceleration * delta)
    
# ノックバック処理
func apply_knockback(direction: Vector2, strength: float):
    # velocityに直接力を加える
    velocity += direction * strength

具体的な動作例（フレームごとの変化）：

シナリオ：プレイヤーが敵の攻撃を受けた場合

1. 攻撃前：velocity = (100, 0) ※右方向に移動中
2. 攻撃直後：apply_knockback()でvelocity = (100, 0) + (200, 0) = (300, 0) ※右方向に吹き飛ばされる
3. その後の復帰過程（acceleration = 500、delta = 0.016秒、プレイヤーは右キーを押し続けている場合）：
   • 目標速度：target_velocity = (100, 0) ※通常の移動速度
   • フレーム1：velocity = (300, 0).move_toward((100, 0), 500 * 0.016) = (292, 0)
   • フレーム2：velocity = (292, 0).move_toward((100, 0), 8) = (284, 0)
   • フレーム3：velocity = (284, 0).move_toward((100, 0), 8) = (276, 0)
   • …25フレーム後：velocity = (100, 0) ※通常速度に復帰

直接代入の場合の問題：

1. 攻撃前：velocity = (100, 0)
2. 攻撃直後：velocity = (300, 0)
3. 次フレーム：velocity = target_velocity = (100, 0) ※ノックバック効果が即座に消失

つまり、move_towardにより「吹き飛ばされた状態のvelocityから、acceleration * deltaの速度で本来の移動ポイント（target_velocity）に段階的に復帰する」という理解が正確です。

敵AIでも同じ原理
敵も同様にmove_towardを使うことで、攻撃を受けてノックバックされた後も、自然にプレイヤー追跡を再開できます。

# 敵のAI例
@export var chase_acceleration: float = 300.0

func chase_target():
    if target:
        var direction = global_position.direction_to(target.global_position)
        var target_velocity = direction * chase_speed
        # ノックバック効果を保持しつつ、段階的に追跡速度へ変化
        velocity = velocity.move_toward(target_velocity, chase_acceleration * delta)

move_towardの3つの効果：

• ノックバック保持：直接代入ではなく段階的変化により、ノックバック効果が即座に消えない
• 制御可能な復帰速度：accelerationの値により、ノックバック後の復帰速度を細かく調整可能
• 滑らかな操作感：急激な方向転換を避け、慣性のある自然な動きを実現

この手法により、プレイヤーも敵も、ノックバック効果を受けながら自然な移動感を維持できるようになりました。accelerationパラメータを調整することで、キャラクターごとに異なる「重さ」や「機敏さ」を表現することも可能です。

グループ：柔軟なオブジェクト判定の要

グループは、あらゆるノードに付与できるタグのようなものです。UnityのTagシステムと非常に似ており、オブジェクトの種類を柔軟に識別できます。Unityでは1つのGameObjectに1つのTagしか設定できませんでしたが、Godotのグループは複数設定可能で、より柔軟な分類ができます。

例えば、「プレイヤーの攻撃が当たったオブジェクトが “enemy” グループに属しているか？」といった判定が簡単に記述できます。is Playerのような型チェックよりも汎用性が高く、Godot開発では頻繁に使われます。

使い方:

1. 判定したいノード（例: Slime）を選択し、インスペクターの「Node」タブ → 「Groups」で “enemies” などのグループ名を入力して追加。
2. コード内でis_in_group()メソッドを使って判定する。

実装例: プレイヤーの攻撃範囲に入ったオブジェクトを判定する

# Playerの攻撃判定用Area2Dに接続された関数
func _on_sword_area_body_entered(body: Node2D):
    # 接触したオブジェクトが "enemies" グループならダメージ処理
    if body.is_in_group("enemies"):
        body.take_damage(attack_power)
    
    # 接触したオブジェクトが "pushable" グループなら押せるオブジェクト
    elif body.is_in_group("pushable"):
        # ...オブジェクトを押す処理
        pass

Collision Layers/Masks：衝突判定の整理術

衝突判定を整理するため、GodotはLayers（レイヤー）とMasks（マスク）という仕組みを提供しています。これらを正しく設定することで、パフォーマンスを向上させ、意図しない衝突を防ぐことができます。

• Collision Layer: そのオブジェクトが「どの層に存在するか」を示します。
• Collision Mask: そのオブジェクトが「どの層と衝突判定を行いたいか」を示します。

レイヤー分けの例:

• Layer 1: Player – プレイヤーキャラクター
• Layer 2: Enemies – 敵キャラクター
• Layer 3: Weapons – プレイヤーの武器（攻撃判定）

シチュエーション別のMask設定:

プレイヤー（Layer 1）の場合:
敵に接触してダメージを受けたいので、Maskに「Layer 2: Enemies」を設定します。

敵（Layer 2）の場合:
プレイヤーに接触してダメージを与えたいが、敵同士はすり抜けて欲しいので、Maskに「Layer 1: Player」のみを設定します。

プレイヤーの武器（Layer 3）の場合:
敵だけを攻撃したいので、Maskに「Layer 2: Enemies」のみを設定します。プレイヤー自身とは衝突しません。

# コード例：衝突判定での使い分け
func _on_weapon_area_body_entered(body):
    # 武器のArea2DのMaskで「Layer 2: Enemies」のみ設定しているため、
    # この関数には敵だけが入ってくる
    if body.is_in_group("enemies"):
        body.take_damage(attack_power)

「プロジェクト設定」→「Layer Names」で各レイヤーに名前を付けておくと、インスペクターでの設定が非常に分かりやすくなります。

Terrains機能：RPGツクール並みのオートタイル作成

GodotのTerrains機能は、いわゆる「オートタイル」を驚くほど簡単に作成できるシステムです。UnityでRule Tileを使ったことがある人なら、その設定の直感性と手軽さに感動するはずです。

基本的な手順は、TileSetリソース内で「Terrains」タブを開き、タイルのどの辺がどのTerrain（地形タイプ、例: 草、土）に接するかを視覚的にペイントしていくだけです。あとはTileMapエディタでブラシツールを使えば、境界線を自動で判断して適切なタイルを配置してくれます。

便利機能:

• ランダムブラシ：ダイスアイコンで複数タイルからランダム選択
• 確率制御：特定タイルの出現頻度を調整可能
• Physics一括設定：「F」キーで全タイルに衝突判定を一括適用

Marker2D：なぜ管理ノードに最適なのか

シーン内に物理的な実体はないが、スクリプトをアタッチして何かを管理させたい場合（例: GameManager, PuzzleManager）、Unityでは空のGameObjectを使います。Godotにおけるその役割を果たすのがMarker2Dです。

Marker2Dは、位置情報(Transform)だけを持つ最も軽量な2Dノードです。レンダリングや物理演算の負荷が一切ないため、シーン全体のイベントやデータを管理する「マネージャー」役のスクリプトを配置するのに最適です。

Editable ChildrenとScene継承：NPCの効率的な量産方法

Godotでは、一つのベースとなるシーンからバリエーションを作成する方法として、主に2つのアプローチがあります。

• Editable Children (子ノードを編集可能にする): シーンに配置したインスタンスを右クリックし、「Editable Children」を選択すると、そのインスタンスの中身（スプライトや当たり判定など）を直接編集できます。変更はそのシーン内にのみ保存されます。
  用途: 機能は同じだが、見た目やセリフだけが違うモブNPCを大量に配置する場合に便利。
• Scene Inheritance (シーンの継承): ベースとなるシーン（例: BaseNPC.tscn）を継承して、新しいシーン（例: Shopkeeper.tscn）を作成します。継承シーンでは、親の機能を引き継ぎつつ、新しいノードやスクリプトを追加して独自の機能を実装できます。
  用途: 「話す」という基本機能に加えて「アイテムを売買する」という特別な機能を持つ商人NPCなど、機能的に異なる派生種を作る場合に最適。

使い分けの指針:

Autoload：シーンをまたぐデータ管理の仕組み

Autoloadは、UnityのDontDestroyOnLoadとシングルトンパターンを組み合わせたような機能です。プロジェクト設定でスクリプトやシーンをAutoloadに登録すると、ゲーム起動時に自動で読み込まれ、どのシーンからでもグローバルな変数としてアクセスできるようになります。

使い方:

1. グローバル管理用のスクリプト（例: GameManager.gd）を作成する。
2. 「プロジェクト設定」→「AutoLoad」タブで、作成したスクリプトを登録し、グローバル名（例: GameManager）を付ける。

実装例: 開封済みの宝箱の状態を記録する

# GameManager.gd (AutoLoadに登録)
extends Node

var opened_chests: Array[String] = []
var player_hp: int = 3
var player_spawn_position: Vector2

# ...その他のグローバルデータ

# TreasureChest.gd
extends StaticBody2D

@export var chest_id: String # インスペクターでユニークなIDを設定 ("forest_chest_01"など)

func _ready():
    # ゲームマネージャーに自分のIDが記録されていれば、開封済みにする
    if GameManager.opened_chests.has(chest_id):
        play_open_animation(false) # アニメーションだけ再生

func open_chest():
    # ...開封処理...
    GameManager.opened_chests.append(chest_id) # IDを記録
    play_open_animation(true)

これにより、プレイヤーの体力、スコア、インベントリ、クエストの進捗など、シーンをまたいで維持したいデータを簡単に管理できます。

視覚効果：modulateによるホワイトフラッシュ実装

キャラクターがダメージを受けた際に一瞬白く光る「ホワイトフラッシュ」効果は、CanvasItem（Sprite2DやCharacterBody2Dなどが継承）が持つmodulateプロパティで簡単に実装できます。

modulateは、ノードとその子孫の色に乗算されるカラー値です。デフォルトは白(1, 1, 1)で、これを変更することでノード全体の色調を手軽に変えられます。

modulateの特徴

• 継承性：親ノードから子ノードに自動継承
• 乗算処理：元の色に対して乗算で色調変更
• 範囲：1.0が基準値、それ以上で明るく、以下で暗く

実装例: 被ダメージ時のフラッシュ

# Player.gd
func take_damage(amount):
    # ...ダメージ計算...
    
    # フラッシュ処理を呼び出す
    flash_effect()

func flash_effect():
    # 白く光らせる (元の色に乗算されるので、大きな値にすると明るくなる)
    modulate = Color(2, 2, 2)
    
    # 0.1秒待機 (awaitを使うと非同期処理を簡潔に書ける)
    await get_tree().create_timer(0.1).timeout
    
    # 元の色に戻す
    modulate = Color(1, 1, 1)

await get_tree().create_timer(0.1).timeoutは、タイマーノードを追加しなくても一時的な待機処理を1行で書ける便利な記法です。CharacterBody2Dのmodulateを変更すれば、その子であるAnimatedSprite2Dも自動的に色が変わるため、個別にスプライトを操作する必要がありません。

AnimatedSprite2D vs AnimationPlayer：アニメーション機能の使い分け

Godotには主要な2Dアニメーションシステムが2つあり、用途に応じて使い分けることが重要です。

AnimatedSprite2D

• 用途：スプライトフレームアニメーション
• 特徴：スプライトシートから直接アニメーション作成
• 適用場面：キャラクターの歩行、攻撃、アイドルアニメーション

# AnimatedSprite2Dの基本使用
if velocity.x > 0:
    $AnimatedSprite2D.play("move_right")
elif velocity.x < 0:
    $AnimatedSprite2D.play("move_left")
else:
    $AnimatedSprite2D.stop()

AnimationPlayer

• 用途：複合的なアニメーション制御
• 特徴：位置、回転、スケール、プロパティを同時制御
• 適用場面：剣を振る動作、UI演出、カメラワーク

# AnimationPlayerの使用例（剣を振る動作）
func attack():
    var player_animation: String = $AnimatedSprite2D.animation
    if player_animation == "move_right":
        $AnimatedSprite2D.play("attack_right")
        $AnimationPlayer.play("attack_right")  # 剣の位置・角度を制御

UnityのAnimatorとの比較

Unity Animator ≈ Godot AnimationPlayer

• 共通点：状態遷移、ブレンド、複数プロパティの同時制御
• 違い：GodotのAnimationPlayerはより直接的で設定が簡単

UnityのAnimatorは状態機械ベースですが、GodotのAnimationPlayerはより直接的にアニメーションを制御できます。複雑な状態遷移が必要な場合はAnimationTree（Godotの上位システム）を使用します。

使い分けの指針

実際の開発では、キャラクターの基本動作にAnimatedSprite2D、武器やエフェクトの動作にAnimationPlayerを組み合わせて使用することが多くなります。

まとめ：実践開発から見えたGodotの真価

今回の実践的なコースを通して、Godotの設計思想の美しさと、2Dゲーム開発におけるその強力さを改めて実感しました。基礎学習だけでは見えなかった、実際の開発フローにおけるGodotの優位性が数多くありました。

特に印象的だった点

• 一貫した設計思想：Process Mode、Motion Mode、Collision Layersなど、概念が統一されている
• 組み込み機能の充実：move_and_slide()、Terrains、Y-Sortingなど、よく使う機能が標準搭載
• 直感的なワークフロー：Editable Children、Autoload、awaitなど、開発効率を重視した設計
• 軽量性と拡張性の両立：Marker2D、Signalシステムなど、必要な部分のみを軽量に実装

特に、ノードベースの設計とシグナルシステムの組み合わせは、オブジェクト間の連携を疎結合に保ちつつ、直感的な開発を可能にしてくれます。また、Terrains（オートタイル）やY-Sort、各種組み込み関数など、「こういう機能が欲しかった」というかゆいところに手が届く機能が標準で充実している点も大きな魅力です。

Unity経験者から見たGodotの位置づけ

Unity経験者にとって、Godotは「学習しやすく、使いやすい」ゲームエンジンという印象です。完全な乗り換えではなく、プロジェクトの性質に応じて使い分ける選択肢として、非常に有力だと感じました。

Godotが特に優れている分野：

• 2Dゲーム開発（機能が非常に洗練されている）
• インディーゲーム開発（軽量で高速な開発サイクル）
• プロトタイピング（直感的な操作性）
• 教育用途（概念が理解しやすい）

Unityと比較した場合、アセットストアの規模や情報量ではまだ及びませんが、こと2Dゲーム開発、特にピクセルアート系のゲームにおいては、Godotは非常に強力な選択肢であると確信しました。エンジン自体の軽量さも相まって、プロトタイピングから製品リリースまで、ストレスなく高速に開発サイクルを回せるポテンシャルを感じます。

今後の学習計画

基礎編、実践編を通して、Godotの基本的な開発フローは理解できました。今後は以下の分野をさらに深く学習していきたいと考えています：

• 3Dゲーム開発：Godotの3D機能の探求
• 高度なシステム：AnimationTree、VisualScript、GDExtensionなど
• パフォーマンス最適化：大規模プロジェクトでの最適化手法
• アセット管理：効率的なプロジェクト構成とワークフロー

今後もGodotの学習を続け、3D機能やより高度なシステムについても探求していきたいと考えています。この学習ノートが、これからGodotでゲーム開発を始める方、特にUnityからの移行を検討している方の一助となれば幸いです。

▶︎ Godot4: Build a 2D Action-Adventure Game (Udemy)

※Godot公式が配布しているのデモプロジェクト (最初の2Dゲーム)

Godot Engineについてご存知でしょうか？

2014年にオープンソース化されたMITライセンスのゲーム開発エンジンですが、近年注目された要因は2023年9月22日にUnityがインストールごとに料金を徴収する新料金プラン「Runtime Fee」を発表したことでした。この発表はコミュニティから大批判を受け、Unityは最終的に方針を撤回しましたが、この騒動をきっかけに多くの開発者がGodotへの移行を検討し、一気に知名度が上がりました。

私自身も以前から興味は持っていたものの、UnityやUnreal Engineでの開発に慣れていたためなかなか手が出せずにいました。しかし、近年Godotが順調に機能拡張を続けており、また気分転換という意味合いも込めて、本格的にGodot学習を開始してみることにしました。

※学習中のUdemyコース「Godot4: Build a 2D Action-Adventure Game (link)」

今回はUdemyの「Godot Engineで気軽に2Dゲームを作ろう」というコースを修了した感想と、主にUnity開発者視点でみたときのGodotに対する疑問点を自分の学習ノートを見ながらまとめたいと思います。

なお、私はあくまでGodot初学者です。Godotについて技術的アドバイスができるほどの知見はまだないですが、初学者だからこそ感じられる疑問点や感動などを記録しておくことで、これからGodotを学習し始める人の参考になればと考えています。

▶︎ Godot Engine 公式サイト

Godot Engineに対するQ&A

下記は自分がGodot学習前に書き記していた疑問に対する自問自答文です。

Q. Godot Engineって？
A. 2014年にオープンソース化されたゲーム開発エンジン。MITライセンスのため完全無料で利用可能。エンジン本体はC++製。

Q. UnityやUnreal Engineと比べた第一印象
A. エンジンが圧倒的に軽量（v4.4.1時点の実行ファイルは約149MB）。ただし日本語情報が少ない。

Q. Godotで作られた有名ゲームって？
A. 「Backpack Battles」、「Backshot Roulette」、「Unrailed 2: Back on Track」など。

Q. ノードベースってなに？
A. 例えば、物理判定のあるキャラクターを作成する場合、CharacterBody2Dというノードの中に、AnimatedSprite2Dというアニメーション用のノードと、CollisionShape2Dという衝突判定用ノードを設置する。Godotはこのようにノードをネストする形で個々の機能を作成していく。

Q. ノードベースって難しい？
A. 簡単。最初は戸惑うかもしれないが、Unityでコンポーネントをアタッチしていく感覚と同じ。

Q. ノードベースって自由度低そうじゃない？
A. 「ノード」と聞くとプリセット範囲でしか値が変更できないような窮屈なイメージがあったが、実際はノードを継承して様々な独自実装ができるので、コーディング体験はUnityやUnreal Engineと何も変わらない。自由。

Q. GDScriptって何？
A. PythonベースのGodot独自言語。開発には基本的にこれを使う。C#も使えるらしいけど、少なくとも基礎学習の範囲では素直にGDScriptで進めたほうが良い。構文もシンプルで理解しやすい。

※Godotで開発されたゲームについては、公式サイトのShowcaseページで一部を閲覧できます。各年度のまとめ動画がオススメです。

Godot基礎学習の開始

新しいゲームエンジンを学習するうえで、公式ドキュメントを確認したり、デモプロジェクトを動かしてみるのは非常に重要です。

私はそれに加えて、YouTubeやUdemyなどの動画チュートリアルを複数個完了させることで基礎を固めています。今回はUdemyにて「Godot Engineで気軽に2Dゲームを作ろう」という基礎に最適なコースを見つけました。これを6.5時間ほどかけて修了しました。

Godotの独自仕様については、ChatGPTやClaudeなどに「これはUnity/Unreal Engineで例えるとどのようなものか？」と質問しながら進めると基礎学習がはかどります。

・@exportは、UnityのSerializeFieldのようなもの
・get_tree().change_scene_to_file()は、UnityのSceneManager.LoadSceneのようなもの

もちろん細かい仕様は異なるとは思いますが、他のゲームエンジンの概念と紐づけることで理解が促進されます。

Udemy講座「Godot Engineで気軽に2Dゲームを作ろう」を学んだ感想

※コースの手順で作成できるゲームの完成形

カリキュラム概要

• Section 1-3： 基礎（プロジェクト設定、ノード・シーン理解）
• Section 4-5： 出力（Windows、Web向けビルド）
• Section 6-9： 2Dゲーム基礎（Player、Mob、HUD実装）
• Section 10： GDScript詳細
• Section 11-13： 高度な2D機能（迷路生成、シーン遷移）
• Section 14-18： システム機能（BGM、UI、データ保存、敵AI、射撃システム）

基礎にフォーカスされたコースで、Godotのインストール手順、セットアップ、エディタの見方、公式デモの実演、より実践的なオリジナルゲームの開発という流れで説明が進みます。1動画あたり1~5分で要点を簡潔に説明してくれるため、サクサクと内容を理解することができました。

オリジナルゲーム開発では、穴掘り法アルゴリズムを用いた迷路のプロシージャル生成、UI作成、データ保存、射撃システムなど、非常に実践的でツボを抑えた解説がされます。これによりタイトル、エリア選択、迷路、タイトルというゲームサイクルを構築することができます。

※穴掘り法アルゴリズムの実行ログ

Godotに興味はあるけどまだ触れたことがない、という人はこのコースから基礎学習を開始することをおすすめします。Godotの日本語情報は非常に少なく、ここまでキレイに整備されたカリキュラムは稀有なので、こうしたコースを第一歩にしてから、より複雑な英語圏のGodotコースを受講するのが良いでしょう。

Udemyはかなり頻繁にセールをしているので、とりあえずお気に入りに登録して、セールのときに購入して空き時間に消化するというスタイルがオススメです。

▶︎ Godot Engineで気軽に2Dゲームを作ろう (Udemy)

ここからはコースの内容ではなく、Godotエンジンに初めて触れて驚いたことや、実際に学習を進めながらメモしたGodotとUnityの対応表などについてまとめてみます。

Godotに触れて感動したこと

このコースを通じて、Godotの設計思想の美しさを実感できました。特に印象的だったのは以下の点です：

• ノードシステムの直感性： 「ノード」と「シグナル」を使いこなせるようになるとGodotは超快適です。エンジン自体が軽量なので、UnityやUEのようにエディタのロードやコンパイルに時間を取られることなく、ガシガシとコードを書いて開発を進めることができます。シグナルは最初は混乱しますが、Unityなどでイベント駆動開発をしたことがある人ならすぐ理解できると思います。
• シーンの再利用性： GodotのシーンはUnity開発者ほど最初は混乱するかもしれませんが、実際の開発体験はUnityと大差ありません。例えば、Unityでは全体管理用のGameManagerというスクリプトをアタッチした空のGameObjectをPrefab化してシーンに配置すると思います。Godotは空のシーンは作れないので、最も軽量なMaker2DというノードにGameManagerスクリプトをアタッチし、そのシーンを別シーンに配置することで再利用することができます。また、グローバル設定にシーンを登録することでシングルトン化することも可能です。つまり、最初の混乱を乗り越えたら、既存のUnity知識がGodot理解の助けになってくれます。
• 軽量な動作： Unreal Engineは言わずもがなですが、Unityでもプロジェクトを開くときに関連パッケージの読み込みに時間がかかることがあります(※Unity6でかなり改善された気はする)。ですがGodotはそもそものエンジンサイズが軽量で、公式サイトからダウンロードしたエディタの.exeをクリックするだけですぐにゲーム開発を再開できるのでストレスがありません。そのうえでしっかりとした開発機能はあるので、かなり面白いエンジンだなと思いました。
• 2D機能の充実： TileMapやAnimatedSprite2Dなど専用ノードの豊富さ
• AnimatedSprite2Dのスプライトシート制作が快適： UnityではスプライトシートをSliceして、個別画像をAnimatorコンポーネントなどに設定して～とかなり手間がかかります。しかしGodotはAnimatedSprite2DのSpriteでスプライトシートを選択してグリッドアイコンを押して、スプライトシートから必要な画像(例: 右歩行の差分4枚)をクリックしたら、即座にタイムラインにその画像が並びます。2Dゲーム開発者ならこの快適さが伝わるのではないでしょうか。
• タイルセット作成時の衝突判定設定が簡単： Unityではオートタイルの登録や衝突判定を設定してタイルシートを作成するのにかなり手間が必要です。一方、Godotではより直感的に進行可否部分を設定することができ、Physics Layerの設定でタイルごとの当たり判定を効率的に管理できます。複雑な設定なしに、視覚的にタイルの衝突範囲を決められるため、ストレスがほとんどありませんでした。

Unity開発者向け: Godotとのおおよその対応表

Unity開発者がGodotを学習する際に、概念的にあらかじめ知っておくと理解の助けになる対応表を作成しました。これから基礎学習を始める前にざっと目を通しておくことをおすすめします。

シーン・オブジェクト関連

• Godotのシーン ≒ UnityのPrefab + Scene
• get_tree().change_scene_to_file() ≒ SceneManager.LoadScene()
• $記法 / get_node() ≒ GameObject.Find() / FindObjectOfType()
• get_parent() ≒ transform.parent

ライフサイクル関連

• _ready() ≒ Start()
• _process() ≒ Update()
• _physics_process() ≒ FixedUpdate()

UI・表示関連

• CanvasLayer ≒ Canvas (Sorting Order)
• Control ≒ UI GameObject
• Label ≒ Text (TextMeshPro)

イベント・通信関連

• シグナル ≒ UnityEvent / C# Event
• emit_signal() ≒ event.Invoke()

その他の基礎機能

• @export ≒ [SerializeField]
• @onready ≒ Awake() / Start()
• AutoLoad ≒ DontDestroyOnLoad
• load() ≒ Resources.Load()

Unity開発者向け: コードで見るGodotとUnityの違い

Unity開発者が最も気になるであろう、実際のコードの記述スタイルの違いをいくつかの例で見てみましょう。

例1：変数の公開と初期化 (`@export` vs `[SerializeField]`)

インスペクターで値を調整できるように変数を公開し、ゲーム開始時にその値をコンソールに出力する基本的な処理です。

Godot (GDScript)

# Player.gd
extends Node2D

@export var player_name: String = "Hero"
@export var speed: int = 100

# UnityのStart()に相当
func _ready():
    print("Player Name: ", player_name)
    print("Initial Speed: ", speed)

Unity (C#)

// Player.cs
using UnityEngine;

public class Player : MonoBehaviour
{
    [SerializeField] private string playerName = "Hero";
    [SerializeField] private int speed = 100;

    // Godotの_ready()に相当
    void Start()
    {
        Debug.Log("Player Name: " + playerName);
        Debug.Log("Initial Speed: " + speed);
    }
}

例2：毎フレームの処理 (`_process` vs `Update`)

オブジェクトを右に移動させ続ける処理です。`delta` (Unityの `Time.deltaTime`) の使い方が分かります。

Godot (GDScript)

# Mover.gd
extends Sprite2D

@export var move_speed: float = 200.0

# UnityのUpdate()に相当
func _process(delta):
    position.x += move_speed * delta

Unity (C#)

// Mover.cs
using UnityEngine;

public class Mover : MonoBehaviour
{
    [SerializeField] private float moveSpeed = 200.0f;

    // Godotの_process()に相当
    void Update()
    {
        transform.position += new Vector3(moveSpeed * Time.deltaTime, 0, 0);
    }
}

例3：物理演算の処理 (`_physics_process` vs `FixedUpdate`)

入力に応じて物理的にキャラクターを動かす処理です。

Godot (GDScript)

# Character.gd
extends CharacterBody2D

const SPEED = 300.0

# UnityのFixedUpdate()に相当
func _physics_process(delta):
    var direction = Input.get_axis("ui_left", "ui_right")
    velocity.x = direction * SPEED
    move_and_slide()  # Godotの便利な組み込み関数

Unity (C#)

// Character.cs
using UnityEngine;

[RequireComponent(typeof(Rigidbody2D))]
public class Character : MonoBehaviour
{
    [SerializeField] private float speed = 300.0f;
    private Rigidbody2D rb;

    void Start()
    {
        rb = GetComponent<Rigidbody2D>();
    }

    // Godotの_physics_process()に相当
    void FixedUpdate()
    {
        float moveInput = Input.GetAxis("Horizontal");
        rb.velocity = new Vector2(moveInput * speed, rb.velocity.y);
    }
}

例4：ノード（オブジェクト）の取得 (`$` vs `GetComponent/transform.Find`)

子ノード（子オブジェクト）を取得して、そのプロパティを変更する処理です。

Godot (GDScript)

# Player.gd
extends Node2D

func _ready():
    # $記法で子ノードに直接アクセス
    $AnimatedSprite2D.play("run")
    
    # get_node() を使う方法もある
    var collision_shape = get_node("CollisionShape2D")
    collision_shape.disabled = true

Unity (C#)

// Player.cs
using UnityEngine;

public class Player : MonoBehaviour
{
    void Start()
    {
        // 子オブジェクトからコンポーネントを取得
        Animator animator = GetComponentInChildren<Animator>();
        if (animator != null)
        {
            animator.Play("run");
        }

        // 名前で子オブジェクトを探す場合
        Transform collisionShape = transform.Find("CollisionShape");
        if (collisionShape != null)
        {
            collisionShape.gameObject.SetActive(false);
        }
    }
}

例5：シグナル（イベント）の使用 (`signal` vs `UnityEvent`)

体力が変化した時に他のオブジェクトに通知する処理です。

Godot (GDScript)

# Player.gd
extends Node2D

signal health_changed(new_health)

var health: int = 100

func take_damage(damage: int):
    health -= damage
    health_changed.emit(health)  # シグナル発信

# UI.gd
extends Control

func _ready():
    var player = get_node("../Player")
    player.health_changed.connect(_on_health_changed)

func _on_health_changed(new_health: int):
    print("体力が ", new_health, " になりました")

Unity (C#)

// Player.cs
using UnityEngine;
using UnityEngine.Events;

public class Player : MonoBehaviour
{
    [SerializeField] private UnityEvent<int> onHealthChanged;
    
    private int health = 100;

    public void TakeDamage(int damage)
    {
        health -= damage;
        onHealthChanged?.Invoke(health);  // イベント発信
    }
}

// UI.cs
using UnityEngine;

public class UI : MonoBehaviour
{
    [SerializeField] private Player player;

    void Start()
    {
        player.onHealthChanged.AddListener(OnHealthChanged);
    }

    private void OnHealthChanged(int newHealth)
    {
        Debug.Log("体力が " + newHealth + " になりました");
    }
}

例6：シーン切り替え (`change_scene_to_file` vs `SceneManager.LoadScene`)

ゲームクリア時に次のレベルに移動する処理です。

Godot (GDScript)

# GameManager.gd
extends Node

func level_complete():
    print("レベルクリア！")
    get_tree().change_scene_to_file("res://scenes/Level2.tscn")

Unity (C#)

// GameManager.cs
using UnityEngine;
using UnityEngine.SceneManagement;

public class GameManager : MonoBehaviour
{
    public void LevelComplete()
    {
        Debug.Log("レベルクリア！");
        SceneManager.LoadScene("Level2");
    }
}

まとめ

今回は「Godot Engineで気軽に2Dゲームを作ろう」コースを通じて、Godotの真価を実感することができました。

結論から言うと、ノードベースシステムのGodotは、特に2D開発者にかなりおすすめできるゲームエンジンだと感じました。私はUnityやUnreal Engineにおける2Dゲーム開発の方法を一通り学んでいますが、Godotは主に2Dスプライトやタイルセット管理でかなりの優位性があるように感じています。純粋な2DゲームはGodot、HD-2Dなどライティング演出にこだわりたいならUnityという使い分けが良いのかなと思案中です。

今回は初学者なりにGodotの魅力をまとめてみましたが、エンジンとしてのクオリティでいえば、UnityやUnreal Engineのほうが現状は圧倒的に上です。関連情報やノウハウの量、Unity StoreやFabなどのストア環境、商業ゲームにおける採用実績などでは、Godotはまだまだ駆け出しエンジンといえるでしょう。

ただし、現状普通に楽しく開発できるだけのクオリティになっているGodotには可能性を感じます。

「Backpack Battles」や「Backshot Roulette」など「えっ、あれってGodot製だったの？」というゲームも少しずつ増えていっている印象です。UnityのRuntime Fee騒動のときに間違いなく一定数の開発者はGodotに移行したはずなので、彼らの作品が完成して注目されれば、Godotシェアも今後伸びていく可能性はあるでしょう。

オープンソースというのが非常にユニークな点です。かつてMayaや3dsMaxが覇権を握っていた3DCG業界が、いつのまにかBlenderに支配されているのを見ると、Godotも化けるかも…？と想像してしまいます。(※Blenderの急速進化が30万円以上する3DCGソフトしかマトモな制作環境がなかったことへの改善圧だと考えると、UnityやUnreal Engineは億単位の収益を稼ぐまでは基本無料なので、Blenderと同じ文脈で進化することはなさそう？やはりRuntime Free騒動のようにUnityかUnreal Engineが批判を受けるたびに利用者を吸収する受け皿として成長していく予感がする。)

とはいえ私はUnityもUnreal Engineにも引き続き触れていきます。Godotは第三の選択肢になり得るポテンシャルがあると確認できただけも収穫です。

ノードベースシステムは、UnityともUnreal Engineとも異なる開発体験が味わえるので、興味があればぜひ触れてみてください。

今後もGodotに関する学習メモを定期的に記事にしつつ、日本におけるGodot情報不足の解消に微力ながら協力していければなと考えています。

• ▶︎ Godot Engine 公式サイト
• ▶︎ Godot Engineで気軽に2Dゲームを作ろう (Udemy)
• ▶︎ Godot4: Build a 2D Action-Adventure Game (Udemy)