Tutorial de Multiplayer/Networking Nativo - GMS

• Título: Tutorial de Multiplayer/Networking Nativo - GMS (sem dll's - multiplataforma)
  
• GM Version: :GMS:
  
• Link para download da Engine: SERVER.GMZ e CLIENT.GMZ
  
• Requer Extensões: Não
  
• Requer DLLs: Não. GML Puro e aplicado =)
  
• Tags: Multiplayer; rede; Network; Nativo; GMS;
  

Tutorial de Multiplayer/Networking Nativo - GMS

Capítulo 0 - Introdução:

Amigos, como sabemos, é muito divertido jogar jogos que sejam multiplayer. A interação com outros jogadores é algo muito valioso.
Até hoje em nosso fórum, ví apenas tutoriais e engines que usam comunicação com ajuda de dll's (como a 39dll, faucetnetwork, etc).

DLL's são legais pois possiblitam estender as funcionalidades do GameMaker, todavia, vc sempre terá a limitação de que seu jogo funcionará apenas no Windows (e talvez no Mac, caso tenhamos a mesma DLL compilada para o MAC).

Então, eu vos digo em verdade:
A única forma de fazer um jogo multiplayer multiplataforma, é através das funções de Networking nativas do GMS (que foram adicionadas a partir da versão 1.1 da IDE).

Como assim, Fred ?
Quero dizer que utilizando as funções nativas de Networking do GMS (em vez de DLL's) vc pode ter um maluco com um Android, um com Linux, outro com um PC, outro com um IPAD, todos jogando AO MESMO TEMPO na mesma sessão do mesmo jogo.

P###a, isso é Fantástico!!!  Só o GMS e a nossa amada Yoyogames pra possibilitar tal prazer!!!

Acham que eu to de sacanagem ? Vejam essa foto então tirada aqui em casa:



Essa foto foi tirada jogando a DEMO de networking nativo da Yoyogames
http://www.yoyogames.com/tech_blog/11

Vou tentar, através deste humilde tutorial, doutriná-los com as ferramentas para que vcs possam construir seus próprios jogos multiplayer MULTIPLATAFORMA usando o networking nativo.

Para começarmos, é bom um pouco de teoria... pois é necessário dominar os conceitos básicos para sair do zero.



Capítulo 1 - Conceitos básicos de Networking/Multiplayer

Existem basicamente 2 formas de se construir uma arquitetura multiplayer:
1) Peer to Peer
2) Server/Client

No mundo Peer2Peer, o primeiro jogador é server e client ao mesmo tempo. Isso é muito utilizando em alguns jogos de ação (como o lendário Soldat, jogos de co-op,etc ). Isso é interessante do ponto de vista de que mesmo em single-player, a programação é feita como se fosse um multiplayer. Aí fica fácil escalonar o código para que mais jogadores se juntem à sessão.

O problema é que o código disto fica uma bagunça. No mesmo projeto vc vai ter a camada SERVER e a camada CLIENT. O Exemplo no blog da Yoyogames utiliza essa perspectiva (peer to peer) que, na minha singela opinião não é nada didático.

Já no mundo Server/Client, esses papéis são bem distintos e bem discriminados. Vc vai precisar de um projeto para o Server (que é de fato o núcleo de tudo que acontece no jogo) e outro projeto para o client (que vai ficar enviando as mensagens para o Server).

É essa abordagem (Server/Client) que vamos utilizar para doutriná-los, prezados companheiros. Inclusive é a abordagem utilizada na maioria dos MMO's e jogos de ação (onde o server precisa ser bem enxuto pra aguentar o arregaço).

Para os que nunca programaram numa arquitetura multiplayer, sinto informá-los que quase tudo que vcs conceberam até hoje de como deve se pensar um jogo vai ser jogado fora. (sim, isso é triste... mas vai passar).

Digo isso porque a maioria dos senhores estão acostumados a criar uma instância do ObjPlayer no jogo, e todas as entradas e mouse / teclado /touch vcs utilizam para acionar diretamente a própria instância do ObjPlayer.  Pois bem.... esse conceito MORREU!!!! ESQUECE ISSO, MULEQUE!!!

Vejam vocês que, toda a interação que os senhores tiverem com mouse/teclado/touch/etc agora vai ser enviada em forma de pacotes para o SERVER. Sim, vcs não "encostam mais em nenhuma instância". QUem movimenta as instâncias é o SERVER.
COMO ???? Simples, o server vai receber o comando, através de pacotes de redes (buffers) do client. E vai atualizar os dados do OBJPlayer relativos àquele cliente específico para TODOS OS JOGADORES (clients).

É exatamente por isso que, quando vc está com problema de conexão num jogo online, seu player fica travadão (por mais que vc marrete o dedo nas setinhas).... horas... vc não "encosta" mais no player.... as setinhas do teclado apenas mandam um comando para o server.... e como esses pacotes não chegam pro server (pq sua internet é uma merda) o server não vai atualizar a SUA posição para vc e os demais clients.

Obs: Quando eu digo "encostar", significa que os eventos de teclado/mouse/touch não afetam diretamente as instâncias no jogo, apenas afeta diretamente o Servidor (pois essa informação do que vc está apertando chega PARA O SERVIDOR através de pacotes pela rede). E o servidor sim "encosta" (ou seja, afeta diretamente) as instâncias dos players .

Bom, pelo menos agora vcs não vão mais ficar socando o teclado qdo der lag, já poupei vcs com isso de stress desnecessário eheheheh.

Uma vez que vcs já repensaram a forma de encarar o mundo, vamos levar isso pro mundo do GMS.

Capítulo 2 - O maravilhoso mundo de Networking do GMS

Antes de entrarmos em códigos, vou contar uma historinha a qual eu me emociono toda a vez que eu conto. Essa história certamente vai ajudar no entendimento do que vai vir daqui pra frente:

Era uma vez um jogo, digo, uma cidade encantada onde ninguém saía de casa, mas todos eram felizes pois se comunicavam através de cartas graças a um servidor, digo, central de correio.

Então, habitavam essa cidade:
- O SERVER (que  é central de correios);
- Os SOCKETS (que são as caixas de correios. Tem uma em cada casa. Elas se ligam à central através de Portas de comunicação);
- Os Buffers (que são os envelopes);
- As Variáveis (tipo string, integer, double, etc...que são as cartas em si. ).
- A Porta de Comunicação (como eu disse,  é a via onde o carteiro trafega).
- A Internet (ou rede) (que são os carteiros robôs).
- Os Clients (que são as pessoas que moram nas casas).

Então, nessa cidade Deus criou primeiro o Server, que era uma central que recebia e redirecionava todas as mensagens.
Quando o server foi criado, a porta do servidor foi criada como uma via para chegar à residência das pessoas (CLIENTS).
Cada residência, precisou criar um SOCKET (caixa de correio), também conectada nessa PORTA DE COMUNICAÇAO (via).

Assim, as pessoas escreviam suas mensagens (variáveis), botavam dentro de um envelope pequeno (BUFFERS) e mandavam pra central de correios (Server).

O Server tinha um envelope grande (BUFFER) que ele usava para ler as cartas de todas as pessoas. Como ele recebia muitas cartas, o envelope dele era bem maior que as pessoas normalmente utilizavam.

Toda a vez que um envelope (buffer) de cliente chegava na central (SERVER), uma campainha tocava (EVENTO ASYNCRONO NETWORKING), assim a central de correio (SERVER) sabia que tinha chegado um envelope (buffer) com uma carta (mensagem) dentro.

Todos viveram felizes para sempre.

Fim.

Sei que a história é comovente, mas segurem o choro. Pois agora vamos falar de GML!


Capítulo 3 - Funções, Variáveis e Estruturas de Networking Nativo do GMS

Finalmente, vamos falar a linguagem do GML (é, sei que vcs já estavam quase dormindo, mas pra aprender direito tem que ser 1 passo de cada vez, CONCENTRA AE, MULEQUE!!!).

Vamos precisar basicamente de:

a) network_create_server(tipo_de_socket,porta,num_clients);
Essa função vai subir o server.  Na historinha, vai criar a central de correio. Seus parâmetros são:
- Tipo de Socket (Se vai ser TCP ou UDP) : Resumindo o bagulho para vcs: TCP existe garantia de recebimento de pacotes, mas é mais lento. UDP não existe garantia de recebimento mas é mais rápido. No nosso exemplo vamos usar TCP através da constante: network_socket_tcp.

- Porta de Comunicação: No mundo IP, cada aplicação trafega seus dados através de uma porta. Aqui vc vai definir qual porta o seu jogo vai usar pra trafegar os dados. Se vc escolher uma porta já utilizada por outros processos vai dar erro, então utilize uma porta alta (entre 6000 e 6550 por exemplo pra ter menos chances de conflito. Na nossa historinha, é a via onde a central se comunica com as caixas de correio (sockets).

-num_clients: O número de clients que vai ser o limite. Na nossa histórinha, se vc quer que a cidade tenha no máximo 10 moradores, então coloque esse número como 10.

b) buffer_create(tamanho_em_bytes,tipo_de_buffer,alinhamento)
O buffer é a estrutura de dados usada para trafegar as informações na rede. Tudo que vc faz, vc salva dentro de um buffer e manda para o servidor. Quando o servidor quer enviar um pacote para o cliente, ele faz o mesmo, escreve a informação dentro  de um buffer e manda para os clients. Logo, essa é a estrutura de dados mais importante nesse caso. Vcs DEVEM ler o manual e tutoriais para entender mais sobre Buffers se quiserem ser alguém na vida.
-Tamanho_em_Bytes: É o tamanho que o buffer (quantos bytes vão caber no buffer). Na historinha, é o tamanho do envelope. Normalmente o buffer do Server é maior que o do client, pois ele recebe pacotes de vários clients.
- Alinhamento: Dependendo do dado que vc vai botar dentro do buffer, vc vai precisar que esse valor seja 1, 2, 4 ou 8. Veja no manual do GMS o número indicado para cada um. Aproveite para aprender mais sobre buffers, zé preguiça.


Pra te ajudar, saca esse excelente tutorial sobre buffers no Wiki da yoyogames:
http://wiki.yoyogames.com/index.php/Buffers

Esse também é bem prático e vem com um exemplo:
http://gmc.yoyogames.com/index.php?showtopic=583534

E ainda temos o ótimo tutorial do PedroX sobre Buffers:
https://gmbr.forumeiros.com/t29377-buffers-tudo-sobre#215492



c) buffer_seek(Buffer, buffer_seek_start, 0)

Resumindo: Esse comando vai preparar o buffer para ser escrito.

d) buffer_write(Buffer , buffer_string, mensagem)

Resumindo: Esse comando vai botar a carta dentro do envelope.

e) network_send_packet( IDdoSocket, Buffer, buffer_tell(Buffer) )

Resumindo: Esse comando envia um pacote pela rede. Se foi executado pelo Client, vai chegar para o Server.
Se foi enviado pelo Server, vai chegar para os Clients.

f) Evento Asynchronous / Networking



Toda a vez que alguém envia uma mensagem pela rede (quando mandam uma carta), é esse evento que é disparado pra quem recebe. É nesse evento que é realizado o tratamento das mensagem que chegam pela rede!!!!

Dentro desse evento, existe uma variável do tipo DS_MAP (se vc não conhece essa estrutura, vá estudar no manual do GMS, seu vagabundo) chamada async_load.

Esse cara (async_load) vai guardar os seguintes dados:

- Type: O tipo de pacote que está chegando (1 para Conexão, 2 para Desconexão e 3 para Dados).

- ID: Se for um pacote do tipo 3 (dados), vai mostrar o ID do cliente que está enviando o dado.

- IP: O IP do cliente que enviou o pacote
Socket: Se for um pacote do tipo 1 ou 2, vai dizer o ID do cliente que está se conectando ou desconectando.

- Buffer = Se existem dados no pacote recebido (é o envelope que contem a carta).

- Size= O tamanho do Buffer (qtde de dados que estão chegando);


Galera, com isso já da pra brincar bastante.

Vamos para o próximo capítulo onde vamos construir o projeto do Server e o Projeto do Client. Estamos quase lá!!!! \o/


Capítulo 4 - Construindo o Server no GMS


Ae, galera!! Chegou a hora de botar a mão na massa (Graças a Deus)!!

Se vc é rico e tem 2 monitores, essa é uma excelente oportunidade pra fazer valer o investimento.

Quero que vcs criem um projeto para server e um projeto para client.

Vamos começar construindo nosso server:


Para isso vamos precisar de:
1 room;
1 objeto que vamos chamar de ObjServer (de preferência dentro da room);


No Event Create do ObjServer:

Código:


//------------------------ Inicialização de Variáveis de Conexão -----------------------//
Servidor = noone; // Essa variavel vai controlar o status da conexão do servidor
Porta= noone; //A porta em que o servidor irá ouvir
ServerBuff=noone; // O Buffer utilizado para receber os dados dos clientes
Start= 0; // Se o servidor está no ar
Erro1 = 0; //Se houve algum erro para subir o server (mais provavel é a porta sendo usada por outro processo)
NumeroClientes=0; // QUantos clientes estão conectados no servidor
//--------------------------------------------------------------------------------------//


//Inicialização das variáveis que vão receber os pacotes que chegam dos clientes --------//
AS_Type=noone; // O tipo de pacote que está chegando (1 para Conexão, 2 para Desconexão e 3 para Dados).
AS_ID=noone; // Se for um pacote do tipo 3 (dados), vai mostrar o ID do cliente que está enviando o dado
AS_IP=noone; // O IP do cliente que enviou o pacote
AS_Socket=noone; // Se for um pacote do tipo 1 ou 2, vai dizer o ID do cliente que está se conectando ou desconectando
AS_Buffer=noone; // Vai se existem dados no pacote recebido
AS_Size=noone; // O tamanho do Buffer (qtde de dados que estão chegando)
AS_Conteudo=noone; // Vai ler o conteúdo da mensagem enviada pela rede (dado).
//----------------------------------------------------------------------------------------//




Pronto, criamos todas as variáveis que precisamos.

Agora, eu quero que, quando o Usuário clique com o botão esquerdo do mouse (ou de um toque no touch), o usuário possa escolher a Porta do Servidor e o servidor fique online. Então:

No Evento Mouse Global Left Released do ObjServer

Código:


if (Start==0) //Se o servidor não está no ar, eu estou clicando para botar no ar
{
    Porta=get_string('Digite o valor da porta do servidor - Default=6554','6554'); //escolho que porta vou subir o server
    Servidor=network_create_server(network_socket_tcp,real(Porta),10); // Esse é o código pra botar o servidor UP
    
    if Servidor >=0 //SE retornar um número >=0, então deu certo
    {
        Start=1; //server está up
        Erro1=0; //não houve erros
        ServerBuff=buffer_create(1024,buffer_fixed,1); //crio aqui o Buffer que vai ler os pacotes dos clientes
    }
    else
    {
        Start=0; //se o server não subiu
        Erro1=1 //é porque deu erro (provavelmente a porta estava sendo usada por outro processo)
    }
}
else
{
    game_restart(); //se eu cliquei com o servidor UP, então o que eu estou querendo é começar novamente
}




Excelente, isso é o bastante pra botar o server no ar!!!


Eu vou aproveitar, e vou utilizar o Draw Event pra mostrar o status de todas essas variáveis que criamos em tempo real. Inclusive, vou construir um painel que, em tempo real me mostre todos os pacotes que estão chegando.

Logo, no Draw_Event do ObjServer

Código:


// ----------------------- Output das variaveis de Conexão -----------------//
draw_text(10,10,'Valor do Servidor = '+string(Servidor));
draw_text(10,30,'Valor da Porta = '+string(Porta));
draw_text(10,50,'Valor do ServerBuff = '+string(ServerBuff));
draw_text(10,70,'Numero de Clientes = '+string(NumeroClientes));
//---------------------------------------------------------------------------


if Start==0 // Se o servidor ainda não está no ar
{
    if (Erro1==0) // Se não houve erro de subir o servidor na tentativa anterior
    {
        draw_text(10,90,'Clique para Startar o Servidor');
    }
    else
    {
        draw_text(10,90,'Erro - Porta em uso'); // Se houve erro é porque a porta escolhida estava ocupada com outros processos
    }    

}

else // Se o servidor está no ar

{
    draw_text(10,90,'Clique para Reiniciar o Servidor');    

    //Mostrando na tela em tempo real os pacotes que chegam do Clientes------//
    draw_text(10,130,'Leitor de Pacotes');
    draw_text(10,160,' Valor do Type = '+string(AS_Type));    
    draw_text(10,190,' Valor do ID = '+string(AS_ID));
    draw_text(10,220,' Valor do IP = '+string(AS_IP));
    draw_text(10,250,' Valor do Socket = '+string(AS_Socket));
    draw_text(10,280,' Valor do Buffer = '+string(AS_Buffer));
    draw_text(10,310,' Valor do Size = '+string(AS_Size));
    draw_text(10,340,' Valor do Conteudo = '+string(AS_Conteudo));
    //----------------------------------------------------------------------//




}



Legal!!! Ta ficando "profissa" nosso servidor!!!

Então, a única coisa que falta, é saber quando vão chegar os pacotes dos clients e, quando esses pacotes chegarem, eu preciso abrir o envelope (buffer) e ler o que está escrito.

Lembrando da nossa amável histórinha, o SERVER é a central de correios.
Quando chegam cartas dos habitantes da cidade, é soada uma campainha. Essa campainha é o evento Asyncrono NETWORKING.

É lá que eu vou ver o que chegou e o que está escrito.

Logo, no EVENTO ASYNCHRONOUS NETWORKING do ObjServer

Código:


//Aqui é onde vão chegar as mensagens dos clientes
/*As mensagens chegam num ds_map conhecido como AsyncLoad, vamos pegar o conteúdo dessa estrutura e jogar nas
nossas variáveis. Assim podemos ler e tratar tudo que chega dos clientes.*/

AS_Type=ds_map_find_value(async_load,"type"); // o Tipo do pacote (Pedido de conexão, Pedido de desconexão ou dados)
AS_ID=ds_map_find_value(async_load,"id"); // ID de quem enviou dado (caso seja um pacote de dados)
AS_IP=ds_map_find_value(async_load,"ip"); //IP de quem enviou o pacote
AS_Socket=ds_map_find_value(async_load,"socket"); //ID de quem enviou o pedido de conexão ou desconexão
AS_Buffer=ds_map_find_value(async_load,"buffer");//Se existe buffer de dados
AS_Size=ds_map_find_value(async_load,"size");//Qual o tamanho do buffer de dados
AS_Conteudo="N/A"; //Só vou abrir se for um pacote de dados (tipo 3)

if AS_Type==network_type_connect // Se for um pedido de conexão (essa constante na verdade tem o valor =1)
{
    NumeroClientes++; //Eu incremento meu contador de clientes
}

if AS_Type==network_type_disconnect // Se for uma notificação de desconexão (essa constante na verdade tem o valor = 2)
{
    NumeroClientes--; //Eu decremento o meu contatdor de clientes
}

if AS_Type==network_type_data //Se for um pacote de dados (essa constante na verdade tem o valor = 3)
{
    AS_Conteudo=buffer_read(AS_Buffer,buffer_string); //Nesse caso sim eu vou ler o buffer pra saber o conteúdo do dado
}



Uhuuu! Nosso server está criado e pronto para receber conexões, bem como ler os pacotes de dados que chegam para ele.


É hora de construir o CLIENT.

Capítulo 5 - Construindo o CLIENT no GMS


Vamos trocar de monitor e focar no projeto do client.

Vamos começar construindo nosso client:


Para isso vamos precisar de:
1 room;
1 objeto que vamos chamar de ObjClient (de preferência dentro da room);


Vamos parir o client:

Create Event do ObjClient

Código:


//---------------- INICIALIZACAO DE TODAS AS VARIAVEIS ------------------------------

Client=noone; //essa variãvel vamos usar como socket
NetworkConnect=noone; //essa variável vai testar a conexão com o server
ClientBuff=noone; //Buffer que o cliente usa para mandar mensagens para o servidor

Conectou=0; //Variavel que testa se a conexão foi bem sucedida
Erro1=0 //Variável que detecta o erro de porta ou de ip do servidor
IP=noone; //IP do servidor
Porta=noone; //Porta do servidor

//----------------------------------------------------------------------------------




Assim como no ObjServer, eu quero uma ação no clique do mouse (ou touch) para me conectar no server (que deve estar rodando para que dê certo).

Assim, vamos lá:

No Evento Global Mouse Left Released do ObjClient:

Código:


if (Conectou==0) //se eu ainda não conectei, então vou tentar conectar nesse evendo do botao esquerdo do mouse
{

    IP=get_string("Digite o IP do Servidor","127.0.0.1"); //pegando o ip do server
    Porta=get_string("Digite a Porta do Servidor","6554"); //pegando a porta que o server esta escutando

    Client = network_create_socket (network_socket_tcp) //criando o socket
    NetworkConnect = network_connect( Client, IP, real(Porta)) //conectando


    if NetworkConnect>=0 //Quando a conexão é bem sucedida, essa variável é >=0
    {
        Conectou=1; //então eu conectei com sucesso
        Erro1=0; //sem erros
        ClientBuff = buffer_create( 256, buffer_grow, 1)
    }
    else //Se deu um número negativo, é pq não funcionou
    {
        Erro1=1; // Logo deu erro
        Conectou=0; //E eu não conectei
    }
}

else //se eu já estou conectado, então eu apertei o botão do mouse para me desconectar

{
    network_destroy(Client); //matei a conexão com o server
    game_restart(); //reiniciei
}


Essa parte é emocionante... nós criamos uma conexão entre o Server e o Client, através de um socket.... isso é fantástico!!! Vc pode rodar o server em qq plataforma, bem como o Client... como eu amo o GMS.
Para termos o controle total da situação, vamos mostrar no DrawEvent a saída de nossas variáveis. Assim, se tiver dando algum erro e vc não consegui conectar nós vamos saber:

No DrawEvent do ObjClient:

Código:


//-------------- Mostrando na Tela nossas variaveis de controle ----------------
draw_text(10,10,'Valor do Client = '+string(Client));
draw_text(10,30,'Valor da Porta = '+string(Porta));
draw_text(10,50,'Valor do ClientBuff = '+string(ClientBuff));
draw_text(10,70,'Valor do NetworkConnect = '+string(NetworkConnect));
// ------------------------------------------------------------------------------

// -------------- Verificando se a conexão foi bem sucedida ----------------------
if(Conectou==false)
{
    if (Erro1=false)
    {
        draw_text(10,100,'Clique para Conectar no Servidor'); // Aqui ainda não tentamos conectar
    }
    else
    {
        draw_text(10,100,'Erro de Conexão - Servidor ou Porta sem serviço'); // Aqui tentamos conectar mas houve um erro
    }
}
else //se a conexão foi bem sucedida
{
    draw_text(10,100,'Conectado no IP '+string(IP)+'#Porta = '+Porta+'#Clique para Desconectar');
    draw_text(10,150,'Tecle Enter para enviar mensagem');
}      

// -------------------------------------------------------------------------------------------------------------




AGora, meus caros, é hora de escrever as cartinhas e mandar para a central (Server).

Essa carta vai ser aberta lá no server e isso vai provar por A+B que somos capazes de fazer jogos multiplayer =)
Eu quero  que o evento de apertar a tecla ENTER (por exemplo) seja responsável por escrever essa carta e mandar para a central.
Em outras palavras, vamos mandar um pacote de dados do client que vai ser processado pelo server. Ou ainda, como alguns dizem,  vamos mandar uma mensagem para o server.


Então, no evento Keyboard ENTER do ObjClient (ou qualquer outro evento que vc preferir):

Código:


if (Conectou==1) // Obviamente só vou mandar mensagens para o servidor se eu estiver conectado
{
    Texto=get_string("Digite a Mensagem","Teste"); //pegando do usuário a mensagem
    buffer_seek(ClientBuff,buffer_seek_start,0); //preparando o buffer
    buffer_write(ClientBuff,buffer_string,Texto); //gravando a mensagem no buffer
    network_send_packet(Client,ClientBuff,buffer_tell(ClientBuff)); //enviando o buffer pela rede... essa ação vai disparar uma chamada no evento Asyncrhonous NETWORKING do server
}



Simples essa parte, não ?

Veja a mensagem aparecendo do outro lado!!! QUe Beleeezaaaa!!!!!

Parabéns, vc conseguiu.


Façam o teste abrindo um server e vários clients (varios exe's) ao mesmo tempo... 2, 3, 4, 5..... vcs verão e entenderão ainda melhor como o GMS trabalha com esses pacotes, como ele classifica, enfim... isso é fundamental para o aprendizado. Garanto que vai cair a ficha.

Capitulo 6 - Considerações Finais:

Se vc entendeu TUUUDO até aqui, vc já está apto a fazer seus jogos multiplayer. Vc domina as ferramentas.
Os códigos que criamos aqui estão disponíveis pra download no cabeçalho deste tutorial.

Eu te ensinei a pescar, agora vá pegar seus próprios peixes.

Leia os tutorias da GMC como:
http://gmc.yoyogames.com/index.php?showtopic=582029
http://www.yoyogames.com/tech_blog/11

Quebre a cabeça com a Demo de Networking do GMS.
A partir de agora vc é capaz.

Reflita bastante sobre esse novo jeito de pensar o seu game. Agora vc pode mandar mensagens para o server sobre o que vc está "apertando", e o server tem que atualizar a posição de cada player em cada cliente. Tudo isso através do tratamento das mensagens que chegam dentro dos buffers. A inteligência está toda no evento NETWORKING.

Mais pra frente eu pretendo postar uma engine básica de movimentação multiplayer.... mas vc também pode começar a construir uma a partir de agora.
Espero que esse tutorial tenha aberto um pouco a cabeça de vcs.

Abraços,
Titio Fred.



EDIT 1:
Atendendo a pedidos - Comunicação do Server com os clients:

Observei que muitos estavam com dúvidas na comunicação do SERVER com os CLIENTS (ou seja, o server mandar mensagens para os clients), portanto estou inserindo essa nota de rodapé no tuto.

A comunicação do server com os clients é um pouco diferente pois vc tem que especificar qual client (através do socket).

Existem 3 formas de vc identificar quem é o socket de destino:
1) Quando um client se conecta ao server, é disparado no server o evento ASYNCRONOUS NETWORKING.
Sempre que isso ocorre, o mapa async_load é carregado com informações.
A informação que vc precisa (ID do SOCKET) estará na variável SOCKET desse mapa.

Toda vez que esse evento de conexão ocorrer, vc vai salvar o ID desse client num vetor ou lista... assim vc tem o "endereço" (ou caixa postal, segundo minha fábula) desse client.

2) Sempre que um cliente (já conectado) manda alguma mensagem para o server, o  mapa async_load novamente é carregado com informações.
A informação que vc precisa (ID do SOCKET) estará na variável ID desse mapa. Então vc sabe quem mandou a mensagem.

3)Pode-se falar com todo mundo via um comando de broadcast:

Código:

   buffer_seek(broadcast_buffer, buffer_seek_start, 0);
    buffer_write(broadcast_buffer, buffer_string, global.ServerName);
    network_send_broadcast(server, 6511, broadcast_buffer, buffer_tell(broadcast_buffer));

Mas penso eu que o broadcast só funciona para socket do tipo UDP.

Parece ser um tutorial muito complexo(e bem feito), ainda não tive coragem de ler(pois não estou ainda nesse nivel)... mais baixei os arquivos "GMZ"
Parabéns.

rickelme.dias escreveu:Parece ser um tutorial muito complexo(e bem feito), ainda não tive coragem de ler(pois não estou ainda nesse nivel)... mais baixei os arquivos "GMZ"
Parabéns.

Fala Rickelme, obrigado pelo comment.

Então, trabalhar com networking não é algo tão trivial. Mas mesmo quem não tem tanta experiência pode ficar nesse tutorial que certamente vai conseguir entender.

Daí pra fazer um chat por exemplo é algo bem fácil.

Espero ter contribuído com seu aprendizado de alguma forma.

Valeuu!

Opa! Bem na hora.
Quero fazer um jogo para OUYA com multiplayer online para até 4 jogadores.
Com certeza vou ler com calma pra entender.
Todo estudo que fiz na área de jogos desde que comecei foi já desenvolvendo um jogo, então já vou começar o projeto paralelo a outros que estou tocando.

cascavelo escreveu:Opa! Bem na hora.
Quero fazer um jogo para OUYA com multiplayer online para até 4 jogadores.
Com certeza vou ler com calma pra entender.
Todo estudo que fiz na área de jogos desde que comecei foi já desenvolvendo um jogo, então já vou começar o projeto paralelo a outros que estou tocando.

Legal, Cascavelo!

Fique à vontade para postar aqui suas dúvidas... terei prazer em ajudar (caso eu tenha competência para tal rsrsrs).

=)

Muito bom! Aprendi muita coisa nova. Ainda não tenho o GM:S, por isso não posso testar. Pelo mesmo motivo não li tudo detalhe por detalhe, mas já entendi bem a lógica do processo.

Bem comentado e bem explicado, numa linguagem de fácil entendimento.

Um convite especial: quer ser um tradutor do fórum ? (obs: todo mundo pode se candidatar)

PedroX escreveu:Muito bom! Aprendi muita coisa nova. Ainda não tenho o GM:S, por isso não posso testar. Pelo mesmo motivo não li tudo detalhe por detalhe, mas já entendi bem a lógica do processo.

Bem comentado e bem explicado, numa linguagem de fácil entendimento.

Um convite especial: quer ser um tradutor do fórum ? (obs: todo mundo pode se candidatar)

Pedro, meu caro. Vc pode baixar a versão FREE do GMStudio.
Te dá direito a 1 conexão client/server.

Dá pra vc testar e estudar =)

O link para download:
http://yoyogames.com/download/studio/free


Quanto ao cargo, agradeço o convite, mas como tradutor não é muito o meu forte. Se eu puder ajudar de outras formas, vamos trocar uma idéia via MP.

Obrigado e abraço.

Tutorial muito bem feito fredcobain, vou usa-lo para fazer minha extensão 39dll para o gms, para reaproveitar os códigos dos meus jogos usando a networking do gms.

Uma duvida: O servidor dele é uma aplicação do game maker ou tem um console separado?
Porque nos VPS que não tem placa gráfica, não tem como rodar uma aplicação do game maker, e por tanto, um servidor não funcionará em uma VPS.

Pit Bull escreveu:Tutorial muito bem feito fredcobain, vou usa-lo para fazer minha extensão 39dll para o gms, para reaproveitar os códigos dos meus jogos usando a networking do gms.

Amigo Pit Bull, acho que já fizeram isso lá no fórum do GMC.

Pegue pronto aqui:

http://gmc.yoyogames.com/index.php?showtopic=586058

=)

No caso, o Server é também uma aplicação em GMS. Temos que pensar sobre como fazer no caso da VPS que não processe os gráficos, de bate e pronto não sei como resolver. Temos que pesquisar.

Edit: Dei uma pesquisada, parece que não é possível desabilitar a parte gráfica. Veja:
http://gmc.yoyogames.com/index.php?showtopic=531102

Abraço.

No link que você passou tem um servidor em c++, pena que só funciona junto com a 39dll, vou tentar adapta-la para a networking do gms.

Pit Bull escreveu:No link que você passou tem um servidor em c++, pena que só funciona junto com a 39dll, vou tentar adapta-la para a networking do gms.

PitBull, veja um exemplo de cliente GMS (nativo) com um servidor C#:
http://gmc.yoyogames.com/index.php?showtopic=588440


E agora um exemplo de um cliente GMS (nativo) com um servidor Java:
http://gmc.yoyogames.com/index.php?showtopic=586718


Acho que isso vai ser útil pra vc.

Eu prefiro o c++ porque eu já conheço ele(aprendi na faculdade), esses outros eu iria ter que aprender a linguagem pra depois desenvolver.

Muito bom seu tutorial, bem explicado... gostei..

@off:
num tem como criar jogos online SEM usar ip's não?

num tem como criar jogos online SEM usar ip's não?

Usei um sistema para não precisar saber o IP em um de meus projetos.

O conceito é:

- Ao iniciar o servidor, enviar o IP para um site na internet. Use uma hospedagem paga se tiver condições. Pode ser uma de R$ 2,00, você acha por aí. Só precisa aceitar PHP. Pode até mesmo pedir a um amigo para colocar a página PHP e uma pasta para os arquivos de texto no site dele.

- O site (página PHP) registra o IP enviado (por uma DLL, como NetRead) num arquivo de texto.

- Quando o cliente iniciar o jogo, baixa a lista de IPs do site.

Não é complicado fazer isso. Se tiver dúvidas, me contate por MP.

Onix, em teoria não. Pois a internet e as redes locais adotaram a pilha de protocolos TCP/IP como protocolo há quase 30 anos. Nesse conceito, todo ativo possui um registro único na rede (IP) que o identifica.

O que vc pode fazer é utilizar o DNS como protocolo que vai transformar os nomes em IP`s. O GM tem uma função específica pra isso, que é o network_resolve(url).

Exemplo :

Código:

game_ip = network_resolve("www.macsweeneygames.com");

O código acima vai resolver o nome www.macsweeneygames.com para o seu respectivo endereço IP.

PedroX escreveu:

num tem como criar jogos online SEM usar ip's não?

- O site (página PHP) registra o IP enviado (por uma DLL, como NetRead) num arquivo de texto.

Pedro, mas vc usando DLL vc vai acabar com a possibilidade de ser multiplataforma =)


Mas é claro que, por trás dos panos, vai continuar usando IP pra se comunicar (pois não há outro jeito).

PedroX: gostei da ideia, mais isso se aplica a qualquer plataforma?

fredcobain: não precisa de alguma senha pra isso? porque sei lá, se não precisa significa que se pode usar qualquer site pra isso...

Isaque Onix escreveu:PedroX: gostei da ideia, mais isso se aplica a qualquer plataforma?

Sim. Basta fazer um request. Pelo GM:S, nativamente, isso é possível.

Isaque Onix escreveu:fredcobain: não precisa de alguma senha pra isso? porque sei lá, se não precisa significa que se pode usar qualquer site pra isso...

Você pega o IP do site apenas. Isso não quer dizer que o site é um host de jogos nem que a porta está aberta. Ou seja, o cliente não vai conseguir se conectar.

num funciona em HTML5 nao? (o seu exemplo)

Networking ainda não funciona no HTML5.

que pena... valeu..