Pawn book, Willian_Luigi

/*Introdução ao Pawn...
  Aprender Pawn...
    (básico)

- Indice:
    * 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...                                  1.4.1
        - Algumas dicas...                              1.4.2
        - Tipo Booleano...                              1.4.3
        - Tipo Númerico...                              1.4.4
        - Tipo String...                                1.4.5
        - Tipo Float...                                 1.4.6
        - Tipo Vetor&Array...                           1.4.7

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

- Inicializadores:                                      3
    * Const                                             3.1
    * Enum                                              3.2
    * Forward                                           3.3
    * Native                                            3.4
    * New                                               3.5
        - Local...                                      3.5.1
        - Global...                                     3.5.2
    * Public                                            3.6
    * 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
    * if-goto                                           5.3
    * do-while                                          5.4
    * Continue                                          5.5
    * Break                                             5.6

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

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

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

=========================================================================================
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
=========================================================================================

1 Pawn / Pawno:

1       Pawn:
        - Pawn é uma linguagem muito ampla e que segue uma certa sintaxe de variáveis/ operadores/ loops de C...
        feito exclusivamente para o SA:MP, GTA.

1.1     Pawno:
        - Pawno é o compilador que lê e interpreta o seu código para o computador...

1.2     Extensões:
        - O Pawno não é um compilador que suporte várias extensões, pois sua única função é
        voltada para o SA:MP, aceita .pwn, salva .pwn, e compila em .amx para que o seu
        samp-server.exe possa executar o GM...

1.3     Comentários:
        - Alguns scripters gostam de criar Códigos úteis e posta-los com comentários dentro de seu
        próprio código fonte mostrando seu nome, dedicações ou até mesmo dicas/suporte para seu code...

        Pra isso existem duas formas de fazer comentários dentro de um código,
1.3.1      comentários de uma única linha:
                seguidos de // - seu comentário -

1.3.2       comentários de várias linhas:
                seguidos por / * - comentário
                                - comentário
                                - comentário
                                - comentário
                            * /
            até o fim de seu comentário...

        Pode ser útil até mesmo para você fazer anotações básicas...

1.4 Variáveis:

1.4.1   Oque são?
        - Variáveis são identificadores utilizados para representar valores mutáveis e voláteis,
        e assim armazenar dados que serão utilizados ao longo de sua execução.

1.4.2   Dicas:
        - Variáveis podem ser declaradas a todo momento em qualquer parte do GM, lógicamente a cada "Var"
        criada ocupara um espaço de bits em seu GM dependendo do seu valor ou tamanho...
        A dica mais precisa seria evitar criar variáveis atoa ou repetidas,
        criar variáveis com nomes lógicos e que transmitam a idéia de seu código, para fácilitar seu uso...

1.4.3   Tipo Booleano:
        - Um booleano expressa um valor lógico que pode ser verdadeiro ou falso.
        Para especificar um valor booleano, utilize a palavra-chave 'bool' seguido de 'new' para definir uma nova variável
        Exemplo:
            new bool:NomeDoBooleano;

        Logo que criado ele assumirá o valor FALSE (falso), igual a 0...
        ele poderá ser modificado durante sua estada dentro do código fonte em apenas duas maneiras...
        Exemplo:
            NomeDoBooleano = true;
                \\
            NomeDoBooleano = false;

1.4.4   Tipo Númerico:
        - Tipo númerico mais conhecido como intiger (inteiro), números que podem ser declarados infinitos...
        Para especificar um valor númerico, utilize apenas o 'new' para definir uma nova variável com valor númerico
        Exemplo:
            new Intiger = 0;

        Assim como Booleano, logo que criado ele assumirá o valor falso, igual a 0 como visto no exemplo...
        ele poderá ser modificado durante sua estada dentro do código fonte em digitos altos, para uso contado...
        Exemplo:
            Intiger = 1;
                \\
            Intiger = 2;
                \\
            Intiger = 3;

1.4.5   Tipo String:
        - Uma string é muito conhecido por 'palavras' 'frases', assim podemos considera-lá uma cadeia de
        caracteres alfanuméricos...
        Para especificar uma string, utilize o clássico 'new' para definir uma nova variável com aspas duplas. " "
        Exemplo:
            new String[] = "Isto é uma String...";

        Uma string diferenciada de números, ela pode assumir uma especia em caracteres inicial declarado pelo programador
        ou ser manipulada para seguir uma lógica(sistemas de frases, anúncios, mensagens), usando Arrays que veremos mais a frente...

1.4.6   Tipo Float:
        - Float, mais conhecida como 'ponto flutuante', armazena números de ponto.
        Para especificar um valor com ponto flutuante, utilize 'new' seguido de 'Float', para definir seu valor com ponto.
        Exemplo:
            new Float:PontoFlutuante;

        Assim como os númericos, e booleanos assumirá um valor falso de (0.0) podendo ser modificado durante
        sua estada no código fonte, ou ser manipulado por sistemas ou funções criadas com finalidades de distância,
        e contas precisas...

1.4.7   Tipo Vetor:
        - Vetoré uma lista de valores armazenados na memória, os quais podem ser de tipos diferentes(números, strings, floats)
        e podem ser acessados a qualquer momento, pois cada valor é relacionado a uma chave.
        Para especificar uma Vetor, pode ser utilizado qualquer item citado acima, sendo eles
        Exemplo:
            new Vetor[4];
            new Float:Vetor[4];

        Uma Vetor pode ser utilizado para fazer banco de dados de grandes sistemas.
        Uma Array pode ser utilizado da mesma forma que um Vetor, porém em dimensões maiores
        Exemplo:
            new Array[4][4]; // linha x coluna, pode ser representado como se fosse uma tabela.

2 Condição:

2.1     If:
        - O if é um estrutura de controle que introduz um desvio condicional, vindo do ingles ( SE )
        caso a condição introduzida no if seja satisfeita, ele executará o bloco de comandos dentro do if...

2.1.1   Braços:
        - Os braços mais conhecidos por brackets, são utilizados em geral para abrir ("{") e fechar ("}") um bloco de códigos
        dentro de uma função, comparação, condição, callback, stock ou etc...
        Exemplo baseado na estrutura condicional ( if ):
            new Variavel;
            if( Variavel == 0 ) {
                Variavel ++;
                return 1;
            }

        Como visto no exemplo, foi utilizado a criação de uma variável nova, cujo seu valor seria assumido por 0,
        na estrutura de 'if' fazemos a condição que caso "Variável" seja igual a 0 ele parte a atuar dentro dos brackets,
        neste caso ele incrementaria um valor a mais na "Variável", assim largando o valor de 0 e assumindo 1,
        e logo a baixo retornamos a função para que se encerre a condição de Variável == 0 com o bracket de fechar '}'
        Mais exemplos:

            new bool:Var;
            if(!Var) {
                print("Var é um valor booleano assumido como falso...");
            }

        Este exemplo poderá ser entendido mais a frente na seção de operadores...

2.1.2   Else:
        - Else vem do popular 'fail', quando usamos a estrutura condicional 'if' como no exemplo acima...
        Se a Variável 'Var' não for true(verdadeira) ele seguirá o bloco...
        Mais e caso a Variável seja true ? Para isso usamos else...
        Exemplo:
            new bool:EstaChovendo;
            if(EstaChovendo == true) {
                print("Está chovendo lá fora...");
            }
            else
            {
                print("Não está chovendo lá fora...");
            }

        Como visto, assim que a Variável é criada e assume o valor de 0, seguimos com a condição,
        se "EstaChovendo" fosse verdadeira, printaria "Está chovendo lá fora..."
        mais como sabemos, ela está em um valor assumido de 0 = falso, ou seja o Else entre em ação...
        Afirmando que "Não está chovendo lá fora..."

2.1.3   Else if:
        - Else if, segue junto com Else, mesma lógica... Apenas pode ser aumentada dentro de mais de 1 condição.
        Exemplo:
            new EstaChovendo;
            if(EstaChovendo == 0) {
                print("Está chovendo...");
            }
            else if(EstaChovendo == 1) {
                print("Não está chovendo...");
            }
            else
            {
                print("Está nublado...");
            }

        Caso 'EstaChovendo' seja igual a 0, afirmaria que está chovendo, caso for 1, afirmaria que não está chovendo,
        caso não seja nenhum dos dois, afirmará que está nublado.

2.2     GOTO:
        - Já vindo do inglês go to(ir para...), é também usado para loops, ou para pulos trágicos de uma função a outra...
        seguindo de goto e suas labeis.
        Exemplo:
            my_func() {
                new nn;
                new ii;
                if(ii == 0) {
                    goto exemplo;
                }
                else {
                    nn++;
                }
                if(nn == 1) {
                    ii++;
                }
            exemplo:
                return 1;
            }

        Como já vimos no inicio, variáveis criadas assumem o valor de 0(falso), sendo assim
        nn e ii são igual a 0, seguindo a lógica da condição, se ii for igual a 0 usaremos o goto para ir até a label 'exemplo'
        que se encontra no terminar do código...
        Caso ii não seja igual a 0, ele incrementará um valor em nn, e assim começando uma nova condição, caso nn igual 1
        incrementará um valor em ii, assim chegando ao fim da função, com valores novos ii = 1, nn =1

3 Inicializadores:

3.1     Const:
        - Const, mais conhecido como constantes, são inicializadores parecidos com o 'new' que venho utilizado em todos os exemplos
        com definições e criações de variáveis...
        O new cria novas variáveis com valores mutáveis, diferente da constante, que cria com um valor único
        que não pode ser modificado ao longo de sua estada no código-fonte...
        re-capitulando, assim que uma constante é definida, seu valor é único e não pode ser alterado ou manipulado...
        Exemplo:
            const Variável = 50;

        Agora 'Variável' possui um valor númerico = 50, e não será modificado...

3.2     Enum:
        - Enum pode ser visto também como uma lista de itens criados pelo programador,
        muito útil para criar um (bancos de dados) juntamente com as Arrays...
        Exemplo:
            enum ListaDeDados {
                Item1,
                Item2,
                Item3,
                Item4,
                Item5,
                Item6
            };

        Uma lista feita em Enum não tem um número certo de itens para ser criado...
        Assim podendo aculumar várias informações, sendo muito útil ao invés de criar várias variáveis para suprir
        um mesmo motivo e ocupando espaços desnecessários...
        Comparação:
                new:            enum:
            new item1;      enum Lista {
            new item2;          item1,
            new item3;          item2,
            new item4;          item3,
                                item4
                            };

3.3     Forward:
        - Não é uma das formas mais indicadas para criar suas funções, mais vários programadores a usam para funções
        stocks, e etc...
        Forward declara uma nova Função/Callback em formato -public- em Pawn...
        Exemplo:
            forward PegarNome(playerid);

        forma de uso:
            public PegarNome(playerid) {
                new nn[MAX_PLAYER_NAME];
                GetPlayerName(playerid, nn, sizeof( nn ));
                return nn;
            }

        A forward está declarando que será criado uma -public- com os seguintes parâmetros "playerid", e logo abaixo
        usaremos a public para pegar o nome de players por exemplo:

            PegarNome(15);

        Assim ela irá salvar o nome do atual id 15 online,
        não é muito complicado de se entender, criamos uma nova Array nomeada 'nn' por acaso...
        e o tamanho dela será 'MAX_PLAYER_NAME' que no caso seria o valor máximo de um nick permitido no SA:MP ( 24 )
        e logo após pode ser utilizado a função,

                          GetPlayerName(playerid, const name[], len);
                                            |          |         |
                                      ID do player   Nome   Tamanho do Nome

        Está função armazenará o nome do 'playerid' escolhido pelo programador, ou manipulado com finalidades de sistemas grandes
        dentro da Variável 'nn[24];' ou 'nn[MAX_PLAYER_NAME];'
        e o tamanho dela (len) será igual ao tamanho da Array criada para armezar o nome -sizeof( nn )-...

3.4     Nativas:
        - Em construção...

3.5     New:
        - É um dos inicializadores mais utilizados, por ser simples rápido e de bom entendimento para qualquer classe
        de programadores, desde iniciantes até veteranos...
        New como visto nos exemplos do primeiro capitulo do indice, pode ser utilizado para definir e criar variáveis novas,
        booleanas, pontos flutuantes, arrays, strings, intigers...
        Exemplo:
            new Var;
            new bool:Var;
            new Float:Var;
            new Var[4];
            new Var = "Var";

3.5.1   New local:
        - Um new contém diferenças quando aplicado dentro ou fora de funções(atoa no GM), uma dessas diferenças
        se chama 'local', uma variável local é aplicada quando se define um novo new dentro da função/public/callback de uso
        instantâneo, como por exemplo:

            Callback:: public OnPlayerConnect(playerid)
            Bracket::  {
            New local::    new Var[MAX_PLAYERS];
            Retornando::   return 1;
            Bracket::  }

        No exemplo foi utilizado a Callback OnPlayerConnect, muito conhecida por ser a função de quando um novo player
        se conecta ao servido, foi utilizado a definição de uma Variável com o valor do tamanho do server(slots), caso o server
        contenha 20 slots, esse será o valor da Variável...
        Como está variável foi criada dentro de uma Callback, é considerada Local, pois só poderá ser usada e modificada dentro da mesma Callback...

3.5.2   New global:
        - Uma global seria o oposto da local, no caso quando você criasse uma variável fora de funções/publics/callbacks,
        para uso global, em todo GM(Game Mode) ela seria de livre uso, e ela guardaria um valor quando fosse manipulada...
        Exemplo:

            New global::  new Var[MAX_PLAYERS];
            Callback::    public OnPlayerConnect(playerid)
            Bracket::     {
            Global::         Var[playerid] ++;
            Retornando::     return 1;
            Bracket::     }

        No exemplo foi utilizado uma Variável criada fora de qualquer função, chamada de Global, para ser usada dentro de uma Callback
        assim acumulando um valor quando fosse alterada ou incrementada como foi feito no exemplo 'Var[playerid] ++;' ...

3.6     Public:
        - Como foi explicado anteriormente em 'Nativas', -public- é um código função criado para executar um bloco de comandos
        toda vez que for chamado...
        Exemplo:
            forward Nome(parâmetros);
            public Nome(parâmetros) {
                //Códigos
                return 1;
            }

3.7     Static:
        - Static pode ser considerado um 'new', idêntico para quem não conheçe, mais suas diferenças não são de imensa preocupação,
        a real diferença, é que o Static não perde o valor quando criado localmente...
        Ele mantém o valor do princípio, bom para códigos com calculo extremo e incrementativo...
        Exemplo:
            static Variavel;
            static Var;

        Exemplo completo:

            NEW:
            my_func() {
                for(new ii = 0; ii < 3; ii++) {
                    new jj = 1;
                    printf("%d", jj);
                    jj++;
                }
                return 1;
            }

            Código retirado do wiki-SA:MP para exemplificar...
            Como visto no código, foi criado uma função nova, e dentro dela foi feito um loop(Será explicado mais afrente oque são loops)
            este loop rodaria 3 vezes, e sempre incrementando um valor na variável 'jj'
            pórem por ser uma variável 'new' local, o seu valor é incrementado uma vez ao completar o loop e retorna a 0(falso)

            resultado: 1 1 1

            STATIC:
            my_func() {
                for(new ii = 0; ii < 3; ii++) {
                    static jj = 1;
                    printf("%d", jj);
                    jj++);
                }
                return 1;
            }

            Código retirado do wiki-SA:MP para exemplificar...
            Como se pode observar neste outro exemplo, ao invés de definir uma 'new' variável, foi usado 'static' variável,
            para que não perdesse o valor toda vez que o loop terminasse uma volta completa.

            resultado: 1 2 3

3.8     Stock:
        - Uma stock é um conjunto de códigos formando uma função, pode ser visto como 'Forward & Public', mais alguns scripters
        iniciantes acham menos complicado.
        Exemplo:

            stock Tapa(playerid)
            {
                new Float:x;
                new Float:y;
                new Float:z;
                GetPlayerPos(playerid, x, y, z);
                SetPlayerPos(playerid, x, y, z+20);
            }

        Está é uma das funções da qual considero mais simples para um iniciante trabalhar em cima e tentar fazer,
        a função de dar um tapa no jogador 'playerid'...
        Como visto, foi usado 3 Floats(Variáveis com pontos flutuantes...), nomeadas (x, y, z) por próposito de coordenadas...
        e logo utilizamos a função:

            GetPlayerPos(playerid, &Float:x, &Float:y, &Float:z); //Esta função está sendo usada para pegar as coordenadas x, y, z de jogador 'playerid'
            SetPlayerPos(playerid, Float:x, Float:y, Float:z); // Esta está sendo usada para Setar novamente as posições x, y, z do jogador 'playerid'

        Com uma pequena diferente, o exemplo pega as coordenadas do playerid e re-faz elas adicionando '+20' ao Z, que seria altura...
        Isso faz com que o Player seja jogado a sua posição z+20 para cima...

4 Operadores:

4.1     Atribuição:
        - Um operador de atribuição é utilizado para definir uma variável atribuindo-lhe um valor.
        O operador básico de atribuição é ( = ).
        Exemplo:
            new Var = 0;    //defini variável = 0
            new Var += 5;   //soma variável com 5
            new Var -= 5;   //subtrai variável com 5
            new Var *= 5;   //multiplica variável por 5
            new Var /= 5;   //dividi variável por 5

            ++Var;          //Pré-incremento, adiciona 1 a Var, e depois retorna à mesma.
            Var++;          //Pós-incremento, retorna Var e depois adiciona 1.
            --Var;          //Pré-decremento, retira 1 da Var, e depois retorna à mesma.
            Var--;          //Pós-decremento, retorna Var e depois retira 1.

4.2     Aritméticos:
        - São operadores utilizados para realização de cálculos matemáticos.
        Exemplo:
            new Var = 5;
            new Var2 = 5;
            new Var3 = Var + Var2;

            Resultado: Var+Var2 = 5+5 = 10

            +   //adição
            -   //subtração
            *   //multiplicação
            /   //divisão
            %   //módulo(resto da divisão)

4.3     Relacionais:
        - São operadores utilizados para realizar comparações entre valores ou expressões, resultando sempre
        um valor booleano (true ou false)
        Exemplo:
            new Var = 10;
            if(Var == 11) return true; //caso Var seja igual a 11 retorna true
            if(Var != 10) return true; //caso Var não seja igual a 10 retorna true
            if(Var >= 10) return true; //caso Var seja maior ou igual a 10 retorna true
            if(Var <= 10) return true; //caso Var seja menor ou igual a 10 retorna true

            ==  //Igual, resultante de true
            !=  //diferente, resulta true se as variáveis forem diferentes
            >   //maior que
            <   //menor que
            >=  //maior ou igual
            <=  //menor ou igual que

4.4     Lógicos:
        - São operadores utilizados para combinar expressões lógicas entre si.
        Exemplo:
            if((Var == true) || (Var == false)) return true; //caso a Var seja falsa 'ou' verdadeira retorna true
            if((Var == true) && (Var1 == false)) return true;//caso a Var seja verdadeira e a Var1 falsa retorna true
            if(!Var) return true //caso a Var seja false, retorna true

            &&  //and do inglês (e...)
            ||  //or do inglês (ou...)
            !   //not go inglês(não...) interpretado por procurar um valor falso

4.5     Char:
        - Usado para retornar o valor necessário para compactar strings...
        Exemplo:
            new Var[10 char];

4.6     Tagof:
        - Usado para retornar a tag da variável...
        Exemplo:
            printf("%d", tagof(Var));

4.7     Sizeof:
        - Usado para retornar o tamanho da array...
        Exemplo:
            printf("%d", sizeof(Var));

4.8     State:
        - Em construção ainda...

5 Loops:

5.1     While: 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:
            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( ; ; )
        - Um dos meus preferidos... O for é conhecido pelas suas expressões, ele é um loop criativo feito em 3 expressões
        Exemplo:

            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:

            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     if-goto:
        - Como já foi explicado a cima sobre o goto, goto também pode ser considerado um loop.
        Exemplo:

            new x;
            laab:
            if(x < 10) {
                x++;
                goto laab;
            }

5.4     do-while:
        - Em construção...

5.5     Continue:
        - Uma expressão usada para dar continuidade a um loop...

5.6     Break:
        - Uma expressão usada para parar um loop...

6 Switch:

6.1     Oque é:
6.2...  - Switch é uma estrutura que simula vários testes sobre uma variável.
6.3...  É semelhante a vários comandos if sobre a mesma expressão...
        Exemplo:

            new ii;
            switch(ii)
            {
                case 1: //caso ii seja igual a 1;
                case 2: //caso ii seja igual a 2;
                case 3: //caso ii seja igual a 3;
                default: //caso não seja igual a nenhuma destes itens acima...;
            }

        Se fossemos comparar ao if seria mais ou menos assim:

            if(ii == 0) {
            }
            else if(ii == 1){
            }
            else {
            }

7 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:
            #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, mais como ordem direta ao compilador...
        Exemplo:
            #if condição...
                //código...
            #endif

7.3     #else:
        - Semelhante ao 'else' comúm, mais como ordem direta ao compilador...

7.4     #else if:
        - Semelhante ao 'else if' comúm, mais como ordem direta ao compilador...

7.5     #endif:
        - Usado para terminar uma condição #if.

7.6     #include:
        - Usado para incluir uma livrária de códigos externos a uso do GM...
        Exemplo:

            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.7     #assert:
        - assert é uma expressão como 'if' mais muito pouco usada, não aconselho usa-lá, pra isso já temos o if

7.8     #emit:
        - Em construção...

7.9     #endinput:
        - Usado para terminar uma saida input...
        Exemplo:
            #if define _wii_include
                #endinput
7.10    #line:
        - Em construção...

7.11    #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:
            #pragma unused symbol
            #pragma tabsize value
            #pragma dll library

7.12    #error:
        - Usado para enviar a ordem de erro ao compilador, muito útil para fazer includes e etc...
        Exemplo:
            #if defined triwii
                #error este item não pode ser definido
            #endif

7.13    #file:
        - Defini o nome do arquivo atual.

7.14    #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.15    #undef:
        - Usado para acabar com uma definição...
        Exemplo:
            #define gay (10)
            #undef gay


*/
// O mini-livro ainda está sendo trabalhado, com o tempo irei atualizando...
// [OutOfDate]