touch controls and hud
This commit is contained in:
+360
-190
@@ -2,15 +2,23 @@ extends CanvasLayer
|
||||
## On-screen controls for touch devices: a floating movement joystick on the left
|
||||
## and a cluster of ability buttons on the right. Instantiated by hud.gd.
|
||||
##
|
||||
## The joystick feeds the same `move_*` input actions the keyboard/gamepad drive
|
||||
## (via Input.action_press with an analog strength), so player.gd needs no touch
|
||||
## awareness — it just reads Input.get_vector() as always. Ability buttons call the
|
||||
## player's public try_activate_ability(), which shares the keyboard's cooldown gate.
|
||||
## All interaction is driven from raw `_input()` with manual hit-testing, NOT from
|
||||
## Control.gui_input. On the web/wasm build the overlay lives in a CanvasLayer nested
|
||||
## under the HUD, and GUI touch routing into a nested CanvasLayer renders fine but
|
||||
## silently drops input — a standard Button here never fires. `_input()` sees every
|
||||
## InputEventScreenTouch regardless of nesting, mouse_filter, or emulate_mouse_from_touch,
|
||||
## so the joystick and buttons work reliably across browsers. Everything is drawn in one
|
||||
## Control (_surface) whose rects are the single source of truth for both drawing and
|
||||
## hit-testing.
|
||||
##
|
||||
## The joystick feeds the same `move_*` input actions the keyboard/gamepad drive (via
|
||||
## Input.action_press with an analog strength), so player.gd needs no touch awareness — it
|
||||
## just reads Input.get_vector() as always. Ability buttons call the player's public
|
||||
## try_activate_ability(), sharing the keyboard's cooldown gate.
|
||||
##
|
||||
## Shown only on touch platforms (see Controls.use_touch_ui), or when DP
|
||||
## "force_touch_controls" is on so the layout can be exercised on a desktop build.
|
||||
## emulate_touch_from_mouse (project.godot) lets a mouse stand in for a finger while
|
||||
## testing.
|
||||
## "force_touch_controls" is on so the layout can be exercised on a desktop build
|
||||
## (emulate_touch_from_mouse turns a mouse click into a touch event for that).
|
||||
|
||||
# move_* actions, indexed by the four joystick push directions.
|
||||
const _MOVE_RIGHT: StringName = &"move_right"
|
||||
@@ -33,80 +41,208 @@ const _ABILITY_ACCENT: Array[Color] = [
|
||||
Color(1.00, 0.82, 0.32), # Roll — gold
|
||||
]
|
||||
|
||||
var _root: Control
|
||||
var _stick: Control
|
||||
var _cd_overlays: Array[ColorRect] = []
|
||||
# Sentinel touch indices. A real finger uses its own non-negative index; the mouse
|
||||
# (desktop force-flag testing, when no real touch has been seen) uses _MOUSE.
|
||||
const _MOUSE: int = -2
|
||||
|
||||
var _surface: Control
|
||||
var _player: Node = null
|
||||
|
||||
# Floating-joystick state. _origin is where the thumb first touched (base centre),
|
||||
# _knob is the current thumb position; both in _stick-local coordinates. _touch_index
|
||||
# is the finger owning the stick (-1 = none, -2 = mouse), so a second finger tapping
|
||||
# an ability button never steals the stick.
|
||||
# Cached textures + styleboxes so the per-frame redraw (cooldowns animate) allocates nothing.
|
||||
var _ability_tex: Array[Texture2D] = []
|
||||
var _ability_style: Array[StyleBoxFlat] = []
|
||||
var _menu_style: StyleBoxFlat
|
||||
|
||||
# Layout rects in screen space — the single source of truth for drawing AND hit-testing.
|
||||
var _stick_zone: Rect2 = Rect2()
|
||||
var _ability_rects: Array[Rect2] = []
|
||||
var _menu_rect: Rect2 = Rect2()
|
||||
|
||||
# Resting "drag to move" affordance drawn in the lower-left when the stick is idle, so a
|
||||
# first-time player sees where to plant their thumb instead of guessing. _hint_pulse gives
|
||||
# it a slow breathing alpha for discoverability.
|
||||
var _stick_hint_center: Vector2 = Vector2()
|
||||
var _hint_pulse: float = 0.0
|
||||
|
||||
# Floating-joystick state. _origin is where the thumb first touched (base centre), _knob is
|
||||
# the current thumb position; both in screen coordinates.
|
||||
var _stick_active: bool = false
|
||||
var _origin: Vector2 = Vector2.ZERO
|
||||
var _knob: Vector2 = Vector2.ZERO
|
||||
var _touch_index: int = -3
|
||||
var _stick_radius: float = 110.0
|
||||
|
||||
# Live fingers by index → screen position, plus what each finger is doing ("stick", a slot
|
||||
# int, "menu", or "camera"). Ownership keeps a second finger on a button from stealing the
|
||||
# stick, and keeps steering/ability fingers from being mistaken for a pinch gesture.
|
||||
var _touches: Dictionary = {}
|
||||
var _touch_owner: Dictionary = {}
|
||||
var _saw_real_touch: bool = false
|
||||
|
||||
# Pinch-to-zoom: only "camera" fingers (right side, not on any button) count, so steering
|
||||
# with one thumb while tapping an ability with the other never reads as a zoom.
|
||||
var _pinching: bool = false
|
||||
var _pinch_dist: float = 0.0
|
||||
|
||||
# Diagnostics surfaced by DP "touch_debug" — lets us see, on the actual device, whether
|
||||
# events arrive and where, since no console is reachable there.
|
||||
var _dbg_events: int = 0
|
||||
var _dbg_last_pos: Vector2 = Vector2.ZERO
|
||||
|
||||
|
||||
func _ready() -> void:
|
||||
layer = 10 # below the HUD (11) so the game-over screen always draws on top
|
||||
process_mode = Node.PROCESS_MODE_ALWAYS
|
||||
|
||||
_root = Control.new()
|
||||
_root.set_anchors_preset(Control.PRESET_FULL_RECT)
|
||||
_root.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
||||
_root.visible = false
|
||||
add_child(_root)
|
||||
for slot: int in 4:
|
||||
var tex: Texture2D = null
|
||||
if ResourceLoader.exists(_ABILITY_ICONS[slot]):
|
||||
tex = load(_ABILITY_ICONS[slot])
|
||||
_ability_tex.append(tex)
|
||||
_ability_style.append(_button_style(_ABILITY_ACCENT[slot]))
|
||||
_menu_style = _button_style(Color(1.00, 0.78, 0.22, 0.8))
|
||||
|
||||
_surface = Control.new()
|
||||
_surface.set_anchors_preset(Control.PRESET_FULL_RECT)
|
||||
_surface.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
||||
_surface.visible = false
|
||||
_surface.draw.connect(_draw_surface)
|
||||
add_child(_surface)
|
||||
|
||||
_build_joystick()
|
||||
_build_ability_buttons()
|
||||
_build_menu_button()
|
||||
_relayout()
|
||||
get_viewport().size_changed.connect(_relayout)
|
||||
|
||||
|
||||
# ── Joystick ────────────────────────────────────────────────────────────────
|
||||
# The stick zone is the whole left half of the screen: touching anywhere in it
|
||||
# plants the base under the thumb, so the player never has to find a fixed pad.
|
||||
# ── Layout ────────────────────────────────────────────────────────────────────
|
||||
# Left half is the joystick zone (touch anywhere in it to plant the base under the thumb);
|
||||
# the ability cluster and menu button sit in the right half so they never overlap it.
|
||||
|
||||
func _build_joystick() -> void:
|
||||
_stick = Control.new()
|
||||
_stick.mouse_filter = Control.MOUSE_FILTER_STOP
|
||||
_stick.gui_input.connect(_on_stick_input)
|
||||
_stick.draw.connect(_draw_stick)
|
||||
_root.add_child(_stick)
|
||||
func _relayout() -> void:
|
||||
var vp := get_viewport().get_visible_rect().size
|
||||
var short := minf(vp.x, vp.y)
|
||||
_stick_radius = clampf(short * 0.16, 80.0, 150.0)
|
||||
_stick_zone = Rect2(Vector2.ZERO, Vector2(vp.x * 0.5, vp.y))
|
||||
|
||||
var bs := clampf(short * 0.16, 72.0, 120.0) # ability button edge
|
||||
var gap := bs * 0.18
|
||||
var margin := bs * 0.28
|
||||
var right := vp.x - margin
|
||||
var bottom := vp.y - margin
|
||||
var col0 := right - bs * 2.0 - gap
|
||||
var col1 := right - bs
|
||||
var row0 := bottom - bs * 2.0 - gap
|
||||
var row1 := bottom - bs
|
||||
_ability_rects = [
|
||||
Rect2(col0, row0, bs, bs), # kick
|
||||
Rect2(col1, row0, bs, bs), # dash
|
||||
Rect2(col0, row1, bs, bs), # slam
|
||||
Rect2(col1, row1, bs, bs), # roll
|
||||
]
|
||||
|
||||
var ms := clampf(short * 0.09, 48.0, 72.0)
|
||||
_menu_rect = Rect2(vp.x - ms - 16.0, 16.0, ms, ms)
|
||||
|
||||
_stick_hint_center = Vector2(vp.x * 0.20, vp.y * 0.74)
|
||||
_surface.queue_redraw()
|
||||
|
||||
|
||||
func _on_stick_input(event: InputEvent) -> void:
|
||||
# ── Input ───────────────────────────────────────────────────────────────────
|
||||
# Raw events only. Real touches drive the touch path; once any real touch is seen the
|
||||
# mouse path is disabled (emulate_mouse_from_touch would otherwise double-fire every tap).
|
||||
# The mouse path stays live for desktop force-flag testing where no touchscreen exists.
|
||||
|
||||
func _input(event: InputEvent) -> void:
|
||||
if get_tree().paused or not Controls.use_touch_ui():
|
||||
return
|
||||
|
||||
if event is InputEventScreenTouch:
|
||||
_saw_real_touch = true
|
||||
var t := event as InputEventScreenTouch
|
||||
if t.pressed and not _stick_active:
|
||||
_begin_stick(t.position, t.index)
|
||||
elif not t.pressed and _touch_index == t.index:
|
||||
_end_stick()
|
||||
_dbg_events += 1
|
||||
_dbg_last_pos = t.position
|
||||
if t.pressed:
|
||||
_touches[t.index] = t.position
|
||||
_on_press(t.index, t.position)
|
||||
else:
|
||||
_on_release(t.index, t.position)
|
||||
_touches.erase(t.index)
|
||||
_update_pinch_state()
|
||||
_surface.queue_redraw()
|
||||
get_viewport().set_input_as_handled()
|
||||
|
||||
elif event is InputEventScreenDrag:
|
||||
var d := event as InputEventScreenDrag
|
||||
if _touch_index == d.index:
|
||||
_update_stick(d.position)
|
||||
elif event is InputEventMouseButton:
|
||||
_dbg_events += 1
|
||||
_dbg_last_pos = d.position
|
||||
_touches[d.index] = d.position
|
||||
_on_drag(d.index, d.position)
|
||||
_surface.queue_redraw()
|
||||
get_viewport().set_input_as_handled()
|
||||
|
||||
elif not _saw_real_touch and event is InputEventMouseButton:
|
||||
var mb := event as InputEventMouseButton
|
||||
if mb.button_index == MOUSE_BUTTON_LEFT:
|
||||
if mb.pressed and not _stick_active:
|
||||
_begin_stick(mb.position, -2)
|
||||
elif not mb.pressed and _touch_index == -2:
|
||||
_end_stick()
|
||||
elif event is InputEventMouseMotion and _touch_index == -2:
|
||||
_update_stick((event as InputEventMouseMotion).position)
|
||||
_dbg_events += 1
|
||||
_dbg_last_pos = mb.position
|
||||
if mb.pressed:
|
||||
_touches[_MOUSE] = mb.position
|
||||
_on_press(_MOUSE, mb.position)
|
||||
else:
|
||||
_on_release(_MOUSE, mb.position)
|
||||
_touches.erase(_MOUSE)
|
||||
_update_pinch_state()
|
||||
_surface.queue_redraw()
|
||||
|
||||
elif not _saw_real_touch and event is InputEventMouseMotion:
|
||||
if _touch_owner.get(_MOUSE, null) == "stick":
|
||||
_touches[_MOUSE] = (event as InputEventMouseMotion).position
|
||||
_update_stick(_touches[_MOUSE])
|
||||
_surface.queue_redraw()
|
||||
|
||||
|
||||
func _begin_stick(pos: Vector2, index: int) -> void:
|
||||
func _on_press(index: int, pos: Vector2) -> void:
|
||||
if _menu_rect.has_point(pos):
|
||||
_touch_owner[index] = "menu"
|
||||
return
|
||||
for slot: int in _ability_rects.size():
|
||||
if _ability_rects[slot].has_point(pos):
|
||||
_touch_owner[index] = slot
|
||||
if _player != null:
|
||||
_player.call(&"try_activate_ability", slot)
|
||||
return
|
||||
if _stick_zone.has_point(pos) and not _stick_active:
|
||||
_touch_owner[index] = "stick"
|
||||
_begin_stick(pos)
|
||||
return
|
||||
_touch_owner[index] = "camera"
|
||||
|
||||
|
||||
func _on_drag(index: int, pos: Vector2) -> void:
|
||||
match _touch_owner.get(index, null):
|
||||
"stick":
|
||||
_update_stick(pos)
|
||||
"camera":
|
||||
if _pinching:
|
||||
_apply_pinch()
|
||||
|
||||
|
||||
func _on_release(index: int, pos: Vector2) -> void:
|
||||
match _touch_owner.get(index, null):
|
||||
"stick":
|
||||
_end_stick()
|
||||
"menu":
|
||||
if _menu_rect.has_point(pos):
|
||||
_touch_owner.erase(index)
|
||||
_return_to_menu()
|
||||
return
|
||||
_touch_owner.erase(index)
|
||||
|
||||
|
||||
# ── Joystick ────────────────────────────────────────────────────────────────
|
||||
|
||||
func _begin_stick(pos: Vector2) -> void:
|
||||
_stick_active = true
|
||||
_touch_index = index
|
||||
_origin = pos
|
||||
_knob = pos
|
||||
_stick.queue_redraw()
|
||||
|
||||
|
||||
func _update_stick(pos: Vector2) -> void:
|
||||
@@ -117,19 +253,16 @@ func _update_stick(pos: Vector2) -> void:
|
||||
offset = offset.normalized() * _stick_radius
|
||||
_knob = _origin + offset
|
||||
_apply_move(offset / _stick_radius)
|
||||
_stick.queue_redraw()
|
||||
|
||||
|
||||
func _end_stick() -> void:
|
||||
_stick_active = false
|
||||
_touch_index = -3
|
||||
_release_move()
|
||||
_stick.queue_redraw()
|
||||
|
||||
|
||||
# Translate a normalised stick offset (screen space: +x right, +y down) into analog
|
||||
# strengths on the four movement actions. Opposite pairs are mutually exclusive, so
|
||||
# only one of each axis is ever pressed at a time.
|
||||
# strengths on the four movement actions. Opposite pairs are mutually exclusive, so only
|
||||
# one of each axis is ever pressed at a time.
|
||||
func _apply_move(v: Vector2) -> void:
|
||||
Input.action_press(_MOVE_RIGHT, maxf(0.0, v.x))
|
||||
Input.action_press(_MOVE_LEFT, maxf(0.0, -v.x))
|
||||
@@ -142,139 +275,184 @@ func _release_move() -> void:
|
||||
Input.action_release(action)
|
||||
|
||||
|
||||
func _draw_stick() -> void:
|
||||
if not _stick_active:
|
||||
# ── Pinch-to-zoom ─────────────────────────────────────────────────────────────
|
||||
# Only "camera" fingers (open right-side area, not on a button) participate, so it can't
|
||||
# fire while the player is steering or tapping abilities.
|
||||
|
||||
func _camera_touches() -> Array:
|
||||
var pts: Array = []
|
||||
for idx: int in _touches:
|
||||
if _touch_owner.get(idx, null) == "camera":
|
||||
pts.append(_touches[idx])
|
||||
return pts
|
||||
|
||||
|
||||
func _update_pinch_state() -> void:
|
||||
var pts := _camera_touches()
|
||||
var was := _pinching
|
||||
_pinching = pts.size() >= 2
|
||||
if _pinching and not was:
|
||||
if _stick_active:
|
||||
_end_stick()
|
||||
_pinch_dist = (pts[0] as Vector2).distance_to(pts[1] as Vector2)
|
||||
elif was and not _pinching:
|
||||
_pinch_dist = 0.0
|
||||
|
||||
|
||||
func _apply_pinch() -> void:
|
||||
var pts := _camera_touches()
|
||||
if pts.size() < 2:
|
||||
return
|
||||
var ring := Color(0.93, 0.88, 0.72, 0.30)
|
||||
var knob := Color(1.00, 0.82, 0.32, 0.55)
|
||||
_stick.draw_circle(_origin, _stick_radius, Color(0.0, 0.0, 0.0, 0.20))
|
||||
_stick.draw_arc(_origin, _stick_radius, 0.0, TAU, 48, ring, 4.0, true)
|
||||
_stick.draw_circle(_knob, _stick_radius * 0.42, knob)
|
||||
var dist := (pts[0] as Vector2).distance_to(pts[1] as Vector2)
|
||||
if _pinch_dist <= 0.0 or dist <= 0.0:
|
||||
_pinch_dist = dist
|
||||
return
|
||||
var cam := get_viewport().get_camera_3d()
|
||||
if cam != null and cam.has_method(&"adjust_zoom"):
|
||||
cam.call(&"adjust_zoom", dist / _pinch_dist)
|
||||
_pinch_dist = dist
|
||||
|
||||
|
||||
# ── Ability buttons ─────────────────────────────────────────────────────────
|
||||
# A 2×2 cluster in the bottom-right thumb reach. Each button taps the matching
|
||||
# ability; a dark overlay wipes down over it while that ability is cooling down.
|
||||
# ── Drawing ───────────────────────────────────────────────────────────────────
|
||||
|
||||
func _build_ability_buttons() -> void:
|
||||
var grid := GridContainer.new()
|
||||
grid.name = "AbilityGrid"
|
||||
grid.columns = 2
|
||||
grid.add_theme_constant_override("h_separation", 14)
|
||||
grid.add_theme_constant_override("v_separation", 14)
|
||||
grid.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
||||
grid.anchor_left = 1.0
|
||||
grid.anchor_right = 1.0
|
||||
grid.anchor_top = 1.0
|
||||
grid.anchor_bottom = 1.0
|
||||
grid.grow_horizontal = Control.GROW_DIRECTION_BEGIN
|
||||
grid.grow_vertical = Control.GROW_DIRECTION_BEGIN
|
||||
grid.offset_left = -220.0
|
||||
grid.offset_top = -220.0
|
||||
grid.offset_right = -24.0
|
||||
grid.offset_bottom = -24.0
|
||||
_root.add_child(grid)
|
||||
func _draw_surface() -> void:
|
||||
for slot: int in _ability_rects.size():
|
||||
var r: Rect2 = _ability_rects[slot]
|
||||
_surface.draw_style_box(_ability_style[slot], r)
|
||||
var inner := r.grow(-r.size.x * 0.14)
|
||||
if _ability_tex[slot] != null:
|
||||
_draw_icon_fit(_ability_tex[slot], inner)
|
||||
else:
|
||||
_draw_centered_text(_ABILITY_LETTERS[slot], r, 40, _ABILITY_ACCENT[slot])
|
||||
var frac := 0.0
|
||||
if _player != null:
|
||||
frac = clampf(_player.call(&"ability_cooldown_fraction", slot), 0.0, 1.0)
|
||||
if frac > 0.0:
|
||||
var ch := r.size.y * frac
|
||||
_surface.draw_rect(
|
||||
Rect2(r.position.x, r.position.y + r.size.y - ch, r.size.x, ch),
|
||||
Color(0.0, 0.0, 0.0, 0.55))
|
||||
|
||||
for slot: int in 4:
|
||||
grid.add_child(_build_ability_button(slot))
|
||||
_surface.draw_style_box(_menu_style, _menu_rect)
|
||||
_draw_hamburger(_menu_rect)
|
||||
|
||||
if _stick_active:
|
||||
_surface.draw_circle(_origin, _stick_radius, Color(0.0, 0.0, 0.0, 0.20))
|
||||
_surface.draw_arc(
|
||||
_origin, _stick_radius, 0.0, TAU, 48, Color(0.93, 0.88, 0.72, 0.30), 4.0, true)
|
||||
_surface.draw_circle(_knob, _stick_radius * 0.42, Color(1.00, 0.82, 0.32, 0.55))
|
||||
elif not _pinching:
|
||||
_draw_stick_hint()
|
||||
|
||||
if Controls.debug_overlay():
|
||||
_draw_debug()
|
||||
|
||||
|
||||
func _build_ability_button(slot: int) -> Control:
|
||||
var panel := PanelContainer.new()
|
||||
panel.custom_minimum_size = Vector2(96.0, 96.0)
|
||||
panel.add_theme_stylebox_override("panel", _button_style(slot))
|
||||
panel.mouse_filter = Control.MOUSE_FILTER_STOP
|
||||
|
||||
var stack := Control.new()
|
||||
stack.set_anchors_preset(Control.PRESET_FULL_RECT)
|
||||
panel.add_child(stack)
|
||||
|
||||
if ResourceLoader.exists(_ABILITY_ICONS[slot]):
|
||||
var icon := TextureRect.new()
|
||||
icon.texture = load(_ABILITY_ICONS[slot])
|
||||
icon.expand_mode = TextureRect.EXPAND_IGNORE_SIZE
|
||||
icon.stretch_mode = TextureRect.STRETCH_KEEP_ASPECT_CENTERED
|
||||
icon.set_anchors_preset(Control.PRESET_FULL_RECT)
|
||||
icon.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
||||
stack.add_child(icon)
|
||||
else:
|
||||
var lbl := Label.new()
|
||||
lbl.text = _ABILITY_LETTERS[slot]
|
||||
lbl.set_anchors_preset(Control.PRESET_FULL_RECT)
|
||||
lbl.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
||||
lbl.vertical_alignment = VERTICAL_ALIGNMENT_CENTER
|
||||
lbl.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
||||
lbl.add_theme_color_override("font_color", _ABILITY_ACCENT[slot])
|
||||
lbl.add_theme_font_size_override("font_size", 40)
|
||||
stack.add_child(lbl)
|
||||
|
||||
# Cooldown wipe — anchored to the bottom, its top edge driven in _process so it
|
||||
# shrinks away as the ability comes off cooldown (mirrors the desktop HUD tiles).
|
||||
var cd := ColorRect.new()
|
||||
cd.color = Color(0.0, 0.0, 0.0, 0.62)
|
||||
cd.anchor_left = 0.0
|
||||
cd.anchor_right = 1.0
|
||||
cd.anchor_top = 1.0
|
||||
cd.anchor_bottom = 1.0
|
||||
cd.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
||||
stack.add_child(cd)
|
||||
_cd_overlays.append(cd)
|
||||
|
||||
# Fire on press (not release) so abilities feel instant under the thumb.
|
||||
panel.gui_input.connect(_on_ability_input.bind(slot))
|
||||
return panel
|
||||
# A faint "ghost" joystick at rest in the lower-left with a caption, so the movement zone
|
||||
# is discoverable. Breathes gently via _hint_pulse; vanishes the moment the stick is grabbed.
|
||||
func _draw_stick_hint() -> void:
|
||||
var a := 0.16 + 0.12 * (0.5 + 0.5 * sin(_hint_pulse))
|
||||
var c := _stick_hint_center
|
||||
var r := _stick_radius * 0.72
|
||||
_surface.draw_circle(c, r, Color(0.0, 0.0, 0.0, a * 0.45))
|
||||
_surface.draw_arc(c, r, 0.0, TAU, 40, Color(0.93, 0.88, 0.72, a + 0.14), 3.0, true)
|
||||
_surface.draw_circle(c, r * 0.32, Color(1.00, 0.82, 0.32, a + 0.16))
|
||||
var font := ThemeDB.fallback_font
|
||||
if font != null:
|
||||
var txt := "DRAG TO MOVE"
|
||||
var fs := 18
|
||||
var tw := font.get_string_size(txt, HORIZONTAL_ALIGNMENT_LEFT, -1, fs)
|
||||
_surface.draw_string(
|
||||
font, c + Vector2(-tw.x * 0.5, r + 28.0), txt, HORIZONTAL_ALIGNMENT_LEFT, -1, fs,
|
||||
Color(0.93, 0.88, 0.72, a + 0.30))
|
||||
|
||||
|
||||
func _on_ability_input(event: InputEvent, slot: int) -> void:
|
||||
var pressed := false
|
||||
if event is InputEventScreenTouch:
|
||||
pressed = (event as InputEventScreenTouch).pressed
|
||||
elif event is InputEventMouseButton:
|
||||
var mb := event as InputEventMouseButton
|
||||
pressed = mb.pressed and mb.button_index == MOUSE_BUTTON_LEFT
|
||||
if pressed and _player != null:
|
||||
_player.call(&"try_activate_ability", slot)
|
||||
func _draw_icon_fit(tex: Texture2D, box: Rect2) -> void:
|
||||
var ts := tex.get_size()
|
||||
if ts.x <= 0.0 or ts.y <= 0.0:
|
||||
return
|
||||
var scale := minf(box.size.x / ts.x, box.size.y / ts.y)
|
||||
var ds := ts * scale
|
||||
_surface.draw_texture_rect(tex, Rect2(box.position + (box.size - ds) * 0.5, ds), false)
|
||||
|
||||
|
||||
func _button_style(slot: int) -> StyleBoxFlat:
|
||||
func _draw_centered_text(text: String, box: Rect2, size: int, color: Color) -> void:
|
||||
var font := ThemeDB.fallback_font
|
||||
if font == null:
|
||||
return
|
||||
var tw := font.get_string_size(text, HORIZONTAL_ALIGNMENT_LEFT, -1, size)
|
||||
var pos := box.position + (box.size - tw) * 0.5 + Vector2(0.0, tw.y * 0.35)
|
||||
_surface.draw_string(font, pos, text, HORIZONTAL_ALIGNMENT_LEFT, -1, size, color)
|
||||
|
||||
|
||||
# Three stacked bars — a "☰" glyph drawn by hand, since the fallback font that ships with
|
||||
# the web build has no U+2630 and renders it as tofu / a codepoint number.
|
||||
func _draw_hamburger(r: Rect2) -> void:
|
||||
var col := Color(1.00, 0.78, 0.22)
|
||||
var bw := r.size.x * 0.5
|
||||
var bh := maxf(3.0, r.size.y * 0.09)
|
||||
var x := r.position.x + (r.size.x - bw) * 0.5
|
||||
var cy := r.position.y + r.size.y * 0.5
|
||||
var gap := r.size.y * 0.22
|
||||
for i: int in [-1, 0, 1]:
|
||||
_surface.draw_rect(Rect2(x, cy + i * gap - bh * 0.5, bw, bh), col)
|
||||
|
||||
|
||||
func _draw_debug() -> void:
|
||||
var font := ThemeDB.fallback_font
|
||||
if font == null:
|
||||
return
|
||||
var players := get_tree().get_nodes_in_group(&"player")
|
||||
var mats := get_tree().get_nodes_in_group(&"matador")
|
||||
var lines := [
|
||||
"GPU: %s" % RenderingServer.get_video_adapter_name(),
|
||||
"API: %s" % RenderingServer.get_video_adapter_api_version(),
|
||||
"method=%s web=%s touch_ui=%s" % [
|
||||
ProjectSettings.get_setting("rendering/renderer/rendering_method", "?"),
|
||||
OS.has_feature("web"), Controls.use_touch_ui()],
|
||||
"bull: %s" % _node_report(players),
|
||||
"matador(%d): %s" % [mats.size(), _node_report(mats)],
|
||||
"events=%d last=%s touches=%d stick=%s" % [
|
||||
_dbg_events, str(_dbg_last_pos.round()), _touches.size(), _stick_active],
|
||||
]
|
||||
var fs := 18
|
||||
var line_h := 24.0
|
||||
var w := 0.0
|
||||
for line: String in lines:
|
||||
w = maxf(w, font.get_string_size(line, HORIZONTAL_ALIGNMENT_LEFT, -1, fs).x)
|
||||
_surface.draw_rect(
|
||||
Rect2(10.0, 34.0, w + 16.0, line_h * lines.size() + 12.0), Color(0.0, 0.0, 0.0, 0.62))
|
||||
var y := 34.0 + 22.0
|
||||
for line: String in lines:
|
||||
_surface.draw_string(
|
||||
font, Vector2(18.0, y), line, HORIZONTAL_ALIGNMENT_LEFT, -1, fs,
|
||||
Color(1.0, 1.0, 0.3))
|
||||
y += line_h
|
||||
|
||||
|
||||
# One-line "does this character exist / is it drawable / where is it" report for the debug
|
||||
# overlay, so an invisible bull/matador on-device can be pinned to spawn vs. position vs.
|
||||
# GPU-draw failure.
|
||||
func _node_report(nodes: Array) -> String:
|
||||
if nodes.is_empty():
|
||||
return "NONE"
|
||||
var n := nodes[0] as Node3D
|
||||
if n == null:
|
||||
return "not Node3D"
|
||||
return "vis=%s pos=%s" % [n.is_visible_in_tree(), str(n.global_position.round())]
|
||||
|
||||
|
||||
func _button_style(accent: Color) -> StyleBoxFlat:
|
||||
var s := StyleBoxFlat.new()
|
||||
s.bg_color = Color(0.10, 0.07, 0.03, 0.80)
|
||||
s.set_corner_radius_all(18)
|
||||
s.corner_detail = 6
|
||||
s.set_border_width_all(3)
|
||||
s.border_color = _ABILITY_ACCENT[slot]
|
||||
s.border_color = accent
|
||||
return s
|
||||
|
||||
|
||||
# ── Menu button ──────────────────────────────────────────────────────────────
|
||||
# Top-right "☰" — the touch stand-in for the keyboard's Esc-to-menu, so a phone
|
||||
# player has a way out of a run.
|
||||
|
||||
func _build_menu_button() -> void:
|
||||
var btn := Button.new()
|
||||
btn.text = "☰"
|
||||
btn.custom_minimum_size = Vector2(56.0, 56.0)
|
||||
btn.focus_mode = Control.FOCUS_NONE
|
||||
btn.anchor_left = 1.0
|
||||
btn.anchor_right = 1.0
|
||||
btn.grow_horizontal = Control.GROW_DIRECTION_BEGIN
|
||||
btn.offset_left = -72.0
|
||||
btn.offset_top = 16.0
|
||||
btn.offset_right = -16.0
|
||||
btn.offset_bottom = 72.0
|
||||
var style := StyleBoxFlat.new()
|
||||
style.bg_color = Color(0.10, 0.07, 0.03, 0.80)
|
||||
style.set_corner_radius_all(12)
|
||||
style.set_border_width_all(2)
|
||||
style.border_color = Color(1.00, 0.78, 0.22, 0.8)
|
||||
btn.add_theme_stylebox_override("normal", style)
|
||||
btn.add_theme_stylebox_override("hover", style)
|
||||
btn.add_theme_stylebox_override("pressed", style)
|
||||
btn.add_theme_color_override("font_color", Color(1.00, 0.78, 0.22))
|
||||
btn.add_theme_font_size_override("font_size", 28)
|
||||
btn.pressed.connect(_return_to_menu)
|
||||
_root.add_child(btn)
|
||||
|
||||
# ── Menu ──────────────────────────────────────────────────────────────────────
|
||||
|
||||
func _return_to_menu() -> void:
|
||||
get_tree().paused = false
|
||||
@@ -282,34 +460,26 @@ func _return_to_menu() -> void:
|
||||
get_tree().change_scene_to_file("res://MainMenu.tscn")
|
||||
|
||||
|
||||
# ── Layout & lifecycle ──────────────────────────────────────────────────────
|
||||
# ── Lifecycle ─────────────────────────────────────────────────────────────────
|
||||
|
||||
func _relayout() -> void:
|
||||
var vp := get_viewport().get_visible_rect().size
|
||||
# Left half is the joystick zone; base radius scales with the shorter screen edge.
|
||||
_stick.position = Vector2.ZERO
|
||||
_stick.size = Vector2(vp.x * 0.5, vp.y)
|
||||
_stick_radius = clampf(minf(vp.x, vp.y) * 0.16, 80.0, 150.0)
|
||||
|
||||
|
||||
func _process(_delta: float) -> void:
|
||||
var active := Controls.use_touch_ui()
|
||||
# The game-over / pause screen owns the display when paused — stand down and drop
|
||||
# any held movement so the bull doesn't coast on a stuck joystick.
|
||||
if not active or get_tree().paused:
|
||||
if _root.visible:
|
||||
_root.visible = false
|
||||
func _process(delta: float) -> void:
|
||||
_hint_pulse = fmod(_hint_pulse + delta * 2.2, TAU)
|
||||
var active := Controls.use_touch_ui() and not get_tree().paused
|
||||
# The game-over / pause screen owns the display when paused — stand down and drop any
|
||||
# held movement so the bull doesn't coast on a stuck joystick.
|
||||
if not active:
|
||||
if _surface.visible:
|
||||
_surface.visible = false
|
||||
if _stick_active:
|
||||
_end_stick()
|
||||
_touches.clear()
|
||||
_touch_owner.clear()
|
||||
_pinching = false
|
||||
return
|
||||
_root.visible = true
|
||||
|
||||
_surface.visible = true
|
||||
if _player == null:
|
||||
var players := get_tree().get_nodes_in_group(&"player")
|
||||
if not players.is_empty():
|
||||
_player = players[0]
|
||||
return
|
||||
|
||||
for slot: int in _cd_overlays.size():
|
||||
var fraction: float = _player.call(&"ability_cooldown_fraction", slot)
|
||||
_cd_overlays[slot].anchor_top = 1.0 - clampf(fraction, 0.0, 1.0)
|
||||
_surface.queue_redraw() # cooldown overlays animate every frame
|
||||
|
||||
Reference in New Issue
Block a user