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