void Awake()
{
isGamePaused = false;
nodeGroup = gameObject.GetComponent <NodeGroup>();
nodeConnection = gameObject.GetComponent <NodeConnections>();
joystick.GetComponentInParent <Canvas>().enabled = false;
}
public FrmMain()
{
InitializeComponent();
graph1.ShowDebugInfos = true;
graph1.ShowGrid = false;
graph1.TimedRedraw = true;
Random rnd = new Random();
int nodeY = 20;
for (int i = 0; i < 5; i++)
{
nodeY += 20;
Node node = new Node(graph1)
{
Location = new FlowGraph.GraphLocation(0, nodeY), Title = "Test"
};
node.Add(new LabelItem()
{
Size = new FlowGraph.GraphSize(node.Size.Width, 30)
});
graph1.AddElement(node);
}
NodeGroup group = new NodeGroup(graph1);
group.Location = new FlowGraph.GraphLocation(0, 0);
group.Size = new FlowGraph.GraphSize(1000, 700);
graph1.AddElement(group);
}
public NodeGroup LoadNodeGroupByJson(string path)
{
string content = "";
#if UNITY_EDITOR
if (File.Exists(path))
{
content = File.ReadAllText(path);
}
#else
content = xc.DBManager.Instance.LoadDBFile(path.Replace("Assets/Res/", ""));
#endif
if (string.IsNullOrEmpty(content) == true)
{
return(null);
}
NodeGroup temp = null;
FullSerializer.fsData fsdata = FullSerializer.fsJsonParser.Parse(content);
var serializer = new FullSerializer.fsSerializer();
var processor = new FileSerializerProcessor();
serializer.AddProcessor(processor);
serializer.TryDeserialize(fsdata, ref temp);
if (temp != null)
{
RemoveNodeGroup(temp.Id);
InitNodeGroup(temp);
nodeGroups.Add(temp.Id, temp);
return(temp);
}
return(null);
}
public NodeGroupDate(NodeGroup value)
{
position = value.transform.position;
groupColor = value.GroupColor;
speed = value.Speed;
Nodes = value.Nodes.Select(n => new NodeDate(n)).ToList();
}
public NodeGroup Update(NodeGroup ng)
{
using (dbc = DAL.Instance.GetDb()){
dbc.Update(ng);
return(ng);
}
}
public void TestNodeGroup()
{
NodeGroup group = null;
Function n = null;
try
{
group = NodeGroup.EnterNewGroup("test");
n = CNTKLib.InputVariable(new int[] { 2 }, DataType.Float);
NodeGroup.Current.Add(n);
n = CNTKLib.ReLU(n);
NodeGroup.Current.Add(n);
}
finally
{
NodeGroup.LeaveGroup();
}
var g = NodeGroup.Groups.ToArray();
Assert.AreEqual(1, g.Length);
Assert.AreEqual(group, g[0]);
var nodes = g[0].Nodes.ToArray();
Assert.AreEqual(2, nodes.Length);
Assert.AreEqual(n.Inputs[0].Uid, nodes[0].Uid);
Assert.AreEqual(n.RootFunction.Uid, nodes[1].Uid);
var f = NodeGroup.FindGroup(n.RootFunction.Uid);
Assert.AreEqual("test", f.Name);
}
/// <summary>
/// Build a one direction recurrent neural network (RNN) with long-short-term-memory (LSTM) cells.
/// http://colah.github.io/posts/2015-08-Understanding-LSTMs/
/// </summary>
/// <param name="input">the input variable</param>
/// <param name="LSTMDim">LSTM output dimension</param>
/// <param name="cellDim">cell dimension</param>
/// <param name="returnSequences">whether to return the last output in the output sequence, or the full sequence</param>
/// <param name="device">CPU or GPU device to run the model</param>
/// <param name="outputName">name of the model output</param>
/// <returns>the RNN model</returns>
public static Function Create(Variable input, int LSTMDim, int cellDim, bool returnSequences, bool stabilize,
DeviceDescriptor device, string outputName)
{
try
{
NodeGroup.EnterNewGroup(outputName);
Func <Variable, Function> pastValueRecurrenceHook = (x) => CNTKLib.PastValue(x);
Function LSTMFunction = LSTMPComponentWithSelfStabilization <float>(
input,
new int[] { LSTMDim },
new int[] { cellDim },
pastValueRecurrenceHook,
pastValueRecurrenceHook,
stabilize,
device,
outputName).Item1;
Composite.Register(LSTMFunction);
if (!returnSequences)
{
var f = CNTKLib.SequenceLast(LSTMFunction);
f.RootFunction.SetName(outputName);
return(f);
}
LSTMFunction.RootFunction.SetName(outputName);
return(LSTMFunction);
}
finally
{
NodeGroup.LeaveGroup();
}
}
public static NodeGroup GetGroups(PluginRoot Plugin, CodeString Code, char BracketLeft = '{', char BracketRight = '}')
{
var Ret = new NodeGroup(Code);
var State = Plugin.State;
var List = RecognizerHelper.SplitToParameters(State, Code, ',');
if (List == null)
{
return(null);
}
for (var i = 0; i < List.Length; i++)
{
var Param = List[i];
if (Param.Length > 1 && Param[0] == BracketLeft && Param[Param.Length] == BracketLeft)
{
Param = Param.Substring(1, Param.Length - 1).Trim();
Ret.Children.Add(Expressions.GetGroups(Plugin, Param));
}
else
{
var Node = Expressions.Recognize(Param, Plugin);
if (Node == null)
{
return(null);
}
Ret.Children.Add(Node);
}
}
return(Ret);
}
public override void OnHeaderGUI()
{
NodeGroup node = (NodeGroup)target;
string title = target.name;
GUILayout.Label(title, NodeEditorResources.styles.nodeHeader, GUILayout.Height(30), GUILayout.MinWidth(0), GUILayout.ExpandWidth(true));
Rect labelRect = GUILayoutUtility.GetLastRect();
node.locked = EditorGUI.ToggleLeft(labelRect, lockIcon, node.locked);
labelRect = GUILayoutUtility.GetLastRect();
labelRect.width = 30;
if (Event.current.type == EventType.MouseUp)
{
if (labelRect.Contains(Event.current.mousePosition))
{
node.locked = !node.locked;
}
}
// base.OnHeaderGUI();
}
/*******************************************/
private static void CollectNodeGroups(NodeGroup group, ref Dictionary <Guid, List <NodeGroup> > result)
{
if (group != null)
{
foreach (Guid id in group.NodeIds)
{
if (!result.ContainsKey(id))
{
result[id] = new List <NodeGroup> {
group
}
}
;
else
{
result[id].Add(group);
}
}
foreach (NodeGroup child in group.InternalGroups)
{
CollectNodeGroups(child, ref result);
}
}
}
public static JsonObject GetJsonLdResultsMetaData(JsonObject jsonLd)
{
JsonObject retval = new JsonObject();
try
{
String JSON_TYPE = "type";
String JSON_NODE_COUNT = "node_count";
// convert the jsonLD to a nodegroup.
// note: this assumes that the results of the construct json can be transformed into a nodegroup.
// this will break in the event that type info is omited, for instance. because this is intended to be
// used with the dispatcher, it is a reasonable assumption for now.
NodeGroup ngTemp;
ngTemp = NodeGroup.FromConstructJson(jsonLd);
retval.Add(JSON_TYPE, JsonValue.CreateStringValue("JSON-LD"));
retval.Add(JSON_NODE_COUNT, JsonValue.CreateNumberValue(ngTemp.GetNodeCount()));
return(retval);
}
catch (Exception e)
{
throw new Exception("Error assembling JSON header information for JSON-LD results: " + e.Message);
}
}
public static void OnHierarchyGUI(int instanceID, Rect selectionRect)
{
GameObject obj = EditorUtility.InstanceIDToObject(instanceID) as GameObject;
if (obj != null)
{
NodeGroup nodeGroup = obj.GetComponent <NodeGroup>();
if (nodeGroup != null)
{
Rect iconRect = new Rect(selectionRect.xMax - 15, selectionRect.y + 4, 10, 10);
ValidateIcons();
if (nodeGroup == NodifyEditorUtilities.currentSelectedGroup)
{
if (m_iconSelected != null)
{
GUI.DrawTexture(iconRect, m_iconSelected);
}
}
else
{
if (m_iconNormal != null)
{
GUI.DrawTexture(iconRect, m_iconNormal);
}
}
}
}
}
public static void OffsetNodes(NodeGroup ng, double xOffset, double yOffset)
{
Polyline poly = new Polyline(
ng.Nodes.Select(x => x.Frame.Origin));
if (ng.CustomData.ContainsKey("LoopClosed") && (bool)ng.CustomData["LoopClosed"])
{
poly.Add(poly[0]);
}
var normal = ng.Frame.ZAxis;
if (normal * Vector3d.ZAxis < 0)
{
normal.Reverse();
}
Polyline newPoly = Util.OffsetPolyline(poly, normal, xOffset, yOffset);
if (newPoly.Count > 1)
{
debug.Add(newPoly);
}
int N = Math.Min(ng.Nodes.Count, newPoly.Count);
for (int i = 0; i < N; ++i)
{
ng.Nodes[i].Frame.Origin = newPoly[i];
}
}
public async Task <SimpleResultSet> ExecuteDispatchFromNodeGroup(NodeGroup ng, JsonObject sparqlConnectionJson, JsonObject edcConstraintsJson, JsonObject runtimeConstraintsJson)
{
SimpleResultSet retval = null;
conf.SetServiceEndpoint(mappingPrefix + dispatchFromNodegroupEndpoint);
this.parameterJson.Add("jsonRenderedNodeGroup", JsonValue.CreateStringValue(ng.ToJson().ToString()));
this.parameterJson.Add("sparqlConnection", JsonValue.CreateStringValue(sparqlConnectionJson.ToString()));
if (edcConstraintsJson != null)
{
this.parameterJson.Add("externalDataConnectionConstraints", JsonValue.CreateStringValue(edcConstraintsJson.ToString()));
}
if (runtimeConstraintsJson != null)
{
this.parameterJson.Add("runtimeConstraints", JsonValue.CreateStringValue(runtimeConstraintsJson.ToString()));
}
try
{
JsonObject kObj = (JsonObject)(await this.Execute());
retval = SimpleResultSet.FromJson(kObj);
retval.ThrowExceptionIfUnsuccessful();
}
finally{
conf.SetServiceEndpoint(null);
this.parameterJson.Remove("jsonRenderedNodeGroup");
this.parameterJson.Remove("sparqlConnection");
this.parameterJson.Remove("externalDataConnectionConstraints");
this.parameterJson.Remove("runtimeConstraints");
}
return(retval);
}
/// <summary>
/// Build a one direction recurrent neural network (RNN) with long-short-term-memory (LSTM) cells.
/// http://colah.github.io/posts/2015-08-Understanding-LSTMs/
/// </summary>
/// <param name="input">the input variable</param>
/// <param name="embeddingDim">dimension of the embedding layer</param>
/// <param name="LSTMDim">LSTM output dimension</param>
/// <param name="cellDim">cell dimension</param>
/// <param name="device">CPU or GPU device to run the model</param>
/// <param name="outputName">name of the model output</param>
/// <returns>the RNN model</returns>
public static Function Create(Variable input, int embeddingDim, int LSTMDim, int cellDim, DeviceDescriptor device,
string outputName)
{
try
{
NodeGroup.EnterNewGroup(outputName);
Function embeddingFunction = Embedding(input, embeddingDim, device, outputName);
Func <Variable, Function> pastValueRecurrenceHook = (x) => CNTKLib.PastValue(x);
Function LSTMFunction = LSTMPComponentWithSelfStabilization <float>(
embeddingFunction,
new int[] { LSTMDim },
new int[] { cellDim },
pastValueRecurrenceHook,
pastValueRecurrenceHook,
device,
outputName).Item1;
Function thoughtVectorFunction = CNTKLib.SequenceLast(LSTMFunction);
thoughtVectorFunction.RootFunction.SetName(outputName);
return(thoughtVectorFunction);
}
finally
{
NodeGroup.LeaveGroup();
}
}
private void AssignSelectedGroup()
{
if (NodifyEditorUtilities.currentSelectedGroup != null)
{
return;
}
if (Selection.activeGameObject != null)
{
NodeGroup group = Selection.activeGameObject.GetComponent <NodeGroup>();
if (group == null)
{
if (Selection.activeGameObject.GetComponent <Anchor>())
{
Selection.activeTransform = Selection.activeTransform.parent;
}
if (Selection.activeGameObject.GetComponent <Node>())
{
group = Selection.activeGameObject.GetComponent <Node>().parent;
}
}
NodifyEditorUtilities.currentSelectedGroup = group;
}
}
public bool OverlapCheck(Vector3Int stonePosition)
{
bool overlaps = false;
NodeGroup nodeGroup = pathfinder.nodeGroup;
for (int x = stonePosition.x - 1; x < stonePosition.x + 1; x++)
{
for (int y = stonePosition.y - 1; y < stonePosition.y + 1; y++)
{
if (nodeGroup.GetNode(x, y).isBuildable == false)
{
overlaps = false;
break;
}
else
{
overlaps = true;
}
}
if (overlaps == false)
{
break;
}
}
return(overlaps);
}
public void NodeGroupFromConstruct()
{
NodeGroup ngResult = new NodeGroup();
NodeGroupExecutionClientConfig necc = new NodeGroupExecutionClientConfig("http", "fake-server.crd.ge.com", 12058);
NodeGroupExecutionClient nec = new NodeGroupExecutionClient(necc);
String nodeGroupId = "Logging SPARQLgraph alerts";
String connectionInfo = "{ \"name\": \"Logging SparqlGraph\", \"domain\": \"http://com.ge.research/knowledge/UsageLogging\", \"model\": [ { \"type\": \"virtuoso\", \"url\": \"http://fake-server.crd.ge.com:2420\", \"dataset\": \"http://com.ge.research/knowledge/UsageLogging/LogMaster\"} ], \"data\": [ {\"type\": \"virtuoso\", \"url\": \"http://fake-server.crd.ge.com:2420\", \"dataset\": \"http://com.ge.research/knowledge/UsageLogging/SPARQLGraph\" } ]}";
JsonObject jObject = JsonObject.Parse(connectionInfo);
JsonObject jsonLD = nec.ExecuteDispatchConstructByIdToJsonLd(nodeGroupId, jObject, null, null).Result;
NodeGroupResultSet ngResultSet = new NodeGroupResultSet(true);
ngResultSet.ReadJson(jsonLD);
ngResult = NodeGroup.FromConstructJson(ngResultSet.GetResultsJson());
Debug.WriteLine("total node count =" + ngResult.GetNodeCount());
Assert.IsTrue(ngResult.GetNodeCount() > 0);
foreach (Node nCurr in ngResult.GetNodeList())
{
// write some basic debug so we can see something is working.
Debug.WriteLine("uri: " + nCurr.GetFullUriName() + " , instanceValue: " + nCurr.GetInstanceValue());
}
}
/// <summary>
/// Creates a Nodegroup thats linked to the existing nodegroup with new weights
/// </summary>
/// <param name="InputNodes">The nodes that its linked to</param>
/// <param name="size">The size of the group</param>
public NodeGroup(NodeGroup InputNodes, int size)
{
Nodes = new Node[size];
for (int i = 0; i < size; i++)
{
}
}
public void GetShared(NodeGroup ng, out List <Node> SharedNodes, out List <Edge> SharedEdges)
{
SharedNodes = this.Nodes.Where(x => ng.Nodes.Contains(x)).ToList();
var theseEdges = this.Nodes.SelectMany(x => x.Edges).ToList();
var thoseEdges = ng.Nodes.SelectMany(x => x.Edges).ToList();
SharedEdges = theseEdges.Where(x => thoseEdges.Contains(x)).ToList();
}
public NodeGroup Save(NodeGroup ng)
{
ng.Id = IdManager.GetId();
using (dbc = DAL.Instance.GetDb()){
dbc.Insert <NodeGroup>(ng);
}
return(ng);
}
private void OnEnable()
{
_group = (NodeGroup)target;
centeredstyle = new GUIStyle();
centeredstyle.alignment = TextAnchor.MiddleCenter;
centeredstyle.fontSize = 15;
centeredstyle.fontStyle = FontStyle.Bold;
}
public async Task <long> ExecuteDispatchCountByNodegroupToLong(NodeGroup nodegroup, JsonObject sparqlConnectionJson, JsonObject edcConstraintsJson, JsonArray runtimeConstraintsJson)
{
SimpleResultSet ret = await this.ExecuteDispatchCountFromNodeGroup(nodegroup, sparqlConnectionJson, edcConstraintsJson, runtimeConstraintsJson);
Table tab = await this.WaitForJobAndGetTable(ret.GetResult("JobId"));
return(tab.GetCellAsInt(0, 0));
}
protected override void AddItem()
{
IMainForm mainForm = Instances.MainForm;
// Show the new account.
NodeGroup newNode = new NodeGroup("", 0);
mainForm.ShowItem(newNode);
}
public void NewNodeGroup()
{
if (GUILayout.Button("+", GUILayout.Width(20)))
{
NodeGroup ng = new GameObject().AddComponent <NodeGroup>();;
ng.nodeList = new List <Node>();
nodegroup = ng;
nodegroup.name = "NewGroup";
}
}
/// <summary>
/// 获取结点组
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public NodeGroup GetNodeGroup(string key)
{
NodeGroup group = null;
if (nodeGroups.TryGetValue(key, out group))
{
return(group);
}
return(null);
}
public void Write(NodeGroup <ConversationNode <TNodeUI, TTransitionUI> > group)
{
//TODO: Write groups again when things have stabilised
//var g = new XElement("Group");
//foreach (var node in group.Contents)
// g.Add(new XElement("Node", new XAttribute("Id", node.Id.ToString())));
//m_nodeUISerializer.Write(group, g);
////WriteArea(group, g);
//m_root.Add(g);
}
private void Initial()
{
_sequence.Clear();
_tokenBuffer.Clear();
_tokens.Clear();
_exps.Clear();
_lexer.Reset();
_group = new Capture(null, _lexer.AnonymousCapCount);
_alternate = new Alternate(_group);
_concatenate = new Concatenate(_alternate);
}
private void PushGroup()
{
if (_unit.Type == NodeType.Comment || _unit.Type == NodeType.Field)
{
return;
}
_group = _unit as NodeGroup;
_alternate = new Alternate(_group);
_concatenate = new Concatenate(_alternate);
_unit = null;
}
/// <summary>
/// Creates a new node with all new Nodes
/// </summary>
/// <param name="nodeGroup"></param>
public Node(NodeGroup nodeGroup)
{
InputNodes = nodeGroup;
Weights = new double[nodeGroup.Size];
Random random = new Random();
for (int i = 0; i < Weights.Length; i++)
{
Weights[i] = random.NextDouble();
}
}
void Dfs1(Node node)
{
node.Index = nextSCCIndex++;
node.LowLink = node.Index;
nodeStack.Push (node);
foreach (var to in node.PointsTo) {
if (to.Index == 0) {
Dfs1 (to);
node.LowLink = System.Math.Min (node.LowLink, to.LowLink);
} else if (nodeStack.Contains (to)) {
node.LowLink = System.Math.Min (node.LowLink, to.Index);
}
}
if (node.LowLink == node.Index) {
NodeGroup g = new NodeGroup ();
Node n;
do {
n = nodeStack.Pop ();
n.Group = g;
g.Add (n);
} while (n != node);
groups.Add (g);
}
}
protected override void ProcessResource( ResourceTree aResourceTree )
{
System.Func<ResourceTreeNode, XElement, XElement> GetChildren = null;
var excludedGroups = new NodeGroup[] {
NodeGroup.ExtensionPackages, NodeGroup.GameInformation, NodeGroup.GlobalGameSettings, NodeGroup.Invalid
};
GetChildren = ( aNode, aParent ) => {
foreach ( var node in aNode ) {
if ( node.Type == NodeTypes.Group )
aParent.Add( GetChildren( node, new XElement( "Group", new XAttribute( "Name", node.Name ) ) ) );
else
aParent.Add( new XElement( "Node", new XAttribute( "Name", node.Name ), new XAttribute( "ID", node.ID ) ) );
}
return aParent;
};
var document =
new XElement( "Tree",
from node in aResourceTree
where !excludedGroups.Contains( node.Group )
select GetChildren( node, new XElement( node.Group.ToString() ) )
);
SaveDocument( document, Filenames.Tree + ".xml" );
}
void parseGraph(string nodeAsset, int dimensionality, int type)
{
TextAsset positionsText = Resources.Load(nodeAsset) as TextAsset;
string[,] myPositionsGrid = CSVReader.SplitCsvGrid(positionsText.text);
int numberOfNodes = myPositionsGrid.GetUpperBound(1) - 1;
masterNodeList = new Node[numberOfNodes];
indicesToShowOrExplode = new int[numberOfNodes];
// add nodes
for (int i = 1; (i < numberOfNodes + 1); i++)
{
if (i != 0) { adjacencyList.AddVertex(i); }
Vector3 position;
int startIndexCoordinates;
if (type == DATA_MNIST)
{
startIndexCoordinates = 3;
}
else
{
startIndexCoordinates = 8;
}
float x_3d = float.Parse(myPositionsGrid[startIndexCoordinates, i]) * ConstantsSpacerock.GRAPH_SPREAD_MULTIPLIER * ConstantsSpacerock.TOTAL_GRAPH_SCALE_MULTIPLIER;
float y_3d = float.Parse(myPositionsGrid[startIndexCoordinates + 1, i]) * ConstantsSpacerock.GRAPH_SPREAD_MULTIPLIER * ConstantsSpacerock.TOTAL_GRAPH_SCALE_MULTIPLIER;
float z_3d = float.Parse(myPositionsGrid[startIndexCoordinates + 2, i]) * ConstantsSpacerock.GRAPH_SPREAD_MULTIPLIER * ConstantsSpacerock.TOTAL_GRAPH_SCALE_MULTIPLIER;
float x_2d = float.Parse(myPositionsGrid[startIndexCoordinates + 3, i]) * ConstantsSpacerock.GRAPH_SPREAD_MULTIPLIER * ConstantsSpacerock.TOTAL_GRAPH_SCALE_MULTIPLIER;
float y_2d = float.Parse(myPositionsGrid[startIndexCoordinates + 4, i]) * ConstantsSpacerock.GRAPH_SPREAD_MULTIPLIER * ConstantsSpacerock.TOTAL_GRAPH_SCALE_MULTIPLIER;
if (dimensionality == GRAPH_3D)
{
position = new Vector3(
x_3d,
y_3d,
z_3d
);
}
else
{
position = new Vector3(
x_2d,
y_3d,
0.0f
);
}
string label = myPositionsGrid[0, i];
GameObject myNodeInstance =
Instantiate(Resources.Load("Node") as GameObject,
position,
Quaternion.identity) as GameObject;
//don't do getcomp live
LayerSelfBasedOnRelativeLocations layerScript = myNodeInstance.GetComponent<LayerSelfBasedOnRelativeLocations>();
layerScript.eagleEyeCamera = eagleEyeCamera;
layerScript.headsetLocation = playerCamera;
NodeForce nodeScript = myNodeInstance.GetComponent<NodeForce>();
nodeScript.x_3d = x_3d;
nodeScript.y_3d = y_3d;
nodeScript.z_3d = z_3d;
nodeScript.x_2d = x_2d;
nodeScript.y_2d = y_2d;
nodeScript.SetText(myPositionsGrid[1, i]);
nodeScript.degree = int.Parse(myPositionsGrid[2, i]);
nodeScript.SetScaleFromDegree(nodeScript.degree);
masterNodeList[i - 1] = new Node(myNodeInstance, i - 1);
if (type == DATA_TWITTER)
{
masterNodeList[i - 1].nodeForce.group = int.Parse(myPositionsGrid[3, i]);
masterNodeList[i - 1].nodeForce.followerCount = (int)float.Parse(myPositionsGrid[4, i]);
}
else if (type == DATA_MNIST)
{
masterNodeList[i - 1].nodeForce.group = (int)float.Parse(myPositionsGrid[1, i]);
}
NodeGroup nodeGroupWrapperObject;
// if this is a new key, make a new group
if (!nodeGroups.ContainsKey(masterNodeList[i - 1].nodeForce.group))
{
GameObject nodeGroupObject = Instantiate(Resources.Load("NodeGroupContainer") as GameObject, new Vector3(0.0f, 0.0f, 0.0f), Quaternion.identity) as GameObject;
nodeGroupWrapperObject = new NodeGroup(nodeGroupObject);
nodeGroupWrapperObject.nodeGroupContainerScript.groupNumber = masterNodeList[i - 1].nodeForce.group;
nodeGroupWrapperObject.gameObject.transform.parent = nodeContainer.transform;
nodeGroups.Add(
masterNodeList[i - 1].nodeForce.group,
nodeGroupWrapperObject
);
}
else // give access to the existing group
{
nodeGroupWrapperObject = nodeGroups[masterNodeList[i - 1].nodeForce.group];
}
masterNodeList[i - 1].nodeForce.SetColorByGroup(masterNodeList[i - 1].nodeForce.group);
masterNodeList[i - 1].gameObject.transform.parent = nodeGroupWrapperObject.gameObject.transform; // not sure if this is gonna work right, off the bat
// populate an array for the mnist image
if (type == DATA_MNIST)
{
for (int q = 0; q < MNIST_IMAGE_SIZE; q++)
{
for (int r = 0; r < MNIST_IMAGE_SIZE; r++)
{
//print("q: " + q + "... r: " + r);
masterNodeList[i - 1].nodeForce.image[q, r] = float.Parse(myPositionsGrid[startIndexCoordinates + 5 + q * MNIST_IMAGE_SIZE + r, i]);
}
}
}
nameToID.Add(label, i - 1);
}
}
void parseMetadata(string metaAsset)
{
TextAsset metaText = Resources.Load(metaAsset) as TextAsset;
string[,] metaGrid = CSVReader.SplitCsvGrid(metaText.text);
int numberOfGroups = metaGrid.GetUpperBound(1) - 1;
for (int i = 1; (i < numberOfGroups + 1); i++)
{
// add the group
GameObject nodeGroupObject = Instantiate(Resources.Load("NodeGroupContainer") as GameObject, new Vector3(0.0f, 0.0f, 0.0f), Quaternion.identity) as GameObject;
NodeGroup nodeGroupWrapperObject = new NodeGroup(nodeGroupObject);
int currentGroupNumber = (int)float.Parse(metaGrid[0, i]);
nodeGroupWrapperObject.nodeGroupContainerScript.groupNumber = currentGroupNumber;
nodeGroupWrapperObject.gameObject.transform.parent = nodeContainer.transform;
// give the group its centroid
float x_3d = float.Parse(metaGrid[1, i]) * ConstantsSpacerock.GRAPH_SPREAD_MULTIPLIER * ConstantsSpacerock.TOTAL_GRAPH_SCALE_MULTIPLIER;
float y_3d = float.Parse(metaGrid[2, i]) * ConstantsSpacerock.GRAPH_SPREAD_MULTIPLIER * ConstantsSpacerock.TOTAL_GRAPH_SCALE_MULTIPLIER;
float z_3d = float.Parse(metaGrid[3, i]) * ConstantsSpacerock.GRAPH_SPREAD_MULTIPLIER * ConstantsSpacerock.TOTAL_GRAPH_SCALE_MULTIPLIER;
GameObject centroidGameObject =
Instantiate(Resources.Load("GroupCentroid") as GameObject,
new Vector3(
x_3d,
y_3d,
z_3d
),
Quaternion.identity)
as GameObject;
centroidGameObject.transform.parent = nodeGroupWrapperObject.gameObject.transform;
GroupCentroidReferences groupCentroidReferenceObject = new GroupCentroidReferences(centroidGameObject);
nodeGroupWrapperObject.nodeGroupContainerScript.centroid = groupCentroidReferenceObject;
groupCentroidReferenceObject.groupCentroidScript.x_3d = x_3d;
groupCentroidReferenceObject.groupCentroidScript.y_3d = y_3d;
groupCentroidReferenceObject.groupCentroidScript.z_3d = z_3d;
nodeGroups.Add(
currentGroupNumber,
nodeGroupWrapperObject
);
groupCentroidReferenceObject.groupCentroidScript.SetColorByGroup(currentGroupNumber);
}
// put a centroid object in every group
// give a reference to the centroid object to the group?
// give the centroid object a reference to the group?
// centroid color should match group color
}
public SkillTree(String treestring, startLoadingWindow start = null, UpdateLoadingWindow update = null, closeLoadingWindow finish = null)
{
bool displayProgress = ( start != null && update != null && finish != null );
// RavenJObject jObject = RavenJObject.Parse( treestring.Replace( "Additional " , "" ) );
JsonSerializerSettings jss = new JsonSerializerSettings
{
Error = delegate(object sender, Newtonsoft.Json.Serialization.ErrorEventArgs args)
{
Debug.WriteLine(args.ErrorContext.Error.Message);
args.ErrorContext.Handled = true;
}
};
var inTree = JsonConvert.DeserializeObject<PoEClasses.PoESkillTree>(treestring.Replace("Additional ", ""), jss);
int qindex = 0;
foreach (var obj in inTree.skillSprites)
{
if (obj.Key.Contains("inactive"))
continue;
iconActiveSkills.Images[obj.Value[3].filename] = null;
foreach (var o in obj.Value[3].coords)
{
iconActiveSkills.SkillPositions[o.Key] = new KeyValuePair<Rect, string>(new Rect(o.Value.x, o.Value.y, o.Value.w, o.Value.h), obj.Value[3].filename);
}
}
foreach (var obj in inTree.skillSprites)
{
if (obj.Key.Contains("active"))
continue;
iconActiveSkills.Images[obj.Value[3].filename] = null;
foreach (var o in obj.Value[3].coords)
{
iconActiveSkills.SkillPositions[o.Key] = new KeyValuePair<Rect, string>(new Rect(o.Value.x, o.Value.y, o.Value.w, o.Value.h), obj.Value[3].filename);
}
}
qindex = 0;
foreach(var ass in inTree.assets)
{
assets[ass.Key] = new Asset(ass.Key,ass.Value.ContainsKey(0.3835f)?ass.Value[0.3835f]:ass.Value.Values.First());
}
if ( displayProgress )
start( );
iconActiveSkills.OpenOrDownloadImages(update );
iconInActiveSkills.OpenOrDownloadImages(update );
if ( displayProgress )
finish( );
foreach( var c in inTree.characterData)
{
CharBaseAttributes[c.Key] = new Dictionary<string, float>() { { "+# to Strength", c.Value.base_str }, { "+# to Dexterity", c.Value.base_dex }, { "+# to Intelligence", c.Value.base_int } };
}
foreach (var nd in inTree.nodes)
{
Skillnodes.Add(nd.id, new SkillTree.SkillNode()
{
id = nd.id,
name = nd.dn,
attributes = nd.sd,
orbit = nd.o,
orbitIndex =nd.oidx,
icon = nd.icon,
linkID =nd.ot,
g = nd.g,
da = nd.da,
ia = nd.ia,
ks = nd.ks,
not = nd.not,
sa = nd.sa,
Mastery = nd.m,
spc=nd.spc.Count()>0?(int?)nd.spc[0]:null
});
}
List<ushort[]> links = new List<ushort[]>( );
foreach ( var skillNode in Skillnodes )
{
foreach ( ushort i in skillNode.Value.linkID )
{
if (
links.Count(
nd => ( nd[ 0 ] == i && nd[ 1 ] == skillNode.Key ) || nd[ 0 ] == skillNode.Key && nd[ 1 ] == i ) ==
1 )
{
continue;
}
links.Add( new ushort[] { skillNode.Key , i } );
}
}
foreach ( ushort[] ints in links )
{
if ( !Skillnodes[ ints[ 0 ] ].Neighbor.Contains( Skillnodes[ ints[ 1 ] ] ) )
Skillnodes[ ints[ 0 ] ].Neighbor.Add( Skillnodes[ ints[ 1 ] ] );
if ( !Skillnodes[ ints[ 1 ] ].Neighbor.Contains( Skillnodes[ ints[ 0 ] ] ) )
Skillnodes[ ints[ 1 ] ].Neighbor.Add( Skillnodes[ ints[ 0 ] ] );
}
foreach(var gp in inTree.groups )
{
NodeGroup ng = new NodeGroup();
ng.OcpOrb = gp.Value.oo;
ng.Position = new Vector2D(gp.Value.x, gp.Value.y);
ng.Nodes = gp.Value.n;
NodeGroups.Add(ng);
}
foreach ( SkillTree.NodeGroup group in NodeGroups )
{
foreach ( ushort node in group.Nodes )
{
Skillnodes[ node ].NodeGroup = group;
}
}
TRect = new Rect2D( new Vector2D( inTree.min_x * 1.1 , inTree.min_y * 1.1 ) ,
new Vector2D(inTree.max_x * 1.1, inTree.max_y * 1.1));
InitNodeSurround( );
DrawNodeSurround( );
DrawNodeBaseSurround( );
DrawSkillIconLayer( );
DrawBackgroundLayer( );
InitFaceBrushesAndLayer( );
DrawLinkBackgroundLayer( links );
InitOtherDynamicLayers( );
CreateCombineVisual( );
Regex regexAttrib = new Regex( "[0-9]*\\.?[0-9]+" );
foreach ( var skillNode in Skillnodes )
{
skillNode.Value.Attributes = new Dictionary<string , List<float>>( );
foreach ( string s in skillNode.Value.attributes )
{
List<float> values = new List<float>( );
foreach ( Match m in regexAttrib.Matches( s ) )
{
if ( !AttributeTypes.Contains( regexAttrib.Replace( s , "#" ) ) )
AttributeTypes.Add( regexAttrib.Replace( s , "#" ) );
if ( m.Value == "" )
values.Add( float.NaN );
else
values.Add( float.Parse( m.Value , System.Globalization.CultureInfo.InvariantCulture ) );
}
string cs = ( regexAttrib.Replace( s , "#" ) );
skillNode.Value.Attributes[ cs ] = values;
}
}
}
public void Connect(NodeGroup to)
{
toGroups.Add (to);
to.fromGroups.Add (this);
}
void Dfs2(NodeGroup g)
{
foreach (var n in g.Nodes) {
foreach (var t in n.PointsTo) {
if (t.Group != g)
g.Connect (t.Group);
}
}
}
public static void OpenInEditor(NodeGroup group)
{
Initialize();
NodifyEditorUtilities.currentSelectedGroup = group;
}
public void DrawNodeGroup(NodeGroup node)
{
object renderer = Nodify.Editor.NodifyEditorUtilities.FindNodeRenderer(node.GetType());
renderer.GetType().GetMethod("Render").Invoke(renderer, new object[] { node });
}
private void HandleEditorEvents(NodeGroup group)
{
int multi_select_nodes = EditorPrefs.GetInt("nodify.hotkeys.multi_select_nodes", 303);
// Begin Context Menu Controls
if (Event.current.type == EventType.ContextClick)
{
if (NodifyEditorUtilities.currentConnectingAnchor != null)
{
NodifyEditorUtilities.currentConnectingAnchor = null;
Event.current.Use();
}
else
{
ShowNodeCreationMenu();
Event.current.Use();
}
}
if(Event.current.type == EventType.KeyDown)
{
// Begin Focus Element Control
if (Event.current.keyCode == (KeyCode)EditorPrefs.GetInt("nodify.hotkeys.focus_on_selected_node2", 102) && NodifyPreferencesGUI.GetAdditionalButtons(EditorPrefs.GetInt("nodify.hotkeys.focus_on_selected_node", 0)))
{
if (Selection.activeGameObject != null)
{
if (Selection.activeGameObject.GetComponent<Node>())
{
FocusNode(group, Selection.activeGameObject.GetComponent<Node>());
}
if (Selection.activeGameObject.GetComponent<Anchor>())
{
FocusNode(group, Selection.activeGameObject.GetComponent<Anchor>().parent);
}
}
ForceRepaint();
}
if (Event.current.keyCode == KeyCode.Delete)
{
foreach (GameObject obj in Selection.gameObjects)
{
if (obj != NodifyEditorUtilities.currentSelectedGroup.gameObject && (obj.GetComponent<Node>() || obj.GetComponent<Anchor>()))
{
if (EditorUtility.DisplayDialog("Are you sure?", "Do you wish to delete the node: " + obj.name, "Delete", "Cancel"))
{
NodifyEditorUtilities.SafeDestroy(obj);
}
}
}
}
}
// Begin Mouse Selection Events
if (NodifyEditorUtilities.currentManipulatingNode == null && NodifyPreferencesGUI.GetAdditionalButtons(EditorPrefs.GetInt("nodify.hotkeys.multi_select_nodes", 303)))
{
switch (Event.current.type)
{
case EventType.MouseDown:
if (Event.current.button == 0)
{
MouseSelectionStartPoint = Event.current.mousePosition;
MouseSelection = true;
ForceRepaint();
}
break;
case EventType.MouseUp:
if (MouseSelection == true)
{
SelectNodesInRect(RectExtensions.GetRectFromPoints(MouseSelectionStartPoint, Event.current.mousePosition));
MouseSelection = false;
}
ForceRepaint();
break;
case EventType.MouseDrag:
if (Event.current.button == 0)
{
ForceRepaint();
}
else if (Event.current.button == 2) // Begin Mouse Drag Controls
{
Vector2 mouseDelta = Event.current.delta;
Vector2 mouseZoomDelta = (1f / group.editorZoomAmount) * mouseDelta;
group.editorWindowOffset += mouseZoomDelta;
Event.current.Use();
}
break;
}
}
if (Event.current.type == EventType.MouseDrag && multi_select_nodes != 0 && !NodifyPreferencesGUI.GetAdditionalButtons(EditorPrefs.GetInt("nodify.hotkeys.multi_select_nodes", 303)))
{
Vector2 mouseDelta = Event.current.delta;
Vector2 mouseZoomDelta = (1f / group.editorZoomAmount) * mouseDelta;
group.editorWindowOffset += mouseZoomDelta;
ForceRepaint();
}
// Begin Zoom Controls
if (Event.current.type == EventType.ScrollWheel)
{
group.editorZoomAmount -= Event.current.delta.y / 80;
group.editorZoomAmount = (float)System.Math.Round((double)Mathf.Clamp(group.editorZoomAmount, minimumZoomFactor, maximumZoomFactor), 2);
Event.current.Use();
}
if (Event.current.type == EventType.MouseDown && multi_select_nodes != 0 && NodifyPreferencesGUI.GetAdditionalButtons(EditorPrefs.GetInt("nodify.hotkeys.deselect_all", 303)))
{
Selection.objects = new UnityEngine.Object[0];
Event.current.Use();
}
// Begin Drag & Drop Components into Variables
if(Event.current.type == EventType.DragPerform || Event.current.type == EventType.DragUpdated)
{
DragAndDrop.visualMode = DragAndDropVisualMode.Link;
if(Event.current.type == EventType.DragPerform)
{
DragAndDrop.AcceptDrag();
foreach(UnityEngine.Object obj in DragAndDrop.objectReferences)
{
foreach(CreateMenu nodeMenu in NodifyEditorUtilities.FindNodeTypes())
{
if(nodeMenu.type.BaseType.IsGenericType)
{
if(nodeMenu.type.BaseType.GetGenericArguments()[0] == obj.GetType())
{
GameObject nodeObj = new GameObject(obj.GetType().Name);
#if UNITY_5
Node nodeClass = (Node)nodeObj.AddComponent(nodeMenu.type);
#else
Node nodeClass = (Node)nodeObj.AddComponent(nodeMenu.type.Name);
#endif
nodeClass.editorPosition = Event.current.mousePosition - group.editorWindowOffset;
nodeClass.editorResourceIcon = nodeMenu.iconResourcePath;
nodeClass.OnEditorNodeCreated();
nodeObj.transform.parent = group.transform;
nodeClass.GetType().GetField("value").SetValue(nodeClass, obj);
}
}
}
}
}
}
}
public void FocusNode(NodeGroup group, Node node)
{
group.editorZoomAmount = maximumZoomFactor;
group.editorWindowOffset = -node.editorPosition + new Vector2(this.position.width / 2, this.position.height / 2);
}
