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