Cidade RP
Manual

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.

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:

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);
    }
}
Pode escrever com ou sem acento nas palavras da linguagem: 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

TipoGuardaExemploComeça com
inteiroNúmeros sem vírgula. Também usado para sim/não (VERDADEIRO = 1, FALSO = 0).42, -7, 0xFF0
decimalNúmeros com casas decimais (use ponto).3.14, 0.50.0
textoLetras e frases, entre aspas. \n pula linha."Olá"""
chaveA identidade de uma pessoa ou objeto (é um texto).obterDono()""
vetorTrês números: posição, tamanho, direção ou cor.vetor(1, 2, 3)vetor(0, 0, 0)
rotacaoUm giro (para onde algo está virado).rotacaoDeGraus(vetor(0, 90, 0))sem giro
listaVá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

OperadorO 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 + valorJunta os dois num texto só.
lista + valorLista nova com o valor no fim (com outra lista: junta as duas).
vetor + vetor, vetor - vetorSoma e diferença de pontos ou direções.
vetor * numero, vetor / numeroAumenta ou diminui o vetor.
vetor * vetorProduto escalar (um decimal).
vetor % vetorProduto vetorial (um vetor perpendicular aos dois).
vetor * rotacaoO vetor girado.
rotacao * rotacaoOs 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);
Um evento não pode demorar: cada um tem um limite de operações. Um laço que nunca acaba vira erro e o script para. Para repetir algo de tempos em tempos, use 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:

  1. o evento atual para ali mesmo;
  2. roda o ao_sair() do estado antigo (se existir);
  3. os eventos que estavam esperando e as escutas (ouvir) são cancelados — o temporizador continua;
  4. roda o ao_iniciar() do estado novo.

Para voltar ao primeiro estado: estado padrao;

Eventos

EventoQuando 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

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

Pagar pessoas (com o dinheiro do dono)

A permissão é pedida uma vez só, normalmente no 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.

Riscos: com essa permissão o objeto paga sozinho, sem perguntar de novo. Um script com erro (um laço que paga sem parar, um prêmio grande demais) ou um script de outra pessoa feito para enganar pode esvaziar o seu saldo, e o dinheiro não volta. Só dê essa permissão a scripts que você escreveu ou que vieram de alguém em quem você confia.

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

// 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:

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

NomeValor
VERDADEIRO, FALSO1 e 0
PI, DOIS_PI, MEIO_PI3.14159…, 6.28318…, 1.57079…
GRAUS_PARA_RAD, RAD_PARA_GRAUSMultiplique para converter ângulos.
TODAS_FACES, TODAS_PECAS-1
CANAL_PUBLICO0
CHAVE_NULAChave vazia ("")
VETOR_ZERO, ROTACAO_ZEROvetor(0, 0, 0) e sem giro
PERMISSAO_DEBITAR, PERMISSAO_ANIMAR, PERMISSAO_TELEPORTAR1, 2 e 4 (some para pedir mais de uma)
PRECO_ESCONDIDO, PRECO_PADRAO-1 e -2 (para definirPrecosPagamento)
MUDOU_DONO, MUDOU_CONTEUDO, MUDOU_FORMA1, 2 e 4 (em ao_mudanca)

Limites

Os limites existem para que nenhum objeto deixe a cidade lenta para os outros.

Scripts por objeto8
Tamanho de um script32.000 letras
Memória das variáveis globais64 KB por script
Operações por evento20.000 (passou disso, o script para com erro)
Eventos esperando na fila64 (os outros se perdem)
Escutas (ouvir) ao mesmo tempo16
Temporizadorno mínimo 0,1 segundo
Mensagens20 seguidas; depois, 2 por segundo (o resto se perde). Até 1024 letras cada.
Texto e lista4096 letras por texto; 512 itens por lista
Texto flutuante254 letras
Mover10 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 criados30 por minuto cada; criar a até 10 m
Conteúdo32 itens por objeto
Dados guardados256 nomes, 16 KB no total por objeto
Menus e pedidos de permissão10 seguidos; depois, 30 por minuto
Internet10 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:

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

A situação é guardada a cada 30 segundos e quando a cidade desliga normalmente. Se o servidor cair de repente, o script volta como estava no último salvamento (no máximo 30 segundos antes). Eventos que estavam esperando na fila não são guardados.

Erros comuns

MensagemO que fazer
esperava ';' no fim do comandoFaltou o ponto e vírgula na linha indicada (ou na anterior).
"x" não foi declaradoCrie a variável antes de usar: inteiro x = 0; Confira também maiúsculas e minúsculas.
função "x" não existeConfira 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 textoConverta: inteiro("12").
operações demais de uma vezUm laço sem fim, ou trabalho demais num evento só. Divida o trabalho com temporizador.
Parado: este terreno não deixa scripts de outros rodaremLeve 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);
    }
}