mtgodot-poc/project/test_solo_guild_domain_parity.gd

# test_solo_guild_domain_parity.gd —— 40250 个人公会领地与建筑建造 1:1 回归测试套件
extends SceneTree

const SoloGuildDomainSystem = preload("res://solo_guild_domain_system.gd")

var _passed := 0
var _failed := 0

func _assert(cond: bool, msg: String) -> void:
	if cond:
		_passed += 1
		print("  [PASS] %s" % msg)
	else:
		_failed += 1
		printerr("  [FAIL] %s" % msg)

func _init() -> void:
	print("\n=== Running test_solo_guild_domain_parity (Direction 2: Solo Guild Domain 1:1) ===")
	_test_claim_domain()
	_test_construct_and_upgrade_buildings()
	_test_guild_blacksmith_refining()
	_test_guardian_altar_passives()
	_finish()

func _test_claim_domain() -> void:
	print("\n--- Test 1: Claiming Guild Domain ---")
	var sys := SoloGuildDomainSystem.new()
	var poor_player := {"gold": 1000}

	# Fail on low gold
	var fail_gold = sys.claim_domain("神圣殿堂", 10, poor_player)
	_assert(fail_gold["ok"] == false and fail_gold["reason"] == "NOT_ENOUGH_GOLD", "Rejected: not enough gold")

	# Fail on low guild level
	var rich_player := {"gold": 50000000}
	var fail_lvl = sys.claim_domain("神圣殿堂", 8, rich_player)
	_assert(fail_lvl["ok"] == false and fail_lvl["reason"] == "GUILD_LEVEL_TOO_LOW", "Rejected: guild level < 10")

	# Success
	var claim_sig := {"fired": false, "name": "", "cost": 0}
	sys.domain_claimed.connect(func(gname: String, cost: int):
		claim_sig["fired"] = true
		claim_sig["name"] = gname
		claim_sig["cost"] = cost
	)

	var res = sys.claim_domain("神圣殿堂", 12, rich_player)
	_assert(res["ok"] == true, "Claimed domain")
	_assert(sys.has_domain == true, "has_domain is true")
	_assert(rich_player["gold"] == 30000000, "Cost 20M deducted (50M -> 30M)")
	_assert(claim_sig["fired"] == true and claim_sig["name"] == "神圣殿堂", "domain_claimed signal emitted")

	# Duplicate claim rejected
	var fail_dup = sys.claim_domain("再次开辟", 12, rich_player)
	_assert(fail_dup["ok"] == false and fail_dup["reason"] == "ALREADY_HAS_DOMAIN", "Duplicate claim rejected")

func _test_construct_and_upgrade_buildings() -> void:
	print("\n--- Test 2: Constructing & Upgrading Buildings ---")
	var sys := SoloGuildDomainSystem.new()
	var player := {"gold": 50000000}
	sys.claim_domain("东方荣耀", 10, player) # 50M -> 30M

	var build_sig := {"fired": false, "btype": 0}
	sys.building_constructed.connect(func(btype: int, _n: String, _l: int):
		build_sig["fired"] = true
		build_sig["btype"] = btype
	)

	# Construct Guild Blacksmith (10M gold)
	var c_res = sys.construct_building(SoloGuildDomainSystem.BuildingType.BLACKSMITH, player)
	_assert(c_res["ok"] == true, "Blacksmith constructed")
	_assert(player["gold"] == 20000000, "Cost 10M deducted (30M -> 20M)")
	_assert(sys.constructed_buildings.has(SoloGuildDomainSystem.BuildingType.BLACKSMITH), "Blacksmith in buildings list")
	_assert(build_sig["fired"] == true and build_sig["btype"] == 1, "building_constructed emitted")

	# Re-construct rejected
	var fail_c = sys.construct_building(SoloGuildDomainSystem.BuildingType.BLACKSMITH, player)
	_assert(fail_c["ok"] == false and fail_c["reason"] == "ALREADY_CONSTRUCTED", "Cannot build twice")

	# Upgrade Blacksmith (Lv 1 -> Lv 2, cost: 8M)
	var up_sig := {"fired": false, "lvl": 0}
	sys.building_upgraded.connect(func(_b: int, lvl: int):
		up_sig["fired"] = true
		up_sig["lvl"] = lvl
	)

	var up_res = sys.upgrade_building(SoloGuildDomainSystem.BuildingType.BLACKSMITH, player)
	_assert(up_res["ok"] == true and up_res["new_level"] == 2, "Upgraded Blacksmith to Lv 2")
	_assert(up_sig["fired"] == true and up_sig["lvl"] == 2, "building_upgraded emitted")
	_assert(player["gold"] == 12000000, "8M upgrade cost deducted (20M -> 12M)")

func _test_guild_blacksmith_refining() -> void:
	print("\n--- Test 3: Guild Blacksmith Enhanced Refining ---")
	var sys := SoloGuildDomainSystem.new()
	var player := {"gold": 50000000}
	sys.claim_domain("锻造公会", 10, player)
	sys.construct_building(SoloGuildDomainSystem.BuildingType.BLACKSMITH, player)

	var item := {"vnum": 10, "name": "巨剑", "refine_level": 7}

	var ref_sig := {"fired": false, "succ": false, "lvl": 0}
	sys.guild_refine_result.connect(func(succ: bool, lvl: int):
		ref_sig["fired"] = true
		ref_sig["succ"] = succ
		ref_sig["lvl"] = lvl
	)

	# Refine with force_success = true (+7 -> +8)
	var res1 = sys.guild_blacksmith_refine(item, player, true)
	_assert(res1["ok"] == true and res1["success"] == true, "Refined to +8")
	_assert(item["refine_level"] == 8, "Item refine level is now 8")
	_assert(ref_sig["fired"] == true and ref_sig["succ"] == true, "guild_refine_result emitted")

	# Refine to +9
	sys.guild_blacksmith_refine(item, player, true)
	_assert(item["refine_level"] == 9, "Item refine level is now 9 (+9 max)")

	# Further refine at +9 must fail
	var fail_max = sys.guild_blacksmith_refine(item, player, true)
	_assert(fail_max["ok"] == false and fail_max["reason"] == "ALREADY_MAX_REFINE", "Cannot refine past +9")

func _test_guardian_altar_passives() -> void:
	print("\n--- Test 4: Guild Guardian Altar Passive Auras ---")
	var sys := SoloGuildDomainSystem.new()
	var player := {"gold": 50000000}
	sys.claim_domain("神坛公会", 10, player)

	# No altar yet
	_assert(sys.get_altar_passive_buffs().is_empty(), "No buffs without Altar")

	# Build Guardian Altar (Lv 1)
	sys.construct_building(SoloGuildDomainSystem.BuildingType.GUARDIAN_ALTAR, player)
	var b1 = sys.get_altar_passive_buffs()
	_assert(b1["max_hp"] == 1500, "Lv 1 Altar gives +1500 Max HP")
	_assert(b1["exp_rate_pct"] == 10, "Lv 1 Altar gives +10% Exp")
	_assert(b1["all_stats"] == 5, "Lv 1 Altar gives +5 All Stats")

	# Upgrade Altar to Lv 2
	sys.upgrade_building(SoloGuildDomainSystem.BuildingType.GUARDIAN_ALTAR, player)
	var b2 = sys.get_altar_passive_buffs()
	_assert(b2["max_hp"] == 3000, "Lv 2 Altar gives +3000 Max HP")
	_assert(b2["exp_rate_pct"] == 20, "Lv 2 Altar gives +20% Exp")
	_assert(b2["all_stats"] == 10, "Lv 2 Altar gives +10 All Stats")

func _finish() -> void:
	print("\n==========================================")
	print("Solo Guild Domain Parity Tests Finished:")
	print("Passed: %d, Failed: %d" % [_passed, _failed])
	print("==========================================")
	if _failed > 0:
		printerr("FAILED: Some tests did not pass.")
		quit(1)
	else:
		print("SUCCESS: All Solo Guild Domain parity tests passed!")
		quit(0)