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); } } }