/tags/Soutenance_finale/Structure/Parser/General.cs

using System;

using System.Collections.Generic;

using System.Text;

using System.Text.RegularExpressions;



namespace Kore.Parser

{

    public static class General

    {

        #region Méthodes de parsage générales

        /// <summary>

        /// Transforme une chaine de caractčre en 

        /// </summary>

        /// <param name="chaine">Ch</param>

        /// <returns></returns>

        public static System.Drawing.Point parsePoint(string chaine)

        {

            int posVirg = chaine.IndexOf(',');



            if (posVirg >= 0)

                return new System.Drawing.Point(Convert.ToInt32(chaine.Substring(0, posVirg)), Convert.ToInt32(chaine.Substring(posVirg + 1)));

            else

                return System.Drawing.Point.Empty;

        }



        /// <summary>

        /// Transforme un point en chaîne de caractčre

        /// </summary>

        /// <param name="pt"></param>

        /// <returns></returns>

        public static string unparsePoint(System.Drawing.Point pt)

        {

            return pt.X + "," + pt.Y;

        }

        #endregion



        #region Méthodes de parsage des cartes

        /// <summary>

        /// Retourne le type de case correspondant au caractčre

        /// </summary>

        public static Structures.CaseType getType(char contenu)

        {

            if (contenu == 'F' || contenu == 'T' || contenu == 'b' || contenu == 'f' || contenu == 'g' || contenu == 's' || contenu == 'n')

                return new Structures.CaseType(Structures.MapSettings.Floor);

            else if (contenu == 'U')

                return new Structures.CaseType(Structures.MapSettings.Floor, Structures.MapSlots.Unbuildable);

            else if (contenu == 'W')

                return new Structures.CaseType(Structures.MapSettings.Wall);

            else if (contenu == 'E')

                return new Structures.CaseType(Structures.MapSettings.Enter);

            else if (contenu == 'S')

                return new Structures.CaseType(Structures.MapSettings.Exit);

            else

                return new Structures.CaseType(Structures.MapSettings.Void);

        }



        /// <summary>

        /// Retourne le caractčre correspondant au type de case (surcharge : prise en compte des tours)

        /// </summary>

        public static char getChar(Structures.CaseType contenu)

        {

            if (contenu.Background == Structures.MapSettings.Floor && contenu.Forground == Structures.MapSlots.Unbuildable)

                return 'U';

            else if (contenu.Background == Structures.MapSettings.Floor)

                return 'F';

            else if (contenu.Background == Structures.MapSettings.Wall)

                return 'W';

            else if (contenu.Background == Structures.MapSettings.Enter)

                return 'E';

            else if (contenu.Background == Structures.MapSettings.Exit)

                return 'S';

            else

                return '.';

        }

        public static char getChar(Structures.CaseType contenu, Structures.Tower tour)

        {

            char tw = General.getTowerChar(tour.Specs.Type);

            if (tw == '\0')

                return General.getChar(contenu);

            else

                return tw;

        }

        #endregion



        #region Méthodes de parsage des monstres

        /// <summary>

        /// Transforme une chaîne de caractčres en une liste chaînée de monstres

        /// </summary>

        /// <param name="list">Chaîne représentant des monstres</param>

        /// <returns>Liste chaînée de monstres</returns>

        public static LinkedList<Kore.Structures.Monster> parseMonstersList(string list)

        {

            if (list != "")

            {

                LinkedList<Kore.Structures.Monster> monsters = new LinkedList<Kore.Structures.Monster>();

                int fpos = 0, pos = 0;

                while ((pos = list.IndexOf('\n', pos + 1)) != -1)

                {

                    monsters.AddLast(parseMonster(list.Substring(fpos, pos - fpos)));

                    fpos = pos;

                }



                return monsters;

            }

            else

                return null;

        }



        /// <summary>

        /// Transforme une liste chaînée de monstres en chaîne de caractčres

        /// </summary>

        /// <param name="list">Liste chaînée de monstres</param>

        /// <returns>Chaîne représentant les monstres</returns>

        public static string unparseMonstersList(LinkedList<Kore.Structures.Monster> list)

        {

            string sortie = "";



            LinkedListNode<Kore.Structures.Monster> lln = list.First;



            while (lln != null)

            {

                sortie += unparseMonster(lln.Value) + '\n';



                lln = lln.Next;

            }



            return sortie;

        }



        /// <summary>

        /// Transforme une chaîne de caractčres en monstre

        /// </summary>

        /// <param name="chaine">Chaîne représentant un monstre</param>

        /// <returns>Monstres</returns>

        public static Kore.Structures.Monster parseMonster(string chaine)

        {

            Regex msntre = new Regex("([a-zA-Z0-9])([0-9]+,[0-9]+);([0-9]{1});([0-9]{1,2})");

            GroupCollection cc = msntre.Match(chaine).Groups;



            if (cc != null)

                return new Kore.Structures.Monster(getMonsterType(cc[1].Value[0]), parsePoint(cc[2].Value), Convert.ToByte(cc[3].Value), Convert.ToInt32(cc[4].Value), 1f);

            else

                return null;

        }



        /// <summary>

        /// Transforme un monstre en chaîne de caractčres

        /// </summary>

        /// <param name="mnstre">Monstres</param>

        /// <returns>Chaîne représentant le monstre</returns>

        public static string unparseMonster(Kore.Structures.Monster mnstre)

        {

            return getMonsterChar(mnstre.Specs.Type) + unparsePoint(mnstre.LastTarget) + ";" + mnstre.Direction + ";" + mnstre.Specs.Level;

        }



        /// <summary>

        /// Retourne le type de monstre correspondant au caractčre passé en argument

        /// </summary>

        /// <param name="contenu">Caractčre ŕ interpręter</param>

        /// <returns>Type de monstre correspondant</returns>

        public static Kore.Structures.MonsterType getMonsterType(char contenu)

        {

            if (contenu == 'b')

                return Structures.MonsterType.Bandit;

            else if (contenu == 'f')

                return Structures.MonsterType.Flying;

            else if (contenu == 'g')

                return Structures.MonsterType.Ghost;

            else if (contenu == 'k')

                return Structures.MonsterType.Kask;

            else if (contenu == 'u')

                return Structures.MonsterType.Kornu;

            else

                return Structures.MonsterType.Normal;

        }



        /// <summary>

        /// Retourne le caractčre correspondant au type de monstre passé en argument

        /// </summary>

        /// <param name="contenu">Type du monstre</param>

        /// <returns>Caractčre correspondant</returns>

        public static char getMonsterChar(Kore.Structures.MonsterType contenu)

        {

            if (contenu == Structures.MonsterType.Bandit)

                return 'b';

            else if (contenu == Structures.MonsterType.Flying)

                return 'f';

            else if (contenu == Structures.MonsterType.Ghost)

                return 'g';

            else if (contenu == Structures.MonsterType.Kask)

                return 'k';

            else if (contenu == Structures.MonsterType.Kornu)

                return 'u';

            else

                return 'n';

        }

        #endregion



        #region Méthodes de parsage des tours

        /// <summary>

        /// Transforme une chaîne de caractčres en une liste chaînée de monstres

        /// </summary>

        /// <param name="list">Chaîne représentant des monstres</param>

        /// <returns>Liste chaînée de monstres</returns>

        public static LinkedList<Kore.Structures.Tower> parseTowersList(string list)

        {

            LinkedList<Kore.Structures.Tower> towers = new LinkedList<Kore.Structures.Tower>();

            int fpos = 0, pos = 0;

            if (list != "")

                while ((pos = list.IndexOf('\n', pos + 1)) != -1)

                {

                    towers.AddLast(parseTower(list.Substring(fpos, pos - fpos)));

                    fpos = pos;

                }



            return towers;

        }



        /// <summary>

        /// Transforme une liste chaînée de monstres en chaîne de caractčres

        /// </summary>

        /// <param name="list">Liste chaînée de monstres</param>

        /// <returns>Chaîne représentant les monstres</returns>

        public static string unparseTowersList(LinkedList<Kore.Structures.Tower> list)

        {

            string sortie = "";



            LinkedListNode<Kore.Structures.Tower> lln = list.First;



            while (lln != null)

            {

                sortie += unparseTower(lln.Value) + '\n';



                lln = lln.Next;

            }



            return sortie;

        }



        /// <summary>

        /// Transforme une chaîne de caractčres en tour

        /// </summary>

        /// <param name="chaine">Chaîne représentant une tour</param>

        /// <returns>Tour</returns>

        public static Kore.Structures.Tower parseTower(string chaine)

        {

            Regex msntre = new Regex("([a-zA-Z0-9])([0-9]+,[0-9]+);([0-9]{1,2})");

            GroupCollection cc = msntre.Match(chaine).Groups;



            if (cc != null)

                return new Kore.Structures.Tower(getTowerType(cc[1].Value[0]), parsePoint(cc[2].Value), Convert.ToInt32(cc[3].Value));

            else

                return null;

        }



        /// <summary>

        /// Transforme un monstre en chaîne de caractčres

        /// </summary>

        /// <param name="mnstre">Monstres</param>

        /// <returns>Chaîne représentant le monstre</returns>

        public static string unparseTower(Kore.Structures.Tower tower)

        {

            return getTowerChar(tower.Specs.Type) + unparsePoint(tower.Position) + ";" + tower.Specs.Level;

        }



        public static char getTowerChar(Structures.TowerType tour)

        {

            if (tour == Structures.TowerType.Null)

                return '\0';

            else if (tour == Structures.TowerType.Bumper)

                return 'b';

            else if (tour == Structures.TowerType.Faster)

                return 'f';

            else if (tour == Structures.TowerType.Glu)

                return 'c';

            else if (tour == Structures.TowerType.Poison)

                return 'p';

            else if (tour == Structures.TowerType.Power)

                return 'o';

            else if (tour == Structures.TowerType.Normal)

                return 'n';

            else if (tour == Structures.TowerType.Stronger)

                return 's';

            else if (tour == Structures.TowerType.Ghost)

                return 'h';

            else

                return 'T';

        }



        public static Structures.TowerType getTowerType(char tour)

        {

            if (tour == 'b')

                return Structures.TowerType.Bumper;

            else if (tour == 'f')

                return Structures.TowerType.Faster;

            else if (tour == 'c')

                return Structures.TowerType.Glu;

            else if (tour == 'p')

                return Structures.TowerType.Poison;

            else if (tour == 'o')

                return Structures.TowerType.Power;

            else if (tour == 'n' || tour == 'T')

                return Structures.TowerType.Normal;

            else if (tour == 's')

                return Structures.TowerType.Stronger;

            else if (tour == 'h')

                return Structures.TowerType.Ghost;

            else

                return Structures.TowerType.Null;

        }

        #endregion

    }

}