GDScript Exporte

Einführung in Exporte

In Godot können Klassenmember exportiert werden. Das bedeutet, dass ihre Werte zusammen mit der zugehörigen Ressource (z.B. der Szene) gespeichert werden. Sie sind außerdem im Eigenschaftseditor verfügbar und können hier editiert werden. Das exportieren funktioniert über das Schlüsselwort export:

extends Button

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

Eine exportierte Variable muss mit einem konstanten Ausdruck initialisiert werden oder einen Zusatz in Form eines Arguments in der Exportanweisung besitzen (siehe Beispiele unten).

Einer der größten Vorteile exportierter Variablen ist, dass diese im Editor sichtbar und veränderbar sind. Auf diese Weise können Grafiker, Spiele Designer, etc. diese Werte verändert, die dann das Spielgeschehen beeinflussen. Hierfür gibt es einen speziellen Export Befehl.

Bemerkung

Exporting properties can also be done in other languages such as C#. The syntax varies depending on the language.

Beispiele

# 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 basic data type as an argument, which will be
# used in the editor.

export(int) var number

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

export(Texture) var character_face
export(PackedScene) var scene_file
# There are many resource types that can be used this way, try e.g.
# the following to list them:
export(Resource) var resource

# 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, "Rebecca", "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 hint.
export(String, FILE, "*.txt") var f

# Using paths in the global filesystem is also possible,
# but only in scripts in "tool" mode.

# 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 and snap the value to multiples 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 (alpha will always be 1).
export(Color, RGB) var col
# Color given as red-green-blue-alpha value.
export(Color, RGBA) var col

# Nodes

# Another node in the scene can be exported as a NodePath.
export(NodePath) var node_path
# Do take note that the node itself isn't being exported -
# there is one more step to call the true node:
onready var node = get_node(node_path)

# Resources

export(Resource) var resource
# In the Inspector, you can then drag and drop a resource file
# from the FileSystem dock into the variable slot.

# Opening the inspector dropdown may result in an
# extremely long list of possible classes to create, however.
# Therefore, if you specify an extension of Resource such as:
export(AnimationNode) var resource
# The drop-down menu will be limited to AnimationNode and all
# its inherited classes.

Es ist zu beachten, dass die exportierten Eigenschaften auch dann bearbeitet werden können, wenn das Skript im Editor nicht ausgeführt wird. Dies kann in Verbindung mit einem Skript im" Tool "-Modus verwendet werden.

Bit Flags exportieren

Integer die als bit flags verwendet werden, können mehrere true/false (boolean) Werte auf einmal enthalten. Mit dem Exporthinweis int, FLAGS, ... können sie im Editor gesetzt werden:

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

Für jedes Flag muss ein Name angeben werden. In diesem Beispiel hat Fire den Wert 1, Water den Wert 2, Earth den Wert 4 und Wind den Wert 8. Normalerweise sollten Konstanten einheitlich bennant werden (z.B.: const ELEMENT_WIND = 8 und so weiter).

Exporthinweise werden auch für die in den Projekteinstellungen definierten Physik- und Renderebenen bereitgestellt:

export(int, LAYERS_2D_PHYSICS) var layers_2d_physics
export(int, LAYERS_2D_RENDER) var layers_2d_render
export(int, LAYERS_3D_PHYSICS) var layers_3d_physics
export(int, LAYERS_3D_RENDER) var layers_3d_render

Die Verwendung von Bitflags erfordert ein gewisses Verständnis der bitweisen Operationen. Verwenden Sie im Zweifelsfall stattdessen boolesche Variablen.

Arrays exportieren

Exportierte Arrays können Initialisierer haben, müssen jedoch konstante Ausdrücke sein.

Wenn das exportierte Array einen Typ angibt, der von Resource erbt, können die Array-Werte im Inspektor festgelegt werden, indem mehrere Dateien gleichzeitig aus dem FileSystem-Dock gezogen und abgelegt werden.

# Default value must be a constant expression.

export var a = [1, 2, 3]

# Exported arrays can specify 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.0, 2.0], [3.0, 4.0]]

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

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

# Arrays with specified types which inherit from resource can be set by
# drag-and-dropping multiple files from the FileSystem dock.

export(Array, Texture) var textures
export(Array, PackedScene) var scenes

# Typed arrays also work, only initialized empty:

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

# Default value can include run-time values, but can't
# be exported.

var c = [a, 2, 3]

Festlegen exportierter Variablen aus einem Tool-Skript

Wenn Sie den Wert einer exportierten Variablen aus einem Skript in Werkzeug-Modus ändern, wird der Wert im Inspektor nicht automatisch aktualisiert. Rufen Sie zum Aktualisieren Folgendes auf property_list_changed_notify(), nachdem Sie den Wert der exportierten Variablen festgelegt haben.

Fortgeschrittene Exporte

Nicht jede Art von Export kann auf der Ebene der Sprache selbst bereitgestellt werden, um unnötige Designkomplexität zu vermeiden. Im Folgenden werden einige mehr oder weniger häufig verwendete Exportfunktionen beschrieben, die mit einer Low-Level-API implementiert werden können.

Bevor Sie weiterlesen, sollten Sie sich mit der Art und Weise vertraut machen, wie Eigenschaften behandelt werden und wie sie angepasst werden können mit _set() , _get() und :ref:` _get_property_list() <class_Object_method__get_property_list> Methoden wie beschrieben in :ref:`doc_accessing_data_or_logic_from_object.

Siehe auch

Informationen zum Binden von Eigenschaften mit den oben genannten Methoden in C++ finden Sie unter Bindung von Eigenschaften mit _set/_get/_get_property_list.

Warnung

Das Skript muss im Werkzeug -Modus arbeiten, damit die oben genannten Methoden im Editor ausgeführt werden können.

Eigenschaften

To understand how to better use the sections below, you should understand how to make properties with advanced exports.

func _get_property_list():
    var properties = []
    # Same as "export(int) var my_property"
    properties.append({
        name = "my_property",
        type = TYPE_INT
    })
    return properties

  • The _get_property_list() function gets called by the inspector. You can override it for more advanced exports. You must return an Array with the contents of the properties for the function to work.

  • name ist der Name einer Kategorie, die dem Inspektor hinzugefügt werden soll

  • type is the type of the property from Variant.Type.

Bemerkung

The float type is called a real (TYPE_REAL) in the Variant.Type enum.

Anhängen von Variablen an Eigenschaften

To attach variables to properties (allowing the value of the property to be used in scripts), you need to create a variable with the exact same name as the property or else you may need to override the _set() and _get() methods. Attaching a variable to to a property also gives you the ability to give it a default state.

# This variable is determined by the function below.
# This variable acts just like a regular gdscript export.
var my_property = 5

func _get_property_list():
    var properties = []
    # Same as "export(int) var my_property"
    properties.append({
        name = "my_property",
        type = TYPE_INT
    })
    return properties

Adding default values for properties

To define default values for advanced exports, you need to override the property_can_revert() and property_get_revert() methods.

  • The property_can_revert() method takes the name of a property and must return true if the property can be reverted. This will enable the Revert button next to the property in the inspector.

  • The property_get_revert() method takes the name of a property and must return the default value for that property.

func _get_property_list():
    var properties = []
    properties.append({
        name = "my_property",
        type = TYPE_INT
    })
    return properties

func property_can_revert(property):
    if property == "my_property":
        return true
    return false

func property_get_revert(property):
    if property == "my_property":
        return 5

Skript Kategorien hinzufügen

Zur besseren visuellen Unterscheidung von Eigenschaften kann eine spezielle Skriptkategorie in den Inspektor eingebettet werden, um als Trennzeichen zu fungieren. Skriptvariablen ist ein Beispiel für eine integrierte Kategorie.

func _get_property_list():
    var properties = []
    properties.append({
        name = "Debug",
        type = TYPE_NIL,
        usage = PROPERTY_USAGE_CATEGORY | PROPERTY_USAGE_SCRIPT_VARIABLE
    })

    # Example of adding a property to the script category
    properties.append({
        name = "Logging_Enabled",
        type = TYPE_BOOL
    })
    return properties

  • name ist der Name einer Kategorie, die dem Inspektor hinzugefügt werden soll;

  • Every following property added after the category definition will be a part of the category.

  • PROPERTY_USAGE_CATEGORY gibt an, dass die Eigenschaft speziell als Skriptkategorie behandelt werden soll, sodass der Typ TYPE_NIL ignoriert werden kann, da er nicht für die Skriptlogik verwendet wird, aber dennoch definiert werden muss.

Eigenschaften gruppieren

Eine Liste von Eigenschaften mit ähnlichen Namen kann gruppiert werden.

func _get_property_list():
    var properties = []
    properties.append({
        name = "Rotate",
        type = TYPE_NIL,
        hint_string = "rotate_",
        usage = PROPERTY_USAGE_GROUP | PROPERTY_USAGE_SCRIPT_VARIABLE
    })

    # Example of adding to the group
    properties.append({
        name = "rotate_speed",
        type = TYPE_REAL
    })

    # This property won't get added to the group
    # due to not having the "rotate_" prefix.
    properties.append({
        name = "trail_color",
        type = TYPE_COLOR
    })
    return properties

  • `` name`` ist der Name einer Gruppe, die als zusammenklappbare Liste von Eigenschaften angezeigt wird;

  • Every following property added after the group property with the prefix (which determined by hint_string) will be shortened. For instance, rotate_speed is going to be shortened to speed in this case. However, movement_speed won't be a part of the group and will not be shortened.

  • PROPERTY_USAGE_GROUP gibt an, dass die Eigenschaft speziell als Skriptgruppe behandelt werden soll, sodass der Typ TYPE_NIL ignoriert werden kann, da er nicht für die Skriptlogik verwendet wird, aber dennoch definiert werden muss.