Talkaction com multiplos parâmetros

[Roku 0]

Tutorial - Talk Actions com multiplos parametros - String Explode e Patterns

Introdução:

Embora muitos ja saibam, e não há dificuldade nisso, muitos se perguntam: "Como eu faço uma talkaction com mais de uma virgula?".

Pergunta comum esta é, e ela se da geralmente entre os iniciantes. Se voce não for um, esse tutorial não é para você, mas sera para mim uma honra sua atenção.

Nesse tutorial, vou ensinar dois meios faceis e simples de fazer isso. Embora os iniciantes tenham mais esse tipo de dúvida, o conteudo é no minimo, Intermediario.

 

I - Informações

No Open Tibia tradicional, em termos de Talkaction temos um padrão simples de parâmetro, Cid (Creature Identification), que é quem fala, Words (palavras) que são as palavras que fala, Param (parametros, de vez enquanto voce ve uma talkaction que é so uma palavra, como !aol, mas nem sempre é assim), que é o adicional, que NÃO ESTÁ DEPOIS DA VIRGULA, e Channel, que é o canal em que o jogador fala.

 

Essas quatro funções nos permitem procriar sofisticadas funções, mas muitas vezes não é o necessário, e pessoalmente falando, não chega nem perto de sua capacidade.

Assim surge a necessidade de parâmetros multiplos.

II - STRING.EXPLODE

É o primeiro método, e o mais facil. O string.explode é armazenado em uma variavel, e sua sintaxe é a seguinte:

p = string.explode(STRING, "*")

Explicação:

p é o nome da variavel, no meu caso, é abreviatura de PARAM.

STRING é a string que a função vai operar, e na talkacion normalmente é param.

* é com que elemento a função vai operar, geralmente é uma virgula "","", mas pode ser outros, como por exemplo, espaço.

Agora vamos aos exemplos.

function onSay(cid, words, param) -- Repare que omiti Channel, que não usarei.
local p = string.explode(param, ",")
if p[1] and p[2] then
doPlayerAddItem(getPlayerByName(p[1]), p[2], 1)
return 1
end
return 0
end

Vamos entender com o algoritimo:

função ná fala (quem falou, palavras que usou, parametros que usou)

p = string.explode(param, ",")

se existe o primeiro parametro e o segundo parametro então

adicionar ao jogador correspondente ao nome do parametro, o item do segundo parametro na quantidade 1

fim

fim

OBS: omiti coisas que não tem impotancia com o assunto

Obs.: p é abrevitura de param (parâmetro).

 

Ainda não entendeu?

Entao veja: foi criada uma variavel para capturar o que o jogador falou depois da palavra. Se ele usou uma virgula, o que está depois dela será o segundo parametro, e o que está antes sera o primeiro, então o string.explode funciona como uma divisória, e pega o que está antes e depois. Entao, se existe algo antes e depois, o script vai, ao jogador correspondente ao que está antes da virgula, o item correspondente ao valor que está depois da virgula, na quantidade um.

Entao se voce quiser que seja configurável a quantidade de itens, ficaria assim:

 

function onSay(cid, words, param)
local p = string.explode(param, ",")
if p[1] and p[2] and p[3] then
doPlayerAddItem(getPlayerByName(p[1]), p[2], p[3])
return 1
end
return 0
end

 

Tudo que muda é que o script vê se existe um terçeiro parametro, e se existe, da ao jogador do parametro 1 a quantidade do parametro 3.

 

Muito simples não?

Se voce AINDA não entendeu, procure nas talkactions scripts que te ajudem a entender, com sua observação.

III - Patterns

 

Nota: se você não sabe o que é FOR, leia a Aula 10 da OTServ Networks.

 

Nota²: Se você é um iniciante que ainda não conheçe string.gmatch, veja este trecho retirado de lua.org:

Retorna uma função iteradora que, cada vez que é chamada, retorna a próxima captura de pattern na cadeia s. Se pattern não especifica nenhuma captura, então o casamento inteiro é produzido a cada chamada.

 

Patterns (do inglês tradicional, "padrão") ou expressão regular, é um outro método. Primeiro vale saber que ele gasta mais espaço que STRING.EXPLODE (espaço, dizendo, me refiro a LINHAS).

Então você se pergunta, qual a vantagem? Isso depende. Do meu ponto de vista, vale a pena saber, por que os PATTERNS estarão sempre em LUA, e o STRING.EXPLODE

apenas em algumas LIBS.

 

O Pattern vai desempenhar a mesma função que a string explode, e usamos ele com uma tabela.

Olhe um exemplo (não é para open tibia):

local t = {}
local s = "String de Teste para o Tutorial. Exemplo de pattern. Esse é muito melhor que o otro. O MOCK é um urso gordo BRIMKS =D."
for k in string.gmatch(s, "%l+") do
table.insert(t, k)
end

Nesse caso, criamos um tabela vazia (Por enquanto!) e uma string de testes.

O for marcado como K fara uma "contagem" das capturas na string, e essas seráo de letras minusculas, definido com "%L+"

Essa coisa de % ja me assustou muito, mas ela é tão fácil quanto bater um carro.

Aqui está a lista:

.: (um ponto) representa todos os caracteres.

%a: representa todas as letras.

%c: representa todos os caracteres de controle.

%d: representa todos os dígitos.

%l: representa todas as letras minúsculas.

%p: representa todos os caracteres de pontuação.

%s: representa todos os caracteres de espaço.

%u: representa todas as letras maiúsculas.

%w: representa todos os caracteres alfanuméricos.

%x: representa todos os dígitos hexadecimais.

%z: representa o caractere com representação 0.

 

As saídas geradas por esse script seriam:

tring

de

este

para

o

utorial

xemplo

de

pattern

sse

muito

melhor

que

o

otro

um

urso

gordo

 

As letras maisculas foram ignoradas.

Se voce mesmo quiser testar isso em um debugger, adiciona isso depois do END do for:

for i = 1, #t do print(t[i]) end

 

Se voce ja está com isso feito no debugger, troque esse %l por outros elementos da lista e veja os resultados!

Mas esse %x, será muito confuso para aqueles que não programam em linguagens como C++, C, etc. Quando começei a aprender C++ fiquei dias empacados nessa história

de hexadecimal =/

 

Bom, agora que ja devem ter entendido um pouco, vamos ao exemplo em uma talkacion.

 

function onSay(cid, words, param)
p = {}
for getParam in string.gmatch(param, "(%P+)") do
table.insert(getParam,k)
end
if p[1] and p[2] and p[3] then
doPlayerAddItem(getPlayerByName(p[1]), p[2], p[3])
return 1
end
return 0
end

 

Obs.: o nome da variavel do for, no meu caso getParam, pode variar. Apenas lembre de colocar ele no primeiro parâmetro do table.insert.

 

Então se torna a mesma coisa, e por isso nao há necessidade de explicar, mas vou explicar breviamente:

t é uma tabela vazia. Entao o for vai procurar todas aparições de um caractere de pontuação, e se eles existirem (vide o IF), ira operar com eles.

Muito simples, não?

 

Vale lembrar, que o + depois do padrão ira "agrupar" as ocorrencias.

 

Eu nao irei ensinar coisas como o string.find, etc, pois esse tutorial não é de padrões, e sim de fazer talkactions com multiplos parametros, e o jeito que eu

ensinei funciona perfeitamente.

 

Agora, vamos fazer um teste para ver se voce realmente aprendeu?

1. Qual a vantagem de Pattern?

2. O que faz string.explode?

3. Quantos parametros posso criar?

4. Usando pattern em uma talkaction, eu me limito a operar com virgulas?

5. Qual a vantagem de usar multiplos parametros?

 

Respostas:

[spoiler=RESPOSTAS]

1. Expressões regulares fazem parte da biblioteca padrão, e o STRING.EXPLODE está apenas em algumas libs de Open Tibia.

2. Permite criar vários parametros de um jeito rápido e fácil.

3. Quantos sua imaginação permitir. Mas isso podera prejudicar algumas coisas, pois sempre lembre, tudo no computador tem seu peso e tempo de execução.

4. Não, os patterns oferecem diversos operadores, virgulas, espaços, números, etc.

5. Criar talkactions mais sofisticadas, com funções mais complexas e uteis.

 

 

E que tal exercitar a mente?

Vou passar três exercícios, faça quem quiser aprender, e não faça quem se julga débil.

1. Crie uma talkacion para mandar uma mensagem para um jogador. Ex: /sendmsg Roku, oi

2. Se possuir um debugger externo (OTScript Live, SciTe...) faça o seguinte:

Crie uma tabela e uma string, e faça com que seja inserido nessa tabela todas ocorrencias de letras maisculas agrupadas.

3. Se possuir um debugger externo (OTScript Live, SciTe...), faça o seguinte:

Crie uma tabela com no mínimo 5 campos, com qualquer valor.

Entao usa um IF para verificar se esses valores existem, e se sim, "printar" eles.

 

Isso ai, o tutorial fica por aqui. Breve farei mais tutoriais para vocês.

Estou disposto a ensinar qualquer um disposto a aprender, se tiver dúvidas, etc, pergunte no tópico, mas se for mais complexa, me contate por:

[email protected]

(So respondo nos finais de semana e feriados!)

 

Hasta!

 

Créditos: Tutorial criado TOTALMENTE por Roku. [100%]

Agradecimentos externos a Notoriouss, pela aula do comando For usada como referencia, e ao site lua.org, pelo exemplo de string.gmatch e tipos de padrão.

SE GOSTOU POR FAVOR CLIQUE NO BOTÃO THANKS NO FINAL DO POST.

Editado 8 Maio, 2010 por Roku

[Flatronez 1]

Gostei do tutorial =]

 

[Roku 3 0]

ah nao é possiveu

um tuto bom desses

ngm comenta.

se tivesse pela primeira pagina

boa parte das duvidas ia

sumir