229 lines
7.9 KiB
GDScript
229 lines
7.9 KiB
GDScript
extends Node
|
|
|
|
## NEO-24 (E1M3-02): client tab-target + lock UI synced to server (NEO-23 `TargetState` v1).
|
|
##
|
|
## Flow:
|
|
## - `request_sync_from_server()` → `GET …/target` returns `PlayerTargetStateResponse` v1.
|
|
## - `request_tab_next()` picks the next id from `PrototypeTargetConstants.ORDERED_IDS`
|
|
## (first id if no lock) and POSTs `TargetSelectRequest` v1.
|
|
## - `request_select_target_id(id)` POSTs a specific id.
|
|
## - `request_clear_target()` POSTs with `targetId` omitted (NEO-23 clear rule).
|
|
## - Movement-triggered refresh: while a lock is held, `on_authoritative_position_snap(...)`
|
|
## fires a throttled `GET` so `validity` flips to `out_of_range` after locomotion without
|
|
## duplicating server radius math on the client (plan Decision 2).
|
|
##
|
|
## Not an `HTTPRequest` subclass — tests inject a `Node` exposing `request()` +
|
|
## `request_completed` (same pattern as `position_authority_client.gd`).
|
|
|
|
signal target_state_changed(state: Dictionary)
|
|
|
|
enum Phase { IDLE, GET, POST_SELECT }
|
|
|
|
const PrototypeTargetConstants := preload("res://scripts/prototype_target_constants.gd")
|
|
|
|
## Cooldown between movement-triggered refresh GETs. Drops further snaps inside the window so
|
|
## one `move-stream` burst does not produce one GET per snap.
|
|
const _REFRESH_COOLDOWN_MSEC: int = 250
|
|
|
|
@export var base_url: String = "http://127.0.0.1:5253"
|
|
@export var dev_player_id: String = "dev-local-1"
|
|
|
|
var _http: Node
|
|
var _busy: bool = false
|
|
var _phase: Phase = Phase.IDLE
|
|
|
|
## Last acknowledged state from the server. Mirrors `PlayerTargetStateResponse` v1:
|
|
## `schemaVersion` (int), `playerId` (String), `lockedTargetId` (String or `null`),
|
|
## `validity` (String: `none` | `ok` | `out_of_range` | `invalid_target`),
|
|
## `sequence` (int). POST responses additionally carry `selectionApplied` (bool) and an optional
|
|
## `reasonCode` (String).
|
|
var _state: Dictionary = {}
|
|
|
|
## `-_REFRESH_COOLDOWN_MSEC` so the first snap is never blocked by the window on boot.
|
|
var _last_refresh_msec: int = -_REFRESH_COOLDOWN_MSEC
|
|
|
|
|
|
func _create_http_request() -> Node:
|
|
return HTTPRequest.new()
|
|
|
|
|
|
func _ready() -> void:
|
|
_http = _create_http_request()
|
|
add_child(_http)
|
|
if _http is HTTPRequest:
|
|
(_http as HTTPRequest).timeout = 30.0
|
|
@warning_ignore("unsafe_method_access")
|
|
_http.request_completed.connect(_on_request_completed)
|
|
|
|
|
|
## Matches `interaction_request_client.gd`: `_input` is more reliable than `_unhandled_input`
|
|
## inside the embedded Game dock / focus quirks. Tab is captured before UI focus navigation,
|
|
## which is fine while the prototype HUD has no focusable controls.
|
|
func _input(event: InputEvent) -> void:
|
|
if event.is_action_pressed("target_tab"):
|
|
request_tab_next()
|
|
elif event.is_action_pressed("target_clear"):
|
|
request_clear_target()
|
|
|
|
|
|
func request_sync_from_server() -> void:
|
|
if _busy:
|
|
return
|
|
_busy = true
|
|
_phase = Phase.GET
|
|
_last_refresh_msec = Time.get_ticks_msec()
|
|
var url := "%s/game/players/%s/target" % [_base_root(), _player_path_segment()]
|
|
var err: Error = _http.request(url)
|
|
if err != OK:
|
|
push_warning("TargetSelectionClient: GET failed to start (%s)" % err)
|
|
_busy = false
|
|
_phase = Phase.IDLE
|
|
|
|
|
|
func request_tab_next() -> void:
|
|
var current: Variant = _state.get("lockedTargetId", null)
|
|
var next_id: String = PrototypeTargetConstants.next_id_after(current)
|
|
if next_id.is_empty():
|
|
return
|
|
request_select_target_id(next_id)
|
|
|
|
|
|
func request_select_target_id(target_id: String) -> void:
|
|
var trimmed := target_id.strip_edges()
|
|
if trimmed.is_empty():
|
|
push_warning("TargetSelectionClient: refusing empty targetId; use request_clear_target()")
|
|
return
|
|
_post_select({"schemaVersion": 1, "targetId": trimmed})
|
|
|
|
|
|
func request_clear_target() -> void:
|
|
# NEO-23: omit `targetId` to clear. JSON `null` also works; omission keeps the body minimal.
|
|
_post_select({"schemaVersion": 1})
|
|
|
|
|
|
## Connected to `PositionAuthorityClient.authoritative_position_received` in `main.gd`.
|
|
## Boot is naturally skipped because no lock is held yet; once a lock exists, subsequent
|
|
## snaps fire a refresh GET subject to a cooldown so bursts collapse to one GET.
|
|
func on_authoritative_position_snap(_world: Vector3, apply_as_snap: bool) -> void:
|
|
if not apply_as_snap:
|
|
return
|
|
if not _has_lock():
|
|
return
|
|
if _busy:
|
|
return
|
|
var now_msec: int = Time.get_ticks_msec()
|
|
if now_msec - _last_refresh_msec < _REFRESH_COOLDOWN_MSEC:
|
|
return
|
|
request_sync_from_server()
|
|
|
|
|
|
func cached_state() -> Dictionary:
|
|
return _state.duplicate()
|
|
|
|
|
|
func _has_lock() -> bool:
|
|
if _state.is_empty():
|
|
return false
|
|
var v: Variant = _state.get("lockedTargetId", null)
|
|
return v is String and not (v as String).is_empty()
|
|
|
|
|
|
func _post_select(payload: Dictionary) -> void:
|
|
if _busy:
|
|
return
|
|
_busy = true
|
|
_phase = Phase.POST_SELECT
|
|
var url := "%s/game/players/%s/target/select" % [_base_root(), _player_path_segment()]
|
|
var body := JSON.stringify(payload)
|
|
var headers := PackedStringArray(["Content-Type: application/json"])
|
|
var err: Error = _http.request(url, headers, HTTPClient.METHOD_POST, body)
|
|
if err != OK:
|
|
push_warning("TargetSelectionClient: POST failed to start (%s)" % err)
|
|
_busy = false
|
|
_phase = Phase.IDLE
|
|
|
|
|
|
func _base_root() -> String:
|
|
return base_url.strip_edges().rstrip("/")
|
|
|
|
|
|
func _player_path_segment() -> String:
|
|
# ASCII-safe ids (e.g. `dev-local-1`); percent-encode if ids gain reserved URL characters.
|
|
return dev_player_id.strip_edges()
|
|
|
|
|
|
func _on_request_completed(
|
|
_result: int, response_code: int, _headers: PackedStringArray, body: PackedByteArray
|
|
) -> void:
|
|
var phase: Phase = _phase
|
|
_busy = false
|
|
_phase = Phase.IDLE
|
|
|
|
if _result != HTTPRequest.RESULT_SUCCESS:
|
|
push_warning("TargetSelectionClient: HTTP failed (result=%s)" % _result)
|
|
return
|
|
|
|
var text := body.get_string_from_utf8()
|
|
var parsed: Variant = JSON.parse_string(text)
|
|
if not parsed is Dictionary:
|
|
if response_code != 200:
|
|
push_warning("TargetSelectionClient: HTTP %s non-JSON body" % response_code)
|
|
return
|
|
var data: Dictionary = parsed
|
|
|
|
match phase:
|
|
Phase.GET:
|
|
if response_code == 200:
|
|
_update_state_from_get(data)
|
|
Phase.POST_SELECT:
|
|
# Server includes authoritative `targetState` on 200 (apply and denial). 400 / 404
|
|
# bodies may lack it — swallow quietly; `_state` keeps last-good.
|
|
if response_code == 200:
|
|
_update_state_from_post(data)
|
|
_:
|
|
pass
|
|
|
|
|
|
func _update_state_from_get(data: Dictionary) -> void:
|
|
var state := _extract_target_state_fields(data)
|
|
if state.is_empty():
|
|
return
|
|
_state = state
|
|
target_state_changed.emit(_state.duplicate())
|
|
|
|
|
|
func _update_state_from_post(data: Dictionary) -> void:
|
|
var target_state_variant: Variant = data.get("targetState", null)
|
|
if not target_state_variant is Dictionary:
|
|
push_warning("TargetSelectionClient: POST 200 missing targetState")
|
|
return
|
|
var state := _extract_target_state_fields(target_state_variant as Dictionary)
|
|
if state.is_empty():
|
|
return
|
|
state["selectionApplied"] = bool(data.get("selectionApplied", false))
|
|
var reason_variant: Variant = data.get("reasonCode", null)
|
|
if reason_variant is String and not (reason_variant as String).is_empty():
|
|
state["reasonCode"] = reason_variant as String
|
|
_state = state
|
|
target_state_changed.emit(_state.duplicate())
|
|
|
|
|
|
## Shape-only parse of the v1 target state payload (works for GET body and POST echo).
|
|
## `lockedTargetId` is normalized to either a non-empty [String] or Variant [code]null[/code].
|
|
func _extract_target_state_fields(data: Dictionary) -> Dictionary:
|
|
if not data.has("validity"):
|
|
return {}
|
|
var out: Dictionary = {}
|
|
out["schemaVersion"] = int(data.get("schemaVersion", 1))
|
|
var pid_variant: Variant = data.get("playerId", "")
|
|
out["playerId"] = (pid_variant as String) if pid_variant is String else ""
|
|
var locked_variant: Variant = data.get("lockedTargetId", null)
|
|
if locked_variant is String and not (locked_variant as String).is_empty():
|
|
out["lockedTargetId"] = locked_variant as String
|
|
else:
|
|
out["lockedTargetId"] = null
|
|
var validity_variant: Variant = data.get("validity", "none")
|
|
out["validity"] = (validity_variant as String) if validity_variant is String else "none"
|
|
out["sequence"] = int(data.get("sequence", 0))
|
|
return out
|