def test_moves(self):
quick_settings = {"quick_moves": ["Vine Whip", "Tackle"]}
quick_mon_filter = Filters.MonFilter('quick_move_filter',
quick_settings)
self.assertTrue(quick_mon_filter.check_event(create_event({
'move_1': 221
})))
self.assertTrue(quick_mon_filter.check_event(create_event({
'move_1': 214
})))
self.assertFalse(quick_mon_filter.check_event(create_event({
'move_1': 1
})))
self.assertFalse(quick_mon_filter.check_event(create_event({
'move_1': 999
})))
charge_settings = {"charge_moves": ["Sludge Bomb", "Seed Bomb"]}
charge_mon_filter = Filters.MonFilter('charge_move_filter',
charge_settings)
self.assertTrue(charge_mon_filter.check_event(create_event({
'move_2': 90
})))
self.assertTrue(charge_mon_filter.check_event(create_event({
'move_2': 59
})))
self.assertFalse(charge_mon_filter.check_event(create_event({
'move_2': 1
})))
self.assertFalse(charge_mon_filter.check_event(create_event({
'move_2': 999
})))
def test_distance(self):
mon_event = Events.MonEvent(generate_monster({}))
settings = {'min_dist': '5', 'max_dist': '2000'}
mon_filter = Filters.MonFilter('distance_filter', settings)
for i in [1000, 5, 2000]:
mon_event.distance = i
self.assertTrue(mon_filter.check_event(mon_event))
settings2 = {'min_dist': '5', 'max_dist': 500}
mon_filter2 = Filters.MonFilter('distance_filter_2', settings2)
for i in [4, 501, 9999]:
mon_event.distance = i
self.assertFalse(mon_filter2.check_event(mon_event))
def test_custom_dts(self):
settings = {'custom_dts': {
'key1': 'value1',
'I\'m a goofy': 'goober yeah!'
}}
mon_filter = Filters.MonFilter('custom_dts_filter', settings)
self.assertTrue(mon_filter.check_event(create_event({})))
def test_height(self):
settings = {'min_height': 15, 'max_height': 'inf'}
mon_filter = Filters.MonFilter('height_filter', settings)
self.assertTrue(mon_filter.check_event(create_event({'height': 15})))
self.assertFalse(mon_filter.check_event(create_event({'height': 14})))
self.assertTrue(mon_filter.check_event(create_event({'height':
'inf'})))
def test_cp(self):
settings = {'min_cp': 20, 'max_cp': 500}
mon_filter = Filters.MonFilter('cp_filter', settings)
for i in [20, 250, 500]:
self.assertTrue(mon_filter.check_event(create_event({'cp': i})))
for i in [19, 501, 9999]:
self.assertFalse(mon_filter.check_event(create_event({'cp': i})))
def test_form(self):
# Create filter that forces settings
settings = {"form_ids": [1, 28]}
mon_filter = Filters.MonFilter('form_filter', settings)
self.assertTrue(mon_filter.check_event(create_event({'form': 1})))
self.assertTrue(mon_filter.check_event(create_event({'form': 28})))
self.assertFalse(mon_filter.check_event(create_event({'form': 2})))
self.assertFalse(mon_filter.check_event(create_event({'form': 999})))
def test_weather(self):
settings = {'weather': [1, "windy"]}
mon_filter = Filters.MonFilter('weather_filter', settings)
for i in [1, 5]:
self.assertTrue(
mon_filter.check_event(create_event({'weather': i})))
for i in [0, 2, 8]:
self.assertFalse(
mon_filter.check_event(create_event({'weather': i})))
def test_size(self):
# Assumes base height/weight of Bulbasaur
settings = {'sizes': ["tiny", "small", "large"]}
mon_filter = Filters.MonFilter('size_filter', settings)
self.assertTrue(mon_filter.check_event(create_event({
'height': 0.71,
'weight': 9
})))
self.assertFalse(mon_filter.check_event(create_event({
'height': 0.71,
'weight': 8
})))
def test_costume(self):
# Create filter that forces settings
settings = {"costume_ids": [1, 2]}
mon_filter = Filters.MonFilter('costume_filter', settings)
# Test events that should pass
for c in [1, 2]:
event = Events.MonEvent(generate_monster({"costume": c}))
self.assertTrue(mon_filter.check_event(event))
# Test events that should fail
for c in [3, 4]:
event = Events.MonEvent(generate_monster({"costume": c}))
self.assertFalse(mon_filter.check_event(event))
def test_missing_info(self):
settings = {
'is_missing_info': False,
'min_atk': 5,
'min_def': 5,
'max_sta': 14
}
mon_filter = Filters.MonFilter('missing_info_filter', settings)
self.assertTrue(mon_filter.check_event(create_event({
'individual_attack': 15,
'individual_defense': 15,
'individual_stamina': 14,
"cp": 280
})))
self.assertFalse(mon_filter.check_event(create_event({})))
def test_time_left(self):
# Create the filters
settings = {'min_time_left': 1000, 'max_time_left': 8000}
mon_filter = Filters.MonFilter('time_filter', settings)
# Test events that should pass
for s in [2000, 4000, 6000]:
d = (datetime.now() + timedelta(seconds=s))
t = time.mktime(d.timetuple())
event = Events.MonEvent(generate_monster({"disappear_time": t}))
self.assertTrue(mon_filter.check_event(event))
# Test events that should fail
for s in [200, 999, 8001]:
d = (datetime.now() + timedelta(seconds=s))
t = time.mktime(d.timetuple())
event = Events.MonEvent(generate_monster({"disappear_time": t}))
self.assertFalse(mon_filter.check_event(event))
def test_iv(self):
# Create filter that forces settings
settings = {"min_iv": 50, "max_iv": 75}
mon_filter = Filters.MonFilter('iv_filter', settings)
# Generate events that pass based off forced filter
pass1 = create_event({ # test max
"individual_attack": 15,
"individual_defense": 15,
"individual_stamina": 3
})
pass2 = create_event({ # in between
"individual_attack": 15,
"individual_defense": 10,
"individual_stamina": 2
})
pass3 = create_event({ # test min
"individual_attack": 10,
"individual_defense": 8,
"individual_stamina": 5
})
for e in [pass1, pass2, pass3]:
self.assertTrue(mon_filter.check_event(e))
# Generate events that fail based off the forced filter
fail1 = create_event({ # test max
"individual_attack": 12,
"individual_defense": 11,
"individual_stamina": 11
})
fail2 = create_event({ # Extreme end
"individual_attack": 15,
"individual_defense": 15,
"individual_stamina": 15
})
fail3 = create_event({ # test min
"individual_attack": 10,
"individual_defense": 8,
"individual_stamina": 4
})
for e in [fail1, fail2, fail3]:
self.assertFalse(mon_filter.check_event(e))
def test_stamina(self):
# Create filter that forces settings
settings = {"min_sta": 5, "max_sta": 10}
mon_filter = Filters.MonFilter('sta_filter', settings)
# Generate events that pass based off forced filter
pass1 = create_event({"individual_stamina": 5}) # test min
pass2 = create_event({"individual_stamina": 7}) # test middle
pass3 = create_event({"individual_stamina": 10}) # test max
for e in [pass1, pass2, pass3]:
self.assertTrue(mon_filter.check_event(e))
fail1 = create_event({"individual_stamina": 4}) # test close to min
fail2 = create_event({"individual_stamina": 11}) # test close to max
fail3 = create_event({"individual_stamina": 1}) # test extreme
for e in [fail1, fail2, fail3]:
self.assertFalse(mon_filter.check_event(e))
def test_rarity_id(self):
# Create the filters
settings = {"rarity": ["common", "Very Rare"]}
mon_filter = Filters.MonFilter('filter1', settings)
# Generate events that should pass
pass1 = Events.MonEvent(generate_monster({"rarity": 0}))
pass2 = Events.MonEvent(generate_monster({"rarity": 3}))
# Test passing events
for e in [pass1, pass2]:
self.assertTrue(mon_filter.check_event(e))
# Generate events that should fail
fail1 = Events.MonEvent(generate_monster({"rarity": 1}))
fail2 = Events.MonEvent(generate_monster({"rarity": 2}))
fail3 = Events.MonEvent(generate_monster({"rarity": 4}))
# Test failing events
for e in [fail1, fail2, fail3]:
self.assertFalse(mon_filter.check_event(e))
def test_lvl(self):
# Create the filters
settings = {"min_lvl": 5, "max_lvl": 10}
mon_filter = Filters.MonFilter('filter1', settings)
# Generate events that should pass
pass1 = Events.MonEvent(generate_monster({"pokemon_level": 5}))
pass2 = Events.MonEvent(generate_monster({"pokemon_level": 7}))
pass3 = Events.MonEvent(generate_monster({"pokemon_level": 10}))
# Test passing events
for e in [pass1, pass2, pass3]:
self.assertTrue(mon_filter.check_event(e))
# Generate events that should fail
fail1 = Events.MonEvent(generate_monster({"pokemon_id": 4}))
fail2 = Events.MonEvent(generate_monster({"pokemon_id": 11}))
fail3 = Events.MonEvent(generate_monster({"pokemon_id": 100}))
# Test failing events
for e in [fail1, fail2, fail3]:
self.assertFalse(mon_filter.check_event(e))
def test_monsters_exclude(self):
# Create the filters
settings = {"monsters_exclude": [4, "5", "Charizard"]}
mon_filter = Filters.MonFilter('filter1', settings)
# Generate events that should pass
pass1 = Events.MonEvent(generate_monster({"pokemon_id": 1}))
pass2 = Events.MonEvent(generate_monster({"pokemon_id": 2}))
pass3 = Events.MonEvent(generate_monster({"pokemon_id": 3}))
# Test passing events
for e in [pass1, pass2, pass3]:
self.assertTrue(mon_filter.check_event(e))
# Generate events that should fail
fail1 = Events.MonEvent(generate_monster({"pokemon_id": 4}))
fail2 = Events.MonEvent(generate_monster({"pokemon_id": 5}))
fail3 = Events.MonEvent(generate_monster({"pokemon_id": 6}))
# Test failing events
for e in [fail1, fail2, fail3]:
self.assertFalse(mon_filter.check_event(e))
def test_monster_id(self):
# Create the filters
settings = {"monsters": [1, "2", "Venusaur"]}
mon_filter = Filters.MonFilter('filter1', settings)
# Generate events that should pass
pass1 = Events.MonEvent(generate_monster({"pokemon_id": 1}))
pass2 = Events.MonEvent(generate_monster({"pokemon_id": 2}))
pass3 = Events.MonEvent(generate_monster({"pokemon_id": 3}))
# Test passing events
for e in [pass1, pass2, pass3]:
self.assertTrue(mon_filter.check_event(e))
# Generate events that should fail
fail1 = Events.MonEvent(generate_monster({"pokemon_id": 5}))
fail2 = Events.MonEvent(generate_monster({"pokemon_id": 102}))
fail3 = Events.MonEvent(generate_monster({"pokemon_id": 30}))
# Test failing events
for e in [fail1, fail2, fail3]:
self.assertFalse(mon_filter.check_event(e))
def gen_filter(self, settings):
""" Generate a generic filter with given settings. """
return Filters.MonFilter(self._mgr, "testfilter", settings)
def test_gender(self):
settings = {'genders': ["male", "female"]}
mon_filter = Filters.MonFilter('gender_filter', settings)
self.assertTrue(mon_filter.check_event(create_event({'gender': 2})))
self.assertFalse(mon_filter.check_event(create_event({'gender': 3})))