GDScriptの基本¶
はじめに¶
GDScriptは、コンテンツの作成用に使われる高水準の動的型付けプログラミング言語です。Pythonに似た構文を採用しています (ブロックはインデントベースで、キーワードの多くは似ています)。その目的は、Godotエンジンと緊密に統合し最適化することで、コンテンツの作成と統合に大きな柔軟性を与えることです。
履歴¶
注釈
GDScriptの歴史についてのドキュメントはよくある質問に移動しました。
GDScriptの例¶
構文を見ることでより良く学べる人もいるので、ここではGDScriptがどのように見えるかの簡単な例を紹介します。
# A file is a class!
# Inheritance
extends BaseClass
# (optional) class definition with a custom icon
class_name MyClass, "res://path/to/optional/icon.svg"
# Member variables
var a = 5
var s = "Hello"
var arr = [1, 2, 3]
var dict = {"key": "value", 2: 3}
var typed_var: int
var inferred_type := "String"
# Constants
const ANSWER = 42
const THE_NAME = "Charly"
# Enums
enum {UNIT_NEUTRAL, UNIT_ENEMY, UNIT_ALLY}
enum Named {THING_1, THING_2, ANOTHER_THING = -1}
# Built-in vector types
var v2 = Vector2(1, 2)
var v3 = Vector3(1, 2, 3)
# Function
func some_function(param1, param2):
var local_var = 5
if param1 < local_var:
print(param1)
elif param2 > 5:
print(param2)
else:
print("Fail!")
for i in range(20):
print(i)
while param2 != 0:
param2 -= 1
var local_var2 = param1 + 3
return local_var2
# Functions override functions with the same name on the base/parent class.
# If you still want to call them, use '.' (like 'super' in other languages).
func something(p1, p2):
.something(p1, p2)
# Inner class
class Something:
var a = 10
# Constructor
func _init():
print("Constructed!")
var lv = Something.new()
print(lv.a)
C、C++、C#などの静的型付き言語の経験があるが、これまでに動的型付き言語を使用したことがない場合は、以下のチュートリアルを読むことをお勧めします。GDScript: 動的言語の紹介。
言語:¶
GDScriptの概要を説明していきます。配列やその他のオブジェクトで使用できるメソッドなどの詳細については、リンクされたクラスの説明を参照してください。
識別子¶
アルファベット文字( a
から z
および A
から Z
)、数字( 0
から 9
)、 _
が識別子として修飾される文字列です。また、識別子は数字で始まってはいけません。識別子では大文字と小文字が区別されます( foo
が FOO
と異なる)。
キーワード¶
言語でサポートされているキーワードのリストを次に示します。キーワードは予約語(トークン)であるため、識別子として使用することはできません。次のセクションに示す演算子( in
、 not
、 and
、 or
など)と組み込み型の名前も予約されています。
キーワードは GDScriptのトークナイザーで定義されているので、内部を調べたい場合に便利です。
キーワード |
説明 |
---|---|
if |
if/else/elif を参照して下さい。 |
elif |
if/else/elif を参照して下さい。 |
else |
if/else/elif を参照して下さい。 |
for |
forを参照して下さい。 |
while |
whileを参照して下さい。 |
match |
matchを参照して下さい。 |
break |
現在の |
continue |
|
レンダーパス |
ステートメントが構文的には必要だが、コードの実行が望ましくない場合 (空の関数など) に使用されます。 |
return |
関数から値を返します。 |
クラス |
内部クラスを定義します。 |
class_name |
クラス名とスクリプトのアイコン(オプション)を定義します。 |
extends |
現在のクラスで拡張するクラスを定義します。 |
is |
変数が特定のクラスを拡張するのか、それとも特定の組み込み型のものかをテストします。 |
as |
可能であれば、指定した型に値をキャストします。 |
self |
現在のクラスインスタンスを参照します。 |
tool |
エディタでスクリプトを実行します。 |
シグナル |
シグナルを定義します。 |
func |
関数を定義します。 |
static |
静的関数を定義します。静的メンバー変数は使用できません。 |
const |
定数を定義します。 |
enum |
列挙型を定義します。 |
var |
変数を定義します。 |
onready |
スクリプトがアタッチされているノードとその子がシーンツリーの一部になると、変数を初期化します。 |
export |
変数をアタッチ先のリソースとともに保存し、エディタで表示および変更できるようにします。 |
setget |
変数の設定および取得関数を定義します。 |
breakpoint |
デバッガブレークポイント用のエディタヘルパー。 |
preload |
クラスまたは変数をプリロードします。Classes as resources を参照してください。 |
yield |
コルーチンサポート 。Coroutines with yield を参照してください。 |
assert |
条件を表明し、失敗時にエラーをログに記録します。 デバッグ以外のビルドでは無視されます。Assert keyword を参照してください。 |
remote |
ネットワーキングRPCアノテーション。 high-level multiplayer docs を参照してください。 |
master |
ネットワーキングRPCアノテーション。 high-level multiplayer docs を参照してください。 |
人形 |
ネットワーキングRPCアノテーション。 high-level multiplayer docs を参照してください。 |
remotesync |
ネットワーキングRPCアノテーション。 high-level multiplayer docs を参照してください。 |
mastersync |
ネットワーキングRPCアノテーション。 high-level multiplayer docs を参照してください。 |
puppetsync |
ネットワーキングRPCアノテーション。 high-level multiplayer docs を参照してください。 |
PI |
PI定数。 |
TAU |
TAU定数。 |
INF |
Infinity定数。比較に使用されます。 |
NAN |
NAN (not a number)定数。比較に使用されます。 |
オペレーター¶
サポートされている演算子とその優先順位を次に示します。
演算子 |
説明 |
|
サブスクリプション(最優先) |
|
要素参照 |
|
関数呼び出し |
|
インスタンス型チェッカー |
|
ビット単位のNOT |
|
負 / 単項否定 |
|
乗算/除算/剰余 これらの演算子は、C++と同じ動作をします。整数の除算は端数を返すのではなく、切り捨てられます。また、%演算子は整数でのみ使用でき (浮動小数点では''fmod'')、さらにFormat Stringにも使用されます |
|
加算 / 配列の連結 |
|
減算 |
|
ビットシフト |
|
ビットAND |
|
ビットXOR |
|
ビットOR |
|
比較 |
|
When used with the |
|
ブール型 NOT |
|
ブール型 AND |
|
ブール型 OR |
|
3項if/else |
|
型キャスト |
|
代入、優先度最低 |
リテラル¶
リテラル |
型 |
|
10進整数 |
|
16進整数 |
|
2進整数 |
|
浮動小数点数(実数) |
|
文字列 |
|
複数行文字列 |
|
NodePathかStringName |
|
|
Integerとfloatの数値は可読性のために _
で分割することができます。以下の数値表現はすべて有効です:
12_345_678 # Equal to 12345678.
3.141_592_7 # Equal to 3.1415927.
0x8080_0000_ffff # Equal to 0x80800000ffff.
0b11_00_11_00 # Equal to 0b11001100.
組み込み型¶
組み込み型はスタック割り当て型です。これらは値として渡されます。つまり、割り当てごとに、または関数に引数として渡すときにコピーが作成されます。唯一の例外は Array
と Dictionary
で、これらは参照によって渡され、共有されます。( PoolArray
s は PoolByteArray
のように値として渡されるわけではありませんが、どちらを使用するかを決定する際にはこの点を考慮してください。)
組み込み型ベース¶
GDScriptの変数は、いくつかの組み込み型に割り当てることができます。
null¶
null
は、情報を含まない空のデータ型であり、他の値を割り当てることはできません。
bool¶
Booleanデータ型には、 true
または false
のみを含めることができます。
int¶
「integer」の略で、整数(正と負)を格納します。64ビット値で格納し、C++の「int64_t」と同等です。
float¶
浮動小数点値を使用して、小数を含む実数を格納します。 C++の "double" に相当する64ビット値として保存されます。注: 現在、Vector2、Vector3、PoolRealArrayなどのデータ構造には、32ビット単精度の"float"値が格納されています。
String¶
Unicode形式の文字列。文字列には下記のエスケープシーケンスも含めることができます。
エスケープシーケンス |
に展開します |
|
改行 (line feed) |
|
水平タブ文字 |
|
リターン |
|
アラート (ビープ/ベル) |
|
バックスペース |
|
フォームフィードの改ページ |
|
垂直タブ文字 |
|
二重引用符 |
|
一重引用符 |
|
バックスラッシュ |
|
Unicodeコードポイント |
GDScriptは GDScriptフォーマット文字列 もサポートしています。
組み込み型ベクトル¶
Vector2¶
x
と y
を含む2Dベクトルタイプ。配列としてアクセスすることもできます。
Rect2¶
position
と size
の2つのベクトルフィールドを含む2D矩形タイプ。または、 position+size
である end
フィールドを含みます。
Vector3¶
x
、 y
、 z
フィールドを含む3Dベクトルタイプ。配列としてアクセスすることもできます。
Transform2D¶
2次元の幾何学変換に使用される3x2行列です。
Plane¶
normal
ベクトルフィールドと d
スカラー距離を含む正規化形式の3D平面型です。
Quat¶
四元数は3D回転を表すために使用されるデータ型です。 回転を補間するのに便利です。
AABB¶
座標軸に平行な直方体(または3Dボックス)には、 position
と size
の2つのベクトルフィールドがあります。または、 position+size
である end
フィールドを含みます。
Basis¶
3Dの回転と拡大縮小に使用される3x3の行列。これには3つのベクトルフィールド(x
、y
、z
)が含まれ、3Dベクトルの配列としてアクセスすることもできます。
Transform¶
3DTransformには、基底(基準軸)フィールド basis
とVector3フィールド origin
が含まれています。
エンジン組み込み型¶
Color¶
カラーデータ型は、 r
、 g
、 b
,および a
フィールドを含みます。色相/彩度/明度の h
、 s
、 v
としてアクセスすることもできます。
NodePath¶
主にシーンシステムで使用されるノードへのコンパイル済みパス。 Stringとの間で簡単に割り当てることができます。
RID¶
リソースID(RID)。サーバーは汎用RIDを使用して不透明なデータを参照します。
Object¶
組み込み型でないものすべての基本クラス。
組み込み型コンテナ¶
配列¶
他の配列や辞書(下記参照)を含む、任意のオブジェクトタイプの一般的なシーケンス、他の配列や辞書を含みます。(下を見てください)。配列のサイズは動的に変更できます。配列にはインデックス 0
から始まるインデックスが付けられます。マイナスのインデックスは最後から数えます。
var arr = []
arr = [1, 2, 3]
var b = arr[1] # This is 2.
var c = arr[arr.size() - 1] # This is 3.
var d = arr[-1] # Same as the previous line, but shorter.
arr[0] = "Hi!" # Replacing value 1 with "Hi!".
arr.append(4) # Array is now ["Hi!", 2, 3, 4].
GDScriptの配列は速度を上げるためにメモリ内で線形に割り当てられます。大規模な配列(数万要素以上)は、メモリの断片化を引き起こす可能性があります。 これが問題になる場合は、特殊なタイプの配列が利用可能です。これらは単一のデータ型のみを受け入れます。この配列はメモリの断片化を回避し、メモリの使用量も少なくなりますが原始的であり、一般的な配列より実行速度が遅くなりがちです。 したがって、それらは大規模なデータセットにのみ使用することをお勧めします:
PoolByteArray: バイト型の配列(0~255の整数)。
PoolIntArray: 整数型の配列。
PoolRealArray: 浮動小数点型の配列。
PoolStringArray: 文字列型の配列。
PoolVector2Array: Vector2 の配列。
PoolVector3Array: Vector3 の配列。
PoolColorArray: Color の配列。
Dictionary¶
一意のキーによって参照される値を含む連想コンテナです。
var d = {4: 5, "A key": "A value", 28: [1, 2, 3]}
d["Hi!"] = 0
d = {
22: "value",
"some_key": 2,
"other_key": [2, 3, 4],
"more_key": "Hello"
}
Luaスタイルのテーブル構文もサポートされています。 Luaスタイルでは、 :
の代わりに =
を使用し、文字列のキーをマークするために引用符を使用しません(記述するのがやや少なくなります)。ただし、他のGDScript識別子と同様に、この形式で書かれたキーは数字で始めることはできません (他のGDScriptの識別子と同様)。
var d = {
test22 = "value",
some_key = 2,
other_key = [2, 3, 4],
more_key = "Hello"
}
既存の辞書にキーを追加するには、既存のキーのようにアクセスして割り当てます:
var d = {} # Create an empty Dictionary.
d.waiting = 14 # Add String "waiting" as a key and assign the value 14 to it.
d[4] = "hello" # Add integer 4 as a key and assign the String "hello" as its value.
d["Godot"] = 3.01 # Add String "Godot" as a key and assign the value 3.01 to it.
var test = 4
# Prints "hello" by indexing the dictionary with a dynamic key.
# This is not the same as `d.test`. The bracket syntax equivalent to
# `d.test` is `d["test"]`.
print(d[test])
注釈
ブラケット構文は、辞書だけでなく、任意の Object のプロパティにアクセスするために使用することができます。存在しないプロパティを添え字にすると、スクリプトエラーが発生するので注意してください。これを避けるには、代わりに Object.get() や Object.set() メソッドを使用します。
データ¶
変数¶
変数はクラスメンバーとして存在することも、関数に対してローカルに存在することもできます。これらは var
キーワードを使用して作成され、必要に応じて初期化時に値が割り当てられます。
var a # Data type is 'null' by default.
var b = 5
var c = 3.8
var d = b + c # Variables are always initialized in order.
変数にはオプションで型指定を指定できます。型を指定すると、変数は常に同じ型を持つように強制され、互換性のない値を割り当てようとするとエラーが発生します。
型は、変数名の後に :
(コロン)記号を使用して変数宣言内で指定され、その後に型が続きます。
var my_vector2: Vector2
var my_node: Node = Sprite.new()
変数が宣言内で初期化されている場合、型を推定できるため、型名を省略できます:
var my_vector2 := Vector2() # 'my_vector2' is of type 'Vector2'.
var my_node := Sprite.new() # 'my_node' is of type 'Sprite'.
型推論が可能なのは、割り当てられた値に型が定義されている場合だけです。定義されていない場合は、エラーが発生します。
有効なタイプは以下のとおりです:
組み込み型(Array、Vector2、int、Stringなど)。
エンジンクラス(Node、Resource、Referenceなど)。
スクリプトリソースを含む場合は定数名(
const MyScript = preload("res://my_script.gd")
を宣言した場合はMyScript
)。同じスクリプト内の他のクラス、スコープを尊重します(
InnerClass.NestedClass
もしclass InnerClass
内でclass NestedClass
を宣言した場合は は同じスコープです)。class_name
キーワードで宣言されたスクリプトクラス。
キャスト¶
型付き変数に割り当てられた値は、互換性のある型を持つ必要があります。特定の型、特にオブジェクト型に対して値を強制する必要がある場合は、キャスト演算子を as
として使用できます。
値が同じ型またはキャスト型のサブタイプの場合、オブジェクト型間でキャストすると同じオブジェクトになります。
var my_node2D: Node2D
my_node2D = $Sprite as Node2D # Works since Sprite is a subtype of Node2D.
値がサブタイプではない場合、キャスト操作は null
値になります。
var my_node2D: Node2D
my_node2D = $Button as Node2D # Results in 'null' since a Button is not a subtype of Node2D.
組み込み型の場合、可能であれば強制的に変換されますが、それ以外の場合はエラーが発生します。
var my_int: int
my_int = "123" as int # The string can be converted to int.
my_int = Vector2() as int # A Vector2 can't be converted to int, this will cause an error.
また、キャストは、シーンツリーと対話するときに、より安全な型保証変数を用意するのにも役立ちます:
# Will infer the variable to be of type Sprite.
var my_sprite := $Character as Sprite
# Will fail if $AnimPlayer is not an AnimationPlayer, even if it has the method 'play()'.
($AnimPlayer as AnimationPlayer).play("walk")
定数¶
定数はゲームの実行中に変更することができない値のことです。これらの値はコンパイル時に確定している必要があります。 const
キーワードを使うことで定数に名前を付けることができます。定数を宣言したよりも後に値を代入しようとすると、エラーが発生します。
値を変更するつもりがないのなら、定数を用いることを推奨します。
const A = 5
const B = Vector2(20, 20)
const C = 10 + 20 # Constant expression.
const D = Vector2(20, 30).x # Constant expression: 20.
const E = [1, 2, 3, 4][0] # Constant expression: 1.
const F = sin(20) # 'sin()' can be used in constant expressions.
const G = x + 20 # Invalid; this is not a constant expression!
const H = A + 20 # Constant expression: 25 (`A` is a constant).
定数の型は割り当てられた値から推測されますが、明示的な型指定を追加することも可能です:
const A: int = 5
const B: Vector2 = Vector2()
互換性のないタイプの値を割り当てると、エラーが発生します。
注釈
配列や辞書は参照で渡されるので、定数は「フラット」です。これは、もし定数の配列や辞書を宣言したとしても、後から修正することができることを意味します。ただし、別の値で再代入することはできません。
列挙型¶
列挙型は基本的に定数の省略形であり、連続した整数をある定数に割り当てたい場合には非常に便利です。
列挙型に名前を渡すと、その名前の定数辞書内にすべてのキーが配置されます。
重要
Godot 3.1以降は、名前の付いた列挙型のキーはグローバル定数としては登録されません。アクセスするには列挙型の名前を前につける必要があります(Name.KEY
)。下記の例を見てください。
enum {TILE_BRICK, TILE_FLOOR, TILE_SPIKE, TILE_TELEPORT}
# Is the same as:
const TILE_BRICK = 0
const TILE_FLOOR = 1
const TILE_SPIKE = 2
const TILE_TELEPORT = 3
enum State {STATE_IDLE, STATE_JUMP = 5, STATE_SHOOT}
# Is the same as:
const State = {STATE_IDLE = 0, STATE_JUMP = 5, STATE_SHOOT = 6}
# Access values with State.STATE_IDLE, etc.
関数¶
関数は常に classに属します。 変数検索のスコープ優先順位は、ローカル→クラスメンバー→グローバルです。 self
変数は常に利用可能でクラスメンバにアクセスするためのオプションとして提供されていますが、必ずしも必要ではありません(Pythonとは異なり、関数の最初の引数として送信しないでください)。
func my_function(a, b):
print(a)
print(b)
return a + b # Return is optional; without it 'null' is returned.
関数は任意の時点で return
することができます。デフォルトの戻り値は``null`` です。
関数には、引数と戻り値の型を指定することもできます。引数の型は次のように変数に追加できます:
func my_function(a: int, b: String):
pass
関数の引数にデフォルト値がある場合は、次のように型を推測できます:
func my_function(int_arg := 42, String_arg := "string"):
pass
関数の戻り型は、引数リストの後に矢印トークン( ->
)を使用して指定できます:
func my_int_function() -> int:
return 0
戻り型を持つ関数は、適切な値を返す必要があります。型を void
に設定すると、関数は何も返しません。Void関数は return
キーワードを使用して早期に戻ることができますが、値を返すことはできません。
func void_function() -> void:
return # Can't return a value
注釈
void関数でない場合は常に値を返す必要があるため、コードに分岐文( if
/else
構造など)がある場合は、考えられるすべてのパスに戻り値が必要です。たとえば、 if
ブロックの内側に戻り値があってもその後に戻り値がない場合、エディタはエラーを発生させます。 if
内のブロックが実行されない場合、関数には有効な戻り値がないからです。
関数の参照¶
Pythonとは反対に、関数はGDScriptの最上位クラスのオブジェクトではありません。つまり、変数に格納したり、引数として別の関数に渡したり、他の関数から返すことはできません。 これはパフォーマンス上の理由からです。
実行時に名前で関数を参照するには(たとえば、変数に格納したり、引数として別の関数に渡したりするには)、 call
または funcref
ヘルパーを使用する必要があります:
# Call a function by name in one step.
my_node.call("my_function", args)
# Store a function reference.
var my_func = funcref(my_node, "my_function")
# Call stored function reference.
my_func.call_func(args)
静的関数¶
関数は静的として宣言できます。静的関数は、インスタンス・メンバー変数または self
にアクセスできません。これは主に、ヘルパー関数のライブラリを作成するのに便利です:
static func sum2(a, b):
return a + b
ステートメントと制御フロー¶
文は標準的なもので、代入、関数呼び出し、制御フロー構造などです(下記参照)。 ;
は文の区切り文字としては完全にオプションです。
if/else/elif¶
単純な条件は、 if
/else
/elif
構文を使用して作成します。条件をかっこで囲むことはできますが、必須ではありません。タブベースのインデントの性質から、インデントのレベルを維持するために elif
を else
/if
の代わりに使用できます。
if [expression]:
statement(s)
elif [expression]:
statement(s)
else:
statement(s)
短いステートメントは、条件と同じ行に記述できます:
if 1 + 1 == 2: return 2 + 2
else:
var x = 3 + 3
return x
場合によっては、ブール式に基づいて異なる初期値を割り当てたいことがあります。 この場合、3項式が便利です:
var x = [value] if [expression] else [value]
y += 3 if y < 10 else -1
三項if式は、2つ以上の条件を扱うために入れ子にすることができます。三項if式を入れ子にする場合は、読みやすさを保つために、式全体を複数行に渡ってラップすることをお勧めします。
var count = 0
var fruit = (
"apple" if count == 2
else "pear" if count == 1
else "banana" if count == 0
else "orange"
)
print(fruit) # banana
# Alternative syntax with backslashes instead of parentheses (for multi-line expressions).
# Less lines required, but harder to refactor.
var fruit_alt = \
"apple" if count == 2 \
else "pear" if count == 1 \
else "banana" if count == 0 \
else "orange"
print(fruit_alt) # banana
You may also wish to check if a value is contained within something. You can
use an if
statement combined with the in
operator to accomplish this:
# Check if a letter is in a string.
var text = "abc"
if 'b' in text: print("The string contains b")
# Check if a variable is contained within a node.
if "varName" in get_parent(): print("varName is defined in parent!")
while¶
Simple loops are created by using while
syntax. Loops can be broken
using break
or continued using continue
(i.e. skipping to the next iteration of the loop without executing any further code in the current iteration):
while [expression]:
statement(s)
for¶
配列やテーブルなどの範囲を反復するには、 for ループが使用されます。配列を反復処理する時には、現在の配列要素がループ変数に格納されます。 辞書を反復処理するとき、 key はループ変数に格納されます。
for x in [5, 7, 11]:
statement # Loop iterates 3 times with 'x' as 5, then 7 and finally 11.
var dict = {"a": 0, "b": 1, "c": 2}
for i in dict:
print(dict[i]) # Prints 0, then 1, then 2.
for i in range(3):
statement # Similar to [0, 1, 2] but does not allocate an array.
for i in range(1, 3):
statement # Similar to [1, 2] but does not allocate an array.
for i in range(2, 8, 2):
statement # Similar to [2, 4, 6] but does not allocate an array.
for c in "Hello":
print(c) # Iterate through all characters in a String, print every letter on new line.
for i in 3:
statement # Similar to range(3)
for i in 2.2:
statement # Similar to range(ceil(2.2))
match¶
match
文はプログラムの実行を分岐するために使用されます。他の多くの言語で見られる switch
文と同等ですが、いくつかの追加機能を提供します。
基本の構文:
match [expression]:
[pattern](s):
[block]
[pattern](s):
[block]
[pattern](s):
[block]
switchステートメントに精通しているユーザー向けのクラッシュ・コース:
match
するswitch
を置換します。case
を削除します。break
を除去します。デフォルトでbreak
しない場合は、continue
を使用してフォールスルーを行うことができます。default
をアンダースコア1つに変更します。
制御フロー:
The patterns are matched from top to bottom.
If a pattern matches, the first corresponding block will be executed. After that, the execution continues below the match
statement.
You can use continue
to stop execution in the current block and check for an additional match in the patterns below it.
6種類のパターンがあります:
- 定数パターン
数値や文字列のような定数プリミティブ:
match x: 1: print("We are number one!") 2: print("Two are better than one!") "test": print("Oh snap! It's a string!")
- 変数パターン
変数/列挙型の内容と一致:
match typeof(x): TYPE_REAL: print("float") TYPE_STRING: print("text") TYPE_ARRAY: print("array")
- ワイルドカードパターン
このパターンはすべてにマッチします。 単一のアンダースコアとして書かれています。
他の言語における
switch
ステートメントでのdefault
と同等のものとして使用できます:match x: 1: print("It's one!") 2: print("It's one times two!") _: print("It's not 1 or 2. I don't care to be honest.")
- バインディングパターン
バインディング・パターンは新しい変数を導入します。ワイルドカード・パターンと同様に、すべてに一致し、その値に名前を付けます。配列や辞書のパターンで特に便利です:
match x: 1: print("It's one!") 2: print("It's one times two!") var new_var: print("It's not 1 or 2, it's ", new_var)
- 配列パターン
配列と一致します。 配列パターンの各要素はパターンそのものなので、それらをネストすることができます。
配列の長さが最初にテストされ、それはパターンと同じサイズでなければなりません、そうでなければパターンは一致しません。
オープンエンド配列: 最後のサブパターンを `` ..`` にすることで配列をパターンよりも大きくすることができます。
各サブパターンはカンマで区切る必要があります。
match x: []: print("Empty array") [1, 3, "test", null]: print("Very specific array") [var start, _, "test"]: print("First element is ", start, ", and the last is \"test\"") [42, ..]: print("Open ended array")
- 辞書パターン
配列パターンと同じように機能します。 すべてのキーは定数パターンでなければなりません。
辞書のサイズが最初にテストされ、それはパターンと同じサイズでなければなりません、そうでなければパターンは一致しません。
オープンエンド辞書: 最後のサブパターンを `` ..`` にすることで辞書をパターンよりも大きくすることができます。
各サブパターンはカンマで区切る必要があります。
値を指定しないと、キーの存在のみがチェックされます。
値パターンは、キーパターンとは
:
で区別されます:。match x: {}: print("Empty dict") {"name": "Dennis"}: print("The name is Dennis") {"name": "Dennis", "age": var age}: print("Dennis is ", age, " years old.") {"name", "age"}: print("Has a name and an age, but it's not Dennis :(") {"key": "godotisawesome", ..}: print("I only checked for one entry and ignored the rest")
- 組み合わせパターン
複数のパターンをカンマで区切って指定することもできます。 これらのパターンには、バインディングを含めることはできません。
match x: 1, 2, 3: print("It's 1 - 3") "Sword", "Splash potion", "Fist": print("Yep, you've taken damage")
クラス¶
デフォルトでは、すべてのスクリプトファイルは名前のないクラスです。この場合、相対パスまたは絶対パスを使用して、ファイルのパスを使用してのみそれらを参照できます。 たとえば、スクリプトファイルに character.gd
という名前を付けたとします:
# Inherit from 'Character.gd'.
extends "res://path/to/character.gd"
# Load character.gd and create a new node instance from it.
var Character = load("res://path/to/character.gd")
var character_node = Character.new()
Registering named classes¶
You can give your class a name to register it as a new type in Godot's
editor. For that, you use the class_name
keyword. You can optionally add
a comma followed by a path to an image, to use it as an icon. Your
class will then appear with its new icon in the editor:
# Item.gd
extends Node
class_name Item, "res://interface/icons/item.png"
警告
スクリプトが res://addons/
ディレクトリにあって、 有効な エディタプラグインの一部であれば、 class_name
はそのノードが Node を新規作成 ダイアログに表示される原因になります。詳細は プラグインの作成 を参照ください。
クラスファイルの例を次に示します:
# Saved as a file named 'character.gd'.
class_name Character
var health = 5
func print_health():
print(health)
func print_this_script_three_times():
print(get_script())
print(ResourceLoader.load("res://character.gd"))
print(Character)
注釈
Godotのクラス構文はコンパクトで、メンバー変数または関数のみを含むことができます。静的関数は使用できますが、静的メンバー変数は使用できません。同様に、インスタンスを作成するたびに変数が初期化されますが、これには配列とディクショナリが含まれます。スクリプトはユーザーが知らなくても別のスレッドで初期化できるため、これはスレッド・セーフの精神に基づいています。
継承¶
クラス(ファイルとして格納されている)は以下から継承することができます:
グローバルクラス。
他のクラスファイル。
別のクラスファイル内の内部クラス。
多重継承はできません。
継承は extends
キーワードを使用します:
# Inherit/extend a globally available class.
extends SomeClass
# Inherit/extend a named class file.
extends "somefile.gd"
# Inherit/extend an inner class in another file.
extends "somefile.gd".SomeInnerClass
特定のインスタンスが特定のクラスを継承するかどうかを確認するには、 is
キーワードを使用します:
# Cache the enemy class.
const Enemy = preload("enemy.gd")
# [...]
# Use 'is' to check inheritance.
if entity is Enemy:
entity.apply_damage()
親クラスの関数(それは,現在のクラスで継承されている)を呼び出すには、 関数名の前に .
を付けます:
.base_func(args)
子クラスの関数は親クラスの同名の関数を置き換えるため、元の親クラスの関数を呼び出すときに特に使用されます。 関数名の 前に``.`` を付けます(他の言語の super
キーワードのように):
func some_func(x):
.some_func(x) # Calls the same function on the parent class.
注釈
_init
などのデフォルト関数と、 _enter_tree
、 _exit_tree
、 _process
、 _physics_process
などのほとんどの通知は、すべての親クラスで自動的に呼び出されます。それらの関数をオーバーロードしたときに明示的に呼び出す必要はありません。
クラスコンストラクター¶
クラスのインスタンス化時に呼び出されるクラスコンストラクターの名前は _init
です。前述のように、親クラスのコンストラクターはクラスを継承するときに自動的に呼び出されます。従って、通常は ._init()
を明示的に呼び出す必要はありません。
.some_func
を使用した上記の例のような通常の関数の呼び出しとは異なり、継承したクラスのコンストラクターが引数を取得する場合、それらは次のように渡されます:
func _init(args).(parent_args):
pass
これは、例を使って説明した方がわかりやすいです。次のようなシナリオがあるとします:
# State.gd (inherited class)
var entity = null
var message = null
func _init(e=null):
entity = e
func enter(m):
message = m
# Idle.gd (inheriting class)
extends "State.gd"
func _init(e=null, m=null).(e):
# Do something with 'e'.
message = m
留意すべきことがいくつかあります:
継承元のクラス(
State.gd
)が_init
コンストラクターを定義し、それが引数を取る場合(このケースはe
)、State.gd
の継承クラス(Idle.gd
)も_init
を定義し、State.gd
の_init
に適切なパラメーターを渡す 必要 があります。Idle.gd
は、親クラスState.gd
と異なる数の引数を持つことができます。上の例では、
State.gd
コンストラクターに渡されるe
は、Idle.gd
に渡されるのと同じe
です。Idle.gd
の_init
コンストラクターが0の引数を取る場合、何もしなくてもState.gd
親クラスに値を渡す必要があります。変数だけでなくリテラルもベースコンストラクターに渡すことができます。 例:# Idle.gd func _init().(5): pass
内部クラス¶
クラスファイルには内部クラスを含めることができます。内部クラスは、 class
キーワードを使用して定義されます。 ClassName.new()
関数を使用してインスタンス化されます。
# Inside a class file.
# An inner class in this class file.
class SomeInnerClass:
var a = 5
func print_value_of_a():
print(a)
# This is the constructor of the class file's main class.
func _init():
var c = SomeInnerClass.new()
c.print_value_of_a()
リソースとしてのクラス¶
ファイルとして保存されたクラスは resources として扱われます。他のクラスでそれらにアクセスするには、それらをディスクからロードする必要があります。 これは、 load
または preload
関数を使用して行われます(下記参照)。ロードされたクラスリソースのインスタンス化は、クラスオブジェクトの新しい関数を呼び出すことによって行われます:
# Load the class resource when calling load().
var MyClass = load("myclass.gd")
# Preload the class only once at compile time.
const MyClass = preload("myclass.gd")
func _init():
var a = MyClass.new()
a.some_function()
エクスポート¶
注釈
エクスポートについてのドキュメントは GDScriptのエクスポート に移動しました。
Setters/getters¶
クラスのメンバー変数がどのような理由で変更されたかを把握しておくと便利です。また、何らかの方法でそのアクセスをカプセル化することが望ましい場合もあるかもしれません。
このため、GDScriptには setget
キーワードを使用した setter/getter 構文が用意されています。変数定義の直後に使用されます:
var variable = value setget setterfunc, getterfunc
variable
の値が 外部 ソースによって変更されると(つまり、クラス内のローカルでの使用によるものではありません)、必ず setter 関数(上記の setterfunc
)が呼び出されます。これは値が変更される 前 に 発生します。 setter は新しい値の処理方法を決定する必要があります。逆に、 variable
がアクセスされると getter 関数(上記の getterfunc
)は目的の値を return
する必要があります。次に例を示します:
var my_var setget my_var_set, my_var_get
func my_var_set(new_value):
my_var = new_value
func my_var_get():
return my_var # Getter must return a value.
setter または getter 関数のどちらかを省略することができます:
# Only a setter.
var my_var = 5 setget my_var_set
# Only a getter (note the comma).
var my_var = 5 setget ,my_var_get
Setterとgetterは、ツールスクリプトまたはプラグインにおいて、入力を検証するためエディタへ変数をエクスポートする場合に特に便利です。
前述したように、 ローカル アクセスはsetter とgetterを 起動しません 。この例を次に示します:
func _init():
# Does not trigger setter/getter.
my_integer = 5
print(my_integer)
# Does trigger setter/getter.
self.my_integer = 5
print(self.my_integer)
ツールモード¶
デフォルトでは、スクリプトはエディタ内では実行されずエクスポートされたプロパティのみを変更できます(ゲームコードの実行あるいは手動でそのようになるのを回避しない限り)。場合によっては、エディタ内で実行することが望ましい場合があります。これには、 tool
キーワードが存在し、ファイルの先頭に配置する必要があります:
tool
extends Button
func _ready():
print("Hello")
詳細については、エディタでコードを実行する を参照してください。
警告
ツールスクリプトでノードをqueue_free()
あるいはfree()
で開放するときは注意してください(特にノードがそのスクリプトのオーナーである場合)。ツールスクリプトはエディタ内で実行されるので、間違って使うとエディタがクラッシュするかもしれません。
メモリ管理¶
クラスが Reference から継承する場合、インスタンスは使用されなくなると解放されます。ガベージコレクタは存在せず、参照カウントのみが存在します。デフォルトでは、継承を定義しないすべてのクラスがReferenceを継承します。これが望ましくない場合は、クラスは手動で Object を継承し、instance.free() を呼び出す必要があります。解放できない参照サイクルを避けるために、弱い参照を作成するための weakref
関数が提供されています。
extends Node
var my_node_ref
func _ready():
my_node_ref = weakref(get_node("MyNode"))
func _this_is_called_later():
var my_node = my_node_ref.get_ref()
if my_node:
my_node.do_something()
あるいは、参照を使用しない場合は、 is_instance_valid(instance)
を使用してオブジェクトが解放されたかどうかを確認できます。
シグナル¶
シグナルはオブジェクトから通知メッセージを送信する手段で、他のオブジェクトはそれを受信することが出来ます。 クラスのカスタムシグナルを作るには``signal`` キーワードを使用します。
extends Node
# A signal named health_depleted.
signal health_depleted
注釈
シグナルはコールバック機構です。これはオブザーバーとしても振る舞う、一般的なプログラミングパターンです。より多くの情報を得るにはGame Programming Patterns ebookの Observer tutorial をお読みください(英語)。
Button や RigidBody の様ななノードの組み込みシグナルを接続するのと同じ方法で、これらのシグナルをメソッドに接続できます。
下の例では、Character
ノードから Game
ノードへ health_depleted
シグナルを接続します。 Character
ノードがシグナルを発信したとき、gameノードの _on_Character_health_depleted
が呼ばれます。
# Game.gd
func _ready():
var character_node = get_node('Character')
character_node.connect("health_depleted", self, "_on_Character_health_depleted")
func _on_Character_health_depleted():
get_tree().reload_current_scene()
あなたが望むシグナルと一緒に多くの引数を発信することができます。
ここに有用な例を示します。アニメーションを伴った、体力の変化を受信するライフバーをスクリーン上に配置しようとしますが、シーンツリー上にあるプレイヤーからはそのユーザーインターフェースを分けたいします。
Character.gd
スクリプト内で health_changed
シグナルを定義し Object.emit_signal() を使って発信し、それをシーンツリーの上層の Game
ノードから、 Object.connect() メソッドを使って Lifebar
へ接続します:
# Character.gd
...
signal health_changed
func take_damage(amount):
var old_health = health
health -= amount
# We emit the health_changed signal every time the
# character takes damage.
emit_signal("health_changed", old_health, health)
...
# Lifebar.gd
# Here, we define a function to use as a callback when the
# character's health_changed signal is emitted.
...
func _on_Character_health_changed(old_value, new_value):
if old_value > new_value:
progress_bar.modulate = Color.red
else:
progress_bar.modulate = Color.green
# Imagine that `animate` is a user-defined function that animates the
# bar filling up or emptying itself.
progress_bar.animate(old_value, new_value)
...
注釈
シグナルを使うにはクラスが Object
クラスを直接継承しているか、もしくは Object
を継承している Node
、 KinematicBody
、 Control
等を継承している必要があります。
Game
ノード内で Character
ノードと Lifebar
ノードを取得し、そして character と受信者を接続し 、 character にシグナルを受信者へ送信させます、受信者はこのケースでは Lifebar
ノードです。
# Game.gd
func _ready():
var character_node = get_node('Character')
var lifebar_node = get_node('UserInterface/Lifebar')
character_node.connect("health_changed", lifebar_node, "_on_Character_health_changed")
これは Character
ノードとのカップリングをせずに Lifebar
に体力の変化を受信することを可能にします。
signalを定義後の括弧内に追加の引数名を書くことが出来ます:
# Defining a signal that forwards two arguments.
signal health_changed(old_value, new_value)
これらの引数はエディタのノードドックに表示され、Godot はこれらを使いコールバック関数を生成します。しかし、シグナルを発信する際に、異なる個数の引数を送信することもできます。正しい値を発信するかはあなた次第です。
GDScriptは、シグナルとメソッド間の接続に値の配列をバインドすることができます。シグナルが発信された時、コールバックメソッドがバインドされた値を受け取ります。これらのバインドされた引数は、それぞれの接続に固有のもので、同じ値が維持されます。
もし、発信されたシグナル自身が必要とするデータへのアクセスをあなたに与えなかったとしても、決まった情報を接続に追加するために値の配列を使うことが出来ます。
上の例に基づいて、Player1 took 22 damage.
のようにスクリーン上にそれぞれのキャラクターの受けたダメージのログを表示したいとします 。health_changed
シグナルはダメージを受けたキャラクターの名前を我々に与えません。その場合、ゲーム内のコンソールにシグナルを接続する事により、バインドされた引数の配列にあるキャラクターの名前を追加することができます:
# Game.gd
func _ready():
var character_node = get_node('Character')
var battle_log_node = get_node('UserInterface/BattleLog')
character_node.connect("health_changed", battle_log_node, "_on_Character_health_changed", [character_node.name])
BattleLog
ノードはバインドされた追加の引数の配列内の要素を、送信者ごとに受け取ります。
# BattleLog.gd
func _on_Character_health_changed(old_value, new_value, character_name):
if not new_value <= old_value:
return
var damage = old_value - new_value
label.text += character_name + " took " + str(damage) + " damage."
コルーチン(yield関数による)¶
GDScriptは、組み込み関数 yield を介して coroutines をサポートしています。 yield()
を呼び出すと、現在の関数から即座に戻り、戻り値と同じ関数の現在の凍結状態が返されます。この結果のオブジェクトで resume()
を呼び出すと、実行を継続し、関数が返すものを返します。再開すると、状態オブジェクトは無効になります。次に例を示します:
func my_func():
print("Hello")
yield()
print("world")
func _ready():
var y = my_func()
# Function state saved in 'y'.
print("my dear")
y.resume()
# 'y' resumed and is now an invalid state.
以下のように表示されます:
Hello
my dear
world
次のように、yield()とresume()の間に値を渡すこともできます:
func my_func():
print("Hello")
print(yield())
return "cheers!"
func _ready():
var y = my_func()
# Function state saved in 'y'.
print(y.resume("world"))
# 'y' resumed and is now an invalid state.
以下のように表示されます:
Hello
world
cheers!
複数の yield
を使用するときは、新しい関数の状態を忘れずに保存してください:
func co_func():
for i in range(1, 5):
print("Turn %d" % i)
yield();
func _ready():
var co = co_func();
while co is GDScriptFunctionState && co.is_valid():
co = co.resume();
コルーチンとシグナル¶
yield
を使うことの本当の強みはシグナルと組み合わせることです。 yield
は、オブジェクトとシグナルの2つの引数を受け付けることができます。シグナルを受信すると、実行が再開されます。次に例を示します:
# Resume execution the next frame.
yield(get_tree(), "idle_frame")
# Resume execution when animation is done playing.
yield(get_node("AnimationPlayer"), "animation_finished")
# Wait 5 seconds, then resume execution.
yield(get_tree().create_timer(5.0), "timeout")
コルーチン自体は、次のように無効な状態に遷移するときに completed
シグナルを使用します。例:
func my_func():
yield(button_func(), "completed")
print("All buttons were pressed, hurray!")
func button_func():
yield($Button0, "pressed")
yield($Button1, "pressed")
my_func
は、両方のボタンを押した後でのみ実行を継続します。
また、オブジェクトからシグナルが発せられたとき、その引数を取得することもできます:
# Wait for when any node is added to the scene tree.
var node = yield(get_tree(), "node_added")
一つ以上の引数があれば、 yield
は引数を含む配列を返します:
signal done(input, processed)
func process_input(input):
print("Processing initialized")
yield(get_tree(), "idle_frame")
print("Waiting")
yield(get_tree(), "idle_frame")
emit_signal("done", input, "Processed " + input)
func _ready():
process_input("Test") # Prints: Processing initialized
var data = yield(self, "done") # Prints: waiting
print(data[1]) # Prints: Processed Test
ある関数が yield するかどうかわからない場合や、何度も yield するかもしれない時は、条件付きで completed
のシグナルを yield させることができます:
func generate():
var result = rand_range(-1.0, 1.0)
if result < 0.0:
yield(get_tree(), "idle_frame")
return result
func make():
var result = generate()
if result is GDScriptFunctionState: # Still working.
result = yield(result, "completed")
return result
これにより、内部でコルーチンが使われていたかどうかに関わらず、関数が返すべきものを確実に返すようになります。 completed
シグナルは関数がもう yield しない場合にのみ発せられるので、ここで while
を使うと冗長になることに注意してください。
onready keyword¶
ノードを使用する場合、シーンの一部への参照を変数に保持することが一般的です。シーンはアクティブなシーンツリーに入ったときにのみ設定されるので、サブノードは Node._ready()
への呼び出しが行われた時にのみ取得できます。
var my_label
func _ready():
my_label = get_node("MyLabel")
これは特にノードと外部参照が重なっている場合には少し面倒になります。このために、GDScriptには onready
キーワードがあります。これは_readyが呼び出されるまでメンバー変数の初期化を遅らせるものです。 上記のコードを単一行に置き換えることができます:
onready var my_label = get_node("MyLabel")
Assertキーワード¶
assert
キーワードはデバックビルド内で状態をチェックする為に使う事が出来ます。これらの assert は非デバッグビルドでは無視されます。これはリリースモードでのプロジェクトのエクスポートでは引数として渡された式が評価されない事を意味します。
# Check that 'i' is 0. If 'i' is not 0, an assertion error will occur.
assert(i == 0)
エディタ上でプロジェクトが実行されている時に、assertion エラーが発生した場合プロジェクトは停止します。
コメント¶
#
から行末までは無視され、コメントと見なされます。# This is a comment.