Exemplo Hyperlink

Este script mostra como transformar um objeto num hyperlink (quase) convencional.

default
{
   state_entry()
   {
       llSetText("Acessar Hello, Avatar!", ‹1.,1.,1.›, 1.);
   }

   touch_start(integer total_number)
   {
       llLoadURL(llDetectedKey(0), "",
         "http://helloavatar.blogspot.com/");
   }
}

Ao tocar no objeto, um navegador será aberto com o endereço especificado na função llLoadURL().

Exemplo Sensor

Este simples script demonstra como utilizar sensores para detectar a presença de agentes num determinado raio, sem a necessidade de contato "físico" com eles.

default
{
  state_entry()
  {
      llSetStatus(STATUS_PHANTOM, TRUE);
      llSensorRepeat("", llGetOwner(), AGENT, 96, PI, .01);
  }

  sensor(integer total_number)
  {
      llSetPos(llDetectedPos(0) + ‹-2.0, -1.5, 1.5›);
  }
}

Neste exemplo, a posição do objeto é reajustada tão logo ele perceba a presença do avatar, dando a impressão de segui-lo.

Exemplo Cores

Este exemplo muda a cor do objeto assim que ele é tocado, variando as intensidades de vermelho, verde e azul, até atingir a cor final.

default
{
   state_entry()
   {
   }

   touch_start(integer total_number)
   {
       llSetTexture(
       "59facb66-4a72-40a2-815c-7d9b42c56f60", ALL_SIDES);

       float R = 0.; // vermelho
       float G = 0.; // verde
       float B = 0.; // azul
       float inc = 1 / 25.5;
      
       while (R ‹ 1.)
       {
           llSetColor(‹(R += inc), 0., 0.›, ALL_SIDES);
           llSleep(inc);
       }

       while (G ‹ 1.)
       {
           llSetColor(‹0., (G += inc), 0.›, ALL_SIDES);
           llSleep(inc);
       }

       while (B ‹ 1.)
       {
           llSetColor(‹0., 0., (B += inc)›, ALL_SIDES);
           llSleep(inc);
       }
   }
}

Exemplo Colisão

Este exemplo mostra como detectar colisões entre objetos.

vector pos;

default
{
 state_entry()
 {
     pos = llGetPos();
 }

 collision_start(integer total_number)
 {
     llSetStatus(STATUS_PHANTOM, TRUE);

     if (llDetectedType(0) & ACTIVE)
     {
         llSetPos(pos + ‹0, 0, 3›);
     }
 }

 collision_end(integer total_number)
 {
     llSleep(0.5);
     llSetPos(pos);
     llSetStatus(STATUS_PHANTOM, FALSE);
 }
}

a) Inicialmente, a posição atual do objeto é salva para uso posterior.

b) Quando uma colisão ocorrer, o objeto é definido como phantom (sim, do tipo que atravessa paredes) e movido para um pouco acima de sua posição inicial.

c) Em seguida, ao não ter mais contato com outros objetos, este retorna para o estado de repouso inicial.

Para ilustrar esse script em ação, tenho um vídeo (bem tosco) de uma pista de corridas que fiz nas horas vagas:

O veículo, ao atingir uma estrela, desloca-a para cima e, então, cai novamente.

Exemplo Touch

Este é um código muito simples que demonstra como tratar o contato "físico" entre o objeto no qual o script está rodando e o agente.

default
{
   state_entry()
   {
       llSay(0, "Toque-me!");
   }

   touch_start(integer total_number)
   {
       llSay(0, "Tocado por " + llDetectedName(0));
   }

   touch(integer total_number)
   {
       llSay(0, "Objeto esta sendo tocado.");
   }

   touch_end(integer total_number)
   {
       llSay(0, "Objeto foi liberado.");
   }
}

Jogo de Lógica em LSL e C#

Este documento implementa um exemplo citado no livro "Dominando o Visual Studio .NET com C#" do Fábio Câmara. Trata-se de um jogo composto por vários botões sendo que, quando um deles é clicado, o mesmo e mais seus quatro adjacentes ortogonais têm sua cor alterada. O objetivo é deixar todos os botões com a mesma cor.


Para tanto, serão necessárias apenas duas primitivas, cada uma com um script específico, demonstrados a seguir. Uma primitiva representará os botões e deverá ser colocada no inventário da outra primitiva, a principal, que será análoga a um winform.

Hora de pegar na enxada.

Vamos começar criando uma primitiva que será a root. Para isto, basta clicar o botão direito no chão de alguma ilha que permita construção, como por exemplo a MLBR Área Livre, e clicar em "Criar/Create".

Em seguida, na guia "Conteúdo/Content", criamos um novo script e introduzimos o primeiro código-fonte (sim, pode ser Ctrl+C, Ctrl+V). Código-fonte da primitiva principal.

Para facilitar, alguns fragmentos do código foram classificados e aqui estão suas respectivas explicações:

1. Na declaração de variáveis, há o número de botões (16 no total, sendo 4 por lado) e as divisões do "formulário" (9, sendo 4 botões e 5 espaços).


2. Um vetor que será o tamanho dos botões, calculado em função do tamanho da primitiva principal.


3. Ao iniciar a execução do script, o evento state_entry() ocorre, posicionando o objeto pouco mais acima e dimensionando-o para um tamanho maior.


4. Neste ponto, quando o avatar tocar o objeto, o script solicitará permissão do usuário para modificar o agrupamento de objetos, já que o resultado final será um conjunto de primitivas e não as queremos "perdidas" por aí. Também há uma verificação que permite apenas ao dono do objeto (você) iniciar as ações.


5. O evento run_time_permissions() ocorrerá quando a solicitação anterior for concedida. Como podemos ter uma única solicitação para várias permissões simultâneas combinadas pelo símbolo "|" (pipe), uma verificação é feita para nos certificarmos que se trata da desejada (note que a comparação é bit a bit, portanto, emprega-se o operador "&" - ampersand).


6. A função llGetScale() retorna as dimensões do objeto que contém o script e, daí, calcula-se o tamanho que os botões deverão ter. O cálculo pode tanto ser realizado diretamente no vetor como por suas componentes isoladas.


7. Não poderia faltar uma gambiarra. Em um form convencional, as propriedades Top e Left são relativas ao canto superior esquerdo da janela. No Second Life, as coordenadas estão localizadas no centro geométrico do objeto, daí a necessidade de "deslocá-lo" para o canto somando metade do seu tamanho menos meio botão.


8. A posição de cada botão é determinada e o mesmo é criado. Note que as coordenadas y e z são decrementadas para que os botões sejam posicionados de cima para baixo e da esquerda para a direita, conforme o sentido indicado pela regra da mão direita.


9. Efetivamente cria cada botão. Um detalhe importante é o número de identificação "i" passado pelo último parâmetro na função llRezObject(). Perceba também que o tamanho dos botões não faz parte dos parâmetros da função. Isto será resolvido (via outra gambiarra) a seguir.


10. O evento object_rez() ocorre toda vez que um objeto é instanciado pela função llRezObject(). Nele, cada novo botão é incluído no agrupamento e, assim que o grupo estiver completo (após 16 ocorrências), uma mensagem é enviada para o conjunto. Esta mensagem será recebida pelo próximo script e leva o tamanho dos botões. Gambiarra rocks!

Neste momento, uma nova primitiva deve ser criada seguindo os mesmos passos anteriores, porém com o código que segue: Código-fonte da primitiva botão.

Lembre-se que quando este segundo objeto estiver pronto, ele deverá ser copiado para o inventário do seu avatar (botão direito, "Take" ou "Take Copy") e então dali arrastado para o inventário do primeiro objeto, acessado através da guia "Conteúdo/Content" da janela de propriedades.

Novamente, seguem explicações para o segundo script:

1. Conjunto de métodos que retornam números correspondentes aos vizinhos do botão passado como parâmetro.


2. Método auxiliar que simplesmente comuta a cor do botão especificado entre verde e vermelho.


3. O evento on_rez() ocorre quando um objeto é instanciado. Para uma instância arrastada diretamente do inventário do avatar, o parâmetro inicial é zero. Para instâncias criadas através da função llRezObject(), o parâmetro start_number corresponde ao "i" passado pelo outro script e nos ajuda a identificar cada botão. Esse número pode ser considerado como o pulo-do-gato deste segundo script.


4. Define o nome do objeto, que também deve corresponder com o nome especificado na função llRezOject() do primeiro script para que o exemplo execute com perfeição.


5. O evento link_message() ocorre quando algum objeto do agrupamento envia uma mensagem através da função llMessageLinked().

   A primeira mensagem esperada é o tamanho dos botões, que foi enviada pelo script da primitiva principal.

   Note que foi usado (vector)llList2String() ao invés de somente llList2Vector(), pois esta última possui um bug conhecido e retorna ZERO_VECTOR. O mesmo ocorre com a função llList2Rot(), porém esta não foi usada neste exemplo.

   
   
6. O evento touch_start() ocorre toda vez que algum avatar toca o objeto. Neste momento, os vizinhos do botão clicado são determinados e cinco mensagens são enviadas. Estas mensagens transportam a identificação de cada botão que deve ser alterado.


7. Ao receber cada mensagem enviada no item anterior, o script verifica se ele possui o mesmo número recebido e, caso afirmativo, chama o método para trocar de cor.

   Como apenas o próprio botão clicado e seus vizinhos devem ter suas cores alteradas, o teste é necessário, pois este segundo script existirá em cada botão.

   
   
8. Mais uma mensagem é enviada, porém somente ao objeto principal, avisando que um botão foi clicado.

   Esta mensagem será recebida pelo item onze do primeiro script que, por sua vez, perguntará aos botões se ainda há algum deles com a cor verde.

   Ao receberem esta nova mensagem (item 9 do segundo script), qualquer botão que fornecer uma respota afirmativa para a primitiva principal anulará o prazo para recebimento de respostas (item 12 do primeiro script).

   Caso o prazo exceda, significa que nenhuma resposta foi recebida, ou seja, todos os botões ficaram vermelhos, logo, o avatar venceu a partida.

   
   

Pronto. Agora basta sair do modo de edição, tocar na primitiva principal (levará alguns segundos) e se divertir. Para reiniciar o jogo, basta clicar numa área livre da primitiva.

Para quem preferir, aqui está o link para download dos fontes. Também são interessantes o client do Second Life e o LSL Editor (este último precisa do .NET Framework 2.0 instalado).

Criação de Bots Pt.1

Bots: Avatares autônomos

Primeiramente, um bot é um avatar, porém controlado por software.

O termo bot aplica-se quando um avatar efetua login e age de maneira autônoma, sem intervenção do usuário. O mesmo avatar pode ou não ser um bot, dependendo da maneira como ele se conectou ao mundo virtual.

Em termos técnicos, uma aplicação escrita em (por exemplo) C# usa funções da biblioteca libsecondlife para gerenciar o bot, desde o seu login, interação com o ambiente, objetos e outros usuários, até o momento em que efetua o logout.

A libsecondlife

O projeto libsecondlife foca a compreensão do funcionamento do Second Life sob uma perspectiva técnica, além da sua integração com a web tradicional. Para os apressados, a lib pode ser obtida já compilada (em formato binário), restando apenas a tarefa de referenciá-la no projeto do bot e usar suas classes.

Como estamos tratando de programação, é claro que vamos pelo caminho mais complicado. Afinal, por quê simplesmente usar uma biblioteca se temos acesso ao código-fonte e podemos compilá-lo com as próprias mãos?

Pré-requisitos

No entanto, para a criação de bots, há alguns requisitos. É necessário um ambiente de programação e, como estou usando o janelão, sugiro o Visual C# Express, que é gratuito e pode ser obtido no site da Microsoft. Certifique-se de ter o framework .NET 2.0 ou superior instalado, além dos service packs.

No site do projeto há também instruções para os sistemas operacionais Mac OS e Linux \o/.

Também será necessário instalar o TortoiseSVN para obtermos o código-fonte diretamente da web. Opcionalmente, há o plug-in para o idioma português.

Para os não-iniciados, um source-control permite que várias pessoas trabalhem num mesmo código, de maneira organizada. A grosso-modo, temos um projeto compartilhado onde posso, por exemplo, marcar um arquivo para edição. Assim que concluir a modificação, libero-o para os demais usuários. Caso alguém tente acessar o mesmo arquivo a qualquer momento, o fonte obtido será sempre a última versão liberada.

Vamos para a segunda parte.