Instruções

Como usar o Gerenciador de Campeonato

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 Gato e de Rato. 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 "bonzao". Então este módulo deve necessariamente ser colocado todo num arquivo chamado bonzao.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 'bonzao)
(in-package bonzao)
(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 'bonzao)
    

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

(in-package bonzao)
    

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 "bonzao". Note que o nome "bonzao" 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 "bonzao".

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

rato-inicia
rato-responde
gato-inicia
gato-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

   % 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 impossível em uma partida (neste caso o oponente é considerado vencedor).

   > (campeonato '(bonzao ruinzao mediao demolidor piradao bruxa ...))
   
   ; loading "bonzao.lsp"
   ; loading "ruinzao.lsp"
   BONZAO versus RUINZAO
   (RATO (8 4) (7 3)) 
   (GATO (1 1) (2 2)) 
   ...
   (VITORIA GATO) 
   ((BONZAO 20 10 0) (RUINZAO 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 de gato e de rato. 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 "rato-inicia" e "rato-responde", e o outro deverá ter "gato-inicia" e "gato-responde" (sem xx- na frente).
4. Chame a função partida com as funções jogadoras como argumentos como segue:

   > (partida #'rato-inicia #'rato-responde #'gato-inicia #'gato-responde)
       

   Isto promoverá uma partida entre o módulo que implementa o rato e o que implementa o gato.