# Chapter 5: Commands ## In This Chapter We're going to be learning how to adding more functionality to our commands. We're going to be adding aliases, permissions, and most importantly, arguments. ## Part 1: Command Entries Before we get into command arguments, let's talk about command entries, since these are fairly easy to understand. A **command entry** is basically a piece of code that modifies the way your command works. It can either be adding a permission to your command, or just describing what it does. to use command entries, you will put it right after creating your command, for example, if I wanted a command to only be executed if the player has permission `tenfont.use`: ``` command /tenfont: permission: tenfont.use ``` There are a bunch of command entries you can use to modify your command. To add a permission, use the `permission: tenfont.use` entry, and to send a message if the player doesn't have permission, use the `permission message: You don't have permission!` entry. To add an alias to your command, use the `aliases: /tf` entry, you can also insert multiple values in the alias like this: `aliases: /tf, /10font, /ten`. To add a description your command, use the `description: This is a command` entry. To add a usage to your command, use the `usage: /tenfont` entry. To make your command only executable by a certain command sender, use the `executable by: player` entry, you can also insert multiple by using `executable by: player and console`. Example code can be found below. ``` command /tenfont: usage: /tenfont description: Just a useless command. permission: tenfont.use permission message: &cYou don't have permission! executable by: player and console aliases: /tf trigger: send "&7Quack" ``` ## Part 2: Command Arguments Alright! So now you know how to add a permission, description, usage, alias, executable types, and a no-permission message to your command! Now let's add some arguments to give the user more control over the command. ### What's an argument? An argument is what comes after your command name. For example, a text argument in a broadcast command, or a player argument in a kill event. Arguments are extremely useful when you want the command sender to have control over a specific part of your command. Before adding arguments however, we must learn about Skript types. ### What's a type? A type in Skript is the type of an expression. Each expression is of some type. For example, the `world "world_name"` expression is of type `world`. The `event-player` expression in the `on teleport` event, and the `victim` in the `on death` event are both of type `player`. If you didn't get it already, types are basically what object the expression returns. The `victim` expression returns the player that died, so we say that it is returning a `player` type.\ \ Arguments in Skript work the same way. Each argument has it's own type, and the command sender may enter anything that matches that type. If the argument is of type `text`, then the user must enter a text. So now, let's go back to Skript Arguments. ### Creating Arguments If you've read the Chapter 1 of this tutorial, you're in luck! Command arguments are somewhat similar to Skript syntaxes. The main difference is that instead of `%` percent signs for placeholders, we use the `<` less than sign, and the `>` greater than sign. So a text argument would look something like ``. Just like Skript syntaxes, to create an optional argument, we would enclose it in square brackets. So an optional player argument would look like `[]`. Now that we know how arguments work, let's create some! In this tutorial, I'll be creating a give command, which gives an item to a specific player, or the entire server. Get ready, because this might get a little long. First of all, to add arguments to our command, we'll just insert the arguments after the command name. So, if we were to create a broadcast command, our first line would look something like `command /broadcast :`. Since we're creating a give command, we'll need 2 arguments. The first will be the item we want to give, and the second will be a player. For this tutorial, I'll make the player argument optional, and if it's not provided, we'll give the item to only the command sender. **Pro Tip!** Similar to Skript syntax, you can also use text in command arguments! For example, in the broadcast command, you could do something like `command /broadcast [to the server]:`, which makes it so the player can also type `to the server` at the end of the command if they would like to. -- Back to our command now, for this tutorial, I'll name the command `give`. And the arguments will be ` [to ]`. Our first line will look like this. ``` command /give [to ]: ``` Next, let's add a permission to this command, since we don't want players giving themselves stacks and stacks of diamond blocks, would we? We're also going to add a permission message which tells the player they don't have permission. We would also want to make the command not executable by the console, since we can't **give** items to the console. Our code will now look like this. ``` command /give [to ]: permission: tenfont.give permission message: You don't have permission! executable by: player trigger: ``` Now let's check if the argument is set or not. For this we'll use a condition. You can read about conditions in the previous chapter of this tutorial. Our condition will check if the player argument is set. If it is, then we're going to get the player argument and give the item to them. Else, we're going to give the item to the sender of the command. The condition we'll use is `%object% is set`, and in our case, `object` will be our `player argument`. There are multiple ways of calling arguments, but my favorite is to call them by their order. In our command, \ is the first argument, and \ is the second argument, so we'll use `arg-2` to call our argument. Now, if the second argument is set, we'll give the item argument to the player. The item argument is the first argument in our command, so we'll call it by using `arg-1`. Then, we use the `give` effect to give the item to the second argument, which is a player (which is the perfect type for the effect!) Our code will look something like this: ``` command /give [to ]: permission: tenfont.give permission message: You don't have permission! executable by: player trigger: if arg-2 is set: give arg-1 to arg-2 ``` Finally, let's create an `else` statement and give the item argument to the command sender. ``` command /give [to ]: permission: tenfont.give permission message: You don't have permission! executable by: player trigger: if arg-2 is set: give arg-1 to arg-2 else: give arg-1 to sender ``` And that's it. You've just created a command with arguments! ## Conclusion There you go! You now know how to create an advanced command, including a permission, permission message, executable type, alias, description, and usage. Also, did you realize this is the only chapter with only 2 parts? --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://tenfont.gitbook.io/skript/tutorial/section-1/chapter-5.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.