Update documentation to match new traits PR

Mostly removing `trait_name` references

Author: Meorge

tutorials/scripting/gdscript/gdscript_basics.rst

@@ -190,9 +190,7 @@ in case you want to take a look under the hood.
 +------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
 | extends    | Defines what class to extend with the current class.                                                                                              |
 +------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
-| trait      | Defines an inner trait. See `Inner traits`_.                                                                                                      |
-+------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
-| trait_name | Defines the script as a globally accessible trait with the specified name. See `Registering named traits`_.                                       |
+| trait      | Defines a trait. See `Traits`_.                                                                                                                   |
 +------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
 | uses       | Defines what trait(s) the current class should use.                                                                                               |
 +------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
@@ -1107,7 +1105,6 @@ Valid types are:
 - Constant names if they contain a script or trait resource (``MyScript`` if you declared ``const MyScript = preload("res://my_script.gd")``).
 - Other classes or traits in the same file, respecting scope (``InnerClass.NestedClass`` if you declared ``class NestedClass`` inside the ``class InnerClass`` in the same scope).
 - Script classes declared with the ``class_name`` keyword.
-- Traits declared with the ``trait_name`` keyword.
 - Autoloads registered as singletons.
 
 .. note::
@@ -1258,18 +1255,6 @@ A base class static variable can also be accessed via a child class:
         B.x = 3
         prints(A.x, B.x) # 3 3
 
-Likewise, if a class uses a trait with static variables, it will inherit those
-variables::
-
-    trait HasStatic:
-        static var static_var = 3
-
-    class UsingClass:
-        uses HasStatic
-
-    func _ready():
-        print(UsingClass.static_var)
-
 ``@static_unload`` annotation
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -2381,94 +2366,74 @@ class resource is done by calling the ``new`` function on the class object:
         var a = MyClass.new()
         a.some_function()
 
+
+.. _doc_gdscript_basics_traits:
+
 Traits
 ------
 
 Since Godot 4.x, GDScript supports traits, which are collections of behaviors and attributes
 that classes can use to guarantee
 functionality to themselves and other objects that may be attempting to use them.
 
-Like classes, by default all ``.gdt`` files are unnamed traits, and you must reference
-them using a relative or absolute path.
-::
-    # Use the trait 'interactable.gdt'.
-    uses "res://path/to/interactable.gdt"
-
 Note that traits on their own *cannot* be instantiated the same way that classes can.
 
-.. _doc_gdscript_basics_trait_name:
-
-Registering named traits
+Registering traits
 ~~~~~~~~~~~~~~~~~~~~~~~~
 
-Traits can be given a global name by using the ``trait_name`` keyword.
+Traits can be created inside of a GDScript class by using the ``trait`` keyword.
 ::
-    trait_name MyTrait
+
+    trait Damageable:
+        signal died
+
+        const MAX_HEALTH = 100
+        var health = MAX_HEALTH
+
+        func take_damage(amount):  # Will automatically exist in any class using this trait.
+            health -= amount
+            on_hit()
+            if health <= 0:
+                on_death()
+                died.emit()
+
+        func on_hit()  # Unimplemented method - Must be overriden in any class using this trait.
     
 Using traits in a class
 ~~~~~~~~~~~~~~~~~~~~~~~
 
-For a class to use a trait, use the ``uses`` keyword:
-::
-    class_name MyScript
-    uses MyTrait
-
-
-Traits may also extend classes. If a trait extends a class, then any class
-that uses that trait must also have that class as an ancestor.
+For a class to use a trait, include the ``uses`` keyword:
 ::
-    # movable.gdt
-    trait_name Movable
-    extends PhysicsBody2D
-
-    # character.gd
-    class_name Character
-    extends CharacterBody2D
-    uses Movable  # Allowed, since CharacterBody2D inherits from PhysicsBody2D.
+    class_name Player
+    uses Damageable
 
 The ``is`` keyword can be used to determine if a given instance uses a particular trait.
 ::
-    if entity is Movable:
-        entity.move()
+    if entity is Damageable:
+        entity.take_damage(1)
 
 If a trait provides a method signature, but no body, then the using class must implement
 a body for the method.
 ::
-    # explosive.gdt
-    trait_name Explosive
-    
-    func explode()  # Body is not defined here, so it must be defined in each class that uses it.
-
-
-    # exploding_barrel.gd
-    class_name ExplodingBarrel
-    extends Sprite2D
-    uses Explosive
+    class_name Player
+    extends CharacterBody2D
+    uses Damageable
 
-    func explode():  # If this definition of Explosive.explode isn't provided, we will get an error.
-        print("Kaboom!")
-        queue_free()
+    func on_hit():
+        print("Ouch, that hurt!")
 
 If a trait provides a method signature *and* a body, then the using class inherits it by default
 and doesn't need to provide its own implementation. It still can override the trait's
 implementation if desired, but the parameter count must stay the same, and the parameter and return
 types must be compatible.
 ::
-    # damageable.gdt
-    trait_name Damageable
-
-    func take_damage():
-        print("Ouch!")
-
-
-    # invincible_npc.gd
     class_name InvincibleNPC
     extends Sprite2D
     uses Damageable
 
     # Allowed, and will run instead of Damageable's original take_damage method.
-    func take_damage():
-        print("You can't hurt me!")
+    func take_damage(amount):
+        print("Ah ha ha! You can't hurt me!")
 
 ..
     TODO: Confirm these behaviors
@@ -2479,39 +2444,6 @@ Other class members have similar rules:
 - Signals can be overriden, as long as the parameter count is maintained and the parameter types are compatible.
 - Named enums can be overriden and have new enum values.
 
-.. _doc_gdscript_basics_inner_traits:
-
-Inner traits
-~~~~~~~~~~~~
-
-Like inner classes, a class or trait file may contain inner traits, defined with the ``trait``
-keyword. Unlike inner classes, they cannot be instantiated directly, but their name can be
-referenced for using or checking use of themselves.
-::
-    # An inner trait in this class file.
-    trait SomeInnerTrait:
-        func do_something():
-            print("I did something!")
-
-
-    # An inner class in this class file, which uses the inner trait.    
-    class SomeInnerClass:
-        uses SomeInnerTrait
-
-
-    func _init():
-        var c = SomeInnerClass.new()
-        if c is SomeInnerTrait:
-            c.do_something()
-
-.. _doc_gdscript_basics_traits_as_resources:
-
-Traits as resources
-~~~~~~~~~~~~~~~~~~~
-
-Traits stored as files are treated as :ref:`GDTraits <class_GDTrait>`, and must
-be loaded similarly to classes (see `Classes as resources`_).
-
 Exports
 -------
 

tutorials/scripting/gdscript/gdscript_styleguide.rst

@@ -651,7 +651,7 @@ code. As a summary table:
 +---------------+----------------+----------------------------------------------------+
 | Class names   | PascalCase     | ``class_name YAMLParser``                          |
 +---------------+----------------+----------------------------------------------------+
-| Trait names   | PascalCase     | ``trait_name Interactable``                        |
+| Trait names   | PascalCase     | ``trait Interactable``                             |
 +---------------+----------------+----------------------------------------------------+
 | Node names    | PascalCase     | ``Camera3D``, ``Player``                           |
 +---------------+----------------+----------------------------------------------------+
@@ -671,8 +671,7 @@ code. As a summary table:
 File names
 ~~~~~~~~~~
 
-Use snake_case for file names. For named classes and traits, convert the PascalCase class or trait
-name to snake_case::
+Use snake\_case for file names. For named classes, convert the PascalCase class name to snake_case::
 
     # This file should be saved as `weapon.gd`.
     class_name Weapon
@@ -684,12 +683,6 @@ name to snake_case::
     class_name YAMLParser
     extends Object
 
-::
-    
-    # This file should be saved as `interactable.gdt`.
-    trait_name Interactable
-    extends Node
-
 This is consistent with how C++ files are named in Godot's source code. This
 also avoids case sensitivity issues that can crop up when exporting a project
 from Windows to other platforms.

tutorials/scripting/gdscript/static_typing.rst

@@ -122,8 +122,7 @@ Here is a complete list of what can be used as a type hint:
 7. Global, native and custom named enums. Note that an enum type is just an ``int``,
    there is no guarantee that the value belongs to the set of enum values.
 8. Constants (including local ones) if they contain a preloaded class or enum.
-9. :ref:`Global traits <doc_gdscript_basics_trait_name>`.
-10. :ref:`Inner traits <_doc_gdscript_basics_inner_traits>`.
+9. :ref:`Traits <doc_gdscript_basics_traits>`.
 
 You can use any class or trait, including your custom classes and traits, as types. There are two ways
 to use them in scripts. The first method is to preload the script you want to use
@@ -148,20 +147,7 @@ and you can use it anywhere, without having to preload it into a constant:
 ::
 
     var my_rifle: Rifle
-
-These methods also work with traits, except using ``trait_name`` and ``uses`` in place
-of ``class_name`` and ``extends``::
-
-    const Shootable = preload("res://player/weapons/shootable.gdt")
-    var something_shootable: Shootable
-
-::
-
-    class_name Rifle
-    uses Shootable
-
-    # Somewhere else...
-    var my_shootable_thing: Shootable
+    
 
 Specify the return type of a function with the arrow ``->``
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~