private void ReadXMLFile(string fileLocation)
{
XMLImporter xmlImporter = new XMLImporter(_stringService);
xmlImporter.LoadFileXML(fileLocation);
_backgrounds = xmlImporter.ReadBackgrounds();
_classes = xmlImporter.ReadClasses();
_conditions = xmlImporter.ReadConditions();
_feats = xmlImporter.ReadFeats();
_items = xmlImporter.ReadItems();
_monsters = xmlImporter.ReadMonsters();
_races = xmlImporter.ReadRaces();
_spells = xmlImporter.ReadSpells();
_languages = xmlImporter.LanguagesFound;
OnPropertyChanged(nameof(BackgroundCount));
OnPropertyChanged(nameof(ClassCount));
OnPropertyChanged(nameof(ConditionCount));
OnPropertyChanged(nameof(FeatCount));
OnPropertyChanged(nameof(ItemCount));
OnPropertyChanged(nameof(LanguageCount));
OnPropertyChanged(nameof(MonsterCount));
OnPropertyChanged(nameof(RaceCount));
OnPropertyChanged(nameof(SpellCount));
}
/// <summary>
/// Loads feats from the default save file location
/// </summary>
public IEnumerable <FeatModel> LoadFeats()
{
List <FeatModel> feats = new List <FeatModel>();
string path = Path.Combine(_saveDataFolder, _featsSaveFileName);
if (File.Exists(path))
{
string xml = File.ReadAllText(path, Encoding.UTF8);
feats = _xmlImporter.ReadFeats(xml);
}
return(feats);
}
/// <summary>
/// Loads the default compendium.
/// </summary>
public void LoadDefaultCompendium()
{
XMLImporter importer = DependencyResolver.Resolve <XMLImporter>();
importer.LoadManifestResourceXML("default_compendium.xml");
_backgrounds = importer.ReadBackgrounds();
_classes = importer.ReadClasses();
_conditions = importer.ReadConditions();
_feats = importer.ReadFeats();
_items = importer.ReadItems();
_monsters = importer.ReadMonsters();
_races = importer.ReadRaces();
_spells = importer.ReadSpells();
_languages = importer.LanguagesFound;
}
private void ReadCharacterArchive(Stream stream)
{
XMLImporter xmlImporter = new XMLImporter(_stringService);
using (ZipArchive archive = new ZipArchive(stream, ZipArchiveMode.Read))
{
ZipArchiveEntry backgroundsEntry = archive.GetEntry("resources/backgrounds.xml");
using (StreamReader reader = new StreamReader(backgroundsEntry.Open(), Encoding.UTF8))
{
string xml = reader.ReadToEnd();
_backgrounds.AddRange(xmlImporter.ReadBackgrounds(xml));
}
ZipArchiveEntry classesEntry = archive.GetEntry("resources/classes.xml");
using (StreamReader reader = new StreamReader(classesEntry.Open(), Encoding.UTF8))
{
string xml = reader.ReadToEnd();
_classes.AddRange(xmlImporter.ReadClasses(xml));
}
ZipArchiveEntry conditionsEntry = archive.GetEntry("resources/conditions.xml");
using (StreamReader reader = new StreamReader(conditionsEntry.Open(), Encoding.UTF8))
{
string xml = reader.ReadToEnd();
_conditions.AddRange(xmlImporter.ReadConditions(xml));
}
ZipArchiveEntry featsEntry = archive.GetEntry("resources/feats.xml");
using (StreamReader reader = new StreamReader(featsEntry.Open(), Encoding.UTF8))
{
string xml = reader.ReadToEnd();
_feats.AddRange(xmlImporter.ReadFeats(xml));
}
ZipArchiveEntry itemsEntry = archive.GetEntry("resources/items.xml");
using (StreamReader reader = new StreamReader(itemsEntry.Open(), Encoding.UTF8))
{
string xml = reader.ReadToEnd();
_items.AddRange(xmlImporter.ReadItems(xml));
}
ZipArchiveEntry languagesEntry = archive.GetEntry("resources/languages.csv");
using (StreamReader reader = new StreamReader(languagesEntry.Open(), Encoding.UTF8))
{
while (!reader.EndOfStream)
{
string languageLine = reader.ReadLine();
if (!String.IsNullOrWhiteSpace(languageLine))
{
string[] parts = languageLine.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
if (parts.Length == 2)
{
if (Guid.TryParse(parts[0], out Guid id))
{
LanguageModel languageModel = new LanguageModel();
languageModel.Id = id;
languageModel.Name = parts[1].Trim();
_languages.Add(languageModel);
}
}
}
}
}
ZipArchiveEntry monstersEntry = archive.GetEntry("resources/monsters.xml");
using (StreamReader reader = new StreamReader(monstersEntry.Open(), Encoding.UTF8))
{
string xml = reader.ReadToEnd();
_monsters.AddRange(xmlImporter.ReadMonsters(xml));
}
ZipArchiveEntry racesEntry = archive.GetEntry("resources/races.xml");
using (StreamReader reader = new StreamReader(racesEntry.Open(), Encoding.UTF8))
{
string xml = reader.ReadToEnd();
_races.AddRange(xmlImporter.ReadRaces(xml));
}
ZipArchiveEntry spellsEntry = archive.GetEntry("resources/spells.xml");
using (StreamReader reader = new StreamReader(spellsEntry.Open(), Encoding.UTF8))
{
string xml = reader.ReadToEnd();
_spells.AddRange(xmlImporter.ReadSpells(xml));
}
ZipArchiveEntry characterEntry = archive.GetEntry("character.ccc");
using (MemoryStream memoryStream = new MemoryStream())
{
using (Stream characterEntryStream = characterEntry.Open())
{
characterEntryStream.CopyTo(memoryStream);
_characters.Add(memoryStream.ToArray());
}
}
}
}
private void RestoreDefaultCompendium()
{
string message = "IMPORTANT!" + Environment.NewLine + Environment.NewLine +
"This cannot be undone!" + Environment.NewLine + Environment.NewLine +
"Restoring your default compendium will remove any custom or imported entries to your compendium. " +
"Characters, Encounters, and any custom content they contain will not be removed but may be replaced." + Environment.NewLine + Environment.NewLine +
"Are you sure you want to restore the default compendium?";
bool?result = _dialogService.ShowConfirmationDialog("Restore Default Compendium", message, "Yes", "No", null);
if (result == true)
{
XMLImporter importer = new XMLImporter(_stringService);
importer.LoadManifestResourceXML("default_compendium.xml");
List <BackgroundModel> backgrounds = importer.ReadBackgrounds();
List <ClassModel> classes = importer.ReadClasses();
List <ConditionModel> conditions = importer.ReadConditions();
List <FeatModel> feats = importer.ReadFeats();
List <ItemModel> items = importer.ReadItems();
List <MonsterModel> monsters = importer.ReadMonsters();
List <RaceModel> races = importer.ReadRaces();
List <SpellModel> spells = importer.ReadSpells();
List <LanguageModel> languages = importer.LanguagesFound;
foreach (CharacterModel character in _compendium.Characters)
{
if (character.Background != null &&
!backgrounds.Any(x => x.Name.Equals(character.Background.Name, StringComparison.CurrentCultureIgnoreCase)))
{
backgrounds.Add(character.Background);
}
if (character.Race != null &&
!races.Any(x => x.Name.Equals(character.Race.Name, StringComparison.CurrentCultureIgnoreCase)))
{
races.Add(character.Race);
}
foreach (LevelModel level in character.Levels)
{
if (level.Class != null)
{
ClassModel defaultClass = classes.FirstOrDefault(x => x.Name.Equals(level.Class.Name, StringComparison.CurrentCultureIgnoreCase));
if (defaultClass == null)
{
classes.Add(level.Class);
}
else
{
if (defaultClass.AutoLevels.Count != level.Class.AutoLevels.Count)
{
classes.Add(level.Class);
}
else
{
for (int i = 0; i < level.Class.AutoLevels.Count; ++i)
{
if (level.Class.AutoLevels[i].Features.Count != defaultClass.AutoLevels[i].Features.Count)
{
classes.Add(level.Class);
break;
}
}
}
}
}
foreach (FeatModel feat in level.Feats)
{
if (!feats.Any(x => x.Name.Equals(feat.Name, StringComparison.CurrentCultureIgnoreCase)))
{
feats.Add(feat);
}
}
}
foreach (LanguageModel language in character.Languages)
{
if (!languages.Any(x => x.Name.Equals(language.Name, StringComparison.CurrentCultureIgnoreCase)))
{
languages.Add(language);
}
}
foreach (AppliedConditionModel appliedCondition in character.Conditions)
{
if (appliedCondition.ConditionModel != null &&
!conditions.Any(x => x.Name.Equals(appliedCondition.ConditionModel.Name, StringComparison.CurrentCultureIgnoreCase)))
{
conditions.Add(appliedCondition.ConditionModel);
}
}
foreach (CompanionModel companion in character.Companions)
{
if (companion.MonsterModel != null &&
!monsters.Any(x => x.Name.Equals(companion.MonsterModel.Name, StringComparison.CurrentCultureIgnoreCase)))
{
monsters.Add(companion.MonsterModel);
}
}
foreach (BagModel bag in character.Bags)
{
foreach (EquipmentModel equipment in bag.Equipment)
{
if (equipment.Item != null &&
!items.Any(x => x.Name.Equals(equipment.Item.Name, StringComparison.CurrentCultureIgnoreCase)))
{
items.Add(equipment.Item);
}
}
}
foreach (SpellbookModel spellbook in character.Spellbooks)
{
foreach (SpellbookEntryModel spellbookEntry in spellbook.Spells)
{
if (spellbookEntry.Spell != null &&
!spells.Any(x => x.Name.Equals(spellbookEntry.Spell.Name, StringComparison.CurrentCultureIgnoreCase)))
{
spells.Add(spellbookEntry.Spell);
}
}
}
}
foreach (EncounterModel encounter in _compendium.Encounters)
{
foreach (EncounterMonsterModel encounterMonster in encounter.Creatures.Where(x => x is EncounterMonsterModel))
{
if (encounterMonster.MonsterModel != null &&
!monsters.Any(x => x.Name.Equals(encounterMonster.MonsterModel.Name, StringComparison.CurrentCultureIgnoreCase)))
{
monsters.Add(encounterMonster.MonsterModel);
}
}
}
_compendium.SetCompendium(backgrounds, classes, conditions, feats, items, languages, monsters, races, spells);
_compendium.SaveBackgrounds();
_compendium.SaveClasses();
_compendium.SaveConditions();
_compendium.SaveFeats();
_compendium.SaveItems();
_compendium.SaveMonsters();
_compendium.SaveRaces();
_compendium.SaveSpells();
_compendium.SaveLanguages();
_compendium.NotifyImportComplete();
base.OnAccept();
}
}
