public static List<List<MoveDesc>> Run(AnalysisNode starting_node,
INodeGenerator node_generator, uint fullmove_depth)
{
Debug.Assert(starting_node != null && starting_node.Position != null);
Debug.Assert(node_generator != null);
Debug.Assert(fullmove_depth > 0);
List<List<MoveDesc>> result = null;
// Run recursive function, which finds all forced mates
// This call erases all nodes (except root), which do not
// lead to a forced checkmate. So, if there is (are) forced mate(s)
// then the remaining tree nodes give us an answer
if (FindMateRecursive(starting_node, node_generator, fullmove_depth)
&& !starting_node.IsLeaf)
{
result = new List<List<MoveDesc>>();
foreach (var child in starting_node.Children)
{
CollectAllVariations(child, new List<MoveDesc>(), result);
}
Debug.Assert(result.Count > 0);
}
return result;
}
private static bool FindMateRecursive(AnalysisNode starting_node,
INodeGenerator nodes_generator, uint fullmove_depth)
{
Debug.Assert(fullmove_depth > 0);
if (fullmove_depth == 1)
{
nodes_generator.GenerateAllChildren(starting_node, 1);
// Release all children nodes except checkmate nodes
nodes_generator.ReleaseChildren(x =>
{
if (x.Position.IsInCheck)
{
nodes_generator.GenerateAllChildren(x, 1);
return !x.Position.IsCheckmate;
}
return true;
},
starting_node);
}
else
{
nodes_generator.GenerateAllChildren(starting_node, 2);
foreach (var my_move in starting_node.Children)
{
bool is_skip = false;
foreach (var her_move in my_move.Children)
{
if (!FindMateRecursive(her_move, nodes_generator,
fullmove_depth - 1))
{
// My opponent can avoid being checkmated
is_skip = true;
break;
}
}
if (is_skip)
{
nodes_generator.ReleaseChildren(my_move);
}
}
// Erase all children except checkmate nodes or move sequences
// that lead to a force mate
nodes_generator.ReleaseChildren(x =>
{
return !x.Position.IsCheckmate && x.Children == null;
},
starting_node);
}
return starting_node.Children != null;
}
public NetworkBuilder(INodeGenerator nodeGenerator, int nodeCount, double networkPower)
{
if (networkPower <= 0.0)
{
throw new ArgumentException("networkPower");
}
if (nodeCount <= 0)
{
throw new ArgumentException("nodeCount");
}
_nodeGenerator = nodeGenerator;
_nodeCount = nodeCount;
_networkPower = networkPower;
}
private INetworkHandler CreateNetwork()
{
var metropolitanNodesCount = int.Parse(MetropolitanNodesNumber.Text);
var metropolitanNetworksCount = int.Parse(MetropolitanNetworksCount.Text);
var networkPower = double.Parse(NetworkPower.Text);
_nodeGenerator = new NodeGenerator();
_nodeGenerator.ResetAccumulator();
_simpleNetworkBuilder = new NetworkBuilder(_nodeGenerator, metropolitanNodesCount, networkPower);
_networkBuilder = new WideAreaNetworkBuilder(_simpleNetworkBuilder, metropolitanNetworksCount);
var network = _networkBuilder.Build();
return(network);
}
public void Setup()
{
_nodeGenerator = new NodeGenerator();
}
