[GML][M.R.O.-Tutorial] 39dll, Segredos Revelados(1)

[Tutorial] 39dll - Segredos desvendados

Requerimentos: GM8 Pro
Nível de dificuldade: Mediano

Bem... a pedido de alguns membros vou tentar desmistificar o 39dll postando este tutorial simples de conexão e envio de dados.

Antes vou resumir o que é necessario para que possamos estabelecer a conexão:
-iniciar as funções da dll
-fazer um cliente conectar a um receptor
-transmitir informações de um pra outro
-mostrar as informações recebidas na tela

Simples não o_O'?

Pois bem, mãos na massa. o/

Primeiros Passos

Baixem este pacote: http://dl.dropbox.com/u/29285576/39dll.zip
Ele contem a dll e um arquivo no formato 'gmres', que inclui todos os scripts necessários. Extraia-os.

-Crie um novo jogo e salve no mesmo diretório onde se encontra a dll.
-Vá na aba "File > Import Resources..." e selecione o arquivo 39dll.gmres.


Importe o arquivo conforme as confugurações na imagem abaixo:


Agora temos tudo que precisamos para começar a utilizar a dll. Salve o jogo.

As funções

Inicialmente, crie 2 rooms (room0 e room1)

Agora, crie um objeto para gerenciar a conexão. ex: obj_gerente
E em seu create, insira:

Código:


dllinit(0,1,1);
//Isto iniciará as funções da dll
//O argumento onde está o 0 seria onde por um caminho alternativo para a dll
//se ela não estivesse na mesma pasta do gmk. Como está, deixaremos 0

//Para efetuar uma conexão precisamos de pelo menos 1 receptor e 1 cliente
//o receptor aguarda por pedidos de conexão vindos de clientes
// quando a conexão é aceita, eles podem trocar informações
//portanto, primeiro decidiremos quem sera o receptor e quem sera o cliente:

global.receptor=show_question("Deseja ser o receptor de conexões?");

//show_question mostra uma pergunta na tela, retornando 'true' (1) se o usuario
//clicou em sim e 'false' (0) se clicou em não
http://global.receptor vai memorizar se o jogo atual vai receber ou efetuar conexões

if global.receptor=true{
//se nós decidimos ser o receptor

global.outro_jogador = -1;
//cria uma variavel para guardar a ID(entificação) do outro jogador
//como ainda nao temos nenhum, poremos -1(pode ser qualquer numero negativo)

porta_de_entrada = tcplisten(3333,2,true);
//tcplisten abre uma das portas de conexão de rede para permitir conexões
//no caso, abrimos a porta numero 3333 (primeiro argumento)
//o segundo argumento indica o numero máximo de jogadores a se conectar
//e o terceiro argumento indica se esta função deve continar o jogo ou 'travá-lo' até que //seja completa.(true nao trava, false trava)
//porta_de_entrada vai memorizar a identificação da porta

};//fim dos codigos no create do receptor
else{
//do contrário (caso nao sejamos o receptor, seremos cliente)

IPdo_receptor=get_string("Qual é o IP do receptor?","localhost");
//com isso pegamos o IP do receptor, para que possamos conectar
//"localhost" é o que estará escrito inicialmente nesta janela de pergunta
//se tentarmos efetuar uma conexão com este valor, o jogo irá procurar
//um servidor no nosso próprio pc (ou seja, outra janela do jogo, sendo que esta funciona como receptor)

global.outro_jogador=tcpconnect(IPdo_receptor,3333,1);
//tcpconnect irá tentar efetuar uma conexão na ip que fornecemos (IPdo_receptor)
//na porta 3333 (a mesma porta 3333 que inserimos no codigo do host)
//'1', no terceiro argument, indica que ele tentará conectar por algum tempo até desistir
//se fosse 0, ele tentaria conectar eternamente (travando o pc) e se fosse 2, ele tentaria conectar mas não seguraria o jogo até conectar/desistir.
//retorna -1 se falhar e algum nomero maior que zero se der certo( está é a ID[entificação] da conexão)

if global.outro_jogador>0 {
//se a nossa tentativa de conexão foi um sucesso
room_goto_next();
//ir para a proxima room
}else{
//do contrario...
game_end();
//fecha o jogo(não há receptor, nao poderemos jogar)
}};

Fim do create. Agora vamos ao step.
O step, como já devem ter pensado, não será utilizado pelo cliente, pois suas funções, quando dão certo, seguem para a proxima room... portanto:

Código:

if global.receptor=true{
//caso sejamos os receptores

global.outro_jogador=tcpaccept(porta_de_entrada,1);
//tcpaccept verifica se há conexões na 'porta_de_entrada' e salva em global.outro_jogador
//retorna -1 se falhar (sem conexões) e algum nomero positivo se obter sucesso( a tal da ID[entificação] do jogador.

if global.outro_jogador>0 {
//se tivermos um novo jogador

show_message("Jogador encontrado");
//mostra na tela que um jogador se conectou

closesocket(porta_de_entrada);
//fecha a porta de entrada para outros jogadores
room_goto_next();
//vai para a proxima room
};
};

Terminamos de programar nosso gerente. Coloque ele em qualquer lugar da room0.

Se tudo der certo e as conexões forem efetuadas, seremos encaminhados da room0 até a room1. Portanto, faremos o tráfego de informações na room1.

OBS: Enquanto o receptor nao recebe uma conexão, o jogo ficara parado, nada acontecerá até alguém entrar.

Crie um novo objeto. ex: obj_comunicador.
Ele será quem ira enviar, ler e mostrar as informações recebidas.
No create:

Código:

outro_x=0;
outro_y=0;

Isto cria 2 variaveis para representar o outro jogador (quando recebermos informações, vamos guardá-las ali)


Depois, em seu step, colocaremos:

Código:


//Primeiro vamos enviar nossas informações ao outro jogador
clearbuffer();
//limpa o buffer( algo que usamos para processar/guardar informações);
writebyte(0);
//escreve um byte, um numero pequeno, no buffer. Usaremos estes 'writebyte' no inicio como se fosse um canal
//para tráfego de informações
//ex: se o byte for 0, enviaremos a posição do jogador. se for 1, enviaremos o nome dele
//serve para identificar o tipo de mensagem
writeshort(mouse_x);
//escreve a posição x do mouse na janela (sim, enviaremos a posição do mouse para o outro jogador)
writeshort(mouse_y);
//escreve o y
//
//ATENÇÂO!!!!!!!!!!!!!!
//writeshort é para valores NUMERICOS
//caso formos enviar um nome ou algo escrito, usaremos writestring();

sendmessage(global.outro_jogador);
//envia o que está no buffer para o outro jogador
//
//Pronto!!! enviamos a informação
//agora precisamos receber o que o outro jogador tem a enviar

tamanho=1;
//em 'tamanho' vamos guardar o tamanho em bytes de mensagens a serem recebidas
//não sabemos ainda quanto temos, mas para podermos começar o ciclo de leitura, precisamos iniciá-lo como 1
while(tamanho>0){
//enquanto 'tamanho'(de dados a receber) for maior que zero
tamanho=receivemessage(global.outro_jogador);
//receivemessage recebe a mensagem vinda do outro jogador(se houver) e retorna o tamanho em bytes
if tamanho>0{
//se houver mensagens
canal=readbyte();
//lê em qual canal a mensagem está
if canal=0{
//se o canal for o 0;
outro_x=readshort();
outro_y=readshort();
//lemos as informações enviadas pelo outro jogador
};
};
};

//enviamos e lemos informações... mas e se o jogador tiver saido? como saberemos?
//existem 2 modos:
//tcpconnected() diz se estamos conectados ou não com o jogador
//e também, se o valor de 'tamanho', recebido lá atrás, for 0, e não um numero negativo
//significa que a conexão foi perdida... portanto:
if tcpconnected(global.outro_jogador)<0 or tamanho=0 {game_end()};
//fim de jogo

Terminamos o tráfego de informações, agora precisamos por o que recebemos na tela!

Insira no draw:

Código:

draw_circle(outro_x,outro_y,10,false);
//desenhará um circulo cheio de raio 10 nas posições recebidas do outro jogador (ou seja, isto representa o mouse dele)

Insira esse objeto na room1 e pronto, experimente!
(Abra duas janelas. Seja receptor numa e cliente noutra. Conecte a localhost)

OBS(edit): Lembre-se de ler as mensagens na mesma ordem em que elas forem escritas:
ex:

Este é o básico para qualquer jogo de conexões online. No próximo tutorial(se houver), criaremos um servidor de jogos, ou seja, vários jogadores juntos.

Pra quem quiser conferir o resultado, o gmk pronto e um executável podem ser baixados AQUI

Agradecimentos

39ster, pela BENÇÃO que é esta dll.

Até mais. o/

Cara, parabéns pelo tutorial.
Bem organizado e bem explicado, eu cheguei a tentar usar a 39 dll só que só tinha tutorial em inglês e só cheguei a fazer uma conexão bem simples,
mas agora vou longe XD.
continue com eles, serão de grande ajuda!

Puxa Matheus, seu tópico está muito bem formatado, os códigos estão bem comentados, deu pra entender muito bem as funções da 39Dll. Aguardo mais tutoriais como o seu, que fazem a comunidade ir pra frente.

Tópico aprovado!