/tags/Soutenance_finale/eradiKor/Network/Connections.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using Microsoft.Xna.Framework;

using Lidgren.Network;



namespace eradiKor.Network

{

    #region enum

    public enum WireType

    {

        Auto,

        Search,

        Direct,

        CreateServ,

        GetInfo

    }

    #endregion



    public class Connections

    {

        const int NBTRYMAX = 2;

        const int DEFAULTPORT = 42422;



        #region Attributs

        private WireConf wConf;

        private NetClient client;

        private NetBuffer netBuffer;

        private Network.Server serv;

        private List<System.Net.IPEndPoint> discovered;

        private string map;



        public Queue<string> sysMess { get; private set; }

        public Queue<NetMessage> inData { get; private set; }

        public Queue<NetMessage> outData { get; private set; }

        #endregion



        #region Constructeur

        public Connections(NetType nT, WireType wT,

            string i, int p, string n, GameTime gametime, string mapstr)

        {

            this.wConf = new WireConf(nT, wT,

                new NetConfiguration("eradiKor"), p, i, n);



            this.discovered = new List<System.Net.IPEndPoint>();

            this.sysMess = new Queue<string>();

            this.map = mapstr;



            if (this.wConf.WType == WireType.CreateServ)

                //il faut lui laisser le temps de s’initialiser

                //la connexion sera assurée par update plus tard

                init_serv(gametime, mapstr);

            else

                init_client(gametime);



            this.inData = new Queue<NetMessage>();

            this.outData = new Queue<NetMessage>();

        }

        #endregion



        #region Accesseurs

        /// <summary>

        /// Statut de la connection

        /// </summary>

        public NetConnectionStatus status

        {

            get { return this.client.Status; }

        }



        public int Id

        {

            get { return this.wConf.Id; }

        }



        public List<System.Net.IPEndPoint> Discovered

        {

            get { return this.discovered; }

        }



        public WireType Type

        {

            get { return this.wConf.WType; }

        }

        #endregion



        #region Méthodes

        public void update(Structures.GameData datas, GameTime gametime)

        {

            //update du serveur, s’il y en a un de lancé

            // + récupérations des éventuels messages systčmes

            // (update renvoie une Queue<string> de messages systčmes)

            if (this.wConf.IsServer && this.serv.Ready)

            {

                Queue<string> aux = this.serv.update((float)gametime.TotalRealTime.TotalSeconds);



                foreach (string s in aux)

                    this.sysMess.Enqueue(s);

            }



            NetMessageType messType;

            if (client != null)

            {

                //avertissement de changement de statut de la connexion

                if (this.client.Status != this.wConf.LastStatus)

                {

                    this.wConf.LastStatus = this.client.Status;

                    if (this.wConf.LastStatus == NetConnectionStatus.Connected)

                        this.sysMess.Enqueue("Connecté");

                    else if (this.wConf.LastStatus == NetConnectionStatus.Connecting)

                        this.sysMess.Enqueue("Connexion en cours");

                    else if (this.wConf.LastStatus == NetConnectionStatus.Disconnected)

                        this.sysMess.Enqueue("Déconnecté");

                    else if (this.wConf.LastStatus == NetConnectionStatus.Disconnecting)

                        this.sysMess.Enqueue("Déconnexion en cours");

                    else if (this.wConf.LastStatus == NetConnectionStatus.Reconnecting)

                        this.sysMess.Enqueue("Reconnexion en cours");

                }



                while (client.ReadMessage(this.netBuffer, out messType))

                {

                    if (messType == NetMessageType.ServerDiscovered)

                    {

                        if (this.wConf.WType == WireType.Auto && this.client.Status != NetConnectionStatus.Connected && this.client.Status != NetConnectionStatus.Connecting)

                        {

                            this.sysMess.Enqueue("Serveur trouvé");

                            this.client.Connect(this.netBuffer.ReadIPEndPoint());

                        }

                        else if (this.wConf.WType == WireType.Search)

                            this.discovered.Add(this.netBuffer.ReadIPEndPoint());

                    }

                    //des données ! voyons voir ce que c’est ...

                    else if (messType == NetMessageType.Data)

                    {

                        //Parsing des données en arrivage

                        NetMessage aux = new NetMessage(this.netBuffer.ReadString());



                        //quoi que ce soit,on se l’enfile dans inData

                        this.inData.Enqueue(aux);



                        //traitement selon les différents types de données

                        if (aux.Type == MessageType.None)

                            this.sysMess.Enqueue(aux.Content);

                        else if (aux.Type == MessageType.Ping)

                        {

                            //mise a jour de notre propre id, si on ne l'a pas encore

                            if (this.wConf.Id == 0 && aux.Id != 0)

                                this.wConf.Id = aux.Id;



                            //réponse instantannée au ping, sans passer par outData

                            this.sendData((new NetMessage(MessageType.Ping, this.wConf.Id, "")).NetString);

                        }

                        else if (aux.Type == MessageType.System)

                        {

                            string[] splitted = aux.Content.Split(new char[] { ':' });

                            if (splitted.Length >= 2)

                            {

                                int toparse = 0;

                                int.TryParse(splitted[0], out toparse);

                                SystemActions ty = NetParsers.parseSysAct(toparse);



                                if (ty == SystemActions.Disconnect)

                                {

                                    int concerned = 0;

                                    int.TryParse(splitted[1], out concerned);



                                    if (concerned == this.Id)

                                        //then, c’est grave

                                        Kore.Structures.Events.Critical.Enqueue(Kore.Structures.EventType.str);



                                }

                            }

                        }//if (données systčme)

                    }//if (données)

                }// while(messages)



                //Maintenant qu’on a paré tous les coups que le serveur nous a

                //envoyé, ŕ nous de riposter ! Tatata !

                if (this.client.Status == NetConnectionStatus.Connected)

                    while (this.outData.Count > 0)

                        this.sendData(this.outData.Dequeue().NetString);

            }



            //comment ça la connexion n’est pas active ?

            //allez hop, au boulot ! nan mais oh...

            if (this.wConf.LastTry + 3 < gametime.TotalRealTime.TotalSeconds && (client == null || this.client.Status != NetConnectionStatus.Connected))

                init_client(gametime);

        }



        private void sendData(string str)

        {

            if (this.client != null && this.client.Status == NetConnectionStatus.Connected)

            {

                NetBuffer outBuffer = new NetBuffer();

                outBuffer.Write(str);

                this.client.SendMessage(outBuffer, NetChannel.ReliableInOrder1);

            }

        }



        public void init_client(GameTime gametime)

        {

            if (this.client == null)

            {

                this.wConf.NetConf = new NetConfiguration("eradiKor");

                //this.wConf.NetConf.Port = this.wConf.Port;

                this.client = new NetClient(this.wConf.NetConf);



                this.client.Start();

            }



            //connexion en fonction du mode choisi

            if (this.wConf.WType == WireType.CreateServ)

                //le serveur a été initialisé par le constructeur

                this.client.Connect("127.0.0.1", this.wConf.Port);

            else if (this.wConf.WType == WireType.Direct)

            {

                if (this.wConf.NbTry >= NBTRYMAX && !this.wConf.IsServer)

                {

                    if (this.client != null)

                    {

                        this.client.Disconnect("");

                        this.client.Dispose();

                    }

                    Kore.Structures.Events.addCriticalEvent(Kore.Structures.EventType.multiCantConnect);

                }

                else

                this.client.Connect(this.wConf.Ip, this.wConf.Port);

            }

            else if (this.wConf.WType == WireType.Search)

            {

                this.discovered.Clear();

                this.client.DiscoverLocalServers(this.wConf.Port);

            }

            else if (wConf.WType == WireType.GetInfo)

                this.client.Connect(this.wConf.Ip, this.wConf.Port);

            else if (this.wConf.WType == WireType.Auto)

            { //le plus chiant !

                if (this.wConf.NbTry >= NBTRYMAX && !this.wConf.IsServer)

                    init_serv(gametime, this.map);

                else

                {

                    this.sysMess.Enqueue("Recherche de serveur");

                    this.client.DiscoverLocalServers(this.wConf.Port);

                }

            }



            this.wConf.NbTry++;

            this.netBuffer = this.client.CreateBuffer();

            this.wConf.LastTry = (float)gametime.TotalRealTime.TotalSeconds;

        }



        public void init_serv(GameTime gametime, string map)

        {

            this.sysMess.Enqueue("Initialisation du serveur");

            this.wConf.NetConf.Port = this.wConf.Port;

            this.wConf.NetConf.MaxConnections = 128;

            this.wConf.NetConf.TimeoutDelay = 5;

            this.serv = new Server(this.wConf.NetConf, this.wConf.NType, map);

            this.wConf.LastTry = (float)gametime.TotalRealTime.TotalSeconds;

            this.wConf.IsServer = true;

        }



        public void dispose()

        {

            if (this.wConf.IsServer && this.serv != null)

                this.serv.dispose();



            this.client.Disconnect("");

            this.client.Dispose();

        }

        #endregion

    }

}