(Tutorial) Introdução a linguagem

Índice:

* Pawn / Pawno 1
* Extensões 1.2
* Comentários 1.3
- Comentar uma única linha... 1.3.1
- Comentar várias linhas... 1.3.2
* Variáveis 1.4
- Oque são...
- Algumas dicas...
- Tipo Booleano... 1.4.1
- Tipo Númerico... 1.4.2
- Tipo String... 1.4.3
- Tipo Float... 1.4.4

- Condição: 2
* If 2.1
- Braços..
- Else... 2.2
- Else if...
* Goto 2.3

- Inicializadores: 3
* Const 3.1
* Enum 3.2
* Forward & public 3.3
* Native 3.4
* New 3.5
- Local... 3.5.1
- Global... 3.5.2
* Static 3.7
- Local... 3.7.1
- Global... 3.7.2
* Stock 3.8

- Operadores: 4
* Atribuição 4.1
* Aritméticos 4.2
* Relacionais 4.3
* Lógicos 4.4
* Char 4.5
* Tagof 4.6
* Sizeof 4.7
* Sate 4.8

- Loops: 5
* While 5.1
* For 5.2
* do-while 5.3
* Continue 5.4
* Break 5.5

- Switch: 6
* Oque é? 6.1
* Case 6.2
* Default 6.3

- Diretivas 7
* #define 7.1
* #if 7.2
* #else 7.3
* #else if
* #endif 7.4
* #include 7.5
* #assert 7.6
* #emit 7.7
* #endinput 7.8
* #pragma 7.9
* #error 7.10
* #tryinclude 7.11
* #undef 7.12

EXTRA:
- Callbacks básicas:
* OnPlayerConnect
* OnPlayerDisconnect
* OnPlayerSpawn
* OnPlayerDeath
* OnPlayerEnterVehicle
* OnPlayerExitVehicle
* OnPlayerText
* OnPlayerCommandText
* OnPlayerStateChange
* OnPlayerKeyStateChange
* OnPlayerUpdate
* OnDialogResponse
* OnFilterScriptInit
* OnFilterScriptExit

• Pawn / Pawno
  
  1 Pawn: Aparentemente, Pawn é uma linguagem utilizada para sa-mp, em partes sim. Mas vai além disto, a matriz de pawn é open-source, então existe a versão criada pelos desenvolvedores do sa-mp, para GTAMP, e existem outros variados tipos de versões, como Pawn para counter-strike, etc...
  Link do site do pawn: CompuPhase, pawn
  
  1.1 Pawno: é o compilador, em específico, que gera o .amx para podermos inicializar o servidor.
  
  1.2 Extensões: Apenas .pwn(source do código), .amx(compilado).
  
  1.3 Comentários: Por questões de organização existem formas de deixar comentários dentro do código fonte, que não influenciam ou alteram o código,
  apenas ficam lá dando significado a algo, ou deixando créditos como muitos scripters costumam fazer.
  1.3.1 - Comentários singleline(uma linha), exemplo:
  

  Código:

  //Exemplo de comentário single line

  
  é utilizado para quando você pretende comentar apenas uma linha.
  
  1.3.2 - Comentários de várias linhas, exemplo:
  

  Código:

  /* Exemplo
de um comentário
de várias linhas*/

  
  útil justamente para por os créditos, ou para deixar informações que as vezes ocupem mais espaço(linhas).
  
  1.4 Variáveis: São identificadores utilizados para representar valores mutáveis e voláteis, armazenam dados que serão utilizados ao longo da execução do seu código, dicas: variáveis serão necessárias em qualquer tipo de script que você tenha em mente, então sempre tente manter uma organização do tipo, nomenclatura de vars: nomes claros que deem a elas uma ideia do motivo pelo qual você as criou, aonde ira utilizar....
  
  1.4.1 Boolean: Expressa um valor lógico que pode ser representado por (verdadeiro/falso), no pawn utilizamos uma tag para criação de uma variável booleana, que seria "bool", ao criarmos uma booleana ela só acessa 2 valores, 0/1 ou false/true.
  Exemplos de definição:
  

  Código:

  new bool: nome;

  
  Ao criar uma variável, seja qual for o tipo dela, ela automaticamente assume o valor falso/null(0), isso indica que quando criamos uma var booleana, e não alteramos seu valor na criação, ela será iniciada como false.
  A alteração desta variável se dá a seguinte forma:
  

  Código:

  nome = true;
// ou
nome = false;

  
  1.4.2 Numérico: Expressa qualquer valor numérico(inteiro), ou seja, a diferença entre o tipo numérico e o tipo boolean, é que o boolean só armazena 0/1(false/true), o tipo numérico representa negativos(-true), positivos(true) e neutros 0(false), o tipo inteiro não necessita de uma tag especial como "bool", ao indicar 'new' o pawn já interpreta como um inteiro, oque difere é a forma como você utilizará ao longo do código.
  Exemplos de definição:
  

  Código:

  new var_inteiro;

  
  A variável já está inicializada com valor 0, a alteração desta var se dá a seguinte forma:
  

  Código:

  var_inteiro = 0;
var_inteiro = 10;
var_inteiro = -1230;
//etc, números inteiros.

  
  1.4.3 String: Expressa uma frase/palavras, string pela definição padrão quer dizer 'junção de caracteres', em muitas linguagens não é um tipo primitivo/nativo, no Pawn não é diferente, trabalhamos com a junção de caracteres, não com string. Mas devido a definição padrão, chamamos de string.
  Exempllos de definição:
  

  Código:

  new var_string[7];

  
  A explicação para está variável é um pouco mais complicada, pois se associa a vetores, estamos criando um vetor de 7 posições, ambos inicializados com o valor false(0).
  
  Como string não é um tipo nativo, pawn disponibiliza algumas funções para a manipulação simples, como alteração, copia, etc.
  A alteração desta var se dá a seguinte forma:
  

  Código:

  strcat(var_string, "Willian");

  Explicação: criamos a string com 7 posições, exatamente a contagem do nome Willian, que contém 7 letras. Se a string tivesse uma posição a mais seria desperdício, se tivesse uma posição a menos, teríamos um erro "Array out of bounds", que indicaria que estamos ultrapassando o tamanho de posições definidas para este vetor. O método utilizado para a alteração da var 'strcat' é como já citamos, uma função de manipulação, simples, significa string concate, utilizado para juntar uma string em outra.
  Veja bem, criamos um vetor de 7 posições e utilizamos para inserir uma string, mas poderíamos utilizar também para inserir valores inteiros.
  Exemplo:
  

  Código:

  var_string[0] = 1;
var_string[1] = 2;
var_string[2] = 01293;
var_string[3] = 23;
var_string[4] = 1293;
var_string[5] = 930;
var_string[6] = 129;
var_string[7] = 0;

  
  1.4.4 Float: Expressa um valor com ponto flutuante, valores quebrados, que vão além de um inteiro.(0.9/23.20/9.10/etc..)
  Este tipo exige uma tag nomeada "Float",
  exemplo de definição:
  

  Código:

  new Float: var_float = 123.0;

  
  
• Condição
  
  2.1 if: Estrutura de controle que expressa um desvio condicional, o if vem do inglês (SE), atualmente existem variados exemplos idio**as, por assim dizer no google.
  exemplo teorico: Se hoje chover, eu não vou sair de casa.
  exemplo prático:
  

  Código:

  new bool:hoje_choveu;
if(hoje_choveu == false)
{
//Não sai de casa
}

  o if estabeleceu uma condição para a variável 'hoje_choveu' caso ela seja false(0), ele passa pelo comentário 'não sai de casa'.
  pelo IF ser uma estrutura de controle, parte nativa das sintaxes de programação em geral, existe um padrão de utilizar o if, que é acompanhado de 'brecks'
  utilizados para criar um escopo de código, que só será executado se a condição do if for VERDADEIRA, no nosso caso ela foi verdadeira, pois 'hoje_choveu' é igual a false.
  
  P: É possível utilizar o if sem brecks ?
  R: Sim, é muito utilizado quando você só pretende executar uma linha pela condição. Exemplo:
  

  Código:

  if (true) //Executar uma linha

  
  2.2 else: é uma contradição ao if, significa que se a condição do if for false, o código executa o else.
  Exemplo:
  

  Código:

  new value = 1;
if (value == 0)
{
//valor igual a 0
}
else
{
//valor não é igual a 0
}

  Neste caso o código passará pelo if, e terá um retorno false, pois value é igual a 1, não a 0.
  Logo ele executará o bloco inserido ao else.
  
  É simples, o else será sempre a contradição do if, quando você quiser fazer uma verificação, você pensa no contrário dela, e nela mesma.
  pode ser aplicado também 'else if', que é quando você quer dar ao else(contrário do if) uma condição específica.
  Exemplo:
  

  Código:

  new value = 1;
if (value == 0)
{
//valor igual a 0
}
else if (value == 1)
{
//valor é igual a 1
}

  
  2.3 goto: Serve para pular linhas para uma determina lbl, eu não vou explicar o goto, pois por mim esta estrutura entraria em descontinuidade, ela é uma má prática, por quebrar o código estruturado pelo desenvolvedor, se o desenvolvedor sabe oque faz, e usa uma lógica bem aplicada, não precisa do goto.
  
  
• Inicializadores
  
  3.1 const: Expressa um valor CONSTANTE, que não pode ser alterado, ao declarar uma variável constante você não poderá em momento algum durante a execução do código, fazer alterações neste valor.
  Exemplo:
  

  Código:

  const Float: PI = 3.646914;

  
  3.2 enum: Expressa uma estrutura de dados, é ótimo para manter a organização de um script como RPG/RP e etc, no geral.
  Exemplo:
  

  Código:

  enum ListaDeDados
{
val1,
val2,
val3
};

  é como se você tivesse criado 3 variáveis inteiras.
  
  Existem práticas padrões em muitos scripts para utilização de um enum, como criar uma variável e usar os nomes do enum apenas como símbolo.
  
  3.3 forward & public: São formas de se definir uma função nova no script(callback), que poderá ser utilizada e chamada por nativas do pawn como por exemplo, SetTimer/SetTimerEx/CallLocalFunction/CallRemoteFunction
  Exemplo:
  

  Código:

  forward n();
public n()
{
//código
}

  funções são que nem variáveis, você irá necessitar delas em seu script para um melhor funcionamento/aplicação de sua lógica, para executar passos que poderiam ser maiores e mais complicados se você não utilizasse funções especificas...
  
  Exemplo, função de cálculos aritméticos:
  

  Código:

  forward calculos_arimeticos(val, op);
public calculos_arimeticos(val1, val2, op)
{
 switch(op)
 {
 case '+': return val1 + val2;
 case '-': return val1 - val2;
 case '*': return val1 * val2;
 case '/': return val1 / val2;
 default: return -1;
 }
 return 1;
}

  Algumas práticas utilizadas nessa função serão explicadas mais adiante,
  como por exemplo switch e os operadores aritméticos.
  
  3.4 native: São funções geralmente definidas por um patrão maior, exemplos: plug-ins, quando você cria um plug-in, ao repassar as funções para o pawn, você precisa defini-las no código fonte como 'native'.(Não será útil ensinar isto agora, estarei fazendo um tutorial mais adiante sobre plug-ins para pawn, por tanto vamos pular esta parte).
  
  3.5 new: Já havia citado o new mais acima, quando estava explicando variáveis, é apenas um identificador de variáveis, sempre que tem new ele indica que você está criando uma variável nova, em outras linguagens o significado não é muito diferente(Só que é relacionado a objetos).
  
  3.5.1 new local: Variáveis locais, são aquelas que você cria dentro de um escopo de código(funções, estruturas).
  3.5.2 new global: Variáveis globais, são aquelas que você cria no inicio do seu código, fora de qualquer função.
  
  3.6 static: São semelhantes ao new, muitas pessoas acham tão semelhantes que até trocam static pelo new, por ser diferente e mais bonito, mas cuidado. O static uma vez que criado/definido como static, você estará com uma variável declarada que não perde seu antigo valor, ou seja, ela não é deletada, por mais que seja local. Há vantagens e desvantagens, possivelmente eu crie outro tutorial para explicar.
  
  3.7 stock: É basicamente o mesmo principio de uma função (forward & public, 3.3), a questão é que por não ser uma callback definida, você não pode chamar ela através das funções SetTimer/SetTimerEx/CallLocalFunction/CallRemoteFunction, em muitas vezes isso chega a ser uma desvantagem.
  Não necessariamente você precisa utilizar o prefixo 'stock', você pode apenas definir um método novo:
  

  Código:

  value(n) return n;

  o prefixo 'stock' impede que este método dê warnings por não estar sendo usado.
  

  Código:

  stock value(n) return n;

  
  
• Operadores
  
  4.1 atribuição: Operadores de atribuição são utilizados para inserir valores em variáveis, por exemplo o operador mais básico (=), indica que uma variável =(está recebendo um) valor...
  Muitas pessoas se atrapalham entre os outros operadores de atribuição e os operadores relacionais, talvez por se parecerem em alguns casos, mas são bem diferentes, vale lembrar.
  
  

  Soma	+=	Ele adiciona valores a uma variável, EX:(var += 10;)
  Subtração	-=	Ele subtrai valores de uma variável, EX:(var -= 10;)
  Divisão	/=	Ele divide o valor da variável pelo valor inserido, EX:(var /= 10;)
  Multiplicação	*=	Ele Multiplica o valor da variável pelo valor inserido, EX:(var *= 10;)

  
  4.2 aritméticos:
  
  

  Soma	+	Faz a soma entre 2 valores, EX:(new i = 10 + 10;)
  Subtração	-	Faz a subtração entre 2 valores, EX:(new i = 10 - 10;)
  Divisão	/	Faz a divisão entre 2 valores, EX:(new i = 10 / 10;)
  Multiplicação	*	Faz a multiplicação entre 2 valores, EX:(new i = 10 * 10;)

  
  4.3 relacionais:
  
  Detalhe: Estes operadores são utilizados para estabelecer uma condição entre 2 valores, muito utilizado em if, else if.
  
  

  Maior	>	Faz a comparação se o valor1 é maior que o valor2, EX:(val1 > val2)
  Menor	<	Faz a comparação se o valor1 é menor que o valor2, EX:(val1 < val2)
  Maior ou igual	>=	Faz a comparação se o valor1 é maior ou igual ao valor2, EX:(val1 >= val2)
  Menor ou igual	<=	Faz a comparação se o valor1 é menor ou igual ao valor2, EX:(val1 <= val2)
  Igual	==	Faz a comparação se o valor1 é igual ao valor2, EX:(val1 == val2)
  Diferente	!=	Faz a comparação se o valor1 é diferente do valor2, EX:(val1 != val2)

  
  4.4 lógicos:
  
  Detalhe: Estes operadores são utilizados em condições(if, else if), eles criam uma tabela da verdade dentro da condição.
  
  

  E	&&	Exige que as duas condições estabelecidas no if sejam TRUE, EX:(val1 > val2 && val1 > val3)
  Ou	||	Exige que apenas uma das duas condições estabelecidas no if sejam TRUE, EX:(val1 < val2 || val2 > val3)
  Negação	!	Faz a negação de uma condição, se ela for TRUE, vira FALSE, EX:(!val1)

  
  4.5 Outros: Existem operadores que não se classificam nas categorias citadas acima, estes eu chamo de 'outros', alguns são muito utilizados como o 'sizeof' outros muitos nem conhecem, como por exemplo 'tagof', 'state' ou 'char', pois estes mesmos não são tão necessários quando se tem um conhecimento bom e robusto em cima dos operadores padrões.
  
  

  sizeof

  Retorna o tamanho da variável, EX:(new i = sizeof(b)

  
  
• Estruturas de repetição(Loops)
  
  5.1 while: While é uma estrutura semelhante ao 'if', sendo que chamamos de loop, pois não faz apenas uma condição
  faz giros em torno de um mesmo código enquanto a condição imposta for true...
  Exemplo:
  
  

  Código:

  new ii;
    while(ii < 10) {
        ii++;
 }

  
  é básicamente uma condição como if, sendo que while(enquanto, do inglês...) como no código exemplar acima
  é possivel ver que a condição é suprida como 'enquanto ii for menor que 10, executa o bloco abaixo.
  Que no caso é incrementar um valor a ii, assim aumentando seu valor... Quando atingido 10 o loop para...
  
  5.2 for: for( ; ; )
  É conhecido pelas suas expressões, ele é um loop criativo feito em 3 expressões
  Exemplo:
  

  Código:

  for( Expressão inicial ; Expressão condicional ; Expressão final )

  
  

  Expressão inicial:	começa dando um valor para o loop se basear...
  Expressão condicional:	faz a condição como se fosse um While ou if, para começar a fazer os giros em torno do código
  Expressão final:	toda vez que o 'for' fizer um giro em torno do código a expressão final incrementará ou decrementará um valor na expressão inicial

  
  Exemplo:
  

  Código:

  
    for(new ii = 0; ii < 10; ii++) {
        //Códigos
 }

  
  Ele usa a expressão inicial pra criar uma variável nova, a condicional para determinar uma condição
  para o loop prosseguir os giros, e a final para incrementar um valor a tal variável...
  
  5.3 do-while: Segue o mesmo princípio do while, porém a condição é verificada somente depois de rodar o loop.
  Exemplo:
  

  Código:

  new i = 10;
do
{
 //Código
 i --;
} while (i > 0);

  
  5.4 continue: Quando aplicado, o continue para de executar as linhas aonde parou e pula para a próxima rodada, ou seja, ele faz a próxima incrementação sem olhar para as linhas que estavam a baixo ainda para executar.
  
  5.5 break: Quando aplicado, o break para o loop, na hora.
  
  
• Switch
  6.1 o que é: é uma estrutura que simula vários testes sobre uma variável. É semelhante a vários comandos if sobre a mesma expressão, só que testando diferentes resultados...
  
  6.2 case: São as formas como o switch é dividido, em um for você utilizaria a seguinte maneira para verificar uma condição com 2 resultado diferentes:
  

  Código:

  if (condição 1)
{

}
else if (condição 2)
{

}

  
  Com switch:
  

  Código:

  switch(variável)
{
 case resultado 1:
 {
 //Código
 }
 case resultado 2:
 {
 //Código
 }
}

  A diferença é que o switch não executa exatamente uma condição relacional completa, ele só verifica se o valor da variável passada é igual a tal case, e então executa seus códigos.
  
  6.3 default: É a ocasião 'else' do switch, ou seja, quando nenhum dos cases forem igual ao valor da variável, o default é chamado.
  
  
• Diretivas
  
  7.1 #define: Já diz o nome #define, define um valor como se fosse uma ordem direta ao compilador para ser executado...
  Muito útil para definir funções, cores, pastas, etc...
  Exemplo:
  
  

  Código:

  #define COR_PRETA 0x000000FF
    #define wii_Kick Kick
    #define SCM(%0,%1) SendClientMessage(%0,-1,%1);
    #define wiiLoop(%0) for(%0; %0<MAX_PLAYERS; %0++)

  
  7.2 #if: Semelhante ao 'if' comúm, porém, como ordem direta ao compilador...
  Exemplo:
  

  Código:

  
    #if condição...
        //código...
 #endif

  
  7.3 #else: Semelhante ao 'else' comúm, mais como ordem direta ao compilador...
  
  7.4 #endif: Usado para terminar uma condição #if.
  
  7.5 #include: Usado para incluir uma livrária de códigos externos a uso do GM...
  Exemplo:
  
  

  Código:

  
  //Você pode criar códigos como de GM comúm, e salva-los como arquivo.inc, na pasta de includes
    //do seu pawno, e executa-lo dentro do GM como...
    #include <name>

  
  7.6 #assert: assert é uma expressão como 'if' mas muito pouco usada, não aconselho usa-lá, pra isso já temos o if.
  
  7.7 #emit: É uma entrada em assembly, isso vai além do (básico) que estou passando para vocês por este tutorial, dependendo dos pedidos eu crio um tutorial para esta diretiva depois.
  
  7.8 #endinput: Usado para terminar uma saida input...
  Exemplo:
  

  Código:

  
    #if define _wii_include
        #endinput

  
  7.9 #pragma: O pragma é útilizado pode ser útilizado para anúnciar uma livrária, anúnciar que um item não está sendo utilizado no GM
  Exemplo:
  

  Código:

  
    #pragma unused symbol
    #pragma tabsize value
    #pragma dll library

  
  7.10 #error: Usado para enviar a ordem de erro ao compilador, muito útil para fazer includes e etc...
  Exemplo:
  

  Código:

  
 #if defined triwii
    #error este item não pode ser definido
 #endif

  
  7.11 #tryinclude: Tem a mesma função da #include, sendo que se a include não existir ou não estiver no local correto,
  ele não dará erros, a menos que a include seja necessária...
  
  7.12 #undef: Usado para acabar com uma definição...
  Exemplo:
  

  Código:

  
    #define teste(10)
    #undef teste

  
  

Extra, callbacks:

Conclusão:



Referência:

Créditos: Willian Luigi ((c) CODE.ME - 2013.1

Agradecimentos: Lucas Vinicius

nuss...que tamanho do topico....kkkkkkkkkkkk....e depois falam que scripters não tem paciencia '-' ...mais grande tutorial,só não aprende quem não quer mesmo,tuto nivel Mr. M kkkk...desse tipo o codeme vai ficar mais movimentado que o forum-samp : DD ...parabéns william <3333 .

nota: só não te do reputação porque já te reputei...tamos empatados em 1 de reputação rçrçrçrç

SUPERB, só não aprende quem não quer mesmo, parabéns will

Haha, recomendações: Utilizar CTRL+F para estudar coisas específicas, porque ler passo a passo é meio tenso.