Conteúdo


Criar plug-ins cognitivos para Minecraft com IBM Cloud, Docker e Watson, Parte 2

Construindo plug-ins para Minecraft com Docker e Eclipse

Comments

Conteúdos da série:

Esse conteúdo é a parte # de # na série: Criar plug-ins cognitivos para Minecraft com IBM Cloud, Docker e Watson, Parte 2

Fique ligado em conteúdos adicionais dessa série.

Esse conteúdo é parte da série:Criar plug-ins cognitivos para Minecraft com IBM Cloud, Docker e Watson, Parte 2

Fique ligado em conteúdos adicionais dessa série.

Na Parte 1 você aprendeu como configurar um servidor Minecraft não modificado, pronto para utilização, no Docker e um servidor Spigot no Docker. Esta é a primeira etapa para criar seus próprios plug-ins do Minecraft que podem aproveitar os vários serviços, incluindo os serviços cognitivos do Watson, disponíveis no IBM Cloud, no ambiente de plataforma como serviço (PaaS) da IBM. O uso destes serviços tornará sua experiência em jogo mais inteligente e mais agradável.

Mas você não pode simplesmente atravessar uma montanha com um pulo. É necessário concluir algumas etapas adicionais antes que você possa desenvolver plug-ins que possam usar os serviços do Watson. Na Parte 2 nós o guiaremos pela próxima etapa na configuração de seu ambiente de desenvolvimento local: configurar o Eclipse, em seguida, desenvolver, construir e exportar seu próprio plug-in do Minecraft do lado do servidor para uma imagem do Docker local.

Nós executaremos todo o desenvolvimento no ambiente de desenvolvimento integrado (IDE) do Eclipse. O Eclipse é um ambiente de desenvolvimento grátis, de software livre, para Java® e várias outras linguagens. É possível escolher quase todo desenvolvimento de plug-in do Java IDE para Minecraft, mas o Eclipse é usado comumente na comunidade de desenvolvimento do Minecraft entre aqueles que usam um IDE.

Configurar o Eclipse no Ubuntu

Para usar o Eclipse IDE, é necessário primeiro instalar Java em seu ambiente Ubuntu Linux. O Eclipse não é apenas um ambiente para desenvolver programas em Java, mas é um programa Java em si. O comando para instalar Java deve parecer familiar porque o usamos em nossos Dockerfiles na Parte 1. No entanto, neste momento você precisa executar o comando na linha de comando de sua instalação do Ubuntu Linux:

sudo apt-get install openjdk-7-jdk

Assim que você tiver instalado o JDK versão 7 com sucesso, terá uma opção:

  • Se você estiver mais confortável usando a GUI do Ubuntu, acesse a página de downloads do Eclipse e selecione o release do Eclipse Mars, em seguida, faça download do arquivo de instalação para Eclipse. O arquivo de instalação está na forma de um arquivo tar compactado. Clique duas vezes no arquivo tar no gerenciador de arquivos do Ubuntu para abri-lo com o Archive Manager. Em seguida, use o gerenciador de arquivos para extrair o conteúdo do arquivo para um diretório denominado "eclipse".
  • Se você estiver mais confortável usando a linha de comando, emita os comandos a seguir, um por vez:
    wget
    "https://eclipse.org/downloads/download.php?file=
    /technology/epp/downloads/release/mars/R/eclipse-jee-mars-R-linux-gtk-x86_64.tar.gz&r=1"
    -O eclipse-jee-mars-R-linux-gtk-x86_64.tar.gz
    
    tar -xzf eclipse-jee-mars-R-linux-gtk-x86_64.tar.gz

Independentemente de como você transferiu por download e instalou o Eclipse, você o inicia da mesma maneira. Assumindo que você o instalou fora de seu diretório inicial, digite o comando a seguir na linha de comando para iniciar o Eclipse:

./eclipse/eclipse

Assim que o Eclipse iniciar, será perguntado se você deseja criar uma nova área de trabalho padrão ou usar uma existente. Prossiga e crie a área de trabalho padrão no diretório especificado.

Workspace launcher
Workspace launcher

Na tela de boas-vindas do Eclipse, clique no ícone de ambiente de trabalho no canto superior direito para abrir o ambiente de trabalho.

Workbench icon

Você vê o Ambiente de Trabalho do Eclipse:

Eclipse workbench
Eclipse workbench

Importar o archive

Usaremos o recurso Importação de Projeto do Eclipse para importar um Project Archive que inclui nosso exemplo. Os projetos no Eclipse são simplesmente estruturas de diretório em seu diretório da área de trabalho. Um Project Archive é um formato de arquivo zip especial para Eclipse que permite compartilhar seus projetos completamente configurados com outras pessoas. Assim que trouxermos o projeto para o Eclipse, analisaremos o código de exemplo. O arquivo de importação de archive está localizado na raiz do diretório minecraft-project que você clonou a partir do GitHub na Parte 1, portanto, se você estiver tentando ir para este tutorial sem seguir todos os exemplos na Parte 1, precisará voltar e executar esse clone.

  1. Selecione Arquivo > Importar no menu na parte superior do Ambiente de Trabalho do Eclipse.
  2. Selecione Geral > Projetos Existentes na Área de Trabalho, em seguida, clique em Avançar. Import dialog
    Import dialog
  3. Selecione Selecionar Archive, em seguida, clique em Procurar. Import dialog
    Import dialog
  4. Navegue para o diretório para o qual você clonou (provavelmente seu diretório inicial, embora isso dependa do que você fez na Parte 1) e abra o diretório minecraft-project. Selecione SpigotPlugin.zip e clique em OK. Import dialog
    Import dialog
  5. Clique em Concluir.
  6. Na Área de Trabalho, você verá um ponto de exclamação vermelho (!) ao lado de SpigotProject. Isto está ok — está apenas nos alertando que precisamos corrigir o caminho de classe para apontar para o arquivo spigot-1.8.3.jar para que o código Java para nosso plug-in seja compilado (como nosso código depende das APIs Spigot, precisamos importar essas APIs).

    Selecione SpigotPlugin.zip na área de janela Projeto. Clique com o botão esquerdo (em outras plataformas, Alt-Enter ou clique enquanto mantém a tecla Control pressionada) e selecione Propriedades no menu pop-up, em seguida, selecione Caminho de Construção Java. Selecione a guia Bibliotecas.

    Import dialog
    Import dialog
  7. Selecione Spigot1.8.3.jar e clique em Editar. Import dialog
    Import dialog
  8. Clique duas vezes em minecraft-project, em seguida, selecione Spigot1.8.3.jar na próxima área de janela.

    Se você estiver seguindo de perto, poderá estar preocupado que este arquivo JAR do Spigot não corresponde ao nível do arquivo JAR do Spigot que foi criado no exemplo anterior (o qual estava no nível 1.8.8). Na verdade, como estamos usando este arquivo JAR somente para permitir que nosso código seja compilado, não há problema se ele está em um nível anterior — a API não mudou durante esse tempo. Se, em seu próprio código, isto se tornar um problema posteriormente, siga as instruções na wiki Spigot Build Tools para criar localmente um novo arquivo JAR spigot e substituir aquele que você transferiu por download a partir do GitHub.

  9. Clique em Aplicar, em seguida, clique em OK, em seguida, em OK novamente.

Neste ponto, sua área de trabalho deve mostrar o projeto SpigotPlugin sem pontos de exclamação vermelhos próximos a ele, o que significa que você resolveu o problema e pode avançar com nosso exemplo.

Desenvolver plugins para Minecraft

A API do plug-in Spigot é de fato muito simples. Se você já usou Java para outros tipos de programação do lado do servidor, como criar servlets, achará isso um exemplo direto dos mesmos princípios. O motivo pelo qual estamos instalando um JDK (Java 1.7) específico é que plug-ins no Minecraft (ou pelo menos aqueles que usam as APIs do Bukkit) devem ser criados no Java 1.7. Caso contrário, você obterá erros de incompatibilidade de classe estranhos no servidor. Isto pode mudar no futuro, mas, por enquanto, é melhor utilizar Java 1.7 para seu desenvolvimento.

A classe HelloWorld

Vamos iniciar consultando um plug-in simples para Minecraft que é o equivalente do programa Hello World em qualquer linguagem de programação. Usaremos este arquivo para revisar alguns dos recursos mais simples da API do Bukkit.

  1. Para iniciar, exiba o arquivo de código-fonte de plug-in na área de janela do projeto do Ambiente de Trabalho do Eclipse clicando e expandindo SpigotPlugin.
  2. Clique e expanda src, em seguida, expanda o diretório com.ibm.minecraftplugin .
  3. Clique em HelloWorld.java.

Vamos consultar o conteúdo do arquivo HelloWorld.java:

package com.ibm.minecraftplugin;

import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.plugin.java.JavaPlugin;

public class HelloWorld extends JavaPlugin {

    public void onEnable(){
        getLogger().info("Hello World!");
    }
    
    public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args)
    {
    if (cmd.getName().equalsIgnoreCase("hello")) {
    sender.sendMessage("Hello Everybody!");
    }
    return false;
    }
}

Há dois conceitos simples que você precisa entender. Primeiro, criar um plug-in é tão simples quanto estender a classe JavaPlugin , portanto, todos os seus plug-ins serão subclasses de JavaPlugin. Segundo, você precisará implementar dois métodos em cada classe de plug-in:

  • onEnable() é um manipulador de eventos que é chamado quando o servidor carrega o plug-in. Você executa qualquer configuração necessária para a classe neste método (por exemplo, configurar uma conexão com o banco de dados). Estamos aplicando um método de depuração padrão, que é registrar algumas informações de status no criador de logs de modo que, quando o plug-in for carregado, você possa ver resultados na saída de log.
  • onCommand() é chamado cada vez que um usuário emite um comando do Minecraft com /&COMMAND&. Cada plug-in deve determinar se o comando pode ser manipulado pelo plug-in (que é tão simples quanto comparar o nome do comando com um nome correspondente que o plug-in pode manipular) e, em seguida, executar quaisquer ações que sejam necessárias.

Em nosso exemplo, assim que tivermos validado que o comando pode ser manipulado pelo plug-in, nós simplesmente enviamos a mensagem "Hello Everybody!" ao emissor do comando. É trivial, mas é suficiente para ver como o conceito funciona. Se desejar, você pode mudar a mensagem de log que o método onEnable() grava, ou a mensagem que o comando envia de volta ao usuário para customizar seu plug-in.

Arquivo Plugin.yml

A parte final da configuração requerida para um plug-in do Bukkit funcionar envolve o arquivo Plugin.yml. Este arquivo de configuração descreve seu plug-in para o restante da estrutura. Ele é gravado em YAML (Yet Another Markup Language) como muitos outros arquivos de configuração que você verá nesta série de tutoriais. Uma coisa a ter em mente é que você não pode usar guias nos arquivos de plug-in do YAML.

Para examinar seu arquivo plugin.yml, dê um clique duplo no arquivo dentro do Projeto SpigotPlugin. Os conteúdos do arquivo são:

name: HelloWorld
main: com.ibm.minecraftplugin.HelloWorld
version: 1.0
commands:
  hello:
    description: A new command

Como você pode ver, é muito simples: você especifica o nome de seu plug-in, a classe principal e a versão na parte superior do arquivo. Quaisquer comandos que são manipulados por sua classe devem ser listados (indentação de um espaço) após a seção commands: . No exemplo aqui, estamos mostrando somente a seção description do comando, mas existem outras seções que você pode usar se examinar a documentação de YAML do Plug-in.

Testar localmente

Agora que você gravou o código de seu primeiro plug-in, está pronto para exportá-lo e experimentá-lo.

É possível ignorar a próxima seção sobre exportação de um arquivo JAR se simplesmente desejar usar o exemplo de arquivo HelloWorld.jar pré-construído fornecido. Se você não fizer nenhuma mudança em seu código, essa é a opção mais rápida. Se você tiver feito qualquer mudança, precisará seguir as etapas na próxima seção para experimentar seu novo código.

Exportar seu arquivo JAR

Para exportar seu arquivo JAR, conclua estas etapas:

  1. No Ambiente de Trabalho, selecione o projeto SpigotPlugin e clique com o botão esquerdo para exibir o menu, em seguida, selecione Exportar.
  2. No diálogo Exportar, selecione Java > Arquivo JAR e clique em Avançar. Export window
    Export window
  3. No diálogo de especificação do arquivo JAR, clique em Procurar.
  4. No diálogo de seleção do arquivo, navegue para o subdiretório spigot-plugin de seu diretório minecraft-project e selecione HelloWorld.jar, em seguida, clique em OK. Jar file selection dialog
    Jar file selection dialog
  5. De volta no diálogo de especificação do arquivo JAR, clique em Sobrescrever arquivos existentes sem aviso, em seguida, clique em Concluir. JAR file specification dialog
    JAR file specification dialog

Seu novo arquivo JAR agora substituiu o antigo. É hora de ver se seu código funciona!

O novo Dockerfile

Assim como no último exemplo, usaremos um novo Dockerfile que construirá o exemplo dentro de uma imagem do Docker. Primeiro, abra uma segunda janela do terminal no Ubuntu — assim você pode executar comandos do Docker enquanto o Eclipse ainda está em execução. Na nova janela do terminal (assumindo que você está no diretório inicial e que também é onde você clonou o diretório minecraft-project), digite os dois comandos a seguir:

cd minecraft-project/spigot-plugin
cat dockerfile

Você verá o novo Dockerfile para este exemplo, conforme mostrado abaixo. Reserve um tempo para ler ele inteiro e veja se você pode indicar as diferenças a partir do nosso último exemplo de Dockerfile.

# Version 0.0.3
# This version builds a spigot server
# using the recommended build strategy for spigot
# This is advantageous in that it’s better for plugin development
# and fits well with the Docker approach
# it also adds a first Minecraft plugin into the bare spigot server
#
FROM ubuntu:14.04
MAINTAINER Kyle Brown "brownkyl@us.ibm.com"
RUN apt-get update
RUN apt-get install -y git
RUN apt-get install -y default-jdk
RUN apt-get install -y wget
RUN mkdir minecraft
RUN wget "https://hub.spigotmc.org//jenkins/job/BuildTools/lastSuccessfulBuild/artifact/target/BuildTools.jar" -O minecraft/BuildTools.jar
RUN java -jar minecraft/BuildTools.jar
RUN echo "eula=true" > eula.txt
RUN mkdir plugins
ADD HelloWorld.jar /plugins/HelloWorld.jar
CMD java -XX:MaxPermSize=128M -Xms512m -Xmx1024m -jar spigot-1.8.8.jar nogui
EXPOSE 25565

Como você provavelmente observou, isto é muito semelhante ao exemplo 0.0.2 do Dockerfile que vimos na Parte 1 desta série, mas com algumas diferenças. Primeiro, este cria um novo diretório chamado "plugins". Segundo, ele então executa um novo comando no Docker que você não viu: ADD.

O comando ADD obtém um arquivo de seu diretório (host) local e o copia no arquivo do Docker — isto é legal! É exatamente o que desejamos em nosso exemplo — desejamos a capacidade de mudar nosso arquivo de plug-in enquanto deixamos todo o resto isolado. No entanto, diferente do comando CMD , que é executado toda vez que você inicia um novo contêiner com run do Docker, o comando ADD é executado somente quando você executa um build do Docker. Isso significa que, se você fizer mudanças em seu plug-in, precisará reconstruir sua imagem. Para este exemplo, vamos criar nossa nova imagem pela primeira vez digitando o comando a seguir na linha de comando:

sudo docker build -t="<directory>/spigot188-plugin" .

Assim como você fez na Parte 1, substitua <directory> por seu ID de login. Na primeira vez que você cria a nova imagem, pode demorar um pouco mais do que em construções subsequentes porque o Docker constrói algumas das novas camadas de imagem.

Agora que você criou a nova imagem, é hora de executá-la! Para fazer isto, digite o comando a seguir:

sudo docker run -i -t -p=25565:25565 <directory>/spigot188-plugin

Como você está iniciando o contêiner do Docker na mesma porta que anteriormente, você não precisa mudar a configuração do cliente Minecraft. Você localizará a primeira indicação de que seu plug-in está funcionando nos logs na tela do servidor Minecraft — procure uma linha como esta:

[14:22:50 INFO]: Done (12.942s)! For help, type "help" or "?"

Assim que você tiver certeza de que o servidor iniciou com sucesso, inicialize o cliente Minecraft, conecte-se com seu servidor e, em seguida dentro do tipo de Minecraft:

/hello

Sua tela de comandos do Minecraft deve ser semelhante a isto:

Minecraft screen
Minecraft screen

Se você vir a mensagem "Hello Everybody" (ou qualquer que seja a mensagem para a qual você alterou), ele está funcionando. Parabéns!

Conclusão

Na Parte 2 desta série de tutoriais, você aprendeu como criar um plug-in simples do lado do servidor para Minecraft usando o Eclipse, e como executá-lo no Docker. Na Parte 3, você levará seu plug-in para o próximo nível — você o colocará em execução na web no IBM Cloud.


Recursos para download


Temas relacionados


Comentários

Acesse ou registre-se para adicionar e acompanhar os comentários.

static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Cloud computing, Tecnologia Java, Cognitive computing
ArticleID=1025984
ArticleTitle=Criar plug-ins cognitivos para Minecraft com IBM Cloud, Docker e Watson, Parte 2: Construindo plug-ins para Minecraft com Docker e Eclipse
publish-date=01222016