/// <summary>
/// Creates an instance of <see cref="BackgroundViewModel"/>
/// </summary>
public BackgroundViewModel(BackgroundModel backgroundModel)
{
_backgroundModel = backgroundModel;
_skills = "None";
if (_backgroundModel.Skills.Count > 0)
{
_skills = String.Join(", ", _backgroundModel.Skills.Select(x => _stringService.GetString(x)));
}
else if (_backgroundModel.SkillsTraitIndex > -1 &&
_backgroundModel.SkillsTraitIndex < _backgroundModel.Traits.Count)
{
TraitModel trait = _backgroundModel.Traits[_backgroundModel.SkillsTraitIndex];
_skills = trait.TextCollection[0].Trim();
}
else if (_backgroundModel.StartingTraitIndex > -1 &&
_backgroundModel.StartingTraitIndex < _backgroundModel.Traits.Count)
{
foreach (string text in _backgroundModel.Traits[_backgroundModel.StartingTraitIndex].TextCollection)
{
if (text.Contains("Skills: "))
{
_skills = text.Replace("Skills: ", "").Trim();
break;
}
}
}
foreach (TraitModel trait in _backgroundModel.Traits)
{
_traits.Add(new TraitViewModel(trait));
}
}
private void Initialize()
{
_details = "None";
if (_backgroundModel.Skills.Count > 0)
{
_details = String.Join(", ", _backgroundModel.Skills.Select(x => _stringService.GetString(x)));
}
else if (_backgroundModel.SkillsTraitIndex > -1 &&
_backgroundModel.SkillsTraitIndex < _backgroundModel.Traits.Count)
{
TraitModel trait = _backgroundModel.Traits[_backgroundModel.SkillsTraitIndex];
_details = trait.TextCollection[0].Trim();
}
else if (_backgroundModel.StartingTraitIndex > -1 &&
_backgroundModel.StartingTraitIndex < _backgroundModel.Traits.Count)
{
foreach (string text in _backgroundModel.Traits[_backgroundModel.StartingTraitIndex].TextCollection)
{
if (text.Contains("Skills: "))
{
_details = text.Replace("Skills: ", "").Trim();
break;
}
}
}
}
private void LoadTraits()
{
try
{
using (var context = new DatabaseContext())
{
List <TraitModel> traits = new List <TraitModel>();
var traitsWithParent = new Dictionary <TraitModel, List <string> >();
var traitArr = context.VnCharacterTraits
.Where(x => x.CharacterId == _characterId && x.SpoilerLevel <= Globals.MaxSpoiler).Select(x => x.TraitId)
.ToArray();
traits.AddRange(traitArr.Select(trait => new TraitModel(Convert.ToInt32(trait), _TraitService)));
foreach (var trait in traits)
{
TraitModel parenttrait = _TraitService.GetLastParentTrait(trait);
if (traitsWithParent.Keys.Any(x => x.Name == parenttrait.Name))
{
traitsWithParent[traitsWithParent.Keys.First(x => x.Name == parenttrait.Name)].Add(trait.Name);
}
else
{
traitsWithParent.Add(parenttrait, new List <string>()
{
trait.Name
});
}
}
string[] rootTraits = traitsWithParent.Select(parent => parent.Key.Name).ToArray();
foreach (var mainTrait in rootTraits)
{
var childTraitList = traitsWithParent.Where(x => x.Key.Name == mainTrait).Select(x => x.Value)
.First();
List <Button> buttonList = childTraitList.Select(trait => new Button()
{
Content = trait, Command = SetSelectedTraitCommand, CommandParameter = trait
}).ToList();
TraitCollection.Add(new TraitNameClickable()
{
RootParentTrait = mainTrait, TraitList = buttonList
});
}
}
}
catch (Exception exception)
{
Globals.Logger.Error(exception);
throw;
}
}
public TraitViewModel(TraitModel traitModel)
{
_traitModel = traitModel;
for (int i = 0; i < _traitModel.TextCollection.Count; ++i)
{
_text += _traitModel.TextCollection[i].Replace("\t", Environment.NewLine);
if (i + 1 < _traitModel.TextCollection.Count)
{
_text += Environment.NewLine;
}
}
}
public TraitModel GetLastParentTrait(TraitModel trait)
{
if (trait.ParentTraits == null)
{
return(trait);
}
if (trait.ParentTraits.Any())
{
return(GetLastParentTrait(trait.ParentTraits.Last()));
}
else
{
return(trait);
}
}
private async void Button_Click_1(object sender, RoutedEventArgs e)
{
try
{
List <TraitModel> traits = new List <TraitModel>();
var traitsWithParent = new Dictionary <TraitModel, List <string> >();
using (var context = new DatabaseContext())
{
var traitArr = context.VnCharacterTraits
.Where(x => x.CharacterId == 107 && x.SpoilerLevel < Globals.MaxSpoiler).Select(x => x.TraitId)
.ToArray();
traits.AddRange(traitArr.Select(trait => new TraitModel(Convert.ToInt32(trait), _TraitService)));
foreach (var trait in traits)
{
TraitModel parenttrait = _TraitService.GetLastParentTrait(trait);
if (traitsWithParent.Keys.Any(x => x.Name == parenttrait.Name))
{
traitsWithParent[traitsWithParent.Keys.First(x => x.Name == parenttrait.Name)].Add(trait.Name);
}
else
{
traitsWithParent.Add(parenttrait, new List <string>()
{
trait.Name
});
}
}
}
var formatted = traitsWithParent
.OrderBy(x => x.Key.Name)
.ToDictionary(x => x.Key, y => string.Join(", ", y.Value.OrderBy(z => z).ToList()));
}
catch (Exception exception)
{
Console.WriteLine(exception);
Globals.Logger.Error(exception);
throw;
}
}
private bool HasLanguage(BackgroundModel backgroundModel, LanguageModel languageModel)
{
bool hasLanguage = languageModel == null;
if (languageModel != null)
{
if (backgroundModel.LanguagesTraitIndex > -1 &&
backgroundModel.LanguagesTraitIndex < backgroundModel.Traits.Count)
{
TraitModel trait = backgroundModel.Traits[backgroundModel.LanguagesTraitIndex];
hasLanguage = trait.Text.ToLower().Contains(languageModel.Name.ToLower());
}
else if (backgroundModel.StartingTraitIndex > -1 &&
backgroundModel.StartingTraitIndex < backgroundModel.Traits.Count)
{
TraitModel trait = backgroundModel.Traits[backgroundModel.StartingTraitIndex];
hasLanguage = trait.Text.ToLower().Contains(languageModel.Name.ToLower());
}
}
return(hasLanguage);
}
private bool HasTool(BackgroundModel backgroundModel, Enum tool)
{
bool hasTool = tool == null;
if (tool != null)
{
string toolString = _stringService.GetString(tool).ToLower();
if (backgroundModel.ToolsTraitIndex > -1 &&
backgroundModel.ToolsTraitIndex < backgroundModel.Traits.Count)
{
TraitModel trait = backgroundModel.Traits[backgroundModel.ToolsTraitIndex];
hasTool = trait.Text.ToLower().Contains(toolString);
}
else if (backgroundModel.StartingTraitIndex > -1 &&
backgroundModel.StartingTraitIndex < backgroundModel.Traits.Count)
{
TraitModel trait = backgroundModel.Traits[backgroundModel.StartingTraitIndex];
hasTool = trait.Text.ToLower().Contains(toolString);
}
}
return(hasTool);
}
public bool IsAssignable(TraitModel model)
{
var assigned = List.Where(x => x.Level > 0).ToList();
return(assigned.All(x => x.Id != model.Id) && assigned.Count < 2);
}
public static CardState Craft(TraitModel trait, CardModel card)
{
return(new CardState(card.maxHp, trait));
}
public CardState(int hp, TraitModel trait)
{
HP = hp;
Traits.Add(trait);
}
