Godot Adapt Desktop To Mobile

extends Node
class_name BatterySaverMode

## Expert Mobile Battery Management
## When the user swipes up or puts the phone to sleep, the OS pauses the app.
## If not handled carefully, continuous calculations will drain the battery and the OS will kill the app.

func _ready() -> void:
    # Runs during all pauses so it can listen for resumes
    process_mode = Node.PROCESS_MODE_ALWAYS

func _notification(what: int) -> void:
    match what:
        NOTIFICATION_APPLICATION_PAUSED, NOTIFICATION_WM_WINDOW_FOCUS_OUT:
            _on_app_backgrounded()
        NOTIFICATION_APPLICATION_RESUMED, NOTIFICATION_WM_WINDOW_FOCUS_IN:
            _on_app_foregrounded()

func _on_app_backgrounded() -> void:
    # 1. Pause game logic and physics
    get_tree().paused = true
    
    # 2. Aggressively drop frame rate to save GPU/CPU cycles
    # Godot will render 1 frame per second to keep the OS snapshot looking correct
    Engine.max_fps = 1 
    
    # 3. Mute all master volume so it doesn't try to play over music
    AudioServer.set_bus_mute(AudioServer.get_bus_index("Master"), true)
    
    print("BatterySaver: App suspended. Physics paused, FPS locked to 1.")

func _on_app_foregrounded() -> void:
    # Resume everything
    get_tree().paused = false
    
    # Setting to 0 unlocks the framerate (or locks to VSync)
    Engine.max_fps = 0 
    
    AudioServer.set_bus_mute(AudioServer.get_bus_index("Master"), false)
    print("BatterySaver: App resumed. Physics active, FPS restored.")

extends Control
class_name DynamicVirtualJoystick

## Expert Virtual Joystick Spawner
## Instead of a hardcoded bottom-left position, this joystick appears 
## exactly where the user touches on the left half of the screen.

signal joystick_updated(direction: Vector2)

@export var max_radius: float = 100.0
@export var return_speed: float = 20.0

@onready var background: Sprite2D = $Background
@onready var handle: Sprite2D = $Handle

var active_touch_index: int = -1
var joystick_center: Vector2 = Vector2.ZERO

func _ready() -> void:
    modulate.a = 0.0 # Hidden by default
    
func _input(event: InputEvent) -> void:
    if event is InputEventScreenTouch:
        # Only activate on the left half of the screen
        if event.pressed and active_touch_index == -1 and event.position.x < get_viewport_rect().size.x / 2.0:
            active_touch_index = event.index
            joystick_center = event.position
            global_position = joystick_center
            handle.position = Vector2.ZERO
            modulate.a = 1.0 # Show
            
        elif not event.pressed and event.index == active_touch_index:
            active_touch_index = -1
            modulate.a = 0.0 # Hide
            joystick_updated.emit(Vector2.ZERO)
            
    elif event is InputEventScreenDrag and event.index == active_touch_index:
        var drag_vector = event.position - joystick_center
        var clamped_drag = drag_vector.limit_length(max_radius)
        
        handle.position = clamped_drag
        var normalized_direction = clamped_drag / max_radius
        joystick_updated.emit(normalized_direction)

extends Node
class_name GestureComboSystem

## Expert Swipe and Pinch Gesture Recognizer
## Tracks touch start/end times and calculates velocity for flicks.

signal swipe_detected(direction: Vector2, velocity: float)
signal zoom_detected(scale_factor: float) # <1 for pinch out, >1 for pinch in

var touches: Dictionary = {}

func _input(event: InputEvent) -> void:
    if event is InputEventScreenTouch:
        if event.pressed:
            touches[event.index] = {
                "start_pos": event.position,
                "current_pos": event.position,
                "time": Time.get_ticks_msec()
            }
        else:
            _analyze_release(event)
            touches.erase(event.index)
            
    elif event is InputEventScreenDrag:
        if touches.has(event.index):
            touches[event.index]["current_pos"] = event.position
            _analyze_drag()

func _analyze_release(event: InputEventScreenTouch) -> void:
    if touches.size() != 1: return # Ignore single swipes if multiple fingers down
    
    var data = touches[event.index]
    var distance = event.position.distance_to(data.start_pos)
    var duration = (Time.get_ticks_msec() - data.time) / 1000.0
    
    # 50 pixels minimum distance, < 0.3 seconds duration to count as swipe
    if distance > 50.0 and duration < 0.3:
        var direction = (event.position - data.start_pos).normalized()
        var velocity = distance / duration
        swipe_detected.emit(direction, velocity)

func _analyze_drag() -> void:
    if touches.size() == 2:
        var keys = touches.keys()
        var touch1 = touches[keys[0]]
        var touch2 = touches[keys[1]]
        
        var start_dist = touch1.start_pos.distance_to(touch2.start_pos)
        var current_dist = touch1.current_pos.distance_to(touch2.current_pos)
        
        if start_dist > 10.0:
            var scale_factor = current_dist / start_dist
            zoom_detected.emit(scale_factor)

class_name HapticManager
extends Node

## Expert Mobile Haptic Feedback Manager
## Godot supports Android vibration out of the box. 
## iOS requires specific native plugins (like iOSHaptics), but we abstract the concept here.

enum HapticType {
    LIGHT_TICK,
    MEDIUM_BUMP,
    HEAVY_CRASH,
    SUCCESS_BUZZ
}

static func trigger(type: HapticType) -> void:
    if not OS.has_feature("mobile"):
        return
        
    var duration_ms: int = 0
    match type:
        HapticType.LIGHT_TICK:
            duration_ms = 15
        HapticType.MEDIUM_BUMP:
            duration_ms = 40
        HapticType.HEAVY_CRASH:
            duration_ms = 100
        HapticType.SUCCESS_BUZZ:
            duration_ms = 250
            
    # Native Android Vibration
    if OS.get_name() == "Android":
        Input.vibrate_handheld(duration_ms)
        
    # Example iOS Plugin Hook (assuming a plugin named "iOSHaptics" is installed)
    elif OS.get_name() == "iOS":
        if Engine.has_singleton("iOSHaptics"):
            var ios_haptics = Engine.get_singleton("iOSHaptics")
            # Usually plugins map to UI selection, impact, or notification haptics
            ios_haptics.impact(int(type))

extends Node
class_name MobileShaderFallback

## Expert Mobile Material Optimizer
## Highly complex shaders (StandardMaterial3D with SSS, Detail textures, CLEARCOAT) 
## will crush weak mobile Adreno/Mali GPUs. This script automatically crawls the 
## SceneTree and replaces complex materials with cheap Unshaded or Vertex-Lit equivalents.

@export var optimize_on_startup: bool = true

func _ready() -> void:
    if OS.has_feature("mobile") and optimize_on_startup:
        # Start the recursive search down the tree
        _downgrade_materials(get_tree().root)

func _downgrade_materials(node: Node) -> void:
    if node is MeshInstance3D:
        _optimize_mesh_instance(node)
        
    for child in node.get_children():
        _downgrade_materials(child)

func _optimize_mesh_instance(mesh_inst: MeshInstance3D) -> void:
    for i in range(mesh_inst.get_surface_override_material_count()):
        var mat = mesh_inst.get_surface_override_material(i)
        if mat and mat is StandardMaterial3D:
            _strip_expensive_features(mat)

func _strip_expensive_features(mat: StandardMaterial3D) -> void:
    # Disable features that destroy mobile tiled renderers
    mat.clearcoat_enabled = false
    mat.subsurf_scatter_enabled = false
    mat.detail_enabled = false
    mat.distance_fade_mode = BaseMaterial3D.DISTANCE_FADE_DISABLED
    
    # If the material doesn't need to react to light dynamically, unshade it completely
    if mat.emission_enabled:
        mat.shading_mode = BaseMaterial3D.SHADING_MODE_UNSHADED

# skills/adapt-desktop-to-mobile/scripts/mobile_ui_adapter.gd
extends CanvasLayer

## Mobile UI Adapter Expert Pattern
## Auto-detects mobile platform and creates touch controls / scales UI.

class_name MobileUIAdapter

@export var virtual_joystick_scene: PackedScene
@export var touch_button_group: Control # Container for right-side buttons

func _ready() -> void:
	if _is_mobile():
		_enable_mobile_controls()
		_scale_ui_elements()
	else:
		_disable_mobile_controls()

func _is_mobile() -> bool:
	return OS.has_feature("mobile") or OS.has_feature("web_android") or OS.has_feature("web_ios")

func _enable_mobile_controls() -> void:
	if virtual_joystick_scene:
		var stick = virtual_joystick_scene.instantiate()
		add_child(stick)
		# Position bottom-left
		stick.set_anchors_preset(Control.PRESET_BOTTOM_LEFT)
		stick.position += Vector2(50, -50) # Margin
	
	if touch_button_group:
		touch_button_group.show()

func _disable_mobile_controls() -> void:
	if touch_button_group:
		touch_button_group.hide()

func _scale_ui_elements() -> void:
	# Iterate over specific groups to scale up for touch
	var buttons = get_tree().get_nodes_in_group("touch_interactive")
	
	for btn in buttons:
		if btn is Control:
			# Ensure min 44pt (approx 88px on high DPI)
			var min_size = 88.0
			if btn.custom_minimum_size.x < min_size:
				btn.custom_minimum_size.x = min_size
			if btn.custom_minimum_size.y < min_size:
				btn.custom_minimum_size.y = min_size

## EXPERT USAGE:
## Add to Main Scene. Assign Virtual Joystick scene. 
## Group small buttons as "touch_interactive" to auto-scale them.

class_name OfflineSaveSync
extends Node

## Expert Mobile Save Data Manager
## Mobile OSs will aggressively terminate background apps. 
## You CANNOT rely on "save on exit" signals like `NOTIFICATION_WM_CLOSE_REQUEST` on iOS/Android.
## You must save immediately during `NOTIFICATION_APPLICATION_PAUSED` or proactively during gameplay.

const SAVE_PATH = "user://mobile_save.dat"
var game_data: Dictionary = {}

func _ready() -> void:
    process_mode = Node.PROCESS_MODE_ALWAYS
    _load_game_data()

func _notification(what: int) -> void:
    match what:
        # App is being swiped away or put to sleep. SAVE NOW.
        NOTIFICATION_APPLICATION_PAUSED, NOTIFICATION_WM_WINDOW_FOCUS_OUT:
            _force_save_to_disk()

## Instead of saving to disk every time a coin is picked up (which causes stutter/battery drain),
## we update a memory Dictionary and only write to disk when backgrounded.
func update_data(key: String, value: Variant) -> void:
    game_data[key] = value

func _force_save_to_disk() -> void:
    var file = FileAccess.open_encrypted_with_pass(SAVE_PATH, FileAccess.WRITE, "secure_mobile_key_123!")
    if file:
        file.store_var(game_data)
        file.close()
        print("OfflineSave: Successfully saved during app pause.")
    else:
        push_error("OfflineSave: Failed to open save file during pause!")

func _load_game_data() -> void:
    if FileAccess.file_exists(SAVE_PATH):
        var file = FileAccess.open_encrypted_with_pass(SAVE_PATH, FileAccess.READ, "secure_mobile_key_123!")
        if file:
            game_data = file.get_var()
            file.close()

extends Control
class_name OnScreenKeyboardHandler

## Expert Virtual Keyboard Management
## When a LineEdit or TextEdit is focused on mobile, the OS pops up a virtual keyboard
## that covers the bottom 30-50% of the screen. We must push the UI UP to keep the input visible.

@export var layout_container: Control # The main UI root to shift

func _ready() -> void:
    # Connect to the OS virtual keyboard signals
    DisplayServer.virtual_keyboard_update.connect(_on_virtual_keyboard_changed)

func _on_virtual_keyboard_changed(keyboard_height: float) -> void:
    if not OS.has_feature("mobile"): return
    
    if keyboard_height > 0:
        # Keyboard opened.
        # Push the UI up by the height of the keyboard
        var tween = create_tween()
        tween.tween_property(layout_container, "position:y", -keyboard_height, 0.2).set_trans(Tween.TRANS_SINE)
    else:
        # Keyboard closed. Return UI to normal.
        var tween = create_tween()
        tween.tween_property(layout_container, "position:y", 0.0, 0.2).set_trans(Tween.TRANS_SINE)

## Automatically close the keyboard if the user taps outside the LineEdit
func _input(event: InputEvent) -> void:
    if event is InputEventScreenTouch and event.pressed:
        var focus_owner = get_viewport().gui_get_focus_owner()
        if focus_owner and (focus_owner is LineEdit or focus_owner is TextEdit):
            # If they didn't touch the text box, release focus and hide keyboard
            var local_event = focus_owner.make_input_local(event)
            if not focus_owner.get_rect().has_point(local_event.position):
                focus_owner.release_focus()
                DisplayServer.virtual_keyboard_hide()

extends Node
class_name AdaptiveMobileResolution

## Expert Viewport Resolution Scaler
## Separates UI rendering from 3D world rendering.
## Dynamically drops the 3D resolution scale down to keep 60 FPS on weak GPUs
## while leaving the 2D UI incredibly sharp.

@export var target_fps: int = 60
@export var check_interval: float = 2.0
@export var min_scale: float = 0.3
@export var scale_step: float = 0.1

var timer: float = 0.0

func _ready() -> void:
    # Requires Project Settings -> Display -> Window -> Stretch -> Mode: 'canvas_items'
    if not OS.has_feature("mobile"):
        set_process(false)

func _process(delta: float) -> void:
    timer += delta
    if timer >= check_interval:
        timer = 0.0
        var current_fps = Engine.get_frames_per_second()
        var current_scale = get_viewport().scaling_3d_scale
        
        if current_fps < target_fps - 5:
            # Dropping frames, decrease 3D resolution
            var new_scale = clampf(current_scale - scale_step, min_scale, 1.0)
            get_viewport().scaling_3d_scale = new_scale
            
        elif current_fps > target_fps + 2 and current_scale < 1.0:
            # Plenty of headroom, try increasing resolution
            var new_scale = clampf(current_scale + (scale_step / 2.0), min_scale, 1.0)
            get_viewport().scaling_3d_scale = new_scale

extends Camera2D
class_name TouchPanZoomCamera2D

## Expert Touch Camera Controller
## Handles 1-finger panning and 2-finger pinch zooming simultaneously.

@export var min_zoom := 0.5
@export var max_zoom := 3.0
@export var pan_speed := 1.0

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)
            
    elif event is InputEventScreenDrag:
        touches[event.index] = event.position
        
        if touches.size() == 1:
            # Panning
            # For Camera2D, we subtract the relative movement to drag the world across the screen
            position -= event.relative * pan_speed * (1.0 / zoom.x)
            
        elif touches.size() == 2:
            # Pinch to Zoom
            var keys = touches.keys()
            var t1 = touches[keys[0]]
            var t2 = touches[keys[1]]
            
            var previous_dist = t1.distance_to(t2)
            
            # Since event.relative is the change this frame, we reconstruct the previous positions
            var prev_t1 = touches[keys[0]]
            var prev_t2 = touches[keys[1]]
            
            if event.index == keys[0]: prev_t1 -= event.relative
            else: prev_t2 -= event.relative
            
            var old_dist = prev_t1.distance_to(prev_t2)
            
            # Ratio of new distance over old distance
            var zoom_factor = previous_dist / max(old_dist, 0.001)
            
            _apply_zoom(zoom_factor)

func _apply_zoom(factor: float) -> void:
    var new_zoom = zoom.x * factor
    new_zoom = clampf(new_zoom, min_zoom, max_zoom)
    zoom = Vector2(new_zoom, new_zoom)

extends MarginContainer
class_name UISafeAreaMargins

## Expert Mobile Notch Avoidance
## On iPhone and Android, screens have physical cutouts (notches, hole punches).
## Instead of guessing, we use the OS safe area Rect2 to apply Margins accurately.

func _ready() -> void:
    get_viewport().size_changed.connect(_apply_safe_area)
    _apply_safe_area()

func _apply_safe_area() -> void:
    if not OS.has_feature("mobile"):
        return
        
    var safe_area: Rect2i = DisplayServer.get_display_safe_area()
    var window_size: Vector2i = DisplayServer.window_get_size()
    
    var left_margin = safe_area.position.x
    var top_margin = safe_area.position.y
    var right_margin = window_size.x - safe_area.end.x
    var bottom_margin = window_size.y - safe_area.end.y
    
    add_theme_constant_override("margin_left", left_margin)
    add_theme_constant_override("margin_top", top_margin)
    add_theme_constant_override("margin_right", right_margin)
    add_theme_constant_override("margin_bottom", bottom_margin)

# skills/adapt-desktop-to-mobile/scripts/virtual_joystick.gd
extends Control

## Virtual Joystick Expert Pattern
## Production-ready joystick with multi-touch support and visual feedback.

class_name VirtualJoystick

signal direction_changed(direction: Vector2)

@export var dead_zone: float = 0.2
@export var max_distance: float = 100.0
@export var clamp_zone: bool = true

# UI References
@onready var base: Sprite2D = $Base
@onready var knob: Sprite2D = $Knob

# State
var _touch_index: int = -1
var _stick_center: Vector2

func _ready() -> void:
	# Ensure pivots are centered
	if base: _stick_center = base.position
	
func _input(event: InputEvent) -> void:
    if not (base and knob): return

    if event is InputEventScreenTouch:
        if event.pressed:
            if _touch_index == -1 and _is_point_inside_base(event.position):
                _touch_index = event.index
                _update_joystick(event.position)
        elif event.index == _touch_index:
            _reset_joystick()
            
    elif event is InputEventScreenDrag:
        if event.index == _touch_index:
            _update_joystick(event.position)

func _is_point_inside_base(point: Vector2) -> bool:
    var global_rect = base.get_rect()
    global_rect.position += base.global_position - (base.texture.get_size() / 2.0)
    return global_rect.has_point(point)

func _update_joystick(touch_pos: Vector2) -> void:
    var local_pos = to_local(touch_pos)
    var vector = local_pos - _stick_center
    var dist = vector.length()
    
    if clamp_zone and dist > max_distance:
        vector = vector.normalized() * max_distance
        
    knob.position = _stick_center + vector
    
    var output = vector / max_distance
    if output.length() < dead_zone:
        output = Vector2.ZERO
        
    direction_changed.emit(output)

func _reset_joystick() -> void:
    _touch_index = -1
    knob.position = _stick_center
    direction_changed.emit(Vector2.ZERO)

## EXPERT USAGE:
## Instantiate in MobileHUD. Connect 'direction_changed' to Player movement.