# Everything after "#" is a comment.
# A file is a class!

# (optional) icon to show in the editor dialogs:
@icon("res://path/to/optional/icon.svg")

# (optional) class definition:
class_name MyClass

# Inheritance:
extends BaseClass

# Member variables.
var a = 5
var s = "Hello"
var arr = [1, 2, 3]
var dict = {"key": "value", 2: 3}
var other_dict = {key = "value", other_key = 2}
var typed_var: int
var inferred_type := "String"

# Constants.
const ANSWER = 42
const THE_NAME = "Charly"

# Enums.
enum {UNIT_NEUTRAL, UNIT_ENEMY, UNIT_ALLY}
enum Named {THING_1, THING_2, ANOTHER_THING = -1}

# Built-in vector types.
var v2 = Vector2(1, 2)
var v3 = Vector3(1, 2, 3)

# Functions.
func some_function(param1, param2, param3):
	const local_const = 5

	if param1 < local_const:
		print(param1)
	elif param2 > 5:
		print(param2)
	else:
		print("Fail!")

	for i in range(20):
		print(i)

	while param2 != 0:
		param2 -= 1

	match param3:
		3:
			print("param3 is 3!")
		_:
			print("param3 is not 3!")

	var local_var = param1 + 3
	return local_var

# Functions override functions with the same name on the base/super class.
# If you still want to call them, use "super":
func something(p1, p2):
	super(p1, p2)

# It's also possible to call another function in the super class:
func other_something(p1, p2):
	super.something(p1, p2)

# Inner class
class Something:
	var a = 10

# Constructor
func _init():
	print("Constructed!")
	var lv = Something.new()
	print(lv.a)

@export_range(1, 100)
var ranged : int = 50

var adict = {
   first  = "blah",
   second = 3,
   third  = [1,2,3],
}

# 'self' is always available
func example(a:int,b:str, c:="blah") -> bool:
	return false

var exfn : Callable = example

example(2,"bloo")
exfn.call(2, "bloo")

var a_lambda : Callable = func(x): print(x)
var b_lambda : Callable = func(x): return x + 2

a_lambda.call(2)

static func blah() -> void:
	print("blah")

func a_coroutine():
	print("blah")
	# Waits until the signal is emitted:
	await $ANode.a_signal
	return true

# Somewhere else:
var result = await a_coroutine()
# will error:
var other = a_coroutine()
# not needing the result does need await:
a_coroutine()

var myvar : int = 2
# Or declared + initialized:
var my_vec := Vector2()
# Belongs to class, not instance:
static var blah : int = 5

# Constants
const name : str = "blah"

var myvar : int = 2
var example : int :
	get:
		return -myvar
	set(value):
		myvar = -value

var mynode: Node2D
mynode = $Sprite2D as Node2D
# results in 'null' if it fails

class_name Blah
extends Node
# extends "res://path/to/something.gd"

func _init():
	pass

class MyClass:
	var example : int = 1

class Sub extends MyClass:
	pass

enum {FIRST, SECOND, THIRD}
enum MyEnum {a, b, c}

FIRST
MyEnum.a

if (false):
    pass
elif (true):
	pass
else:
	pass

while (false):
	# continue
	# break
	pass

for x:int in [1,2,3,4]:
	pass

var d = {"a":2,"b":3}
for x:str in d:
	print(d[x])

for x:int in range(1,5):
	pass

var myval : int = 5
match myval:
	5:
		pass
	4,3:
		pass
	var x when x > 2:
		pass
	[]:
		pass
	[1,2,3]:
		pass
	[var x, var y]:
		pass
	{"name":"blah"}:
		pass
	_:
		print("default")

var i : int = 4
assert(i == 0, "val was not zero")

free($aNode)
queue_free($aNode)

# An observer callback, in aNode:
signal my_signal(val)

# Somewhere else:

func my_fun(val):
	pass

$aNode.my_signal.connect(my_fun)

# Back in aNode:
my_signal.emit(2)