def test_slider_start(self): settings = StdScoreData.Settings() for require_tap_press in [True, False]: for require_aim_press in [True, False]: for miss_aim in [True, False]: cursor_xy = [500, 500] if miss_aim else [0, 0] settings.require_tap_press = require_tap_press settings.require_aim_press = require_aim_press # Set hitwindow ranges to what these tests have been written for settings.neg_hit_miss_range = 450 # ms point of early miss window settings.neg_hit_range = 300 # ms point of early hit window settings.pos_hit_range = 300 # ms point of late hit window settings.pos_hit_miss_range = 450 # ms point of late miss window # Time: 0 ms -> 3000 ms # Scoring: Awaiting press at slider start (100 ms @ (0, 0)) for ms in range(0, 3000): score_data = {} adv = StdScoreData._StdScoreData__process_hold( settings, score_data, self.map_data.values, ms, cursor_xy[0], cursor_xy[1], [0, 0]) offset = ms - self.map_data.iloc[0]['time'] # Regardless of anythingg a tap is required and this got a hold instead self.assertEqual(adv, StdScoreData._StdScoreData__ADV_NOP, f'Offset: {offset} ms') self.assertEqual(len(score_data), 0, f'Offset: {offset} ms')
def test_circle_nomisaim(self): settings = StdScoreData.Settings() # Set hitwindow ranges to what these tests have been written for settings.pos_hit_range = 300 # ms point of late hit window settings.neg_hit_range = 300 # ms point of early hit window settings.pos_hit_miss_range = 450 # ms point of late miss window settings.neg_hit_miss_range = 450 # ms point of early miss window settings.pos_rel_range = 500 # ms point of late release window settings.neg_rel_range = 500 # ms point of early release window settings.pos_rel_miss_range = 1000 # ms point of late release window settings.neg_rel_miss_range = 1000 # ms point of early release window # Time: 0 ms -> 3000 ms # Location: At 1st hitcircle (500, 500) # Scoring: Awaiting press at hitcircle (1000 ms @ (500, 500)) # Behavior: # Scorepoint awaits PRESS -> NOP # -> NOP for ms in range(0, 3000): score_data = {} adv = StdScoreData._StdScoreData__process_release( settings, score_data, self.map_data.iloc[1:].values, ms, 500, 500, [0, 0]) offset = ms - self.map_data.iloc[1]['time'] self.assertEqual(adv, StdScoreData._StdScoreData__ADV_NOP, f'Offset: {offset} ms') self.assertEqual(len(score_data), 0, f'Offset: {offset} ms')
def test_circle_hold_nomisaim__window_miss(self): settings = StdScoreData.Settings() settings.require_tap_press = True settings.require_aim_hold = True # Set hitwindow ranges to what these tests have been written for settings.pos_hit_range = 300 # ms point of late hit window settings.neg_hit_range = 300 # ms point of early hit window settings.pos_hit_miss_range = 450 # ms point of late miss window settings.neg_hit_miss_range = 450 # ms point of early miss window settings.pos_rel_range = 500 # ms point of late release window settings.neg_rel_range = 500 # ms point of early release window settings.pos_rel_miss_range = 1000 # ms point of late release window settings.neg_rel_miss_range = 1000 # ms point of early release window settings.neg_hld_range = 50 # ms range of early hold settings.pos_hld_range = 1000 # ms range of late hold # Time: 0 ms -> 3000 ms # Location: At 1st hitcircle (500, 500) # Scoring: Awaiting press at 1st hitcircle (1000 ms @ (500, 500)) for ms in range(0, 3000): score_data = {} adv = StdScoreData._StdScoreData__process_hold( settings, score_data, self.map_data.iloc[4:].values, ms, 500, 500, [0, 0]) offset = ms - self.map_data.iloc[4]['time'] self.assertEqual(adv, StdScoreData._StdScoreData__ADV_NOP, f'Offset: {offset} ms') self.assertEqual(len(score_data), 0, f'Offset: {offset} ms')
def test_slider_start_press_misaim__noblank(self): settings = StdScoreData.Settings() settings.blank_miss = False # Set hitwindow ranges to what these tests have been written for settings.pos_hit_range = 300 # ms point of late hit window settings.neg_hit_range = 300 # ms point of early hit window settings.pos_hit_miss_range = 450 # ms point of late miss window settings.neg_hit_miss_range = 450 # ms point of early miss window settings.pos_rel_range = 500 # ms point of late release window settings.neg_rel_range = 500 # ms point of early release window settings.pos_rel_miss_range = 1000 # ms point of late release window settings.neg_rel_miss_range = 1000 # ms point of early release window # Time: -1000 ms -> 4000 ms # Location: Blank area (1000, 1000) # Scoring: Awaiting press at slider start (100 ms @ (0, 0)) # Behavior: # Scorepoint awaits PRESS -> NOP # -> NOP for ms in range(-1000, 4000): score_data = {} adv = StdScoreData._StdScoreData__process_press(settings, score_data, self.map_data.values, ms, 1000, 1000, [0, 0]) offset = ms - self.map_data.iloc[0]['time'] self.assertEqual(adv, StdScoreData._StdScoreData__ADV_NOP, f'Offset: {offset} ms') self.assertEqual(len(score_data), 0, f'Offset: {offset} ms')
def test_circle_press_missaim__blank(self): settings = StdScoreData.Settings() settings.blank_miss = True # Set hitwindow ranges to what these tests have been written for settings.pos_hit_range = 300 # ms point of late hit window settings.neg_hit_range = 300 # ms point of early hit window settings.pos_hit_miss_range = 450 # ms point of late miss window settings.neg_hit_miss_range = 450 # ms point of early miss window settings.pos_rel_range = 500 # ms point of late release window settings.neg_rel_range = 500 # ms point of early release window settings.pos_rel_miss_range = 1000 # ms point of late release window settings.neg_rel_miss_range = 1000 # ms point of early release window # Time: -1000 ms -> 4000 ms # Location: Blank area (1000, 1000) # Scoring: Awaiting press at hitcircle (1000 ms @ (500, 500)) for ms in range(-1000, 4000): score_data = {} adv = StdScoreData._StdScoreData__process_press(settings, score_data, self.map_data.iloc[4:].values, ms, 1000, 1000, [0, 0]) offset = ms - self.map_data.iloc[4]['time'] self.assertEqual(adv, StdScoreData._StdScoreData__ADV_NOP, f'Offset: {offset} ms') self.assertEqual(score_data[0][6], StdScoreData.TYPE_EMPTY)
def test_relax_map(self): settings = StdScoreData.Settings() settings.neg_hit_miss_range = 100 # ms point of early miss window settings.neg_hit_range = 100 # ms point of early hit window settings.pos_hit_range = 100 # ms point of late hit window settings.pos_hit_miss_range = 100 # ms point of late miss window settings.require_tap_press = False settings.require_tap_hold = False settings.require_tap_release = False beatmap = BeatmapIO.open_beatmap('unit_tests/maps/osu/test/relax_map.osu') map_data = StdMapData.get_map_data(beatmap) replay = ReplayIO.open_replay('unit_tests/replays/osu/score_test/relax_map_fc.osr') replay_data = StdReplayData.get_replay_data(replay) score_data = StdScoreData.get_score_data(replay_data, map_data, settings) # No misses in this play self.assertTrue(not any(score_data['type'] == StdScoreData.TYPE_MISS)) beatmap = BeatmapIO.open_beatmap('unit_tests/maps/osu/test/relax_map2.osu') map_data = StdMapData.get_map_data(beatmap) replay = ReplayIO.open_replay('unit_tests/replays/osu/score_test/relax_map2_fc.osr') replay_data = StdReplayData.get_replay_data(replay) score_data = StdScoreData.get_score_data(replay_data, map_data, settings) # This play has 1 miss aim miss_count = np.count_nonzero(score_data['type'].values == StdScoreData.TYPE_MISS) self.assertTrue(miss_count == 1)
def test_circle_misaim(self): settings = StdScoreData.Settings() # Set hitwindow ranges to what these tests have been written for settings.pos_hit_range = 300 # ms point of late hit window settings.neg_hit_range = 300 # ms point of early hit window settings.pos_hit_miss_range = 450 # ms point of late miss window settings.neg_hit_miss_range = 450 # ms point of early miss window settings.pos_rel_range = 500 # ms point of late release window settings.neg_rel_range = 500 # ms point of early release window settings.pos_rel_miss_range = 1000 # ms point of late release window settings.neg_rel_miss_range = 1000 # ms point of early release window # Time: 0 ms -> 3000 ms # Location: Blank area (1000, 1000) # Scoring: Awaiting press at 1st hitcircle (1000 ms @ (500, 500)) for ms in range(0, 3000): score_data = {} adv = StdScoreData._StdScoreData__process_free( settings, score_data, self.map_data.iloc[4:].values, ms, 1000, 1000, [0, 0]) offset = ms - self.map_data.iloc[4]['time'] if offset <= settings.pos_hit_miss_range: self.assertEqual(adv, StdScoreData._StdScoreData__ADV_NOP, f'Offset: {offset} ms') self.assertEqual(len(score_data), 0, f'Offset: {offset} ms') else: self.assertEqual(adv, StdScoreData._StdScoreData__ADV_NOTE, f'Offset: {offset} ms') self.assertEqual(score_data[0][6], StdScoreData.TYPE_MISS, f'Offset: {offset} ms')
def test_slider_press_nomissaim__noblank(self): settings = StdScoreData.Settings() settings.blank_miss = False # Set hitwindow ranges to what these tests have been written for settings.pos_hit_range = 300 # ms point of late hit window settings.neg_hit_range = 300 # ms point of early hit window settings.pos_hit_miss_range = 450 # ms point of late miss window settings.neg_hit_miss_range = 450 # ms point of early miss window settings.pos_rel_range = 500 # ms point of late release window settings.neg_rel_range = 500 # ms point of early release window settings.pos_rel_miss_range = 1000 # ms point of late release window settings.neg_rel_miss_range = 1000 # ms point of early release window # Time: -1000 ms -> 4000 ms # Location: At 2st slider (500, 500) # Scoring: Awaiting press at slider (3100 ms @ (0, 0)) for ms in range(-1000, 4000): score_data = {} adv = StdScoreData._StdScoreData__process_press(settings, score_data, self.map_data.iloc[8:].values, ms, 0, 0, [0, 0]) offset = ms - self.map_data.iloc[8]['time'] if offset <= -settings.neg_hit_miss_range: self.assertEqual(adv, StdScoreData._StdScoreData__ADV_NOP, f'Offset: {offset} ms') self.assertEqual(len(score_data), 0, f'Offset: {offset} ms') elif -settings.neg_hit_miss_range < offset <= -settings.neg_hit_range: self.assertEqual(adv, StdScoreData._StdScoreData__ADV_NOTE, f'Offset: {offset} ms') self.assertEqual(score_data[0][6], StdScoreData.TYPE_MISS, f'Offset: {offset} ms') elif -settings.neg_hit_range < offset <= settings.pos_hit_range: self.assertEqual(adv, StdScoreData._StdScoreData__ADV_AIMP, f'Offset: {offset} ms') self.assertEqual(score_data[0][6], StdScoreData.TYPE_HITP, f'Offset: {offset} ms') elif settings.pos_hit_range < offset <= settings.pos_hit_miss_range: self.assertEqual(adv, StdScoreData._StdScoreData__ADV_NOTE, f'Offset: {offset} ms') self.assertEqual(score_data[0][6], StdScoreData.TYPE_MISS, f'Offset: {offset} ms') elif settings.pos_hit_miss_range < offset: self.assertEqual(adv, StdScoreData._StdScoreData__ADV_NOP, f'Offset: {offset} ms') self.assertEqual(len(score_data), 0, f'Offset: {offset} ms') else: self.fail('Testing error!')
def test_nm_map(self): settings = StdScoreData.Settings() settings.neg_hit_miss_range = 100 # ms point of early miss window settings.neg_hit_range = 100 # ms point of early hit window settings.pos_hit_range = 100 # ms point of late hit window settings.pos_hit_miss_range = 100 # ms point of late miss window beatmap = BeatmapIO.open_beatmap('unit_tests/maps/osu/test/score_test_basic_AR8,OD5,CS2.osu') map_data = StdMapData.get_map_data(beatmap) # The map is SS'd in this replay replay = ReplayIO.open_replay('unit_tests/replays/osu/score_test_new/score_test_basic_AR8,OD5,CS2_7,1,0,0,0,0,100p.osr') replay_data = StdReplayData.get_replay_data(replay) score_data = StdScoreData.get_score_data(replay_data, map_data) offsets = score_data['map_t'] - score_data['replay_t'] self.assertTrue(not any(score_data['type'] == StdScoreData.TYPE_MISS)) self.assertTrue(all(abs(offsets) <= 50))
def test_circle_press_missaim__noblank__100window(self): settings = StdScoreData.Settings() # Set hitwindow ranges to what these tests have been written for settings.pos_hit_range = 100 # ms point of late hit window settings.neg_hit_range = 100 # ms point of early hit window settings.pos_hit_miss_range = 100 # ms point of late miss window settings.neg_hit_miss_range = 100 # ms point of early miss window # Time: -1000 ms -> 4000 ms # Location: On hit circle (500, 500) # Scoring: Awaiting press at hitcircle (1000 ms @ (500, 500)) for ms in range(-1000, 4000): score_data = {} adv = StdScoreData._StdScoreData__process_press(settings, score_data, self.map_data.iloc[4:].values, ms, 500, 500, [0, 0]) offset = ms - self.map_data.iloc[4]['time'] if offset <= -settings.neg_hit_miss_range: self.assertEqual(adv, StdScoreData._StdScoreData__ADV_NOP, f'Offset: {offset} ms') self.assertEqual(len(score_data), 0, f'Offset: {offset} ms') elif -settings.neg_hit_miss_range < offset <= -settings.neg_hit_range: self.assertEqual(adv, StdScoreData._StdScoreData__ADV_NOTE, f'Offset: {offset} ms') self.assertEqual(score_data[0][6], StdScoreData.TYPE_MISS, f'Offset: {offset} ms') elif -settings.neg_hit_range < offset <= settings.pos_hit_range: self.assertEqual(adv, StdScoreData._StdScoreData__ADV_NOTE, f'Offset: {offset} ms') self.assertEqual(score_data[0][6], StdScoreData.TYPE_HITP, f'Offset: {offset} ms') self.assertEqual(score_data[0][0] - score_data[0][1], offset, f'Offset: {offset} ms') elif settings.pos_hit_range < offset <= settings.pos_hit_miss_range: self.assertEqual(adv, StdScoreData._StdScoreData__ADV_NOTE, f'Offset: {offset} ms') self.assertEqual(score_data[0][6], StdScoreData.TYPE_MISS, f'Offset: {offset} ms') elif settings.pos_hit_miss_range < offset: self.assertEqual(adv, StdScoreData._StdScoreData__ADV_NOP, f'Offset: {offset} ms') self.assertEqual(len(score_data), 0, f'Offset: {offset} ms') else: self.fail('Testing error!')
def test_slider_release_hold_nomisaim__window_miss(self): settings = StdScoreData.Settings() settings.require_tap_hold = True settings.require_aim_hold = True settings.neg_hld_range = 50 # ms range of early hold settings.pos_hld_range = 1000 # ms range of late hold # Time: 0 ms -> 3000 ms # Location: At slider release (300, 0) # Scoring: Awaiting release at slider end (750 ms @ (300, 0)) for ms in range(0, 3000): score_data = {} adv = StdScoreData._StdScoreData__process_hold( settings, score_data, self.map_data.iloc[3:].values, ms, 300, 0, [0, 0]) offset = ms - self.map_data.iloc[3]['time'] self.assertEqual(adv, StdScoreData._StdScoreData__ADV_NOP, f'Offset: {offset} ms') self.assertEqual(len(score_data), 0, f'Offset: {offset} ms')
def test_slider_hold(self): settings = StdScoreData.Settings() for require_tap_hold in [True, False]: for require_aim_hold in [True, False]: for recoverable_missaim in [True, False]: for slider_miss in [True, False]: for miss_aim in [True, False]: cursor_xy = [1000, 1000] if miss_aim else [0, 0] settings.require_tap_hold = require_tap_hold settings.require_aim_hold = require_aim_hold settings.recoverable_missaim = recoverable_missaim settings.miss_slider = slider_miss # Set hitwindow ranges to what these tests have been written for self.neg_hld_range = 50 self.pos_hld_range = 1000 # Time: 0 ms -> 3000 ms # Scoring: Awaiting hold at slider aimpoint (350 ms @ (100, 0)) for ms in range(0, 3000): score_data = {} adv = StdScoreData._StdScoreData__process_hold( settings, score_data, self.map_data.iloc[1:].values, ms, cursor_xy[0], cursor_xy[1], [0, 0]) offset = ms - self.map_data.iloc[1]['time'] expected_miss_adv = StdScoreData._StdScoreData__ADV_NOTE if slider_miss else StdScoreData._StdScoreData__ADV_AIMP def proc_required_tap(): if offset <= -settings.neg_hld_range: self.assertEqual( adv, StdScoreData. _StdScoreData__ADV_NOP, f'Offset: {offset} ms') self.assertEqual( len(score_data), 0, f'Offset: {offset} ms') if -settings.neg_hld_range < offset <= settings.pos_hld_range: self.assertEqual( adv, StdScoreData. _StdScoreData__ADV_AIMP, f'Offset: {offset} ms') self.assertEqual( score_data[0][6], StdScoreData.TYPE_AIMH, f'Offset: {offset} ms') if settings.pos_hld_range < offset: self.assertEqual( adv, StdScoreData. _StdScoreData__ADV_NOP, f'Offset: {offset} ms') self.assertEqual( len(score_data), 0, f'Offset: {offset} ms') def proc_required_aim(): if settings.recoverable_missaim: if settings.pos_hld_range < offset: self.assertEqual( adv, expected_miss_adv, f'Offset: {offset} ms') self.assertEqual( score_data[0][6], StdScoreData.TYPE_MISS, f'Offset: {offset} ms') else: self.assertEqual( adv, StdScoreData. _StdScoreData__ADV_NOP, f'Offset: {offset} ms') self.assertEqual( len(score_data), 0, f'Offset: {offset} ms') def proc_required_non(): if offset < 0: self.assertEqual( adv, StdScoreData. _StdScoreData__ADV_NOP, f'Offset: {offset} ms') self.assertEqual( len(score_data), 0, f'Offset: {offset} ms') else: self.assertEqual( adv, StdScoreData. _StdScoreData__ADV_AIMP, f'Offset: {offset} ms') self.assertEqual( score_data[0][6], StdScoreData.TYPE_AIMH, f'Offset: {offset} ms') if not require_aim_hold and not require_tap_hold: # No need to tap or aim; Automatic freebie proc_required_non() continue if not require_aim_hold and require_tap_hold: proc_required_tap() continue if require_aim_hold and not require_tap_hold: if miss_aim: proc_required_aim() else: proc_required_non() continue if require_aim_hold and require_tap_hold: if miss_aim: proc_required_aim() else: proc_required_tap() continue
def test_slider_hold(self): settings = StdScoreData.Settings() for require_tap_release in [True, False]: for require_aim_release in [True, False]: for require_tap_hold in [True, False]: for recoverable_release in [True, False]: for slider_miss in [True, False]: for miss_aim in [True, False]: cursor_xy = [1000, 1000 ] if miss_aim else [0, 0] settings.require_tap_hold = require_tap_hold settings.require_tap_release = require_tap_release settings.require_aim_release = require_aim_release settings.recoverable_release = recoverable_release settings.miss_slider = slider_miss # Set hitwindow ranges to what these tests have been written for settings.neg_rel_miss_range = 450 # ms point of early miss window settings.neg_rel_range = 300 # ms point of early release window settings.pos_rel_range = 300 # ms point of late release window settings.pos_rel_miss_range = 450 # ms point of late miss window # Set hitwindow ranges to what these tests have been written for self.neg_hld_range = 0 self.pos_hld_range = 1000 # Time: 0 ms -> 3000 ms # Scoring: Awaiting hold at slider aimpoint (350 ms @ (100, 0)) for ms in range(0, 3000): score_data = {} adv = StdScoreData._StdScoreData__process_release( settings, score_data, self.map_data.iloc[1:].values, ms, cursor_xy[0], cursor_xy[1], [0, 0]) offset = ms - self.map_data.iloc[1]['time'] expected_miss_adv = StdScoreData._StdScoreData__ADV_NOTE if slider_miss else StdScoreData._StdScoreData__ADV_AIMP if require_tap_hold: if recoverable_release: self.assertEqual( adv, StdScoreData. _StdScoreData__ADV_NOP, f'Offset: {offset} ms') self.assertEqual( len(score_data), 0, f'Offset: {offset} ms') else: self.assertEqual( adv, expected_miss_adv, f'Offset: {offset} ms') self.assertEqual( score_data[0][6], StdScoreData.TYPE_MISS, f'Offset: {offset} ms') else: # No need to tap self.assertEqual( adv, StdScoreData. _StdScoreData__ADV_NOP, f'Offset: {offset} ms') self.assertEqual( len(score_data), 0, f'Offset: {offset} ms')
def test_slider_release(self): settings = StdScoreData.Settings() for require_tap_release in [True, False]: for require_aim_release in [True, False]: for require_tap_hold in [True, False]: for recoverable_release in [True, False]: for slider_miss in [True, False]: for miss_aim in [True, False]: cursor_xy = [1000, 1000 ] if miss_aim else [300, 0] settings.require_tap_hold = require_tap_hold settings.require_tap_release = require_tap_release settings.require_aim_release = require_aim_release settings.recoverable_release = recoverable_release settings.miss_slider = slider_miss # Set hitwindow ranges to what these tests have been written for settings.neg_rel_miss_range = 450 # ms point of early miss window settings.neg_rel_range = 300 # ms point of early release window settings.pos_rel_range = 300 # ms point of late release window settings.pos_rel_miss_range = 450 # ms point of late miss window # Set hitwindow ranges to what these tests have been written for self.neg_hld_range = 0 self.pos_hld_range = 1000 # Time: 0 ms -> 3000 ms # Scoring: Awaiting release at slider end (750 ms @ (300, 0)) for ms in range(0, 3000): score_data = {} adv = StdScoreData._StdScoreData__process_release( settings, score_data, self.map_data.iloc[3:].values, ms, cursor_xy[0], cursor_xy[1], [0, 0]) offset = ms - self.map_data.iloc[3]['time'] def proc_required_tap(): if offset <= -settings.neg_rel_miss_range: self.assertEqual( adv, StdScoreData. _StdScoreData__ADV_NOP, f'Offset: {offset} ms') self.assertEqual( len(score_data), 0, f'Offset: {offset} ms') if -settings.neg_rel_miss_range < offset <= -settings.neg_rel_range: self.assertEqual( adv, StdScoreData. _StdScoreData__ADV_NOTE, f'Offset: {offset} ms') self.assertEqual( score_data[0][6], StdScoreData.TYPE_MISS, f'Offset: {offset} ms') if -settings.neg_rel_range < offset <= settings.pos_rel_range: self.assertEqual( adv, StdScoreData. _StdScoreData__ADV_NOTE, f'Offset: {offset} ms') self.assertEqual( score_data[0][6], StdScoreData.TYPE_HITR, f'Offset: {offset} ms') if settings.pos_rel_range < offset <= settings.pos_rel_miss_range: self.assertEqual( adv, StdScoreData. _StdScoreData__ADV_NOTE, f'Offset: {offset} ms') self.assertEqual( score_data[0][6], StdScoreData.TYPE_MISS, f'Offset: {offset} ms') if settings.pos_rel_miss_range < offset: self.assertEqual( adv, StdScoreData. _StdScoreData__ADV_NOP, f'Offset: {offset} ms') self.assertEqual( len(score_data), 0, f'Offset: {offset} ms') def proc_required_aim(): self.assertEqual( adv, StdScoreData. _StdScoreData__ADV_NOTE, f'Offset: {offset} ms') self.assertEqual( score_data[0][6], StdScoreData.TYPE_MISS, f'Offset: {offset} ms') def proc_required_non(): if offset < 0: self.assertEqual( adv, StdScoreData. _StdScoreData__ADV_NOP, f'Offset: {offset} ms') self.assertEqual( len(score_data), 0, f'Offset: {offset} ms') else: self.assertEqual( adv, StdScoreData. _StdScoreData__ADV_NOTE, f'Offset: {offset} ms') self.assertEqual( score_data[0][6], StdScoreData.TYPE_HITR, f'Offset: {offset} ms') if not require_aim_release and not require_tap_release: # No need to tap or aim; Automatic freebie proc_required_non() continue if not require_aim_release and require_tap_release: proc_required_tap() continue if require_aim_release and not require_tap_release: if miss_aim: proc_required_aim() else: proc_required_non() continue if require_aim_release and require_tap_release: if miss_aim: proc_required_aim() else: proc_required_tap() continue
def test_slider_start(self): settings = StdScoreData.Settings() for require_tap_press in [True, False]: for require_aim_press in [True, False]: for miss_aim in [True, False]: cursor_xy = [500, 500] if miss_aim else [0, 0] settings.require_tap_press = require_tap_press settings.require_aim_press = require_aim_press # Set hitwindow ranges to what these tests have been written for settings.neg_hit_miss_range = 450 # ms point of early miss window settings.neg_hit_range = 300 # ms point of early hit window settings.pos_hit_range = 300 # ms point of late hit window settings.pos_hit_miss_range = 450 # ms point of late miss window # Time: 0 ms -> 3000 ms # Scoring: Awaiting press at slider start (100 ms @ (0, 0)) for ms in range(0, 3000): score_data = {} adv = StdScoreData._StdScoreData__process_free( settings, score_data, self.map_data.values, ms, cursor_xy[0], cursor_xy[1], [0, 0]) offset = ms - self.map_data.iloc[0]['time'] def proc_required(): # Regardless of whether aim is required, a tap is required and this got a free instead if offset <= settings.pos_hit_miss_range: self.assertEqual( adv, StdScoreData._StdScoreData__ADV_NOP, f'Offset: {offset} ms') self.assertEqual(len(score_data), 0, f'Offset: {offset} ms') else: self.assertEqual( adv, StdScoreData._StdScoreData__ADV_NOTE, f'Offset: {offset} ms') self.assertEqual(score_data[0][6], StdScoreData.TYPE_MISS, f'Offset: {offset} ms') def proc_required_non(): if offset < 0: self.assertEqual( adv, StdScoreData._StdScoreData__ADV_NOP, f'Offset: {offset} ms') self.assertEqual(len(score_data), 0, f'Offset: {offset} ms') else: self.assertEqual( adv, StdScoreData._StdScoreData__ADV_NOTE, f'Offset: {offset} ms') self.assertEqual(score_data[0][6], StdScoreData.TYPE_HITP, f'Offset: {offset} ms') if not require_aim_press and not require_tap_press: # No need to tap or aim; Automatic freebie proc_required_non() continue if not require_aim_press and require_tap_press: proc_required() continue if require_aim_press and not require_tap_press: if miss_aim: proc_required() else: proc_required_non() continue if require_aim_press and require_tap_press: if miss_aim: proc_required() else: proc_required() continue