feat: add documentation for more command utilities

Author: zachwaffle4

src/nextftc/commands/utilities.md

@@ -2,25 +2,74 @@
 
 NextFTC has a bunch of utility commands to help you simplify your code!
 
-## `InstantCommand`
+## Instant Commands
 
 An `InstantCommand` runs a function and ends instantly.
+The `instant` utility function can be used to create an `InstantCommand`.
 
 :::tabs key:code
 == Kotlin
 
 ```kotlin
-InstantCommand {
+instant("name") {
+    // code here
+}
+
+// or 
+
+instant {
     // code here
 }
 ```
 
 == Java
 
 ```java
-new InstantCommand(() -> {
+instant("name", () -> {
     // code here
 })
+
+// or
+
+instant(() -> {
+    // code here
+});
+```
+
+:::
+
+## Run Commands
+
+A run command is similar to an `InstantCommand`, but it runs continuously until it is interrupted.
+There is no specific `RunCommand` class; 
+instead, the `run` utility function can be used to create a run command.
+
+:::tabs key:code
+
+== Kotlin
+```kotlin
+run("name") {
+    // code here
+} 
+
+// or
+
+run {
+    // code here
+}
+```
+
+== Java
+```java
+run("name", () -> {
+    // code here
+});
+
+// or
+
+run(() -> {
+    // code here
+});
 ```
 
 :::
@@ -44,75 +93,82 @@ new NullCommand(parameter1, parameter2)
 
 :::
 
-## `ForcedParallelCommand`
+## `proxy`
 
-A `ForcedParallelCommand` schedules another command and instantly ends. This can be useful in `SequentialGroups` where you want to start a command and move on.
+A proxy command schedules another command and instantly ends. 
+This can be useful in `SequentialGroups` where you want to start a command and move on.
 
 :::tabs key:code
 == Kotlin
 
 ```kotlin
-ForcedParallelCommand(command)
+proxy(command)
 ```
 
 == Java
 
 ```java
-new ForcedParallelCommand(command)
+proxy(command)
 ```
 
 :::
 
-Alternatively, you can used the `.forcedParallel()` utility:
+Alternatively, you can used the `.asProxy()` utility:
 
 :::tabs key:code
 
 == Kotlin
 
 ```kotlin
-command.forcedParallel()
+command.asProxy()
 ```
 
 == Java
 
 ```java
-command.forcedParallel()
+command.asProxy()
 ```
 
 :::
 
-## `PerpetualCommand`
+## `repeatedly`
 
-A `PerpetualCommand` wraps another command and never finishes unless it is interrupted. It simply ignores the `isDone` condition on the command it wraps.
+The `repeatedly` decorator can be used to create a command that runs until it is interrupted or stopped, 
+repeatedly executing a given block of code.
 
-:::tabs key:code
-== Kotlin
+If `isDone` is true, the command will restart, causing `start` to be called again.
+This will happen infinitely until the command is interrupted,
+or stopped as part of a `ParallelRaceGroup` or `ParallelDeadlineGroup`.
+
+::: tabs key:code
 
+== Kotlin
 ```kotlin
-PerpetualCommand(commandToWrap)
+command.repeatedly()
 ```
 
 == Java
-
 ```java
-new PerpetualCommand(commandToWrap)
+command.repeatedly();
 ```
 
-:::
+::: 
 
-Alternatively, you can use the `.perpetually()` utility:
+## `until`
 
-:::tabs key:code
-== Kotlin
+The `until` decorator can be used to create a command that runs until a given condition is true.
 
+::: tabs key:code
+
+== Kotlin
 ```kotlin
-commandToWrap.perpetually()
+command.until { /* condition */ }
 ```
 
 == Java
-
 ```java
-commandToWrap.perpetually()
+command.until(() -> { /* condition */ });
 ```
 
-:::
+:::
+

src/nextftc/concepts/subsystems.md

@@ -105,6 +105,41 @@ public Command pivotRight = new SetPosition(pivotServo, 0.0).requires(pivotServo
 
 :::
 
+## Subsystem Command Factories
+
+Within a `Subsystem`, you can use the builtin `instant` and `run` functions
+to create commands that automatically require the subsystem. 
+
+:::tabs key:code
+
+== Kotlin
+
+```kotlin
+object MySubsystem : Subsystem {
+    private val motor = MotorEx("motor")
+
+    val stopMotor = instant {
+        motor.power = 0.0
+    } // automatically requires this
+}
+```
+
+== Java
+
+```java
+public class MySubsystem implements Subsystem {
+    public static MySubsystem INSTANCE = new MySubsystem();
+
+    private MotorEx motor = new MotorEx("motor");
+
+    public Command stopMotor = instant(() -> {
+        motor.setPower(0.0);
+    }); // automatically requires this
+}
+```
+
+:::
+
 ## Subsystem Groups
 
 NextFTC provides a `SubsystemGroup` class that can be used to group multiple