/// <summary>
/// Generates a name for the treenode based on values contained in the CharacterCache object.
/// </summary>
/// <param name="objCache"></param>
/// <returns></returns>
private static async Task <string> CalculatedName(HeroLabCharacterCache objCache)
{
string strName = objCache.CharacterAlias;
if (string.IsNullOrEmpty(strName))
{
strName = objCache.CharacterName;
if (string.IsNullOrEmpty(strName))
{
strName = await LanguageManager.GetStringAsync("String_UnnamedCharacter");
}
}
string strBuildMethod = await LanguageManager.GetStringAsync("String_" + objCache.BuildMethod, false);
if (string.IsNullOrEmpty(strBuildMethod))
{
strBuildMethod = await LanguageManager.GetStringAsync("String_Unknown");
}
string strSpace = await LanguageManager.GetStringAsync("String_Space");
strName += strSpace + '(' + strBuildMethod + strSpace + '-' + strSpace
+ await LanguageManager.GetStringAsync(objCache.Created? "Title_CareerMode" : "Title_CreateMode") + ')';
return(strName);
}
private void treCharacterList_AfterSelect(object sender, TreeViewEventArgs e)
{
HeroLabCharacterCache objCache = null;
TreeNode objSelectedNode = treCharacterList.SelectedNode;
if (objSelectedNode != null && objSelectedNode.Level > 0)
{
int intIndex = Convert.ToInt32(objSelectedNode.Tag, GlobalOptions.InvariantCultureInfo);
if (intIndex >= 0 && intIndex < _lstCharacterCache.Count)
{
objCache = _lstCharacterCache[intIndex];
}
}
UpdateCharacter(objCache);
treCharacterList.ClearNodeBackground(treCharacterList.SelectedNode);
}
private async void treCharacterList_AfterSelect(object sender, TreeViewEventArgs e)
{
HeroLabCharacterCache objCache = null;
TreeNode objSelectedNode = await treCharacterList.DoThreadSafeFuncAsync(x => x.SelectedNode);
if (objSelectedNode?.Level > 0)
{
int intIndex = Convert.ToInt32(objSelectedNode.Tag, GlobalSettings.InvariantCultureInfo);
if (intIndex >= 0 && intIndex < _lstCharacterCache.Count)
{
objCache = _lstCharacterCache[intIndex];
}
}
await UpdateCharacter(objCache);
await treCharacterList.DoThreadSafeAsync(x => x.ClearNodeBackground(x.SelectedNode));
}
/// <summary>
/// Generates a name for the treenode based on values contained in the CharacterCache object.
/// </summary>
/// <param name="objCache"></param>
/// <returns></returns>
private static string CalculatedName(HeroLabCharacterCache objCache)
{
string strName = objCache.CharacterAlias;
if (string.IsNullOrEmpty(strName))
{
strName = objCache.CharacterName;
if (string.IsNullOrEmpty(strName))
{
strName = LanguageManager.GetString("String_UnnamedCharacter", GlobalOptions.Language);
}
}
string strBuildMethod = LanguageManager.GetString("String_" + objCache.BuildMethod, GlobalOptions.Language, false);
if (string.IsNullOrEmpty(strBuildMethod))
{
strBuildMethod = "Unknown build method";
}
string strCreated = LanguageManager.GetString(objCache.Created ? "Title_CareerMode" : "Title_CreateMode", GlobalOptions.Language);
string strReturn = $"{strName} ({strBuildMethod} - {strCreated})";
return(strReturn);
}
/// <summary>
/// Generates a name for the treenode based on values contained in the CharacterCache object.
/// </summary>
/// <param name="objCache"></param>
/// <returns></returns>
private static string CalculatedName(HeroLabCharacterCache objCache)
{
string strName = objCache.CharacterAlias;
if (string.IsNullOrEmpty(strName))
{
strName = objCache.CharacterName;
if (string.IsNullOrEmpty(strName))
{
strName = LanguageManager.GetString("String_UnnamedCharacter");
}
}
string strBuildMethod = LanguageManager.GetString("String_" + objCache.BuildMethod, false);
if (string.IsNullOrEmpty(strBuildMethod))
{
strBuildMethod = LanguageManager.GetString("String_Unknown");
}
strName += string.Format("{0}({1}{0}-{0}{2})",
LanguageManager.GetString("String_Space"),
strBuildMethod,
LanguageManager.GetString(objCache.Created ? "Title_CareerMode" : "Title_CreateMode"));
return(strName);
}
/// <summary>
/// Generates a character cache, which prevents us from repeatedly loading XmlNodes or caching a full character.
/// </summary>
/// <param name="strFile"></param>
private TreeNode CacheCharacters(string strFile)
{
if (!File.Exists(strFile))
{
Program.MainForm.ShowMessageBox(this, LanguageManager.GetString("Message_File_Cannot_Be_Accessed") + Environment.NewLine + Environment.NewLine + strFile);
return(null);
}
List <XPathNavigator> lstCharacterXmlStatblocks = new List <XPathNavigator>(3);
try
{
using (ZipArchive zipArchive = ZipFile.Open(strFile, ZipArchiveMode.Read, Encoding.GetEncoding(850)))
{
foreach (ZipArchiveEntry entry in zipArchive.Entries)
{
string strEntryFullName = entry.FullName;
if (strEntryFullName.EndsWith(".xml", StringComparison.OrdinalIgnoreCase) && strEntryFullName.StartsWith("statblocks_xml", StringComparison.Ordinal))
{
// If we run into any problems loading the character cache, fail out early.
try
{
XPathDocument xmlSourceDoc;
using (StreamReader sr = new StreamReader(entry.Open(), true))
using (XmlReader objXmlReader = XmlReader.Create(sr, GlobalOptions.SafeXmlReaderSettings))
xmlSourceDoc = new XPathDocument(objXmlReader);
lstCharacterXmlStatblocks.Add(xmlSourceDoc.CreateNavigator());
}
// If we run into any problems loading the character cache, fail out early.
catch (IOException)
{
Utils.BreakIfDebug();
}
catch (XmlException)
{
Utils.BreakIfDebug();
}
}
else if (strEntryFullName.StartsWith("images", StringComparison.Ordinal) && strEntryFullName.Contains('.'))
{
string strKey = Path.GetFileName(strEntryFullName);
using (Bitmap bmpMugshot = new Bitmap(entry.Open(), true))
{
Bitmap bmpNewMugshot = bmpMugshot.PixelFormat == PixelFormat.Format32bppPArgb
? bmpMugshot.Clone() as Bitmap // Clone makes sure file handle is closed
: bmpMugshot.ConvertPixelFormat(PixelFormat.Format32bppPArgb);
if (_dicImages.ContainsKey(strKey))
{
_dicImages[strKey].Dispose();
_dicImages[strKey] = bmpNewMugshot;
}
else
{
_dicImages.Add(strKey, bmpNewMugshot);
}
}
}
}
}
}
catch (IOException)
{
Program.MainForm.ShowMessageBox(this, LanguageManager.GetString("Message_File_Cannot_Be_Accessed") + Environment.NewLine + Environment.NewLine + strFile);
return(null);
}
catch (NotSupportedException)
{
Program.MainForm.ShowMessageBox(this, LanguageManager.GetString("Message_File_Cannot_Be_Accessed") + Environment.NewLine + Environment.NewLine + strFile);
return(null);
}
catch (UnauthorizedAccessException)
{
Program.MainForm.ShowMessageBox(this, LanguageManager.GetString("Message_Insufficient_Permissions_Warning"));
return(null);
}
string strFileText = strFile.CheapReplace(Application.StartupPath, () => "<" + Application.ProductName + ">");
TreeNode nodRootNode = new TreeNode
{
Text = strFileText,
ToolTipText = strFileText
};
XPathNavigator xmlMetatypesDocument = XmlManager.LoadXPath("metatypes.xml");
foreach (XPathNavigator xmlCharacterDocument in lstCharacterXmlStatblocks)
{
XPathNavigator xmlBaseCharacterNode = xmlCharacterDocument.SelectSingleNode("/document/public/character");
if (xmlBaseCharacterNode != null)
{
HeroLabCharacterCache objCache = new HeroLabCharacterCache
{
PlayerName = xmlBaseCharacterNode.SelectSingleNode("@playername")?.Value ?? string.Empty
};
string strNameString = xmlBaseCharacterNode.SelectSingleNode("@name")?.Value ?? string.Empty;
objCache.CharacterId = strNameString;
if (!string.IsNullOrEmpty(strNameString))
{
int intAsIndex = strNameString.IndexOf(" as ", StringComparison.Ordinal);
if (intAsIndex != -1)
{
objCache.CharacterName = strNameString.Substring(0, intAsIndex);
objCache.CharacterAlias = strNameString.Substring(intAsIndex).TrimStart(" as ").Trim('\'');
}
else
{
objCache.CharacterName = strNameString;
}
}
string strRaceString = xmlBaseCharacterNode.SelectSingleNode("race/@name")?.Value;
if (strRaceString == "Metasapient")
{
strRaceString = "A.I.";
}
if (!string.IsNullOrEmpty(strRaceString))
{
foreach (XPathNavigator xmlMetatype in xmlMetatypesDocument.Select("/chummer/metatypes/metatype"))
{
string strMetatypeName = xmlMetatype.SelectSingleNode("name")?.Value ?? string.Empty;
if (strMetatypeName == strRaceString)
{
objCache.Metatype = strMetatypeName;
objCache.Metavariant = "None";
break;
}
foreach (XPathNavigator xmlMetavariant in xmlMetatype.Select("metavariants/metavariant"))
{
string strMetavariantName = xmlMetavariant.SelectSingleNode("name")?.Value ?? string.Empty;
if (strMetavariantName == strRaceString)
{
objCache.Metatype = strMetatypeName;
objCache.Metavariant = strMetavariantName;
break;
}
}
}
}
objCache.Description = xmlBaseCharacterNode.SelectSingleNode("personal/description")?.Value;
objCache.Karma = xmlBaseCharacterNode.SelectSingleNode("karma/@total")?.Value ?? "0";
objCache.Essence = xmlBaseCharacterNode.SelectSingleNode("attributes/attribute[@name = \"Essence\"]/@text")?.Value;
objCache.BuildMethod = xmlBaseCharacterNode.SelectSingleNode("creation/bp/@total")?.Value == "25" ?
CharacterBuildMethod.Priority.ToString() :
CharacterBuildMethod.Karma.ToString();
objCache.Created = objCache.Karma != "0";
if (!objCache.Created)
{
XPathNodeIterator xmlJournalEntries = xmlBaseCharacterNode.Select("journals/journal");
if (xmlJournalEntries?.Count > 1)
{
objCache.Created = true;
}
else if (xmlJournalEntries?.Count == 1 && xmlJournalEntries.Current?.SelectSingleNode("@name")?.Value != "Title")
{
objCache.Created = true;
}
}
string strImageString = xmlBaseCharacterNode.SelectSingleNode("images/image/@filename")?.Value;
if (!string.IsNullOrEmpty(strImageString) && _dicImages.TryGetValue(strImageString, out Bitmap objTemp))
{
objCache.Mugshot = objTemp;
}
objCache.FilePath = strFile;
TreeNode objNode = new TreeNode
{
Text = CalculatedName(objCache),
ToolTipText = strFile.CheapReplace(Application.StartupPath, () => "<" + Application.ProductName + ">")
};
nodRootNode.Nodes.Add(objNode);
lock (_lstCharacterCacheLock)
{
_lstCharacterCache.Add(objCache);
objNode.Tag = _lstCharacterCache.IndexOf(objCache);
}
}
}
nodRootNode.Expand();
return(nodRootNode);
}
/// <summary>
/// Update the labels and images based on the selected treenode.
/// </summary>
/// <param name="objCache"></param>
private void UpdateCharacter(HeroLabCharacterCache objCache)
{
if (objCache != null)
{
txtCharacterBio.Text = objCache.Description;
string strUnknown = LanguageManager.GetString("String_Unknown");
string strNone = LanguageManager.GetString("String_None");
lblCharacterName.Text = objCache.CharacterName;
if (string.IsNullOrEmpty(lblCharacterName.Text))
{
lblCharacterName.Text = strUnknown;
}
lblCharacterNameLabel.Visible = !string.IsNullOrEmpty(lblCharacterName.Text);
lblCharacterName.Visible = !string.IsNullOrEmpty(lblCharacterName.Text);
lblCharacterAlias.Text = objCache.CharacterAlias;
if (string.IsNullOrEmpty(lblCharacterAlias.Text))
{
lblCharacterAlias.Text = strUnknown;
}
lblCharacterAliasLabel.Visible = !string.IsNullOrEmpty(lblCharacterAlias.Text);
lblCharacterAlias.Visible = !string.IsNullOrEmpty(lblCharacterAlias.Text);
lblPlayerName.Text = objCache.PlayerName;
if (string.IsNullOrEmpty(lblPlayerName.Text))
{
lblPlayerName.Text = strUnknown;
}
lblPlayerNameLabel.Visible = !string.IsNullOrEmpty(lblPlayerName.Text);
lblPlayerName.Visible = !string.IsNullOrEmpty(lblPlayerName.Text);
lblCareerKarma.Text = objCache.Karma;
if (string.IsNullOrEmpty(lblCareerKarma.Text) || lblCareerKarma.Text == 0.ToString(GlobalOptions.CultureInfo))
{
lblCareerKarma.Text = strNone;
}
lblCareerKarmaLabel.Visible = !string.IsNullOrEmpty(lblCareerKarma.Text);
lblCareerKarma.Visible = !string.IsNullOrEmpty(lblCareerKarma.Text);
lblEssence.Text = objCache.Essence;
if (string.IsNullOrEmpty(lblEssence.Text))
{
lblEssence.Text = strUnknown;
}
lblEssenceLabel.Visible = !string.IsNullOrEmpty(lblEssence.Text);
lblEssence.Visible = !string.IsNullOrEmpty(lblEssence.Text);
picMugshot.Image = objCache.Mugshot;
// Populate character information fields.
XPathNavigator objMetatypeDoc = XmlManager.LoadXPath("metatypes.xml");
XPathNavigator objMetatypeNode = objMetatypeDoc.SelectSingleNode("/chummer/metatypes/metatype[name = " + objCache.Metatype.CleanXPath() + "]");
if (objMetatypeNode == null)
{
objMetatypeDoc = XmlManager.LoadXPath("critters.xml");
objMetatypeNode = objMetatypeDoc.SelectSingleNode("/chummer/metatypes/metatype[name = " + objCache.Metatype.CleanXPath() + "]");
}
string strMetatype = objMetatypeNode?.SelectSingleNode("translate")?.Value ?? objCache.Metatype;
if (!string.IsNullOrEmpty(objCache.Metavariant) && objCache.Metavariant != "None")
{
objMetatypeNode = objMetatypeNode?.SelectSingleNode("metavariants/metavariant[name = " + objCache.Metavariant.CleanXPath() + "]");
strMetatype += " (" + (objMetatypeNode?.SelectSingleNode("translate")?.Value ?? objCache.Metavariant) + ')';
}
lblMetatype.Text = strMetatype;
if (string.IsNullOrEmpty(lblMetatype.Text))
{
lblMetatype.Text = strUnknown;
}
lblMetatypeLabel.Visible = !string.IsNullOrEmpty(lblMetatype.Text);
lblMetatype.Visible = !string.IsNullOrEmpty(lblMetatype.Text);
cmdImport.Enabled = true;
}
else
{
txtCharacterBio.Text = string.Empty;
lblCharacterNameLabel.Visible = false;
lblCharacterName.Visible = false;
lblCharacterAliasLabel.Visible = false;
lblCharacterAlias.Visible = false;
lblPlayerNameLabel.Visible = false;
lblPlayerName.Visible = false;
lblMetatypeLabel.Visible = false;
lblMetatype.Visible = false;
lblCareerKarmaLabel.Visible = false;
lblCareerKarma.Visible = false;
lblEssenceLabel.Visible = false;
lblEssence.Visible = false;
picMugshot.Image = null;
cmdImport.Enabled = false;
}
picMugshot_SizeChanged(null, EventArgs.Empty);
}
/// <summary>
/// Generates a character cache, which prevents us from repeatedly loading XmlNodes or caching a full character.
/// </summary>
/// <param name="strFile"></param>
private async Task <TreeNode> CacheCharacters(string strFile)
{
if (!File.Exists(strFile))
{
Program.ShowMessageBox(
this,
string.Format(GlobalSettings.CultureInfo,
await LanguageManager.GetStringAsync("Message_File_Cannot_Be_Accessed"), strFile));
return(null);
}
ThreadSafeList <XPathNavigator> lstCharacterXmlStatblocks = new ThreadSafeList <XPathNavigator>(3);
try
{
try
{
using (ZipArchive zipArchive
= ZipFile.Open(strFile, ZipArchiveMode.Read, Encoding.GetEncoding(850)))
{
// NOTE: Cannot parallelize because ZipFile.Open creates one handle on the entire zip file that gets messed up if we try to get it to read multiple files at once
foreach (ZipArchiveEntry entry in zipArchive.Entries)
{
string strEntryFullName = entry.FullName;
if (strEntryFullName.EndsWith(".xml", StringComparison.OrdinalIgnoreCase) &&
strEntryFullName.StartsWith("statblocks_xml", StringComparison.Ordinal))
{
// If we run into any problems loading the character cache, fail out early.
try
{
using (StreamReader sr = new StreamReader(entry.Open(), true))
{
await Task.Run(() =>
{
XPathDocument xmlSourceDoc;
using (XmlReader objXmlReader
= XmlReader.Create(sr, GlobalSettings.SafeXmlReaderSettings))
xmlSourceDoc = new XPathDocument(objXmlReader);
XPathNavigator objToAdd = xmlSourceDoc.CreateNavigator();
lstCharacterXmlStatblocks.Add(objToAdd);
});
}
}
// If we run into any problems loading the character cache, fail out early.
catch (IOException)
{
Utils.BreakIfDebug();
}
catch (XmlException)
{
Utils.BreakIfDebug();
}
}
else if (strEntryFullName.StartsWith("images", StringComparison.Ordinal) &&
strEntryFullName.Contains('.'))
{
string strKey = Path.GetFileName(strEntryFullName);
using (Bitmap bmpMugshot = new Bitmap(entry.Open(), true))
{
Bitmap bmpNewMugshot = bmpMugshot.PixelFormat == PixelFormat.Format32bppPArgb
? bmpMugshot.Clone() as Bitmap // Clone makes sure file handle is closed
: bmpMugshot.ConvertPixelFormat(PixelFormat.Format32bppPArgb);
while (!await _dicImages.TryAddAsync(strKey, bmpNewMugshot))
{
(bool blnSuccess, Bitmap bmpOldMugshot) =
await _dicImages.TryRemoveAsync(strKey);
if (blnSuccess)
{
bmpOldMugshot?.Dispose();
}
}
}
}
}
}
}
catch (IOException)
{
Program.ShowMessageBox(
this,
string.Format(GlobalSettings.CultureInfo,
await LanguageManager.GetStringAsync("Message_File_Cannot_Be_Accessed"),
strFile));
return(null);
}
catch (NotSupportedException)
{
Program.ShowMessageBox(
this,
string.Format(GlobalSettings.CultureInfo,
await LanguageManager.GetStringAsync("Message_File_Cannot_Be_Accessed"),
strFile));
return(null);
}
catch (UnauthorizedAccessException)
{
Program.ShowMessageBox(
this, await LanguageManager.GetStringAsync("Message_Insufficient_Permissions_Warning"));
return(null);
}
string strFileText
= await strFile.CheapReplaceAsync(Utils.GetStartupPath, () => '<' + Application.ProductName + '>');
TreeNode nodRootNode = new TreeNode
{
Text = strFileText,
ToolTipText = strFileText
};
XPathNavigator xmlMetatypesDocument = await XmlManager.LoadXPathAsync("metatypes.xml");
foreach (XPathNavigator xmlCharacterDocument in lstCharacterXmlStatblocks)
{
XPathNavigator xmlBaseCharacterNode
= xmlCharacterDocument.SelectSingleNode("/document/public/character");
if (xmlBaseCharacterNode != null)
{
HeroLabCharacterCache objCache = new HeroLabCharacterCache
{
PlayerName = xmlBaseCharacterNode.SelectSingleNode("@playername")?.Value ?? string.Empty
};
string strNameString = xmlBaseCharacterNode.SelectSingleNode("@name")?.Value ?? string.Empty;
objCache.CharacterId = strNameString;
if (!string.IsNullOrEmpty(strNameString))
{
int intAsIndex = strNameString.IndexOf(" as ", StringComparison.Ordinal);
if (intAsIndex != -1)
{
objCache.CharacterName = strNameString.Substring(0, intAsIndex);
objCache.CharacterAlias
= strNameString.Substring(intAsIndex).TrimStart(" as ").Trim('\'');
}
else
{
objCache.CharacterName = strNameString;
}
}
string strRaceString = xmlBaseCharacterNode.SelectSingleNode("race/@name")?.Value;
if (strRaceString == "Metasapient")
{
strRaceString = "A.I.";
}
if (!string.IsNullOrEmpty(strRaceString))
{
foreach (XPathNavigator xmlMetatype in xmlMetatypesDocument.Select(
"/chummer/metatypes/metatype"))
{
string strMetatypeName = xmlMetatype.SelectSingleNode("name")?.Value ?? string.Empty;
if (strMetatypeName == strRaceString)
{
objCache.Metatype = strMetatypeName;
objCache.Metavariant = "None";
break;
}
foreach (XPathNavigator xmlMetavariant in
await xmlMetatype.SelectAndCacheExpressionAsync("metavariants/metavariant"))
{
string strMetavariantName
= xmlMetavariant.SelectSingleNode("name")?.Value ?? string.Empty;
if (strMetavariantName == strRaceString)
{
objCache.Metatype = strMetatypeName;
objCache.Metavariant = strMetavariantName;
break;
}
}
}
}
objCache.Description = xmlBaseCharacterNode.SelectSingleNode("personal/description")?.Value;
objCache.Karma = xmlBaseCharacterNode.SelectSingleNode("karma/@total")?.Value ?? "0";
objCache.Essence = xmlBaseCharacterNode
.SelectSingleNode("attributes/attribute[@name = \"Essence\"]/@text")?.Value;
objCache.BuildMethod
= xmlBaseCharacterNode.SelectSingleNode("creation/bp/@total")?.ValueAsInt <= 100
? CharacterBuildMethod.Priority
: CharacterBuildMethod.Karma;
string strSettingsSummary =
xmlBaseCharacterNode.SelectSingleNode("settings/@summary")?.Value;
if (!string.IsNullOrEmpty(strSettingsSummary))
{
int intSemicolonIndex;
bool blnDoFullHouse = false;
int intSourcebooksIndex
= strSettingsSummary.IndexOf("Core Rulebooks:", StringComparison.OrdinalIgnoreCase);
if (intSourcebooksIndex != -1)
{
intSemicolonIndex = strSettingsSummary.IndexOf(';', intSourcebooksIndex);
if (intSourcebooksIndex + 16 < intSemicolonIndex)
{
blnDoFullHouse
= true; // We probably have multiple books enabled, so use Full House instead
}
}
string strHeroLabSettingsName = "Standard";
int intCharCreationSystemsIndex =
strSettingsSummary.IndexOf("Character Creation Systems:",
StringComparison.OrdinalIgnoreCase);
if (intCharCreationSystemsIndex != -1)
{
intSemicolonIndex = strSettingsSummary.IndexOf(';', intCharCreationSystemsIndex);
if (intCharCreationSystemsIndex + 28 <= intSemicolonIndex)
{
strHeroLabSettingsName = strSettingsSummary.Substring(
intCharCreationSystemsIndex + 28,
strSettingsSummary.IndexOf(
';', intCharCreationSystemsIndex)
- 28 - intCharCreationSystemsIndex)
.Trim();
if (strHeroLabSettingsName == "Established Runners")
{
strHeroLabSettingsName = "Standard";
}
}
}
if (strHeroLabSettingsName == "Standard")
{
if (blnDoFullHouse)
{
strHeroLabSettingsName = objCache.BuildMethod == CharacterBuildMethod.Karma
? "Full House (Point Buy)"
: "Full House";
}
else if (objCache.BuildMethod == CharacterBuildMethod.Karma)
{
strHeroLabSettingsName = "Point Buy";
}
}
objCache.SettingsName = strHeroLabSettingsName;
}
objCache.Created = objCache.Karma != "0";
if (!objCache.Created)
{
XPathNodeIterator xmlJournalEntries
= await xmlBaseCharacterNode.SelectAndCacheExpressionAsync("journals/journal");
if (xmlJournalEntries?.Count > 1)
{
objCache.Created = true;
}
else if (xmlJournalEntries?.Count == 1 &&
xmlJournalEntries.Current?.SelectSingleNode("@name")?.Value != "Title")
{
objCache.Created = true;
}
}
string strImageString = xmlBaseCharacterNode.SelectSingleNode("images/image/@filename")?.Value;
if (!string.IsNullOrEmpty(strImageString))
{
(bool blnSuccess, Bitmap objTemp) = await _dicImages.TryGetValueAsync(strImageString);
if (blnSuccess)
{
objCache.Mugshot = objTemp;
}
}
objCache.FilePath = strFile;
TreeNode objNode = new TreeNode
{
Text = await CalculatedName(objCache),
ToolTipText = await strFile.CheapReplaceAsync(Utils.GetStartupPath,
() => '<' + Application.ProductName + '>')
};
nodRootNode.Nodes.Add(objNode);
await _lstCharacterCache.AddAsync(objCache);
objNode.Tag = await _lstCharacterCache.IndexOfAsync(objCache);
}
}
nodRootNode.Expand();
return(nodRootNode);
}
finally
{
await lstCharacterXmlStatblocks.DisposeAsync();
}
}
private async Task DoImport(CancellationToken token = default)
{
TreeNode objSelectedNode = await treCharacterList.DoThreadSafeFuncAsync(x => x.SelectedNode, token);
if (objSelectedNode == null || objSelectedNode.Level <= 0)
{
return;
}
int intIndex = Convert.ToInt32(objSelectedNode.Tag, GlobalSettings.InvariantCultureInfo);
if (intIndex < 0 || intIndex >= _lstCharacterCache.Count)
{
return;
}
HeroLabCharacterCache objCache = _lstCharacterCache[intIndex];
if (objCache == null)
{
return;
}
string strFile = objCache.FilePath;
string strCharacterId = objCache.CharacterId;
if (string.IsNullOrEmpty(strFile) || string.IsNullOrEmpty(strCharacterId))
{
return;
}
using (await CursorWait.NewAsync(this, token: token))
{
bool blnLoaded = false;
Character objCharacter = new Character();
try
{
await Program.OpenCharacters.AddAsync(objCharacter);
CharacterSettings objHeroLabSettings =
SettingsManager.LoadedCharacterSettings.Values.FirstOrDefault(
x => x.Name == objCache.SettingsName && x.BuildMethod == objCache.BuildMethod);
if (objHeroLabSettings != null)
{
objCharacter.SettingsKey = objHeroLabSettings.DictionaryKey;
}
else
{
objHeroLabSettings = SettingsManager.LoadedCharacterSettings.Values.FirstOrDefault(
x => x.Name.Contains(objCache.SettingsName) && x.BuildMethod == objCache.BuildMethod);
if (objHeroLabSettings != null)
{
objCharacter.SettingsKey = objHeroLabSettings.DictionaryKey;
}
else
{
(bool blnSuccess, CharacterSettings objDefaultCharacterSettings)
= await SettingsManager.LoadedCharacterSettings.TryGetValueAsync(
GlobalSettings.DefaultCharacterSetting, token);
if (blnSuccess && objCache.BuildMethod.UsesPriorityTables()
== objDefaultCharacterSettings.BuildMethod.UsesPriorityTables())
{
objCharacter.SettingsKey = objDefaultCharacterSettings.DictionaryKey;
}
else
{
objCharacter.SettingsKey = SettingsManager.LoadedCharacterSettings.Values
.FirstOrDefault(
x => x.BuiltInOption &&
x.BuildMethod == objCache.BuildMethod)
?.DictionaryKey
?? SettingsManager.LoadedCharacterSettings.Values
.FirstOrDefault(
x => x.BuiltInOption &&
x.BuildMethod.UsesPriorityTables()
== objCache.BuildMethod
.UsesPriorityTables())
?.DictionaryKey
?? GlobalSettings.DefaultCharacterSetting;
}
}
}
using (ThreadSafeForm <SelectBuildMethod> frmPickBP = await ThreadSafeForm <SelectBuildMethod> .GetAsync(() => new SelectBuildMethod(objCharacter, true), token))
{
if (await frmPickBP.ShowDialogSafeAsync(this, token) != DialogResult.OK)
{
return;
}
}
//Timekeeper.Start("load_file");
if (!await objCharacter.LoadFromHeroLabFileAsync(strFile, strCharacterId, objCharacter.SettingsKey))
{
return;
}
blnLoaded = true;
//Timekeeper.Finish("load_file");
await Program.OpenCharacter(objCharacter, token : token);
}
finally
{
await cmdImport.DoThreadSafeAsync(x => x.Enabled = true, token);
await cmdSelectFile.DoThreadSafeAsync(x => x.Enabled = true, token);
if (!blnLoaded)
{
await Program.OpenCharacters.RemoveAsync(objCharacter);
}
}
}
await this.DoThreadSafeAsync(x => x.Close(), token);
}
/// <summary>
/// Update the labels and images based on the selected treenode.
/// </summary>
/// <param name="objCache"></param>
private async Task UpdateCharacter(HeroLabCharacterCache objCache)
{
if (objCache != null)
{
await txtCharacterBio.DoThreadSafeAsync(x => x.Text = objCache.Description);
string strUnknown = await LanguageManager.GetStringAsync("String_Unknown");
await lblCharacterName.DoThreadSafeAsync(x =>
{
x.Text = objCache.CharacterName;
if (string.IsNullOrEmpty(x.Text))
{
x.Text = strUnknown;
}
x.Visible = true;
});
await lblCharacterNameLabel.DoThreadSafeAsync(x => x.Visible = true);
await lblCharacterAlias.DoThreadSafeAsync(x =>
{
x.Text = objCache.CharacterAlias;
if (string.IsNullOrEmpty(x.Text))
{
x.Text = strUnknown;
}
x.Visible = true;
});
await lblCharacterAliasLabel.DoThreadSafeAsync(x => x.Visible = true);
await lblPlayerName.DoThreadSafeAsync(x =>
{
x.Text = objCache.PlayerName;
if (string.IsNullOrEmpty(x.Text))
{
x.Text = strUnknown;
}
x.Visible = true;
});
await lblPlayerNameLabel.DoThreadSafeAsync(x => x.Visible = true);
string strNone = await LanguageManager.GetStringAsync("String_None");
await lblCareerKarma.DoThreadSafeAsync(x =>
{
x.Text = objCache.Karma;
if (string.IsNullOrEmpty(x.Text) || x.Text == 0.ToString(GlobalSettings.CultureInfo))
{
x.Text = strNone;
}
x.Visible = true;
});
await lblCareerKarmaLabel.DoThreadSafeAsync(x => x.Visible = true);
await lblEssence.DoThreadSafeAsync(x =>
{
x.Text = objCache.Essence;
if (string.IsNullOrEmpty(x.Text))
{
x.Text = strUnknown;
}
x.Visible = true;
});
await lblEssenceLabel.DoThreadSafeAsync(x => x.Visible = true);
await picMugshot.DoThreadSafeAsync(x => x.Image = objCache.Mugshot);
// Populate character information fields.
XPathNavigator objMetatypeDoc = await XmlManager.LoadXPathAsync("metatypes.xml");
XPathNavigator objMetatypeNode = objMetatypeDoc.SelectSingleNode("/chummer/metatypes/metatype[name = " + objCache.Metatype.CleanXPath() + ']');
if (objMetatypeNode == null)
{
objMetatypeDoc = await XmlManager.LoadXPathAsync("critters.xml");
objMetatypeNode = objMetatypeDoc.SelectSingleNode("/chummer/metatypes/metatype[name = " + objCache.Metatype.CleanXPath() + ']');
}
string strMetatype = objMetatypeNode != null
? (await objMetatypeNode.SelectSingleNodeAndCacheExpressionAsync("translate"))?.Value
?? objCache.Metatype
: objCache.Metatype;
if (!string.IsNullOrEmpty(objCache.Metavariant) && objCache.Metavariant != "None")
{
objMetatypeNode = objMetatypeNode?.SelectSingleNode("metavariants/metavariant[name = " + objCache.Metavariant.CleanXPath() + ']');
strMetatype += " (" + (objMetatypeNode != null
? (await objMetatypeNode.SelectSingleNodeAndCacheExpressionAsync("translate"))?.Value
?? objCache.Metavariant
: objCache.Metavariant) + ')';
}
await lblMetatype.DoThreadSafeAsync(x =>
{
x.Text = strMetatype;
if (string.IsNullOrEmpty(x.Text))
{
x.Text = strUnknown;
}
x.Visible = true;
});
await lblMetatypeLabel.DoThreadSafeAsync(x => x.Visible = true);
await cmdImport.DoThreadSafeAsync(x => x.Enabled = true);
}
else
{
await txtCharacterBio.DoThreadSafeAsync(x => x.Text = string.Empty);
await lblCharacterNameLabel.DoThreadSafeAsync(x => x.Visible = false);
await lblCharacterName.DoThreadSafeAsync(x => x.Visible = false);
await lblCharacterAliasLabel.DoThreadSafeAsync(x => x.Visible = false);
await lblCharacterAlias.DoThreadSafeAsync(x => x.Visible = false);
await lblPlayerNameLabel.DoThreadSafeAsync(x => x.Visible = false);
await lblPlayerName.DoThreadSafeAsync(x => x.Visible = false);
await lblMetatypeLabel.DoThreadSafeAsync(x => x.Visible = false);
await lblMetatype.DoThreadSafeAsync(x => x.Visible = false);
await lblCareerKarmaLabel.DoThreadSafeAsync(x => x.Visible = false);
await lblCareerKarma.DoThreadSafeAsync(x => x.Visible = false);
await lblEssenceLabel.DoThreadSafeAsync(x => x.Visible = false);
await lblEssence.DoThreadSafeAsync(x => x.Visible = false);
await picMugshot.DoThreadSafeAsync(x => x.Image = null);
await cmdImport.DoThreadSafeAsync(x => x.Enabled = false);
}
await ProcessMugshot();
}
/// <summary>
/// Generates a character cache, which prevents us from repeatedly loading XmlNodes or caching a full character.
/// </summary>
/// <param name="strFile"></param>
/// <param name="objParentNode"></param>
private TreeNode CacheCharacters(string strFile)
{
if (!File.Exists(strFile))
{
MessageBox.Show(LanguageManager.GetString("Message_File_Cannot_Be_Accessed", GlobalOptions.Language) + "\n\n" + strFile);
return(null);
}
List <XmlDocument> lstCharacterXmlStatblocks = new List <XmlDocument>();
try
{
using (ZipArchive zipArchive = ZipFile.Open(strFile, ZipArchiveMode.Read, Encoding.GetEncoding(850)))
{
foreach (ZipArchiveEntry entry in zipArchive.Entries)
{
string strEntryFullName = entry.FullName;
if (strEntryFullName.EndsWith(".xml") && strEntryFullName.StartsWith("statblocks_xml"))
{
XmlDocument xmlSourceDoc = new XmlDocument();
// If we run into any problems loading the character cache, fail out early.
try
{
using (StreamReader sr = new StreamReader(entry.Open(), true))
{
xmlSourceDoc.Load(sr);
lstCharacterXmlStatblocks.Add(xmlSourceDoc);
}
}
// If we run into any problems loading the character cache, fail out early.
catch (IOException)
{
Utils.BreakIfDebug();
}
catch (XmlException)
{
Utils.BreakIfDebug();
}
}
else if (strEntryFullName.StartsWith("images") && strEntryFullName.Contains('.'))
{
string strKey = Path.GetFileName(strEntryFullName);
Bitmap imgMugshot = (new Bitmap(entry.Open(), true)).ConvertPixelFormat(PixelFormat.Format32bppPArgb);
if (_dicImages.ContainsKey(strKey))
{
_dicImages[strKey] = imgMugshot;
}
else
{
_dicImages.Add(strKey, imgMugshot);
}
}
}
}
}
catch (IOException)
{
MessageBox.Show(LanguageManager.GetString("Message_File_Cannot_Be_Accessed", GlobalOptions.Language) + "\n\n" + strFile);
return(null);
}
catch (NotSupportedException)
{
MessageBox.Show(LanguageManager.GetString("Message_File_Cannot_Be_Accessed", GlobalOptions.Language) + "\n\n" + strFile);
return(null);
}
catch (UnauthorizedAccessException)
{
MessageBox.Show(LanguageManager.GetString("Message_Insufficient_Permissions_Warning", GlobalOptions.Language));
return(null);
}
string strFileText = strFile.CheapReplace(Application.StartupPath, () => "<" + Application.ProductName + ">");
TreeNode nodRootNode = new TreeNode
{
Text = strFileText,
ToolTipText = strFileText
};
XmlDocument xmlMetatypesDocument = XmlManager.Load("metatypes.xml");
foreach (XmlDocument xmlCharacterDocument in lstCharacterXmlStatblocks)
{
XmlNode xmlBaseCharacterNode = xmlCharacterDocument.SelectSingleNode("/document/public/character");
if (xmlBaseCharacterNode != null)
{
HeroLabCharacterCache objCache = new HeroLabCharacterCache
{
PlayerName = xmlBaseCharacterNode.Attributes?["playername"]?.InnerText
};
string strNameString = xmlBaseCharacterNode.Attributes?["name"]?.InnerText ?? string.Empty;
objCache.CharacterId = strNameString;
if (!string.IsNullOrEmpty(strNameString))
{
int intAsIndex = strNameString.IndexOf(" as ", StringComparison.Ordinal);
if (intAsIndex != -1)
{
objCache.CharacterName = strNameString.Substring(0, intAsIndex);
objCache.CharacterAlias = strNameString.Substring(intAsIndex).TrimStart(" as ").Trim('\'');
}
else
{
objCache.CharacterName = strNameString;
}
}
string strRaceString = xmlBaseCharacterNode.SelectSingleNode("race/@name")?.InnerText;
if (strRaceString == "Metasapient")
{
strRaceString = "A.I.";
}
if (!string.IsNullOrEmpty(strRaceString))
{
using (XmlNodeList xmlMetatypeList = xmlMetatypesDocument.SelectNodes("/chummer/metatypes/metatype"))
{
if (xmlMetatypeList?.Count > 0)
{
foreach (XmlNode xmlMetatype in xmlMetatypeList)
{
string strMetatypeName = xmlMetatype["name"]?.InnerText ?? string.Empty;
if (strMetatypeName == strRaceString)
{
objCache.Metatype = strMetatypeName;
objCache.Metavariant = "None";
break;
}
using (XmlNodeList xmlMetavariantList = xmlMetatype.SelectNodes("metavariants/metavariant"))
{
if (xmlMetavariantList?.Count > 0)
{
foreach (XmlNode xmlMetavariant in xmlMetavariantList)
{
string strMetavariantName = xmlMetavariant["name"]?.InnerText ?? string.Empty;
if (strMetavariantName == strRaceString)
{
objCache.Metatype = strMetatypeName;
objCache.Metavariant = strMetavariantName;
break;
}
}
}
}
}
}
}
}
objCache.Description = xmlBaseCharacterNode.SelectSingleNode("personal/description")?.InnerText;
objCache.Karma = xmlBaseCharacterNode.SelectSingleNode("karma/@total")?.InnerText ?? "0";
objCache.Essence = xmlBaseCharacterNode.SelectSingleNode("attributes/attribute[@name = \"Essence\"]/@text")?.InnerText;
objCache.BuildMethod = xmlBaseCharacterNode.SelectSingleNode("creation/bp/@total")?.InnerText == "25" ?
CharacterBuildMethod.Priority.ToString() :
CharacterBuildMethod.Karma.ToString();
objCache.Created = objCache.Karma != "0";
if (!objCache.Created)
{
XmlNodeList xmlJournalEntries = xmlBaseCharacterNode.SelectNodes("journals/journal");
if (xmlJournalEntries?.Count > 1)
{
objCache.Created = true;
}
else if (xmlJournalEntries?.Count == 1 && xmlJournalEntries[0]?.Attributes?["name"]?.InnerText != "Title")
{
objCache.Created = true;
}
}
string strImageString = xmlBaseCharacterNode.SelectSingleNode("images/image/@filename")?.InnerText;
if (!string.IsNullOrEmpty(strImageString) && _dicImages.TryGetValue(strImageString, out Bitmap objTemp))
{
objCache.Mugshot = objTemp;
}
objCache.FilePath = strFile;
TreeNode objNode = new TreeNode
{
Text = CalculatedName(objCache),
ToolTipText = strFile.CheapReplace(Application.StartupPath, () => "<" + Application.ProductName + ">")
};
nodRootNode.Nodes.Add(objNode);
lock (_lstCharacterCacheLock)
{
_lstCharacterCache.Add(objCache);
objNode.Tag = _lstCharacterCache.IndexOf(objCache);
}
}
}
nodRootNode.Expand();
return(nodRootNode);
}
