GDScript

class_name Player
extends CharacterBody2D
## Doc comment: shown in the editor's help.
 
signal died
 
const MAX_HP := 100
 
@export var speed := 200.0
var hp := MAX_HP
 
func _ready() -> void:
    print("ready with ", hp, " hp")
 
func take_damage(amount: int) -> void:
    hp -= amount
    if hp <= 0:
        died.emit()

var a = 5            # Variant: can later hold a String
var b: int = 5       # typed, explicit
var c := 5           # typed, inferred as int
var d: float         # default 0.0 (int 0, bool false,
                     # String "", Object null)
const GRAVITY := 980.0
const DIRS: Array[Vector2] = [Vector2.UP, Vector2.DOWN]
static var instances := 0  # shared by all instances
 
enum State { IDLE, RUN, JUMP }       # State.IDLE == 0
enum Tier { LOW = 1, MID = 5, HIGH = 10 }
enum { UNNAMED_A, UNNAMED_B }        # plain int constants
 
var state: State = State.IDLE

var names: Array[String] = ["ada", "lin"]
var scores: Dictionary[String, int] = {"ada": 3}
var enemies: Array[Enemy] = []           # custom class
var target: Node2D = null          # Objects may be null
 
var n := get_node("Sprite2D") as Sprite2D  # or null
if n is Sprite2D:                          # narrowing check
    n.flip_h = true
if n is not AnimatedSprite2D:              # 4.3+
    pass
 
for name: String in names:   # typed loop variable
    print(name.to_upper())
 
# Array.map returns an untyped Array; assign() converts
var lengths: Array[int] = []
lengths.assign(names.map(func(s): return s.length()))

var a: Array[int] = [3, 1, 2]
a.append(4)          # push_back
a.insert(0, 9)
a.erase(9)           # remove first matching value
a.remove_at(0)       # by index
var last: int = a.pop_back()  # Variant return
a.sort()             # in place
a.sort_custom(func(x, y): return x > y)   # descending
var evens := a.filter(func(x): return x % 2 == 0)
var total: int = a.reduce(func(acc, x): return acc + x, 0)
var any_big := a.any(func(x): return x > 10)
print(a.has(2), a.find(2), a.size(), a.is_empty())
print(a.slice(1, 3), a.front(), a.back(), a.max())
var copy := a.duplicate()        # shallow; true for deep
var pick: int = a.pick_random()
 
var d := {"hp": 10, "name": "slime"}
d["hp"] -= 1
d.speed = 3.0              # dot access for String keys
print(d.get("armor", 0))   # default when missing
print(d.has("hp"), "hp" in d, d.keys(), d.values())
d.erase("speed")
d.merge({"xp": 5})         # overwrite=false by default
for key in d:
    print(key, " = ", d[key])

if hp <= 0:
    die()
elif hp < 20:
    warn()
else:
    pass
 
for i in 5:                   # 0..4
    pass
for i in range(10, 0, -2):    # 10, 8, 6, 4, 2
    pass
for child in get_children():
    pass
for key in dict:              # keys; dict[key] for value
    pass
for ch in "hey":              # characters
    pass
 
while queue.size() > 0:
    var item = queue.pop_front()
    if item == null:
        continue
    if item.done:
        break

match value:
    0:
        print("zero")
    1, 2, 3:                         # several patterns
        print("small")
    State.RUN:                       # constants and enums
        print("running")
    [var x, var y]:                  # array, binds x and y
        print(x, y)
    [1, ..]:                         # open-ended array
        print("starts with 1")
    {"type": "hit", "dmg": var dmg}: # dictionary
        print(dmg)
    var n when n is int and n > 100: # guard with `when`
        print("big ", n)
    _:                               # wildcard / default
        print("other")

func add(a: int, b: int = 1) -> int:
    return a + b
 
static func clamp01(x: float) -> float:   # no self
    return clampf(x, 0.0, 1.0)
 
func sum(first: float, ...rest: Array) -> float:  # 4.5+
    var t := first
    for v in rest:
        t += v
    return t
 
func log_all(...args: Array) -> void:     # variadic
    print(" ".join(args.map(str)))

# Lambdas are Callables; single-line or indented block
var double := func(x: int) -> int: return x * 2
var greet := func(name: String) -> void:
    print("hi ", name)
    print("bye")
 
double.call(4)                 # 8
double.callv([4])              # args as an Array
var bound := add.bind(10)      # appends args: add(x, 10)
bound.call(1)                  # 11
var method := Callable(self, "add")  # dynamic by name
method.is_valid()
button.pressed.connect(func(): print("clicked"))
 
# Captures copy values at creation: reassigning a
# captured local does not reach the outer scope. Mutate
# a container instead.
var count := [0]
var inc := func(): count[0] += 1

@abstract                       # 4.5+: cannot .new()
class_name Weapon
extends Resource
 
@export var damage := 1
 
@abstract func fire(from: Vector2) -> void
 
func describe() -> String:
    return "%s (%d dmg)" % [get_class(), damage]

class_name Shotgun
extends Weapon
 
func _init(dmg := 4) -> void:   # constructor
    damage = dmg
 
func fire(from: Vector2) -> void:
    for i in 5:
        print("pellet from ", from)
 
func describe() -> String:
    return "Shotgun: " + super()   # parent method

# Inner classes: namespaced under the outer script
class Stats:                    # extends RefCounted
    var hp := 10
    var armor := 0
    func _init(h: int) -> void:
        hp = h
 
var s := Stats.new(20)          # outside: Player.Stats
var gun := Shotgun.new(6)
const EnemyScript := preload("res://enemy.gd")
var e = EnemyScript.new()      # no class_name needed

signal health_changed(value: int)
 
@export var max_health := 100
 
var health := 100:
    set(value):
        health = clampi(value, 0, max_health)  # no recursion
        health_changed.emit(health)
    get:
        return health
 
var ratio: float:                 # computed, no storage
    get:
        return float(health) / max_health
 
var speed: float = 1.0: set = set_speed
 
func set_speed(v: float) -> void:
    speed = maxf(v, 0.0)

@tool
extends Node2D
 
@export_group("Shape")
@export_range(1.0, 500.0, 0.5, "suffix:px")
var radius := 32.0:
    set(v):
        radius = v
        queue_redraw()   # live preview in the editor
@export var color := Color.TOMATO
@export var resource: Weapon            # typed resource slot
@export var targets: Array[Node2D] = [] # node references
 
func _draw() -> void:
    draw_circle(Vector2.ZERO, radius, color)

var s := "Hello"
var multi := """line 1
line 2"""
var raw := r"C:\no\escapes"      # raw string
var sn := &"jump"                # StringName literal
var np := ^"UI/HealthBar"        # NodePath literal
 
"%s has %d hp" % ["slime", 5]    # printf-style
"%.2f" % 3.14159                 # 3.14
"%05d" % 42                      # 00042
"%-8s|" % "ab"                   # left-aligned: "ab      |"
"%x" % 255                       # ff
"%*d" % [4, 7]                   # width from args: "   7"
"{0} vs {1}".format(["a", "b"])
"{name} lv{lvl}".format({"name": "Ada", "lvl": 3})
str(42) + " " + str(Vector2(1, 2))  # "42 (1, 2)"
String.num(3.14159, 2)           # "3.14"

signal hit(damage: int, source: Node)
signal died
 
func _ready() -> void:
    hit.connect(_on_hit)
    died.connect(func(): print("dead"), CONNECT_ONE_SHOT)
 
func _on_hit(damage: int, source: Node) -> void:
    print(source.name, " dealt ", damage)
 
func take(dmg: int, src: Node) -> void:
    hit.emit(dmg, src)

# await pauses this function until the signal fires
func flash() -> void:
    modulate = Color.RED
    await get_tree().create_timer(0.1).timeout
    modulate = Color.WHITE
 
# A function that awaits is a coroutine; await its result
func ask() -> bool:
    $Dialog.popup()
    var ok: bool = await $Dialog.answered  # 1 arg: value
    return ok
 
func _on_button_pressed() -> void:
    if await ask():
        print("confirmed")
    await get_tree().process_frame    # wait one frame
    await get_tree().physics_frame    # wait one tick
    await $Anim.animation_finished

var err := ResourceSaver.save(res, "user://a.tres")
if err != OK:
    push_error("save failed: %s" % error_string(err))
    return
 
var f := FileAccess.open("user://x.txt", FileAccess.READ)
if f == null:                           # null on failure
    push_warning(str(FileAccess.get_open_error()))
 
assert(speed > 0.0, "speed must be positive")  # debug only
print_debug("reached")   # adds file:line (debug builds)
print_stack()            # current GDScript call stack
breakpoint               # keyword: pause here in debugger

var dir := (target.global_position - global_position)
var n := dir.normalized()          # safe on ZERO: ZERO
var facing := Vector2.RIGHT.rotated(rotation)
position += n * speed * delta      # position.x += 1 works
look_at(get_global_mouse_position())  # Node2D helper
var local := to_local(world_point)    # and to_global()
 
var t := Transform3D.IDENTITY.looking_at(
    Vector3(0, 0, -5), Vector3.UP)
var fwd := -global_transform.basis.z  # 3D forward
var c := Color.WHITE.lerp(Color.RED, 0.5)

# Frame-rate independent smoothing (exponential decay)
var k := 10.0
pos = pos.lerp(target, 1.0 - exp(-k * delta))

enum State { IDLE, RUN, ATTACK }
var state := State.IDLE
 
func _physics_process(delta: float) -> void:
    match state:
        State.IDLE:
            if Input.get_axis("left", "right") != 0.0:
                _enter(State.RUN)
        State.RUN:
            _move(delta)
            if Input.is_action_just_pressed("attack"):
                _enter(State.ATTACK)
        State.ATTACK:
            pass  # animation_finished returns to IDLE
 
func _enter(next: State) -> void:
    if next == state:
        return
    state = next
    $Anim.play(State.keys()[next].to_lower())

@export var cooldown := 0.4
var _ready_at := 0.0
 
func try_fire() -> bool:
    var now := Time.get_ticks_msec() / 1000.0
    if now < _ready_at:
        return false
    _ready_at = now + cooldown
    _spawn_bullet()
    return true

static func weighted_pick(
    items: Array, weights: PackedFloat32Array,
) -> Variant:
    var total := 0.0
    for w in weights:
        total += w
    var r := randf() * total
    for i in items.size():
        r -= weights[i]
        if r <= 0.0:
            return items[i]
    return items.back()
 
# weighted_pick(["common", "rare"], [9.0, 1.0])

class_name ItemStack
extends RefCounted
 
var id: StringName
var count: int
 
func _init(p_id: StringName, p_count := 1) -> void:
    id = p_id
    count = p_count
 
func _to_string() -> String:   # used by print() / str()
    return "%s x%d" % [id, count]
 
# var s := ItemStack.new(&"potion", 3); print(s)

var _gen := 0
 
func debounce(fn: Callable, wait := 0.3) -> void:
    _gen += 1
    var my_gen := _gen
    await get_tree().create_timer(wait).timeout
    if my_gen == _gen:        # nothing newer arrived
        fn.call()
 
func _on_search_text_changed(t: String) -> void:
    debounce(_run_search.bind(t))

@abstract
class_name Targeting
extends RefCounted
 
@abstract func pick(from: Node2D, all: Array) -> Node2D

class_name NearestTargeting
extends Targeting
 
func pick(from: Node2D, all: Array) -> Node2D:
    var best: Node2D = null
    var best_d := INF
    for n: Node2D in all:
        var p := n.global_position
        var d := from.global_position.distance_squared_to(p)
        if d < best_d:
            best = n
            best_d = d
    return best
 
# var t: Targeting = NearestTargeting.new()
# Targeting.new() is an error (abstract)