input_manager.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
const DataCacheManager = preload("res://scripts/systems/dataCacheManager/data_cache_manager.gd")
 
var prompts := {}
var actions := {}
var controller_active := false
var last_controller_active := false
var keyboard_active := false
var preferred_input_mode := "auto"
var data_cache_manager = DataCacheManager.new()
 
const JOY_BUTTON_NAMES := {
    "A": JOY_BUTTON_A,
    "B": JOY_BUTTON_B,
    "X": JOY_BUTTON_X,
    "Y": JOY_BUTTON_Y,
    "Back": JOY_BUTTON_BACK,
    "Start": JOY_BUTTON_START,
    "Left Shoulder": JOY_BUTTON_LEFT_SHOULDER,
    "Right Shoulder": JOY_BUTTON_RIGHT_SHOULDER,
    "Left Stick": JOY_BUTTON_LEFT_STICK,
    "Right Stick": JOY_BUTTON_RIGHT_STICK,
    "Dpad Up": JOY_BUTTON_DPAD_UP,
    "Dpad Down": JOY_BUTTON_DPAD_DOWN,
    "Dpad Left": JOY_BUTTON_DPAD_LEFT,
    "Dpad Right": JOY_BUTTON_DPAD_RIGHT
}
 
const JOY_AXIS_NAMES := {
    "Left X": JOY_AXIS_LEFT_X,
    "Left Y": JOY_AXIS_LEFT_Y,
    "Right X": JOY_AXIS_RIGHT_X,
    "Right Y": JOY_AXIS_RIGHT_Y,
    "Trigger Left": JOY_AXIS_TRIGGER_LEFT,
    "Trigger Right": JOY_AXIS_TRIGGER_RIGHT
}
 
 
 
func load_actions(file_path:String) -> void:
    var data = data_cache_manager.load_json(file_path)
    if not data is Dictionary:
        return
    actions.clear()
    for action in data.get("actions", []):
        if not action is Dictionary:
            continue
        var id = str(action.get("id", ""))
        if id == "":
            continue
        actions[id] = action.duplicate(true)
        ensure_action(id)
        if action.has("keyboard"):
            _add_key_binding(id, OS.find_keycode_from_string(str(action["keyboard"])))
        for key_name in action.get("keyboard_alt", []):
            _add_key_binding(id, OS.find_keycode_from_string(str(key_name)))
        for button_name in action.get("joy_buttons", []):
            bind_joy_button(id, _joy_button_from_value(button_name))
        for axis_binding in action.get("joy_axes", []):
            if axis_binding is Dictionary:
                bind_joy_axis(id, _joy_axis_from_value(axis_binding.get("axis", 0)), float(axis_binding.get("value", 1.0)))
        if action.has("prompt"):
            set_prompt(id, "keyboard", str(action["prompt"]))
 
 
 
func get_cache_stats() -> Dictionary:
    return data_cache_manager.get_cache_stats()
 
 
 
func get_actions(include_locked:bool = false) -> Array:
    var list = []
    for id in actions.keys():
        if not include_locked and not is_action_remappable(str(id)):
            continue
        var action = actions[id].duplicate(true)
        action["id"] = id
        action["prompt"] = get_prompt(id)
        list.append(action)
    return list
 
 
 
func is_action_remappable(action:String) -> bool:
    var definition = actions.get(action, {})
    if not definition is Dictionary:
        return true
    if str(action) == "game_pause" or str(action) == "game_settings":
        return false
    return bool(definition.get("remappable", true))
 
 
 
func ensure_action(action:String, deadzone:float = 0.5) -> void:
    if not InputMap.has_action(action):
        InputMap.add_action(action, deadzone)
 
 
 
func bind_key(action:String, keycode:Key) -> void:
    ensure_action(action)
    InputMap.action_erase_events(action)
    _add_key_binding(action, keycode)
    set_prompt(action, "keyboard", OS.get_keycode_string(keycode))
 
 
 
func bind_from_event(action:String, event:InputEvent) -> bool:
    note_input_event(event)
    if not is_action_remappable(action):
        return false
    if event is InputEventKey and event.pressed and not event.echo:
        bind_key(action, event.keycode)
        return true
    if event is InputEventMouseButton and event.pressed:
        bind_mouse_button(action, event.button_index)
        set_prompt(action, "keyboard", "Mouse %d" % int(event.button_index))
        return true
    if event is InputEventJoypadButton and event.pressed:
        bind_joy_button(action, event.button_index)
        set_prompt(action, "controller", "Button %d" % int(event.button_index))
        return true
    if event is InputEventJoypadMotion and abs(event.axis_value) >= 0.5:
        bind_joy_axis(action, event.axis, sign(event.axis_value))
        set_prompt(action, "controller", "Axis %d %s" % [int(event.axis), "+" if event.axis_value > 0.0 else "-"])
        return true
    return false
 
 
 
func bind_joy_button(action:String, button_index:int) -> void:
    ensure_action(action)
    var event = InputEventJoypadButton.new()
    event.button_index = button_index
    _add_event_if_missing(action, event)
 
 
 
func bind_joy_axis(action:String, axis:int, axis_value:float) -> void:
    ensure_action(action)
    var event = InputEventJoypadMotion.new()
    event.axis = axis
    event.axis_value = clamp(axis_value, -1.0, 1.0)
    _add_event_if_missing(action, event)
 
 
 
func bind_mouse_button(action:String, button_index:int) -> void:
    ensure_action(action)
    var event = InputEventMouseButton.new()
    event.button_index = button_index
    _add_event_if_missing(action, event)
 
 
 
func is_pressed(action:String) -> bool:
    return Input.is_action_pressed(action)
 
 
 
func just_pressed(action:String) -> bool:
    return Input.is_action_just_pressed(action)
 
 
 
func note_input_event(event:InputEvent) -> void:
    if event is InputEventJoypadButton and event.pressed:
        controller_active = true
        keyboard_active = false
    elif event is InputEventJoypadMotion and abs(event.axis_value) >= 0.35:
        controller_active = true
        keyboard_active = false
    elif event is InputEventKey and event.pressed:
        controller_active = false
        keyboard_active = true
    elif event is InputEventMouseButton and event.pressed:
        controller_active = false
        keyboard_active = false
    elif event is InputEventScreenTouch and event.pressed:
        controller_active = false
        keyboard_active = false
 
 
 
func set_input_mode(mode:String) -> void:
    preferred_input_mode = mode if mode in ["auto", "touch", "keyboard", "controller"] else "auto"
 
 
func get_active_input_mode() -> String:
    if preferred_input_mode != "auto":
        return preferred_input_mode
    if controller_active:
        return "controller"
    if keyboard_active:
        return "keyboard"
    if DisplayServer.is_touchscreen_available():
        return "touch"
    if not Input.get_connected_joypads().is_empty():
        return "controller"
    return "keyboard"
 
 
func is_touch_active() -> bool:
    return get_active_input_mode() == "touch"
 
 
 
func is_controller_active() -> bool:
    return get_active_input_mode() == "controller"
 
 
 
func is_controller_label_active() -> bool:
    return get_active_input_mode() == "controller"
 
 
 
func is_keyboard_active() -> bool:
    return get_active_input_mode() == "keyboard"
 
 
 
func get_controller_label_set() -> String:
    var joypads := Input.get_connected_joypads()
    var joy_name := Input.get_joy_name(joypads[0]).to_lower() if not joypads.is_empty() else ""
    if "playstation" in joy_name or "dualsense" in joy_name or "dualshock" in joy_name:
        return "playstation"
    if "nintendo" in joy_name or "switch" in joy_name:
        return "nintendo"
    return "xbox"
 
 
 
func format_active_prompt(keyboard:String, xbox:String, playstation:String = "", nintendo:String = "") -> String:
    if not is_controller_label_active():
        return keyboard
    match get_controller_label_set():
        "playstation": return playstation if playstation != "" else xbox
        "nintendo": return nintendo if nintendo != "" else xbox
        _: return xbox
 
 
 
func consume_controller_mode_changed() -> bool:
    var active = is_controller_active()
    if active == last_controller_active:
        return false
    last_controller_active = active
    return true
 
 
 
func get_slot_label(slot_index:int, controller_label_set:String = "xbox") -> String:
    if is_controller_label_active():
        var labels = _controller_slot_labels(controller_label_set)
        if slot_index >= 0 and slot_index < labels.size():
            return str(labels[slot_index])
    return str(slot_index + 1)
 
 
 
func get_slot_color(slot_index:int, controller_label_set:String = "xbox") -> Color:
    if not is_controller_label_active():
        return Color("#f2c86b")
    var colors = _controller_slot_colors(controller_label_set)
    if slot_index >= 0 and slot_index < colors.size():
        return Color(str(colors[slot_index]))
    return Color("#f2c86b")
 
 
 
func apply_controller_scroll(root:Node, delta:float, pixels_per_second:float = 720.0) -> bool:
    var down_strength:float = Input.get_action_strength("ui_scroll_down") if InputMap.has_action("ui_scroll_down") else 0.0
    var up_strength:float = Input.get_action_strength("ui_scroll_up") if InputMap.has_action("ui_scroll_up") else 0.0
    var amount:float = down_strength - up_strength
    if abs(amount) < 0.12:
        return false
    var scroll = _find_scroll_target(root)
    if scroll == null:
        return false
    scroll.scroll_vertical = clampi(
        scroll.scroll_vertical + int(amount * pixels_per_second * delta),
        0,
        scroll.get_v_scroll_bar().max_value
    )
    return true
 
 
 
func update_input_module(root:Node, delta:float, onscreen_controls = null, user_onscreen_enabled:bool = true, scroll_speed:float = 720.0) -> bool:
    var mode_changed = consume_controller_mode_changed()
    if onscreen_controls != null and onscreen_controls.has_method("set_visible"):
        var desired_visible := user_onscreen_enabled and is_touch_active()
        if not onscreen_controls.has_method("is_visible") or bool(onscreen_controls.is_visible()) != desired_visible:
            onscreen_controls.set_visible(desired_visible)
    apply_controller_scroll(root, delta, scroll_speed)
    return mode_changed
 
 
 
func set_prompt(action:String, device:String, text:String) -> void:
    if not prompts.has(action):
        prompts[action] = {}
    prompts[action][device] = text
 
 
 
func get_prompt(action:String, device:String = "keyboard") -> String:
    return str(prompts.get(action, {}).get(device, action))
 
 
 
func get_state() -> Dictionary:
    return {
        "prompts": prompts.duplicate(true),
        "actions": actions.duplicate(true),
        "bindings": _get_binding_state()
    }
 
 
 
func apply_state(state:Dictionary) -> void:
    if state.is_empty():
        return
    prompts = state.get("prompts", prompts).duplicate(true)
    if state.has("actions") and not state.get("actions", {}).is_empty():
        var saved_actions = state.get("actions", {})
        for action_id in saved_actions.keys():
            if actions.has(action_id) and saved_actions[action_id] is Dictionary:
                var merged = actions[action_id].duplicate(true)
                for key in saved_actions[action_id].keys():
                    merged[key] = saved_actions[action_id][key]
                actions[action_id] = merged
            else:
                actions[action_id] = saved_actions[action_id]
    for action in state.get("bindings", {}).keys():
        _apply_action_bindings(str(action), state["bindings"][action])
 
 
func _get_binding_state() -> Dictionary:
    var bindings = {}
    for action in actions.keys():
        if not is_action_remappable(str(action)):
            continue
        var action_bindings = []
        if not InputMap.has_action(str(action)):
            continue
        for event in InputMap.action_get_events(str(action)):
            if event is InputEventKey:
                action_bindings.append({"type": "key", "keycode": event.keycode})
            elif event is InputEventMouseButton:
                action_bindings.append({"type": "mouse", "button_index": event.button_index})
            elif event is InputEventJoypadButton:
                action_bindings.append({"type": "joy_button", "button_index": event.button_index})
            elif event is InputEventJoypadMotion:
                action_bindings.append({"type": "joy_axis", "axis": event.axis, "axis_value": event.axis_value})
        bindings[action] = action_bindings
    return bindings
 
 
func _apply_action_bindings(action:String, action_bindings:Array) -> void:
    ensure_action(action)
    if not is_action_remappable(action):
        InputMap.action_erase_events(action)
        _ensure_definition_defaults(action)
        return
    InputMap.action_erase_events(action)
    for binding in action_bindings:
        if not binding is Dictionary:
            continue
        match str(binding.get("type", "")):
            "key":
                var event = InputEventKey.new()
                event.keycode = int(binding.get("keycode", 0))
                InputMap.action_add_event(action, event)
            "mouse":
                var event = InputEventMouseButton.new()
                event.button_index = int(binding.get("button_index", 0))
                InputMap.action_add_event(action, event)
            "joy_button":
                var event = InputEventJoypadButton.new()
                event.button_index = int(binding.get("button_index", 0))
                InputMap.action_add_event(action, event)
            "joy_axis":
                var event = InputEventJoypadMotion.new()
                event.axis = int(binding.get("axis", 0))
                event.axis_value = float(binding.get("axis_value", 1.0))
                InputMap.action_add_event(action, event)
    _ensure_definition_defaults(action)
 
 
func _add_key_binding(action:String, keycode:Key) -> void:
    if keycode == KEY_NONE:
        return
    var event = InputEventKey.new()
    event.keycode = keycode
    _add_event_if_missing(action, event)
 
 
func _add_event_if_missing(action:String, event:InputEvent) -> void:
    for existing in InputMap.action_get_events(action):
        if _events_match(existing, event):
            return
    InputMap.action_add_event(action, event)
 
 
func _events_match(left:InputEvent, right:InputEvent) -> bool:
    if left.get_class() != right.get_class():
        return false
    if left is InputEventKey and right is InputEventKey:
        return left.keycode == right.keycode
    if left is InputEventMouseButton and right is InputEventMouseButton:
        return left.button_index == right.button_index
    if left is InputEventJoypadButton and right is InputEventJoypadButton:
        return left.button_index == right.button_index
    if left is InputEventJoypadMotion and right is InputEventJoypadMotion:
        return left.axis == right.axis and sign(left.axis_value) == sign(right.axis_value)
    return false
 
 
func _ensure_definition_defaults(action_id:String) -> void:
    var definition = actions.get(action_id, {})
    if not definition is Dictionary:
        return
    if definition.has("keyboard"):
        _add_key_binding(action_id, OS.find_keycode_from_string(str(definition["keyboard"])))
    for key_name in definition.get("keyboard_alt", []):
        _add_key_binding(action_id, OS.find_keycode_from_string(str(key_name)))
    for button_name in definition.get("joy_buttons", []):
        bind_joy_button(action_id, _joy_button_from_value(button_name))
    for axis_binding in definition.get("joy_axes", []):
        if axis_binding is Dictionary:
            bind_joy_axis(action_id, _joy_axis_from_value(axis_binding.get("axis", 0)), float(axis_binding.get("value", 1.0)))
 
 
func _joy_button_from_value(value) -> int:
    if value is int:
        return int(value)
    return int(JOY_BUTTON_NAMES.get(str(value), int(value) if str(value).is_valid_int() else JOY_BUTTON_A))
 
 
func _joy_axis_from_value(value) -> int:
    if value is int:
        return int(value)
    return int(JOY_AXIS_NAMES.get(str(value), int(value) if str(value).is_valid_int() else JOY_AXIS_LEFT_X))
 
 
func _controller_slot_labels(controller_label_set:String) -> Array:
    match controller_label_set:
        "nintendo":
            return ["B", "Y", "X", "A", "LS"]
        "playstation":
            return ["Cross", "Square", "Triangle", "Circle", "L3"]
    return ["A", "X", "Y", "B", "LS"]
 
 
func _controller_slot_colors(controller_label_set:String) -> Array:
    match controller_label_set:
        "nintendo":
            return ["#f05f64", "#55d17a", "#4aa3ff", "#f2c86b", "#aab6c4"]
        "playstation":
            return ["#55d17a", "#4aa3ff", "#f2c86b", "#f05f64", "#aab6c4"]
    return ["#55d17a", "#4aa3ff", "#f2c86b", "#f05f64", "#aab6c4"]
 
 
func _find_scroll_target(root:Node) -> ScrollContainer:
    if root == null:
        return null
    var viewport = root.get_viewport() if root is Control else null
    if viewport != null:
        var focus = viewport.gui_get_focus_owner()
        var focused_scroll = _ancestor_scroll_container(focus)
        if _scroll_can_move(focused_scroll):
            return focused_scroll
    var visible_scrolls = []
    _collect_visible_scrolls(root, visible_scrolls)
    for scroll in visible_scrolls:
        if _scroll_can_move(scroll):
            return scroll
    return null
 
 
func _ancestor_scroll_container(node:Node) -> ScrollContainer:
    var current = node
    while current != null:
        if current is ScrollContainer:
            return current
        current = current.get_parent()
    return null
 
 
func _collect_visible_scrolls(node:Node, results:Array) -> void:
    if node is Control and not node.is_visible_in_tree():
        return
    if node is ScrollContainer:
        results.append(node)
    for child in node.get_children():
        _collect_visible_scrolls(child, results)
 
 
func _scroll_can_move(scroll:ScrollContainer) -> bool:
    if scroll == null or not scroll.is_visible_in_tree():
        return false
    var bar = scroll.get_v_scroll_bar()
    return bar != null and bar.max_value > 0.0 and scroll.vertical_scroll_mode != ScrollContainer.SCROLL_MODE_DISABLED