Show how to use rlbottraining (#21)

Author: DomNomNom

requirements.txt

@@ -1,6 +1,7 @@
 # Include everything the framework requires
 # You will automatically get updates for all versions starting with "1.".
 rlbot==1.*
+rlbottraining
 
 # This will cause pip to auto-upgrade and stop scaring people with warning messages
 pip

training/drive_to_ball_grader.py

@@ -0,0 +1,48 @@
+from dataclasses import dataclass, field
+from math import sqrt
+from typing import Optional
+
+from rlbot.training.training import Grade, Pass, Fail
+
+from rlbottraining.grading.training_tick_packet import TrainingTickPacket
+from rlbottraining.common_graders.timeout import FailOnTimeout
+from rlbottraining.common_graders.compound_grader import CompoundGrader
+from rlbottraining.grading.grader import Grader
+
+
+"""
+This file shows how to create Graders which specify when the Exercises finish
+and whether the bots passed the exercise.
+"""
+
+
+class DriveToBallGrader(CompoundGrader):
+    """
+    Checks that the car gets to the ball in a reasonable amount of time.
+    """
+    def __init__(self, timeout_seconds=4.0, min_dist_to_pass=200):
+        super().__init__([
+            PassOnNearBall(min_dist_to_pass=min_dist_to_pass),
+            FailOnTimeout(timeout_seconds),
+        ])
+
+@dataclass
+class PassOnNearBall(Grader):
+    """
+    Returns a Pass grade once the car is sufficiently close to the ball.
+    """
+
+    min_dist_to_pass: float = 200
+    car_index: int = 0
+
+    def on_tick(self, tick: TrainingTickPacket) -> Optional[Grade]:
+        car = tick.game_tick_packet.game_cars[self.car_index].physics.location
+        ball = tick.game_tick_packet.game_ball.physics.location
+
+        dist = sqrt(
+            (car.x - ball.x) ** 2 +
+            (car.y - ball.y) ** 2
+        )
+        if dist <= self.min_dist_to_pass:
+            return Pass()
+        return None

training/example_playlist.py

@@ -0,0 +1,12 @@
+import hello_world_training
+import rlbottraining.common_exercises.bronze_goalie as bronze_goalie
+
+def make_default_playlist():
+    exercises = (
+        hello_world_training.make_default_playlist() +
+        bronze_goalie.make_default_playlist()
+    )
+    for exercise in exercises:
+        exercise.match_config = hello_world_training.make_match_config_with_my_bot()
+
+    return exercises

training/hello_world_training.py

@@ -0,0 +1,96 @@
+from pathlib import Path
+from dataclasses import dataclass, field
+from math import pi
+
+from rlbot.utils.game_state_util import GameState, BoostState, BallState, CarState, Physics, Vector3, Rotator
+from rlbot.matchconfig.match_config import MatchConfig, PlayerConfig, Team
+from rlbottraining.common_exercises.common_base_exercises import StrikerExercise
+from rlbottraining.rng import SeededRandomNumberGenerator
+from rlbottraining.match_configs import make_empty_match_config
+from rlbottraining.grading.grader import Grader
+from rlbottraining.training_exercise import TrainingExercise, Playlist
+
+import training_util
+from drive_to_ball_grader import DriveToBallGrader
+
+
+def make_match_config_with_my_bot() -> MatchConfig:
+    # Makes a config which only has our bot in it for now.
+    # For more defails: https://youtu.be/uGFmOZCpel8?t=375
+    match_config = make_empty_match_config()
+    match_config.player_configs = [
+        PlayerConfig.bot_config(
+            Path(__file__).absolute().parent.parent / 'python_example' / 'python_example.cfg',
+            Team.BLUE
+        ),
+    ]
+    return match_config
+
+@dataclass
+class StrikerPatience(StrikerExercise):
+    """
+    Drops the ball from a certain height, requiring the bot to not drive
+    underneath the ball until it's in reach.
+    """
+
+    car_start_x: float = 0
+
+    def make_game_state(self, rng: SeededRandomNumberGenerator) -> GameState:
+        return GameState(
+            ball=BallState(physics=Physics(
+                location=Vector3(0, 4400, 1000),
+                velocity=Vector3(0, 0, 200),
+                angular_velocity=Vector3(0, 0, 0))),
+            cars={
+                0: CarState(
+                    physics=Physics(
+                        location=Vector3(self.car_start_x, 3000, 0),
+                        rotation=Rotator(0, pi / 2, 0),
+                        velocity=Vector3(0, 0, 0),
+                        angular_velocity=Vector3(0, 0, 0)),
+                    jumped=False,
+                    double_jumped=False,
+                    boost_amount=0)
+            },
+            boosts={i: BoostState(0) for i in range(34)},
+        )
+
+@dataclass
+class DrivesToBallExercise(TrainingExercise):
+    """
+    Checks that we drive to the ball when it's in the center of the field.
+    """
+    grader: Grader = field(default_factory=DriveToBallGrader)
+
+    def make_game_state(self, rng: SeededRandomNumberGenerator) -> GameState:
+        return GameState(
+            ball=BallState(physics=Physics(
+                location=Vector3(0, 0, 100),
+                velocity=Vector3(0, 0, 0),
+                angular_velocity=Vector3(0, 0, 0))),
+            cars={
+                0: CarState(
+                    physics=Physics(
+                        location=Vector3(0, 2000, 0),
+                        rotation=Rotator(0, -pi / 2, 0),
+                        velocity=Vector3(0, 0, 0),
+                        angular_velocity=Vector3(0, 0, 0)),
+                    jumped=False,
+                    double_jumped=False,
+                    boost_amount=100)
+            },
+            boosts={i: BoostState(0) for i in range(34)},
+        )
+
+
+def make_default_playlist() -> Playlist:
+    exercises = [
+        StrikerPatience('start perfectly center'),
+        StrikerPatience('start on the right', car_start_x=-1000),
+        DrivesToBallExercise('Get close to ball'),
+        DrivesToBallExercise('Get close-ish to ball', grader=DriveToBallGrader(min_dist_to_pass=1000))
+    ]
+    for exercise in exercises:
+        exercise.match_config = make_match_config_with_my_bot()
+
+    return exercises

training/training_util.py

@@ -0,0 +1,7 @@
+from rlbottraining.rng import SeededRandomNumberGenerator
+
+from rlbot.utils.game_state_util import Vector3
+
+
+def get_car_start_near_goal(rng: SeededRandomNumberGenerator) -> Vector3:
+    return Vector3(rng.uniform(1000, 2000), 3000, 0)

training/unit_tests.py

@@ -0,0 +1,37 @@
+import unittest
+
+from rlbot.training.training import Pass, Fail
+from rlbottraining.exercise_runner import run_playlist
+
+from hello_world_training import StrikerPatience
+
+class PatienceTest(unittest.TestCase):
+    """
+    These units check that this bot behaves as we expect,
+    with regards to the StrikerPatience exercise.
+
+    By default, the bot isn't very smart so it'll fail in the cases where
+    patience is required but passes in cases where no patience is required.
+
+    Tutorial:
+    https://youtu.be/hCw250aGN8c?list=PL6LKXu1RlPdxh9vxmG1y2sghQwK47_gCH&t=187
+    """
+
+    def test_patience_required(self):
+        result_iter = run_playlist([StrikerPatience(name='patience required')])
+        results = list(result_iter)
+        self.assertEqual(len(results), 1)
+        result = results[0]
+        self.assertEqual(result.exercise.name, 'patience required')
+        self.assertIsInstance(result.grade, Fail)  # If you make the bot is smarter, update this assert that we pass.
+
+    def test_no_patience_required(self):
+        result_iter = run_playlist([StrikerPatience(name='no patience required', car_start_x=-1000)])
+        results = list(result_iter)
+        self.assertEqual(len(results), 1)
+        result = results[0]
+        self.assertEqual(result.exercise.name, 'no patience required')
+        self.assertIsInstance(result.grade, Pass)
+
+if __name__ == '__main__':
+    unittest.main()