Instruções

Como usar o Gerenciador de Campeonato

O gerenciador de campeonato funciona perfeitamente em UNIX, conforme as instruções abaixo. Infelizmente, ainda não conseguimos fazê-lo funcionar no XLISP de PC (veja nota sobre portabilidade no final deste documento). Parece que há alguma diferença em como as packages funcionam. Quem descobrir como fazê-lo funcionar nos PCs, por favor me avise, mas não percam seu tempo com isso, pois pode ser uma tarefa sem fim.

O gerenciador de campeonato é um programa em LISP contido num arquivo chamado camp.lsp. Para usá-lo, você tem que ter pelo menos dois módulos que implementam a funcionalidade de Branco e Preto. Cada módulo deve estar num arquivo e deve ter um nome. O nome será usado para duas coisas: dar nome ao arquivo e dar nome ao pacote. Os módulos devem ser "empacotados" para evitar conflitos de variáveis e funções entre módulos diferentes. O nome escolhido para entregar o seu projeto deve ser igual ao seu login, mas para testar você pode usar qualquer nome.

Você deverá ter no mínimo dois módulos para poder jogar um contra o outro. Nao dá pra fazer campeonato com apenas um jogador. Contudo, mesmo se você tiver apenas uma implementação, poderá fabricar dois módulos iguaizinhos, mas com nomes diferentes, e colocá-los para enfrentar-se. Veja abaixo como preparar módulos e como colocá-los para jogar entre si.

Preparação de um módulo

Para exemplificar, suponha que você queira escrever um módulo de nome "ra999999". Então este módulo deve necessariamente ser colocado todo num arquivo chamado ra999999.lsp, para ser usado pelo gerenciador, e as primeiras três linhas deste arquivo devem especificar as características do empacotamento, como segue:

(make-package 'ra999999)
(in-package ra999999)
(lisp::use-package 'lisp)
    

Vamos explicar linha por linha o que significam estas operações. (Maiores explicações podem ser obtidas consultando o manual on line.)

(make-package 'ra999999)
    

Cria novo pacote, chamado "ra999999". Esta operação dá erro quando já existe um pacote chamado "ra999999". O pacote pode posteriormente ser removido pela chamada (delete-package 'ra999999).

(in-package ra999999)
    

Esta operação informa ao interpretador que a partir deste momento todas as variáveis e funções que forem definidas deverão ser colocadas dentro do pacote "ra999999". Note que o nome "ra999999" aqui vai sem apóstrofe.

(lisp::use-package 'lisp)
    

Esta operação informa o interpretador que a partir deste momento vamos usar todos os símbolos do pacote "lisp", já existente no sistema, sem qualificação. O pacote "lisp" é onde estão todas as funções pré-definidas do sistema, por exemplo, car e cdr, então é bom a gente poder usá-las sem qualificação. "Usar sem qualificação" significa poder escrever car ao invés de lisp::car, que é o jeito que teria que ser usado se a gente não faz use-package. Observe que nesta própria operação a função use-package tem que ser chamada usando qualificação, já que o pacote "lisp" não está ainda em uso no pacote "ra999999".

No resto do arquivo ra999999.lsp você deve implementar as quatro funções

branco-inicia
branco-responde
preto-inicia
preto-responde
    

Fazendo campenatos

Se você já tem vários (no mínimo dois) módulos, cada um preparado como acima, poderá usar o gerenciador para promover um campeonato entre eles, da seguinte forma.

1. Chame o xlisp (/n/lang/bin/xlisp)

   % xlisp
   XLISP-PLUS version 2.1g
   Portions Copyright (c) 1988, by David Betz.
   Modified by Thomas Almy and others.
   UNIX version
   >
       

2. Carregue o gerenciador

   > (load "camp")
   ; loading "camp.lsp"
   T
   >
       

3. Chame a função campeonato, passando como parâmetro uma lista com os nomes de todos os módulos que vão participar. A função promove os jogos de todos contra todos, imprime os lances de cada jogo e o resultado, e quando o campeonato terminar retorna o placar final. Este placar é uma lista contendo os nomes dos módulos e quantas vitórias, derrotas, e desclassificações cada módulo teve. Uma desclassificação ocorre quando um módulo faz uma jogada inválida em uma partida (neste caso o oponente é considerado vencedor).

   > (campeonato '(ra999999 ra474747 ra987654 ...))
   
   ; loading "ra999999.lsp"
   ; loading "ra474747.lsp"
   RA999999 versus RA474747
   1. BRANCO (7 1)
   2. PRETO (2 7)
   ...
   (VITORIA BRANCO) 
   ((RA999999 20 10 0) (RA474747 3 27 0) ... )
       

Portabilidade

1. Chame o xlisp
2. Carregue o gerenciador (dê o pathname completo)

   > (load "c:/joao/lisp/mc600/camps/camp")
   T
       

3. Carregue seus módulos. Cuidado: os módulos não podem compartilhar nenhuma variável ou função! Se você quiser fazer um módulo jogar contra si mesmo, modifique todos os símbolos em um dos módulos para que não haja conflitos, por exemplo, coloque xx- na frente de todos os nomes.

   > (load "modulo1")
   T
   > (load "modulo2")
   T
       

   Outra coisa importante: apenas um dos módulos deverá ter as funcoes "branco-inicia" e "branco-responde", e o outro deverá ter "preto-inicia" e "preto-responde" (sem xx- na frente).
4. Chame a função partida com as funções jogadoras como argumentos como segue:

   > (partida #'branco-inicia #'branco-responde #'preto-inicia #'preto-responde)
       

   Isto promoverá uma partida entre o módulo que implementa o branco e o que implementa o preto.