Hello, Avatar!

Exemplo Hyperlink

2009-03-24T22:25:00.000-07:00

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

2009-03-24T22:21:00.000-07:00

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

2009-03-24T22:13:00.000-07:00

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

2009-03-24T21:54:00.000-07:00

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

2009-03-24T21:44:00.000-07:00

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#

2008-06-23T17:34:00.000-07:00

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:

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).

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

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.

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.

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).

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.

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.

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.

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.

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:

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

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

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.

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.

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.
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.

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.
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

2008-05-31T23:04:00.000-07:00

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.

Criação de Bots Pt.2

2008-05-31T22:54:00.000-07:00

Obtendo a lib

Instalados o Visual C# e o TortoiseSVN, seguem os demais passos.

1. Coloque Delicate Sound of Thunder do Pink Floyd para tocar (senão não compila).
2. Criar uma pasta C:\dev e uma subpasta C:\dev\libsecondlife
3. Clicar o botão direito sobre a subpasta libsecondlife e escolher SVN Checkout.
4. Colocar svn://opensecondlife.org/libsl/trunk no campo URL of Repository.
5. Clique OK e aguarde o recebimento dos arquivos.
6. Em dev\libsecondlife\libsecondlife, abra um dos arquivos .sln ou .proj.
7. No Visual C#, em Solution Explorer, clique direito em Solution 'libsecondlife' e em Build Solution.
8. Busque uma cerveja (para compilar em modo otimizado).

Criando um projeto

Vamos então conceber a criança. Na documentação oficial, é sugerido criar um novo projeto na própria solução libsecondlife. Se alguém preferir criar uma solução nova para os testes, à vontade.

1. No Visual Studio (ou Visual C#, ou VC# como vou usar adiante), localize o painel Solution Explorer, clique o botão direito e selecione Add -> New Project.

2. Na caixa New Project, selecione Empty Project, nomeie-o como MyFirstBot e confirme em OK.

Os próximos passos são os mais importantes em muitos projetos, pois nos permite usar classes e funções disponíveis em bibliotecas externas ao projeto (produtos de terceiros, por exemplo).

3. No projeto MyFirtsBot criado, clique o direito sobre References e selecione Add Reference.

4. Na aba Projects, selecione libsecondlife na lista e confirme. Se você optou por criar uma nova solução para o projeto do bot, vá até a aba Browse e localize o arquivo C:\dev\libsecondlife\bin\libsecondlife.dll.

5. Clique direito no projeto MyFirstBot e vá em Add -> New Item.

6. Selecione o template Class, nomeie o arquivo como MyFirstBot.cs e confirme clicando em Add.

Essa parte foi tranqüila. Vamos para a terceira.

Criação de Bots Pt.3

2008-05-31T22:40:00.000-07:00

Codificando o bot

Embora tenha seguido o how-to até agora, vou simplificar o texto. Qualquer dúvida, os links originais são sempre citados, os comentários estão habilitados e minha disposição é sempre positiva.

Obviamente, os passos anteriores devem ter sido bem-sucedidos e é necessário conhecer a linguagem de programação C# (outras como VB.NET ou C++ também são possíveis).

Coloque o álbum A Night At The Opera do Blind Guardian e vamos programar.

1. Primeiramente, podemos acrescentar o namespace libsecondlife para simplificar a codificação, incluindo no topo do arquivo-fonte:

using libsecondlife;

2. Em seguida, declarar um objeto membro da classe MyFirstBot que será a própria instância do Second Life em execução e que fará todas as ações.

static SecondLife client = new SecondLife();

3. Precisamos também de um ponto de entrada para nossa aplicação, ou seja, um método capaz de iniciar todas as atividades necessárias.

public static void Main()
{
}

4. Pela sua característica assíncrona, a ocorrência de muitas coisas é tratada através de algum evento correspondente. Podemos, por exemplo, identificar quando algum contato tornou-se on-line, quando o grid caiu ou quando recebemos um pedido de amizade e, então, tomar as providências necessárias.

Em termos de programação, é necessário acrescentar um handler (manipulador) de eventos que aponta para o método a ser executado quando algo previsto ocorrer. Para identificar quando o bot logou, incluímos no código a linha:

client.Network.OnConnected += new
   NetworkManager.ConnectedCallback(Network_OnConnected);

5. Ao digitar o += pressione a tecla TAB duas vezes para gerar o método associado automaticamente. Caso contrário, digite manualmente. Teremos então:

static void Network_OnConnected(object sender)
{
 throw new Exception
   ("The method or operation is not implemented.");
}

6. Se usou o TAB, exclua a linha "throw new Exception..."

7. De volta ao método Main(), abaixo da linha do handler vai o código responsável pelo login do avatar. Substitua os parâmetros nome, sobrenome e senha por valores válidos.

if (client.Network.Login("nome", "sobrenome",
      "senha", "My First Bot", ""))
{
  Console.WriteLine("Bot logado com sucesso");
}
else
{
  Console.WriteLine("Falha no login: "
     + client.Network.LoginMessage);
}

8. No método Onconnected() acrescentamos um código para simplesmente dizer um "Olá, mundo" já dentro do Second Life.

static void Network_OnConnected(object sender)
{
  client.Self.Chat("Ola, mundo", 0, ChatType.Normal);
  client.Network.Logout();
}

O bot aparecerá no seu local de nascimento normalmente e, dependendo da sua configuração, poderá ser o último local onde o avatar foi deixado ou um ponto pré-definido.

9. Ainda no método anterior, o bot é deslogado.

Certifique-se de que o MyFirstBot será o projeto executado dentre os demais da solução clicando o direito sobre o projeto (no Solution Explorer) e selecionando Set As StartUp Project. MyFirstBot deverá ser mostrado em negrito.

10. Rode o projeto, coloque Apocalyptica para tocar e busque mais cerveja.

Agora é explorar a classe SecondLife e o que ela oferece. Praticamente tudo o que for possível de se fazer in-world. Segue meu código completo:

using System;
using libsecondlife;

namespace MyFirtsBot
{
class MyFirstBot
{
  static SecondLife client = new SecondLife();

  public static void Main()
  {
    client.Network.OnConnected += new
        NetworkManager.ConnectedCallback
        (Network_OnConnected);

    if (client.Network.Login("nome", "sobrenome",
          "senha", "My First Bot", ""))
    {
      Console.WriteLine("Bot logado com sucesso");
    }
    else
    {
      Console.WriteLine("Falha no login: "
          + client.Network.LoginMessage);
    }
  }

  static void Network_OnConnected(object sender)
  {
    client.Self.Chat("Ola, mundo", 0, ChatType.Normal);
    client.Network.Logout();
  }
}
}

Simples.

O Propósito

2008-05-31T20:21:00.001-07:00

Aqui estamos novamente. Resolvi criar um novo blog para atacar mais a fundo a programação para Second Life e sua integração com a web. Sim, afinal, o metaverso da californiana Linden Labs não está restrito apenas a ele mesmo.

Minha birra com as produções atuais são as ilhas do tipo "visite e não volte", que até são bem modeladas, mas pouco oferecem em termos de interação. E interação, entendo eu, não significa uma casa virtual com portas que se abrem quando o avatar as toca.

Vejamos o Second Life como um eliminador de barreiras geográficas de baixo custo. Some a isso as novas tendências da web de se orientar para o Creative Commons, como a Wikipédia, no qual a comunidade participa da criação. Daí, podemos começar a compreender os ambientes virtuais como ferramentas para facilitar a integração humana - ou interação, se preferir.

Interação com simples objetos que sequer existem no mundo real? Não, obrigado. Meu horizonte é um pouco mais infinito que isso e não é por essa direção que pretendo trilhar este blog. Tentarei, conforme possível, propiciar aos interessados um conjunto de ferramentas conceituais capaz de torná-los hábeis a participar desta criação comunitária. Por isso, os tópicos abordados serão predominantemente técnicos.

Sigam-me os bons!