142 lines
5.1 KiB
Python
142 lines
5.1 KiB
Python
import math, os, random, sys, unittest
|
|
|
|
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "home", "minqlx-plugins"))
|
|
from lgbot import (PRESETS, KEYS, resolve, Strafer, wanted_range, steer, fix_z, pick_target, to_int)
|
|
|
|
|
|
def preset(n, **kw):
|
|
s = dict(PRESETS[n]); s.update(kw); return s
|
|
|
|
|
|
class Resolve(unittest.TestCase):
|
|
def test_preset_only(self):
|
|
self.assertEqual(resolve(3, {}), PRESETS[3])
|
|
|
|
def test_minus_one_and_none_keep_preset(self):
|
|
self.assertEqual(resolve(2, {k: -1 for k in KEYS}), PRESETS[2])
|
|
self.assertEqual(resolve(2, {"fake": None}), PRESETS[2])
|
|
|
|
def test_override_and_clamp(self):
|
|
s = resolve(1, {"fake": 50, "range": 5000, "speed": 10})
|
|
self.assertEqual((s["fake"], s["range"], s["speed"]), (50, 750, 50))
|
|
|
|
def test_bad_move_level(self):
|
|
self.assertEqual(resolve(9, {}), PRESETS[5])
|
|
self.assertEqual(resolve(0, {}), PRESETS[1])
|
|
self.assertEqual(resolve(None, {}), PRESETS[3])
|
|
|
|
def test_max_below_min(self):
|
|
s = resolve(3, {"strafe_min": 800, "strafe_max": 200})
|
|
self.assertEqual((s["strafe_min"], s["strafe_max"]), (800, 800))
|
|
|
|
|
|
class StraferTest(unittest.TestCase):
|
|
def changes(self, s, n=2000, seed=1):
|
|
st, now, out = Strafer(random.Random(seed)), 0, []
|
|
d = st.step(now, s)
|
|
while len(out) < n:
|
|
now += 5
|
|
nd = st.step(now, s)
|
|
if nd != d:
|
|
out.append((now, nd)); d = nd
|
|
return out
|
|
|
|
def test_holds_within_range_without_fakes(self):
|
|
s = preset(3, fake=0, strafe_min=250, strafe_max=600)
|
|
ch = self.changes(s, 300)
|
|
gaps = [b[0] - a[0] for a, b in zip(ch, ch[1:])]
|
|
self.assertTrue(all(245 <= g <= 610 for g in gaps), (min(gaps), max(gaps)))
|
|
|
|
def test_fake_taps_are_short_and_return(self):
|
|
s = preset(5, fake=100, strafe_min=300, strafe_max=300)
|
|
ch = self.changes(s, 200)
|
|
gaps = [b[0] - a[0] for a, b in zip(ch, ch[1:])]
|
|
# always faking: alternating short tap (60-120) and full hold (300), direction never really changes
|
|
short = [g for g in gaps if g <= 125]
|
|
self.assertTrue(len(short) >= 90)
|
|
self.assertTrue(all(60 <= g <= 125 for g in short))
|
|
|
|
def test_fake_fraction_matches_setting(self):
|
|
s = preset(3, fake=30, strafe_min=300, strafe_max=300)
|
|
st, now, fakes, decisions = Strafer(random.Random(7)), 0, 0, 0
|
|
st.step(0, s)
|
|
while decisions < 2000:
|
|
now += 5
|
|
was = st.faking
|
|
before = st.until
|
|
st.step(now, s)
|
|
if st.until != before and not was:
|
|
decisions += 1; fakes += st.faking
|
|
self.assertAlmostEqual(fakes / decisions, 0.30, delta=0.04)
|
|
|
|
|
|
class Range(unittest.TestCase):
|
|
def test_plain(self):
|
|
self.assertEqual(wanted_range(preset(1), 100, 100), 450)
|
|
|
|
def test_back_off_when_low(self):
|
|
self.assertEqual(wanted_range(preset(5), 50, 20), 700)
|
|
|
|
def test_push_when_ahead(self):
|
|
self.assertEqual(wanted_range(preset(5), 150, 100), 250)
|
|
|
|
def test_even_fight(self):
|
|
self.assertEqual(wanted_range(preset(5), 100, 90), 350)
|
|
|
|
def test_range_play_off(self):
|
|
self.assertEqual(wanted_range(preset(5, range_play=0), 50, 20), 350)
|
|
|
|
|
|
class Steer(unittest.TestCase):
|
|
def test_perpendicular_at_wanted_range(self):
|
|
vx, vy = steer((0, 0), (400, 0), 1, preset(3), 400)
|
|
self.assertAlmostEqual(vx, 0, places=3)
|
|
self.assertAlmostEqual(abs(vy), 320, places=3)
|
|
|
|
def test_direction_flips_side(self):
|
|
a = steer((0, 0), (400, 0), 1, preset(3), 400)
|
|
b = steer((0, 0), (400, 0), -1, preset(3), 400)
|
|
self.assertAlmostEqual(a[1], -b[1], places=3)
|
|
|
|
def test_speed_cap(self):
|
|
for d in (50, 400, 1200):
|
|
vx, vy = steer((0, 0), (d, 0), 1, preset(1), 450)
|
|
self.assertLessEqual(math.hypot(vx, vy), 320 * 0.8 + 1e-6)
|
|
|
|
def test_closes_in_when_far(self):
|
|
vx, _ = steer((0, 0), (1000, 0), 1, preset(3), 400)
|
|
self.assertGreater(vx, 100)
|
|
|
|
def test_backs_off_when_close(self):
|
|
vx, _ = steer((0, 0), (100, 0), 1, preset(3), 400)
|
|
self.assertLess(vx, -100)
|
|
|
|
def test_same_spot(self):
|
|
vx, vy = steer((5, 5), (5, 5), 1, preset(3), 400)
|
|
self.assertLessEqual(math.hypot(vx, vy), 320 + 1e-6)
|
|
|
|
|
|
class Misc(unittest.TestCase):
|
|
def test_fix_z(self):
|
|
self.assertEqual(fix_z(275), 0)
|
|
self.assertEqual(fix_z(-100), -100)
|
|
self.assertEqual(fix_z(40), 40) # slopes/stairs
|
|
self.assertEqual(fix_z(800), 800) # jump pads
|
|
|
|
def test_to_int(self):
|
|
self.assertEqual(to_int("5"), 5)
|
|
self.assertEqual(to_int(" -1 "), -1)
|
|
self.assertEqual(to_int("2.7"), 2)
|
|
self.assertIsNone(to_int("abc"))
|
|
self.assertIsNone(to_int(None))
|
|
|
|
def test_pick_target(self):
|
|
c = [((300, 0), "near"), ((900, 0), "far")]
|
|
self.assertEqual(pick_target((0, 0), c), "near")
|
|
self.assertIsNone(pick_target((0, 0), [((2000, 0), "x")]))
|
|
self.assertIsNone(pick_target((0, 0), []))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|