private void RemoveButtonClickChild(object sender, RoutedEventArgs e)
{
if (ArchetypesList.SelectedItem == null)
{
return;
}
ArchetypeBase selected = (ArchetypeBase)ArchetypesList.SelectedItem;
if (NodesList.SelectedItem == null)
{
return;
}
ArchetypeSkillNode selectedNode = (ArchetypeSkillNode)NodesList.SelectedItem;
if (ChildList.SelectedItem == null)
{
return;
}
selectedNode.Children.Remove((int)ChildList.SelectedItem);
ChildList.Items.Refresh();
DrawCanvas();
}
private void TypeBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
ComboBox box = (ComboBox)sender;
if (box.SelectedValue == null || ArchetypesList.SelectedItem == null || NodesList.SelectedItem == null)
{
return;
}
ArchetypeBase selected = (ArchetypeBase)ArchetypesList.SelectedItem;
ArchetypeSkillNode node = (ArchetypeSkillNode)NodesList.SelectedItem;
if ((NodeType)e.AddedItems[0] == NodeType.ABILITY)
{
NodeAbilityList.IsReadOnly = false;
NodeAbilityList.IsHitTestVisible = true;
NodeAbilityList.Focusable = true;
}
else
{
NodeAbilityList.IsHitTestVisible = false;
NodeAbilityList.Focusable = false;
NodeAbilityList.IsReadOnly = true;
NodeAbilityList.SelectedItem = null;
node.AbilityId = null;
}
}
private Vector3 BuildArchetypeTree(ArchetypeBase archetypeBase, UILineRenderer treeParent, Dictionary <ArchetypeSkillNode, ArchetypeUITreeNode> nodeDict)
{
HashSet <ArchetypeSkillNode> traversedNodes = new HashSet <ArchetypeSkillNode>();
largestX = 0;
largestY = 0;
Vector3 homeNodePosition = Vector3.zero;
Vector2 halfScreen = new Vector2(0, UIManager.Instance.referenceResolution.y / 2);
foreach (ArchetypeSkillNode node in archetypeBase.nodeList)
{
if (node.initialLevel == 1)
{
CreateTreeNode(node, traversedNodes, archetypeBase, treeParent, nodeDict);
}
}
foreach (ArchetypeUITreeNode uiNode in nodeDict.Values)
{
uiNode.CheckSurroundingNodes();
if (uiNode.node.id == 0)
{
homeNodePosition = (uiNode.transform as RectTransform).anchoredPosition;
}
}
treeParent.rectTransform.sizeDelta = new Vector2(largestX * 230, largestY * 150);
return(-homeNodePosition);
}
public static AbilityCoreItem CreateAbilityItemFromArchetype(ArchetypeBase archetypeItem, AbilityBase abilityBase)
{
{
string name = archetypeItem.LocalizedName + "'s " + abilityBase.LocalizedName;
return(new AbilityCoreItem(abilityBase, name));
}
}
public void SelectArchetype(int i)
{
ArchetypeBase archetype;
Button button;
Button button2;
if (i == 0)
{
archetype = selectedHero.PrimaryArchetype.Base;
button = ArchetypeButton1;
button2 = ArchetypeButton2;
}
else
{
archetype = selectedHero.SecondaryArchetype.Base;
button = ArchetypeButton2;
button2 = ArchetypeButton1;
}
if (archetypeToKeep == archetype)
{
archetypeToKeep = null;
button.image.color = Color.white;
button2.image.color = Color.white;
textBox.text = "XP Stock Gained: " + (selectedHero.Experience * 0.4f).ToString("N0");
}
else
{
archetypeToKeep = archetype;
button.image.color = Helpers.SELECTION_COLOR;
button2.image.color = Color.white;
textBox.text = "Archetype " + archetypeToKeep.LocalizedName + " will be returned as an item.\nXP Stock Gained: " + (selectedHero.Experience * 0.2f).ToString("N0");
}
}
public HeroArchetypeData(ArchetypeBase archetype, HeroData hero)
{
Id = Guid.NewGuid();
Base = archetype;
this.hero = hero;
AvailableAbilityList = new ArchetypeLeveledAbilityList();
InitializeArchetypeData();
}
private void AddButtonClick(object sender, RoutedEventArgs e)
{
ArchetypeBase temp = new ArchetypeBase
{
IdName = "UNTITLED NEW",
};
Archetypes.Add(temp);
//ArchetypesList.Items.Refresh();
currentID++;
}
public void OpenPreviewTree(ArchetypeBase archetype)
{
isPreviewMode = true;
UIManager.Instance.ArchetypeNodeInfoPanel.SetPreviewMode(true);
secondaryTreeParent.gameObject.SetActive(false);
primaryTreeParent.gameObject.SetActive(true);
ScrollView.content = primaryTreeParent.rectTransform;
UIManager.Instance.OpenWindow(gameObject, false);
BuildArchetypeTree(archetype);
SetTreeStartingView(0);
}
private void ChildNumRefresh()
{
if (ArchetypesList.SelectedItem == null)
{
return;
}
ArchetypeBase selected = (ArchetypeBase)ArchetypesList.SelectedItem;
ChildNum.ItemsSource = null;
ChildNum.ItemsSource = selected.NodeList;
}
private void CopyButtonClick(object sender, RoutedEventArgs e)
{
if (ArchetypesList.SelectedItem == null)
{
return;
}
ArchetypeBase temp = ArchetypeBase.DeepClone((ArchetypeBase)ArchetypesList.SelectedItem);
Archetypes.Add(temp);
//ArchetypesList.Items.Refresh();
currentID++;
}
private void OnEnable()
{
selectedHero = null;
archetypeToKeep = null;
ArchetypeButton1.gameObject.SetActive(false);
ArchetypeButton2.gameObject.SetActive(false);
confirmButton.interactable = false;
buttonText.text = "Select Hero";
helpText.text = "";
textBox.text = "";
slotsText.text = "Hero Slots: " + GameManager.Instance.PlayerStats.HeroList.Count + "/" + PlayerStats.maxHeroes;
}
public static HeroData CreateNewHero(string name, ArchetypeBase primaryArchetype, ArchetypeBase subArchetype = null)
{
HeroData hero = new HeroData(name);
hero.archetypeList[0] = new HeroArchetypeData(primaryArchetype, hero);
if (subArchetype != null)
{
hero.archetypeList[1] = new HeroArchetypeData(subArchetype, hero);
}
hero.LevelUp();
return(hero);
}
private void DoubleUpDown_ValueChanged(object sender, RoutedPropertyChangedEventArgs <object> e)
{
DoubleUpDown d = ((DoubleUpDown)sender);
if (d.Value == null)
{
return;
}
switch (d.Name)
{
case "HpGrow":
HealthL.Content = Math.Round((double)d.Value * 100f, 1, MidpointRounding.AwayFromZero);
break;
case "SpGrow":
SoulL.Content = Math.Round((double)d.Value * 100f, 1, MidpointRounding.AwayFromZero);
break;
case "StrGrow":
StrL.Content = Math.Round((double)d.Value * 100f, 1, MidpointRounding.AwayFromZero);
break;
case "IntGrow":
IntL.Content = Math.Round((double)d.Value * 100f, 1, MidpointRounding.AwayFromZero);
break;
case "AgiGrow":
AgiL.Content = Math.Round((double)d.Value * 100f, 1, MidpointRounding.AwayFromZero);
break;
case "WillGrow":
WillL.Content = Math.Round((double)d.Value * 100f, 1, MidpointRounding.AwayFromZero);
break;
}
if (ArchetypesList.SelectedItem == null)
{
return;
}
ArchetypeBase selected = (ArchetypeBase)ArchetypesList.SelectedItem;
double totalstats = 0, totalhpsp = 0, total = 0;
totalstats = selected.StrengthGrowth + selected.IntelligenceGrowth + selected.AgilityGrowth + selected.WillGrowth;
//totalhpsp = selected.HealthGrowth + selected.SoulPointGrowth * 50;
totalhpsp = selected.HealthGrowth;
total = totalhpsp + totalstats;
TotalL.Content = totalstats.ToString("F2") + " + " + totalhpsp.ToString("F2") + " = " + total.ToString("F2");
}
public static Color GetArchetypeStatColor(ArchetypeBase archetype)
{
List <float> growths = new List <float>()
{
archetype.strengthGrowth, archetype.intelligenceGrowth, archetype.agilityGrowth, archetype.willGrowth
};
int sameCount = 0, sameGrowthIndex = 0, highestIndex = 0, secondHighestIndex = 0;
float highest = 0, secondHighest = 0, sum = 0;
for (int i = 0; i < growths.Count; i++)
{
if (growths[i] > highest)
{
highest = growths[i];
highestIndex = i;
}
sum += growths[i];
}
for (int j = 0; j < growths.Count; j++)
{
if (j == highestIndex)
{
continue;
}
else if (growths[j] == highest)
{
sameCount++;
sameGrowthIndex = j;
}
else if (growths[j] > secondHighest)
{
secondHighest = growths[j];
secondHighestIndex = j;
}
}
if (sameCount >= 2)
{
return(NORMAL_COLOR);
}
else if (sameCount == 1)
{
return(Color.Lerp(GetColorFromStatIndex(highestIndex), GetColorFromStatIndex(sameGrowthIndex), 0.5f));
}
else
{
return(Color.Lerp(GetColorFromStatIndex(highestIndex), Color.Lerp(GetColorFromStatIndex(highestIndex), GetColorFromStatIndex(secondHighestIndex), 0.5f), 0.05f / (highest - growths[secondHighestIndex])));
}
}
private void AddButtonClickNode(object sender, RoutedEventArgs e)
{
if (ArchetypesList.SelectedItem == null)
{
return;
}
ArchetypeBase selected = (ArchetypeBase)ArchetypesList.SelectedItem;
ArchetypeSkillNode temp = new ArchetypeSkillNode
{
IdName = "UNTITLED NEW",
Id = selected.NodeList.Count,
};
selected.NodeList.Add(temp);
//NodesList.Items.Refresh();
//ChildNumRefresh();
}
private void CalculateTotalSkillPoints()
{
if (ArchetypesList.SelectedItem == null)
{
return;
}
ArchetypeBase selected = (ArchetypeBase)ArchetypesList.SelectedItem;
int total = 0;
foreach (ArchetypeSkillNode n in selected.NodeList)
{
total += n.MaxLevel;
total -= n.InitialLevel;
}
TotalSkillPoints.Content = total.ToString();
}
private void ShiftAllClick(object sender, RoutedEventArgs e)
{
if (ArchetypesList.SelectedItem == null)
{
return;
}
ArchetypeBase archetypeBase = ArchetypesList.SelectedItem as ArchetypeBase;
int xShift = (int)ShiftX.Value;
int yShift = (int)ShiftY.Value;
foreach (ArchetypeSkillNode node in archetypeBase.NodeList)
{
node.NodePosition.x += xShift;
node.NodePosition.y += yShift;
}
DrawCanvas();
}
// Version for archetype items
private ArchetypeUITreeNode CreateTreeNode(ArchetypeSkillNode node, HashSet <ArchetypeSkillNode> traversedNodes,
ArchetypeBase archetypeBase, UILineRenderer parent, Dictionary <ArchetypeSkillNode, ArchetypeUITreeNode> nodeDict)
{
if (node == null)
{
return(null);
}
ArchetypeUITreeNode currentNode;
// Check if node has been traversed yet
// if already created, just return the node
if (traversedNodes.Add(node))
{
currentNode = Instantiate(nodePrefab, parent.transform);
currentNode.SetNode(node, null, true);
nodeDict.Add(node, currentNode);
if (Math.Abs(node.nodePosition.x) > largestX)
{
largestX = Math.Abs(node.nodePosition.x);
}
if (Math.Abs(node.nodePosition.y) > largestY)
{
largestY = Math.Abs(node.nodePosition.y);
}
}
else
{
return(nodeDict[node]);
}
foreach (int x in node.children)
{
ArchetypeSkillNode n = archetypeBase.GetNode(x);
ArchetypeUITreeNode child = CreateTreeNode(n, traversedNodes, archetypeBase, parent, nodeDict);
currentNode.connectedNodes.Add(child, null);
child.connectedNodes.Add(currentNode, null);
UILineRenderer.LinePoint point = new UILineRenderer.LinePoint(currentNode.transform.localPosition + LineOffsetY, child.transform.localPosition + LineOffsetY, Color.black);
parent.AddPoints(point);
}
return(currentNode);
}
private void RemoveAffixClick(object sender, RoutedEventArgs e)
{
if (ArchetypesList.SelectedItem == null)
{
return;
}
if (infusionList.SelectedItem == null || infusionList.SelectedItems.Count == 0)
{
return;
}
ArchetypeBase archetypeBase = ArchetypesList.SelectedItem as ArchetypeBase;
for (int i = infusionList.SelectedItems.Count - 1; i >= 0; i--)
{
AffixBase affixBase = (AffixBase)infusionList.SelectedItems[i];
archetypeBase.InfusionAffixes_Editor.Remove(affixBase);
}
}
private void TextBlock_Loaded(object sender, RoutedEventArgs e)
{
if (sender == null)
{
return;
}
if (ArchetypesList.SelectedItem == null)
{
return;
}
if (NodesList.SelectedItem == null)
{
return;
}
ArchetypeBase selected = (ArchetypeBase)ArchetypesList.SelectedItem;
if (selected.NodeList.Count == 0)
{
return;
}
ArchetypeSkillNode selectedNode = NodesList.SelectedItem as ArchetypeSkillNode;
TextBlock s = sender as TextBlock;
if (s.Text == null || s.Text == "")
{
return;
}
if (int.TryParse(s.Text, out int x))
{
IEnumerable <ArchetypeSkillNode> targetNode = selected.NodeList.Where(y => y.Id == x);
if (targetNode.Count() == 0)
{
s.Text = x + "\t ERROR";
}
else
{
s.Text = x + "\t" + targetNode.First().IdName;
}
}
}
public void OnClickConfirm()
{
if (selectedHero == null)
{
return;
}
for (int i = 0; i < 3; i++)
{
selectedHero.UnequipAbility(i);
}
foreach (EquipSlotType e in Enum.GetValues(typeof(EquipSlotType)))
{
selectedHero.UnequipFromSlot(e);
}
float xp;
if (archetypeToKeep == null)
{
xp = selectedHero.Experience * 0.4f;
}
else
{
GameManager.Instance.PlayerStats.AddArchetypeToInventory(ArchetypeItem.CreateArchetypeItem(archetypeToKeep, selectedHero.Level));
xp = selectedHero.Experience * 0.2f;
}
GameManager.Instance.PlayerStats.RemoveHeroFromList(selectedHero);
selectedHero = null;
archetypeToKeep = null;
GameManager.Instance.PlayerStats.ModifyExpStock((int)xp);
SaveManager.Save();
ArchetypeButton1.gameObject.SetActive(false);
ArchetypeButton2.gameObject.SetActive(false);
buttonText.text = "Select Hero";
helpText.text = "";
textBox.text = "";
slotsText.text = "Hero Slots: " + GameManager.Instance.PlayerStats.HeroList.Count + "/" + PlayerStats.maxHeroes;
}
private void RemoveButtonClickNode(object sender, RoutedEventArgs e)
{
if (ArchetypesList.SelectedItem == null)
{
return;
}
ArchetypeBase selected = (ArchetypeBase)ArchetypesList.SelectedItem;
if (NodesList.SelectedItem == null)
{
return;
}
ArchetypeSkillNode selectedNode = (ArchetypeSkillNode)NodesList.SelectedItem;
selected.NodeList.Remove(selectedNode);
//NodesList.Items.Refresh();
//ChildNumRefresh();
}
private void AddAffix_Click(object sender, RoutedEventArgs e)
{
if (ArchetypesList.SelectedItem == null)
{
return;
}
if (affixList.SelectedItem == null || affixList.SelectedItems.Count == 0)
{
return;
}
ArchetypeBase archetypeBase = ArchetypesList.SelectedItem as ArchetypeBase;
foreach (AffixBase affixBase in affixList.SelectedItems)
{
if (!archetypeBase.InfusionAffixes_Editor.Contains(affixBase))
{
archetypeBase.InfusionAffixes_Editor.Add(affixBase);
}
}
}
private void AddArchetypeDrops(BattleEndWindow battleEndWindow)
{
//Get Archetype
int archetypeDrops = 1 + survivalLoopCount / 3;
int i = 0;
if (stageInfo.archetypeDropList.Count != 0)
{
WeightList <string> stageDropList = Helpers.CreateWeightListFromWeightBases(stageInfo.archetypeDropList);
string baseId = stageDropList.ReturnWeightedRandom();
ArchetypeBase archetypeBase = ResourceManager.Instance.GetArchetypeBase(baseId);
ArchetypeItem item = ArchetypeItem.CreateArchetypeItem(archetypeBase, stageLevel);
gainedArchetypeItems.Add(item);
i = 1;
}
for (; i < archetypeDrops; i++)
{
ArchetypeItem item = ArchetypeItem.CreateArchetypeItem(ResourceManager.Instance.GetRandomArchetypeBase(stageLevel + survivalLoopCount), stageLevel + survivalLoopCount);
gainedArchetypeItems.Add(item);
}
}
private void AddButtonClickChild(object sender, RoutedEventArgs e)
{
if (ArchetypesList.SelectedItem == null)
{
return;
}
if (NodesList.SelectedItem == null || ChildNum.SelectedValue == null)
{
return;
}
ArchetypeBase selected = (ArchetypeBase)ArchetypesList.SelectedItem;
ArchetypeSkillNode selectedNode = (ArchetypeSkillNode)NodesList.SelectedItem;
if (selectedNode.Children.Contains((int)ChildNum.SelectedValue))
{
return;
}
selectedNode.Children.Add((int)ChildNum.SelectedValue);
ChildList.Items.Refresh();
DrawCanvas();
}
private void CopyButtonClickNode(object sender, RoutedEventArgs e)
{
if (ArchetypesList.SelectedItem == null)
{
return;
}
ArchetypeBase selected = (ArchetypeBase)ArchetypesList.SelectedItem;
if (NodesList.SelectedItem == null)
{
return;
}
ArchetypeSkillNode selectedNode = (ArchetypeSkillNode)NodesList.SelectedItem;
ArchetypeSkillNode temp = Helpers.DeepClone(selectedNode);
temp.Id = selected.NodeList.Count;
string s = new string(temp.IdName.Where(c => char.IsDigit(c)).ToArray());
if (s.Length > 0)
{
if (Int32.TryParse(new string(temp.IdName.Where(c => char.IsDigit(c)).ToArray()), out int res))
{
temp.IdName = temp.IdName.TrimEnd(s.ToCharArray());
temp.IdName += (res + 1);
}
}
else
{
temp.IdName += 1.ToString();
}
selected.NodeList.Add(temp);
//NodesList.Items.Refresh();
//ChildNumRefresh();
}
private void CanvasEdit(object sender, RoutedPropertyChangedEventArgs <object> e)
{
if (ArchetypesList.SelectedItem == null)
{
return;
}
ArchetypeBase selected = (ArchetypeBase)ArchetypesList.SelectedItem;
foreach (ArchetypeSkillNode node in selected.NodeList)
{
foreach (int index in node.Children)
{
if (selected.NodeList.Where(y => y.Id == index).Count() == 0)
{
node.HasError = true;
}
else
{
node.HasError = false;
}
}
}
DrawCanvas();
}
public void BuildArchetypeTree(ArchetypeBase archetypeBase)
{
ResetTreeView();
hero = null;
primaryTreeStartingView = BuildArchetypeTree(archetypeBase, primaryTreeParent, primaryNodes);
}
private void DrawCanvas()
{
int spacing = GridSpacing;
NodeTree.Children.Clear();
DrawGrid();
if (ArchetypesList.SelectedItem == null)
{
return;
}
ArchetypeBase selected = (ArchetypeBase)ArchetypesList.SelectedItem;
if (selected.NodeList.Count == 0)
{
return;
}
Rectangle r;
foreach (ArchetypeSkillNode node in selected.NodeList)
{
r = new Rectangle
{
Height = 50,
Width = 50,
Stroke = System.Windows.Media.Brushes.Black,
Fill = System.Windows.Media.Brushes.LightGray
};
if (node.Type == NodeType.ABILITY)
{
r.Fill = System.Windows.Media.Brushes.PaleTurquoise;
}
if (node.InitialLevel > 0)
{
r.Fill = System.Windows.Media.Brushes.LightGreen;
}
if (node.Type == NodeType.GREATER)
{
r.Fill = System.Windows.Media.Brushes.PaleGoldenrod;
}
if (SearchBox.Text != "" && node.Bonuses.ToList().FindAll(x => x.bonusType.ToString().ToLower().Contains(SearchBox.Text.ToLower())).Any())
{
r.Fill = System.Windows.Media.Brushes.LightSkyBlue;
}
if (node.Id == selectedNodeId)
{
r.Stroke = System.Windows.Media.Brushes.Red;
}
r.MouseLeftButtonDown += mouseDown;
r.MouseLeftButtonUp += mouseUp;
r.MouseMove += rect_MouseMove;
r.DataContext = node;
TextBlock t = new TextBlock
{
Height = 50,
Width = 50,
Text = node.Id.ToString() + "\n" + node.IdName + "\nMax: " + node.MaxLevel,
FontSize = 12,
FontWeight = FontWeights.Bold,
TextAlignment = TextAlignment.Center,
TextTrimming = TextTrimming.CharacterEllipsis,
IsHitTestVisible = false
};
NodeTree.Children.Add(r);
NodeTree.Children.Add(t);
Canvas.SetLeft(r, NodeTree.ActualWidth / 2 + node.NodePosition.x * spacing - 25);
Canvas.SetBottom(r, 0 + node.NodePosition.y * spacing);
Canvas.SetLeft(t, NodeTree.ActualWidth / 2 + node.NodePosition.x * spacing - 25);
Canvas.SetBottom(t, 0 + node.NodePosition.y * spacing);
if (node.Children.Count > 0)
{
ArchetypeSkillNode c = null;
foreach (int id in node.Children)
{
c = selected.NodeList.ToList().Find(x => x.Id == id);
if (c != null)
{
Line l = new Line()
{
Stroke = System.Windows.Media.Brushes.Black,
X1 = 0,
Y1 = 0,
X2 = (c.NodePosition.x - node.NodePosition.x) * spacing,
Y2 = 0 + (node.NodePosition.y - c.NodePosition.y) * spacing
};
NodeTree.Children.Add(l);
Canvas.SetLeft(l, NodeTree.ActualWidth / 2 + node.NodePosition.x * spacing);
Canvas.SetZIndex(l, -1);
if (node.NodePosition.y <= c.NodePosition.y)
{
Canvas.SetBottom(l, 0 + node.NodePosition.y * spacing + r.Height / 2);
}
else
{
Canvas.SetBottom(l, 0 + (node.NodePosition.y - (node.NodePosition.y - c.NodePosition.y)) * spacing + r.Height / 2);
}
}
}
}
}
}
private void ArchetypeTotalsClick(object sender, RoutedEventArgs e)
{
if (ArchetypesList.SelectedItem == null)
{
return;
}
ArchetypeBase archetypeBase = ArchetypesList.SelectedItem as ArchetypeBase;
Dictionary <string, NodeTotalInfo> nodeDict = new Dictionary <string, NodeTotalInfo>();
foreach (ArchetypeSkillNode node in archetypeBase.NodeList)
{
foreach (ScalingBonusProperty_Int prop in node.Bonuses)
{
string s = prop.bonusType + "#" + prop.modifyType + "#" + prop.restriction;
if (!nodeDict.ContainsKey(s))
{
nodeDict[s] = new NodeTotalInfo(prop.bonusType, prop.modifyType, prop.restriction);
}
NodeTotalInfo totalInfo = nodeDict[s];
float finalStat;
if (node.MaxLevel == 1)
{
finalStat = prop.growthValue;
}
else
{
finalStat = prop.growthValue * (node.MaxLevel - 1) + prop.finalLevelValue;
}
if (prop.modifyType != ModifyType.MULTIPLY)
{
if (finalStat < 0)
{
totalInfo.negTotal += finalStat;
totalInfo.negTotalLevel += node.MaxLevel;
}
else
{
totalInfo.posTotal += finalStat;
totalInfo.posTotalLevel += node.MaxLevel;
}
}
else
{
if (finalStat < 0)
{
totalInfo.negTotal *= (1f + finalStat / 100f);
totalInfo.negTotalLevel += node.MaxLevel;
}
else
{
totalInfo.posTotal *= (1f + finalStat / 100f);
totalInfo.posTotalLevel += node.MaxLevel;
}
}
}
}
string display = "";
List <NodeTotalInfo> list = nodeDict.Values.OrderBy(x => x.bonus).ToList();
foreach (NodeTotalInfo nodeInfo in list)
{
if (nodeInfo.mod == ModifyType.FIXED_TO)
{
continue;
}
if (nodeInfo.mod != ModifyType.MULTIPLY)
{
if (nodeInfo.posTotal > 0)
{
float posAvg = nodeInfo.posTotal / nodeInfo.posTotalLevel;
display += Localization.GetBonusTypeString(nodeInfo.bonus, nodeInfo.mod, nodeInfo.posTotal, nodeInfo.posTotal, nodeInfo.restrict) + "Levels: " + nodeInfo.posTotalLevel + ", Avg: " + posAvg.ToString("n2") + "\n\n";
}
if (nodeInfo.negTotal < 0)
{
float negAvg = nodeInfo.negTotal / nodeInfo.negTotalLevel;
display += Localization.GetBonusTypeString(nodeInfo.bonus, nodeInfo.mod, nodeInfo.negTotal, nodeInfo.negTotal, nodeInfo.restrict) + "Levels: " + nodeInfo.negTotalLevel + ", Avg: " + negAvg.ToString("n2") + "\n\n";
}
}
else
{
if (nodeInfo.posTotal > 100f)
{
float posAvg = nodeInfo.posTotal / nodeInfo.posTotalLevel;
nodeInfo.posTotal -= 100f;
display += Localization.GetBonusTypeString(nodeInfo.bonus, nodeInfo.mod, nodeInfo.posTotal, nodeInfo.posTotal, nodeInfo.restrict) + "Levels: " + nodeInfo.posTotalLevel + ", Avg: " + posAvg.ToString("n2") + "\n\n";
}
if (nodeInfo.negTotal < 100f)
{
float negAvg = nodeInfo.negTotal / nodeInfo.negTotalLevel;
nodeInfo.negTotal -= 100f;
display += Localization.GetBonusTypeString(nodeInfo.bonus, nodeInfo.mod, nodeInfo.negTotal, nodeInfo.negTotal, nodeInfo.restrict) + "Levels: " + nodeInfo.negTotalLevel + ", Avg: " + negAvg.ToString("n2") + "\n\n";
}
}
}
//MessageBoxResult result = System.Windows.MessageBox.Show(display, "Totals", MessageBoxButton.OK);
TotalsDisplay totalsDisplay = new TotalsDisplay(display);
totalsDisplay.ShowDialog();
}
