def setUp(self):
self.carnivore = TraitCard(CARNIVORE, 3)
self.burrowing = TraitCard(BURROWING, 2)
self.fattissue = TraitCard(FATTISSUE, 4)
self.foraging = TraitCard(FORAGING, 2)
self.horns = TraitCard(HORNS, 6)
self.cooperation = TraitCard(COOPERATION, 1)
self.scavenger = TraitCard(SCAVENGER, 2)
self.species_1 = Species(4, 4, 4, [])
self.species_2 = Species(4, 4, 4)
self.species_3 = Species(4, 4, 3)
self.species_4 = Species(4, 3, 3)
self.species_5 = Species(3, 1, 3)
self.species_6 = Species(4, 3, 3)
self.species_7 = Species(4, 4, 4)
self.species_list = [
self.species_2, self.species_4, self.species_3, self.species_5,
self.species_1
]
self.player_1 = PlayerState(
species=[self.species_4, self.species_5, self.species_6],
hand=[self.carnivore])
self.player_2 = PlayerState(species=[self.species_1],
hand=[self.carnivore, self.fattissue])
self.player_3 = PlayerState(
species=[self.species_2, self.species_3, self.species_7],
hand=[self.foraging])
def feed_carnivore(cls, hungry_carnivores, player_state, list_of_player):
"""
Feeds the largest hungry carnivore
:param hungry_carnivores: list of hungry carnivores
:param player_state: the current player state
:param list_of_player: list of all player states
:return: One of:
[Carnivore, Defending Player, Defending Species] if there is a valid target in list_of_players' species
False, if no valid targets and Player chooses not to attack own Species
None, if no valid targets and is unable to attack own species
"""
sorted_carnivores = cls.sort_by_size(hungry_carnivores)
for carnivore in sorted_carnivores:
targets = []
for player in list_of_player:
for defender in player.species:
left_neighbor = PlayerState.get_left_neighbor(defender, player.species)
right_neighbor = PlayerState.get_right_neighbor(defender, player.species)
if defender.is_attackable(carnivore, left_neighbor, right_neighbor):
targets.append(defender)
if targets:
target = cls.sort_by_size(targets)[0]
target_player = next(player for player in list_of_player if target in player.species)
return [carnivore, target_player, target]
for carnivore in sorted_carnivores:
for defender in player_state.species:
if carnivore == defender:
continue
if defender.is_attackable(carnivore,
PlayerState.get_left_neighbor(defender, player_state.species),
PlayerState.get_right_neighbor(defender, player_state.species)):
return False
return None
def validate_cards(self):
"""
Validates that all cards known by this dealer are valid possibilities and unique
:raise: ValueError if duplicate or invalid cards exist
"""
total_deck = Dealer.make_deck()
TraitCard.validate_all_unique(self.deck, total_deck)
PlayerState.validate_all_cards(self.list_of_players, total_deck)
def validate_attributes(self):
"""
Validates the attributes of this Dealer
:raise AssertionError if any attributes are out of bounds
"""
assert (isinstance(self.list_of_players, list)
and LOP_MAX >= len(self.list_of_players) >= LOP_MIN)
PlayerState.validate_all_attributes(self.list_of_players)
assert (isinstance(self.watering_hole, int)
and self.watering_hole >= MIN_WATERING_HOLE)
assert (isinstance(self.deck, list) and LOC_MAX >= len(self.deck))
TraitCard.validate_all_attributes(self.deck)
def setUp(self):
self.species_1 = Species(4, 4, 4)
self.species_2 = Species(4, 4, 4)
self.species_3 = Species(4, 4, 3)
self.species_4 = Species(4, 3, 3)
self.species_5 = Species(3, 1, 3)
self.species_6 = Species(4, 3, 3)
self.species_7 = Species(4, 4, 4)
self.species_list = [self.species_2, self.species_4,
self.species_3, self.species_5,
self.species_1]
self.player_1 = PlayerState(Player,
species=[self.species_4,
self.species_5,
self.species_6])
self.player_2 = PlayerState(Player,
species=[self.species_1])
self.player_3 = PlayerState(Player,
species=[self.species_2,
self.species_3,
self.species_7])
self.attacker = Species()
self.attacker.traits = [TraitCard("carnivore")]
self.defender = Species()
def setUp(self):
self.species_1 = Species(4, 4, 4)
self.species_2 = Species(4, 4, 4)
self.species_3 = Species(4, 4, 3)
self.species_4 = Species(4, 3, 3)
self.species_5 = Species(3, 1, 3)
self.species_6 = Species(4, 3, 3)
self.species_7 = Species(4, 4, 4)
self.species_list = [
self.species_2, self.species_4, self.species_3, self.species_5,
self.species_1
]
self.player_1 = PlayerState(
species=[self.species_4, self.species_5, self.species_6])
self.player_2 = PlayerState(species=[self.species_1])
self.player_3 = PlayerState(
species=[self.species_2, self.species_3, self.species_7])
def previous_playlist(self, state):
next_genre_index = self._next_genre_index(state, advance=-1)
next_genre = self._genre_list[next_genre_index]
self._prep_song_list(next_genre, reset=True)
print('Genre: {}'.format(next_genre))
return PlayerState(next_genre, self._genre_song_list[len(self._genre_song_list) - 1], state.exclude_from_genre)
def make_playerstates(cls, loxp):
"""
Creates a PlayerState for each of the given external Players
:return: List of PlayerState objects representing internal players
"""
lop = []
for x in range(len(loxp)):
lop.append(PlayerState(name=x + 1, ext_player=loxp[x]))
return lop
def setUp(self):
self.attacker = Species()
self.attacker.traits = [TraitCard(CARNIVORE)]
self.defender = Species()
self.left_neighbor = Species()
self.right_neighbor = Species()
self.species_1 = Species(4, 4, 4)
self.species_2 = Species(4, 4, 4)
self.species_3 = Species(4, 4, 3)
self.species_4 = Species(4, 3, 3)
self.species_5 = Species(3, 3, 3)
self.species_list = [
self.species_2, self.species_4, self.species_3, self.species_5,
self.species_1
]
self.player_1 = PlayerState(1)
self.player_2 = PlayerState(2)
def random_song_anywhere(self, state):
genre = random.choice(self._genre_list)
self._prep_song_list(genre, reset=True)
song = random.choice(self._genre_song_list)
print('Genre: {}'.format(genre))
# state *can* be None, for first-time operation.
exclude_from_genre = False if state is None else state.exclude_from_genre
return PlayerState(genre, song, exclude_from_genre)
def setUp(self):
self.trait1 = TraitCard(CARNIVORE, 2)
self.trait2 = TraitCard(SCAVENGER, 3)
self.trait3 = TraitCard(FATTISSUE, 2)
self.trait4 = TraitCard(FORAGING, 3)
self.species_1 = Species(4, 4, 4, [self.trait3], 3)
self.species_2 = Species(4, 4, 4)
self.species_3 = Species(4, 4, 3)
self.species_4 = Species(4, 3, 3)
self.species_5 = Species(3, 1, 3)
self.species_6 = Species(4, 3, 3)
self.species_7 = Species(4, 4, 4)
self.player_1 = PlayerState(
1, 2, [self.trait1, self.trait2],
[self.species_4, self.species_5, self.species_6])
self.player_2 = PlayerState(2, 10, [], [self.species_1])
self.player_3 = PlayerState(
3, 4, [self.trait4],
[self.species_2, self.species_3, self.species_7])
self.dealer_1 = Dealer([self.player_1, self.player_2, self.player_3],
10, [self.trait1, self.trait2])
def setUp(self):
# Traits (Trait, Food-value)
self.carnivore = TraitCard(CARNIVORE, 3)
self.burrowing = TraitCard(BURROWING, 2)
self.fattissue = TraitCard(FATTISSUE, 4)
self.foraging = TraitCard(FORAGING, 2)
self.horns = TraitCard(HORNS, 6)
self.cooperation = TraitCard(COOPERATION, 1)
self.scavenger = TraitCard(SCAVENGER, 2)
# Species (Population, Food, Body, Traits, Fat-Storage)
self.species1 = Species(1, 0, 2, [self.cooperation])
self.species2 = Species(6, 2, 1, [self.carnivore])
self.species3 = Species(3, 3, 3, [self.fattissue], 0)
self.species4 = Species(5, 5, 5, [self.burrowing])
self.species5 = Species(5, 3, 4, [self.foraging])
self.species6 = Species(
2, 1, 7, [self.carnivore, self.fattissue, self.scavenger], 0)
self.species7 = Species(7, 1, 6, [self.horns])
self.player1_species = [self.species1, self.species2]
self.player2_species = [self.species3, self.species4, self.species5]
self.player3_species = [self.species6, self.species7]
# Players (Name, Bag, Hand, Species)
self.player1 = PlayerState(1, 0, [self.fattissue],
self.player1_species)
self.player2 = PlayerState(2, 3, [self.fattissue, self.carnivore],
self.player2_species)
self.player3 = PlayerState(3, 6, [self.burrowing],
self.player3_species)
self.public_player1 = PlayerState(1, False, False,
self.player1_species)
self.public_player2 = PlayerState(2, False, False,
self.player2_species)
self.public_player3 = PlayerState(3, False, False,
self.player3_species)
self.list_of_players = [self.player1, self.player2, self.player3]
# Dealer (List of Players, Watering Hole, Deck)
self.dealer1 = Dealer(self.list_of_players, 10, [])
# Actions
self.food_card_action1 = FoodCardAction(0)
self.food_card_action2 = FoodCardAction(1)
self.grow_action_pop = GrowAction(POPULATION, 0, 0)
self.grow_action_body = GrowAction(BODY, 1, 1)
self.add_species_action1 = AddSpeciesAction(0, [1])
self.add_species_action2 = AddSpeciesAction(0, [])
self.replace_trait_action1 = ReplaceTraitAction(0, 0, 0)
self.replace_trait_action2 = ReplaceTraitAction(2, 0, 1)
self.replace_trait_action3 = ReplaceTraitAction(0, 2, 0)
# Action4
self.action4_1 = Action4(self.player1, [self.food_card_action1])
self.action4_2 = Action4(
self.player2, [self.food_card_action2, self.grow_action_pop])
def public_players(self, feeding_player):
"""
Creates a copy of this Dealer's list of players, excluding the specified feeding player, so that
the feeding player may choose which player to attack without having access to their private fields.
:param feeding_player: The PlayerState of the player feeding
:return: a list of public representations of PlayerStates
"""
return [
PlayerState(name=player.name,
food_bag=False,
hand=False,
species=player.species)
for player in self.list_of_players if player != feeding_player
]
def _remove_player_from_game(self, game, player):
if player not in self.player_states:
self.logger.error("Trying to remove unknown %s from a game" % player)
return
state = self.player_states[player]
if state.is_in_game() or state.is_after_game():
if game == state.get_game():
# TODO: when/if a voluntary leave is implemented, send a signal to the GameState to unsub the player
self.player_states[player] = PlayerState.get_initial(player)
self._send_to_player(player, self.player_states[player].as_init_action())
def setUp(self):
# Traits (Trait, Food-value)
self.carnivore = TraitCard(CARNIVORE, 3)
self.burrowing = TraitCard(BURROWING, 2)
self.fattissue = TraitCard(FATTISSUE, 2)
self.foraging = TraitCard(FORAGING, 2)
self.horns = TraitCard(HORNS, 0)
self.cooperation = TraitCard(COOPERATION, 1)
self.scavenger = TraitCard(SCAVENGER, 2)
# Species (Population, Food, Body, Traits, Fat-Storage)
self.species1 = Species(1, 0, 2, [self.cooperation])
self.species2 = Species(6, 2, 1, [self.carnivore])
self.species3 = Species(3, 3, 3, [self.fattissue], 0)
self.species4 = Species(5, 5, 5, [self.burrowing])
self.species5 = Species(5, 3, 4, [self.foraging])
self.species6 = Species(
2, 1, 7, [self.carnivore, self.fattissue, self.scavenger], 0)
self.species7 = Species(7, 1, 6, [self.horns])
self.player1_species = [self.species1, self.species2]
self.player2_species = [self.species3, self.species4, self.species5]
self.player3_species = [self.species6, self.species7]
# Players (Name, Bag, Hand, Species)
self.player1 = PlayerState(1,
0, [self.horns, self.foraging],
self.player1_species,
ext_player=Player())
self.player2 = PlayerState(2,
3, [self.carnivore, self.fattissue],
self.player2_species,
ext_player=Player())
self.player3 = PlayerState(3,
6, [self.burrowing],
self.player3_species,
ext_player=Player())
self.public_player1 = PlayerState(1, False, False,
self.player1_species)
self.public_player2 = PlayerState(2, False, False,
self.player2_species)
self.public_player3 = PlayerState(3, False, False,
self.player3_species)
self.list_of_players = [self.player1, self.player2, self.player3]
# Dealer (List of Players, Watering Hole, Deck)
self.dealer1 = Dealer(self.list_of_players, 10, [])
# Action
self.action4_1 = Action4(FoodCardAction(1),
[GrowAction(POPULATION, 0, 0)], [], [], [])
self.action4_2 = Action4(FoodCardAction(0), [], [], [],
[ReplaceTraitAction(1, 0, 1)])
self.action4_3 = Action4(FoodCardAction(0), [], [], [], [])
self.action4_list = [self.action4_1, self.action4_2, self.action4_3]
def handle_open(self, connection):
player = self._identify_player(connection)
self._add_connection_with(player, connection)
if player not in self.player_states:
player_state = PlayerState.get_initial(player)
self.logger.info("New player online, init their state with %s" % player_state.as_init_action())
self.player_states[player] = player_state
elif player in self.disconnect_timeouts:
self._player_reconnected(player)
else:
self.logger.debug("Got a new connection with %s" % player)
def get_public_players(self, player_id=0):
"""
Produce a copy of the list of players. Each copies player in the list (except for the choosing player)
will have no food_bag and no hand so that when given for a feeding the player
feeding won't have that information
:param player_id: Id of player to maintain private fields
:return: List of PlayerStates
"""
result = []
for player in self.list_of_players:
if player_id == player.name:
result.append(player)
else:
result.append(PlayerState(name=player.name, food_bag=None, species=player.species))
return result
def _initialize_game(self, players, **game_settings):
new_state = GameState.create_random([(player, player.nickname) for player in players], **game_settings)
# TODO: make a separate method "send state delta" so that game only deals in state deltas, not full actions
new_state.add_update_handler(lambda p, msg: self._send_to_player(p, msg))
new_state.update_end_game_callback(
lambda px: self._handle_game_end(new_state, px)
)
for player in players:
self.player_states[player] = PlayerState.get_in_game(player, new_state)
self._send_to_player(player, self.player_states[player].as_init_action())
new_state.start()
def _handle_game_end(self, game, players):
for player in game.order_disconnected:
player.count_leave()
for player in game.order_won:
player.count_win()
loser = game.end_summary['loser']
if loser is not None:
loser.count_loss()
for p in players:
if p not in game.order_disconnected:
self.player_states[p] = PlayerState.get_after_game(p, game)
self._send_to_player(p, self.player_states[p].as_init_action())
self.get_ioloop().call_later(20, lambda: self._remove_players_from_game(game, players))
def setUp(self):
species_0 = Species(population=1,
food=3,
body=4,
traits=["carnivore"])
species_1 = Species(population=1,
food=1,
body=1,
traits=["burrowing"])
species_2 = Species(population=1,
food=0,
body=1,
traits=["fat-tissue"])
species = [species_0, species_1, species_2]
hand = [TraitCard("long-neck", food_points=2),
TraitCard("climbing", food_points=-2),
TraitCard("scavenger", food_points=4)]
self.player = PlayerState(Player, hand=hand, species=species)
def setUp(self):
self.carnivore_trait = TraitCard(CARNIVORE, 3)
self.burrowing_trait = TraitCard(BURROWING, 2)
self.fattissue_trait = TraitCard(FATTISSUE, 4)
self.foraging_trait = TraitCard(FORAGING, 2)
self.horns_trait = TraitCard(HORNS, 6)
self.cooperation_trait = TraitCard(COOPERATION, 1)
self.scavenger_trait = TraitCard(SCAVENGER, 2)
self.species1 = Species(1, 0, 2, [self.cooperation_trait])
self.species2 = Species(6, 2, 1, [self.carnivore_trait])
self.species3 = Species(3, 3, 3, [self.fattissue_trait], 0)
self.species4 = Species(5, 5, 5, [self.burrowing_trait])
self.species5 = Species(5, 3, 4, [self.foraging_trait])
self.species6 = Species(
2, 1, 7,
[self.carnivore_trait, self.fattissue_trait, self.scavenger_trait],
0)
self.species7 = Species(7, 1, 6, [self.horns_trait])
self.player1_species = [self.species1, self.species2]
self.player2_species = [self.species3, self.species4, self.species5]
self.player3_species = [self.species6, self.species7]
self.player1 = PlayerState(1, 0, [], self.player1_species)
self.player2 = PlayerState(
2, 3, [self.carnivore_trait, self.fattissue_trait],
self.player2_species)
self.player3 = PlayerState(3, 6, [self.burrowing_trait],
self.player3_species)
self.public_player1 = PlayerState(1, None, None, self.player1_species)
self.public_player2 = PlayerState(2, None, None, self.player2_species)
self.public_player3 = PlayerState(3, None, None, self.player3_species)
self.list_of_players = [self.player1, self.player2, self.player3]
self.dealer1 = Dealer(self.list_of_players, 10, [])
class TestPlayerState(unittest.TestCase):
@classmethod
def setUpClass(cls):
test_utils.setup()
def setUp(self):
species_0 = Species(population=1,
food=3,
body=4,
traits=[TraitCard("carnivore")])
species_1 = Species(population=1,
food=1,
body=1,
traits=[TraitCard("burrowing")])
species_2 = Species(population=1,
food=0,
body=1,
traits=[TraitCard("fat-tissue")])
species = [species_0, species_1, species_2]
hand = [TraitCard("long-neck", food_points=2),
TraitCard("climbing", food_points=-2),
TraitCard("scavenger", food_points=4)]
self.player = PlayerState(hand=hand, species=species)
def test_create_new_boards_one(self):
board_addition = BoardAddition(0, traits=[1, 2])
before = copy.deepcopy(self.player)
self.player.create_new_boards([board_addition])
self.player.remove_used_cards()
changes = {"species":{ 3: {
"population": 1,
"food": 0,
"body": 0,
"fat_storage": 0,
"traits": [TraitCard("climbing", food_points=-2),
TraitCard("scavenger", food_points=4)]}},
"hand": []}
self.check_player(before, self.player, changes)
def test_create_new_boards_many(self):
board_addition_0 = BoardAddition(0)
board_addition_1 = BoardAddition(1)
board_addition_2 = BoardAddition(2)
before = copy.deepcopy(self.player)
self.player.create_new_boards([board_addition_0,
board_addition_1,
board_addition_2])
self.player.remove_used_cards()
new_species = {
"population": 1,
"food": 0,
"body": 0,
"fat_storage": 0,
"traits": []
}
changes = {
"species":{
3: new_species,
4: new_species,
5: new_species,
},
"hand": []
}
self.check_player(before, self.player, changes)
# TODO: Species don't need whole trait cards, just their traits.
def test_replace_traits_one(self):
replacements = [ReplaceTrait(0, 0, 0)]
before = copy.deepcopy(self.player)
self.player.replace_traits(replacements)
self.player.remove_used_cards()
changes = {
"species":
{0: {"traits": [TraitCard("long-neck", food_points=2)]}},
"hand":
[TraitCard("climbing", food_points=-2),
TraitCard("scavenger", food_points=4)]
}
self.check_player(before, self.player, changes)
def test_replace_traits_many(self):
replacements = [ReplaceTrait(0, 0, 0),
ReplaceTrait(2, 0, 1),
ReplaceTrait(1, 0, 2)]
before = copy.deepcopy(self.player)
self.player.replace_traits(replacements)
self.player.remove_used_cards()
changes = {
"species":
{0: {"traits": [TraitCard("long-neck", food_points=2)]},
2: {"traits": [TraitCard("climbing", food_points=-2)]},
1: {"traits": [TraitCard("scavenger", food_points=4)]}},
"hand":
[]
}
self.check_player(before, self.player, changes)
def test_increase_populations_one(self):
pop_grows = [PopGrow(1, 1)]
before = copy.deepcopy(self.player)
self.player.increase_populations(pop_grows)
self.player.remove_used_cards()
changes = {
"species":
{1: {"population": 2}},
"hand":
[TraitCard("long-neck", food_points=2),
TraitCard("scavenger", food_points=4)]
}
self.check_player(before, self.player, changes)
def test_increase_populations_many_same_species(self):
pop_grows = [PopGrow(1, 1),PopGrow(1, 0),PopGrow(1, 2),]
before = copy.deepcopy(self.player)
self.player.increase_populations(pop_grows)
self.player.remove_used_cards()
changes = {
"species":
{1: {"population": 4}},
"hand":
[]
}
self.check_player(before, self.player, changes)
def test_increase_populations_many_different_species(self):
pop_grows = [PopGrow(1, 1),PopGrow(0, 0),PopGrow(2, 2),]
before = copy.deepcopy(self.player)
self.player.increase_populations(pop_grows)
self.player.remove_used_cards()
changes = {
"species":
{0: {"population": 2},
1: {"population": 2},
2: {"population": 2}},
"hand":
[]
}
self.check_player(before, self.player, changes)
def test_increase_body_sizes_one(self):
body_grows = [BodyGrow(1, 1)]
before = copy.deepcopy(self.player)
self.player.increase_body_sizes(body_grows)
self.player.remove_used_cards()
changes = {
"species":
{1: {"body": 2}},
"hand":
[TraitCard("long-neck", food_points=2),
TraitCard("scavenger", food_points=4)]
}
self.check_player(before, self.player, changes)
def test_increase_body_sizes_many_same_species(self):
body_grows = [BodyGrow(1, 1),BodyGrow(1, 0),BodyGrow(1, 2),]
before = copy.deepcopy(self.player)
self.player.increase_body_sizes(body_grows)
self.player.remove_used_cards()
changes = {
"species":
{1: {"body": 4}},
"hand":
[]
}
self.check_player(before, self.player, changes)
def test_increase_body_sizes_many_different_species(self):
body_grows = [BodyGrow(1, 1),BodyGrow(0, 0),BodyGrow(2, 2),]
before = copy.deepcopy(self.player)
self.player.increase_body_sizes(body_grows)
self.player.remove_used_cards()
changes = {
"species":
{0: {"body": 5},
1: {"body": 2},
2: {"body": 2}},
"hand":
[]
}
self.check_player(before, self.player, changes)
def handle_message(self, connection, msg):
self.logger.info("Got message %s" % msg)
msg = json.loads(msg)
if 'kind' in msg:
player = self.identity_of[connection]
# TODO: rearrange in order of descending frequency
if msg['kind'] == 'request-init':
self.logger.info("Got request for init form socket %s" % self)
self._send_to_player(player, self.player_states[player].as_init_action())
elif msg['kind'] == 'act-looking-for-game(start)':
if not self.player_states[player].is_initial():
self.logger.warn("Player %s is in %s, should be in initial" % (
player, self.player_states[player].as_short_str()))
return
self.player_states[player] = PlayerState.get_looking_for_game(player, self.mm_pool)
# TODO: transition from initial to lfg instead of init into lfg!
self._send_to_player(player, self.player_states[player].as_init_action())
self.mm_pool.add_player(player)
elif msg['kind'] == 'act-looking-for-game(stop)':
if not self.player_states[player].is_looking_for_game():
self.logger.warn("Player %s isn't looking for game" % (player,))
return
self.player_states[player] = PlayerState.get_initial(player)
self._send_to_player(player, self.player_states[player].as_init_action())
self.mm_pool.remove_player(player)
elif msg['kind'] == 'act-finish-game':
if not self.player_states[player].is_after_game():
self.logger.warn("Player %s isn't in a game that has ended" % (player,))
return
self._remove_player_from_game(self.player_states[player].get_game(), player)
elif msg['kind'] == 'set-nickname':
self._set_nickname(player, msg['newNickname'])
elif msg['kind'] == 'set-mm-deck':
self._set_mm_settings(player, deck=msg['deck'])
elif msg['kind'] == 'set-mm-min-players':
self._set_mm_settings(player, min_players=msg['minPlayers'])
elif msg['kind'] == 'set-no-auto-end':
self._set_game_settings(player, no_auto_end=msg['newVal'])
elif msg['kind'][:5] == 'move-':
if player not in self.player_states:
logging.warning("Unknown player %s issued a move" % player)
return
state = self.player_states[player]
if not state.is_in_game():
logging.warning("Player %s issued a move while in %s" % (player, state))
return
game = state.get_game()
try:
game.process_move(player, msg)
except IllegalMoveException as e:
logging.warning("Player %s issued an illegal move: %s" % (self, repr(e),))
logging.warning(game.as_dict())
from player_state import PlayerState
from utils import p
import re
import tornado.ioloop
card_update_pattern = re.compile(
'^.*id=(?P<id>\d*) .*cardId=(?P<card_id>[a-zA-Z0-9\_]*).*player=(?P<player>\d*)\](?: CardID=(?P<alternate_card_id>[a-zA-Z0-9\_]*))?.*$'
)
game_complete_pattern = re.compile(
'^.*TAG_CHANGE Entity=GameEntity tag=STATE value=COMPLETE.*$')
player_state = PlayerState()
def parse_log_lines(line):
if game_complete_pattern.match(line):
player_state.clear_players()
match = card_update_pattern.match(line)
if not match:
return
id = match.group('id')
cardId = match.group('card_id')
alternate_card_id = match.group('alternate_card_id')
player = match.group('player')
if player_state.card_drawn(id, cardId or alternate_card_id, player):
p("Updated player state")
class TestPlayer(unittest.TestCase):
@classmethod
def setUpClass(cls):
test_utils.setup()
def setUp(self):
self.species_1 = Species(4, 4, 4)
self.species_2 = Species(4, 4, 4)
self.species_3 = Species(4, 4, 3)
self.species_4 = Species(4, 3, 3)
self.species_5 = Species(3, 1, 3)
self.species_6 = Species(4, 3, 3)
self.species_7 = Species(4, 4, 4)
self.species_list = [self.species_2, self.species_4,
self.species_3, self.species_5,
self.species_1]
self.player_1 = PlayerState(Player,
species=[self.species_4,
self.species_5,
self.species_6])
self.player_2 = PlayerState(Player,
species=[self.species_1])
self.player_3 = PlayerState(Player,
species=[self.species_2,
self.species_3,
self.species_7])
self.attacker = Species()
self.attacker.traits = [TraitCard("carnivore")]
self.defender = Species()
def test_feed_fatty(self):
self.species_4.traits = [TraitCard("fat-tissue")]
self.species_1.traits = [TraitCard("fat-tissue")]
self.species_5.traits = [TraitCard("fat-tissue")]
self.assertEqual(Player.feed_fatty([self.species_4, self.species_1, self.species_5], 10),
[self.species_5, 3])
self.assertEqual(Player.feed_fatty([self.species_4, self.species_1, self.species_5], 1),
[self.species_5, 1])
self.assertEqual(Player.feed_fatty([self.species_4, self.species_1], 10),
[self.species_4, 3])
def test_feed_herbivore(self):
self.assertEqual(Player.feed_herbivores([self.species_4, self.species_5]), self.species_4)
def give_carnivore_trait(self):
self.player_1.species = [self.species_6, self.species_5, self.species_4]
self.species_4.traits = ["carnivore"]
self.species_5.traits = ["carnivore"]
self.species_6.traits = ["carnivore"]
def test_feed_carnivore_tie_attacker(self):
# Test tie in largest carnivore in attacking player's hand => first species chosen
self.give_carnivore_trait()
self.player_1.species = [self.species_4, self.species_5, self.species_6]
self.assertEqual(Player.feed_carnivore(self.player_1.species, self.player_1,
[self.player_2, self.player_3]),
[self.species_4, self.player_2, self.species_1])
def test_feed_carnivore_ordering(self):
# Repeat to test first is chosen again when order is changed
self.give_carnivore_trait()
self.assertEqual(Player.feed_carnivore(self.player_1.species, self.player_1,
[self.player_2, self.player_3]),
[self.species_6, self.player_2, self.species_1])
def test_feed_carnivore_tie_defender(self):
# Test tie in largest target between defending players' hands => first given player chosen
self.give_carnivore_trait()
self.assertEqual(Player.feed_carnivore(self.player_1.species, self.player_1,
[self.player_3, self.player_2]),
[self.species_6, self.player_3, self.species_2])
def test_feed_carnivore_tie_largest(self):
# Test tie in largest target within defending player's hand => first species chosen
self.give_carnivore_trait()
self.player_3.species = [self.species_7, self.species_3, self.species_2]
self.assertEqual(Player.feed_carnivore(self.player_1.species, self.player_1,
[self.player_3, self.player_2]),
[self.species_6, self.player_3, self.species_7])
def test_feed_carnivore_first_attackable(self):
# Retest tie, but with first species unattackable => second largest chosen
self.give_carnivore_trait()
self.player_3.species = [self.species_7, self.species_3, self.species_2]
self.species_7.traits = ["climbing"]
self.assertEqual(Player.feed_carnivore(self.player_1.species, self.player_1,
[self.player_3, self.player_2]),
[self.species_6, self.player_3, self.species_2])
def test_feed_carnivore_first_player_unattackable(self):
# Repeat again, but since both largest in first player's hand are
# unattackable => second player w/ largest
self.give_carnivore_trait()
self.player_3.species = [self.species_7, self.species_3, self.species_2]
self.species_7.traits = ["climbing"]
self.species_2.traits = ["burrowing"]
self.assertEqual(Player.feed_carnivore(self.player_1.species, self.player_1,
[self.player_3, self.player_2]),
[self.species_6, self.player_2, self.species_1])
def test_feed_carnivore_smaller_attackable(self):
# Test that if all largest species are unattackable, a smaller species is chosen
self.give_carnivore_trait()
self.player_3.species = [self.species_7, self.species_3, self.species_2]
self.species_7.traits = ["climbing"]
self.species_2.traits = ["burrowing"]
self.species_1.traits = ["climbing"]
self.assertEqual(Player.feed_carnivore(self.player_1.species, self.player_1,
[self.player_3, self.player_2]),
[self.species_6, self.player_3, self.species_3])
def test_feed_carnivore_climbing(self):
# Test that a carnivore with overriding traits attacks the largest species attackable
self.give_carnivore_trait()
self.player_3.species = [self.species_7, self.species_3, self.species_2]
self.species_7.traits = ["climbing"]
self.species_2.traits = ["burrowing"]
self.species_1.traits = ["climbing"]
self.species_3.traits = ["climbing"]
self.species_4.traits.append("climbing")
self.assertEqual(Player.feed_carnivore(self.player_1.species,
self.player_1,
[self.player_3, self.player_2]),
[self.species_4, self.player_3, self.species_7])
def test_next_feeding(self):
self.species_4.traits = ["carnivore"]
self.species_5.traits = ["fat-tissue"]
# Test if fat_tissue_species
next_feeding = Player().next_feeding(self.player_1, 10, [self.player_2, self.player_3])
self.assertEqual(next_feeding.species_index, 1)
self.assertEqual(next_feeding.food_requested, 3)
# Test if hungry_herbivores
self.species_5.traits = []
next_feeding = Player().next_feeding(self.player_1, 10, [self.player_2])
self.assertEqual(next_feeding.species_index, 2)
# Test if hungry_carnivore
self.species_5.traits = ["carnivore"]
self.species_6.traits = ["carnivore"]
next_feeding = Player().next_feeding(self.player_1, 10, [self.player_2, self.player_3])
self.assertEqual(next_feeding.attacker_index, 0)
self.assertEqual(next_feeding.target_index, 0)
self.assertEqual(next_feeding.defender_index, 0)
# Test if you can attack your own species.
next_feeding = Player().next_feeding(self.player_1, 10, [self.player_1])
self.assertEqual(next_feeding.attacker_index, 0)
self.assertEqual(next_feeding.target_index, 0)
self.assertEqual(next_feeding.defender_index, 2)
def test_is_larger(self):
# Population different
self.defender.population = 2
self.attacker.population = 1
self.assertEqual(Player.is_larger(self.defender, self.attacker), 1)
self.assertEqual(Player.is_larger(self.attacker, self.defender), -1)
# Same population different food
self.attacker.population = 2
self.defender.food = 2
self.attacker.food = 1
self.assertEqual(Player.is_larger(self.defender, self.attacker), 1)
self.assertEqual(Player.is_larger(self.attacker, self.defender), -1)
# Same population and food different body
self.attacker.food = 2
self.defender.body = 4
self.attacker.body = 3
self.assertEqual(Player.is_larger(self.defender, self.attacker), 1)
self.assertEqual(Player.is_larger(self.attacker, self.defender), -1)
# Equal population, food, and body
self.attacker.body = 4
self.assertEqual(Player.is_larger(self.defender, self.attacker), 0)
def test_sort_lex(self):
sorted_list = [self.species_2, self.species_1, self.species_3,
self.species_4, self.species_5]
self.assertEqual(Player.sort_lex(self.species_list), sorted_list)
self.assertNotEqual(Player.sort_lex(self.species_list), self.species_list)
def test_largest_tied_species(self):
tied_species = [self.species_2, self.species_1]
self.assertEqual(Player.largest_tied_species(self.species_list), tied_species)
def test_largest_fatty_need(self):
self.species_1.traits = [TraitCard("fat-tissue")]
self.species_2.traits = [TraitCard("fat-tissue")]
self.species_4.traits = [TraitCard("fat-tissue")]
self.assertEqual(Player.largest_fatty_need([self.species_1, self.species_4]),
self.species_4)
self.assertEqual(Player.largest_fatty_need([self.species_1, self.species_2]),
self.species_1)
def test_choose(self):
self.player_1.hand = [TraitCard("burrowing"), TraitCard("carnivore"),
TraitCard("fertile")]
expected = Action(0, [], [], [BoardAddition(1, [2])], [])
choice = Choice([self.species_list], [])
strategy = Player()
strategy.start(self.player_1, 10)
self.assertEqual(expected, strategy.choose(choice))
def test_choose_gp(self):
self.player_1.hand = [TraitCard("scavenger"), TraitCard("burrowing"),
TraitCard("carnivore"), TraitCard("fertile")]
expected = Action(1, [PopGrow(3, 0)], [], [BoardAddition(2, [3])], [])
choice = Choice([self.species_list], [])
strategy = Player()
strategy.start(self.player_1, 10)
actual = strategy.choose(choice)
self.assertEqual(expected, actual)
def test_choose_gb(self):
self.player_1.hand = [TraitCard("scavenger"), TraitCard("burrowing"),
TraitCard("carnivore"), TraitCard("fertile"),
TraitCard("foraging")]
expected = Action(1, [PopGrow(3, 4)], [BodyGrow(3, 0)], [BoardAddition(2, [3])], [])
choice = Choice([self.species_list], [])
strategy = Player()
strategy.start(self.player_1, 10)
actual = strategy.choose(choice)
self.assertEqual(expected, actual)
def test_choose_rt(self):
self.player_1.hand = [TraitCard("long-neck"), TraitCard("scavenger"),
TraitCard("burrowing"), TraitCard("carnivore"),
TraitCard("fertile"), TraitCard("foraging")]
expected = Action(2, [PopGrow(3, 5)], [BodyGrow(3, 0)],
[BoardAddition(3, [4])], [ReplaceTrait(3, 0, 1)])
choice = Choice([self.species_list], [])
strategy = Player()
strategy.start(self.player_1, 10)
actual = strategy.choose(choice)
self.assertEqual(expected, actual)
def test_choose_rt_2(self):
self.player_1.hand = [TraitCard("long-neck"), TraitCard("scavenger"),
TraitCard("burrowing"), TraitCard("carnivore"),
TraitCard("fertile"), TraitCard("foraging"),
TraitCard("scavenger", 3)]
expected = Action(2, [PopGrow(3, 5)], [BodyGrow(3, 0)], [BoardAddition(3, [4])],
[ReplaceTrait(3, 0, 1)])
choice = Choice([self.species_list], [])
strategy = Player()
strategy.start(self.player_1, 10)
actual = strategy.choose(choice)
player_expected = copy.deepcopy(self.player_1)
player_expected.apply_action(expected)
self.player_1.apply_action(actual)
self.check_player(player_expected, self.player_1, {})
class TestPlayer(unittest.TestCase):
def setUp(self):
self.species_1 = Species(4, 4, 4)
self.species_2 = Species(4, 4, 4)
self.species_3 = Species(4, 4, 3)
self.species_4 = Species(4, 3, 3)
self.species_5 = Species(3, 1, 3)
self.species_6 = Species(4, 3, 3)
self.species_7 = Species(4, 4, 4)
self.species_list = [
self.species_2, self.species_4, self.species_3, self.species_5,
self.species_1
]
self.player_1 = PlayerState(
species=[self.species_4, self.species_5, self.species_6])
self.player_2 = PlayerState(species=[self.species_1])
self.player_3 = PlayerState(
species=[self.species_2, self.species_3, self.species_7])
def test_sort_largest(self):
sorted_list = [
self.species_2, self.species_1, self.species_3, self.species_4,
self.species_5
]
self.assertEqual(Player.sort_by_size(self.species_list), sorted_list)
self.assertNotEqual(Player.sort_by_size(self.species_list),
self.species_list)
def test_largest_fatty_need(self):
self.species_1.traits = self.species_2.traits = self.species_4.traits = [
TraitCard(FATTISSUE)
]
self.species_1.fat_storage = self.species_2.fat_storage = self.species_4.fat_storage = 0
self.assertEqual(
Player.largest_fatty_need([self.species_1, self.species_4]),
self.species_1)
self.assertEqual(
Player.largest_fatty_need([self.species_1, self.species_2]),
self.species_1)
def test_feed_herbivore(self):
self.assertEqual(
Player.feed_herbivores([self.species_4, self.species_5],
self.player_1), HerbivoreFeeding(0))
def test_feed_carnivore(self):
self.species_4.traits = [TraitCard(CARNIVORE, 4)]
self.species_5.traits = [TraitCard(CARNIVORE)]
self.species_6.traits = [TraitCard(CARNIVORE)]
# Test tie in largest carnivore in attacking player's hand => first species chosen
self.assertEqual(
Player.feed_carnivore(self.player_1.species, self.player_1,
[self.player_2, self.player_3]),
CarnivoreFeeding(0, 0, 0))
# Repeat to test first is chosen again when order is changed
self.player_1.species = [
self.species_6, self.species_5, self.species_4
]
self.assertEqual(
Player.feed_carnivore(self.player_1.species, self.player_1,
[self.player_2, self.player_3]),
CarnivoreFeeding(0, 0, 0))
# Test tie in largest target between defending players' hands => first given player chosen
self.assertEqual(
Player.feed_carnivore(self.player_1.species, self.player_1,
[self.player_3, self.player_2]),
CarnivoreFeeding(0, 0, 0))
# Test tie in largest target within defending player's hand => first species chosen
self.player_3.species = [
self.species_7, self.species_3, self.species_2
]
self.assertEqual(
Player.feed_carnivore(self.player_1.species, self.player_1,
[self.player_3, self.player_2]),
CarnivoreFeeding(0, 0, 0))
# Retest tie, but with first species unattackable => second largest chosen
self.species_7.traits = [TraitCard(CLIMBING)]
self.assertEqual(
Player.feed_carnivore(self.player_1.species, self.player_1,
[self.player_3, self.player_2]),
CarnivoreFeeding(0, 0, 2))
# Repeat again, but since both largest in first player's hand are unattackable => second player w/ largest
self.species_2.traits = [TraitCard(BURROWING)]
self.assertEqual(
Player.feed_carnivore(self.player_1.species, self.player_1,
[self.player_3, self.player_2]),
CarnivoreFeeding(0, 1, 0))
# Test that if all largest species are unattackable, a smaller species is chosen
self.species_1.traits = [TraitCard(CLIMBING)]
self.assertEqual(
Player.feed_carnivore(self.player_1.species, self.player_1,
[self.player_3, self.player_2]),
CarnivoreFeeding(0, 0, 1))
# Test that a carnivore with overriding traits attacks the largest species attackable
self.species_3.traits = [TraitCard(CLIMBING)]
self.species_4.traits.append(TraitCard(CLIMBING))
self.assertEqual(
Player.feed_carnivore(self.player_1.species, self.player_1,
[self.player_3, self.player_2]),
CarnivoreFeeding(2, 0, 0))
def test_next_feeding(self):
self.species_4.traits = [TraitCard(CARNIVORE)]
self.species_5.traits, self.species_5.fat_storage = ([
TraitCard(FATTISSUE)
], 0)
# Test if fat_tissue_species
self.assertEqual(
Player.next_feeding(self.player_1, 10,
[self.player_2, self.player_3]),
FatFeeding(1, 3))
# Test if hungry_herbivores
self.species_5.traits = []
self.assertEqual(
Player.next_feeding(self.player_1, 10, [self.player_2]),
HerbivoreFeeding(2))
# Test if hungry_carnivore
self.species_5.traits = [TraitCard(CARNIVORE)]
self.species_6.traits = [TraitCard(CARNIVORE)]
self.assertEqual(
Player.next_feeding(self.player_1, 10,
[self.player_2, self.player_3]),
CarnivoreFeeding(0, 0, 0))
# Test no attackable species
self.assertEqual(Player.next_feeding(self.player_1, 10, []),
NoFeeding())
def test_show_changes(self):
self.assertEquals(
self.player_1.show_changes(self.player_2),
'Species 0: [[food, 3->4], [body, 3->4]], '
'Species 1: Species removed, '
'Species 2: Species removed')
self.player_2.food_bag = 3
self.player_2.active = False
self.assertEquals(
self.player_1.show_changes(self.player_2), '[food_bag, 0->3], '
'Species 0: [[food, 3->4], [body, 3->4]], '
'Species 1: Species removed, '
'Species 2: Species removed, '
'[active, True->False]')
self.assertEquals(
self.player_2.show_changes(self.player_1), "[food_bag, 3->0], "
"Species 0: [[body, 4->3]], "
"Species 1: New Species: [[food, 1], [body, 3], [population, 3], [traits, []]], "
"Species 2: New Species: [[food, 3], [body, 3], [population, 4], [traits, []]], "
"[active, False->True]")
def get_player_state_gid(gid: int) -> list:
query_res = sql(f'SELECT * FROM player_states WHERE game_id = ?', True, (gid,))
result: list = []
for line in query_res:
result.append(PlayerState(line[0], line[1], line[2], line[3], line[4], line[5], line[6], line[7]))
return result
def previous_song(self, state):
self._prep_song_list(state.genre)
next_song_index = self._next_song_index(state, advance=-1)
return PlayerState(state.genre, self._genre_song_list[next_song_index], state.exclude_from_genre)
class TestPlayer(unittest.TestCase):
def setUp(self):
self.carnivore = TraitCard(CARNIVORE, 3)
self.burrowing = TraitCard(BURROWING, 2)
self.fattissue = TraitCard(FATTISSUE, 4)
self.foraging = TraitCard(FORAGING, 2)
self.horns = TraitCard(HORNS, 6)
self.cooperation = TraitCard(COOPERATION, 1)
self.scavenger = TraitCard(SCAVENGER, 2)
self.species_1 = Species(4, 4, 4, [])
self.species_2 = Species(4, 4, 4)
self.species_3 = Species(4, 4, 3)
self.species_4 = Species(4, 3, 3)
self.species_5 = Species(3, 1, 3)
self.species_6 = Species(4, 3, 3)
self.species_7 = Species(4, 4, 4)
self.species_list = [
self.species_2, self.species_4, self.species_3, self.species_5,
self.species_1
]
self.player_1 = PlayerState(
species=[self.species_4, self.species_5, self.species_6],
hand=[self.carnivore])
self.player_2 = PlayerState(species=[self.species_1],
hand=[self.carnivore, self.fattissue])
self.player_3 = PlayerState(
species=[self.species_2, self.species_3, self.species_7],
hand=[self.foraging])
def test_grow_attribute(self):
growpop = GrowAction("population", 0, 0)
growbody = GrowAction("body", 0, 0)
old_player = copy.deepcopy(self.player_1)
self.player_1.grow_attribute(growpop)
self.player_1.grow_attribute(growpop)
self.player_1.grow_attribute(growbody)
self.assertEqual(old_player.show_changes(self.player_1),
'Species 0: [[population, 4->6], [body, 3->4]]')
def test_add_species(self):
old_player_1 = copy.deepcopy(self.player_1)
old_player_2 = copy.deepcopy(self.player_2)
self.player_1.add_species([])
self.assertEqual(
old_player_1.show_changes(self.player_1),
'Species 3: New Species: [[food, 0], [body, 0], [population, 1], [traits, []]]'
)
self.player_1.add_species([0])
self.assertEqual(
old_player_1.show_changes(self.player_1),
'Species 3: New Species: [[food, 0], [body, 0], [population, 1], [traits, []]], '
'Species 4: New Species: [[food, 0], [body, 0], [population, 1], [traits, [[carnivore, 3]]]]'
)
self.player_2.add_species([0, 1])
self.assertEqual(
old_player_2.show_changes(self.player_2), 'Species 1: '
'New Species: '
'[[food, 0], [body, 0], [population, 1], [traits, [[carnivore, 3], [fat-tissue, 4]]]]'
)
def test_discard_all(self):
self.player_1.hand = [
self.carnivore, self.fattissue, self.foraging, self.burrowing,
self.cooperation
]
old_player = copy.deepcopy(self.player_1)
self.player_1.discard_all([0, 2, 4])
self.assertEqual(
old_player.show_changes(self.player_1),
'removed cards: [carnivore, 3], [foraging, 2], [cooperation, 1]')
return
def test_show_changes(self):
self.assertEquals(
self.player_1.show_changes(self.player_2),
'new cards: [fat-tissue, 4], '
'Species 0: [[food, 3->4], [body, 3->4]], '
'Species 1: Species removed, '
'Species 2: Species removed')
self.player_2.food_bag = 3
self.player_2.active = False
self.assertEquals(
self.player_1.show_changes(self.player_2), '[food_bag, 0->3], '
'new cards: [fat-tissue, 4], '
'Species 0: [[food, 3->4], [body, 3->4]], '
'Species 1: Species removed, '
'Species 2: Species removed, '
'[active, True->False]')
self.assertEquals(
self.player_2.show_changes(self.player_1), "[food_bag, 3->0], "
'removed cards: [fat-tissue, 4], '
"Species 0: [[food, 4->3], [body, 4->3]], "
"Species 1: New Species: [[food, 1], [body, 3], [population, 3], [traits, []]], "
"Species 2: New Species: [[food, 3], [body, 3], [population, 4], [traits, []]], "
"[active, False->True]")
def get_player_state_pid(pid: int) -> PlayerState:
query_res = sql(f'SELECT * FROM player_states WHERE player_id = ?', True, (pid,))[0]
return PlayerState(query_res[0], query_res[1], query_res[2], query_res[3], query_res[4],
query_res[5], query_res[6], query_res[7])
def add_player(self, address, location):
self.next_player_id += 1
new_player = PlayerState(location, self.next_player_id)
client = ClientState(address, new_player)
self.players[new_player.id] = client
return new_player
class TestPlayerState(unittest.TestCase):
@classmethod
def setUpClass(cls):
test_utils.setup()
def setUp(self):
species_0 = Species(population=1,
food=3,
body=4,
traits=["carnivore"])
species_1 = Species(population=1,
food=1,
body=1,
traits=["burrowing"])
species_2 = Species(population=1,
food=0,
body=1,
traits=["fat-tissue"])
species = [species_0, species_1, species_2]
hand = [TraitCard("long-neck", food_points=2),
TraitCard("climbing", food_points=-2),
TraitCard("scavenger", food_points=4)]
self.player = PlayerState(Player, hand=hand, species=species)
def test_create_new_boards_one(self):
board_addition = BoardAddition(0, traits=[1, 2])
before = copy.deepcopy(self.player)
self.player.create_new_boards([board_addition])
self.player.remove_used_cards()
changes = {
"species": {3: {
"population": 1,
"food": 0,
"body": 0,
"fat_storage": 0,
"traits": ["climbing", "scavenger"]}},
"hand": []}
self.check_player(before, self.player, changes)
def test_create_new_boards_many(self):
board_addition_0 = BoardAddition(0)
board_addition_1 = BoardAddition(1)
board_addition_2 = BoardAddition(2)
before = copy.deepcopy(self.player)
self.player.create_new_boards([board_addition_0,
board_addition_1,
board_addition_2])
self.player.remove_used_cards()
new_species = {
"population": 1,
"food": 0,
"body": 0,
"fat_storage": 0,
"traits": []
}
changes = {
"species": {
3: new_species,
4: new_species,
5: new_species,
},
"hand": []
}
self.check_player(before, self.player, changes)
# TODO: Species don't need whole trait cards, just their traits.
def test_replace_traits_one(self):
replacements = [ReplaceTrait(0, 0, 0)]
before = copy.deepcopy(self.player)
self.player.replace_traits(replacements)
self.player.remove_used_cards()
changes = {
"species":
{0: {"traits": ["long-neck"]}},
"hand":
[TraitCard("climbing", food_points=-2),
TraitCard("scavenger", food_points=4)]
}
self.check_player(before, self.player, changes)
def test_replace_traits_many(self):
replacements = [ReplaceTrait(0, 0, 0),
ReplaceTrait(2, 0, 1),
ReplaceTrait(1, 0, 2)]
before = copy.deepcopy(self.player)
self.player.replace_traits(replacements)
self.player.remove_used_cards()
changes = {
"species":
{0: {"traits": ["long-neck"]},
2: {"traits": ["climbing"]},
1: {"traits": ["scavenger"]}},
"hand":
[]
}
self.check_player(before, self.player, changes)
def test_increase_populations_one(self):
pop_grows = [PopGrow(1, 1)]
before = copy.deepcopy(self.player)
self.player.increase_populations(pop_grows)
self.player.remove_used_cards()
changes = {
"species":
{1: {"population": 2}},
"hand":
[TraitCard("long-neck", food_points=2),
TraitCard("scavenger", food_points=4)]
}
self.check_player(before, self.player, changes)
def test_increase_populations_many_same_species(self):
pop_grows = [PopGrow(1, 1), PopGrow(1, 0), PopGrow(1, 2)]
before = copy.deepcopy(self.player)
self.player.increase_populations(pop_grows)
self.player.remove_used_cards()
changes = {
"species":
{1: {"population": 4}},
"hand":
[]
}
self.check_player(before, self.player, changes)
def test_increase_populations_many_different_species(self):
pop_grows = [PopGrow(1, 1), PopGrow(0, 0), PopGrow(2, 2)]
before = copy.deepcopy(self.player)
self.player.increase_populations(pop_grows)
self.player.remove_used_cards()
changes = {
"species":
{0: {"population": 2},
1: {"population": 2},
2: {"population": 2}},
"hand":
[]
}
self.check_player(before, self.player, changes)
def test_increase_body_sizes_one(self):
body_grows = [BodyGrow(1, 1)]
before = copy.deepcopy(self.player)
self.player.increase_body_sizes(body_grows)
self.player.remove_used_cards()
changes = {
"species":
{1: {"body": 2}},
"hand":
[TraitCard("long-neck", food_points=2),
TraitCard("scavenger", food_points=4)]
}
self.check_player(before, self.player, changes)
def test_increase_body_sizes_many_same_species(self):
body_grows = [BodyGrow(1, 1), BodyGrow(1, 0), BodyGrow(1, 2)]
before = copy.deepcopy(self.player)
self.player.increase_body_sizes(body_grows)
self.player.remove_used_cards()
changes = {
"species": {1: {"body": 4}},
"hand": []
}
self.check_player(before, self.player, changes)
def test_increase_body_sizes_many_different_species(self):
body_grows = [BodyGrow(1, 1), BodyGrow(0, 0), BodyGrow(2, 2)]
before = copy.deepcopy(self.player)
self.player.increase_body_sizes(body_grows)
self.player.remove_used_cards()
changes = {
"species":
{0: {"body": 5},
1: {"body": 2},
2: {"body": 2}},
"hand":
[]
}
self.check_player(before, self.player, changes)
def test_can_feed(self):
self.assertTrue(self.player.can_feed([self.player]))
self.player.species[0].traits = ["carnivore"]
self.player.species[1].traits = ["carnivore"]
self.player.species[2].traits = ["carnivore"]
self.assertFalse(self.player.can_feed([]))
def test_are_actions_in_range_valid(self):
good_action_gp_gb = Action(2, [PopGrow(0, 1)], [BodyGrow(1, 0)], [], [])
good_action_board = Action(2, [], [], [BoardAddition(0, [1])], [])
good_action_ba_rt = Action(2, [], [], [BoardAddition(0, [])], [ReplaceTrait(0, 0, 1)])
self.assertTrue(self.player.are_actions_in_range(good_action_gp_gb))
self.assertTrue(self.player.are_actions_in_range(good_action_board))
self.assertTrue(self.player.are_actions_in_range(good_action_ba_rt))
def test_are_actions_in_range_invalid(self):
good_action_gp_gb = Action(3, [PopGrow(0, 1)], [BodyGrow(1, 0)], [], [])
good_action_board = Action(2, [], [], [BoardAddition(0, [3])], [])
good_action_ba_rt = Action(2, [], [], [BoardAddition(0, [])], [ReplaceTrait(0, 0, 3)])
self.assertFalse(self.player.are_actions_in_range(good_action_gp_gb))
self.assertFalse(self.player.are_actions_in_range(good_action_board))
self.assertFalse(self.player.are_actions_in_range(good_action_ba_rt))
def test_validate_pop_grows(self):
good_action = Action(3, [PopGrow(0, 1), PopGrow(0, 0)], [], [], [])
self.assertTrue(self.player.validate_pop_grows(good_action))
self.player.species[0].population = MAX_POPULATION
bad_action = Action(3, [PopGrow(0, 1)], [], [], [])
self.assertFalse(self.player.validate_pop_grows(bad_action))
self.player.species[0].population = MAX_POPULATION - 1
bad_action = Action(3, [PopGrow(0, 1), PopGrow(0, 0)], [], [], [])
self.assertFalse(self.player.validate_pop_grows(bad_action))
def test_validate_body_grows(self):
good_action = Action(3, [], [BodyGrow(0, 1), BodyGrow(0, 0)], [], [])
self.assertTrue(self.player.validate_body_grows(good_action))
self.player.species[0].body = MAX_BODY_SIZE
bad_action = Action(3, [], [BodyGrow(0, 1)], [], [])
self.assertFalse(self.player.validate_body_grows(bad_action))
self.player.species[0].body = MAX_BODY_SIZE - 1
bad_action = Action(3, [], [BodyGrow(0, 1), BodyGrow(0, 0)], [], [])
self.assertFalse(self.player.validate_body_grows(bad_action))
def test_validate_board_additions(self):
good_action = Action(3, [], [], [BoardAddition(0, [1])], [])
self.assertTrue(self.player.validate_board_additions(good_action))
self.player.hand.append(TraitCard("long-neck"))
bad_action = Action(3, [], [], [BoardAddition(0, [0, 3])], [])
self.assertFalse(self.player.validate_board_additions(bad_action))
def test_validate_trait_replacements(self):
good_action = Action(3, [], [], [], [ReplaceTrait(0, 0, 1)])
self.assertTrue(self.player.validate_trait_replacements(good_action))
bad_action = Action(3, [], [], [], [ReplaceTrait(0, 1, 1)])
self.assertFalse(self.player.validate_trait_replacements(bad_action))
self.player.species[0].traits.append("long-neck")
bad_action = Action(3, [], [], [], [ReplaceTrait(0, 0, 0)])
self.assertFalse(self.player.validate_trait_replacements(bad_action))
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
text=True)
print("shutdown: {}: {}", result.returncode, result.stdout)
elif shutdown:
print('Shutdown is not implemented on Windows yet, sorry.')
sys.exit(0)
if __name__ == '__main__':
print('Playlist DJ 2.0')
_print_help()
song_list = Playlist(known_songs_state.load())
state = PlayerState.from_saved_state()
if state is None:
state = song_list.random_song_anywhere(state)
def _next_song():
global state
state = song_list.next_song(state)
_play_and_save(player, state)
player = Player(next_song_callback=_next_song)
_resume_playing_on_start(player, state)
song_transition_map = {
keys.NEXT_SONG_KEY: song_list.next_song,
keys.PREVIOUS_SONG_KEY: song_list.previous_song,
def random_song_in_playlist(self, state):
random_song = random.choice(self._genre_song_list)
while self._is_excluded_song(state, random_song):
random_song = random.choice(self._genre_song_list)
return PlayerState(state.genre, random_song, state.exclude_from_genre)
