void CreateLinkage(int[] id, int connectionId = -1)
{
if (prevPath.Length > 0)
{
if (connectionId == -1)
{
int linkType = LoadedData.GetVariableType(abilityData.subclasses.l[prevPath[0]].classType, prevPath[1], VariableTypes.SIGNAL_ONLY) ? 1 : 0;
connectionId = abilityData.linkAddresses.Add(new int[] { prevPath[0], prevPath[1], id[0], id[1], linkType });
}
//Debug.LogFormat("ConnectionID assigned {0}. For {1} and {2}", connectionId, prevPath[0], id[0]);
// Make sure both ends will feedback if window was dragged.
abilityWindows.l[prevPath[0]].linesRelated.Add(connectionId);
abilityWindows.l[id[0]].linesRelated.Add(connectionId);
Transform[] points = new Transform[2];
int lastObj = LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <LinearLayout>(abilityWindows.l[prevPath[0]].variables[prevPath[1]]).objects.Count - 1;
points[0] = LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <LinearLayout>(abilityWindows.l[prevPath[0]].variables[prevPath[1]]).objects[lastObj];
points[1] = LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <LinearLayout>(abilityWindows.l[id[0]].variables[id[1]]).objects[0];
CreateLines(points, connectionId);
// Removes the prev path.
prevPath = new int[0];
}
}
public static string[] GetImageDependencies(AbilityDataSubclass[] target)
{
HashSet <string> imageDependencies = new HashSet <string>();
for (int i = 0; i < target.Length; i++)
{
for (int j = 0; j < target[i].var.Length; j++)
{
if (LoadedData.GetVariableType(target[i].classType, j, VariableTypes.IMAGE_DEPENDENCY))
{
RuntimeParameters <string> imagePath = target[i].var[j].field as RuntimeParameters <string>;
if (!imageDependencies.Contains(imagePath.v))
{
imageDependencies.Add(imagePath.v);
}
}
}
}
string[] sArray = new string[imageDependencies.Count];
int index = 0;
foreach (string path in imageDependencies)
{
sArray[index] = path;
index++;
}
return(sArray);
//return imageDependencies.ToArray();
}
public bool CheckIfReferenced(int nodeId, int variableId)
{
if (nodes[nodeId] == null)
{
return(false);
}
bool notInstanced = LoadedData.GetVariableType(subclassTypes[nodeId], variableId, VariableTypes.NON_INSTANCED);
if (notInstanced || !instancedNodes.ContainsKey(nodeId) || instancedNodes[nodeId] == null)
{
return(false);
}
return(true);
}
void CreateLines(Transform[] points, int id)
{
// Creates the graphical strings.
SpawnerOutput lGraphic = LoadedData.GetSingleton <UIDrawer>().CreateScriptedObject(typeof(ButtonWrapper));
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Image>(lGraphic, "Image").rectTransform.pivot = new Vector2(0.5f, 0);
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Text>(lGraphic, "Text").text = "";
// Adds event for changing of button colors
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Button>(lGraphic).onClick.AddListener(() => {
switch (mMode)
{
case MouseMode.EDIT_CONN:
int[] linkData = abilityData.linkAddresses.l[id];
if (!LoadedData.GetVariableType(abilityData.subclasses.l[linkData[0]].classType, linkData[1], VariableTypes.PERMENANT_TYPE))
{
linkData[4] = (int)lMode;
UpdateLineColor(id);
mMode = MouseMode.NONE;
}
break;
case MouseMode.REMOVE_CONN:
RemoveLine(id);
mMode = MouseMode.NONE;
break;
}
});
LineData line = new LineData(points[0], points[1], lGraphic);
lineData.ModifyElementAt(id, line);
UpdateLineColor(id);
UpdateLines(id);
}
public void CreateWindow(int id, Vector3 location)
{
EditableWindow editWindow = LoadedData.GetSingleton <UIDrawer>().CreateScriptedObject(typeof(EditableWindow)).script as EditableWindow;
editWindow.link = this;
//Runs deletion delegate.
Button del = editWindow.deleteButton.button;
del.onClick.AddListener(() => {
//Handles UI deletion.
editWindow.gameObject.SetActive(false);
for (int i = editWindow.linesRelated.Count - 1; i >= 0; i--)
{
//lineData.l[editWindow.linesRelated[i]].line.gameObject.SetActive(false);
//abilityData.linkAddresses.Remove(editWindow.linesRelated[i]);
RemoveLine(editWindow.linesRelated[i]);
}
abilityData.subclasses.Remove(id);
});
editWindow.transform.position = location;
abilityWindows.ModifyElementAt(id, editWindow);
//Initialises variable linear layouts.
editWindow.variables = new SpawnerOutput[abilityData.subclasses.l[id].var.Length];
Vector2 varGraphicsDimensions = new Vector2(0, 0);
for (int i = 0; i < abilityData.subclasses.l[id].var.Length; i++)
{
if (LoadedData.GetVariableType(abilityData.subclasses.l[id].classType, i, VariableTypes.HIDDEN))
{
continue;
}
SpawnerOutput[] var = CreateVariableField(id, i);
SpawnerOutput get = CreateVariableButtons(ActionType.RECIEVE, new int[] { id, i });
SpawnerOutput set = CreateVariableButtons(ActionType.SEND, new int[] { id, i });
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Image>(get, "Image").color = Color.red;
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Image>(set, "Image").color = Color.green;
SpawnerOutput align = LoadedData.GetSingleton <UIDrawer>().CreateScriptedObject(typeof(LinearLayout));
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <LinearLayout>(align).o = LinearLayout.Orientation.X;
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <LinearLayout>(align).Add(get.script.transform as RectTransform);
for (int j = 0; j < var.Length; j++)
{
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <LinearLayout>(align).Add(var[j].script.transform as RectTransform);
}
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <LinearLayout>(align).Add(set.script.transform as RectTransform);
//(align.script.transform as RectTransform).sizeDelta = (align.script.transform as RectTransform).sizeDelta;
editWindow.lL.Add(align.script.transform as RectTransform);
editWindow.variables[i] = align;
varGraphicsDimensions.y += (align.script.transform as RectTransform).sizeDelta.y;
if ((align.script.transform as RectTransform).sizeDelta.x > varGraphicsDimensions.x)
{
varGraphicsDimensions.x = (align.script.transform as RectTransform).sizeDelta.x;
}
}
editWindow.ChangeWindowsContentSize(varGraphicsDimensions);
editWindow.windowsText.text = abilityData.subclasses.l[id].classType.Name;
}
void RetrieveStartNodes()
{
int nonPsuedoNodes = dataVar.Length - 2;
AutoPopulationList <bool> connected = new AutoPopulationList <bool>(nonPsuedoNodes);
for (int i = 0; i < nonPsuedoNodes; i++)
{
int totalCurrLinks = 0;
for (int j = 0; j < dataVar[i].Length; j++)
{
totalCurrLinks += dataVar[i][j].links.Length;
for (int k = 0; k < dataVar[i][j].links.Length; k++)
{
int[] currLink = dataVar[i][j].links[k];
// Marks target as true so it can't be root.
connected.ModifyElementAt(currLink[0], true);
}
}
if (totalCurrLinks == 0)
{
dataVar[i][dataVar[i].Length - 1].links = new int[][] { new int[] { dataVar.Length - 1, 0, 0 } }
}
;
}
List <int[]> rC = new List <int[]>();
for (int i = 0; i < connected.l.Count; i++)
{
if (!connected.l[i])
{
rC.Add(new int[] { i, 0, 1 });
}
}
rootSubclasses = rC.ToArray();
}
void RunNodeFlow(int nextNode, int targetVar, Tuple <int, int, int>[] pN = null)
{
int[] lC = LoadedData.loadedNodeInstance[dataType[nextNode]].ReturnLinkChannels();
for (int k = 0; k < lC.Length; k++)
{
if (pN != null)
{
Tuple <int, int, int> precedingNode = pN[lC[k]];
if (linkGenerator[lC[k]][precedingNode.Item1][precedingNode.Item2] == null)
{
linkGenerator[lC[k]][precedingNode.Item1][precedingNode.Item2] = new HashSet <Tuple <int, int, int> >();
}
Tuple <int, int, int> currNode = Tuple.Create(nextNode, targetVar, precedingNode.Item3);
if (!linkGenerator[lC[k]][precedingNode.Item1][precedingNode.Item2].Contains(currNode))
{
linkGenerator[lC[k]][precedingNode.Item1][precedingNode.Item2].Add(currNode);
}
}
}
//if(LoadedData.loadedNodeInstance[dataType[nextNode]] is INodeNetworkPoint)
//progenitor = nextNode;
//Debug.LogFormat("Curr Node: {0}, {1}", nextNode,dataType[nextNode]);
for (int i = 0; i < dataVar[nextNode].Length; i++)
{
for (int j = 0; j < dataVar[nextNode][i].links.Length; j++)
{
int[] currLink = dataVar[nextNode][i].links[j];
// Adds links to rhs.
Tuple <int, int, int, int> rhslinkTup = Tuple.Create(currLink[0], currLink[1], currLink[2], j);
if (!linkData[nextNode].rHS.Contains(rhslinkTup))
{
linkData[nextNode].rHS.Add(rhslinkTup);
}
// Adds links to target lhs.
Tuple <int, int, int, int> lhslinkTup = Tuple.Create(nextNode, i, currLink[2], j);
if (!linkData[currLink[0]].lHS.Contains(lhslinkTup))
{
linkData[currLink[0]].lHS.Add(lhslinkTup);
}
Tuple <int, int, int> nextNodeRef = Tuple.Create <int, int, int>(nextNode, i, currLink[2]);
List <Tuple <int, int, int> > precedingArray = new List <Tuple <int, int, int> >();
if (pN != null)
{
precedingArray.AddRange(pN);
}
else
{
precedingArray.Add(null);
precedingArray.Add(null);
}
for (int k = 0; k < lC.Length; k++)
{
precedingArray[lC[k]] = nextNodeRef;
}
// Iterates to target.
RunNodeFlow(currLink[0], currLink[1], precedingArray.ToArray());
}
}
//Debug.LogWarningFormat("End of Node: {0}, {1}", nextNode, dataType[nextNode]);
}
void GenerateLinks()
{
// Generate links after
generatedLinks = new int[linkGenerator.Length][][][][];
for (int i = 0; i < linkGenerator.Length; i++)
{
generatedLinks[i] = new int[linkGenerator[i].Length][][][];
for (int j = 0; j < linkGenerator[i].Length; j++)
{
generatedLinks[i][j] = new int[linkGenerator[i][j].Length][][];
for (int k = 0; k < linkGenerator[i][j].Length; k++)
{
List <int[]> convertedLinks = new List <int[]>();
//generatedLinks[i][j][k] = new int[linkGenerator[i][j][k].Count];
if (linkGenerator[i][j][k] != null)
{
foreach (var item in linkGenerator[i][j][k])
{
convertedLinks.Add(new int[] { item.Item1, item.Item2, item.Item3 });
}
}
//Debug.LogFormat("Generating for: {0}, {1}, {2}", i, j, k);
generatedLinks[i][j][k] = convertedLinks.ToArray();
}
}
}
}
void EditLinks()
{
lM = new LinkModifier();
for (currBuildNode = 0; currBuildNode < dataType.Length; currBuildNode++)
{
LoadedData.loadedNodeInstance[dataType[currBuildNode]].ConstructionPhase(this);
}
//LoadedData.loadedNodeInstance[dataType[i]].LinkEdit(i, lD, lM, dataVar);
foreach (var add in lM.add)
{
List <int[]> links = new List <int[]>(dataVar[add.Key.Item1][add.Key.Item2].links);
foreach (var ele in add.Value)
{
links.Add(new int[] { ele.Item1, ele.Item2, ele.Item3 });
Debug.LogFormat("Adding to {0},{1}. Content: {2},{3}", add.Key.Item1, add.Key.Item2, ele.Item1, ele.Item2);
}
dataVar[add.Key.Item1][add.Key.Item2].links = links.ToArray();
}
foreach (var rm in lM.remove)
{
int[] rmArr = rm.Value.ToArray();
Array.Sort(rmArr);
List <int[]> links = new List <int[]>(dataVar[rm.Key.Item1][rm.Key.Item2].links);
for (int i = rmArr.Length - 1; i >= 0; i--)
{
Debug.LogFormat("Removing at {0},{1}. Content: {2},{3}", rm.Key.Item1, rm.Key.Item2, links[rmArr[i]][0], links[rmArr[i]][0]);
links.RemoveAt(rmArr[i]);
}
dataVar[rm.Key.Item1][rm.Key.Item2].links = links.ToArray();
}
}
void BeginDepenciesBuild()
{
nodeBranchingData = new int[dataVar.Length];
autoManagedVariables = new int[dataVar.Length][];
boolData = new AbilityBooleanData(dataVar);
for (int i = 0; i < dataVar.Length; i++)
{
List <int> aMVar = new List <int>();
List <int> networkVariables = new List <int>();
//Debug.Log("Printing for Node: " + i);
for (int j = 0; j < dataVar[i].Length; j++)
{
//Debug.Log("Printing for Variable: " + j);
bool interchangeable = LoadedData.GetVariableType(dataType[i], j, VariableTypes.INTERCHANGEABLE);
AutoPopulationList <List <int[]> > varLinks = new AutoPopulationList <List <int[]> >(1);
for (int k = 0; k < dataVar[i][j].links.Length; k++)
{
int[] currLink = dataVar[i][j].links[k];
//Debug.LogFormat("{0},{1}", currLink[0], currLink[1]);
bool signal = currLink[2] == (int)LinkMode.SIGNAL ? true : false;//LoadedData.GetVariableType(dataType[i], j, VariableTypes.SIGNAL_ONLY);
// Marks target as true so it will be blocked.
if (!signal)
{
if (dataVar[i][j].field.t == dataVar[currLink[0]][currLink[1]].field.t || interchangeable)
{
boolData.varsBlocked[currLink[0]][currLink[1]] = true;
//Debug.LogFormat("From Node {0} Variable {1} link {2} name {3}", i, j, k, dataVar[i][j].field.n);
//Debug.LogFormat("To Node {0} Variable {1} link {2} signal {3} interchange {4} name {5}", currLink[0], currLink[1], k, signal, interchangeable, dataVar[i][j].field.n);
//Debug.Log("This was called true.");
}
}
}
if (LoadedData.GetVariableType(dataType[i],j,VariableTypes.BLOCKED))
{
boolData.varsBlocked[i][j] = true;
}
if (LoadedData.GetVariableType(dataType[i],j,VariableTypes.AUTO_MANAGED))
{
aMVar.Add(j);
}
if (!LoadedData.GetVariableType(dataType[i],j,VariableTypes.NON_LINK))
{
nodeBranchingData[i] += dataVar[i][j].links.Length;
}
if (LoadedData.GetVariableType(dataType[i],j,VariableTypes.GLOBAL_VARIABLE))
{
string gVN = (dataVar[i][j].field as RuntimeParameters <string>).v;
if (!AbilitiesManager.GetAssetData(playerId).globalVariables.ContainsKey(gVN))
{
AbilitiesManager.GetAssetData(playerId).globalVariables.Add(gVN,null);
}
}
if (LoadedData.GetVariableType(dataType[i],j,VariableTypes.NETWORK))
{
networkVariables.Add(j);
}
}
autoManagedVariables[i] = aMVar.ToArray();
if (networkVariables.Count > 0)
{
nodeNetworkVariables.Add(i,networkVariables.ToArray());
}
//aMVar.Add(j);
}
}
/*public NETWORK_CLIENT_ELIGIBILITY CheckEligibility(int nodeId, int variableId) {
*
* if(LoadedData.GetVariableType(subclassTypes[nodeId], variableId, VariableTypes.CLIENT_ACTIVATED)) {
* if(playerId != ClientProgram.clientId)
* return NETWORK_CLIENT_ELIGIBILITY.DENIED;
* else
* return NETWORK_CLIENT_ELIGIBILITY.GRANTED;
* }
*
* if(LoadedData.GetVariableType(subclassTypes[nodeId], variableId, VariableTypes.HOST_ACTIVATED))
* if(ClientProgram.hostId != ClientProgram.clientId)
* return NETWORK_CLIENT_ELIGIBILITY.DENIED;
* else
* return NETWORK_CLIENT_ELIGIBILITY.GRANTED;
*
*
* return NETWORK_CLIENT_ELIGIBILITY.LOCAL_HOST;
* }*/
public void UpdateVariableValue <T>(int nodeId, int variableId, T value, bool runNetworkCode = true, bool runValueChanged = true)
{
bool reference = CheckIfReferenced(nodeId, variableId);
// If reference is not empty, redirects it to change that variable instead.
if (reference)
{
Tuple <int, int, int> refLink = instancedNodes[nodeId];
//Debug.LogFormat("Var set, central {0}, node {1}, var {2}, value {3}", refLink.Item1, refLink.Item2, variableId, value);
GetRootReferenceCentral(nodeId).UpdateVariableValue <T>(refLink.Item3, variableId, value, runValueChanged);
return;
}
if (runNetworkCode)
{
if (LoadedData.GetVariableType(subclassTypes[nodeId], variableId, VariableTypes.NETWORK))
{
AbilityNodeNetworkData dataPacket = new AbilityNodeNetworkData <T>(nodeId, variableId, value, networkVariableData[nodeId].nodeCallbackCount);
//Debug.Log("Input is been sent out.");
//INodeNetworkPoint nwPointInst = nodes[progenitorData[nodeId]] as INodeNetworkPoint;
//Debug.Log(nodes[progenitorData[nodeId]]);
//nwPointInst.ModifyDataPacket(dataPacket);
AddVariableNetworkData(dataPacket);
}
/*NETWORK_CLIENT_ELIGIBILITY nCE = CheckEligibility(nodeId, variableId);
*
* switch(nCE) {
* case NETWORK_CLIENT_ELIGIBILITY.GRANTED:
* //Debug.Log("Data point going");
* //Debug.LogFormat("Data going to be applied to: {0} to: {1}", value, GetNode(nodeId));
* AbilityNodeNetworkData dataPacket = new AbilityNodeNetworkData<T>(nodeId, variableId, value, networkVariableData[nodeId].nodeCallbackCount);
* //INodeNetworkPoint nwPointInst = nodes[progenitorData[nodeId]] as INodeNetworkPoint;
* //Debug.Log(nodes[progenitorData[nodeId]]);
* //nwPointInst.ModifyDataPacket(dataPacket);
* AddVariableNetworkData(dataPacket);
* break;
*
* case NETWORK_CLIENT_ELIGIBILITY.DENIED:
* return;
* }*/
}
// Does run value stuff here.
/*if(runValueChanged) {
*
* int totalOnCalled = RunTargettedNodes<T>(nodeId, variableId, ON_VARIABLE_CATERGORY.ON_CHANGED, value);
*
* if(onCallbacks.ContainsKey(nodeId))
* if(onCallbacks[nodeId].ContainsKey(ON_VARIABLE_CATERGORY.ON_CHANGED))
* foreach(var id in onCallbacks[nodeId][ON_VARIABLE_CATERGORY.ON_CHANGED]) {
* AbilityCentralThreadPool centralInst = AbilitiesManager.aData[id.Item1].playerSpawnedCentrals.GetElementAt(id.Item2);
* totalOnCalled += centralInst.RunTargettedNodes<T>(id.Item3, variableId, ON_VARIABLE_CATERGORY.ON_CALLED, value);
* }
*
* if(totalOnCalled > 0)
* return;
* }*/
RuntimeParameters <T> paramInst = runtimeParameters[nodeId][variableId] as RuntimeParameters <T>;
bool varWasSet = false;
if (paramInst != null)
{
paramInst.v = value;
booleanData[nodeId][variableId] = false;
varWasSet = true;
}
else if (LoadedData.GetVariableType(subclassTypes[nodeId], variableId, VariableTypes.INTERCHANGEABLE))
{
string varName = runtimeParameters[nodeId][variableId].n;
//int[][] links = runtimeParameters[nodeId][variableId].links;
//Debug.LogFormat("Var changed from {0} to {1}", runtimeParameters[nodeId][variableId].field.t, typeof(T));
runtimeParameters[nodeId][variableId] = new RuntimeParameters <T>(varName, value);
booleanData[nodeId][variableId] = false;
varWasSet = true;
}
if (varWasSet && runValueChanged)
{
//Debug.Log(value);
IOnVariableSet oVS = CreateNewNodeIfNull(nodeId) as IOnVariableSet;
if (oVS != null)
{
oVS.OnVariableSet(variableId);
}
}
}
