212 lines
6.9 KiB
Python
212 lines
6.9 KiB
Python
from coolrl_lost_cities.games.classic.game import Card, GameState, LostCitiesConfig
|
|
|
|
from coolrl_lost_cities.games.classic.bots import (
|
|
LostCitiesBot,
|
|
RandomBot,
|
|
SafeHeuristicBot,
|
|
)
|
|
from coolrl_lost_cities.games.classic.bots.heuristic import draw_from_discard_action
|
|
from coolrl_lost_cities.games.classic.evaluation import play_game_for_evaluation
|
|
|
|
|
|
def test_builtin_bots_implement_lost_cities_bot() -> None:
|
|
assert isinstance(RandomBot(1), LostCitiesBot)
|
|
assert isinstance(SafeHeuristicBot(), LostCitiesBot)
|
|
|
|
|
|
def test_safe_heuristic_mirror_match_finishes() -> None:
|
|
state, result = play_game_for_evaluation(
|
|
SafeHeuristicBot(),
|
|
SafeHeuristicBot(),
|
|
LostCitiesConfig(n_colors=3, n_ranks=5, n_handshakes=1, hand_size=5),
|
|
seed=2000,
|
|
max_steps=200,
|
|
)
|
|
assert state.terminal is True
|
|
assert result.timed_out is False
|
|
|
|
|
|
def test_safe_heuristic_opponent_value_ignores_hidden_hand() -> None:
|
|
config = LostCitiesConfig(n_colors=2, n_ranks=8, hand_size=3)
|
|
bot = SafeHeuristicBot()
|
|
discard_card = Card(color=0, rank=6)
|
|
|
|
state_a = GameState.empty(config)
|
|
state_a.expeditions[1][0] = [Card(color=0, rank=0), Card(color=0, rank=4)]
|
|
state_a.discards[0] = [discard_card]
|
|
state_a.hands[1] = [Card(color=0, rank=5)]
|
|
|
|
state_b = GameState.empty(config)
|
|
state_b.expeditions[1][0] = [Card(color=0, rank=0), Card(color=0, rank=4)]
|
|
state_b.discards[0] = [discard_card]
|
|
state_b.hands[1] = [Card(color=0, rank=5), Card(color=0, rank=7), Card(color=0, rank=8)]
|
|
|
|
value_a = bot._card_value_for_opponent(
|
|
state=state_a,
|
|
opponent=1,
|
|
card=discard_card,
|
|
derived=bot._derived(state_a),
|
|
)
|
|
value_b = bot._card_value_for_opponent(
|
|
state=state_b,
|
|
opponent=1,
|
|
card=discard_card,
|
|
derived=bot._derived(state_b),
|
|
)
|
|
|
|
assert value_a == value_b
|
|
|
|
|
|
def test_safe_heuristic_started_expedition_value_ignores_invalid_lower_followup() -> None:
|
|
config = LostCitiesConfig(n_colors=2, n_ranks=8, hand_size=3)
|
|
bot = SafeHeuristicBot()
|
|
high_card = Card(color=0, rank=8)
|
|
|
|
base_state = GameState.empty(config)
|
|
base_state.expeditions[0][0] = [Card(color=0, rank=4)]
|
|
base_state.hands[0] = [high_card]
|
|
|
|
lower_followup_state = GameState.empty(config)
|
|
lower_followup_state.expeditions[0][0] = [Card(color=0, rank=4)]
|
|
lower_followup_state.hands[0] = [Card(color=0, rank=5), high_card]
|
|
|
|
base_value = bot._started_expedition_play_value(
|
|
state=base_state,
|
|
player=0,
|
|
card=high_card,
|
|
derived=bot._derived(base_state),
|
|
deck_left=config.deck_size,
|
|
)
|
|
lower_followup_value = bot._started_expedition_play_value(
|
|
state=lower_followup_state,
|
|
player=0,
|
|
card=high_card,
|
|
derived=bot._derived(lower_followup_state),
|
|
deck_left=config.deck_size,
|
|
)
|
|
|
|
assert lower_followup_value == base_value
|
|
|
|
|
|
def test_safe_heuristic_draws_playable_discard_instead_of_deck() -> None:
|
|
config = LostCitiesConfig(n_colors=2, n_ranks=8, hand_size=3)
|
|
bot = SafeHeuristicBot()
|
|
|
|
state = GameState.empty(config)
|
|
state.current_player = 0
|
|
state.phase = "draw"
|
|
state.expeditions[0][0] = [Card(color=0, rank=4)]
|
|
state.discards[0] = [Card(color=0, rank=6)]
|
|
state.deck = [Card(color=1, rank=8)]
|
|
|
|
assert bot._act_draw(state) == draw_from_discard_action(0)
|
|
|
|
|
|
def test_safe_heuristic_can_draw_discard_to_deny_opponent_when_losing() -> None:
|
|
config = LostCitiesConfig(n_colors=2, n_ranks=8, hand_size=4)
|
|
bot = SafeHeuristicBot()
|
|
|
|
state = GameState.empty(config)
|
|
state.current_player = 0
|
|
state.phase = "draw"
|
|
state.deck = [Card(color=1, rank=8), Card(color=1, rank=7)]
|
|
state.hands[0] = [Card(color=0, rank=0), Card(color=0, rank=7)]
|
|
state.expeditions[0][1] = [Card(color=1, rank=8)]
|
|
state.expeditions[1][0] = [
|
|
Card(color=0, rank=0),
|
|
Card(color=0, rank=5),
|
|
Card(color=0, rank=6),
|
|
Card(color=0, rank=7),
|
|
Card(color=0, rank=8),
|
|
]
|
|
state.discards[0] = [Card(color=0, rank=6)]
|
|
|
|
assert state.score_diff(0) < 0
|
|
assert bot._act_draw(state) == draw_from_discard_action(0)
|
|
|
|
|
|
def test_safe_heuristic_classic_self_play_opens_expeditions() -> None:
|
|
state = GameState.new_game(LostCitiesConfig(), seed=1)
|
|
bot = SafeHeuristicBot()
|
|
player0_actions: list[int] = []
|
|
|
|
for _ in range(60):
|
|
if state.terminal:
|
|
break
|
|
action = bot.act(state)
|
|
unified = state.to_unified_action(action)
|
|
if state.current_player == 0:
|
|
player0_actions.append(unified)
|
|
state.apply_unified_action(unified)
|
|
|
|
play_actions = [
|
|
action
|
|
for action in player0_actions
|
|
if action < state.config.card_action_size and action % 2 == 0
|
|
]
|
|
|
|
assert play_actions
|
|
assert any(state.expeditions[0][color] for color in range(state.config.n_colors))
|
|
|
|
|
|
def test_safe_heuristic_avoids_opening_weak_fifth_color() -> None:
|
|
config = LostCitiesConfig(n_colors=5, n_ranks=8, hand_size=8)
|
|
bot = SafeHeuristicBot()
|
|
state = GameState.empty(config)
|
|
state.current_player = 0
|
|
state.phase = "card"
|
|
|
|
state.expeditions[0][0] = [Card(color=0, rank=4)]
|
|
state.expeditions[0][1] = [Card(color=1, rank=4)]
|
|
state.expeditions[0][2] = [Card(color=2, rank=5)]
|
|
state.expeditions[0][3] = [Card(color=3, rank=6)]
|
|
weak_open = Card(color=4, rank=4)
|
|
state.hands[0] = [weak_open, Card(color=4, rank=7), Card(color=0, rank=6)]
|
|
state.sort_hand(0)
|
|
|
|
assert (
|
|
bot._should_open_expedition(
|
|
state=state,
|
|
player=0,
|
|
color=4,
|
|
opening_card=weak_open,
|
|
derived=bot._derived(state),
|
|
deck_left=config.deck_size,
|
|
)
|
|
is False
|
|
)
|
|
|
|
|
|
def test_safe_heuristic_prefers_followup_on_started_expedition() -> None:
|
|
config = LostCitiesConfig(n_colors=3, n_ranks=8, hand_size=5)
|
|
bot = SafeHeuristicBot()
|
|
state = GameState.empty(config)
|
|
state.current_player = 0
|
|
state.phase = "card"
|
|
state.expeditions[0][0] = [Card(color=0, rank=4)]
|
|
state.hands[0] = [Card(color=0, rank=6), Card(color=1, rank=4), Card(color=1, rank=7)]
|
|
state.sort_hand(0)
|
|
|
|
action = bot._act_card(state)
|
|
chosen = state.hands[0][action // 2]
|
|
|
|
assert action % 2 == 0
|
|
assert chosen.color == 0
|
|
|
|
|
|
def test_safe_heuristic_avoids_unopened_discard_draw_after_four_opens() -> None:
|
|
config = LostCitiesConfig(n_colors=5, n_ranks=8, hand_size=8)
|
|
bot = SafeHeuristicBot()
|
|
state = GameState.empty(config)
|
|
state.current_player = 0
|
|
state.phase = "draw"
|
|
state.deck = [Card(color=0, rank=8), Card(color=1, rank=8)]
|
|
state.expeditions[0][0] = [Card(color=0, rank=4)]
|
|
state.expeditions[0][1] = [Card(color=1, rank=4)]
|
|
state.expeditions[0][2] = [Card(color=2, rank=5)]
|
|
state.expeditions[0][3] = [Card(color=3, rank=6)]
|
|
state.hands[0] = [Card(color=4, rank=4), Card(color=4, rank=7)]
|
|
state.discards[4] = [Card(color=4, rank=5)]
|
|
|
|
assert bot._act_draw(state) == 0
|