/// <summary>
/// Checks if there is a mine at the specified coordinates.
/// </summary>
/// <param name="chosenRow">The chosen row.</param>
/// <param name="chosenColumn">The chosen column.</param>
public void CheckCoordinates(int chosenRow, int chosenColumn)
{
try
{
BoardStatus boardStatus = this.board.OpenField(chosenRow, chosenColumn);
if (boardStatus == BoardStatus.SteppedOnAMine)
{
int score = this.board.CountOpenedFields();
this.EndGame(
string.Format(
"Booooom! You were killed by a mine. You revealed" + " {0} cells without mines.", score));
this.RestartGame();
}
else if (boardStatus == BoardStatus.FieldAlreadyOpened)
{
this.gameRenderer.DisplayMessage("That field has already been opened!");
}
else if (boardStatus == BoardStatus.AllFieldsAreOpened)
{
this.EndGame("Congratulations! You win!!");
this.RestartGame();
}
else
{
this.gameRenderer.DrawBoard(this.board);
}
}
catch (IndexOutOfRangeException)
{
this.gameRenderer.DisplayError("The row and column entered must be within the playing field!");
}
}
private PirateTactics AssignTargets(IPirateGame game, BoardStatus status)
{
PirateTactics tactics = new PirateTactics()
{
Pirate = status.Pirate
};
tactics.Moves = game.GetActionsPerTurn();
if (status.Script != null)
{
tactics.FinalDestination = status.Script.Location;
}
else if (!tactics.Pirate.HasTreasure)
{
tactics.FinalDestination = status.Treasure.Location;
}
else
{
tactics.Moves = 1;
tactics.FinalDestination = status.Pirate.InitialLocation;
}
List <Location> possibleLocations = game.GetSailOptions(tactics.Pirate, tactics.FinalDestination, tactics.Moves);
List <Location> safeLocations = GetSafeLocations(game, possibleLocations);
if (safeLocations.Count > 0)
{
tactics.TempDestination = safeLocations[0];
}
return(tactics);
}
public void DoTurn(IPirateGame game)
{
BoardStatus status = GetBoardStatus(game);
PirateTactics tactics = AssignTargets(game, status);
TakeAction(game, tactics);
}
// Use this for initialization
void Start()
{
//pageOrg = gameObject.transform.parent.GetComponent<PageOrganizer>();
worldCursor = GameObject.Find("Cursor101").GetComponent <WorldCursor>();
// Noteboard events
contextGrid = canvasContextContent.GetComponent <HorizontalLayoutGroup>();
canvasContextContent.SetActive(false);
// Set the not-init state
boardStatus = BoardStatus.NOT_INIT;
BoardBorder.SetActive(false);
PanelBackground.SetActive(false);
CanvasMenu.SetActive(false);
// Set board-tag info
boardHintText = CanvasBoardInfo.GetComponentInChildren <Text>();
boardImgMove = GameObject.Find("Image-Move");
boardImgSave = GameObject.Find("Image-Save");
boardTagBorder = GameObject.Find("Panel-TagBorder");
boardCollider = panelBoardObj.GetComponent <BoxCollider>();
resizeBtnObj = GameObject.Find("BtnResize");
// DEBUG MODE
boardHintText.text = "";
boardImgMove.SetActive(false);
boardImgSave.SetActive(false);
boardTagBorder.SetActive(false);
panelBoardObj.SetActive(false);
}
public void TestOpenFieldWhenOpenLastClosed()
{
int rows = 2;
int columns = 2;
Field[,] fixedFields = new Field[rows, columns];
fixedFields[0, 0] = new Field();
fixedFields[0, 0].Status = FieldStatus.Closed;
fixedFields[0, 1] = new Field();
fixedFields[0, 1].Status = FieldStatus.IsAMine;
fixedFields[1, 0] = new Field();
fixedFields[1, 0].Status = FieldStatus.Opened;
fixedFields[1, 1] = new Field();
fixedFields[1, 1].Status = FieldStatus.Opened;
Board board = new Board(rows, columns, 1);
Type type = typeof(Board);
var fieldValue = type.GetField("fields", BindingFlags.Instance | BindingFlags.NonPublic);
fieldValue.SetValue(board, fixedFields);
BoardStatus expected = BoardStatus.AllFieldsAreOpened;
BoardStatus actual = board.OpenField(0, 0);
Assert.AreEqual(
expected,
actual,
string.Format("The BoardStatus is {0}, but must be {1}!", actual, expected));
}
public void TapOnBoardTag()
{
if (boardStatus == BoardStatus.MOVING)
{
//BoardBorder.SetActive(false);
panelBoardObj.SetActive(true);
boardImgMove.SetActive(false);
// Tap to confirm the positioning and resizing
gameObject.transform.position = topLeftObj.transform.position;
gameObject.transform.rotation = topLeftObj.transform.rotation;
gameObject.transform.Rotate(Vector3.left, 180);
gameObject.transform.localEulerAngles = GetStableAngle(gameObject.transform.localEulerAngles);
AdaptBoardSize(currBoardWidth, currBoardHeight);
// zoom out the menu and contents.
StartCoroutine(ResumeBoard());
avgNoteHeight = currBoardHeight * 0.3f;
notePadding = currBoardWidth * NotePaddingScale;
// TODO: resize the font on the menu.
boardStatus = BoardStatus.COMPLETE;
Debug.Log("Tap to transfer to COMPLETE.");
}
else if (boardStatus == BoardStatus.ARCHIVE_READY)
{
// Play an archive animation.
boardImgSave.SetActive(false);
StartCoroutine(ArchiveBoard());
Debug.Log("Tap to archive the content, transfer to NOT_INIT");
}
}
public Board(IBoardStatus boardStatus,
IRobotStatus robotStatus,
IActionsManager actionManager,
IUIBoardManager uiManager,
ILogger logger)
{
BoardStatus = boardStatus ?? throw new ArgumentNullException(nameof(boardStatus));
RobotStatus = robotStatus ?? throw new ArgumentNullException(nameof(robotStatus));
ActionManager = actionManager ?? throw new ArgumentNullException(nameof(actionManager));
UIManager = uiManager ?? throw new ArgumentNullException(nameof(uiManager));
Logger = logger ?? throw new ArgumentNullException(nameof(logger));
InitializeComponent();
BoardStatus.Update(boardPanelWidth: BoardPanel.Width,
boardPanelHeight: BoardPanel.Height,
roboPanelWidth: RoboPanel.Width,
boardPanel: BoardPanel);
List <Bitmap> imgs = GetImageResources();
RobotStatus.Update(isPlaced: false,
robotPanel: RoboPanel,
imgs: imgs);
Logger.Update(logTextBox: LogTextBox);
}
private BoardStatus CheckBlock(int square)
{
BoardStatus status = BoardStatus.Solved;
Span <bool> foundNumbers = stackalloc bool[size + 1];
int blockRow = square / blocks;
int blockColumn = square % blocks;
for (int i = 0; i < blocks; i++)
{
for (int j = 0; j < blocks; j++)
{
int n = board[blockRow * blocks + i, blockColumn *blocks + j];
if ((n < 1) || (n > size))
{
status = BoardStatus.Unknown;
}
else if (foundNumbers[n])
{
return(BoardStatus.Unsolvable);
}
else
{
foundNumbers[n] = true;
}
}
}
return(status);
}
public BoardPosition GetMovePosition()
{
BoardPosition position = RobotStatus.GetPosition();
BoardPosition pos = null;
if (position != null)
{
Tuple <int, char> moveInfo = GetMoveInfo(position.Direction);
int blockSize = BoardStatus.GetBlockSize();
int offset = BoardStatus.GetOffset();
int boardHeight = BoardStatus.GetBoardDimension().Height;
pos = position.Clone();
switch (moveInfo.Item2)
{
case 'X':
int XBlock = position.XBlock + moveInfo.Item1;
int xBlock = (position.XBlock - 1) + moveInfo.Item1;
pos.XBlock = XBlock;
pos.X = (xBlock * blockSize) + offset;
break;
case 'Y':
int YBlock = position.YBlock + moveInfo.Item1;
pos.YBlock = YBlock;
pos.Y = boardHeight - (YBlock * blockSize) + offset;
break;
}
Directions dir = (Directions)Enum.Parse(typeof(Directions), GetDirectionName(position.Direction));
RobotStatus.SetDirectionOrigin((char)dir);
}
return(pos);
}
// Do not alter/remove this method signature
public List <Command> GetCommands(BoardStatus status)
{
_status = status;
_commands = new List <Command>
{
//if its the first round build a miner otherwise try to build an attacker
status.Round == 1
? new BuildLesserMinionCommand(1, 1, 1, 4, 2, 1, status.YourBase.X + 1, status.YourBase.Y - 1)
: new BuildLesserMinionCommand(3, 2, 1, 1, 2, 1, status.YourBase.X + 1, status.YourBase.Y - 1)
};
AssignMinionRoles(status);
GoMining(_miners);
if (status.Vision.EnemyBases.Any())
{
MoveAndDestroy();
}
else
{
MoveAround(_attackers);
}
return(_commands);
}
public static BoardPosition GetBestMove(BoardStatus who, Board board)
{
int score = 0;
total = 0; calculate = 0;
var cache = new Dictionary <int, int>();
var boardPosition = GetBestMove(who, board, 4, cache, out score);
if (boardPosition.i == 0 && boardPosition.j == 0 && score == 0)
{
boardPosition.i = 7;
boardPosition.j = 7;
if (who == BoardStatus.Black)
{
return(boardPosition);
}
else
{
var random = new Random();
boardPosition.i += random.Next(-1, 1);
boardPosition.j += boardPosition.i == 7 ? random.Next(1, 2) * 2 - 3 : random.Next(-1, 1);
return(boardPosition);
}
}
Debug.Print(string.Format("Total: {0} Skip:{1} Rate:{2} Score:{3}",
total, (total - calculate), (total - calculate) * 1.0 / total, score));
return(boardPosition);
}
public AppStateMachine(GlobalInfo globalInfo, AudioAnalyzerForm audioAnalyzerForm)
{
_boardStatus = BoardStatus.Disconnect;
_analyzeStatus = AnalyzeStatus.Idle;
this._globalInfo = globalInfo;
this._audioAnalyzerForm = audioAnalyzerForm;
this._taskRunning = false;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="before">The before status</param>
/// <param name="from">The starting square</param>
/// <param name="to">The ending square</param>
/// <param name="actor"></param>
internal Move(BoardStatus before, int @from, int to, IPiece actor)
{
this.before = before;
after = before;// the after board status is initialized with the before status
this.from = from;
this.to = to;
Actor = actor;
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
BoardStatus boardStatus = await db.BoardStatus.FindAsync(id);
db.BoardStatus.Remove(boardStatus);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public void onPlayerMove(object msg, ConnectedPlayer p)
{
if (p != currentPlayer() || gameOver)
{
return;
}
//Parse msg
string words = Convert.ToString(msg);
int[] move = new int[4];
int[] start = new int[2];
int[] target = new int[2];
try{
start = new int[] { int.Parse(words[0].ToString()), int.Parse(words [1].ToString()) };
target = new int[] { int.Parse(words[2].ToString()), int.Parse(words [3].ToString()) };
}catch (Exception e) {
print("Corrupt incoming msg: " + Convert.ToString(msg));
protocol.requestMove(currentPlayer().peerID, theGame.ToString());
return;
}
//Check if Valid move
Move playedMove = MoveHandler.isValidMove(theGame, p.color == Game.PlayerColor.White, start, target);
if (playedMove == null)
{
print("Not valid Move: " + Convert.ToString(msg));
protocol.requestMove(currentPlayer().peerID, theGame.ToString());
return;
}
//Play move & Broadcast
theGame = theGame.playMove(playedMove);
RPCMove rpcMove = new RPCMove(start, target, p.color);
foreach (ConnectedPlayer pl in players)
{
protocol.sendRPCMove(pl.peerID, rpcMove);
}
//Check if gameOver
nextPlayer();
BoardStatus status = MoveHandler.getGameState(theGame, currentPlayer().color == Game.PlayerColor.White);
if (status != BoardStatus.normal)
{
gameOver = true;
Game.PlayerColor winColor;
winColor = status == BoardStatus.draw ? Game.PlayerColor.None : p.color;
broadcastGameOver(winColor);
}
else
{
protocol.requestMove(currentPlayer().peerID, theGame.ToString());
}
}
private void Initialize()
{
_board.Children.Clear();
PaintGridLine();
PaintDots();
_currentPlayer = BoardStatus.Black;
_boardModel = new Board();
_isEnd = false;
}
private int JumpCount(BoardStatus who, int i, int j, int count, int emptyCount)
{
var result = 0;
result += JumpExpand(who, i, j, 1, 0, emptyCount, count);
result += JumpExpand(who, i, j, 0, 1, emptyCount, count);
result += JumpExpand(who, i, j, 1, 1, emptyCount, count);
result += JumpExpand(who, i, j, 1, -1, emptyCount, count);
return(result);
}
public virtual void UduinoFound()
{
boardStatus = BoardStatus.Found;
#if UNITY_EDITOR
if (Application.isPlaying)
{
EditorUtility.SetDirty(UduinoManager.Instance);
}
#endif
}
public async Task <ActionResult> Edit([Bind(Include = "BoardStatusId,Name")] BoardStatus boardStatus)
{
if (ModelState.IsValid)
{
db.Entry(boardStatus).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(boardStatus));
}
public virtual void Close()
{
if (boardStatus != BoardStatus.Closed && OnBoardClosed != null)
{
OnBoardClosed();
OnBoardClosed = null;
}
ClearQueues();
boardStatus = BoardStatus.Closed;
}
public async Task <ActionResult> Create([Bind(Include = "BoardStatusId,Name")] BoardStatus boardStatus)
{
if (ModelState.IsValid)
{
db.BoardStatus.Add(boardStatus);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(boardStatus));
}
public void TestOpenFieldWhenMine()
{
Board board = new Board(1, 1, 1);
BoardStatus expected = BoardStatus.SteppedOnAMine;
BoardStatus actual = board.OpenField(0, 0);
Assert.AreEqual(
expected,
actual,
string.Format("The BoardStatus is {0}, but must be {1}!", actual, expected));
}
private IEnumerator ArchiveBoard()
{
for (float i = 1.0f; i > 0; i -= Time.deltaTime)
{
gameObject.transform.localScale = Vector3.one * i;
yield return(null);
}
// Hide menu
CanvasMenu.SetActive(false);
PanelBackground.SetActive(false);
boardHintText.text = "";
boardStatus = BoardStatus.NOT_INIT;
}
/// <summary>
/// Don't call this method if the board is not scary enough for bluffing
/// or the position/number of alive players doesn't allow a bluffing play
/// Check those condition prior to calling this method.
/// </summary>
/// <param name="boardStatus"></param>
/// <param name="heroHoles"></param>
/// <param name="villainHoles"></param>
/// <returns></returns>
public bool CanBluff(BoardStatus boardStatus, HoldingHoles heroHoles, HoldingHoles villainHoles)
{
if (BettingUtils.CompareHoles(heroHoles, villainHoles, boardStatus) > 0)
{
//It's not a bluff bet with a better hand than villain's
return(false);
}
var heroRange = BettingUtils.GetVillainGuessOnHeroRange();
var villainEquity = _equityCalculator.CalculateEquityAgainstARange(villainHoles, heroRange, boardStatus);
return(BettingUtils.VillainIsWillingToCall(villainEquity, _potOddsToBluff) == false);
}
public bool CanBetForValue(BoardStatus boardStatus, HoldingHoles heroHoles, HoldingHoles villainHoles)
{
if (BettingUtils.CompareHoles(heroHoles, villainHoles, boardStatus) <= 0)
{
//It's not a value bet if hero's hand is worse than villain's
return(false);
}
var heroRange = BettingUtils.GetVillainGuessOnHeroRange();
var villainEquity = _equityCalculator.CalculateEquityAgainstARange(villainHoles, heroRange, boardStatus);
return(BettingUtils.VillainIsWillingToCall(villainEquity, _potOddsToBet) == true);
}
// GET: BoardStatus/Delete/5
public async Task <ActionResult> Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
BoardStatus boardStatus = await db.BoardStatus.FindAsync(id);
if (boardStatus == null)
{
return(HttpNotFound());
}
return(View(boardStatus));
}
private int NormalCount(BoardStatus who, int i, int j, int number, int emptyCount)
{
int result = 0;
// from left to right
result += DirectExpand(who, i, j, 1, 0, emptyCount, number);
// from up to down
result += DirectExpand(who, i, j, 0, 1, emptyCount, number);
// from left-up to down-right
result += DirectExpand(who, i, j, 1, 1, emptyCount, number);
// from left-down to up-right
result += DirectExpand(who, i, j, 1, -1, emptyCount, number);
return(result);
}
public List <InputHandler.MoveDirection> Solve()
{
List <LevelSolver> visited = new List <LevelSolver>();
List <BoardStatus> queue = new List <BoardStatus>();
foreach (InputHandler.MoveDirection move in Enum.GetValues(typeof(InputHandler.MoveDirection)))
{
queue.Add(
new BoardStatus
{
moves = new List <InputHandler.MoveDirection>(new InputHandler.MoveDirection[] { move }),
board = Clone().Move(move)
});
}
while (queue.Count > 0)
{
BoardStatus bs = queue[0];
queue.RemoveAt(0);
visited.Add(bs.board);
if (bs.board.IsSolution())
{
return(bs.moves);
}
if (bs.moves.Count < MaxSteps)
{
foreach (InputHandler.MoveDirection move in Enum.GetValues(typeof(InputHandler.MoveDirection)))
{
LevelSolver n = bs.board.Clone().Move(move);
if (!visited.Exists(b => b.EqualsTo(n)) && !queue.Exists(b => b.board.EqualsTo(n)))
{
List <InputHandler.MoveDirection> m = new List <InputHandler.MoveDirection>(bs.moves.ToArray());
m.Add(move);
queue.Add(
new BoardStatus
{
moves = m,
board = n
}
);
}
}
}
}
return(new List <InputHandler.MoveDirection>());
}
public virtual void Close()
{
if (boardStatus != BoardStatus.Closed && OnBoardClosed != null)
{
OnBoardClosed();
OnBoardClosed = null;
}
ClearQueues();
boardStatus = BoardStatus.Closed;
if (_connection != null)
{
_connection.Disconnect();
}
}
public BoardSpectrum MakeSpectrum(BoardStatus boardStatus)
{
var allCards = TexasBot.Tools.Utils.GenerateAllCards().Select(c => c.ConvertCard()).ToList();
allCards.RemoveElementEqualsTo(boardStatus.Flop1);
allCards.RemoveElementEqualsTo(boardStatus.Flop2);
allCards.RemoveElementEqualsTo(boardStatus.Flop3);
if (boardStatus.Turn != null)
{
allCards.RemoveElementEqualsTo(boardStatus.Turn);
}
if (boardStatus.River != null)
{
allCards.RemoveElementEqualsTo(boardStatus.River);
}
var enumeratedTwoCards = TexasBot.Tools.Utils.Enumerate(allCards.ToArray(), 0, 2);
var holdingHands = new List <HoldingHoles>();
foreach (var twoCards in enumeratedTwoCards)
{
var twoCardsList = twoCards.ToList();
holdingHands.Add(new HoldingHoles(twoCardsList[0], twoCardsList[1]));
}
var spectrumDict = new Dictionary <BoardHandTypeEnum, List <HoldingHoles> >();
foreach (var holes in holdingHands)
{
var boardHand = _handDetector.DetectBoardHand(boardStatus, holes);
if (!spectrumDict.ContainsKey(boardHand))
{
spectrumDict.Add(boardHand, new List <HoldingHoles>());
}
spectrumDict[boardHand].Add(holes);
}
var spectrumUnitList = new List <BoardSpectrumUnit>();
foreach (var entry in spectrumDict)
{
spectrumUnitList.Add(new BoardSpectrumUnit(entry.Key, entry.Value));
}
spectrumUnitList.Sort((u1, u2) => - u1.CompareTo(u2));
return(new BoardSpectrum(spectrumUnitList));
}
public List<BoardStatus> promotePawn(ChessPiece color, int i, int j)
{
List<BoardStatus> result = new List<BoardStatus>();
string code = BoardManager.statusIndexesToCode(i, j);
switch (color)
{
case ChessPiece.WHITE:
if (i == 7)
{
BoardStatus st = new BoardStatus(this);
st.Status[code] = ChessPiece.WHITE_BISHOP;
result.Add(st);
st = new BoardStatus(this);
st.Status[code] = ChessPiece.WHITE_KNIGHT;
result.Add(st);
st = new BoardStatus(this);
st.Status[code] = ChessPiece.WHITE_QUEEN;
result.Add(st);
st = new BoardStatus(this);
st.Status[code] = ChessPiece.WHITE_ROOK;
result.Add(st);
}
break;
case ChessPiece.BLACK:
if (i == 1)
{
BoardStatus st = new BoardStatus(this);
st.Status[code] = ChessPiece.BLACK_BISHOP;
result.Add(st);
st = new BoardStatus(this);
st.Status[code] = ChessPiece.BLACK_KNIGHT;
result.Add(st);
st = new BoardStatus(this);
st.Status[code] = ChessPiece.BLACK_QUEEN;
result.Add(st);
st = new BoardStatus(this);
st.Status[code] = ChessPiece.BLACK_ROOK;
result.Add(st);
}
break;
}
return result;
}
/// <summary>
/// Copy constructor
/// </summary>
/// <param name="status">Status to copy</param>
public BoardStatus(BoardStatus status)
{
m_status = new Dictionary<string, ChessPiece>();
foreach (string key in status.m_status.Keys)
{
m_status.Add(key, status.m_status[key]);
}
m_whitePiecesPosition = new List<string>();
m_whitePiecesPosition.AddRange(status.m_whitePiecesPosition);
m_blackPiecesPosition = new List<string>();
m_blackPiecesPosition.AddRange(status.m_blackPiecesPosition);
m_ID = NextID;
}
/// <summary>
/// Returns all the BoardStatus that can be originated from this BoardStatus
/// given a color to move
/// </summary>
/// <param name="color">Color to move</param>
public List<BoardStatus> getAllBoardMovements(ChessPiece color)
{
List<BoardStatus> result = new List<BoardStatus>();
//if (m_boardCache.ContainsKey(m_ID) && m_boardCache[m_ID].ContainsKey(color))
//{
// //Debug.LogWarning(m_ID + " estaba cacheado");
// result = m_boardCache[m_ID][color];
// //foreach (BoardStatus st in result)
// //{
// // Movement m = this.getMovementDifference(color, st);
// // Debug.Log(st.ID + " Origin: " + m.Origin + " Dest: " + m.Destination + " Piece: " + m.PieceMoved);
// //}
//}
//else
//{
List<string> piecesToMove = color == ChessPiece.WHITE ? WhitePieces : BlackPieces;
foreach (string tile in piecesToMove)
{
ChessPiece piece = m_status[tile];
HashSet<string> movements = getAllPieceMovements(piece, tile);
foreach (string movement in movements)
{
BoardStatus newBoard = new BoardStatus(this);
newBoard.movePieceToDestination(tile, movement);
if (!newBoard.Check(color))
{
result.Add(newBoard);
}
}
}
//Pawn promotion.
//int i = color == ChessPiece.WHITE ? 7 : 1;
//string code = "";
//for (int j = 0; j < 8; ++j)
//{
// code = BoardManager.statusIndexesToCode(i, j);
// if ((color == ChessPiece.WHITE && Status[code] == ChessPiece.WHITE_PAWN) || (color == ChessPiece.BLACK && Status[code] == ChessPiece.BLACK_PAWN))
// {
// result.AddRange(promotePawn(color, i, j));
// }
//}
//if (m_boardCache.ContainsKey(m_ID))
//{
// m_boardCache[m_ID].Add(color, result);
//}
//else
//{
// Dictionary<ChessPiece, List<BoardStatus>> cache = new Dictionary<ChessPiece, List<BoardStatus>>();
// cache.Add(color, result);
// m_boardCache.Add(m_ID, cache);
//}
//}
return result;
}
/// <summary>
/// Returns the movement difference between to chess boards.
///
/// ***IMPORTANT*** Only works with a board that has 1 movement of difference.
/// Other boards will return bad results
/// </summary>
/// <param name="color">Color of the pieces that had been moved</param>
/// <param name="destinationBoard">Destination Board to check</param>
/// <returns>KeyValuePair with this structure: (Piece, (origin, destination))</returns>
public Movement getMovementDifference(ChessPiece color, BoardStatus destinationBoard)
{
List<string> colorPieces = color == ChessPiece.WHITE ? WhitePieces : BlackPieces;
List<string> otherColorPieces = color == ChessPiece.WHITE ? destinationBoard.WhitePieces : destinationBoard.BlackPieces;
string origin = "";
string destination = "";
foreach (string myPiece in colorPieces)
{
if (!otherColorPieces.Contains(myPiece))
{
origin = myPiece;
break;
}
}
foreach (string otherPiece in otherColorPieces)
{
if (!colorPieces.Contains(otherPiece))
{
destination = otherPiece;
break;
}
}
ChessPiece pieceMoved = m_status[origin];
return new Movement(origin, destination, pieceMoved);
}
/// <summary>
/// Node constructor
/// </summary>
/// <param name="board">Board status</param>
/// <param name="depth">Depth from the origin node</param>
/// <param name="parentNode">Parent node</param>
/// <param name="nodeType">Node type</param>
public ChessNode(BoardStatus board, int depth, ChessNode parentNode, NodeType nodeType)
: base(depth, parentNode, nodeType)
{
m_board = board;
}
/// <summary>
/// Method used to update the current status with the given movement
/// </summary>
/// <param name="movement">Movement data to update</param>
public void UpdateCurrentStatus(BoardStatus movement)
{
//CurrentStatus.movePieceToDestination(movement.Origin, movement.Destination);
CurrentStatus = movement;
}
/// <summary>
/// Function used to start a match
/// </summary>
public void startMatch()
{
m_currentStatus = new BoardStatus();
}
