/// <summary>
/// Checks if node is still movable
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
protected Boolean IsValid(MoveNode from, MoveNode to)
{
// There was no previous node, so it's valid
if (from.Action == MoveNode.Type.None)
{
return(true);
}
// Already on the next node, so it's valid
if (from.Equals(to))
{
return(true);
}
// Look up if to is still a neighbour of from (pre-calc)
List <Node <MoveNode> > neighbours = null;
if (_neighbours.TryGetValue(from, out neighbours))
{
return(neighbours.Any(n => n.Value.Equals(to)));
}
// Fetch and look up
return(CreateMoveNodesFrom(new Node <MoveNode>()
{
Value = from
}).Any(n => n.Value.Equals(to)));
}
public void MoveLeft(int distance)
{
try {
Debug.Log(gameObject.name + ": Moving West");
//throw new System.NotImplementedException();
int x = currentNode.x;
int z = currentNode.z;
if (x <= 0)
{
Debug.Log("You hit the left! node_id= " + x + " z = " + z);
DestroyBullet();
EndPhase();
return;
}
MoveNode targetNode = nodes[x - distance, z];
//remove from currentNode
//add to targetNode
currentNode.RemoveFromNode(gameObject);
targetNode.AddToNode(gameObject);
StartCoroutine(MoveToNode(targetNode));
currentNode = targetNode;
} catch (NullReferenceException e) {
Console.WriteLine(e);
}
}
/// <summary>
/// Expand the tree out to our maximum depth, only expanding leaf nodes with the best-possible score
/// </summary>
/// <param name="maxDepth"></param>
public void Expand(int maxDepth)
{
NumLeaves = 0;
ConsideredBoardStates = new List <TakBoard>();
List <TakMove> nextMoves = PlayerAI.EnumerateMoves(MyColor, Root.InitialState);
foreach (TakMove m in nextMoves)
{
MoveNode n = new MoveNode(Root.InitialState, m);
if (!ConsideredBoardStates.Contains(n.ResultingState.Board))
{
ConsideredBoardStates.Add(n.ResultingState.Board);
n.Depth = 1;
n.Parent = null;
n.Score = n.ResultingState.Evaluate(MyColor);
Root.Children.Add(n);
}
}
// recursively expand the tree
MaxDepth = maxDepth;
foreach (MoveNode n in Root.Children)
{
n.Score = ABPrune(n, (double)int.MinValue - 1, (double)int.MaxValue + 1, true);
}
Root.Children.Sort();
PrintDebug(string.Format("Explored {0} board states", ConsideredBoardStates.Count));
PrintDebug(string.Format("Explored {0} leaves", NumLeaves));
}
public MovesTree()
{
root = new MoveNode();
lastAttackCombo = -1;
return;
}
public List <MoveNode> GetPossInRange(Vector2Int pos, int range, bool canMoveThroughUnits = true)
{
var possInRange = new List <MoveNode>();
var existingPoss = new Dictionary <Vector2Int, bool>();
var possToCheck = new List <MoveNode>();
var newPoss = new List <MoveNode>();
possToCheck.Add(new MoveNode(pos, null));
existingPoss[pos] = true;
for (int i = 0; i < range; i++)
{
foreach (var posToCheck in possToCheck)
{
foreach (var adjacentPos in GridUtils.GetAdjacentPoss(posToCheck.pos))
{
if (!existingPoss.ContainsKey(adjacentPos) && IsTileAt(adjacentPos) && (canMoveThroughUnits || !GetUnitAt(adjacentPos)))
{
existingPoss[adjacentPos] = true;
var newNode = new MoveNode(adjacentPos, posToCheck);
possInRange.Add(newNode);
newPoss.Add(newNode);
}
}
}
possToCheck = newPoss;
newPoss = new List <MoveNode>();
}
return(possInRange);
}
public Direction?GetTargetDirection(MoveNode node)
{
int x = currentNode.x;
int z = currentNode.z;
if (node.x == x && node.z == z + 1)
{
return(Direction.North);
}
else if (node.x == x && node.z == z - 1)
{
return(Direction.South);
}
else if (node.x == x + 1 && node.z == z)
{
return(Direction.East);
}
else if (node.x == x - 1 && node.z == z)
{
return(Direction.West);
}
else
{
return(null);
}
}
public List <Move> GetPath(int x, int y, int rot)
{
MoveNode node = field[x, y, rot];
if (!node.valid)
{
return(null);
}
List <Move> moves = new List <Move>();
bool skipping = true;
while (!node.root)
{
if (node.move != Move.SONIC_DROP)
{
skipping = false;
}
if (!skipping)
{
moves.Add(node.move);
}
node = field[node.parent.x, node.parent.y, node.parent.rot];
}
moves.Reverse();
return(moves);
}
public static MoveNode BuildMoveTree(BeamCoreState g, Vector2 curPos, Heading curHead, int depth, List <Vector2> otherBadPos = null)
{
Vector2 nextPos = UpcomingGridPoint(curPos, curHead);
MoveNode root = MoveNode.GenerateTree(g, nextPos, curHead, 1, otherBadPos);
return(root);
}
/// <summary>
/// Checks if we have debut answer for moves
/// </summary>
/// <param name="moves">List of all moves</param>
/// <returns>MoveIterator that points on certain node, or End iterator if there no answer</returns>
public MoveIterator CheckMoves(List<Move> moves)
{
//there no so long combinations in tree :(
if (moves.Count > 10)
return MoveIterator.End;
MoveNode temp = new MoveNode(moves[0]);
if (!rootMoves.ContainsKey(temp))
return MoveIterator.End;
MoveIterator iter = new MoveIterator(rootMoves[temp]);
for (int i = 1; i < moves.Count; ++i)
{
if (iter == MoveIterator.End)
break;
temp.Move = moves[i];
if (!iter.CurrentNode.Replies.ContainsKey(temp))
return MoveIterator.End;
iter.CurrentNode = iter.CurrentNode.Replies[temp];
}
return iter;
}
public void SpawnEnemy(int nodeX, int nodeZ, EnemyType type)
{
MoveNode node = Nodes[nodeX, nodeZ];
if (node.objectsOnNode.Count == 0)
{
GameObject enemy = (GameObject)Instantiate(EnemyTransforms[(int)type].gameObject);
int enemyX = nodeX;
int enemyZ = nodeZ;
enemy.GetComponent <EnemyMover>().currentNode = Nodes[enemyX, enemyZ];
EnemyController.totalEnemies++;
Nodes[enemyX, enemyZ].AddToNode(enemy);
EnemiesController.ec.Enemies.Add(enemy.GetComponent <EnemyController>());
enemy.transform.position = Nodes[enemyX, enemyZ].transform.position;
enemy.name = "Enemy " + EnemyController.totalEnemies;
foreach (Transform t in enemy.transform)
{
Renderer[] renderers = t.GetComponentsInChildren <Renderer>();
foreach (Renderer r in renderers)
{
r.enabled = false;
}
}
FallingSpawn fs = enemy.GetComponent <FallingSpawn>();
//StartCoroutine(fs.FallIntoPlace());
fs.FallIntoPlaceTweened();
}
else
{
Debug.Log("Node (" + nodeX + "," + nodeZ + ") full, can't spawn here!");
}
}
public void MoveDown(int distance)
{
try {
Debug.Log(gameObject.name + ": Moving South");
//throw new System.NotImplementedException();
int x = currentNode.x;
int z = currentNode.z;
if (z <= 0)
{
Debug.Log("You hit the bottom! node_id= " + x + " z = " + z);
_ec.EndPhase();
return;
}
MoveNode targetNode = nodes [x, z - distance];
//remove from currentNode
//add to targetNode
currentNode.RemoveFromNode(gameObject);
targetNode.AddToNode(gameObject);
MoveToNodeTweened(targetNode);
currentNode = targetNode;
} catch (NullReferenceException e) {
Console.WriteLine(e);
}
}
private Direction?GetDirectionToNode(MoveNode from, MoveNode to)
{
int deltaX = from.x - to.x;
int deltaZ = from.z - to.z;
if (Mathf.Abs(deltaX) > Mathf.Abs(deltaZ))
{
if (deltaX > 0) //enemy is east of node, must move west
{
return(Direction.West);
}
if (deltaX < 0)
{
return(Direction.East);
}
}
else if (Mathf.Abs(deltaZ) > Mathf.Abs(deltaX))
{
if (deltaZ > 0) //enemy is north of node, must move south
{
return(Direction.South);
}
if (deltaZ < 0)
{
return(Direction.North);
}
}
return(null);
}
public void MoveRight(int distance)
{
try {
Debug.Log(gameObject.name + ": Moving East");
//throw new System.NotImplementedException();
int x = currentNode.x;
int z = currentNode.z;
if (x >= nodes.GetUpperBound(0))
{
Debug.Log("You hit the right! node_id= " + x + " z = " + z);
_ec.EndPhase();
return;
}
MoveNode targetNode = nodes [x + distance, z];
//remove from currentNode
//add to targetNode
currentNode.RemoveFromNode(gameObject);
targetNode.AddToNode(gameObject);
MoveToNodeTweened(targetNode);
currentNode = targetNode;
} catch (NullReferenceException e) {
Console.WriteLine(e);
}
}
public void MoveUp(int distance)
{
try {
Debug.Log(gameObject.name + ": Moving North");
//throw new System.NotImplementedException();
int x = currentNode.x;
int z = currentNode.z;
if (z >= nodes.GetUpperBound(1)) //bust out early if you're at the top of the map
{
Debug.Log("You hit the top! node_id= " + x + " z = " + z);
_ec.EndPhase();
return;
}
MoveNode targetNode = nodes [x, z + distance];
//remove from currentNode
//add to targetNode
currentNode.RemoveFromNode(gameObject);
targetNode.AddToNode(gameObject);
MoveToNodeTweened(targetNode);
currentNode = targetNode;
} catch (NullReferenceException e) {
Console.WriteLine(e);
}
}
/// <summary>
/// 指し手行を出力します。
/// </summary>
private void WriteMakeKif(TextWriter writer, MoveNode node,
Board board, bool hasVariation)
{
var lmove = board.ConvertLiteralFromMove(node.Move, true);
if (lmove == null || !lmove.Validate())
{
Log.Error("指し手'{0}'を出力できませんでした。", node.Move);
return;
}
if (lmove.SpecialMoveType == SpecialMoveType.None)
{
// 半角文字相当の文字数で空白の数を計算します。
var moveText = Stringizer.ToString(lmove, MoveTextStyle.KifFile);
var hanLen = moveText.HankakuLength();
writer.WriteLine(
@"{0,4} {1}{2} ({3:mm\:ss} / {4:hh\:mm\:ss}){5}",
node.MoveCount,
moveText,
new string(' ', Math.Max(0, 14 - hanLen)),
node.Duration,
node.TotalDuration,
(hasVariation ? "+" : ""));
}
else
{
// とりあえず空にしておく
}
}
//HELPER METHODS
public MoveNode GetDistantNode(MoveNode currentNode, int newX, int newZ)
{
int thisX = currentNode.x;
int thisZ = currentNode.z;
return(Nodes[thisX + newX, thisZ + newZ]);
}
public void SpawnPhone(int nodeX, int nodeZ)
{
//Relies on the calling method having checked for a clear space
MoveNode node = Nodes[nodeX, nodeZ];
GameObject phone = Instantiate(PhoneTransform.gameObject);
int phoneX = nodeX;
int phoneZ = nodeZ;
phone.GetComponent <Phone>().currentNode = Nodes[phoneX, phoneZ];
PhoneController.pc.currentPhone = phone.GetComponent <Phone>();
Nodes[phoneX, phoneZ].AddToNode(phone);
phone.transform.position = Nodes[phoneX, phoneZ].transform.position;
foreach (Transform t in phone.transform)
{
Renderer[] renderers = t.GetComponentsInChildren <Renderer>();
foreach (Renderer r in renderers)
{
r.enabled = false;
}
}
FallingSpawn fs = phone.GetComponent <FallingSpawn>();
//StartCoroutine(fs.FallIntoPlace());
fs.FallIntoPlaceTweened();
}
/// <summary>
/// Adds all moves to Tree
/// </summary>
/// <param name="whitePos">Position of white figures on board</param>
/// <param name="moves">Pairs of moves and replies e.g. ("e2-e4", "e7-e5")</param>
public void AddMoves(PlayerPosition whitePos, params string[] moves)
{
Move temp = new Move(moves[0]);
MoveNode tempNode = new MoveNode(temp);
//iterator, that will add move to tree
MoveIterator pushingIterator = null;
MoveNode next = null;
if (!rootMoves.ContainsKey(tempNode))
{
rootMoves.Add(tempNode, tempNode);
next = rootMoves[tempNode].Add(new Move(moves[1]));
}
else
{
next = rootMoves[tempNode].Add(new Move(moves[1]));
}
pushingIterator = GetIterator(tempNode);
//next answer
pushingIterator.CurrentNode = next;
int i = 2;
while (i < moves.Length)
{
pushingIterator.CurrentNode = pushingIterator.CurrentNode.Add(moves[i], whitePos);
++i;
}
}
private Tuple<MoveNode, double> getChild(Square square)
{
instances++;
MoveNode node = new MoveNode(board, square, evaluator);
if (square.number == 2) return Tuple.Create(node, 0.9);
else return Tuple.Create(node, 0.1);
}
public MoveNode(int x, int y, double rank)
{
group = new Group(x, y, 0);
this.rank = rank;
ply = 0;
board = null;
previousMove = null;
}
public MoveNode()
{
group = new Group(0, 0, 0);
rank = 0;
ply = 0;
board = null;
previousMove = null;
}
public IEnumerator MoveUnit(Unit unit, MoveNode moveNode)
{
unitsByPos[unit.GetPosition()] = null;
yield return(StartCoroutine(unit.Move(moveNode)));
unitsByPos[unit.GetPosition()] = unit;
}
public MoveNode(Group m, double rank, int ply, Grid board, MoveNode last)
{
this.group = m;
this.rank = rank;
this.ply = ply;
this.board = board;
previousMove = last;
}
public void Clear()
{
// TODO: Dispose Moves
FirstMove = null;
NextMove = null;
MovesCount = 0;
StartingState.Clear();
}
public void FlagNewLOSNodes()
{
//unflag all nodes
foreach (MoveNode node in Nodes)
{
node.LOSToPlayer = false;
}
MoveNode currentNode = PlayerController.pc.Mover.currentNode;
//flag player's node
currentNode.LOSToPlayer = true;
//find LOS nodes in each direction
//Check North, stop at first obstacle
for (int i = currentNode.z; i < mapLength; i++)
{
MoveNode node = Nodes[currentNode.x, i];
if (node.blocksLOS)
{
break;
}
node.LOSToPlayer = true;
}
//Check South
for (int i = currentNode.z; i >= 0; i--)
{
MoveNode node = Nodes[currentNode.x, i];
if (node.blocksLOS)
{
break;
}
node.LOSToPlayer = true;
}
//Check East
for (int i = currentNode.x; i < mapWidth; i++)
{
MoveNode node = Nodes[i, currentNode.z];
if (node.blocksLOS)
{
break;
}
node.LOSToPlayer = true;
}
//Check West
for (int i = currentNode.x; i >= 0; i--)
{
MoveNode node = Nodes[i, currentNode.z];
if (node.blocksLOS)
{
break;
}
node.LOSToPlayer = true;
}
}
private void addIndex(SquareIndex index)
{
MoveNode endNode = nodeList[0];
nodeList.Add(instantiateMoveNode(moveNodePrefab, endNode.index, 10));
endNode.index = index;
endNode.gameObject.transform.localPosition = board.squareIndexToWorld(index);
}
public void TakeTurn(Piece[,] board, Piece[,] WhiteTaken, Piece[,] BlackTaken, int[] whiteTakenIndeces, int[] blackTakenIndeces, int depth)
{
topNode = new MoveNode(board);
think(depth, topNode);
bool mate = false;
AvailableMove move = selectMove(allMovesList, board, ref mate, currentColour);
if (!mate)
makeMove(move, board, WhiteTaken, BlackTaken, whiteTakenIndeces, blackTakenIndeces);
}
/// <summary>
/// CSA形式の指し手を出力します。
/// </summary>
private void WriteMoveNode(TextWriter writer, MoveNode node)
{
// 各指し手行を出力します。
for (node = node.NextNode; node != null; node = node.NextNode)
{
writer.WriteLine(node.Move.ToCsa());
writer.WriteLine("T" + node.DurationSeconds);
}
}
public SymmetryEnvironment(MoveNode.GradeNode lowestNode)
{
this.lowestNode = lowestNode;
config = lowestNode.MoveNode.config;
colorFalse = new bool[config.colors];
colorUsed = new bool[config.colors];
init();
}
private void Form1_Load(object sender, EventArgs e)
{
textBox3.Text = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory) + "\\New";
moveNode1 = new MoveNode(treeView1);
//RELOAD
Reload();
}
public void UnTagMovableNodes()
{
for (int i = 0; i < movableNodes.Count; i++)
{
MoveNode node = movableNodes[i];
MovableNode nodeController = node.transform.parent.GetComponentInChildren <MovableNode>();
nodeController.currentState = MovableNode.NodeState.Off;
node.movable = false;
}
movableNodes.Clear();
}
private void analysis()
{
Console.WriteLine("Starting Root Analysis...");
Type assessClass = typeof(MaxSizeAssessor);
Stopwatch st = Stopwatch.StartNew();
MoveNode mn = mm.runOneStepAheadAnalysis(assessClass);
Console.WriteLine("Time Taken: " + st.ElapsedMilliseconds + " ms");
printResultMove(mn);
gradePrompt();
}
/// <summary>
/// コメント行を出力します。
/// </summary>
private void WriteCommentKif(TextWriter writer, MoveNode node)
{
var commentList = node.Comment.Split(
new char[] { '\n' },
StringSplitOptions.RemoveEmptyEntries);
foreach (var comment in commentList)
{
writer.WriteLine("*{0}", comment);
}
}
/// <summary>
/// Instantiates a new move node
/// </summary>
/// <returns>The move node.</returns>
/// <param name="prefab">The prefab for the node (there could be different nodes).</param>
/// <param name="index">The index for the node.</param>
/// <param name="numMoves">Number of moves left to show on the node.</param>
private MoveNode instantiateMoveNode(GameObject prefab, SquareIndex index, int numMoves)
{
MoveNode moveNode = (GameObject.Instantiate(prefab) as GameObject).GetComponent <MoveNode>();
moveNode.init(numMoves, index);
moveNode.transform.parent = transform;
moveNode.transform.localPosition = board.squareIndexToWorld(index);
return(moveNode);
}
public virtual bool checkSymmetry(MoveNode move)
{
StringBuilder SymmetryString = new StringBuilder(config.pegs);
int UnusedNumber = 0;
bool anySymmetries = false;
bool allUnused = true;
int[] currentSet = move.SinglePegs;
for (int i = 0; i < currentSet.Length; i++) // loop through
{
// the currently
// tested move
int peg = currentSet[i]; // select a peg
if (!colorUsed[peg]) // if that color hasn't been used yet
{
// --> free color
anySymmetries = true;
for (int z = 0; z < i; z++) // check whether we already had
{
// that color marked unused
if (alphabet.Contains(SymmetryString[z] + "") && currentSet[z] == peg)
{
SymmetryString.Append(SymmetryString[z]);
goto pegLoopContinue;
}
}
SymmetryString.Append(alphabet[UnusedNumber]);
UnusedNumber++;
}
else if (colorFalse[peg])
{
SymmetryString.Append("z");
anySymmetries = true;
allUnused = false;
}
else
{
SymmetryString.Append(peg);
allUnused = false;
}
pegLoopContinue:;
}
if (anySymmetries)
{
string sym = SymmetryString.ToString();
if (!SymmetrySet.TryAdd(sym, 0))
return false;
if (allUnused)
{
permutation("", sym);
}
}
return true;
}
/// <summary>
/// CSA形式の指し手を出力します。
/// </summary>
private void WriteMoveNode(TextWriter writer, MoveNode node)
{
var csaList = KifuObject.Convert2List(node)
.Select(_ => _.ToCsa());
// 各指し手行を出力します。
foreach (var csa in csaList)
{
writer.WriteLine(csa);
}
}
//Set Active
public void SetActive(int n, MoveNode m)
{
if (n != active)
{
active = n;
currentNode = m;
if (active == 1)
{
Debug.Log("Follow Active");
}
}
}
/// <summary>
/// 指し手ツリーをリスト形式に変換します。
/// </summary>
public static IEnumerable<BoardMove> Convert2List(MoveNode root)
{
if (root == null)
{
throw new ArgumentNullException("root");
}
for (var node = root.NextNode; node != null; node = node.NextNode)
{
yield return node.Move;
}
}
public void UnTagShootableEnemies()
{
for (int i = 0; i < shootableEnemies.Count; i++)
{
EnemyController ec = shootableEnemies[i];
MoveNode node = ec.Mover.currentNode;
ec.shootable = false;
ShootableNode nodeController = node.transform.parent.GetComponentInChildren <ShootableNode>();
nodeController.currentState = ShootableNode.NodeState.Off;
}
shootableEnemies.Clear();
}
public void TagMovableNodes()
{
movableNodes = new List <MoveNode>();
MoveNode node = GetTargetNode(Direction.North, 1);
if (node != null)
{
if (!node.blocksMovement)
{
node.movable = true;
MovableNode nodeController = node.transform.parent.GetComponentInChildren <MovableNode>();
nodeController.currentState = MovableNode.NodeState.MovableUnselected;
movableNodes.Add(node);
}
}
node = GetTargetNode(Direction.South, 1);
if (node != null)
{
if (!node.blocksMovement)
{
node.movable = true;
MovableNode nodeController = node.transform.parent.GetComponentInChildren <MovableNode>();
nodeController.currentState = MovableNode.NodeState.MovableUnselected;
movableNodes.Add(node);
}
}
node = GetTargetNode(Direction.East, 1);
if (node != null)
{
if (!node.blocksMovement)
{
node.movable = true;
MovableNode nodeController = node.transform.parent.GetComponentInChildren <MovableNode>();
nodeController.currentState = MovableNode.NodeState.MovableUnselected;
movableNodes.Add(node);
}
}
node = GetTargetNode(Direction.West, 1);
if (node != null)
{
if (!node.blocksMovement)
{
node.movable = true;
MovableNode nodeController = node.transform.parent.GetComponentInChildren <MovableNode>();
nodeController.currentState = MovableNode.NodeState.MovableUnselected;
movableNodes.Add(node);
}
}
}
//Set Active
public void SetActive(int n, MoveNode m)
{
if (n != active)
{
active = n;
currentNode = m;
if (active == 1)
{
Debug.Log("Return Active");
targetNode = p.getCurrrentNode();
}
}
}
public MoveNode[] expandNodes(Grid board, MoveNode last, int ply)
{
List<MoveNode> nodes = new List<MoveNode>();
List<Group> moves = board.calculateGroups();
foreach(Group move in moves)
{
Grid b = board.copy();
if (b.checkMove(move.X, move.Y))
{
b.removeGroup(move.X, move.Y);
b.compressGrid();
nodes.Add(new MoveNode(move, rankGrid(b), ply, b, last));
}
}
return nodes.ToArray();
}
public Direction getDirection(GameBoard board)
{
Stopwatch timer = Stopwatch.StartNew();
int level = 0;
rootNode = new MoveNode(board, evaluator);
List<GameNode> bottomNodes = new List<GameNode>();
bottomNodes.Add(rootNode);
while (timer.ElapsedMilliseconds < moveTimeInMs)
{
level++;
List<GameNode> newNodes = new List<GameNode>();
foreach (GameNode node in bottomNodes)
{
node.calculateChildren();
newNodes.AddRange(node.getChildren());
}
bottomNodes = newNodes;
}
Console.WriteLine(level);
return rootNode.bestDirection();
}
/// <summary>
/// 指し手リストをツリー形式に変換します。
/// </summary>
public static MoveNode Convert2Node(IEnumerable<BoardMove> moveList,
int firstMoveCount)
{
if (moveList == null)
{
throw new ArgumentNullException("moveList");
}
var root = new MoveNode();
var last = root;
foreach (var move in moveList)
{
var node = new MoveNode()
{
MoveCount = firstMoveCount++,
Move = move,
};
last.NextNodes.Add(node);
last = node;
}
return root;
}
/// <summary>
/// 次の指し手ノードを追加します。
/// </summary>
public void AddNext(MoveNode node)
{
if (node == null)
{
throw new ArgumentNullException("node");
}
if (node.ParentNode != null)
{
throw new InvalidOperationException(
"すでに親ノードが登録されています。");
}
NextNodes.Add(node);
node.ParentNode = this;
}
/// <summary>
/// コンストラクタ
/// </summary>
public KifuObject(KifuHeader header,
Board startBoard,
MoveNode root, Exception error = null)
{
Error = error;
SetHeader(header);
SetBoard(startBoard, true);
SetRootNode(root);
}
public MoveIterator(MoveIterator from)
{
if (from == MoveIterator.End)
return;
iter = new MoveNode(from.iter);
prev = new MoveIterator(from.prev);
}
/// <summary>
/// 変化ツリーのルートノードを設定します。
/// </summary>
public void SetRootNode(MoveNode root)
{
if (root == null)
{
throw new ArgumentNullException("root");
}
RootNode = root;
MoveList = Convert2List(root).ToList();
}
/// <summary>
/// コンストラクタ
/// </summary>
public KifuObject(KifuHeader header,
Board startBoard,
Exception error = null)
{
MoveList = new List<BoardMove>();
RootNode = new MoveNode();
Error = error;
SetHeader(header);
SetBoard(startBoard, false);
}
private double evaluateChildren(MoveNode currentNode, int depth)
{
List<double> ratings = new List<double>();
foreach (MoveNode child in currentNode.Children)
ratings.Add(child.Move.Rating);
if (depth % 2 == 1)
return ratings.Min();
else
return ratings.Max();
}
/// <summary>
/// ノード全体を比較します。
/// </summary>
public bool NodeEquals(MoveNode other, bool compareComment)
{
if (ReferenceEquals(other, null))
{
return false;
}
if (MoveCount != other.MoveCount)
{
return false;
}
if (Move != other.Move)
{
return false;
}
if (Duration != other.Duration)
{
return false;
}
if (NextNodeCount != other.NextNodeCount)
{
return false;
}
if (compareComment && Comment != other.Comment)
{
return false;
}
for (var i = 0; i < NextNodeCount; ++i)
{
if (!NextNodes[i].NodeEquals(other.NextNodes[i], compareComment))
{
return false;
}
}
return true;
}
public MoveIterator(MoveNode node, MoveIterator prevIter)
{
iter = node;
prev = prevIter;
}
/// <summary>
/// KifMoveNodeからMoveNodeへ構造を変換します。
/// </summary>
public MoveNode ConvertToMoveNode(Board board, KifMoveNode head,
out Exception error)
{
var errors = new List<Exception>();
var root = new MoveNode
{
MoveCount = head.MoveCount,
Duration = head.Duration,
Comment = head.Comment,
};
// これでrootの子要素に指し手ツリーが設定されます。
ConvertToMoveNode(board, root, errors);
error = (
!errors.Any() ? null :
errors.Count() == 1 ? errors.FirstOrDefault() :
new AggregateException(errors));
return root;
}
public MoveNode(MoveNode from)
{
if ((object)from == null)
{
currentMove = null;
replies = new Dictionary<MoveNode, MoveNode>();
}
else
{
currentMove = new Move(from.currentMove);
replies = new Dictionary<MoveNode, MoveNode>(from.replies);
}
}
/// <summary>
/// Adds reply to certain move in moves map
/// </summary>
/// <param name="moveReply">Move-reply to add</param>
/// <returns>Move node, that points to added move</returns>
public MoveNode Add(Move moveReply)
{
MoveNode temp = new MoveNode(moveReply);
if (!replies.ContainsKey(temp))
replies.Add(temp, temp);
return replies[temp];
}
MoveNode GetMover()
{
if (this.mover == null) {
switch (dir) {
case NudgeDirection.Up:
this.mover = GetNudgeUp();
break;
case NudgeDirection.Down:
this.mover = GetNudgeDown();
break;
case NudgeDirection.Left:
this.mover = GetNudgeLeft();
break;
case NudgeDirection.Right:
this.mover = GetNudgeRight();
break;
}
}
return this.mover;
}
/// <summary>
/// Adds reply to certain move in moves map
/// </summary>
/// <param name="moveReply">Move, represented by System.String</param>
/// <param name="whitePos">Position of White figures on board</param>
/// <returns>Move node, that points to added move</returns>
public MoveNode Add(string moveReply, PlayerPosition whitePos)
{
MoveNode tempNode = new MoveNode(moveReply, whitePos);
if (!replies.ContainsKey(tempNode))
replies.Add(tempNode, tempNode);
return replies[tempNode];
}
private void think(int depth, MoveNode currentNode)
{
//get piece list for whoever is moving
if (depth % 2 == 0)
updatePieceList(pieceList, currentNode.Board, currentColour);
else
updatePieceList(pieceList, currentNode.Board, uf.OtherColour(currentColour));
//get list of moveable pieces
updateMoveList(pieceList, currentNode.Board);
//make each move and add it to the tree
foreach (AvailableMove move in allMovesList)
{
Piece[,] tmpBoard = makeTheoreticalMove(move, currentNode.Board);
move.Rating = evaluateBoard(tmpBoard, currentColour);
currentNode.AddChildren(currentNode, move, tmpBoard);
}
if (depth < depthOfThought)
foreach (MoveNode nextNode in currentNode.Children)
{
think(depth + 1, nextNode);
currentNode.Move.Rating = evaluateChildren(currentNode, depth);
}
if (depth == 0)
{
allMovesList.Clear();
foreach (MoveNode child in currentNode.Children)
allMovesList.Add(child.Move);
}
}
/// <summary>
/// KifMoveNodeからMoveNodeへ構造を変換します。
/// 結果は<paramref name="root"/>以下に設定されます。
/// </summary>
private void ConvertToMoveNode(Board board, MoveNode root,
List<Exception> errors)
{
for (var node = this; node != null; node = node.Variation)
{
var cloned = board.Clone();
// 指し手を実際に指してみます。
var bmove = node.MakeMove(cloned, errors);
if (bmove == null)
{
continue;
}
var moveNode = new MoveNode
{
Move = bmove,
MoveCount = node.MoveCount,
Duration = node.Duration,
Comment = node.Comment,
};
// 次の指し手とその変化を変換します。
if (node.Next != null)
{
node.Next.ConvertToMoveNode(cloned, moveNode, errors);
}
root.AddNext(moveNode);
}
}
/// <summary>
/// KifMoveNodeからMoveNodeへ構造を変換します。
/// </summary>
public MoveNode ConvertToMoveNode(Board board, out Exception error)
{
var root = new MoveNode();
var errors = new List<Exception>();
ConvertToMoveNode(board, root, errors);
error = (
!errors.Any() ? null :
errors.Count() == 1 ? errors.FirstOrDefault() :
new AggregateException(errors));
return root;
}
