def test_double_fainted_active_pokemon(self):
self.battle.user.active.hp = 0
self.battle.opponent.active.hp = 0
self.battle.user.active.moves = [
Move('tackle'),
Move('charm'),
]
self.battle.opponent.active.moves = [
Move('tackle'),
Move('thunderbolt'),
]
self.battle.user.reserve = [
Pokemon('caterpie', 100),
Pokemon('spinarak', 100)
]
self.battle.opponent.reserve = [
Pokemon('caterpie', 100),
Pokemon('houndour', 100)
]
expected_options = (['switch caterpie', 'switch spinarak'],
['switch caterpie', 'switch houndour'])
self.assertEqual(expected_options, self.battle.get_all_options())
def switch_or_drag(battle, split_msg):
"""The opponent's pokemon has changed
If the new one hasn't been seen, create it"""
if is_opponent(battle, split_msg):
battle.opponent.side_conditions[constants.TOXIC_COUNT] = 0
if battle.opponent.active is not None:
# reset the boost of the pokemon being replaced
battle.opponent.active.boosts.clear()
# reset the volatile statuses of the pokemon being replaced
battle.opponent.active.volatile_statuses.clear()
# check if the pokemon exists in the reserves
# if it does not, then the newly-created pokemon is used (for formats without team preview)
pkmn = Pokemon.from_switch_string(split_msg[3])
pkmn = find_pokemon_in_reserves(pkmn.name, battle.opponent.reserve)
if pkmn is None:
pkmn = Pokemon.from_switch_string(split_msg[3])
else:
battle.opponent.reserve.remove(pkmn)
# pkmn != active is a special edge-case for Zoroark
if battle.opponent.active is not None and pkmn != battle.opponent.active:
battle.opponent.reserve.append(battle.opponent.active)
battle.opponent.active = pkmn
if battle.opponent.active.name in constants.UNKOWN_POKEMON_FORMES:
battle.opponent.active = Pokemon.from_switch_string(split_msg[3])
else:
battle.user.side_conditions[constants.TOXIC_COUNT] = 0
battle.user.active.boosts.clear()
def test_gives_no_options_for_user_and_only_switches_for_opponent_when_opponent_active_is_dead(self):
self.battle.opponent.active.hp = 0
self.battle.user.active.moves = [
Move('tackle'),
Move('charm'),
]
self.battle.opponent.active.moves = [
Move('tackle'),
Move('thunderbolt'),
]
self.battle.user.reserve = [Pokemon('caterpie', 100), Pokemon('spinarak', 100)]
self.battle.opponent.reserve = [Pokemon('caterpie', 100), Pokemon('houndour', 100)]
expected_options = (
[
'splash'
],
[
'switch caterpie',
'switch houndour'
]
)
self.assertEqual(expected_options, self.battle.get_all_options())
def test_gets_multiple_switches_and_multiple_moves(self):
self.battle.user.active.moves = [
Move('tackle'),
Move('charm'),
]
self.battle.opponent.active.moves = [
Move('tackle'),
Move('thunderbolt'),
]
self.battle.user.reserve = [Pokemon('caterpie', 100), Pokemon('spinarak', 100)]
self.battle.opponent.reserve = [Pokemon('caterpie', 100), Pokemon('houndour', 100)]
expected_options = (
[
'tackle',
'charm',
'switch caterpie',
'switch spinarak'
],
[
'tackle',
'thunderbolt',
'switch caterpie',
'switch houndour'
]
)
self.assertEqual(expected_options, self.battle.get_all_options())
def test_ignores_moves_and_gives_opponent_no_option_when_force_switch_is_true(self):
self.battle.force_switch = True
self.battle.user.active.moves = [
Move('tackle'),
Move('charm'),
]
self.battle.opponent.active.moves = [
Move('tackle'),
Move('thunderbolt'),
]
self.battle.user.reserve = [Pokemon('caterpie', 100), Pokemon('spinarak', 100)]
self.battle.opponent.reserve = [Pokemon('caterpie', 100), Pokemon('houndour', 100)]
expected_options = (
[
'switch caterpie',
'switch spinarak'
],
[
'splash'
]
)
self.assertEqual(expected_options, self.battle.get_all_options())
def test_gets_all_moves_when_an_unknown_set_is_there(self):
self.get_sets_mock.return_value = {
constants.SETS: {
"grassknot|hiddenpowerice60|voltswitch|volttackle": 16,
"grassknot|hiddenpowerice60|irontail|poisonjab": 33
},
constants.MOVES: {
"grassknot": 1,
"hiddenpowerice60": 1,
"voltswitch": 1,
"volttackle": 1,
"irontail": 1,
"poisonjab": 1,
}
}
expected_moves = [
Move("tackle"),
Move("grassknot"),
Move("hiddenpowerice60"),
Move("voltswitch"),
Move("volttackle"),
Move("irontail"),
Move("poisonjab")
]
p = Pokemon('pikachu', 100)
p.moves = [Move("tackle")]
p.update_moves_for_random_battles()
self.assertEqual(expected_moves, p.moves)
def test_preserves_previous_status_condition(self):
self.get_mega_name_mock.return_value = 'venusaurmega'
pkmn = Pokemon('venusaur', 100)
pkmn.status = constants.BURN
pkmn.try_convert_to_mega()
self.assertEqual(constants.BURN, pkmn.status)
def test_preserves_previous_hitpoints(self):
self.get_mega_name_mock.return_value = 'venusaurmega'
pkmn = Pokemon('venusaur', 100)
pkmn.hp = 1
pkmn.try_convert_to_mega()
self.assertEqual(1, pkmn.hp)
def test_preserves_previous_boosts(self):
self.get_mega_name_mock.return_value = 'venusaurmega'
pkmn = Pokemon('venusaur', 100)
pkmn.boosts[constants.ATTACK] = 1
pkmn.try_convert_to_mega()
self.assertEqual(1, pkmn.boosts[constants.ATTACK])
def test_preserves_previous_moves(self):
self.get_mega_name_mock.return_value = 'venusaurmega'
pkmn = Pokemon('venusaur', 100)
pkmn.moves = [
{
'1': '2'
},
{
'3': '4'
},
{
'5': '6'
},
{
'7': '8'
},
]
pkmn.try_convert_to_mega()
expected_moves = [
{
'1': '2'
},
{
'3': '4'
},
{
'5': '6'
},
{
'7': '8'
},
]
self.assertEqual(expected_moves, pkmn.moves)
def test_converts_when_it_is_in_sets_lookup_and_check_sets_is_true(self):
self.pkmn_sets_mock.pokemon_sets = {"venusaurmega": {}}
self.get_mega_name_mock.return_value = 'venusaurmega'
pkmn = Pokemon('venusaur', 100)
pkmn.try_convert_to_mega(check_in_sets=True)
self.assertEqual("venusaurmega", pkmn.name)
def test_opponent_has_no_moves_results_in_splash_or_switches(self):
self.battle.user.active.moves = [
Move('tackle'),
Move('charm'),
]
self.battle.opponent.active.moves = [
]
self.battle.user.reserve = [Pokemon('caterpie', 100), Pokemon('spinarak', 100)]
self.battle.opponent.reserve = [Pokemon('caterpie', 100)]
expected_options = (
[
'tackle',
'charm',
'switch caterpie',
'switch spinarak'
],
[
'splash',
'switch caterpie',
]
)
self.assertEqual(expected_options, self.battle.get_all_options())
def test_opponent_has_no_moves_when_uturn_happens_after_switch(self):
self.battle.user.active.moves = [
Move('tackle'),
Move('charm'),
Move('uturn'),
]
self.battle.opponent.active.moves = [
Move('tackle'),
Move('charm'),
]
self.battle.user.reserve = [
Pokemon('caterpie', 100),
Pokemon('spinarak', 100)
]
self.battle.opponent.reserve = [Pokemon('caterpie', 100)]
# using uturn on the previous turn would cause force_switch to be True
self.battle.force_switch = True
self.battle.turn = 5
self.battle.user.last_used_move = LastUsedMove(
move='uturn',
pokemon_name='pikachu',
turn=5,
)
self.battle.opponent.last_used_move = LastUsedMove(
move='switch pikachu', pokemon_name=None, turn=5)
expected_options = (['switch caterpie', 'switch spinarak'], ['splash'])
self.assertEqual(expected_options, self.battle.get_all_options())
def test_removes_pokemon_from_reserve_if_it_is_in_there(self):
zoroark = Pokemon('zoroark', 82)
self.battle.opponent.active = Pokemon('meloetta', 100)
self.battle.opponent.reserve = [zoroark]
split_msg = ['', '-replace', 'p2a: Zoroark', 'Zoroark, L82, M']
form_change(self.battle, split_msg)
self.assertNotIn(zoroark, self.battle.opponent.reserve)
def test_does_not_convert_when_it_is_not_in_sets_lookup_and_check_sets_is_true(
self):
self.pkmn_sets_mock.standard_battle_sets = {}
self.get_mega_name_mock.return_value = 'venusaurmega'
pkmn = Pokemon('venusaur', 100)
pkmn.try_convert_to_mega(check_in_sets=True)
self.assertEqual("venusaur", pkmn.name)
def test_does_not_convert_if_item_is_revealed(self):
self.pkmn_sets_mock.standard_battle_sets = {}
self.get_mega_name_mock.return_value = 'venusaurmega'
pkmn = Pokemon('venusaur', 100)
pkmn.item = 'leftovers'
pkmn.try_convert_to_mega()
self.assertEqual("venusaur", pkmn.name)
def test_does_not_convert_if_item_is_none(self):
self.pkmn_sets_mock.pokemon_sets = {}
self.get_mega_name_mock.return_value = 'venusaurmega'
pkmn = Pokemon('venusaur', 100)
pkmn.item = None
pkmn.try_convert_to_mega()
self.assertEqual("venusaur", pkmn.name)
def switch_or_drag(battle, split_msg):
if is_opponent(battle, split_msg):
side = battle.opponent
logger.debug("Opponent has switched - clearing the last used move")
else:
side = battle.user
side.side_conditions[constants.TOXIC_COUNT] = 0
if side.active is not None:
# set the pkmn's types back to their original value if the types were changed
if constants.TYPECHANGE in side.active.volatile_statuses:
original_types = pokedex[side.active.name][constants.TYPES]
logger.debug(
"{} had it's type changed - changing its types back to {}".
format(side.active.name, original_types))
side.active.types = original_types
# if the target was transformed, reset its transformed attributes
if constants.TRANSFORM in side.active.volatile_statuses:
logger.debug(
"{} was transformed. Resetting its transformed attributes".
format(side.active.name))
side.active.stats = calculate_stats(side.active.base_stats,
side.active.level)
side.active.ability = None
side.active.moves = []
side.active.types = pokedex[side.active.name][constants.TYPES]
# reset the boost of the pokemon being replaced
side.active.boosts.clear()
# reset the volatile statuses of the pokemon being replaced
side.active.volatile_statuses.clear()
# reset toxic count for this side
side.side_conditions[constants.TOXIC_COUNT] = 0
# check if the pokemon exists in the reserves
# if it does not, then the newly-created pokemon is used (for formats without team preview)
pkmn = Pokemon.from_switch_string(split_msg[3])
pkmn = find_pokemon_in_reserves(pkmn.name, side.reserve)
if pkmn is None:
pkmn = Pokemon.from_switch_string(split_msg[3])
else:
side.reserve.remove(pkmn)
side.last_used_move = LastUsedMove(pokemon_name=None,
move='switch {}'.format(pkmn.name),
turn=battle.turn)
# pkmn != active is a special edge-case for Zoroark
if side.active is not None and pkmn != side.active:
side.reserve.append(side.active)
side.active = pkmn
if side.active.name in constants.UNKOWN_POKEMON_FORMES:
side.active = Pokemon.from_switch_string(split_msg[3])
def setUp(self):
self.battle = Battle(None)
self.battle.user.name = 'p1'
self.battle.opponent.name = 'p2'
self.battle.user.active = Pokemon('pikachu', 100)
self.opponent_active = Pokemon('caterpie', 100)
self.battle.opponent.active = self.opponent_active
self.battle.opponent.reserve = []
def test_arceus_ghost_switching_in(self):
already_seen_pokemon = Pokemon('arceus', 100)
self.battle.opponent.reserve.append(already_seen_pokemon)
split_msg = ['', 'switch', 'p2a: Arceus', 'Arceus-Ghost', '100/100']
switch_or_drag(self.battle, split_msg)
expected_pokemon = Pokemon('arceus-ghost', 100)
self.assertEqual(expected_pokemon, self.battle.opponent.active)
def test_gets_one_switch_and_splash(self):
self.battle.user.active.moves = []
self.battle.opponent.active.moves = []
self.battle.user.reserve = [Pokemon('caterpie', 100)]
self.battle.opponent.reserve = [Pokemon('caterpie', 100)]
expected_options = (['switch caterpie'], ['splash', 'switch caterpie'])
self.assertEqual(expected_options, self.battle.get_all_options())
def test_gets_four_moves_when_none_are_known(self):
p = Pokemon('pikachu', 100)
moves = [('move1', 95), ('move2', 94), ('move3', 93), ('move4', 92)]
moves = p.get_possible_moves(moves)
expected_result = (['move1', 'move2', 'move3', 'move4'], [])
self.assertEqual(expected_result, moves)
def setUp(self):
self.battle = Battle(None)
self.battle.user.name = 'p1'
self.battle.opponent.name = 'p2'
self.opponent_active = Pokemon('caterpie', 100)
self.battle.opponent.active = self.opponent_active
self.user_active = Pokemon('weedle', 100)
self.battle.user.active = self.user_active
def test_guesses_most_likely_item(self):
self.get_sets_mock.return_value = {
constants.ITEMS: {
"item_one": 10,
"item_two": 9
}
}
p = Pokemon('pikachu', 100)
p.item = constants.UNKNOWN_ITEM
p.update_item_for_random_battles()
self.assertEqual("item_one", p.item)
def test_chance_moves_are_not_affected_by_known_moves(self):
p = Pokemon('pikachu', 100)
p.moves = [Move('tackle')]
moves = [('move1', 95), ('move2', 40), ('move3', 40), ('move4', 40)]
moves = p.get_possible_moves(moves)
expected_result = (['move1'], ['move2', 'move3', 'move4'])
self.assertEqual(expected_result, moves)
def test_gets_most_likely_ability(self):
self.get_sets_mock.return_value = {
constants.ABILITIES: {
"immunity": 10,
"sandveil": 9
}
}
p = Pokemon('gligar', 100)
p.ability = None
p.update_ability_for_random_battles()
self.assertEqual("immunity", p.ability)
def test_silvally_steel_replaces_silvally(self):
already_seen_pokemon = Pokemon('silvally', 100)
self.battle.opponent.reserve.append(already_seen_pokemon)
split_msg = [
'', 'switch', 'p2a: silvally', 'Silvally-Steel, L100, M', '100/100'
]
switch_or_drag(self.battle, split_msg)
expected_pokemon = Pokemon('silvallysteel', 100)
self.assertEqual(expected_pokemon, self.battle.opponent.active)
def test_gets_only_first_3_moves_when_one_move_is_known(self):
p = Pokemon('pikachu', 100)
p.moves = [Move('tackle')]
moves = [('move1', 95), ('move2', 94), ('move3', 93), ('move4', 92)]
moves = p.get_possible_moves(moves)
expected_result = (['move1', 'move2', 'move3'], [])
self.assertEqual(expected_result, moves)
def test_does_not_get_moves_below_threshold(self):
p = Pokemon('pikachu', 100)
moves = [('move1', 95), ('move2', 94), ('move3', 50), ('move4', 25),
('move5', 25), ('move6', 15), ('move7', 15)]
moves = p.get_possible_moves(moves)
expected_result = (['move1', 'move2'], ['move3', 'move4', 'move5'])
self.assertEqual(expected_result, moves)
def test_gets_less_likely_moves_as_chance_moves(self):
p = Pokemon('pikachu', 100)
moves = [('move1', 95), ('move2', 94), ('move3', 50), ('move4', 25),
('move5', 25), ('move6', 25), ('move7', 25)]
moves = p.get_possible_moves(moves)
expected_result = (['move1', 'move2'],
['move3', 'move4', 'move5', 'move6', 'move7'])
self.assertEqual(expected_result, moves)
