Além dos dois comandos básicos tratados na página anterior, todo adventure precisa dispor de meios simples e eficientes para lidar com objetos e as três operações básicas são: pegar, soltar e examinar. Mas antes vamos ver um pouco sobre a filosofia de funcionamento do sistema do jogo.

Sempre que o jogador tenta executar uma ação com objetos, o sistema monta um nome de script usando para isso o índice do verbo da frase e mais os índices das duas palavras mencionados (objetos ou não), em formato hexadecimal (o zero indica que não há objeto mencionado).

Por que duas palavras e não uma ou três? Porque com esse esquema é possível construir comandos complexos, em uma única operação, do tipo: coloque a lanterna na mala. Se tratasse apenas um objeto, essa mesma ação teria que ser desmembrada em pelo menos dois comandos sequenciais.

Por outro lado, tratar com múltiplos objetos permite também a construção de comandos interessantes, como comandos compostos do tipo: pegue a mala, a vela, a lanterna e o chapéu. O sistema irá processar esse comando desmembrando-o automaticamente em quatro comandos específicos.

A lógica de toda essa funcionalidade está na construção dos comandos básicos, montados de forma genérica. Entenda da seguinte forma: num adventure existem inúmeros objetos e a grande maioria deles não tem nenhuma especificidade em relação às operações básicas (pegar, soltar e examinar). Escrever ou repetir uma a uma essas operações para todos os objetos torna-se portanto uma tarefa monótona. Daí desenvolvermos o uso de instruções genéricas.

Por exemplo, ao digitar a frase pegue a mala, o sistema procura por um script comando cujo nome é formado pelo índice do verbo pegar, pelo índice do objeto mala e mais o zero. Não encontrando esse script, o sistema então procura por um script genérico cujo nome contém apenas o índice do verbo em questão. Temos aqui um comando "pegar" que em princípio será executado sempre que o sistema não encontrar nenhum comando específico para uma dada situação.

Tal comando não faz menção a nenhum objeto, mas o índice do objeto digitado pelo jogador ainda pode ser resgatado. Se numa instrução for usado o parâmetro OBJ1 ou OBJ2, o sistema irá resgatar exatamente o índice do primeiro ou segundo objeto digitado pelo jogador.

Por exemplo, a instrução pega objeto permite as seguintes sintaxes:

  pega MALA

Isso faz com que o sistema mude a configuração do objeto MALA, indicando que ele agora está com o jogador. No entanto, a sintaxe:

  pega obj1

obriga o sistema a mudar a configuração do primeiro objeto digitado pelo jogador o que, na prática, permite escrever o código apenas uma vez e ele valerá para todos os objetos do jogo, mesmo aqueles que forem criados durando a execução do jogo.

O sistema permite ainda que o objeto seja referenciado pelo seu índice. Por exemplo, se sabemos que o índice do objeto MALA é 5, podemos construir o comando desta forma:

  pega 5

Este tipo de construção permite inclusive que a palavra que identifica o objeto (no caso MALA) possa ser mudada durante o jogo e isso não causar prejuizo algum para a performance do comando.

Uma vez que os registradores permitem o uso de nominação, ou seja, dar nomes a eles, é possível inclusive usar essa contrução na sintaxe do comando:

  pega x1

sendo que x1 é um nome de um registrador anteriormente definido e válido. Por exemplo: definimos que o registrado 51 terá o nome x1. Assim, toda vez que a instrução pega com essa sintaxe for executada, ela pegará o índice do objeto no conteúdo deste registrador. Usamos todas as demais instruções de registradores para a manipulação do mesmo, contruindo assim comandos altamente dinâmicos.

Porém, o ato de pegar um objeto não é tão simples assim. Primeiro é preciso verificar se o objeto que o jogador prentede pegar (o nome que ele digitou) existe no jogo. Se existir, é preciso verificar se ele está na mesma posição que o jogador.

Se ele não estiver na mesma posição, mas dentro de outro objeto que esteja na mesma posição e esteja aberto, então na sequência é preciso verificar se o jogador pode de fato carregar mais um objeto.

Resolvidas essas questões, então pode-se pegar o objeto. Veja como seria montado esse comando genérico para pegar objetos:

//comando genérico para pegar objetos
  ifoext obj1,LP01
  msg= Não entendi o que é para pegar.
  fim
:LP01
  ifojog obj1,LP02
  ifoloc obj1,LP03
  msg= Neste local não tem
  msg+ obj1
  msg+ .
  fim
:LP02
  msg= Você já tem esse objeto.
  fim
:LP03
  pega obj1
  objs jog
  objs loc
  msg= Ok.

Uma vez que este tipo de operação é muito freqüente, criamos uma instrução que executa todos esses passos automaticamente. Veja como fica então o comando:

//comando genérico para pegar objetos
  x_peg obj1

Da mesma forma temos um comando sintético x_slt para soltar objetos. Apenas a ação de examinar o objeto é que deve ser escrita na sua forma desmembrada:

//comando genérico para EXAMINAR objetos
  ifoloc obj1,LP1
  ifojog obj1,LP1
  msg= Não vejo isto por aqui.
  fim
:LP1
  msg= É apenas 
  msg+ obj1
  msg+ .

Se tiver dúvida em relação ao que faz uma determinada instrução, consulte a lista de instruções, no box de edição de script, para ter uma explicação simplificada.