Randoloot/tests/levels/system_lifecycle_test.gd

extends Node

const GAME_SCENE := preload("res://scenes/game/game.tscn")
const ITEM_GENERATOR := preload("res://scripts/items/item_generator.gd")

func _ready() -> void:
	GameState.start_new_run()
	GameState.system_seed = 314159
	var game := GAME_SCENE.instantiate() as Node2D
	get_tree().root.call_deferred("add_child", game)
	await get_tree().process_frame
	await get_tree().process_frame
	get_tree().current_scene = game
	_freeze(game)
	assert(GameState.system_level == 1 and int(game.call("get_remaining_enemies")) == 5)
	assert(not game.has_node("WeaponTestTarget"))
	assert(game.get_node("CelestialBodies").get_child_count() >= 2)
	var player := game.get_node("PlayerShip") as CharacterBody2D
	var inventory := player.get_node("ShipInventory") as ShipInventory
	var weapon := ITEM_GENERATOR.generate_for_definition(preload("res://resources/items/beam_laser.tres"), 1)
	weapon.damage_min = 1
	weapon.damage_max = 5
	var free_slot := inventory.cargo.find(null)
	assert(inventory.add_item(weapon))
	assert(inventory.move_item("cargo", free_slot, "weapon", 0))
	assert(inventory.move_item("cargo", 2, "module", 0))
	var equipped_module := inventory.get_item("module", 0)
	var tooltip := weapon.get_tooltip_text()
	var initial_data: Dictionary = game.get("system_data")
	var initial_seed := GameState.system_seed
	var planet: Node2D = game.get("protected_planet")
	player.position = planet.position
	game.call("_physics_process", 0.0)
	var menu: Control = game.get("services_menu")
	assert(not menu.visible and not bool(game.call("advance_to_next_level")))
	_clear_enemies(game)
	game.call("_physics_process", 0.0)
	assert(menu.visible and bool(player.get("is_docked")))
	assert(bool(game.get("system_cleared")) and bool(planet.get("is_safe")))
	var previous_hull := float(player.get("hull"))
	player.call("take_damage", 100000.0)
	assert(float(player.get("hull")) == previous_hull)
	menu.call("_close")
	game.call("_physics_process", 0.0)
	assert(not menu.visible and not bool(player.get("is_docked")))
	player.position = initial_data["player_start"]
	game.call("_physics_process", 0.0)
	player.position = planet.position
	game.call("_physics_process", 0.0)
	assert(menu.visible)
	menu.call("_close")
	player.position = initial_data["player_start"]
	player.call("take_damage", 100000.0)
	await get_tree().create_timer(1.3).timeout
	game = get_tree().current_scene as Node2D
	_freeze(game)
	player = game.get_node("PlayerShip") as CharacterBody2D
	inventory = player.get_node("ShipInventory") as ShipInventory
	assert(GameState.system_level == 1 and GameState.system_seed == initial_seed)
	assert(game.get("system_data") == initial_data)
	assert(int(game.call("get_remaining_enemies")) == 5)
	assert(inventory.get_item("weapon", 0) == weapon)
	assert(inventory.get_item("module", 0) == equipped_module)
	assert(weapon.get_tooltip_text() == tooltip)
	_assert_full_resources(player)
	_clear_enemies(game)
	planet = game.get("protected_planet")
	player.position = planet.position
	game.call("_physics_process", 0.0)
	assert(bool(game.call("advance_to_next_level")))
	assert(not bool(game.call("advance_to_next_level")))
	await get_tree().process_frame
	await get_tree().process_frame
	await get_tree().process_frame
	game = get_tree().current_scene as Node2D
	_freeze(game)
	player = game.get_node("PlayerShip") as CharacterBody2D
	inventory = player.get_node("ShipInventory") as ShipInventory
	assert(GameState.system_level == 2 and GameState.system_seed != initial_seed)
	assert(game.get("system_data") != initial_data)
	assert(inventory.get_item("weapon", 0) == weapon and inventory.get_item("module", 0) == equipped_module)
	assert(weapon.get_tooltip_text() == tooltip)
	_assert_full_resources(player)
	var enemy := get_tree().get_nodes_in_group("enemies")[0] as CharacterBody2D
	enemy.call("apply_level_settings", 2, 2)
	assert(float(enemy.get("max_hull")) > 300.0)
	enemy.call("take_damage", 100000.0)
	await get_tree().process_frame
	await get_tree().process_frame
	var found_level_two_loot := false
	for loot in get_tree().get_nodes_in_group("loot"):
		if game.is_ancestor_of(loot):
			assert(int(loot.get("item").get("item_level")) == 2)
			found_level_two_loot = true
	assert(found_level_two_loot)
	inventory.preserve_for_restart()
	GameState.system_level = 1000
	assert(get_tree().reload_current_scene() == OK)
	await get_tree().process_frame
	await get_tree().process_frame
	await get_tree().process_frame
	game = get_tree().current_scene as Node2D
	_freeze(game)
	assert(int(game.call("get_remaining_enemies")) == 40)
	_clear_enemies(game)
	player = game.get_node("PlayerShip") as CharacterBody2D
	planet = game.get("protected_planet")
	player.position = planet.position
	game.call("_physics_process", 0.0)
	menu = game.get("services_menu")
	assert(menu.visible)
	assert(bool(menu.get_node("Center/Panel/Contents/NextButton").get("disabled")))
	assert(not bool(game.call("advance_to_next_level")))
	print("SYSTEM_LIFECYCLE_TEST: PASS (locked services, docking, retry, inventory preservation, next level, scaled loot and level cap)")

func _freeze(game: Node2D) -> void:
	game.set_physics_process(false)
	game.get_node("PlayerShip").set_physics_process(false)
	game.get_node("PlayerShip/WeaponController").set_physics_process(false)
	for enemy in get_tree().get_nodes_in_group("enemies"):
		if game.is_ancestor_of(enemy):
			enemy.set_physics_process(false)

func _clear_enemies(game: Node2D) -> void:
	for enemy in get_tree().get_nodes_in_group("enemies"):
		if game.is_ancestor_of(enemy):
			enemy.call("take_damage", 100000.0)

func _assert_full_resources(player: CharacterBody2D) -> void:
	for resource in ["hull", "shields", "energy"]:
		assert(is_equal_approx(float(player.get(resource)), float(player.get("max_" + resource))))