Godot Input Handling

# action_state_machine.gd
# Tracking 'Just Pressed' vs 'Released' for complex behavior
extends Node

# PROBLEM: Input.is_action_just_pressed() only works once per frame. 
# State machines need to know if an action is currently in its 'Release' phase.

var is_jumping: bool = false
var is_falling: bool = false

func _physics_process(_delta: float) -> void:
	if Input.is_action_just_pressed("jump"):
		is_jumping = true
		_start_jump()
		
	if Input.is_action_just_released("jump") and is_jumping:
		is_jumping = false
		is_falling = true
		_end_jump_early() # Variable jump height logic

# advanced_input_buffer.gd
# Frame-perfect input buffering for combos and responsive feel [12, 13]
extends Node

# EXPERT NOTE: Simple buffering just checks "was jump pressed". 
# Advanced buffering tracks the 'time_since_pressed' for multiple 
# actions to allow priority-based execution (e.g. Dash over Jump).

var _buffer: Dictionary = {} # action_name -> timestamp
@export var buffer_window_ms: int = 150

func _input(event: InputEvent) -> void:
	for action in ["jump", "dash", "attack"]:
		if event.is_action_pressed(action):
			_buffer[action] = Time.get_ticks_msec()

func is_action_buffered(action: String) -> bool:
	if _buffer.has(action):
		var delta = Time.get_ticks_msec() - _buffer[action]
		if delta <= buffer_window_ms:
			return true
	return false

func consume_buffer(action: String) -> void:
	_buffer.erase(action)

# analog_deadzone_manager.gd
# Expert radial deadzone management for analog sticks [24]
extends Node

# PROBLEM: Axial deadzones (X/Y separately) cause "cross-shaped" deadzones.
# SOLUTION: Radial deadzone (vector length) provides a circular, natural feel.

@export var deadzone: float = 0.2

func get_movement_vector() -> Vector2:
	var raw = Input.get_vector("move_left", "move_right", "move_up", "move_down")
	
	if raw.length() < deadzone:
		return Vector2.ZERO
	
	# Optional: Scaled Radial Deadzone (remaps 0.2..1.0 to 0.0..1.0)
	return raw.normalized() * ((raw.length() - deadzone) / (1.0 - deadzone))

# glyph_prompt_manager.gd
# Dynamic UI prompt switching (Keyboard vs Gamepad) [25]
extends Node

signal device_changed(type: String)

enum Device { KEYBOARD_MOUSE, GAMEPAD }
var last_device: Device = Device.KEYBOARD_MOUSE

func _input(event: InputEvent) -> void:
	var current: Device = last_device
	
	if event is InputEventKey or event is InputEventMouseButton:
		current = Device.KEYBOARD_MOUSE
	elif event is InputEventJoypadButton or event is InputEventJoypadMotion:
		current = Device.GAMEPAD
		
	if current != last_device:
		last_device = current
		device_changed.emit("GamePad" if current == Device.GAMEPAD else "KBM")

# hold_toggle_accessibility.gd
# Software-side Support for 'Hold' vs 'Toggle' actions
extends Node

@export var use_toggle_sprint: bool = false
var _sprint_active: bool = false

func _physics_process(_delta: float) -> void:
	if use_toggle_sprint:
		if Input.is_action_just_pressed("sprint"):
			_sprint_active = !_sprint_active
	else:
		_sprint_active = Input.is_action_pressed("sprint")
	
	if _sprint_active:
		_apply_sprint()

func _apply_sprint():
	pass

# skills/input-handling/code/input_buffer_manager.gd
extends Node

## Input Buffer Manager Expert Pattern
## Implements "Input Buffering" for responsive action-game controls.

@export var buffer_window_frames: int = 10
var _buffer: Dictionary = {} # ActionName -> FrameCount

func _process(_delta: float) -> void:
    # 1. Decay the Buffer
    for action in _buffer.keys():
        _buffer[action] -= 1
        if _buffer[action] <= 0:
            _buffer.erase(action)

func _unhandled_input(event: InputEvent) -> void:
    # 2. Action-based Input Capture
    # Professional games NEVER check for individual keys in logic.
    if event is InputEventAction and event.is_pressed():
        _buffer[event.action] = buffer_window_frames

func is_action_buffered(action: String) -> bool:
    return _buffer.has(action)

func consume_action(action: String) -> void:
    _buffer.erase(action)

## EXPERT NOTE:
## Use the 'Jump Buffering' pattern: Check 'is_action_buffered(\"jump\")' 
## when the character touches the 'is_on_floor()' ground to allow 
## jumping even if the button was pressed frames early.
## Combine with 'Coyote Time' for the industry-standard "Tight Controls" feel.
## For 'input-handling', implement 'Action Remapping' by saving modified 
## 'InputMap' settings to a 'ConfigFile' for persistence.

# skills/input-handling/scripts/input_buffer.gd
extends Node

## Input Buffer Expert Pattern
## Buffers inputs for responsive controls - press jump 100ms before landing? Still registers.

class_name InputBuffer

var _buffer: Dictionary = {}  # action_name → buffer time remaining
@export var buffer_duration: float = 0.15  # 150ms

func _process(delta: float) -> void:
	# Decay all buffered inputs
	for action in _buffer.keys():
		_buffer[action] -= delta
		if _buffer[action] <= 0:
			_buffer.erase(action)

func buffer_action(action_name: String) -> void:
	_buffer[action_name] = buffer_duration

func is_action_buffered(action_name: String) -> bool:
	return action_name in _buffer

func consume_action(action_name: String) -> bool:
	if action_name in _buffer:
		_buffer.erase(action_name)
		return true
	return false

## EXPERT USAGE:
## In _unhandled_input():
##   if Input.is_action_just_pressed("jump"):
##     input_buffer.buffer_action("jump")
##
## In _physics_process():
##   if is_on_floor() and input_buffer.consume_action("jump"):
##     velocity.y = JUMP_VELOCITY

# input_echo_filter.gd
# Filtering echo events for UI navigation vs Gameplay
extends Control

# EXPERT NOTE: InputEvent.is_echo() is true for auto-repeated keys.
# Never trigger gameplay actions on echo, but always allow UI movement.

func _unhandled_input(event: InputEvent) -> void:
	if event.is_action_pressed("ui_accept"):
		if event.is_echo():
			# Ignore hold-to-confirm if that's not desired
			return
		_do_confirm()

func _do_confirm():
	print("Confirmed!")

# skills/input-handling/scripts/input_remapper.gd
extends Node

## Input Remapper Expert Pattern
## Runtime input rebinding with conflict detection and persistence.

class_name InputRemapper

const CONFIG_PATH := "user://input_bindings.cfg"

func rebind_action(action_name: String, new_event: InputEvent) -> bool:
	# Check for conflicts
	for existing_action in InputMap.get_actions():
		if existing_action == action_name:
			continue
		for event in InputMap.action_get_events(existing_action):
			if _events_match(event, new_event):
				push_warning("Input conflict: %s already bound to %s" % [new_event, existing_action])
				return false
	
	# Clear existing binding
	InputMap.action_erase_events(action_name)
	
	# Add new binding
	InputMap.action_add_event(action_name, new_event)
	
	return true

func save_bindings() -> void:
	var config := ConfigFile.new()
	
	for action in InputMap.get_actions():
		var events := InputMap.action_get_events(action)
		if events.size() > 0:
			config.set_value("bindings", action, _serialize_events(events))
	
	config.save(CONFIG_PATH)

func load_bindings() -> void:
	var config := ConfigFile.new()
	if config.load(CONFIG_PATH) != OK:
		return
		
	for action in config.get_section_keys("bindings"):
		var event_data = config.get_value("bindings", action)
		var events := _deserialize_events(event_data)
		
		InputMap.action_erase_events(action)
		for event in events:
			InputMap.action_add_event(action, event)

func _events_match(event_a: InputEvent, event_b: InputEvent) -> bool:
	if event_a.get_class() != event_b.get_class():
		return false
		
	if event_a is InputEventKey:
		return event_a.keycode == (event_b as InputEventKey).keycode
	elif event_a is InputEventMouseButton:
		return event_a.button_index == (event_b as InputEventMouseButton).button_index
	elif event_a is InputEventJoypadButton:
		return event_a.button_index == (event_b as InputEventJoypadButton).button_index
	
	return false

func _serialize_events(events: Array) -> Array:
	var result := []
	for event in events:
		result.append(var_to_str(event))
	return result

func _deserialize_events(data: Array) -> Array:
	var result := []
	for event_str in data:
		result.append(str_to_var(event_str))
	return result

## EXPERT USAGE:
## InputRemapper.load_bindings()  # In autoload _ready()
## InputRemapper.rebind_action("jump", event)
## InputRemapper.save_bindings()

# mouse_capture_manager.gd
# Handling mouse capture and sensitivity scaling for FPS games
extends Node3D

@export var sensitivity: float = 0.002
var _captured: bool = false

func _ready() -> void:
	_toggle_capture(true)

func _input(event: InputEvent) -> void:
	if event.is_action_pressed("ui_cancel"):
		_toggle_capture(!_captured)
		
	if _captured and event is InputEventMouseMotion:
		# Expert: Apply sensitivity scaling here
		var rot = -event.relative * sensitivity
		_apply_rotation(rot)

func _toggle_capture(enable: bool) -> void:
	_captured = enable
	Input.mouse_mode = Input.MOUSE_MODE_CAPTURED if enable else Input.MOUSE_MODE_VISIBLE

func _apply_rotation(_rot: Vector2):
	pass

# multi_touch_gestures.gd
# Handling touch, drags, and pinch-to-zoom gestures
extends Node2D

var _touches: Dictionary = {}

func _unhandled_input(event: InputEvent) -> void:
	if event is InputEventScreenTouch:
		if event.pressed:
			_touches[event.index] = event.position
		else:
			_touches.erase(event.index)
			
	if event is InputEventScreenDrag:
		_touches[event.index] = event.position
		if _touches.size() == 2:
			_handle_pinch()

func _handle_pinch() -> void:
	# Logic for calculating distance between touch 0 and 1
	pass

# safe_runtime_rebind.gd
# Safe runtime input rebinding with multi-device support [15, 16]
extends Node

# EXPERT NOTE: Always check for conflicts before applying a rebind. 
# Also, handle the case where a player binds a Joypad button to a keyboard action.

func rebind_action(action_name: String, new_event: InputEvent) -> bool:
	# 1. Check for conflicts
	for action in InputMap.get_actions():
		if action == action_name: continue
		if InputMap.action_has_event(action, new_event):
			printerr("Conflict: ", new_event.as_text(), " already bound to ", action)
			return false
	
	# 2. Apply rebind
	InputMap.action_erase_events(action_name)
	InputMap.action_add_event(action_name, new_event)
	
	# 3. Persistence (Save to ConfigFile)
	_save_rebinds()
	return true

func _save_rebinds():
	# Standard pattern: save to user://input.cfg
	pass

# unhandled_input_priority.gd
# Expert use of _unhandled_input across the tree [26]
extends Node2D

# 1. _input() -> Global (always)
# 2. Control._gui_input() -> UI only
# 3. _unhandled_input() -> Gameplay (only if UI didn't use it)
# 4. _unhandled_key_input() -> Shortcuts

func _unhandled_input(event: InputEvent) -> void:
	if event.is_action_pressed("interact"):
		# This interaction only triggers if the player didn't 
		# just click a 'Use' button on a menu!
		_check_interaction()

func _check_interaction():
	pass