package serveur;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;
import common.Conteneur;
import common.Joueur;
import common.TypeConteneur;
import common.misc.Utils;
/**
* Implémentation d'un serveur de jeu multi-connexion. Plusieurs joueurs peuvent
* se connecter simultanément au serveur pour accéder à un partie.<br/>
*
* Les parties se jouent à deux joueurs. Ainsi si un joueur est seul, il devra
* attendre la disponibilité d'un second joueur afin de démarrer une partie.
*
*
* @author Ait Elhaj Brahim
*
*/
public class ServeurJeu {
/* Le port par utilisé par défaut */
public static int DEFAULT_PORT = 7050;
private int nbClients;
private GestionnaireServeur gs;
private ServerSocket ss;
//private Socket connexionServeur;
/* On maintient une liste des joueurs clé : pseudo, valeur : Socket */
private HashMap joueurs;
/**
* Lance un serveur de jeu sur la machine. A partir de la, le serveur attend
* des connexions de clients.
*
*/
public ServeurJeu() {
joueurs = new HashMap();
gs = new GestionnaireServeur(this);
try {
ss = new ServerSocket(DEFAULT_PORT);
while (true) {
System.out.println("Serveur en attente de connection : ");
Socket s = ss.accept();
// Arrivée d'un nouveau client
/*System.out.println("[Serveur] : Connection du client "
+ s.getInetAddress());*/
Thread fils = new ServeurFils(s);
fils.start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* Gestion de chaque client indépendamment dans un <code>Thread</code>.
* On lance une nouvelle partie pour ce client ou on le connecte avec un
* joueur en attente.
*
* @author Ait Elhaj Brahim
*
*/
public class ServeurFils extends Thread {
private Socket s;
/**
* Création d'un serveur fils pour la connexion d'un nouveau client.
*
* @param s
* La socket du client
*/
public ServeurFils(Socket s) {
this.s = s;
}
/**
* Lancement du traitement lié à la connexion d'un nouveau client.
*/
public void run() {
try {
System.out.println("[SERVEUR] connection recue : " + s);
InputStream in = s.getInputStream();
OutputStream out = s.getOutputStream();
/*
* InputStreamReader reader = new InputStreamReader(s
* .getInputStream());
*/
// System.out.println("reader :" + reader);
// BufferedReader in = new BufferedReader(reader);
// String req = (String)Utils.deserialize(in);
//this.envoyerConteneur(null);
BufferedReader reader = new BufferedReader(new InputStreamReader(in));
PrintWriter writer = new PrintWriter(new OutputStreamWriter(out), true);
writer.print("SAlam le client => !");
writer.flush();
/*Conteneur c = (Conteneur) Utils.deserialize(in);
System.out.println("[SERVEUR] TypeConteneur = "
+ c.getTypeConteneur());*/
//if (c.getTypeConteneur().equals(TypeConteneur.JOUEUR)) {
//Joueur j = (Joueur) c.getObject();
//String pseudo = j.getPseudo();
//String pseudo = (String)c.getObject();
// Si le pseudo existe déja, on prévient le client
/*if (joueurs.containsKey(pseudo)) {
// Envoi message
System.out.println("Un joueur du nom de " + pseudo
+ " est déja présent sur le serveur");
} else */{
//joueurs.put(pseudo, s);
//nbClients++;
//gs.ajouterJoueur(pseudo);
}
//}
} catch (IOException e) {
e.printStackTrace();
} catch (Exception ex) {
ex.printStackTrace();
}
}
public void envoyerConteneur(Conteneur c) {
// Socket ss = new Socket(InetAddress.getByName(nomMachine), num_port);
// Ouverture d'un Socket avec le serveur
System.out.println("Socket connecté ? : "+s.isConnected());
// PrintWriter out = new PrintWriter(ss.getOutputStream());
//OutputStream out = /*s*/connexionServeur.getOutputStream();
// On sérialize et on envoie au serveur
//byte[] data = Utils.serialize(c);
/*out.write(data);*/
}
}
/**
* Envoie un objet <code>Conteneur</code> au serveur. Ce conteneur
* plusieurs types d'objets
*
* @param c
* @throws IOException
*/
public void envoyerConteneur(Conteneur c, Socket s) throws IOException {
// Socket ss = new Socket(InetAddress.getByName(nomMachine), num_port);
// Ouverture d'un Socket avec le serveur
System.out.println("ENVOI !");
// PrintWriter out = new PrintWriter(ss.getOutputStream());
//OutputStream out = /*s*/connexionServeur.getOutputStream();
// On sérialize et on envoie au serveur
//byte[] data = Utils.serialize(c);
/*out.write(data);*/
// Un PrintWriter possède toutes les opérations print classiques.
// En mode auto-flush, le tampon est vidé (flush) à l'appel de println.
BufferedReader reader = new BufferedReader(new InputStreamReader(s.getInputStream()));
PrintWriter writer = new PrintWriter(new OutputStreamWriter(s.getOutputStream()), true);
writer.print("SAlam le client => !");
writer.flush();
//out.write(data);
//out.flush();
// s.close();
}
/**
* On prévient les clients que la partie peut commencer
*
* @param pseudoJoueur
*/
public void partieCommence(String pseudoJoueurCroix, String pseudoJoueurRond)
throws IOException {
/*
* Socket sCroix = new Socket( (InetAddress)
* joueurs.get(pseudoJoueurCroix), DEFAULT_PORT); Socket sRond = new
* Socket((InetAddress) joueurs.get(pseudoJoueurRond), DEFAULT_PORT);
*/
Socket sCroix = (Socket) joueurs.get(pseudoJoueurCroix);
Socket sRond = (Socket) joueurs.get(pseudoJoueurRond);
Conteneur cCroix = new Conteneur(TypeConteneur.PARTIE_PEUT_COMMENCER,
TypeConteneur.CROIX);
Conteneur cRond = new Conteneur(TypeConteneur.PARTIE_PEUT_COMMENCER,
TypeConteneur.ROND);
envoyerConteneur(cCroix, sCroix);
envoyerConteneur(cRond, sRond);
}
/**
*
* @param argv
*/
public static void main(String argv[]) {
ServeurJeu s = new ServeurJeu();
}
}