public static void ParseLevels(string html, Spell spell, ILog log)
        {
            List<SpellListLevel> levels = new List<SpellListLevel>();

            ParseClassLevel(html, levels, SpellList.Ids.Bard, string.Format(ClassPattern, "barde", "Bard"));
            if (!ParseClassLevel(html, levels, SpellList.Ids.SorcererWizard, EnsWizPattern1))
            {
                // Version alternative
                if (!ParseClassLevel(html, levels, SpellList.Ids.SorcererWizard, string.Format(ClassPattern, "magicien", "Mag")))
                {
                    ParseClassLevel(html, levels, SpellList.Ids.SorcererWizard, EnsWizPattern2);
                }
            }

            ParseClassLevel(html, levels, SpellList.Ids.Ranger, string.Format(ClassPattern, "rôdeur", "Rôd"));
            ParseClassLevel(html, levels, SpellList.Ids.Paladin, string.Format(ClassPattern, "paladin", "Pal"));
            ParseClassLevel(html, levels, SpellList.Ids.Druid, string.Format(ClassPattern, "druide", "Dru"));
            ParseClassLevel(html, levels, SpellList.Ids.Cleric, string.Format(ClassPattern, "prêtre", "Prê"));
            ParseClassLevel(html, levels, SpellList.Ids.Inquisitor, string.Format(ClassPattern, "inquisiteur", "Inq"));
            ParseClassLevel(html, levels, SpellList.Ids.Summoner, string.Format(ClassPattern, "invocateur|conjurateur", "Inv"));
            ParseClassLevel(html, levels, SpellList.Ids.Witch, string.Format(ClassPattern, "sorcière", "Sor"));
            ParseClassLevel(html, levels, SpellList.Ids.Alchemist, string.Format(ClassPattern, "alchimiste", "Alch"));
            ParseClassLevel(html, levels, SpellList.Ids.Oracle, string.Format(ClassPattern, "oracle", "Ora"));
            ParseClassLevel(html, levels, SpellList.Ids.Oracle, string.Format(ClassPattern, "prêtre", "Prê"));
            ParseClassLevel(html, levels, SpellList.Ids.Magus, string.Format(ClassPattern, "magus", "magus"));
            ParseClassLevel(html, levels, SpellList.Ids.AntiPaladin, string.Format(ClassPattern, "antipaladin", "antipaladin"));

            if (levels.Count == 0)
            {
                throw new ParseException("Impossible de détecter les niveaux de classe");
            }

            spell.Levels = levels.ToArray();
        }
        public static void ParseCastingTime(string html, Spell spell, ILog log)
        {
            var match = Regex.Match(html, Pattern, RegexOptions.CultureInvariant | RegexOptions.IgnoreCase);

            if (!match.Success)
            {
                throw new ParseException("Impossible de détecter le temps d'incantation");
            }

            var castingTime = spell.CastingTime = new SpellCastingTime();

            var value = match.Groups["Value"].Value.Trim();

            match = Regex.Match(value, ValuePattern, RegexOptions.CultureInvariant);

            if (match.Success)
            {
                castingTime.Value = int.Parse(match.Groups["Quantity"].Value);

                var unit = match.Groups["Unit"].Value.ToLowerInvariant();

                if (unit.IndexOf("voir description") != -1)
                    castingTime.Unit = TimeUnit.Special;
                else
                    castingTime.Unit = ParseTimeUnit(unit);
            }

            if (!match.Success || castingTime.Unit == TimeUnit.Special)
            {
                castingTime.Value = 0;
                castingTime.Unit = TimeUnit.Special;
                castingTime.Text = MarkupUtil.RemoveMarkup(value);
            }
        }
        public static void ParseTarget(string html, Spell spell, ILog log)
        {
            var match = Regex.Match(html, Pattern, RegexOptions.CultureInvariant | RegexOptions.ExplicitCapture);

            if (!match.Success)
            {
                if (!noTargetSpells.Contains(spell.Id))
                {
                    log.Warning($"{spell.Name} : cible introuvable. Si le sort n'a pas de cible, il doit être ajouté dans le fichier contenant les sorts sans cible");
                }

                return;
            }

            var type = match.Groups["Type"].Value;
            int count;
            typeCount.TryGetValue(type, out count);
            count++;
            typeCount[type] = count;

            var value = MarkupUtil.RemoveMarkup(match.Groups["Value"].Value.Trim());

            spell.Target = new SpellTarget
            {
                Value = value
            };
        }
Пример #4
0
 public static bool TryParse(WikiPage page, out Spell spell, ILog log = null)
 {
     spell = null;
     try
     {
         spell = Parse(page, log);
         return true;
     }
     catch (ParseException e)
     {
         log.Error("{0}: {1}", page.Title, e.Message);
         return false;
     }
 }
        public static void ParseDescriptor(string html, Spell spell, ILog log)
        {
            var match = Regex.Match(html, DescriptorPattern, RegexOptions.CultureInvariant);

            if (!match.Success)
            {
                match = Regex.Match(html, DescriptorPattern2, RegexOptions.CultureInvariant);
            }

            if (match.Success)
            {
                foreach (var descriptor in match.Groups["Title"].Value.Split(',').Select(d => d.Trim().ToLowerInvariant()))
                {
                    spell.Descriptor |= ParseDescriptorValue(descriptor);
                }
            }
        }
        public static void ParseSchool(string html, Spell spell, ILog log)
        {
            var schoolMatch = Regex.Match(html, SchoolPattern, RegexOptions.CultureInvariant);

            if (schoolMatch.Success)
            {
                spell.School = ParseSpellSchoolTitle(schoolMatch.Groups["Title"].Value);
            }
            else if (html.IndexOf(UniversalSchoolPattern, StringComparison.OrdinalIgnoreCase) != -1)
            {
                spell.School = SpellSchool.Universal;
            }
            else
            {
                throw new ParseException("Impossible de lire l'école de magie");
            }

            // TODO lire les branches
        }
Пример #7
0
        private static Spell Parse(WikiPage page, ILog log = null)
        {
            var spell = new Spell();
            spell.Name = page.Title;
            spell.Id = page.Id;

            // Ajout source wiki
            spell.Source.References.Add(References.FromFrWiki(page.Url));

            // Ajout source drp
            spell.Source.References.Add(References.FromFrDrp(page.Id));

            var wiki = page.Raw;

            if (wiki.IndexOf("'''École'''", StringComparison.Ordinal) == -1 && wiki.IndexOf("'''Ecole'''", StringComparison.Ordinal) == -1)
            {
                throw new ParseException("École de magie introuvable");
            }

            SpellParser parser = new SpellParser(spell, wiki);
            parser.Execute(log);

            return spell;
        }
Пример #8
0
 public SpellParser(Spell spell, string html)
 {
     this.spell = spell;
     this.html = html;
 }
        public static void ParseSavingThrow(string html, Spell spell, ILog log)
        {
            if (spell.Name == "Transmutation de potion en poison")
            {
                // Cas particulier : ce sort décrit plusieurs sorts
                return;
            }

            var match = Regex.Match(html, Pattern, RegexOptions.CultureInvariant | RegexOptions.ExplicitCapture);

            if (!match.Success)
            {
                return;
                throw new ParseException("Jet de sauvegarde introuvable");
            }

            var value = MarkupUtil.RemoveMarkup(match.Groups["Value"].Value.Trim());
            var compareValue = value.ToLowerInvariant();

            var savingThrow = new SpellSavingThrow();

            var copyValue = false;

            if (compareValue.IndexOf(" ou ", StringComparison.Ordinal) != -1 ||
                compareValue.IndexOf(" et ", StringComparison.Ordinal) != -1 ||
                compareValue.IndexOf(" puis ", StringComparison.Ordinal) != -1)
            {
                copyValue = true;
                savingThrow.Target = SpellSavingThrowTarget.Special;
                savingThrow.Effect = SpellSavingThrowEffect.Special;
            }
            else if ((match = Regex.Match(compareValue, EffectPattern, RegexOptions.CultureInvariant | RegexOptions.ExplicitCapture)).Success)
            {
                switch (match.Groups["Type"].Value)
                {
                    case "volonté":
                        savingThrow.Target = SpellSavingThrowTarget.Will;
                        break;

                    case "réflexes":
                        savingThrow.Target = SpellSavingThrowTarget.Reflex;
                        break;

                    case "vigueur":
                        savingThrow.Target = SpellSavingThrowTarget.Fortitude;
                        break;

                    case "oui":
                        savingThrow.Target = SpellSavingThrowTarget.Special;
                        copyValue = true;
                        break;

                    case "non":
                        savingThrow.Target = SpellSavingThrowTarget.None;
                        copyValue = true;
                        break;
                }

                var effect = match.Groups["Value"].Value.Trim();

                if (effect.EndsWith(", voir texte"))
                {
                    copyValue = true;
                    effect = effect.Substring(0, effect.Length - ", voir texte".Length);
                }
                else if (effect.EndsWith(", voir description"))
                {
                    copyValue = true;
                    effect = effect.Substring(0, effect.Length - ", voir description".Length);
                }
                else if (effect.EndsWith(", voir plus bas"))
                {
                    copyValue = true;
                    effect = effect.Substring(0, effect.Length - ", voir plus bas".Length);
                }

                match = Regex.Match(effect, BonusPattern, RegexOptions.CultureInvariant | RegexOptions.ExplicitCapture);

                if (match.Success)
                {
                    effect = match.Groups["Effect"].Value.Trim();

                    foreach (Capture bonusCapture in match.Groups["Parenthesis"].Captures)
                    {
                        var bonus = bonusCapture.Value.Trim().ToLowerInvariant();

                        switch (bonus)
                        {
                            case "inoffensif":
                                savingThrow.Harmless = true;
                                break;

                            case "objet":
                                savingThrow.Objects = true;
                                break;

                            case "inoffensif, objet":
                            case "objet, inoffensif":
                                savingThrow.Harmless = true;
                                savingThrow.Objects = true;
                                break;

                            case "spécial, voir texte":
                            case "voir texte":
                            case "voir plus bas":
                            case "voir description":
                            case "en cas d’interaction":
                            case "en cas d'interaction":
                            case "spécial, voir plus bas":
                                copyValue = true;
                                break;

                            case "":
                                break;

                            default:
                                throw new ParseException(string.Format("Détail du jet de sauvegarde non reconnu : \"{0}\" dans le texte \"{1}\"", bonus, value));
                        }
                    }
                }

                switch (effect)
                {
                    case "annuler":
                    case "annule":
                        savingThrow.Effect = SpellSavingThrowEffect.Negates;
                        break;

                    case "1/2 dégâts":
                    case "réduit de moitié":
                    case "réduire de moitié":
                        savingThrow.Effect = SpellSavingThrowEffect.Half;
                        break;

                    case "partiel":
                    case "partielle":
                        savingThrow.Effect = SpellSavingThrowEffect.Partial;
                        break;

                    case "dévoile":
                    case "dévoiler":
                    case "dévoiler l'illusion":
                        savingThrow.Effect = SpellSavingThrowEffect.Disbelief;
                        break;

                    case "":
                        break;

                    default:
                        if (copyValue)
                        {
                            // On a déjà détecté un sort spécial, on arrête là
                        }
                        else
                        {
                            throw new ParseException(string.Format("Impossible de décoder l'effet du jet de sauvegarde \"{0}\"", effect));
                        }
                        break;
                }
            }
            else if (compareValue.EqualsOrdinal("aucun") || compareValue.EqualsOrdinal("non"))
            {
                savingThrow = null;
            }
            else if (compareValue.StartsWithOrdinal("aucun"))
            {
                savingThrow.SpecificValue = value;
            }
            else if (compareValue.EqualsOrdinal("voir description") || compareValue.EqualsOrdinal("voir texte"))
            {
                savingThrow.Effect = SpellSavingThrowEffect.Special;
                savingThrow.SpecificValue = value;
            }
            else if (compareValue.EqualsOrdinal("spécial, voir plus bas"))
            {
                savingThrow.Effect = SpellSavingThrowEffect.Special;
                savingThrow.SpecificValue = value;
            }
            else if (compareValue.EqualsOrdinal("spécial, voir texte"))
            {
                savingThrow.Effect = SpellSavingThrowEffect.Special;
                savingThrow.SpecificValue = value;
            }
            else
            {
                throw new ParseException(string.Format("Impossible de décoder le type de jet de sauvegarde dans \"{0}\"", value));
            }

            if (copyValue)
            {
                savingThrow.SpecificValue = value;
            }

            spell.SavingThrow = savingThrow;
        }
 public SpellWrapper(Spell spell)
 {
     this.spell = spell;
 }
Пример #11
0
        public static void ParseRange(string html, Spell spell, ILog log)
        {
            var match = Regex.Match(html, RangePattern, RegexOptions.CultureInvariant);

            if (!match.Success)
            {
                if (!noRangeSpells.Contains(spell.Id))
                {
                    throw new ParseException($"Portée introuvable pour l'id {spell.Id}");
                }
                // portée ignorée
                return;
            }

            var rangeValue = match.Groups["Value"].Value.Trim();

            switch (rangeValue.ToLowerInvariant())
            {
                case "[[personnelle]]":
                case "personnelle":
                case "[[présentation des sorts#portee|personnelle]]":
                    spell.Range = new SpellRange {Unit = SpellRangeUnit.Personal};
                    break;

                case "[[contact]]":
                case "contact":
                case "[[présentation des sorts#portee|contact]]":
                case "[[présentation des sorts#contact|contact]]":
                    spell.Range = new SpellRange {Unit = SpellRangeUnit.Touch};
                    break;

                case "[[illimitée]]":
                case "illimitée":
                    spell.Range = new SpellRange {Unit = SpellRangeUnit.Unlimited};
                    break;

                case "courte (7,50 m + 1,50 m/2 [[niveau|niveaux]])":
                case "courte (7,50 m + 1,50 m/2 [[niveau|niveaux]]) (5 cases + 1 case/2 [[niveau|niveaux]])": // Format sans snippet
                case "courte (7,50 m + 1,50 m/2 [[niveau|niveaux]]) (5 {s:c} + 1 {s:c}/2 [[niveau|niveaux]])": // Format APG
                case "courte (7,50 m + 1,50 m/2 [[niveau|niveaux]])/(5 {s:c} + 1 {s:c}/2 [[niveau|niveaux]])": // Format UM
                case "courte (7,50 m + 1,50 m/2 [[niveau|niveaux]]) / (5 {s:c} + 1 {s:c}/2 [[niveau|niveaux]])": // Format UM 2
                case "courte (7,50 m + 1,50 m/2 [niveau|niveaux]])/(5 {s:c} + 1 {s:c}/2 [[niveau|niveaux]])": // Format UM (buggé!)
                case "courte (7,5 m + 1,5 m/2 [[niveau|niveaux]]) (5 {s:c} + 1 {s:c}/2 [[niveau|niveaux]])": // Format court (pas de décimale non significative)
                case "courte (7,50 m + 1,50 m/2 niveaux) (5 cases + 1 case/2 niveaux)":
                case "ccourte (7,50 m + 1,50 m/2 [[niveau|niveaux]]) (5 {s:c} + 1 {s:c}/2 [[niveau|niveaux]])": // Transmutation du sang en acide (BUG)
                    //case "courte (7,50 m + 1,50 m/2 ([niveau|niveaux]])": // Détection faussée
                    //case "courte (7,50 mètres + 1,50 mètre/2 [[niveau|niveaux]])": // Convocation de monstres I
                    //case "proche (7,50 m + 1,50 m/2 [[niveau|niveaux]])": // Délivrance de la paralysie
                    //case "courte (7,50 m/5 cases + 1,50 m/1 case par 2 [[niveau|niveaux]])": // Illumination
                    //case "courte (7,50 m + 1,50 m/2 [[niveau|niveaux]])/(5 cases + 1 case/2 [[niveau|niveaux]])": // Lenteur
                    //case "courte (7,50 m + 1,50 m/2 niveaux) / (5 cases + 1 case/2 [[niveau|niveaux]])": // Lien télépathique
                    //case "courte (7,50 m + 1,50 m/2 [[niveau|niveaux]]) / (5 cases + 1 case/2 [[niveau|niveaux]])": // Manipulation à distance
                    //case "courte (7,50 m + 1,50 m/2 [[niveau|niveaux]]) / (5 cases + 1 cases/2 [[niveau|niveaux]])": // Mauvais oeil
                    //case "courte (7,50 + 1,50 m/2 [[niveau|niveaux]])": // Profanation
                    //case "courte (7,50 m + 1,50 m/2 [[niveau|niveaux]]) (5 {s:c} + 1 ({s:c}))": // Vermine géante
                    //case "courte (7,50 m + 1,50 m/2 [[niveau|niveaux]] - 5 cases + 1 case/2 [[niveau|niveaux]])": // Zone de vérité
                    //case "courte (7,50 m + 1,50 m/2 niveaux) (5 {s:c} + 1 {s:c}/2 niveaux)": // Appel cacophonique
                    //case "courte (7,50 m + 1,50 m/2 [[niveau|niveaux]) (5 {s:c} + 1 {s:c}/2 [[niveau|niveaux])": // Bouclier involontaire
                    //case "courte (7,5 m + 1,5 m/2 [[niveau|niveaux]]) (5 {s:c} + 1 {s:c}/2 [[niveau|niveaux]])": // Dangereux final
                    //case "courte (7,50 m + 1,50 m/2 niveaux)": // Négation de l'arôme
                    //case "courte (7,50 m + 1,50 m/2 niveaux) (5 cases + 1 case/2 niveaux)": // Vérole
                    spell.Range = new SpellRange {Unit = SpellRangeUnit.Close};
                    break;

                // Format standard
                case "moyenne (30 m + 3 m/[[niveau]])":
                case "moyenne (30 m + 3 m/[[niveau]]) (20 {s:c} + 2 {s:c}/[[niveau]])":
                case "moyenne (30 m + 3 m/[[niveau|niveaux]])/(20 {s:c} + 2 {s:c}/[[niveau|niveaux]])":
                case "moyenne (30 m + 3 m/[[niveau]]) / (20 {s:c} + 2 {s:c}/[[niveau]])":
                //case "moyenne (20 cases + 2 cases/[[niveau]]) (30 m + 3 m/[[niveau]])": // Extinction des feux
                //case "moyenne (30 m/20 cases + 3 m/2 cases par [[niveau]])": // Immobilisation de morts-vivants
                //case "moyenne (30 m + 3 m/[[niveau]]) / (20 cases + 2 cases/[[niveau]])": // Lueur d'arc-en-ciel
                //case "moyenne (30 m + 3 m/[[niveau]])/(20 cases + 2 cases/[[niveau]])": // Main spectrale
                //case "moyenne (30 m + 3 m/[[niveau]]) / (20 cases + 2 case/[[niveau]])": // Mur de feu
                //case "moyenne (30 m + 3 m/niveau) / (20 cases + 2 cases/[[niveau]])": // Mur de glace
                //case "moyenne (30 m + 3 m/niveau)": // Pétrification
                // Format APG
                case "intermédiaire (30 m + 3 m/[[niveau]]) (20 {s:c} + 2 {s:c}/[[niveau]])":
                    //case "intermédiaire (30 m + 3 m/niveau)": // Appel des pierres
                    spell.Range = new SpellRange {Unit = SpellRangeUnit.Medium};
                    break;

                case "longue (120 m + 12 m/[[niveau]])": // Format standard
                case "longue (120 m + 12 m/[[niveau]]) (80 {s:c} + 8 {s:c}/[[niveau]])": // Format APG
                case "longue (120 m + 12 m/[[niveau]]) / (80 {s:c} + 8 {s:c}/[[niveau]])": // Format UM
                    //case "longue (120 m/80 cases + 12 m/8 cases par [[niveau]])": // Image silencieuse
                    //case "longue (120 m + 12 m/[[niveau]])/(80 cases + 8 cases/[[niveau]])": // Localisation d'objets
                    //case "longue (120 m + 12 m/[[niveau]]) / (80 cases + 8 cases/[[niveau]])": // Lueur féerique
                    //case "longue (120 m + 12 m/niveau)": // Sphère glaciale
                    //case "longue (120 m + 12 m/niveau) (80  cases + 8 cases/niveau)": // Tsunami
                    //case "longue (120 m + 12 m/niveau) (80 cases) + 8 cases par niveau)": // Vortex
                    spell.Range = new SpellRange {Unit = SpellRangeUnit.Long};
                    break;

                case "0 m":
                case "0 m (0 {s:c})":
                    spell.Range = new SpellRange {Unit = SpellRangeUnit.Squares, SpecificValue = "0"};
                    break;

                case "1,50 m": // Charmant cadeau
                case "1,50 m (1 {s:c})": // Manteau de rêves
                    spell.Range = new SpellRange {Unit = SpellRangeUnit.Squares, SpecificValue = "1"};
                    break;

                case "3 m":
                //case "3 m - 2 cases": // Zone d'antimagie
                case "3 m (2 {s:c})": // Interdiction du fou
                    spell.Range = new SpellRange {Unit = SpellRangeUnit.Squares, SpecificValue = "2"};
                    break;

                case "4,50 m":
                case "4,50 m (3 {s:c})":
                    //case "4,50 m/3 cases": // Mains brûlantes
                    spell.Range = new SpellRange {Unit = SpellRangeUnit.Squares, SpecificValue = "3"};
                    break;

                case "6 m":
                //case "6 m (4 cases)": // Manteau du chaos
                case "6 m (4 {s:c})": // Final revigorant
                    spell.Range = new SpellRange {Unit = SpellRangeUnit.Squares, SpecificValue = "4"};
                    break;

                case "9 m":
                case "9 m (6 {s:c})": // Cri strident
                    spell.Range = new SpellRange {Unit = SpellRangeUnit.Squares, SpecificValue = "6"};
                    break;

                case "12 m":
                case "12 m (8 {s:c})": // Recherche de pensées
                    spell.Range = new SpellRange {Unit = SpellRangeUnit.Squares, SpecificValue = "8"};
                    break;

                case "15 m/10 cases":
                case "15 m/10 {s:c}": // Imprécation
                case "15 m (10 {s:c})": // Bénédiction
                    spell.Range = new SpellRange {Unit = SpellRangeUnit.Squares, SpecificValue = "10"};
                    break;

                case "18 mètres":
                case "18 m":
                case "18 m/12 cases":
                case "18 m (12 {s:c})":
                case "18 mètres (12 {s:c})": // Extase
                case "18 m/12 {s:c}": // Identification
                    spell.Range = new SpellRange {Unit = SpellRangeUnit.Squares, SpecificValue = "12"};
                    break;

                case "30 m (20 {s:c})": // Joueur de flûte
                    spell.Range = new SpellRange {Unit = SpellRangeUnit.Squares, SpecificValue = "20"};
                    break;

                case "36 m": // Sillage de lumière
                case "36 m (24 {s:c})": // Éclair
                    spell.Range = new SpellRange {Unit = SpellRangeUnit.Squares, SpecificValue = "24"};
                    break;

                case "jusqu’à 3 m (2 {s:c})/[[niveau]]": // Champ de force
                    spell.Range = new SpellRange {SpecificValue = "jusqu'à 2 cases/niveau"};
                    break;

                case "12 m (8 {s:c})/[[niveau]]": // Contrôle des vents
                    spell.Range = new SpellRange {Unit = SpellRangeUnit.Squares, SpecificValue = "8/level"};
                    break;

                case "15 m (10 {s:c})/[[niveau]]": // Entrer dans une image
                    spell.Range = new SpellRange {Unit = SpellRangeUnit.Squares, SpecificValue = "10/level"};
                    break;

                case "1,5 km/[[niveau]]": // Vent des murmures
                    spell.Range = new SpellRange {SpecificValue = "1,5 km/niveau"};
                    break;

                case "3 ou 9 m (2 ou 6 {s:c})": // Détonation discordante
                    spell.Range = new SpellRange {SpecificValue = "3 ou 9 m (2 ou 6 cases)"};
                    break;

                case "9 ou 18 m (6 ou 12 {s:c})": // Souffle de dragon
                    spell.Range = new SpellRange {SpecificValue = "9 ou 18 m (6 ou 12 cases)"};
                    break;

                case "voir description": // Coffre secret
                case "courte (7,50 m + 1,50 m/2 [[niveau|niveaux]]) (5 {s:c} + 1 {s:c}/2 [[niveau|niveaux]]) (voir description)":
                case "[[présentation des sorts#portee|contact]] (voir description)": // Passage dans l'éther
                case "0 m (voir description)": // Symbole de mort
                case "3 m (voir description)": // Communication avec les apparitions
                case "spéciale (voir description)": // Enchevetrement flamboyant & Flammes de la vengeance
                //case "contact ; voir texte": // Lien sacré
                //case "voir texte": // Vague mondiale
                case "[[présentation des sorts#portee|contact]] et [[présentation des sorts#portee|illimitée]] (voir description)": // Vengeance fantasmagorique
                case "[[personnelle]] ou 1,50 m (1 {s:c}) (voir description)": // Voile d'énergie positive & Voile du paradis
                case "3 km": // Contrôle du climat
                case "7,5 km": // Main du berger
                case "1,5 km": // Oeil indiscret
                case "n’importe où dans la zone défendue": // Défense magique
                case "[[présentation des sorts#portee|personnelle]] ou [[présentation des sorts#portee|contact]]": // Invisibilité, Prémonition et Sphère d'invisibilité
                case "[[personnelle]] ou [[contact]]":
                case "[[personnelle]] ou courte (7,50 m + 1,50 m/2 [[niveau|niveaux]]) (5 {s:c} + 1 {s:c}/2 [[niveau|niveaux]])": // Lévitation
                case "[[personnelle]] et [[contact]]": // Téléportation et Téléportation interplanétaire
                case "[[personnelle]] et [[présentation des sorts#portee|contact]]":
                case "[[personnelle]] ou [[présentation des sorts#portee|contact]]": // Liberté de mouvement, orientation
                case "9 ou 18 m": // Souffle de dragon
                case "[[contact]] (voir description)": // *
                case "[[présentation des sorts#portee|contact]] ou 1,50 m (1 {s:c}) (voir description)": // Manteau de colère
                case "[[contact]] ou 1,50 m (1 {s:c}) (voir description)": // Manteau de colère
                case "[[personnelle]] et courte (7,50 m + 1,50 m/2 [[niveau|niveaux]]) (5 {s:c} + 1 {s:c}/2 [[niveau|niveaux]])": // Lien des esprits combatifs
                case "[[émanation]] de 9 m (6 {s:c}) de rayon centrée sur le lanceur de sorts": // Note pétrifiante
                    spell.Range = new SpellRange
                    {
                        SpecificValue = rangeValue
                            .Replace("[[niveau|niveaux]]", "niveaux")
                            .Replace("[[", string.Empty)
                            .Replace("]]", string.Empty)
                            .Replace("{s:c}", "case(s)")
                    };
                    break;

                default:
                    log.Warning("{0}: Portée non reconnue \"{1}\"", spell.Name, rangeValue);
                    spell.Range = new SpellRange
                    {
                        SpecificValue = MarkupUtil.RemoveMarkup(rangeValue)
                    };
                    break;
            }

            if (spell.Range != null)
            {
                return;
            }

            const string meterRange = "^(\\d+) m$";

            match = Regex.Match(rangeValue, meterRange, RegexOptions.CultureInvariant);

            if (match.Success)
            {
            }
        }
 private string AsSourceLabel(Spell spell)
 {
     switch (spell.Source.Id)
     {
         case Source.Ids.PathfinderRpg:
             return "PHB";
         case Source.Ids.AdvancedPlayerGuide:
             return "APG";
         case Source.Ids.UltimateMagic:
             return "UM";
         case Source.Ids.UltimateCombat:
             return "UC";
         default:
             return string.Empty;
     }
 }
        private static string GetSpellListLevel(Spell spell, string spellListId)
        {
            var level = spell.Levels.FirstOrDefault(l => l.List == spellListId);

            return level != null ? level.Level.ToString() : string.Empty;
        }
        private static string GetLocalizedEntry(Spell spell, string language, string href, string defaultValue = null)
        {
            if (spell.Localization == null)
                return defaultValue;

            return spell.Localization.GetLocalizedEntry(language, href, defaultValue);
        }
        public static void ParseComponents(string html, Spell spell, ILog log)
        {
            var match = Regex.Match(html, Pattern, RegexOptions.CultureInvariant | RegexOptions.IgnoreCase);

            if (!match.Success)
            {
                if (!noComponentSpells.Contains(spell.Id))
                {
                    throw new ParseException($"Composantes introuvables pour l'id {spell.Id}");
                }
                // composantes ignorée
                return;
            }

            spell.Components = new SpellComponents();

            var components = match.Groups["Value"].Value.Split(',').Select(s => s.Trim().ToLowerInvariant());

            foreach (var c in components)
            {
                switch (c)
                {
                    case "m":
                        spell.Components.Kinds |= SpellComponentKinds.Material;
                        break;

                    case "v":
                        spell.Components.Kinds |= SpellComponentKinds.Verbal;
                        break;

                    case "g":
                    case "s": // Désactiver pour trouver tous les sorts de l'APG avec le bug
                        spell.Components.Kinds |= SpellComponentKinds.Somatic;
                        break;

                    case "fd":
                        spell.Components.Kinds |= SpellComponentKinds.DivineFocus;
                        break;

                    case "f":
                        spell.Components.Kinds |= SpellComponentKinds.Focus;
                        break;

                    case "m/fd":
                    case "fd/m":
                        spell.Components.Kinds |= SpellComponentKinds.MaterialOrDivineFocus;
                        break;

                    case "f/fd":
                    case "fd/f":
                        spell.Components.Kinds |= SpellComponentKinds.FocusOrDivineFocus;
                        break;

                    default:
                        throw new ParseException("Formule de composantes inconnue");
                }
            }

            var comment = match.Groups["Comment"].Value.Trim();

            if (comment.Length > 1)
            {
                if (comment[0] == '(' && comment[comment.Length - 1] == ')')
                {
                    comment = comment.Substring(1, comment.Length - 2);
                }
            }

            spell.Components.Description = MarkupUtil.RemoveMarkup(comment);
        }
        public static void ParseMagicResistance(string html, Spell spell, ILog log)
        {
            const string pattern = "'''Résistance à la magie''' ";
            var i = html.IndexOf(pattern, StringComparison.Ordinal);

            var spellResist = spell.SpellResistance = new SpellResistance();

            if (i == -1)
            {
                //throw new ParseException("Résistance à la magie introuvable");
                spellResist.Resist = SpecialBoolean.No;
                return;
            }

            var eol = html.IndexOf('\n', i);

            if (eol == -1)
            {
                throw new ParseException("Résistance à la magie mal formée");
            }

            i += pattern.Length;

            // La valeur de résistance à la magie est la fin de la phrase
            var value = html.Substring(i, eol - i);

            // On conserve la valeur originale (si la détection échoue, c'est elle que l'on indiquera)
            var originalValue = value;

            // On supprime les éventuels liens indiqués en fin de RM
            value = Regex.Replace(value.ToLowerInvariant(), RemoveMarkupPattern, "$2").Trim();

            switch (value)
            {
                case No:
                    // Il ne reste plus que le texte "non" comme valeur, on le renvoie
                    spellResist.Resist = SpecialBoolean.No;
                    return;

                case Yes:
                    // Il ne reste plus que le texte "oui" comme valeur, on le renvoie
                    spellResist.Resist = SpecialBoolean.Yes;
                    return;
            }

            // On va tenter de déchiffrer la valeur spécifique de RM indiquée
            var match = Regex.Match(value, RMPattern, RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);

            if (!match.Success)
            {
                // On a pas pu détecter le type de RM, on renvoie spécial
                spellResist.Resist = SpecialBoolean.Special;
                spellResist.Text = MarkupUtil.RemoveMarkup(originalValue).Trim();
                return;
            }

            switch (match.Groups["val"].Value.ToLowerInvariant())
            {
                case Yes:
                    spellResist.Resist = SpecialBoolean.Yes;
                    break;

                case No:
                    spellResist.Resist = SpecialBoolean.No;
                    break;
            }

            foreach (var capture in match.Groups["word"].Captures.Cast<Capture>())
            {
                switch (capture.Value.ToLowerInvariant())
                {
                    case "voir description":
                    case "voir texte":
                    case "spécial":
                        spellResist.Text = value;
                        break;

                    case "inoffensif":
                        spellResist.Harmless = true;
                        break;

                    case "objet":
                    case "[[présentation des sorts#jetsdesauvegarde|objet]]":
                        spellResist.Objects = true;
                        break;

                    default:
                        // ??
                        throw new ParseException(string.Format("Détail de RM non reconnu : {0}", capture.Value));
                }
            }
        }