Minecraft Wiki
Advertisement
Esse artigo fala sobre um comando que executa outros comandos. Para o comando para matar um jogador ou outra entidade, veja Comandos/kill.
execute
Nível de permissão
requirido

2‌[EJ apenas]
1‌[EB apenas]

Restrições

Cheats only‌[EB apenas]

/execute executa outro comando, mas permite alterar o executor, alterar a posição e o ângulo em que é executado, adicionar pré-condições e armazenar seu resultado.

Edição Java

Na Edição Java, existem doze instruções (ou subcomandos) para o comando /execute. Vários subcomandos são conectados após /execute. Os subcomandos são divididos em 4 categorias: subcomandos de modificação, subcomandos de condição, subcomandos de armazenamento e subcomando run.

  • Modificar subcomandos modificam variáveis de comando e alteram a situação em que o comando é executado, e executam subcomandos seguindo-o com executor(es) específico(s), posição(ões) de execução, dimensão(ões) de execução, rotação(ões) de execução e âncora de execução.
  • Subcomandos de condição são usados para testar se certas condições são verdadeiras e resultados de saída ou condições limite de execução.
  • Os subcomandos de armazenamento podem armazenar os valores de retorno do comando em um placar ou os dados de uma entidade, entidade de bloco ou armazenamento, e também podem alterar o valor máximo ou atual de uma barra de saliência.
  • O subcomando run é usado para executar outro comando.

Todos os subcomandos necessários podem ser concatenados juntos. Os subcomandos diferentes do subcomando run podem ser organizados arbitrariamente e usados várias vezes. Mas o subcomando run só pode ser usado uma vez e deve ser colocado no final da cadeia de subcomandos. Um subcomando run ou um condição de subcomando finaliza o comando, caso contrário o comando não faz nada. O jogo processa esses subcomandos em ordem do início ao fim, por exemplo, os seguintes comandos são diferentes:

  • Todas as entidades avançam um bloco: execute as @e at @s run tp ^ ^ ^1
  • Todas as entidades são teletransportadas para um bloco na frente do executor: execute at @s as @e run tp ^ ^ ^1

O jogo processa outros subcomandos antes de processar os subcomandos run, portanto, o subcomando run não pode afetar outros subcomandos. Em alguns casos, o comando pode terminar no meio do caminho e não faz nada.

Depois de executado (se não terminar no meio do caminho), o comando retorna um valor success e um valor result (consulte #Store subcommand para obter detalhes). Esses dois valores vêm do último subcomando (pode ser um subcomando de condição ou um subcomando run). Observe que o valor de retorno do comando deve ser um número inteiro, caso contrário, é arredondado para baixo. O valor de success é sempre 0 ou 1. Quando o comando falha, ambos os valores de retorno são 0. Os dois valores podem ser armazenados pelos subcomandos store. Quando o último subcomando (pode ser um subcomando de condição ou um subcomando run) é executado várias vezes, os valores de retorno de cada um serão armazenados após cada execução.

O comando /execute também tem uma contagem de sucesso (termina ou não no meio do caminho), que é diferente de success e result valor. Geralmente é 0 ou 1, mas se o último subcomando for executado várias vezes separadamente (como talvez com "/execute as @a -> execute") então o sucesso pode ser um número maior que 1. Ao executá-lo com um bloco de comando, a contagem de sucesso é retornada ao bloco de comando, que pode ser verificado por um bloco de comando condicional para obter sucesso ou ser lido com um comparador redstone.

Existem doze instruções (ou subcomandos) para o comando /execute, e cada uma tem sua própria sintaxe especial, então descrever a sintaxe requer uma grande árvore ramificada.

Árvore de sintaxe completa
/execute . . .
  • align <axes> -> execute
  • anchored <anchor> -> execute
  • as <targets> -> execute
  • at <targets> -> execute
  • facing (<pos>|entity <targets> <anchor>) -> execute
  • in <dimension> -> execute
  • positioned (<pos>|as <targets>) -> execute
  • rotated (<rot>|as <targets>) -> execute
  • store (result|success) . . .
    • … block <targetPos> <path> <type> <scale> -> execute
    • … bossbar <id> (max|value) -> execute
    • … entity <target> <path> <type> <scale> -> execute
    • … score <targets> <objective> -> execute
    • … storage <target> <path> <type> <scale> -> execute
  • … (if|unless) . . .
    • … block <pos> <block> -> [execute]
    • … blocks <start> <end> <destination> (all|masked) -> [execute]
    • … data . . .0
      • … block <sourcePos> <path> -> [execute]
      • … entity <source> <path> -> [execute]
      • … storage <source> <path> -> [execute]
    • … entity <entities> -> [execute]
    • … predicate <predicate> -> [execute]
    • … score <target> <targetObjective> . . .
      • … (<|<=|=|>|>=) <source> <sourceObjective> -> [execute]
      • … matches <range> -> [execute]
  • run <command>
onde -> execute representa o início de outro subcomando.

Modificar subcomandos

align

Atualiza a posição de execução do comando, alinhando à sua posição atual do bloco (um inteiro). Aplica-se apenas ao longo dos eixos especificados.
Isso é semelhante a piso as coordenadas – ou seja, arredondando-as para baixo.
Sintaxe
align <axes> -> execute
Argumentos
<axes>: swizzle
Must be a collection of axes. Axes can be declared in any order, but they cannot duplicate.
Resultado
As Posições de execução nos eixos indicados são pavimentadas, mudando em menos de 1 bloco.
Não analisável se o argumento não for especificado corretamente.
Exemplo
  • Dado (-1.8, 2.3, 5.9), /execute align xz muda a posição para (-2, 2, 5).
  • Dado (2.4, -1.1, 3.8), /execute align yxz run spawnpoint @p ~ ~ ~ define o ponto de spawn do jogador para (2, -2, 3).

anchored

Define a âncora de execução para os olhos ou pés. Padrões para pés.
Recentraliza efetivamente coordenadas locais nos olhos ou nos pés, também alterando o ângulo do subcomando enfrentando (de /execute e /teleport) funciona fora de.
Sintaxe
anchored <anchor> -> execute
Argumentos
<anchor>: entity_anchor (eyes ou feet)
Se deve ancorar o comando executado nos olhos ou nos pés
Resultado
A Âncora de execução está definida para os olhos ou os pés.
Não analisável se o argumento não for especificado corretamente.
Exemplo
O efeito de /tp é mover um alvo colocando seus pés na posição dada.
execute anchored eyes run tp ^ ^ ^ efetivamente teletransporta os pés do executor para onde estão seus olhos (a posição de execução).
execute anchored eyes run tp ^5 ^ ^ significa "coloque os pés do executor 5 blocos à esquerda de onde estão seus olhos"

as

Define o executor do comando para a entidade alvo, sem alterar a posição de execução, rotação, dimensão, ou âncora
Sintaxe
as <targets> -> execute
Argumentos
<targets>: entity
Entidade/entidades alvo para se tornar o novo executor.
Deve ser um nome de jogador, seletores de destino ou o UUID
Resultado
Executor é atualizado para entidade de destino (o que altera o significado de @s).
Não analisável se o argumento não for especificado corretamente.
Termina se <targets> não resolver para uma ou mais entidades válidas (os jogadores nomeados devem estar online).
Quando várias entidades são selecionadas, o próximo subcomando é executado uma vez por cada executor.
Exemplo
Obter dados de todas as ovelhas: execute as @e[type=sheep] run data get entity @s[Edição Java apenas]
Torne todos os aldeões em chunks carregados invencíveis: execute as @e[type=villager] run data merge entity @s {Invulnerable:1}[Edição Java apenas]

at

Define a posição de execução, rotação e dimensão para corresponder às de uma entidade; não muda de executor.
Sintaxe
at <targets> -> execute
Argumentos
<targets>: entity
Entidade/entidades de destino para corresponder à posição, rotação e dimensão.
Deve ser um nome de jogador, seletores de destino ou o UUID
Resultado
Posição de execução, rotação e dimensão são atualizados para corresponder à entidade de destino.
Não analisável se o argumento não for especificado corretamente.
Termina se <targets> não resolver para uma ou mais entidades válidas (os jogadores nomeados devem estar online).
Quando várias entidades são selecionadas, o próximo subcomando é executado uma vez na posição de execução, rotação e dimensão de cada entidade.
Exemplo
Mova todas as ovelhas para cima 1 bloco: execute as @e[type=sheep] at @s run tp ~ ~1 ~
Mate o jogador que está executando o comando, pois "at" não altera o executor: execute at @e[type=sheep] run kill @s

facing

define a rotação de execução para enfrentar um determinado ponto, conforme visto de sua âncora (os olhos ou os pés)
Sintaxe
facing <pos> -> execute
facing entity <targets> <anchor> -> execute
Argumentos
Opções: facing <pos>
<pos>: vec3
Coordenar para girar em direção
Must be a three-dimensional coordinates with floating-point number elements. Accepts tilde and caret notations.
Opções: facing entity <targets> <anchor>
<targets>: entity
O(s) alvo(s) para girar em direção
Deve ser um nome de jogador, seletores de destino ou o UUID
<anchor>: entity_anchor (eyes ou feet)
Se deve apontar para os olhos ou pés do alvo
Resultado
Rotação de execução é atualizada para enfrentar determinada posição ou alvos
Não analisável se o argumento não for especificado corretamente
Termina se <targets> não resolver para uma ou mais entidades válidas (os jogadores nomeados devem estar online)
Quando várias entidades são selecionadas, o próximo subcomando é executado uma vez em cada rotação de execução
Exemplo
O executor gira uma vez para a esquerda: execute facing ^1 ^ ^ run tp ~ ~ ~
Todas as entidades movem um bloco na direção de (0, 64, 0) (sem alterar sua rotação): execute as @e at @s facing 0 64 0 run tp @s ^ ^ ^1
Todas as entidades movem um bloco na direção de (0, 64, 0) (com mudança de rotação): execute as @e at @s facing 0 64 0 run tp ^ ^ ^1 ~ ~
Todas as entidades que não são jogadores se movem um espaço na direção do jogador mais próximo (sem alterar sua rotação): execute as @e[type=!player] at @s facing entity @p feet run tp @s ^ ^ ^1

in

Define a dimensão de execução e a posição
Respeita a escala de dimensão para coordenadas relativas e locais: a posição de execução (apenas a parte X/Z) é dividida por 8 ao mudar do Mundo Superior para o Nether, e é multiplicada por 8 quando vice-versa. Aplica-se também a dimensões personalizadas. :;Sintaxe
in <dimension> -> execute
Argumentos
<dimension>: dimension
Nome da nova dimensão de execução
Must be a namespaced ID of a dimension. As dimensões padrão no namespace minecraft são "overworld", "the_nether", e "the_end".
Resultado
Execution dimension é atualizada
Não analisável se o argumento não for especificado corretamente
Exemplo
Procurando uma cidade do end (no Overworld): execute in the_end run locate EndCity
Se um jogador na posição (16,64,16) no Overworld executa o comando execute in minecraft:the_nether positioned as @s run tp ~ ~ ~, o jogador é teleportado para (16,64,16) no Nether.
Se um jogador na posição (16,64,16) no Overworld executa o comando execute in minecraft:the_nether run tp ~ ~ ~, o jogador é teletransportado para (2,64,2) no Nether.
Se um jogador na posição (80,64,80) no Overworld executa o comando execute in minecraft:the_nether run tp ~ ~ ~5, o jogador é teletransportado para (10,64,15) no Nether.

positioned

Define a posição de execução, sem alterar a rotação de execução ou a dimensão; pode corresponder à posição de uma entidade
Sintaxe
positioned <pos> -> execute
positioned as <targets> -> execute
Argumentos
Opção: positioned <pos>
<pos>: vec3
Nova Posição
Must be a three-dimensional coordinates with floating-point number elements. Accepts tilde and caret notations.
Opção: positioned as <targets>
<targets>: entity
Entidade/entidades de destino para corresponder à posição
Deve ser um nome de jogador, seletores de destino ou o UUID
Resultado
Execution position é atualizada. E positioned <pos> altera a âncora de execução para pés.
Não analisável se o argumento não for especificado corretamente.
Termina se <targets> não resolver para uma ou mais entidades válidas (os jogadores nomeados devem estar online).
Quando múltiplas entidades são selecionadas, o próximo subcomando é executado uma vez em cada posição de execução.
Exemplos
Procurar uma vila perto de (0, 64, 0)
execute positioned 0 64 0 run locate village

rotated

Define a rotação de execução; pode corresponder à rotação de uma entidade
Sintax
rotated <rot> -> execute
rotated as <targets> -> execute
Argumentos
<rot>: rotation (<yaw> <pitch>)
Must be a rotation with double number elements, including yaw and pitch, measured in degrees.
  • For the horizontal rotation (yaw), -180.0 for due north, -90.0 for due east, 0.0 for due south, 90.0 for due west, to 179.9 for just west of due north, before wrapping back around to -180.0.
  • For the vertical rotation (pitch), -90.0 for straight up to 90.0 for straight down.
Tilde notation can be used to specify a rotation relative to the executor's rotation.
<targets>: entity
Entidade/entidades de destino para combinar a rotação com
Deve ser um nome de jogador, seletores de destino ou o UUID
Resultado
Não analisável se o argumento não for especificado corretamente
Termina se <targets> não resolver para uma ou mais entidades válidas (os jogadores nomeados devem estar online).
Quando múltiplas entidades são selecionadas, o próximo subcomando é executado uma vez em cada rotação de execução.
Exemplo
Mova cada ovelha 1 quarteirão na direção em que o jogador mais próximo está voltado:

execute as @e[type=sheep] at @sORpositioned as @s rotated as @p run tp @s ^ ^ ^1

Subcomandos de condição

O uso particular dos subcomandos if e unless é para restringir a execução do comando para acontecer apenas sob condições especificadas. Na maioria dos casos, unless é uma negação de if, equivalente a "se não...". Os dois comandos têm estruturas de argumentos idênticas.

Resultado dos subcomandos de condição
Não analisável se o argumento não for especificado corretamente.
Em alguns casos, por exemplo, testando um bloco fora do mundo, tanto if quanto unless termina ou falha. : Quando não estiver no final da cadeia de subcomandos, somente se os testes de condição passarem é que o subcomando seguinte será executado; caso contrário, termina. Se for executado várias vezes por várias variáveis (por exemplo, executores, posições de execução, rotações de execução), ele atua como um filtro de variável - Somente a variável que corresponde à condição executa o próximo subcomando.
Quando no final da cadeia de subcomandos, verifica se a condição é atendida e, em seguida, gera a saída.

Existem seis tipos diferentes de condições:

  1. (if|unless) block – Testa um único bloco real
  2. (if|unless) blocks – Testa um volume retangular 3D real contra outro
  3. (if|unless) data – Testa os dados mantidos por um bloco, entidade ou armazenamento real
  4. (if|unless) entity – Testa se uma entidade como a dada é real
  5. (if|unless) predicate – Testa um predicado
  6. (if|unless) score - Testa a pontuação de um alvo

(if|unless) block

Compara o bloco em uma determinada posição com um determinado ID de bloco ou tag de bloco.
Sintaxe
(if|unless) block <pos> <block> -> [execute]
Argumentos
<pos>: block_pos
Posição de um bloco de destino para testar
It deve ser um bloco de posição composto de <x>, <y> e <z>, cada um deles deve ser um número inteiro ou notação de til e circunflexo.
<block>: block_predicate
Um ID de bloco ou tag de bloco válido para testar
It must be a block argument (accepts block tags).
Resultado
Não analisável se o argumento não for especificado corretamente
Nas seguintes condições, termina quando este subcomando não está no final da cadeia de subcomandos; falha quando no final:
  • Se <pos> estiver descarregado ou fora do mundo.
  • Se o teste não passar.
Quando no final da cadeia de subcomandos, e o comando for bem sucedido, o valor de sucess e o valor de result são 1.

(if|unless) blocks

Compares the blocks in two equally sized volumes
Sintaxe
(if|unless) blocks <start> <end> <destination> <scan mode> -> [execute]
Argumentos
<start>: block_pos
<end>: block_pos
Posições de quaisquer dois cantos diagonais do volume de origem (o comparador; o volume a ser comparado)
It deve ser um bloco de posição composto de <x>, <y> e <z>, cada um deles deve ser um número inteiro ou notação de til e circunflexo.
<destination>: block_pos
Posição do canto noroeste inferior do volume de destino (o comparador; o volume a ser comparado)
Presume-se que seja do mesmo tamanho que o volume de origem
It deve ser um bloco de posição composto de <x>, <y> e <z>, cada um deles deve ser um número inteiro ou notação de til e circunflexo.
<scan mode> : literal (all|masked)
Especifica se todos os blocos no volume de origem devem ser comparados ou se os blocos de ar devem ser mascarados/ignorados
Resultado
Não analisável se o argumento não for especificado corretamente
Nas seguintes condições, termina quando este subcomando não está no final da cadeia de subcomandos; falha quando no final:
  • Se <start>, <end> ou <destination> estiver descarregado ou fora do mundo.
  • Se o volume da região de origem for maior que 32768 (o equivalente a 8 seções de pedaços)‌
  • Se o teste não passar.
Quando no final da cadeia de subcomandos, e o comando é bem sucedido, o valor de sucess é 1.
Para o modo if, o valor result é o número de blocos correspondentes (o número total de blocos no modo all ou o número de blocos blocos não aéreos da região de origem no modo masked).
Para o modo unless, o valor de result é 1.

(if|unless) data

Verifica se o bloco, entidade ou [[Armazenamento de comandos|armazenamento] de destino possui alguma tag de dados para um determinado caminho
Sintaxe
(if|unless) data block <pos> <path> -> [execute] – para verificação de dados de um bloco
(if|unless) data entity <target> <path> -> [execute] – para verificação de dados de uma entidade
(if|unless) data storage <source> <path> -> [execute] – para verificação de dados de um armazenamento
Argumentos
Option: (if|unless) data block <pos> <path>
<pos>: block_pos
Posição do bloco cujos dados serão testados.
It deve ser um bloco de posição composto de <x>, <y> e <z>, cada um deles deve ser um número inteiro ou notação de til e circunflexo.
<path>: nbt_path
Caminho de dados para verificar se o bloco tem.
Must be an NBT path.
Option: (if|unless) data entity <target> <path>
<target>: entity
Uma única entidade cujos dados serão testados.
Deve ser um nome de jogador, seletores de destino ou o UUID.
<path>: nbt_path
Caminho de dados para verificar se a entidade tem.
Must be an NBT path.
Option: (if|unless) data storage <source> <path>
<source>: resource_location
O local do recurso do armazenamento cujos dados serão testados.
Must be a namespaced ID.
<path>: nbt_path
Caminho de dados para verificar se o armazenamento tem.
Must be an NBT path.
Resultado
Não analisável se o argumento não for especificado corretamente
Nas seguintes condições, termina quando este subcomando não está no final da cadeia de subcomandos; falha quando no final:
  • Se <pos> estiver descarregado ou fora do mundo.
  • Se o bloco em <pos> não for uma entidade de bloco.
  • Se target não resolver para uma entidade válida (os jogadores nomeados devem estar online)
  • Se o teste não passar.
Quando no final da cadeia de subcomandos, e o comando é bem sucedido, o valor de sucess é 1.
Para o modo if, o valor result é o número de tags de dados correspondentes.
Para o modo unless, o valor de result é 1.

(if|unless) entity

Verifica se uma ou mais entidades existem.
Sintaxe
(if|unless) entity <targets> -> [execute]
Argumentos
<entities>: entity
A(s) entidade(s) alvo(s) a verificar
Deve ser um nome de jogador, seletores de destino ou o UUID.
Resultado
Não analisável se o argumento não for especificado corretamente
Se o teste não passar, termina quando este subcomando não está no final da cadeia de subcomandos; falha quando no final.
Quando no final da cadeia de subcomandos, e o comando é bem sucedido, o valor de sucess é 1.
Para o modo if, o valor result é o número de entidades correspondentes.
Para o modo unless, o valor de result é 1.

(if|unless) predicate

Verifica se o predicado é avaliado como um resultado positivo. Consulte Predicado para obter mais informações.
Sintaxe
(if|unless) predicate <predicate> -> [execute]
Argumentos
<predicate>: resource_location
O predicado a ser verificado se avalia um resultado positivo.
Must be a namespaced ID.
Resultado
Não analisável se o argumento não for especificado corretamente
Nas seguintes condições, termina quando este subcomando não está no final da cadeia de subcomandos; falha quando no final:
  • Se o predicado não existir.
  • Se o teste não passar.
Quando no final da cadeia de subcomandos, e o comando é bem sucedido, o valor de sucess e result é 1.

(if|unless) score

Verifique se uma pontuação tem relação específica com outra pontuação ou se está em um determinado intervalo.
Sintaxe
(if|unless) score <target> <targetObjective> (<|<=|=|>=|>) <source> <sourceObjective> -> [execute] – para comparar duas pontuações
(if|unless) score <target> <targetObjective> matches <range> -> [execute] – para comparar uma pontuação com um intervalo
Argumentos
<target>: score_holder
Um único titular de pontuação.
Must be a selection of score holders. It may be either a target selector, a player name, a UUID, or * for all score holders.
<targetObjective>: objective
O objetivo do placar a ser verificado. A pontuação de <target> neste objetivo será verificada.
Must be a scoreboard objective name.
Option: (<|<=|=|>=|>) <source> <sourceObjective>
<source>: score_holder
Um único detentor de pontuação para comparar com
Must be a selection of score holders. It may be either a target selector, a player name, a UUID, or * for all score holders.
<sourceObjective>: objective
Um objetivo de placar. A pontuação de <source> neste objetivo será verificada.
Must be a scoreboard objective name.
Option: matches <range>
<range>: int_range
Intervalo para comparar a pontuação com
Must be a range acceptable for integer values. (e.g. 0 - exact match of 0. ..0 - less than or equal to 0. 0.. - more than or equal to 0. 0..1 - between 0 and 1, inclusive.)
Resultado
Não analisável se o argumento não for especificado corretamente
Nas seguintes condições, termina quando este subcomando não está no final da cadeia de subcomandos; falha quando no final:
  • Se target ou source for *.
  • Se o teste não passar.
Quando no final da cadeia de subcomandos, e o comando é bem sucedido, o valor de sucess e result é 1.

Exemplo

Mate todos os jogadores em pé sobre uma lã: execute as @a at @s if block ~ ~-1 ~ #wool run kill @s
Verifique se suas próprias pontuações A e B são iguais: execute if score @s A = @s B

Store subcomando

Armazena o valor result ou success do comando final em algum lugar. Ele é processado primeiro junto com outros subcomandos, gravando o local para armazenar. Após o último subcomando (pode ser um subcomando de condição ou um subcomando run) ser executado, os valores de retorno serão armazenados no local. Observe que os valores de retorno dos comandos devem ser um número inteiro. Se for decimal, é arredondado para baixo.

There are five different modes of storage:

  1. store (result|success) block – Store return value under one of a block's NBTs
  2. store (result|success) bossbar – Store return value as a bossbar data
  3. store (result|success) entity – Store return value under one of an entity's NBTs
  4. store (result|success) score – Store return value under a target's score on an objective
  5. store (result|success) storage – Store return value under one of a storage's NBTs

store (result|success) block

Salva o valor de retorno do comando final como dados de tag dentro de uma entidade de bloco. Armazenar como byte, short, int, long, float ou double. Se o valor de retorno for um decimal, ele será arredondado primeiro e depois multiplicado por <scale>.
Sintaxe
store (result|success) block <targetPos> <path> <type> <scale> -> execute
Argumentos
<targetPos>: block_pos
Posição do bloco de destino
<path>: nbt_path
Localização da tag desejada para manter o valor em
<type> : literal (byte|short|int|long|float|double)
Tamanho/tipo de dados desejado
<scale>: double
Multiplicador a ser aplicado antes de armazenar o valor
Resultado
Não analisável se o argumento não for especificado corretamente.
Não armazena nada quando o caminho não existe.

store (result|success) bossbar

Salva o valor de retorno do comando final no valor atual de uma bossbar ou em seu valor máximo
Sintaxe
store (result|success) bossbar <id> (value|max) -> execute
Argumentos
<id>: resource_location
ID da bossbar a ser direcionada para salvar
<value> : literal (value|max)
Se deve substituir o valor atual da bossbar ou seu valor máximo
Resultado
Não analisável se o argumento não for especificado corretamente.

store (result|success) entity

Salve o valor de retorno do comando final em uma das tags de dados de uma entidade. Armazenar como byte, short, int, long, float ou double. Se o valor de retorno for um decimal, ele será arredondado primeiro e depois multiplicado por <scale>. Como o comando "/data","/execute store <arguments>" não pode modificar o NBT do jogador.
Sintax
store (result|success) entity <target> <path> <type> <scale> -> execute
Argumentos
<target>: entity
Uma única entidade para armazenar sob
<path>: nbt_path
Localização da tag desejada para manter o valor em
<type> : literal (byte|short|int|long|float|double)
Tamanho/tipo de dados desejado
<scale>: double
Multiplicador para aplicar antes de armazenar valor
Resultado
Não analisável se o argumento não for especificado corretamente.
Não armazena nada quando o caminho não existe.

store (result|success) score

substitui a pontuação mantida por <targets> no <objective> fornecido pelo valor de retorno do comando final.
Sintaxe
store (result|success) score <targets> <objective> -> execute
Argumentos
<targets>: score_holder
Especifica os titulares de pontuação cuja pontuação deve ser substituída
<objective>: objective
Um objetivo de placar
Resultado
Não analisável se o argumento não for especificado corretamente.

store (result|success) storage

Usa o <path> dentro de armazenamento <target> para armazenar o valor de retorno. Armazene como byte, short, int, long, float ou double. Se o valor de retorno for um decimal, ele será arredondado primeiro e depois multiplicado por <scale>. Se o armazenamento ainda não existir, ele será criado.
Sintaxe
store (result|success) storage <target> <path> <type> <scale> -> execute
Argumentos
<target>: resource_location (Única palavra)
Contêiner de armazenamento de destino, como um local do recurso
<path>: nbt_path
Localização da tag desejada para manter o valor em
<type> : literal (byte|short|int|long|float|double)
Tipo/tamanho de dados desejado
<scale>: double
Multiplicador a ser aplicado antes de armazenar o valor
Resultado
Não analisável se o argumento não for especificado corretamente

Run subcomando

O único argumento do comando run é o comando a ser executado, cujas variáveis podem ser modificadas pelos subcomandos utilizados.

Sintaxe
run --><command>
Argumentos
<command>
Pode ser qualquer comando
Técnico
Redefine o nó de comando para a raiz do despachante de comando
Informações sobre comandos de modelagem como texto de bate-papo:
  • O command dispatcher é o que inicia quando o jogador inicia uma mensagem com uma barra (/).
  • Um nó de comando é a palavra/entrada específica que o cursor está editando, seja um comando ou um argumento.
  • O nó raiz vem antes da primeira palavra no comando atual.
Resultado
Execute este comando. Falha se <command> falhar.

Mais exemplos

  • Teleportar todos os jogadores que possuem um item encantado com Eficiência em seu primeiro slot de hotbar para as coordenadas (0, 64, 0):
    /execute as @a if data entity @s Inventory[{Slot:0b}].tag.Enchantments[{id:"minecraft:efficiency"}] run tp @s 0 64 0
  • Crie uma fumaça partícula três blocos na frente de todos os jogadores:
    /execute as @a at @s anchored eyes run particle smoke ^ ^ ^3
  • Coloque uma sela nos porcos localizados a 5 blocos do jogador executor e remova as selas dos porcos localizados a mais de 5 blocos do jogador executor:
    /execute as @e[type=pig] at @s store success entity @s Saddle byte 1 if entity @p[distance=..5]
  • Faça um jogador dizer "My feet are soaked!" no chat se estiverem localizados em um bloco de água:
    /execute as @a at @s if block ~ ~ ~ water run say "My feet are soaked!"
  • Faça um jogador dizer "Score is reset" no chat se a pontuação 'teste' não estiver definida, por exemplo, fazendo "scoreboard players reset @s test":
    /execute as @a unless score @s test = @s test run say "Score is reset"
  • Arremesse todos os porcos para o céu que estiverem a 3 quarteirões do jogador mais próximo:
    /execute at @p as @e[type=pig,distance=..3] run data merge entity @s {Motion:[0.0,2.0,0.0]}
  • Mate todos os zumbis que não têm capacete:
    /execute as @e[type=zombie] unless data entity @s ArmorItems[3].id run kill @s

Edição Bedrock

Sintaxe

execute <origin: target> <position: x y z> <command: command>
Uma sintaxe alternativa permite que o comando seja executado somente se um bloco específico for detectado:
execute <origin: target> <position: x y z> detect <detectPos: x y z> <block: Block> <data: int> <command: command>

Argumentos

origin: target

Especifica o destino para ser o executor do comando. Deve ser um nome de jogador ou seletor de alvo. Se mais de uma entidade for selecionada, o comando será executado uma vez como cada uma delas.

position: x y z

Especifica a posição a partir da qual executar o comando. As coordenadas especificadas com Notação de til e acento circunflexo são relativas ao alvo, não à posição de execução do comando.

command: command

Especifica o comando a ser executado. Deve ser um comando válido.

detectPos: x y z

Especifica a posição do bloco a ser verificado. Pode usar Notação de til e acento circunflexo para especificar distâncias relativas à posição: x y z.

block: Block

Especifica o ID do bloco que o bloco em detectPos deve corresponder para que o comando seja executado. Deve ser um ID de bloco válido.

data: int

Deve ser um dado de bloco válido para esse tipo de bloco ou -1 para corresponder a qualquer dado de bloco.

Resultado

Falha se os argumentos não forem especificados corretamente, se origin: target não resolver para uma ou mais entidades válidas (os jogadores nomeados devem estar online), se o bloco verificado não tiver o ID de bloco correto, os dados ou estado, ou se o comando especificado falhar.
Em caso de sucesso, executa o comando especificado como se fosse executado pelo(s) alvo(s) especificado(s), feito com permissão de nível operador na coordenada especificada.

Exemplos

  • Para invocar relâmpagos nas posições de cada zumbi:
    execute @e[type=zombie] ~ ~ ~ summon lightning_bolt
  • Para invocar relâmpagos nas posições de cada zumbi em qualquer tipo de areia:
    execute as @e[type=zombie] at @s if block ~ ~-1 ~ minecraft:sand run summon lightning_bolt
  • Para invocar 10 creepers na posição do jogador mais próximo (só funciona enquanto houver pelo menos 10 entidades no mundo carregado):
    execute @e[c=10] ~ ~ ~ execute @p ~ ~ ~ summon creeper ~ ~ ~
  • Para invocar o dragão ender na posição de outro jogador:
    execute @a[name=name_of_player] ~ ~ ~ summon ender_dragon

História

Edição Java
1.8 14w07a Adicionado /execute.
14w08a Comandos executados usando /execute agora passam seu valor de sucesso de volta para o bloco de comando que os executa.
1.11 16w32a Adicionado suporte a Estados de bloco para /execute.
1.13 17w45a A sintaxe de /execute foi dividida.
17w45b Refeita /execute store (result|success).
18w02a Adicionados novos subcomandos a /execute para permitir mais controle sobre os comandos.
18w05a Adiconado /execute store (result|success).
1.14 18w43a Adiconado /execute (if|unless) data.
1.15 19w38a Adiconado /execute if predicate <predicate>.
Adiconado /execute store storage.
Edição Pocket Alpha
v0.16.0 build 1 Adiconado /execute.
A funcionalidade é quase equivalente ao uso da Edição Java 1.10, exceto que o destino da entidade é opcional em /execute.
Advertisement