/// <inheritdoc /> public override IGraphType GenerateGraphType(NodeInterface nodeInterface, List <TypeInterface> interfaces) { var graphType = new VirtualGraphType(this.ComplexTypeName); graphType.AddField( new FieldType { Name = "deletedId", ResolvedType = new IdGraphType(), Resolver = new DeletedIdResolver() }); graphType.AddField( this.CreateField( "node", this.EdgeType.ObjectType, new NodeResolver(this.EdgeType.ObjectType))); graphType.AddField(this.CreateField("edge", this.EdgeType)); graphType.AddField(this.CreateField("errors", this.ErrorType, new ResultErrorsResolver())); graphType.AddField( new FieldType { Name = "clientMutationId", ResolvedType = new StringGraphType(), Resolver = new ClientMutationIdIdResolver() }); graphType.AddField(this.CreateField("api", this.root, this.root)); return(graphType); }
/// <inheritdoc /> public override IGraphType ExtractInterface(ApiProvider provider, NodeInterface nodeInterface) { var extractInterface = (TypeInterface)base.ExtractInterface(provider, nodeInterface); extractInterface.AddField(this.CreateNodeField(nodeInterface)); return(extractInterface); }
/// <inheritdoc /> public override IGraphType GenerateGraphType(NodeInterface nodeInterface, List <TypeInterface> interfaces) { switch (this.ScalarType) { case EnScalarType.Boolean: return(new BooleanGraphType()); case EnScalarType.Float: return(new FloatGraphType()); case EnScalarType.Decimal: return(new DecimalGraphType()); case EnScalarType.Integer: return(new IntGraphType()); case EnScalarType.String: return(new StringGraphType()); case EnScalarType.Guid: return(new GuidGraphType()); case EnScalarType.DateTime: return(new DateGraphType()); default: throw new ArgumentOutOfRangeException(); } }
public override bool Match(NodeInterface node) { int emptyIndex = ((GameNode)node).EmptyTileIndex; switch (emptyIndex) { case 0: return ((GameNode)node).EmptyTileIndex == 0; case 1: return ((GameNode)node).EmptyTileIndex == 1; case 2: return ((GameNode)node).EmptyTileIndex == 2; case 3: return ((GameNode)node).EmptyTileIndex == 3; case 4: return ((GameNode)node).EmptyTileIndex == 4; case 5: return ((GameNode)node).EmptyTileIndex == 5; case 6: return ((GameNode)node).EmptyTileIndex == 6; case 7: return ((GameNode)node).EmptyTileIndex == 7; case 8: return ((GameNode)node).EmptyTileIndex == 8; } return false; }
public NodeInterface Remove() { this.Prev.Next = this.Next; this.Next.Prev = this.Prev; this.Next = this.Prev = this; return(this); }
public bool FindPath(NodeInterface start_node, NodeInterface end_node, bool include_off_paths) { List <NodeInterface> _TouchedNodes = new List <NodeInterface>(); _TouchedNodes.Add(start_node); Queue <NodeInterface> _Nodes = new Queue <NodeInterface>(); foreach (NodeConnection c in start_node.Connections) { PowerConsumer power_consumer_comp = c.GetComponent <PowerConsumer>(); if (!include_off_paths && (!power_consumer_comp || !power_consumer_comp.IsActive)) { continue; } NodeInterface _OtherNode = c.GetOtherConnection(start_node); if (_OtherNode == end_node) { return(true); } else { _Nodes.Enqueue(_OtherNode); _TouchedNodes.Add(_OtherNode); } } while (_Nodes.Count > 0) { NodeInterface _currentNode = _Nodes.Dequeue(); foreach (NodeConnection c in _currentNode.Connections) { PowerConsumer power_consumer_comp = c.GetComponent <PowerConsumer>(); if (!include_off_paths && (!power_consumer_comp || !power_consumer_comp.IsActive)) { continue; } NodeInterface _OtherNode = c.GetOtherConnection(_currentNode); if (_OtherNode == end_node) { return(true); } else if (!_TouchedNodes.Contains(_OtherNode)) { _Nodes.Enqueue(_OtherNode); _TouchedNodes.Add(_OtherNode); } } } return(false); }
/// <inheritdoc /> public override IGraphType GenerateGraphType(NodeInterface nodeInterface, List <TypeInterface> interfaces) { var graphType = (VirtualGraphType)base.GenerateGraphType(nodeInterface, interfaces); var nodeFieldType = this.CreateNodeField(nodeInterface); graphType.AddField(nodeFieldType); return(graphType); }
/// <inheritdoc /> public override IGraphType ExtractInterface(ApiProvider provider, NodeInterface nodeInterface) { if (this.Provider != provider) { return(null); } return(this.GenerateGraphType(null, null)); }
public NodeInterface Insert(NodeInterface b) { NodeInterface c = Next; b.Next = c; b.Prev = this; this.Next = b; c.Prev = b; return(b); }
public override IEnumerable<NodeInterface> GetSuccessors(NodeInterface node) { var result = new List<NodeInterface>(); int emptyIndex = ((GameNode)node).EmptyTileIndex; switch (emptyIndex) { case 0: AddSuccessor((GameNode) node, result, 1); AddSuccessor((GameNode) node, result, 3); break; case 1: AddSuccessor((GameNode) node, result, 0); AddSuccessor((GameNode) node, result, 2); AddSuccessor((GameNode) node, result, 4); break; case 2: AddSuccessor((GameNode) node, result, 1); AddSuccessor((GameNode) node, result, 5); break; case 3: AddSuccessor((GameNode) node, result, 0); AddSuccessor((GameNode) node, result, 4); AddSuccessor((GameNode) node, result, 6); break; case 4: AddSuccessor((GameNode) node, result, 1); AddSuccessor((GameNode) node, result, 3); AddSuccessor((GameNode) node, result, 5); AddSuccessor((GameNode) node, result, 7); break; case 5: AddSuccessor((GameNode) node, result, 2); AddSuccessor((GameNode) node, result, 4); AddSuccessor((GameNode) node, result, 8); break; case 6: AddSuccessor((GameNode) node, result, 3); AddSuccessor((GameNode) node, result, 7); break; case 7: AddSuccessor((GameNode) node, result, 4); AddSuccessor((GameNode) node, result, 6); AddSuccessor((GameNode) node, result, 8); break; case 8: AddSuccessor((GameNode) node, result, 5); AddSuccessor((GameNode) node, result, 7); break; default: break; } return result; }
public void Splice(NodeInterface b) { NodeInterface a = this; NodeInterface an = a.Next; NodeInterface bn = b.Next; a.Next = bn; b.Next = an; an.Next = b; bn.Prev = a; }
/// <inheritdoc /> public override IGraphType GenerateGraphType(NodeInterface nodeInterface, List <TypeInterface> interfaces) { var fields = this.Fields.Select(this.ConvertApiField); var inputGraphType = new VirtualInputGraphType(this.ComplexTypeName) { Description = this.Description }; inputGraphType.AddFields(fields); return(inputGraphType); }
/// <inheritdoc /> public override IGraphType GenerateGraphType(NodeInterface nodeInterface, List <TypeInterface> interfaces) { var graphType = new VirtualGraphType(this.ComplexTypeName); graphType.AddField(this.CreateField("result", this.OriginalReturnType, new ResultResolver(this.OriginalReturnType))); graphType.AddField(new FieldType { Name = "clientMutationId", ResolvedType = new StringGraphType(), Resolver = new MergedConnectionMutationResultType.ClientMutationIdIdResolver() }); graphType.AddField(this.CreateField("api", this.root, this.root)); return(graphType); }
/// <inheritdoc /> public override IGraphType GenerateGraphType(NodeInterface nodeInterface, List <TypeInterface> interfaces) { var fields = new List <FieldType> { new FieldType { Name = "cursor", ResolvedType = new StringGraphType(), Resolver = new CursorResolver(), Description = "A value to use with paging positioning" }, new FieldType { Name = "node", ResolvedType = new VirtualGraphType("tmp"), Metadata = new Dictionary <string, object> { { MetaDataTypeKey, new MergedField( "node", this.ObjectType, this.Provider, null, description: this.ObjectType.Description) { Resolver = new NodeResolver(this.ObjectType) } } } } }; var generateGraphType = new VirtualGraphType(this.ComplexTypeName, fields) { Description = this.Description }; if (interfaces != null) { foreach (var typeInterface in interfaces) { typeInterface.AddPossibleType(generateGraphType); generateGraphType.AddResolvedInterface(typeInterface); } } return(generateGraphType); }
/// <inheritdoc /> public override IGraphType GenerateGraphType(NodeInterface nodeInterface, List <TypeInterface> interfaces) { var fields = new List <FieldType> { new FieldType { Name = "count", ResolvedType = new IntGraphType(), Resolver = new CountResolver(), Description = "The total count of objects satisfying filter conditions" }, new FieldType { Name = "edges", Description = "The list of edges according to filtering and paging conditions", ResolvedType = new VirtualGraphType("tmp"), Metadata = new Dictionary <string, object> { { MetaDataTypeKey, new MergedField( "edges", this.EdgeType, this.Provider, null, EnFieldFlags.IsArray, description: "The list of edges according to filtering and paging conditions") } } } }; var generateGraphType = new VirtualGraphType(this.ComplexTypeName, fields) { Description = this.Description }; if (interfaces != null) { foreach (var typeInterface in interfaces) { typeInterface.AddPossibleType(generateGraphType); generateGraphType.AddResolvedInterface(typeInterface); } } return(generateGraphType); }
public IEnumerable<NodeInterface> Execute(NodeInterface currentNode) { var node = currentNode as GameNode; var successorRules = new List<SuccessorNodesCalculationRuleInterface> { new GameSuccessorsForEmptyTile() }; return successorRules .Single(r => r.Match(node)) .GetSuccessors(node); }
public int[,] unstringNode(NodeInterface node) { int[] strung = node.Tiles; int[,] unstrung = new int[N,N]; int elemN = 0; for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) { unstrung[i, j] = strung[elemN]; elemN++; } } return unstrung; }
/// <summary> /// Creates the node searcher field for the graph type /// </summary> /// <param name="nodeInterface">The node interface</param> /// <returns>The node field</returns> private FieldType CreateNodeField(NodeInterface nodeInterface) { var nodeFieldType = new FieldType(); nodeFieldType.Name = "__node"; nodeFieldType.ResolvedType = nodeInterface; nodeFieldType.Description = "The node global searcher according to Relay specification"; nodeFieldType.Arguments = new QueryArguments( new QueryArgument(typeof(IdGraphType)) { Name = "id", Description = "The node global id" }); nodeFieldType.Resolver = this.NodeSearher; return(nodeFieldType); }
protected virtual void NodeOnClick() { string connection_names = "Current connections: "; for (int i = 0; i < m_Connections.Count; i++) { NodeInterface connected_node = m_Connections[i].GetOtherConnection(this); if (connected_node) { connection_names += "'" + connected_node.name + "' "; } } Debug.Log(connection_names); }
/// <summary> /// Generates the list of all api type interfaces /// </summary> /// <param name="providers">The list of api providers</param> /// <param name="types">The list of merged api types</param> /// <param name="nodeInterface">The node interface</param> /// <returns>The list of interfaces</returns> private static Dictionary <string, IGraphType> GenerateApiTypeInterfaces( List <ApiProvider> providers, List <MergedType> types, NodeInterface nodeInterface) { var interfaces = providers.ToDictionary( p => p, p => types.Where(t => !(t is MergedInputType)) .Select(t => t.ExtractInterface(p, nodeInterface)) .Where(i => i != null) .GroupBy(i => i.Name) .Select(g => g.First()) .ToDictionary(i => i.Name)); foreach (var apiInterfaces in interfaces) { foreach (var apiInterface in apiInterfaces.Value.Values.OfType <TypeInterface>()) { foreach (var field in apiInterface.Fields) { var fieldDescription = field.GetMetadata <MergedField>(MergedType.MetaDataTypeKey); if (fieldDescription == null) { continue; } var fieldInterfaceName = fieldDescription.Type.GetInterfaceName(apiInterfaces.Key); IGraphType fieldValue; if (apiInterfaces.Value.TryGetValue(fieldInterfaceName, out fieldValue)) { field.ResolvedType = fieldDescription.Flags.HasFlag(EnFieldFlags.IsArray) ? new ListGraphType(fieldValue) : fieldValue; } } } } var allInterfaces = interfaces.Values.SelectMany(i => i) .GroupBy(i => i.Key) .ToDictionary(i => i.Key, i => i.First().Value); return(allInterfaces); }
public float Execute(NodeInterface goal, NodeInterface node) { float result = 0.0f; var currentNode = node as GameNode; var goalNode = goal as GameNode; for (int i = 0; i < 9; i++) { if (goalNode == null) continue; int currentNumber = goalNode.Tiles[i]; int currentIndex = FindTileCurrentIndex(currentNumber, currentNode); result = GetDistanceToGoalTileForIndex(result, i, currentIndex); } return result; }
/// <inheritdoc /> public override IGraphType ExtractInterface(ApiProvider provider, NodeInterface nodeInterface) { if (this.Provider != provider) { return(null); } var nodeType = (ObjectGraphType)this.GenerateGraphType(null, null); var apiInterface = new TypeInterface(this.GetInterfaceName(provider), this.Description); foreach (var field in nodeType.Fields) { apiInterface.AddField(field); } return(apiInterface); }
public void BuildTurretOn(NodeInterface node) { if (PlayerStats.Creds < turretToBuild.schemaCost) { Debug.Log("Not enough creds to build that!"); return; } PlayerStats.Creds -= turretToBuild.schemaCost; GameObject turret = (GameObject)Instantiate(turretToBuild.prefab, node.GetBuildPosition(), Quaternion.identity); node.turret = turret; GameObject effect = (GameObject)Instantiate(buildEffect, node.GetBuildPosition(), Quaternion.identity)); Destroy(effect, 5f); Debug.Log("Turret Built, Creds remaining: " + PlayerStats.Creds); }
/// <inheritdoc /> public override IGraphType GenerateGraphType(NodeInterface nodeInterface, List <TypeInterface> interfaces) { var graphType = new EnumerationGraphType { Description = this.apiEnumType.Description, Name = this.ComplexTypeName }; foreach (var enumValue in this.apiEnumType.Values) { graphType.AddValue( enumValue, this.apiEnumType.Descriptions.TryGetValue(enumValue, out var description) ? description : null, enumValue); } return(graphType); }
/// <inheritdoc /> public override IGraphType GenerateGraphType(NodeInterface nodeInterface, List <TypeInterface> interfaces) { var graphType = (VirtualGraphType)base.GenerateGraphType(nodeInterface, interfaces); var nodeFieldType = new FieldType(); nodeFieldType.Name = "node"; nodeFieldType.ResolvedType = nodeInterface; nodeFieldType.Description = "The node global searcher according to Relay specification"; nodeFieldType.Arguments = new QueryArguments( new QueryArgument(typeof(IdGraphType)) { Name = "id", Description = "The node global id" }); nodeFieldType.Resolver = this.searcher; graphType.AddField(nodeFieldType); return(graphType); }
/// <inheritdoc /> public override IGraphType GenerateGraphType(NodeInterface nodeInterface, List <TypeInterface> interfaces) { var fields = this.Fields.Select(this.ConvertApiField); var graphType = new VirtualGraphType(this.ComplexTypeName, fields.ToList()) { Description = this.Description }; if (interfaces != null) { foreach (var typeInterface in interfaces) { typeInterface.AddImplementedType(this.ComplexTypeName, graphType); graphType.AddResolvedInterface(typeInterface); } } return(graphType); }
/// <inheritdoc /> public override IGraphType GenerateGraphType(NodeInterface nodeInterface, List <TypeInterface> interfaces) { var graphType = (VirtualGraphType)base.GenerateGraphType(nodeInterface, interfaces); var idField = graphType.Fields.FirstOrDefault(f => f.Name == "id"); if (idField != null) { idField.Name = "__id"; } graphType.AddField( new FieldType { Name = "id", ResolvedType = new IdGraphType(), Resolver = new GlobalIdResolver() }); graphType.AddResolvedInterface(nodeInterface); nodeInterface.AddImplementedType(this.ComplexTypeName, graphType); return(graphType); }
public NodeInterface GetOtherConnection(NodeInterface requesting_node) { if (m_NodeOne == requesting_node) { return(m_NodeTwo); } else if (m_NodeTwo == requesting_node) { //If the connection is a directional connection then we will always have the connection going to node two, not node one if (!m_IsDirectional) { return(m_NodeOne); } } else { Debug.LogError(requesting_node.name + " tried getting the other node in connection " + this.name + " when it isn't a part of this connection!"); return(null); } return(null); }
/// <summary> /// Generates the list of used end-types /// </summary> /// <param name="providers">The list of defined api providers</param> /// <param name="types">The list of merged types</param> /// <param name="nodeInterface">The node interface (for relay compliance)</param> /// <param name="allInterfaces">The list of defined type interfaces</param> /// <param name="api">The api root element</param> /// <param name="mutationType">The type containing all mutation methods</param> /// <returns>The list of defined types</returns> private static Dictionary <string, IGraphType> GenerateApiTypes( List <ApiProvider> providers, List <MergedType> types, NodeInterface nodeInterface, Dictionary <string, IGraphType> allInterfaces, MergedApiRoot api, out IObjectGraphType mutationType) { var graphTypes = types.ToDictionary( type => type.ComplexTypeName, type => type.GenerateGraphType(nodeInterface, GetTypeInterfaces(type, providers, allInterfaces))); mutationType = api.GenerateMutationType(); graphTypes[mutationType.Name] = mutationType; graphTypes.Values.OfType <IComplexGraphType>().SelectMany(a => a.Fields).ForEach( f => { var fieldDescription = f.GetMetadata <MergedField>(MergedType.MetaDataTypeKey); if (fieldDescription == null) { return; } SetFieldArguments(f, fieldDescription, graphTypes); f.ResolvedType = GetTypeForField(fieldDescription, graphTypes); if (f.Resolver == null) { f.Resolver = fieldDescription.Resolver ?? fieldDescription.Type; } if (!string.IsNullOrWhiteSpace(fieldDescription.Description)) { f.Description = fieldDescription.Description; } }); return(graphTypes); }
/// <summary> /// Generates GraphQL schema /// </summary> /// <param name="providers">The list of providers</param> /// <returns>The new GraphQL schema</returns> public static Schema Generate(List <ApiProvider> providers) { var createdTypes = new Dictionary <string, MergedType>(); var api = MergeApis(providers, createdTypes); api.Initialize(); var nodeInterface = new NodeInterface(); var root = new MergedRoot("Query", providers, api); root.Initialize(); createdTypes[root.ComplexTypeName] = root; createdTypes[api.ComplexTypeName] = api; var types = createdTypes.Values.GroupBy(t => t.ComplexTypeName).Select(g => g.First()).ToList(); var allInterfaces = GenerateApiTypeInterfaces(providers, types, nodeInterface); IObjectGraphType mutationType; var graphTypes = GenerateApiTypes(providers, types, nodeInterface, allInterfaces, api, out mutationType); AdjustInterfaceFieldsArguments(allInterfaces, graphTypes); graphTypes.Values.OfType <VirtualGraphType>().ForEach(vgt => vgt.StoreFieldResolvers()); var schema = new Schema { Query = (VirtualGraphType)graphTypes[root.ComplexTypeName], Mutation = mutationType.Fields.Any() ? mutationType : null }; var arrayOfInterfaces = allInterfaces.Values.OfType <TypeInterface>().Cast <IGraphType>().ToArray(); schema.RegisterTypes(arrayOfInterfaces); schema.Initialize(); return(schema); }
public NodeInterface Execute(NodeInterface startNode, NodeInterface goalNode) { Cycles = 0; var openList = new List<NodeInterface> { startNode }; var closedList = new List<NodeInterface>(); while (openList.Count > 0) { Cycles++; NodeInterface currentNode = GetBestNodeFromOpenList(openList); openList.Remove(currentNode); closedList.Add(currentNode); IEnumerable<NodeInterface> successorNodes = _successorNodesGenerator.Execute(currentNode); foreach (NodeInterface successorNode in successorNodes) { if (successorNode.Equals(goalNode)) return successorNode; successorNode.G = _gValueCalculator.AddCost(currentNode); successorNode.H = _hValueCalculator.Execute(goalNode, successorNode); successorNode.F = successorNode.G + successorNode.H; if (OpenListHasBetterNode(successorNode, openList)) continue; openList.Add(successorNode); } } return null; }
/// <inheritdoc /> public override IGraphType ExtractInterface(ApiProvider provider, NodeInterface nodeInterface) { var fieldProvider = this.providers.FirstOrDefault(fp => fp.Provider == provider); if (fieldProvider == null) { return(null); } var fields = this.Fields.Where(f => f.Value.Providers.Any(fp => fp == provider)) .Select(this.ConvertApiField) .ToList(); var idField = fields.FirstOrDefault(f => f.Name == "id"); if (idField != null) { idField.Name = "__id"; } fields.Insert(0, new FieldType { Name = "id", ResolvedType = new IdGraphType() }); var apiInterface = new TypeInterface( this.GetInterfaceName(provider), fieldProvider.FieldType.Description); foreach (var field in fields) { apiInterface.AddField(field); } return(apiInterface); }
public bool Equals(NodeInterface node) { var testNode = node as GameNode; return testNode != null && Tiles.SequenceEqual(testNode.Tiles); }
private static bool OpenListHasBetterNode(NodeInterface successor, IEnumerable<NodeInterface> list) { return list.FirstOrDefault(n => n.G.Equals(successor.G) && n.F < successor.F) != null; }
public bool ConnectionHasNode(NodeInterface requesting_node) { return(m_NodeOne == requesting_node || m_NodeTwo == requesting_node); }
public virtual bool Match(NodeInterface node) { return false; }
private static bool IsEqualToParentState(NodeInterface node, IEnumerable<int> state) { return node != null && state.SequenceEqual(((GameNode) node).Tiles); }
public virtual IEnumerable<NodeInterface> GetSuccessors(NodeInterface node) { return null; }
public Node() { this.Next = this; this.Prev = this; }
/// <summary> /// Generates a new <see cref="IGraphType"/> /// </summary> /// <param name="nodeInterface"> /// The node Interface. /// </param> /// <param name="interfaces"> /// The list of implemented interfaces. /// </param> /// <returns> /// The representing <see cref="IGraphType"/> /// </returns> public abstract IGraphType GenerateGraphType(NodeInterface nodeInterface, List <TypeInterface> interfaces);
/// <summary> /// Extracts interface to represent type for specific API provider /// </summary> /// <param name="provider"> /// The api provider /// </param> /// <param name="nodeInterface"> /// The node interface. /// </param> /// <returns> /// The interface type or null if type is not defined for provider /// </returns> public abstract IGraphType ExtractInterface(ApiProvider provider, NodeInterface nodeInterface);