87 lines
4.0 KiB
Python
87 lines
4.0 KiB
Python
"""Original-byte guards and bounded Grappler scalar references; no gameplay run."""
|
|
from pathlib import Path
|
|
import sys
|
|
import unittest
|
|
|
|
ROOT=Path(__file__).resolve().parents[1]
|
|
sys.path.insert(0,str(ROOT/'tools/binary'))
|
|
from grappler import (attach_scalars, collect, f32, fast_reel, held_reel,
|
|
jump_detaches, material_blocks_aim, swing_scalars)
|
|
|
|
|
|
class GrapplerSourceTests(unittest.TestCase):
|
|
def test_original_identity_dispatchers_and_constants(self):
|
|
report=collect(ROOT.parent/'Original')
|
|
self.assertEqual(len(report['bodies']),12)
|
|
self.assertEqual(len(report['constants']),16)
|
|
self.assertEqual(report['raw_mode'],7)
|
|
self.assertEqual(report['aim_local_point'],[0,2400,2400])
|
|
self.assertTrue(all(int(b['va'],16)-int(b['file_offset'],16)==0x400000
|
|
for b in report['bodies']))
|
|
|
|
def test_material_ranges_are_inclusive_and_have_real_holes(self):
|
|
for value in [60,69,80,89,210,219,-1,170]:
|
|
self.assertTrue(material_blocks_aim(value),value)
|
|
for value in [59,70,79,90,209,220,-2,0,111,169,171]:
|
|
self.assertFalse(material_blocks_aim(value),value)
|
|
|
|
def test_material_absence_is_not_equivalent_to_definition_absence(self):
|
|
self.assertTrue(material_blocks_aim(0,material_present=False))
|
|
self.assertFalse(material_blocks_aim(60,definition_present=False))
|
|
self.assertFalse(material_blocks_aim(60,polygon=False,material_present=False))
|
|
|
|
def test_attach_sets_vertical100_and_first_scale_from_distance_minus100(self):
|
|
result=attach_scalars((0,0,0),(0,300,400),(10,-200,20))
|
|
self.assertEqual(result.length,400.)
|
|
self.assertEqual(result.initial_length,400.)
|
|
self.assertEqual(result.scale_z,f32(400*f32(1/600)))
|
|
self.assertEqual(result.reel_target,100.)
|
|
self.assertEqual(result.velocity,(10,100,20))
|
|
|
|
def test_reattach_retains_first_scale_even_when_length_changes(self):
|
|
result=attach_scalars((0,0,0),(0,600,800),initial_length=400.)
|
|
self.assertEqual(result.length,900.)
|
|
self.assertEqual(result.initial_length,400.)
|
|
self.assertIsNone(result.scale_z)
|
|
|
|
def test_held_reel_can_undershoot250_and_stays_afterward(self):
|
|
length=held_reel(251.,.1)
|
|
self.assertEqual(length,226.)
|
|
self.assertEqual(held_reel(length,.1),226.)
|
|
self.assertEqual(held_reel(250.,.1),250.)
|
|
|
|
def test_fast_reel_can_undershoot_target(self):
|
|
self.assertEqual(fast_reel(251.,250.,.1),156.)
|
|
self.assertEqual(fast_reel(250.,250.,.1),250.)
|
|
|
|
def test_swing_acceleration_precedes_discrete_damping(self):
|
|
x,z,t=swing_scalars(10.,20.,0.,.1,100.,-200.,400.)
|
|
self.assertAlmostEqual(x,8.3,places=5)
|
|
self.assertAlmostEqual(z,23.4,places=5)
|
|
self.assertEqual(t,f32(.1))
|
|
|
|
def test_swing_350_boundary_and_clamp(self):
|
|
short=swing_scalars(100.,-100.,.2,0.,0.,0.,349.)
|
|
long=swing_scalars(100.,-100.,.2,0.,0.,0.,350.)
|
|
self.assertEqual(short[:2],(f32(50*f32(.95)),f32(-50*f32(.95))))
|
|
self.assertEqual(long[:2],(f32(50*f32(.98)),f32(-50*f32(.98))))
|
|
|
|
def test_long_tick_damps_only_once_and_retains_elapsed_remainder(self):
|
|
x,z,t=swing_scalars(50.,50.,0.,.6,0.,0.,400.)
|
|
self.assertEqual(x,f32(50*f32(.98)))
|
|
self.assertEqual(z,x)
|
|
self.assertAlmostEqual(t,.4,places=6)
|
|
|
|
def test_jump_release_requires_no_primary_fire(self):
|
|
self.assertTrue(jump_detaches(jump_held=True,fire_held=False,attached=True))
|
|
for values in [(True,True,True),(False,False,True),(True,False,False)]:
|
|
self.assertFalse(jump_detaches(jump_held=values[0],fire_held=values[1],attached=values[2]))
|
|
|
|
def test_nonfinite_and_negative_time_rejected_by_projection_boundary(self):
|
|
for function,args in [(held_reel,(300.,-.1)),(fast_reel,(300.,250.,float('nan')))]:
|
|
with self.assertRaises(ValueError):function(*args)
|
|
with self.assertRaises(ValueError):attach_scalars((0,0),(0,0,0))
|
|
|
|
|
|
if __name__=='__main__':unittest.main()
|