예제 #1
0
        public void ParseSameAsTest()
        {
            Assert.AreEqual(
                new Move
            {
                SameAsOld = true,
                Piece     = Piece.Hu,
            },
                ShogiParser.ParseMove("同歩", true));
            Assert.AreEqual(
                new Move
            {
                SameAsOld = true,
                Piece     = Piece.Ryu,
            },
                ShogiParser.ParseMove("同 流", true));
            Assert.AreEqual(
                new Move
            {
                SameAsOld = true,
                Piece     = Piece.Uma,
            },
                ShogiParser.ParseMove("DOU 馬", true));

            Assert.AreEqual(
                new Move
            {
                SameAsOld   = true,
                Piece       = Piece.Kin,
                RelFileType = RelFileType.Right,
            },
                ShogiParser.ParseMove("同衾右", true));

            Assert.AreEqual(
                new Move
            {
                SameAsOld = true,
                Piece     = Piece.Hu,
            },
                ShogiParser.ParseMove("34同じくおふーさん", true));
            Assert.AreEqual(
                new Move
            {
                SameAsOld    = true,
                Piece        = Piece.Gin,
                RelFileType  = RelFileType.Right,
                RankMoveType = RankMoveType.Up,
            },
                ShogiParser.ParseMove("34同 ぎん右上がる", true));
            Assert.AreEqual(
                new Move
            {
                SameAsOld    = true,
                Piece        = Piece.Gyoku,
                RelFileType  = RelFileType.Left,
                RankMoveType = RankMoveType.Back,
            },
                ShogiParser.ParseMove("99dou kinghidarisagaru", true));
        }
예제 #2
0
        private static Move M(string moveStr)
        {
            var move = ShogiParser.ParseMove(moveStr, true);

            Assert.NotNull(move);
            Assert.True(move.Validate());

            return(move);
        }
예제 #3
0
        private static void TestMove(Board board, string moveStr, bool makeMove = false)
        {
            var move = ShogiParser.ParseMove(moveStr, true);

            Assert.NotNull(move);
            Assert.True(move.Validate());

            TestMove(board, move, makeMove);
        }
예제 #4
0
        private static void TestInvalidMove(Board board, string moveStr)
        {
            var move = ShogiParser.ParseMove(moveStr, true);

            if (move == null || !move.Validate())
            {
                // 成功
                return;
            }

            TestInvalidMove(board, move);
        }
예제 #5
0
        public void ParseSpecialMoveTest()
        {
            Assert.AreEqual(
                new Move
            {
                SpecialMoveType = SpecialMoveType.Resign,
            },
                ShogiParser.ParseMove("投了", true));
            Assert.AreEqual(
                new Move
            {
                SpecialMoveType = SpecialMoveType.Interrupt,
                BWType          = BWType.Black,
            },
                ShogiParser.ParseMove("▲中断", true));
            Assert.AreEqual(
                new Move
            {
                SpecialMoveType = SpecialMoveType.Sennichite,
                BWType          = BWType.White,
            },
                ShogiParser.ParseMove("△千日手", true));
            Assert.AreEqual(
                new Move
            {
                SpecialMoveType = SpecialMoveType.TimeUp,
                BWType          = BWType.Black,
            },
                ShogiParser.ParseMove("▼時間切れ", true));
            Assert.AreEqual(
                new Move
            {
                SpecialMoveType = SpecialMoveType.Resign,
                BWType          = BWType.White,
            },
                ShogiParser.ParseMove("▽とうりょう", true));
            Assert.AreEqual(
                new Move
            {
                SpecialMoveType = SpecialMoveType.Jishogi,
            },
                ShogiParser.ParseMove("持将棋X", false));

            Assert.Null(ShogiParser.ParseMove("不明", true));
            Assert.Null(ShogiParser.ParseMove("投 了", true));
            Assert.Null(ShogiParser.ParseMove("▲投了A", true));
        }
예제 #6
0
        public void ResignTest()
        {
            var resign = new Move
            {
                SpecialMoveType = SpecialMoveType.Resign,
            };

            Assert.AreEqual(
                ShogiParser.ParseMove("まけました", true),
                resign);
            Assert.AreEqual(
                ShogiParser.ParseMove("あ、まけました", true),
                resign);
            Assert.AreNotEqual(
                ShogiParser.ParseMove("あ 負けました", true),
                resign);
        }
예제 #7
0
        /// <summary>
        /// 指し手行をパースします。
        /// </summary>
        private IEnumerable <Move> ParseMoveLineKi2(string line)
        {
            while (!Util.IsWhiteSpaceOnly(line))
            {
                var parsedLine = string.Empty;
                var move       = ShogiParser.ParseMoveEx(
                    line, false, false, ref parsedLine);

                if (move == null)
                {
                    throw new FileFormatException(
                              this.lineNumber,
                              "ki2形式の指し手が正しく読み込めません。");
                }

                line = line.Substring(parsedLine.Length);
                yield return(move);
            }
        }
예제 #8
0
        /// <summary>
        /// 指し手行をパースします。
        /// </summary>
        private IEnumerable <Move> ParseMoveLineKi2(Board board, string line,
                                                    ref Exception error)
        {
            var moves = new List <Move>();

            while (!Util.IsWhiteSpaceOnly(line))
            {
                var parsedLine = string.Empty;
                var lmove      = ShogiParser.ParseMoveEx(
                    line, false, ref parsedLine);

                if (lmove == null || !lmove.Validate())
                {
                    error = new FileFormatException(
                        this.lineNumber,
                        "ki2形式の指し手が正しく読み込めません。");
                    break;
                }

                var move = board.ConvertMoveFromLiteral(lmove);
                if (move == null || !move.Validate())
                {
                    error = new FileFormatException(
                        this.lineNumber,
                        lmove + ": 指し手の変換に失敗しました。");
                    break;
                }

                if (!board.DoMove(move, MoveFlags.DoMoveDefault & ~MoveFlags.CheckPawnDropCheckMate))
                {
                    error = new FileFormatException(
                        this.lineNumber,
                        move + ": 指し手の着手に失敗しました。");
                    break;
                }

                line = line.Substring(parsedLine.Length);
                moves.Add(move);
            }

            return(moves);
        }
예제 #9
0
        public void ParsePlayerTest()
        {
            var player1 = new ShogiPlayer()
            {
                Nickname   = "てすと",
                SkillLevel = new SkillLevel(SkillKind.Kyu, 9),
            };

            AssertPlayer(
                player1,
                ShogiParser.ParsePlayer("てすと 9級"));
            AssertPlayer(
                player1,
                ShogiParser.ParsePlayer(" てすと きゅうきゅう"));
            AssertPlayer(
                player1,
                ShogiParser.ParsePlayer("  てすと  きゅう級"));
            AssertPlayer(
                player1,
                ShogiParser.ParsePlayer("  てすと 9級"));
            AssertPlayerNot(
                player1,
                ShogiParser.ParsePlayer("  てすと 級きゅう"));
            AssertPlayer(
                player1,
                ShogiParser.ParsePlayer("てすと 急急"));

            /*var player2 = new ShogiPlayer()
            *  {
            *  Nickname = "三級",
            *  };
            *  AssertPlayer(
            *  player2,
            *  ShogiParser.ParsePlayer("三級"));*/
            /*AssertPlayer(
             *  player2,
             *  ShogiParser.ParsePlayer(" @ 三級"));*/
            /*AssertPlayer(
             *  player2,
             *  ShogiParser.ParsePlayer("三級 三級"));*/
        }
예제 #10
0
        /// <summary>
        /// 指し手行をパースします。
        /// </summary>
        private KifMoveNode ParseMoveLineKif(string line)
        {
            var m = MoveLineRegex.Match(line);

            if (!m.Success)
            {
                return(null);
            }

            var moveCount    = int.Parse(m.Groups[1].Value);
            var hasVariation = m.Groups[5].Success;

            // 指し手'3六歩(37)'のような形式でパースします。
            var moveText = m.Groups[2].Value;
            var lmove    = ShogiParser.ParseMove(moveText, false);

            if (lmove == null || !lmove.Validate())
            {
                throw new FileFormatException(
                          this.lineNumber,
                          string.Format(
                              "{0}手目: 指し手が正しくありません。({1})",
                              m.Groups[1].Value, moveText));
            }

            // 時間を取得します。
            var duration = ParseDuration(m.Groups[4].Value);

            return(new KifMoveNode
            {
                LiteralMove = lmove,
                MoveCount = moveCount,
                Duration = duration,
                LineNumber = this.lineNumber,
                HasVariationNode = hasVariation,
            });
        }
예제 #11
0
        public void ParseMoveTest()
        {
            Assert.AreEqual(
                ShogiParser.ParseMove("同格", true),
                new Move
            {
                SameAsOld = true,
                Piece     = Piece.Kaku,
            });

            var gin68 = new Move
            {
                DstSquare = new Square(6, 8),
                Piece     = Piece.Gin,
            };

            Assert.AreEqual(
                ShogiParser.ParseMove("ろっぱち銀", true),
                gin68);
            Assert.AreEqual(
                ShogiParser.ParseMove("ロッパチ銀", true),
                gin68);

            Assert.AreEqual(
                ShogiParser.ParseMove("46歩", true),
                new Move
            {
                DstSquare = new Square(4, 6),
                Piece     = Piece.Hu,
            });

            Assert.AreEqual(
                ShogiParser.ParseMove("56ふぅ", true),
                new Move
            {
                DstSquare = new Square(5, 6),
                Piece     = Piece.Hu,
            });
            Assert.AreEqual(
                ShogiParser.ParseMove("救急玉", true),
                new Move
            {
                DstSquare = new Square(9, 9),
                Piece     = Piece.Gyoku,
            });
            Assert.AreEqual(
                ShogiParser.ParseMove("燦燦劉", true),
                new Move
            {
                DstSquare = new Square(3, 3),
                Piece     = Piece.Ryu,
            });
            Assert.AreEqual(
                ShogiParser.ParseMove("32RYUU", true),
                new Move
            {
                DstSquare = new Square(3, 2),
                Piece     = Piece.Ryu,
            });
            Assert.AreEqual(
                ShogiParser.ParseMove("32KINN", true),
                new Move
            {
                DstSquare = new Square(3, 2),
                Piece     = Piece.Kin,
            });
        }
예제 #12
0
        public void ParseMoveTest2()
        {
            Assert.AreEqual(
                ShogiParser.ParseMove("13馬右", true),
                new Move
            {
                DstSquare   = new Square(1, 3),
                Piece       = Piece.Uma,
                RelFileType = RelFileType.Right,
            });
            Assert.AreEqual(
                ShogiParser.ParseMove("13馬右引く", true),
                new Move
            {
                DstSquare    = new Square(1, 3),
                Piece        = Piece.Uma,
                RankMoveType = RankMoveType.Back,
                RelFileType  = RelFileType.Right,
            });
            Assert.AreEqual(
                ShogiParser.ParseMove("43ほーす左", true),
                new Move
            {
                DstSquare   = new Square(4, 3),
                Piece       = Piece.Uma,
                RelFileType = RelFileType.Left,
            });

            Assert.AreEqual(
                ShogiParser.ParseMove("13不不成り", true),
                new Move
            {
                DstSquare  = new Square(1, 3),
                Piece      = Piece.Hu,
                ActionType = ActionType.Unpromote,
            });

            Assert.AreEqual(
                ShogiParser.ParseMove("55うまごん", true),
                new Move
            {
                DstSquare = new Square(5, 5),
                Piece     = Piece.Uma,
            });

            Assert.AreEqual(
                ShogiParser.ParseMove("39ときんちゃん", true),
                new Move
            {
                DstSquare = new Square(3, 9),
                Piece     = Piece.To,
            });
            Assert.AreEqual(
                ShogiParser.ParseMove("ごよんぽ", true),
                new Move
            {
                DstSquare = new Square(5, 4),
                Piece     = Piece.Hu,
            });

            Assert.AreEqual(
                ShogiParser.ParseMove("シックスナイン不", true),
                new Move
            {
                DstSquare = new Square(6, 9),
                Piece     = Piece.Hu,
            });

            Assert.AreEqual(
                ShogiParser.ParseMove("△6二角行", true),
                new Move
            {
                Piece        = Piece.Kaku,
                DstSquare    = new Square(6, 2),
                RankMoveType = RankMoveType.Up,
                BWType       = BWType.White,
            });
        }