feature updates
This commit is contained in:
363
tests/unit/test_modal_choice_system.gd
Normal file
363
tests/unit/test_modal_choice_system.gd
Normal file
@@ -0,0 +1,363 @@
|
||||
extends GutTest
|
||||
|
||||
## Tests for the Modal Choice System (CHOOSE_MODE effects)
|
||||
## Tests parser output, ChoiceModal UI, and AbilitySystem integration
|
||||
|
||||
|
||||
# =============================================================================
|
||||
# PARSER OUTPUT TESTS
|
||||
# =============================================================================
|
||||
|
||||
func test_modal_effect_has_correct_structure() -> void:
|
||||
# Simulate a parsed CHOOSE_MODE effect
|
||||
var effect = {
|
||||
"type": "CHOOSE_MODE",
|
||||
"select_count": 1,
|
||||
"select_up_to": false,
|
||||
"mode_count": 3,
|
||||
"modes": [
|
||||
{
|
||||
"index": 0,
|
||||
"description": "Choose 1 Forward. Deal it 7000 damage.",
|
||||
"effects": [{"type": "DAMAGE", "amount": 7000}]
|
||||
},
|
||||
{
|
||||
"index": 1,
|
||||
"description": "Choose 1 Monster. Break it.",
|
||||
"effects": [{"type": "BREAK"}]
|
||||
},
|
||||
{
|
||||
"index": 2,
|
||||
"description": "Deal 3000 damage to all Forwards.",
|
||||
"effects": [{"type": "DAMAGE", "amount": 3000}]
|
||||
}
|
||||
]
|
||||
}
|
||||
|
||||
assert_eq(effect.type, "CHOOSE_MODE", "Effect type should be CHOOSE_MODE")
|
||||
assert_eq(effect.select_count, 1, "Should select 1 mode")
|
||||
assert_eq(effect.mode_count, 3, "Should have 3 modes")
|
||||
assert_eq(effect.modes.size(), 3, "Modes array should have 3 entries")
|
||||
assert_false(effect.select_up_to, "Should not be 'up to' selection")
|
||||
|
||||
|
||||
func test_modal_effect_with_enhanced_condition() -> void:
|
||||
var effect = {
|
||||
"type": "CHOOSE_MODE",
|
||||
"select_count": 1,
|
||||
"select_up_to": false,
|
||||
"mode_count": 3,
|
||||
"modes": [],
|
||||
"enhanced_condition": {
|
||||
"description": "if you have 5 or more ifrit in your break zone",
|
||||
"select_count": 3,
|
||||
"select_up_to": true
|
||||
}
|
||||
}
|
||||
|
||||
assert_true(effect.has("enhanced_condition"), "Should have enhanced condition")
|
||||
assert_eq(effect.enhanced_condition.select_count, 3, "Enhanced should allow 3 selections")
|
||||
assert_true(effect.enhanced_condition.select_up_to, "Enhanced should be 'up to'")
|
||||
|
||||
|
||||
func test_modal_mode_has_description_and_effects() -> void:
|
||||
var mode = {
|
||||
"index": 0,
|
||||
"description": "Draw 2 cards.",
|
||||
"effects": [{"type": "DRAW", "amount": 2}]
|
||||
}
|
||||
|
||||
assert_true(mode.has("description"), "Mode should have description")
|
||||
assert_true(mode.has("effects"), "Mode should have effects array")
|
||||
assert_eq(mode.effects.size(), 1, "Mode should have 1 effect")
|
||||
assert_eq(mode.effects[0].type, "DRAW", "Effect should be DRAW")
|
||||
|
||||
|
||||
# =============================================================================
|
||||
# CHOICE MODAL TESTS
|
||||
# =============================================================================
|
||||
|
||||
func test_choice_modal_instantiates() -> void:
|
||||
var modal = ChoiceModal.new()
|
||||
assert_not_null(modal, "ChoiceModal should instantiate")
|
||||
modal.free()
|
||||
|
||||
|
||||
func test_choice_modal_starts_invisible() -> void:
|
||||
var modal = ChoiceModal.new()
|
||||
add_child_autofree(modal)
|
||||
|
||||
# Need to wait for _ready to complete
|
||||
await get_tree().process_frame
|
||||
|
||||
assert_false(modal.visible, "ChoiceModal should start invisible")
|
||||
|
||||
|
||||
func test_choice_modal_has_correct_layer() -> void:
|
||||
var modal = ChoiceModal.new()
|
||||
add_child_autofree(modal)
|
||||
|
||||
await get_tree().process_frame
|
||||
|
||||
assert_eq(modal.layer, 200, "ChoiceModal should be at layer 200")
|
||||
|
||||
|
||||
func test_choice_modal_signals_exist() -> void:
|
||||
var modal = ChoiceModal.new()
|
||||
|
||||
assert_true(modal.has_signal("choice_made"), "Should have choice_made signal")
|
||||
assert_true(modal.has_signal("choice_cancelled"), "Should have choice_cancelled signal")
|
||||
|
||||
modal.free()
|
||||
|
||||
|
||||
# =============================================================================
|
||||
# EFFECT RESOLVER TESTS
|
||||
# =============================================================================
|
||||
|
||||
func test_effect_resolver_has_choice_required_signal() -> void:
|
||||
var resolver = EffectResolver.new()
|
||||
|
||||
assert_true(resolver.has_signal("choice_required"), "Should have choice_required signal")
|
||||
|
||||
|
||||
func test_effect_resolver_emits_choice_required_for_choose_mode() -> void:
|
||||
var resolver = EffectResolver.new()
|
||||
var signal_received = false
|
||||
var received_effect = {}
|
||||
var received_modes = []
|
||||
|
||||
resolver.choice_required.connect(func(effect, modes):
|
||||
signal_received = true
|
||||
received_effect = effect
|
||||
received_modes = modes
|
||||
)
|
||||
|
||||
var effect = {
|
||||
"type": "CHOOSE_MODE",
|
||||
"modes": [
|
||||
{"index": 0, "description": "Option 1", "effects": []},
|
||||
{"index": 1, "description": "Option 2", "effects": []}
|
||||
]
|
||||
}
|
||||
|
||||
# Resolve the effect
|
||||
resolver.resolve(effect, null, [], null)
|
||||
|
||||
assert_true(signal_received, "Should emit choice_required signal")
|
||||
assert_eq(received_modes.size(), 2, "Should pass modes to signal")
|
||||
|
||||
|
||||
# =============================================================================
|
||||
# FIELD EFFECT MANAGER TESTS
|
||||
# =============================================================================
|
||||
|
||||
func test_field_effect_manager_block_immunity_empty() -> void:
|
||||
var manager = FieldEffectManager.new()
|
||||
|
||||
# With no abilities registered, should return false
|
||||
var result = manager.has_block_immunity(null, null, null)
|
||||
assert_false(result, "Should return false with no abilities")
|
||||
|
||||
|
||||
func test_field_effect_manager_attack_restriction_empty() -> void:
|
||||
var manager = FieldEffectManager.new()
|
||||
|
||||
var result = manager.has_attack_restriction(null, null)
|
||||
assert_false(result, "Should return false with no abilities")
|
||||
|
||||
|
||||
func test_field_effect_manager_block_restriction_empty() -> void:
|
||||
var manager = FieldEffectManager.new()
|
||||
|
||||
var result = manager.has_block_restriction(null, null)
|
||||
assert_false(result, "Should return false with no abilities")
|
||||
|
||||
|
||||
func test_field_effect_manager_taunt_targets_empty() -> void:
|
||||
var manager = FieldEffectManager.new()
|
||||
|
||||
var result = manager.get_taunt_targets(0, null)
|
||||
assert_eq(result.size(), 0, "Should return empty array with no abilities")
|
||||
|
||||
|
||||
func test_field_effect_manager_cost_modifier_empty() -> void:
|
||||
var manager = FieldEffectManager.new()
|
||||
|
||||
var result = manager.get_cost_modifier(null, 0, null)
|
||||
assert_eq(result, 0, "Should return 0 with no abilities")
|
||||
|
||||
|
||||
func test_field_effect_manager_max_attacks_default() -> void:
|
||||
var manager = FieldEffectManager.new()
|
||||
|
||||
var result = manager.get_max_attacks(null, null)
|
||||
assert_eq(result, 1, "Default max attacks should be 1")
|
||||
|
||||
|
||||
# =============================================================================
|
||||
# BLOCKER IMMUNITY CONDITION TESTS
|
||||
# =============================================================================
|
||||
|
||||
func test_blocker_immunity_condition_empty() -> void:
|
||||
var manager = FieldEffectManager.new()
|
||||
|
||||
# Empty condition means unconditional immunity
|
||||
var result = manager._blocker_matches_immunity_condition(null, {}, null)
|
||||
assert_true(result, "Empty condition should return true (unconditional)")
|
||||
|
||||
|
||||
func test_blocker_immunity_condition_cost_gte() -> void:
|
||||
var manager = FieldEffectManager.new()
|
||||
|
||||
# Create mock card data
|
||||
var blocker = _create_mock_card(3, 5000) # cost 3, power 5000
|
||||
|
||||
var condition = {
|
||||
"comparison": "GTE",
|
||||
"attribute": "cost",
|
||||
"value": 4
|
||||
}
|
||||
|
||||
var result = manager._blocker_matches_immunity_condition(blocker, condition, null)
|
||||
assert_false(result, "Cost 3 is not >= 4")
|
||||
|
||||
blocker.card_data.cost = 4
|
||||
result = manager._blocker_matches_immunity_condition(blocker, condition, null)
|
||||
assert_true(result, "Cost 4 is >= 4")
|
||||
|
||||
blocker.free()
|
||||
|
||||
|
||||
func test_blocker_immunity_condition_power_lt_self() -> void:
|
||||
var manager = FieldEffectManager.new()
|
||||
|
||||
var blocker = _create_mock_card(3, 5000)
|
||||
var attacker = _create_mock_card(4, 8000)
|
||||
|
||||
var condition = {
|
||||
"comparison": "LT",
|
||||
"attribute": "power",
|
||||
"compare_to": "SELF_POWER"
|
||||
}
|
||||
|
||||
# Blocker power 5000 < attacker power 8000
|
||||
var result = manager._blocker_matches_immunity_condition(blocker, condition, attacker)
|
||||
assert_true(result, "5000 < 8000 should be true")
|
||||
|
||||
# Change blocker power to be higher
|
||||
blocker.current_power = 9000
|
||||
result = manager._blocker_matches_immunity_condition(blocker, condition, attacker)
|
||||
assert_false(result, "9000 < 8000 should be false")
|
||||
|
||||
blocker.free()
|
||||
attacker.free()
|
||||
|
||||
|
||||
# =============================================================================
|
||||
# ABILITY SYSTEM INTEGRATION TESTS
|
||||
# =============================================================================
|
||||
|
||||
func test_ability_system_has_choice_modal_reference() -> void:
|
||||
# Check that AbilitySystem has the choice_modal variable
|
||||
var ability_system_script = load("res://scripts/game/abilities/AbilitySystem.gd")
|
||||
assert_not_null(ability_system_script, "AbilitySystem script should exist")
|
||||
|
||||
|
||||
func test_modes_selected_queues_effects() -> void:
|
||||
# This tests the logic of _on_modes_selected indirectly
|
||||
var effect = {
|
||||
"type": "CHOOSE_MODE",
|
||||
"modes": [
|
||||
{"index": 0, "description": "Deal damage", "effects": [{"type": "DAMAGE", "amount": 5000}]},
|
||||
{"index": 1, "description": "Draw cards", "effects": [{"type": "DRAW", "amount": 2}]}
|
||||
]
|
||||
}
|
||||
|
||||
var modes = effect.modes
|
||||
var selected_indices = [1] # Player selected option 2 (draw)
|
||||
|
||||
# Verify mode selection logic
|
||||
var queued_effects = []
|
||||
for index in selected_indices:
|
||||
if index >= 0 and index < modes.size():
|
||||
var mode = modes[index]
|
||||
for mode_effect in mode.get("effects", []):
|
||||
queued_effects.append(mode_effect)
|
||||
|
||||
assert_eq(queued_effects.size(), 1, "Should queue 1 effect")
|
||||
assert_eq(queued_effects[0].type, "DRAW", "Queued effect should be DRAW")
|
||||
assert_eq(queued_effects[0].amount, 2, "Draw amount should be 2")
|
||||
|
||||
|
||||
func test_multi_select_queues_multiple_effects() -> void:
|
||||
var effect = {
|
||||
"type": "CHOOSE_MODE",
|
||||
"select_count": 2,
|
||||
"modes": [
|
||||
{"index": 0, "effects": [{"type": "DAMAGE", "amount": 5000}]},
|
||||
{"index": 1, "effects": [{"type": "DRAW", "amount": 2}]},
|
||||
{"index": 2, "effects": [{"type": "BREAK"}]}
|
||||
]
|
||||
}
|
||||
|
||||
var modes = effect.modes
|
||||
var selected_indices = [0, 2] # Player selected damage and break
|
||||
|
||||
var queued_effects = []
|
||||
for index in selected_indices:
|
||||
if index >= 0 and index < modes.size():
|
||||
var mode = modes[index]
|
||||
for mode_effect in mode.get("effects", []):
|
||||
queued_effects.append(mode_effect)
|
||||
|
||||
assert_eq(queued_effects.size(), 2, "Should queue 2 effects")
|
||||
assert_eq(queued_effects[0].type, "DAMAGE", "First effect should be DAMAGE")
|
||||
assert_eq(queued_effects[1].type, "BREAK", "Second effect should be BREAK")
|
||||
|
||||
|
||||
# =============================================================================
|
||||
# ENHANCED CONDITION TESTS
|
||||
# =============================================================================
|
||||
|
||||
func test_enhanced_condition_parsing() -> void:
|
||||
var condition = {
|
||||
"description": "if you have a total of 5 or more card name ifrita and/or card name ifrit in your break zone",
|
||||
"select_count": 3,
|
||||
"select_up_to": true
|
||||
}
|
||||
|
||||
# Test that description contains expected keywords
|
||||
assert_true("break zone" in condition.description, "Should mention break zone")
|
||||
assert_true("5 or more" in condition.description, "Should mention count requirement")
|
||||
|
||||
|
||||
func test_regex_count_extraction() -> void:
|
||||
var description = "if you have 5 or more ifrit in your break zone"
|
||||
|
||||
var regex = RegEx.new()
|
||||
regex.compile(r"(\d+) or more")
|
||||
var match_result = regex.search(description)
|
||||
|
||||
assert_not_null(match_result, "Should find count pattern")
|
||||
assert_eq(match_result.get_string(1), "5", "Should extract '5'")
|
||||
assert_eq(int(match_result.get_string(1)), 5, "Should convert to int 5")
|
||||
|
||||
|
||||
# =============================================================================
|
||||
# HELPER FUNCTIONS
|
||||
# =============================================================================
|
||||
|
||||
func _create_mock_card(cost: int, power: int) -> CardInstance:
|
||||
var card = CardInstance.new()
|
||||
|
||||
# Create minimal card data
|
||||
var data = CardDatabase.CardData.new()
|
||||
data.cost = cost
|
||||
data.power = power
|
||||
data.type = Enums.CardType.FORWARD
|
||||
|
||||
card.card_data = data
|
||||
card.current_power = power
|
||||
|
||||
return card
|
||||
Reference in New Issue
Block a user