Cela fait pas mal de temps que je n’ai plus publié de tutoriaux, eh oui… Je les garde pour moi en général, mais cette fois j’ai décidé d’en publier un. En effet à la suite d’un cours que j’ai donné à un haut dignitaire de la communauté (c’est bon j’arrête J), j’ai décidé de reprendre le produit de ce cours et d’en faire un cours sur papier, ou sur pixel…
En fait j’ai été appelé à expliquer le multi et j’ai donc en même temps que j’expliquai écrit un petit jeu de plateforme multi joueurs, que j’ai ensuite corrigé avec mon « élève » (Outch ! ça fait vieux dit ainsi.). Je vous propose de vous donner le même cours dans la même suite d’évènement et en expliquant chaque script. J’ajouterai également une partie sur les routeurs de type NAT, car nous avons été contraints de configurer le sien pour qu’il puisse jouer en tant que client, car avec un routeur c’est trop lent pour faire serveur. A bas les routeurs !
Sommaire :
I) Créons et Expliquons un Jeu de Plateforme Multijoueur.
1) Script de Connexion
2) Script de Création des Joueurs
3) Script de Maintenance, le cœur du Multijoueur
II) Les routeurs de type NAT et comment leur permettre de jouer avec des jeux Game Maker.
I) Créons et Expliquons un Jeu de Plateforme Multijoueur.
|
Légende: |
Le
but de ce
tutorial est avant tout d’expliquer comment faire un jeu multijoueur,
la
programmation est une science appliquée nous passerons donc par-dessus
la
théorie. Ce tutorial s’adresse donc aux philistins cartésiens et
pragmatistes
(un triple pléonasme ma parole !).
Bon avant
toute chose veuillez démarrer Game Maker, mais aussi une musique qui
soit
motivante, une musique qui fait vibrer vos tripes et let go !
1) Script de Connexion
Dans un jeu multijoueur la première chose qu’on fait c’est se connecter, nous allons donc tout d’abord réaliser le script de connexion, il faut dans ce script définir un serveur et un client, chez nous le serveur sera la personne qui créera la partie, le client celui qui s’y connectera.
Dans ce script il sera nécessaire de d’abord demander l’ip que l’on voudra utiliser, celui qui créera la partie entrera sa propre ip, celui qui la joindra entrera l’ip de celui qui l’a créée. On peut connaître son ip en exécutant : cmd dans Windows puis en entrant : ipconfig /all, cependant il nécessaire de faire attention si vous avez un routeur, l’ip qui va s’afficher sera celle que le routeur aura attribué à votre ordinateur dans le réseau local, nous verrons dans la section II comment régler ces problèmes de routeur. Si vous essayez le jeu en local, c'est-à-dire si vous comptez démarrer le client et le serveur sur votre propre PC afin de faire des tests il vous suffit de n’entrer aucune ip, ou alors pour être sûr : 127.0.0.1 . Qui est l’ip que l’on peut également nommer : localhost.
Après quoi ce script de connexion fera appel à la fonction : mplay_init_tcpip(ip), fonction qui initialise une connexion tcp/ip, et qui retourne si cela réussit ou non. Si cette fonction ne retourne pas 1, c'est-à-dire en booléen : true (vrai), il faudra afficher un message signifiant : connexion impossible, puis casser l’exécution du script avec : break. Autrement si cette fonction renvoie true, il faudra demander le nom du joueur, que nous stockerons dans : global.name pour ce tutorial ce ne sera pas nécessaire de le demander, c’est pourquoi nous lui donnerons la chaîne : "onsenfout" comme valeur.
!Note : Un bug récurrent de
Game Maker
fait que si une connexion est ratée, ensuite pendant tout le temps que
l’exécution du programme se fera plus aucune connexion ne réussira, il
faut
donc redémarrer le jeu dans le cas où la connexion ne fonctionne pas du
premier
coup.
Ensuite nous ferons appel à la fonction : mplay_session_find(), cette fonction retourne le nombre de session sur cette adresse ip qui accepte encore des joueurs, si le résultat de l’appel de cette fonction est égal à 0, c'est-à-dire qu’il n’existe pas une session, ou du moins pas une session de libre sur cette ip. Nous exécuterons alors la fonction : mplay_session_create(sesname,playnumb,playername), cette fonction créera donc une session du nom de sesname, avec un maximum de playnumb joueurs et qui assignera le nom : playername au joueur qui créera cette session. Playername sera en fait chez nous : global.name.
Toujours dans la même structure nous regarderons combien de joueurs sont en ligne, en toute logique c’est 1, pour ce faire nous utiliserons la fonction : mplay_player_find(), qui retourne le nombre de joueur connectés à la session en cours. Nous stockerons le résultat dans : global.number. Cela permet ainsi de définir qui est le joueur 1, puis nous verrons ensuite que cela permet aussi de voir qui est le joueur 2, et cela irait pour un nombre infini de joueurs.
Après
quoi dans cette même structure nous définirons l’id de l’objet qui sera
celui
du joueur 1, nous enverrons dans le slot 51 cette valeur ainsi : mplay_data_write(51,obj_jo_1);. Cela écrit donc dans le
slot 51
l’id de l’objet obj_jo_1.
Pourquoi le
slot 51 ? C’est un choix arbitraire, étant donné qu’il y a 1000000
de
slots on peut se permettre d’espacer les choses. Nous garderons donc
les slots
allant de 51 à 99 inclus pour le nom des joueurs (dans le tutorial vous
n’aurez
besoin que de 51 et 52, mais si vous le continuez vous pourriez bien en
avoir
besoin de plus). Ceux de 0 à 50 pour tout ce qui est fonctions
d’administration
et enfin pour chaque joueur nous utiliserons de 100 à 199 pour le
joueur 1, de
200 à 299 pour le joueur 2 etc.
Ne vous inquiétez pas nous n’en ferons usage que d’une dizaine pour
chacun des
joueurs, ce n’est que pour se donner de la marge afin que vous puissiez
continuer le résultat de ce tutorial par la suite.
Revenons
à mplay_session_find(), si au
contraire cette
fonction retourne autre chose que 0, au moins 1, alors cela signifiera
que la
personne qui exécute le script est celle qui joint la session, donc
nous
utiliserons : mplay_session_join(mplay_session_name(0),global.name);.
Cette fonction permet donc de se joindre à la session du nom de mplay_session_name(0), c'est-à-dire à la
session
numéro 0, la première, avec le nom de joueur global.name.
Après
quoi dans la même structure nous ferons appel à nouveau à :
global.number
= mplay_player_find();.
Afin de définir quel joueur est en train de se connecter et ainsi de
définir
l’id de l’objet de ce dernier dans un des slots entre 51 et 99. Si global.number
est égal à 2, nous écrirons ainsi dans le slot 52 : mplay_data_write(52,obj_jo_2);. Enfin nous fermerons la
structure.
!Note : Pour que la connexion se fasse entre deux jeux Game Maker il faut qu’ils aient le même Game ID, autrement les deux exécutables ou fichiers sources ne pourront se connecter l’un à l’autre.
Cela nous donnera un code tel que celui-ci :
Listing 1 : scr_connexion();
|
ip = get_string("Ip:","127.0.0.1");
if (mplay_init_tcpip(ip) != 1) { show_message("Connexion Impossible."); break;} else {global.name = "onsenfout"}
if (mplay_session_find() == 0) { mplay_session_create("Ex1",2,global.name); global.number = mplay_player_find(); mplay_data_write(51,obj_jo_1); } else { mplay_session_join(mplay_session_name(0),global.name); global.number = mplay_player_find(); if global.number = 2 { mplay_data_write(52,obj_jo_2); } } |
2) Script de Création des
Joueurs
Cela fait
il est temps de nous atteler au script de création des joueurs.
Ce script permet à tout moment de créer les joueurs dans le jeu,
c'est-à-dire
ceux qui se connectent, il est donc nécessaire qu’il soit exécuté en
permanence
dans draw, ou dans step.
Il est
très simple, on reprend la valeur des slots de 51 à 99 et si cette
valeur
vérifiée avec instance_number est inférieure à 1 on crée l’objet en
question.
Il ne gère cependant pas la destruction des objets lors de la
déconnexion, mais
si on voulait le faire il suffirait de mettre dans l’évènement room end, une ligne telle que
celle-ci :
|
with (mplay_data_read(50+global.number)) instance_destroy(); mplay_data_write(50+global.number,obj_noone); |
Ainsi l’objet serait détruit et le script que nous sommes en train
d’expliquer
ne créerait plus rien que l’objet obj_noone,
serait un objet que nous aurions préalablement créé et mit dans la
room. Ne
confondez cependant pas avec l’objet : noone, qui a un id
de -4 et
qui signifie : pas d’objet.
Le code de création des objets serait donc ainsi :
Listing 2 : scr_jo_create();
|
//Création Joueur 1 p1 = mplay_data_read(51); if instance_number(p1) < 1 { instance_create(obj_spawn.x,obj_spawn.y,p1); }
//Création Joueur 2 p2 = mplay_data_read(52); if instance_number(p2) < 1 { instance_create(obj_spawn.x,obj_spawn.y,p2); } |
L’objet obj_spawn est un objet
vide, c’est simplement
un marqueur définissant où, en quel x et y il faut créer les objets
joueurs.
3) Script
de Maintenance, le cœur du Multijoueur
Avant de passer au code central du multi, c'est-à-dire celui de
synchronisation
des données des joueurs, nous allons créer les objets nécessaire, et
justement
les objets joueurs en eux-mêmes.
Comme vous avez pu le remarquer nous avons codé de façon à ce que les
objets de
chaque joueur soient des objets différents, c’est un choix fait pour
simplifier
les explications, mais rien n’empêche de prendre un seul objet pour
chaque
joueur et d’y mettre des variables fluctuantes, c’est d’ailleurs mieux
pour
gagner de la place dans le jeu final et du temps en développement, par
contre
si vous écrivez un tutorial à propos, évitez. J’en ferai un, un jour
qui
prendra en compte cela, mais pour le moment j’ai assez de mal à ne pas
m’empêtrer dans des explications complexes qui ne peuvent être
comprises que
par celui qui l’énonce, car il ne sait comment clarifier les choses.
Ces 4
dernières lignes en sont une preuve. :D
Par exemple pour la programmation de jeux tels que les mmorpg on n’a
besoin que
de deux objets, un objet joueur et un autre que l’on nomme en
général : dummy,
c’est en fait le représentant de tous les autres objets synchronisés en
multi
par les autres joueurs. Ainsi pour dummy on peut ne synchroniser que
les
données importantes et en créer des milliers d’instances qui se
comporterons
chaque fois de la façon de l’objet joueur de chaque ordinateur connecté
à qui
elles sont attribuées. Un peu complexe, pour mieux comprendre référez
vous à
l’exemple de SleepinJohnnyFish
du GM6_Pack_4.
Bien, il est temps de créer les objets en question, avant cela faites
donc des sprites,
faites des sprites de sphère de 16x16 du nom de spr_jo_1
et spr_jo_2,
chacun d’une autre
couleur. Faites un bloc de 32x32 du nom de spr_dec_bloc.
Et enfin un projectile de 6x6 du nom de : spr_projectile.
Ensuite
faites 7 objets : obj_connexion,
dans lequel vous allez faire exécuter le script : scr_connexion(); dans l’évènement create.
Puis l’objet : Ynit,
dans lequel
vous mettrez un évènement create contenant : mplay_data_mode(false);
Ce qui signifie que les données seront envoyées en mode non garanti
durant le
jeu, c’est moins sûr, c’est pourquoi nous le faisons après l’objet obj_connexion, mais c’est
extrêmement plus
rapide qu’en mode garanti. Dans draw nous ferons exécuter le
script : obj_jo_create();
et dans Keyboard Press
Enter:
execute_string(get_string("Code:",""));
Il est
toujours utile
de pouvoir déboguer le programme en pleine exécution.
Ensuite
l’objet obj_spawn,
que nous avons déjà
abordé et qui n’est qu’un marqueur, vous le laisserez donc ainsi.
Suivi de l’objet : obj_dec_bloc,
à qui vous donnerez le sprite que vous avez créé et vous le réglerez
en : solid.
Vous ferez également l’objet obj_projectile,
même chose donnez lui son sprite mais laissez le ainsi.
Passons
aux objets centraux, qui sont : obj_jo_1
et obj_jo_2, ils
seront exactement
pareils, simplement dans l’évènement step vous veillerez à ce que
chacun ait son script à exécuter, script que
nous allons bientôt écrire, pour obj_jo_1 :
scr_update_jo_1();
et
évidemment pour obj_jo_2 :
scr_update_jo_2();
Donc
dans create de l’obj_jo_1 et 2 vous
mettrez ce
code-ci :
|
Vie = 100; score_kill = 0; selected_weapon = "pistol"; //Pistolet cadence_pistol = 0; munition_pistol = 60; |
Il déclare les variables de Vie du joueur, le score du nombre de tués,
l’arme
sélectionnée, et des variables qui vont nous servir pour la cadence et
les
munitions de l’arme. Toutes ces variables vont être utile dans les
scripts
principaux : scr_update_jo. Vous
verrez alors l’utilité de ces variables.
Vous
créerez un évènement : Alarm[0], dans
lequel vous
mettrez la variable cadence_pistol à 0.
Enfin dans step vous
règlerez la
gravité à l’aide de ce code-ci :
|
gravity_direction = 270; if place_free(x,y+1) gravity=0.5; if not place_free(x,y+1) gravity=0; if vspeed>12 vspeed=12; scr_update_jo_1(); |
Ce
code est
simple, il règle la direction de la gravité à chaque début de step, ensuite
si à x et y+1
il n’y a pas d’objet la gravité est réglée à 0.5 et si au contraire il
y a
quelque chose elle est mise à 0, enfin si sa vitesse verticale dépasse
12 pixel
alors elle est ramenée à 12. Ensuite le script principal : scr_update_jo_1(); est
exécuté.
Ensuite dans l’évènement de collision avec
l’objet : obj_dec_bloc insérez
les lignes qui suivent :
|
if (vspeed > 0 && not place_free(x,y+vspeed)) move_contact(270); vspeed = 0; |
Maintenant que cela est, passons au principal du tutorial, au code
central du
multi joueur, la gestion des joueurs et les synchronisations de leurs
valeurs.
Ce script va gérer aussi bien les déplacements et la gestion des
contrôles que l’écriture
dans les slots et leur lecture, le principe c’est que chaque
objet : obj_jo_1 et obj_jo_2 écrivent
les slots de
leurs joueurs et les lisent.
Par exemple, l’obj_jo_1 lorsque il est sur l’ordinateur du joueur 1, c'est-à-dire lorsque la variable global.number est égale à 1, alors il écrit dans les slots et l’on peut le guider, mais aussi et ce pour tous les ordinateurs ainsi que lui-même il lit les slots qu’il a écrit.
L’explication du script va clarifier ce principe, commençons :
Listing 3 : scr_update_jo_1();
|
//Script de maintenance pour obj_jo_1 if global.number = 1/*Début de if global.number*/ { if (keyboard_check(vk_left)) { x -= 3 } if (keyboard_check(vk_right)) { x += 3 }
if (keyboard_check(vk_up)) { if not place_free(x,y+1) vspeed = -12; } //Ecriture données { mplay_data_write(51,obj_jo_1); mplay_data_write(100,x); mplay_data_write(101,y); mplay_data_write(102,vspeed); mplay_data_write(105,"false"); mplay_data_write(107,Vie); mplay_data_write(108,score_kill); } /////Armes///// ////////////// //Pistolet if keyboard_check(vk_control) {
if selected_weapon = "pistol" { if cadence_pistol = 0 && munition_pistol > 0 {cadence_pistol = 1;alarm[0] = 13; munition_pistol -= 1; mplay_data_write(105,"true"); mplay_data_write(106,point_direction(x,y,mouse_x,mouse_y));} }
}
}/*Fin de if global.number A partir d'ici jusqu'à la prochaine execution du script on a fermé la possibilité à l'utilisateur: global.number d'agir sur quoi que ce soit! */
//Lecture données pour tout le monde, même celui qui a écrit ces données. x = mplay_data_read(100); y = mplay_data_read(101); vspeed = mplay_data_read(102); Vie = mplay_data_read(107); score_kill = mplay_data_read(108); //Armes du joueur //Pistolet if mplay_data_read(105) = "true" { with (instance_create(x,y,obj_projectile)) {motion_set(mplay_data_read(106),20);} }
//Dommages pouvant être causés aux joueurs if place_meeting(x,y,obj_projectile) { Vie -= 5 }
//Vie du Joueur if Vie <= 0 { Vie = 100; score_kill -= 1; mplay_data_write(125,"killed");//On envoie à l'autre que le J1 est mort pour augmenter son score_kill. Non réalisé dans ce tutorial. x = obj_spawn.x; y = obj_spawn.y; } |
Lisez le
script avant tout.
La première structure principale composant le code, marquée par : Début
de if global.number et Fin
de if global.number.
Comporte tout d’abord trois sous structure qui permettent à celui chez qui la valeur global.number est égale à 1, c'est-à-dire celui qui a créé la session, d’influer directement sur les déplacement de l’objet.
Après quoi on écrit toutes les données relatives aux déplacements, dans la fourchette de slot que nous nous sommes alloués pour le joueur 1 :
|
//Ecriture données { mplay_data_write(51,obj_jo_1); mplay_data_write(100,x); mplay_data_write(101,y); mplay_data_write(102,vspeed); mplay_data_write(105,"false"); mplay_data_write(107,Vie); mplay_data_write(108,score_kill); } |
On écrit donc ces valeurs 30 fois par step (si on
laisse le nombre de FPS à 30), la valeur 105 est
remise à "false" à chaque
étape, elle va nous servir pour les tirs, vous
allez la comprendre sous peu.
Ensuite vient donc la gestion des tirs, si la touche control est
pressée, et si
l’arme choisie est le pistolet alors si la cadence le permet et qu’il
reste des
munitions, bloquer la cadence, ne la réautoriser que dans 13 étapes,
enlever
une munition et écrire dans le slot 105 que l’on est en train de tirer,
puis
dans le slot 106 la direction dans laquelle on tire.
Fin de la
structure if global.number.
Ce qui suit est donc exécuté chez tout le monde, même chez le joueur 1,
d’ailleurs sans cela les projectiles ne seraient pas créés chez lui. On
lit
donc la valeur x, la valeur y etc. de l’objet. Ensuite vient le
problème des
armes, il est simple (comme tout ce tutorial).
Si la
valeur 105 est sur true, c’est donc que celui qui a la
valeur de global.number à 1 a pressé sur Control et qu’il avait l’arme
pistolet
de sélectionné. (Vous pourriez d’ailleurs faire plusieurs armes, et les
différencier en faisant écrire dans le slot 105:
« trueM4 » par
exemple.)
Comme la valeur 105 est true, alors on va créer le projectile chez tout
le monde
étant donné qu’on est au dehors de la structure if global.number,
et lui
donner la direction que le joueur 1 avait définie. Vous allez
dire :
« Mais le joueur va tirer éternellement ? »
Eh bien non, car justement nous avons définie que 30 fois pas step, le joueur
1 remet la
valeur 105 à false. Ce qui suit n’étant que la gestion de la vie et du
respawn
des joueurs n’a pas lieu d’être expliqué.
Pour le second joueur c’est exactement le même script, il faut juste modifier la centaine des slots, par exemple à la place du slot 105, on aura le slot 205. Voici le listing de ce script :
Listing 4 : scr_update_jo_2();
|
//Script de maintenance pour obj_jo_2 if global.number = 2/*Début de if global.number*/ { if (keyboard_check(vk_left)) { x -= 3 } if (keyboard_check(vk_right)) { x += 3 }
if (keyboard_check(vk_up)) { if not place_free(x,y+1) vspeed = -12; } //Ecriture données { mplay_data_write(52,obj_jo_2); mplay_data_write(200,x); mplay_data_write(201,y); mplay_data_write(202,vspeed); mplay_data_write(205,"false"); mplay_data_write(207,Vie); mplay_data_write(208,score_kill); } /////Armes///// ////////////// //Pistolet if keyboard_check(vk_control) {
if selected_weapon = "pistol" { if cadence_pistol = 0 && munition_pistol > 0 {cadence_pistol = 1;alarm[0] = 13; munition_pistol -= 1; mplay_data_write(205,"true"); mplay_data_write(206,point_direction(x,y,mouse_x,mouse_y));} }
}
}/*Fin de if global.number A partir d'ici jusqu'à la prochaine execution du script on a fermé la possibilité à l'utilisateur: global.number d'agir sur quoi que ce soit! */
//Lecture données pour tout le monde, même celui qui a écrit ces données. x = mplay_data_read(200); y = mplay_data_read(201); vspeed = mplay_data_read(202); Vie = mplay_data_read(207); score_kill = mplay_data_read(208); //Armes du joueur //Pistolet if mplay_data_read(205) = "true" { with (instance_create(x,y,obj_projectile)) {motion_set(mplay_data_read(206),20);} }
//Dommages pouvant être causés aux joueurs if place_meeting(x,y,obj_projectile) { Vie -= 5 }
//Vie du Joueur if Vie <= 0 { Vie = 100; score_kill -= 1; mplay_data_write(225,"killed");//On envoie à l'autre que le J2 est mort pour augmenter son score_kill. Non réalisé dans ce tutorial. x = obj_spawn.x; y = obj_spawn.y; } |
Vous
avez
désormais un jeu de plateforme pour deux joueurs via Internet, il vous
est
facile de coder des nouveaux joueurs et je vous ai expliqué comment
gérer leur
destruction et leur déconnexion, je vous laisse donc le gm6 en fin de
ce
tutorial, au cas où vous auriez des problèmes éventuels.
J’espère avoir été assez complet, je sais cependant que mes explications ont du mal à être claires, car la programmation du multi est une logique que l’on trouve par soi, et chacun a la sienne. La difficulté d’expliquer le multi joueur est surtout dû au fait que toute l’approche de la programmation de jeu est orientée objet, alors que le multijoueur n’a aucune logique objet, et les gens ont donc du mal à comprendre que ce qui est réalisé dans un objet sur un ordinateur ne se fait pas sur un autre joueur pour ce même objet sans la nécessité d’une synchronisation. Ils ne comprennent pas nécessairement non plus qu’un objet chez un joueur écrive ses données, et qu’ils les lisent lui-même, mais que cela soit effectif chez tous les joueurs. C’est pourquoi je vous laisse l’exemple en .gm6 car il n’y a pas de meilleures façons d’apprendre que de regarder les choses faire, si ce n’est peut-être de chercher par soi-même.
II) Les routeurs de type
NAT et
comment leur permettre de jouer avec des jeux Game Maker.
Cette
section sera courte, mais certainement utile, car beaucoup de gens ont
des
routeurs.
Tout d’abord si vous voulez faire serveur et si vous passez par un
routeur il
va vous falloir un débit énorme, dans l’ordre de 100 Megaoctet par
seconde,
mais aussi un réseau interne rapide, ou alors il faut faire en sorte
que le
script de connexion prenne bien son temps pour chaque action. Une
dernière
option est d’utiliser des autres protocoles pour le multi joueurs, par
exemple
avec les dll’s SOC, 39Ster DLL, GMSock, EasySock etc.
Cette configuration ne vous concerne que si vous voulez jouer via Internet, si vous restez sur le réseau local du routeur, c'est-à-dire avec les ordinateurs qui y sont branchés cela n’est pas nécessaire, il suffit d’utiliser les ips internes qui sont allouées par le routeur à ces derniers.
Donc pour
que les routeurs puissent se connecter, il faut que le joueur qui créé
la
partie ouvre un port sur son ip, de nombreux sites listent les
fourchettes de
ports libres, je vous conseille de prendre le port 3020, pour
l’utiliser sur un
ordinateur qui n’a pas de routeur, c’est simple, il suffit lorsque l’on
vous
demande d’entrer l’ip de l’entrer comme suit : “192.23.122.11:3020“.
Pour quelqu’un qui a un routeur s’il veut se connecter à ce serveur, il
lui
faut d’abord, avant de démarrer le jeu, se connecter au système de
configuration de son routeur, en général cela se fait à l’aide d’une
page web.
Vous trouverez l’adresse de la page de configuration de votre routeur
dans son
mode d’emploi, sur le site de votre FAI, ou alors il existe des sites
Internet
expliquant pour chaque marque de routeur comment faire.
A partir de cette page vous aurez accès à la configuration de votre
routeur,
vous pourrez ouvrir un port. Il vous faudra ajouter le port 3020 et lui
dire de
rediriger tout ce qui y vient vers l’ip de votre ordinateur dans le
réseau
local, c'est-à-dire l’ip que le routeur alloue à votre ordinateur.
Ainsi tout
ce qui viendra sur votre ip vers le port 3020, sera envoyé sur l’ip de
votre
ordinateur dans le réseau local et la connexion pourra se faire.
Une fois ce port ouvert il vous suffit de démarrer le jeu et d’entrer l’ip du serveur, suivi du double point et du numéro de port. Et cela fonctionnera !
Attention toutefois, il faut que ce port soit ouvert et chez le serveur et chez le client ! Il faut donc que le développeur du jeu prévoit cela à l’avance, autant donner un port pour le jeu, puisque de toutes manières cela ne gêne pas ceux qui n’ont pas de routeur et cela permet de faire fonctionner le jeu chez ceux qui en ont un. Nous voilà heureux !
Buhl Damien
alias daminetreg
http://www.gamemaker.fr/
Plus Qu’une Communauté, Une Synergie.