Como usar a linguagem do Certificado de Linden

Esta página é um tutorial curto que utiliza a língua do Certificado de Linden (LSL). Inclui uma coleção dos exemplos que ilustram potencialidades básicas de LSL nos gráficos, “física,” uma comunicação entre usuários e certificados, e criação do objeto. Os exemplos são escolhidos com a apresentação de “blocos de edifícios razoavelmente isolados”, que podem ser combinados mais tarde para criar certificados mais complexos, e compreender melhor os certificados dos exemplos e a biblioteca do certificado apresentados.

Tópicos
• Certificados funcionando de LSL
• Incorporando e funcionando um certificado simples
• Mudando a aparência de um objeto sobre o tempo
• Mudando a posição de um objeto sobre o tempo
• Um sistema simples da partícula
• Girando um objeto
• Rotação local a cada cliente
• Girando um objeto em uma órbita
• Dois exemplos simples usando LSL “física”
• Controlando um objeto com os comandos encaixados no texto do bate-papo
• Controlando um objeto através de uma caixa de diálogo
• Controlando um objeto com as chaves de controle do movimento do avatar
• Objetos de Rezzing dentro dos certificados
• Criando jogos ligados dos objetos
• Uma animação simples da textura
• Usando um sensor para definir o centro (se mover) da rotação
• Investigando alguns certificados do exemplo
• Sumário

Esta página não é uma introdução à sintaxe ou à programação da língua de LSL no geral. Você pode querer consultar um destes tutoriais:
• LSL 101: A guia do Newbie completo a Scripting na segunda vida
• Curso de ruído elétrico
• Tutorial

Além, as ligações do homepage de LSL Wiki a muitas características de LSL, incluindo uma lista de funções de LSL pela categoria que será provavelmente útil como você lê este tutorial, desde que quase cada seção introduz pelo menos uma função nova de LSL.
Caveat: Esta página não cobre nem veículos nem colisões, e está ainda sob desenvolvimento.

Certificados funcionando de LSL

SecondLife inclui uma facilidade para definir certificados dentro dos objetos existentes. Para criar um objeto, o começo SecondLife, o início de uma sessão, clique com o direito na terra ou água virtual e em seguida em “criar”, no menu circular que aparece. Quando você faz este clique, “um menu da manipulação objeto” abrirá no lado esquerdo de sua tela e seu cursor mudará “a um wand mágico” quando você paira sobre a terra outra vez.

Esquerdo-clique outra vez na terra. Você ouvirá então um rumble misterioso e um objeto aparecerá. Será alguma figura geométrica tridimensional, tal como um cubo, um cone ou uma esfera. As linhas coloridas que sairão desse objeto serão usadas para fazer mudanças posicionais no objeto.

Retorne ao menu da manipulação do objeto e se você vir uma tecla de “More>>”, pressioná-la uma vez, até que a versão prolongada do menu abra. Dentro do menu prolongado, o esquerdo-clique na aba do “objeto”, e você verá opções mudando a forma e as dimensões totais do objeto atualmente selecionado. O esquerdo-clique na aba e você verá uma lista dos certificados associados com o objeto. “Satisfaz” o diretório indicado dentro da aba “satisfeita” estará muito provável vazio.

O esquerdo-clique “na tecla do certificado novo”, e um “certificado” que edita a janela abrirá. A janela de edição tem um “certificado editar a área” onde você pode datilografar ou pasta em um certificado novo, e as teclas para conservar o certificado, undoing as mudanças feitas, etc. Olhará qualquer outra coisa semelhante:

O certificado que edita a área deve conter o seguinte certificado:

optar {state_entry () {llSay (0, “Hello, Avatar! ”); } touch_start (total_number do inteiro) {llSay (0, “tocado. ”); }}

Esquerdo-clique no “excepto” a tecla. Você deve ver a mensagem “compilar bem sucedido, conservando…” aparecer na caixa abaixo do certificado que edita a área. Depois de uma pausa curta você deve ver a mensagem “excepto completo” aparecer nessa caixa também.

Uma vez que o certificado é conservado, você verá a mensagem “Hello, Avatar!” aparecer no canto inferior esquerdo de sua tela. Esta mensagem indica que o certificado eventos do toque partiu e do espera.

Para testar o objeto “para tocar,” próximo janelas da manipulação da edição e do objeto do certificado, e direito-clique no objeto. O menu circular do objeto aparecerá de qual você pode selecionar o “toque.” Você deve então ver o “objeto tocado.” aparecer no canto inferior esquerdo também.

Incorporando e funcionando um certificado simples

Está aqui um programa muito simples que muda a cor e o tamanho do objeto, quando o objeto é tocado todas as vezes.

contador do inteiro; optar {state_entry () {llSay (0, “Hello, Avatar! Toque para mudar a cor e o tamanho. ”); contador = 0; } touch_start (total_number do inteiro) {// faz estas instruções quando o objeto for tocado. contador = + 1 contrário; // escolhe três componentes aleatórios da cor do RGB entre 0. e. redness do flutuador 1.0 = llFrand (1.0); greenness do flutuador = llFrand (1.0); blueness do flutuador = llFrand (1.0); componentes da cor da liga de // em um vetor e em um uso que vector // para ajustar a cor do objeto. prim_color do vetor = < redness="">; llSetColor (prim_color, ALL_SIDES); cor ajustada // do objeto à cor nova. // escolhe um número aleatório entre 0. e 10. para o uso como um fator de escala. flutuar o new_scale = o llFrand (10.0) + 1.0; llSetScale (< new=""> ); // ajustou a escala do objeto. llSay (0, “tocado pelo número do anjo” + (corda) contrário); }}

Veja a figura que mostra o autor ao lado de uma das caixas criadas por este programa.

Note que suas caixas terão cores e tamanhos diferentes e que este programa conta também o número das vezes que o objeto foi tocado, além de escrever uma mensagem no canto inferior esquerdo da tela que dá esse número.

Introduzir este certificado no objeto criado apenas, direito estala sobre o objeto, reabre o certificado que edita a janela, cola este certificado no certificado que edita a área, e clique “excepto”. Quando o certificado foi conservado, testá-lo direito-estalando no objeto e no “toque escolhendo”, como antes.

Você pode ter que fazer algum que elimina erros para corrigir erros, e quando você começa finalmente as coisas que funcionam corretamente, você pode querer o direito-clique no objeto e escolher a “tomada” mover o objeto em seu inventário. Os objetos em seu inventário remanescerão lá. Basta então nivelar após o término de uma sessão e estarão disponíveis quando você registra para trás dentro. Mais tarde, você pode mover cópias destes objetos para trás em SecondLife, e repetir para evitar de recriá-los.

Mudando a aparência de um objeto sobre o tempo

Está aqui um certificado que muda a cor e o tamanho de um objeto cada dois segundos por aproximadamente 40 segundos que começam quando o objeto é tocado.

contador do inteiro; inteiro em segundo; optar {state_entry () {llSay (0, “Hello, Avatar! Toque para mudar a cor e o tamanho. ”); contador = 0; } touch_start (total_number do inteiro) {contrário = + 1 contrário; llSay (0, “tocado pelo número do anjo” + (corda) contrário); llSetTimerEvent (2); // cría do “um evento temporizador” cada 2 segundos. } o temporizador () // faz estas instruções cada vez que o evento do temporizador ocorre. {second++; // escolhe três componentes aleatórios da cor do RGB entre 0. e. vermelho do flutuador 1.0 = llFrand (1.0); verde do flutuador = llFrand (1.0); azul do flutuador = llFrand (1.0); componentes da cor da liga de // em um vetor e em um uso que vector // para ajustar a cor do objeto. prim_color do vetor = < red="">; llSetColor (prim_color, ALL_SIDES); cor ajustada // do objeto à cor nova. // um número aleatório escolher entre 0. e 10 para o uso como um fator de escala. new_scale do flutuador = llFrand (10.0); llSetScale (< new=""> ); // ajustou a escala do objeto. se (em segundo > 19) // cronometrar então para envolver acima este. {preto do objeto da volta de //, mensagem “descansando” da cópia, e objeto restaurado…. llSetColor ( < 0="">, ALL_SIDES); llSay (0, “objetam agora descansar e restaurar o certificado.” ); llResetScript (); objeto do retorno de // ao estado pronto. }}}

Quando um evento do touch start ocorre, o programa começa um temporizador que “funciona para fora” cada 2 segundos, causando “um evento temporizador.” Sempre que um evento do temporizador ocorre, o segmento do certificado dentro dos suportes abaixo da corda “temporizador ()” é executado. A seção do temporizador () conta o número das épocas que é ativado, e restaura o certificado após 20 ou assim ativações.

Se os avatares múltiplos tocarem no objeto ao mesmo tempo, um comportamento estranho pode ocorrer. Tal evento pode ser monitorado e controlado usando a variável do total_number passada ao touch_start.

Mudando a posição de um objeto sobre o tempo

Um certificado pode mudar a posição de seu objeto usando a função dos llSetPos (). Está aqui um certificado que reposiciona um objeto usando llSetPos () aproximadamente uma vez um segundo para 20 ou o secunde assim.

As posições novas são escolhidas incrementando a posição. Começar usando um vetor construído durante cada iteração de 3 valores aleatórios entre 0.0 e 10.0 medidores.

contador do inteiro; inteiro em segundo; startPosition do vetor; optar {state_entry () {llSay (0, “Hello, Avatar! Toque para mudar a posição. ”); contador = 0; startPosition = llGetPos (); } touch_start (total_number do inteiro) {contrário = + 1 contrário; llSay (0, “tocado pelo número do anjo” + (corda) contrário); llSetTimerEvent (1); // arranja para do “um evento temporizador” cada segundo. } o temporizador () // faz estas instruções cada vez que o evento do temporizador ocorre. {second++; // escolhe três distâncias aleatórias entre 0. e 10.0. flutuadores X_distance = llFrand (10.0); flutuador Y_distance = llFrand (10.0); flutuador Z_distance = llFrand (10.0); a liga de // estes distance componentes em um vetor e usa-os // incrementar a posição começar e reposicionar o objeto. incremento do vetor = < X="">; newPosition = startPosition + incremento do vetor; llSetPos (newPosition); // reposiciona o objeto. se (em segundo > 19) // cronometrar então para envolver acima este. {parte traseira do objeto do movimento de // à posição começar… quando (llVecDist (llGetPos (), startPosition) > 0.001) {llSetPos (startPosition); } llSay (0, “objeto agora descansando e restaurando o certificado.” ); llResetScript (); objeto do retorno de // ao estado pronto. }}}

Para ajudar-lhe manter-se a par do objeto, está reposicionado à posição começar antes que o certificado reinicialize. O movimento gerado pelo reposicionamento aleatório é, naturalmente, completamente “aleatório. Para fazer com que um objeto mova “mais naturalmente” deve escolher posições subseqüentes com mais cuidado. As posições novas devem encontrar-se ao longo de uma trilha do movimento, e sejam suficientemente perto de uma outra que o jerkiness é não aparente ou minimizado. Isto é às vezes difícil em SecondLife devido à rede atrasa, congestionado usuário, e/ou o processador central do cliente ou os gráficos pobres card o desempenho.

Um processador central de 3 gigahertz emparelhou-se com um cartão high-end dos gráficos 3D, tal como o nVidia 6800 Ultra, entregará geralmente o desempenho muito bom que opera-se sobre uma conexão de rede com uma estadia do sibilo do roundtrip 50ms a um usuário do SL. Um processador central de 3 gigahertz que hospeda um nVidia Quadro NVS (projetado primeiramente para 2D gráficos) e que opera-se com uma estadia do sibilo 200ms fornece somente resultados moderada satisfatórios.

Para ver um exemplo tentar portray o movimento suave do objeto sob o controle do certificado, olhar este certificado para mover um objeto em um volume contido.

Um sistema simples da partícula

É possível arranjar para que um objeto gere e emita-se “partículas” sob o controle do certificado. Por exemplo, um objeto pode ser ajustado até emitir bolhas, faíscas, fogo, etc.

Para ver isto na ação, você pode modificar o certificado na seção precedente para emitir-se partículas quando o objeto se mover. Para fazer que introduzem uma chamada ao llParticleSystem () em touch_event () e uma outra chamada para girá-lo fora de quando o objeto foi retornado a sua posição começar e ao certificado está a ponto de ser restaurada.

A primeira chamada deve gostar deste do Wiki:

llParticleSystem ([PSYS_PART_FLAGS, PSYS_PART_WIND_MASK | PSYS_PART_EMISSIVE_MASK, PSYS_SRC_PATTERN, PSYS_SRC_PATTERN_EXPLODE, PSYS_PART_START_COLOR, <1>
]);

e a segunda chamada deve olhar o gosto:

llParticleSystem ([]);

Está aqui um instantâneo do autor estando ao lado de um objeto movente que emite esferas vermelhas incandescente, como especificado na chamada acima:
A disposição incomum mostrada na chamada do sistema do llParticle () acima é significada enfatizar como os parâmetros na chamada ao llParticleSystem () são emitidos como uma coleção de pares do elemento dentro de uma lista de LSL.

Cada linha na lista do parâmetro contém dois elementos separados por uma única vírgula. O primeiro elemento é o nome do parâmetro e o segundo elemento é o valor a ser associado com esse parâmetro. Por exemplo, a cor da partícula é controlada pelo parâmetro PSYS_PART_START_COLOR, e o valor emitido é < 1, 0, 0 >, que especifica a cor “vermelho”.

Alguns parâmetros podem fazer exame de ajustes múltiplos ao mesmo tempo. Por exemplo, o par PSYS_PART_FLAGS

do parâmetro-valor, PSYS_PART_WIND_MASK | PSYS_PART_EMISSIVE_MASK
ajusta as bandeiras de PSYS_PART_WIND_MASK e de PSYS_PART_EMISSIVE_MASK dentro do parâmetro de PSYS_PART_FLAGS ao mesmo tempo. (Você pode ajustar tantas como bandeiras como necessário separando as com lógico OU caráteres (|) como mostrado acima.)

A página de Wiki para o llParticleSystem () lista todos os parâmetros acessíveis. Há muitos parâmetros e alguns têm nomes difíceis, mas é razoavelmente fácil experimentar com eles para encontrar para fora como trabalham, desde que têm geralmente diretamente efeitos observáveis.

Note que as partículas estão geradas localmente em cada cliente dentro da escala. Isso significa que não põe muita carga sobre o usuário e podem ser completamente realísticas.

Girando um objeto

Há diversas maneiras de representar o movimento rotatório em LSL. A respresentação de Euler usa o vetor de a (3-part) onde cada componente especifica o movimento em uma de 3 dimensões. Por exemplo, os componentes de um vetor, V, prendendo uma rotação de Euler, são compostos de uma descrição angular de 3 componentes:

Movimento componente no plano em torno da linha central sabida como --------- ----------------- ------------ -------- A guinada X-Y do passo V.z Z do rolo V.y X-Z Y de V.x Y-Z X

quando a respresentação de Euler for razoavelmente intuitive e é suportada dentro de LSL, movments rotatórios pode também ser representada como “quaternions.”
Quaternions é executado dentro de LSL através de um tipo variável interno, chamado “rotação,” composta de 4 componentes, x, y, z, e s, todo o tipo flutuador.

Os primeiros 3 componentes podem ser pensados como de definir uma linha central em torno de que a rotação ocorre, quando os 4ns descreverem a quantidade de rotação.
Uma rotação pode ser definida usando uma representação de Euler e então ser convertida à representação do quaternion, através de uma chamada a llEuler2Rot (). Por exemplo, < 0=""> define uma rotação de 10 graus em torno da linha central de Y, e pode ser convertido ao formulário do quaternion usando a chamada

llEuler2Rot ( < 0="">)
que rende um valor de < 0="">.

Quando a rotação que descreve “a orientação atual” de um objeto é sabida, uma orientação nova pode ser derivada simplesmente multiplicando uma rotação por outra.
Está aqui um certificado do exemplo que ilustra o uso para que o laço simule a rotação contínua de um objeto em um lugar. Usa o llGetRot () adquirir a rotação que descreve a orientação atual, modifica o valor retornado e usa então o llSetRot () reorient o objeto.

optar {state_entry () {llSay (0, “Hello, Avatar! ”); startPoint = llGetPos do vetor (); } touch_start (total_number do inteiro) {llSay (0, “tocaram.” ); // define uma rotação de 10 graus em torno do Y-axis. rotação Y_10 = llEuler2Rot ( < 0=""> ); // gira agora o objeto 10 graus no plano de X-Z durante // cada iteração do laço. anotar que cada chamada ao llSetRot // causa um .2 segundo atrasa. inteiro i; para (i = 1; i < 100="">

cada passagem com para o laço calcula uma orientação nova relativo à orientação atual multiplicando a orientação rotatória atual do objeto pela rotação de 10 graus definida durante o evento state_entry.

Se você clica com o direito no objeto quando girar, os machados do objeto aparecer, e você puder verificar está girando em torno de seu Y-axis. Note que a ordem do operando é significativa ao multiplicar por variáveis do tipo rotação. A indicação:

newRot da rotação = llGetRot () * Y_15;

girará o objeto com respeito às coordenadas globais, quando a indicação:

newRot da rotação = Y_15 * llGetRot ();

girará com respeito aos machados locais do objeto.

Rotação local a cada cliente

A rotação pode também ser simulada usando a função do llTargetOmega () dentro de um certificado. O movimento produzido por esta função é produzido independentemente por cada cliente de SecondLife que pode observar o objeto movente. Em conseqüência, o movimento é muito mais suave, mas o comportamento diferirá ligeiramente em cada cliente.

Está aqui um exemplo que gira um objeto em torno dos machados de Y e de Z (como se usar especificado < 0="">) em uma taxa de .2 * radianos do Pi por o segundo:

optar {state_entry () {llTargetOmega ( < 0="">, .2 * PI, 1.0); }}

Note que esta aproximação é menos flexível do que o movimento rotatório produzido quando usado o llSetRot ().

Girando um objeto em uma órbita

Está aqui um certificado que faça uma órbita do objeto no plano X-Y em torno de um ponto < 3=""> de sua posição começar. Este certificado emprega o efeito de multiplicar um vetor da posição por uma rotação. A página de Wiki que descreve esta operação diz:

“Um objeto pode ser girado em torno de um ponto arbitrário multiplicando um vetor por uma rotação. O vetor deve ser a diferença entre a posição atual do objeto e o “centro-ponto desejado” da rotação. Fazer exame do resultado da multiplicação e adicioná-lo à posição atual do objeto. Este vetor será “a posição nova” que o objeto deve ser movido para.”

O movimento orbitral é simulado através do laço que reposiciona o objeto por 15 graus durante cada iteração. Note que os llSetPos () estão usados no lugar do llSetRot () durante este processo.

vector o rotationCenter; ponto de // a girar ao redor. optar {state_entry () {llSay (0, “Hello, Avatar! ”); startPoint = llGetPos do vetor (); rotationCenter = startPoint + < 3="">; a distância de // ao ponto da rotação deve provavelmente ser uma função de // da dimensão máxima do objeto. } touch_start (total_number do inteiro) {llSay (0, “tocaram.” ); // define uma “rotação” de 10 graus em torno da z-linha central. rotação Z_15 = llEuler2Rot ( < 0=""> ); inteiro i; para (i = 1; i < 100="">

Veja um instantâneo do autor que monta um cone alaranjado grande que gira sob o controle de uma versão hybrid do certificado acima de usar o código de ambos os exemplos da rotação apresentados apenas. O cone gira em torno do Y-axis ao simultaneamente orbitar o ponto center distante.

E é aqui o que a experiência olha como do ponto do autor da vista apenas como o instantâneo acima foi feito exame:

Note que é também possível combinar este movimento da órbita com a rotação local produzida usando o llSetTargetOmega (), como mostrado neste certificado. Isto é realizado começando a rotação local junto com um temporizador que execute periodicamente instruções para mover o objeto girando em uma órbita. Esta aproximação pode ser usada para simular o movimento lunar em torno de um planeta orbiting (se o objeto orbiting é duas esferas ligadas). Note, entretanto, que o planeta girará na mesma taxa que a lua, que não é realística.

Dois exemplos simples usando LSL “física”

LSL inclui a habilidade de simular algumas das leis físicas que governam a energia, a gravidade, o torque, etc. enquanto afetam o em-mundo dos objetos. Esta habilidade deriva-se de um jogo de funções internas que execute os efeitos destas leis. Para ver a “física” na ação, cria um objeto, abre a aba do objeto, verifica a caixa da “física”, muda a altura da Z-linha central de seu objeto para fazer-lhe diversos medidores acima da terra, e fecha então a janela da manipulação do objeto. Seu objeto deve então deixar cair à terra, e se a terra não for em nível e seu objeto for suficientemente esférico, pode mesmo rolar para baixo. (No fato, você pode ter que o perseguir para regain o controle dele).

O seguinte certificado ajusta "ON" da física usando o llSetStatus da ligação de controle:

(1, VERDADEIRO)

e então, quando o objeto é tocado, usa o llApplyImpulse
do comando ( < 0="">, FALSO);

para aplicar um impulso vertical instantâneo:

optar {state_entry () {llSay (0, “Hello, Avatar! Toque para lançar-me em linha reta acima. ”); llSetStatus (1, RECTIFICA); // gira sobre a física. } touch_start (total_number) {start_color do vetor = llGetColor do inteiro (ALL_SIDES); // conserva a cor atual. llSetColor ( < 1=""> , ALL_SIDES); cor ajustada // ao vermelho. objMass = llGetMass do flutuador (); flutuador Z_force = 20.0 * objMass; llApplyImpulse ( < 0="">, FALSOS); llSay (0, “impulso de” + (corda) Z_force + “se aplicaram.” ); llSetColor (start_color, ALL_SIDES); cor ajustada // ao verde. }}

O exemplo seguinte aplica uma força vertical ascendente contínua usando o llSetForce do comando

( < 0="">, O FALSO)

no objeto. Esta ligação de controle ajusta acima uma força de 0.0 newtons ao longo do X-axis positivo, de 0.0 newtons ao longo do Y-axis positivo, e de newtons de Z_force ao longo da Z-linha central positiva.

Desde que o peso de um objeto é igual à massa do objeto vezes a força da gravidade, ou a 9.8 medidores por segundo, uma força mais extremamente de 9.8 * os objMass devem superar a força da gravidade e levantar o objeto. Neste certificado, Z_force é ajustado a “10.2 * os objMass”, que devem levantar o objeto lentamente. Você pode editar o certificado para mudar este parâmetro e para observar comportamentos diferentes do objeto.

startPos do vetor; curPos do vetor; curForce do vetor; inteiro em segundo; optar {state_entry () {llSay (0, “Hello, Avatar! Toque para lançar-me em linha reta acima. ”); llSetStatus (1, RECTIFICA); startPos = < 0="">; } touch_start (total_number) do inteiro {startPos = llGetPos (); curPos = startPos; curForce = < 0="">; em segundo = 0; llSetColor ( < 1=""> , ALL_SIDES); cor ajustada // ao vermelho. objMass = llGetMass do flutuador (); flutuador Z_force = 10.2 * objMass; llSetForce ( < 0="">, FALSOS); llSay (0, “força de” + (corda) Z_force + “sendo aplicado.” ); llSetTimerEvent (1); } temporizador () {second++; curPos = llGetPos (); curDisplacement do flutuador = llVecMag (curPos - startPos); se ((curDisplacement > 30. ) o && // objeta então é demasiado faraway, e (llGetForce ()! = < 0=""> )) força de // não já zero, {// deixa então a gravidade fazer exame sobre, e muda a cor ao verde. llSetForce ( < 0="">, FALSOS); llSetColor ( < 0="">, ALL_SIDES); llSay (0, “força removeram; objeto no vôo livre.” ); } se (em segundo > 19) // cronometrar então para envolver acima este. {objeto da volta de // azul e força zero a ser segura…. llSetColor ( < 0="">, ALL_SIDES); cor da mudança de // ao azul. llSetForce ( < 0="">, FALSOS); parte traseira do objeto do movimento de //… à posição começar… //… após o status atual do saving do atributo da física. savedStatus do inteiro = llGetStatus (1); llSetStatus (1, FALSO); física da volta de // fora. quando (llVecDist (llGetPos (), startPos) > 0.001) {llSetPos (startPos); } llSetStatus (1, savedStatus); status da física do restore de //. //...and então gira a cor para o preto e restaura o certificado. llSetColor ( < 1="">, ALL_SIDES); llSetTimerEvent (0); // desliga eventos do temporizador. llSay (0, “feito e restaurando o certificado.” ); llResetScript (); objeto do retorno de // ao estado pronto. }}}

Anotar que pode ser difícil controlar objetos no movimento no segundo ambiente da vida. Por exemplo, os avatars perdem aparentemente o controle dos objetos mais de 10 medidores ausente, e os objetos ajustados no movimento podem continuar através de muitas terras antes que saem eventualmente do espaço simulado. (Quando saírem geralmente são retornados ao “perdido e encontraram” a área de seu inventário.)

O certificado acima tem duas características para a ajudar manter o controle. Primeiramente, usa um evento do temporizador, como ilustrado em um programa precedente, para monitorar a posição do objeto, e para fazer exame da ação corretiva. No detalhe, se o objeto mover mais de 30 medidores de sua posição começar, o certificado do evento do temporizador elimina força usando o llSetForce da ligação de controle (, < 0="">FALSO aplicados).

Em segundo, o certificado pára a simulação e retorna o objeto à sua posição começar após um número fixo de eventos do temporizador. Note que este certificado manipula deliberadamente a possibilidade do objeto às forças físicas. No detalhe, a física é "OFF", girado quando o objeto for reposicionado à sua posição começar usando as funções do certificado que não trabalharão quando a física é permitida.

Controlando um objeto com os comandos encaixados no texto do bate-papo

Um certificado pode ser ajustado até “escuta” diálogo do bate-papo e responde aos comandos emitidos através do bate-papo. Está aqui um certificado que aguarde até escutar as mensagens do bate-papo que vêm do proprietário do objeto em que o certificado reside. Se uma linha começa do bate-papo com as cordas “acima” ou de “para baixo” (separado do outro texto na linha por um espaço em branco), o certificado supuser o proprietário está dando um comando abaixar o objeto acima ou. Então procurará uma segunda corda em branco-limitada, convertê-la-á a um número, e usá-la-á esse número decidir-se como para mover distante para cima ou para baixo o objeto.

startPosition do vetor; groundLevel do flutuador; defeito {state_entry () {llListen (0, "", llGetOwner (), ""); startPosition = llGetPos (); groundLevel = llGround (startPosition); llSay (0, “controlam este objeto com comandos do bate-papo como: ”); llSay (0, ““acima de” ou “para baixo” seguido por uma distância.” ); } escutar (canaleta do inteiro, nome da corda, identificação chave, mensagem da corda) {// separa a entrada no símbolo em branco-delmited. alistar analisado gramaticalmente = llParseString2List (mensagem, [““], []); // começa a primeira parte--o “comando”. comando da corda = llList2String (analisado gramaticalmente, 0); // começa a segunda parte--a “distância”. corda que distance_string = llList2String (analisado gramaticalmente, 1); distância do flutuador = (flutuador) distance_string; posição = llGetPos do vetor (); se (== do comando “acima de”) {se ((position.z + distância) <> ); // move para cima o llSetText (“foi acima de” + a distância (da corda) < 1="">, 1); } mais {llSetText (“não pode ir assim altamente. ” < 1="">, 1); }} mais se (== do comando “para baixo”) {se ((position.z - distância) > groundLevel) {llSetPos (llGetPos () + < 0=""> ); // abaixa o llSetText (“foi abaixo” + a distância (da corda) < 1="">, 1); } mais {llSetText (“não pode ir assim baixo. ” < 1="">, 1); }}}}

llListen () é usado ajustar acima um disparador do evento, assim que “escuta” o evento será invocado sempre que uma mensagem do bate-papo é recebida do proprietário. O evento escutar recebe o índice da mensagem em seu argumento da “mensagem”, e “analisa gramaticalmente” essa mensagem em suas peças em branco-limitadas. Na primeira parte é feito exame como um “comando” e a segunda parte como uma “distância”, como descrita acima. Note que esta técnica pode também ser usada por objetos se comunicar um com o outro, se forem próximos bastante a um outro.

Controlando um objeto através de uma caixa de diálogo

É possível para um objeto apresentar um jogo das opções a um avatar que possa ser usado controlar seu comportamento. Está aqui um programa que move um objeto para cima ou para baixo ao longo de sua linha central de Z sob o controle do diálogo:

dialog_channel= 427 do inteiro; // ajusta um menu da lista da canaleta do diálogo = [“ir acima de”, “vão abaixo”]; vector o startPosition; flutuar o groundLevel; defeito {state_entry () {// arranja para aguardar até escutar respostas do diálogo (dos usuários múltiplos) llListen (dialog_channel, "", NULL_KEY, ""); startPosition = llGetPos (); groundLevel = llGround (startPosition); } touch_start (total_number) {llDialog do inteiro (llDetectedKey (0), “que você quer fazer? ”, menu, dialog_channel); } escutar (canaleta do inteiro, nome da corda, identificação chave, escolha) da corda {posição = llGetPos do vetor (); // se uma escolha válida for feita, instrumento essa escolha se possível. // (o llListFindList retorna -1 se a escolha não estiver na lista do menu.) se (llListFindList (menu, [escolha])! = -1) {se (o == bem escolhido “vai acima de”) {se (position.z <> ); // move para cima}} mais se (o == bem escolhido “vai abaixo”) {se (position.z > (groundLevel + 1.0)) {llSetPos (llGetPos () + < 0=""> ); // abaixa}}} mais {llSay (0, “escolha inválida: ” + escolha); }}}

Sempre que o objeto é tocado pedirá que o usuário o mova para cima ou tragar.
Note que uma caixa de diálogo pode incluir uma opção para pedir “as opções adicionais” que aparecerão em uma caixa de diálogo sida conectada em cascata.

Controlando um objeto com as chaves de controle do movimento do avatar

É também possível permitir que um objeto responda às chaves de teclado que controlam normalmente seu avatar. Por exemplo, o certificado seguinte pedirá permissão atribuir novamente para a frente seu avatar e chaves inversas do movimento para mover para cima e para baixo o objeto.

startPosition do vetor; groundLevel do flutuador; optar {state_entry () {// começa a permissão fazer exame sobre das entradas do controle do avatar. llRequestPermissions (llGetOwner (), PERMISSION_TAKE_CONTROLS); startPosition = llGetPos (); groundLevel = llGround (startPosition); } evento de // dos run_time_permissions (perm do inteiro) para processar o diálogo da permissão de //. {se (perm & PERMISSION_TAKE_CONTROLS) a permissão de // foi dada. {// vai adiante e faz exame sobre dos controles para diante e inversos. llTakeControls (CONTROL_FWD | CONTROL_BACK, VERDADEIRO, FALSO); }} evento de // do controle (identificação da chave, inteiro prendido, mudança do inteiro) para processar a pressão chave de // {posição = llGetPos do vetor (); se (mudança & prendido & CONTROL_FWD) {// do “o controle para diante movimento” foi ativado. se (position.z <>); // move para cima}} mais se (mudança & prendido & CONTROL_BACK) {// do “a chave inversa movimento” foi ativado. se (position.z > groundLevel + 1.0) {llSetPos (llGetPos () + < 0="">); // abaixa}}}}

Note que este certificado faz exame sobre ambas as chaves ascendentes e da para baixo-seta, assim como para diante e as teclas inversas do controle fornecidas pela “vista/movimento controlam”.

Objetos de Rezzing dentro dos certificados

“Rezzing” é o processo de criar um objeto. Os Avatars podem criar objetos como descritos mais cedo. Entretanto, não é possível para um certificado criar um objeto nesta forma. Os certificados enlatam somente o “instantiate” (criar exemplos de) objetam criado já e residindo no inventário do objeto em que o certificado é ficado situado.

Para trabalhar com esta característica, para criar um objeto, para dar-lhe o nome “Object1”, e para permitir seja copy selecionando “permitir que qualquer um copie” e “o proprietário seguinte pode copiar” dentro da janela da manipulação do objeto. Então o direito-clique no objeto e “faz exame” no inventário do seu avatar.

Criar agora um segundo objeto com o nome “Object2”, e abrir sua aba do “índice” da janela da manipulação do objeto. Então abrir o inventário do seu avatar estalando “inventário” no fundo de sua janela de SecondLife, abrir “objeto” o dobrador, esquerdo-clique na entrada “Object1”, e arrastam-no ao Object2 “satisfaz” a área do dobrador.

Editar agora o seguinte certificado em Object2:
optar {state_entry () {llSay (0, “Hello, Avatar! ”); } touch_start (total_number do inteiro) {llSay (0, “tocado. ”); llRezObject (“Object1”, llGetPos () + < 0="">, ZERO_VECTOR, ZERO_ROTATION, 42); }}

Agora que você toca em Object2, o llRezObject () o instantiate Object1, e você deve ver uma cópia de Object1 aparecer 2 medidores acima de Object2.

O último parâmetro na chamada do llRezObject () (“42” neste exemplo) é passado ao objeto novo. É apresentado como o único parâmetro ao evento do on_rez no objeto novo. Uma versão “inteligente” de Object1 poderia usar tal parâmetro fazer mudanças imediatas (tais como a cor ou o tamanho) sob seu controle.

O llRezObject () provoca o evento do object_rez e passa a chave do objeto novo longitudinalmente para o uso subseqüente dentro de Object2. Os comandos dentro do object_rez podem então ligar o objeto recentemente criado e/ou emitir mensagens ao objeto, etc. novos para afetar sua aparência ou comportamento.

Criando jogos ligados aos objetos

LSL fornece um jogo das funções para os jogos ligando e controlando objetos primitivos, chamados às vezes “link_sets.” Os objetos primitivos que são ligados junto comportar-se-ão como um único objeto em algumas maneiras. Por exemplo, mover-se-ão como um único objeto se reposicionado ou o exame feito, e a edição de comandos se aplicarem à coleção. Podem também ser ajustados até comunicam-se um com o outro e passam-se determinada informação do evento entre si.

Está aqui uma versão do certificado acima daquela pede permissão ligar outros objetos em um jogo ligado e cria dois objetos da criança somente se recebe a permissão os ligar estiveram criados uma vez que.

Uma vez que o enlace é estabelecido, o certificado a seguir usa o llSetLinkColor () fazer o vermelho recentemente criado dos objetos. Os objetos recentemente criados e ligados são identificados usando a ligação numeram “2” e “3” durante trocas da mensagem dentro do linkset, mas podem também ser dirigidos através das constantes de LSL como “LINK_ALL_CHILDREN” ou “LINK_SET”.

O objeto do pai é identificado como a ligação número “1” e pode ser dirigido como “LINK_ROOT” (embora os objetos primitivos sem crianças ligadas são identificados como a ligação número “0”).

createdObjectCounter do inteiro; linkedObjectCounter do inteiro; optar {state_entry () {llSay (0, “Hello, Avatar! ”); linkedObjectCounter = 0; // zero o contador do objeto ligado. } touch_start (total_number do inteiro) {se (createdObjectCounter <>, ZERO_VECTOR, ZERO_ROTATION, 42); createdObjectCounter = createdObjectCounter + 1; llRezObject (“Object1”, llGetPos () + < -1="">, ZERO_VECTOR, ZERO_ROTATION, 42); createdObjectCounter = createdObjectCounter + 1; } mais {llOwnerSay (“não começou a permissão às ligações de mudança.” ); retorno; }} object_rez (child_id chave) {llOwnerSay (o “rez aconteceu e produziu o objeto com chave” + child_id (da corda)); ligação de // como o pai à criança criada justa. llCreateLink (o child_id, RECTIFICA); // se todos os objetos da criança forem criados então a lata // do certificado continua a trabalhar como um jogo ligado dos objetos. linkedObjectCounter++; se (>= 2 do linkedObjectCounter) {mudança que de // toda a criança objeta no jogo ao vermelho (pai including). llSetLinkColor (LINK_ALL_CHILDREN < 1="">, ALL_SIDES); // faz a criança objetar a metade-tranparent “2”. llSetLinkAlpha (2, .5, ALL_SIDES); A inserção de // comanda aqui para controlar a atividade subseqüente do linkset de //, como este comando girar o resultado: llTargetOmega de // ( < 0="">, .2 * PI, 1.0); }}}

As atividades dentro deste certificado são coordenadas através de uma cascata dos eventos. O evento dos run_time_permissions funciona somente depois que o proprietário responde ao alerta para permitir que as ligações do objeto sejam estabelecidas. Verifica para ver se a permissão for concedida e rezzes os objetos novos ou diz que não pode.

O evento do objeto_rez funciona somente quando um rez sucede, em que ponto o objeto novo é ligado dentro e o certificado verifica para ver se todos os objetos foram criados com sucesso. Se assim, os objetos da criança são requisitado para mudar sua cor, e uma é feita semi-transparente. É aqui que os comandos adicionais poderiam ser adicionados para dirigir subseqüente comportamento do linkset.

Por exemplo, o jogo inteiro podia ser feito girar introduzindo parcelas do certificado da rotação apresentou-se mais cedo. Alternativamente, este certificado podia mudar o controle a um certificado diferente indicar (usando o comando do “estado”) que continuaria a dirigir comportamento do linkset. Os membros de um linkset podem emitir mensagens a outros membros do linkset usando-se llMessageLinked () a função. Para receber mensagens, membro os objetos devem ter um alimentador link_message_event do evento definido dentro seus certificados.

Note que os objetos podem somente ser criados dentro de 10 medidores de distância do objeto contendo o certificado criador. Também, quando os objetos puderem ser criados dentro dos laços (embora há um short atrasa com cada estação), você deve ter muito cuidado aproximadamente criação interative ou recursive do objeto para evitar panes do sistema. Uma animação simples da textura é possível criar as limas da textura que prendem o indivíduo múltiplo as imagens que podem ser usadas como a animação moldam.

Quando uma série de tais frames for indicada em cima do lado de um objeto, muitos efeitos diferentes são possíveis. Por exemplo, um objeto pode ser feito para parecer como se está girando mesmo embora não efetivamente esteja. Está aqui um instantâneo do autor ao lado de uma flama simulada usando animação da textura:

O seguinte certificado produzirá uma flama similar quando aplicado a um objeto apropriado:

defeito { state_entry () { llSetStatus (STATUS_PHANTOM, RECTIFICAM); llSetTexture (“lit_texture”, ALL_SIDES); llSetTextureAnim (ANIM_ON | LAÇO, ALL_SIDES, 4, 4, 0, 0, 15.0); } }

Este certificado trabalha em um cubo aplainado com dimensões de aproximadamente 8.0 por 8.0 por 0.0 medidores, e requerem uma textura como este flame_texture. Começá-lo a esta textura em um objeto deve primeiramente começá-lo no seu O inventário de SecondLife e move-o então no objeto. Para começá-lo em seu inventário: download do • esta textura a seu computador direito-estalando a ligação acima e o • que seleciona “excepto o alvo como”. • upload do • a lima downloaded no SL, usando do “a imagem Upload” seleção do • sob lima” opção do SecondLife “do menu.” o • do “imagem Upload” deixá-lo-á browse seu espaço da lima de computador e o • seleciona a lima para upload. O • quando você o seleciona, SecondLife mostrará o nome do presente da lima e do • uma opção para terminar aproximadamente o upload para L$10. O • quando você concorda à carga do upload, o nome da lima a ser • uploaded aparecerá e transferência começará. Transferência do • faz exame tipicamente de alguns minutos, e está completa quando você • começa uma mensagem que diga que “você pagou L$10 para upload.” • • Você deve então encontrar a textura na seção das texturas do seu O inventário do •, e pode movê-la para o objeto junto com o certificado. O • certifica-se que o nome da textura e o nome especificado na chamada do llSetTextureAnim do • () são idênticos. • Durante o processo do upload você verá que a lima da textura é composto de 16 imagens ligeiramente diferentes da flama colocou para fora em uns 4 pela grade 4, como mostrado abaixo:

O certificado chama o llSetStatus () para fazer ao objeto um “phantom” e especifica então a textura para o llSetTextureAnimation () para usar-se com uma chamada ao llSetTexture (). Finalmente, o llSetTextureAnimation () é chamado para dar laços com cada um de as 16 imagens da flama. Os terceiros e quartos parâmetros no parâmetro alistam (a saber, “4, 4”) especificam os 4 pela grade 4. Os quintos e sextos parâmetros (a saber, “0, 0”) especificam o frame começando e o número dos frames para incluir no laço, onde “0” no parâmetro 5 especificam o primeiro frame, e onde “0” no parâmetro 6 especificam “todos os frames.”

O último parâmetro especifica o número dos frames para indicar por o segundo. Note que esta imagem será quase bidimensional. Para criar uma ilusão convencendo, anime os lados de um objeto composto feito de dois painéis lisos que cruzam-se orthogonally em seus midlines verticais. Para fazer o esse, criar os dois painéis, posicioná-los para cruzar-se, e ligá-los junto usando a opção da “ligação” sob “dirige” a opção do menu (ou simplesmente o Controle-l). (Também seria possível ao rez e ligaria o segundo painel para esta finalidade usando a técnica apresentada mais cedo.)

Note que o llSetTextureAnim () executa localmente, de modo que pareça ligeiramente diferente em clientes diferentes de SecondLife. Note também que as linhas amarelas verticais estarão vistas às vezes ao lado da flama. Estes são realmente os lados muito estreitos do cubo que incandesce com a imagem da flama. (A especificação talvez cuidadosa dos lados do objeto a ser usados durante a animação poderá impedir estes artifacts.)

Usando um sensor definir o centro de a (se mover) de rotação. Uma seção mais adiantada mostrou como fazer com que um objeto gire ao redor um centro fixo. Esta seção introduz sensores e mostra como podem ser usados para identificar a posição de um avatar, de modo que um objeto pode ser feito para girar em torno dele. Os sensores permitem que os objetos façam a varredura de seu ambiente para estabelecer presença de outros objetos ou agentes em sua vizinhança.

Os sensores são invocados usando o llSensor () ou funções do llSensorRepeat () fazer a varredura de parcelas selecionadas do ambiente. o llSensor () faz uma única varredura, quando o llSensorRepeat () puder ser ajustado até a varredura o ambiente em intervalos regulares. Note que um objeto pode ter somente um sensor ativo de cada vez.

Quando um sensor conduz uma varredura, induz o evento do “sensor” que pode processar os resultados da varredura. Dentro do certificado para processar o evento do sensor, um jogo de funções de detecção pode ser usado adquirir a informação sobre objetos detectados. Está aqui um certificado que use uma varredura repetindo do sensor identificar a posição de seu proprietário, e gira seu objeto em torno de seu proprietário.

// isto é um certificado projetado orbitar seu proprietário. startPos do vetor; curPos do vetor; offset do vetor; // deslocou do agente iteração do inteiro; rotationRate do flutuador; graus de // de rotação por a iteração flutuador sensorInterval; segundos de // entre a varredura do sensor. defeito { state_entry () { llOwnerSay (“Hello, Avatar! Toque para começar orbitar.” ); llSetStatus (1, FALSO); física da volta de // fora. offset = < 2, 2, 1 >; iteração = 0; rotationRate = .5; = .3 sensorInterval; touch_start (total_number do inteiro) { startPos = llGetPos (); curPos = startPos; llSleep (.1); chave identificação = llGetOwner (); llSensorRepeat ("", identificação, AGENTE, 96, PI, sensorInterval); } sensor (total_number do inteiro) { iteration++; se (iteração > 300) { llResetScript (); } se (llGetOwner do == do llDetectedOwner (0) ()) {// o agente detectado é meu proprietário. posição do vetor = llDetectedPos (0); posição do proprietário do achado de //. // calcula o parente seguinte da posição do objeto à posição de // do proprietário e ao contador do intervalo do tempo atual. Isto é, o uso de // o contador da iteração definir uma rotação, multiplica // a rotação pelo offset constante para começar um vetor offset girado de //, e adiciona esse offset girado à posição atual // ao defne a posição nova. flutuar o degreeRotation = o llRound (rotationRate * iteração) % 360; rotação da rotação = llEuler2Rot (< 0, 0, degreeRotation * DEG_TO_RAD >); o rotatedOffset do vetor = deslocou * a rotação; posicionar o rotatedOffset de +=; a mudança de // a posição do objeto e excepto // (girado) atual deslocou para o uso durante a iteração seguinte. llSetPos (posição); offset = rotatedOffset; } } }

As varreduras do sensor neste certificado são ajustadas à busca para o agente do proprietário dentro de 96 medidores do objeto e dentro dos radianos do PI a um ou outro lado do vetor para diante do objeto (que é dizer toda em torno do objeto).

Investigando alguns certificados do exemplo

Este tutorial apresentou uma variedade de certificados anotados do exemplo para ajudar a leitores aprender usar LSL. Usando-se as estruturas básicas apresentaram-se assim distante, deve ser possível começar a compreender alguns exemplos mais detalhados.

Do interesse particular ser: • o exemplo Certificados do injetor e da bala do • do Wiki. • • • o certificado do vagabundo que reserva • um avatar “para dirigir um objeto em torno” de usar chaves de seta, etc. • (esta é uma versão do certificado do vagabundo reparado por Illume.) • • • um certificado para sentar cross-legged um avatar • em cima de um objeto. • Para usar o certificado do injetor do exemplo, criar um objeto a ser usado como um injetor. Um cubo do defeito fará, mas você pode preferir algo mais realístico. Copy o certificado do injetor no objeto recentemente criado, abaixar a velocidade da bala substituindo a linha o flutuador gBulletSpeed = 75.0; com a linha o flutuador gBulletSpeed = 7.5; e “excepto” o certificado. Esta mudança fará possível ver a bala enquanto emerge do injetor e se move através do espaço.

Criar agora um objeto apropriado para rezzing como uma “bala”. Uma vez que outra vez, uma esfera do defeito fará, mas você pode escolher mais (ou menos) um objeto realístico. Por o certificado da bala no objeto recentemente criado da bala, “excepto” ele, e então “fazer-lhe exame” do objeto em seu inventário. Quando o objeto da bala está em seu inventário, você pode mover uma cópia para a coleção dos índices do objeto do injetor, “para carregar” seu injetor.

“Unir” o injetor a seu righthand, incorporar “Mouselook” e cada cronometrá-lo esquerdo-clique, você “ateará fogo” a uma bala. Anotar que o injetor e a bala têm a “física”. Cada um disparou causará um recoil, e as balas cairão sob a influência da gravidade. Usar uma velocidade lenta do açaime permite que você observe estes efeitos mais fàcilmente. Para usar o certificado do vagabundo, movê-lo para um objeto e “excepto” ele como usual.

Quando as economias estão completas, o direito-clique o objeto, e seleciona “começa em”. Você verá que “para estar acima” a tecla aparecer no fundo de sua tela. Quando você é assentado com segurança, o direito-clique e escolhe o “toque”. O certificado fará exame sobre de seu teclado e você verá que a “liberação fecha à chave” e as teclas de “Mouselook” aparecem no fundo de sua tela, as well as uma lista de comandos de controle na área do bate-papo.

Você pode também datilografar o “menu” para pedir o certificado para repetir o menu de comandos de controle em qualquer altura. (Note que o “toque” toggle o controle do certificado sobre seu teclado.) O vagabundo e cruz-pé-senta certificados pode ser usado junto permitir que seu avatar sente-se cross-legged no objeto que está sendo dirigido.

Usar estes certificados junto põe apenas ambos eles separadamente na coleção satisfeita de um objeto. Com exceção do fato que seu avatar se sentará em uma posição mais elástica satisfazendo, o certificado do vagabundo trabalhará o mesmo.

Sumário - Este tutorial apresentou uma coleção dos exemplos que ilustram muitas das facilidades básicas disponíveis aos scripters de LSL. Usando estas estruturas básicas, deve ser possível a construção de certificados para uma larga variedade de finalidades. Por exemplo, você pode criar jogos simples do certificado, dispositivos dinâmicos e arte cinética. Deve mesmo ser possível investigar mais e/ou ilustrar alguns fenômenos físicos ou menos forma realística usando o em-mundo disponível da “física”. Emitir, por favor, sugestões para problemas da melhoria e do relatório e os sucessos encontraram usando este original de Michael Grobe, em mgrobe@ksbor.org. Boa viagem! Primeira versão: Agosto 5, 2005 Versão atual: Sept 19, 2005.

Traduzido automaticamente. Original, em inglês CLIQUE AQUI