Scripts: dê vida aos seus objetos
Uma porta que abre, uma luz que acende, uma placa que mostra a hora, uma loja que cumprimenta quem chega. Tudo isso se faz com scripts: pequenos programas, escritos em português, que ficam dentro dos objetos que você constrói.
O que é um script
Um script é um texto com instruções. Ele fica guardado dentro de um objeto e roda no servidor da cidade, então funciona para todo mundo ao mesmo tempo, mesmo quando você sai do jogo.
- Para criar: abra Construir, escolha o seu objeto e vá na aba Scripts. Clique em + Novo script.
- Escreva (ou cole) o texto e clique em Salvar (ou Ctrl+S). O servidor confere o script na hora: se tiver erro, ele mostra a linha.
- Cada objeto pode ter até 8 scripts. Na lista dá para Parar, Ligar, Reiniciar e Apagar cada um.
- Só quem pode modificar o objeto vê o texto dos scripts. Quem compra uma cópia leva o objeto funcionando.
- Scripts rodam no terreno do dono do objeto, ou em terrenos onde o dono liberou “Scripts de outros funcionam”.
- Objetos podem vender, cobrar e pagar: veja Dinheiro e permissões.
Seu primeiro script
Este é o modelo que aparece quando você cria um script novo. Ele fala quando começa e responde quando alguém toca no objeto (clique nele, ou toque rápido no celular).
// Meu primeiro script
padrao
{
ao_iniciar()
{
dizer(0, "Olá! Eu sou " + obterNome() + ".");
}
ao_tocar(chave quem, texto nome)
{
dizer(0, nome + " tocou em mim.");
}
}
Repare nas partes:
padraoé o estado onde todo script começa. Dentro dele ficam os eventos: coisas que acontecem com o objeto.ao_iniciar()roda quando o script começa do zero (ao salvar ou ao clicar em Reiniciar).ao_tocar(chave quem, texto nome)roda quando alguém toca no objeto.quemidentifica a pessoa enomeé o nome dela.dizer(0, …)fala no canal 0, que é a conversa normal: quem estiver a até 20 m vê a mensagem.- Cada instrução termina com
;. Os blocos ficam entre{ }. O que vem depois de//é comentário e é ignorado.
Como um script é feito
Um script tem três partes, nesta ordem: variáveis globais (opcional), funções suas (opcional) e um ou mais estados, começando pelo padrao.
// 1) Variáveis globais: valem para o script todo e guardam valor entre um evento e outro
inteiro toques = 0;
texto saudacao = "Oi";
// 2) Funções suas (opcional)
texto cumprimentar(texto nome)
{
retorne saudacao + ", " + nome + "!";
}
// 3) Estados: todo script começa no estado padrao
padrao
{
ao_tocar(chave quem, texto nome)
{
toques++;
dizer(0, cumprimentar(nome) + " Já fui tocado " + toques + " vezes.");
se (toques >= 3) estado cansado;
}
}
estado cansado
{
ao_iniciar()
{
dizer(0, "Chega por hoje...");
temporizador(10);
}
ao_temporizador()
{
toques = 0;
estado padrao;
}
ao_sair()
{
temporizador(0);
}
}
senao e senão, faca e faça, padrao e padrão, rotacao e rotação funcionam igual. Os nomes das funções prontas são sem acento.Tipos de valor
| Tipo | Guarda | Exemplo | Começa com |
|---|---|---|---|
inteiro | Números sem vírgula. Também usado para sim/não (VERDADEIRO = 1, FALSO = 0). | 42, -7, 0xFF | 0 |
decimal | Números com casas decimais (use ponto). | 3.14, 0.5 | 0.0 |
texto | Letras e frases, entre aspas. \n pula linha. | "Olá" | "" |
chave | A identidade de uma pessoa ou objeto (é um texto). | obterDono() | "" |
vetor | Três números: posição, tamanho, direção ou cor. | vetor(1, 2, 3) | vetor(0, 0, 0) |
rotacao | Um giro (para onde algo está virado). | rotacaoDeGraus(vetor(0, 90, 0)) | sem giro |
lista | Vários valores de qualquer tipo (menos outras listas). | [1, "a", 2.5] | [] |
inteiro vidas = 3;
decimal velocidade = 2.5;
texto recado = "Bom dia";
chave dono = obterDono();
vetor ponto = vetor(10, 0, -4); // x, y (altura), z
rotacao giro = rotacaoDeGraus(vetor(0, 90, 0));
lista coisas = [1, "dois", 3.0, vetor(1, 1, 1)];
Convertendo
Inteiros e decimais se convertem sozinhos (decimal para inteiro corta a parte depois do ponto). Qualquer valor vira texto sozinho quando é juntado com um texto: "Você tem " + 3 + " vidas". Para o resto, use o nome do tipo como função:
texto t = "42";
inteiro n = inteiro(t); // 42
decimal d = decimal("3,5"); // 3.5 (vírgula ou ponto)
texto s = texto(12.5); // "12.5"
vetor v = vetor("<1, 2, 3>"); // de texto para vetor
inteiro arredondado = (inteiro)7.9; // 7 (também vale o jeito com parênteses)
Partes de vetores e rotações: v.x, v.y, v.z (e r.w nas rotações). Dá para mudar só uma parte: ponto.y = 5;. Itens de lista e letras de texto: coisas[0], recado[1] (só leitura).
Contas e comparações
| Operador | O que faz |
|---|---|
+ - * / % | Somar, subtrair, multiplicar, dividir e resto da divisão. Entre inteiros, a divisão é inteira: 7 / 2 é 3; 7.0 / 2 é 3.5. |
texto + valor | Junta os dois num texto só. |
lista + valor | Lista nova com o valor no fim (com outra lista: junta as duas). |
vetor + vetor, vetor - vetor | Soma e diferença de pontos ou direções. |
vetor * numero, vetor / numero | Aumenta ou diminui o vetor. |
vetor * vetor | Produto escalar (um decimal). |
vetor % vetor | Produto vetorial (um vetor perpendicular aos dois). |
vetor * rotacao | O vetor girado. |
rotacao * rotacao | Os dois giros, um depois do outro (primeiro o da esquerda). |
== != < > <= >= | Comparações. Dão VERDADEIRO (1) ou FALSO (0). |
&& || ! | E, ou, não. |
= += -= *= /= %= | Guardar valor: pontos += 10; é o mesmo que pontos = pontos + 10; |
++ -- | Soma ou tira 1: toques++; |
& | ^ ~ << >> | Operações com os bits de inteiros. |
Use parênteses quando estiver em dúvida sobre a ordem: (a + b) * 2.
Se, laços e saltos
se (pontos > 10)
{
dizer(0, "Ganhou!");
}
senao se (pontos > 5)
{
dizer(0, "Quase!");
}
senao
{
dizer(0, "Tente de novo.");
}
inteiro i;
para (i = 1; i <= 3; i++)
{
dizer(0, "Contando: " + i);
}
enquanto (vidas > 0)
{
vidas--;
se (vidas == 1) pare; // sai do laço
}
faca
{
tentativas++;
} enquanto (tentativas < 3);
se (condição) … senao …— faz uma coisa ou outra.enquanto (condição) …— repete enquanto a condição for verdadeira.para (começo; condição; passo) …— o laço de contar.faca … enquanto (condição);— repete, testando no fim (roda pelo menos uma vez).pare;sai do laço;continue;pula para a próxima volta.retorne;sai do evento ou da função (retorne valor;nas funções que devolvem algo).
temporizador.Suas funções
Crie funções para não repetir código. Escreva o tipo que ela devolve antes do nome (ou nada, se não devolver valor):
decimal media(decimal a, decimal b)
{
retorne (a + b) / 2;
}
avisar(texto recado)
{
dizerAoDono("[" + obterNome() + "] " + recado);
}
Funções ficam fora dos estados e podem ser usadas em qualquer evento. Variáveis criadas dentro de uma função ou evento só existem ali; as globais (fora de tudo) guardam o valor enquanto o script roda.
Estados
Um estado é um “modo” do objeto, com os seus próprios eventos. Uma porta pode ter os estados padrao (fechada) e aberta. Para trocar, escreva estado aberta;. Ao trocar:
- o evento atual para ali mesmo;
- roda o
ao_sair()do estado antigo (se existir); - os eventos que estavam esperando e as escutas (
ouvir) são cancelados — o temporizador continua; - roda o
ao_iniciar()do estado novo.
Para voltar ao primeiro estado: estado padrao;
Eventos
| Evento | Quando acontece |
|---|---|
ao_iniciar() | O script começou do zero (salvar ou Reiniciar) ou entrou neste estado. Não roda de novo quando a cidade reinicia: o script só continua. |
ao_sair() | O script está saindo deste estado. |
ao_tocar(chave quem, texto nome) | Alguém tocou no objeto (clique, toque rápido no celular, ou “Tocar” no menu redondo). Precisa estar a até 30 m. |
ao_ouvir(inteiro canal, texto nome, chave id, texto mensagem) | Alguém (pessoa ou objeto) falou algo que o script está ouvindo. Precisa de ouvir(…) antes. |
ao_temporizador() | Passou o tempo marcado em temporizador(segundos). Repete até desligar. |
ao_pagamento(chave quem, inteiro valor) | Alguém pagou o objeto (menu “Pagar…” ou clique, com definirAcaoDoClique("pagar")). O dinheiro já foi para o dono do objeto. |
ao_permissao(inteiro permissoes) | A pessoa respondeu ao pedirPermissao: as permissões dadas, ou 0 se negou (ou se o dono revogou). |
ao_mensagem(inteiro numero, texto mensagem, chave id) | Outro script deste objeto mandou mensagemInterna. |
ao_sentar(chave quem) | Alguém sentou ou deitou num lugar deste objeto. |
ao_levantar(chave quem) | Alguém levantou de um lugar deste objeto. |
ao_colisao(chave quem, texto nome) | Alguém encostou no objeto (ou entrou nele, se for fantasma). |
ao_fim_colisao(chave quem, texto nome) | A pessoa saiu de perto. |
ao_criado(inteiro parametro) | O objeto acabou de ser colocado no mundo (do inventário: parâmetro 0; por criarObjeto: o número passado). |
ao_mudanca(inteiro mudanca) | Algo mudou: MUDOU_DONO, MUDOU_CONTEUDO ou MUDOU_FORMA (peças ligadas/desligadas). Compare com &. |
ao_resposta_web(chave pedido, inteiro status, texto corpo) | Chegou a resposta de requisicaoWeb. Status 200 = deu certo; 0 = não conectou (o motivo vem no corpo). |
Os eventos de um script rodam um de cada vez, na ordem em que chegam. Os parâmetros precisam ter exatamente estes tipos (os nomes você escolhe).
Posição e rotação
- Distâncias são em metros.
xé leste–oeste,yé a altura (para cima) ezé norte–sul. - Cores também são vetores, de 0 a 1:
vetor(1, 1, 1)é branco,vetor(1, 0.5, 0)é laranja. - Para girar algo a partir de onde ele está:
definirRotacao(obterRotacao() * rotacaoDeGraus(vetor(0, 45, 0))); - Objetos giram em volta do centro da peça principal. Para uma porta girar pela dobradiça, ligue a porta a uma peça fina (a dobradiça) e deixe a dobradiça como peça principal.
- Um objeto movido por script nunca sai do terreno do dono, e anda no máximo 10 m por chamada.
Canais e comandos
Além da conversa normal (canal 0), existem os canais numerados, que só os scripts ouvem. Na conversa do jogo, digite uma barra, o número do canal e a mensagem:
/7 abrir
Ninguém vê essa mensagem; só os objetos a até 20 m que estão ouvindo o canal 7 recebem. Objetos também conversam entre si por canais, com dizer(7, "abrir"). Um objeto nunca ouve a si mesmo.
No canal 0, o script ouve o que as pessoas falam perto (20 m, ou 100 m quando alguém grita). Use os filtros do ouvir para não receber tudo: ouvir(0, "", obterDono(), "") ouve só o dono.
Dinheiro e permissões
Objetos podem receber e pagar dinheiro. Com isso dá para fazer lojas, máquinas de jogos, catracas pagas, gorjetas, aluguel de objetos e muito mais.
Receber pagamentos
- Basta o script ter o evento
ao_pagamento. O menu redondo do objeto passa a mostrar Pagar…; comdefinirAcaoDoClique("pagar"), um clique já abre a janela de pagar. - O dinheiro sai de quem paga e vai direto para o saldo do dono do objeto. Depois o script recebe
ao_pagamento(quem, valor)e decide o que fazer. definirPrecosPagamentoescolhe os botões de valor. ComPRECO_ESCONDIDOa pessoa só pode pagar os valores dos botões.- Se nenhum script receber o pagamento (parado, com erro), o dinheiro volta para quem pagou.
Pagar pessoas (com o dinheiro do dono)
ao_iniciar (quando o dono salva o script, ele está no jogo). Ela fica guardada no objeto: a loja ou a máquina continua funcionando 24 horas, com o dono fora do jogo e mesmo depois que a cidade reinicia. Receber pagamentos não precisa de permissão nenhuma.Um objeto não tem dinheiro próprio: quando ele paga alguém com darDinheiro, o valor sai do saldo do dono do objeto. Por isso, antes, o script precisa pedir pedirPermissao(obterDono(), PERMISSAO_DEBITAR). O dono vê uma janela que explica os riscos e decide se permite.
Para cancelar: Construir → aba Scripts → Revogar, ou pare/apague o script. A permissão também acaba sozinha quando o texto do script muda, quando ele é reiniciado e quando o objeto muda de dono. Objetos da própria cidade nunca recebem essa permissão.
- Cada script guarda as permissões de uma pessoa por vez (
quemDeuPermissao()).PERMISSAO_ANIMARePERMISSAO_TELEPORTARsão pedidas a quem vai ser animado ou levado. - Limites de segurança: no máximo 30 pagamentos por minuto por script, de 1 a 1.000.000 cada.
- Tudo fica no extrato do painel (motivo “objeto”).
// Vendedor: quem paga o preço recebe o produto guardado no Conteúdo do objeto.
// Antes: Construir → aba Scripts → Conteúdo… → coloque o produto (com o mesmo nome de "produto").
inteiro preco = 50;
texto produto = "Camiseta";
padrao
{
ao_iniciar()
{
definirPrecosPagamento(PRECO_ESCONDIDO, [preco]); // só aceita o valor certo
definirAcaoDoClique("pagar"); // clicar já abre a janela de pagar
definirTextoFlutuante(produto + "\nC$ " + preco + "\nClique para comprar", vetor(1, 1, 1), 1.0);
}
ao_pagamento(chave quem, inteiro valor)
{
se (darItem(quem, produto))
{
dizerPara(quem, "Obrigado! \"" + produto + "\" está no seu inventário, em Recebidos.");
}
senao
{
dizerAoDono("Não consegui entregar \"" + produto + "\" para " + nomeDe(quem) + ". Confira o Conteúdo e devolva o dinheiro.");
}
}
}
Conteúdo e entregas
Todo objeto tem um Conteúdo: itens guardados dentro dele. Abra Construir → aba Scripts → Conteúdo… para colocar itens do seu inventário (objetos, texturas, landmarks) ou tirá-los de volta.
darItem(pessoa, nome)entrega uma cópia do item. A pessoa recebe em Recebidos, mesmo se estiver fora do jogo.criarObjeto(nome, posição, giro, parâmetro)coloca um objeto do conteúdo no mundo, a até 10 m (portas que aparecem, fogos, móveis de uma loja de demonstração…).- As permissões do criador valem: um item “sem cópia” sai do objeto quando é entregue ou criado; um item que “não passa adiante” só pode ir para o dono.
- Até 32 itens por objeto. Quem não pode modificar o objeto não vê o conteúdo.
// Caixa de presentes: cada pessoa pega um presente só uma vez.
// Coloque o presente no Conteúdo do objeto (Construir → Scripts → Conteúdo…).
padrao
{
ao_tocar(chave quem, texto nome)
{
se (lerDado(quem) != "")
{
dizerPara(quem, "Você já pegou o seu presente em " + lerDado(quem) + ".");
retorne;
}
se (quantidadeDeItens() == 0)
{
dizerPara(quem, "A caixa está vazia.");
retorne;
}
se (darItem(quem, nomeDoItem(0)))
{
guardarDado(quem, dataHora());
dizerPara(quem, "Feliz aniversário da cidade! O presente está no seu inventário.");
}
}
}
Notas
No inventário, o botão + Nota cria uma nota de texto (até 8.000 caracteres). Coloque a nota no Conteúdo do objeto e o script lê linha por linha com linhasDaNota(nome) e lerNota(nome, linha): cardápios, regras do lugar, listas de preços, falas de um personagem… Para mudar o texto, edite a nota e coloque de novo no objeto.
// Cardápio: lê uma nota chamada "Cardápio" (do Conteúdo do objeto) e mostra ao tocar.
// Crie a nota no inventário (+ Nota), escreva um item por linha e coloque no Conteúdo deste objeto.
padrao
{
ao_tocar(chave quem, texto nome)
{
inteiro total = linhasDaNota("Cardápio");
se (total < 0)
{
dizerPara(quem, "Coloque uma nota chamada Cardápio no Conteúdo do objeto.");
retorne;
}
dizerPara(quem, "Cardápio de hoje:");
para (inteiro i = 0; i < total; i++)
{
texto linha = lerNota("Cardápio", i);
se (linha != "") dizerPara(quem, "• " + linha);
}
}
}
Animações e sons próprios
Você pode enviar as suas próprias animações e sons e usá-los nos objetos:
- No menu Arquivo → Enviar animação… ou Enviar som… (ou no Inventário, em Enviar animação ou som…), no computador. Cada envio tem um pequeno custo, mostrado na janela de escolher o arquivo, e vai para a pasta Animações ou Sons.
- Animação: arquivo
.bvh(o Blender e quase todos os programas de animação exportam). O esqueleto precisa começar em pose T e ter os ossos com nomes comuns (Hips, Spine, Head, LeftArm, RightUpLeg…). Até 30 segundos. Marque “Animação repete” antes de enviar se ela deve repetir sem parar. Ela se ajusta a qualquer avatar. - Som: arquivo
.oggou.wavde até 30 segundos (2 MB). Use OGG para sons longos. - No inventário dá para testar a animação no seu avatar e ouvir o som.
- Para um script usar, ponha o item no Conteúdo do objeto. Depois:
tocarSom("Portão abrindo", 1.0),repetirSom("Chuva", 0.5)outocarAnimacao(pessoa, "Minha dança")— sempre pelo nome do item. - Quem está perto ouve e vê. A pessoa para a animação andando.
// PORTÃO COM SOM: toque para abrir/fechar. Toca "Portão abrindo" ao abrir
// e "Portão fechando" ao fechar.
// Antes: envie os dois sons (.ogg ou .wav) pelo Inventário → "Enviar animação ou som…"
// e coloque-os no Conteúdo deste objeto (Construir → aba Scripts → Conteúdo…).
// O portão gira na peça principal (deixe a dobradiça como peça principal).
inteiro aberto = FALSO;
decimal ANGULO = 90.0; // quanto abre (graus)
decimal TEMPO = 2.5; // segundos para abrir/fechar
padrao
{
ao_tocar(chave quem, texto nome)
{
rotacao giro;
se (aberto)
{
tocarSom("Portão fechando", 1.0);
giro = obterRotacao() * rotacaoDeGraus(vetor(0, -ANGULO, 0));
}
senao
{
tocarSom("Portão abrindo", 1.0);
giro = obterRotacao() * rotacaoDeGraus(vetor(0, ANGULO, 0));
}
definirRotacaoSuave(giro, TEMPO);
aberto = !aberto;
}
}
// POSE PERSONALIZADA (ex.: um tapete de fotos)
// Envie a sua animação .bvh pelo Inventário e coloque no Conteúdo do objeto com o nome abaixo.
// Toque: pede permissão para animar o seu avatar e toca a pose. Toque de novo para parar.
texto ANIMACAO = "Minha pose";
chave posando = "";
padrao
{
ao_iniciar()
{
definirTextoFlutuante("Toque para posar", vetor(1, 1, 1), 1.0);
repetirSom("Música ambiente", 0.4); // opcional: só toca se houver esse som no Conteúdo
}
ao_tocar(chave quem, texto nome)
{
se (quem == posando)
{
pararAnimacao(quem);
posando = "";
retorne;
}
pedirPermissao(quem, PERMISSAO_ANIMAR);
}
ao_permissao(inteiro p)
{
se (p & PERMISSAO_ANIMAR)
{
posando = quemDeuPermissao();
se (!tocarAnimacao(posando, ANIMACAO))
dizerAoDono("Não achei a animação \"" + ANIMACAO + "\" no Conteúdo.");
}
}
}
Menus e janelas
mostrarMenu abre uma janela com botões na tela da pessoa; pedirTexto abre uma caixa para ela escrever. A resposta chega como se a pessoa tivesse falado no canal escolhido: o script precisa ouvir esse canal. Use canais negativos (como -7425) — ninguém consegue digitar neles.
// Luz com menu: toque para escolher a cor numa janela de botões.
inteiro canal = -7425; // canal negativo: ninguém consegue digitar nele
padrao
{
ao_iniciar()
{
ouvir(canal, "", "", "");
}
ao_tocar(chave quem, texto nome)
{
mostrarMenu(quem, "Escolha a cor da luz:", ["Vermelho", "Verde", "Azul", "Branco", "Apagar"], canal);
}
ao_ouvir(inteiro c, texto nome, chave id, texto escolha)
{
vetor cor = vetor(1, 1, 1);
se (escolha == "Apagar")
{
definirLuz(FALSO, cor, 0.0, 0.0);
definirBrilho(0.0, TODAS_FACES);
retorne;
}
se (escolha == "Vermelho") cor = vetor(1, 0.1, 0.1);
senao se (escolha == "Verde") cor = vetor(0.1, 1, 0.2);
senao se (escolha == "Azul") cor = vetor(0.2, 0.4, 1);
definirCor(cor, TODAS_FACES);
definirBrilho(0.4, TODAS_FACES);
definirLuz(VERDADEIRO, cor, 0.8, 8.0);
}
}
Dados guardados
Além das variáveis, o objeto tem uma pequena “gaveta” de dados com nome: guardarDado("recorde", "120") e lerDado("recorde"). Os dados ficam no objeto mesmo quando o script é apagado, trocado ou reiniciado, e todos os scripts do objeto enxergam os mesmos dados. Bom para recordes, listas de quem já pegou um presente, configurações.
Internet
requisicaoWeb chama um site ou serviço (só endereços https://; nada da rede interna do servidor). A resposta chega depois, em ao_resposta_web. Use jsonObter para ler respostas em JSON. Cada pedido leva o cabeçalho X-CidadeRP-Objeto com a chave do objeto.
// Hora certa pela internet: toque e o objeto busca a hora num serviço público.
padrao
{
ao_tocar(chave quem, texto nome)
{
requisicaoWeb("https://worldtimeapi.org/api/timezone/America/Sao_Paulo", "GET", "");
}
ao_resposta_web(chave pedido, inteiro status, texto corpo)
{
se (status != 200)
{
dizer(0, "Não consegui ver a hora agora (" + corpo + ").");
retorne;
}
texto agora = jsonObter(corpo, "datetime");
dizer(0, "Agora são " + parteTexto(agora, 11, 5) + " em São Paulo.");
}
}
Funções prontas
Onde aparece face, use o número da face (0, 1, 2…) ou TODAS_FACES. Onde aparece peca, 1 é a peça principal e TODAS_PECAS são todas.
Conversa
dizer(inteiro canal, texto mensagem) | Fala a até 20 m. No canal 0 as pessoas veem na conversa; em outros canais, só scripts ouvem. |
gritar(inteiro canal, texto mensagem) | Como dizer, mas alcança 100 m. |
sussurrar(inteiro canal, texto mensagem) | Como dizer, mas alcança só 10 m. |
dizerAoDono(texto mensagem) | Mensagem só para o dono do objeto (se ele estiver na cidade). |
dizerPara(chave pessoa, texto mensagem) | Mensagem só para uma pessoa (use a chave recebida em ao_tocar ou ao_ouvir). |
inteiro ouvir(inteiro canal, texto nome, chave id, texto mensagem) | Começa a ouvir um canal. Deixe nome, id ou mensagem vazios ("") para aceitar qualquer um. Devolve um número para usar em pararDeOuvir. Máximo de 16 por script. |
pararDeOuvir(inteiro numero) | Para de ouvir (use o número que ouvir devolveu). |
Tempo
temporizador(decimal segundos) | Chama ao_temporizador a cada tantos segundos (mínimo 0.1). temporizador(0) desliga. |
decimal tempo() | Segundos desde que o script começou (ou desde zerarTempo). |
zerarTempo() | Volta o relógio de tempo() para zero. |
texto dataHora() | Data e hora de Brasília, no formato 2026-11-09 18:30:00. |
decimal horaDoDia() | Segundos desde a meia-noite (horário de Brasília). 43200 = meio-dia. |
inteiro unixTempo() | Segundos desde 1/1/1970 (bom para guardar quando algo aconteceu). |
Objeto
chave obterChave() | A chave (identidade) deste objeto. |
chave obterDono() | A chave do dono do objeto. |
texto nomeDoDono() | O nome do dono. |
texto obterNome() | O nome do objeto. |
definirNome(texto nome) | Muda o nome do objeto (é o nome que aparece quando ele fala). |
texto obterDescricao() | A descrição do objeto. |
definirDescricao(texto descricao) | Muda a descrição (bom para guardar um texto curto). |
vetor obterPosicao() | Onde o objeto está, em metros. |
inteiro definirPosicao(vetor posicao) | Move o objeto (no máximo 10 m por vez). Não sai do terreno: devolve FALSO se não coube. |
inteiro definirPosicaoSuave(vetor posicao, decimal segundos) | Como definirPosicao, mas o objeto desliza até lá devagar, levando segundos (até 10). Bom para portas de correr e elevadores. |
rotacao obterRotacao() | Para onde o objeto está virado. |
inteiro definirRotacao(rotacao giro) | Vira o objeto. Devolve FALSO se, virado, ele passaria do terreno. |
inteiro definirRotacaoSuave(rotacao giro, decimal segundos) | Como definirRotacao, mas o objeto gira devagar, levando segundos (até 10). Bom para portas que abrem. |
vetor obterEscala() | Tamanho da peça principal, em metros. |
inteiro definirEscala(vetor tamanho) | Muda o tamanho da peça principal (0.01 a 32 m por lado). |
inteiro numeroDePecas() | Quantas peças o objeto tem (1 se não estiver ligado a outras). |
inteiro adicionarAssento(vetor ponto, decimal giro, decimal altura) | Cria um lugar para sentar (sofá, banco, cadeira). ponto = no chão, na frente do assento, relativo ao centro do objeto; giro = para onde a pessoa sentada olha (graus); altura = altura do assento. Quem chega perto vê o botão Sentar. Até 8 lugares por objeto. |
inteiro adicionarCama(vetor peDaCama, decimal giro, decimal altura) | Cria um lugar para deitar. peDaCama = no chão, no pé da cama; giro = para onde ficam os pés; altura = altura do colchão. O corpo deita de costas na direção da cabeceira. |
limparAssentos() | Apaga todos os lugares de sentar e deitar do objeto. |
definirFantasma(inteiro ligado) | VERDADEIRO: dá para atravessar o objeto. |
Aparência
definirCor(vetor cor, inteiro face) | Pinta a peça principal. Cor de 0 a 1: vetor(1, 0, 0) é vermelho. Face: número ou TODAS_FACES. |
definirCorPeca(inteiro peca, vetor cor, inteiro face) | Pinta outra peça (1 = principal) ou TODAS_PECAS. |
vetor obterCor(inteiro face) | A cor de uma face da peça principal. |
definirOpacidade(decimal opacidade, inteiro face) | 1 = sólido, 0.5 = meio transparente, 0 = invisível. |
definirOpacidadePeca(inteiro peca, decimal opacidade, inteiro face) | O mesmo, em outra peça. |
definirBrilho(decimal brilho, inteiro face) | Faz a face brilhar (0 a 1). |
definirBrilhoPeca(inteiro peca, decimal brilho, inteiro face) | O mesmo, em outra peça. |
definirLuzPropria(inteiro ligada, inteiro face) | A face fica clara mesmo à noite ou na sombra. |
definirTextura(texto textura, inteiro face) | Troca a textura. Use o nome da biblioteca (como aparece em Construir → Textura) ou o código de uma textura enviada. |
definirTexturaPeca(inteiro peca, texto textura, inteiro face) | O mesmo, em outra peça. |
definirTextoFlutuante(texto texto, vetor cor, decimal opacidade) | Texto que flutua em cima do objeto (até 254 letras; \n pula linha). Texto vazio apaga. |
definirLuz(inteiro ligada, vetor cor, decimal intensidade, decimal alcance) | O objeto ilumina em volta. Intensidade de 0 a 1, alcance de 0.1 a 20 m. |
girar(vetor eixo, decimal velocidade) | Gira o objeto sem parar (velocidade em radianos por segundo; PI = meia volta por segundo). girar(VETOR_ZERO, 0) para. É só visual: o objeto não muda de lugar de verdade. |
Pessoas
texto nomeDe(chave pessoa) | O nome de uma pessoa que está na cidade (vazio se não estiver). |
vetor posicaoDe(chave pessoa) | Onde a pessoa está (VETOR_ZERO se não estiver na cidade). |
lista avataresPerto(decimal raio) | Chaves das pessoas a até raio metros (máximo 96), da mais perto para a mais longe. No máximo 16. |
Matemática
abs(numero) | Valor sem sinal. Devolve inteiro ou decimal, igual ao que recebeu. |
inteiro arredondar(decimal x) | Arredonda para o inteiro mais perto. |
inteiro piso(decimal x) | Arredonda para baixo. |
inteiro teto(decimal x) | Arredonda para cima. |
decimal raiz(decimal x) | Raiz quadrada. |
decimal potencia(decimal base, decimal expoente) | base elevado a expoente. |
decimal seno(decimal radianos) | Seno. |
decimal cosseno(decimal radianos) | Cosseno. |
decimal tangente(decimal radianos) | Tangente. |
decimal arcoSeno(decimal x) | Ângulo (radianos) cujo seno é x. |
decimal arcoCosseno(decimal x) | Ângulo (radianos) cujo cosseno é x. |
decimal arcoTangente2(decimal y, decimal x) | Ângulo (radianos) do ponto (x, y). |
decimal logaritmo(decimal x) | Logaritmo natural. |
decimal logaritmo10(decimal x) | Logaritmo na base 10. |
decimal minimo(decimal a, decimal b) | O menor dos dois. |
decimal maximo(decimal a, decimal b) | O maior dos dois. |
decimal limitar(decimal x, decimal menor, decimal maior) | Prende x entre os dois limites. |
decimal aleatorio(decimal maximo) | Número sorteado de 0 até maximo. |
inteiro aleatorioInteiro(inteiro de, inteiro ate) | Inteiro sorteado de de até ate (os dois valem). |
Vetores e rotações
decimal distancia(vetor a, vetor b) | Distância em metros entre dois pontos. |
decimal comprimento(vetor v) | Tamanho do vetor. |
vetor normalizar(vetor v) | Mesmo sentido, tamanho 1. |
rotacao rotacaoDeGraus(vetor graus) | Rotação a partir de graus em x, y e z. rotacaoDeGraus(vetor(0, 90, 0)) = um quarto de volta deitado. |
vetor grausDeRotacao(rotacao giro) | O contrário: os graus em x, y e z (de -180 a 180). |
rotacao rotacaoEixo(vetor eixo, decimal graus) | Gira graus em volta de um eixo. |
rotacao rotacaoEntre(vetor de, vetor para) | O giro que leva uma direção até a outra. |
vetor frenteDe(rotacao giro) | Para onde é a frente (eixo z) depois do giro. |
vetor direitaDe(rotacao giro) | Para onde é a direita (eixo x) depois do giro. |
vetor cimaDe(rotacao giro) | Para onde é o alto (eixo y) depois do giro. |
Dinheiro e permissões
definirPrecosPagamento(inteiro padrao, lista botoes) | Configura a janela de pagar: até 4 botões de valor rápido (ex.: [10, 50, 100]) e o valor sugerido no campo livre. Use PRECO_ESCONDIDO para aceitar só os valores dos botões, ou PRECO_PADRAO para o campo livre sem sugestão. O objeto só aparece para pagar se tiver o evento ao_pagamento. |
pedirPermissao(chave pessoa, inteiro permissoes) | Abre uma janela para a pessoa aceitar ou negar. Some as permissões: PERMISSAO_DEBITAR (só o dono do objeto; o objeto passa a poder tirar dinheiro do saldo dele), PERMISSAO_ANIMAR e PERMISSAO_TELEPORTAR. A resposta chega em ao_permissao. Uma pessoa por vez. |
inteiro permissoes() | As permissões que o script tem agora (some/compare com &). |
chave quemDeuPermissao() | Quem deu as permissões atuais. |
inteiro darDinheiro(chave pessoa, inteiro valor) | Paga a pessoa com o dinheiro do dono do objeto. Precisa da PERMISSAO_DEBITAR. Devolve FALSO se o dono não tem saldo ou a pessoa não existe. Até 30 pagamentos por minuto; de 1 a 1.000.000 cada. |
inteiro saldoDoDono() | O saldo do dono (precisa da PERMISSAO_DEBITAR). |
Conteúdo do objeto
inteiro quantidadeDeItens() | Quantos itens estão guardados no objeto (aba Scripts → Conteúdo…). |
texto nomeDoItem(inteiro posicao) | Nome do item na posição (0 = primeiro). |
inteiro temItem(texto nome) | VERDADEIRO se existe um item com esse nome. |
inteiro linhasDaNota(texto nome) | Quantas linhas tem a nota com esse nome no conteúdo do objeto (-1 se não existe). |
texto lerNota(texto nome, inteiro linha) | Uma linha da nota (a primeira é a 0; fora do intervalo devolve texto vazio). Crie a nota no inventário (+ Nota) e coloque no Conteúdo do objeto. |
inteiro darItem(chave pessoa, texto nome) | Entrega uma cópia do item à pessoa (vai para Recebidos, mesmo se ela estiver fora do jogo). Itens sem permissão de cópia saem do objeto. Até 30 por minuto. |
inteiro criarObjeto(texto nome, vetor posicao, rotacao giro, inteiro parametro) | Coloca no mundo um objeto do conteúdo, a até 10 m. O dono é o mesmo deste objeto e ele precisa caber no terreno. Os scripts do objeto novo recebem ao_criado(parametro). |
apagarObjeto() | Apaga este objeto do mundo (de vez, sem ir para a Lixeira). O evento atual termina ali. |
definirTemporario(inteiro ligado) | VERDADEIRO: o objeto some sozinho 1 minuto depois de criado (bom para balas, fogos, efeitos). |
Menus e janelas
mostrarMenu(chave pessoa, texto mensagem, lista botoes, inteiro canal) | Abre uma janela com até 12 botões (24 letras cada). O botão escolhido chega em ao_ouvir no canal (use um canal diferente de 0 e ouvir antes), com o nome e a chave da pessoa. |
pedirTexto(chave pessoa, texto mensagem, inteiro canal) | Abre uma caixa para a pessoa escrever (até 255 letras). A resposta chega em ao_ouvir no canal. |
Mensagens
mensagemInterna(inteiro numero, texto mensagem, chave id) | Manda uma mensagem para os outros scripts deste objeto (evento ao_mensagem). Bom para dividir um objeto grande em vários scripts. |
dizerNaCidade(inteiro canal, texto mensagem) | Fala num canal (diferente de 0) para objetos da cidade inteira, sem limite de distância. |
Dados guardados
inteiro guardarDado(texto nome, texto valor) | Guarda um valor com um nome, dentro do objeto. Fica guardado mesmo se o script for apagado, reiniciado ou trocado, e é o mesmo para todos os scripts do objeto. Até 256 dados e 16 KB no total. Devolve FALSO se não coube. |
texto lerDado(texto nome) | O valor guardado com esse nome ("" se não tem). |
apagarDado(texto nome) | Apaga um dado. |
lista chavesDosDados() | Os nomes de todos os dados guardados. |
limparDados() | Apaga todos os dados do objeto. |
Lugares e pessoas
inteiro numeroDeAssentos() | Quantos lugares de sentar/deitar o objeto tem. |
chave quemEstaSentado(inteiro lugar) | Quem está no lugar (1, 2…); com 0, a primeira pessoa sentada. "" se está vazio. |
inteiro tirarDoAssento(chave pessoa) | Faz a pessoa levantar de um lugar deste objeto. |
inteiro tocarAnimacao(chave pessoa, texto animacao) | Faz o avatar da pessoa tocar uma animação ENVIADA que está no Conteúdo do objeto (pelo nome do item) ou uma ação do jogo: "dancar", "danca1" até "danca18" (estilo masculino), "dancaf1" até "dancaf18" (estilo feminino), "conversar", "agachar"… Precisa da PERMISSAO_ANIMAR dessa pessoa. Devolve FALSO se não achou. |
inteiro pararAnimacao(chave pessoa) | Para a ação do avatar (precisa da PERMISSAO_ANIMAR). |
inteiro teleportar(chave pessoa, vetor destino) | Leva a pessoa para o ponto (se ela puder entrar lá). Precisa da PERMISSAO_TELEPORTAR dessa pessoa. |
Sons
inteiro tocarSom(texto som, decimal volume) | Toca uma vez um som enviado que está no Conteúdo do objeto (pelo nome do item). Volume de 0 a 1. Quem está a até 30 m ouve (mais baixo de longe). Até 60 por minuto. Devolve FALSO se não achou o som. |
inteiro repetirSom(texto som, decimal volume) | Deixa um som tocando sem parar no objeto (música ambiente, motor, chuva). Continua mesmo se a cidade reiniciar. |
pararSom() | Para o som que está repetindo. |
Clique e efeitos
definirAcaoDoClique(texto acao) | O que o clique esquerdo faz: "tocar", "sentar", "pagar" (abre a janela de pagar), "nenhuma" ou "" (normal: tocar se o script tem ao_tocar, senão sentar). |
inteiro pecaTocada() | No ao_tocar: qual peça foi tocada (1 = principal; 0 = não se sabe). |
inteiro faceTocada() | No ao_tocar: qual face foi tocada (-1 = não se sabe). |
definirParticulas(texto efeito, vetor cor, decimal intensidade) | Liga um efeito: "fogo", "fumaca", "faisca", "bolhas", "confete", "brilho", "chuva" ou "neve". Cor branca usa as cores naturais do efeito. Intensidade de 0.1 a 3. |
pararParticulas() | Desliga o efeito. |
Mundo
chave obterCriador() | Quem criou o objeto. |
texto nomeDoCriador() | O nome de quem criou o objeto. |
texto nomeDoObjeto(chave objeto) | Nome de outro objeto (pela chave). |
vetor posicaoDoObjeto(chave objeto) | Onde está outro objeto. |
chave donoDoObjeto(chave objeto) | Dono de outro objeto. |
lista objetosPerto(decimal raio) | Chaves dos objetos a até raio metros (até 96), do mais perto ao mais longe. No máximo 16. |
chave donoDoTerreno(vetor ponto) | Dono do terreno nesse ponto. |
texto nomeDoTerreno(vetor ponto) | Nome do terreno nesse ponto. |
chave locatarioDoTerreno(vetor ponto) | Locatário do terreno nesse ponto (quem alugou). Vazio se não estiver alugado. |
texto nomeDoLocatario(vetor ponto) | Nome do locatário do terreno nesse ponto. Vazio se não estiver alugado. |
inteiro fimDoAluguel(vetor ponto) | Quando o aluguel do terreno nesse ponto acaba, em segundos Unix (compare com unixTempo()). 0 se não estiver alugado. |
inteiro podeUsarTerreno(chave avatar) | 1 se o avatar é o dono ou o locatário do terreno onde este objeto está. Use em portas, luzes e cofres da casa para que funcionem para quem alugou: se (podeUsarTerreno(quem) == 1) { ... } |
Peças
vetor posicaoDaPeca(inteiro peca) | Posição da peça em relação à principal. |
inteiro definirPosicaoPeca(inteiro peca, vetor posicao) | Move uma peça (não a principal) em relação à principal, até 64 m. |
rotacao rotacaoDaPeca(inteiro peca) | Giro da peça em relação à principal. |
inteiro definirRotacaoPeca(inteiro peca, rotacao giro) | Gira uma peça (não a principal). |
vetor escalaDaPeca(inteiro peca) | Tamanho da peça. |
inteiro definirEscalaPeca(inteiro peca, vetor tamanho) | Muda o tamanho de uma peça. |
texto nomeDaPeca(inteiro peca) | Nome da peça. |
definirNomePeca(inteiro peca, texto nome) | Muda o nome da peça. |
Internet
chave requisicaoWeb(texto endereco, texto metodo, texto corpo) | Chama um site (só https://). Método "GET", "POST", "PUT" ou "DELETE". A resposta chega em ao_resposta_web (até 4096 letras). Até 10 por minuto; espera no máximo 10 s. |
texto jsonObter(texto json, texto caminho) | Lê um valor de um JSON: jsonObter(corpo, "dados.lista.0.nome"). "" se não tem. |
texto jsonDefinir(texto json, texto caminho, texto valor) | Devolve o JSON com o valor trocado (cria o que faltar). Números e true/false viram números e booleanos. |
texto codificarUrl(texto t) | Prepara um texto para ir num endereço: espaço vira %20. |
texto decodificarUrl(texto t) | O contrário de codificarUrl. |
Texto
inteiro tamanho(texto t) | Quantas letras. |
texto parteTexto(texto t, inteiro inicio, inteiro quantidade) | Pedaço do texto. A primeira letra é 0; início negativo conta do fim. |
inteiro procurar(texto t, texto trecho) | Onde o trecho começa, ou -1 se não tem. Diferencia maiúsculas. |
inteiro contem(texto t, texto trecho) | VERDADEIRO se tem o trecho (sem ligar para maiúsculas). |
inteiro comecaCom(texto t, texto inicio) | Começa assim? (sem ligar para maiúsculas) |
inteiro terminaCom(texto t, texto fim) | Termina assim? (sem ligar para maiúsculas) |
texto maiusculas(texto t) | TUDO MAIÚSCULO. |
texto minusculas(texto t) | tudo minúsculo. |
texto aparar(texto t) | Tira os espaços do começo e do fim. |
texto substituir(texto t, texto de, texto para) | Troca todos os trechos de por para. |
lista dividir(texto t, texto separador) | Quebra em pedaços: dividir("a,b,c", ",") = ["a", "b", "c"]. |
texto juntar(lista l, texto separador) | O contrário de dividir. |
texto caractere(inteiro codigo) | A letra desse código (65 = "A"). |
inteiro codigo(texto t, inteiro posicao) | O código da letra na posição. |
texto hashMd5(texto t) | Resumo MD5 (32 letras hexadecimais). |
texto hashSha256(texto t) | Resumo SHA-256 (64 letras hexadecimais). Bom para conferir senhas e assinaturas. |
texto paraBase64(texto t) | Converte para Base64. |
texto deBase64(texto t) | Converte de Base64. |
texto listaParaTexto(lista l) | Itens separados por vírgula: "1, a, 2.5". |
lista textoParaLista(texto t) | O contrário: quebra nas vírgulas e tira os espaços. |
Listas
inteiro tamanhoLista(lista l) | Quantos itens. |
item(lista l, inteiro posicao) | O item na posição (0 = primeiro, -1 = último). Também dá para escrever l[0]. |
texto tipoDoItem(lista l, inteiro posicao) | "inteiro", "decimal", "texto", "vetor" ou "rotacao". |
lista adicionar(lista l, valor) | Lista nova com o valor no fim. O mesmo que l + valor. |
lista inserir(lista l, valor, inteiro posicao) | Lista nova com o valor na posição. |
lista removerItens(lista l, inteiro inicio, inteiro quantidade) | Lista nova sem esses itens. |
inteiro procurarNaLista(lista l, valor) | Posição do valor, ou -1. |
lista sublista(lista l, inteiro inicio, inteiro quantidade) | Pedaço da lista. |
lista ordenar(lista l, inteiro crescente) | Lista nova em ordem (VERDADEIRO = crescente). |
lista embaralhar(lista l) | Lista nova com os itens em ordem sorteada. |
Script
reiniciarScript() | Recomeça o script do zero: variáveis voltam ao valor inicial e o estado volta para padrao. |
texto estadoAtual() | O nome do estado em que o script está. |
texto nomeDoScript() | O nome deste script. |
inteiro memoriaLivre() | Quantos bytes de memória ainda sobram (de 64 KB). |
ligarScript(texto nome, inteiro ligado) | Liga ou para outro script deste objeto. |
chave gerarChave() | Uma chave nova, única (bom para identificar pedidos). |
Constantes
| Nome | Valor |
|---|---|
VERDADEIRO, FALSO | 1 e 0 |
PI, DOIS_PI, MEIO_PI | 3.14159…, 6.28318…, 1.57079… |
GRAUS_PARA_RAD, RAD_PARA_GRAUS | Multiplique para converter ângulos. |
TODAS_FACES, TODAS_PECAS | -1 |
CANAL_PUBLICO | 0 |
CHAVE_NULA | Chave vazia ("") |
VETOR_ZERO, ROTACAO_ZERO | vetor(0, 0, 0) e sem giro |
PERMISSAO_DEBITAR, PERMISSAO_ANIMAR, PERMISSAO_TELEPORTAR | 1, 2 e 4 (some para pedir mais de uma) |
PRECO_ESCONDIDO, PRECO_PADRAO | -1 e -2 (para definirPrecosPagamento) |
MUDOU_DONO, MUDOU_CONTEUDO, MUDOU_FORMA | 1, 2 e 4 (em ao_mudanca) |
Limites
Os limites existem para que nenhum objeto deixe a cidade lenta para os outros.
| Scripts por objeto | 8 |
| Tamanho de um script | 32.000 letras |
| Memória das variáveis globais | 64 KB por script |
| Operações por evento | 20.000 (passou disso, o script para com erro) |
| Eventos esperando na fila | 64 (os outros se perdem) |
Escutas (ouvir) ao mesmo tempo | 16 |
| Temporizador | no mínimo 0,1 segundo |
| Mensagens | 20 seguidas; depois, 2 por segundo (o resto se perde). Até 1024 letras cada. |
| Texto e lista | 4096 letras por texto; 512 itens por lista |
| Texto flutuante | 254 letras |
| Mover | 10 m por chamada, sem sair do terreno do dono |
Pagamentos (darDinheiro) | 30 por minuto, de 1 a 1.000.000; só com PERMISSAO_DEBITAR |
| Itens entregues / objetos criados | 30 por minuto cada; criar a até 10 m |
| Conteúdo | 32 itens por objeto |
| Dados guardados | 256 nomes, 16 KB no total por objeto |
| Menus e pedidos de permissão | 10 seguidos; depois, 30 por minuto |
| Internet | 10 pedidos por minuto; resposta até 4096 letras; 10 s de espera |
O script não esquece
As variáveis globais, o estado atual, o temporizador e as escutas (ouvir) ficam guardados dentro do objeto. Por isso o script continua de onde parou:
- quando a cidade reinicia (atualizações, manutenção) — um contador que estava em 100 continua em 100;
- quando o objeto vai para o inventário e volta para o mundo, ou é copiado (a cópia leva os valores);
- quando você clica em Parar e depois em Ligar.
As permissões dadas com pedirPermissao também continuam — menos quando o objeto muda de dono.
Nesses casos o ao_iniciar() não roda de novo. O script volta do zero (variáveis com o valor inicial e ao_iniciar() rodando) só quando você salva o script, clica em Reiniciar ou usa reiniciarScript().
Erros comuns
| Mensagem | O que fazer |
|---|---|
| esperava ';' no fim do comando | Faltou o ponto e vírgula na linha indicada (ou na anterior). |
| "x" não foi declarado | Crie a variável antes de usar: inteiro x = 0; Confira também maiúsculas e minúsculas. |
| função "x" não existe | Confira o nome na lista de funções prontas (sem acento). |
| o evento ao_tocar deve ser: … | Os parâmetros do evento precisam ter os tipos certos, na ordem certa. |
| esperava inteiro, mas veio texto | Converta: inteiro("12"). |
| operações demais de uma vez | Um laço sem fim, ou trabalho demais num evento só. Divida o trabalho com temporizador. |
| Parado: este terreno não deixa scripts de outros rodarem | Leve o objeto para o seu terreno, ou peça ao dono do terreno para liberar scripts. |
Quando um script para por erro, o dono recebe uma mensagem na conversa. Corrija e salve de novo (ou clique em Reiniciar).
Exemplos
Copie, cole na janela do script e salve. Depois mude à vontade.
Lâmpada
Toque para acender e apagar.
inteiro acesa = FALSO;
padrao
{
ao_tocar(chave quem, texto nome)
{
acesa = !acesa;
se (acesa)
{
definirLuz(VERDADEIRO, vetor(1, 0.9, 0.7), 0.8, 8);
definirBrilho(0.6, TODAS_FACES);
}
senao
{
definirLuz(FALSO, vetor(1, 1, 1), 0, 1);
definirBrilho(0, TODAS_FACES);
}
}
}Porta que fecha sozinha
Abre devagar ao tocar e fecha depois de 3 segundos. Usa dois estados e o temporizador.
// Porta que abre devagar ao tocar e fecha sozinha depois de 3 segundos
rotacao fechada;
padrao
{
ao_iniciar()
{
fechada = obterRotacao(); // guarda como a porta está fechada
}
ao_tocar(chave quem, texto nome)
{
estado aberta;
}
}
estado aberta
{
ao_iniciar()
{
definirRotacaoSuave(fechada * rotacaoDeGraus(vetor(0, 90, 0)), 1.5); // abre em 1,5 s
temporizador(1.5 + 3); // espera abrir e mais 3 segundos
}
ao_temporizador()
{
estado padrao;
}
ao_sair()
{
temporizador(0);
definirRotacaoSuave(fechada, 1.5); // fecha em 1,5 s
}
}Placa
Texto flutuando em cima do objeto.
padrao
{
ao_iniciar()
{
definirTextoFlutuante("Loja do Zé\nAberta todos os dias", vetor(1, 0.85, 0.3), 1);
}
}Ventilador
Gira sem parar.
padrao
{
ao_iniciar()
{
girar(vetor(0, 1, 0), PI); // meia volta por segundo, em volta do eixo de cima
}
}Controle por comando
O dono digita /7 azul na conversa.
inteiro CANAL = 7;
padrao
{
ao_iniciar()
{
ouvir(CANAL, "", obterDono(), ""); // só o dono manda
dizerAoDono("Comandos: /7 vermelho, /7 azul, /7 sumir, /7 aparecer");
}
ao_ouvir(inteiro canal, texto nome, chave id, texto mensagem)
{
texto m = minusculas(aparar(mensagem));
se (m == "vermelho") definirCor(vetor(1, 0, 0), TODAS_FACES);
senao se (m == "azul") definirCor(vetor(0, 0.4, 1), TODAS_FACES);
senao se (m == "sumir") definirOpacidade(0, TODAS_FACES);
senao se (m == "aparecer") definirOpacidade(1, TODAS_FACES);
}
}Recepção da loja
Cumprimenta quem chega perto e conta os visitantes.
lista visitantes = [];
padrao
{
ao_iniciar()
{
temporizador(2);
}
ao_temporizador()
{
lista perto = avataresPerto(5);
inteiro i;
para (i = 0; i < tamanhoLista(perto); i++)
{
chave quem = perto[i];
se (procurarNaLista(visitantes, quem) == -1)
{
visitantes += quem;
inteiro total = tamanhoLista(visitantes);
dizerPara(quem, "Bem-vindo, " + nomeDe(quem) + "! Você é o visitante número " + total + ".");
definirTextoFlutuante("Visitantes: " + total, vetor(1, 1, 1), 1);
}
}
}
}Dado
Sorteia um número de 1 a 6.
padrao
{
ao_tocar(chave quem, texto nome)
{
inteiro n = aleatorioInteiro(1, 6);
dizer(0, nome + " jogou o dado e tirou " + n + "!");
}
}Plataforma que sobe
Sobe 3 m e desce a cada toque.
vetor embaixo;
inteiro emCima = FALSO;
padrao
{
ao_iniciar()
{
embaixo = obterPosicao();
}
ao_tocar(chave quem, texto nome)
{
emCima = !emCima;
se (emCima) definirPosicaoSuave(embaixo + vetor(0, 3, 0), 2);
senao definirPosicaoSuave(embaixo, 2);
}
}Pisca-pisca
Muda de cor a cada meio segundo.
padrao
{
ao_iniciar()
{
temporizador(0.5);
}
ao_temporizador()
{
definirCor(vetor(aleatorio(1), aleatorio(1), aleatorio(1)), TODAS_FACES);
}
}Relógio
Mostra a hora de Brasília.
padrao
{
ao_iniciar()
{
temporizador(1);
}
ao_temporizador()
{
texto agora = dataHora(); // "2026-11-09 18:30:05"
definirTextoFlutuante(parteTexto(agora, 11, 8), vetor(0.6, 1, 0.7), 1);
}
}Lanchonete 24 horas
Vende vários produtos do Conteúdo. Pede a permissão uma vez só, ao ser salva, para devolver o dinheiro sozinha quando faltar produto — depois funciona com o dono fora do jogo.
// LANCHONETE 24 h: vende até 4 produtos. Cada botão da janela de pagar é um produto.
// 1) Construir → aba Scripts → Conteúdo… → "Colocar" os produtos (nomes IGUAIS aos da lista).
// 2) Ao salvar, o script pede UMA VEZ a permissão de usar o seu saldo (para devolver
// o dinheiro sozinho se um produto faltar). Depois disso a loja funciona sozinha,
// com você fora do jogo, mesmo se a cidade reiniciar.
// Comando do dono na conversa: /8 vendas
lista produtos = ["Refrigerante", "Lanche", "Pizza"];
lista precos = [5, 12, 30]; // preços diferentes: o valor pago diz qual produto foi
atualizarPlaca()
{
texto placa = "LANCHONETE\n";
inteiro i;
para (i = 0; i < tamanhoLista(produtos); i++)
{
placa += produtos[i] + " ........ C$ " + precos[i] + "\n";
}
placa += "Clique para comprar";
definirTextoFlutuante(placa, vetor(1, 0.9, 0.4), 1.0);
}
// Devolve o dinheiro de quem pagou (sai do saldo do dono, por isso precisa da permissão)
devolver(chave quem, inteiro valor, texto motivo)
{
se ((permissoes() & PERMISSAO_DEBITAR) && darDinheiro(quem, valor))
{
dizerPara(quem, motivo + " Seu dinheiro (C$ " + valor + ") foi devolvido.");
dizerAoDono("Devolvi C$ " + valor + " para " + nomeDe(quem) + ": " + motivo);
}
senao
{
dizerPara(quem, motivo + " O dono foi avisado para devolver o seu dinheiro.");
dizerAoDono("Devolva C$ " + valor + " para " + nomeDe(quem) + ": " + motivo);
}
}
padrao
{
ao_iniciar()
{
definirPrecosPagamento(PRECO_ESCONDIDO, precos); // só aceita os preços da lista
definirAcaoDoClique("pagar"); // clicar abre a janela de pagar
atualizarPlaca();
ouvir(8, "", obterDono(), ""); // comandos só do dono
pedirPermissao(obterDono(), PERMISSAO_DEBITAR); // pede uma vez só
}
ao_permissao(inteiro p)
{
se (p & PERMISSAO_DEBITAR) dizerAoDono("Permissão dada: a lanchonete devolve o dinheiro sozinha quando faltar produto.");
senao dizerAoDono("Sem a permissão a lanchonete vende normalmente, mas não consegue devolver dinheiro sozinha.");
}
ao_pagamento(chave quem, inteiro valor)
{
inteiro i = procurarNaLista(precos, valor);
se (i < 0)
{
devolver(quem, valor, "Esse valor não é o preço de nenhum produto.");
retorne;
}
texto produto = produtos[i];
se (!temItem(produto))
{
devolver(quem, valor, produto + " acabou.");
retorne;
}
se (darItem(quem, produto))
{
dizerPara(quem, "Bom apetite! \"" + produto + "\" está no seu inventário, em Recebidos.");
guardarDado("vendas", (texto)((inteiro)lerDado("vendas") + 1));
guardarDado("faturado", (texto)((inteiro)lerDado("faturado") + valor));
}
senao
{
devolver(quem, valor, "Não consegui entregar \"" + produto + "\".");
}
}
ao_ouvir(inteiro canal, texto nome, chave id, texto mensagem)
{
se (minusculas(aparar(mensagem)) == "vendas")
{
dizerAoDono("Vendas: " + lerDado("vendas") + " · Faturado: C$ " + lerDado("faturado"));
}
}
}Caça-níquel
Cada jogada custa C$ 10; os prêmios saem do saldo do dono, que precisa abrir a máquina e dar a permissão. Tem confete quando alguém ganha.
// Caça-níquel: cada jogada custa C$ 10. Os prêmios saem do SALDO DO DONO,
// por isso a máquina só abre depois que o dono der a permissão PERMISSAO_DEBITAR.
inteiro aposta = 10;
lista simbolos = ["Cereja", "Limão", "Uva", "Sino", "Estrela", "7"];
padrao
{
ao_iniciar()
{
definirAcaoDoClique("");
definirTextoFlutuante("Caça-níquel\nFECHADO\n(dono: toque para abrir)", vetor(1, 0.6, 0.3), 1.0);
}
ao_tocar(chave quem, texto nome)
{
se (quem == obterDono())
{
pedirPermissao(quem, PERMISSAO_DEBITAR);
}
senao
{
dizerPara(quem, "A máquina está fechada.");
}
}
ao_permissao(inteiro permissoes)
{
se (permissoes & PERMISSAO_DEBITAR)
{
estado aberto;
}
dizerAoDono("Sem a permissão a máquina não consegue pagar os prêmios.");
}
}
estado aberto
{
ao_iniciar()
{
definirPrecosPagamento(PRECO_ESCONDIDO, [aposta]);
definirAcaoDoClique("pagar");
definirTextoFlutuante("Caça-níquel\nC$ " + aposta + " por jogada\nClique para jogar", vetor(1, 0.85, 0.3), 1.0);
}
ao_pagamento(chave quem, inteiro valor)
{
texto a = simbolos[aleatorioInteiro(0, 5)];
texto b = simbolos[aleatorioInteiro(0, 5)];
texto c = simbolos[aleatorioInteiro(0, 5)];
dizer(0, nomeDe(quem) + " puxou a alavanca: [" + a + "] [" + b + "] [" + c + "]");
inteiro premio = 0;
se (a == b && b == c)
{
se (a == "7") premio = aposta * 25;
senao premio = aposta * 8;
}
senao se (a == b || b == c || a == c)
{
premio = aposta; // par: devolve a aposta
}
se (premio == 0)
{
dizerPara(quem, "Não foi dessa vez!");
retorne;
}
se (darDinheiro(quem, premio))
{
dizer(0, nomeDe(quem) + " ganhou C$ " + premio + "!");
definirParticulas("confete", vetor(1, 1, 1), 1.0);
temporizador(3.0);
}
senao
{
dizerPara(quem, "A máquina ficou sem dinheiro para pagar. O dono foi avisado.");
dizerAoDono("Faltou saldo para pagar C$ " + premio + " a " + nomeDe(quem) + ".");
}
}
ao_temporizador()
{
pararParticulas();
temporizador(0);
}
ao_permissao(inteiro permissoes)
{
// o dono revogou a permissão: fecha
se (!(permissoes & PERMISSAO_DEBITAR)) estado padrao;
}
}Teletransportador
Leva quem toca até outro ponto da cidade (com a permissão da pessoa).
// Teletransportador: toque, aceite a permissão e vá para o destino.
vetor destino = vetor(120, 22, 80);
padrao
{
ao_iniciar()
{
definirTextoFlutuante("Teletransporte\nToque para ir à praça", vetor(0.6, 0.9, 1), 1.0);
}
ao_tocar(chave quem, texto nome)
{
pedirPermissao(quem, PERMISSAO_TELEPORTAR);
}
ao_permissao(inteiro permissoes)
{
se (permissoes & PERMISSAO_TELEPORTAR)
{
teleportar(quemDeuPermissao(), destino);
}
}
}Bola de dança
36 danças (18 de estilo masculino e 18 de estilo feminino) num menu com páginas. Pede permissão uma vez, gira, brilha e troca a cor da luz.
// BOLA DE DANÇA (globo de festa) — 36 danças
// Toque na bola: na primeira vez ela pede permissão para animar o seu avatar.
// Depois aparece o menu: escolha o número da dança (1 a 18), troque o estilo
// (masculino/feminino) ou "Parar". Andar também para a dança.
// A bola gira, brilha e troca a cor da luz sozinha.
inteiro CANAL = -5150; // canal do menu (negativo: ninguém digita nele)
lista cores = [vetor(1, 0.2, 0.6), vetor(0.2, 0.6, 1), vetor(0.6, 1, 0.2), vetor(1, 0.8, 0.1), vetor(0.7, 0.3, 1)];
inteiro corAtual = 0;
inteiro pagina = 0; // 0 = danças 1 a 9; 1 = danças 10 a 18
inteiro feminino = FALSO; // estilo das danças
mostrarDancas(chave quem)
{
lista botoes = [];
inteiro i;
para (i = 1; i <= 9; i++)
{
botoes += (texto)(pagina * 9 + i);
}
se (pagina == 0) botoes += "Mais ›";
senao botoes += "‹ Voltar";
se (feminino) botoes += "Estilo masc.";
senao botoes += "Estilo fem.";
botoes += "Parar";
texto estilo = "masculino";
se (feminino) estilo = "feminino";
mostrarMenu(quem, "Escolha a dança (estilo " + estilo + "):", botoes, CANAL);
}
padrao
{
ao_iniciar()
{
girar(vetor(0, 1, 0), 1.2); // gira devagar
definirBrilho(0.6, TODAS_FACES);
definirParticulas("brilho", vetor(1, 1, 1), 1.5); // brilhinhos em volta
definirTextoFlutuante("Toque para dançar", vetor(1, 0.85, 1), 1.0);
ouvir(CANAL, "", "", "");
temporizador(0.8); // muda a cor da luz
}
ao_tocar(chave quem, texto nome)
{
// a permissão é de uma pessoa por vez: se já é dela, só mostra o menu
se (quemDeuPermissao() == quem && (permissoes() & PERMISSAO_ANIMAR))
{
mostrarDancas(quem);
}
senao
{
pedirPermissao(quem, PERMISSAO_ANIMAR);
}
}
ao_permissao(inteiro p)
{
se (p & PERMISSAO_ANIMAR)
{
pagina = 0;
tocarAnimacao(quemDeuPermissao(), "danca1"); // já começa dançando
mostrarDancas(quemDeuPermissao());
}
}
ao_ouvir(inteiro canal, texto nome, chave id, texto escolha)
{
// só aceita o menu de quem deu a permissão
se (id != quemDeuPermissao() || !(permissoes() & PERMISSAO_ANIMAR)) retorne;
se (escolha == "Parar")
{
pararAnimacao(id);
dizerPara(id, "Até a próxima, " + nome + "!");
retorne;
}
se (escolha == "Mais ›") pagina = 1;
senao se (escolha == "‹ Voltar") pagina = 0;
senao se (escolha == "Estilo fem.") feminino = VERDADEIRO;
senao se (escolha == "Estilo masc.") feminino = FALSO;
senao
{
texto comando = "danca";
se (feminino) comando = "dancaf";
tocarAnimacao(id, comando + escolha);
}
mostrarDancas(id); // o menu volta para trocar de dança
}
ao_temporizador()
{
corAtual = (corAtual + 1) % tamanhoLista(cores);
vetor c = cores[corAtual];
definirCor(c, TODAS_FACES);
definirLuz(VERDADEIRO, c, 1.5, 12.0);
}
}Efeitos de partículas
O dono escolhe fogo, fumaça, faísca, bolhas, confete, brilho, chuva ou neve por menu ou pela conversa (/9 neve, /9 cor azul, /9 forte).
// EFEITOS DE PARTÍCULAS
// Toque no objeto (só o dono) para escolher o efeito num menu.
// Também dá para usar a conversa: /9 fogo /9 neve /9 cor azul /9 forte /9 fraco /9 desligar
// Dica: um cubo pequeno e fantasma (atravessável) vira uma "fonte" de efeito invisível
// se você deixar ele transparente.
inteiro CANAL_MENU = -9091;
inteiro CANAL_CONVERSA = 9;
lista efeitos = ["fogo", "fumaca", "faisca", "bolhas", "confete", "brilho", "chuva", "neve", "desligar"];
lista nomesCores = ["natural", "vermelho", "laranja", "amarelo", "verde", "azul", "roxo", "rosa"];
lista valoresCores = [vetor(1, 1, 1), vetor(1, 0.15, 0.1), vetor(1, 0.5, 0.1), vetor(1, 0.9, 0.2),
vetor(0.2, 1, 0.3), vetor(0.2, 0.5, 1), vetor(0.6, 0.3, 1), vetor(1, 0.4, 0.8)];
texto efeito = "fogo";
vetor cor = vetor(1, 1, 1); // branco = cores naturais do efeito
decimal intensidade = 1.0;
aplicar()
{
se (efeito == "desligar")
{
pararParticulas();
definirLuz(FALSO, cor, 0.0, 0.0);
definirTextoFlutuante("", cor, 0.0);
retorne;
}
definirParticulas(efeito, cor, intensidade);
// fogo e faísca também iluminam em volta
se (efeito == "fogo" || efeito == "faisca")
definirLuz(VERDADEIRO, vetor(1, 0.55, 0.2), 0.8 * intensidade, 6.0);
senao
definirLuz(FALSO, cor, 0.0, 0.0);
}
padrao
{
ao_iniciar()
{
ouvir(CANAL_MENU, "", obterDono(), "");
ouvir(CANAL_CONVERSA, "", obterDono(), "");
aplicar();
dizerAoDono("Efeitos prontos. Toque no objeto ou use /9 seguido do efeito (ex.: /9 neve).");
}
ao_tocar(chave quem, texto nome)
{
se (quem != obterDono())
{
dizerPara(quem, "Só o dono escolhe o efeito.");
retorne;
}
mostrarMenu(quem, "Efeito atual: " + efeito + "\nEscolha um efeito:", efeitos, CANAL_MENU);
}
ao_ouvir(inteiro canal, texto nome, chave id, texto mensagem)
{
texto m = minusculas(aparar(mensagem));
se (procurarNaLista(efeitos, m) >= 0)
{
efeito = m;
}
senao se (comecaCom(m, "cor "))
{
inteiro i = procurarNaLista(nomesCores, aparar(parteTexto(m, 4, 20)));
se (i < 0)
{
dizerAoDono("Cores: " + juntar(nomesCores, ", "));
retorne;
}
cor = valoresCores[i];
}
senao se (m == "forte")
{
intensidade = minimo(3.0, intensidade + 0.5);
}
senao se (m == "fraco")
{
intensidade = maximo(0.2, intensidade - 0.3);
}
senao
{
dizerAoDono("Use: " + juntar(efeitos, ", ") + " · cor <nome> · forte · fraco");
retorne;
}
aplicar();
dizerAoDono("Efeito: " + efeito + " · intensidade " + intensidade);
}
}Cadeira simpática
Cumprimenta quem senta e se despede de quem levanta.
// Cadeira que cumprimenta quem senta.
padrao
{
ao_iniciar()
{
limparAssentos();
adicionarAssento(vetor(0, 0, 0.55), 180.0, 0.45);
}
ao_sentar(chave quem)
{
dizerPara(quem, "Fique à vontade, " + nomeDe(quem) + "!");
}
ao_levantar(chave quem)
{
dizerPara(quem, "Volte sempre.");
}
}Scripts conversando
Dois scripts do mesmo objeto trocando mensagens.
// Dois scripts no mesmo objeto conversando. Este é o "botão":
padrao
{
ao_tocar(chave quem, texto nome)
{
mensagemInterna(1, "ligar", quem);
}
ao_mensagem(inteiro numero, texto mensagem, chave id)
{
se (numero == 2) dizer(0, "A luz respondeu: " + mensagem);
}
}