> ## Documentation Index
> Fetch the complete documentation index at: https://wiki.soba.xyz/llms.txt
> Use this file to discover all available pages before exploring further.

# List of all nodes

> Learn about all the no-code editor on Soba

<Accordion title="What are Nodes" icon="square-share-nodes">
  Nodes are the connections you find when making custom graphs (adding custom logic to a block, one that goes beyond the options offered by default). See image below for understanding what are nodes.

  <p align="center">
    <img width="400" noZoom src="https://i.imgur.com/auOEI1d.png" />
  </p>
</Accordion>

# Nodes Library

| Category  | Group                       | Node Name               | Description                                                                                                         | Inputs                                                                | Outputs                                                   |
| --------- | --------------------------- | ----------------------- | ------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------- | --------------------------------------------------------- |
| Sources   |                             | All Players             | Gets all players currently in the game.                                                                             |                                                                       | Players (players)                                         |
| Sources   | Random Values               | Random Number           | Generates a random number between 0 and 1.                                                                          |                                                                       | Random Number (float)                                     |
| Sources   | Random Values               | Random Color            | Generates a random color.                                                                                           |                                                                       | RandomColor (color)                                       |
| Sources   |                             | Game Time               |                                                                                                                     |                                                                       |                                                           |
| Sources   | Empty List                  | Empty Number List       |                                                                                                                     |                                                                       |                                                           |
| Sources   | Empty List                  | Empty Text List         |                                                                                                                     |                                                                       |                                                           |
| Sources   | Empty List                  | Empty True/False List   |                                                                                                                     |                                                                       |                                                           |
| Sources   | Empty List                  | Empty Position List     |                                                                                                                     |                                                                       |                                                           |
| Sources   | Empty List                  | Empty Orientation List  |                                                                                                                     |                                                                       |                                                           |
| Sources   | Empty List                  | Empty Object List       |                                                                                                                     |                                                                       |                                                           |
| Sources   | Empty List                  | Empty Player List       |                                                                                                                     |                                                                       |                                                           |
| Sources   | Empty List                  | Empty Orientation List  |                                                                                                                     |                                                                       |                                                           |
| Sources   |                             | This Object             |                                                                                                                     |                                                                       |                                                           |
| Sources   | Object                      | Object Source           |                                                                                                                     |                                                                       |                                                           |
| Sources   | Object                      | Object List Source      |                                                                                                                     |                                                                       |                                                           |
| Operators | Number Operations           | A + B                   | Addition: A + B = Result.                                                                                           | A (float) B (float)                                                   | Sum (float)                                               |
| Operators | Number Operations           | A - B                   | Subtraction: A - B = Result.                                                                                        | A (float) B (float)                                                   | Result (float)                                            |
| Operators | Number Operations           | A × B                   | Multiplication: A × B = Result.                                                                                     | A (float) B (float)                                                   | Result (float)                                            |
| Operators | Number Operations           | A / B                   | Division: A / B = Result.                                                                                           | A (float) B (float)                                                   | Result (float)                                            |
| Operators | Number Operations           | A % B                   | Modulo: A % B = Result. Divides two numbers and outputs the remainder of the division.                              | A (float) B (float)                                                   | Result (float)                                            |
| Operators | Number Operations           | A = B                   | Results in true when number A equals number B.                                                                      | A (float) B (float)                                                   | Result (bool)                                             |
| Operators | Number Operations           | A ≥ B                   | Results in true when number A equals B or A is greater than B.                                                      | A (float) B (float)                                                   | Result (bool)                                             |
| Operators | Number Operations           | A ≤ B                   | Results in true when number A equals B or A is less than B.                                                         | A (float) B (float)                                                   | Result (bool)                                             |
| Operators | Number Operations           | A > B                   | Results in true when number A is greater than B.                                                                    | A (float) B (float)                                                   | Result (bool)                                             |
| Operators | Number Operations           | A \< B                  | Results in true when number A is less than B.                                                                       | A (float) B (float)                                                   | Result (bool)                                             |
| Operators | Number Operations           | Round A                 |                                                                                                                     | A (float)                                                             | Result                                                    |
| Operators | Number Operations           | -1 × A                  | Negation: -1 × A = Result.                                                                                          | A (float)                                                             | Result (float)                                            |
| Operators | Property Extractors         | Get Health              | Gets a player’s health.                                                                                             | Player (player)                                                       | Health (number)                                           |
| Operators | Property Extractors         | Get Max Health          | Gets the maximum value of a player’s health.                                                                        | Player (player)                                                       | Max Health (number)                                       |
| Operators | Property Extractors         | Get Lives               | Gets a player’s lives.                                                                                              | Player (player)                                                       | Lives (number)                                            |
| Operators | Property Extractors         | Get Max Lives           | Gets the maximum number of a player’s lives.                                                                        | Player (player)                                                       | Max Lives (number)                                        |
| Operators | Property Extractors         | Player Position         | Gets the position of a player.                                                                                      | Player (player)                                                       | Position (position)                                       |
| Operators | Property Extractors         | Player Orientation      | Gets the orientation of a player.                                                                                   | Player (player)                                                       | Orientation (orientation)                                 |
| Operators | Property Extractors         | Get Score               | Gets the score of a player.                                                                                         | Player (player)                                                       | Score (float)                                             |
| Operators | Property Extractors         | Get Team                | Gets the team of a player.                                                                                          | Player (player)                                                       | Team (team)                                               |
| Operators | Property Extractors         | Object Position         | Gets the position of an object.                                                                                     | Object (object)                                                       | Position (position)                                       |
| Operators | Property Extractors         | Object Orientation      | Gets the orientation of an object.                                                                                  | Object (object)                                                       | Orientation (orientation)                                 |
| Operators | Boolean Operations          | Negate                  |                                                                                                                     | Input                                                                 | Output                                                    |
| Operators | Boolean Operations          | A==B                    |                                                                                                                     | A B                                                                   | Result                                                    |
| Operators | Boolean Operations          | And                     |                                                                                                                     | A B                                                                   | True/False                                                |
| Operators | Boolean Operations          | Or                      |                                                                                                                     | A B                                                                   | ResultA B                                                 |
| Operators | Boolean Operations          | XOR                     |                                                                                                                     | A B                                                                   | Result                                                    |
| Operators | Boolean Operations          | All                     |                                                                                                                     | Boolean                                                               | True/False                                                |
| Operators | Boolean Operations          | Any                     |                                                                                                                     | Boolean                                                               | True/False                                                |
| Operators | Comparisons                 | Compare Colors          | Determines if two colors are the same.                                                                              | Color A(Hex code) Color B (Hex code)                                  | Same? (bool)                                              |
| Operators | Comparisons                 | Compare Objects         | Determines if two objects are the same.                                                                             | Object A (object) Object B (object)                                   | Same? (bool)                                              |
| Operators | Comparisons                 | Compare Players         | Determines if two players are the same.                                                                             | Player A (player) Player B (player)                                   | Same? (bool)                                              |
| Operators | Comparisons                 | Compare Teams           | Determines if two teams are the same.                                                                               | Team A (team) Team B (team)                                           | Same? (bool)                                              |
|           |                             |                         |                                                                                                                     |                                                                       |                                                           |
| Operators | Comparisons                 | Compare Positions       | Determines if two positions are the same.                                                                           | Position A (vector) Position B (vector)                               | Same? (bool)                                              |
| Operators | Comparisons                 | Compare Orientations    | Determines if two orientations are the same.                                                                        | Orientation A (vector) Orientation B (vector)                         | Same? (bool)                                              |
| Operators | Comparisons                 | Compare Texts           | Determines if two texts are the same.                                                                               | Text A (text field) Text B (text field)                               | Same? (bool)                                              |
| Operators | Comparisons                 | Compare Vectors         | Determines if two vectors are the same.                                                                             | Vector A (vector) Vector B (vector)                                   | Same? (bool)                                              |
| Operators | Position Operations         | Object Offset Position  | Gets the position of an object with an offset taking the object rotation into account.                              | Object (object) Offset (position)                                     | Result Position (position)                                |
| Operators | Position Operations         | Player Offset Position  | Gets the position of a player with an offset taking the player rotation into account.                               | Player (player) Offset (position)                                     | Result Position (position)                                |
| Operators | Position Operations         | Random Position         | Picks a random position.                                                                                            | Center (vector) Extent X (number) Extent Y (number) Extent Z (number) | Position (position)                                       |
| Operators | Position Operations         | Direction               | Converts a direction vector to an orientation. Note that the input vector doesn't represent the three Euler angles. | From (position) To (position)                                         | Orientation (orientation)                                 |
| Operators | Position Operations         | Distance                | Calculates the distance between two positions.                                                                      | From (position) To (position)                                         | Distance (float)                                          |
| Operators | Position Operations         | In Line Of Sight        | Checks whether two positions are in the line of sight of each other and outputs true or false.                      | From (position) To (position)                                         | True Or False (bool)                                      |
| Operators | Boolean List Operations     | Append                  |                                                                                                                     |                                                                       |                                                           |
| Operators | Boolean List Operations     | Pick First              |                                                                                                                     |                                                                       |                                                           |
| Operators | Boolean List Operations     | Pick Reverse            |                                                                                                                     |                                                                       |                                                           |
| Operators | Boolean List Operations     | Shuffle                 |                                                                                                                     |                                                                       |                                                           |
| Operators | Boolean List Operations     | Size                    |                                                                                                                     |                                                                       |                                                           |
| Operators | Number List Operations      | Append                  |                                                                                                                     |                                                                       |                                                           |
|           |                             |                         |                                                                                                                     |                                                                       |                                                           |
| Operators | Number List Operations      | Max                     |                                                                                                                     |                                                                       |                                                           |
| Operators | Number List Operations      | Min                     |                                                                                                                     |                                                                       |                                                           |
| Operators | Number List Operations      | Pick First              |                                                                                                                     |                                                                       |                                                           |
| Operators | Number List Operations      | Reverse                 |                                                                                                                     |                                                                       |                                                           |
| Operators | Number List Operations      | Shuffle                 |                                                                                                                     |                                                                       |                                                           |
| Operators | Number List Operations      | Size                    |                                                                                                                     |                                                                       |                                                           |
| Operators | Object List Operations      | Append                  |                                                                                                                     |                                                                       |                                                           |
| Operators | Object List Operations      | Pick First              |                                                                                                                     |                                                                       |                                                           |
| Operators | Object List Operations      | Reverse                 |                                                                                                                     |                                                                       |                                                           |
| Operators | Object List Operations      | Shuffle                 |                                                                                                                     |                                                                       |                                                           |
| Operators | Object List Operations      | Size                    |                                                                                                                     |                                                                       |                                                           |
| Operators | Orientation List Operations | Append                  |                                                                                                                     |                                                                       |                                                           |
| Operators | Orientation List Operations | Pick First              |                                                                                                                     |                                                                       |                                                           |
| Operators | Orientation List Operations | Reverse                 |                                                                                                                     |                                                                       |                                                           |
| Operators | Orientation List Operations | Shuffle                 |                                                                                                                     |                                                                       |                                                           |
| Operators | Orientation List Operations | Size                    |                                                                                                                     |                                                                       |                                                           |
| Operators | Player List Operations      | Append                  |                                                                                                                     |                                                                       |                                                           |
| Operators | Player List Operations      | Pick First              |                                                                                                                     |                                                                       |                                                           |
| Operators | Player List Operations      | Reverse                 |                                                                                                                     |                                                                       |                                                           |
| Operators | Player List Operations      | Shuffle                 |                                                                                                                     |                                                                       |                                                           |
| Operators | Player List Operations      | Size                    |                                                                                                                     |                                                                       |                                                           |
| Operators | Position List Operations    | Append Position         |                                                                                                                     |                                                                       |                                                           |
| Operators | Position List Operations    | Pick First Position     |                                                                                                                     |                                                                       |                                                           |
| Operators | Position List Operations    | Reverse Position List   |                                                                                                                     |                                                                       |                                                           |
| Operators | Position List Operations    | Shuffle Positions       |                                                                                                                     |                                                                       |                                                           |
| Operators | Position List Operations    | Size Positions          |                                                                                                                     |                                                                       |                                                           |
| Operators | String List Operations      | Append Text             |                                                                                                                     |                                                                       |                                                           |
| Operators | String List Operations      | Pick First Text         |                                                                                                                     |                                                                       |                                                           |
| Operators | String List Operations      | Reverse Text List       |                                                                                                                     |                                                                       |                                                           |
| Operators | String List Operations      | Shuffle Texts           |                                                                                                                     |                                                                       |                                                           |
| Operators | String List Operations      | Size Texts              |                                                                                                                     |                                                                       |                                                           |
| Operators | Team Operations             | Get Score               | Gets the score of a team.                                                                                           | Team (team)                                                           | Score (float)                                             |
| Operators | Team Operations             | Split by Team           | Filters players by team from a given list of players.                                                               | Team (team) Players (players)                                         | Players Of Team (players) Players Of Other Team (players) |
| Operators | Vector Operations           | Vector Negation         |                                                                                                                     |                                                                       |                                                           |
| Operators | Vector Operations           | Normalize Vector        | Normalizes a vector so it has a length of 1.                                                                        | Vector (vector)                                                       | Normalized Vector (vector)                                |
| Operators | Vector Operations           | Vector Addition         | Addition: Vector A + Vector B = Result Vector                                                                       | Vector A (vector) Vector B (vector)                                   | Result Vector (vector)                                    |
| Operators | Vector Operations           | Vector Subtraction      | Subtraction: Vector A - Vector B = Result Vector.                                                                   | Vector A (vector) Vector B (vector)                                   | Result Vector (vector)                                    |
| Operators | Vector Operations           | Multiply Vector         | Multiplication: Vector × Number = Result Vector. Changes the length of a vector.                                    | Vector (vector) Number (float)                                        | Result Vector (vector)                                    |
| Operators | Vector Operations           | Vector Magnitude        |                                                                                                                     |                                                                       |                                                           |
| Operators | Vector Operations           | Vector From Components  | Creates a vector from single value.                                                                                 | X (float) Y (float) Z (float)                                         | Vector (vector)                                           |
| Operators | Vector Operations           | Position To Vector      | Turns a position into a vector.                                                                                     | Position (position)                                                   | Vector (vector)                                           |
| Operators | Vector Operations           | Vector From Orientation | Converts a vector to a position.                                                                                    | Vector (vector)                                                       | Position (position)                                       |
| Operators | Vector Operations           | Vector To Position      | Converts a vector to a position.                                                                                    | Vector (vector)                                                       | Position (position)                                       |
| Operators | Vector Operations           | Vector From Orientation |                                                                                                                     |                                                                       |                                                           |
| Operators | Vector Operations           | Vector To Orientation   |                                                                                                                     |                                                                       |                                                           |