Bullosseum/systems/input/controls_manager.gd

extends Node

## Global keybinding manager (autoload `Controls`).
## Loads saved keyboard bindings on startup and applies them to InputMap so
## rebinds made in the intro menu persist into the game scene. Only the
## keyboard event of each action is overridden; joypad/mouse events are kept.

const SAVE_PATH := "user://controls.cfg"
const SECTION := "keybinds"

## Actions the options menu lets the player rebind (keyboard only).
const REBINDABLE_ACTIONS: PackedStringArray = [
	&"move_forward",
	&"move_back",
	&"move_left",
	&"move_right",
	&"ability_kick",
	&"ability_dash",
	&"ability_slam",
	&"ability_roll",
]


func _ready() -> void:
	_ensure_gamepad_confirm_binding()
	load_saved()
	_install_web_fullscreen_hook()


## Godot's built-in ui_accept (menu/button confirm) ships with zero joypad bindings —
## checked directly: only Enter/Kp Enter/Space. ui_left/right/up/down, by contrast, do
## default to the D-pad and stick, which is why gamepad focus navigation on a menu works out
## of the box while "confirming" the focused button does nothing. Bind joypad button 0 (the
## bottom face button in Xbox-style position mapping) as the confirm button.
func _ensure_gamepad_confirm_binding() -> void:
	var alt := InputEventJoypadButton.new()
	alt.button_index = JOY_BUTTON_A
	if not InputMap.action_has_event(&"ui_accept", alt):
		InputMap.action_add_event(&"ui_accept", alt)


# ── Web fullscreen + landscape lock ─────────────────────────────────────────────
# The reliable way to force fullscreen on the web: install a NATIVE DOM listener that calls
# requestFullscreen() synchronously inside the real user-gesture event — the same thing
# three.js games do. Godot dispatches input from its rAF render loop, one hop removed from the
# DOM event, so both Godot's window_set_mode and a JS call made from _input() run outside the
# gesture's activation and some mobile browsers reject them. The listener below sidesteps that
# entirely, and — left attached — re-enters fullscreen on the next tap if the player leaves it.
# All of it is guarded, so iPhone Safari (no requestFullscreen) and desktop just no-op cleanly.
func _install_web_fullscreen_hook() -> void:
	if not OS.has_feature("web"):
		return
	JavaScriptBridge.eval("""
(function(){
	if (window.__bullFSInit) return;
	window.__bullFSInit = true;
	window.__bull_fs = 'idle';
	// Armed = we should grab fullscreen on the next tap. Starts true so the first tap enters,
	// then disarms — so once the player is in (or deliberately leaves via Esc / back / swipe)
	// ordinary gameplay taps never yank them back in. WebStartGate re-arms via arm_fullscreen().
	window.__bullFSArmed = true;
	window.__bullFS = function(){
		try {
			if (document.fullscreenElement || document.webkitFullscreenElement) {
				window.__bull_fs = 'ok'; window.__bullFSArmed = false; return;
			}
			if (!window.__bullFSArmed) return;
			var c = document.getElementById('canvas') || document.querySelector('canvas')
				|| document.documentElement;
			var rf = c.requestFullscreen || c.webkitRequestFullscreen
				|| c.msRequestFullscreen || c.mozRequestFullScreen;
			if (!rf) { window.__bull_fs = 'no-api'; lock(); return; }
			window.__bull_fs = 'req';
			var p = rf.call(c);
			if (p && p.then) {
				p.then(function(){ window.__bull_fs = 'ok'; window.__bullFSArmed = false; lock(); },
					function(e){ window.__bull_fs = 'err:' + (e && e.name || e); });
			} else { window.__bull_fs = 'ok'; window.__bullFSArmed = false; lock(); }
		} catch(e){ window.__bull_fs = 'ex:' + (e && e.name || e); }
		function lock(){ try { if (screen.orientation && screen.orientation.lock)
			screen.orientation.lock('landscape').catch(function(){}); } catch(e){} }
	};
	// pointerup / touchend / click grant transient activation (pointerdown/touchstart do not).
	['pointerup','touchend','click'].forEach(function(ev){
		window.addEventListener(ev, function(){ window.__bullFS(); }, true);
	});
})();
""", true)


## Ask to enter fullscreen + landscape now (e.g. from WebStartGate's tap). The DOM listener
## installed above normally beats this to it on the same gesture; this is the explicit path and
## is a safe no-op if we're already fullscreen. No-op off web.
func request_fullscreen_landscape() -> void:
	if not OS.has_feature("web"):
		return
	_install_web_fullscreen_hook()
	JavaScriptBridge.eval("if (window.__bullFS) window.__bullFS();", true)


## Re-arm the "grab fullscreen on next tap" hook, so the next tap re-enters. WebStartGate calls
## this whenever it shows itself (boot, or after the player left fullscreen). No-op off web.
func arm_fullscreen() -> void:
	if OS.has_feature("web"):
		JavaScriptBridge.eval("window.__bullFSArmed = true;", true)


## Whether the browser can go fullscreen at all. False on iPhone Safari (no requestFullscreen),
## which lets WebStartGate stop prompting there instead of nagging forever. True off web (n/a).
func fullscreen_supported() -> bool:
	if not OS.has_feature("web"):
		return true
	var r: Variant = JavaScriptBridge.eval(
		"(function(){var c=document.getElementById('canvas')||document.documentElement;"
		+ "return !!(c.requestFullscreen||c.webkitRequestFullscreen"
		+ "||c.msRequestFullscreen||c.mozRequestFullScreen)?1:0;})()", true)
	if r is bool:
		return r
	if r is int or r is float:
		return int(r) != 0
	return false


## Is the browser currently fullscreen? No-op-ish off web (returns false).
func is_browser_fullscreen() -> bool:
	if not OS.has_feature("web"):
		return false
	var r: Variant = JavaScriptBridge.eval(
		"(document.fullscreenElement||document.webkitFullscreenElement)?1:0", true)
	if r is bool:
		return r
	if r is int or r is float:
		return int(r) != 0
	return false


## One-line web diagnostic for the on-device debug overlay: secure context, cross-origin
## isolation (threads), last fullscreen attempt result, and whether we're fullscreen now.
func fullscreen_status() -> String:
	if not OS.has_feature("web"):
		return "native"
	var r: Variant = JavaScriptBridge.eval(
		"'sec=' + (window.isSecureContext ? 1 : 0) + ' iso=' + (window.crossOriginIsolated ? 1 : 0)"
		+ " + ' fs=' + (window.__bull_fs || '?')"
		+ " + ' cur=' + ((document.fullscreenElement || document.webkitFullscreenElement) ? 1 : 0)",
		true)
	return str(r) if r != null else "?"


## Whether to drive the game with the on-screen touch UI (joystick + buttons)
## instead of keyboard hints. Platform detection is cached (it can't change mid-run)
## so the per-frame/per-input callers don't repay the cost — but the DP force flag is
## re-read every call so the console can toggle the layout live on a desktop build.
var _touch_ui_cached: int = -1   # -1 = not yet detected, 0 = false, 1 = true


func use_touch_ui() -> bool:
	if DP.b("force_touch_controls"):
		return true
	if _touch_ui_cached == -1:
		_touch_ui_cached = 1 if _detect_touch_ui() else 0
	return _touch_ui_cached == 1


## True only on touch-primary devices (phones, tablets). Detection is deliberately
## conservative so a desktop never gets the on-screen thumb UI.
##
## DisplayServer.is_touchscreen_available() is unusable here on two fronts: on native
## desktop `emulate_touch_from_mouse` (on for testing) forces it true, and on the web build
## it maps to `'ontouchstart' in window`, which desktop Chromium reports true even with no
## touchscreen. So on web we ask the browser two questions instead: does it report touch
## points, AND is the *primary* pointer coarse? A desktop-with-mouse (even a touch laptop)
## answers no to the second and keeps the desktop HUD; a phone/tablet answers yes to both.
## maxTouchPoints also catches iPadOS, which masquerades as desktop Safari.
func _detect_touch_ui() -> bool:
	if (
		OS.has_feature("mobile")
		or OS.has_feature("web_android")
		or OS.has_feature("web_ios")
	):
		return true
	if not OS.has_feature("web"):
		return false
	var js := "(navigator.maxTouchPoints > 0) && window.matchMedia('(pointer: coarse)').matches"
	var touch_primary: Variant = JavaScriptBridge.eval(js, true)
	if touch_primary is bool:
		return touch_primary
	if touch_primary is int or touch_primary is float:
		return int(touch_primary) != 0
	return false


## Whether on-screen debug overlays (touch state + render diagnostics) should show. True on
## the DP "touch_debug" flag, or — so it can be switched on from a phone where no console is
## reachable — when the page URL carries a `debug` query param (append `?debug=1`).
var _url_debug: int = -1


func debug_overlay() -> bool:
	if DP.b("touch_debug"):
		return true
	if _url_debug == -1:
		_url_debug = 0
		if OS.has_feature("web"):
			var has: Variant = JavaScriptBridge.eval(
				"String(window.location.search).indexOf('debug') >= 0", true)
			if (has is bool and has) or ((has is int or has is float) and int(has) != 0):
				_url_debug = 1
	return _url_debug == 1


## Whether to apply the rigid-skin workaround (rigid_skin.gd) instead of native GPU skinning.
## Defaults to the DP "use_rigid_skin" flag (on for web), but a page URL param overrides it so
## native skinning can be A/B'd on the actual phone with no console reachable: append `?noskin=1`
## to force it OFF (does the device render skinned meshes natively now — e.g. after a Godot web
## template update? — and do the bear's rigid-skin seam holes go away), or `?skin=1` to force ON.
## -1 = not read yet, 0 = url forces off, 1 = url forces on, 2 = no url override (use DP flag).
var _url_skin: int = -1


func rigid_skin_enabled() -> bool:
	if _url_skin == -1:
		_url_skin = 2
		if OS.has_feature("web"):
			var q: Variant = JavaScriptBridge.eval("String(window.location.search)", true)
			var s: String = str(q) if q != null else ""
			if s.find("noskin") >= 0:
				_url_skin = 0
			elif s.find("skin") >= 0:
				_url_skin = 1
	if _url_skin == 0:
		return false
	if _url_skin == 1:
		return true
	return DP.b("use_rigid_skin")


## Rumble a connected gamepad, gated on the DP "gamepad_vibration" flag. Off web this is a thin
## wrapper over Input.start_joy_vibration(); on web that call is a documented engine no-op
## (godotengine/godot#96985 — never wired to the browser side), so there we drive the Gamepad
## Haptic Actuator API ourselves. Safe no-op wherever it's unsupported (Safari, most Firefox
## versions, or a controller with no rumble motors) — desktop Chromium/Edge is the target.
func vibrate(device: int, weak_magnitude: float, strong_magnitude: float, duration: float) -> void:
	if not DP.b("gamepad_vibration"):
		return
	if not OS.has_feature("web"):
		Input.start_joy_vibration(device, weak_magnitude, strong_magnitude, duration)
		return
	JavaScriptBridge.eval("""
(function(){
	try {
		var pads = navigator.getGamepads ? navigator.getGamepads() : [];
		var pad = pads[%d];
		var act = pad && pad.vibrationActuator;
		if (act && act.playEffect) {
			act.playEffect('dual-rumble', {
				duration: %d,
				weakMagnitude: %f,
				strongMagnitude: %f
			});
		}
	} catch (e) {}
})();
""" % [device, int(duration * 1000.0), weak_magnitude, strong_magnitude], true)


## Godot's own start_joy_vibration() docs warn that a single long effect is unreliable —
## "not every hardware is compatible with long effects; you may want to make a shorter
## effect and make it repeat instead." That's exactly what broke the lobby gate's 7-second
## rumble (the short 0.2 s hit-vibration works fine): this repeats vibrate() as short pulses
## to cover the same total duration instead of one long call.
## Explicitly stopping between pulses (rather than letting each one time out on its own) and
## spacing them out avoids re-triggering the effect faster than some drivers/browsers can
## retire the previous one — back-to-back-to-back start calls left the gamepad's rumble
## motor stuck reporting "busy" for the rest of the session on at least one setup.
func vibrate_for(device: int, weak_magnitude: float, strong_magnitude: float,
		total_duration: float, pulse: float = 0.25, gap: float = 0.6) -> void:
	var elapsed := 0.0
	while elapsed < total_duration:
		vibrate(device, weak_magnitude, strong_magnitude, pulse)
		await get_tree().create_timer(pulse).timeout
		if not OS.has_feature("web"):
			Input.stop_joy_vibration(device)
		await get_tree().create_timer(gap).timeout
		elapsed += pulse + gap


## Returns the first keyboard event bound to an action, or null.
func get_key_event(action: StringName) -> InputEventKey:
	for event: InputEvent in InputMap.action_get_events(action):
		if event is InputEventKey:
			return event
	return null


## Human-readable label for the action's current key (e.g. "W", "Space").
func get_key_label(action: StringName) -> String:
	var event := get_key_event(action)
	if event == null:
		return "—"
	return event.as_text_physical_keycode()


## Replaces the primary keyboard event of `action` with `event`, keeping
## every other event (e.g. arrow-key alternates, joypad) in its place.
func rebind(action: StringName, event: InputEventKey) -> void:
	rebind_no_save(action, event)
	save()


func save() -> void:
	var cfg := ConfigFile.new()
	for action: StringName in REBINDABLE_ACTIONS:
		var event := get_key_event(action)
		if event != null:
			cfg.set_value(SECTION, String(action), event.physical_keycode)
	cfg.save(SAVE_PATH)


func load_saved() -> void:
	var cfg := ConfigFile.new()
	if cfg.load(SAVE_PATH) != OK:
		return
	for action: StringName in REBINDABLE_ACTIONS:
		var key := String(action)
		if not cfg.has_section_key(SECTION, key):
			continue
		var keycode: int = cfg.get_value(SECTION, key)
		var event := InputEventKey.new()
		event.physical_keycode = keycode as Key
		rebind_no_save(action, event)


## Rebuilds the action's event list, swapping the first keyboard event for
## `event` in place so ordering (and thus the "primary" key) is preserved.
func rebind_no_save(action: StringName, event: InputEventKey) -> void:
	var events := InputMap.action_get_events(action)
	InputMap.action_erase_events(action)
	var replaced := false
	for existing: InputEvent in events:
		if not replaced and existing is InputEventKey:
			InputMap.action_add_event(action, event)
			replaced = true
		else:
			InputMap.action_add_event(action, existing)
	if not replaced:
		InputMap.action_add_event(action, event)


func reset_defaults() -> void:
	InputMap.load_from_project_settings()
	if FileAccess.file_exists(SAVE_PATH):
		DirAccess.remove_absolute(SAVE_PATH)