> For the complete documentation index, see [llms.txt](https://thepython10110.gitbook.io/better-commands/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://thepython10110.gitbook.io/better-commands/commands/execute.md). # /execute Runs a Better Command after changing the context Usage There are currently seven instructions (aka. subcommands) for the `/execute` command. Multiple subcommands can be chained after `/execute`. Subcommands are divided into 2 categories: Modifier subcommands and rhe `run` subcommand. * Modifier subcommands modify execution context variables to change the context the command is executed. Subcommands following it execute with specific executor(s), execution position(s), execution dimension(s), execution rotation(s) and execution anchor. * The `run` subcommand is used for carrying out another command. All needed subcommands can be concatenated together. Subcommands other than the `run` subcommand can be arranged arbitrarily and used multiple times. But the `run` subcommand can be used only once and must be put at the end of the subcommands chain. A `run` subcommand or a condition subcommand finalizes the chain, otherwise the command is unparseable. The game processes the subcommand chain in order from front to end, for example, the following commands are different: All entities move one block forward: `execute as @e at @s run tp ^ ^ ^1` All entities are teleported to one block in front of the executor: `execute at @s as @e run tp ^ ^ ^1` Some subcommands can fork the command execution into multiple branches, that is, they cause subcommands following it to be executed multiple times. For example, when `as` subcommand selects multiple entities, the subcommand following it executes once per entity. If the `/execute` command hasn't ever forked, we describe it as having only one branch — the main branch. A branch may terminate halfway and does nothing (does not execute `run` subcommands). For example, if the condition in a condition subcommand isn't met, or as subcommand selects zero entities. If all branches terminated, we describe the /execute command itself as terminating. Note that `... run execute ...` has no effect at all. For example, the following commands work the same: `execute as @e[type=pig] at @e[type=pig] run summon pig` `execute as @e[type=pig] run execute at @e[type=pig] run execute run /execute run summon pig` Better Commands' version of `/execute` acts like the non-coffee-flavored version of ACOVG in that it processes subcommands depth-first. This means that after forking, all the following subcommands are considered as a whole and are executed once for each branch. There is no way to achieve breadth-first execution, just because it's harder to do without completely rewriting large parts of my code. ## Output values I haven't quite figured this part out yet. ## Syntax There are currently eight subcommands (eventually, there will be 12-13) for the `/execute` command, and each has its own special syntax, so describing syntax takes a large branching tree. #### Full syntax tree `/execute ...` * `... align -> execute` * `... as -> execute` * `... at -> execute` * `... facing (|entity ) -> execute` * `... positioned (|as ) -> execute` * `... rotated (|as ) -> execute` * `... run ` where `-> execute` represents the start of another subcommand that is required. #### Modifier subcommands
align Updates the execution position, aligning to its current block position (integer coordinates). Applies only along specified axes. This akin to flooring the coordinates - i.e. rounding then \*downward\* (not toward zero). *Usage* `align -> execute` *Arguments* `` [String](/better-commands/data-types.md#string) Any non-repeating combination of the characters 'x', 'y', and 'z'. Axes can be declared in any order, but they cannot duplicate. (For example, `x`, `xz`, `zyx`, or `yz`.) *Result* Execution position in the given axes are floored, changing by less than 1 block. Causes an error if the argument is not specified correctly. Given (-1.8, 2.3, 5.9), `execute align xz` changes the position to (-2, 2.3, 5).Given (2.4, -1.1, 3.8), `execute align yxz run tp @p ~ ~ ~` teleports the nearest player to (2, -2, 3).
as Sets the *executor* to target entity, without changing *execution position, rotation, dimension, and anchor.* *Syntax* `as -> execute` *Arguments* `` [Selector](/better-commands/target-selectors.md) Target entity/entities to become the new executor. *Result* Executor is updated to target entity (which changes the meaning of `@s`). Causes an error if the argument is not specified correctly. Forks if `` selects multiple entities. Terminates current branch if `` fails to resolve to one or more entities (named players must be online). *Example* Kill all sheep: `execute as @e[type=sheep] run kill @s` Teleport all loaded cows five blocks above you: `execute as @e[type=cow] run tp ~ ~5 ~`
at Sets the *execution position, rotation,* and *dimension* to match those of an entity; does not change *executor*. *Syntax* `at -> execute` *Arguments* `` [Selector](/better-commands/target-selectors.md) Target entity/entities to match position, rotation, and dimension with. *Result* *Execution position, rotation,* and *dimension* are updated to match target entity. Causes an error if the argument is not specified correctly. Forks if `` selects multiple entities. Terminates current branch if `` fails to resolve to one or more entities (named players must be online). *Example* Move all sheep upward 1 block: `execute as @e[type=sheep] at @s run tp ~ ~1 ~` Kill the player running the command, because "`at`" does not change the executor: `execute at @e[type=sheep] run kill @s`
facing Sets the *execution rotation* to face a given point, as viewed from its anchor (either the eyes or the feet). ***Syntax*** `facing -> execute` `facing entity -> execute` ***Arguments*** Options: `facing ` `` [Position](/better-commands/data-types.md#position) Coordinates to rotate toward. Options: `facing entity ` `` [Selector](/better-commands/target-selectors.md) The target(s) to rotate toward. Must be a player name or [target selector](/better-commands/target-selectors.md). ***Result*** *Execution rotation* is updated to face given position or targets. Causes an error if the argument is not specified correctly. Forks if `` selects multiple entities. Terminates current branch if `` or `origin: target` fails to resolve to one or more entities (named players must be online). ***Example*** Executor rotates one degree to the left: `execute facing ^1 ^ ^ run tp @s ~ ~ ~ ~ ~` All entities move one block in the direction of (0, 64, 0) (without changing their rotation): `execute as @e at @s facing 0 64 0 run tp @s ^ ^ ^1` All entities move one block in the direction of (0, 64, 0) (with changing their rotation): `execute as @e at @s facing 0 64 0 run tp ^ ^ ^1 ~ ~` All non player entities move one space in the direction of their nearest player (without changing their rotation): `execute as @e[type=!player] at @s facing entity @p run tp @s ^ ^ ^1`\\
positioned Sets the *execution position*, without changing *execution rotation* or *dimension*; can match an entity's position. ***Syntax*** `positioned -> execute` `positioned as -> execute` ***Arguments*** Option: `positioned ` `` [Position](/better-commands/data-types.md#position) New position. Option: `positioned as ` `` [Selector](/better-commands/target-selectors.md) The target(s) to match position with. ***Result*** *Execution position* is updated. And `positioned ` also resets *execution anchor* to `feet`. Causes an error if the argument is not specified correctly. Forks if `` selects multiple entities. Terminates current branch if `` fails to resolve to one or more entities (named players must be online). ***Example*** Say the name of the player closest to (0, 64, 0): `execute positioned 0 64 0 run say @p`
rotated Sets the *execution rotation*, can match an entity's rotation. ***Syntax*** `rotated -> execute` `rotated as -> execute` ***Arguments*** Option: `rotated ` `` [Rotation](/better-commands/data-types.md#rotation) The rotation (yaw and optionally pitch), in degrees Option: `rotated as ` `` [Selector](/better-commands/target-selectors.md) The target(s) to match rotation with. Must be a player name or [target selector](/better-commands/target-selectors.md). ***Result*** *Execution rotation* is updated. Causes an error if the argument is not specified correctly. Forks if `` selects multiple entities. Terminates current branch if `` fails to resolve to one or more entities (named players must be online). ***Example*** Move every sheep 1 block in the direction that the player closest to it is facing: `execute as @e[type=sheep] at @s rotated as @p run tp @s ^ ^ ^1`
#### Run subcommand The `run` command's single argument is the command to be executed, the context variables of which may be modified by the subcommands used. ***Syntax*** `run ` ***Arguments*** `` [Long string](/better-commands/data-types.md#long-string) Can be any [Better Command](/better-commands/commands.md) ***Result*** Execute the specified command. Fails if the command fails. ## Examples Teleport all zombies five nodes in the direct1ion of the nearest player. `execute as @e[type=zombie] at @s facing @p run tp ^ ^ ^5` Make every entity say the name of the nearest other entity. `execute as @e at @s run say @e[sort=nearest,limit=1,distance=.1..]` ## History | Version | Action | | ------- | ----------------------------- | | v1.0 | Added `/execute` | | v2.0 | Removed `anchored` subcommand |