public static CareerNode RandomCareerNode(int id, int child1, int child2, int child3)
{
string[] args = new string[6];
args[0] = "" + id;
args[2] = "" + child1;
args[3] = "" + child2;
args[4] = "" + child3;
args[5] = "";
int nodeType = 1;
if (Util.RandInt(0, 100) > 80)
{
nodeType = 5; // Weighted distribution of rest sites
}
args[1] = "" + nodeType;
if (nodeType == 1)
{
args[5] = RandomArenaMap();
}
return(CareerNode.FromRow(args));
}
public static System.Collections.Generic.Dictionary <int, CareerNode[]> GetLevels(List <CareerNode> nodes)
{
System.Collections.Generic.Dictionary <int, CareerNode[]> ret;
ret = new System.Collections.Generic.Dictionary <int, CareerNode[]>();
CareerNode root = Root(nodes);
CareerNode[] rootRow = new CareerNode[1];
rootRow[0] = root;
ret.Add(0, rootRow);
if (root == null)
{
GD.Print("CareerNode.GetLevels Root node null");
return(null);
}
else if (root.IsLeaf())
{
return(ret);
}
int level = 1;
List <CareerNode> nextLevel = GetChildren(root, nodes);
while (nextLevel.Count > 0)
{
ret.Add(level, nextLevel.ToArray());
level++;
nextLevel = GetChildren(nextLevel, nodes);
}
return(ret);
}
/*
* As a player traverses their career, they will be presented with
* multiple choices per level according to previous choices.
*
*/
public static bool NodeIsActive(CareerNode node, List <CareerNode> nodes, int currentLevel, int lastNode)
{
if (node == null || nodes == null)
{
GD.Print("NodeIsActive: Invalid args " + node + "," + nodes);
return(false);
}
int nodeLevel = GetLevel(node, nodes);
if (node.IsLeaf() && currentLevel == -1)
{
return(true);
}
if (CareerNode.IsRoot(node, nodes) && currentLevel == 0)
{
GD.Print("Node " + node.nodeId + " is root and currentLevel is 0");
return(true);
}
if (node.HasChild(lastNode))
{
return(true);
}
return(false);
}
public static bool IsRoot(CareerNode node, List <CareerNode> nodes)
{
if (ParentCount(node, nodes) == 0)
{
return(true);
}
return(false);
}
public static Career LoadCareer()
{
GD.Print("CareerDb.LoadCareer");
List <CareerNode> nodes = CareerNode.FromRows(CSV.ReadRows(CareerFile));
StatsManager stats = StatsManager.FromRows(CSV.ReadRows(StatsFile));
return(Career.Factory(nodes, stats));
}
public static Career Factory(string championName)
{
Career ret = new Career(championName);
ret.careerNodes = GenerateCareerTree(championName);
ret.root = CareerNode.Root(ret.careerNodes);
ret.leaves = CareerNode.Leaves(ret.careerNodes);
return(ret);
}
void ScaleNodeButtons()
{
System.Collections.Generic.Dictionary <int, CareerNode[]> levels = CareerNode.GetLevels(careerNodes);
List <CareerNode> nodes = Session.session.career.careerNodes;
foreach (int key in levels.Keys)
{
ScaleLevel(key, levels[key], nodes);
}
}
public static Career Factory(List <CareerNode> careerNodes, StatsManager stats)
{
Career ret = new Career();
ret.careerNodes = careerNodes;
ret.root = CareerNode.Root(ret.careerNodes);
ret.leaves = CareerNode.Leaves(ret.careerNodes);
ret.stats = stats;
ret.playerData = new ActorData(ret.stats);
return(ret);
}
public Career(string championName = "")
{
careerNodes = new List <CareerNode>();
root = null;
leaves = new List <CareerNode>();
if (championName != "")
{
stats = new StatsManager(championName);
playerData = new ActorData(stats);
}
}
void ScaleLevel(int level, CareerNode[] levelNodes, List <CareerNode> nodes)
{
Career career = Session.session.career;
int currentLevel = career.stats.GetStat(StatsManager.Stats.CurrentLevel);
int lastNode = career.stats.GetStat(StatsManager.Stats.LastNode);
for (int i = 0; i < levelNodes.Length; i++)
{
bool active = CareerNode.NodeIsActive(levelNodes[i], nodes, currentLevel, lastNode);
ScaleNodeButton(levelNodes[i].nodeId, level, i, levelNodes.Length, active);
}
}
public static List <CareerNode> GetParents(CareerNode node, List <CareerNode> nodes)
{
List <CareerNode> ret = new List <CareerNode>();
foreach (CareerNode candidate in nodes)
{
if (candidate.child1 == node.nodeId || candidate.child2 == node.nodeId || candidate.child3 == node.nodeId)
{
ret.Add(candidate);
}
}
return(ret);
}
public static List <CareerNode> GetChildren(CareerNode node, List <CareerNode> nodes)
{
List <CareerNode> ret = new List <CareerNode>();
foreach (CareerNode candidate in nodes)
{
int id = candidate.nodeId;
if (id == node.child1 || id == node.child2 || id == node.child3)
{
ret.Add(candidate);
}
}
return(ret);
}
public static int ParentCount(CareerNode node, List <CareerNode> nodes)
{
int count = 0;
foreach (CareerNode candidate in nodes)
{
if (candidate.child1 == node.nodeId || candidate.child2 == node.nodeId || candidate.child3 == node.nodeId)
{
count++;
}
}
return(count);
}
public static List <CareerNode> GetActiveParents(CareerNode node, List <CareerNode> nodes, int currentLevel, int lastNode)
{
List <CareerNode> parents = GetParents(node, nodes);
List <CareerNode> ret = new List <CareerNode>();
foreach (CareerNode parent in parents)
{
if (NodeIsActive(parent, nodes, currentLevel, lastNode))
{
ret.Add(parent);
}
}
return(ret);
}
public void ExecuteNode(int id)
{
CareerNode node = CareerNode.GetNode(id, careerNodes);
if (node == null)
{
GD.Print("Can't execute null node id " + id);
return;
}
stats.SetBaseStat(StatsManager.Stats.LastNode, stats.GetStat(StatsManager.Stats.CurrentNode));
stats.SetBaseStat(StatsManager.Stats.CurrentNode, id);
stats.SetBaseStat(StatsManager.Stats.NodeInProgress, 1);
CareerDb.SaveCareer(this);
switch (node.nodeType)
{
case CareerNode.NodeTypes.None:
GD.Print("NullEncounter");
CompleteEncounter();
break;
case CareerNode.NodeTypes.ArenaMatch:
ArenaEncounter(node.extraInfo);
break;
case CareerNode.NodeTypes.BossMatch:
ArenaEncounter(node.extraInfo);
break;
case CareerNode.NodeTypes.FinalBoss:
ArenaEncounter(node.extraInfo);
break;
case CareerNode.NodeTypes.Shop:
ShopEncounter(node.extraInfo);
break;
case CareerNode.NodeTypes.RestSite:
RestSiteEncounter(node.extraInfo);
break;
case CareerNode.NodeTypes.PressEvent:
PressEventEncounter(node.extraInfo);
break;
}
}
void AddNodeButton(CareerNode node)
{
CareerNode.NodeTypes nodeType = node.nodeType;
string nodeName = "" + nodeType;
if (nodeType == CareerNode.NodeTypes.ArenaMatch)
{
nodeName = node.extraInfo;
nodeName = nodeName.Replace("res://Scenes/Maps/", "");
nodeName = nodeName.Replace(".tscn", "");
nodeName = nodeType + ": " + nodeName;
}
Button button = NodeButton(node.nodeId, nodeName);
careerButtons.Add(node.nodeId, button);
AddChild(button);
}
public static int GetLevel(CareerNode node, List <CareerNode> nodes)
{
if (node == null || nodes == null)
{
GD.Print("Invalid args" + node + "," + nodes);
return(-1);
}
System.Collections.Generic.Dictionary <int, CareerNode[]> levels = GetLevels(nodes);
foreach (int key in levels.Keys)
{
CareerNode[] level = levels[key];
for (int i = 0; i < level.Length; i++)
{
if (level[i].nodeId == node.nodeId)
{
return(key);
}
}
}
return(-1);
}
public static CareerNode FromRow(string[] row)
{
if (row.Length != 6)
{
GD.Print("CareerNode.FromRow invalid row length: " + row.Length);
return(null);
}
CareerNode ret = new CareerNode();
ret.nodeId = Util.ToInt(row[0]);
int category = Util.ToInt(row[1]);
ret.nodeType = (NodeTypes)category;
ret.child1 = Util.ToInt(row[2]);
ret.child2 = Util.ToInt(row[3]);
ret.child3 = Util.ToInt(row[4]);
ret.extraInfo = row[5];
return(ret);
}
public string ToString()
{
string text = "Career:\n";
text += "Root: " + root.ToString() + "\n";
text += "\nLeaves:\n";
foreach (CareerNode leaf in leaves)
{
text += "\t" + leaf.ToString() + "\n";
}
text += "\nNodes:\n";
foreach (CareerNode node in careerNodes)
{
text += "\t" + node.ToString() + "\n";
}
text += "Levels:\n";
System.Collections.Generic.Dictionary <int, CareerNode[]> levels;
levels = CareerNode.GetLevels(careerNodes);
foreach (int key in levels.Keys)
{
text += "\n level[" + key + "]:";
CareerNode[] level = levels[key];
for (int i = 0; i < level.Length; i++)
{
text += level[i].ToString();
}
text += "\n";
}
return(text);
}
public void CompleteEncounter()
{
if (Session.session.player != null)
{
playerData = Session.session.player.GetData();
if (playerData != null && playerData.stats != null)
{
int health = playerData.stats.GetBaseStat(StatsManager.Stats.Health);
stats.SetBaseStat(StatsManager.Stats.Health, health);
playerData.stats = stats;
}
}
Session.ClearGame();
int id = stats.GetStat(StatsManager.Stats.CurrentNode);
CareerNode node = CareerNode.GetNode(id, careerNodes);
int nodeLevel = CareerNode.GetLevel(node, careerNodes);
int nextLevel = nodeLevel - 1;
stats.SetBaseStat(StatsManager.Stats.CurrentLevel, nextLevel);
stats.SetBaseStat(StatsManager.Stats.LastNode, id);
stats.SetBaseStat(StatsManager.Stats.CurrentNode, 0);
stats.SetBaseStat(StatsManager.Stats.NodeInProgress, 0);
CareerDb.SaveCareer(this);
Session.session.player = null;
if (nextLevel == -1)
{
CompleteGame();
}
else
{
Session.ChangeMenu(Menu.Menus.Career);
}
}
void ExecuteNode(int id)
{
GD.Print("Executing node " + id + ".");
Session.session.career.ExecuteNode(id);
return;
Career career = Session.session.career;
CareerNode node = CareerNode.GetNode(id, career.careerNodes);
int nodeLevel = CareerNode.GetLevel(node, career.careerNodes);
int nextLevel = nodeLevel - 1;
if (nodeLevel == 0)
{
GD.Print("Final boss time!");
return;
}
else
{
GD.Print("Changing current level to " + nextLevel);
}
ScaleControls();
}
public static void SaveCareer(Career career)
{
GD.Print("CareerDb.SaveCareer");
CSV.WriteToFile(StatsFile, career.stats.GetRows());
CSV.WriteToFile(CareerFile, CareerNode.ToRows(career.careerNodes));
}
