Tutorial - Como fazer um jogo multiplayer online - Parte II

Parte II: Fazendo um Jogo

Antes de iniciar:
Na primeira parte já aprendemos bem como é o conceito para fazer um jogo online, agora iremos ver a parte pratica. Usaremos a 39Dll e o Game Maker 7 PRO.
É necessário saber GML em nível intermediário ou superior para completar o tutorial sem grandes dificuldades. Todo o código é explicado em maior parte direto nos comentários, apenas alguns detalhes são explicados fora do código.

Um novo projeto:
Para fazer o jogo, vamos precisar importar alguns scrips, mas como são vários e o Game Maker não importa eles separando por pastas vou disponibilizar um projeto com os scripts já prontos.

Primeiramente precisaremos desse pacote: Download [Contem: Projeto.gmk e 39Dll.dll]
Depois de baixá-lo, extraia para uma pasta qualquer. Serão extraídos dois arquivos:

Projeto.gmk: Projeto já iniciado contendo apenas as funções da 39Dll.

39Dll.dll: A DLL deve estar sempre acompanhada do executável do jogo, é nela que o jogo encontra as funções a serem executadas.

Abra o Projeto e de uma olhada nos scripts, são vários não é mesmo? A maioria nós nem iremos usar, mas não iremos apagar nenhum porque não sabemos se vamos precisar deles no futuro.

O menu:
Antes de qualquer coisa, vamos fazer um menu bem simples só para testar mesmo. Faça 2 objetos: obj_btmHost e obj_btmClient e crie uma sprite para cada um. Para isso você talvez queira saber o que eles farão então aqui vai uma pequena explicação:

obj_btmHost: Esse botão será usado para criar um Servidor, fazer um Host. Lembra da primeira aula? O Servidor é onde os jogadores conectam.

obj_btmClient: Agora ficou fácil, esse é o Client, ao clicar nesse botão será possível conectar em algum servidor.

Esses são apenas botões, não terão funções muito complexas. Antes de começarmos a adicionar código, crie mais 2 objetos (Esses não precisam de sprites) e marque-os como Persistent:
obj_Host
obj_Client


Vamos começar pelo botão de host:
Faça um evento “Mouse Left Released” e nele adicione um “Execute a piece of Code”.
Escreva o seguinte:

//Botão para fazer um Servidor
global.ServerName = get_string("Digite o nome do Servidor","");
instance_create(0,0,obj_Host);
Não tem muito segredo, é um código bem simples. Não vou explicar, pois se você não entendeu o que foi feito aqui você deve estudar mais GML antes de querer fazer um jogo online.
O botão do Client é praticamente a mesma coisa, só mude o código dele para o seguinte:

//Botão para conectar em um Servidor
global.connectIP = get_string("Digite o IP do Servidor","127.0.0.1");
instance_create(0,0,obj_Client);
Simples também.
Agora crie um outro objeto “Controlador” de sua preferência, eu gosto de chamá-lo de GAME (Deixe ele como Persistent). Nesse novo objeto, adicione um evento Create e coloque o seguinte código:

global.Nick = get_string("Digite seu Nick: ",""); //Pegar o nick do jogador
global.Server = 0; //Guarda o Socket do Servidor.
global.MyID = -1; //ID online do jogador
global.MaxPlayers = 0;

dllinit("39dll.dll",1); //Inicializar funções de Sockets da DLL.
O código junto dos comentários já está explicado, não vou entrar em mais detalhes aqui.
Feito isso coloque esse objeto na PRIMEIRA room do jogo, se você ainda não criou nenhuma, faça-o agora, vou usar ela como menu então a minha vai ter nome rm_Menu. O GAME deve ser o primeiro objeto a ser criado. Aproveite e monte o seu menu como quiser o meu ficou assim:



Já estamos prontos para iniciar a programar o Servidor.

Iniciando o Servidor:
Vamos para o objeto obj_Host. No evento Create adicione o seguinte:

//Criar servidor
global.Server = tcplisten(5068,5,1); //Inicializa o Servidor, fica em espera por conexões na porta 5068.
//Você pode mudar os argumentos dessa função como preferir.
//tcplisten(PORTA,CONEXÕES SIMUNTANEAS, MODO);
//PORTA -> Porta para conectar
//CONEXÕES SIMUNTANEAS -> Antes do jogador entrar mesmo no jogo, sua conexão deve ser aceita, enquanto isso ele ficara na "espera".
//Isso é para quantos você quer deixar na espera. Não é preciso um valor muito alto.
//MODO -> deixe o valor em 1, senão seu servidor ficará travado até alguem conectar

if (!global.Server) //Caso não tenha inicializado corretamente passar uma mensagem de erro.
{instance_destroy();
show_message("Erro ao criar o servidor");
exit;}

global.MaxPlayers = 10; //Limite de jogadores

//Criar lista de Jogadores.
for (i = 0; i < global.MaxPlayers; i += 1)
{
players[i,PL_SOCK] = -3; //Socket do player [Só usado no Host]
players[i,PL_NICK] = ""; //Nick do player
}

//Adicionar informações do servidor na lista [Servidor sempre é o 0]
players[0,PL_SOCK] = global.Server;
players[0,PL_NICK] = global.Nick;
global.MyID = 0;

room_goto(rm_WaitingRoom); //Depois de inicializar tudo corretamente ir para a tela de espera.
//Esse objeto é "Persistent", pois isso não será destruido na troca de rooms.
Comentei bastante o código para ficar fácil de entender. Mas temos que adicionar algumas Constantes ao nosso jogo, repare que ao criar a lista de jogadores foram usados os seguintes valores: PL_SOCK e PL_NICK, esses são Constantes e devem ser declarados para o Game Maker.
Vá em Global Game Settings, aba Constants. Insira os 3 valores da seguinte forma:
Name (Nome) Value (Valor)
PL_NICK 1
PL_SOCK 0

Muito bem, o evento Create está completo.


Conectando no Servidor:
Vamos para o obj_Client para iniciar a conexão, no Create coloque o código:
global.Server = tcpconnect(global.connectIP,5068,1);

if (!global.Server) //Se não conectarmos sair e exibir mensagem de erro
{instance_destroy();
show_message("Erro ao conectar");
exit;}

room_goto(rm_WaitingRoom);
Esse é bem curto, apenas conectamos no servidor e verificamos se foi possível a conexão. Se conectar vamos para a próxima tela, senão ficamos por aqui e exibimos uma mensagem de erro.


A estrutura de uma mensagem:
Antes de seguirmos para o próximo item, é preciso saber como é a estrutura das mensagens trocadas entre Client e Servidor. Na verdade é muito simples, mas sempre varia de mensagem para mensagem. A estrutura básica é assim:

Primeiros dois bytes = Tamanho da mensagem em bytes.
Terceiro byte = ID da mensagem. Serve para identificar qual o tipo de mensagem é essa, para que possamos manipulá-la corretamente.
Restantes = “Mensagem”.

Vamos ver um exemplo em que eu envio uma String “Testando” que tem ID de mensagem 5:

clearbuffer(); //Limpa o buffer interno, aqui é como uma Carta que vamos enviar, primeiro precisamos de um papel em branco, não é?
writebyte(5); //ID
writestring(“Testando”); //Mensagem
sendmessage(SOCKET); //Envia a mensagem para o Socket

Ué, mas cade os dois primeiros bytes de tamanho?
Esses são adicionados automaticamente pela DLL. Você não precisa se preocupar com eles.

Mas eles não são inúteis? Vou usar eles só para deixar a mensagem maior?
2 Bytes é pouca coisa, eles não vão te atrapalhar, eles também são lidos automaticamente. Se você acha que esses 2 bytes vão causar lags, está enganado. Esses bytes são necessários, é com eles que a DLL pode saber qual é o tamanho da mensagem para poder escrevê-la no buffer (Para podermos manipular depois). Imagine a mensagem recebida:

[Tamanho Total = 11 bytes]
Byte1 Valor: 9 (11 bytes contando esses 2, mas para o buffer eles não são contados)
Byte2

Os seguintes são carregados no buffer:
Byte3 ---- Valor: 5
Byte4 até Byte 11 ---- Valor: “Testando”

Nosso buffer ficaria assim:
Byte1 = 5
Byte2 = T
Byte3 = e
Byte4 = s
Byte5 = t
Byte6 = a
Byte7 = n
Byte8 = d
Byte9 = o

A leitura do buffer seria dessa forma:
IDdaMensagem = readbyte(); //Le o primeiro byte
Mensagem = readstring(); //Le todo o resto

No final teríamos os valores:
IDdaMensagem = 5
Mensagem = “Testando”

Ao usar o readbyte, readshort ou qualquer outra função de leitura os bytes são lidos e RETIRADOS do buffer (As funções retornam esses bytes removidos do buffer).
Então em muitos casos é preciso guardar esses bytes em alguma variável, mesmo que temporária.


Aceitando novas conexões:
Para aceitar novas conexões não é muito difícil, o código é bem curto. Vamos para o evento Step do objeto obj_Host e adicione o seguinte código:
//Aceitar novas conexões
var i, sock, newPL;
sock = tcpaccept(global.Server, 1);
if (!sock) //Se não existirem novas conexões
{exit;} //sair do script

for (i = 0; i < global.MaxPlayers; i+=1)
{
if (!players[i,PL_SOCK])
{
newPL = i;
break;
}
}

if newPL //Tem vagas no servidor
{
players[newPL,PL_SOCK] = sock;

//Enviar uma mensagem para o jogador, falando que ele foi aceito
clearbuffer(); //Limpar o buffer
writebyte(MSG_CONEXAO_ACEITA); //Byte identificador da mensagem
writebyte(newPL); //Enviar o ID do jogador
writebyte(global.MaxPlayers); //Enviar quantidade maxima de jogadores
sendmessage(sock); //Enviar mensagem
}
else //Servidor cheio
{
//Enviar uma mensagem para o jogador, falando que o servidor já está cheio e ele não pode se conectar.
clearbuffer(); //Limpar o buffer
writebyte(MSG_SERVIDOR_CHEIO); //Byte identificador da mensagem
sendmessage(sock); //Enviar mensagem

closesocket(sock);
}
Esse código é um pouquinho mais complicado. Agora nós recebemos a conexão do jogador e se houver espaço no servidor permitimos que ele entre, caso contrário enviamos uma mensagem falando que o servidor está cheio e terminamos a conexão com ele.
Note que aqui temos mais duas constantes:
MSG_CONEXAO_ACEITA
MSG_SERVIDOR_CHEIO

Crie elas também, os valores você que escolhe, mas eles NÃO podem ser maiores que 255 nem menores do que 0! Ou seja, são valores entre 0 e 255. Perceba que essas constantes tem um prefixo diferente das outras duas, elas começam com um “MSG_”, fizemos isso para identificar o tipo de uso para ela. Então para identificar as mensagens vamos usar constantes com prefixo MSG_. Logo não faz diferença se elas possuem o mesmo valor de outra constante, contando que não seja uma constante do tipo MSG_. Criei as minhas assim:
Nome Valor
MSG_CONEXAO_ACEITA 0
MSG_SERVIDOR_CHEIO 255

Recebendo as mensagens iniciais:
Ok, agora precisamos programar para o Client receber as mensagens do servidor, no evento Step do obj_Client coloque o seguinte:
//Receber mensagens do servidor
var size, msgID;
size = 1;

while (size)
{
size = receivemessage(global.Server); //Retorna a quantidade de bytes recebidos

if (!size) //Se não recebermos nada, sair desse script.
{exit;}

msgID = readbyte(); //Lemos o primeiro byte da mensagem, ou seja o ID da mensagem.

switch (msgID)
{
case MSG_CONEXAO_ACEITA: //Fui aceito no servidor
global.MyID = readbyte(); //Pegamos o meu ID
global.MaxPlayers = readbyte(); //Lemos a quantidade de jogadores maxima no servidor

//Criar lista de Jogadores.
for (i = 0; i < global.MaxPlayers; i += 1)
{
//players[i,PL_SOCK] = -3; //Socket do player [Só usado no Host]
players[i,PL_NICK] = ""; //Nick do player
}
players[global.MyID,PL_NICK] = global.Nick;

//Para dar continuidade agora vamos enviar o meu nick para o servidor
//e ele retornara com o nick de todos os jogadores
clearbuffer();
writebyte(MSG_PLDATA);
writestring(global.Nick);
sendmessage(global.Server);
break;

case MSG_SERVIDOR_CHEIO:
closesocket(global.Servidor); //Fechamos a conexão
show_message("Servidor lotado"); //Exibimos o erro
instance_destroy();
room_goto(rm_Menu); //Voltamos para o menu
exit;
break;
}
}
Lembre-se de adicionar a constante: MSG_PLDATA.
Agora já temos o sistema inicial pronto, agora é só troca de mensagens. Ainda precisamos fazer para o Servidor receber as mensagens, mas é bem parecido com o sistema do Client, possui apenas algumas mudanças.

Recebendo as mensagem do Client:
Para receber as mensagens do client vamos usar o obj_Host, no step adicione outro execute a piece of code, para não deixar o primeiro muito comprido e facilitar a procura de partes especificas no código depois se for necessário.
Assim como o do client, adicionando apenas um loop for e editando a mensagem recebida como necessário:
//Receber mensagens do Client
var size, msgID;

for (iPL = 1; iPL < global.MaxPlayers; iPL += 1) //Precisamos receber a mensagem de cada jogador
{ //Usamos "iPL" pois depois serão feitos outros loops e usar a variavel "i" pode gerar conflitos
size = 1;
while (size)
{
size = receivemessage(players[iPL,PL_SOCK]); //Receber a mensagem do socket de cada player

if (!size) //Se não recebermos nada, sair desse script e passar para o próximo player
{break;}

msgID = readbyte(); //Lemos o primeiro byte da mensagem, ou seja o ID da mensagem.

switch (msgID)
{
case MSG_PLDATA: //Pegar dados do jogador
var nick;
nick = readstring(); //Ler o nick do jogador.

//Agora guardamos o nick na variavel do jogador:
players[iPL, PL_NICK] = nick;
//Não precisamos guardar o ID porque isso já foi feito quando ele se conectou!

//Agora vamos repassar para os outros jogadores:
clearbuffer();
writebyte(MSG_PLDATA);
writebyte(iPL); //Os outros jogadores só recebem dados do servidor, então precisam saber o ID de qual player são esses dados
writestring(nick);
for (i=1; i < global.MaxPlayers; i+=1) //Como são varios jogadores, precisamos enviar para todos eles
{ //Usando um loop for isso fica bem facil! Repare que começamos do 1, porque o 0 é sempre o servidor.
if (i != iPL) //Não precisamos repassar a mensagem para quem a enviou
{sendmessage(players[i,PL_SOCK]);}
}

//O Hoster possui os dados de todos os jogadores então ele mesmo pode repassar os nicks dos demais players
for (i = 0; i < global.MaxPlayers; i += 1)
{
if (i != iPL) //Não enviar o nick do proprio jogador para ele mesmo
{
clearbuffer();
writebyte(MSG_PLDATA);
writebyte(i);
writestring(players[i,PL_NICK]);
sendmessage(players[iPL,PL_SOCK]);
}
}
break;
}
}
}
Agora precisamos fazer os Clients receberem essa mensagem, vamos voltar para o obj_Client e adicionar uma outra mensagem a ser recebida, dessa vez vou passar apenas a parte que será adicionada:

case MSG_PLDATA:
players[readbyte(), PL_NICK] = readstring();
break;

Esse é bem curto, não é? Acho que nem precisamos de explicação. Apenas pegamos o ID de quem enviou a mensagem e usamos o valor na posição da array, depois lemos o Nick enviado par atribuir o valor na array.

A partir desse momento já são recebidos todos os dados de cada jogador e a base está pronta. Vamos adicionar um evento Draw no objeto GAME apenas para visualizar a lista e testarmos o código:

if room = rm_WaitingRoom
{
draw_text(200,16,"Tela de Espera");
}

if instance_exists(obj_Client)
{
for (i=0; i < global.MaxPlayers; i += 1)
{
draw_text(5,32+i*16, string(i)+" "+obj_Client.players[i,PL_NICK]);
}
}
else if instance_exists(obj_Host)
{
for (i=0; i < global.MaxPlayers; i += 1)
{
draw_text(5,32+i*16, string(i)+" Sock: "+string(obj_Host.players[i,PL_SOCK])+" Nick: "+obj_Host.players[i,PL_NICK]);
}
}

Para testar, crie o executável do jogo, copie ele e a DLL para outra pasta, de forma que você tenha duas cópias do jogo. Abra as 2, em cada uma você coloca um Nick diferente, em uma das telas você Cria um servidor, na outra Conecta com o IP 127.0.0.1.
Se tudo correr bem você verá uma lista nas duas telas, na do servidor contendo o valor do socket e Nick de cada jogador, na do client uma lista contendo apenas os Nicks. Se você recebeu algum erro, volte o tutorial e confira todos os códigos novamente.


Vou terminar essa aula por aqui. Na próxima colocaremos um chat e um botão na sala para começarmos o “jogo”, que será apenas um circulo de cada jogador se movendo pela tela. Finalizando o tutorial por completo.

Recomendo que você leia as descrições das funções dos scripts Buffer -> Writing e Reading. Para entender melhor como funciona cada um dos tipos de dados.

Você não vai postar uma engine do tutorial?
Não! Se eu postar uma engine a grande maioria irá apenas baixá-la e editar como quiser. Postando apenas o tutorial vocês terão que ler para fazer a engine! Assim sei que meu tempo para escrever o tutorial não foi desperdiçado e vocês aprenderão muito mais.
Se você seguir o tutorial a risca, não terá problemas para fazer a mesma engine que eu fui fazendo conforme escrevia o tutorial. Está tudo explicado passo a passo, exatamente da forma que eu fiz.

Eu não entendi o que ele falou.
Tem que explicar melhor, nem sempre as pessoas entendem todas essas coisas dificeis. Explicar melhor é a chave pra fazer coisas decentes.

Minha nota ao tutorial é acima da média: 5.5, porque pode ter gente que entende melhor.

Tenha um bom dia.
Nizzio

Muito bom seu tutorial, esclareceu algumas duvidas minhas, eu nao sabia que uma string escrevia bytes para cada letra... muito bom mesmo!
Vai ter mais alguma parte?

Obs: Boa iniciativa de nao colocar a engine.

FLW

F. Nizzio escreveu:Eu não entendi o que ele falou.
Tem que explicar melhor, nem sempre as pessoas entendem todas essas coisas dificeis. Explicar melhor é a chave pra fazer coisas decentes.

Minha nota ao tutorial é acima da média: 5.5, porque pode ter gente que entende melhor.

Tenha um bom dia.
Nizzio

Amigo, este é um assunto avançado e requer que a pessoa não tenha dúvidas em nenhuma parte da engine do Game Maker para entende-lo. Tente ler novamente que você vai entender.

Ae JanX! Eu já vinha esperando esse tutorial a um bom tempo! Ficou muito fácil de ser entendido e muito bem explicado. E o fato de você não ter postado uma engine pronta é ótimo pois força a pessoa a realmente entender o funcionamento para criar sua própria engine. Excelente!

cara, parabéns.
ótimo tutorial!!!!
não sei se foi de propósito, mas acho que achei uma "pegadinha" no meio dos scripts, um espaço em branco, se o cara não ler a engine, ele vai postar o erro.
algo que só quem usar o switch, ou sabe como funciona, ou é inteligente vai perceber.

tutorial ficou muito bom, Janx estou esperando pelo tuto III!!!
finalmente um tutorial para dll 39 em português.

otima minha engine ficou otima adorei seus tutorial agora vou fazer meu jogo online com mais facilidade

como eu crio uma constante no gm 8 pro?
EDIT
ja descobri

Para fazer constantes do GM8 vá em Resources -> Define Constants
Ou simplesmente pressione shift+ctrl+N

Obrigado pelos comentários!

@CogumeloDoRock
Não fiz nada proposital assim... Mas sabe que não é má ideia?

@F. Nizzio
Esse é um tutorial avançado, como eu já disse. Leia o comentário do primeiro código desse tutorial .

@Super Games
Você está tentando abrir a DLL como um arquivo qualquer? Porque não é isso que você deve fazer... Uma dll não funciona assim.

--
A parte III vai, infelizmente, demorar um pouco para sair. Só no próximo mês. Mas a partir dessa aula vocês já tem uma base para fazer algo sozinhos! Tentem fuçar um pouco!

Voce nao tem que abrir a DLL.
Somente o jogo.

E nao precisa criar um exe, basta selecionar em File - Preferencias - E desmarcar a opcao Hidden designer (algo assim).

Ai voce clica em testar para abrir o jogo e depois testar para abrir outro.

O jogo que abrira a Dll, nem precisa mecher no arquivo.

FLW

1-você fala para adicionar a constante MSG_PLDATA, mas não fala o valor...

2-você manda por o seguinte código no obj_Client:

Código:

case MSG_PLDATA:
    players[readbyte(), PL_NICK] = readstring();
break;


mas não fala em que evento

Ola Janx, eu segui seu tuto e esta dando os seguintes erros, se nao for pedir muito tem como me ajudar?
Um Abraço e excelente tutorial
__________________________________________
ERROR in
action number 2
of Create Event
for object obj_Client:

Error in code at line 1:
case MSG_PLDATA:
^
at position 6: Case statement only allowed inside switch statement.

___________________________________________
ERROR in
action number 1
of Create Event
for object obj_Host:

Error in code at line 20:
players[i,PL_SOCK] = -3; //Socket do player [Só usado no Host]
^
at position 12: Unknown variable PL_SOCK

allanjau, leia o tutorial, ele está explicando o que fazer com a PL_SOCK.

carot:
isso vc deve adicionar no switch abaixo.

switch (msgID)
{
case MSG_CONEXAO_ACEITA: //Fui aceito no servidor
global.MyID = readbyte(); //Pegamos o meu ID
global.MaxPlayers = readbyte(); //Lemos a quantidade de jogadores maxima no servidor

//Criar lista de Jogadores.
for (i = 0; i < global.MaxPlayers; i += 1)
{
//players[i,PL_SOCK] = -3; //Socket do player [Só usado no Host]
players[i,PL_NICK] = ""; //Nick do player
}
players[global.MyID,PL_NICK] = global.Nick;

//Para dar continuidade agora vamos enviar o meu nick para o servidor
//e ele retornara com o nick de todos os jogadores
clearbuffer();
writebyte(MSG_PLDATA);
writestring(global.Nick);
sendmessage(global.Server);
break;

case MSG_SERVIDOR_CHEIO:
closesocket(global.Servidor); //Fechamos a conexão
show_message("Servidor lotado"); //Exibimos o erro
instance_destroy();
room_goto(rm_Menu); //Voltamos para o menu
exit;
break;
}

carotmaker escreveu:1-você fala para adicionar a constante MSG_PLDATA, mas não fala o valor...

2-você manda por o seguinte código no obj_Client:

Código:

case MSG_PLDATA:
    players[readbyte(), PL_NICK] = readstring();
break;


mas não fala em que evento

1-

Crie elas também, os valores você que escolhe, mas eles NÃO podem ser maiores que 255 nem menores do que 0! Ou seja, são valores entre 0 e 255. Perceba que essas constantes tem um prefixo diferente das outras duas, elas começam com um “MSG_”, fizemos isso para identificar o tipo de uso para ela. Então para identificar as mensagens vamos usar constantes com prefixo MSG_. Logo não faz diferença se elas possuem o mesmo valor de outra constante, contando que não seja uma constante do tipo MSG_. Criei as minhas assim:
...

O valor das constantes não é muito importante (ele só não pode ser igual a outra constante usada para a mesma finalidade [no caso, identificar as mensagens]). Só usamos constantes para ficar mais fácil LER e ENTENDER o código. Imagine se só fossem usados valores como 0 e 255 no lugar das constantes "MSG_CONEXAO_ACEITA" e "MSG_SERVIDOR_CHEIO". Usando apenas essas duas até fica facil lembrar o que cada valor significa, mas quando o seu jogo/programa/projeto ficar maior provavelmente vai ter mais de 30 tipos diferentes de mensagens, quem sabe muito mais. Decorar tudo não é tão fácil. Errar o valor = BUGS. Usando constantes fica fácil lembrar o nome e a função do valor (apesar que não precisamos saber o valor, apenas o nome da constante).

2-
No unico lugar onde o client recebe as mensagens!

Agora precisamos fazer os Clients receberem essa mensagem, vamos voltar para o obj_Client e adicionar uma outra mensagem a ser recebida:

Recebendo as mensagens iniciais:
Ok, agora precisamos programar para o Client receber as mensagens do servidor, no evento Step do obj_Client coloque o seguinte:

@allanjau
Você criou as constantes?

Você está colocando o código
case MSG_PLDATA:
players[readbyte(), PL_NICK] = readstring();
break;

NO CREATE? Não é ai que ele fica...
"case" é usado em SWITCH. Basta ler o erro.

@Super Games
Você não tem que fazer nada com a DLL, só deixar ela na pasta do jogo. A dll é carregada pelo script "dllinit".


Acho que vocês precisam estudar um pouco mais sobre GML / Lógica de programação antes de seguirem o tutorial! Estão cometendo alguns erros básicos.

vlwww Janx sabia que estava esquecendo algo muito obrigado, vlw cogumelo pela help.

Kra, eu amo tutoriais de Gm online, sempre quis fazer um jogo que tivesse tantos assesos quanto um Tibia.

pena q eu tenho gm8 Lite

mas tudo bem,
quando eu comprar o pró, eu vou usar esse tuto, sempre quis um tuto com 39Dll

Janx escreveu:

carotmaker escreveu:1-você fala para adicionar a constante MSG_PLDATA, mas não fala o valor...

2-você manda por o seguinte código no obj_Client:

Código:

case MSG_PLDATA:
    players[readbyte(), PL_NICK] = readstring();
break;


mas não fala em que evento

1-

Crie elas também, os valores você que escolhe, mas eles NÃO podem ser maiores que 255 nem menores do que 0! Ou seja, são valores entre 0 e 255. Perceba que essas constantes tem um prefixo diferente das outras duas, elas começam com um “MSG_”, fizemos isso para identificar o tipo de uso para ela. Então para identificar as mensagens vamos usar constantes com prefixo MSG_. Logo não faz diferença se elas possuem o mesmo valor de outra constante, contando que não seja uma constante do tipo MSG_. Criei as minhas assim:
...

O valor das constantes não é muito importante (ele só não pode ser igual a outra constante usada para a mesma finalidade [no caso, identificar as mensagens]). Só usamos constantes para ficar mais fácil LER e ENTENDER o código. Imagine se só fossem usados valores como 0 e 255 no lugar das constantes "MSG_CONEXAO_ACEITA" e "MSG_SERVIDOR_CHEIO". Usando apenas essas duas até fica facil lembrar o que cada valor significa, mas quando o seu jogo/programa/projeto ficar maior provavelmente vai ter mais de 30 tipos diferentes de mensagens, quem sabe muito mais. Decorar tudo não é tão fácil. Errar o valor = BUGS. Usando constantes fica fácil lembrar o nome e a função do valor (apesar que não precisamos saber o valor, apenas o nome da constante).

2-
No unico lugar onde o client recebe as mensagens!

Agora precisamos fazer os Clients receberem essa mensagem, vamos voltar para o obj_Client e adicionar uma outra mensagem a ser recebida:

Recebendo as mensagens iniciais:
Ok, agora precisamos programar para o Client receber as mensagens do servidor, no evento Step do obj_Client coloque o seguinte:

@allanjau
Você criou as constantes?

Você está colocando o código
case MSG_PLDATA:
players[readbyte(), PL_NICK] = readstring();
break;

NO CREATE? Não é ai que ele fica...
"case" é usado em SWITCH. Basta ler o erro.

@Super Games
Você não tem que fazer nada com a DLL, só deixar ela na pasta do jogo. A dll é carregada pelo script "dllinit".


Acho que vocês precisam estudar um pouco mais sobre GML / Lógica de programação antes de seguirem o tutorial! Estão cometendo alguns erros básicos.

Deu este error:

___________________________________________
ERROR in
action number 2
of Step Event
for object obj_Client:

Error in code at line 1:
case MSG_PLDATA:
^
at position 6: Case statement only allowed inside switch statement.