Replace PlayerArgument with EntitySelectorArgument.OnePlayer where applicable

Author: DerEchtePilz

docs/en/annotations/annotations.md

@@ -88,7 +88,7 @@ The annotations for arguments are really simple, there are just two things you n
 
 $$\begin{align}
 \texttt{StringArgument}&\xrightarrow{A}\texttt{@AStringArgument}\\\\
-\texttt{PlayerArgument}&\xrightarrow{A}\texttt{@APlayerArgument}\\\\
+\texttt{IntegerArgument}&\xrightarrow{A}\texttt{@AIntegerArgument}\\\\
 \texttt{AdvancementArgument}&\xrightarrow{A}\texttt{@AAdvancementArgument}\\\\
 &\hspace{0.75em}\vdots
 \end{align}$$

docs/en/create-commands/arguments/arguments.md

@@ -22,8 +22,8 @@ Adding arguments for registration is simple:
 // Create a List
 List<Argument> arguments = new ArrayList<>();
 
-// Add an argument with the node "target", which is a PlayerArgument
-arguments.add(new PlayerArgument("target"));
+// Add an argument with the node "target", which is a EntitySelectorArgument.OnePlayer
+arguments.add(new EntitySelectorArgument.OnePlayer("target"));
 ```
 
 The String value is the node that is registered into Minecraft's internal command graph. This name is also used as a prompt that is shown to a player when they are entering the command.
@@ -118,9 +118,8 @@ The type to cast each argument (declared in the `dev.jorel.commandapi.arguments`
 |                                                             [`NBTCompoundArgument<T>`](./types/nbt-arguments) | The cast type changes depending on whether you're shading the CommandAPI or using the CommandAPI as a plugin:<br /><ul><li>Shading:<br />`T` (implemented yourself)</li><br /><li>Plugin:<br />`dev.jorel.commandapi.nbtapi.NBTContainer`</li></ul> |
 |                              [`ObjectiveArgument`](./types/scoreboard/objective-arguments#objective-argument) | `org.bukkit.scoreboard.Objective`                                                                                                                                                                                                                   |
 |             [`ObjectiveCriteriaArgument`](./types/scoreboard/objective-arguments#objective-criteria-argument) | `String`                                                                                                                                                                                                                                            |
-|                                  [`OfflinePlayerArgument`](./types/entities-arguments#offlineplayer-argument) | `org.bukkit.OfflinePlayer`                                                                                                                                                                                                                          |
 |                                                         [`ParticleArgument`](./types/misc/particle-arguments) | `dev.jorel.commandapi.wrappers.ParticleData`                                                                                                                                                                                                        |
-|                                                [`PlayerArgument`](./types/entities-arguments#player-argument) | `org.bukkit.entity.Player`                                                                                                                                                                                                                          |
+|                                  [`PlayerProfileArgument`](./types/entities-arguments#playerprofile-argument) | `org.bukkit.entity.Player`                                                                                                                                                                                                                          |
 |                                                       [`PotionEffectArgument`](./types/misc/potion-arguments) | `org.bukkit.potion.PotionEffectType`                                                                                                                                                                                                                |
 |                                         [`PotionEffectArgument.NamespacedKey`](./types/misc/potion-arguments) | `org.bukkit.NamespacedKey`                                                                                                                                                                                                                          |
 |                                                             [`RecipeArgument`](./types/misc/recipe-arguments) | The cast type changes depending on your Minecraft version:<br><ul><li>Version 1.14.4 and below:<br />`org.bukkit.inventory.Recipe`</li><br /><li>1.15 and above:<br />`org.bukkit.inventory.ComplexRecipe` </li></ul>                               |

docs/en/create-commands/arguments/optional-arguments.md

@@ -65,12 +65,12 @@ When using the `withOptionalArguments` method it might be interesting to know th
 
 ```java
 new CommandAPICommand("optional")
-    .withOptionalArguments(new PlayerArgument("target"))
+    .withOptionalArguments(new EntitySelectorArgument.OnePlayer("target"))
 ```
 
 ```java
 new CommandAPICommand("optional")
-    .withArguments(new PlayerArgument("target").setOptional(true))
+    .withArguments(new EntitySelectorArgument.OnePlayer("target").setOptional(true))
 ```
 
 However, calling `withOptionalArguments` is safer because it makes sure that the argument is optional because of that internal call.
@@ -131,7 +131,7 @@ At this point, your command is basically done.
 Any attempt to add a required argument will result in an `OptionalArgumentException`.
 However, this is where the `combineWith` method comes in.
 This method allows you to combine arguments.
-Let's say you have an optional `StringArgument` (here simplified to `A`) and you want a required `PlayerArgument` (here simplified to `B`).
+Let's say you have an optional `StringArgument` (here simplified to `A`) and you want a required `EntitySelectorArgument.OnePlayer` (here simplified to `B`).
 Argument `B` should only be required if argument `A` is given.
 To implement that logic, we’re going to use the `combineWith` method so that we have this syntax:
 
@@ -144,7 +144,7 @@ This does two things:
 1. When checking optional argument constraints the argument `B` will be ignored so the `OptionalArgumentException` will not be thrown
 2. It allows you to define additional optional arguments afterwards which can only be entered if argument `B` has been entered
 
-This is how you would add another optional `PlayerArgument` (here simplified to `C`):
+This is how you would add another optional `EntitySelectorArgument.OnePlayer` (here simplified to `C`):
 
 ```java
 new CommandAPICommand("mycommand")

docs/en/create-commands/arguments/suggestions/safe-suggestions.md

@@ -66,9 +66,8 @@ The list of supported arguments are displayed in the following table. The parame
 |                              [`MathOperationArgument`](../types/misc/mathoperation-arguments) | `dev.jorel.commandapi.wrappers.MathOperation`  |
 |                                               [`NBTCompoundArgument`](../types/nbt-arguments) | `de.tr7zw.nbtapi.NBTContainer`                 |
 |             [`ObjectiveArgument`](../types/scoreboard/objective-arguments#objective-argument) | **`org.bukkit.scoreboard.Objective`**          |
-|                        [`OfflinePlayerArgument`](../types/entities-arguments#player-argument) | `org.bukkit.OfflinePlayer`                     |
 |                                        [`ParticleArgument`](../types/misc/particle-arguments) | `org.bukkit.Particle`                          |
-|                               [`PlayerArgument`](../types/entities-arguments#player-argument) | `org.bukkit.entity.Player`                     |
+|                 [`PlayerProfileArgument`](../types/entities-arguments#playerprofile-argument) | `org.bukkit.entity.Player`                     |
 |                                      [`PotionEffectArgument`](../types/misc/potion-arguments) | `org.bukkit.potion.PotionEffectType`           |
 |                                            [`RecipeArgument`](../types/misc/recipe-arguments) | `org.bukkit.inventory.Recipe`                  |
 |                                    [`RotationArgument`](../types/position/rotation-arguments) | `dev.jorel.commandapi.wrappers.Rotation`       |

docs/en/create-commands/arguments/suggestions/string-suggestions.md

@@ -39,7 +39,7 @@ The `strings(Function<SuggestionInfo, String[]> suggestions)` method in `Argumen
 
 ::::tip Example - Friend list by replacing suggestions
 
-Say you have a plugin which has a "friend list" for players. If you want to teleport to a friend in that list, you could use a `PlayerArgument`, which has the list of suggestions replaced with the list of friends that that player has. Since the list of friends _depends on the sender_, we can use the function to determine what our suggestions should be. Let's use the following command to teleport to a friend from our friend list:
+Say you have a plugin which has a "friend list" for players. If you want to teleport to a friend in that list, you could use a `EntitySelectorArgument.OnePlayer`, which has the list of suggestions replaced with the list of friends that that player has. Since the list of friends _depends on the sender_, we can use the function to determine what our suggestions should be. Let's use the following command to teleport to a friend from our friend list:
 
 ```mccmd
 /friendtp <friend>

docs/en/create-commands/arguments/types/misc/advancement-arguments.md

@@ -20,7 +20,7 @@ Say we want to award a player an advancement. First, we need the syntax that our
 /award <player> <advancement>
 ```
 
-Since we require a player, we will use the `PlayerArgument` for this example. Given a player, we can simply get the `AdvancementProgress` for that player, and then award the criteria required to fully complete the provided advancement.
+Since we require a player, we will use the `EntitySelectorArgument.OnePlayer` for this example. Given a player, we can simply get the `AdvancementProgress` for that player, and then award the criteria required to fully complete the provided advancement.
 
 :::tabs
 ===Java

docs/en/create-commands/arguments/types/misc/potion-arguments.md

@@ -20,7 +20,7 @@ Say we wanted to have a command that gives a player a potion effect. For this co
 /potion <target> <potion> <duration> <strength>
 ```
 
-In this example, we utilize some of the other arguments that we've described earlier, such as the `PlayerArgument` and `TimeArgument`. Since duration for the `PotionEffect` constructor is in ticks, this is perfectly fit for the `TimeArgument`, which is represented in ticks.
+In this example, we utilize some of the other arguments that we've described earlier, such as the `EntitySelectorArgument.OnePlayer` and `TimeArgument`. Since duration for the `PotionEffect` constructor is in ticks, this is perfectly fit for the `TimeArgument`, which is represented in ticks.
 
 #### Use `PotionEffectArgument`
 

docs/en/create-commands/command-trees.md

@@ -67,7 +67,7 @@ Say we want to take our `/sayhi` command from above and also have an argument wh
 /sayhi <target> - Says "Hi!" to a target player
 ```
 
-We can do this by adding a `PlayerArgument` to our command. As described above, to add this argument, we must use the `then()` method:
+We can do this by adding an `EntitySelectorArgument.OnePlayer` to our command. As described above, to add this argument, we must use the `then()` method:
 
 :::tabs
 ===Java
@@ -76,7 +76,7 @@ We can do this by adding a `PlayerArgument` to our command. As described above,
 <<< @/../reference-code/bukkit/src/main/kotlin/createcommands/CommandTrees.kt#commandTreesExample
 :::
 
-In this example, we have our normal `/sayhi` command using the `executes()` method. We then add a new argument (a new "branch" in our "tree"), the `PlayerArgument`, using the `then()` method. **We want to make this branch executable, so we also use the `executes()` method _on the argument itself_**. To register the full command tree (which includes both `/sayhi` and `/sayhi <target>`), we call `register()` on the `CommandTree` object.
+In this example, we have our normal `/sayhi` command using the `executes()` method. We then add a new argument (a new "branch" in our "tree"), the `EntitySelectorArgument.OnePlayer`, using the `then()` method. **We want to make this branch executable, so we also use the `executes()` method _on the argument itself_**. To register the full command tree (which includes both `/sayhi` and `/sayhi <target>`), we call `register()` on the `CommandTree` object.
 
 ::::
 

docs/en/create-commands/permissions.md

@@ -79,7 +79,7 @@ We first declare the command as normal. Nothing fancy is going on here:
 <<< @/../reference-code/bukkit/src/main/kotlin/createcommands/Permissions.kt#argumentPermissionExampleStep1
 :::
 
-Now we declare our command with arguments. We use a `PlayerArgument` and apply the permission _to the argument_. After that, we register our command as normal:
+Now we declare our command with arguments. We use a `EntitySelectorArgument.OnePlayer` and apply the permission _to the argument_. After that, we register our command as normal:
 
 :::tabs
 ===Java

docs/en/create-commands/unregistration.md

@@ -152,7 +152,7 @@ For the ExamplePlugin, setting `verbose-outputs` to `true` gives this:
 ```log
 [Server thread/INFO]: [ExamplePlugin] Enabling ExamplePlugin v0.0.1
 [Server thread/INFO]: [CommandAPI] Registering command /break block<LocationArgument>
-[Server thread/INFO]: [CommandAPI] Registering command /myeffect target<PlayerArgument> potion<PotionEffectArgument>
+[Server thread/INFO]: [CommandAPI] Registering command /myeffect target<EntitySelectorArgument.OnePlayer> potion<PotionEffectArgument>
 [Server thread/INFO]: [CommandAPI] Registering command /nbt nbt<NBTCompoundArgument>
 ```