From b560df7e37b09f68f595efd288b4c4141cd52061 Mon Sep 17 00:00:00 2001 From: Yan Maniez Date: Fri, 13 Jul 2018 17:44:14 +0200 Subject: [PATCH] =?UTF-8?q?Nouveau=20format=20g=C3=A9n=C3=A9rique=20adopt?= =?UTF-8?q?=C3=A9=20;)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../AideDeJeu/Models/Conditions/Condition.cs | 102 ++++++- .../AideDeJeu/Models/Monsters/Monster.cs | 282 +++++++++++++++++- .../AideDeJeu/Models/Monsters/MonsterHD.cs | 5 - .../AideDeJeu/Models/Monsters/MonsterVO.cs | 5 - .../AideDeJeu/ViewModels/ItemsViewModel.cs | 12 +- Data/monsters_hd.md | 1 - 6 files changed, 390 insertions(+), 17 deletions(-) diff --git a/AideDeJeu/AideDeJeu/Models/Conditions/Condition.cs b/AideDeJeu/AideDeJeu/Models/Conditions/Condition.cs index 63a63aa8..a1e6c62f 100644 --- a/AideDeJeu/AideDeJeu/Models/Conditions/Condition.cs +++ b/AideDeJeu/AideDeJeu/Models/Conditions/Condition.cs @@ -1,6 +1,8 @@ using System; using System.Collections.Generic; using System.Text; +using System.Text.RegularExpressions; +using AideDeJeu.Tools; using Markdig.Syntax; namespace AideDeJeuLib @@ -22,7 +24,105 @@ namespace AideDeJeuLib public override void Parse(ref ContainerBlock.Enumerator enumerator) { - throw new NotImplementedException(); + enumerator.MoveNext(); + while (enumerator.Current != null) + { + var block = enumerator.Current; + //DumpBlock(block); + if (block is Markdig.Syntax.HeadingBlock) + { + var headingBlock = block as Markdig.Syntax.HeadingBlock; + //DumpHeadingBlock(headingBlock); + if (headingBlock.HeaderChar == '#' && (headingBlock.Level == 1 || headingBlock.Level == 2)) + { + if (this.Name != null) + { + return; + //yield return spell; + } + this.Name = headingBlock.Inline.ToMarkdownString(); + //Console.WriteLine(spell.Name); + } + } + if (block is Markdig.Syntax.ParagraphBlock) + { + if (block.IsNewItem()) + { + return; + } + var paragraphBlock = block as Markdig.Syntax.ParagraphBlock; + this.Text += MarkdownExtensions.MarkdownToHtml(paragraphBlock.ToMarkdownString()) + "\n"; + } + if (block is Markdig.Syntax.ListBlock) + { + var listBlock = block as Markdig.Syntax.ListBlock; + //DumpListBlock(listBlock); + if (listBlock.BulletType == '-') + { + foreach (var inblock in listBlock) + { + //DumpBlock(inblock); + var regex = new Regex("(?.*?): (?.*)"); + if (inblock is Markdig.Syntax.ListItemBlock) + { + var listItemBlock = inblock as Markdig.Syntax.ListItemBlock; + foreach (var ininblock in listItemBlock) + { + //DumpBlock(ininblock); + if (ininblock is Markdig.Syntax.ParagraphBlock) + { + var paragraphBlock = ininblock as Markdig.Syntax.ParagraphBlock; + //DumpParagraphBlock(paragraphBlock); + var str = paragraphBlock.Inline.ToMarkdownString(); + + var properties = new List>>() + { + new Tuple>("NameVO: ", (m, s) => m.NameVO = s), + }; + + foreach (var property in properties) + { + if (str.StartsWith(property.Item1)) + { + property.Item2.Invoke(this, str.Substring(property.Item1.Length)); + break; + } + } + + } + } + } + } + } + else + { + foreach (var inblock in listBlock) + { + if (inblock is Markdig.Syntax.ListItemBlock) + { + var listItemBlock = inblock as Markdig.Syntax.ListItemBlock; + foreach (var ininblock in listItemBlock) + { + //DumpBlock(ininblock); + if (ininblock is Markdig.Syntax.ParagraphBlock) + { + var paragraphBlock = ininblock as Markdig.Syntax.ParagraphBlock; + this.Text += listBlock.BulletType + " " + MarkdownExtensions.MarkdownToHtml(paragraphBlock.ToMarkdownString()) + "\n"; + } + } + } + } + } + } + else if (block is Markdig.Extensions.Tables.Table) + { + var tableBlock = block as Markdig.Extensions.Tables.Table; + this.Text += "\n\n" + tableBlock.ToMarkdownString() + "\n\n"; + } + + enumerator.MoveNext(); + + } } } } diff --git a/AideDeJeu/AideDeJeu/Models/Monsters/Monster.cs b/AideDeJeu/AideDeJeu/Models/Monsters/Monster.cs index 792f386c..7f9b22a8 100644 --- a/AideDeJeu/AideDeJeu/Models/Monsters/Monster.cs +++ b/AideDeJeu/AideDeJeu/Models/Monsters/Monster.cs @@ -1,4 +1,8 @@ -using System.Collections.Generic; +using AideDeJeu; +using AideDeJeu.Tools; +using Markdig.Syntax; +using System; +using System.Collections.Generic; using System.Linq; using System.Runtime.Serialization; using System.Text.RegularExpressions; @@ -38,5 +42,281 @@ namespace AideDeJeuLib public IEnumerable Reactions { get; set; } public IEnumerable LegendaryActions { get; set; } + + public override void Parse(ref ContainerBlock.Enumerator enumerator) + { + List features = null; + //List specialFeatures = null; + //List actions = null; + //List reactions = null; + //List legendaryActions = null; + enumerator.MoveNext(); + //try + //{ + while (enumerator.Current != null) + { + var block = enumerator.Current; + //Debug.WriteLine(block.GetType()); + //DumpBlock(block); + if (block is Markdig.Syntax.HeadingBlock) + { + var headingBlock = block as Markdig.Syntax.HeadingBlock; + //DumpHeadingBlock(headingBlock); + if (headingBlock.HeaderChar == '#' && headingBlock.Level == 1) + { + if (this.Name != null) + { + return; + } + this.Name = headingBlock.Inline.ToMarkdownString(); + //Console.WriteLine(spell.Name); + } + if (headingBlock.HeaderChar == '#' && headingBlock.Level == 2) + { + switch (headingBlock.Inline.ToMarkdownString()) + { + case "Capacités": + case "Special Features": + SpecialFeatures = features = new List(); + break; + case "Actions": + Actions = features = new List(); + break; + case "Réaction": + case "Réactions": + case "Reaction": + case "Reactions": + Reactions = features = new List(); + break; + case "Actions légendaires": + case "Legendary Actions": + LegendaryActions = features = new List(); + break; + default: + App.Current.MainPage.DisplayAlert("Erreur de parsing", headingBlock.Inline.ToMarkdownString(), "OK"); + break; + } + } + } + else if (block is Markdig.Syntax.ParagraphBlock) + { + if (block.IsNewItem()) + { + return; + } + var paragraphBlock = block as Markdig.Syntax.ParagraphBlock; + features?.Add(paragraphBlock.ToMarkdownString()); + ////DumpParagraphBlock(paragraphBlock); + //Console.WriteLine(paragraphBlock.IsBreakable); + //spell.DescriptionHtml += paragraphBlock.Inline.ToContainerString(); + //if(paragraphBlock.IsBreakable) + //{ + // spell.DescriptionHtml += "\n"; + //} + } + else if (block is Markdig.Syntax.ListBlock) + { + var listBlock = block as Markdig.Syntax.ListBlock; + //DumpListBlock(listBlock); + if (listBlock.BulletType == '-') + { + this.Source = ""; + foreach (var inblock in listBlock) + { + //DumpBlock(inblock); + var regex = new Regex("(?.*?): (?.*)"); + if (inblock is Markdig.Syntax.ListItemBlock) + { + var listItemBlock = inblock as Markdig.Syntax.ListItemBlock; + foreach (var ininblock in listItemBlock) + { + //DumpBlock(ininblock); + if (ininblock is Markdig.Syntax.ParagraphBlock) + { + var paragraphBlock = ininblock as Markdig.Syntax.ParagraphBlock; + //DumpParagraphBlock(paragraphBlock); + var str = paragraphBlock.Inline.ToMarkdownString(); + + var properties = new List>>() + { + new Tuple>("**Classe d'armure** ", (m, s) => m.ArmorClass = s), + new Tuple>("**Points de vie** ", (m, s) => m.HitPoints = s), + new Tuple>("**Vitesse** ", (m, s) => m.Speed = s), + new Tuple>("**Résistance aux dégâts** ", (m, s) => m.DamageResistances = s), + new Tuple>("**Résistances aux dégâts** ", (m, s) => m.DamageResistances = s), + new Tuple>("**Résistance contre les dégâts** ", (m, s) => m.DamageResistances = s), + new Tuple>("**Résistances contre les dégâts** ", (m, s) => m.DamageResistances = s), + new Tuple>("**Immunité contre les dégâts** ", (m, s) => m.DamageImmunities = s), + new Tuple>("**Immunité contre des dégâts** ", (m, s) => m.DamageImmunities = s), + new Tuple>("**Immunité aux dégâts** ", (m, s) => m.DamageImmunities = s), + new Tuple>("**Immunité à l'état** ", (m, s) => m.ConditionImmunities = s), + new Tuple>("**Immunités à l'état** ", (m, s) => m.ConditionImmunities = s), + new Tuple>("**Immunité contre l'état** ", (m, s) => m.ConditionImmunities = s), + new Tuple>("**Immunité contre les états** ", (m, s) => m.ConditionImmunities = s), + new Tuple>("**Immunités contre les états** ", (m, s) => m.ConditionImmunities = s), + new Tuple>("**Vulnérabilité aux dégâts** ", (m, s) => m.DamageVulnerabilities = s), + new Tuple>("**Vulnérabilité contre les dégâts** ", (m, s) => m.DamageVulnerabilities = s), + new Tuple>("**Vulnérabilité** ", (m, s) => m.DamageVulnerabilities = s), + new Tuple>("**Sens** ", (m, s) => m.Senses = s), + new Tuple>("**Langue** ", (m, s) => m.Languages = s), + new Tuple>("**Langues** ", (m, s) => m.Languages = s), + new Tuple>("**Dangerosité** ", (m, s) => m.Challenge = s), + new Tuple>("**Jets de sauvegarde** ", (m, s) => m.SavingThrows = s), + new Tuple>("**Jet de sauvegarde** ", (m, s) => m.SavingThrows = s), + new Tuple>("**Compétences** ", (m, s) => m.Skills = s), + new Tuple>("**Compétence** ", (m, s) => m.Skills = s), + + new Tuple>("**Armor Class** ", (m, s) => m.ArmorClass = s), + new Tuple>("**Hit Points** ", (m, s) => m.HitPoints = s), + new Tuple>("**Speed** ", (m, s) => m.Speed = s), + new Tuple>("**Damage Resistance** ", (m, s) => m.DamageResistances = s), + new Tuple>("**Damage Resistances** ", (m, s) => m.DamageResistances = s), + new Tuple>("**Résistance contre les dégâts** ", (m, s) => m.DamageResistances = s), + new Tuple>("**Résistances contre les dégâts** ", (m, s) => m.DamageResistances = s), + new Tuple>("**Damage Immunities** ", (m, s) => m.DamageImmunities = s), + new Tuple>("**Immunité contre des dégâts** ", (m, s) => m.DamageImmunities = s), + new Tuple>("**Immunité aux dégâts** ", (m, s) => m.DamageImmunities = s), + new Tuple>("**Condition Immunities** ", (m, s) => m.ConditionImmunities = s), + new Tuple>("**Immunités à l'état** ", (m, s) => m.ConditionImmunities = s), + new Tuple>("**Immunité contre l'état** ", (m, s) => m.ConditionImmunities = s), + new Tuple>("**Immunité contre les états** ", (m, s) => m.ConditionImmunities = s), + new Tuple>("**Immunités contre les états** ", (m, s) => m.ConditionImmunities = s), + new Tuple>("**Damage Vulnerabilities** ", (m, s) => m.DamageVulnerabilities = s), + new Tuple>("**Vulnérabilité contre les dégâts** ", (m, s) => m.DamageVulnerabilities = s), + new Tuple>("**Vulnérabilité** ", (m, s) => m.DamageVulnerabilities = s), + new Tuple>("**Senses** ", (m, s) => m.Senses = s), + new Tuple>("**Languages** ", (m, s) => m.Languages = s), + new Tuple>("**Langues** ", (m, s) => m.Languages = s), + new Tuple>("**Challenge** ", (m, s) => m.Challenge = s), + new Tuple>("**Saving Throws** ", (m, s) => m.SavingThrows = s), + new Tuple>("**Jet de sauvegarde** ", (m, s) => m.SavingThrows = s), + new Tuple>("**Skills** ", (m, s) => m.Skills = s), + new Tuple>("**Compétence** ", (m, s) => m.Skills = s), + + new Tuple>("NameVO: ", (m, s) => m.NameVO = s), + + new Tuple>("", (m,s) => + { + if (!string.IsNullOrEmpty(m.Alignment)) + { + App.Current.MainPage.DisplayAlert("Erreur de parsing", s, "OK"); + } + else + { + //Debug.Assert(monster.Alignment == null, str); + var regexx = new Regex("(?.*) de taille (?.*), (?.*)"); + var matchh = regexx.Match(s); + m.Alignment = matchh.Groups["alignment"].Value; + m.Size = matchh.Groups["size"].Value; + m.Type = matchh.Groups["type"].Value; + if(string.IsNullOrEmpty(m.Alignment)) + { + regexx = new Regex("(?.*?) (?.*?), (?.*)"); + matchh = regexx.Match(s); + m.Alignment = matchh.Groups["alignment"].Value; + m.Size = matchh.Groups["size"].Value; + m.Type = matchh.Groups["type"].Value; + } + } + }) + }; + + foreach (var property in properties) + { + if (str.StartsWith(property.Item1)) + { + property.Item2.Invoke(this, str.Substring(property.Item1.Length)); + break; + } + } + } + } + + //DumpListItemBlock(inblock as Markdig.Syntax.ListItemBlock); + } + } + } + else + { + foreach (var inblock in listBlock) + { + if (inblock is Markdig.Syntax.ListItemBlock) + { + var listItemBlock = inblock as Markdig.Syntax.ListItemBlock; + foreach (var ininblock in listItemBlock) + { + //DumpBlock(ininblock); + if (ininblock is Markdig.Syntax.ParagraphBlock) + { + var paragraphBlock = ininblock as Markdig.Syntax.ParagraphBlock; + features?.Add(listBlock.BulletType + " " + paragraphBlock.ToMarkdownString()); + } + } + } + } + } + } + else if (block is Markdig.Extensions.Tables.Table) + { + var tableBlock = block as Markdig.Extensions.Tables.Table; + var table = tableBlock.ToTable(); + if (table.ContainsKey("FOR")) + { + this.Strength = table["FOR"].FirstOrDefault(); + this.Dexterity = table["DEX"].FirstOrDefault(); + this.Constitution = table["CON"].FirstOrDefault(); + this.Intelligence = table["INT"].FirstOrDefault(); + this.Wisdom = table["SAG"].FirstOrDefault(); + this.Charisma = table["CHA"].FirstOrDefault(); + } + else if (table.ContainsKey("STR")) + { + this.Strength = table["STR"].FirstOrDefault(); + this.Dexterity = table["DEX"].FirstOrDefault(); + this.Constitution = table["CON"].FirstOrDefault(); + this.Intelligence = table["INT"].FirstOrDefault(); + this.Wisdom = table["WIS"].FirstOrDefault(); + this.Charisma = table["CHA"].FirstOrDefault(); + } + //else + //{ + features?.Add(tableBlock.ToMarkdownString()); + //} + } + else if (block is Markdig.Syntax.LinkReferenceDefinitionGroup) + { + + var linkReferenceDefinitionGroup = block as Markdig.Syntax.LinkReferenceDefinitionGroup; + + foreach (var linkBlock in linkReferenceDefinitionGroup) + { + var linkReferenceDefinition = linkBlock as Markdig.Syntax.LinkReferenceDefinition; + //linkReferenceDefinition. + } + } + else if (block is Markdig.Syntax.LinkReferenceDefinition) + { + //Debug.WriteLine(block.GetType()); + } + else + { + //Debug.WriteLine(block.GetType()); + } + enumerator.MoveNext(); + } + //} + //finally + + ////if (monster != null) + //{ + // this.SpecialFeatures = specialFeatures; + // this.Actions = actions; + // this.Reactions = reactions; + // this.LegendaryActions = legendaryActions; + // //yield return monster; + //} + } + + } } diff --git a/AideDeJeu/AideDeJeu/Models/Monsters/MonsterHD.cs b/AideDeJeu/AideDeJeu/Models/Monsters/MonsterHD.cs index 7afccf00..f914ef09 100644 --- a/AideDeJeu/AideDeJeu/Models/Monsters/MonsterHD.cs +++ b/AideDeJeu/AideDeJeu/Models/Monsters/MonsterHD.cs @@ -37,10 +37,5 @@ namespace AideDeJeuLib (LegendaryActions != null ? $"## Actions Légendaires\n\n" + LegendaryActions.Aggregate((s1, s2) => s1 + "\n\n" + s2) : ""); } } - - public override void Parse(ref ContainerBlock.Enumerator enumerator) - { - throw new NotImplementedException(); - } } } \ No newline at end of file diff --git a/AideDeJeu/AideDeJeu/Models/Monsters/MonsterVO.cs b/AideDeJeu/AideDeJeu/Models/Monsters/MonsterVO.cs index 03d2b91f..ebe0b7c2 100644 --- a/AideDeJeu/AideDeJeu/Models/Monsters/MonsterVO.cs +++ b/AideDeJeu/AideDeJeu/Models/Monsters/MonsterVO.cs @@ -37,10 +37,5 @@ namespace AideDeJeuLib (LegendaryActions != null ? $"## Legendary Actions\n\n" + LegendaryActions.Aggregate((s1, s2) => s1 + "\n\n" + s2) : ""); } } - - public override void Parse(ref ContainerBlock.Enumerator enumerator) - { - throw new NotImplementedException(); - } } } diff --git a/AideDeJeu/AideDeJeu/ViewModels/ItemsViewModel.cs b/AideDeJeu/AideDeJeu/ViewModels/ItemsViewModel.cs index 49b6f29b..fe7c948e 100644 --- a/AideDeJeu/AideDeJeu/ViewModels/ItemsViewModel.cs +++ b/AideDeJeu/AideDeJeu/ViewModels/ItemsViewModel.cs @@ -39,7 +39,8 @@ namespace AideDeJeu.ViewModels { resourceName = "AideDeJeu.Data.monsters_vo.md"; var md = await Tools.Helpers.GetResourceStringAsync(resourceName); - _AllItems = Tools.MarkdownExtensions.MarkdownToMonsters(md); + _AllItems = Tools.MarkdownExtensions.ToItem(md) as IEnumerable; + //_AllItems = Tools.MarkdownExtensions.MarkdownToMonsters(md); } break; case ItemSourceType.MonsterHD: @@ -47,7 +48,8 @@ namespace AideDeJeu.ViewModels resourceName = "AideDeJeu.Data.monsters_hd.md"; //var md = await Tools.Helpers.GetStringFromUrl("https://raw.githubusercontent.com/Nioux/AideDeJeu/master/Data/monsters_hd.md"); var md = await Tools.Helpers.GetResourceStringAsync(resourceName); - _AllItems = Tools.MarkdownExtensions.MarkdownToMonsters(md); + _AllItems = Tools.MarkdownExtensions.ToItem(md) as IEnumerable; + //_AllItems = Tools.MarkdownExtensions.MarkdownToMonsters(md); } break; case ItemSourceType.SpellVO: @@ -71,7 +73,8 @@ namespace AideDeJeu.ViewModels { resourceName = "AideDeJeu.Data.conditions_vo.md"; var md = await Tools.Helpers.GetResourceStringAsync(resourceName); - _AllItems = Tools.MarkdownExtensions.MarkdownToConditions(md); + _AllItems = Tools.MarkdownExtensions.ToItem(md) as IEnumerable; + //_AllItems = Tools.MarkdownExtensions.MarkdownToConditions(md); } break; case ItemSourceType.ConditionHD: @@ -79,7 +82,8 @@ namespace AideDeJeu.ViewModels resourceName = "AideDeJeu.Data.conditions_hd.md"; //var md = await Tools.Helpers.GetStringFromUrl("https://raw.githubusercontent.com/Nioux/AideDeJeu/master/Data/spells_hd.md"); var md = await Tools.Helpers.GetResourceStringAsync(resourceName); - _AllItems = Tools.MarkdownExtensions.MarkdownToConditions(md); + _AllItems = Tools.MarkdownExtensions.ToItem(md) as IEnumerable; + //_AllItems = Tools.MarkdownExtensions.MarkdownToConditions(md); } break; } diff --git a/Data/monsters_hd.md b/Data/monsters_hd.md index 2feb9354..89b44ff8 100644 --- a/Data/monsters_hd.md +++ b/Data/monsters_hd.md @@ -56,7 +56,6 @@ L'aboleth peut effectuer 3 actions légendaires qu'il choisit parmi celles décr **Succion psychique (coûte 2 actions).** Une créature [charmée] par l'aboleth subit 10 (3d6) dégâts psychiques et l'aboleth récupère un nombre de points de vie égal aux dégâts subis par la créature. -![](https://raw.githubusercontent.com/Nioux/AideDeJeu/master/Data/Monsters/aboleth.jpg) [][MonsterHD]