Merge beta docs into main (#29)

* refactor: move command creation info to the custom commands page

* feat: add documentation for more command utilities

Author: zachwaffle4

src/nextftc/commands/custom-commands.md

@@ -49,3 +49,120 @@ fun runToPosition(
 
 The `setStart`, `setUpdate`, `setIsDone`, and `setStop` 
 methods directly map to the methods of the `Command` class.
+
+In general, a lambda command can be created as follows:
+
+:::tabs key:code
+== Kotlin
+
+```kotlin
+val myLambdaCommand = LambdaCommand()
+    .setStart { 
+        // Runs on start
+    }
+    .setUpdate { 
+        // Runs on update
+    }
+    .setStop { interrupted ->
+        // Runs on stop
+    }
+    .setIsDone { true } // Returns if the commmand has finished
+    .requires(/* subsystems the command implements */)
+    .setInterruptible(true)
+    .named("My Command") // sets the name of the command; optional
+```
+
+== Java
+
+```java
+Command myLambdaCommand = new LambdaCommand()
+    .setStart(() -> {
+        // Runs on start
+    })
+    .setUpdate(() -> {
+        // Runs on update
+    })
+    .setStop(interrupted -> {
+        // Runs on stop
+    })
+    .setIsDone(() -> true) // Returns if the command has finished
+    .requires(/* subsystems the command implements */)
+    .setInterruptible(true)
+    .named("My Command"); // sets the name of the command; optional
+```
+
+:::
+
+> [!TIP]
+> All functions are completely optional. You only need to call the ones you will
+> use. They can be called in any order.
+
+## Command Classes
+
+### Commands as Classes
+
+It is unlikely that you will need to use this very often, but you can also
+create a command as a class. This is useful for cases where you need to reuse
+your command a lot. An command can be created as a class as follows:
+
+:::tabs key:code
+== Kotlin
+
+```kotlin
+class MyCommand(): Command() {
+
+    init {
+        requires(/* subsystems */)
+        setInterruptible(true) // this is the default, so you don't need to specify
+    }
+
+    override val isDone: Boolean
+        get() = false // whether or not the command is done
+
+    override fun start() {
+        // executed when the command begins
+    }
+
+    override fun update() {
+        // executed on every update of the command
+    }
+
+    override fun stop(interrupted: Boolean) {
+        // executed when the command ends
+    }
+}
+```
+
+== Java
+
+```java
+public class MyCommand extends Command {
+
+    public MyCommand() {
+        requires(/* subsystems */);
+        setInterrptuptible(true); // this is the default, so you don't need to specify
+    }
+
+    @Override
+    public boolean isDone() {
+        return false; // whether or not the command is done
+    }
+
+    @Override
+    public void start() {
+        // executed when the command begins
+    }
+
+    @Override
+    public void update() {
+        // executed on every update of the command
+    }
+
+    @Override
+    public void stop(boolean interrupted) {
+        // executed when the command ends
+    }
+}
+```
+
+:::

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 */ });
 ```
 
-:::
+:::
+