def test_get_best_action_works_right(self):
board = PodBoard([Vec2(5000, 5000), Vec2(1000, 1000)])
# Pod is directly below the check, but the check is behind and to its right
pod = PodState(Vec2(5000, 0))
pod.angle = math.pi * 1.25
self.__do_get_best_action_assert(board, pod, 0, -Constants.max_turn())
def test_get_best_action_works_behind_right(self):
board = PodBoard([Vec2(5000, 5000), Vec2(1000, 1000)])
# Pod is directly right of check, but facing away (slightly to the right)
pod = PodState(Vec2(7000, 5000))
pod.angle = -0.000001
self.__do_get_best_action_assert(board, pod, 0, -Constants.max_turn())
def test_get_best_action_works_straight(self):
board = PodBoard([Vec2(5000, 5000), Vec2(1000, 1000)])
# Pod is directly below the check, but looking straight at it
pod = PodState(Vec2(5000, 0))
pod.angle = math.pi / 2
self.__do_get_best_action_assert(board, pod, Constants.max_thrust(), 0)
def step(self,
pod: PodState,
play: PlayOutput,
output: PodState = None) -> PodState:
"""
For the given pod, implement the given play.
On each turn the pods movements are computed this way:
Rotation: the pod rotates to face the target point, with a maximum of 18 degrees (except for the 1rst round).
Acceleration: the pod's facing vector is multiplied by the given thrust value. The result is added to the current speed vector.
Movement: The speed vector is added to the position of the pod. If a collision would occur at this point, the pods rebound off each other.
Friction: the current speed vector of each pod is multiplied by 0.85
The speed's values are truncated and the position's values are rounded to the nearest integer.
Collisions are elastic. The minimum impulse of a collision is 120.
A boost is in fact an acceleration of 650.
A shield multiplies the Pod mass by 10.
The provided angle is absolute. 0° means facing EAST while 90° means facing SOUTH.
:param pod: Initial state
:param play: Action to play
:param output: Output state to update (may be the same as input pod). If not given, a new one will be created.
:return: The new pod state (same object as output if given)
"""
if output is None:
output = PodState()
# 1. Rotation
requested_angle = (play.target - pod.pos).angle()
angle = legal_angle(requested_angle, pod.angle)
output.angle = angle
# 2. Acceleration
dir = UNIT.rotate(angle)
thrust = int(within(play.thrust, 0, Constants.max_thrust()))
output.vel = pod.vel + (dir * thrust)
# 3. Movement
output.pos = pod.pos + output.vel
# 4. Friction
output.vel = output.vel * Constants.friction()
# 5. Rounding
output.pos = output.pos.round()
output.vel = output.vel.truncate()
# Update progress
output.turns = pod.turns + 1
output.nextCheckId = pod.nextCheckId
output.laps = pod.laps
check = self.checkpoints[pod.nextCheckId]
if (check - output.pos).square_length() < Constants.check_radius_sq():
output.nextCheckId += 1
if output.nextCheckId >= len(self.checkpoints):
output.nextCheckId = 0
output.laps += 1
return output
def test_PodState_deserializes_equal_to_serialized(self):
pod = PodState()
pod.angle = 1.23
pod.pos = Vec2(34, 56)
pod.laps = 69
pod.vel = Vec2(88, 77)
pod.nextCheckId = 37
ser = pod.serialize()
copy = PodState()
copy.deserialize(ser)
self.assertEqual(pod.angle, copy.angle)
self.assertEqual(pod.pos, copy.pos)
self.assertEqual(pod.laps, copy.laps)
self.assertEqual(pod.vel, copy.vel)
self.assertEqual(pod.nextCheckId, copy.nextCheckId)
