Running code in the editor

    You can use it for doing many things, but it is mostly useful in level design for visually presenting things that are hard to predict ourselves. Here are some use cases:

    • If you have a cannon that shoots cannonballs affected by physics (gravity), you can draw the cannonball’s trajectory in the editor, making level design a lot easier.

    • If you have jumppads with varying jump heights, you can draw the maximum jump height a player would reach if it jumped on one, also making level design easier.

    • If your player doesn’t use a sprite, but draws itself using code, you can make that drawing code execute in the editor to see your player.

    Danger

    tool scripts run inside the editor, and let you access the scene tree of the currently edited scene. This is a powerful feature which also comes with caveats, as the editor does not include protections for potential misuse of tool scripts. Be extremely cautious when manipulating the scene tree, especially via , as it can cause crashes if you free a node while the editor runs logic involving it.

    To turn a script into a tool, add the keyword tool at the top of your code.

    To check if you are currently in the editor, use: Engine.editor_hint.

    For example, if you want to execute some code only in the editor, use:

    GDScript   C#

    1. if (Engine.EditorHint)
    2. {
    3.     // Code to execute when in editor.
    4. }

    On the other hand, if you want to execute code only in game, simply negate the same statement:

    1. if not Engine.editor_hint:
    2.     # Code to execute when in game.
    1. if (!Engine.EditorHint)
    2. {
    3.     // Code to execute when in game.
    4. }

    Pieces of code do not have either of the 2 conditions above will run both in-editor and in-game.

    Here is how a _process() function might look for you:

    GDScript   C#

    1. func _process(delta):
    2.     if Engine.editor_hint:
    3.         # Code to execute in editor.
    5.     if not Engine.editor_hint:
    6.         # Code to execute in game.
    8.     # Code to execute both in editor and in game.

    Note

    Modifications in editor are permanent. For example, in the following case, when we remove the script, the node will keep its rotation. Be careful to avoid making unwanted modifications.

    Add a Sprite node to your scene and set the texture to Godot icon. Attach and open a script, and change it to this:

    GDScript   C#

    1. tool
    2. extends Sprite
    4. func _process(delta):
    5.     rotation_degrees += 180 * delta
    1. using Godot;
    2. using System;
    4. [Tool]
    5. {
    7.     {
    8.         RotationDegrees += 180 * delta;
    9.     }
    10. }

    Save the script and return to the editor. You should now see your object rotate. If you run the game, it will also rotate.

    Note

    If you don’t see the changes, reload the scene (close it and open it again).

    GDScript   C#

    1. func _process(delta):
    2.     if Engine.editor_hint:
    3.         rotation_degrees += 180 * delta
    4.     else:
    5.         rotation_degrees -= 180 * delta
    1. public override void _Process(float delta)
    2. {
    3.     if (Engine.EditorHint)
    4.     {
    5.         RotationDegrees += 180 * delta;
    6.     }
    7.     else
    8.     {
    9.         RotationDegrees -= 180 * delta;
    10.     }
    11. }

    Save the script. Now the object will spin clockwise in the editor, but if you run the game, it will spin counter-clockwise.

    Add and export a variable speed to the script. The function set_speed after “setget” is executed with your input to change the variable. Modify _process() to include the rotation speed.

    GDScript   C#

    1. using Godot;
    2. using System;
    4. [Tool]
    5. public class MySprite : Sprite
    6. {
    7.     private float speed = 1;
    9.     [Export]
    10.     public float Speed {
    11.         get => speed;
    12.         set => SetSpeed(value);
    13.     }
    14.     // Update speed and reset the rotation.
    16.     {
    17.         speed = newSpeed;
    18.         RotationDegrees = 0;
    19.     }
    21.     public override void _Process(float delta)
    22.     {
    23.         RotationDegrees += 180 * delta * speed;
    24.     }
    25. }

    Note

    Code from other nodes doesn’t run in the editor. Your access to other nodes is limited. You can access the tree and nodes, and their default properties, but you can’t access user variables. If you want to do so, other nodes have to run in the editor too. AutoLoad nodes cannot be accessed in the editor at all.

    You can instantiate packed scenes normally and add them to the scene currently opened in the editor. By default, nodes or scenes added with Node.add_child(node) are not visible in the Scene tree dock and are not persisted to disk. If you wish the node or scene to be visible in the scene tree dock and persisted to disk when saving the scene, you need to set the child node’s property to the currently edited scene root.

    If you are using tool:

    GDScript   C#

    1. func _ready():
    2.     var node = Spatial.new()
    3.     add_child(node) # Parent could be any node in the scene
    5.     # The line below is required to make the node visible in the Scene tree dock
    6.     # and persist changes made by the tool script to the saved scene file.
    7.     node.set_owner(get_tree().edited_scene_root)
    1. public override void _Ready()
    2. {
    3.     var node = new Spatial();
    4.     AddChild(node); // Parent could be any node in the scene
    6.     // The line below is required to make the node visible in the Scene tree dock
    7.     // and persist changes made by the tool script to the saved scene file.
    8.     node.Owner = GetTree().EditedSceneRoot;
    9. }

    If you are using EditorScript:

    GDScript   C#

    1. func _run():
    2.     var parent = get_scene().find_node("Parent") # Parent could be any node in the scene
    3.     var node = Spatial.new()
    4.     parent.add_child(node)
    6.     # The line below is required to make the node visible in the Scene tree dock
    7.     # and persist changes made by the tool script to the saved scene file.

    Using tool improperly can yield many errors. It is advised to first write the code how you want it, and only then add the tool keyword to the top. Also, make sure to separate code that runs in-editor from code that runs in-game. This way, you can find bugs more easily.