docs: improve clarity and formatting in ext roadrunner documentation

Author: zachwaffle4

src/extensions/roadrunner/command-builder.md

@@ -2,7 +2,7 @@
 
 The RoadRunner extension provides a `TrajectoryCommandBuilder` class 
 that makes it easy to create commands that follow trajectories,
-similarly to `TrajectoryActionBuilder` in the RoadRunner library.
+similar to `TrajectoryActionBuilder` in the RoadRunner library.
 
 Once you've set up the RoadRunner extension in your project,
 including the relevant changes to your `MecanumDrive` class,
@@ -30,7 +30,7 @@ class CommandBuilderKt : NextFTCOpMode() {
     }
 
     // the onInit blocks are executed in the order they are defined,
-    // so drive will be initialized before driveCommand
+    // so `drive` will be initialized before `driveCommand`.
     val driveCommand: Command by onInit {
         drive.commandBuilder(startPose)
             .splineTo(scorePose.position, scorePose.heading)

src/extensions/roadrunner/index.md

@@ -1,32 +1,30 @@
 # RoadRunner Extension
 
-This extension provides integration with the 
-[RoadRunner Library](https://rr.brott.dev/),
+This extension provides integration with the
+[RoadRunner Library](https://rr.brott.dev/)
 and [QuickStart](https://github.com/acmerobotics/road-runner-quickstart).
 
 ## Installation
 
-To install the RoadRunner extension,
-add the following line to your `build.gradle` file:
+Add the following line to your `build.gradle` file
+to install the RoadRunner extension:
 
 ```groovy
 implementation 'dev.nextftc.extensions:roadrunner:1.0.0'
 ```
 
 ::: warning
-Version `1.0.0` supports RoadRunner `1.0.1`,
-and RoadRunner FTC `0.1.25`,
-and is not compatible with earlier versions.
+Version `1.0.0` supports RoadRunner `1.0.1`
+and RoadRunner FTC `0.1.25`, and is not compatible with earlier versions.
 
-This guide also assumes you are using
-the QuickStart for RoadRunner,
+This guide also assumes you are using QuickStart for RoadRunner
 and its `MecanumDrive` class.
 :::
 
 ## QuickStart Additions
 
 To use the RoadRunner extension,
-you will need to make a few additions to the QuickStart code.
+make the following additions to the QuickStart code.
 
 First, make your `MecanumDrive` class extend `NextFTCMecanumDrive`:
 
@@ -36,8 +34,8 @@ public class MecanumDrive extends NextFTCMecanumDrive {
 }
 ```
 
-You will probably get an error about unimplemented members;
-you can copy the following implementations into your class:
+You will probably get an error about unimplemented members.
+You can copy the following implementations into your class:
 
 ```java
     HolonomicController controller = new HolonomicController(
@@ -59,17 +57,21 @@ you can copy the following implementations into your class:
 
     @Override
     public void setDrivePowersFF(@NotNull PoseVelocity2dDual<Time> powers) {
-        MecanumKinematics.WheelVelocities<Time> wheelVels = kinematics.inverse(poseVelocity2dDual);
+        MecanumKinematics.WheelVelocities<Time> wheelVels =
+            kinematics.inverse(poseVelocity2dDual);
         double voltage = voltageSensor.getVoltage();
 
-        final MotorFeedforward feedforward = new MotorFeedforward(PARAMS.kS,
-                PARAMS.kV / PARAMS.inPerTick, PARAMS.kA / PARAMS.inPerTick);
+        final MotorFeedforward feedforward = new MotorFeedforward(
+            PARAMS.kS,
+            PARAMS.kV / PARAMS.inPerTick,
+            PARAMS.kA / PARAMS.inPerTick
+        );
         double leftFrontPower = feedforward.compute(wheelVels.leftFront) / voltage;
         double leftBackPower = feedforward.compute(wheelVels.leftBack) / voltage;
         double rightBackPower = feedforward.compute(wheelVels.rightBack) / voltage;
         double rightFrontPower = feedforward.compute(wheelVels.rightFront) / voltage;
         mecanumCommandWriter.write(new MecanumCommandMessage(
-                voltage, leftFrontPower, leftBackPower, rightBackPower, rightFrontPower
+            voltage, leftFrontPower, leftBackPower, rightBackPower, rightFrontPower
         ));
 
         leftFront.setPower(feedforward.compute(wheelVels.leftFront) / voltage);
@@ -99,7 +101,7 @@ you can copy the following implementations into your class:
 
 Android Studio will probably suggest the necessary imports.
 
-There is an example `MecanumDrive` class in the NextFTC branch of my 
+There is an example `MecanumDrive` class in the NextFTC branch of my
 [RoadRunner QuickStart fork](https://github.com/zachwaffle4/road-runner-quickstart/tree/nextftc).
-Do note that this is just an example,
-and it may not be updated to the latest version of RoadRunner or NextFTC.
+Note that this is just an example and may not be updated
+to the latest version of RoadRunner or NextFTC.

src/extensions/roadrunner/other-commands.md

@@ -4,31 +4,34 @@ The `TrajectoryCommandBuilder` has functions to schedule other commands
 during trajectory execution. This can be useful for coordinating
 mechanisms on your robot while following a path.
 
-Here are the functions available in `TrajectoryCommandBuilder` for this purpose:
+Here are the functions available in `TrajectoryCommandBuilder`
+for this purpose:
 - `waitSeconds(seconds: Double)`: Adds a wait period to the trajectory.
   An additional overload accepts a `Duration` argument instead of a `Double`.
-  - `afterTime(seconds: Double, command: Command)`: Schedules a command to run after a specified time into the trajectory.
-  An additional overload accepts a `Duration` argument instead of a `Double`.
-- `afterDisplacement(displacement: Double, command: Command)`: 
-  Schedules a command to run after the robot has traveled a specified distance along the trajectory.
-- `stopAndAdd(command: Command)`: 
-  Stops the trajectory following and runs the specified command. 
-  The trajectory will not resume after the command completes.
+- `afterTime(seconds: Double, command: Command)`: Schedules a command to run
+after a specified time into the trajectory.
+  An additional overload accepts
+a `Duration` argument instead of a `Double`.
+- `afterDisplacement(displacement: Double, command: Command)`: Schedules a command
+to run after the robot has traveled a specified distance along the trajectory.
+- `stopAndAdd(command: Command)`: Stops the trajectory following and runs
+the specified command.
+  The trajectory will resume after the command completes.
 
 `afterTime`, `afterDisplacement`, and `stopAndAdd` also have overloads
 that accept a `Runnable` instead of a `Command` object,
 which schedules an `InstantCommand`.
 
 Here is an example of using these functions in an OpMode,
-using the [lift](../../guide/subsystems/lift) and 
+using the [lift](../../guide/subsystems/lift) and
 [claw](../../guide/subsystems/claw) subsystems from the previous guides.
 
-As you can see, this example requires us to use
-the `SubsystemComponent` to add the subsystems to our OpMode,
-so that their `periodic` methods are called during the OpMode.
-You can add other subsystems to the same `SubsystemComponent` if needed,
-and other `Component` types can be added alongside it,
-if needed or desired.
+As you can see, this example requires you to use the `SubsystemComponent`
+to add the subsystems to your OpMode, so that their `periodic` methods
+are called during the OpMode.
+You can add other subsystems to the same
+`SubsystemComponent` if needed, and other `Component` types can be added
+alongside it if needed or desired.
 
 ::: tabs key:code
 == Kotlin
@@ -71,7 +74,7 @@ public class OtherCommands extends NextFTCOpMode {
 
     public OtherCommands() {
         addComponents(
-                new SubsystemComponent(Lift.INSTANCE, Claw.INSTANCE)
+            new SubsystemComponent(Lift.INSTANCE, Claw.INSTANCE)
         );
     }
 
@@ -80,15 +83,15 @@ public class OtherCommands extends NextFTCOpMode {
         drive = new MecanumDrive(hardwareMap, startPose);
 
         driveCommand = drive.commandBuilder(startPose)
-                .splineTo(scorePose.position, scorePose.heading)
-                .afterTime(0.5, Lift.INSTANCE.toHigh())
-                .stopAndAdd(Claw.INSTANCE.open())
-                .build();
+            .splineTo(scorePose.position, scorePose.heading)
+            .afterTime(0.5, Lift.INSTANCE.toHigh())
+            .stopAndAdd(Claw.INSTANCE.open())
+            .build();
     }
 
     @Override
     public void onStartButtonPressed() {
         driveCommand.schedule();
     }
 }
-```
+```