Criar um recurso usando o Mta:se

Introdução

Antes de começar

Este guia assume que você sabe que a Lua pouco. Vamos explicar como utilizar as funções de script MTA, Lua, mas não fundamental. Se você não sabe qualquer Lua, você precisará ler sobre ele primeiro se você quiser qualquer uma dessas coisas para ter qualquer significado. Você pode encontrar tutoriais sobre LUA aqui (em inglês). Certifique-se de ler pelo menos as três primeiras seções.

Você deve ter em mente que este tutorial só irá explicar os conceitos básicos. Quando são dadas explicações para as funções que são usados em exemplos de código e afins, isto é de maneira nenhuma um guia completo para MTA quantidade bastante grande de funções. Você é encorajado a pesquisar e explorar por sua conta própria.

As guia MTA 1.0 e versões posteriores.

Ambiente de Desenvolvimento

Um programador deve ter um lugar para trabalhar. Enquanto você pode trabalhar em bloco de notas ou qualquer editor de texto básico, não há dúvida nenhuma razão para isso.

Embora não haja, a partir de agora, nenhum editor de script oficial do MTA, plugins e arquivos da API podem ter sido desenvolvida para o multi-editor razoavelmente popular finalidade texto Notepad++, para que possa obter auto-realização das funções do MTA, e uma visualização de protótipos de função, argumentos e valores de retorno.

Você pode encontrar-se Notepad++ aqui, eo plugin de arquivos aqui.

Um editor oficial de recursos esta sendo feito pela equipe do MTA, enquanto nao sai o Notepad++ e o adequado


Elementos


Este conceito é um pouco difícil de explicar, mas não tão difícil de entender. Um elemento é um objeto genérico. Tudo em entidades de jogo como os jogadores, veículos, objetos, pickups e assim por diante são elementos que você pode consultar em scripts.

Como exemplo, vamos criar um elemento de agora:

Nome = createVehicle(411, 1, 2, 3) -- cria um Infernus (id 411) Posicao 1, 2, 3

Esta linha faz duas coisas bastante straight e forward. A mais óbvia é que ele cria um novo veículo. Também armazena o veículo recém-criado em uma variável chamada "Nome". (A maioria das funções que criam um novo elemento irá retornar o elemento que foi criado, assim que você pode armazenar em uma variável.) Isto torna mais fácil para fazer outras coisas para este veículo particular depois. Como corrigi-lo, por exemplo:

Nome (fixVehicle)

Cedo ou tarde, vai com certeza querer fazer alguma coisa para um determinado jogador, também. Vamos ver se há um jogador chamado Bob e, se houver, nós vamos dar-lhe algum dinheiro.

theplayer = getPlayerFromName ("Bob") - Verificar se existe um jogador chamado Bob.

o comando "getPlayerFromName" vai dar uma olhada rápida, e se há um Bob no servidor, que agora será capaz de se referir a ele usando a theplayer. No entanto, se ele sair não temos um Bob, no momento, theplayer terá o valor booleano variável falso, e qualquer tentativa de utilização que, em uma função que quer um jogador que vai jogar fora os erros. Nós não queremos isso, é claro.

if thePlayer ~= false then
GivePlayerMoney (theplayer, 5000) - envia 5000 reais para o jogador com inicio theplayer no script

Estamos agora com segurança escapar nenhum erro e se Bob esta no servidor, ele tem agora 5000 reais a mais em seu banco, então todo mundo está feliz. xD

Todos os jogadores, peds, veículos, etc são elementos. Além das funções para tipos de elementos específicos, como jogadores ou veículos, também há funções que se aplicam a todos os tipos de elementos. Estas funções incluem funções para obter e definir posição de elementos, a saúde, a velocidade e assim por diante.



Comandos


Fora de muitas maneiras diferentes de se comunicar com os usuários, os comandos são provavelmente os mais fáceis de configurar logo no início. Sua simplicidade é uma grande vantagem, mas este método também tem alguns inconvenientes. Eles não são particularmente atraente, para uma coisa, e eles nem sempre são fáceis de entender, ou lembre-se, para os jogadores. Um manipulador de comando básico é criado assim:

AddCommandHandler ("Comando", Comando)

Observe que o nome é uma string, a função não é. Quando um comando é digitado por um jogador, o manipulador de comando correspondente (se houver) chama a função dada com dois argumentos padrão ou parâmetros. Estes são o jogador que digitou o comando, e do próprio comando. O seguinte é um exemplo completo de como fazer um comando de base.

function Comando(player, command)
outputChatBox("Bem vindo, " .. getPlayerName(player) .. "!", player)
end addCommandHandler("Comando", Comando)

Isso registra trecho de um comando chamado Comando. Os jogadores podem em seguida, escrever /Comando na sua caixa de chat, ou apenas Comando em seu console, e nós demos a função será executada. Neste caso, se Bob usar este comando, ele irá receber uma mensagem no seu chat dizendo: "Bem vindo, Bob!"

Se queremos que o jogador dar algum tipo de entrada no comando, vamos apenas deixar Lua sabemos que vamos usar argumentos mais na função. O trecho seguinte terá dois números, acrescentá-los, e dizer que o jogador o resultado.

function Comando2(player, command, arg1, arg2)

local a = tonumber(arg1)
local b = tonumber(arg2)

if a ~= nil and b ~= nil then
outputChatBox("A resposta e: " .. a+b, player)
end

end

addCommandHandler("Comando2", Comando2)

Este é um exemplo de um manipulador de comando bastante básico. O comando permite aos jogadores entrar algo como
/Comando2 46 19 e tem a resposta impressa em seu chat. Todos os argumentos inseridos pelos jogadores são separadas por espaços quando o comando está inscrita e passado para a função como cordas, o que significa que, a fim de fazer nada matemático para eles, nós precisaremos de transformá-los em números primeiro. Isso é onde a para n º função entra É uma parte padrão da Lua e devolve um número se a entrada era bom, nula, se não foi.

Se você tentar fazer operações matemáticas em valores não-número (como cordas, nil, valores booleanos, e assim por diante) Lua vai disparar erros. É por isso que verificar se eles estão nulo. Se não estiverem, isso significa que eles são números, e isso significa que está tudo certo para adicioná-los.



Eventos


Em muitos dos seus scripts, você vai querer saber quando certas coisas acontecem. Quando um jogador entra, sai, mata, morre, entra em um carro, palestras, e assim por diante, há um acionamento do evento em algum lugar. Para fazer certas coisas no seu script acontecem quando um evento é acionado, você terá que usar manipuladores de eventos.

Ao contrário de muitos outros sistemas, MTA não usa "retornos", onde as funções em scripts estão sendo chamados pelos nomes. Sistema MTA evento é mais como uma lista de funções a ser chamado quando um evento é acionado, o que significa que você pode adicionar muito bem como funções de manipulador de muitos para um evento como você quer. (Isto também se aplica aos comandos, etc)

Adicionando um manipulador de eventos

Para adicionar um manipulador de eventos, é só chamar a AddEventHandler. função

addEventHandler("onPlayerJoin", getRootElement(), Função)

Não há nada realmente difícil aqui. Esta linha adiciona um manipulador para o evento onPlayerJoin a "Função" será executada sempre que esse evento é acionado. (Nota: o nome do evento é uma string, a função do elemento e não são!)

A única coisa que resta para explicar o negócio aqui é sobre os elementos de raiz. Basicamente, todos os elementos do MTA estão organizados em uma árvore. Quando um evento é acionado, ele irá iniciar no elemento é demitido por e propagar para baixo para a raiz.

Se quisermos adicionar um manipulador de evento para um único elemento, vamos escrever:

addEventHandler("Evento", Elemento, Função)

Quando você dá o elemento de raiz, apenas significa que a função será chamada, não importa qual elemento o evento é acionado.

Eu tenho minhas fontes.. xD

Quando um evento é acionado, ele será acionado a partir de uma fonte. Exatamente o que contém essa fonte vai depender muito de que o evento é, mas você vai em muitos casos, quer usá-lo durante o manuseamento do evento.

Vamos tentar fazer um manipulador simples para o onPlayerJoin evento agora. Este evento não possui argumentos, e sua fonte é o jogador que se juntou.

function joinHandler()
outputChatBox( getPlayerName(source) .. " entrou no servidor!" )
end

addEventHandler("onPlayerJoin", getRootElement(), joinHandler)

Observe o uso da de variável origem. Quando utilizado dentro de uma função de manipulador de eventos, fonte é sempre o elemento para o qual o evento foi disparado. onPlayerJoin é acionado para o elemento que o jogador recentemente se juntou's. Este trecho manipula esse evento por produzir uma mensagem para o chat.

Argumentos

Imagine que você realmente quer saber quando um jogador pega uma pickup. Temos a fonte, certo???? Isso só nos diz que o jogador pegou algo, embora, e não aquilo. Em outras palavras, por vezes, a fonte só não é suficiente. É por isso que temos argumentos. Não há nenhum grande truque para eles, basta colocá-los na declaração de sua função de manipulador como este.

function pickupHandler(thePickup)
outputChatBox( getPlayerName(source) .. " pegou um " .. getPickupType(thePickup) .. " pickup!" )
end

addEventHandler("onPlayerPickupUse", getRootElement(), pickupHandler)

Isto diz-nos tudo o que precisamos saber. Quando um jogador tem uma pickup agora, iremos obter uma mensagem sobre isso na caixa de chat, dizendo-nos não só que o coletor foi utilizado, mas se foi uma saúde, armadura ou arma pickup.

Cancelamento de eventos

Uma vez e outra vez você vai querer parar um evento ocorra em função de uma determinada condição. É por isso que temos o cancelamento do evento. Quando você cancelar um evento, vai ver que o MTA e, se suporta o cancelamento do evento, algo diferente vai acontecer. Por exemplo, se você quiser impedir que os jogadores com um determinado nome de juntar o seu servidor, você pode fazer algo como isto:

function connectHandler(nick, ip, username, serial)
if nick == "Player" or nick == "Nick" then
cancelEvent(true, "Seu nick esta proibido no servidor.")
end
end

addEventHandler("onPlayerConnect", getRootElement(), connectHandler)


Isso funciona perfeitamente como um exemplo sobre como funciona a cancelar - se o nome do jogador é "Player" ou "Nick", ele vai ser desligado, a mensagem que escreveu no cancelEvent (o argumento da razão cancelar) irá mostrar, eo evento onPlayerJoin nunca ser acionado para esse jogador. (Isto, obviamente, não deve ser usada como um método real de proibição de pessoas.)

Adicionando e desencadeando eventos personalizados

Adicionando e desencadeamento de eventos personalizados podem ser uma ferramenta útil. Quando você quer se comunicar com outros recursos, esta é uma das maneiras mais fáceis de fazê-lo. Criar um evento personalizado é bastante simples:

addEvent("Evento")

Temos agora o nosso novo evento. Disse que era simples, não? Você pode adicionar manipuladores para este evento, como você faria qualquer evento normal como onPlayerWasted e os outros.

function Evento()
outputChatBox("O novo evento foi adicionado por " .. getPlayerName(source) )
end

addEventHandler("Evento", getRootElement(), Evento)

Acionar nosso evento é também um pedaço de bolo. (Nota: o bolo não é uma mentira. xD)

triggerEvent ( "Evento", getRandomPlayer() )

O primeiro argumento para triggerEvent é, naturalmente, o nome do evento que queremos. O segundo argumento é o elemento que é acionado. Este elemento é a fonte do evento.

Note que este script assume agora está sendo acionado para um jogador. Se você tentar desencadear o evento para mais nada, você receberá um aviso de mau argumento eo script não irá funcionar. Você não pode obter o nome do jogador, se algo de que algo não é um jogador, naturalmente. Além disso, se não há jogadores no servidor quando este evento é acionado, ele irá falhar porque getRandomPlayer () retornará false em vez de um jogador.

Você também deve observar que você pode passar argumentos ao desencadeamento de eventos. Isto é feito assim:

function Evento(arg)
outputChatBox( getPlayerName(source) .. " diz: " .. arg .. "!" )
end

addEventHandler("Evento", getRootElement(), Evento)

Acionar nosso evento ainda é fácil, só precisamos adicionar o argumento, que é tudo:

triggerEvent ( "myNewEvent", getRandomPlayer(), "hello")

Eventos personalizados e comunicação cliente-servidor

Desencadeamento de eventos do servidor a partir de scripts de cliente e vice-versa não é problema. No entanto, há duas coisas que você deve fazer para que ele funcione. Primeiro, você deve certificar-se o evento é ativadas remotamente. Isto é feito pela adição de um segundo argumento para addEvent e deixá-lo ser verdadeiras. Você deve também usar funções especiais para acionar o evento do "outro lado". Essas funções são chamado triggerServerEvent e triggerClientEvent. Como um exemplo de como isso funciona, dê uma olhada nisso.

addEvent("serverEvent", true) -- add seu evento

function handleServerEvent(arg)

-- Envia uma mensagem para o chatbox
outputChatBox("Mensagem: " .. arg .. " . Feita por " .. getPlayerName(source) )

-- Envia uma resposta para o chatbox
triggerClientEvent ( source , "clientEvent", source, arg .. " pra voce tambem! xD" )

end

addEvent("clientEvent", true) -- add seu evento

function handleClientEvent(arg)

-- Mensagem na chatbox
outputChatBox("Mensagem: " .. arg .. " do servidor!" )

end

addEventHandler("clientEvent", getRootElement(), handleClientEvent)

Finalmente, o código que define a coisa inteira fora:

triggerServerEvent("serverEvent", getLocalPlayer(), "Oi! xD" )

Para um passo-a-passo a passo a passo, isso começa com o cliente desencadeamento do serverEvent com um argumento: "Oi! xD". O servidor permite que toda a gente sabe que o servidor recebeu uma mensagem. Também mostra que o enviou eo que ele continha. Neste caso, a linha chatbox resultante seria "Mensagem: Olá do cliente Bob". Após a saída deste, o servidor desencadeia clientEvent para Bob (ou o jogador que provocou o evento) e diz-lhe "Olá para você também!"

Você deve ter notado que, ao enviar os argumentos com os acontecimentos entre o cliente eo servidor, você não pode enviar elementos de um tipo que não existe no "outro lado" para temporizadores exemplo, nós XML, ACL ACL e grupos que só existe na o servidor, ou TXD, DFF e elementos similares que existem apenas do lado do cliente.


Binds

Às vezes você é obrigado a querer fazer algo acontecer quando um jogador pressionar uma tecla. Abrir um menu, abrindo uma janela de ajuda, fazer alguma coisa para o jogador ou um objeto ao redor, e assim por diante.

Binds são uma forma bastante simples de detectar quando um jogador pressionar uma tecla, e fazer algo acontecer. Se você já jogou alguns outros mods para GTA: SA que são susceptíveis de ser usada para usar comandos quando você quer que algo aconteça. Em MTA você pode usar os comandos, mas não é tão agradável, simples ou amigável quanto poderia ser e, portanto, não é recomendado. Afinal, o que poderia ser mais simples do que apertar um botão?

bindKey ( thePlayer, "i", "down", theFunction )

Esse é o layout básico para vincular uma tecla. Diz MTA para chamar theFunction sempre que o jogador (ou seja, theplayer) pressiona a tecla I. Você pode vincular praticamente qualquer tecla, os controles do jogo, (fogo, salto, Sprint, etc) ou mesmo os botões do mouse ea roda de rolagem. A função de ligar você receberá os seguintes parâmetros passados para ele quando a tecla é pressionada:

functionName ( keyPresser, key, keyState)

keyPresser é o elemento jogador que apertou o botão. fundamental é o nome da chave que foi pressionado, e keyState é ou "acima" ou "baixo".

Agora, parece lógico que, uma vez que fizemos uma ligação chave, podemos removê-lo. E nós podemos.

unbindKey (thePlayer, "i", "down", theFunction )

E estamos a fazer. Para cumprir mais um exemplo, olhe isso:

function speedBoost(thePlayer)

local v = getPedOccupiedVehicle(thePlayer) -- dar um carro com o jogador

if v == false then
return -- ao sair de um veiculo para a funcao
end

local vx,vy,vz = getElementVelocity(v) -- ver a velocidade
setElementVelocity(v, vx * 2, vy * 2, vz * 2) -- dobro da velocidade

unbindKey (thePlayer, "3", "down", speedBoost) -- disponivel apenas uma vez para fazer o unbind

end

function handleSpawn()
bindKey(source,"3","down",speedBoost) -- fazer bind
end

addEventHandler("onPlayerSpawn", getRootElement(), handleSpawn)

O que acontece neste trecho é que, primeiro, as duas funções que usaremos são declarados. Em seguida, a função gerar manipulador é ligado ao seu evento. Quando um jogador desova, sua chave 3 será vinculado a uma função. A primeira coisa que acontece aqui é que conseguimos o veículo que ele está atualmente sitting in Se ele não ocupa um veículo, nós cortamos a função inteiro com retorno. Se ele for, nós vamos chegar a velocidade de seu veículo, a velocidade duas vezes ao longo de todos os eixos (X, Y e Z) e depois aplicar o resultado.



GUI

GUI significa "Graphical User Interface". Uma maneira mais gráfica de deixar seus scripts de se comunicar com seus usuários, e vice-versa. GUIs pode ser simples ou complexa, pequena ou grande, e pode ser usado para um monte de coisas diferentes.


Uma maneira mais simples de obter entrada do usuário
Primeiro de tudo, você deve ter notado que todas as funções da GUI estão do modo do cliente somente. Não e possível voce criar uma GUI no modo servidor, você pode definir o seu texto, movê-lo, mostrar ou esconder, mudar cores, fontes, atributos e assim por diante, sem algum tipo de scripts client-side. Não há nada de errado em usar a abordagem de eventos personalizados mencionado anteriormente, no entanto.

A fim de fazer uma interface gráfica você pode script ou ele mesmo ou usar um recurso editor GUI. Pessoalmente, eu recomendo o último, já que é mais rápido, e muito menos um aborrecimento com ele para ficar exatamente como você quer. Você pode querer código de uma interface gráfica simples mesmo para a experiência, mas não é realmente necessário.

No entanto, editor ou não, você ainda terá que modificar o código manualmente, de qualquer maneira, por isso não ignore este capítulo.

Elementos GUI

É isso mesmo: o GUIs têm sua própria categoria do elemento. Eles também têm uma porção de funções diferentes para percorrer, mas, por agora, vamos mantê-la simples. Os elementos gráficos que você irá usar mais o são janelas, caixas de texto (chamados campos de edição), etiquetas de texto, botões e possivelmente listas grade.

A janela

A janela irá mostrar-se, sem dúvida, mais cedo ou mais tarde. Embora você possa criar elementos gráficos sem uma janela, você provavelmente vai querer usar o Windows mesmo.

Nome = guiCreateWindow ( 320, 240, 100, 50, "Isto e uma janela!", false )

Isto irá criar uma janela (você pode se referir a ele com myWindow posterior) de 100x50 pixels grandes, e está localizado em 320x240 na sua tela. Seu título é "Esta é uma janela!". O último argumento significa simplesmente que a localização eo tamanho argumentos são coordenadas absolutas, o que significa que a janela vai ser exatamente como grande e localizada exatamente onde você disse que ele. Se o argumento passado eram verdadeiras, você daria a localização eo tamanho de decimais de 0-1, como uma fração do tamanho, neste caso, a própria tela. Um ponto que é 0,5 x 0,5 em coordenadas relativas é exatamente o centro da tela.

O rótulo de texto

Uma maneira simples e direta de exibir algum texto.

NomeDoTexto = guiCreateLabel ( 150, 300, 50, 20, "Isto cria um texto", false, nil )

Isso cria um texto de 50x20 pixels em 150x300 na tela do cliente. Seu texto é "Isto cria um texto" e podemos ver de duas maneiras diferentes que as coordenadas e tamanho são absolutos.

O botão

Ela mostra o texto e você pode clicar sobre ele. Não há muito mais a dizer.

NomeDoBotao = guiCreateButton ( 0.3, 0.3, 0.3, 0.3, 0.3, true, myWindow )

Obtendo entrada

Detectar cliques, ficando de entrada e processá-lo são muito importantes partes de um trabalho GUI. Agora, suponha que temos uma janela que contém um campo de edição e um botão. O evento onClientGUIClick irá dizer-nos quando o botão é clicado, e é aqui como nós vamos colocar esse off:

function handleClick(mouseButton)

if mouseButton ~= "left" then
return
end

local val = guiGetText(NomeDaCaixaDeEdicao) -- texto do campo de adicão

guiSetText(Nome, val) -- define o titulo do texto

guiSetVisible(NomeDoBotao, false) -- coloca um botão visivel

end

addEventHandler("onClientGUIClick", myButton, handleClick)

Desencadeamento do lado do servidor

Você provavelmente vai querer fazer a ativação real do servidor com GUI, em muitos casos. Neste exemplo, vamos mais uma vez voltar para eventos personalizados. Vamos começar com o código do cliente.

addEvent("showGui", true) -- Cria um evento

function handleGuiShowEvent()
guiSetVisible(Nome, true) -- mostra a janela
end

addEventHandler("showGui", getLocalPlayer(), handleGuiShowEvent)

Observe como estamos anexando o manipulador de eventos para o leitor local, e não o elemento de raiz ou qualquer outra coisa. Isso é porque nós não queremos mostrar a interface gráfica não ser que o evento foi disparado especificamente para este jogador. Agora, vamos passar para o código do servidor, não é?

triggerClientEvent (theplayer ", showGui", theplayer)

Isso obviamente não é tudo que você pode fazer com GUI, mas deve ser suficiente para fazer o básico. Você pode ler mais sobre isso na wiki MTA.