230 lines
7.4 KiB
GDScript
230 lines
7.4 KiB
GDScript
extends SceneTree
|
|
|
|
const MainScene: PackedScene = preload("res://main/main.tscn")
|
|
const TEST_PORT: int = 18152
|
|
const PREJOIN_MESSAGE: String = "private prejoin message"
|
|
const LIVE_MESSAGE: String = "live message after join"
|
|
const HOST_ROLEPLAY: String = "/me grabs [b]his fishing rod[/b]"
|
|
const CLIENT_ROLEPLAY: String = "/me waves [color=red]hello[/color]"
|
|
|
|
|
|
func _initialize() -> void:
|
|
call_deferred("_run")
|
|
|
|
|
|
func _run() -> void:
|
|
var arguments: PackedStringArray = OS.get_cmdline_user_args()
|
|
if arguments.has("host"):
|
|
await _run_host()
|
|
return
|
|
if arguments.has("client"):
|
|
await _run_client()
|
|
return
|
|
push_error("Chat privacy validation needs host or client mode.")
|
|
quit(1)
|
|
|
|
|
|
func _run_host() -> void:
|
|
var main: Node = await _create_initialized_main()
|
|
var session := main.get_node("%NetworkSession") as NetworkSession
|
|
var save_manager := main.get("_save_manager") as PlayerSaveManager
|
|
assert(bool(main.call(
|
|
"_apply_world", WorldLayout.STARTER_ISLAND, 1, true
|
|
)))
|
|
assert(session.set_host_world(WorldLayout.STARTER_ISLAND, 1))
|
|
assert(session.start_private_host(TEST_PORT))
|
|
assert(save_manager.initialize_new_game())
|
|
main.call("_enter_gameplay")
|
|
for _frame: int in 4:
|
|
await physics_frame
|
|
assert(session.set_host_open(true))
|
|
var chat_service := main.get_node(
|
|
"%NetworkChatService"
|
|
) as NetworkChatService
|
|
assert(not chat_service.send_local_message("/me"))
|
|
assert(chat_service.send_local_message(PREJOIN_MESSAGE))
|
|
var remote_peer_id: int = await _wait_for_remote_peer(session)
|
|
assert(remote_peer_id > 1)
|
|
await create_timer(1.0).timeout
|
|
assert(chat_service.send_local_message(LIVE_MESSAGE))
|
|
assert(chat_service.send_local_message(HOST_ROLEPLAY))
|
|
var client_roleplay_deadline: int = Time.get_ticks_msec() + 8000
|
|
while (
|
|
Time.get_ticks_msec() < client_roleplay_deadline
|
|
and not _history_contains(chat_service, CLIENT_ROLEPLAY)
|
|
):
|
|
await process_frame
|
|
assert(_history_contains(chat_service, CLIENT_ROLEPLAY))
|
|
var client_roleplay: Dictionary = _history_message(
|
|
chat_service, CLIENT_ROLEPLAY
|
|
)
|
|
assert(int(client_roleplay.get("sender_peer_id", 0)) == remote_peer_id)
|
|
assert(
|
|
str(client_roleplay.get("sender_display_name", ""))
|
|
== session.get_peer_record(remote_peer_id).display_name
|
|
)
|
|
_assert_roleplay_rendered(
|
|
main,
|
|
str(client_roleplay["sender_display_name"]),
|
|
"waves [color=red]hello[/color]",
|
|
)
|
|
_assert_no_world_speech(main, remote_peer_id)
|
|
var disconnect_deadline: int = Time.get_ticks_msec() + 8000
|
|
while (
|
|
Time.get_ticks_msec() < disconnect_deadline
|
|
and session.is_authenticated_peer(remote_peer_id)
|
|
):
|
|
await process_frame
|
|
assert(not session.is_authenticated_peer(remote_peer_id))
|
|
print("Chat privacy multiplayer host validation: PASS")
|
|
await _session_cleanup(main, session)
|
|
|
|
|
|
func _run_client() -> void:
|
|
var main: Node = await _create_initialized_main()
|
|
main.call("_on_title_join_game_requested", "127.0.0.1:%d" % TEST_PORT)
|
|
var session := main.get_node("%NetworkSession") as NetworkSession
|
|
var join_deadline: int = Time.get_ticks_msec() + 20000
|
|
while Time.get_ticks_msec() < join_deadline:
|
|
await process_frame
|
|
if session.state == NetworkSession.State.VERIFYING_SERVER_IDENTITY:
|
|
main.call("_confirm_server_trust")
|
|
if session.is_joined_client() and bool(main.get("_gameplay_started")):
|
|
break
|
|
assert(session.is_joined_client())
|
|
var chat_service := main.get_node(
|
|
"%NetworkChatService"
|
|
) as NetworkChatService
|
|
await create_timer(0.5).timeout
|
|
assert(not _history_contains(chat_service, PREJOIN_MESSAGE))
|
|
var live_deadline: int = Time.get_ticks_msec() + 8000
|
|
while (
|
|
Time.get_ticks_msec() < live_deadline
|
|
and (
|
|
not _history_contains(chat_service, LIVE_MESSAGE)
|
|
or not _history_contains(chat_service, HOST_ROLEPLAY)
|
|
)
|
|
):
|
|
await process_frame
|
|
assert(_history_contains(chat_service, LIVE_MESSAGE))
|
|
assert(_history_contains(chat_service, HOST_ROLEPLAY))
|
|
assert(not _history_contains(chat_service, PREJOIN_MESSAGE))
|
|
var host_roleplay: Dictionary = _history_message(
|
|
chat_service, HOST_ROLEPLAY
|
|
)
|
|
var host_peer_id: int = int(host_roleplay.get("sender_peer_id", 0))
|
|
assert(host_peer_id > 0)
|
|
assert(
|
|
str(host_roleplay.get("sender_display_name", ""))
|
|
== session.get_peer_record(host_peer_id).display_name
|
|
)
|
|
_assert_roleplay_rendered(
|
|
main,
|
|
str(host_roleplay["sender_display_name"]),
|
|
"grabs [b]his fishing rod[/b]",
|
|
)
|
|
_assert_world_speech_body(main, host_peer_id, LIVE_MESSAGE)
|
|
assert(chat_service.send_local_message(CLIENT_ROLEPLAY))
|
|
var confirmation_deadline: int = Time.get_ticks_msec() + 8000
|
|
while (
|
|
Time.get_ticks_msec() < confirmation_deadline
|
|
and not _history_contains(chat_service, CLIENT_ROLEPLAY)
|
|
):
|
|
await process_frame
|
|
assert(_history_contains(chat_service, CLIENT_ROLEPLAY))
|
|
_assert_no_world_speech(main, session.get_local_peer_id())
|
|
print("Chat privacy multiplayer client validation: PASS")
|
|
await _session_cleanup(main, session)
|
|
|
|
|
|
func _history_contains(service: NetworkChatService, body: String) -> bool:
|
|
return service.get_history().any(
|
|
func(message: Dictionary) -> bool:
|
|
return str(message.get("body", "")) == body
|
|
)
|
|
|
|
|
|
func _history_message(
|
|
service: NetworkChatService,
|
|
body: String,
|
|
) -> Dictionary:
|
|
for message: Dictionary in service.get_history():
|
|
if str(message.get("body", "")) == body:
|
|
return message
|
|
return {}
|
|
|
|
|
|
func _assert_roleplay_rendered(
|
|
main: Node,
|
|
display_name: String,
|
|
action: String,
|
|
) -> void:
|
|
var chat_ui := main.get_node("%GameUI").get_node("%ChatUI") as ChatUI
|
|
var history := chat_ui.get("_history") as RichTextLabel
|
|
assert(history != null)
|
|
var expected: String = "%s %s" % [display_name, action]
|
|
assert(history.get_parsed_text().contains(expected))
|
|
assert(not history.get_parsed_text().contains(
|
|
"%s: /me" % display_name
|
|
))
|
|
assert(not history.bbcode_enabled)
|
|
var italic_font := history.get_theme_font("italics_font") as FontVariation
|
|
assert(italic_font != null)
|
|
assert(not is_zero_approx(italic_font.variation_transform.y.x))
|
|
|
|
|
|
func _assert_no_world_speech(main: Node, peer_id: int) -> void:
|
|
var chat_ui := main.get_node("%GameUI").get_node("%ChatUI") as ChatUI
|
|
var speech: Dictionary = chat_ui.get("_speech")
|
|
assert(not speech.has(peer_id))
|
|
|
|
|
|
func _assert_world_speech_body(
|
|
main: Node,
|
|
peer_id: int,
|
|
expected_body: String,
|
|
) -> void:
|
|
var chat_ui := main.get_node("%GameUI").get_node("%ChatUI") as ChatUI
|
|
var speech: Dictionary = chat_ui.get("_speech")
|
|
assert(speech.has(peer_id))
|
|
var state: Dictionary = speech[peer_id]
|
|
var bubble := state.get("bubble") as PanelContainer
|
|
assert(bubble != null)
|
|
for child: Node in bubble.get_children():
|
|
if child is Label:
|
|
assert((child as Label).text == expected_body)
|
|
return
|
|
assert(false, "Speech bubble label is missing.")
|
|
|
|
|
|
func _create_initialized_main() -> Node:
|
|
root.size = Vector2i(1280, 720)
|
|
var main: Node = MainScene.instantiate()
|
|
root.add_child(main)
|
|
for _frame: int in 4:
|
|
await process_frame
|
|
if not bool(main.get("_application_initialized")):
|
|
main.call("_activate_selected_data_path", "", true)
|
|
for _frame: int in 8:
|
|
await process_frame
|
|
assert(bool(main.get("_application_initialized")))
|
|
return main
|
|
|
|
|
|
func _wait_for_remote_peer(session: NetworkSession) -> int:
|
|
var deadline: int = Time.get_ticks_msec() + 20000
|
|
while Time.get_ticks_msec() < deadline:
|
|
await process_frame
|
|
for peer_id: int in session.get_authenticated_peer_ids():
|
|
if peer_id != session.get_local_peer_id():
|
|
return peer_id
|
|
return 0
|
|
|
|
|
|
func _session_cleanup(main: Node, session: NetworkSession) -> void:
|
|
session.disconnect_session("")
|
|
main.queue_free()
|
|
for _frame: int in 4:
|
|
await process_frame
|
|
await create_timer(0.1).timeout
|
|
quit()
|