Add collaborative surface drawing
This commit is contained in:
parent
6b7ef4c11b
commit
b92c55562d
28 changed files with 3504 additions and 2 deletions
252
tests/surface_drawing_multiplayer_validation.gd
Normal file
252
tests/surface_drawing_multiplayer_validation.gd
Normal file
|
|
@ -0,0 +1,252 @@
|
|||
extends SceneTree
|
||||
|
||||
const MainScene: PackedScene = preload("res://main/main.tscn")
|
||||
const TEST_PORT: int = 18133
|
||||
const WAIT_MSEC: int = 20000
|
||||
|
||||
|
||||
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("Surface drawing multiplayer 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
|
||||
assert(session.start_private_host(TEST_PORT))
|
||||
var save_manager := main.get("_save_manager") as PlayerSaveManager
|
||||
assert(save_manager.initialize_new_game())
|
||||
main.call("_enter_gameplay")
|
||||
await physics_frame
|
||||
await physics_frame
|
||||
|
||||
var service := main.get_node(
|
||||
"%NetworkSurfaceDrawingService"
|
||||
) as NetworkSurfaceDrawingService
|
||||
var surface: Dictionary = _surface_below_local_player(main)
|
||||
assert(not surface.is_empty())
|
||||
assert(service.request_canvas_at_surface(
|
||||
surface["position"], surface["normal"], Vector3.RIGHT
|
||||
))
|
||||
var canvas_id: String = service.get_canvas_ids()[0]
|
||||
assert(service.request_cell_edits(canvas_id, [{
|
||||
"x": 7,
|
||||
"y": 7,
|
||||
"color_id": "coral",
|
||||
}]))
|
||||
assert(session.set_host_open(true))
|
||||
|
||||
var remote_peer_id: int = await _wait_for_remote_peer(session)
|
||||
assert(remote_peer_id > 1)
|
||||
var remote_record: PeerRegistry.PeerRecord = session.get_peer_record(
|
||||
remote_peer_id
|
||||
)
|
||||
assert(remote_record != null)
|
||||
assert(session.peer_supports_capability(
|
||||
remote_peer_id, SurfaceDrawingProtocol.CAPABILITY
|
||||
))
|
||||
|
||||
var overwrite_deadline: int = Time.get_ticks_msec() + WAIT_MSEC
|
||||
while Time.get_ticks_msec() < overwrite_deadline:
|
||||
await process_frame
|
||||
var state: Dictionary = service.get_canvas_state(canvas_id)
|
||||
if int(state.get("revision", 0)) < 2:
|
||||
continue
|
||||
var cell: Dictionary = _find_cell(state, 7, 7)
|
||||
if (
|
||||
str(cell.get("color_id", "")) == "blue"
|
||||
and str(cell.get("author_fingerprint", ""))
|
||||
== remote_record.identity_fingerprint
|
||||
):
|
||||
break
|
||||
var overwritten_state: Dictionary = service.get_canvas_state(canvas_id)
|
||||
assert(int(overwritten_state["revision"]) >= 2)
|
||||
var overwritten_cell: Dictionary = _find_cell(overwritten_state, 7, 7)
|
||||
assert(str(overwritten_cell["color_id"]) == "blue")
|
||||
assert(
|
||||
str(overwritten_cell["author_fingerprint"])
|
||||
== remote_record.identity_fingerprint
|
||||
)
|
||||
|
||||
assert(service.request_cell_edits(canvas_id, [{
|
||||
"x": 8,
|
||||
"y": 7,
|
||||
"color_id": "sunny",
|
||||
}]))
|
||||
var undo_deadline: int = Time.get_ticks_msec() + WAIT_MSEC
|
||||
while Time.get_ticks_msec() < undo_deadline:
|
||||
await process_frame
|
||||
var state: Dictionary = service.get_canvas_state(canvas_id)
|
||||
if str(_find_cell(state, 7, 7).get("color_id", "")) == "coral":
|
||||
break
|
||||
assert(
|
||||
str(_find_cell(service.get_canvas_state(canvas_id), 7, 7)["color_id"])
|
||||
== "coral"
|
||||
)
|
||||
var guide_deadline: int = Time.get_ticks_msec() + WAIT_MSEC
|
||||
while Time.get_ticks_msec() < guide_deadline:
|
||||
await process_frame
|
||||
if not bool(service.get_canvas_state(canvas_id).get("guide_visible", true)):
|
||||
break
|
||||
assert(not bool(service.get_canvas_state(canvas_id)["guide_visible"]))
|
||||
# Keep the shared hidden state observable before publishing the restore.
|
||||
await create_timer(1.0).timeout
|
||||
assert(service.request_guide_visibility(canvas_id, true))
|
||||
await create_timer(1.0).timeout
|
||||
assert(service.request_guide_visibility(canvas_id, false, true))
|
||||
await create_timer(1.0).timeout
|
||||
assert(service.clear_session_artwork())
|
||||
await create_timer(1.0).timeout
|
||||
print("Surface drawing multiplayer host validation: PASS")
|
||||
session.disconnect_session("")
|
||||
main.queue_free()
|
||||
await process_frame
|
||||
quit()
|
||||
|
||||
|
||||
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() + WAIT_MSEC
|
||||
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())
|
||||
assert(session.supports_server_capability(
|
||||
SurfaceDrawingProtocol.CAPABILITY
|
||||
))
|
||||
|
||||
var service := main.get_node(
|
||||
"%NetworkSurfaceDrawingService"
|
||||
) as NetworkSurfaceDrawingService
|
||||
var snapshot_deadline: int = Time.get_ticks_msec() + WAIT_MSEC
|
||||
while (
|
||||
Time.get_ticks_msec() < snapshot_deadline
|
||||
and service.get_canvas_ids().is_empty()
|
||||
):
|
||||
await process_frame
|
||||
assert(service.get_canvas_ids().size() == 1)
|
||||
var canvas_id: String = service.get_canvas_ids()[0]
|
||||
var snapshot: Dictionary = service.get_canvas_state(canvas_id)
|
||||
assert(str(_find_cell(snapshot, 7, 7).get("color_id", "")) == "coral")
|
||||
assert(service.request_cell_edits(canvas_id, [{
|
||||
"x": 7,
|
||||
"y": 7,
|
||||
"color_id": "blue",
|
||||
}]))
|
||||
|
||||
var shared_edit_deadline: int = Time.get_ticks_msec() + WAIT_MSEC
|
||||
while Time.get_ticks_msec() < shared_edit_deadline:
|
||||
await process_frame
|
||||
var state: Dictionary = service.get_canvas_state(canvas_id)
|
||||
if str(_find_cell(state, 8, 7).get("color_id", "")) == "sunny":
|
||||
break
|
||||
var final_state: Dictionary = service.get_canvas_state(canvas_id)
|
||||
assert(str(_find_cell(final_state, 7, 7)["color_id"]) == "blue")
|
||||
assert(str(_find_cell(final_state, 8, 7)["color_id"]) == "sunny")
|
||||
assert(service.request_undo_last_stroke())
|
||||
var undo_deadline: int = Time.get_ticks_msec() + WAIT_MSEC
|
||||
while Time.get_ticks_msec() < undo_deadline:
|
||||
await process_frame
|
||||
var state: Dictionary = service.get_canvas_state(canvas_id)
|
||||
if str(_find_cell(state, 7, 7).get("color_id", "")) == "coral":
|
||||
break
|
||||
assert(
|
||||
str(_find_cell(service.get_canvas_state(canvas_id), 7, 7)["color_id"])
|
||||
== "coral"
|
||||
)
|
||||
assert(service.request_guide_visibility(canvas_id, false))
|
||||
var guide_hidden_deadline: int = Time.get_ticks_msec() + WAIT_MSEC
|
||||
while Time.get_ticks_msec() < guide_hidden_deadline:
|
||||
await process_frame
|
||||
if not bool(service.get_canvas_state(canvas_id).get("guide_visible", true)):
|
||||
break
|
||||
assert(not bool(service.get_canvas_state(canvas_id)["guide_visible"]))
|
||||
var guide_restored_deadline: int = Time.get_ticks_msec() + WAIT_MSEC
|
||||
while Time.get_ticks_msec() < guide_restored_deadline:
|
||||
await process_frame
|
||||
if bool(service.get_canvas_state(canvas_id).get("guide_visible", false)):
|
||||
break
|
||||
assert(bool(service.get_canvas_state(canvas_id)["guide_visible"]))
|
||||
var finalized_deadline: int = Time.get_ticks_msec() + WAIT_MSEC
|
||||
while Time.get_ticks_msec() < finalized_deadline:
|
||||
await process_frame
|
||||
if bool(service.get_canvas_state(canvas_id).get("finalized", false)):
|
||||
break
|
||||
assert(bool(service.get_canvas_state(canvas_id)["finalized"]))
|
||||
var reset_deadline: int = Time.get_ticks_msec() + WAIT_MSEC
|
||||
while Time.get_ticks_msec() < reset_deadline:
|
||||
await process_frame
|
||||
if service.get_canvas_ids().is_empty():
|
||||
break
|
||||
assert(service.get_canvas_ids().is_empty())
|
||||
print("Surface drawing multiplayer client validation: PASS")
|
||||
session.disconnect_session("")
|
||||
main.queue_free()
|
||||
await process_frame
|
||||
quit()
|
||||
|
||||
|
||||
func _surface_below_local_player(main: Node) -> Dictionary:
|
||||
var player := main.get("_player") as Player
|
||||
var query := PhysicsRayQueryParameters3D.create(
|
||||
player.global_position + Vector3.UP * 3.0,
|
||||
player.global_position + Vector3.DOWN * 6.0,
|
||||
1,
|
||||
)
|
||||
query.collide_with_areas = false
|
||||
query.collide_with_bodies = true
|
||||
query.exclude = [player.get_rid()]
|
||||
return player.get_world_3d().direct_space_state.intersect_ray(query)
|
||||
|
||||
|
||||
func _wait_for_remote_peer(session: NetworkSession) -> int:
|
||||
var deadline: int = Time.get_ticks_msec() + WAIT_MSEC
|
||||
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 _find_cell(state: Dictionary, x: int, y: int) -> Dictionary:
|
||||
for value: Variant in state.get("cells", []):
|
||||
if typeof(value) != TYPE_DICTIONARY:
|
||||
continue
|
||||
var cell: Dictionary = value
|
||||
if int(cell.get("x", -1)) == x and int(cell.get("y", -1)) == y:
|
||||
return cell
|
||||
return {}
|
||||
|
||||
|
||||
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
|
||||
1
tests/surface_drawing_multiplayer_validation.gd.uid
Normal file
1
tests/surface_drawing_multiplayer_validation.gd.uid
Normal file
|
|
@ -0,0 +1 @@
|
|||
uid://bj5dje2scya34
|
||||
161
tests/surface_drawing_runtime_validation.gd
Normal file
161
tests/surface_drawing_runtime_validation.gd
Normal file
|
|
@ -0,0 +1,161 @@
|
|||
extends SceneTree
|
||||
|
||||
const MainScene: PackedScene = preload("res://main/main.tscn")
|
||||
const TEST_PORT: int = 18132
|
||||
|
||||
|
||||
func _initialize() -> void:
|
||||
call_deferred("_run")
|
||||
|
||||
|
||||
func _run() -> void:
|
||||
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")))
|
||||
var session := main.get_node("%NetworkSession") as NetworkSession
|
||||
assert(session.start_private_host(TEST_PORT))
|
||||
var save_manager := main.get("_save_manager") as PlayerSaveManager
|
||||
assert(save_manager.initialize_new_game())
|
||||
main.call("_enter_gameplay")
|
||||
await physics_frame
|
||||
await physics_frame
|
||||
|
||||
var player := main.get("_player") as Player
|
||||
var service := main.get_node(
|
||||
"%NetworkSurfaceDrawingService"
|
||||
) as NetworkSurfaceDrawingService
|
||||
assert(service != null)
|
||||
assert(session.supports_server_capability(SurfaceDrawingProtocol.CAPABILITY))
|
||||
_validate_marker_controls(service, player)
|
||||
var query := PhysicsRayQueryParameters3D.create(
|
||||
player.global_position + Vector3.UP * 3.0,
|
||||
player.global_position + Vector3.DOWN * 6.0,
|
||||
1,
|
||||
)
|
||||
query.collide_with_areas = false
|
||||
query.collide_with_bodies = true
|
||||
query.exclude = [player.get_rid()]
|
||||
var hit: Dictionary = player.get_world_3d().direct_space_state.intersect_ray(query)
|
||||
assert(not hit.is_empty())
|
||||
assert(service.request_canvas_at_surface(
|
||||
hit["position"], hit["normal"], Vector3.RIGHT
|
||||
))
|
||||
assert(service.get_canvas_ids().size() == 1)
|
||||
var canvas_id: String = service.get_canvas_ids()[0]
|
||||
assert(service.request_cell_edits(canvas_id, [{
|
||||
"x": 8,
|
||||
"y": 8,
|
||||
"color_id": "ocean_teal",
|
||||
}]))
|
||||
var state: Dictionary = service.get_canvas_state(canvas_id)
|
||||
assert(int(state["revision"]) == 1)
|
||||
assert((state["cells"] as Array).size() == 1)
|
||||
assert(state["cells"][0]["color_id"] == "ocean_teal")
|
||||
assert(
|
||||
state["cells"][0]["author_fingerprint"]
|
||||
== session.get_local_identity_fingerprint()
|
||||
)
|
||||
assert(service.request_guide_visibility(canvas_id, false))
|
||||
state = service.get_canvas_state(canvas_id)
|
||||
assert(not bool(state["guide_visible"]))
|
||||
var canvas_nodes: Dictionary = service.get("_canvas_nodes")
|
||||
var canvas := canvas_nodes[canvas_id] as SurfaceDrawingCanvas
|
||||
assert(not canvas.is_guide_visible())
|
||||
assert(service.request_guide_visibility(canvas_id, true))
|
||||
assert(bool(service.get_canvas_state(canvas_id)["guide_visible"]))
|
||||
assert(service.request_guide_visibility(canvas_id, false, true))
|
||||
assert(bool(service.get_canvas_state(canvas_id)["finalized"]))
|
||||
assert(canvas.is_finalized())
|
||||
assert(service.request_canvas_at_surface(
|
||||
hit["position"], hit["normal"], Vector3.RIGHT
|
||||
))
|
||||
assert(service.get_canvas_ids().size() == 2)
|
||||
var replacement_canvas_id: String = ""
|
||||
for candidate_id: String in service.get_canvas_ids():
|
||||
if candidate_id != canvas_id:
|
||||
replacement_canvas_id = candidate_id
|
||||
assert(not replacement_canvas_id.is_empty())
|
||||
assert(service.request_cell_edits(replacement_canvas_id, [{
|
||||
"x": 8,
|
||||
"y": 8,
|
||||
"color_id": "blue",
|
||||
}]))
|
||||
assert((service.get_canvas_state(canvas_id)["cells"] as Array).is_empty())
|
||||
assert(
|
||||
str(service.get_canvas_state(replacement_canvas_id)["cells"][0]["color_id"])
|
||||
== "blue"
|
||||
)
|
||||
assert(service.request_undo_last_stroke())
|
||||
assert((service.get_canvas_state(replacement_canvas_id)["cells"] as Array).is_empty())
|
||||
assert(
|
||||
str(service.get_canvas_state(canvas_id)["cells"][0]["color_id"])
|
||||
== "ocean_teal"
|
||||
)
|
||||
var player_list := main.get_node(
|
||||
"%NetworkPlayerListService"
|
||||
) as NetworkPlayerListService
|
||||
assert(player_list.get_session_artwork_counts() == Vector2i(2, 1))
|
||||
assert(player_list.reset_session_artwork())
|
||||
assert(service.get_canvas_ids().is_empty())
|
||||
|
||||
print("Surface drawing runtime validation: PASS")
|
||||
session.disconnect_session("")
|
||||
main.queue_free()
|
||||
await process_frame
|
||||
quit()
|
||||
|
||||
|
||||
func _validate_marker_controls(
|
||||
service: NetworkSurfaceDrawingService,
|
||||
player: Player,
|
||||
) -> void:
|
||||
var prior_mouse_mode: Input.MouseMode = Input.mouse_mode
|
||||
service.activate()
|
||||
assert(service.is_active())
|
||||
assert(not service.is_placement_mode())
|
||||
if DisplayServer.get_name() != "headless":
|
||||
assert(Input.mouse_mode == Input.MOUSE_MODE_CAPTURED)
|
||||
|
||||
var placement_key := InputEventKey.new()
|
||||
placement_key.physical_keycode = KEY_R
|
||||
placement_key.pressed = true
|
||||
assert(service.handle_input(placement_key, true))
|
||||
assert(service.is_placement_mode())
|
||||
|
||||
var pointer_before: Vector2 = service.get_pointer_screen_position()
|
||||
var pointer_motion := InputEventMouseMotion.new()
|
||||
pointer_motion.screen_relative = Vector2(30.0, -12.0)
|
||||
assert(service.handle_input(pointer_motion, true))
|
||||
assert(service.get_pointer_screen_position() != pointer_before)
|
||||
var zoom_event := InputEventMouseButton.new()
|
||||
zoom_event.button_index = MOUSE_BUTTON_WHEEL_UP
|
||||
zoom_event.shift_pressed = true
|
||||
zoom_event.pressed = true
|
||||
assert(not service.handle_input(zoom_event, true))
|
||||
var prior_zoom: float = float(player.get("_target_zoom"))
|
||||
player.call("_unhandled_input", zoom_event)
|
||||
assert(float(player.get("_target_zoom")) < prior_zoom)
|
||||
|
||||
var camera_press := InputEventMouseButton.new()
|
||||
camera_press.button_index = MOUSE_BUTTON_RIGHT
|
||||
camera_press.pressed = true
|
||||
assert(not service.handle_input(camera_press, true))
|
||||
var pointer_before_camera: Vector2 = service.get_pointer_screen_position()
|
||||
assert(not service.handle_input(pointer_motion, true))
|
||||
assert(service.get_pointer_screen_position() == pointer_before_camera)
|
||||
var camera_release := InputEventMouseButton.new()
|
||||
camera_release.button_index = MOUSE_BUTTON_RIGHT
|
||||
camera_release.pressed = false
|
||||
assert(not service.handle_input(camera_release, true))
|
||||
|
||||
assert(service.handle_input(placement_key, true))
|
||||
assert(not service.is_placement_mode())
|
||||
service.deactivate()
|
||||
assert(Input.mouse_mode == prior_mouse_mode)
|
||||
1
tests/surface_drawing_runtime_validation.gd.uid
Normal file
1
tests/surface_drawing_runtime_validation.gd.uid
Normal file
|
|
@ -0,0 +1 @@
|
|||
uid://8c30wxeu4lxv
|
||||
284
tests/surface_drawing_validation.gd
Normal file
284
tests/surface_drawing_validation.gd
Normal file
|
|
@ -0,0 +1,284 @@
|
|||
extends SceneTree
|
||||
|
||||
const FINGERPRINT_A: String = (
|
||||
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
||||
)
|
||||
const FINGERPRINT_B: String = (
|
||||
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
|
||||
)
|
||||
|
||||
|
||||
func _initialize() -> void:
|
||||
call_deferred("_run")
|
||||
|
||||
|
||||
func _run() -> void:
|
||||
_validate_palette()
|
||||
_validate_protocol_bounds()
|
||||
_validate_grid_snapping()
|
||||
await _validate_canvas_geometry_and_collaboration()
|
||||
await _validate_blocked_author_visibility()
|
||||
_validate_peer_capability_tracking()
|
||||
print("Surface drawing validation: PASS")
|
||||
quit()
|
||||
|
||||
|
||||
func _validate_palette() -> void:
|
||||
var ids: Array[StringName] = SurfaceDrawingPalette.get_color_ids()
|
||||
assert(ids.size() == 8)
|
||||
assert(ids.front() == SurfaceDrawingPalette.DEFAULT_COLOR_ID)
|
||||
for color_id: StringName in ids:
|
||||
assert(SurfaceDrawingPalette.has_color(color_id))
|
||||
assert(not SurfaceDrawingPalette.get_display_name(color_id).is_empty())
|
||||
assert(
|
||||
SurfaceDrawingPalette.filter_unlocked_ids([])
|
||||
== [SurfaceDrawingPalette.DEFAULT_COLOR_ID]
|
||||
)
|
||||
|
||||
|
||||
func _validate_protocol_bounds() -> void:
|
||||
assert(SurfaceDrawingProtocol.GRID_WIDTH == 32)
|
||||
assert(SurfaceDrawingProtocol.GRID_HEIGHT == 32)
|
||||
assert(is_equal_approx(SurfaceDrawingProtocol.CELL_SIZE, 0.075))
|
||||
assert(is_equal_approx(
|
||||
float(SurfaceDrawingProtocol.GRID_WIDTH)
|
||||
* SurfaceDrawingProtocol.CELL_SIZE,
|
||||
2.4,
|
||||
))
|
||||
var canvas_request: Dictionary = {
|
||||
"request_id": "canvas-1",
|
||||
"session_id": "session",
|
||||
"origin": [0.0, 1.0, 2.0],
|
||||
"normal": [0.0, 1.0, 0.0],
|
||||
"tangent": [1.0, 0.0, 0.0],
|
||||
"width": SurfaceDrawingProtocol.GRID_WIDTH,
|
||||
"height": SurfaceDrawingProtocol.GRID_HEIGHT,
|
||||
"cell_size": SurfaceDrawingProtocol.CELL_SIZE,
|
||||
}
|
||||
assert(SurfaceDrawingProtocol.validate_canvas_request(canvas_request))
|
||||
var malformed: Dictionary = canvas_request.duplicate(true)
|
||||
malformed["origin"] = [INF, 0.0, 0.0]
|
||||
assert(not SurfaceDrawingProtocol.validate_canvas_request(malformed))
|
||||
var edit_request: Dictionary = {
|
||||
"request_id": "edit-1",
|
||||
"session_id": "session",
|
||||
"canvas_id": "canvas-1",
|
||||
"stroke_id": "stroke-1",
|
||||
"edits": [{"x": 0, "y": 0, "color_id": "ocean_teal"}],
|
||||
}
|
||||
assert(SurfaceDrawingProtocol.validate_edit_request(edit_request))
|
||||
edit_request["edits"] = [{
|
||||
"x": SurfaceDrawingProtocol.GRID_WIDTH,
|
||||
"y": 0,
|
||||
"color_id": "ocean_teal",
|
||||
}]
|
||||
assert(not SurfaceDrawingProtocol.validate_edit_request(edit_request))
|
||||
var guide_request: Dictionary = {
|
||||
"request_id": "guide-1",
|
||||
"session_id": "session",
|
||||
"canvas_id": "canvas-1",
|
||||
"guide_visible": false,
|
||||
"finalized": false,
|
||||
}
|
||||
assert(SurfaceDrawingProtocol.validate_guide_request(guide_request))
|
||||
guide_request["guide_visible"] = 0
|
||||
assert(not SurfaceDrawingProtocol.validate_guide_request(guide_request))
|
||||
var undo_request: Dictionary = {
|
||||
"request_id": "undo-1",
|
||||
"session_id": "session",
|
||||
"stroke_id": "stroke-1",
|
||||
}
|
||||
assert(SurfaceDrawingProtocol.validate_undo_request(undo_request))
|
||||
|
||||
|
||||
func _validate_grid_snapping() -> void:
|
||||
var anchor: Dictionary = {
|
||||
"session_id": "session",
|
||||
"canvas_id": "anchor",
|
||||
"origin": [0.0, 0.0, 0.0],
|
||||
"normal": [0.0, 1.0, 0.0],
|
||||
"tangent": [1.0, 0.0, 0.0],
|
||||
"width": SurfaceDrawingProtocol.GRID_WIDTH,
|
||||
"height": SurfaceDrawingProtocol.GRID_HEIGHT,
|
||||
"cell_size": SurfaceDrawingProtocol.CELL_SIZE,
|
||||
"revision": 0,
|
||||
"guide_visible": false,
|
||||
"finalized": true,
|
||||
"layer": 1,
|
||||
"creator_fingerprint": FINGERPRINT_A,
|
||||
"cells": [],
|
||||
}
|
||||
var snapped: Dictionary = SurfaceDrawingPlacement.resolve(
|
||||
Vector3(2.28, 0.02, 0.08),
|
||||
Vector3.UP,
|
||||
Vector3.RIGHT,
|
||||
[anchor],
|
||||
)
|
||||
assert(bool(snapped["snapped"]))
|
||||
var snapped_origin: Vector3 = snapped["origin"]
|
||||
assert(snapped_origin.is_equal_approx(Vector3(2.4, 0.0, 0.0)))
|
||||
var unsnapped: Dictionary = SurfaceDrawingPlacement.resolve(
|
||||
Vector3(1.2, 0.0, 0.0),
|
||||
Vector3.UP,
|
||||
Vector3.RIGHT,
|
||||
[anchor],
|
||||
)
|
||||
assert(not bool(unsnapped["snapped"]))
|
||||
|
||||
|
||||
func _validate_canvas_geometry_and_collaboration() -> void:
|
||||
var world := Node3D.new()
|
||||
root.add_child(world)
|
||||
var canvas := SurfaceDrawingCanvas.new()
|
||||
world.add_child(canvas)
|
||||
var state: Dictionary = {
|
||||
"session_id": "session",
|
||||
"canvas_id": "canvas-1",
|
||||
"origin": [0.0, 0.0, 0.0],
|
||||
"normal": [0.0, 1.0, 0.0],
|
||||
"tangent": [1.0, 0.0, 0.0],
|
||||
"width": SurfaceDrawingProtocol.GRID_WIDTH,
|
||||
"height": SurfaceDrawingProtocol.GRID_HEIGHT,
|
||||
"cell_size": SurfaceDrawingProtocol.CELL_SIZE,
|
||||
"revision": 0,
|
||||
"creator_fingerprint": FINGERPRINT_A,
|
||||
"cells": [],
|
||||
}
|
||||
assert(canvas.setup(state, null))
|
||||
var first_center: Vector3 = canvas.get_cell_world_position(0, 0)
|
||||
assert(canvas.cell_at_world_point(first_center) == Vector2i(0, 0))
|
||||
assert(canvas.contains_world_point(first_center))
|
||||
var first_update: Dictionary = {
|
||||
"session_id": "session",
|
||||
"canvas_id": "canvas-1",
|
||||
"revision": 1,
|
||||
"edits": [{
|
||||
"x": 3,
|
||||
"y": 4,
|
||||
"color_id": "coral",
|
||||
"author_fingerprint": FINGERPRINT_A,
|
||||
}],
|
||||
}
|
||||
assert(canvas.apply_update(first_update))
|
||||
var finish_update: Dictionary = {
|
||||
"session_id": "session",
|
||||
"canvas_id": "canvas-1",
|
||||
"revision": 2,
|
||||
"guide_visible": false,
|
||||
"finalized": true,
|
||||
}
|
||||
assert(canvas.apply_guide_update(finish_update))
|
||||
assert(not canvas.is_guide_visible())
|
||||
assert(canvas.is_finalized())
|
||||
await process_frame
|
||||
var finished_pixel_scale: float = canvas.get_rendered_pixel_size()
|
||||
assert(
|
||||
is_equal_approx(
|
||||
finished_pixel_scale, SurfaceDrawingProtocol.CELL_SIZE
|
||||
),
|
||||
"finished pixel scale %f does not match cell size %f"
|
||||
% [finished_pixel_scale, SurfaceDrawingProtocol.CELL_SIZE],
|
||||
)
|
||||
var second_update: Dictionary = {
|
||||
"session_id": "session",
|
||||
"canvas_id": "canvas-1",
|
||||
"revision": 3,
|
||||
"edits": [{
|
||||
"x": 3,
|
||||
"y": 4,
|
||||
"color_id": "blue",
|
||||
"author_fingerprint": FINGERPRINT_B,
|
||||
}],
|
||||
}
|
||||
assert(canvas.apply_update(second_update))
|
||||
var cells: Array[Dictionary] = canvas.get_authoritative_cells()
|
||||
assert(cells.size() == 1)
|
||||
assert(cells[0]["color_id"] == "blue")
|
||||
assert(cells[0]["author_fingerprint"] == FINGERPRINT_B)
|
||||
var erase_update: Dictionary = {
|
||||
"session_id": "session",
|
||||
"canvas_id": "canvas-1",
|
||||
"revision": 4,
|
||||
"edits": [{
|
||||
"x": 3,
|
||||
"y": 4,
|
||||
"color_id": "",
|
||||
"author_fingerprint": "",
|
||||
}],
|
||||
}
|
||||
assert(canvas.apply_update(erase_update))
|
||||
assert(canvas.get_authoritative_cells().is_empty())
|
||||
world.queue_free()
|
||||
await process_frame
|
||||
|
||||
|
||||
func _validate_peer_capability_tracking() -> void:
|
||||
var registry := PeerRegistry.new()
|
||||
assert(registry.add_peer(
|
||||
1,
|
||||
"profile",
|
||||
"Voyager",
|
||||
NetworkProtocol.PROTOCOL_VERSION,
|
||||
FINGERPRINT_A,
|
||||
"public key fixture",
|
||||
PackedStringArray([str(SurfaceDrawingProtocol.CAPABILITY)]),
|
||||
))
|
||||
var record: PeerRegistry.PeerRecord = registry.get_peer(1)
|
||||
assert(record != null)
|
||||
assert(str(SurfaceDrawingProtocol.CAPABILITY) in record.capability_flags)
|
||||
|
||||
|
||||
func _validate_blocked_author_visibility() -> void:
|
||||
var relationships := PlayerRelationshipStore.new()
|
||||
relationships.set("_loaded", true)
|
||||
relationships.set("_records", {
|
||||
FINGERPRINT_B: {"blocked": true, "muted": true},
|
||||
})
|
||||
var world := Node3D.new()
|
||||
root.add_child(world)
|
||||
var canvas := SurfaceDrawingCanvas.new()
|
||||
world.add_child(canvas)
|
||||
var state: Dictionary = {
|
||||
"session_id": "session",
|
||||
"canvas_id": "blocked-author-canvas",
|
||||
"origin": [0.0, 0.0, 0.0],
|
||||
"normal": [0.0, 1.0, 0.0],
|
||||
"tangent": [1.0, 0.0, 0.0],
|
||||
"width": SurfaceDrawingProtocol.GRID_WIDTH,
|
||||
"height": SurfaceDrawingProtocol.GRID_HEIGHT,
|
||||
"cell_size": SurfaceDrawingProtocol.CELL_SIZE,
|
||||
"revision": 1,
|
||||
"creator_fingerprint": FINGERPRINT_A,
|
||||
"cells": [
|
||||
{
|
||||
"x": 1,
|
||||
"y": 1,
|
||||
"color_id": "coral",
|
||||
"author_fingerprint": FINGERPRINT_A,
|
||||
},
|
||||
{
|
||||
"x": 2,
|
||||
"y": 1,
|
||||
"color_id": "blue",
|
||||
"author_fingerprint": FINGERPRINT_B,
|
||||
},
|
||||
],
|
||||
}
|
||||
assert(canvas.setup(state, relationships))
|
||||
assert(_rendered_pixel_count(canvas) == 1)
|
||||
relationships.set("_records", {})
|
||||
canvas.refresh_relationship_visibility()
|
||||
await process_frame
|
||||
assert(_rendered_pixel_count(canvas) == 2)
|
||||
world.queue_free()
|
||||
await process_frame
|
||||
|
||||
|
||||
func _rendered_pixel_count(canvas: SurfaceDrawingCanvas) -> int:
|
||||
var count: int = 0
|
||||
for child: Node in canvas.get_children():
|
||||
if child is MultiMeshInstance3D:
|
||||
var instance := child as MultiMeshInstance3D
|
||||
if instance.multimesh != null:
|
||||
count += instance.multimesh.instance_count
|
||||
return count
|
||||
1
tests/surface_drawing_validation.gd.uid
Normal file
1
tests/surface_drawing_validation.gd.uid
Normal file
|
|
@ -0,0 +1 @@
|
|||
uid://dui5ueufqooul
|
||||
Loading…
Add table
Add a link
Reference in a new issue