[Tutorial]Experimental Micro web Networking GM:S

Descrição : Este tutorial sobre a Rede experimental do GM:S (Networking EXPERIMENTAL Micro Web server) da nova atualização do GameMaker Studio foi encontrado no fórum de game maker da yoyogames , então resolvi traduzi-la e postar aqui no fórum ajuda os usuários a compreender sobre este sistema feito pela própria YOYO games que promete ser melhor que qualquer DLL feita . Quem tem o Game Maker Studio , e não tem o evento Networking , faça o update e adquira o evento e uma engine que vem na aba "TUTORIAL" .


Obs:Tutorial traduzido , menos as imagem , vocês mesmo terão que traduzi-las.
Obs²:Desculpe-me se tiver alguma parte que não tem muita coerência , estou tentando traduzi-la melhor possível.

Game Maker : Disponivel apenas em GM: Studio Free , Stardart , Profissional version update 1.1.867 , e update Version 1.1.872.

Tutorial Original: http://www.yoyogames.com/tech_blog/11



Introdução GameMaker: Studio Networking(rede) .


Nesta última versão do GameMaker: Studio, nós adicionamos algumas redes experimental, e por isso vou agora dar-lhe um breve resumo de como tudo funciona, quais sãoas regras gerais, e uma maneira de fazer um simples cliente / servidor que você pode usar em um jogo. Este tutorial será baseado no novo exemplo Plataforma Rede (Networked Platformer example que vem no ultimo update do GM: Studio), então você deve olhar através dele para que você ter uma vaga ideia do que vou falar.

http://www.yoyogames.com/extras/posts/normal/414_NetworkPlatformer.png

Primeiro, o sistema de rede é baseado em "soquetes" (sockets), que são padrão, e está disponível em todas as plataformas - excluindo para HTML5 . Demos-lhe a capacidade de criar clientes e servidores em GML permitindo que você crie até mesmo jogos single player (com um jogador) usando um modelo cliente / servidor - o que permitirá adicionar facilmente um modo multiplayer (varios jogadores) mais tarde. Eu não vou chegar muito longe em como trabalhar com "soquetes" , que é um assunto com grandes lotes de tutoriais, demonstrações e descrições na net, mas vou dar um breve resumo do que é um soquete .

Um soquete é um objeto que pode enviar, receber, ligar e ouvir portas na rede. Inicialmente, vamos tratar apenas conexões TCP / IP, que é o que a Internet está baseada em IPv4 (para ser mais preciso).Isso na verdade permite que você conecte em um soquete utilizando um endereço IP (digamos 192.168.1.10) para outro soquete em outro endereço IP (digamos 192.168.1.11 ). Uma vez conectados, os dois soquetes pode enviar dados e receber usando o network_send_packet () e da Rede de Eventos ASYNC (Network ASYNC Event) - mas nós vamos entrar neste assunto mais tarde. Primeiro, os endereços IP também têm o que é chamado de Portas. Em vez de programas que têm de ler e lidar com todos os bits de tráfego de rede entrado em uma máquina, os endereços IP também lida com portas, variando de 0 a 65535. Isso permite que cada programa obtenha apenas os pacotes (packets) que ele está interessado, e não tudo - isso também poupa tempo considerável de CPU , uma vez que reduz seriamente em processamento de dados. Uma coisa que você também deve notar, é que algumas portas já estão em uso por seu system, e por isso você deve tentar escolher um número de porta "superior". Você pode ver uma lista deles aqui.(WIKI - PORTUGUES)(WIKI - INGLES (este esta no tuto original))

Para tornar a vida um pouco mais fácil, você também pode "ouvir" as portas. Assim, um servidor irá criar um soquete, e depois ligá-lo a uma porta específica para ouvir. Ele, então, seria notificado de ligações, desligamentos e transferências de dados.

Então ... rápida revisão de um soquete, você pode conectar a uma porta em um endereço IP, e ler / escrever alguns dados, enquanto que um servidor pode "ouvir" a uma porta, e então, pode fazer e informar uma conexão / desconexão e ler / escrever alguns dados . Assim você cria um servidor, diga a ele para ouvir uma porta, e quando um cliente tenta se conectar, o servidor avisa, conecta e então cria um "link" entre eles para que possam livremente enviar dados e receber. Bastante simples, até agora.

Agora, tudo isso acontece de forma assíncrona(asynchronously). O que significa que envia dados para fora, mas não tem ideia de quando os dados virão. Para ajudar com isso, nós adicionamos um evento rede ASYNC (Network ASYNC Event). Todos os dados são recebidos através deste evento, junto com todo os detalhes da conexão / desconexão.

Isto significa que podemos enviar em qualquer lugar, mas todos os dados de entrada se dá através do evento - para o cliente e servidor. Isso significa que precisamos de saber quem os dados é, e o que ele contém. Agora soquete são "fluxos", e isso significa que se uma máquina envia dois pacotes de dados para um servidor, ele pode acabar ficando um bloco de dados grande no retorno. Então ao invés de dois retornos de 32 bytes, você tem um retorno de chamada de 64 bytes.

Isto torna a vida um pouco complicado. GameMaker pode ajudar com isso. A chamada network_send_packet () vai dividir automaticamente estes feixes - você não precisa, mas eu recomendo.

GameMaker atribui um pequeno cabeçalho para cada pacote enviado para que ele saiba que é um pacote, e o tamanho, e deste modo permite que processa cada uma, a manipulação do fluxo irritante para si.

Então, o que você agora acabou de saber, é um retorno para cadapacote qualquer cliente lhe enviou. Isto deixa-o livre para escrever o código do servidor com base em pacotes de dados simples.

Assim, exatamente como você deve escrever um simples jogo em rede? Bem, obviamente há um número infinito de formas, por isso vamos pegar um exemplo muito simples (e longe de ser perfeito!), E discutir isso. Para o nosso sistema, vamos correr o jogo inteiro no servidor, deixando o cliente apenas para exibir os resultados.

http://www.yoyogames.com/extras/posts/normal/415_client_server.png

Agora, normalmente em um jogo single player (um jogador), você tem um simples objeto correndo em voltas , verificando as chaves em si, mas para o nosso jogo em rede(networked game), nós vamos mudar isso. Ao contrário do que o teclado sendo diretamente controlados pelo jogador, nós vamos criar um novo objeto "oCLIENT" que verifica as chaves, e que vai, então, encaminhar esses eventos de tecla pressionada / liberada para o servidor como eles acontecem. Isso é muito claro sobre o tráfego de rede como, se você estiver executando-o direito (por exemplo), você recebe um evento para começar a correr, e depois muito mais tarde, uma para parar. Apenas 2 pacotes de rede no total, o que é ideal.

Então, próximo passo , vamos precisar de um servidor, algo que vai receber essas chaves e processar todos os jogadores conectados de alguma forma. Na criação, o nosso objeto oServertenta criar um socket e tenta ouvir na porta 6510, à espera de um cliente para conectar (veja abaixo). O "32" é o número total de clientes que queremos para permitir a ligação de uma só vez. Este número é com você, muitos, e seu jogo vai saturar a rede ou o seu CPU não será capaz de lidar com o tratamento de número de jogadores - use com cuidado.

server = network_create_server( network_socket_tcp, 6510, 32 );

Se isto falhar, então já podemos ter um servidor nesta máquina - ou a porta está em uso por outro programa. Apenas uma soquete pode ouvir a mesma porta de uma vez, por isso, se alguma coisa está a usá-lo, você terá que escolher outro. Uma vez que o nosso servidor é criado e já ouve, então podemos colocar nosso cliente a se conectar.

Primeiro, vamos lidar com uma criação de uma soquete e conecta-la.

client = network_create_socket( network_socket_tcp );
network_connect( client, “127.0.0.1”, 6510 );

"127.0.0.1" é um endereço de rede especial que é próprio da sua máquina. É um "loopback", ou seja, nada realmente vai para a rede, mas entregues diretamente para sua própria máquina. Isto pode ser alterado mais tarde.

E é isso! Uma vez conectado, agora estamos prontos para enviar dados e receber do cliente para o servidor! A primeira coisa que o cliente faz é enviar um pacote especial para o servidor, informando o nome dos jogadores. Para isso vamos usar um dos nossos novos "buffers binários" (consulte o manual para mais detalhes) Isso nos permite criar um pacote de matérias-primas, os dados binários, que possamos envia-los para o servidor. Os buffers são muito simples de usar. Basta criar um, escrever alguns dados, e depois enviá-lo. Eu recomendo que você mantenha o buffer em torno de modo que você pode reutilizá-lo, lembrando que se você fizer isso você vai precisa redefinir a leitura / escrita de volta para o início de cada vez. Então, dentro de nosso objeto OCLIENT, vamos criar um novo buffer

buff = buffer_create( 256, buffer_grow, 1)

Isso cria um novo buffer de 256 bytes de tamanho, que vai crescer conforme necessário, com um alinhamento de 1 (sem espaços à esquerda), que para o nosso tráfego mínimo, é apenas multa.

Para enviar alguns dados para o servidor nós simplesmente temos que escrever para o buffer e enviá-lo.

buffer_seek(buff, buffer_seek_start, 0);
buffer_write(buff, buffer_s16, PING_CMD );
network_send_packet( client, buff, buffer_tell(buff) );

E é isso. O buffer_seek () no início nos permite reutilizar o buffer como o sistema de rede sempre toma os dados de índice 0 no buffer, e jogando fora todo tempo os buffers é um desperdício.

Então, como é que o servidor obtem esses dados? Bem , usando o novo Evento de Rede (new Network event), é bastante simples também.

http://www.yoyogames.com/extras/posts/normal/416_NetworkEvent.png

Nós simplesmente escolhemos o evento de rede (networking) no menu (acima), e depois podemos começaremos a escrever alguns códigos de cliente / servidor para quando os dados chegam (como mostrado abaixo).

http://www.yoyogames.com/extras/posts/normal/417_ServerEvent.png

O Evento de Rede(Network event) cria um novo ds_map e atribui async_load para segurá-la, e isso nos permite olhar tudo o que precisamos, e isso nos permite decidir sobre o curso atual da ação.

var eventid = ds_map_find( async_load, “id” );

Isso retorna o ID da soquete que jogou no evento. Isso pode ser o ID do servidor, ou um ID de cliente conectado. Se é o ID do servidor, então temos um evento de conexão / desconexão especial, e é neste ponto que podemos começar a criar novos jogadores para o cliente conectar, ou jogá-los fora, se desconectar.

Assim, para dizer se é uma conexão ou uma desconexão, vamos verificar o "tipo" na ds_map.

var t = ds_map_find_value(async_load, "type");

Se t == 1, então é uma conexão, e assim podemos obter o ID do novo soquete e de onde está vindo o IP.

var sock = ds_map_find_value(async_load, "socket");
var ip = ds_map_find_value(async_load, "ip");

A variável sock irá conter o ID que tenha sido designado para esse cliente, e será o mesmo ID, desde que o cliente permanece conectado. Podemos, portanto, usar isto como uma pesquisa para todos os dados do cliente.

A maneira mais simples de obter informação sobre o cliente, é a utilização de um ds_map e utilizar sock como uma pesquisa para uma instância que pode conter todos os dados/variáveis do clientes. Então tudo que você precisa fazer é criar um "clientes" ds_map no evento de criação de oServer, e depois na conexão, o servidor irá criar um novo jogador, e adicioná-lo a um ds_map como este ...

var inst = instance_create( 64,192, oPlayer );
ds_map_add( clients, sock, inst );

Isto significa então que sempre que algum dado é recebido a partir do cliente, podemos simplesmente procurar a instância e, em seguida, atribuir os dados conforme necessário. Se fosse 0, então nós simplesmente temos que retirar a soquete do mapa, e excluir a instância player.

Assim, a próxima coisa a resolver, é o que acontece quando o cliente envia alguns dados para o servidor. Isto vem para o Evento de Rede(Network Event) com um ID do sock que não é a do servidor, mas um que já conectado e inicializado. Isso significa que tudo o que precisamos fazer no código do evento servidor de rede (Server Network event) , é verificar que não é o soquete do servidor, e se não é ... procurar a instância no ds_map, comece a ler os dados que estão dentro.

var buff = ds_map_find_value(async_load, "buffer");
var sock = ds_map_find_value(async_load, "id");
var inst = ds_map_find_value(Clients, sock );

Portanto, este agora nos dá o buffer onde os dados do cliente esta, a identificação do soquete que veio dela, e a instância ligada à soquete; tudo o que precisa ler os dados e processá-lo. Nós agora podemos ler os dados do buffer, e depois armazenar as informações relevantes na instância.

A última parte do quebra-cabeça é o envio de atualizações para o cliente, e tendo que exibir o jogo. Esta é, novamente, muito simples e feito através de um Evento de Rede e, a única diferença é que nós queremos a informação vinda do buffer , no caso de haver um problema de conexão. No caso do nosso pequeno exemplo, o que ele faz é simplesmente desenhar(Draw) todas as sprites enviadas a ele pelo servidor. O evento Step do servidor faz isso a cada frame, para todos os jogadores inscritos e vilões ativos, este mantém simples o exemplo.

Note-se que este é o lugar onde modelos de "inteligentes" clientes / servidores diferem do que temos aqui. Eles vão tentar minimizar os dados que estão sendo enviados, o envio de atualizações, e limitar a frequência com que transmite. Nós não fazemos nada disso. Este sistema irá funcionar bem para um jogo em uma rede local, com alguns jogadores, mas provavelmente irá quebrar imediatamente se você tentou isso através da internet. Ainda assim, com isso em mente, como é que o nosso simples cliente recebera os dados?

Primeiro, acrescentar um Evento de Rede, como fizemos o servidor, e, em seguida, a primeira coisa que nós vamos verificar, é que o ID do evento é o id do cliente - se é, então é para nós.

var eventid = ds_map_find_value(async_load, "id");
if( client == eventid )
{
}

Agora, para amortecer os dados de entrada optei por usar um ds_list, eu simplesmente criar isso no create event do oCLIENT , e depois sempre que receberemos novos dados, limpamos , e adicionar os dados a ele. Simples.

var buff = ds_map_find_value(async_load, "buffer");
sprites = buffer_read(buff, buffer_u32 ); // Number of sprites

ds_list_clear(allsprites);
for(var i=0;i ds_list_add(allsprites, buffer_read(buff,buffer_s16) ); //x
ds_list_add(allsprites, buffer_read(buff,buffer_s16) ); //y
ds_list_add(allsprites, buffer_read(buff,buffer_s16) ); //sprite_index
ds_list_add(allsprites, buffer_read(buff,buffer_s16) ); //image_index
ds_list_add(allsprites, buffer_read(buff,buffer_s32) ); //image_blend
ds_list_add(allsprites, buffer_read(buff,buffer_string) ); // player name
}

Agora que nós temos algo para desenhar(Draw), podemos desenhar dentro do Draw event do Clienteem um loop simples.

var index = 0;
for(i=0;i var xx,yy,sp,spindex, col;
xx = ds_list_find_value(allsprites,index++);
yy = ds_list_find_value(allsprites,index++);
sp = ds_list_find_value(allsprites,index++);
spindex = ds_list_find_value(allsprites,index++);
col = ds_list_find_value(allsprites,index++);
name = ds_list_find_value(allsprites,index++);

draw_sprite_ext(sp,spindex,xx,yy,1,1,0,col,1.0);
}

E é isso pessoal.... Então, vamos recapitular rapidamente. Temos oServer, oCLIENT e oPlayer.

O oCLIENT é um cliente que envia teclas para o servidor, e vai desenhar (Draw) todas as sprites o servidor envia de volta.

oServer é o controlador, que irá conectar / desconectar os clientes, criar os novos jogadores que eles chegam (e mapeá-los para a soquete de ID), e enviar todos os sprites para todos os clientes conectados.

oPlayer é como se fosse em um jogo single player (neste caso), a não ser que já não verifica as chaves diretamente, mas um conjunto de chaves do servidor preenche quando chega teclas do cliente.


Bem aqui termina o tutorial , um breve tutorial para ser exato , explicando os conceitos basicos da nova ferramente util de sistema de rede da GameMaker.

Terminamos por aqui , abraço , tomara que eu fiz uma boa tradução , se não fiz , fale aqui no topicó , que tentarei corrigi , mas se ficou boa , exitem em elogiar , te a próxima.

Legal, assim fica MUITO melhor...porem... ...eu não tenho o gms, é muito KARO..um dia eu compro..

Ola GamePLay, preci lhe questionar, você conseguiu reproduzir o tutorial?

Eu fiz certinho e tava com os dois em mão (traduzido e o original), porem não consegui fazer a "conexão".
Na verdade colocando tudo em apenas uma aplicação, deu certo, isto é, ele reconhece a conexão e/ou entrada de dados pela rede.

Porem quando tentei fazer uma aplicação para o servidor e outra para o cliente, ele não faz a conexão.
*Executo o servidor;
*em seguida o cliente
*mas quando clico no botão (criei um botão para fazer a conexão manual), ele da problema de funcionamento no cliente, ou seja para de responder.

Sabeeeee alguem que possa esclarecer minha duvida? [caso não tenha ficado claro, quero apenas fazer a conexão em aplicações separadas, uma apenas para servidor e outra pas os clientes]

Você testou no game maker studio free ou a versão paga ?

Testei noma versão PRO paralela, e mesmo que fosse FREE na documentação ele deixa claro que essa conexão só funciona com um servidor (Sr. Óbvio) e com apenas uma conexão de cliente (limite da FREE).

A questão é que eu consigo fazer a conexão se eu colocar todos os códigos em apenas uma aplicação, por exemplo:
*botão iniciar server [para criar o socket na porta definida];
*botão conectar [para fazer a conexão na porta definida].

Desta forma ele funciona tranquilamente, e conhece o numero maximo de conexões permitidas (no caso eu defini como 32 conex simultan).

Mas quando tentei criar em aplicações (arquivos/executaveis) separadas ele não funciona.

eu teste e funcionei man , não sei bem onde você errou por que eu não fui o autor do tutorial , mas abra o tutorial Platformer Networking do Game maker , e procure ver onde voce errou man , ou faça um teste , transforme em executável(Tome cuidado pra não exporta como executável com instaler) e abre dois dele , um é o servidor , outro o cliente , escolha o servidor na tela e veja no que da.

!!Game Play!! escreveu:[...] transforme em executável(Tome cuidado pra não exporta como executável com instaler) e abre dois dele , um é o servidor , outro o cliente , escolha o servidor na tela e veja no que da.

Bom ja me cria outras duvidas. Por que não como instaler? foi assim que criei para poder abrir dois diferentes, não sei gerar apenas a pasta com executavel.

mas assim do gento que vc esta falando, eu entendo que vc criou apenas um projeto como aqueles no antigo GM 8, onde uma apricação tem codigo para ser servidor como tambem para ser cliente, e vc escolhe então depois qual vai ser qual.

Se este for o caso eu ja criei 2 separados, um somente para servidor (não possui codigo de cliente), e outro só para cliente (não possui codigo do server).

Ah na minha versão do GMS ele tem ja as funções do "network" mas não tem o tutorial disponivel.

O servidor é uma aplicação do compilador(vira um executavel igual o cliente) ou ele cria um arquivo diferenciado que não usa interface grafica?

Vira um executavel como o cliente, porem um é diferente do outro, cada um com os codigos exclusivos.

Se alguem fez ae e puder postar a engine.

machosupremo

olha aqui o mini tutorial que eu fiz , contem o down da engine que você deseja.

[Tutorial]Como usar a engine Network Platform GM:S

se não usar a opção single run time pra fazer o executavel tbm funciona?

vlw

Funciona sim mina , só falei para exporta com a opção single para ficar fácil o entendimento .

o exemplo no gms já vem configurado pra funcionar ou tem q fazer alguma modificação? não estou conseguindo snif.. ninguem falou nada de IP não tem q colocar o IP da maquina que sera o servidor em algum lugar ?
vlw

afinal,o que e game maker studio?

o exemplo no gms já vem configurado pra funcionar ou tem q fazer alguma modificação? não estou conseguindo snif.. ninguem falou nada de IP não tem q colocar o IP da maquina que sera o servidor em algum lugar ?
vlw

mina eu fiz um tutorial como abrir um servidor e clientes neste exemplo

Veja aqui = https://gmbr.forumeiros.com/t26423-tutorialcomo-usar-a-engine-network-platform-gms

Se ainda não resolveu teu problema , continue questionado , abraço.

afinal,o que e game maker studio?

yiahooo é a versão do game maker , que tem a opção de exportar seus jogos para varias plataformas (android,html5,iOS,windows phone , windows 8 entre outras) mas tem que pagar para ter algumas desses módulos de exportação .