GDscript 中的类

2024年8月29日 | 阅读 8 分钟

脚本文件的主体是一个未命名的类，它只能作为资源或文件从外部引用。类语法的设计紧凑，只能包含成员变量或函数。允许使用静态函数，但不允许使用静态成员（这是为了线程安全，因为脚本可以在不知道用户的情况下在单独的线程中初始化）。同样，每次创建实例时都会初始化成员变量（包括数组和字典）。

以下是一个类文件的示例；

# Saved as a file named 'myclass.gd.' 

var a = 5

func print_value_of_a():
    print(a)

继承

类可以从以下类继承

全局类
另一个类文件
另一个类文件中的内部类。

不允许使用多重继承。

继承使用 extends 关键字

# Inherit/extend a globally available class.
extends SomeClass

# Inherit/extend a named class file.
extends "some file.gd."

# Inherit 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()

要调用基类（即，在我们当前类中 –ed 扩展的类）中的函数，请在函数名称前添加 . （点）

这很有用，因为扩展类中的函数会替换其基类中具有相同名称的函数。因此，如果我们仍然想调用它们，我们可以像其他语言中的 super 关键字一样使用它。（点）

func some_func(x):
    .some_func(x) # Calls the same function on the parent class.

类构造函数

在类实例化时调用的类构造函数名为 _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），那么继承的类 (Idle.gd) 也必须定义 _init 并将适当的参数传递给来自 gd 的 _init。
gd 可以具有与基类 State.gd 不同的参数数量。
在上面的示例中，传递给 gd 构造函数的 e 与移动到 Idle.gd 中的 e 相同。
如果 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()

类作为资源

存储为文件的类被视为资源。必须从磁盘加载它们才能在其他类中访问它们。这是使用 load 或 preload 函数完成的。通过在类对象上调用 new 函数来完成加载的类资源的实例化；

# Load the class resource when calling load().
var my_class = load("myclass.gd")

# Preload the class only at compile time.
const MyClass = preload("myclass.gd")

func _init():
    var a = MyClass.new()
    a.some_function()

导出

可以导出类成员。这意味着它们的值会与它们附加到的资源一起保存。它们可以在属性编辑器中进行编辑。导出通过使用 export 关键字来完成

extends Button
export var number = 5 # Value will be saved and visible in the property editor.

导出的变量必须初始化为常量表达式，或者具有 export 提示，该提示以参数的形式传递给 export 关键字

导出成员变量的一个重要好处是使它们在编辑器中可见且可编辑。通过使用 export 关键字来完成发布。

导出成员变量的主要好处之一是使它们在编辑器中可见且可编辑。这样，美术师和游戏设计师可以修改以后会影响程序运行方式的值。提供了一种特殊的导出语法。

# If the exported value assigns a constant or constant expression,
# the type will be inferred and used in the editor.

export var number = 5

# Export can take a primary data type as an argument which will be
# used in the editor.

export(int) var number

# Export can take a resource type to use as a hint.

export(Texture) var character_face
export(PackedScene) var scene_file

# Integers and strings hint enumerated values.

# Editor will enumerate as 0, 1 and 2.
export(int, "Warrior", "Magician", "Thief") var character_class
# Editor will enumerate with string names.
export(String, "Rebeca", "Mary", "Leah") var character_name

# Named Enum Values

# Editor will enumerate as THING_1, THING_2, ANOTHER_THING.
enum NamedEnum {THING_1, THING_2, ANOTHER_THING = -1}
export (NamedEnum) var x

# Strings as Paths

# String is a path to a file.
export(String, FILE) var f
# String is a path to a directory.
export(String, DIR) var f
# String is a path to a file, custom filter provided as a hint.
export(String, FILE, "*.txt") var f

# Using paths in the global filesystem is also possible,
# but only in tool scripts (see further below).

# String is a path to a PNG file in the global filesystem.
export(String, FILE, GLOBAL, "*.png") var tool_image
# String is a path to a directory in the global filesystem.
export(String, DIR, GLOBAL) var tool_dir

# The MULTILINE setting tells the editor to show a large input
# field for editing over multiple lines.
export(String, MULTILINE) var text

# Limiting editor input ranges

# Allow integer values from 0 to 20.
export(int, 20) var i
# Allow integer values from -10 to 20.
export(int, -10, 20) var j
# Allow floats from -10 to 20, with a step of 0.2.
export(float, -10, 20, 0.2) var k
# Allow values y = exp(x) where y varies between 100 and 1000
# while snapping to steps of 20. The editor will present a
# slider for easily editing the value.
export(float, EXP, 100, 1000, 20) var l

# Floats with Easing Hint

# Display a visual representation of the ease() function
# when editing.
export(float, EASE) var transition_speed

# Colors

# Color given as Red-Green-Blue value
export(Color, RGB) var col # Color is RGB.
# Color given as Red-Green-Blue-Alpha value
export(Color, RGBA) var col # Color is RGBA.

# Another node in the scene can be exported too.

export(NodePath) var node

必须注意的是，即使脚本不在编辑器中，导出的属性仍然可以编辑。

请参阅下面的 (tool)

导出位标志

在位标志中使用的整数可以在一个属性中存储多个 true/ false 值。通过使用导出提示 [int, FLAGS]，可以将它们发送到编辑器。

# individually edit a bit of integer.
Export(int,FLAGS) var spell/elements=ELEMENT/WIND|ELEMENT/WATER

也可以限制任何数量的编号标志中的标志。语法类似于枚举语法。

# Set any of the given flags from the editor.
export(int, FLAGS, "Fire", "Water", "Earth", "Wind") var spell_elements = 0

在该示例中，Fire 的值为 1，Water 的值为 2，Earth 的值为 4，而 wind 对应于值 8。通常，应相应地定义常量。

使用位标志需要了解一些按位运算。如果有疑问，则应改为导出布尔变量。

导出数组

导出数组有效，但有一个重要的警告：虽然常规数组是为每个类实例本地创建的，但导出的数组在所有实例之间共享。这意味着在一个实例中进行编辑将导致它们在所有其他实例中发生更改。导出的数组可以具有初始化器，但它们必须是常量表达式。

# Exported array, shared between all instances.
The # Default value must be a constant expression.

export var a = [1, 2, 3]

# Exported arrays can specify a type (using the same hints as before).

export(Array, int) var ints = [1,2,3]
export(Array, int, "Red", "Green", "Blue") var enums = [2, 1, 0]
export(Array, Array, float) var two_dimensional = [[1, 2], [3, 4]]

# You can omit the default value, but then it would be null if not assigned.

export(Array) var b
export(Array, PackedScene) var scenes

# Typed arrays also work, only initialized empty:

export var vector3s = PoolVector3Array()
export var strings = PoolStringArray()

# Regular array created locally for every instance.
The # Default value can include run-time values, but can't
# be exported.

var c = [a, 2, 3]

Setter/getter

了解类的成员变量由于任何原因而发生更改时都很有用。可能还需要以某种方式封装其访问。

为此，GDScript 提供了一种使用 setget 关键字的 setter/getter 语法。它直接在变量定义之后使用

每当 variable 的值被外部源修改时（即，不是来自类中的本地用法），将调用 setter 函数（上面的 setterfunc）。

这发生在值更改之前。 setter 必须决定如何处理新值。反之亦然，当访问 variable 时，getter 函数 getterfunc 上面) 必须返回所需的值。

示例

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 myvar_set
# Only a getter (note the comma).
var my_var = 5 setget ,myvar_get

Get/Setter 在工具脚本或插件中将变量导出到编辑器以验证输入时特别有用。

本地访问不会触发 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)

下一主题GDScript中的工具模式