# QuestDialog (P7) —— 渲染 GC_SCRIPT 的 NPC 对话（EventManager 脚本，客户端只渲染）。
#
#   var qd := preload("res://ui/quest_dialog.gd").new()
#   add_child(qd)
#   qd.setup(m2client, canvas_parent)
#
# 脚本格式（`CPythonEventManager`）：纯文本 + `[命令 arg(值)]` token 交错。
#   [ENTER]            换行
#   [CLEAR]            清空
#   [NEXT] / [DONE]    「继续 / 关闭」按钮 -> M2Client.script_answer(255)
#   [QUESTION arg("是") arg("否")]  选项按钮 -> script_answer(0..N-1)
#   [LETTER value("...")]  追加文本（旧写法）
#   [INPUT]            显示文本输入框，提交 -> M2Client.quest_input()
#   [SELECT_ITEM]      要求从背包选一颗魔石 -> 发 select_item_requested 信号（打开 SelectItemUI）
#   [CONFIRM_WAIT] 等：本版忽略
#
# quest_confirm_ask（GC_QUEST_CONFIRM）也在这里弹 是/否 -> quest_confirm(yes, pid)。
extends Node

const UiAssets = preload("res://ui/ui_assets.gd")

signal opened()
signal closed()
# EventManager EVENT_TYPE_SELECT_ITEM —— 对应 interfacemodule.BINARY_OpenSelectItemWindow
signal select_item_requested()
# EventManager side effects that are owned by the interface layer in ClientVS22.
# Keeping them as signals makes the dialog usable with both the real client and
# headless fixtures without smuggling minimap/camera state into the parser.
signal quest_button_received(index: int, title: String, icon_type: String, icon_name: String)
signal quest_button_cleared(index: int)
signal map_signal_added(x: float, y: float)
signal map_signals_cleared()
signal atlas_center_requested(x: int, y: int)
signal camera_event_requested(kind: String, values: Array)
signal fade_event_requested(kind: String, speed: float)
signal camera_event_requested_full(kind: String, setting: Dictionary, blendtime: float)
signal fade_event_requested_full(kind: String, speed: float)
signal done_event()

var client: Node
var proto: Node
var _assets_root := ""
var _root: Control
var _text: RichTextLabel
var _btnrow: VBoxContainer
var _image_layer: Control
var _confirm_pid := 0
var _confirm_wait := false
var _active_set
var _active_commands: Array = []
var _active_cursor := 0
var _active_script := false

signal dungeon_result_requested(result: Dictionary)

func setup(m2client: Node, parent: Node, proto_node: Node = null, assets_root := "") -> void:
	client = m2client
	proto = proto_node
	_assets_root = assets_root if assets_root != "" else AssetRoot.path()
	set_process_unhandled_input(true)
	set_process(true)
	_build(parent)
	if client.has_signal("script_dialog"):
		client.script_dialog.connect(_on_script)
	if client.has_signal("quest_confirm_ask"):
		client.quest_confirm_ask.connect(_on_confirm)

func set_proto(proto_node: Node) -> void:
	# Proto is created after the dialog in GameScene because item/mob loading is
	# expensive.  Keep the dialog usable before that point, then resolve future
	# [ITEM]/[MOB] tags against the real tables.
	proto = proto_node

func is_open() -> bool:
	return _root != null and _root.visible

func _process(delta: float) -> void:
	if not _active_script or _active_set == null:
		return
	# The first headless frame may report a zero delta.  ClientVS22 still runs
	# one UpdateEventSet tick, so use one nominal 60 FPS frame as the floor.
	_process_active(maxf(delta * 1000.0, 16.0))

# Deterministic entry point used by the frame loop and headless tests.  The
# argument is milliseconds because EventManager's lLastDelayTime/lWaitingTime
# are millisecond values in ClientVS22.
func process_events(elapsed_ms: float) -> void:
	if _active_script and _active_set != null:
		_process_active(maxf(0.0, elapsed_ms))

func begin_script(src: String) -> void:
	_active_set = EventSet.new()
	_active_set.init_event_set()
	_active_commands = _tokenize(src)
	_active_cursor = 0
	_active_script = true
	# RegisterEventSetFromString replaces a leading RUN_CINEMA event set with
	# the referenced .msc file. Keep the signal for the presentation layer and
	# load the event text when the loose asset is available.
	if not _active_commands.is_empty() and String(_active_commands[0].get("literal", "")) == "" \
			and String(_active_commands[0].get("name", "")).to_upper().trim_prefix("/") == "RUN_CINEMA":
		var cinema := _arg_s(String(_active_commands[0].get("tok", "")), "value")
		if cinema != "":
			cinema_requested.emit(cinema)
			var cinema_text := _read_script_file(cinema)
			if cinema_text != "":
				_active_commands = _tokenize(cinema_text)
			else:
				# No local .msc: keep the empty event set alive so the caller can
				# show its own cinema player, but do not re-process RUN_CINEMA.
				_active_commands = []
	_present_event_set(_active_set)
	_root.visible = true
	opened.emit()
	# Start the same nominal first tick immediately.  This keeps the dialog
	# responsive even when a SceneTree caller resumes before child _process()
	# callbacks (notably in headless fixtures).
	_process_active(16.0)

func _read_script_file(vpath: String) -> String:
	var rel := vpath.replace("\\", "/")
	if rel.length() >= 2 and rel[1] == ":":
		rel = rel.substr(2)
	rel = rel.lstrip("/")
	var candidates: Array[String] = []
	if _assets_root != "":
		candidates.append(_assets_root.path_join(rel))
		var resolved := UiAssets._resolve(_assets_root, rel)
		if resolved != "":
			candidates.append(resolved)
	for path in candidates:
		if FileAccess.file_exists(path):
			return FileAccess.get_file_as_string(path)
	return ""

func skip() -> void:
	if not _active_script or _active_set == null:
		return
	# CPythonEventManager::Skip: an input lock is released; otherwise the
	# current delay is forced to expire and the next command is consumed.
	if _active_set.isLock:
		_active_set.lLastDelayTime = 0
		_active_set.isLock = false
	else:
		_active_set.lLastDelayTime = -1
	_process_active(0.0)

func end_event_process() -> void:
	if _active_set != null:
		_active_set.isWaitFlag = false

func _process_active(elapsed_ms: float) -> void:
	var remaining := elapsed_ms
	var forced_step: bool = _active_set.lLastDelayTime < 0
	if forced_step:
		_active_set.lLastDelayTime = 0
	while _active_script and _active_set != null:
		if _active_set.isConfirmWait:
			if int(Time.get_ticks_msec() / 1000) >= _active_set.iConfirmEndTime:
				_active_set.isConfirmWait = false
				_active_set.iConfirmEndTime = 0
				_confirm_wait = false
				if client and client.has_method("quest_cancel"):
					client.quest_cancel()
				_active_script = false
				close()
			else:
				_present_event_set(_active_set)
			return
		if _active_set.isWaitFlag or _active_set.isLock:
			_present_event_set(_active_set)
			return
		if _active_set.lLastDelayTime > 0:
			if remaining <= 0.0:
				return
			var wait := float(_active_set.lLastDelayTime)
			if remaining < wait:
				_active_set.lLastDelayTime -= int(remaining)
				return
			_active_set.lLastDelayTime = 0
			remaining -= wait
		if _active_cursor >= _active_commands.size():
			_active_script = false
			_active_set.isLock = true
			_present_event_set(_active_set)
			return
		var command: Dictionary = _active_commands[_active_cursor]
		_active_cursor += 1
		_process_event_set(_active_set, command)
		_emit_runtime_side_effect(command, _active_set)
		_present_event_set(_active_set)
		forced_step = false
		if _active_set.isWaitFlag or _active_set.isLock or _active_set.isConfirmWait:
			return
		if remaining <= 0.0:
			return

func _finish_runtime() -> void:
	_active_script = false
	_active_commands.clear()
	_active_cursor = 0

func _emit_runtime_side_effect(command: Dictionary, es: EventSet) -> void:
	var idx := _get_script_event_index(String(command.get("name", "")))
	if not idx.ok:
		return
	var tok := String(command.get("tok", ""))
	match int(idx.type):
		EVT_SELECT_ITEM:
			select_item_requested.emit()
		EVT_QUEST_BUTTON:
			if not es.quest_buttons.is_empty():
				var q: Dictionary = es.quest_buttons.back()
				quest_button_received.emit(int(q.get("index", -1)), String(q.get("title", "")),
						String(q.get("icon_type", "")), String(q.get("icon_name", "")))
		EVT_QUEST_BUTTON_CLOSE:
			quest_button_cleared.emit(_arg_i(tok, "idx", 0))
		EVT_ADD_MAP_SIGNAL:
			map_signal_added.emit(_arg_f(tok, "x", 0), _arg_f(tok, "y", 1))
		EVT_CLEAR_MAP_SIGNAL:
			map_signals_cleared.emit()
		EVT_SET_CENTER_MAP_POSITION:
			atlas_center_requested.emit(_arg_i(tok, "x", 0), _arg_i(tok, "y", 1))
		EVT_SET_CAMERA, EVT_BLEND_CAMERA, EVT_RESTORE_CAMERA:
			var camera: Dictionary = es.camera_events.back() if not es.camera_events.is_empty() else {}
			var kind := String(camera.get("kind", ""))
			camera_event_requested.emit(kind, camera.get("values", []))
			camera_event_requested_full.emit(kind, camera.get("setting", {}).duplicate(true),
				float(camera.get("blendtime", 0.0)))
		EVT_FADE_OUT, EVT_FADE_IN, EVT_WHITE_OUT, EVT_WHITE_IN:
			var fade: Dictionary = es.fade_events.back() if not es.fade_events.is_empty() else {}
			var fade_kind := String(fade.get("kind", ""))
			var fade_speed := float(fade.get("speed", 0.0))
			fade_event_requested.emit(fade_kind, fade_speed)
			fade_event_requested_full.emit(fade_kind, fade_speed)
		EVT_DUNGEON_RESULT:
			dungeon_result_requested.emit(es.dungeon_result.duplicate())
		EVT_END_CONFIRM_WAIT:
			_confirm_wait = false
		_:
			pass

func _present_event_set(es: EventSet) -> void:
	var parsed := _event_set_result(es)
	if parsed.body.strip_edges() == "" and parsed.choices.is_empty() and not parsed.has_input \
			and not parsed.confirm_wait and not _active_script:
		close()
		return
	_text.text = parsed.body
	_text.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER if parsed.text_centered else HORIZONTAL_ALIGNMENT_LEFT
	if parsed.window_size.size() >= 2:
		var width := maxi(320, int(parsed.window_size[0]))
		var height := maxi(220, int(parsed.window_size[1]))
		_root.size = Vector2(width, height)
		_text.size = Vector2(width - 32, height - 100)
		_btnrow.position = Vector2(16, height - 78)
		_btnrow.custom_minimum_size = Vector2(width - 32, 0)
	_confirm_wait = parsed.confirm_wait
	_render_images(parsed.images, parsed.title_image)
	_fill_buttons(parsed.choices, parsed.has_next, parsed.has_input, parsed.confirm_wait,
		String(parsed.get("next_button_type", "")))

# --- 收 GC_SCRIPT ------------------------------------------------------

func _on_script(_skin: int, text: String) -> void:
	begin_script(text)

func _emit_side_effects(parsed: Dictionary) -> void:
	if parsed.has_select_item:
		select_item_requested.emit()
	for quest in parsed.quest_buttons:
		quest_button_received.emit(int(quest.get("index", -1)), String(quest.get("title", "")),
			String(quest.get("icon_type", "")), String(quest.get("icon_name", "")))
	for index in parsed.quest_button_closes:
		quest_button_cleared.emit(int(index))
	for point in parsed.map_signals:
		map_signal_added.emit(float(point.x), float(point.y))
	if parsed.clear_map_signals:
		map_signals_cleared.emit()
	if parsed.atlas_center.size() >= 2:
		atlas_center_requested.emit(int(parsed.atlas_center[0]), int(parsed.atlas_center[1]))
	for camera in parsed.camera_events:
		var kind := String(camera.get("kind", ""))
		camera_event_requested.emit(kind, camera.get("values", []))
		camera_event_requested_full.emit(kind, camera.get("setting", {}).duplicate(true),
			float(camera.get("blendtime", 0.0)))
	for fade in parsed.fade_events:
		var fade_kind := String(fade.get("kind", ""))
		var fade_speed := float(fade.get("speed", 0.0))
		fade_event_requested.emit(fade_kind, fade_speed)
		fade_event_requested_full.emit(fade_kind, fade_speed)
	if String(parsed.get("cinema_file", "")) != "":
		cinema_requested.emit(String(parsed.cinema_file))

func _on_confirm(msg: String, _timeout: int, request_pid: int) -> void:
	_finish_runtime()
	_confirm_pid = request_pid
	_text.text = msg
	_fill_confirm()
	_root.visible = true
	opened.emit()

func close() -> void:
	_finish_runtime()
	if _root:
		_root.visible = false
	_confirm_wait = false
	closed.emit()

func _unhandled_input(event: InputEvent) -> void:
	if not is_open() or not (event is InputEventKey):
		return
	var key := event as InputEventKey
	if key.pressed and not key.echo and key.keycode == KEY_ESCAPE:
		# The legacy client sends QUEST_CANCEL when the active script is dismissed
		# with Escape; ordinary answer buttons continue to use SCRIPT_ANSWER.
		if _active_script:
			skip()
			get_viewport().set_input_as_handled()
			return
		if client and client.has_method("quest_cancel"):
			client.quest_cancel()
		close()
		get_viewport().set_input_as_handled()

# --- 脚本解析（CPythonEventManager 1:1）----------------------------------
#
# 参照 REF/UserInterface/PythonEventManager.{h,cpp}：
#   · EVENT_TYPE_MAP        —— EventTypeMap（PythonEventManager.cpp:1148 起 42 条）
#   · _get_script_event_index —— GetScriptEventIndex（:1093，前导 '/' = EVENT_POSITION_END）
#   · EventSet              —— SEventSet（PythonEventManager.h:98，字段名保持一致）
#   · _process_event_set    —— ProcessEventSet（:377 的 switch 逐 case 对拷）
#   · EventSet.insert_line  —— __InsertLine（:976）
#   · EventSet.clear_line   —— ClearLine（:953）
#   · _make_question        —— MakeQuestion（:884）
#   · _make_next_button 效果 —— MakeNextButton（:878，本 POC 只置 has_next / iAdjustLine）
#
# 网络 GC_SCRIPT 里的裸文本被折成合成 LETTER（is_raw=true，跳过 iRestrictedCharacterCount
# 的 30 字断行——reference 脚本只有显式 [LETTER]，裸文本是本客户端的扩展，逐字符断句会
# 破坏服务器写好的句子）。
#
# EventSet 现在由 _process_active 按 ClientVS22::UpdateEventSet 的毫秒延迟逐步消费；
# parse_script() 仍保留为离线兼容接口，用于一次性检查整个脚本的最终状态。

signal cinema_requested(filename: String)

enum {
	EVT_LETTER, EVT_COLOR, EVT_DELAY, EVT_ENTER, EVT_WAIT, EVT_CLEAR, EVT_QUESTION,
	EVT_NEXT, EVT_DONE,
	EVT_LEFT_IMAGE, EVT_TOP_IMAGE, EVT_BACKGROUND_IMAGE, EVT_IMAGE,
	EVT_ADD_MAP_SIGNAL, EVT_CLEAR_MAP_SIGNAL, EVT_SET_MESSAGE_POSITION,
	EVT_ADJUST_MESSAGE_POSITION, EVT_SET_CENTER_MAP_POSITION,
	EVT_QUEST_BUTTON, EVT_QUEST_BUTTON_CLOSE,
	EVT_SLEEP, EVT_SET_CAMERA, EVT_BLEND_CAMERA, EVT_RESTORE_CAMERA,
	EVT_FADE_OUT, EVT_FADE_IN, EVT_WHITE_OUT, EVT_WHITE_IN,
	EVT_CLEAR_TEXT, EVT_TEXT_HORIZONTAL_ALIGN_CENTER, EVT_TITLE_IMAGE,
	EVT_RUN_CINEMA, EVT_DUNGEON_RESULT,
	EVT_ITEM_NAME, EVT_MONSTER_NAME,
	EVT_COLOR256, EVT_WINDOW_SIZE,
	EVT_INPUT, EVT_CONFIRM_WAIT, EVT_END_CONFIRM_WAIT,
	EVT_INSERT_IMAGE, EVT_SELECT_ITEM,
}

# EventTypeMap（PythonEventManager.cpp:1148-1207）。键即脚本 tag，前导 '/' 由
# _get_script_event_index 剥离后再查表。
const EVENT_TYPE_MAP := {
	"LETTER": EVT_LETTER, "COLOR": EVT_COLOR, "DELAY": EVT_DELAY, "ENTER": EVT_ENTER,
	"WAIT": EVT_WAIT, "CLEAR": EVT_CLEAR, "QUESTION": EVT_QUESTION, "NEXT": EVT_NEXT, "DONE": EVT_DONE,
	"LEFTIMAGE": EVT_LEFT_IMAGE, "TOPIMAGE": EVT_TOP_IMAGE, "BGIMAGE": EVT_BACKGROUND_IMAGE, "IMAGE": EVT_IMAGE,
	"ADDMAPSIGNAL": EVT_ADD_MAP_SIGNAL, "CLEARMAPSIGNAL": EVT_CLEAR_MAP_SIGNAL,
	"SETMSGPOS": EVT_SET_MESSAGE_POSITION, "ADJMSGPOS": EVT_ADJUST_MESSAGE_POSITION,
	"SETCMAPPOS": EVT_SET_CENTER_MAP_POSITION,
	"QUESTBUTTON": EVT_QUEST_BUTTON, "QUESTBUTTON_CLOSE": EVT_QUEST_BUTTON_CLOSE,
	"SLEEP": EVT_SLEEP, "SET_CAMERA": EVT_SET_CAMERA, "BLEND_CAMERA": EVT_BLEND_CAMERA,
	"RESTORE_CAMERA": EVT_RESTORE_CAMERA, "FADE_OUT": EVT_FADE_OUT, "FADE_IN": EVT_FADE_IN,
	"WHITE_OUT": EVT_WHITE_OUT, "WHITE_IN": EVT_WHITE_IN, "CLEAR_TEXT": EVT_CLEAR_TEXT,
	"TEXT_HORIZONTAL_ALIGN_CENTER": EVT_TEXT_HORIZONTAL_ALIGN_CENTER, "TITLE_IMAGE": EVT_TITLE_IMAGE,
	"RUN_CINEMA": EVT_RUN_CINEMA, "DUNGEON_RESULT": EVT_DUNGEON_RESULT,
	"ITEM": EVT_ITEM_NAME, "MOB": EVT_MONSTER_NAME,
	"COLOR256": EVT_COLOR256, "WINDOW_SIZE": EVT_WINDOW_SIZE,
	"INPUT": EVT_INPUT, "CONFIRM_WAIT": EVT_CONFIRM_WAIT, "END_CONFIRM_WAIT": EVT_END_CONFIRM_WAIT,
	"INSERT_IMAGE": EVT_INSERT_IMAGE, "SELECT_ITEM": EVT_SELECT_ITEM,
}

const EVENT_POSITION_START := 0
const EVENT_POSITION_END := 1
const C_NORMAL_WAITING_TIME := 10   # c_lNormal_Waiting_Time
const C_LINE_TEMP := 16             # c_fLine_Temp
const BOX_VISIBLE_LINE_COUNT := 5

# SEventSet（PythonEventManager.h:98）—— 字段名与 C++ 保持一致，另加本 POC 的
# 行累加 / 副作用收集容器（顶替 CGraphicTextInstance 链表与 Python handler 回调）。
class EventSet:
	extends RefCounted
	var ix := 0
	var iy := 0
	var iWidth := 0
	var iyLocal := 0
	var isLock := false
	var lLastDelayTime := 0
	var iCurrentLetter := 0
	var CurrentColor := Color(1, 1, 1, 1)
	var strCurrentLine := ""
	var isConfirmWait := false
	var iConfirmEndTime := 0
	var DiffuseColor := Color(1, 1, 1, 1)
	var lWaitingTime := C_NORMAL_WAITING_TIME
	var iRestrictedCharacterCount := 30
	var iVisibleStartLine := 0
	var iVisibleLineCount := BOX_VISIBLE_LINE_COUNT
	var iAdjustLine := 0
	var isTextCenterMode := false
	var isWaitFlag := false
	var nAnswer := 0
	# --- POC 累加 ---
	var lines: Array[String] = []
	var color_open := false
	var end_confirm := false
	var choices: Array[String] = []
	var has_next := false
	var next_button_type := ""
	var has_input := false
	var has_select_item := false
	var confirm_timeout := 0
	var window_size: Array[int] = []
	var images: Array[Dictionary] = []
	var insert_images: Array[Dictionary] = []
	var title_image := ""
	var quest_buttons: Array[Dictionary] = []
	var quest_button_closes: Array[int] = []
	var map_signals: Array[Vector2] = []
	var clear_map_signals := false
	var atlas_center: Array[int] = []
	var camera_events: Array[Dictionary] = []
	var fade_events: Array[Dictionary] = []
	var dungeon_result: Dictionary = {}
	var cinema_file := ""

	func init_event_set() -> void:   # __InitEventSet（PythonEventManager.cpp:72）
		ix = 0; iy = 0; iWidth = 0; iyLocal = 0
		isLock = false
		lLastDelayTime = 0
		iCurrentLetter = 0
		CurrentColor = Color(1, 1, 1, 1)
		strCurrentLine = ""
		isConfirmWait = false
		iConfirmEndTime = 0
		DiffuseColor = Color(1, 1, 1, 1)
		lWaitingTime = C_NORMAL_WAITING_TIME
		iRestrictedCharacterCount = 30
		iVisibleStartLine = 0
		iVisibleLineCount = BOX_VISIBLE_LINE_COUNT
		iAdjustLine = 0
		isTextCenterMode = false
		isWaitFlag = false
		# __InsertLine：init 时 pCurrentTextLine==NULL，不推行，只备一条空当前行。

	func insert_line(_center := false) -> void:   # __InsertLine（:976）
		lines.append(strCurrentLine)
		iyLocal += C_LINE_TEMP                     # __AddSpace(c_fLine_Temp)
		strCurrentLine = ""
		iCurrentLetter = 0

	func clear_line() -> void:                     # ClearLine（:953）
		lines.clear()
		strCurrentLine = ""
		iCurrentLetter = 0
		color_open = false

	func body_text() -> String:
		var parts := lines.duplicate()
		parts.append(strCurrentLine)
		var s := "\n".join(parts)
		if color_open:
			s += "[/color]"
		return s.strip_edges()

# GetScriptEventIndex（PythonEventManager.cpp:1093）—— 前导 '/' = EVENT_POSITION_END。
# -> { ok:bool, position:int, type:int }
func _get_script_event_index(raw_name: String) -> Dictionary:
	var position := EVENT_POSITION_START
	var name := raw_name
	if name.begins_with("/"):
		position = EVENT_POSITION_END
		name = name.substr(1)
	name = name.to_upper()
	if not EVENT_TYPE_MAP.has(name):
		return {"ok": false, "position": position, "type": -1}
	return {"ok": true, "position": position, "type": int(EVENT_TYPE_MAP[name])}

# -> { body, choices, has_next, has_input, has_select_item, confirm_wait,
#      confirm_timeout, text_centered, window_size, images, title_image,
#      quest_buttons, quest_button_closes, map_signals, clear_map_signals,
#      atlas_center, camera_events, fade_events,
#      insert_images, dungeon_result, adjust_line, waiting_time,
#      is_locked, wait_flag, answer_count, cinema_file, end_confirm }
func parse_script(src: String) -> Dictionary:
	var es := EventSet.new()
	es.init_event_set()
	var cmds := _tokenize(src)
	# RUN_CINEMA 首命令特例（RegisterEventSetFromString:142 —— ScriptGroup.ReadCmd 读
	# 第一条命令）。本 POC 无法加载 .msc 事件文件，记录文件名走 seam；其余 token 照常
	# 处理。仅当 RUN_CINEMA 是脚本的第一个 token（无前导文本）时生效。
	if not cmds.is_empty() and String(cmds[0].get("literal", "")) == "" \
			and String(cmds[0].get("name", "")).to_upper().trim_prefix("/") == "RUN_CINEMA":
		es.cinema_file = _arg_s(String(cmds[0].get("tok", "")), "value")
	for cmd in cmds:
		_process_event_set(es, cmd)
	return {
		"body": es.body_text(),
		"choices": es.choices,
		"has_next": es.has_next,
		"next_button_type": es.next_button_type,
		"has_input": es.has_input,
		"has_select_item": es.has_select_item,
		"confirm_wait": es.isConfirmWait,
		"confirm_timeout": es.confirm_timeout,
		"text_centered": es.isTextCenterMode,
		"window_size": es.window_size,
		"images": es.images,
		"title_image": es.title_image,
		"quest_buttons": es.quest_buttons,
		"quest_button_closes": es.quest_button_closes,
		"map_signals": es.map_signals,
		"clear_map_signals": es.clear_map_signals,
		"atlas_center": es.atlas_center,
		"camera_events": es.camera_events,
		"fade_events": es.fade_events,
		# --- 增量 95 新增：EventSet 状态透出 ---
		"insert_images": es.insert_images,
		"dungeon_result": es.dungeon_result,
		"adjust_line": es.iAdjustLine,
		"waiting_time": es.lWaitingTime,
		"is_locked": es.isLock,
		"wait_flag": es.isWaitFlag,
		"answer_count": es.nAnswer,
		"cinema_file": es.cinema_file,
		"end_confirm": es.end_confirm,
	}

func _event_set_result(es: EventSet) -> Dictionary:
	return {
		"body": es.body_text(),
		"choices": es.choices,
		"has_next": es.has_next,
		"next_button_type": es.next_button_type,
		"has_input": es.has_input,
		"has_select_item": es.has_select_item,
		"confirm_wait": es.isConfirmWait,
		"confirm_timeout": es.confirm_timeout,
		"text_centered": es.isTextCenterMode,
		"window_size": es.window_size,
		"images": es.images,
		"title_image": es.title_image,
		"quest_buttons": es.quest_buttons,
		"quest_button_closes": es.quest_button_closes,
		"map_signals": es.map_signals,
		"clear_map_signals": es.clear_map_signals,
		"atlas_center": es.atlas_center,
		"camera_events": es.camera_events,
		"fade_events": es.fade_events,
		"insert_images": es.insert_images,
		"dungeon_result": es.dungeon_result,
		"adjust_line": es.iAdjustLine,
		"waiting_time": es.lWaitingTime,
		"is_locked": es.isLock,
		"wait_flag": es.isWaitFlag,
		"answer_count": es.nAnswer,
		"cinema_file": es.cinema_file,
		"end_confirm": es.end_confirm,
	}

# 把混排文本 / [tag ...] 拆成命令流。裸文本 -> { literal:String }；
# tag -> { name:String(大写,带/前缀), pos:int, tok:String(方括号内原文) }。
func _tokenize(src: String) -> Array:
	var out := []
	var i := 0
	var n := src.length()
	while i < n:
		var c := src[i]
		if c == "[":
			var close_i := src.find("]", i)
			if close_i == -1:
				out.append({"literal": src.substr(i)})
				break
			var tok := src.substr(i + 1, close_i - i - 1).strip_edges()
			i = close_i + 1
			if tok == "":
				continue
			var first := tok.split(" ", false)[0]
			var pos := EVENT_POSITION_START
			if first.begins_with("/"):
				pos = EVENT_POSITION_END
			out.append({"name": first.to_upper(), "pos": pos, "tok": tok})
		else:
			var next_tag := src.find("[", i)
			if next_tag == -1:
				next_tag = n
			var lit := src.substr(i, next_tag - i)
			if lit != "":
				out.append({"literal": lit})
			i = next_tag
	return out

# ProcessEventSet（PythonEventManager.cpp:377）的 switch 逐 case 对拷。
func _process_event_set(es: EventSet, cmd: Dictionary) -> void:
	var literal := String(cmd.get("literal", ""))
	if literal != "":
		_evt_letter(es, literal, true)
		return
	var idx := _get_script_event_index(String(cmd.get("name", "")))
	if not idx.ok:
		# GetScriptEventIndex: 未知命令 -> PARSING ERROR，跳过（不进 switch）。
		return
	var etype: int = idx.type
	var pos: int = idx.position
	var tok := String(cmd.get("tok", ""))
	match etype:
		EVT_LETTER:
			var vv := _tag_strings(tok)
			if vv.size() > 0:
				_evt_letter(es, vv[0], false)
		EVT_DELAY:
			# START: lWaitingTime = atoi(value)；END(/DELAY): 复位 c_lNormal_Waiting_Time。
			es.lWaitingTime = _arg_i(tok, "value", 0) if pos == EVENT_POSITION_START else C_NORMAL_WAITING_TIME
		EVT_COLOR:
			_evt_color(es, tok, pos, 1.0)
		EVT_COLOR256:
			_evt_color(es, tok, pos, 255.0)
		EVT_ENTER:
			es.insert_line()
		EVT_WAIT:
			es.iyLocal = 0
			es.isLock = true
		EVT_CLEAR, EVT_CLEAR_TEXT:
			es.clear_line()
		EVT_QUESTION:
			_make_question(es, tok)
		EVT_NEXT:
			# MakeNextButton(BUTTON_TYPE_NEXT); iAdjustLine += 2。
			es.has_next = true
			es.next_button_type = "NEXT"
			es.iAdjustLine += 2
		EVT_DONE:
			# MakeNextButton(BUTTON_TYPE_DONE); the reference invokes DoneEvent
			# from the button callback, not while the token is being parsed.
			es.has_next = true
			es.next_button_type = "DONE"
			es.iAdjustLine += 2
		EVT_LEFT_IMAGE:
			es.images.append({"panel": "LEFTIMAGE", "path": _arg_s(tok, "src")})
		EVT_TOP_IMAGE:
			es.images.append({"panel": "TOPIMAGE", "path": _arg_s(tok, "src")})
		EVT_BACKGROUND_IMAGE:
			es.images.append({"panel": "BGIMAGE", "path": _arg_s(tok, "src")})
		EVT_IMAGE:
			var ipath := _arg_s(tok, "src", 0)
			if ipath != "":
				es.images.append({"x": _arg_i(tok, "x", 0), "y": _arg_i(tok, "y", 1), "path": ipath})
		EVT_INSERT_IMAGE:
			var img := _arg_s(tok, "image_name")
			es.insert_images.append({
				"image_name": img,
				"image_type": _arg_s(tok, "image_type"),
				"idx": _arg_i(tok, "idx"),
				"title": _arg_s(tok, "title"),
				"desc": _arg_s(tok, "desc"),
				"index": _arg_i(tok, "index"),
				"total": _arg_i(tok, "total"),
				"is_item_icon": img == "",
			})
			es.iAdjustLine += 2
		EVT_ADD_MAP_SIGNAL:
			es.map_signals.append(Vector2(_arg_f(tok, "x", 0), _arg_f(tok, "y", 1)))
		EVT_CLEAR_MAP_SIGNAL:
			es.clear_map_signals = true
		EVT_QUEST_BUTTON_CLOSE:
			es.quest_button_closes.append(_arg_i(tok, "idx", 0))
		EVT_QUEST_BUTTON:
			_make_quest_button(es, tok)
		EVT_SET_MESSAGE_POSITION, EVT_ADJUST_MESSAGE_POSITION:
			# PythonEventManager.cpp:562 / :566 —— 客户端故意留空（无副作用）。
			pass
		EVT_SET_CENTER_MAP_POSITION:
			es.atlas_center = [_arg_i(tok, "x", 0), _arg_i(tok, "y", 1)]
		EVT_SLEEP:
			es.lLastDelayTime = _arg_i(tok, "value", 0)
		EVT_SET_CAMERA:
			es.camera_events.append({"kind": "SET_CAMERA", "values": _tag_numbers(tok),
				"setting": _camera_setting(tok)})
		EVT_BLEND_CAMERA:
			es.camera_events.append({"kind": "BLEND_CAMERA", "values": _tag_numbers(tok),
				"setting": _camera_setting(tok), "blendtime": _arg_f(tok, "blendtime")})
		EVT_RESTORE_CAMERA:
			es.camera_events.append({"kind": "RESTORE_CAMERA", "values": []})
		EVT_FADE_OUT, EVT_FADE_IN, EVT_WHITE_OUT, EVT_WHITE_IN:
			var kinds := {EVT_FADE_OUT: "FADE_OUT", EVT_FADE_IN: "FADE_IN",
				EVT_WHITE_OUT: "WHITE_OUT", EVT_WHITE_IN: "WHITE_IN"}
			es.fade_events.append({"kind": kinds[etype], "speed": _arg_f(tok, "speed", 0)})
			es.isWaitFlag = true   # 等 EndEventProcess（seam：无逐帧循环，不真正阻塞）。
		EVT_TEXT_HORIZONTAL_ALIGN_CENTER:
			es.isTextCenterMode = true
		EVT_TITLE_IMAGE:
			es.title_image = _arg_s(tok, "src", 0)
		EVT_RUN_CINEMA:
			# ProcessEventSet 无此 case（仅 RegisterEventSetFromString 首命令阶段处理）。
			pass
		EVT_DUNGEON_RESULT:
			es.dungeon_result = {
				"killstone_count": _arg_i(tok, "killstone_count"),
				"killmob_count": _arg_i(tok, "killmob_count"),
				"find_hidden": _arg_i(tok, "find_hidden"),
				"hidden_total": _arg_i(tok, "hidden_total"),
				"use_potion": _arg_i(tok, "use_potion"),
				"is_revived": _arg_i(tok, "is_revived"),
				"killallmob": _arg_i(tok, "killallmob"),
				"total_time": _arg_i(tok, "total_time"),
				"bonus_exp": _arg_i(tok, "bonus_exp"),
			}
		EVT_ITEM_NAME:
			_evt_item_name(es, _arg_i(tok, "value", 0))
		EVT_MONSTER_NAME:
			_evt_mob_name(es, _arg_i(tok, "value", 0))
		EVT_WINDOW_SIZE:
			var w := _arg_i(tok, "width", 0)
			var h := _arg_i(tok, "height", 1)
			if w > 0 and h > 0:
				es.window_size = [w, h]
		EVT_INPUT:
			es.insert_line()
			es.has_input = true
		EVT_CONFIRM_WAIT:
			es.confirm_timeout = _arg_i(tok, "timeout", 0)
			es.isConfirmWait = true
			# ClientVS22 stores the deadline in seconds (timeGetTime()/1000),
			# not the timeout duration itself.
			es.iConfirmEndTime = int(Time.get_ticks_msec() / 1000) + es.confirm_timeout
			es.insert_line(true)
			# MakeNextButton(BUTTON_TYPE_CANCEL) —— 取消按钮由 _fill_buttons(confirm_wait) 出。
		EVT_END_CONFIRM_WAIT:
			es.isConfirmWait = false
			es.iConfirmEndTime = 0
			es.end_confirm = true
		EVT_SELECT_ITEM:
			es.has_select_item = true
		_:
			pass

# EVENT_TYPE_LETTER / 裸文本（is_raw）。
func _evt_letter(es: EventSet, value: String, is_raw: bool) -> void:
	es.strCurrentLine += value
	if not is_raw:
		es.iCurrentLetter += value.length()
		if es.iCurrentLetter >= es.iRestrictedCharacterCount:
			es.insert_line()
	es.lLastDelayTime = es.lWaitingTime

# EVENT_TYPE_COLOR / EVENT_TYPE_COLOR256。BBCode span：新 span 前先关旧的。
func _evt_color(es: EventSet, tok: String, pos: int, divisor: float) -> void:
	if es.color_open:
		es.strCurrentLine += "[/color]"
		es.color_open = false
	if pos == EVENT_POSITION_START:
		var kv := _tag_kv(tok)
		var r: float
		var g: float
		var b: float
		if kv.has("r") or kv.has("g") or kv.has("b"):
			r = float(kv.get("r", "0"))
			g = float(kv.get("g", "0"))
			b = float(kv.get("b", "0"))
		else:
			var nums := _tag_numbers(tok)
			if nums.size() < 3:
				return
			r = nums[0]; g = nums[1]; b = nums[2]
		es.CurrentColor = Color(clampf(r / divisor, 0.0, 1.0),
			clampf(g / divisor, 0.0, 1.0), clampf(b / divisor, 0.0, 1.0), 1.0)
		es.strCurrentLine += "[color=#%s]" % es.CurrentColor.to_html(false)
		es.color_open = true
	else:
		es.CurrentColor = Color(1, 1, 1, 1)

# MakeQuestion（PythonEventManager.cpp:884）。
func _make_question(es: EventSet, tok: String) -> void:
	var args := _tag_strings(tok)
	if args.is_empty():
		return
	for a in args:
		es.choices.append(String(a))
	es.nAnswer = args.size()

# EVENT_TYPE_QUEST_BUTTON（:558）—— idx/name/icon_type/icon_name，带位置回退。
func _make_quest_button(es: EventSet, tok: String) -> void:
	var kv := _tag_kv(tok)
	var nums := _tag_numbers(tok)
	var strs := _tag_strings(tok)
	var qidx := -1
	if kv.has("idx") and String(kv["idx"]).is_valid_int():
		qidx = int(kv["idx"])
	elif nums.size() > 0:
		qidx = int(nums[0])
	if qidx < 0:
		return
	var nm := String(kv.get("name", strs[0] if strs.size() > 0 else ""))
	var itype := String(kv.get("icon_type", strs[1] if strs.size() > 1 else ""))
	var iname := String(kv.get("icon_name", strs[2] if strs.size() > 2 else ""))
	es.quest_buttons.append({"index": qidx, "title": nm, "icon_type": itype, "icon_name": iname})

func _evt_item_name(es: EventSet, vnum: int) -> void:
	var nm := _quest_item_name([float(vnum)])
	es.strCurrentLine += nm
	es.iCurrentLetter += nm.length()
	if es.iCurrentLetter >= es.iRestrictedCharacterCount:
		es.insert_line()
	es.lLastDelayTime = es.lWaitingTime

func _evt_mob_name(es: EventSet, vnum: int) -> void:
	var nm := _quest_mob_name([float(vnum)])
	es.strCurrentLine += nm
	es.iCurrentLetter += nm.length()
	if es.iCurrentLetter >= es.iRestrictedCharacterCount:
		es.insert_line()
	es.lLastDelayTime = es.lWaitingTime

# GetCameraSettingFromArgList（PythonEventManager.cpp:48）。
func _camera_setting(tok: String) -> Dictionary:
	return {
		"x": _arg_i(tok, "x"), "y": _arg_i(tok, "y"), "z": _arg_i(tok, "z"),
		"up": _arg_i(tok, "up"), "view": _arg_i(tok, "view"), "cross": _arg_i(tok, "cross"),
		"distance": _arg_i(tok, "distance"), "rot": _arg_i(tok, "rot"), "pitch": _arg_i(tok, "pitch"),
	}

# --- arg 提取（keyword 优先，位置回退）--------------------------------

# key(val) / key("val") / key;val 的键值对。重复键取最后一个。
func _tag_kv(tok: String) -> Dictionary:
	var out := {}
	var raw := tok.substr(tok.find(" ") + 1) if tok.find(" ") >= 0 else ""
	var i := 0
	var n := raw.length()
	while i < n:
		while i < n and raw[i] in [" ", "\t", ","]:
			i += 1
		var start := i
		while i < n and not (raw[i] in [" ", "\t", ",", "(", ";"]):
			i += 1
		if i >= n:
			break
		var key := raw.substr(start, i - start)
		var val := ""
		if raw[i] == "(":
			var depth := 1
			i += 1
			var vs := i
			while i < n and depth > 0:
				if raw[i] == "(":
					depth += 1
				elif raw[i] == ")":
					depth -= 1
					if depth == 0:
						break
				i += 1
			val = raw.substr(vs, i - vs)
			i += 1
		elif raw[i] == ";":
			i += 1
			var vs2 := i
			while i < n and not (raw[i] in [" ", "\t", ","]):
				i += 1
			val = raw.substr(vs2, i - vs2)
		val = val.strip_edges()
		if val.length() >= 2 and val[0] == '"' and val[val.length() - 1] == '"':
			val = val.substr(1, val.length() - 2)
		if key != "":
			out[key] = val
	return out

func _arg_s(tok: String, key: String, fallback_idx: int = -1) -> String:
	var kv := _tag_kv(tok)
	if kv.has(key):
		return String(kv[key])
	if fallback_idx >= 0:
		var strs := _tag_strings(tok)
		if fallback_idx < strs.size():
			return String(strs[fallback_idx])
	return ""

func _arg_f(tok: String, key: String, fallback_idx: int = -1) -> float:
	var kv := _tag_kv(tok)
	if kv.has(key) and String(kv[key]).is_valid_float():
		return float(kv[key])
	if fallback_idx >= 0:
		var nums := _tag_numbers(tok)
		if fallback_idx < nums.size():
			return nums[fallback_idx]
	return 0.0

func _arg_i(tok: String, key: String, fallback_idx: int = -1) -> int:
	return int(_arg_f(tok, key, fallback_idx))

func _tag_strings(tok: String) -> Array[String]:
	var quoted: Array[String] = []
	for raw in _rx_args(tok):
		quoted.append(String(raw))
	if not quoted.is_empty():
		return quoted
	var out: Array[String] = []
	var raw := tok.substr(tok.find(" ") + 1).strip_edges() if tok.find(" ") >= 0 else ""
	for part in raw.replace(",", ";").split(";", false):
		var value := part.strip_edges()
		if value in ["value", "arg"] or value.is_empty():
			continue
		if value.begins_with("value("):
			value = value.trim_prefix("value(").trim_suffix(")")
		if value.begins_with("arg("):
			value = value.trim_prefix("arg(").trim_suffix(")")
		if not value.is_empty():
			out.append(value)
	return out

func _tag_numbers(tok: String) -> Array[float]:
	var out: Array[float] = []
	var raw := tok.substr(tok.find(" ") + 1).strip_edges() if tok.find(" ") >= 0 else ""
	raw = raw.replace(",", " ").replace(";", " ").replace("(", " ").replace(")", " ")
	for part in raw.split(" ", false):
		var value := part.strip_edges()
		if value.is_valid_float():
			out.append(float(value))
	return out

func _quest_item_name(values: Array[float]) -> String:
	if values.is_empty():
		return ""
	var vnum := int(values[0])
	if proto and proto.has_method("item"):
		var data: Dictionary = proto.item(vnum)
		var name := String(data.get("locale_name", data.get("name", "")))
		if name != "":
			return name
	return "物品 #%d" % vnum

func _quest_mob_name(values: Array[float]) -> String:
	if values.is_empty():
		return ""
	var vid := int(values[0])
	if client and client.has_method("get_entity"):
		var entity: Dictionary = client.get_entity(vid)
		var name := String(entity.get("name", ""))
		if name != "":
			return name
	return "怪物 #%d" % vid

# 抓 tok 里所有 arg("...") / value("...") 的字符串
func _rx_args(tok: String) -> Array:
	var out := []
	var i := 0
	while true:
		var q1 := tok.find('"', i)
		if q1 == -1:
			break
		var q2 := tok.find('"', q1 + 1)
		if q2 == -1:
			break
		out.append(tok.substr(q1 + 1, q2 - q1 - 1))
		i = q2 + 1
	return out

# --- UI --------------------------------------------------------------

func _build(parent: Node) -> void:
	_root = Control.new()
	_root.set_anchors_preset(Control.PRESET_CENTER)
	_root.position = Vector2(-230, -160)
	_root.size = Vector2(460, 300)
	_root.visible = false
	_root.set_meta("is_titlebar", true)
	parent.add_child(_root)
	var panel := Panel.new()
	panel.set_anchors_preset(Control.PRESET_FULL_RECT)
	var sb := StyleBoxFlat.new()
	sb.bg_color = Color(0.08, 0.07, 0.06, 0.97)
	sb.border_color = Color(0.5, 0.42, 0.3)
	sb.set_border_width_all(1)
	sb.set_corner_radius_all(4)
	panel.add_theme_stylebox_override("panel", sb)
	_root.add_child(panel)
	_image_layer = Control.new()
	_image_layer.set_anchors_preset(Control.PRESET_FULL_RECT)
	_image_layer.mouse_filter = Control.MOUSE_FILTER_IGNORE
	_root.add_child(_image_layer)
	_text = RichTextLabel.new()
	_text.bbcode_enabled = true
	_text.position = Vector2(16, 14)
	_text.size = Vector2(428, 200)
	_text.add_theme_font_size_override("normal_font_size", 13)
	_root.add_child(_text)
	_btnrow = VBoxContainer.new()
	_btnrow.position = Vector2(16, 222)
	_btnrow.custom_minimum_size = Vector2(428, 0)
	_btnrow.add_theme_constant_override("separation", 4)
	_root.add_child(_btnrow)

func _render_images(images: Array, title_image: String) -> void:
	if _image_layer == null:
		return
	for child in _image_layer.get_children():
		child.queue_free()
	for spec in images:
		var path := String(spec.get("path", ""))
		var tex: Texture2D = UiAssets.load_tex(_assets_root, path)
		if tex == null:
			continue
		var image := TextureRect.new()
		image.texture = tex
		image.expand_mode = TextureRect.EXPAND_IGNORE_SIZE
		image.stretch_mode = TextureRect.STRETCH_KEEP_ASPECT_CENTERED
		image.mouse_filter = Control.MOUSE_FILTER_IGNORE
		var panel_name := String(spec.get("panel", ""))
		if panel_name == "BGIMAGE":
			image.set_anchors_preset(Control.PRESET_FULL_RECT)
		elif panel_name == "TOPIMAGE":
			image.position = Vector2(0, 0)
			image.size = Vector2(_root.size.x, minf(84.0, tex.get_size().y))
		elif panel_name == "LEFTIMAGE":
			image.position = Vector2(0, 0)
			image.size = Vector2(minf(150.0, tex.get_size().x), _root.size.y)
		else:
			image.position = Vector2(float(spec.get("x", 0)), float(spec.get("y", 0)))
			image.size = tex.get_size()
		_image_layer.add_child(image)
	if title_image != "":
		var title_tex: Texture2D = UiAssets.load_tex(_assets_root, title_image)
		if title_tex:
			var title := TextureRect.new()
			title.texture = title_tex
			title.expand_mode = TextureRect.EXPAND_IGNORE_SIZE
			title.stretch_mode = TextureRect.STRETCH_KEEP_ASPECT_CENTERED
			title.mouse_filter = Control.MOUSE_FILTER_IGNORE
			title.position = Vector2((_root.size.x - title_tex.get_size().x) * 0.5, 4)
			title.size = title_tex.get_size()
			_image_layer.add_child(title)

func _clear_buttons() -> void:
	for c in _btnrow.get_children():
		c.queue_free()

func _fill_buttons(choices: Array, has_next: bool, has_input := false, confirm_wait := false,
		next_button_type := "") -> void:
	_clear_buttons()
	if has_input:
		var input := LineEdit.new()
		input.placeholder_text = "请输入"
		input.custom_minimum_size = Vector2(428, 28)
		_btnrow.add_child(input)
		var submit := _mkbtn("提交")
		submit.pressed.connect(func(): _submit_input(input))
		input.text_submitted.connect(func(_text): _submit_input(input))
		return
	if confirm_wait:
		var cancel := _mkbtn("取消")
		cancel.pressed.connect(func():
			if client and client.has_method("quest_cancel"):
				client.quest_cancel()
			close())
		return
	if choices.is_empty():
		var is_done := next_button_type == "DONE"
		var b := _mkbtn("关闭" if is_done else ("继续" if has_next else "关闭"))
		b.pressed.connect(func():
			if is_done:
				# MakeNextButton(BUTTON_TYPE_DONE) wires DoneEvent to the
				# actual click.  Keep parse_script() side-effect free and only
				# notify consumers when the player confirms the DONE button.
				done_event.emit()
			if client and client.has_method("script_answer"):
				client.script_answer(255)
			close())
		return
	for i in choices.size():
		var idx := i
		var b := _mkbtn(String(choices[i]))
		b.pressed.connect(func():
			client.script_answer(idx)
			close())

func _submit_input(input: LineEdit) -> void:
	if client and client.has_method("quest_input") and client.quest_input(input.text):
		close()

func _fill_confirm() -> void:
	_clear_buttons()
	var row := HBoxContainer.new()
	row.add_theme_constant_override("separation", 8)
	_btnrow.add_child(row)
	for spec in [["接受", true], ["拒绝", false]]:
		var yes: bool = spec[1]
		var b := Button.new()
		b.text = spec[0]
		b.custom_minimum_size = Vector2(120, 30)
		b.pressed.connect(func():
			client.quest_confirm(yes, _confirm_pid)
			close())
		row.add_child(b)

func _mkbtn(text: String) -> Button:
	var b := Button.new()
	b.text = text
	b.custom_minimum_size = Vector2(428, 26)
	_btnrow.add_child(b)
	return b