Minecraft Data Packs

Machine Translated by Google
Índice
1. Programação do Pacote de Dados do Minecraft: Introdução
2. Programação do Pacote de Dados do Minecraft: Sintaxe de
Comando 3. Programação do Pacote de Dados do Minecraft: Uso do Placar
Pacote de Dados do Minecraft
Programação: Introdução
Observação: este guia cobre especificamente a versão Java Edition do Minecraft. A Bedrock
Edition não usa pacotes de dados, mas fornece personalização por meio de complementos.
Os pacotes de dados construídos nesta série podem ser encontrados no

repositório unicorn enunciados/mc-datapacks-tutorial . Sinta-se à vontade para usá-lo como
referência ao ler esses artigos!
O que é um pacote de dados?
O sistema de pacote de dados do Minecraft permite que os jogadores modifiquem

fundamentalmente o comportamento existente do jogo "substituindo" ou adicionando a seus arquivos
de dados. Os pacotes de dados normalmente usam arquivos .mcfunction para especificar sua
funcionalidade como uma lista de comandos para o jogo executar e arquivos .json para escrever
avanços ou tabelas de pilhagem.
Uma coisa a observar: embora os pacotes de dados sejam simples de usar e permitam uma
grande quantidade de funcionalidades, eles têm algumas desvantagens. Uma delas é que,
embora os pacotes de dados permitam que a maioria dos recursos do jogo sejam alterados, eles
não permitem que os jogadores adicionem novos recursos ao jogo (embora alguns possam criar
essa ilusão de forma convincente com alguns truques).
Se você deseja adicionar novos controles ao jogo, integrar-se a serviços externos ou

fornecer uma interface de usuário complexa, uma estrutura de modding do Minecraft,
como Fabric ou Torneira pode ser melhor para você.
Vantagens dos mods do Minecraft
Pode se comunicar com serviços externos

Os mods podem executar solicitações HTTP, conversar com outros aplicativos ou usar
qualquer biblioteca compatível com o tempo de execução Java do Minecraft.
Capaz de modificar a interface do usuário e os menus de configurações
Alguns pacotes de dados usaram soluções inovadoras (e altamente complexas)

para isso usando texturas de itens modificados, mas, em geral, os controles e a
interface do usuário do Minecraft não podem ser alterados fundamentalmente sem o
uso de um mod.
Pode adicionar funcionalidades totalmente novas ao jogo
Embora os pacotes de dados possam adicionar coisas como mobs ou itens personalizados
por meio de algumas soluções alternativas, sempre há algumas limitações. Os mods podem
adicionar qualquer código ao jogo sem restrições de comportamento.
Mais desempenho do que pacotes de dados ao executar grandes operações
Obviamente, isso depende de quão bem sua funcionalidade é escrita, mas os mods podem
fornecer um desempenho muito melhor com multithreading, código assíncrono e acesso
geralmente mais rápido aos dados de que precisam.
Em comparação, os pacotes de dados são limitados pelo desempenho dos comandos
disponíveis para eles.
Vantagens dos pacotes de dados
Fácil de instalar em qualquer versão do Minecraft (Java Edition)
Os pacotes de dados são amplamente suportados em quase todos os inicializadores,

carregadores de mods e provedores de hospedagem do Minecraft. Em comparação, os
mods exigirão que os jogadores configurem uma instalação específica do Minecraft (como
Fabric ou Forge) antes de poderem ser usados.
Geralmente mais simples de testar e escrever

Embora algumas ferramentas de modding possam fornecer testes e depuração

bastante contínuos, todas elas exigem conhecimento de programação em Java e/ou
Kotlin, e pode ser tedioso configurar um ambiente de desenvolvimento para isso se você
ainda não tiver um. A maior parte do comportamento do pacote de dados pode ser
escrita em qualquer editor de texto e testada diretamente no chat de texto do seu jogo!
Mais seguro cometer erros com
Como os pacotes de dados são restritos à interação com os comandos fornecidos

pelo Minecraft, normalmente não é possível fazer nada que interrompa totalmente o
seu jogo. No entanto, os mods podem executar qualquer código arbitrário em seu
sistema - o que significa que há uma chance maior de que algo dê errado.
Normalmente, melhor compatibilidade de atualização
Embora alguns comandos mudem em novas atualizações do Minecraft, eu

(especialmente) descobri que as mudanças são menos impactantes do que o trabalho
necessário para atualizar os mods com novas versões. Como os mods geralmente usam
mixins e interagir diretamente com o código interno do Minecraft, eles podem ser afetados
por alterações ocultas que não fariam nenhuma diferença para um pacote de dados.
Resumo
Normalmente, prefiro escrever pacotes de dados para a maioria das coisas em que trabalho,
pois os considero mais úteis para um público mais amplo devido ao processo de instalação mais
fácil. Alguns jogadores simplesmente não querem o trabalho de configurar outra pasta de
instalação ou usar um carregador de Minecraft diferente para jogar com um mod específico, e os
pacotes de dados podem funcionar com quase qualquer combinação de outros mods e tecnologia
de servidor.
Com isso dito, os pacotes de dados podem certamente ser tediosos de escrever às vezes -
embora sejam mais fáceis de criar para funcionalidades simples que podem ser invocadas
diretamente por meio de comandos, um comportamento mais complexo pode ser melhor como um mod se
essas vantagens são mais atraentes. Nada é sem suas desvantagens, e qualquer escolha aqui
é válida.
Escrevendo nossa primeira

função do Minecraft
Os pacotes de dados fazem uso frequente de arquivos .mcfunction , que são arquivos de texto
que contêm uma lista de comandos para execução do Minecraft. Mas como sabemos quais
comandos escrever? Na verdade, podemos testá-los no Minecraft primeiro!
Vamos tentar criar um novo mundo Minecraft; Vou nomear o meu "teste" para que eu possa
encontrá-lo facilmente. Certifique-se de que a opção "Allow Cheats" esteja definida como "ON"
e pressione "Create World".
Se você pressionar "t" para abrir o chat de texto, digite "/s", uma lista de comandos deve
aparecer! Esta lista pode ser navegada com as setas "para cima" e "para baixo"
teclas e inclui todos os comandos do jogo. Se você começar a digitar um, ele deve solicitar
qualquer sintaxe adicional necessária. Se o comando ficar vermelho, significa que a sintaxe
é inválida.
Vamos tentar fazer uma lista de comandos que podem gerar alguns animais. Os
comandos abaixo devem funcionar quando digitados no chat de texto e convocarão a
entidade no mesmo local que o jogador.
concha /
invocarinvocar
ovelhavaca
2/ 1/
invocarinvocar
cabra 4porco
/invocar
3/
lhama 5
Agora vamos ver se podemos colocá-los em uma função!
Construindo uma estrutura de pasta de pacote de dados
Precisamos criar uma nova pasta para construir nosso pacote de dados — vou nomear o
meu como "1-introdução" para refletir o nome deste artigo. Em seguida, precisamos colocar
um arquivo "pack.mcmeta" dentro desta pasta para descrever nosso pacote.
json
12
3 { "pack":
{ "pack_format": 10,
"description": "Surge um bando de animais ao redor do 4º jogador" } 5 } 6
O "pack_format": 10 neste arquivo corresponde ao Minecraft 1.19; normalmente, o

formato muda a cada grande atualização, portanto, para versões mais recentes, pode ser
necessário aumentar esse número...
Versão Minecraft "pack_format" valor 1.19
"formato_pacote": 10
1.18.2
"formato_pacote": 9
1.18-1.18.1
"formato_pacote": 8
1.17-1.17.1
"formato_pacote": 7
Precisamos então criar uma série de pastas próximas a este arquivo, que devem ser
aninhadas uma dentro da outra da seguinte forma:
1 dados/fennifith/funções/animais/
Nesse caminho, a pasta fennifith/ pode ser chamada de namespace — isso deve ser
exclusivo para evitar possíveis conflitos se alguém tentar usar vários pacotes de dados de
uma só vez; se dois pacotes de dados usarem exatamente o mesmo nome de função, pelo
menos um deles não funcionará como esperado.
O namespace e a pasta animals/ podem ser renomeados como você quiser, mas as pastas
data/ e functions/ devem permanecer as mesmas para que o pacote de dados funcione.
Além disso, é importante que a pasta "funções" esteja exatamente um nível abaixo da pasta
"dados". Por exemplo, data/functions/ ou data/a/b/functions/ não seriam estruturas válidas.
Finalmente, devemos criar nosso arquivo .mcfunction nesta pasta. Vou nomear minha
função spawn.mc:
concha
12 convocar vaca
convocar ovelhas
3 invocar porco
4 invocar cabra
5 invocar lhama
Observe que, embora seja necessário um / anterior para digitar esses comandos no chat de
texto, ele não deve ser incluído no arquivo .mcfunction .
Agora devemos ter nosso pacote de dados organizado da seguinte forma:
shell 1
1-introdução/ pack.mcmeta
4 5 funções/
2 3 dados/
animais/
fennifith/
67
spawn.mcfunção
Instalando e testando o pacote de dados
Para transformar esta pasta em um pacote de dados, basta converter a pasta "1-
introdução" em um arquivo zip.
janelas
Isso pode ser feito mantendo pressionada a tecla Shift e selecionando os arquivos
pack.mcmeta e data/ no explorador de arquivos. Em seguida, clique com o botão direito do
mouse e escolha "Enviar para > Pasta compactada (zipada)".
Isso deve criar um arquivo zip no mesmo local - você pode querer renomeá-lo para o nome
do seu pacote de dados. Clique com o botão direito do mouse e copie-o para que possamos
movê-lo para o mundo do Minecraft!
Para encontrar a localização do seu mundo salvo, abra o Minecraft e encontre o mundo
de "teste" que criamos anteriormente. Clique nele, escolha a opção "Editar" e "Abrir pasta do
mundo".
Na janela do Explorer que se abre, entre na pasta "datapacks". Clique com o botão direito e
cole o arquivo zip aqui.
Mac OS
Isso pode ser feito abrindo seu pacote de dados no Finder e selecionando pack.mcmeta
e data/ arquivos. Clique com a tecla Control pressionada ou toque nos arquivos
selecionados usando dois dedos e escolha "Compactar" no menu de opções.
Agora você deve ter um arquivo chamado "Archive.zip" — você pode querer renomeá-
lo para o nome do seu pacote de dados. Em seguida, copie este arquivo para que
possamos movê-lo para o mundo do Minecraft!
Para encontrar a localização do seu mundo salvo, abra o Minecraft e encontre o

mundo de "teste" que criamos anteriormente. Clique nele, escolha a opção "Editar" e
"Abrir pasta do mundo".
Na janela do Finder que se abre, entre na pasta "datapacks" e cole o arquivo zip dentro
dela.
Linux
Isso pode ser feito usando o comando zip em seu terminal. Depois de fazer o cd na pasta do
pacote de dados, execute o comando abaixo para criar um arquivo zip.
shell
-r 1-introduction.zip
cd 1-introduction/
./*1 2 zip
Então, assumindo que você nomeou seu mundo como "testing", o comando ls
~/.minecraft/saves/testing deve listar os arquivos salvos desse mundo. Execute mv ./1-
introduction.zip ~/.minecraft/saves/testing/datapacks/ para mover o arquivo zip para a
pasta de pacotes de dados do mundo.
Agora que instalamos o pacote de dados, você poderá entrar no world save novamente
(ou usar o comando /reload se ainda o tiver aberto).
Mas nada acontece!
Isso porque, embora nossa função exista, ela não está conectada a nenhum evento do
jogo — ainda precisamos digitar um comando para realmente executá-la. Veja como deve ser
o comando para minha função:
shell
1 /função fennifith:animais/spawn
Se você não usou os mesmos nomes de pasta, o preenchimento automático deve

ajudá-lo a descobrir o nome de sua função. Depois de executar este comando, se você vir
todos os seus animais aparecerem, você tem um pacote de dados funcionando!
Especificando uma tag de função
Para executar uma função automaticamente, o Minecraft fornece duas tags de função
integradas que rodam durante eventos específicos: load (quando o mundo é aberto) e
tick (cada tick do jogo).
Usando o evento "load"

Começaremos com load — para o qual precisaremos criar dois novos arquivos em nossa
estrutura de pastas! Abaixo, estou criando uma nova função load.mc ao lado de nossa
função anterior e um arquivo minecraft/tags/functions/load.json para a tag load .
shell
pack.mcmeta
1-introdução/
data/1 23 4
minecraft/ tags/ 5 6
funções/ load.json
7 8 fennifith/
funções/
9 animais/
10 load.mcfunction
11 12 spawn.mcfunction
Observe que, enquanto estou usando o namespace fennifith/ para minhas funções, o
arquivo de tag fica sob o namespace minecraft/ . Isso ajuda a manter alguns dados
isolados do restante do jogo — quaisquer arquivos na pasta minecraft/ modificam a
funcionalidade do Minecraft, enquanto qualquer coisa em um namespace diferente cria
algo que pertence ao meu pacote de dados.
Dentro do load.json, podemos adicionar um array JSON que contém o nome da nossa
função load da seguinte forma:
json
12
3 { "valores": ["fennifith:animais/carga"] }
Em load.mcfunction, escreverei apenas um comando para teste:
shell
dizer Olá, mundo! 1
Testando o evento "load"

Se você repetir as etapas para instalar o pacote de dados agora, deverá ver a mensagem
"Hello, world" na janela de bate-papo! Você pode modificar esta mensagem para exibir
informações sobre seu pacote de dados ou explicar como usá-lo.
Para invocar a tag "load" manualmente, você pode usar o comando /reload ou
digitar /function #minecraft:load (observe o símbolo # usado para especificar a tag).
E o evento "tick"...
Esteja ciente de que ao usar o evento tick, é muito fácil fazer coisas que causam
enormes quantidades de lag em seu jogo. Por exemplo, conectar isso à nossa função
spawn.mc anterior pode ter algumas consequências adversas ao convocar
aproximadamente 100 animais por segundo.
Agora, e se tentarmos adicionar um arquivo para o evento tick com o mesmo conteúdo?
Poderíamos adicionar um arquivo tick.json apontando para uma função fennifith:animals/
tick — e escrever um arquivo tick.mcfunction para que ele seja executado.
A janela de bate-papo se enche de mensagens "Olá, mundo"! Toda vez que a tag de
função tick é invocada (o jogo normalmente roda 20 ticks por segundo), ela adiciona uma nova
mensagem! Isso provavelmente não é algo que queremos fazer.
Poderia haver uma maneira de verificar algum tipo de condição antes de executar nossos
comandos? Por exemplo, se quisermos executar nosso comando say quando o jogador
estiver em um bloco específico...
Tente experimentar! Veja se você consegue encontrar um comando que faça isso — e
confira a próxima postagem desta série para a solução!
Conclusão
Se o seu pacote de dados não funcionou primeiro, tente - não se preocupe! Há muitas
etapas aqui, e o menor erro de digitação ou extravio fará com que o Minecraft ignore
completamente seu código. Se você está preso e não consegue encontrar o problema, a
discórdia Unicorn Utterances é um ótimo lugar para pedir ajuda!
Até agora, cobrimos os fundamentos dos pacotes de dados e como escrevê-los — mas há
muito mais para abordar. Em seguida, começaremos a escrever comportamento condicional
usando posições de bloco e seletores de entidade!
Programação: Sintaxe de Comando
Observação: este guia cobre especificamente a versão Java Edition do Minecraft. A

Bedrock Edition não usa pacotes de dados, mas fornece personalização por meio de
complementos.

Uma nota sobre ferramentas
Neste ponto, estamos começando a escrever comportamentos mais complexos em

nossos pacotes de dados e pode ser útil ter algumas ferramentas para verificar se
nossos comandos são válidos enquanto os escrevemos.
Eu uso o Visual Studio Code editor com a função language-mc extension by Arcensoth, que
fornece realce de sintaxe e preenchimento automático para meus comandos diretamente no
editor de texto. No entanto, existem muitas extensões semelhantes com recursos diferentes,
e outros editores de texto provavelmente também têm seus próprios plug-ins para fornecer
esse comportamento.
Lógica condicional com o comando

"/execute"
No post anterior, terminamos com uma questão interessante — como escrevemos um

comando que só é executado se o jogador estiver em um determinado bloco?
Bem, o Minecraft realmente tem um comando específico para verificar as pré-

condições e outros atributos de um comando antes de executá-lo - o /execute
comando!
Este comando pode ser usado com um número indefinido de argumentos, o que
pode torná-lo confuso ao ler sua documentação — mas isso significa efetivamente
que você pode adicionar qualquer número de pré-condições a este comando.
Por exemplo:
shell
executar if block ~ ~ ~ air run diga "Você está parado em 1 ar!"
Isso usa dois subcomandos do comando execute : if block ~ ~ ~ air verifica se o

identificador de bloco no local do jogador é minecraft:air e run diz "Você está parado
no ar!" invocará o comando say se as condições anteriores tiverem passado.
Tente executar este comando no Minecraft! Contanto que você esteja em um

bloco de ar, você verá sua mensagem aparecer no chat. Se você ficar debaixo
d'água ou em qualquer bloco que não seja ar (como arbustos/folhagem), ele deve
parar de executar.
Parado no ar Parado na água

Se quisermos negar essa condição, podemos substituir o subcomando if por

except — isso imprimirá sua mensagem enquanto o jogador não estiver parado
no ar.
shell
parado
executar
no ar!"
a menos que o bloco ~ ~ ~ air run diga "Você não está 1
Você também pode alterar o identificador de bloco para procurar um tipo diferente
de bloco. Por exemplo, se o bloco ~ ~ ~ água garantiria que o jogador estivesse
na água.
Sintaxe da posição
Então, o que os tils (~ ~ ~) significam no comando anterior? Isso se refere à
posição atual (nos eixos X, Y e Z) do jogador que está executando o comando.
Existem algumas maneiras diferentes de escrever posições como essas no Minecraft,
que explicarei aqui:
Coordenadas absolutas
As coordenadas podem ser escritas como uma posição fixa no mundo -

digamos, 32 60 -94 (essas coordenadas podem ser obtidas abrindo a tela de
depuração F3 e encontrar a posição "Bloco direcionado".
Coordenadas atuais (notação til)
Usar os símbolos de til (~ ~ ~) fará referência à posição atual em que o comando

é executado. Isso também pode ser misturado com valores estáticos, como 32
~ -94, que farão referência ao bloco em (x: 32, z: -94) usando o eixo y atual do
jogador.
Coordenadas relativas
Essas posições também podem ser compensadas por um certo número de blocos
em qualquer direção, adicionando um número após o til. Por exemplo, ~2 ~-4 ~3
moverá 2 blocos horizontalmente a partir do eixo x do jogador, 4 blocos para
baixo no eixo y e 3 blocos horizontalmente no eixo z.
Coordenadas direcionais (notação de circunflexo)
Semelhante às coordenadas relativas, as coordenadas direcionais (^ ^ ^)

começarão de onde o comando for executado. No entanto, quaisquer
deslocamentos serão aplicados em relação a onde quer que o jogador ou
entidade atual esteja olhando. Por exemplo, ^2 ^-4 ^3 moverá 2 blocos para a
esquerda do jogador, 4 blocos para baixo e 3 blocos na frente da direção que o
jogador enfrenta.
Para experimentar a sintaxe de posição e ver onde certas posições terminam no

mundo, podemos adicionar coordenadas ao comando /summon para gerar entidades
em um local específico. /summon pig ~ ~ ~ usaria a posição atual do jogador (seu
comportamento padrão), enquanto /summon pig ~ ~-4 ~ provavelmente geraria o porco
no subsolo. Se você gerar muitos porcos, você pode usar /kill @e[type=pig] para
removê-los.
Uma observação importante ao usar essas posições: para os jogadores (e para a

maioria das outras entidades), todas as posições começarão nos pés do jogador. Se
quisermos começar na cabeça do jogador, podemos usar o subcomando de olhos
ancorados para corrigir isso — usando coordenadas direcionais, /execute olhos
ancorados correr convocar porco ^ ^ ^4 deve invocar um porco 4 quarteirões à frente no
centro exato de onde quer que o jogador está olhando.
Posições em um subcomando "/execute"
Nas seções a seguir, pode ser útil ter em mente que todo comando tem um
contexto específico no qual é executado. Esse contexto consiste em uma
posição no mundo e uma entidade selecionada que executa o comando.
Quando você digita um comando no chat de texto do Minecraft, a posição é a
sua localização atual no mundo e a entidade selecionada é o seu jogador.
Esse contexto afeta a quais blocos, locais e entidades determinados

comandos e sintaxe farão referência. O comando /execute pode alterar
esse contexto para qualquer comando que ele execute, que é o que você
verá no exemplo a seguir...
O comando /execute também possui um subcomando que pode mudar sua

localização no mundo: posicionada ~ ~ ~. Usando isso, podemos reescrever
nosso comando anterior:
shell
ancorados
executarposicionados
olhos ancorados
^ ^ ^4executar
executarinvocar
convocar
porco
porco
^^~^421 executar olhos
~~
Esses dois comandos fazem a mesma coisa! Quando usamos o ^ ^ ^4

posicionado, estamos movendo a localização do nosso comando para essas
coordenadas. Nosso comando summon pig então usa sua posição atual
~, que
emestá
~~
no local para o qual o movemos.
Usando "/execute" com funções
Se você se lembra da função que criamos no capítulo anterior, acabamos fazendo

um único comando (/function fennifith:animals/spawn) que gera vários animais
de uma só vez.
Se usarmos /execute para definir a posição dessa função antes de ser

executada, isso também afetará a localização de cada comando nessa função.
shell 1
execute os olhos ancorados posicionados ^ ^ ^ 4 execute a função fennifith:animals/spawn
Como nossa função de spawn convoca todos os animais em suas

coordenadas atuais, podemos usar o comando /execute para mudar essa posição!
Este comando agora deve gerar todos os animais na frente do jogador, em vez
de diretamente em cima deles.
Alinhamento da grade de coordenadas
Para alinhar uma posição com a borda de um bloco, podemos usar outro
subcomando: /execute align xyz. Isso alinhará a posição do comando nos eixos
X, Y e Z. Você também pode omitir quaisquer eixos que não precisem de alinhamento,
portanto, alinhar x ou alinhar xz também funcionaria conforme o esperado.
Podemos usar isso para garantir que uma entidade convocada seja sempre
gerada em alinhamento com a grade do bloco e não entre as coordenadas do
bloco:
shell
1 executar alinhar xz executar convocar porco ~ ~ ~
No entanto, uma coisa importante a observar sobre o sistema de coordenadas do

Minecraft é que os números inteiros não se referem ao centro de um bloco. Em
vez disso, eles são alinhados com o canto inferior na direção negativa de cada eixo.
Isso significa que, se você convocar uma entidade em 0 ~ 0, ela acabará no canto
do bloco em (0, 0). Para corrigir isso, você precisará corrigir o deslocamento
movendo-o 0,5 em cada eixo; ou seja, 0,5 ~ 0,5.
(0, 0)
(0,5, 0,5)
Assim, para invocar uma entidade no centro de um bloco, podemos utilizar

este comando:
shell
1 execute align xz run summon pig ~0.5 ~ ~0.5
Seletores de entidade
Então descobrimos como usar a posição do jogador, mas como podemos nos referir a
outras entidades no mundo? Se você prestou atenção ao /kill
Comando @e[type=pig] anterior, na verdade, está usando um seletor de entidade para

referenciar todos os porcos do mundo. Estamos usando a variável @e (todas as entidades do mundo) e
filtrando-a por type=pig para selecionar apenas as entidades que são porcos.
Aqui está uma lista de algumas outras variáveis de seletor que podemos usar:
@p tem como alvo apenas o jogador mais próximo da execução do comando @a

tem como alvo todos os jogadores do mundo (útil para servidores/reinos multijogador) @e
tem como alvo todos os jogadores, animais e entidades do mundo @s tem como alvo
apenas a entidade que executou o comando
E aqui estão algumas das maneiras pelas quais podemos aplicar os atributos de filtro:
[type=player] seleciona o tipo de entidade (porco, vaca, item_frame, etc.)

[gamemode=survival] pode selecionar jogadores em um modo de jogo
específico (criativo, espectador, etc.) [limit=1] restringirá o número total
de entidades que podem ser selecionadas pelo seletor [sort=nearest] afetará
a ordem das entidades selecionadas (mais distante, aleatória, arbitrária)
Usando esses seletores, podemos usar @e[type=pig,sort=nearest,limit=3] para referenciar os três porcos
mais próximos do jogador que executa o comando.
E se usarmos /kill @a[type=pig]? Isso não selecionará nada — porque @a seleciona apenas
as entidades do jogador . Da mesma forma, @s[type=pig] também não selecionará nada, porque
@s se refere à entidade que executa o comando — que é você, uma entidade de type=player.
Entidades em um subcomando "/execute"

Assim como /execute posicionado <x> <y> <z> pode ser usado para definir a posição do comando
que executa, o subcomando /execute as <entity> pode ser usado para definir a entidade que executa o
comando. Isso efetivamente
altere a entidade a que @s se refere em tudo o que executa. Vamos usar isso com
nosso comando /kill @e[type=pig] !
shell 1
kill @e[type=pig] execute
como @e[type=pig] execute kill @s 2
Uma observação importante sobre como esse recurso funciona é que, após
o subcomando as @a[type=pig] , ele executará os subcomandos a seguir
uma vez para cada entidade selecionada. Isso significa que ele está
executando individualmente kill @s uma vez para cada entidade do tipo=porco.
Posições de entidade em um subcomando "/execute"

Então, poderíamos usar isso com nosso comando if block ~ ~ ~ air anterior para
selecionar apenas as entidades suínas que estão em um bloco de ar... mas isso pode
não funcionar como esperávamos.
shell
executar como @e[type=pig] if block ~ ~ ~ air run kill @s 1
Você notará que isso está realmente afetando todos os porcos do mundo... a menos
que você fique debaixo d'água ou em um bloco de folhagem, caso em que não fará
nada. Isso ocorre porque, embora o comando as <entity> altere a entidade em
execução, ele não afeta a posição de execução do comando — ele ainda está em
execução no seu local.
Embora possamos usar posições relativas com o subcomando position ~

~ ~ , você notará que não há como se referir a uma entidade selecionada nesta
sintaxe... é por isso que precisaremos usar o at <entity> subcomando em vez
disso!
shell
executar como @e[type=pig] em @s if block ~ ~ ~ air run 1 kill @s
Este comando primeiro seleciona todas as entidades @e[type=pig] , então - para cada
porco - muda a posição do comando para a posição de @s (a entidade selecionada).
Como resultado, a posição em ~ ~ ~ agora se refere à posição de @s.
Isso também pode ser usado com funções, como antes! No entanto, vou adicionar um
limit=5 ao nosso seletor de entidade aqui — caso contrário, ele pode gerar um número
crescente de entidades cada vez que for executado, o que pode causar lag em seu jogo se
executado repetidamente.
shell
fennifith:animals/spawn
execute como @e[type=pig,limit=5] em @s run function 1
Filtrando entidades por posição

Além dos atributos de filtro que discutimos anteriormente, os atributos [distance=
<range>] e [x=<number>,dx=<number>] podem ser usados para selecionar entidades com
base em sua localização no mundo.
Aqui estão alguns exemplos disso em uso:
seleção de raio
Com o atributo [distance=<range>] , as entidades serão selecionadas se estiverem dentro

de um raio específico de uma posição. No entanto, para que funcione conforme o esperado,
o valor precisa ser um intervalo, não um número. Por exemplo, [distance=6] selecionará
apenas entidades a uma distância de exatamente 6 quarteirões de distância.
Os intervalos podem ser especificados colocando dois pontos (..) como o intervalo entre
dois números. Se um dos lados for deixado de fora, o intervalo será interpretado como
aberto e aceitará qualquer número nessa direção. Por si só, .. é um intervalo que inclui
todos os números, 5.. aceita qualquer número acima de 5, ..5 aceita qualquer número
abaixo de 5 e 1..5 aceita qualquer número entre 1 e 5.
@e[distância=..5] @e[distância=5..] @e[distância=2..5]

@e[distância=..5] @e[distância=5..] @e[distância=2..5]
r=5 r=5 r=5
Seleção de área
Os atributos [x=], [y=] e [z=] filtrarão as entidades por sua posição exata. No
entanto, como as entidades podem se mover para posições entre os blocos, suas
coordenadas geralmente não são números inteiros — portanto, é improvável que
esses filtros por si só selecionem quaisquer entidades.
No entanto, esses atributos podem ser combinados com [dx=], [dy=] e [dz=] para
selecionar uma faixa de valores nos eixos X, Y e Z. Por exemplo, [y=10,dy=20]
irá filtrar qualquer entidade com uma posição entre Y=10 e Y=30.
O uso de todos esses atributos juntos pode criar uma área de caixa para pesquisar
entidades dentro dela. Por exemplo, @e[x=1,y=2,z=3,dx=10,dy=20,dz=30] está
efetivamente criando uma caixa com 10 blocos de largura, 20 blocos de altura, 30 blocos
de profundidade, começando na posição (1, 2, 3).
@e[x=5,z=1] @e[x=5,dx=10] @e[x=5,z=1,dx=10,dz=5]

@e[x=5,z=1] @e[x=5,dx=10] @e[x=5,z=1,dx=10,dz=5]
(15, 6)
(5, 1)
x=5 x=15
(5, 1)
Desafio: Usar "/execute" em

nossa função tick.mc
No post anterior, conseguimos nosso pacote de dados para imprimir uma mensagem a cada
tick do jogo. Vamos tentar mudar isso - veja se você pode escrever um comando que
verifique o bloco abaixo do jogador para ver se é ar. Se o bloco embaixo do jogador for ar,
provavelmente ele está caindo, então vamos imprimir "aaaaaaaaaaaaaaaaaaaaa" no chat
de texto.
Precisa de uma dica?
Solução
Observação: se você usar os subcomandos as e at juntos, saiba que ambos executarão

quaisquer subcomandos consecutivos para cada entidade que selecionarem. Então ,
como @a em @a, em um servidor multijogador, primeiro selecionará cada entidade de
jogador, então (para cada entidade de jogador) será executado na posição de cada entidade
de jogador. Se n = o número de jogadores, isso resultará na execução do comando n*n
vezes no total.
Você pode tentar isso com @e[type=pig] para ver quantas vezes ele imprime:
Concha
1 # Este comando imprimirá muito mais mensagens do que o

número de porcos em seu mundo.
2 execute como @e[type=pig] em @e[type=pig] execute diga oi
Conclusão
Até agora, começamos a usar a lógica condicional e cobrimos a maior parte da sintaxe que
você verá nos comandos do Minecraft.
Entre os artigos, sinta-se à vontade para experimentar outros comandos, como /

setblock ou /playsound. A maioria deles não será mencionada diretamente no restante
desta série, portanto, será útil ler esta lista para descobrir o que cada comando pode fazer.
Na próxima postagem, abordaremos um recurso totalmente diferente do Minecraft:

placares de jogadores! Isso nos permitirá manter a contagem de diferentes variáveis,
detectar certas ações no jogo e armazenar um estado específico ou global do jogador
em nossos pacotes de dados.
Programação: uso do placar

Observação: este guia cobre especificamente a versão Java Edition do Minecraft. A
Bedrock Edition não usa pacotes de dados, mas fornece personalização por meio de
complementos.

Anteriormente, esta série abordou a estrutura de um pacote de dados, instruções condicionais

e outras sintaxes de comando. Este artigo será construído em cima disso para cobrir placares,
o que nos permite acompanhar as informações do jogador e armazenar variáveis em nossos
programas.
Armazenando pontuações
Em muitos pacotes de dados, você pode encontrar a necessidade de armazenar informações

que não podem ser acessadas diretamente por meio de uma entidade ou outro comando. Uma
forma comum de fazer isso é através do uso de placares, que podem armazenar uma tabela de
números para cada entidade ou jogador. Eles podem ser usados para fazer referência às
estatísticas do jogador, como o número de blocos minerados ou acompanhar valores arbitrários
em seu código.
Criando um placar
Podemos usar os subcomandos de objetivos /scoreboard para criar e modificar placares em
um mundo. Vamos tentar fazer um placar para rastrear o número de animais que cada
jogador gerou por meio de nosso pacote de dados.
Concha
objetivos do placar adicionar fennifith.animals_spawned 1 manequim
Isso cria um objetivo chamado fennifith.animals_spawned que está conectado à

estatística do jogo fictício . Falaremos sobre outras estatísticas mais tarde, mas a estatística
fictícia efetivamente significa que o placar só será modificado se você mesmo definir seus
valores.
O que é um objetivo?
A nomenclatura de "objetivo" e "placar" pode ser um ponto de confusão. Neste artigo, para
simplificar, eles podem ser considerados como dois nomes para a mesma coisa — mesmo
que tenham significados ligeiramente diferentes.
De um modo geral, um "objetivo" é uma relação entre um conjunto de pontuações e uma

estatística. Aqui, o nome do objetivo é fennifith.animals_spawned e a estatística é dummy. O
objetivo contém suas pontuações para cada jogador na forma de um placar.
Convenções do placar
Nomes de objetivos com namespace
Os jogadores geralmente desejam ter vários pacotes de dados instalados em seu mundo
ao mesmo tempo. Como todos os placares operam globalmente no mundo, precisamos
garantir que os nomes de nossos placares não entrem em conflito com nenhum placar usado
por outros pacotes de dados.
Por exemplo, o que pode acontecer se dois pacotes de dados quiserem rastrear blocos
diferentes que o jogador extraiu? O primeiro pode criar um placar para blocksMined que
rastreia pedra, enquanto o segundo pode usar blocksMined para rastrear sujeira. No entanto,
ambos os pacotes de dados farão referência ao mesmo placar de blocksMined no mundo, o
que pode acabar rastreando tanto a pedra quanto a terra, misturando o comportamento de
ambos. Precisamos de uma maneira de separar as pontuações desses pacotes de dados e
evitar que entrem em conflito.
Para fazer isso, é comum "espaçar" os nomes do placar em seu pacote de dados
adicionando um determinado prefixo. Aqui, comecei meus nomes de placar com
fennifith.animals para indicar que eles pertencem ao meu pacote de dados.
Criando e removendo placares
Normalmente, você desejará criar quaisquer placares de que precisa

em uma função load.mcfunction , conectada à tag de função #minecraft:load .
Alguns pacotes de dados criam adicionalmente um arquivo uninstall.mcfunction ,

não conectado a nenhuma marca de função, que pode ser executado para remover todos
os objetivos do placar do pacote de dados. Isso é útil quando um jogador deseja remover
seu pacote de dados de seu mundo sem deixar nenhum de seus comportamentos para
trás.
Definindo valores
Podemos definir valores de um placar usando os subcomandos /scoreboard

players . A maioria desses subcomandos aceita dois argumentos para que o <seletor>
e o <objetivo> da pontuação sejam alterados. Por exemplo, o comando a seguir
definirá nossa entrada na tabela fennifith.animals_spawned como 1.
shell #
jogador
definir
atualnossa
("fennifith")
entrada2 de
# | placar
| modifique
1 # | use
o placar
a entrada
chamado
do
@s fennifith.animals_spawned
3 "fennifith.animals_spawned"
1 Entrada
# | |fennifith.animals_spawned
defina "1" como o valor destafennifith
entrada1 # | | jogadores do placar definidos
4
5 || |
6
Se quisermos adicionar a esse valor, podemos usar o subcomando de adição de

jogadores do placar . Da mesma forma, a remoção dos jogadores do placar irá subtrair
um valor do nosso placar.
shell #
do jogador
adiciona
atual
um2 número
# | | useao
"2"valor
comoatual
número
do placar
para somar
1 # | use
3 #a| entrada
|4
5 Entrada
jogadores
fennifith.animals_spawned
do placar adicionam @sfennifith
3 2
Nota: Tenha cuidado com a diferença entre /scoreboard objectivos add e /scoreboard
players add, pois eles são fáceis de confundir - eu até os confundi algumas vezes
enquanto escrevia este artigo! Os subcomandos de objetivos são usados
exclusivamente para criar ou remover placares inteiros, enquanto os subcomandos
dos jogadores podem modificar entradas específicas em placares existentes para
alterar seus valores.
objetivos adicionar significa "adicionar um novo placar", enquanto os jogadores

adicionam está aumentando o valor de uma entrada do placar em um determinado número.
Usando entradas globais
Em certos casos, queremos armazenar valores que não sejam específicos do jogador,
mas que afetem todo o nosso pacote de dados. Por exemplo, podemos querer rastrear o
número total de animais gerados em nosso mundo, além do número de animais de cada
jogador.
Podemos fazer isso referenciando um jogador inexistente. O placar incluirá uma entrada
para qualquer entidade ou nome, independentemente de ele realmente existir em nosso
mundo — portanto, usando um nome que nunca existirá, podemos referenciá-lo
globalmente de qualquer lugar em nosso código.
jogadores de placar shell definir $ global fennifith.animals_spawned 1

4Entrada fennifith.animals_spawned
fennifith 3
$global 4
Esse truque funciona porque $ não é um personagem que os jogadores do Minecraft

possam registrar em seu nome de usuário. Dessa forma, podemos garantir que a entrada
$global nunca seja usada por nenhum jogador ou entidade real no mundo.
Se não incluíssemos o $ antes do nome da variável neste trecho, nosso código ainda
funcionaria! No entanto, o que aconteceria se um jogador registrasse o nome de usuário global
e tentasse usar nosso pacote de dados? A pontuação deles usaria a mesma entrada que
nossa variável global e ambos tentariam armazenar seus valores no mesmo lugar — fazendo
com que qualquer lógica que escrevêssemos parecesse quebrada.
Como o $ é um caractere de nome de usuário inválido, podemos usá-lo com segurança para
valores globais sem essa possibilidade.
Usando o subcomando "/execute store"

Cada comando do Minecraft fornece um valor de "sucesso" e um "resultado" que especifica
se o comando foi bem-sucedido - e, em caso afirmativo, qual valor ele retornou.
O subcomando execute store pode ser usado para designar um local para armazenar esses
valores, como uma entrada no placar.
Por exemplo, este comando irá copiar o valor da nossa variável $global para $global_2...
shell #
coloque-o
armazena
em "$global_2"
o resultado
# do
|34comando
# | executar
1 2 #loja
|
resultado pontuação $global_2 5
fennifith.animals_spawned executar placar
Entradajogadores
| execute
obter um
$global
comando
quefennifith
retorne3o valor de "$global" |
|
$global 4
$global_2 4
Embora este exemplo copie com sucesso nossa variável $global para $global_2,
há uma maneira um pouco mais curta de conseguir isso usando
operações de placar...
Pode nem sempre ser óbvio qual valor um comando retorna como seu
"resultado", já que às vezes é diferente do que é impresso no chat do jogo.
No entanto, todos os comandos podem ser consultados no wiki do Minecraft para ver
quais valores e comportamento eles devem fornecer.
Operações do placar
Se quisermos definir um valor de placar com base em outra entrada, podemos usar o
subcomando de operação de jogadores de placar para especificar um estado conceitual
de existência entre os dois valores.
Por exemplo, para tornar nossa entrada $global nos exemplos anteriores igual à entrada
fennifith , podemos usar o seguinte comando:
shell 1
# escreve o resultado *na* entrada $global # | definir os placares
placariguais
jogadores
entreoperação
si 2 3 # | |$global
obtenhafennifith.animals_spawned
o valor *de* @s # | | 4 5 =
@s fennifith.animals_spawned
fennifith 3 Entrada fennifith.animals_spawned
|
$global 3
$global_2 4
operações matemáticas
Também podemos substituir a operação = por outras operações matemáticas que

podem ser executadas na entrada do placar.
Por exemplo, para adicionar a entrada @s a $global:
shell #
valor existente
grava o resultado
2 *na* entrada $global 1 # | adicionar ao
3 #| | obter o valor *de* @s |

4 #| |
5 placar jogadores operação $global
fennifith.animals_spawned += @s fennifith.animals_spawned Entrada
fennifith.animals_spawned fennifith 3
$global 6
$global_2 4
O subcomando de operação só é executado nas entradas do placar, portanto,

não podemos passar valores constantes para ele. scoreboard players operation
$global fennifith.animals_spawned /= 2 infelizmente não é um comando que o
jogo irá rodar.
Se quisermos dividir nossa entrada $global por dois, primeiro precisamos

escrever o valor do divisor em outro placar temporário.
shell #
placardefina
definem
a variável
$ divisor
"$2divisor"
para "2" 1 jogadores2do
3 # divide a entrada "$global" por "$divisor" (2) placar jogadores

4 operação $global
fennifith.animals_spawned /= $ divisor
fennifith.animals_spawned Entrada
fennifith.animals_spawned fennifith 3
$divisor 2
$global 3
$global_2 4
Isso resulta em $global, que anteriormente era 6, sendo dividido por 2 — como
tal, seu valor agora é 3.
Aqui está uma lista de todas as outras operações que podem ser executadas
com este comando. lhs denota o lado esquerdo da operação (a entrada do
placar sendo gravada), enquanto rhs denota o lado direito.
= define lhs para o valor de rhs

+= adiciona rhs a lhs

-= subtrai rhs de lhs *= multiplica
lhs por rhs /= divide lhs por rhs
%= define lhs para o restante
de lhs / rhs < define lhs para rhs somente se rhs for
menor > define lhs para rhs somente se rhs for
maior >< troca os valores de lhs e rhs
Embora ambos os lados dessas operações aceitem seletores de entidade, apenas

lhs pode se referir a várias entidades. Por exemplo, @e[type=pig] pode ser usado
para definir os placares de cada entidade suína do jogo.
Em rhs, pode ser necessário adicionar um atributo limit=1 para limitar o número de
entidades que ele pode selecionar.
Exibindo pontuações
Para ver quais pontuações são aplicadas a qualquer entidade, existem alguns
métodos de exibição dos valores do placar para os jogadores.
Exibição no jogo
O subcomando setdisplay dos objetivos /scoreboard pode ser usado para definir um placar
específico a ser exibido em parte da IU. Por exemplo, /scoreboard objetivos setdisplay sidebar
fennifith.animals_spawned mostrará todos os jogadores e o número de animais que eles
geraram em uma barra lateral à direita da tela.
Mais áreas além da barra lateral incluem:
lista, que mostra as pontuações ao lado dos nomes dos jogadores no menu de guias (em
Multijogador apenas)
abaixoNome, que exibe a pontuação de um jogador abaixo de sua etiqueta de nome
Barra Lateral Lista abaixo do nome

Barra Lateral Lista abaixo do nome
comando /tellraw
O comando /tellraw pode ser usado para enviar uma mensagem formatada no chat do
jogo. Possui uma ampla variedade de usos e opções de formatação, uma das quais
pode incorporar um valor de placar na mensagem impressa.
/tellraw aceita uma matriz de argumentos que concatena para formar sua mensagem.
Para referenciar uma pontuação neste array, podemos escrever um elemento com a
estrutura {"score":{"name":"<selector>","objective":" <objective>"}}. Por exemplo, aqui está
um comando que imprime o número de animais que o jogador (@s) gerou:
shell
tellraw @s ["Você convocou ",{"pontuação": 1
{"name":"@s","objective":"fennifith.animals_spawned"}}," animais!"]
Condições com valores do placar
E se tivermos um comando que só queremos executar se o jogador tiver uma

determinada pontuação?
No artigo anterior, você deve ter notado que /execute tem um subcomando if
score adicional. Podemos usar isso para verificar nossos valores de placar como uma
condição!
Comparando valores entre placares

Com os símbolos <, <=, =, >= ou > , podemos usar este comando para comparar valores
entre diferentes entradas do placar. Por exemplo, o comando a seguir compara a pontuação
de um jogador entre os placares fennifith.animals_spawned e fennifith.berries_eaten ...
shell
1 2 # |verifica
se a pontuação
uma condição de pontuação...
"fennifith.animals_spawned"
| | é maior que... 3 4 # |do | | ajogador...
pontuação # "fennifith.berries_eaten" do jogador...
frutinhas!"
# | | | 5fennifith.berries_eaten
6 # | | | execute if score run
@stellraw
@s "Você gerou mais > animais
@s 7 do que
| envie uma mensagem ao jogador! |

|
Neste exemplo, se a pontuação do jogador para fennifith.animals_spawned for maior que

fennifith.berries_eaten, a condição será válida — e executará o comando tellraw que a segue.
Comparando intervalos de números com "correspondências"
Usando a opção de correspondências , também é possível comparar diretamente

um placar com um intervalo de números.
shell
para# aseentrada
esta condição
do jogadorde pontuação
atual em 2 for válida... 1 # |
corresponder
"fennifith.animals_spawned"...
a "0"... # | | | envie uma# mensagem
| | se seu valor
ao
jogador! # | | | executar se pontuação @s
3 fennifith.animals_spawned corresponder a 0
4
5 |
6
run tellraw @s "Você ainda não convocou nenhum animal!"

Este comando verifica se a pontuação do jogador em "fennifith.animals_spawned" é

exatamente igual a 0. No entanto, também podemos usar ..0 para "menor que ou igual", 0..
para "maior que ou igual", e assim por diante .
Os intervalos de números também podem ser limitados em ambos os lados — como

10..50 para "entre 10 e 50" — e são limitados de forma inclusiva, o que significa que um
intervalo de 10..50 também incluirá 10 e 50 , além de quaisquer números entre.
Verificação de pontuações inexistentes
O que acontece se acessarmos uma entrada do placar que não existe? Normalmente, o
jogo trata entradas de placar inexistentes como "0" — o comando /scoreboard players add ,
por exemplo, aumentará qualquer pontuação inexistente para "1".
No entanto, isso funciona de maneira um pouco diferente para as condições if score . Se

verificarmos a condição $nonexistente fennifith.animals_spawned corresponde a 0.., ele
não executará o comando — porque $inexistente não tem um valor.
Os intervalos 0.. e ..0 falharão — se a pontuação tiver um valor, esperaríamos que pelo
menos uma dessas condições fosse verdadeira.
Normalmente, esse comportamento não é uma preocupação - se você estiver verificando um

placar em uma condição, geralmente é esperado que a condição não funcione para
pontuações não definidas. No entanto, se você quiser verificar diretamente se existe uma
pontuação, o seguinte comando é uma maneira de fazer isso...
shell #
verifique
verifique
se $inexistente
se $inexistente
>= 0 #<= | |0se1 nenhuma
2#|
for verdadeira, a pontuação não pode
# | | execute a menos que marque existir 34
$ inexistente
corresponde
5 fennifith.animals_spawned
aamenos
0 .. execute
que marque
tellraw $@scorresponde
inexistente
"A pontuação
..0 de $ inexistente em
| não existe!"
Existe outra maneira um pouco mais simples de verificar isso, que aproveita o valor máximo
que o jogo pode armazenar em um placar. Os placares do Minecraft são limitados pelo
tamanho inteiro mínimo/máximo de Java de 32 bits, ou um intervalo de -2147483648 a
2147483647. Podemos escrever isso em uma única condição para verificar se a pontuação
está dentro desse intervalo.
shell #
contrário,
verifica
a pontuação
se a pontuação
não pode
estáexistir
dentro2 dos
# | 3limites
executar,
do inteiro
a menos1 do
que
Java
marque
# | caso
$
inexistente 4 partidas fennifith.animals_spawned -2147483648..2147483647 execute
não existe!"
tellraw @s "A pontuação para $ inexistente em fennifith.animals_spawned
|
Estatísticas de rastreamento
Os placares também podem ser criados para rastrear as estatísticas do jogo, como o número
de blocos minerados ou o número de vezes que um item foi usado. Eles podem ser
encontrados no jogo abrindo o menu de pausa em qualquer mundo ou servidor e clicando no
botão "Estatísticas" - e os nomes usados para fazer referência a eles podem ser encontrados
no wiki do Minecraft.
Podemos usar qualquer estatística como o segundo argumento de /scoreboard

objetivos adicionados quando criamos um novo objetivo — por exemplo:
shell 1
objetivos do placar adicionar fennifith.animals_carrot_stick
minecraft.used:minecraft.carrot_on_a_stick
Observação: essas estatísticas são rastreadas apenas para jogadores! Embora

ainda possamos manipular os valores do placar para outras entidades usando
comandos, as entidades que não são jogadores não têm estatísticas e seus objetivos
não serão atualizados quando uma ação for executada.
Embora este placar seja atualizado quando sua estatística mudar, suas entradas também
podem ser alteradas individualmente pelo pacote de dados, portanto, pode não refletir
necessariamente o mesmo valor que a estatística em todos os momentos.
Por exemplo, podemos criar o placar acima para rastrear o número de vezes que uma
"cenoura no palito" foi usada. Se definirmos nossa entrada como 0 nesse placar, seu valor
permanecerá em 0, independentemente da estatística do jogador para esse item. Se o jogador
usar a "Cenoura no Palito" novamente, a estatística e o placar aumentarão em 1.
Detecção de eventos com estatísticas
Podemos usar esse comportamento em nossa função tick.mc (que é executada em todos
os ticks do jogo) para detectar quando um jogador usou a cenoura no palito. Vamos primeiro
definir o valor para todos os jogadores como 0 e, em seguida, verificar o placar em cada tick
para ver se ele aumentou. Em caso afirmativo, sabemos que o item foi usado e podemos
redefini-lo para 0 para detectá-lo novamente.
Para verificar o valor de cada jogador em nosso placar, podemos usar o subcomando /
execute if score junto com um intervalo de números para executar condicionalmente nossa
função se o placar tiver um valor >= 1.
Em caso afirmativo, executaremos a função fennifith:animals/spawn — que foi criada no

artigo anterior — para gerar um grupo de animais.
1. Primeiro precisamos criar nosso placar quando nosso pacote de dados for carregado
pelo jogo — então colocaremos a seguinte linha em nossa função load.mc:
shell #
data/fennifith/functions/animals/load.mcfunction 1 2 3
# cria um novo placar rastreando a estatística

"carrot_on_a_stick"
4 objetivos do placar adicionar
fennifith.animals_carrot_stick
minecraft.used:minecraft.carrot_on_a_stick
2. Em seguida, podemos colocar um comando na função tick.mc para executar nosso

função fennifith:animals/spawn se o placar tiver um valor >= 1.
shell #
data/fennifith/functions/animals/tick.mcfunction 1 2 3 4 5 6 7
# para cada jogador no jogo... # | se a

pontuação deles para "carrot_stick" for >= 1 # | # | | executar
como @a
| gerar
se alguns
pontuaranimais
@s |
fennifith.animals_carrot_stick corresponde a 1.. execute a função

fennifith:animals/spawn
3. Finalmente, depois de executarmos nossa função, precisamos redefinir o valor do placar

para que ele não seja executado até que o item seja usado novamente:
shell #
placardefine
de jogadores
a pontuação
definido
"carrot_stick"
@a 2 fennifith.animals_carrot_stick
para todos os jogadores como
0 01
Exemplos de
funcionalidade de placar
Aplicando valores únicos a cada entidade em um seletor
Se tivermos um seletor de entidade, como @e[type=pig], podemos atribuir um valor de placar
diferente para cada entidade. Isso pode ser feito de forma concisa usando o subcomando
execute store result ...
shell 1
# cria um objetivo fictício para armazenar IDs exclusivos de entidade de porco 2
3
objetivos do placar adicionar manequim fennifith.animals_id
4 # define uma variável $counter para 0

5 placar jogadores set $counter fennifith.animals_id 0
6
7 # para cada entidade em @e[type=pig]... # |
8 armazene o resultado como a pontuação
"fennifith.animals_id" da entidade # | 9 # | 10 executar como
@s 11@e[type=pig]
fennifith.animals_id
| adicione
armazenar
"1" àexecutar
variável
pontuação
$counter
placardo
jogadores
|resultado
adicionar|$counter fennifith.animals_id 1
Para cada entidade porco, o comando scoreboard add incrementa nossa variável
$counter em 1. Convenientemente, o comando add também retorna o valor total de seu
placar como resultado, então podemos usar isso para armazenar o valor incrementado
como pontuação da entidade porco.
Desafio: Valor máximo de um placar

Agora que o placar fennifith.animals_id tem algumas entradas, como podemos
encontrar a pontuação mais alta que ele contém? (sem usar a variável $counter ...)
Para fazer isso, podemos usar o seletor @e[type=pig] para selecionar cada entidade
suína do jogo e armazenar o resultado em $max fennifith.animals_id.
Dica
Solução
Conclusão
Este artigo cobriu a maioria dos comandos do placar que podemos usar, mas há muito
mais que pode ser feito com eles. Eles podem ser usados em todas as funções para
escrever praticamente qualquer lógica numérica; tente experimentar para ver o que você
pode realizar!
Na próxima postagem, abordaremos os avanços, que fornecem algumas formas alternativas

de detectar ações específicas do jogador e outras condições.

Minecraft Data Packs

Enviado por

Dados do documento

Descrição original:

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Minecraft Data Packs

Enviado por

Direitos autorais:

Formatos disponíveis

Machine Translated by Google

Machine Translated by Google

Pacote de Dados do Minecraft

Os pacotes de dados construídos nesta série podem ser encontrados no

O que é um pacote de dados?

O sistema de pacote de dados do Minecraft permite que os jogadores modifiquem

Se você deseja adicionar novos controles ao jogo, integrar-se a serviços externos ou

Vantagens dos mods do Minecraft

Pode se comunicar com serviços externos

Capaz de modificar a interface do usuário e os menus de configurações

Alguns pacotes de dados usaram soluções inovadoras (e altamente complexas)

Pode adicionar funcionalidades totalmente novas ao jogo

Mais desempenho do que pacotes de dados ao executar grandes operações

Vantagens dos pacotes de dados

Fácil de instalar em qualquer versão do Minecraft (Java Edition)

Os pacotes de dados são amplamente suportados em quase todos os inicializadores,

Geralmente mais simples de testar e escrever

Embora algumas ferramentas de modding possam fornecer testes e depuração

Mais seguro cometer erros com

Como os pacotes de dados são restritos à interação com os comandos fornecidos

Normalmente, melhor compatibilidade de atualização

Embora alguns comandos mudem em novas atualizações do Minecraft, eu

Escrevendo nossa primeira

Agora vamos ver se podemos colocá-los em uma função!

Construindo uma estrutura de pasta de pacote de dados

"description": "Surge um bando de animais ao redor do 4º jogador" } 5 } 6

O "pack_format": 10 neste arquivo corresponde ao Minecraft 1.19; normalmente, o

Versão Minecraft "pack_format" valor 1.19

Agora devemos ter nosso pacote de dados organizado da seguinte forma:

Instalando e testando o pacote de dados

Para encontrar a localização do seu mundo salvo, abra o Minecraft e encontre o

Se você não usou os mesmos nomes de pasta, o preenchimento automático deve

Especificando uma tag de função

Usando o evento "load"

Em load.mcfunction, escreverei apenas um comando para teste:

Testando o evento "load"

Pacote de Dados do Minecraft

Programação: Sintaxe de Comando

Observação: este guia cobre especificamente a versão Java Edition do Minecraft. A

Os pacotes de dados construídos nesta série podem ser encontrados no

Uma nota sobre ferramentas

Neste ponto, estamos começando a escrever comportamentos mais complexos em

Lógica condicional com o comando

No post anterior, terminamos com uma questão interessante — como escrevemos um

Bem, o Minecraft realmente tem um comando específico para verificar as pré-

Isso usa dois subcomandos do comando execute : if block ~ ~ ~ air verifica se o

Tente executar este comando no Minecraft! Contanto que você esteja em um

Parado no ar Parado na água

Se quisermos negar essa condição, podemos substituir o subcomando if por

As coordenadas podem ser escritas como uma posição fixa no mundo -

Coordenadas atuais (notação til)

Usar os símbolos de til (~ ~ ~) fará referência à posição atual em que o comando

Coordenadas direcionais (notação de circunflexo)

Semelhante às coordenadas relativas, as coordenadas direcionais (^ ^ ^)

Para experimentar a sintaxe de posição e ver onde certas posições terminam no

Uma observação importante ao usar essas posições: para os jogadores (e para a

Posições em um subcomando "/execute"

Esse contexto afeta a quais blocos, locais e entidades determinados

O comando /execute também possui um subcomando que pode mudar sua

Esses dois comandos fazem a mesma coisa! Quando usamos o ^ ^ ^4

Usando "/execute" com funções

Se você se lembra da função que criamos no capítulo anterior, acabamos fazendo

3 #| | obter o valor de @s |