private void BonusGridSumValues()
{
if (ArchetypesList.SelectedItem == null)
{
return;
}
if (NodesList.SelectedItem == null)
{
return;
}
if (BonusGrid == null)
{
return;
}
ArchetypeSkillNode node = NodesList.SelectedItem as ArchetypeSkillNode;
for (int i = 0; i < BonusGrid.Items.Count; ++i)
{
var k = BonusGrid.Items[i];
if (k is ScalingBonusProperty_Int)
{
ScalingBonusProperty_Int o = k as ScalingBonusProperty_Int;
SetBonusEditorValues(o, node);
}
}
}
public void SetNode(ArchetypeSkillNode n, HeroArchetypeData data, bool isPreviewMode)
{
node = n;
archetypeData = data;
for (int i = 0; i < node.maxLevel - 1; i++)
{
Image newLevelIcon = Instantiate(levelIcons[0], levelIconParent.transform);
levelIcons.Add(newLevelIcon);
}
if (node.type == NodeType.GREATER)
{
GetComponent <Image>().sprite = UIManager.Instance.ArchetypeUITreeWindow.LargeNodeImage;
((RectTransform)transform).sizeDelta = new Vector2(95, 95);
}
this.isPreviewMode = isPreviewMode;
if (isPreviewMode)
{
UpdateNodePreview();
}
else
{
UpdateNode();
}
((RectTransform)transform).anchoredPosition = new Vector3(n.nodePosition.x * 110, n.nodePosition.y * 110 + yPositionOffset, 0);
}
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;
}
}
// Version for Archetypes attached to heroes
private ArchetypeUITreeNode CreateTreeNode(ArchetypeSkillNode node, HashSet <ArchetypeSkillNode> traversedNodes,
HeroArchetypeData archetype, 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, archetype, false);
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]);
}
int currentNodeLevel = archetype.GetNodeLevel(node);
foreach (int x in node.children)
{
ArchetypeSkillNode n = archetype.Base.GetNode(x);
ArchetypeUITreeNode child = CreateTreeNode(n, traversedNodes, archetype, parent, nodeDict);
Color color = Color.black;
int childNodeLevel = archetype.GetNodeLevel(n);
if (currentNodeLevel > 0 && childNodeLevel > 0)
{
color = ArchetypeUITreeNode.CONNECTED_COLOR;
}
else if (currentNodeLevel > 0 || childNodeLevel > 0)
{
color = ArchetypeUITreeNode.AVAILABLE_COLOR;
}
UILineRenderer.LinePoint point = new UILineRenderer.LinePoint(currentNode.transform.localPosition + LineOffsetY, child.transform.localPosition + LineOffsetY, color);
currentNode.connectedNodes.Add(child, point);
child.connectedNodes.Add(currentNode, point);
parent.AddPoints(point);
}
return(currentNode);
}
public bool IsNodeMaxLevel(ArchetypeSkillNode node)
{
if (nodeLevels[node.id] == node.maxLevel)
{
return(true);
}
else
{
return(false);
}
}
private void SetBonusEditorValues(ScalingBonusProperty_Int bonus, ArchetypeSkillNode node)
{
if (node.MaxLevel == 1)
{
bonus.sum = bonus.growthValue;
}
else
{
bonus.sum = bonus.growthValue * (node.MaxLevel - 1) + bonus.finalLevelValue;
}
bonus.perPoint = (float)bonus.sum / node.MaxLevel;
}
private void NodesList_Selected(object sender, RoutedEventArgs e)
{
ListView view = sender as ListView;
ArchetypeSkillNode archetypeSkillNode = view.SelectedItem as ArchetypeSkillNode;
if (archetypeSkillNode == null)
{
selectedNodeId = -1;
return;
}
selectedNodeId = archetypeSkillNode.Id;
DrawCanvas();
}
private void LoadNodeLevelsFromSave(ArchetypeSkillNode node, int initalLevel, int setLevel)
{
if (node == null)
{
return;
}
if (initalLevel == setLevel)
{
return;
}
hero.ModifyArchetypePoints(-(setLevel - initalLevel));
if (node.type == NodeType.ABILITY && setLevel >= 1)
{
AvailableAbilityList.Add(node.GetAbility());
}
foreach (var bonus in node.bonuses)
{
float bonusValue = 0f;
if (setLevel > initalLevel)
{
if (setLevel == 1 && node.maxLevel == 1)
{
bonusValue = bonus.growthValue;
}
else if (setLevel == node.maxLevel)
{
int difference = setLevel - initalLevel - 1;
bonusValue = bonus.growthValue * difference + bonus.finalLevelValue;
}
else
{
int difference = setLevel - initalLevel;
bonusValue = bonus.growthValue * difference;
}
hero.AddArchetypeStatBonus(bonus.bonusType, bonus.restriction, bonus.modifyType, bonusValue);
}
}
foreach (TriggeredEffectBonusProperty triggeredEffectBonus in node.triggeredEffects)
{
TriggeredEffect t = new TriggeredEffect(triggeredEffectBonus, triggeredEffectBonus.effectMinValue, node.idName);
hero.AddTriggeredEffect(triggeredEffectBonus, t);
}
nodeLevels[node.id] = setLevel;
AllocatedPoints += setLevel;
}
public void SetAndUpdatePanel(ArchetypeSkillNode node, HeroArchetypeData archetypeData, ArchetypeUITreeNode uiNode)
{
this.node = node;
this.archetypeData = archetypeData;
this.uiNode = uiNode;
if (isPreviewMode)
{
UpdatePanel_Preview();
}
else
{
UpdatePanel();
}
}
private void mouseUp(object sender, MouseEventArgs e)
{
var rect = (Rectangle)sender;
rect.ReleaseMouseCapture();
if (rect.DataContext != null)
{
ArchetypeSkillNode a = (ArchetypeSkillNode)rect.DataContext;
NodesList.SelectedItem = a;
a.NodePosition.x = (int)Math.Round((Canvas.GetLeft(rect) - NodeTree.ActualWidth / 2) / GridSpacing, 0);
a.NodePosition.y = (int)Math.Round(Canvas.GetBottom(rect) / GridSpacing, 0);
}
DrawCanvas();
}
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();
}
// 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 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;
}
}
}
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 BonusGrid_LoadingRow(object sender, DataGridRowEventArgs e)
{
if (ArchetypesList.SelectedItem == null)
{
return;
}
if (NodesList.SelectedItem == null)
{
return;
}
ArchetypeSkillNode node = NodesList.SelectedItem as ArchetypeSkillNode;
DataGridRow r = e.Row;
int i = e.Row.GetIndex();
var k = e.Row.Item;
if (k is ScalingBonusProperty_Int)
{
ScalingBonusProperty_Int o = k as ScalingBonusProperty_Int;
SetBonusEditorValues(o, node);
}
}
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();
}
public bool DelevelNode(ArchetypeSkillNode node)
{
if (nodeLevels[node.id] == node.initialLevel)
{
return(false);
}
if (node.type == NodeType.ABILITY)
{
var ability = AvailableAbilityList.GetAbility(node.GetAbility());
if (ability.equippedHero != null)
{
hero.UnequipAbility(ability.equippedSlot);
}
AvailableAbilityList.Remove(node.GetAbility());
}
foreach (var bonus in node.bonuses)
{
float bonusValue = 0f;
if (bonus.modifyType != ModifyType.MULTIPLY)
{
if (nodeLevels[node.id] == 1)
{
bonusValue = bonus.growthValue;
}
else if (nodeLevels[node.id] == node.maxLevel)
{
bonusValue = bonus.finalLevelValue;
}
else
{
bonusValue = bonus.growthValue;
}
hero.RemoveArchetypeStatBonus(bonus.bonusType, bonus.restriction, bonus.modifyType, bonusValue);
}
else
{
if (nodeLevels[node.id] == 1)
{
bonusValue = bonus.growthValue;
}
else if (nodeLevels[node.id] == node.maxLevel)
{
bonusValue = bonus.growthValue * (nodeLevels[node.id] - 1) + bonus.finalLevelValue;
hero.AddArchetypeStatBonus(bonus.bonusType, bonus.restriction, bonus.modifyType, bonus.growthValue * (nodeLevels[node.id] - 1));
}
else
{
bonusValue = bonus.growthValue * nodeLevels[node.id];
hero.AddArchetypeStatBonus(bonus.bonusType, bonus.restriction, bonus.modifyType, bonus.growthValue * (nodeLevels[node.id] - 1));
}
hero.RemoveArchetypeStatBonus(bonus.bonusType, bonus.restriction, bonus.modifyType, bonusValue);
}
}
if (nodeLevels[node.id] == 1)
{
foreach (TriggeredEffectBonusProperty triggeredEffectBonus in node.triggeredEffects)
{
hero.RemoveTriggeredEffect(triggeredEffectBonus);
}
}
nodeLevels[node.id]--;
AllocatedPoints--;
hero.UpdateActorData();
return(true);
}
public bool LevelUpNode(ArchetypeSkillNode node)
{
if (nodeLevels[node.id] == node.maxLevel)
{
return(false);
}
nodeLevels[node.id]++;
AllocatedPoints++;
if (node.type == NodeType.ABILITY)
{
AvailableAbilityList.Add(node.GetAbility());
}
foreach (var bonus in node.bonuses)
{
float bonusValue = 0f;
if (bonus.modifyType != ModifyType.MULTIPLY)
{
if (nodeLevels[node.id] == 1)
{
bonusValue = bonus.growthValue;
}
else if (nodeLevels[node.id] == node.maxLevel)
{
bonusValue = bonus.finalLevelValue;
}
else
{
bonusValue = bonus.growthValue;
}
hero.AddArchetypeStatBonus(bonus.bonusType, bonus.restriction, bonus.modifyType, bonusValue);
}
else
{
if (nodeLevels[node.id] == 1)
{
bonusValue = bonus.growthValue;
}
else if (nodeLevels[node.id] == node.maxLevel)
{
bonusValue = bonus.growthValue * (nodeLevels[node.id] - 1) + bonus.finalLevelValue;
hero.RemoveArchetypeStatBonus(bonus.bonusType, bonus.restriction, bonus.modifyType, bonus.growthValue * (nodeLevels[node.id] - 1));
}
else
{
bonusValue = bonus.growthValue * nodeLevels[node.id];
hero.RemoveArchetypeStatBonus(bonus.bonusType, bonus.restriction, bonus.modifyType, bonus.growthValue * (nodeLevels[node.id] - 1));
}
hero.AddArchetypeStatBonus(bonus.bonusType, bonus.restriction, bonus.modifyType, bonusValue);
}
}
if (nodeLevels[node.id] == 1)
{
foreach (TriggeredEffectBonusProperty triggeredEffectBonus in node.triggeredEffects)
{
TriggeredEffect t = new TriggeredEffect(triggeredEffectBonus, triggeredEffectBonus.effectMinValue, node.idName);
hero.AddTriggeredEffect(triggeredEffectBonus, t);
}
}
hero.UpdateActorData();
return(true);
}
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);
}
}
}
}
}
}
public int GetNodeLevel(ArchetypeSkillNode node)
{
return(nodeLevels[node.id]);
}