MC336 - Paradigmas de Programação

Turma A - Primeiro Semestre de 2008

Voltar à pagina inicial da disciplina

Instruções para o jogador em Java

Introdução

A criação e execução do jogador em Java é um pouco mais complexa do que foi em Lisp e em Prolog. Nestas últimas, era necessário apenas enviar ao campeonato um arquivo contendo o código fonte, que precisava apenas conter as funções (ou cláusulas) previamente especificadas.

Além disso, os ambientes de Lisp e Prolog são baseados em linha de comando, o que permite diretamente a chamada das funções (ou cláusulas) definidas. O modo como Java foi implementado, por outro lado, deixa a impressão de que os desenvolvedores da linguagem não contavam com a hipótese de alguém querer utilizar a linha de comando em detrimento de uma interface gráfica.

Para contornar esse problema, foi implementado um “emulador” da linha de comando, o que faz com que a execução do jogador em Java enviado ao campeonato se assemelhe um pouco com a execução dos jogadores nas outras duas linguagens. Para que essa idéia funcione é preciso que os jogadores enviados ao campeonato se comportem da maneira esperada.

O presente documento visa instruir os alunos a criar um jogador que seja considerado válido para o campeonato. Para tanto, pressupõe-se que você já tenha algumas noções de orientação a objetos em Java.

Arquivos necessários

Para acompanhar as intruções é necessário que você tenha em seu computador:

Biblioteca catlib

A biblioteca catlib é composta por um conjunto de classes necessárias para que o seu código seja compilado e assim, você possa testá-lo. A figura abaixo mostra as classes/interfaces e respectivos métodos, bem como os relacionamentos existentes entre eles.

Recomenda-se fortemente utilizar o javadoc para obter informações detalhadas sobre cada classe antes de continuar.

Criação do jogador

Para criar o seu jogador o ponto de partida será o jogador vazio. Para tanto, utilize o editor de texto de sua preferência.

Observe no jogador vazio a declaração da classe pública:

public class raxxxxxx implements ContainerInterface {

Indica que o a classe pública satisfaz o comportamento especificado pela interface ContainerInterface, cuja definição está na biblioteca catlib.jar vista na seção anterior. O fato de implementar esta interface indica que esta classe é um repositório de onde podem ser extraídas instâncias de jogadores através dos seguintes métodos:

public PlayerInterface getCatPlayer(); public PlayerInterface getCatcherPlayer();

Perceba que ambos os métodos já possuem uma implementação padrão no jogador vazio que, em geral, não precisará ser mudada. Note também que as instâncias dos jogadores devem implementar uma outra interface, chamada PlayerInterface. Estas duas interfaces, em conjunto, permitem que o seu jogador “converse” com o campeonato.

Observe agora a linha que declara a classe do jogador ‘gato’ no seu repositório.

private class Cat extends AbstractCatPlayer {

Diferente do que foi feito anteriormente, não foi declarado explicitamente que a classe Cat obedece a interface PlayerInterface. Isto ocorre porque está implícito na herança que a interface PlayerInterface é implementada, pois a classe Cat herda o comportamento de AbstractCatPlayer que, por sua vez, herda de AbstractPlayer que, finalmente, implementa PlayerInterface.

A herança é necessária porque as classes AbstractCatPlayer e AbstractPlayer implementam código que você pode reutilizar. Ou seja, se você modificar a linha acima para:

private class Cat implements PlayerInterface {

e escrever pessoalmente os métodos requeridos por PlayerInterface, o seu código não será aceito pelo campeonato, apesar de cumprir todos os requisitos necessários para interagir com ele.

Continuando no arquivo do jogador vazio você observará que cada classe interna possui a mesma lista dos métodos que precisam ser implementados:

public Position calcMove()
public boolean validMove(Position myMove)

No próprio jogador vazio você encontrará um resumo do objetivo de cada método. Dessa forma, observe os comentários no início de cada método antes de implementá-lo.

Recomenda-se que, antes de começar a escrever seu jogador, você já esteja familiarizado com a classe Position, para tanto, verifique no javadoc o construtor da classe e o sumário dos métodos implementados por ela. A classe Position implementa simplesmente as coordenadas de uma posição no tabuleiro, mas você pode estender esta classe caso queira atribuir mais informações a cada posição.

Método de compilação

Para compilar o seu jogador localmente (recomendamos que faça isso antes de enviar ao servidor) você poderá optar por utilizar a biblioteca compilada catlib.jar ou o código fonte catlib.zip.

Utilizando a biblioteca catlib.jar

O comando para compilar o código é o javac, que deverá receber a localização do arquivo jar através da opção classpath. Dessa forma, procure no seu computador pelo executável javac que, por padrão, está na pasta bin do diretório onde você instalou o JDK.

Supondo que eu instalei o JDK no diretório C:\Arquivos de programas\Java\jdk1.6.0_05 e coloquei o arquivo catlib.jar no diretório C:\java, a linha de comando para compilar o arquivo raxxxxxx.java é:

C:\Arquiv~1\Java\jdk1.6.0_05\bin\javac -classpath C:\java\catlib.jar raxxxxxx.java

Observe que você deverá executar esse comando no mesmo diretório do arquivo raxxxxxx.java.

Utilizando o código fonte catlib.zip

A maneira mais fácil de utilizar o código fonte é descompactá-lo e copiar o seu jogador para dentro da pasta catlib criada, onde há o arquivo CLInterpreter.java e a pasta unicamp.

Supondo que você seguiu o procedimento acima, o comando para compilar o seu código é:

C:\Arquiv~1\Java\jdk1.6.0_05\bin\javac raxxxxxx.java

Interface de execução

Agora que você já está com o jogador compilado, é possível testá-lo.

Utilizando a biblioteca catlib.jar

Execute a classe CLInterpreter passando como parâmetro a palavra cat ou catcher (para executar o gato ou o pegador respectivamente) e o nome do seu jogador, mas sem a extensão .java.

C:\Arquiv~1\Java\jdk1.6.0_05\bin\java -jar C:\java\catlib.jar catcher raxxxxxx

O prompt de comando ficará piscando na próxima linha, sinal de que está aguardando que você entre com alguma informação. Vá para a seção “Interagindo com a linha de comando".

Utilizando o código fonte catlib.zip

Primeiramente você deverá compilar o arquivo CLInterpreter.java.

C:\Arquiv~1\Java\jdk1.6.0_05\bin\javac CLInterpreter.java

Após isso, você executa a classe CLInterpreter passando como parâmetro a palavra cat ou catcher (para executar o gato ou o pegador respectivamente) e o nome do seu jogador, mas sem a extensão .java.

C:\Arquiv~1\Java\jdk1.6.0_05\bin\java CLInterpreter catcher raxxxxxx

Interagindo com a linha de comando

Nas subseções anteriores, você iniciou a linha de comando e definiu se quer jogar contra o seu gato ou contra o seu pegador. Agora que a linha de comando está aguardando uma informação, você deverá, primeiramente, passar a posição inicial do gato e o tabuleiro.

Por exemplo, inicie o gato na posição (6,6) e as casas (1,2), (2,3) e (3,4) bloqueados da seguinte maneira:

(6,6) (1,2;2,3;3,4)

Será devolvida a palavra ok. Indicando que o jogo já pode começar. A partir de agora você deverá informar as suas jogadas e receber as respostas do seu jogador no formato (x,y). Vale ressaltar que espaços não são permitidos.

A seguir, a demostração de um jogo.

(6,6) (1,2;2,3;3,4)
ok
(6,5)
(7,5)
(6,4)
(7,4)
(7,3)
(8,3)
(7,2)
(8,2)
(8,1)
(9,1)
(10,1)
(8,2)

Como você notou no jogo acima, não há uma verificação para saber se o jogo acabou e, muito menos, para saber se alguma das jogadas foi inválida. Espera-se que, localmente, você seja capaz de identificar ambos os eventos. Entretanto, durante o campeonato, assim como ocorreu nos campeonatos anteriores, a sua jogada será validada e o sistema identificará o término da partida.

Por fim, caso você insira algum erro na linha de comando, uma mensagem será enviada a você indicando a informação esperada pelo sistema.