Godot Adapt Mobile To Desktop

extends Node
class_name CursorStateManager

## Expert PC Cursor Manager
## Mobile has no cursor concept. On PC, the cursor must be managed:
## Custom hardware textures, hiding during action, showing in menus.

@export var default_cursor: Texture2D
@export var crosshair_cursor: Texture2D

func _ready() -> void:
    # Set standard hardware cursors to look professional instead of default OS arrows
    if default_cursor:
        Input.set_custom_mouse_cursor(default_cursor, Input.CURSOR_ARROW, Vector2(0, 0))
    if crosshair_cursor:
        Input.set_custom_mouse_cursor(crosshair_cursor, Input.CURSOR_CROSS, Vector2(16, 16))

func set_combat_mode(active: bool) -> void:
    if active:
        # Hide standard cursor, switch to crosshair or fully captured
        Input.set_mouse_mode(Input.MOUSE_MODE_CONFINED_HIDDEN)
    else:
        # Released for menu usage
        Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)

func _notification(what: int) -> void:
    # Hide cursor if the game window loses focus, to not confuse the user's OS usage
    if what == NOTIFICATION_WM_WINDOW_FOCUS_OUT:
        pass # Optional: Reset to OS default 

# skills/adapt-mobile-to-desktop/scripts/desktop_input_adapter.gd
extends Node

## Desktop Input Adapter Expert Pattern
## Maps standard Desktop inputs (WASD + Mouse) to Mobile actions.

class_name DesktopInputAdapter

# Configuration -> Action Map
# Maps "mobile_action_name": [Keycodes]
var key_map = {
    "interact": [KEY_E, KEY_SPACE],
    "inventory": [KEY_I, KEY_TAB],
    "pause": [KEY_ESCAPE],
    "map": [KEY_M]
}

func _ready() -> void:
    if OS.has_feature("pc") or OS.has_feature("web_pc") or OS.is_debug_build():
        _inject_input_map()
        _enable_mouse_look()

func _inject_input_map() -> void:
    # Ensure PC keys trigger the same actions as Mobile buttons
    for action in key_map:
        if not InputMap.has_action(action):
            InputMap.add_action(action)
        
        for key in key_map[action]:
            var ev = InputEventKey.new()
            ev.keycode = key
            if not InputMap.action_has_event(action, ev):
                InputMap.action_add_event(action, ev)

func _enable_mouse_look() -> void:
    # If the game uses virtual joystick aiming on mobile,
    # we want mouse aiming on desktop.
    
    # This is often handled in the Player script, but we can emit signals
    pass

func get_aim_vector(current_pos: Vector2) -> Vector2:
    if OS.has_feature("pc") or OS.has_feature("web_pc"):
         # Mouse aim
        return (get_viewport().get_mouse_position() - current_pos).normalized()
    else:
        # Joystick aim (assumes Input Map "aim_x", "aim_y" setup)
        return Input.get_vector("aim_left", "aim_right", "aim_up", "aim_down")

## EXPERT USAGE:
## AutoLoad this script. Use `DesktopInputAdapter.get_aim_vector()` in player code
## to support both Joystick (mobile) and Mouse (desktop) seamlessly.

extends Control
class_name DesktopUISHRINKER

## Expert Desktop UI Scaler
## When migrating a mobile game to PC, buttons are usually MASSIVE (to fit thick thumbs).
## Using the `DisplayServer.screen_get_dpi()` we can selectively shrink the Control tree on PC monitors.

@export var shrink_factor: float = 0.65

func _ready() -> void:
    if not OS.has_feature("mobile"): # If we are on Windows/macOs/Linux
        _shrink_recursive(self)

func _shrink_recursive(node: Node) -> void:
    if node is Control:
        # If the button had a custom minimum size of 150x150 for touch screens, scale it down
        var old_min = node.custom_minimum_size
        if old_min.x > 0 and old_min.y > 0:
            node.custom_minimum_size = old_min * shrink_factor
            
        # Optional: reduce font sizes in theme overrides
        if node.has_theme_font_size_override("font_size"):
            var current_size = node.get_theme_font_size("font_size")
            node.add_theme_font_size_override("font_size", int(current_size * shrink_factor))
            
    for child in node.get_children():
        _shrink_recursive(child)

extends Node
class_name DynamicWindowManager

## Expert Desktop Window Manager
## Mobile games are always full screen. PC gamers demand Borderless Windowed,
## standard Windowed, and Full Screen Exclusive.

enum WindowMode {
    WINDOWED,
    FULLSCREEN,
    BORDERLESS_FULLSCREEN
}

var current_mode: WindowMode = WindowMode.WINDOWED

func _input(event: InputEvent) -> void:
    # Standard PC shortcut: Alt+Enter to toggle fullscreen
    if event.is_action_pressed("toggle_fullscreen") or (event is InputEventKey and event.keycode == KEY_ENTER and event.alt_pressed):
        if current_mode == WindowMode.WINDOWED:
            set_mode(WindowMode.BORDERLESS_FULLSCREEN)
        else:
            set_mode(WindowMode.WINDOWED)

func set_mode(mode: WindowMode) -> void:
    current_mode = mode
    match current_mode:
        WindowMode.WINDOWED:
            DisplayServer.window_set_mode(DisplayServer.WINDOW_MODE_WINDOWED)
            DisplayServer.window_set_flag(DisplayServer.WINDOW_FLAG_BORDERLESS, false)
        WindowMode.FULLSCREEN:
            DisplayServer.window_set_mode(DisplayServer.WINDOW_MODE_EXCLUSIVE_FULLSCREEN)
            DisplayServer.window_set_flag(DisplayServer.WINDOW_FLAG_BORDERLESS, false)
        WindowMode.BORDERLESS_FULLSCREEN:
            # Borderless fills the screen but allows fast alt-tabbing on modern OSs
            DisplayServer.window_set_mode(DisplayServer.WINDOW_MODE_FULLSCREEN)
            DisplayServer.window_set_flag(DisplayServer.WINDOW_FLAG_BORDERLESS, true)
            
    print("Window mode set to: ", WindowMode.keys()[current_mode])

# skills/adapt-mobile-to-desktop/scripts/hover_bridge.gd
extends Node

## Hover Bridge Expert Pattern
## Re-enables desktop hover interactions for shared codebases.
## Mobile usually ignores mouse_entered/exited; this bridges the gap.

class_name HoverBridge

signal hover_state_changed(node: Control, is_hovering: bool)

@export var hover_scale: float = 1.1
@export var hover_color: Color = Color(1.2, 1.2, 1.2) # Brighten
@export var animate: bool = true

var _original_scales: Dictionary = {}
var _original_modulates: Dictionary = {}

func _ready() -> void:
    if not (OS.has_feature("pc") or OS.has_feature("web_pc")):
        set_process(false)
        return
        
    # Auto-connect to all hoverable buttons in group
    for node in get_tree().get_nodes_in_group("hoverable"):
        connect_node(node)
        
    get_tree().node_added.connect(_on_node_added)

func _on_node_added(node: Node) -> void:
    if node.is_in_group("hoverable"):
        connect_node(node)

func connect_node(node: Control) -> void:
    if node.mouse_entered.is_connected(_on_mouse_entered.bind(node)):
        return
        
    node.mouse_entered.connect(_on_mouse_entered.bind(node))
    node.mouse_exited.connect(_on_mouse_exited.bind(node))
    
    # Store originals
    _original_scales[node.get_instance_id()] = node.scale
    _original_modulates[node.get_instance_id()] = node.modulate

func _on_mouse_entered(node: Control) -> void:
    hover_state_changed.emit(node, true)
    
    if animate:
        var tween = create_tween()
        tween.set_parallel(true)
        tween.tween_property(node, "scale", _original_scales[node.get_instance_id()] * hover_scale, 0.1)
        tween.tween_property(node, "modulate", hover_color, 0.1)

func _on_mouse_exited(node: Control) -> void:
    hover_state_changed.emit(node, false)
    
    if animate:
        var tween = create_tween()
        tween.set_parallel(true)
        tween.tween_property(node, "scale", _original_scales[node.get_instance_id()], 0.1)
        tween.tween_property(node, "modulate", _original_modulates[node.get_instance_id()], 0.1)

## EXPERT USAGE:
## Add "hoverable" group to your UI buttons. AutoLoad this script.
## Instantly gives Desktop feel to Mobile-first UI.

extends Node
class_name KeybindingRemapper

## Expert PC Input Remapping
## Mobile uses hardcoded on-screen button positions. PC requires full WASD/Key rebinding.

const SAVE_PATH = "user://keybinds.ini"

func _ready() -> void:
    _load_keybindings()

func rebind_action(action_name: String, new_event: InputEventKey) -> void:
    # 1. Clear old events for this action
    InputMap.action_erase_events(action_name)
    
    # 2. Assign the new key
    InputMap.action_add_event(action_name, new_event)
    
    # 3. Save to disk so bindings persist between sessions
    _save_keybindings()
    print("Rebound '", action_name, "' to keycode: ", new_event.keycode)

func _save_keybindings() -> void:
    var config = ConfigFile.new()
    for action in InputMap.get_actions():
        # Ignore built-in UI actions unless you want to rebind UI navigation
        if action.begins_with("ui_"): continue 
        
        var events = InputMap.action_get_events(action)
        if events.size() > 0 and events[0] is InputEventKey:
            config.set_value("Keybindings", action, events[0].keycode)
            
    config.save(SAVE_PATH)

func _load_keybindings() -> void:
    var config = ConfigFile.new()
    if config.load(SAVE_PATH) == OK:
        for action in config.get_section_keys("Keybindings"):
            var keycode = config.get_value("Keybindings", action)
            var event = InputEventKey.new()
            event.keycode = keycode
            
            InputMap.action_erase_events(action)
            InputMap.action_add_event(action, event)

extends Node3D
class_name MouseCaptureLook

## Expert Mouse Capture Controller
## When porting a mobile dual-stick shooter or swipe-look game to PC,
## you must strictly capture the mouse and accumulate relative motion.

@export var max_pitch: float = 85.0
@export var min_pitch: float = -85.0
@export var mouse_sensitivity: float = 0.002

@onready var pitch_pivot: Node3D = $PitchPivot
var is_captured: bool = false

func _ready() -> void:
    capture_mouse()

func capture_mouse() -> void:
    Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED)
    is_captured = true

func release_mouse() -> void:
    Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)
    is_captured = false

func _unhandled_input(event: InputEvent) -> void:
    if event.is_action_pressed("ui_cancel"):
        release_mouse()
    elif event.is_action_pressed("shoot") and not is_captured:
        capture_mouse()
        
    if is_captured and event is InputEventMouseMotion:
        # Rotate horizontally (yaw) around the root object
        rotate_y(-event.relative.x * mouse_sensitivity)
        
        # Rotate vertically (pitch) around the inner pivot
        pitch_pivot.rotate_x(-event.relative.y * mouse_sensitivity)
        
        # Clamp pitch to avoid looking backwards upside down
        pitch_pivot.rotation.x = clamp(
            pitch_pivot.rotation.x, 
            deg_to_rad(min_pitch), 
            deg_to_rad(max_pitch)
        )

extends Node
class_name MultiMonitorSnapManager

## Expert Multiple Monitor Detection
## Unlike mobile, PC users frequently have 2 or 3 monitors. 
## We must intelligently query the OS and spawn the game on the correct active screen.

func _ready() -> void:
    # Small delay to ensure the OS window server is fully initialized post-launch
    get_tree().create_timer(0.2).timeout.connect(_center_on_active_monitor)

func _center_on_active_monitor() -> void:
    var screen_count = DisplayServer.get_screen_count()
    if screen_count <= 1: 
        return # Standard single monitor, ignore

    # We determine the "Active" monitor by checking where the mouse pointer currently is
    var mouse_pos = DisplayServer.mouse_get_position()
    var active_screen = DisplayServer.get_screen_from_rect(Rect2i(mouse_pos, Vector2i(1,1)))
    
    # Get the position and size of the active screen
    var screen_pos = DisplayServer.screen_get_position(active_screen)
    var screen_size = DisplayServer.screen_get_size(active_screen)
    
    var window_size = DisplayServer.window_get_size()
    
    # Calculate perfect center
    var new_window_pos = screen_pos + (screen_size / 2) - (window_size / 2)
    
    # Apply
    DisplayServer.window_set_current_screen(active_screen)
    DisplayServer.window_set_position(new_window_pos)

    print("Snapped game window to Monitor: ", active_screen)

extends Node
class_name QuitConfirmationHandler

## Expert PC Desktop Window State interceptor
## Unlike mobile iOS/Android where swiping away means immediate termination,
## PC users pressing the 'X' window button expect a "Are you sure you want to quit?" dialog
## to save their progress!

@export var confirmation_dialog: ConfirmationDialog

func _ready() -> void:
    # We must explicitly tell the OS we want to handle the quit request ourselves
    # Otherwise Godot simply closes immediately upon clicking 'X'
    get_tree().set_auto_accept_quit(false)

func _notification(what: int) -> void:
    if what == NOTIFICATION_WM_CLOSE_REQUEST:
        print("X clicked. Showing confirmation popup...")
        
        # Pause the game in the background
        get_tree().paused = true
        
        confirmation_dialog.popup_centered()
        
func _on_save_and_quit_pressed() -> void: # Connected via Editor Signal
    # Wait for file saving to conclude...
    # ...
    
    # Finally explicitly quit
    get_tree().quit()

func _on_cancel_quit_pressed() -> void: # Connected via Editor Signal
    get_tree().paused = false
    confirmation_dialog.hide()

extends OptionButton
class_name ResolutionDropdownManager

## Expert PC Resolution Options
## PC games must provide native resolution choices that respect the monitor's capabilities.
## Mobile simply forces the native OS resolution, but windowed PC needs explicit arrays.

const SUPPORTED_ASPECTS = [
    Vector2i(1920, 1080), # 16:9
    Vector2i(2560, 1440), # 16:9 1440p
    Vector2i(3840, 2160), # 16:9 4K
    Vector2i(3440, 1440), # 21:9 Ultrawide
    Vector2i(1280, 720)   # 16:9 720p (for absolute potatoes)
]

func _ready() -> void:
    item_selected.connect(_on_resolution_selected)
    _populate_resolutions()

func _populate_resolutions() -> void:
    self.clear()
    
    # Query the physical monitor size
    var screen_size = DisplayServer.screen_get_size()
    
    var index = 0
    for res in SUPPORTED_ASPECTS:
        # Don't offer resolutions larger than the user's actual monitor
        if res.x <= screen_size.x and res.y <= screen_size.y:
            self.add_item(str(res.x) + " x " + str(res.y), index)
            self.set_item_metadata(index, res)
            index += 1

func _on_resolution_selected(index: int) -> void:
    var res = self.get_item_metadata(index)
    
    # Apply to the window frame
    DisplayServer.window_set_size(res)
    
    # Center the window back on the screen after scaling
    var screen_center = DisplayServer.screen_get_position() + (DisplayServer.screen_get_size() / 2)
    var new_window_pos = screen_center - (res / 2)
    DisplayServer.window_set_position(new_window_pos)

extends Camera2D
class_name ScrollWheelZoomer

## Expert Mouse Wheel Zoomer
## Mobile uses "Pinch-To-Zoom", but PC relies almost exclusively on the Scroll Wheel.
## This script handles discrete scroll "ticks" and interpolates smoothly to target zoom levels.

@export var zoom_speed: float = 0.1
@export var min_zoom: float = 0.5
@export var max_zoom: float = 3.0
@export var interpolation_speed: float = 10.0

var target_zoom: float = 1.0

func _ready() -> void:
    target_zoom = zoom.x

func _unhandled_input(event: InputEvent) -> void:
    if event is InputEventMouseButton:
        if event.button_index == MOUSE_BUTTON_WHEEL_UP:
            _increment_zoom(zoom_speed)
        elif event.button_index == MOUSE_BUTTON_WHEEL_DOWN:
            _increment_zoom(-zoom_speed)

func _increment_zoom(amount: float) -> void:
    # Add to the TARGET zoom, rather than immediately mutating the current zoom
    target_zoom = clampf(target_zoom + amount, min_zoom, max_zoom)

func _process(delta: float) -> void:
    # Smoothlerp the actual camera zoom towards the target scroll wheel tick
    zoom.x = lerpf(zoom.x, target_zoom, delta * interpolation_speed)
    zoom.y = zoom.x

extends Node
class_name UncappedFramerateController

## Expert Desktop Framerate Unlocker
## Mobile naturally caps at 60fps to save battery. PC gamers with 144Hz, 240Hz monitors
## demand uncapped framerates and toggleable V-Sync.

func apply_video_settings(use_vsync: bool, max_fps: int = 0) -> void:
    if use_vsync:
        # V-Sync ties the frame rate to monitor refresh rate (prevents tearing)
        DisplayServer.window_set_vsync_mode(DisplayServer.VSYNC_ENABLED)
        Engine.max_fps = 0 # 0 means "unlocked", let V-Sync handle it
    else:
        # Mailbox mode is "fast v-sync" (renders unlimited frames but only displays the newest to prevent tearing)
        DisplayServer.window_set_vsync_mode(DisplayServer.VSYNC_MAILBOX)
        
        # If the user sets a hard cap (e.g. 144), enforce it here. 
        # A value of 0 entirely unlocks the engine, which can cause 1000+ FPS in menus and melt GPUs.
        Engine.max_fps = max_fps if max_fps > 0 else 0
        
    print("Framerate adjusted. VSync: ", use_vsync, " Max FPS: ", Engine.max_fps)