Suporte no desenvolvimento de jogos


    Aprendendo sobre Win32API

    Valentine
    Valentine
    Administrador
    Administrador

    Medalhas : Aprendendo sobre Win32API 94JxvAprendendo sobre Win32API ZgLkiRU
    Mensagens : 5025
    Créditos : 1115
    Cash : 0

    Aprendendo sobre Win32API Empty Aprendendo sobre Win32API

    Mensagem por Valentine em Dom Mar 19, 2017 2:47 pm

    Neste tutorial você irá aprender sobre a classe do Ruby, Win32API, para que ela serve e como usá-la.
    O que é uma API(Application Programming Interface - Interface de Programação de Aplicativos)?  são blocos de DLL's usadas para gerenciar suas principais funções(funções da DLL), e elas nos darão a chave para controlar tudo(da DLL). No caso as mais usadas são a Win32API e a Win32OLE, como o RGSS só dá suporte somente à Win32API, então iremos falar dela.

    Win32API : é um conjunto base de API para o SO do Windows.

    Chamar uma API é basicamente chamar uma DLL, definir a função que irá ser usada, definir os tipos de parâmetros e definir o valor dos seus parâmetros, nisso tudo irá haver o retorno de um objeto.

    Há classe Win32API tem 4 argumentos essenciais que precisam ser definidos. Veja abaixo:
    Código:
    Win32API.new(name, function, imputArray, export)

    Vejamos agora as explicações dos elementos logo abaixo.

    name : Neste argumento iremos definir o nome da DLL que irá ser chamada. Por exemplo a DLL "user32" que fica dentro da pasta "C:\Windows\system32\".
    O tipo do valor desse argumento deve ser uma String(Texto).

    function : Neste argumento iremos definir o nome da função em que irá ser chamada. Por exemplo a função Beep da DLL "kernel32".
    O tipo do valor desse argumento deve ser uma String(Texto).

    imputArray : Trata-se de um conjuntos de letras(string) que irá definir os parâmetros que serão usados para iniciar a determinada function. Existe 5 letras em questão(n, l, i, p, v), mais abaixo você verá o que cada letra significa.

    export : Neste argumento definimos o valor do parâmetro que determina o valor do parâmetro em resposta da determinada function. É bem simples a lógica em si. Exemplo: Suponhamos que você chama uma DLL, você determina a sua função e a função da DLL que irá ser chamada irá desenhar um Quadrado na telinha. Como que o RGSS irá identificar que você clicou no Quadrado? A resposta é através do export. Se no caso a função retornar ao valor de uma String(Texto), você irá definir o export como "p" e assim por diante.

    Significado das letras:

    n(Long) ou l(Long) : Representa números não literais.
    i(Integer) : Representa o integers(números inteiros, bignums, fixnums)
    p(String) : Representa uma String(texto).
    v(Void) : Representa o valor nulo(nil).

    Chamando nossa primeira DLL:

    Agora iremos chamar nossa primeira DLL, será algo bem simples. Chamaremos a DLL "kernel32", a função será o Beep — Usado para gerar tons simples — é a chamaremos no Maker. Veja abaixo todo o código e logo após as suas explicações e como acha-los.
    Código:
    beep = Win32API.new("kernel32.dll", "Beep", "LL", "L")
    beep.call(0x7FFF, 50)
    Primeiro passo: O primeiro passo é descobrir qual DLL está sendo usada. No caso acima e a DLL "kernel32"

    Segundo passo: E saber qual função está sendo chamada da DLL. No caso acima é a função do Beep(Que é usado para gerar tons simples.)
    Obsv.: Há sites específicos que mostram as funções de algumas DLL, como por exemplo o site AllAPI.

    Terceiro passo: É saber os parâmetros da imputArray. Aí você se pergunta como irei saber os bendito parâmetros da imputArray? Existem sites de buscas, que mostram de forma detalhada as funções da DLL, como o MSDN da própria Microsoft. Bom como estamos chamando a DLL "kernel32" e sua função "Beep", vamos usar um site de busca AllAPI. Vamos por partes.
    Entrando no site, você verá uma coluna de cor verde, e nessa coluna terá a opção API List, clique lá. Após o clique irá aparecer um index com as letras do alfabeto, logo abaixo do index a algumas funções de várias DLL do Windows(a maioria e da "user32" e do "kernel32"). Como estamos procurando a função Beep, clique no index B. Após o clique irá aparecer abaixo a função Beep, clique nela.
    Aprendendo sobre Win32API 1145894_orig
    Certo após o clique, irá aparecer uma nova página contendo a descrição da função, a DLL que a pertence, os parâmetros do imputArray e o valor do parâmetro do export. Veja abaixo mais explicadamente.
    Aprendendo sobre Win32API 2302966_orig
    Vermelho e Verde : Aqui é o nome da função da DLL. No caso é o Beep.
    Azul : Aqui é o nome da DLL. No caso é a kernel32.
    Roxo escuro : Aqui fica os parâmetros do imputArray. No caso seria "LL".
    Rosa : Aqui fica o parâmetro do export. No caso seria "L".
    Abaixo uma tradução para que vocês entendam melhor o quadrinho cinza.
    Chamar função Beep da DLL "kernel32" (valor do imputArray dwFreq e Long(L), valor do imputArray dwDuration é Long(L)) valor do export é Long(L).
    Daí então podemos concluir que, o nome da DLL é "kernel32", a sua função é "Beep", o parâmetro do imputArray e "LL" e o parâmetro do export é "L".
    Código:
    beep = Win32API.new("kernel32.dll", "Beep", "LL", "L")
    beep.call(0x7FFF, 50)
    Ok, mais é agora é o comando call como poderei saber os valores do comando? Logo mais abaixo na página do site, haverá um tópico chamado Parameter Information, lá estará explicado os argumentos que será estabelecido no call. No caso é o dwFreq e o dwDuration. Dóis argumentos que precisam ser definidos na chamada da função Beep.
    Código:
    beep.call(dwFreq, dwDuration)
    dwFreq : Como está escrito lá é o valor específico da frequência em hertz, do som. Este parâmetro deve estar na gama de 37 a 32.765 (0x25 ... 0x7FFF) .
    dwDuration : Como está escrito lá é o valor específico da duração em milissegundos do som.
    Com isso damos a saber os argumentos a serem definidos. Vejamos abaixo um código exemplo: O sonzinho é meio sinistro mas tá valendo.
    Código:
    dwDuration = 50
    beep = Win32API.new("kernel32.dll", "Beep", "LL", "L")
    (5000...5050).each { |dwFreq|
     beep.call(dwFreq, dwDuration)
    }
    Bom com isso chegamos ao final da aula. Recomendo agora vocês tentarem chamar novas funções, descobrir novas coisas usando o Win32API. Agora é com vocês!

    Tópico original:
    http://tutorial-dax.weebly.com/win32api.html


    _________________
    Aprendendo sobre Win32API AIymW
    Paulo Soreto
    Paulo Soreto
    Lenda
    Lenda

    Mensagens : 1966
    Créditos : 362
    Cash : 0

    Ficha do personagem
    Nível: 1
    Experiência:
    Aprendendo sobre Win32API Left_bar_bleue0/0Aprendendo sobre Win32API Empty_bar_bleue  (0/0)
    Vida:
    Aprendendo sobre Win32API Left_bar_bleue30/30Aprendendo sobre Win32API Empty_bar_bleue  (30/30)

    Aprendendo sobre Win32API Empty Re: Aprendendo sobre Win32API

    Mensagem por Paulo Soreto em Seg Mar 20, 2017 11:21 am

    Uma correção do tópico em relação as parâmetros passados na função e como funciona a definição de tipos. Onde classificou com n, l, i, p e v existem outros. Esses argumentos são especificados pelo tipo assim como na função pack (para arrays). Na documentação do Ruby 1.8.6 (versão mais próxima da usada no RMXP com documentação oficial disponível), vemos o seguinte:
    Código:
    Directive    Meaning
    ---------------------------------------------------------------
        @     |  Moves to absolute position
        A     |  ASCII string (space padded, count is width)
        a     |  ASCII string (null padded, count is width)
        B     |  Bit string (descending bit order)
        b     |  Bit string (ascending bit order)
        C     |  Unsigned char
        c     |  Char
        D, d  |  Double-precision float, native format
        E     |  Double-precision float, little-endian byte order
        e     |  Single-precision float, little-endian byte order
        F, f  |  Single-precision float, native format
        G     |  Double-precision float, network (big-endian) byte order
        g     |  Single-precision float, network (big-endian) byte order
        H     |  Hex string (high nibble first)
        h     |  Hex string (low nibble first)
        I     |  Unsigned integer
        i     |  Integer
        L     |  Unsigned long
        l     |  Long
        M     |  Quoted printable, MIME encoding (see RFC2045)
        m     |  Base64 encoded string
        N     |  Long, network (big-endian) byte order
        n     |  Short, network (big-endian) byte-order
        P     |  Pointer to a structure (lammer-length string)
        p     |  Pointer to a null-terminated string
        Q, q  |  64-bit number
        S     |  Unsigned short
        s     |  Short
        U     |  UTF-8
        u     |  UU-encoded string
        V     |  Long, little-endian byte order
        v     |  Short, little-endian byte order
        w     |  BER-compressed integer\fnm
        X     |  Back up a byte
        x     |  Null byte
        Z     |  Same as ``a'', except that null is added with *

    Fonte: http://ruby-doc.org/core-1.8.6/Array.html#method-i-pack


    _________________
    Aprendendo sobre Win32API FwYnoXI
    Valentine
    Valentine
    Administrador
    Administrador

    Medalhas : Aprendendo sobre Win32API 94JxvAprendendo sobre Win32API ZgLkiRU
    Mensagens : 5025
    Créditos : 1115
    Cash : 0

    Aprendendo sobre Win32API Empty Re: Aprendendo sobre Win32API

    Mensagem por Valentine em Seg Mar 20, 2017 1:15 pm

    Paulo S. escreveu:Uma correção do tópico em relação as parâmetros passados na função e como funciona a definição de tipos. Onde classificou com n, l, i, p e v existem outros. Esses argumentos são especificados pelo tipo assim como na função pack (para arrays). Na documentação do Ruby 1.8.6 (versão mais próxima da usada no RMXP com documentação oficial disponível), vemos o seguinte:
    Código:
    Directive    Meaning
    ---------------------------------------------------------------
        @     |  Moves to absolute position
        A     |  ASCII string (space padded, count is width)
        a     |  ASCII string (null padded, count is width)
        B     |  Bit string (descending bit order)
        b     |  Bit string (ascending bit order)
        C     |  Unsigned char
        c     |  Char
        D, d  |  Double-precision float, native format
        E     |  Double-precision float, little-endian byte order
        e     |  Single-precision float, little-endian byte order
        F, f  |  Single-precision float, native format
        G     |  Double-precision float, network (big-endian) byte order
        g     |  Single-precision float, network (big-endian) byte order
        H     |  Hex string (high nibble first)
        h     |  Hex string (low nibble first)
        I     |  Unsigned integer
        i     |  Integer
        L     |  Unsigned long
        l     |  Long
        M     |  Quoted printable, MIME encoding (see RFC2045)
        m     |  Base64 encoded string
        N     |  Long, network (big-endian) byte order
        n     |  Short, network (big-endian) byte-order
        P     |  Pointer to a structure (lammer-length string)
        p     |  Pointer to a null-terminated string
        Q, q  |  64-bit number
        S     |  Unsigned short
        s     |  Short
        U     |  UTF-8
        u     |  UU-encoded string
        V     |  Long, little-endian byte order
        v     |  Short, little-endian byte order
        w     |  BER-compressed integer\fnm
        X     |  Back up a byte
        x     |  Null byte
        Z     |  Same as ``a'', except that null is added with *

    Fonte: http://ruby-doc.org/core-1.8.6/Array.html#method-i-pack
    Bem lembrado, Soreto.

    + 1 crédito.

    Eu geralmente uso só esses do tópico mesmo, mas é sempre bom ficar atento.


    _________________
    Aprendendo sobre Win32API AIymW

    Conteúdo patrocinado

    Aprendendo sobre Win32API Empty Re: Aprendendo sobre Win32API

    Mensagem por Conteúdo patrocinado


      Data/hora atual: Sab Dez 14, 2019 10:02 pm