| 1. Principe | 
                    
                     
                      | Le principe est d'utiliser les 
                        composants ClientSocket et 
                        ServerSocket. Une des joueurs 
                        sera le serveur, c'est lui qui contrôlera le jeu et synchronisera 
                        tous les joueurs, qui seront les clients. L'architecture 
                        réseau est la suivante. Les clients ne peuvent pas communiquer 
                        directement entre eux, tout passe par le serveur. (Ils 
                        peuvent cependant communiquer entre eux via le serveur.) 
                         | 
                    
                     
                      |  
                        
                       | 
                    
                     
                      | 2. Etablir les connexions 
                        entres les joueurs | 
                    
                     
                      | Il faut d'abord qu'un des joueurs 
                        lance le serveur. Pour cela, il doit ouvrir une socket 
                        serveur comme suit : | 
                    
                     
                      |  ServerSocket1.Port:=StrToInt(EditNumeroPort.Text); | 
                    
                     
                      | ServerSocket1.Open; | 
                    
                     
                      | . | 
                    
                     
                      | Le numéro de port sera une valeur 
                        quelconque. Les seuls critères de choix sont les suivants 
                        : | 
                    
                     
                      | · Le numéro de port ne doit pas 
                        être déjà utilisé, par un firewall, ou quelque soit d'autre. | 
                    
                     
                      | · Le numéro de port devra impérativement 
                        être le même pour toutes les joueurs qui se connecteront 
                        ensemble. | 
                    
                     
                      | . | 
                    
                     
                      | La socket serveur étant lancée, 
                        il faut maintenant que les client s'y connectent, en ouvrant 
                        une socket client, pointant sur celle du serveur, comme 
                        suit : | 
                    
                     
                      |  ClientSocket1.Port:=StrToInt(EditNumeroPort.Text); 
                         | 
                    
                     
                      | ClientSocket1.Host:=EditNomServeur.Text; 
                         | 
                    
                     
                      | ClientSocket1.Open;  | 
                    
                     
                      | . | 
                    
                     
                      | Le numéro de port sera celui sur 
                        lequel la socket serveur aura été ouverte. | 
                    
                     
                      | Le nom du host sera l'adresse 
                        IP (Internet Protocole) du serveur hôte.On peut aussi 
                        utiliser le nom de la machine serveur, au moins en réseau 
                        local (on l'obtient, par exemple, en faisant un clic droit 
                        sur le poste de travail dans l'explorer). | 
                    
                     
                      | . | 
                    
                     
                      | 3. Faire dialoguer 
                        les machines | 
                    
                     
                      | Une fois que les connexions sont 
                        établies entres les différentes machines des différents 
                        joueurs, il s'agit de les faire dialoguer entre eux. Pour 
                        cela, on va utiliser les commandes suivantes :  | 
                    
                     
                      | . | 
                    
                     
                      | En émission, pour une trame envoyée 
                        par le serveur à tous les clients : | 
                    
                     
                      |  For I:=0 
                        To ServerSocket1.Socket.ActiveConnections -1 Do ServerSocket1.Socket.Connections[I].SendText('Salut 
                        les clients !');  | 
                    
                     
                      | . | 
                    
                     
                      | En émission, pour une trame envoyée 
                        par le serveur à un client en particulier :  | 
                    
                     
                      | ServerSocket1.Socket.Connections[n° 
                        du client].SendText('Salut client !');  | 
                    
                     
                      | . | 
                    
                     
                      | En émission, pour une trame envoyée 
                        par un client au serveur : | 
                    
                     
                      |  ClientSocket1.Socket.SendText('Salut 
                        serveur !');  | 
                    
                     
                      | .. | 
                    
                     
                      | En réception, pour une trame reçue 
                        par le serveur d'un client :  | 
                    
                     
                      | procedure TForm1.ServerSocket1ClientRead(Sender: 
                        TObject; Socket: TCustomWinSocket);  | 
                    
                     
                      | begin  | 
                    
                     
                      | ShowMessage(Socket.ReceiveText); 
                         | 
                    
                     
                      | end;  | 
                    
                     
                      | . | 
                    
                     
                      | En réception, pour une trame reçue 
                        par le client du serveur :  | 
                    
                     
                      | procedure TForm1.ClientSocket1Read(Sender: 
                        TObject; Socket: TCustomWinSocket);  | 
                    
                     
                      | begin  | 
                    
                     
                      | ShowMessage(Socket.ReceiveText); 
                         | 
                    
                     
                      | end;  | 
                    
                     
                      | . | 
                    
                     
                      | Maintenant, on a les bases d'un 
                        programme de chat, qui fait dialoguer les postes entre 
                        eux. Bien évidemment, une trame transmise par un client 
                        ne sera reçu que par le serveur. Il faudra donc que le 
                        serveur redispatche la trame à tous les clients, si besoin 
                        est.  | 
                    
                     
                      | . | 
                    
                     
                      | 4. Jouer | 
                    
                     
                      | Pour jouer, on va faire passer 
                        les ordres donnés au moteur du jeu, dans les sockets. | 
                    
                     
                      | Pour tout cela, on va utiliser 
                        une structure de trame, qui va pouvoir se découper, par 
                        exemple, comme suit : | 
                    
                     
                      | · Code de début de trame, ex : 
                        'DEBUT'  | 
                    
                     
                      | · Code de type de trame, ex : 
                        'BOUGER-PIECE'  | 
                    
                     
                      | · Contenu de la trame, ex : 'A3-B2' 
                         | 
                    
                     
                      | · Code de fin de trame, ex : 'FIN' 
                         | 
                    
                     
                      | . | 
                    
                     
                      | Une codification de ce type va 
                        permettre de faire passer plusieurs types de trames dans 
                        les sockets. Chaque type de trame ayant son utilité propre. 
                        Par exemple :  | 
                    
                     
                      | · un type de trame qui transmet 
                        le nom des joueurs (plus convivial que les adresses IP 
                        ou les noms de machines),  | 
                    
                     
                      | · un type de trame qui permet 
                        l'initialisation de la position des pièces avant le début 
                        du jeu,  | 
                    
                     
                      | · un type de trame qui transmet 
                        les pièces bougées.  | 
                    
                     
                      | . | 
                    
                     
                      | Les codes de débuts et de fin 
                        de trame ne sont pas obligatoires. Cependant, ils permettent 
                        de pratiquer des batteries de contrôles pour s'assurer 
                        de la validité des infos passés. Cela permet parfois d'éviter 
                        le blocage du jeu, parce que les plateaux de jeu des différents 
                        joueurs ne seraient plus à la même hauteur. De plus, l'utilisation 
                        d'un code de fin de trame, permet d'utiliser des trames 
                        de longueurs variables. Ce qui est très pratique, et indispensable 
                        si on ajoute un chat au jeu.  | 
                    
                     
                      | . | 
                    
                     
                      | Souvent, après la phase de débugage, 
                        on remplacera, par exemple, 'BOUGER-PIECE' par 'Òœ„Þ¾ÌÛõ§÷ý'. 
                        Ceci, simplement pour que les codes de trames ne puissent 
                        plus être confondus avec le contenu d'un message de chat. 
                        Ce qui, là encore, bloquerai le jeu. |