feat: more changes

Signed-off-by: BeepBot99 <74377508+BeepBot99@users.noreply.github.com>

Author: BeepBot99

.idea/workspace.xml

@@ -49,10 +49,6 @@ export default [
             {
                 text: "Delays",
                 link: "/nextftc/helpful-commands/delays"
-            },
-            {
-                text: "Miscellaneous",
-                link: "/nextftc/helpful-commands/misc"
             }
         ]
     },

.vitepress/sidebar/nextftc.mts

@@ -1,28 +1,44 @@
 # Commands
 
-_Why use commands?_ Commands allow you to **organize your code** much more efficiently than you could otherwise. They are an excellent alternative to [finite state machines](https://gm0.org/en/latest/docs/software/concepts/finite-state-machines.html), but are a lot easier to create and modify, and can reach higher levels of complexity than a finite state machine can.
+_Why use commands?_ Commands allow you to **organize your code** much more
+efficiently than you could otherwise. They are an excellent alternative
+to [finite state machines](https://gm0.org/en/latest/docs/software/concepts/finite-state-machines.html),
+are a lot easier to create and modify, and can reach higher levels of complexity
+than a finite state machine can.
 
 ## Parts of a Command
 
 A command has four main components: `isDone`, `start`, `update`, and `stop`.
 
--   `isDone` is checked every loop. If it ever evaluates to `true`, the command will stop running.
--   `start` is run once, when the command is scheduled. It is used for setting up starting states and doing other things that should only happen once.
--   `update` runs every loop, many times per second. Because of this, it is crucial that it never takes more than a trivial amount of time to execute. You should be extremely careful of looping or doing anything else that could take significant amounts of time
--   `stop` runs once when the command ends, and recieves a parameter of whether or not it was interrupted by a different command.
+- `isDone` is checked every loop. If it ever evaluates to `true`, the command
+  will stop running.
+- `start` is run once, when the command is scheduled. It is used for setting up
+  starting states and doing other things that should only happen once.
+- `update` runs every loop, many times per second. Because of this, it is
+  crucial that it never takes more than a trivial amount of time to execute. You
+  should be extremely careful of looping or doing anything else that could take
+  significant amounts of time
+- `stop` runs once when the command ends, and receives a parameter of
+  whether it was interrupted by a different command.
 
 Additionally, it has two more properties:
 
--   `interruptible` determines whether or not the command is able to be interrupted. A command is interrupted when another command is scheduled that requires a subsystem the command is using. If a command is not interruptible, then the new command will not run.
--   `subsystems` is a set of all the subsystems a command uses. This is used for determing when two commands requrie the same subsystem. This is passed to the constructor of most premade commands.
+- `interruptible` determines whether the command is able to be
+  interrupted. A command is interrupted when another command is scheduled that
+  requires a subsystem the command is using. If a command is not interruptible,
+  then the new command will not run.
+- `requirements` is a set of all the requirements a command has. This is
+  used to determine when two commands require the same resource.
 
 ## Creating Commands
 
-There are two ways to create a command: a `LambdaCommand` and by creating your own command class.
+There are two ways to create a command: a `LambdaCommand` and by creating your
+own command class.
 
 ### Lambda Commands
 
-A lambda command is the main way to create a command in NextFTC. A lambda command can be created as follows:
+A lambda command is the main way to create a command in NextFTC. A lambda
+command can be created as follows:
 
 :::tabs key:code
 == Kotlin
@@ -39,7 +55,7 @@ val myLambdaCommand = LambdaCommand()
         // Runs on stop
     }
     .setIsDone { true } // Returns if the commmand has finished
-    .setRequirements(/* subsystems the command implements */)
+    .requires(/* subsystems the command implements */)
     .setInterruptible(true)
 ```
 
@@ -57,18 +73,21 @@ Command myLambdaCommand = new LambdaCommand()
         // Runs on stop
     })
     .setIsDone(() -> true) // Returns if the command has finished
-    .setRequirements(/* subsystems the command implements */)
+    .requires(/* subsystems the command implements */)
     .setInterruptible(true)
 ```
 
 :::
 
 > [!TIP]
-> All functions are completely optional. You only need to call the ones you will use. They can be called in any order.
+> All functions are completely optional. You only need to call the ones you will
+> use. They can be called in any order.
 
 ## 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:
+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
@@ -77,7 +96,7 @@ It is unlikely that you will need to use this very often, but you can also creat
 class MyCommand(): Command() {
 
     init {
-        setRequirements(/* subsystems */) // you can make this a constructor parameter, if needed
+        requires(/* subsystems */)
         setInterruptible(true) // this is the default, so you don't need to specify
     }
 
@@ -104,7 +123,7 @@ class MyCommand(): Command() {
 public class MyCommand extends Command {
 
     public MyCommand() {
-        setRequirements(/* subsystems */); // you can make this a constructor parameter, if needed
+        requires(/* subsystems */);
         setInterrptuptible(true); // this is the default, so you don't need to specify
     }
 
@@ -134,9 +153,8 @@ public class MyCommand extends Command {
 
 ## Executing Commands
 
-There are two ways to schedule a command.
+There are two ways to schedule a command. You can either call:
 
-You can either call:
 :::tabs key:code
 == Kotlin
 
@@ -155,6 +173,7 @@ CommandManager.INSTANCE.scheduleCommand(myCommand);
 :::
 
 Or just:
+
 :::tabs key:code
 == Kotlin
 

src/nextftc/concepts/commands.md

@@ -9,8 +9,7 @@ accomplish a wide range of functions when they're used in your OpModes.
 NextFTC has several built-in components, including:
 
 - `BulkReadComponent`
-- `BindingsComponent` (for NextBindings)
-- `PedroComponent` (for NextPedro)
+- `BindingsComponent` (for [NextBindings](/bindings))
 - `SubsystemComponent`
 - `CommandManager`
 
@@ -71,7 +70,7 @@ For example:
 init {
     addComponents(
         MyComponent(),
-        BindingComponent()
+        BindingsComponent
     )
 }
 ```
@@ -82,7 +81,7 @@ init {
 {
     addComponents(
         new MyComponent(),
-        new BindingComponent()
+        BindingsComponent.INSTANCE
     );
 }
 ```

src/nextftc/concepts/components.md

@@ -65,47 +65,42 @@ in that subsystem. For example:
 == Kotlin
 
 ```kotlin
-val open = SetPositon(claw, 1.0).setRequirements(this)
+val open = SetPositon(claw, 1.0).requires(this)
 ```
 
 == Java
 
 ```java
-public Command open = new SetPosition(claw, 1).setRequirements(this);
+public Command open = new SetPosition(claw, 1).requires(this);
 ```
 
 :::
 
 However, if you have multiple degrees of freedom in one subsystem, commands
 for each degree of freedom should get its own requirement. A simple way to
-do this is as follows.
+do this is by using the hardware objects as requirements. See the following
+example.
 
 :::tabs key:code
 
 == Kotlin
 
 ```kotlin
-private val claw = Any()
-private val pivot = Any()
+val openClaw = SetPosition(clawServo, 1.0).requires(clawServo)
+val closeClaw = SetPosition(clawServo, 0.0).requires(clawServo)
 
-val openClaw = SetPosition(clawServo, 1.0).setRequirements(claw)
-val closeClaw = SetPosition(clawServo, 0.0).setRequirements(claw)
-
-val pivotLeft = SetPosition(pivotServo, 0.0).setRequirements(pivot)
-val pivotRight = SetPostion(pivotServo, 1.0).setRequirements(left) 
+val pivotLeft = SetPosition(pivotServo, 0.0).requires(pivotServo)
+val pivotRight = SetPostion(pivotServo, 1.0).requires(pivotServo) 
 ```
 
 == Java
 
 ```java
-private Object claw = new Object();
-private Object pivot = new Object();
-
-public Command openClaw = new SetPosition(clawServo, 1).setRequirements(claw);
-public Command closeClaw = new SetPosition(clawServo, 0).setRequirements(claw);
+public Command openClaw = new SetPosition(clawServo, 1).requires(clawSerov);
+public Command closeClaw = new SetPosition(clawServo, 0).requires(clawServo);
 
-public Command pivotLeft = new SetPosition(pivotServo, 0.0).setRequirements(pivot);
-public Command pivotRight = new SetPosition(pivotServo, 0.0).setRequirements(pivot);
+public Command pivotLeft = new SetPosition(pivotServo, 0.0).requires(pivotServo);
+public Command pivotRight = new SetPosition(pivotServo, 0.0).requires(pivotServo);
 ```
 
 :::

src/nextftc/concepts/subsystems.md

@@ -1,10 +1,15 @@
 # Units
 
-NextFTC has an immutable, type-safe units system that allows you to pass quantities in any unit. It also prevents you from mixing up units accidentally. NextFTC has three types of units: `Distance`, `Angle`, and `TimeSpan`. All units extend the `Quantity` abstract class.
+NextFTC has an immutable, type-safe units system that allows you to pass
+quantities in any unit. It also prevents you from mixing up units accidentally.
+NextFTC has two types of units: `Distance` and `Angle`. All units extend the
+`Quantity` abstract class.
 
 ## `Distance`
 
-The first unit we'll look at is `Distance`. There are six units `Distance` accepts: millimeters, centimeters, meters, inches, feet, and yards. Internally it is stored in millimeters.
+The first unit we'll look at is `Distance`. There are six units `Distance`
+accepts: millimeters, centimeters, meters, inches, feet, and yards. Internally
+it is stored in millimeters.
 
 Creating a `Distance` is simple:
 
@@ -83,7 +88,6 @@ val inch = 1.inch
 
 val sum = foot + inch // 13 in
 val difference = foot - inch // 11 in
-val product = foot * inch // 12 in (should be in^2 but NextFTC isn't THAT complicated)
 val quotient = foot / inch // 12
 
 val bigger = foot * 2 // 24 in
@@ -115,7 +119,6 @@ Distance inch = Distance.fromIn(1);
 
 Distance sum = foot.plus(inch); // 13 in
 Distance difference = foot.minus(inch); // 11 in
-Distance product = foot.times(inch); // 12 in (should be in^2 but NextFTC isn't THAT complicated)
 double quotient = foot.div(inch); // 12
 
 Distance bigger = foot.times(2); // 24 in
@@ -140,42 +143,11 @@ boolean isNaN = foot.isNaN(); // false
 
 :::
 
-## `TimeSpan`
-
-`TimeSpan` is very similar to `Distance`, only with different units. Supported units are microseconds, milliseconds, and seconds. Internally it is stored in microseconds.
-
-Using `TimeSpans` is simple:
-
-:::tabs key:code
-== Kotlin
-
-```kotlin
-val seconds  = 1.sec
-val milliseconds = 5.ms
-val microseconds = 70000000.us
-
-val secondsInMilliseconds = seconds.inMs // 1,000
-val millisecondsInMicroseconds = milliseconds.inUs // 5,000
-val microsecondsInSeconds = microseconds.inSec // 70
-```
-
-== Java
-
-```java
-TimeSpan seconds = TimeSpan.fromSec(1);
-TimeSpan milliseconds = TimeSpan.fromMs(5);
-TimeSpan microseconds = TimeSpan.fromUs(70000000);
-
-double secondsInMilliseconds = seconds.inMs; // 1,000
-double millisecondsInMicroseconds = milliseconds.inUs; // 5,000
-double microsecondsInSeconds = microseconds.inSec; // 70
-```
-
-:::
-
 ## `Angle`
 
-An `Angle` is very similar to `Distance` and `TimeSpan`, but it also has functionality for wrapping and normalizing. Angles can be in radians, degrees, or full revolutions, and are stored internally as radians.
+`Angle` is very similar to `Distance`, but it also has
+functionality for wrapping and normalizing. Angles can be in radians, degrees,
+or full revolutions, and are stored internally as radians.
 
 :::tabs key:code
 == Kotlin
@@ -204,7 +176,8 @@ Double quarterRadians = quarterCircle.inRad; // pi/2
 
 :::
 
-You can also wrap and normalize angles. Below is a table of what wrapping and normalizing does for angles in different units.
+You can also wrap and normalize angles. Below is a table of what wrapping and
+normalizing does for angles in different units.
 
 | Unit        | Wrapping | Normalizing |
 |-------------|----------|-------------|