Non, il ne s'agit pas du personnage portant le même nom dans Zelda ^_^, il s'agit d'autre chose qui est également très intéressant : la liaison entre 2 TI68k en C :)

Comment faire lorsqu'on veut un jeu qui se joue à plusieurs mais que le clavier étant trop limité (c'est pas un clavier d'ordi, et encore ... :p) on ne peut pas jouer sur la même TI ?
réponse : en utilisant 2 TI !
Félicitations, vous venez de comprendre le concept du link, maintenant il faut savoir comment faire, et c'est l'objet de ce tuto :p
Allons-y donc ...



Euh......comment qu'on fait ça ?

Un peu de patience, jeune padawan (la phrase qu'on place dans chaque tuto, il fallait bien que je la sorte ), on va d'abord présenter les instructions nécessaires pour qu'on puisse "travailler"

Il faut d'abord savoir qu'il existe 2 "types" d'instructions pour le link : celles de haut niveau et celles de bas niveau. La différence ? le haut niveau est plus facile à comprendre pour nous mais en contrepartie il est parfois plus lent (même si c'est de l'ordre de quelques millisecondes) et plus lourd (en taille je parle bien sûr ^^). A l'inverse, le bas niveau est plus difficile à comprendre pour nous, et plus facile pour la TI, mais il est plus rapide et plus léger en général.
Dans ce tuto, je vais uniquement utiliser les instructions de haut niveau, mais si vous voulez améliorer tout ça, vous pourrez utiliser les fonctions de bas niveau

Les fonctions que nous allons utiliser sont donc ......... *roulements de tambour*

• LIO_SendData();
  
• LIO_RecvData();
  

Un peu plus d'informations quand même ?

LIO_SendData() sert à ..... envoyer quelque chose ! comment ça je vous apprend rien de nouveau ?!
Bon en revanche, je suis sûr que vous ne savez pas que cette fonction prend 2 arguments
- Le premier est un pointeur de type void vers la variable à envoyer ( variable créée dans le programme, pas une variable du Var-Link, on verra ça plus tard)
- Le second correspond à la taille de la variable à envoyer (reportez-vous à la doc pour savoir la taille de la variable selon son type, ou sinon utilisez sizeof(...)), il est de type unsigned short


LIO_RecvData() est assez similaire au niveau des arguments, mais bien sûr, elle sert à recevoir quelque chose envoyé par l'autre TI :)
Elle prend 3 arguments :
- Le premier est un pointeur de type void vers l'endroit où la variable reçue sera stockée

Citation :

Rien de compliqué pourtant, pour faire plus clair, supposons un exemple : la TI émettrice (nommons-la A) envoie une variable de type short nommée ma_var à une TI réceptrice B
Mais comment est-ce que B va savoir que la variable envoyée s'appelle ma_var, d'autant que je rappelle que lors de la compilation, les noms de variables n'ont plus aucune signification ? Elle va alors recevoir le contenu de la variable ma_var de A, puis le stocker dans une variable créée avant :


TI émettrice
...
short ma_var = 42;
LIO_SendData(&ma_var, sizeof(short)); //envoie le contenu de ma_var
...



TI réceptrice
...
short ma_var_venant_de_la_TI_emettrice;

short s = LIO_RecvData(&ma_var_venant_de_la_TI_emettrice, sizeof(short), 200); //reçoit le contenu de ma_var

...
//si tout s'est bien passé, ma_var_venant_de_la_TI_emettrice contient la valeur 42


C'est aussi simple que ça
Vous remarquerez que j'ai anticipé (c'est ça un bon rédacteur de tuto ) sur les autres arguments que doit recevoir l'instruction LIO_RecvData :
- le 2ème argument est la taille de la variable à recevoir, il est de type unsigned short
- enfin, le 3ème argument est le temps à attendre

Citation :

200 secondes ?! mais j'ai le temps de faire plein de trucs en 200 secondes !

Ah oui ?
Enfin, non, ce n'est pas des secondes, "l'unité" de mesure est plutôt un tick

Citation :

Un tique ? beuuurrrk

non, pas un tique, un tick. Un tick correspond à 1/20ème de seconde, ou 0.05 seconde si vous préférez.
Ici je vous laisse faire le calcul, 200 ticks correspondent à 200/20ème de seconde, soit 10 secondes.
Dans l'exemple, la TI réceptrice va donc attendre ce qu'elle doit recevoir pendant 10 secondes, avant d'aller dire à l'autre d'aller se faire voir parce que c'est trop long


Que se passe t-il alors si la TI réceptrice ne reçoit rien ? c'est vrai, j'ai mis un short s = ... devant l'instruction, cela veut bien dire qu'elle retourne quelque chose ?
En effet, elle retourne 0 si elle a bien reçu quelque chose (et elle est contente ), ou une autre valeur non nulle (et elle est pas contente ) sinon. Attention, c'est pas l'inverse, ce n'est pas un boolean (enfin, c'est facile à adapter avec un simple opérateur ternaire : s = (s==0)?1:0; mais ça n'a pas vraiment d'intérêt)

Voilà, vous avez maintenant les outils pour travailler (je ne dirais pas tous, il reste plein d'autres instructions à découvrir), nous allons donc pouvoir mettre tout ça en application :)








Finie la théorie, place à la pratique !

Le "but du jeu" de ce paragraphe est simple, il s'agit d'un programme tout "con" : A déplace un pixel sur son écran, et ce pixel s'affiche en temps réel sur l'écran de B à la position où il se trouve sur l'écran de A ^^
Rien de compliqué non ? Eh bien allons-y alors

Première chose à laquelle on doit réfléchir avant de commencer tout programme : quelle sera la structure du programme ?
Ici on a 2 possibilités :

• soit on fait un programme différent sur chaque TI, l'un étant pour recevoir, l'autre pour envoyer
  
• soit on fait un programme commun qui réagira différemment selon que la TI est la TI réceptrice ou la TI émettrice
  

Pour cette partie, on utilisera la 1ère possibilité, parce que c'est la plus rapide à faire. Vous pourrez ensuite adapter le programme et utiliser la 2ème possibilité, référez-vous alors à la 3ème partie, la partie BONUS
Nous disions donc que nous allions faire 2 programmes différents

Commençons donc par le programme émetteur :

01 : #include < tigcclib.h >
02 :
03 : #define STOP -1
04 : #define C89_92(a,b) (TI89?a:b)
05 :
06 : void _main(void)
07 : {
08 : .....short pos[] = {C89_92(80,120), C89_92(50,64)};
09 : .....short link = 1;
10 : .....ST_helpMsg("En attente de l'autre TI.....");
11 :
12 : .....while(link = LIO_SendData(&link, sizeof(short), 1)) ............... continue;
13 :











Un p'tit bonus pour terminer

Pour terminer ce tuto, voici un bonus : une fonction qui établit un lien entre 2 TI, de façon particulière : elle permet de dire qui sera celui qui hébergera la partie et qui sera celui qui la rejoindra. Cette fonction est modifiable, ici celui qui appuiera le premier sur [Enter] hébergera la partie, le deuxième sera celui qui la rejoindra; cela peut être utile pour certains jeux, où seul celui qui hébergera la partie pourra modifier les options du jeu par exemple ...



Avant de créer cette fonction, donnons quelques précisions sur le fonctionnement de cette fonction :
Le principe est simple : le premier à exécuter une certaine action (appuyer sur [Enter] par exemple) va se mettre en mode attente jusqu'à ce que l'autre TI envoie une certaine information qui confirmera qu'il y a une liaison fonctionnelle et qu'on peut continuer.

Voici donc le code que je propose, essayez d'en comprendre au moins les grandes lignes avant de passer à la suite (pour rendre cette compréhension plus facile, "mettez-vous à la place des TI" dans chacun des cas)


01 : void establish_link()
02 : {
03 : .....#define getKey() (kbhit()?ngetchx():0);
04 : .....#define WAITING 0;
05 : .....#define READY 1;
06 :
07 : .....DrawStr(30,10,"Appuyer sur [ENTER] pour commencer",A_NORMAL);
08 : .....short statut = WAITING;
09 : .....BOOL received = FALSE;
10 : .....short key = 0, sent = 1;
11 :
12 : .....while (key != KEY_ENTER)
13 : .....{
14 : ..........LIO_RecvData(&received, sizeof(short), 1);
14 : ..........key = getKey();
15 : .....}
16 :
17 : .....statut = READY;
18 :
19 : .....if (received == FALSE)
20 : .....{
21 : ..........while(sent
22 : sent = LIO_SendData(&
)
}



to be completed...

Un tuto du plus haut intérêt ! Je suis fan.

rajouté quelques petits trucs, la fin ce soir :)