5E/AideDeJeu
1
0
Fork 0
mirror of https://github.com/Nioux/AideDeJeu.git synced 2025-10-29 14:35:45 +00:00
Code Issues Projects Releases Wiki Activity

Nouveau format générique adopté ;)

Browse source
This commit is contained in:
Yan Maniez 2018-07-13 17:44:14 +02:00
parent 72587c773a
commit b560df7e37
6 changed files with 390 additions and 17 deletions
Download patch file Download diff file Expand all files Collapse all files

102
AideDeJeu/AideDeJeu/Models/Conditions/Condition.cs
View file

@ -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("(?<key>.*?): (?<value>.*)");
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<Tuple<string, Action<Condition, string>>>()
{
new Tuple<string, Action<Condition, string>>("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();
}
}
}
}

282
AideDeJeu/AideDeJeu/Models/Monsters/Monster.cs
View file

@ -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<string> Reactions { get; set; }
public IEnumerable<string> LegendaryActions { get; set; }
public override void Parse(ref ContainerBlock.Enumerator enumerator)
{
List<string> features = null;
//List<string> specialFeatures = null;
//List<string> actions = null;
//List<string> reactions = null;
//List<string> 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<string>();
break;
case "Actions":
Actions = features = new List<string>();
break;
case "Réaction":
case "Réactions":
case "Reaction":
case "Reactions":
Reactions = features = new List<string>();
break;
case "Actions légendaires":
case "Legendary Actions":
LegendaryActions = features = new List<string>();
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("(?<key>.*?): (?<value>.*)");
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<Tuple<string, System.Action<Monster, string>>>()
{
new Tuple<string, Action<Monster, string>>("**Classe d'armure** ", (m, s) => m.ArmorClass = s),
new Tuple<string, Action<Monster, string>>("**Points de vie** ", (m, s) => m.HitPoints = s),
new Tuple<string, Action<Monster, string>>("**Vitesse** ", (m, s) => m.Speed = s),
new Tuple<string, Action<Monster, string>>("**Résistance aux dégâts** ", (m, s) => m.DamageResistances = s),
new Tuple<string, Action<Monster, string>>("**Résistances aux dégâts** ", (m, s) => m.DamageResistances = s),
new Tuple<string, Action<Monster, string>>("**Résistance contre les dégâts** ", (m, s) => m.DamageResistances = s),
new Tuple<string, Action<Monster, string>>("**Résistances contre les dégâts** ", (m, s) => m.DamageResistances = s),
new Tuple<string, Action<Monster, string>>("**Immunité contre les dégâts** ", (m, s) => m.DamageImmunities = s),
new Tuple<string, Action<Monster, string>>("**Immunité contre des dégâts** ", (m, s) => m.DamageImmunities = s),
new Tuple<string, Action<Monster, string>>("**Immunité aux dégâts** ", (m, s) => m.DamageImmunities = s),
new Tuple<string, Action<Monster, string>>("**Immunité à l'état** ", (m, s) => m.ConditionImmunities = s),
new Tuple<string, Action<Monster, string>>("**Immunités à l'état** ", (m, s) => m.ConditionImmunities = s),
new Tuple<string, Action<Monster, string>>("**Immunité contre l'état** ", (m, s) => m.ConditionImmunities = s),
new Tuple<string, Action<Monster, string>>("**Immunité contre les états** ", (m, s) => m.ConditionImmunities = s),
new Tuple<string, Action<Monster, string>>("**Immunités contre les états** ", (m, s) => m.ConditionImmunities = s),
new Tuple<string, Action<Monster, string>>("**Vulnérabilité aux dégâts** ", (m, s) => m.DamageVulnerabilities = s),
new Tuple<string, Action<Monster, string>>("**Vulnérabilité contre les dégâts** ", (m, s) => m.DamageVulnerabilities = s),
new Tuple<string, Action<Monster, string>>("**Vulnérabilité** ", (m, s) => m.DamageVulnerabilities = s),
new Tuple<string, Action<Monster, string>>("**Sens** ", (m, s) => m.Senses = s),
new Tuple<string, Action<Monster, string>>("**Langue** ", (m, s) => m.Languages = s),
new Tuple<string, Action<Monster, string>>("**Langues** ", (m, s) => m.Languages = s),
new Tuple<string, Action<Monster, string>>("**Dangerosité** ", (m, s) => m.Challenge = s),
new Tuple<string, Action<Monster, string>>("**Jets de sauvegarde** ", (m, s) => m.SavingThrows = s),
new Tuple<string, Action<Monster, string>>("**Jet de sauvegarde** ", (m, s) => m.SavingThrows = s),
new Tuple<string, Action<Monster, string>>("**Compétences** ", (m, s) => m.Skills = s),
new Tuple<string, Action<Monster, string>>("**Compétence** ", (m, s) => m.Skills = s),
new Tuple<string, Action<Monster, string>>("**Armor Class** ", (m, s) => m.ArmorClass = s),
new Tuple<string, Action<Monster, string>>("**Hit Points** ", (m, s) => m.HitPoints = s),
new Tuple<string, Action<Monster, string>>("**Speed** ", (m, s) => m.Speed = s),
new Tuple<string, Action<Monster, string>>("**Damage Resistance** ", (m, s) => m.DamageResistances = s),
new Tuple<string, Action<Monster, string>>("**Damage Resistances** ", (m, s) => m.DamageResistances = s),
new Tuple<string, Action<Monster, string>>("**Résistance contre les dégâts** ", (m, s) => m.DamageResistances = s),
new Tuple<string, Action<Monster, string>>("**Résistances contre les dégâts** ", (m, s) => m.DamageResistances = s),
new Tuple<string, Action<Monster, string>>("**Damage Immunities** ", (m, s) => m.DamageImmunities = s),
new Tuple<string, Action<Monster, string>>("**Immunité contre des dégâts** ", (m, s) => m.DamageImmunities = s),
new Tuple<string, Action<Monster, string>>("**Immunité aux dégâts** ", (m, s) => m.DamageImmunities = s),
new Tuple<string, Action<Monster, string>>("**Condition Immunities** ", (m, s) => m.ConditionImmunities = s),
new Tuple<string, Action<Monster, string>>("**Immunités à l'état** ", (m, s) => m.ConditionImmunities = s),
new Tuple<string, Action<Monster, string>>("**Immunité contre l'état** ", (m, s) => m.ConditionImmunities = s),
new Tuple<string, Action<Monster, string>>("**Immunité contre les états** ", (m, s) => m.ConditionImmunities = s),
new Tuple<string, Action<Monster, string>>("**Immunités contre les états** ", (m, s) => m.ConditionImmunities = s),
new Tuple<string, Action<Monster, string>>("**Damage Vulnerabilities** ", (m, s) => m.DamageVulnerabilities = s),
new Tuple<string, Action<Monster, string>>("**Vulnérabilité contre les dégâts** ", (m, s) => m.DamageVulnerabilities = s),
new Tuple<string, Action<Monster, string>>("**Vulnérabilité** ", (m, s) => m.DamageVulnerabilities = s),
new Tuple<string, Action<Monster, string>>("**Senses** ", (m, s) => m.Senses = s),
new Tuple<string, Action<Monster, string>>("**Languages** ", (m, s) => m.Languages = s),
new Tuple<string, Action<Monster, string>>("**Langues** ", (m, s) => m.Languages = s),
new Tuple<string, Action<Monster, string>>("**Challenge** ", (m, s) => m.Challenge = s),
new Tuple<string, Action<Monster, string>>("**Saving Throws** ", (m, s) => m.SavingThrows = s),
new Tuple<string, Action<Monster, string>>("**Jet de sauvegarde** ", (m, s) => m.SavingThrows = s),
new Tuple<string, Action<Monster, string>>("**Skills** ", (m, s) => m.Skills = s),
new Tuple<string, Action<Monster, string>>("**Compétence** ", (m, s) => m.Skills = s),
new Tuple<string, Action<Monster, string>>("NameVO: ", (m, s) => m.NameVO = s),
new Tuple<string, Action<Monster, string>>("", (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("(?<type>.*) de taille (?<size>.*), (?<alignment>.*)");
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("(?<size>.*?) (?<type>.*?), (?<alignment>.*)");
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;
//}
}
}
}

5
AideDeJeu/AideDeJeu/Models/Monsters/MonsterHD.cs
View file

@ -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();
}
}
}

5
AideDeJeu/AideDeJeu/Models/Monsters/MonsterVO.cs
View file

@ -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();
}
}
}

12
AideDeJeu/AideDeJeu/ViewModels/ItemsViewModel.cs
View file

@ -39,7 +39,8 @@ namespace AideDeJeu.ViewModels
{
resourceName = "AideDeJeu.Data.monsters_vo.md";
var md = await Tools.Helpers.GetResourceStringAsync(resourceName);
_AllItems = Tools.MarkdownExtensions.MarkdownToMonsters<MonsterVO>(md);
_AllItems = Tools.MarkdownExtensions.ToItem(md) as IEnumerable<Item>;
//_AllItems = Tools.MarkdownExtensions.MarkdownToMonsters<MonsterVO>(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<MonsterHD>(md);
_AllItems = Tools.MarkdownExtensions.ToItem(md) as IEnumerable<Item>;
//_AllItems = Tools.MarkdownExtensions.MarkdownToMonsters<MonsterHD>(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<AideDeJeuLib.Condition>(md);
_AllItems = Tools.MarkdownExtensions.ToItem(md) as IEnumerable<Item>;
//_AllItems = Tools.MarkdownExtensions.MarkdownToConditions<AideDeJeuLib.Condition>(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<AideDeJeuLib.Condition>(md);
_AllItems = Tools.MarkdownExtensions.ToItem(md) as IEnumerable<Item>;
//_AllItems = Tools.MarkdownExtensions.MarkdownToConditions<AideDeJeuLib.Condition>(md);
}
break;
}

1
Data/monsters_hd.md
View file

@ -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]