示例#1
0
        /// <summary>
        /// Fills the map of shadow items based on the state of markups.
        /// </summary>
        /// <param name="boardSize">Size of game board.</param>
        /// <param name="kind">Kind of sequence markup. (Letter, Number)</param>
        /// <returns>Map of shadow items.</returns>
        public string[,] FillSequenceShadowMap(GameBoardSize boardSize, SequenceMarkupKind kind)
        {
            string shadow;

            string[,] shadows = new string[boardSize.Width, boardSize.Height];
            if (kind == SequenceMarkupKind.Letter)
            {
                shadow = GetSmallestUnusedLetter().ToString();
            }
            else
            {
                shadow = GetSmallestUnusedNumber().ToString();
            }

            for (int x = 0; x < boardSize.Width; x++)
            {
                for (int y = 0; y < boardSize.Height; y++)
                {
                    shadows[x, y] = shadow;
                }
            }

            foreach (var label in GetMarkups <Label>())
            {
                shadows[label.Position.X, label.Position.Y] = "r";
            }

            return(shadows);
        }
示例#2
0
 public void FillBoardStateOfRoot(GameBoardSize boardSize, IRuleset ruleset)
 {
     if (Parent != null)
     {
         throw new InvalidOperationException("Only call this on a root.");
     }
     FillBoardStateInternal(new GameBoard(boardSize), new GroupState(ruleset.RulesetInfo), ruleset);
 }
示例#3
0
 /// <summary>
 /// Creates a game tree with a given ruleset
 /// </summary>
 public GameTree(IRuleset ruleset, GameBoardSize boardSize)
 {
     Ruleset                 = ruleset;
     BoardSize               = boardSize;
     GameTreeRoot            = new GameTreeNode();
     GameTreeRoot.BoardState = new GameBoard(boardSize);
     GameTreeRoot.GroupState = new GroupState(ruleset.RulesetInfo);
     LastNode                = GameTreeRoot;
 }
示例#4
0
 public GameInfo(PlayerInfo whitePlayerInfo, PlayerInfo blackPlayerInfo, GameBoardSize boardSize, RulesetType rulesetType, int numberOfHandicapStones, HandicapPlacementType handicapPlacementType, float komi, CountingType countingType)
 {
     White                  = whitePlayerInfo;
     Black                  = blackPlayerInfo;
     BoardSize              = boardSize;
     RulesetType            = rulesetType;
     NumberOfHandicapStones = numberOfHandicapStones;
     HandicapPlacementType  = handicapPlacementType;
     Komi         = komi;
     CountingType = countingType;
 }
示例#5
0
        /// <summary>
        /// Creates a game tree with a given ruleset and root
        /// </summary>
        /// <param name="ruleset">Ruleset</param>
        /// <param name="boardSize">Board size</param>
        /// <param name="gameTreeRoot">Root</param>
        public GameTree(IRuleset ruleset, GameBoardSize boardSize, GameTreeNode gameTreeRoot)
        {
            Ruleset      = ruleset;
            BoardSize    = boardSize;
            GameTreeRoot = gameTreeRoot;
            var lastNode = gameTreeRoot;

            while (lastNode.NextNode != null)
            {
                lastNode = lastNode.NextNode;
            }
            LastNode = lastNode;
        }
示例#6
0
 internal SgfPoint ToSgfPoint(GameBoardSize size) =>
 new SgfPoint(X, size.Height - Y - 1);
示例#7
0
 /// <summary>
 /// Converts SGF point to Position
 /// </summary>
 /// <param name="sgfPoint">SGF point</param>
 /// <param name="size">Game board size is used for reversing Y coordinates.</param>
 /// <returns>Position</returns>
 internal static Position FromSgfPoint(SgfPoint sgfPoint, GameBoardSize size) =>
 new Position(sgfPoint.Column, size.Height - sgfPoint.Row - 1);
示例#8
0
        /// <summary>
        /// Fills the map of shadow items based on the state of markups.
        /// </summary>
        /// <param name="boardSize">Size of game board.</param>
        /// <param name="kind">Kind of simple markup. (Circle, Cross, Square, Triangle)</param>
        /// <returns>Map of shadow items.</returns>
        public char[,] FillSimpleShadowMap(GameBoardSize boardSize, SimpleMarkupKind kind)
        {
            char[,] shadows = new char[boardSize.Width, boardSize.Height];

            switch (kind)
            {
            case SimpleMarkupKind.Circle:
            {
                for (int x = 0; x < boardSize.Width; x++)
                {
                    for (int y = 0; y < boardSize.Height; y++)
                    {
                        shadows[x, y] = 'c';
                    }
                }

                foreach (var circle in GetMarkups <Circle>())
                {
                    shadows[circle.Position.X, circle.Position.Y] = 'r';
                }
            }
                return(shadows);

            case SimpleMarkupKind.Cross:
            {
                for (int x = 0; x < boardSize.Width; x++)
                {
                    for (int y = 0; y < boardSize.Height; y++)
                    {
                        shadows[x, y] = 'x';
                    }
                }

                foreach (var cross in GetMarkups <Cross>())
                {
                    shadows[cross.Position.X, cross.Position.Y] = 'r';
                }
            }
                return(shadows);

            case SimpleMarkupKind.Square:
            {
                for (int x = 0; x < boardSize.Width; x++)
                {
                    for (int y = 0; y < boardSize.Height; y++)
                    {
                        shadows[x, y] = 's';
                    }
                }

                foreach (var square in GetMarkups <Square>())
                {
                    shadows[square.Position.X, square.Position.Y] = 'r';
                }
            }
                return(shadows);

            case SimpleMarkupKind.Triangle:
            {
                for (int x = 0; x < boardSize.Width; x++)
                {
                    for (int y = 0; y < boardSize.Height; y++)
                    {
                        shadows[x, y] = 't';
                    }
                }

                foreach (var triangle in GetMarkups <Triangle>())
                {
                    shadows[triangle.Position.X, triangle.Position.Y] = 'r';
                }
            }
                return(shadows);
            }

            return(shadows);
        }
示例#9
0
 /// <summary>
 /// Initializes a new <see cref="GameBoard"/> with the specified dimensions.
 /// </summary>
 /// <param name="boardSize">Size of the board.</param>
 public GameBoard(GameBoardSize boardSize)
 {
     _board    = new StoneColor[boardSize.Width, boardSize.Height];
     this.Size = boardSize;
 }