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(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_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_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_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_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_adv(self):
map_time = 0
# Time: Before start
# Hitobject: Slider
# Advancement: No operation
adv = StdScoreData._StdScoreData__ADV_NOP
new_map_time = StdScoreData._StdScoreData__adv(self.map_data, map_time, adv)
self.assertEqual(new_map_time, 0)
# Time: Before start
# Hitobject: Slider
# Advancement: Aimpoint
adv = StdScoreData._StdScoreData__ADV_AIMP
new_map_time = StdScoreData._StdScoreData__adv(self.map_data, map_time, adv)
self.assertEqual(new_map_time, 100)
# Time: Before start
# Hitobject: Slider
# Advancement: Note
adv = StdScoreData._StdScoreData__ADV_NOTE
new_map_time = StdScoreData._StdScoreData__adv(self.map_data, map_time, adv)
self.assertEqual(new_map_time, 100)
map_time = 100
# Time: At first aimpoint
# Hitobject: Slider
# Advancement: No operation
adv = StdScoreData._StdScoreData__ADV_NOP
new_map_time = StdScoreData._StdScoreData__adv(self.map_data, map_time, adv)
self.assertEqual(new_map_time, 100)
# Time: At first aimpoint
# Hitobject: Slider
# Advancement: Aimpoint
adv = StdScoreData._StdScoreData__ADV_AIMP
new_map_time = StdScoreData._StdScoreData__adv(self.map_data, map_time, adv)
self.assertEqual(new_map_time, 350)
# Time: At first aimpoint
# Hitobject: Slider
# Advancement: Note
adv = StdScoreData._StdScoreData__ADV_NOTE
new_map_time = StdScoreData._StdScoreData__adv(self.map_data, map_time, adv)
self.assertEqual(new_map_time, 1000)
map_time = 350
# Time: At second aimpoint
# Hitobject: Slider
# Advancement: No operation
adv = StdScoreData._StdScoreData__ADV_NOP
new_map_time = StdScoreData._StdScoreData__adv(self.map_data, map_time, adv)
self.assertEqual(new_map_time, 350)
# Time: At second aimpoint
# Hitobject: Slider
# Advancement: Aimpoint
adv = StdScoreData._StdScoreData__ADV_AIMP
new_map_time = StdScoreData._StdScoreData__adv(self.map_data, map_time, adv)
self.assertEqual(new_map_time, 600)
# Time: At second aimpoint
# Hitobject: Slider
# Advancement: Note
adv = StdScoreData._StdScoreData__ADV_NOTE
new_map_time = StdScoreData._StdScoreData__adv(self.map_data, map_time, adv)
self.assertEqual(new_map_time, 1000)
map_time = 750
# Time: At slider release
# Hitobject: Slider
# Advancement: No operation
adv = StdScoreData._StdScoreData__ADV_NOP
new_map_time = StdScoreData._StdScoreData__adv(self.map_data, map_time, adv)
self.assertEqual(new_map_time, 750)
# Time: At slider release
# Hitobject: Slider
# Advancement: Aimpoint
adv = StdScoreData._StdScoreData__ADV_AIMP
new_map_time = StdScoreData._StdScoreData__adv(self.map_data, map_time, adv)
self.assertEqual(new_map_time, 1000)
# Time: At slider release
# Hitobject: Slider
# Advancement: Note
adv = StdScoreData._StdScoreData__ADV_NOTE
new_map_time = StdScoreData._StdScoreData__adv(self.map_data, map_time, adv)
self.assertEqual(new_map_time, 1000)
map_time = 1000
# Time: At 2nd hitobject
# Hitobject: Circle
# Advancement: No operation
adv = StdScoreData._StdScoreData__ADV_NOP
new_map_time = StdScoreData._StdScoreData__adv(self.map_data, map_time, adv)
self.assertEqual(new_map_time, 1000)
# Time: At 2nd hitobject
# Hitobject: Circle
# Advancement: Aimpoint
adv = StdScoreData._StdScoreData__ADV_AIMP
new_map_time = StdScoreData._StdScoreData__adv(self.map_data, map_time, adv)
self.assertEqual(new_map_time, 1001)
# Time: At 2nd hitobject
# Hitobject: Circle
# Advancement: Note
adv = StdScoreData._StdScoreData__ADV_NOTE
new_map_time = StdScoreData._StdScoreData__adv(self.map_data, map_time, adv)
self.assertEqual(new_map_time, 2000)
map_time = 2000
# Time: At last hitobject
# Hitobject: Circle
# Advancement: No operation
adv = StdScoreData._StdScoreData__ADV_NOP
new_map_time = StdScoreData._StdScoreData__adv(self.map_data, map_time, adv)
self.assertEqual(new_map_time, 2000)
# Time: At last hitobject
# Hitobject: Circle
# Advancement: Aimpoint
adv = StdScoreData._StdScoreData__ADV_AIMP
new_map_time = StdScoreData._StdScoreData__adv(self.map_data, map_time, adv)
self.assertEqual(new_map_time, 2001)
# Time: At last hitobject
# Hitobject: Circle
# Advancement: Note
adv = StdScoreData._StdScoreData__ADV_NOTE
new_map_time = StdScoreData._StdScoreData__adv(self.map_data, map_time, adv)
self.assertEqual(new_map_time, 2002)
map_time = 2001
# Time: At last scorepoint
# Hitobject: Circle
# Advancement: No operation
adv = StdScoreData._StdScoreData__ADV_NOP
new_map_time = StdScoreData._StdScoreData__adv(self.map_data, map_time, adv)
self.assertEqual(new_map_time, 2001)
# Time: At last hitobject
# Hitobject: Circle
# Advancement: Aimpoint
adv = StdScoreData._StdScoreData__ADV_AIMP
new_map_time = StdScoreData._StdScoreData__adv(self.map_data, map_time, adv)
self.assertEqual(new_map_time, 2002)
# Time: At last hitobject
# Hitobject: Circle
# Advancement: Note
adv = StdScoreData._StdScoreData__ADV_NOTE
new_map_time = StdScoreData._StdScoreData__adv(self.map_data, map_time, adv)
self.assertEqual(new_map_time, 2002)
map_time = 3000
# Time: After last hitobject
# Hitobject: Circle
# Advancement: No operation
adv = StdScoreData._StdScoreData__ADV_NOP
new_map_time = StdScoreData._StdScoreData__adv(self.map_data, map_time, adv)
self.assertEqual(new_map_time, 3000)
# Time: After last hitobject
# Hitobject: Circle
# Advancement: Aimpoint
adv = StdScoreData._StdScoreData__ADV_AIMP
new_map_time = StdScoreData._StdScoreData__adv(self.map_data, map_time, adv)
self.assertEqual(new_map_time, 2002)
# Time: After last hitobject
# Hitobject: Circle
# Advancement: Note
adv = StdScoreData._StdScoreData__ADV_NOTE
new_map_time = StdScoreData._StdScoreData__adv(self.map_data, map_time, adv)
self.assertEqual(new_map_time, 2002)
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
