Traduzido do Inglês para o Português - www.onlinedoctranslator.

com

bukkit

#bukkit
Índice
Sobre 1

Capítulo 1: Começando com o bukkit 2

Observações 2

Versões 2

Exemplos 3

Criando um plug-in 3

Pré-requisitos 3

Adicionando Bukkit como uma dependência 3

Classe Principal 3

Criando um plugin.yml 5

Crie um servidor de teste no Windows 5

BuildTools 6

O que é? 6

Pré-requisitos 6

janelas 6

git 6

Java 6

Linux 6

Mac 6

Executando BuildTools 7

Capítulo 2: Comandos 8

Sintaxe 8

Exemplos 8

Manipulando um Comando 8

Um comando Set GameMode simples ( /gm ) 8

Comando fora da classe principal 9

Capítulo 3: Arquivos de configuração 11

Sintaxe 11

Observações 11
 Exemplos 11

Plugin Config.yml 11

Seção de Caminhos Múltiplos 12

Capítulo 4: Entidades 13

Exemplos 13

Teleportar uma entidade para outra entidade 13

Teleportar uma entidade para um local 13

Tipo de entidade 14

Passageiro 17

Entidades Próximas 18

Capítulo 5: Eventos de Entidade 19

Introdução 19

Exemplos 19

Evento EntityDamage 19

EntityDamageEvent 19

EntityDamageByEntityEvent 19

EntityDamageByBlockEvent 20

EntityEvent (Superclasse) 20

Capítulo 6: Tratamento de eventos 22

Introdução 22

Sintaxe 22

Observações 22

Exemplos 22

Registrar eventos dentro da classe Listener 22

Registrando eventos em sua classe principal 23

Ouvindo eventos 23

Criando um manipulador de eventos 23

Registrando Eventos 24

Criando eventos personalizados 24

Chamando seu evento personalizado 25

Ouvindo um evento personalizado 25

Tornando seu CustomEvent cancelável 25

Tratamento básico de eventos 26

Criando um manipulador de eventos 26

Registrando Eventos 27

Prioridades do evento 27

Capítulo 7: Caindo 29

Observações 29

Exemplos 29

Distância de queda da entidade 29

Cancelando Dano 29

Capítulo 8: Escondendo Jogadores 30

Sintaxe 30

Observações 30

Exemplos 30

Escondendo um jogador de outros jogadores 30

Mostrando um jogador para outro jogador 30

Verificando se o jogador pode ser visto 30

Escondendo o Jogador de uma Entidade 30

Capítulo 9: Log 32

Exemplos 32

Usando o Bukkit Logger 32

Níveis de registro 32

Capítulo 10: Manipulando Conquistas 34

Sintaxe 34

Exemplos 34

Conquistas de premiação 34

Capítulo 11: NMS 36

Introdução 36

Observações 36

Exemplos 36

Acessando a versão atual do Minecraft 36

 Obtendo o ping de um jogador 37

Capítulo 12: Eventos do jogador 39

Introdução 39

Exemplos 39

PlayerJoinEvent 39

PlayerMoveListener 39

PlayerLoginEvent 39

Eventos de cama de jogador 40

Capítulo 13: Escala 42

Introdução 42

Exemplos 42

Configuração do projeto (Scala Eclipse) 42

Capítulo 14: Programação do Agendador 44

Sintaxe 44

Observações 44

Exemplos 44

Tarefa de repetição do agendador 44

Tarefa atrasada do agendador 44

Executando Tarefas Assincronamente 45

Executando Tarefas no Thread Principal 45

Executando um BukkitRunnable 45

Executando código seguro de thread de uma tarefa assíncrona 46

Capítulo 15: Gerar Ovos 47

Observações 47

Exemplos 47

Criando um ItemStack de um SpawnEgg 47

Capítulo 16: Versões 48

Exemplos 48

Obtendo versão em tempo de execução 48

Acessando o NMS nas versões de implementação 48

Capítulo 17: Geração mundial 49

Exemplos 49
 Gerador de Vazio 49

Capítulo 18: Manipulação do Mundo 50

Observações 50

Exemplos 50

Criando Explosões 50

Soltando um item 50

Gerando uma árvore 50

Regras de desova 52

Créditos 54
Sobre
Você pode compartilhar este PDF com qualquer pessoa que sinta que pode se beneficiar dele, baixando a versão mais recente
de:bukkit

É um e-book bukkit não oficial e gratuito criado para fins educacionais. Todo o conteúdo é extraído
deDocumentação de Estouro de Pilha, que é escrito por muitos indivíduos esforçados no Stack
Overflow. Não é afiliado ao Stack Overflow nem ao bukkit oficial.

O conteúdo é distribuído sob o Creative Commons BY-SA, e a lista de colaboradores para cada capítulo é fornecida na
seção de créditos no final deste livro. As imagens podem ter direitos autorais de seus respectivos proprietários, a menos
que especificado de outra forma. Todas as marcas comerciais e marcas registradas são de propriedade de seus
respectivos proprietários de empresas.

Use o conteúdo apresentado neste livro por sua conta e risco; não é garantido que esteja correto
nem preciso, envie seus comentários e correções parainfo@zzzprojects.com

https://riptutorial.com/ 1
Capítulo 1: Começando com o bukkit
Observações

Bukkit é uma API simples que permite modificar a experiência multijogador normal do Minecraft usando plug-
ins.

Bukkit foi descontinuado, e não está mais disponível para versões mais recentes do Minecraft.Spigot, uma
versão do Bukkit que melhora o desempenho do servidorestá disponível. A API do Spigot é essencialmente
a mesma do Bukkit.

Versões

Versão do Minecraft Link para Download do Spigot Data de lançamento

1.10.2 Link 03/11/2016

1.10 Link 2016-06-26

1.9.4 Link 2016-06-09

1.9.2 Link 30/03/2016

1.9 Link 29/02/2016

1.8.8 Link 28/07/2015

1.8.7 Link 2015-06-05

1.8.6 Link 2015-05-25

1.8.5 Link 2015-05-22

1.8.4 Link 17/04/2015

1.8.3 Link 20/02/2015

1.8 Link 2014-09-02

1.7.10 Link 2014-06-26

1.7.9 Link 14-04-2014

1.7.8 -- 2014-04-11

1.7.5 Link 2014-02-26

1.7.2 Link 2013-10-25

https://riptutorial.com/ 2
 Versão do Minecraft Link para Download do Spigot Data de lançamento

1.6.4 Link 19/09/2013

1.6.2 Link 2013-07-08

1.5.2 Link 2013-05-02

1.5.1 Link 2013-03-21

1.4.7 Link 2013-01-09

1.4.6 -- 20/12/2012

Exemplos

Criando um plug-in

Pré-requisitos
• JDK 7 ou superior (recomendado: JDK 8+)

Adicionando Bukkit como uma dependência

O método mais simples para adicionar a API do Bukkit ao seu projeto é baixar o Bukkit.jar diretamente do
Repositório Spigote adicione-o ao classpath do seu projeto. As versões legadas do Bukkit podem ser
encontradas noRepositório Bukkit.

A outra é adicioná-lo como uma dependência do Maven, adicionando as seguintes linhas ao seupom.xml:

<repositórios>
<repositório>
<id>spigot-repo</id>
<url>https://hub.spigotmc.org/nexus/content/repositories/snapshots/</url> </repository>

</repositórios>
<dependências>
<!--API do Bukkit-->
<dependência>
<groupId>org.bukkit</groupId>
<artifactId>bukkit</artifactId>
<version>{VERSION}</version>
<scope>fornecido</scope>
</dependência>
</dependencies>

https://riptutorial.com/ 3
Classe Principal

A classe principal do plug-in é o ponto de entrada para o Bukkit carregar e interagir com seu plug-in. É uma
classe que se estendeJavaPlugine apenas uma instância dele deve ser criada pelo seu plugin. Por convenção, é
bom dar a esta classe o mesmo nome do seu plugin.

Aqui está um exemplo de uma classe de plugin principal para o plugin "MyPlugin":

pacote com.example.myplugin; //{$TopLevelDomain}.{$Domain}.{$PluginName};

import org.bukkit.plugin.java.JavaPlugin;

public final class MyPlugin extends JavaPlugin {

@Sobrepor
public void onEnable() {
//Chamado quando o plug-in está ativado
getLogger().info("onEnable foi invocado!");
}

@Sobrepor
public void onDisable() {
//Chamado quando o plug-in está desabilitado
getLogger().info("onDisable foi invocado!");
}

Para acessar sua instância de plug-in de outra classe, você precisará armazenar a instância de sua
classe MyPlugin criada pelo Bukkit para que seja acessível de fora da classe.

public class MyPlugin extends JavaPlugin {

instância MyPlugin estática privada; //Efetivamente variável final contendo a instância do seu plugin

public MyPlugin(){
if(MyPlugin.instance != null) { //Verificação desnecessária, mas garante que seu plug-in seja inicializado apenas
uma vez.
throw new Error("Plugin já inicializado!");
}

MyPlugin.instance = this; //O construtor de um plugin só deve ser chamado uma vez
}

public static MyPlugin getInstance(){ //Obter a instância do seu plugin

instância de retorno;
}

//seu outro código...

}

Então, para acessar sua classe principal de outra classe, basta usarMeuPlugin.getInstance()

https://riptutorial.com/ 4
 public class MinhaOutraClasse {

public void doSomethingWithMainClass(){

MyPlugin.getInstance().getLogger().info("Acabamos de usar o MyPlugin");
}

Criando um plugin.yml
O arquivo plugin.yml vai na raiz do seu arquivo jar final e fornece informações essenciais para o Bukkit
carregar seu plugin. O plugin.yml mais simples se parece com isso

nome: {$PluginName} //Nome do plug-in

main: {$PackageName}.{$MainClass} //O nome totalmente qualificado da classe principal. versão:
{$Versão} //A versão do plugin

Por exemplo, com a classe MyPlugin acima

nome: MyPlugin
main: com.example.myplugin.MyPlugin versão:
1.0

Crie um servidor de teste no Windows

Para poder criar um servidor, você precisa ter o spigot ou o arquivo bukkit jar. Reefer para o tópico de
versõespara selecionar sua jarra

1. Primeiro, crie uma nova pasta. Nessa pasta, coloque o arquivo jar spigot/bukkit.
2. Clique com o botão direito do mouse na pasta e escolha Novo > Documento de texto.

3. Nomeie o novo documento como start.bat, clique com o botão direito nele e clique em Editar.

4. Adicione o seguinte código:

@echo desligado

java -Xms512M -Xmx1G -XX:+UseConcMarkSweepGC -jar {SEU_JAR.jar} pausa

Não se esqueça de alterar {YOUR_JAR.jar} para o jar que você baixou antes de iniciar estes tópicos.

5. Você pode editar-Xmspara alterar a RAM mínima permitida (Ex: -Xms1024M = 1024MB, - Xms1G =
1GB). Você também pode editar-Xmxpara alterar a RAM máxima permitida. Certifique-se de que o
máximo é maior que o mínimo.
6. Salve o arquivo, feche a janela e inicie seustart.batarquivo. Seu servidor agora deve abrir. Para
executar o servidor, você deve aceitar oEULA.
7. Se você concorda com oEULA, abrireula.txtmudareula=falsoparaeula=verdadeiroClique em "Salvar"
e agora você poderá iniciar seu servidor.
8. Para se conectar ao seu servidor, execute ostart.bat, abra o Minecraft, adicione um servidor e coloquehost local

https://riptutorial.com/ 5
 como IP.

BuildTools

O que é?
BuildTools.jar é uma solução para construir Bukkit, CraftBukkit, Spigot e Spigot-API. Tudo isso é feito no
seu computador! Alguns programas de pré-requisito são necessários, mas as instruções abaixo irão
guiá-lo em tudo o que você precisa fazer.

Pré-requisitos
Existem dois aplicativos necessários para usar o BuildTools: Git e Java.

janelas
git
Para que o BuildTools seja executado no Windows, você precisará instalar o Git. Para Windows é distribuído via
git-scm, que pode ser baixadoaqui. Instale-o onde quiser, ele fornecerá git bash, que será usado para executar
o jar BuildTools. Continue pressionando próximo ao executar o instalador.

Java
Baixe o JRE 8 emaquie instale. Continue pressionando próximo ao executar o instalador.

Linux
Tanto o git quanto o Java, bem como os comandos util, podem ser instalados usando um único comando por meio do
gerenciador de pacotes.

Debian/Ubuntu:sudo apt-get install git openjdk-7-jre-headless tar

CentOS/RHEL:sudo dnf install git java-1.7.0-openjdk-devel tar

Arco:pacman -S jdk8-openjdk git

Mac
O Git pode ser baixado em:http://sourceforge.net/projects/git-osx-installer/files/

https://riptutorial.com/ 6
O Java pode precisar ser atualizado a partir da versão distribuída da Apple e, mesmo se atualizado anteriormente, pode precisar
ser vinculado para uso do shell. Por favor, siga os passos encontrados aqui:
https://gist.github.com/johan/10590467

Executando BuildTools
1. Baixe BuildTools.jar de https://hub.spigotmc.org/jenkins/job/BuildTools/lastSuccessfulBuild/
artifact/target/BuildTools.jar
.

2. Abra seu terminal se estiver no Linux ou git bash no Windows.

1. Git bash pode ser encontrado na área de trabalho ou no menu Iniciar sob o nome "git bash". Também é possível
abri-lo clicando com o botão direito do mouse em qualquer coisa, pois agora é um item em seu menu de
contexto.

3. Navegue até onde você baixou BuildTools.jar ou use a linha de comando para fazer
download do jar para seu diretório atual.

1. No Windows, você pode usar o comando cd para alterar os diretórios ou clicar com o botão
direito do mouse no espaço em branco da pasta onde BuildTools.jar está (NÃO clique em
BuildTools.jar em si) e clique em "git bash", que irá abra-o em seu diretório atual.

4. Execute BuildTools.jar a partir do terminal (não clique duas vezes em BuildTools.jar) fazendo o
seguinte:

1. No Linux, execute git config --global --unset core.autocrlf e execute java -jar BuildTools.jar no bash
ou em outro shell apropriado.
2. No Windows, execute o comando abaixo dentro da janela do git bash que se abriu: java -jar
BuildTools.jar Esteja ciente de que é necessário ter o BuildTools #35 ou posterior, versões mais
antigas não funcionarão.
3. No Mac, execute os comandos abaixo, export MAVEN_OPTS="-Xmx2G" java -Xmx2G -jar
BuildTools.jar
4. Se precisar de uma versão mais antiga, você pode especificar a versão usando o argumento --rev
para BuildTools, por exemplo para 1.8.8: java -jar BuildTools.jar --rev 1.8.8

5. Espere enquanto ele constrói seus frascos. Em alguns minutos, você deve ter jars recém-compilados!

6. Você pode encontrar CraftBukkit e Spigot no mesmo diretório em que executou o BuildTools.jar
(para minecraft versão 1.10, eles seriam craftbukkit-1.10.jar e spigot-1.10.jar). Você pode
encontrar Spigot-API em \Spigot\Spigot-API\target\ (para minecraft versão 1.10, seria
spigotapi-1.10-R0.1-SNAPSHOT.jar).

Leia Introdução ao bukkit online:https://riptutorial.com/bukkit/topic/5400/getting-startedwith-

bukkit

https://riptutorial.com/ 7
Capítulo 2: Comandos
Sintaxe
• @Substituir public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args)

Exemplos

Manipulando um Comando

Para manipular um comando, você deve ter uma classe que implemente a interface CommandExecutor.
A classe JavaPlugin (a classe principal do seu plugin) já implementa isso.

Ao implementar a interface CommandExecutor, o seguinte método deve ser implementado:

public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) { //Trate seu comando
aqui
retornar verdadeiro; ///Deve retornar false se você quiser mostrar o uso

O remetente é aquele que enviou o comando. Pode ser um Player ou o Console.

CMD é o comando que você está ouvindo, conforme declarado em plugin.yml. Não confundir com rótulo.

label é o alias usado para executar este comando, é o que o remetente digita após a barra.

e, finalmente, args são os argumentos que o remetente pode ter usado para enviar seu comando.

Um possível comando pode ir como

/tell Kerooker Olá, Kerooker!

Tell seria seu rótulo e também pode ser definido como seu comando se você disser isso em plugin.yml;

'Kerooker', 'Olá', 'Kerooker!' são seus args 0, 1 e 2, respectivamente

Como retorno, você provavelmente sempre desejará retornar true quando esperava que tudo acontecesse
dessa maneira. Você deve retornar false se quiser mostrar ao remetente o uso do comando definido em seu
plugin.yml

Um comando Set GameMode simples ( /gm )

Este exemplo mostra um exemplo muito básico de como utilizar onCommand. Não sugiro
processar seus comandos diretamente no onCommand, mas isso resolve esse caso simples.

Neste exemplo, tentamos definir o modo de jogo do jogador.

https://riptutorial.com/ 8
A primeira coisa que precisamos fazer é garantir que o remetente não seja um ConsoleCommandSender, porque
não podemos definir o modo de jogo de um console. Isso é feito com (instância do remetente do Player).

Em seguida, queremos que o jogador digite /gm CREATIVE (ou qualquer outro modo de jogo), então temos que verificar
2 coisas:

1. certifique-se de que eles passam em 1 argumento (CREATIVE)

2. certifique-se de que o comando deles seja "gm"

Realizamos essas verificações com: args.length == 1 && label.equalsIgnoreCase("gm")

Agora sabemos com certeza que o jogador digitou "/gm x".

A próxima coisa que precisamos fazer é transformar args[0] em um objeto GameMode para que possamos aplicá-lo
ao jogador. Isso pode ser feito com GameMode.valueOf(String) No entanto, de acordo com a documentação de
enumeração Java, se uma string for passada para valueOf() que não corresponder a uma enumeração, ela lançará
um IllegalArgumentException - portanto, temos que garantir pegar isso.

Assim que tivermos o modo de jogo, podemos simplesmente usar p.setGameMode(gm) e o modo de jogo
do jogador mudará. No caso de detectarmos uma exceção - simplesmente imprimimos uma instrução e
retornamos false.

@Sobrepor
public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if (instância do remetente do Player) {
final Jogador p = (Jogador) remetente;

if (args.length == 1 && label.equalsIgnoreCase("gm")) {

tentar {
GameMode gm = GameMode.valueOf(args[0]);
p.setGameMode(gm);
p.sendMessage(ChatColor.GREEN + "Seu modo de jogo foi definido como: " +
gm.toString());
retornar verdadeiro;
} catch (IllegalArgumentException e) {
p.sendMessage(ChatColor.RED + "Opção de modo de jogo inválida!"); retorna
falso;
}

}
}
retorna falso;
}

Comando fora da classe principal

Se você tiver muitos comandos, não deve colocá-los todos na classe principal.

1. Crie uma nova classe e implemente-aCommandExecutor

2. Adicione o seguinte à classe:

@Sobrepor

https://riptutorial.com/ 9
 public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args)
{

3. Em sua classe principal, adicione onEnable (substitua commandName pelo nome do

comando e CommandExecutor pelo nome da classe):

getCommand("commandName").setExecutor(new CommandExecutor());

Leia Comandos online:https://riptutorial.com/bukkit/topic/6880/commands

https://riptutorial.com/ 10
Capítulo 3: Arquivos de configuração

Sintaxe
• String s = config.getString("path.to.string");
• int i = config.getInt("path.to.int");
• double d = config.getDouble("path.to.double");
• List<String> sl = config.getStringList("path.to.stringlist");
• List<Double> dl = config.getDoubleList("path.to.doublelist");
• List<Integer> il = config.getIntegerList("path.to.integerlist");

Observações

Os arquivos de configuração do Bukkit são arquivos YAML (Yet Another Markup Language) diretos e são
implementados dessa forma.

Exemplos

Plugin Config.yml

Você pode ter um arquivo config.yml que carrega diretamente de seu arquivo jar. Ele deve ser adicionado à pasta
do seu projeto, da mesma forma que o arquivo plugin.yml.

Neste arquivo você tem os valores padrão para sua configuração.

Exemplo de configuração:

# Este é um comentário YML

adminName: "Kerooker"
moderadores: ["Romário", "Pelé", "Cafú"]

O arquivo de configuração de exemplo deve ser adicionado à pasta do projeto.

Para carregar o arquivo de configuração padrão para a pasta do seu plugin, o seguinte código deve ser adicionado ao
seu onEnable():

salvarDefaultConfig();

Isso fará com que o arquivo config.yml do projeto seja o arquivo de configuração do plug-in e o
adicionará à pasta do plug-in.

A partir daí, você pode acessar seu arquivo de configuração de qualquer lugar, usando sua instância de plugin:

plug-in JavaPlugin; // Sua instância do plug-in

FileConfiguration config = plugin.getConfig(); //Acessando o arquivo de configuração

https://riptutorial.com/ 11
A partir daí, podemos acessar qualquer coisa que foi definida no config do plugin.

Nota: O arquivo de configuração padrão pode ter seus valores alterados, caso o usuário queira editar o arquivo
config.yml gerado para a pasta.

String adminName = config.getString("adminName"); List<String> moderadores =

config.getStringList("moderators");

Seção de Caminhos Múltiplos

O que pode acontecer no seu arquivo de configuração é ter um caminho para uma variável que passa por várias
seções.

Configuração de exemplo

administradores:

primeiro nível: "Kerooker"

segundo nível: "Mordekaiser"
terceiro nível: "Yesh4"

O nome "Kerooker" vem da seção "first-tier", que vem da seção "admins". Para acessar os caminhos internos do
nosso arquivo, usamos um simples '.' como uma forma de dizer que queremos a próxima seção. Então, para
acessarmos o "Kerooker", vamos:

config.getString("admins.first-tier");

Leia os arquivos de configuração online:https://riptutorial.com/bukkit/topic/6824/configuration-files

https://riptutorial.com/ 12
Capítulo 4: Entidades

Exemplos

Teleportar uma entidade para outra entidade

Entidade entidade; //A entidade que você deseja teletransportar

Entidade teleportTo; //A entidade para onde você quer que <entity> seja teletransportado

sucesso booleano = entity.teleport(teleportTo); //Tentativa de teletransporte.

if(sucesso) {
//O teletransporte foi bem-
sucedido }else {
//Teleporte não foi bem sucedido }

Você também pode adicionar uma causa ao seu teletransporte, para poder personalizar como sua causa será tratada
pelo seu plugin ou por outros:

Entidade entidade; //A entidade que você deseja teletransportar

Entidade teleportTo; //A entidade para onde você deseja que <entidade> seja teletransportada para
PlayerTeleportEvent.TeleportCause cause; //A causa que você quer que seja o teletransporte

sucesso booleano = entity.teleport(teleportTo, cause); //Tentativa de teletransporte.

if(sucesso) {
//O teletransporte foi bem-
sucedido }else {
//Teleporte não foi bem sucedido }

Teleportar uma entidade para um local

Entidade a ser teletransportada; //A entidade que você deseja teletransportar

Location teleportTo = new Location(world,x,y,z,yaw,pitch); //O local para onde se teletransportar

sucesso booleano = toBeTeleported.teleport(teleportTo);

if(sucesso) {
//O teletransporte foi bem-
sucedido }else {
//O teletransporte não foi bem sucedido
}

Você também pode adicionar uma causa ao seu teletransporte, para poder personalizar como sua causa será tratada
pelo seu plugin ou por outros:

Entidade a ser teletransportada; //A entidade que você deseja teletransportar

Location teleportTo = new Location(world,x,y,z,yaw,pitch); //O local para onde se teletransportar

https://riptutorial.com/ 13
 PlayerTeleportEvent.TeleportCause causa; //A causa que você quer que seja o teletransporte

sucesso booleano = toBeTeleported.teleport(teleportTo, cause);

if(sucesso) {
//O teletransporte foi bem-
sucedido }else {
//O teletransporte não foi bem sucedido
}

Tipo de entidade

A enumeração EntityType representa todas as entidades do Bukkit/Spigot.

Todos os seus valores podem ser encontrados abaixo.

Valor Descrição

AREA_EFFECT_CLOUD N/D

Entidade mecânica com um inventário para colocar armas/

ARMOR_STAND
armaduras.

SETA Um projétil de flecha; pode ficar preso no chão.

BASTÃO N/D

CHAMA N/D

BARCO Um lugar barco

ARANHA DA CAVERNA N/D

FRANGO N/D

COMPLEX_PARTE N/D

VACA N/D

RASTEJADOR N/D

DRAGON_FIREBALL Como FIREBALL, mas com efeitos extras

DROPPED_ITEM Um item descansando no chão.

OVO Um ovo de galinha voador.

ENDER_CRYSTAL N/D

ENDER_DRAGON N/D

https://riptutorial.com/ 14
 Valor Descrição

ENDER_PEARL Uma pérola do ender voador.

ENDER_SIGNAL Um sinal de olho final.

ENDERMAN N/D

ENDERMITE N/D

EXPERIENCE_ORB Uma esfera de experiência.

FALLING_BLOCK Um bloco que vai ou está prestes a cair.

BOLA FOGO Uma grande bola de fogo voadora, lançada por um Ghast, por exemplo.

Representação interna de um Firework uma vez

FOGO DE ARTIFÍCIO
lançado.

FISHING_HOOK Uma linha de pesca e bobber.

GAST N/D

GIGANTE N/D

GUARDIÃO N/D

CAVALO N/D

GIGANTE DE FERRO N/D

ITEM_FRAME Um quadro de item em uma parede.

LEASH_HITCH Uma coleira presa a uma cerca.

RAIO Um raio.

LINGERING_POTION Uma poção prolongada voadora

CUBO DE MAGMA N/D

MINECART N/D

MINECART_CHEST N/D

MINECART_COMMAND N/D

MINECART_FURNACE N/D

MINECART_HOPPER N/D

MINECART_MOB_SPAWNER N/D

https://riptutorial.com/ 15
 Valor Descrição

MINECART_TNT N/D

COGUMELO_COW N/D

JAGUATIRICA N/D

PINTURA Uma pintura em uma parede.

PORCO N/D

PIG_ZOMBIE N/D

JOGADOR N/D

URSO POLAR N/D

PRIMED_TNT TNT preparado que está prestes a explodir.

COELHO N/D

OVELHA N/D

SHULKER N/D

SHULKER_BULLET Bala disparada por SHULKER.

SILVERFISH N/D

ESQUELETO N/D

SLIME N/D

SMALL_FIREBALL Uma pequena bola de fogo voadora, como a lançada por um Blaze ou jogador.

BOLA DE NEVE Uma bola de neve voadora.

BONECO DE NEVE N/D

Como TIPPED_ARROW, mas causa o efeito

SPECTRAL_ARROW
PotionEffectType.GLOWING em todos os membros da equipe.

ARANHA N/D

SPLASH_POTION Uma poção de respingo voador

LULA N/D

THROWN_EXP_BOTTLE Uma garrafa de experiência voadora.

TIPPED_ARROW Como ARROW, mas com uma poção específica que é

https://riptutorial.com/ 16
 Valor Descrição

aplicado em contato.

DESCONHECIDO Uma entidade desconhecida sem uma classe de entidade

ALDEÃO N/D

CLIMA N/D

BRUXA N/D

MURCHAR N/D

WITHER_SKULL Um projétil de crânio murcho voador.

LOBO N/D

ZUMBI N/D

Passageiro

As entidades podem ter passageiros. Um bom exemplo de passageiro é um jogador montado em um porco selado ou um zumbi
dentro de um carrinho de mina.

Embora existam veículos específicos, qualquer entidade pode ser veículo de qualquer outra entidade com o
método SetPassenger.

Veículo da entidade;
Passageiro da entidade;
resultado booleano = veículo.setPassageiro(passageiro); razão //False se não puder ser feito por qualquer coisa

O passageiro deve agora estar preso ao veículo

Você pode verificar se uma entidade tem um passageiro usando

boolean hasPassenger = entity.isEmpty()

Se a entidade tiver um passageiro, você pode recuperar a entidade do passageiro com

Entidade passageiro = entity.getPassenger();

Só devolverá o passageiro principal se o veículo puder ter múltiplos.

Finalmente, você pode ejetar o passageiro de uma entidade com

https://riptutorial.com/ 17
 boolean b = entity.eject(); ser ejetado //Ejetar todos os passageiros - retorna verdadeiro se houver um passageiro

Entidades Próximas

Para recuperar uma lista de entidades próximas de uma entidade, pode-se usar

List<Entidade> nas proximidades = entity.getNearbyEntities(duplo x, duplo y, duplo z);

O Bukkit irá então calcular uma caixa delimitadora centrada na entidade, tendo como parâmetros:

• x: 1/2 do tamanho da caixa ao longo do eixo x

• y: 1/2 do tamanho da caixa ao longo do eixo y
• z: 1/2 do tamanho da caixa ao longo do eixo z

A lista pode estar vazia, significando que não há entidades próximas com os parâmetros.

Essa abordagem pode ser usada para detectar entidades próximas a projéteis personalizados, por exemplo, lançar um
Itemstack e detectar quando ele colide com um jogador

Ler Entidades online:https://riptutorial.com/bukkit/topic/7886/entities

https://riptutorial.com/ 18
Capítulo 5: Eventos de Entidade

Introdução
Todos os eventos de entidade estendem EntityEvent, a superclasse para EntityEvents.

Todos os EntityEvents conhecidos podem ser encontrados abaixo e serão abordados nesta documentação.

Exemplos

Evento EntityDamage

O evento EntityDamage é lançado quando uma Entidade é danificada.

EntityDamageEvent

@EventHandler
public void onEntityDamage(EntityDamageEvent e) {
CausaDanoscausa = e.getCause(); double //Pega o evento DamageCause
rawDamage = e.getDamage(); //Retorna o dano antes de qualquer cálculo
double damageModified = e.getDamage(DamageModifier.X); ser causado //Retorna o dano que causaria
com o modificador especificado
double finalDamage = e.getFinalDamage(); todos os //Recebe o dano final deste evento, com
cálculos incluídos

e.setCancelled(boolean x); //Se por algum motivo você quiser que o evento não aconteça, você
pode cancelá-lo
e.setDamage(dano duplo); //Você pode alterar o dano total que o evento causará
e.setDamage(modificador DamageModifier, dano duplo); //Altera o dano considerando
qualquer modificador possível
}

Na maioria das vezes, o EntityDamageEvent não será usado. Em vez disso, uma de suas subclasses será usada,
comoEntityDamageByEntityEventouEntityDamageByBlockEvent. Ambos podem ser vistos abaixo.

EntityDamageByEntityEvent

@EventHandler
public void onEntityDamageByEntity(EntityDamageByEntityEvent e) {
//Recuperando a Entidade que causou dano Entity
damageDealer = e.getDamager();

//Recuperando a Entidade que sofreu dano Entity

damageTaker = e.getEntity();

//Recuperando a causa do dano

https://riptutorial.com/ 19
 CausaDanoscausa = e.getDamageCause();

//dano é o dobro do valor do dano antes de todas as resistências e modificadores terem sido aplicados

dano duplo = e.getDamage();

//FinalDamage é o dobro do valor do dano após todas as resistências e modificadores terem sido aplicados

double finalDamage = e.getFinalDamage();

//Você também pode definir o dano bruto (antes dos modificadores) para o evento com um valor diferente
e.setDamage(20.0);
}

EntityDamageByBlockEvent

Uma extensão simples para o EntityDamageEvent, mas com um método diferente:

Bloco b = event.getDamager(); //Retorna o bloco que deu dano a entidade

EntityEvent (Superclasse)

As subclasses conhecidas para Entity Events são:

Subclasses Subclasses Subclasses

CreatureSpawnEvent CreeperPowerEvent EntityChangeBlockEvent

EntityCombustEvent EntityCreatePortalEvent EntityDamageEvent

EntityDeathEvent EntityExplodeEvent EntidadeInteraçãoEvento

EntityPortalEnterEvent EntityRegainHealthEvent EntityShootBowEvent

EntityTameEvent EntityTargetEvent EntityTeleportEvent

EntityUnleashEvent ExplosionPrimeEvent FoodLevelChangeEvent

HorseJumpEvent ItemDespawnEvent ItemSpawnEvent

PigZapEvent ProjétilHitEvent ProjétilLaunchEvent

SheepDyeWoolEvent SheepRegrowWoolEvent SlimeSplitEvent

Além disso, todas as subclasses herdam os seguintes métodos:

Entidade getEntidade(); //Entidade que está envolvida neste evento //EntityType da

EntityType getEntityType(); Entidade envolvida neste evento

https://riptutorial.com/ 20
Leia os Eventos da Entidade online:https://riptutorial.com/bukkit/topic/6486/entity-events

https://riptutorial.com/ 21
Capítulo 6: Tratamento de eventos

Introdução
Quando algo acontece dentro do Bukkit, um evento é chamado para que cada plugin possa decidir o que
fazer sempre que algo acontecer.

Um evento é chamado quando um jogador tenta jogar um bloco, quando uma entidade desaparece, quando alguém faz login...
Os plug-ins podem ouvir eventos específicos e lidar com eles de várias maneiras diferentes, por exemplo, enviando uma
mensagem para um administrador quando um Player efetua login, por meio do PlayerLoginEvent.

Sintaxe

• Bukkit.getPluginManager().registerEvents(Listener l, Plugin p);

Observações

Ao registrar um evento, verifique se você não está registrando duas vezes! Ou seu plugin irá agir duas vezes
para o evento registrado.

Dê uma olhada extra em como lidar com eventos específicos:

• Eventos do Jogador

• Eventos de Entidade

Exemplos

Registrar eventos dentro da classe Listener

import org.bukkit.event.Listener; import

org.bukkit.event.EventHandler; import
org.bukkit.event.EventPriority; import
org.bukkit.event.player.PlayerLoginEvent; import
org.bukkit.event.player.PlayerQuitEvent;

public class MyEventListener implements Listener {

/**
* Construtor
*/
public MyEventListener(Plugin principal){
//registra eventos desta classe
//com método: registerEvents(Listener, Plugin);
plugin.getServer().getPluginManager().registerEvents(this, plugin);
}

/**
* Um evento com ALTA prioridade
*/

https://riptutorial.com/ 22
 @EventHandler(priority = EventPriority.HIGH) //Uma anotação EventHandler public void
onPlayerLogin(PlayerLoginEvent event){ //Um evento bukkit
event.getPlayer().sendMessage("Bem-vindo.");
}
/**
* Um evento com prioridade NORMAL (padrão)
*/
@EventHandler
public void onPlayerQuit(evento PlayerQuitEvent){
Bukkit.broadcastMessage(event.getPlayer().getName() + " saiu do servidor.");
}

/**
* Classe principal
*/
public class Principal estende JavaPlugin {
public void onEnable(){
// Registra eventos
novo MyEventListener(este);
}
}

Registrando eventos em sua classe principal

public class Principal estende JavaPlugin {

@Sobrepor
public void onEnable() {
Bukkit.getPluginManager().registerEvents(este, este);
}

@EventHandler
public void yourEvent(Event e) { //...

}
}

Ouvindo eventos

O Bukkit usa um sistema baseado em eventos que permite aos desenvolvedores de plugins interagir e modificar o
servidor e ações específicas que ocorrem no mundo.

Criando um manipulador de eventos

Manipuladores de eventos são métodos que são chamados quando o evento ocorre. Eles são geralmente públicos e vazios,
bem como nomeadosem{EventNameStem}por convenção. Todos os manipuladores, no entanto, devem ter o
@EventHandleranotação, bem como conter seu evento como o parâmetro ONLY. Aqui está um exemplo de um
manipulador de eventos para oPlayerJoinEvent

https://riptutorial.com/ 23
 @EventHandler
public void onPlayerJoin(evento PlayerJoinEvent){
// Executa quando um jogador entra
}

Observação:O formato de nomenclatura para eventos do Bukkit é{Origem}{Ação}({Destino})Evento. Alguns exemplos de

esses nomes de eventos são:PlayerInteractEventouBlockBreakEventouPlayerJoinEvent. uma lista de todos
eventos podem ser encontrados noSpigot Javadocs

Registrando Eventos
Apenas criar um manipulador de eventos não é suficiente para permitir que o Bukkit comece a enviar chamadas de eventos para
o seu método. Você também deve registrá-lo através da interface do PluginManager.

A maneira mais comum de registrar eventos é criar uma classe que implemente a interface Listener e usá-
la para agrupar seus manipuladores de eventos.

public class EventListener implements Listener { //Implementa a interface do Listener

@EventHandler
public void onPlayerJoin(evento PlayerJoinEvent){
// Executa quando um jogador entra
}

Esta classe de ouvinte e todos os seus eventos podem ser registrados em sua classe de plugin principal assim:

@Sobrepor
public void onEnable(){
Bukkit.getPluginManager().registerEvents(new EventListener(), this); //Registra seu ouvinte e seus manipuladores
de eventos
}

Criando eventos personalizados

Às vezes você precisa criar seu próprio evento, um que outros plugins possam ouvir (o Vault, entre outros plugins,
faz isso) e até cancelar. A API de eventos do Bukkit permite que isso seja possível. Tudo o que você precisa fazer é
criar uma nova classe, estendê-laEvento, adicione os manipuladores e os atributos de que seu evento precisa (como
Player ou mensagem).

import org.bukkit.event.Event; import

org.bukkit.event.HandlerList;

public final class CustomEvent extends Event {

private static final manipuladores HandlerList = new HandlerList(); mensagem String
privada;

public CustomEvent(String exemplo) {

https://riptutorial.com/ 24
 mensagem = exemplo;
}

public String getMessage() {

mensagem de retorno;
}

public HandlerList getHandlers() {

manipuladores de retorno;
}

public static HandlerList getHandlerList() {

manipuladores de retorno;
}
}

Chamando seu evento personalizado

Você está no controle de criar e chamar seus eventos, onde você os chama depende totalmente de você. Aqui
está um exemplo

// Cria o evento aqui

CustomEvent event = new CustomEvent("Exemplo de mensagem"); //
Chama o evento
Bukkit.getServer().getPluginManager().callEvent(event);
Bukkit.getServer().broadcastMessage(event.getMessage());

Lembre-se: você está no controle de seus eventos. Se você não chamar e agir de acordo com isso, não acontecerá!

Ouvindo um evento personalizado

Ouvir um evento personalizado é o mesmo que ouvir um evento normal.

import org.bukkit.event.Listener; import

org.bukkit.event.EventHandler;

public final class CustomListener implementa Ouvinte {

@EventHandler
public void onCustomEvent(CustomEvent event) { // Algum
código aqui
}
}

Tornando seu CustomEvent cancelável

Se você quiser tornar seu evento cancelável, basta adicionarimplementa cancelável,booleano cancelado
e um getter e setter:

https://riptutorial.com/ 25
 import org.bukkit.event.Event; import
org.bukkit.event.HandlerList; import
org.bukkit.event.Cancellable;

public final class CustomEvent extends Event implements Cancelable {

private static final manipuladores HandlerList = new HandlerList(); mensagem String
privada;
privado booleano cancelado;

public CustomEvent(String exemplo) {

mensagem = exemplo;
}

public String getMessage() {

mensagem de retorno;
}

public boolean isCancelled() {

devolução cancelada;
}

public void setCancelled(boolean cancel) {

cancelado = cancelar;
}

public HandlerList getHandlers() {

manipuladores de retorno;
}

public static HandlerList getHandlerList() {

manipuladores de retorno;
}
}

Depois, você verificaria se um plug-in cancelou o evento personalizado.

// Cria o evento aqui

CustomEvent event = new CustomEvent("Exemplo de mensagem"); //
Chama o evento
Bukkit.getServer().getPluginManager().callEvent(event); // Verifica se o
evento não foi cancelado
if (!event.isCancelled()) {
Bukkit.getServer().broadcastMessage(event.getMessage());
}

Tratamento básico de eventos

O Bukkit usa um sistema baseado em eventos que permite aos desenvolvedores de plugins interagir e modificar o
servidor e ações específicas que ocorrem no mundo.

Criando um manipulador de eventos

Manipuladores de eventos são métodos que são chamados quando o evento ocorre. Geralmente são públicos e

https://riptutorial.com/ 26
vazio, bem como nomeadoem{EventNameStem}por convenção. Todos os manipuladores, no entanto, devem ter o
@EventHandleranotação, bem como conter seu evento como o parâmetro ONLY. Aqui está um exemplo de um
manipulador de eventos para oPlayerJoinEvent

@EventHandler
public void onPlayerJoin(evento PlayerJoinEvent){
// Executa quando um jogador entra
}

Observação:O formato de nomenclatura para eventos do Bukkit é{Origem}{Ação}({Destino})Evento. Alguns exemplos de

esses nomes de eventos são:PlayerInteractEventouBlockBreakEventouPlayerJoinEvent. uma lista de todos
eventos podem ser encontrados noSpigot Javadocs

Registrando Eventos
Apenas criar um manipulador de eventos não é suficiente para permitir que o Bukkit comece a enviar chamadas de eventos para
o seu método. Você também deve registrá-lo através da interface do PluginManager.

A maneira mais comum de registrar eventos é criar uma classe que implemente a interface Listener e usá-
la para agrupar seus manipuladores de eventos.

public class EventListener implements Listener { //Implementa a interface do Listener

@EventHandler
public void onPlayerJoin(evento PlayerJoinEvent){
// Executa quando um jogador entra
}

Esta classe de ouvinte e todos os seus eventos podem ser registrados em sua classe de plugin principal assim:

@Sobrepor
public void onEnable(){
Bukkit.getPluginManager().registerEvents(new EventListener(), this); //Registra seu ouvinte e seus manipuladores
de eventos
}

Prioridades do evento

Bukkit tem um sistema chamadoPrioridades do eventopara ajudar os plug-ins a lidar com eventos no formato antigo correto. As sete
prioridades são (em mais antigo do primeiro executado ao último):

• Mais baixo
• Baixo
• Normal (padrão)
• Alto

https://riptutorial.com/ 27
 • Altíssima
• Monitor

Se você planeja cancelar muitos eventos (por exemplo, plug-in de proteção), seria uma boa ideia usar prioridade
mais baixa (ou mais baixa) para evitar problemas.

Você nunca deve modificar o resultado de um evento no MONITOR.

@EventHandler //o mesmo que @EventHandler(priority = EventPriority.NORMAL) public void

onLogin(PlayerLoginEvent event) {
// login normal
}

@EventHandler(priority = EventPriority.HIGH) public void

onLogin(PlayerLoginEvent event) {
// login alto
}

Mais informações:

• EventPriority em spigot javadocs

• Prioridades de eventos no BukkitWiki

Leia Manipulação de Eventos online:https://riptutorial.com/bukkit/topic/5743/event-handling

https://riptutorial.com/ 28
Capítulo 7: Caindo

Observações

Atualmente, não há nenhuma maneira consistente de evitar que uma entidade sofra gravidade, mesmo se você cancelar
seu movimento, o lado do cliente do jogador ainda tentará cair antes que o evento seja cancelado.

Exemplos

Distância de queda da entidade

A distância de queda da entidade é a distância que a entidade caiu sem atingir um bloco.

Pode ser usado para calcular diferentes danos de queda ou ativar um efeito após uma grande queda.

Recuperando a distância de queda

float distanceFell = entity.getFallingDistance();

Definindo a distância de queda

Isso pode ser usado para simular uma distância de queda diferente da real. O Bukkit calculará o dano
usando a nova distância de queda.

entidade.setFallingDistance(distância flutuante);

Cancelando Dano

Você pode cancelar um dano de queda usando oEntityDamageEvent

@EventHandler
public void onEntityDamage(EntityDamageEvent e) { Entidade
levouDamage = e.getEntity();

CausaDanoscausa = e.getCause();

if (cause == DamageCause.FALL){
//O dano foi causado pela queda, cancele-o
e.setCancelled(true);
}

Leia Caindo online:https://riptutorial.com/bukkit/topic/7899/falling

https://riptutorial.com/ 29
Capítulo 8: Escondendo Jogadores

Sintaxe

• void hide(Player toHide);

• void show(Player toShow);
• boolean canSee(Player toBeSeen);

Observações

Os eventos são melhor cobertos emDocumentação da lista de eventos do StackOverflow

Exemplos

Escondendo um jogador de outros jogadores

Player playerToHide;
Player playerToNotSee;

playerToNotSee.hide(playerToHide);
//playerToHide não será mais visto por playerToNotSee.

Se o jogador já estiver oculto, nada acontece

Mostrando um jogador para outro jogador

Jogador para Unhide;

Jogador a ver novamente

toSeeAgain.show(toUnhide);
//Player toSeeAgain agora verá Player toUnhide novamente.

Se o jogador já estiver visível, nada acontece.

Verificando se o jogador pode ser visto

Player playerToCheck;
Player playerSeeing;

boolean isVisible = playerSeeing.canSee(playerToCheck);

//isVisible retorna true se playerSeeing pode ver playerToCheck e false caso contrário

Escondendo o Jogador de uma Entidade

Isso pode ser feito usando o evento EntityTargetEvent

https://riptutorial.com/ 30
As entidades não terão como alvo o jogador se você cancelar o evento:

@EventHandler
public void onEntityTarget(EntityTargetEvent e) {
Entidade alvo = e.getEntity(); if(instância
de destino do Player) {
Jogador jogadorTargetted = (Jogador) alvo; if
(shouldBeInvisible(playertargetted) {
e.setCancelado(verdadeiro); //Cancela o evento de destino
}
}
}

Leia Ocultando Jogadores online:https://riptutorial.com/bukkit/topic/7697/hiding-players

https://riptutorial.com/ 31
Capítulo 9: Log
Exemplos

Usando o Bukkit Logger

public class MinhaClasse {

public void foo() {

Logger logger = Bukkit.getLogger();

logger.info("Uma mensagem de registro");

logger.log(Level.INFO, "Outra mensagem");
logger.fine("Uma boa mensagem");

// registrando uma exceção try

{
// o código pode lançar uma exceção }
catch (SomeException ex) {
// registra um aviso imprimindo "Algo deu errado" // junto com a
mensagem de exceção e stacktrace logger.log(Level.WARNING, "Algo
deu errado", ex);
}

String s = "Olá Mundo!";

// registrando um objeto LOG.log(Level.FINER, "String s:

{0}", s);

// logando vários objetos

LOG.log(Level.FINEST, "String s: {0} tem comprimento {1}", new Object[]{s, s.length()});
}

Níveis de registro

Java Logging API tem 7níveis. Os níveis em ordem decrescente são:

• FORTE(valor mais alto)

• AVISO
• INFORMAÇÕES

• CONFIG
• MULTAR

• MAIS FINO

• MELHOR(menor valor)

O nível padrão éINFORMAÇÕES(mas isso depende do sistema e usou uma máquina virtual).

Observação: Existem também níveisDESLIGADO(pode ser usado para desativar o logon) eTODOS(o oposto deDESLIGADO).

Exemplo de código para isso:

https://riptutorial.com/ 32
 importar java.util.logging.Logger;

níveis de classe pública {

logger logger final estático privado = Bukkit.getLogger();

public static void main(String[] args) {

logger.severe("Mensagem registrada por SEVERE");

logger.warning("Mensagem registrada por WARNING");
logger.info("Mensagem registrada por INFO");
logger.config("Mensagem registrada pelo CONFIG");
logger.fine("Mensagem registrada por FINE");
logger.finer("Mensagem registrada pelo FINER");
logger.finest("Mensagem registrada por FINEST");

// Todos os métodos acima são apenas atalhos para // public void

log(Nível de nível, String msg): logger.log(Level.FINEST, "Mensagem
registrada por FINEST");
}
}

Por padrão, a execução desta classe produzirá apenas mensagens com nível superior aCONFIG:

23 de julho de 2016 21:16:11 NíveisExemplo principal

SEVERE: Mensagem registrada por SEVERE
23 de julho de 2016 21:16:11 Níveis Exemplo principal
AVISO: Mensagem registrada por AVISO
23 de julho de 2016 21:16:11 NíveisExemplo INFO
principal: Mensagem registrada por INFO

Leia o registro online:https://riptutorial.com/bukkit/topic/7202/logging

https://riptutorial.com/ 33
Capítulo 10: Manipulando Conquistas
Sintaxe

• player.awardAchievement(Achievement ach);

Exemplos

Conquistas de premiação

Jogador jogador; //O jogador com o qual você deseja premiar sua conquista
Realização de realização; //A conquista que você deseja conceder ao seu jogador

player.awardAchievement(conquista); //Atribuindo a conquista

Verificando se o jogador tem conquista:

Jogador jogador;
Realização de realização;
boolean hasAchievement = jogador.hasAchievement(conquista);

O código premiará a conquista e qualquer conquista dos pais.

As possíveis conquistas são:

• ACQUIRE_IRON (Adquirir hardware)

• BAKE_CAKE (A Mentira)
• ESTANTE (Bibliotecário)
• BREED_COW (Repovoamento)
• BREW_POTION (cervejaria local)
• BUILD_BETTER_PICKAXE (obtendo uma atualização)
• BUILD_FURNACE (tópico atual)
• BUILD_HOE (Hora de cultivar!)
• BUILD_PICKAXE (Hora de minerar!)
• BUILD_SWORD (hora de atacar!)
• BUILD_WORKBENCH (Comparação)
• COOK_FISH (Delicioso Peixe)
• DIAMONDS_TO_YOU (Diamantes para você!)
• ENCANTOS (Enchanter)
• END_PORTAL (O Fim?)
• EXPLORE_ALL_BIOMES (Tempo de aventura)
• FLY_PIG (Quando os Porcos Voam)
• FULL_BEACON (Beaconator)
• GET_BLAZE_ROD (no fogo)
• GET_DIAMONDS (DIAMONDS!)

https://riptutorial.com/ 34
 • GHAST_RETURN (Devolver ao remetente)
• KILL_COW (Tipper de vacas)
• KILL_ENEMY (Caçador de Monstros)
• KILL_WITHER (O Começo.)
• MAKE_BREAD (assar pão)
• MINE_WOOD (obtendo madeira)
• NETHER_PORTAL (Precisamos ir mais fundo)
• ON_A_RAIL (em um trilho)
• OPEN_INVENTORY (Fazendo Inventário)
• OVERKILL (Exagero)
• OVERPOWERED (Superpotente)
• SNIPE_SKELETON (Duelo de Sniper)
• SPAWN_WITHER (O Começo?)
• THE_END (Fim.)

Referência

Leia Manipulando Conquistas online:https://riptutorial.com/bukkit/topic/7690/

manipulatedachievements

https://riptutorial.com/ 35
Capítulo 11: NMS
Introdução
NMS, também conhecido comoNet.M.Server é o pacote que contém o código central do servidor
Minecraft. As classes neste pacote foram feitas por Mojang (não Bukkit) e, portanto, são ofuscadas e
não devem ser usadas ou alteradas. No entanto, interagir com o código do servidor Minecraft neste
nível permite que você modifique quase todos os aspectos dele. Isso é significativo porque existem
inúmeras modificações que o Bukkit não suporta.

Observações

A API Bukkit é um wrapper ou camada de abstração para NMS que permite aos desenvolvedores de plug-in
interagir com o servidor sem se preocupar com as alterações feitas na base de código interna.

O uso do código NMS é desencorajado, pois ele quebra frequentemente entre as alterações de versão do
Minecraft e não pode ser suportado pelo Bukkit ou Spigot, pois eles não o criam, possuem ou mantêm.

Exemplos

Acessando a versão atual do Minecraft

Uma das partes mais críticas ao lidar com o código NMS é ser capaz de oferecer suporte a várias versões do
Minecraft. Existem várias maneiras de fazer isso, mas uma solução simples é usar esse código para armazenar a
versão como um campo estático público:

public static final String NMS_VERSION =

Bukkit.getServer().getClass().getPackage().getName().substring(23);

Este trecho de código funciona usando a classe CraftServer:

org.bukkit.craftbukkit.VERSION.CraftServer.class

Obtendo seu pacote:

org.bukkit.craftbukkit.VERSION

E pegando a substring do nome do pacote começando no índice 23 que sempre estará depois de
'org.bukkit.craftbukkit.' (que tem um comprimento de 23 caracteres). Resultando na string VERSION
final:

VERSÃO

Existem várias razões pelas quais é tão importante poder acessar a versão atual do Minecraft. Principalmente
porque qualquer acesso a uma classe em um servidor executando uma versão do Minecraft diferente daquela com a
qual o plug-in estava codificando gerará um erro.

https://riptutorial.com/ 36
Aqui está um exemplo que demonstra como resolver esse problema usando oNMS_VERSIONcampo para recuperar
uma instância do CraftPlayer (que é uma classe NMS) em qualquer versão do Minecraft.

/**
* Invoca o método getHandle() na instância CraftPlayer do jogador para
* recupera a representação EntityPlayer do jogador como um objeto para
* evitar problemas de alteração de versão do pacote
*
* @param jogador
* o jogador para lançar
* @return a representação NMS EnityPlayer do jogador
*/
public static Object getCraftPlayer(Player player) {
tentar {
return Class.forName("org.bukkit.craftbukkit." + NMS_VERSION + ".entity.CraftPlayer")
. getMethod("getHandle")
. invocar(jogador);
} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException | NoSuchMethodException |
SecurityException | ClassNotFoundException e) {
lançar novo Error(e);
}
}

O objeto resultante pode então ser manipulado usando reflexão para executar tarefas baseadas em NMS sem
se preocupar em tentar acessar a versão errada da classe.

No entanto, mesmo esse método não é infalível, pois os nomes de campo e método do NMS mudam facilmente, portanto, a única
coisa que você garante ao fazer isso é que seu código definitivamente não será interrompido toda vez que o Minecraft for
atualizado.

Obtendo o ping de um jogador

Uma coisa muito simples que você pode querer fazer com o NMS que o Bukkit não suporta é obter o ping
do player. Isso pode ser feito assim:

/**
* Obtém o ping dos jogadores usando NMS para acessar o campo 'ping' interno em
* EntityPlayer
*
* @param jogador
* o jogador cujo ping para obter
* @return o ping do jogador
*/
public static int getPing(Player player) {
EntityPlayer entityPlayer = ((CraftPlayer) jogador).getHandle(); return
entityPlayer.ping;
}

Se você estiver usando um método como getCraftPlayer(Player), que retorna uma instância da instância
CraftPlayer correspondente do Player como um Object. Você pode acessar os dados sem importar as classes
dependentes da versão usando reflexão como esta:

/**
* Obtém o ping do jogador usando reflexão para evitar quebrar em um Minecraft

https://riptutorial.com/ 37
 * atualizar
*
* @param jogador
* o jogador cujo ping para obter
* @return o ping do jogador
*/
public static int getPing(Player player) {
tentar {
Objeto craftPlayer = getCraftPlayer(jogador);
return (int) craftPlayer.getClass().getField("ping").get(craftPlayer);
} catch (IllegalArgumentException | IllegalAccessException | NoSuchFieldException | SecurityException e) {

lançar novo Error(e);

}
}

Leia NMS online:https://riptutorial.com/bukkit/topic/9576/nms

https://riptutorial.com/ 38
Capítulo 12: Eventos do jogador

Introdução
Esta é uma lista de eventos do jogador e um exemplo de como usá-los.

Exemplos

PlayerJoinEvent

public class PlayerJoinListener implementa Ouvinte {

@EventHandler
public void onPlayerJoin(PlayerJoinEvent evt) {
Jogador entrou = evt.getPlayer(); String joinName
= join.getName();

//RECUPERANDO A MENSAGEM DE JOIN JÁ DEFINIDA

String joinMessage = evt.getJoinMessage();

//CONFIGURANDO A MENSAGEM DE JOIN evt.setJoinMessage(joinedName +

" entrou no jogo");

//LIMPANDO A MENSAGEM DE JOIN

evt.setJoinMessage(null);
}
}

PlayerMoveListener

public class PlayerMoveListener implementa Ouvinte {

@EventHandler
public void onPlayerMove(PlayerMoveEvent evt) {
Localização de = evt.getFrom();
Localização para = evt.getTo(); double
xFrom = from.getX(); duplo yFrom =
from.getY(); duplo zFrom = from.getZ();
duplo xTo = to.getX();

duplo yTo = to.getY(); duplo zTo

= to.getZ();

Bukkit.getLogger().info("Jogador " + evt.getPlayer().getName()

+ " moveu-se de x: " + xDe + " y: " + yDe + " z: "
+ zDe + " para x: " + xTo + " y: " + yTo + " z: " + zTo);
}
}

PlayerLoginEvent

O evento armazena detalhes para jogadores que tentam fazer login

https://riptutorial.com/ 39
 @EventHandler
public void onPlayerLogin(PlayerLoginEvent e) {
PlayertryToLogin = e.getPlayer();

//Proibindo o login de um jogador

e.disallow(PlayerLoginEvent.Result.KICK_FULL , "O servidor está reservado e cheio para
você!");

//Permitindo o login do jogador

if (e.getResult() != PlayerLoginEvent.Result.ALLOW) {
if (isVip(tryingToLogin) ){
e.allow();
}
}

//Obtendo o IP do jogador
String ip = e.getAddress();

//Obter o hostname player usado para acessar o servidor String

ipJoined = e.getHostname();

//Obtém o resultado atual da tentativa de login

PlayerLoginEvent.Result result = e.getResult();

//Definir mensagem de kick se o resultado não for

ALLOW e.setKickMessage("Você foi kickado!");

//Recupera a mensagem de kick String s

= e.getKickMessage();

PlayerLoginEvent.Result ENUM:

• PERMITIDO - O jogador tem permissão para fazer login

• KICK_BANNED - O jogador não pode logar, pois foi banido
• KICK_FULL - O jogador não tem permissão para fazer login, devido ao servidor estar cheio
• KICK_OTHER - O jogador não tem permissão para fazer login, por motivos indefinidos
• KICK_WHITELIST - O jogador não tem permissão para fazer login, por não estar na lista
branca

Eventos de cama de jogador

Evento disparado quando o jogador entra em uma cama:PlayerBedEnterEvent

PlayerBedEnterEvent(Jogador que, Bloquear cama)

@EventHandler
public void onPlayerBedEnter(PlayerBedEnterEvent e) {
Jogador digitado = e.getPlayer();

Bloco bedEntered = e.getBed();

}

https://riptutorial.com/ 40
Evento disparado quando o jogador sai da cama:JogadorCamaSairEvento

PlayerBedLeaveEvent(Jogador que, Bloco de cama)

@EventHandler
public void onPlayerBedEnter(PlayerBedEnterEvent e) {
Jogador digitado = e.getPlayer();

Bloco bedEntered = e.getBed();

}

Leia os eventos do jogador online:https://riptutorial.com/bukkit/topic/8905/player-events

https://riptutorial.com/ 41
Capítulo 13: Escala

Introdução
Como implementar plug-ins do Bukkit na linguagem de programação Scala

Exemplos

Configuração do projeto (Scala Eclipse)

Criar um projeto em scala é muito semelhante a criar um em java. Aqui está como a classe de entrada
deve se parecer:

pacote com.example.myplugin; //{$TopLevelDomain}.{$Domain}.{$PluginName}

import org.bukkit.plugin.java.JavaPlugin import

org.bukkit.command.CommandSender import
org.bukkit.command.Command

classe PluginName estende JavaPlugin {

substituir def onEnable() {

substituir def onDisable() {

override def onCommand(remetente: CommandSender, cmd: Command, label: String, args: Array[String]):
Boolean = {

falso
}

Primeiro, certifique-se de ter instalado a versão mais recente do Scala localizada aqui:https://
www.scalalang.org/download/

Em seguida, você vai querer baixar o Scala Eclipse, disponível aqui:http://scala-ide.org/e extraia o download
para uma pasta de sua preferência.

Depois que ambos estiverem instalados, basta abrir o Scala Eclipse.

Por fim, para que seu plug-in funcione - você precisa ter algum tipo de plug-in de tempo de execução para
carregar a biblioteca scala para você, eu uso este:https://dev.bukkit.org/projects/scala-loader(coloque este jar na
sua pasta de plugins como qualquer outro plugin)

Daqui em diante, o processo é quase idêntico ao java:

https://riptutorial.com/ 42
 1. PressioneAlt+Shift+N->cliqueProjeto Scala
2. Clique com o botão direito do mouse em seu projeto - cliquePropriedades

3. Clique emCaminho de Construção Java, depois clique nobibliotecasaba

4. Clique emAdicionar frascos externose selecione seu arquivo jar spigot-api
5. Clique emAplicare entãoOK

Para a configuração do projeto, você desejará criar um pacote para:

Clique com o botão direito do mouse no projeto ->Novo->Pacote

Nomeie-o como você gostaria, normalmente:com.yourdomain.pluginname

Dentro deste pacote, crie uma classe Scala e nomeie-a como quiser, normalmente:PluginName

faça a aulaestende o JavaPlugine substitua as funções fornecidas para uma configuração básica conforme mostrado
acima.

Por fim, clique com o botão direito do mouse na pasta chamada "src" e selecione Novo arquivo. Nomeie o arquivo plugin.yml
(NÃO o nome do seu plugin, mas explicitamente plugin.yml) e abra-o.

Uma implementação básica deve ficar assim:

nome: PluginName
main: com.example.pluginname.PluginName versão:
0.1

E aí está! Depois de terminar de escrever seu plug-in, clique emArquivo->Exportar->Java->arquivo jar

-> Selecione seu projeto e especifique a pasta de plugins do seu servidor como destino -> cliqueTerminar

Normalmente, você pode simplesmente recarregar seu servidor para ver as alterações após a exportação, no entantoalguns
plugins irão quebrar ao recarregar, então tome cuidado!aconselho semprereiniciandoo servidor, a menos que você saiba
que recarregar não irá quebrar outros plugins.

Leia Scala online:https://riptutorial.com/bukkit/topic/9259/scala

https://riptutorial.com/ 43
Capítulo 14: Programação do Agendador

Sintaxe
• Bukkit.getScheduler().scheduleSyncRepeatingTask(Plugin plugin, tarefa executável, int initialDelay, int
repeatingDelay)
• Bukkit.getScheduler().scheduleSyncDelayedTask(Plugin plugin, tarefa executável, int initialDelay)

• Bukkit.getScheduler().runTaskAsynchronously(Plugin plug-in, tarefa executável)

• Bukkit.getScheduler().runTask(Plugin plug-in, tarefa executável)
• new BukkitRunnable() { @Override public void run() { /* CODE */ } }.runTaskLater(Plugin plugin, long delay);

• new BukkitRunnable() { @Override public void run() { /* CODE */ } }.runTaskTimer(Plugin plugin, long initialDelay, long
repeatingDelay);

Observações

Poucos métodos de API do Bukkit são thread-safe e podem ser chamados de forma assíncrona. Por esse motivo, os
métodos da API do Bukkit devemapenas, com algumas exceções, seja executado no thread principal.

Código executado dentro deagendaSincronizarmétodos, bem como osexecutarTaskO método será executado no thread
principal.

Código executado dentro derunTaskAsynchronouslyserá executado de forma assíncrona a partir do thread principal. Os métodos
assíncronos são muito úteis para fazer grandes operações matemáticas ou de banco de dados sem atrasar o servidor, mas
causarão um comportamento indefinido se usados para chamar os métodos da API do Bukkit. Por esse motivo, os métodos da
API do Bukkit que devem ser executados após o código assíncrono devem sempre ser colocados em umexecutarTaskmétodo.

Exemplos

Tarefa de repetição do agendador

O tempo para as Tarefas do Agendador é medido em Ticks. Em condições normais, há 20 tiques por
segundo.

Tarefas agendadas com.ScheduleSyncRepeatingTaskserá executado no thread principal

Bukkit.getScheduler().ScheduleSyncRepeatingTask(plugin, novo Runnable() {

@Sobrepor
public void run() {
Bukkit.broadcastMessage("Esta mensagem é mostrada imediatamente e depois repetida a cada segundo");

}
}, 0L, 20L); // Atraso inicial de 0 Tick, 20 Tick (1 segundo) entre as repetições

Tarefa atrasada do agendador

O tempo para as Tarefas do Agendador é medido em Ticks. Em condições normais, existem 20 carrapatos

https://riptutorial.com/ 44
por segundo.

Tarefas agendadas com.ScheduleSyncDelayedTaskserá executado no thread principal

Bukkit.getScheduler().ScheduleSyncDelayedTask(plugin, novo Runnable() {

@Sobrepor
public void run() {
Bukkit.broadcastMessage("Esta mensagem é exibida após um segundo");
}
}, 20L); //Atraso de 20 Ticks (1 Segundo) antes de run() ser chamado

Executando Tarefas Assincronamente

Você pode fazer o código rodar de forma assíncrona a partir do thread principal usandorunTaskAsynchronously.
Isso é útil para fazer operações matemáticas ou de banco de dados intensivas, pois evitará que o thread
principal congele (e o servidor fique lento).

Poucos métodos da API do Bukkit são thread-safe, muitos causarão um comportamento indefinido se chamados de
forma assíncrona a partir do thread principal.

Bukkit.getScheduler().runTaskAsynchronously(plugin, novo Runnable() {

@Sobrepor
public void run() {
Bukkit.getLogger().info("Esta mensagem foi impressa no console de forma assíncrona"); //
Bukkit.broadcastMessage não é thread-safe
}
});

Executando Tarefas no Thread Principal

Você também pode fazer o código rodar de forma síncrona com o thread principal usandoexecutarTask. Isso é útil quando
você deseja chamar os métodos da API do Bukkit após executar o código de forma assíncrona a partir do thread principal.

O código chamado dentro deste Runnable será executado no thread principal, tornando seguro chamar os métodos
da API do Bukkit.

Bukkit.getScheduler().executarTask(plugin, novo Runnable() {

@Sobrepor
public void run() {
Bukkit.broadcastMessage("Esta mensagem é exibida para o servidor no thread principal"); //
Bukkit.broadcastMessage é thread-safe
}
});

Executando um BukkitRunnable

O BukkitRunnable é um Runnable encontrado no Bukkit. É possível agendar uma tarefa diretamente de um

BukkitRunnable e também cancelá-la de dentro dele.

Importante: O tempo nas tarefas é medido em Ticks. Um segundo tem 20 ticks.

https://riptutorial.com/ 45
Tarefa não repetitiva:

plug-in JavaPlugin; //Sua instância do plug-in

Long timeInSeconds = 10;
Long timeInTicks = 20 * timeInSeconds; novo
BukkitRunnable() {

@Sobrepor
public void run() {
//O código interno será executado em {timeInTicks} ticks.

}
}.runTaskLater(plugin, timeInTicks); // Sua instância do plugin, o tempo a ser atrasado.

Repetindo Tarefa:

plug-in JavaPlugin; //Sua instância do plug-in

Long timeInSeconds = 10;
Long timeInTicks = 20 * timeInSeconds; novo
BukkitRunnable() {

@Sobrepor
public void run() {
//O código interno será executado em {timeInTicks} ticks. //Depois disso, será
reexecutado a cada {timeInTicks} ticks; //A tarefa também pode cancelar a
execução, se você quiser.

if (booleano) {
this.cancel();
}

}
}.runTaskTimer(plugin, timeInTicks, timeInTicks); //Sua instância do plug-in,
//o tempo de espera até a primeira execução, //o tempo
entre as execuções.

Executando código seguro de thread de uma tarefa assíncrona

Às vezes, você precisará executar código síncrono de dentro de uma tarefa assíncrona. Para fazer
isso, simplesmente agende uma tarefa síncrona de dentro do bloco assíncrono.

Bukkit.getScheduler().runTaskTimerAsynchronously(VoidFlame.getPlugin(), () -> {

Bukkit.getScheduler().runTask(VoidFlame.getPlugin(), () -> {
Mundo mundo = Bukkit.getWorld("mundo");
world.spawnEntity(new Location(world, 0, 100, 0), EntityType.PRIMED_TNT);
});

}, 0L, 20L);

Leia Programação do Agendador online:https://riptutorial.com/bukkit/topic/5436/

schedulerprogramming

https://riptutorial.com/ 46
Capítulo 15: Gerar Ovos
Observações

Referir-seDocumentação das Entidadespara entender melhor o EntityType

Exemplos

Criando um ItemStack de um SpawnEgg

Para qualquer coisa abaixo de 1,9

SpawnEgg egg = new SpawnEgg(EntityType.CREEPER); ItemStack

creeperEgg = egg.toItemStack(5);

Para 1.9 e acima

Nas versões 1.9 e superiores, o Spigot não possui uma implementação para criar ovos de desova sem usar o
NMS. Para conseguir isso, você pode usar uma pequena classe/wrapper personalizado para fazer isso
acontecer:

public ItemStack toItemStack(quantidade int, tipo EntityType) {

ItemStack item = new ItemStack(Material.MONSTER_EGG, quantidade);
net.minecraft.server.v1_9_R1.ItemStack stack = CraftItemStack.asNMSCopy(item); NBTTagCompound
tagCompound = stack.getTag();
if(tagCompound == null){
tagCompound = new NBTTagCompound();
}
NBTTagCompound id = new NBTTagCompound();
id.setString("id", type.getName());
tagCompound.set("EntityTag", id);
stack.setTag(tagCompound);
return CraftItemStack.asBukkitCopy(pilha);
}

Leia Spawn Eggs online:https://riptutorial.com/bukkit/topic/7737/spawn-eggs

https://riptutorial.com/ 47
Capítulo 16: Versões
Exemplos

Obtendo versão em tempo de execução

@Sobrepor
public void onEnable() {
String versão = Bukkit.getBukkitVersion(); //A versão string deste servidor bukkit
}

Acessando o NMS nas versões de implementação

// obtém os objetos Class do pacote net.mminecraft.server com o nome fornecido public Class<?>
getNmsClass(String name) throws ClassNotFoundException {
// explodir o nome do pacote da implementação da interface do servidor em seus componentes String[] packageArray =
Bukkit.getServer().getClass().getPackage().getName().split("\\.");

// escolhe o componente que representa a versão do pacote, se estiver presente String

packageVersion = array.length == 4 ? matriz[3] + "." : "";

// construir o nome de classe qualificado a partir da versão do pacote obtida String qualName =
"net.minecraft.server." + pacoteVersão + nome;

// chamada simples para obter o objeto Class

return Class.forName(qualName);
}

Versões de leitura online:https://riptutorial.com/bukkit/topic/7730/versions

https://riptutorial.com/ 48
Capítulo 17: Geração mundial
Exemplos

Gerador de Vazio

A classe do gerador de void:

public class VoidGenerator extends ChunkGenerator {

@SuppressWarnings("reprovação")
public byte[] generate(World w, Random rand, int x, int z) {

byte[] resultado = novo byte[32768]; //array de tamanho de pedaço preenchido com 0 - Ar //

Construa uma plataforma com Bedrock onde o jogador irá aparecer mais tarde if(x == 0 && z ==
0)
{
resultado[xyz(0, 64, 0)] = (byte)Material.BEDROCK.getId(); resultado[xyz(1,
64, 0)] = (byte)Material.BEDROCK.getId(); resultado[xyz(0, 64, 1)] =
(byte)Material.BEDROCK.getId();
}
resultado de retorno;
}

private Integer xyz(int x, int y, int z) {

retornar (x * 16 + z)*128+y; // posição dentro do pedaço

}

Qualquer classe onde você deseja gerar um novo mundo:

public void gerarMundo(String mapName) {

tentar

{
WorldCreator w = new WorldCreator(mapName);
w.generateStructures(falso); //sem árvores, etc.
w.generator(new VoidGenerator()); //use o VoidGenerator
w.ambiente(Ambiente.NORMAL); //sem nether, etc.
w.createWorld(); //cria o mundo
}
catch(Exceção ex)
{
ex.printStackTrace();
}
}

Leia a geração do mundo online:https://riptutorial.com/bukkit/topic/6652/world-generation

https://riptutorial.com/ 49
Capítulo 18: Manipulação do Mundo

Observações

Referir-seGeração Mundialpara tópicos de geração mundial

Exemplos

Criando Explosões

Para criar uma explosão, as seguintes assinaturas de método podem ser usadas:

boolean createExplosion(double x, double y, double z, float power);

boolean createExplosion(double x, double y, double z, float power, boolean setFire); boolean
createExplosion(double x, double y, double z, float power,
booleano setFire, booleano breakBlocks);
boolean createExplosion(Location loc, float power);
boolean createExplosion(Location loc, float power, boolean setFire);

• x, y, z e loc representam o local onde você deseja que a explosão aconteça.

• power representa o poder de sua explosão, TnT power é 4F.
• setFire representa a capacidade da explosão de incendiar os blocos
• breakBlocks representa a capacidade da explosão de destruir blocos ao seu redor.
• todos os métodos retornam true se a explosão aconteceu, e retornam false se um plugin cancelou o
evento de explosão.

Simulando uma explosão de TnT que quebra blocos e incendeia em x=0, y=0 e z=0

createExplosion(0.0, 0.0, 0.0, 4F, verdadeiro, verdadeiro);

Soltando um item

Os seguintes métodos podem ser usados para soltar um item em algum lugar do mundo:

Item dropItem(Location loc, ItemStack is); Item

dropItemNaturally(Location loc, ItemStack is);

dropItemsignifica soltar um Item exatamente no local, retornando um objeto Item.

dropItemNaturalmentesignifica soltar o item no local, mas com um deslocamento aleatório, o que significa que
não será exatamente no local, mas muito próximo. Isso é feito para simular um item sendo descartado por
uma entidade ou um bloco, como um Dispenser.

Gerando uma árvore

https://riptutorial.com/ 50
Os métodos a seguir podem ser usados para gerar uma árvore naturalmente (como se fosse cultivada a partir de uma muda) no
mundo.

boolean generateTree(Location loc, tipo TreeType);

boolean generateTree(Location loc, tipo TreeType, delegado BlockChangeDelegate);

• A localização é onde você deseja que a árvore apareça

• TreeType é o tipo de árvore que você deseja gerar e pode ser um dos seguintes

enumeração TreeType

Tipo Descrição

ACÁCIA árvore de acácia

GRANDE ÁRVORE Árvore regular, extra alta com galhos

BÉTULA bétula

BROWN_MUSHROOM Grande cogumelo marrom; alto e tipo guarda-chuva

CHORUS_PLANT Grande planta nativa do Fim

CACAU_TREE Árvore da selva com plantas de cacau; 1 bloco de largura

CARVALHO ESCURO Carvalho escuro.

SELVA Árvore da selva padrão; 4 blocos de largura e altura

JUNGLE_BUSH Arbusto pequeno que cresce na selva

MEGA_REDWOOD Mega sequóia; 4 blocos de largura e altura

RED_MUSHROOM Grande cogumelo vermelho; baixo e gordo

REDWOOD Árvore Redwood, em forma de pinheiro

SMALL_JUNGLE Árvore da selva menor; 1 bloco de largura

PÂNTANO Árvore do pântano (normal com trepadeiras ao lado)

ALTO_BIRCH bétula alta

TALL_REDWOD Árvore alta de pau-brasil com apenas algumas folhas no topo

ÁRVORE Árvore normal, sem galhos

• delegado pode ser usado se você quiser que uma classe chame para cada bloco alterado como resultado deste
método

https://riptutorial.com/ 51
Ambas as assinaturas retornarão true se a árvore foi gerada com sucesso, false caso contrário.

Regras de desova

Existem algumas regras de desova em Worlds in Bukkit. Eles são:

• Desova de Animais
• Geração de Criaturas
• Quantidade acima que pode ser gerada

Desova de animais

A desova de animais pode ser dividida nas seguintes categorias:

• Animais aquáticos
• Animais terrestres

Para obter a quantidade de animais que podem ser gerados dentro do mundo em tempo de execução, você pode usar o
método

int getAnimalSpawnLimit()

Para animais terrestres e

int getWaterAnimalSpawnLimit();

Para animais aquáticos.

Ambos os limites podem ser definidos com os métodos

void setAnimalSpawnLimit(int limit); void

setWaterAnimalSpawnLimit(int limit);

Observação:Se definido para números abaixo de 0, o valor padrão do mundo será usado.

O Minecraft tenta gerar animais a cada 400 tiques (padrão). Isso pode ser alterado se você
desejar, usando as seguintes assinaturas:

void setTicksPerAnimalSpawns(int ticks); void

setTicksPerWaterAnimalSpawns(int ticks);

• Um valor de 1 significa que o servidor tentará gerar animais neste mundo a cada tick.
• Um valor de 400 significa que o servidor tentará gerar animais neste mundo a cada 400 ticks.

• Um valor abaixo de 0 será redefinido para o padrão do Minecraft.

Observação: Se definido como 0, a desova de animais será desativada para este mundo. É recomendado usar

https://riptutorial.com/ 52
setSpawnFlags(boolean, boolean) para controlar isso.

Leia World Manipulation online:https://riptutorial.com/bukkit/topic/7926/world-manipulation

https://riptutorial.com/ 53
Créditos

S.
Capítulos Contribuintes
Não

Começando com Comunidade,Drayke,ItzPamName,Jojodmo,Keenan Thompson,

1
bukkit Kerooker,kmecpp,Martin W,RamenChef,Tassu,uniedro

2 Comandos anno,Kerooker,Martin W

3 Arquivos de configuração Kerooker

4 Entidades Kerooker

5 Eventos de Entidade Alw7SHxD,Ferrybig,Kerooker,kmecpp

6 Manipulação de eventos Drayke,Jarrod Dixon,Kerooker,kmecpp,Martin W,Tassu

7 Caindo Kerooker

8 Escondendo Jogadores Kerooker

9 Exploração madeireira Kerooker

manipulando
10 Kerooker
Conquistas

11 NMS Alw7SHxD,kmecpp

12 Eventos do Jogador Ferrybig,Kerooker,Tassu

13 escala anno

Agendador
14 Ferrybig,Jojodmo,Kerooker,kmecpp,Pokéchu22
Programação

15 Gerar Ovos cara infundido,Kerooker,RamenChef

16 Versões caseif,Kerooker

17 geração mundial Drayke

18 manipulação do mundo Kerooker

https://riptutorial.com/ 54