straywild/tests/message_bottle_reader_validation.gd

extends SceneTree

const ReaderScene: PackedScene = preload(
	"res://ui/message_bottle_reader.tscn"
)
const PlayerMenuScene: PackedScene = preload("res://ui/player_menu.tscn")
const ItemCatalogResource: ItemCatalog = preload(
	"res://items/catalog/item_catalog.tres"
)
const BottleCatalog: BottleMessageCatalog = preload(
	"res://messages/catalog/bottle_message_catalog.tres"
)


class FakeSaveManager:
	extends PlayerSaveManager

	func save_if_dirty() -> bool:
		return true


func _initialize() -> void:
	_run.call_deferred()


func _run() -> void:
	root.size = Vector2i(1280, 720)
	var prior_button := Button.new()
	prior_button.text = "inventory slot"
	root.add_child(prior_button)
	prior_button.grab_focus()

	var reader := ReaderScene.instantiate() as MessageBottleReader
	root.add_child(reader)
	await process_frame
	assert(not reader.is_open())
	assert(reader.mouse_filter == Control.MOUSE_FILTER_STOP)
	assert(reader.find_children("*", "ColorRect", true, false).is_empty())
	assert(reader.find_child("Title", true, false) == null)
	var parchment := reader.get_node("%ParchmentSurface") as Control
	var parchment_art := reader.get_node("%ParchmentArt") as TextureRect
	var fallback_panel := reader.get_node("%FallbackPanel") as Control
	assert(parchment_art.texture != null)
	assert(parchment_art.texture.resource_path.ends_with("parchment.png"))
	assert(parchment_art.texture.get_size() == Vector2(256.0, 192.0))
	assert(parchment_art.visible)
	assert(not fallback_panel.visible)
	assert(is_equal_approx(
		parchment.custom_minimum_size.x / parchment.custom_minimum_size.y,
		4.0 / 3.0,
	))

	var observed := {"closed_count": 0}
	reader.closed.connect(
		func() -> void: observed["closed_count"] += 1
	)
	reader.present("it's as simple as pushing squares")
	await process_frame
	assert(reader.is_open())
	var message := reader.get_node("%MessageLabel") as Label
	var close_button := reader.get_node("%CloseButton") as Button
	assert(message.text == "it's as simple as pushing squares")
	assert(root.gui_get_focus_owner() == close_button)

	reader.present("a replacement message")
	await process_frame
	assert(message.text == "a replacement message")
	assert(reader.consume_escape())
	await process_frame
	assert(not reader.is_open())
	assert(int(observed["closed_count"]) == 1)
	assert(root.gui_get_focus_owner() == prior_button)
	assert(not reader.consume_escape())

	root.size = Vector2i(480, 270)
	reader.present("small viewport")
	await process_frame
	assert(parchment.size.x <= 448.0)
	assert(parchment.size.y <= 238.0)
	assert(absf(parchment.size.x / parchment.size.y - 4.0 / 3.0) < 0.01)
	reader.queue_free()
	prior_button.queue_free()
	await process_frame

	await _validate_player_menu_controller_open_and_close()

	print("Message bottle reader validation: PASS")
	quit(0)


func _validate_player_menu_controller_open_and_close() -> void:
	root.size = Vector2i(1280, 720)
	var host := Node.new()
	root.add_child(host)
	var menu := PlayerMenuScene.instantiate() as PlayerMenu
	var bag := PlayerBag.new()
	var catches := FishInventory.new()
	var capacity := PlayerCoolerCapacity.new()
	var layout := PlayerInventoryLayout.new()
	var hotbar := PlayerHotbar.new()
	var state := PlayerBottleMessageState.new()
	var saves := FakeSaveManager.new()
	var service := BeachBottleService.new()
	for node: Node in [
		menu,
		bag,
		catches,
		capacity,
		layout,
		hotbar,
		state,
		saves,
		service,
	]:
		host.add_child(node)
	await process_frame

	bag.setup(ItemCatalogResource)
	var bottle_item: ItemData = ItemCatalogResource.get_item_by_id(&"message_bottle")
	assert(bottle_item != null)
	assert(bottle_item.icon != null)
	assert(bottle_item.icon.resource_path.ends_with("message_in_a_bottle.png"))
	assert(bottle_item.icon.get_size() == Vector2(64.0, 64.0))
	layout.setup(bag, catches, ItemCatalogResource, capacity)
	bag.set_inventory_layout(layout)
	catches.set_inventory_layout(layout)
	hotbar.setup(bag, ItemCatalogResource, catches, layout)
	assert(bag.add_item(&"message_bottle"))
	var now_unix: int = int(Time.get_unix_time_from_system())
	assert(state.restore_from_save_data({
		"schema_version": 1,
		"received_message_ids": ["pushing_squares"],
		"pending_message_id": "pushing_squares",
		"pending_bottle_picked_up": true,
		"next_bottle_at_unix": now_unix + 300000,
		"last_observed_unix": now_unix,
	}))
	service.set("_bag", bag)
	service.set("_state", state)
	service.set("_catalog", BottleCatalog)
	service.set("_save_manager", saves)
	menu.set("_bag", bag)
	menu.set("_inventory", catches)
	menu.set("_hotbar", hotbar)
	menu.set("_inventory_layout", layout)
	menu.set("_item_catalog", ItemCatalogResource)
	menu.setup_message_bottles(service)
	var inventory_grid := menu.get("_general_inventory_grid") as GeneralInventoryGrid
	inventory_grid.setup(
		layout,
		bag,
		catches,
		hotbar,
		ItemCatalogResource,
		PlayerInventoryLayout.InventoryContainer.INVENTORY,
	)
	menu.visible = true
	menu.call("_show_section_immediate", PlayerMenu.Section.BAG)
	menu.call("_set_shell_interactive", true)
	menu.set(
		"_controller_ownership",
		PlayerMenu.ControllerOwnership.ITEM_LIST,
	)
	menu.call("_apply_inventory_controller_zone_focus_modes")
	var bottle_slot: GeneralInventorySlot
	for slot: GeneralInventorySlot in inventory_grid.get_slots():
		if slot.entry_identity == &"message_bottle":
			bottle_slot = slot
			break
	assert(bottle_slot != null)
	bottle_slot.grab_focus()

	var accept := InputEventJoypadButton.new()
	accept.button_index = JOY_BUTTON_A
	accept.pressed = true
	assert(bool(menu.call("_handle_controller_ownership_input", accept)))
	accept.pressed = false
	assert(bool(menu.call("_handle_controller_ownership_input", accept)))
	await process_frame
	var menu_reader := menu.get_node("%MessageBottleReader") as MessageBottleReader
	assert(menu_reader.is_open())
	assert(
		(menu_reader.get_node("%MessageLabel") as Label).text
		== "it's as simple as pushing squares"
	)
	assert(not bag.owns_item(&"message_bottle"))
	assert(not state.has_pending_message())
	assert(
		(menu.get_node("%InventoryTab") as Button).focus_mode
		== Control.FOCUS_NONE
	)

	var cancel := InputEventJoypadButton.new()
	cancel.button_index = JOY_BUTTON_B
	cancel.pressed = true
	menu.call("_input", cancel)
	await process_frame
	assert(not menu_reader.is_open())
	assert(
		(menu.get_node("%InventoryTab") as Button).focus_mode
		== Control.FOCUS_ALL
	)
	host.queue_free()
	await process_frame