Input & physics

# Runtime rebinding
func rebind(action: StringName, ev: InputEvent) -> void:
    InputMap.action_erase_events(action)
    InputMap.action_add_event(action, ev)
 
# Define actions in code (tools, tests)
if not InputMap.has_action("dash"):
    InputMap.add_action("dash")
    var k := InputEventKey.new()
    k.physical_keycode = KEY_SHIFT
    InputMap.action_add_event("dash", k)

func _physics_process(delta: float) -> void:
    var move := Input.get_vector(
        "move_left", "move_right", "move_up", "move_down")
    var turn := Input.get_axis("turn_left", "turn_right")
    if Input.is_action_just_pressed("jump"):
        jump()

 event arrives (key, mouse, touch, joypad, action)
   │
   ├─► _input(event)              every node that defines it
   │     reverse depth-first: deepest / last child first
   ├─► Control._gui_input(event)  the Control under the mouse
   │     or with focus; mouse_filter decides propagation
   ├─► _shortcut_input(event)     keys, shortcuts, joy buttons
   ├─► _unhandled_key_input(event) key events only
   ├─► _unhandled_input(event)    gameplay input goes here
   └─► physics picking            CollisionObject input_event
                                  (if the viewport enables it)
 any step can stop it:
   get_viewport().set_input_as_handled()
   (or accept_event() inside _gui_input)

func _unhandled_input(event: InputEvent) -> void:
    if event.is_action_pressed("interact"):
        interact()
        get_viewport().set_input_as_handled()
    elif event.is_action_pressed("pause", false, true):
        pass  # (allow_echo, exact_match: no extra modifiers)

func _unhandled_input(event: InputEvent) -> void:
    if event is InputEventMouseButton and event.pressed:
        Input.mouse_mode = Input.MOUSE_MODE_CAPTURED
    elif event.is_action_pressed("ui_cancel"):
        Input.mouse_mode = Input.MOUSE_MODE_VISIBLE

extends CharacterBody2D
 
const SPEED := 300.0
const JUMP_VELOCITY := -400.0     # up is negative Y
 
func _physics_process(delta: float) -> void:
    if not is_on_floor():
        velocity += get_gravity() * delta
    var jump := Input.is_action_just_pressed("jump")
    if jump and is_on_floor():
        velocity.y = JUMP_VELOCITY
    var dir := Input.get_axis("move_left", "move_right")
    if dir:
        velocity.x = dir * SPEED
    else:
        velocity.x = move_toward(velocity.x, 0, SPEED)
    move_and_slide()             # uses velocity and delta

# Push rigid bodies after moving
for i in get_slide_collision_count():
    var c := get_slide_collision(i)
    var rb := c.get_collider() as RigidBody2D
    if rb:
        rb.apply_central_impulse(-c.get_normal() * 20.0)

extends RigidBody2D
 
var _respawn := false
var spawn_point := Vector2.ZERO
 
func _ready() -> void:
    contact_monitor = true          # needed for body_entered
    max_contacts_reported = 4
    body_entered.connect(_on_hit)
 
func kick(dir: Vector2) -> void:
    apply_central_impulse(dir * 300.0)  # instant
    apply_torque_impulse(50.0)
 
func _physics_process(_d: float) -> void:
    apply_central_force(Vector2(0, -20)) # continuous
 
# Safe place to teleport or edit the state directly
func _integrate_forces(
        state: PhysicsDirectBodyState2D) -> void:
    if _respawn:
        state.transform = Transform2D(0, spawn_point)
        state.linear_velocity = Vector2.ZERO
        _respawn = false

extends Area2D
 
func _ready() -> void:
    body_entered.connect(_on_body_entered)
 
func _on_body_entered(body: Node2D) -> void:
    if body is Player:
        EventBus.coin_collected.emit(1)
        queue_free()

# Layers are 1-based in the editor and these helpers
set_collision_layer_value(2, true)
set_collision_mask_value(3, true)
collision_mask = 0b101          # layers 1 and 3 (bit n-1)
var hits_enemies := get_collision_mask_value(3)
 
@export_flags_2d_physics var scan_layers := 1  # picker

# RayCast2D node: updated every physics tick
@onready var ray: RayCast2D = $RayCast2D
 
func _physics_process(_d: float) -> void:
    ray.target_position = Vector2(0, 32)   # local space
    if ray.is_colliding():
        var hit := ray.get_collider()
        var at := ray.get_collision_point()    # global
        var n := ray.get_collision_normal()
    # after moving the ray in the same tick:
    ray.force_raycast_update()

# One-off query through the physics space
func _physics_process(_d: float) -> void:
    var space := get_world_2d().direct_space_state
    var q := PhysicsRayQueryParameters2D.create(
        global_position, global_position + aim * 500.0)
    q.exclude = [get_rid()]          # Array[RID]
    q.collision_mask = 0b101
    q.collide_with_areas = true
    var hit := space.intersect_ray(q)
    if hit:                          # {} when nothing hit
        print(hit.collider, hit.position, hit.normal)

 time ──►   frame      frame      frame      frame
 render:    |    ·     |    ·     |   ·      |   (144 Hz)
 physics:   T0         .          T1         .   (60 Hz)
 without interpolation: renders show T0, T0, T1 ... (judder)
 with interpolation:    renders blend T0→T1 by the fraction

extends CharacterBody2D
 
@export var speed := 120.0
@onready var agent: NavigationAgent2D = $NavigationAgent2D
 
func _ready() -> void:
    agent.velocity_computed.connect(_on_safe_velocity)
    # The navigation map syncs on the first physics frame
    await get_tree().physics_frame
    agent.target_position = Vector2(600, 300)
 
func _physics_process(_d: float) -> void:
    if agent.is_navigation_finished():
        return
    var next := agent.get_next_path_position()
    var v := global_position.direction_to(next) * speed
    if agent.avoidance_enabled:
        agent.velocity = v      # result: velocity_computed
    else:
        _on_safe_velocity(v)
 
func _on_safe_velocity(v: Vector2) -> void:
    velocity = v
    move_and_slide()

extends CharacterBody2D
 
@export var speed := 220.0
@export var accel := 1800.0
@export var friction := 2200.0
@export var jump_velocity := -420.0
@export var coyote_time := 0.1
@export var buffer_time := 0.12
 
var _coyote := 0.0
var _buffer := 0.0
 
func _physics_process(delta: float) -> void:
    if is_on_floor():
        _coyote = coyote_time
    else:
        _coyote -= delta
        velocity += get_gravity() * delta
 
    if Input.is_action_just_pressed("jump"):
        _buffer = buffer_time
    else:
        _buffer -= delta
 
    if _buffer > 0.0 and _coyote > 0.0:
        velocity.y = jump_velocity
        _buffer = 0.0
        _coyote = 0.0
 
    # Short hop: cut upward speed when jump is released
    if Input.is_action_just_released("jump") \
            and velocity.y < 0.0:
        velocity.y *= 0.5
 
    var dir := Input.get_axis("move_left", "move_right")
    var target := dir * speed
    var rate := accel if dir != 0.0 else friction
    velocity.x = move_toward(
        velocity.x, target, rate * delta)
    move_and_slide()

extends CharacterBody2D
 
@export var speed := 200.0
@export var smoothing := 14.0    # higher = snappier
 
func _ready() -> void:
    motion_mode = MOTION_MODE_FLOATING
 
func _physics_process(delta: float) -> void:
    var input := Input.get_vector(
        "move_left", "move_right", "move_up", "move_down")
    var target := input * speed      # diagonals capped at 1
    var w := 1.0 - exp(-smoothing * delta)
    velocity = velocity.lerp(target, w)
    move_and_slide()
    if input != Vector2.ZERO:
        $Sprite2D.flip_h = input.x < 0.0
    look_at(get_global_mouse_position())  # aim at mouse

extends CharacterBody3D
 
@export var speed := 5.0
@export var jump_velocity := 4.5
@export var sensitivity := 0.0025
@onready var head: Node3D = $Head    # Camera3D inside
 
func _ready() -> void:
    Input.mouse_mode = Input.MOUSE_MODE_CAPTURED
 
func _unhandled_input(event: InputEvent) -> void:
    if event is InputEventMouseMotion \
            and Input.mouse_mode \
            == Input.MOUSE_MODE_CAPTURED:
        rotate_y(-event.relative.x * sensitivity)
        head.rotate_x(-event.relative.y * sensitivity)
        head.rotation.x = clampf(
            head.rotation.x, deg_to_rad(-89), deg_to_rad(89))
    elif event.is_action_pressed("ui_cancel"):
        Input.mouse_mode = Input.MOUSE_MODE_VISIBLE
 
func _physics_process(delta: float) -> void:
    if not is_on_floor():
        velocity += get_gravity() * delta
    elif Input.is_action_just_pressed("jump"):
        velocity.y = jump_velocity
    var input := Input.get_vector(
        "move_left", "move_right",
        "move_forward", "move_back")
    var dir := transform.basis * Vector3(input.x, 0, input.y)
    velocity.x = dir.x * speed
    velocity.z = dir.z * speed
    move_and_slide()

extends Node3D
 
signal selected(target: Node3D)
var _click: Variant = null       # Vector2 or null
 
func _unhandled_input(event: InputEvent) -> void:
    if event is InputEventMouseButton and event.pressed \
            and event.button_index == MOUSE_BUTTON_LEFT:
        _click = event.position
 
func _physics_process(_d: float) -> void:
    if _click == null:
        return
    var cam := get_viewport().get_camera_3d()
    var from := cam.project_ray_origin(_click)
    var to := from + cam.project_ray_normal(_click) * 1000.0
    var q := PhysicsRayQueryParameters3D.create(from, to)
    var hit := get_world_3d().direct_space_state \
        .intersect_ray(q)
    _click = null
    if hit:
        selected.emit(hit.collider)

class_name Hurtbox
extends Area2D
 
signal hurt(amount: int, from: Node)
 
func _ready() -> void:
    collision_layer = 0
    set_collision_layer_value(5, true)  # player_hurtbox
    collision_mask = 0
    set_collision_mask_value(6, true)   # enemy_hitbox
    area_entered.connect(_on_area_entered)
 
func _on_area_entered(area: Area2D) -> void:
    if area is Hitbox:
        hurt.emit(area.damage, area.owner)

class_name Hitbox
extends Area2D
 
@export var damage := 1