Exemplo n.º 1
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="figMovedKoma"></param>
        /// <param name="move">棋譜に記録するために「指す前/指した後」を含めた手。</param>
        /// <param name="kifu"></param>
        /// <param name="isMakimodosi"></param>
        private static void Kifusasi25(
            out Finger figMovedKoma,
            ShootingStarlightable move,
            KifuTree kifu,
            bool isMakimodosi
            ,
            [CallerMemberName] string memberName    = "",
            [CallerFilePath] string sourceFilePath  = "",
            [CallerLineNumber] int sourceLineNumber = 0
            )
        {
            figMovedKoma = Fingers.Error_1;

            SkyConst src_Sky = kifu.CurNode.Value.ToKyokumenConst;

            //------------------------------------------------------------
            // 選択  :  動かす駒
            //------------------------------------------------------------
            if (isMakimodosi)
            {
                // [巻戻し]のとき
                //>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

                // 打った駒も、指した駒も、結局は将棋盤の上にあるはず。

                RO_Star_Koma koma = Util_Koma.AsKoma(move.Now);

                // 動かす駒
                figMovedKoma = Util_Sky.Finger_AtMasuNow_Shogiban(
                    src_Sky,
                    koma.Pside,
                    koma.Masu//[巻戻し]のときは、先位置が 駒の居場所。
                    );
            }
            else
            {
                // 進むとき
                //>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

                //------------------------------
                // 符号の追加(一手進む)
                //------------------------------
                KifuNode genKyokumenCopyNode = new KifuNodeImpl(move, new KyokumenWrapper(src_Sky), KifuNodeImpl.GetReverseTebanside(((KifuNode)kifu.CurNode).Tebanside));

                // TODO: ↓?
                ((KifuNode)kifu.CurNode).AppendChildA_New(genKyokumenCopyNode);
                kifu.CurNode = genKyokumenCopyNode;

                if (Util_Sky.IsDaAction(move))
                {
                    //----------
                    // 駒台から “打”
                    //----------

                    RO_Star_Koma srcKoma = Util_Koma.AsKoma(move.LongTimeAgo);
                    RO_Star_Koma dstKoma = Util_Koma.AsKoma(move.Now);


                    figMovedKoma = Util_Sky.FingerNow_BySyuruiIgnoreCase(
                        src_Sky,
                        Util_Masu.GetOkiba(srcKoma.Masu),
                        Haiyaku184Array.Syurui(dstKoma.Haiyaku)
                        );
                }
                else
                {
                    //----------
                    // 将棋盤から
                    //----------

                    RO_Star_Koma srcKoma = Util_Koma.AsKoma(move.LongTimeAgo);
                    RO_Star_Koma dstKoma = Util_Koma.AsKoma(move.Now);


                    figMovedKoma = Util_Sky.Finger_AtMasuNow_Shogiban(
                        src_Sky,
                        dstKoma.Pside,
                        Util_Masu.OkibaSujiDanToMasu(
                            Util_Masu.GetOkiba(Masu_Honshogi.Items_All[Util_Masu.AsMasuNumber(dstKoma.Masu)]),
                            Util_Masu.AsMasuNumber(srcKoma.Masu)
                            )
                        );
                }
            }
        }
Exemplo n.º 2
0
        /// <summary>
        /// 符号1「7g7f」を元に、move を作ります。
        ///
        /// <[再生]、[コマ送り]で呼び出されます>
        /// </summary>
        /// <returns></returns>
        public static void ExecuteSfenMoves_FromTextSub(
            bool isHonshogi,
            string str1,    //123456789 か、 PLNSGKRB
            string str2,    //abcdefghi か、 *
            string str3,    //123456789
            string str4,    //abcdefghi
            string strNari, //+
            out ShootingStarlightable move,
            KifuTree kifu,
            string hint,
            int tesumi_yomiGenTeban//読み進めている現在の手目済
            )
        {
            move = Util_Sky.NullObjectMove;

            SkyConst src_Sky = kifu.NodeAt(tesumi_yomiGenTeban).Value.ToKyokumenConst;

            Debug.Assert(!Util_MasuNum.OnKomabukuro(Util_Masu.AsMasuNumber(((RO_Star_Koma)src_Sky.StarlightIndexOf((Finger)0).Now).Masu)), "[" + tesumi_yomiGenTeban + "]手目、駒が駒袋にあった。");

            try
            {
                PieceType uttaSyurui; // 打った駒の種類

                int srcSuji = Util_Koma.CTRL_NOTHING_PROPERTY_SUJI;
                int srcDan  = Util_Koma.CTRL_NOTHING_PROPERTY_DAN;

                if ("*" == str2)
                {
                    //>>>>>>>>>> 「打」でした。

                    Converter04.SfenUttaSyurui(str1, out uttaSyurui);
                }
                else
                {
                    //>>>>>>>>>> 指しました。
                    uttaSyurui = PieceType.None;//打った駒はない☆

                    //------------------------------
                    // 1
                    //------------------------------
                    if (!int.TryParse(str1, out srcSuji))
                    {
                    }

                    //------------------------------
                    // 2
                    //------------------------------
                    srcDan = Converter04.Alphabet_ToInt(str2);
                }

                //------------------------------
                // 3
                //------------------------------
                int suji;
                if (!int.TryParse(str3, out suji))
                {
                }

                //------------------------------
                // 4
                //------------------------------
                int dan;
                dan = Converter04.Alphabet_ToInt(str4);

                Finger koma;

                if ("*" == str2)
                {
                    //>>>>> 「打」でした。
                    Node <ShootingStarlightable, KyokumenWrapper> siteiNode = kifu.CurNode;

                    // 駒台から、打った種類の駒を取得
                    koma = Util_Sky.FingerNow_BySyuruiIgnoreCase(
                        siteiNode.Value.ToKyokumenConst,
                        Converter04.Pside_ToKomadai(kifu.CountPside(kifu.CurNode)),//Okiba.Sente_Komadai,//FIXME:
                        uttaSyurui);
                    if (Fingers.Error_1 == koma)
                    {
                        throw new Exception($"TuginoItte_Sfen#GetData_FromTextSub:駒台から種類[{uttaSyurui}]の駒を掴もうとしましたが、エラーでした。");
                    }

                    //// FIXME: 打のとき、srcSuji、srcDan が Int.Min
                }
                else
                {
                    //>>>>> 打ではないとき
                    koma = Util_Sky.Fingers_AtMasuNow(
                        src_Sky, Util_Masu.OkibaSujiDanToMasu(Okiba.ShogiBan, srcSuji, srcDan)
                        ).ToFirst();

                    if (Fingers.Error_1 == koma)
                    {
                        //
                        // エラーの理由:
                        // 0手目、平手局面を想定していたが、駒がすべて駒袋に入っているときなど
                        //

                        var sky2 = Util_Sky.Json_1Sky(src_Sky, "エラー駒になったとき", $"{hint}_SF解3",
                                                      tesumi_yomiGenTeban);

                        throw new Exception($@"TuginoItte_Sfen#GetData_FromTextSub:SFEN解析中の失敗: 将棋盤から [{srcSuji}]筋、[{srcDan}]段 にある駒を掴もうとしましたが、駒がありませんでした。
isHonshogi=[{isHonshogi}]
str1=[{str1}]
str2=[{str2}]
str3=[{str3}]
str4=[{str4}]
strNari=[{strNari}]
hint=[{hint}]
tesumi_yomiGenTeban=[{tesumi_yomiGenTeban}]
局面=sfen {Util_SfenStartposWriter.CreateSfenstring(new StartposExporter(src_Sky), true)}
{sky2}");
                    }
                }


                PieceType dstSyurui;
                PieceType srcSyurui;
                Okiba     srcOkiba;
                SyElement srcMasu;


                if ("*" == str2)
                {
                    //>>>>> 打った駒の場合

                    dstSyurui = uttaSyurui;
                    srcSyurui = uttaSyurui;
                    switch (kifu.CountPside(kifu.CurNode))
                    {
                    case Playerside.P2:
                        srcOkiba = Okiba.Gote_Komadai;
                        break;

                    case Playerside.P1:
                        srcOkiba = Okiba.Sente_Komadai;
                        break;

                    default:
                        srcOkiba = Okiba.Empty;
                        break;
                    }

                    int lastTesumi = kifu.CountTesumi(kifu.CurNode);
                    Node <ShootingStarlightable, KyokumenWrapper> siteiNode = kifu.NodeAt(lastTesumi);

                    Finger srcKoma = Util_Sky.FingerNow_BySyuruiIgnoreCase(siteiNode.Value.ToKyokumenConst, srcOkiba, srcSyurui);

                    RO_Star_Koma dstKoma = Util_Koma.AsKoma(src_Sky.StarlightIndexOf(srcKoma).Now);

                    srcMasu = dstKoma.Masu;
                }
                else
                {
                    //>>>>> 盤上の駒を指した場合

                    RO_Star_Koma dstKoma = Util_Koma.AsKoma(src_Sky.StarlightIndexOf(koma).Now);


                    dstSyurui = Haiyaku184Array.Syurui(dstKoma.Haiyaku);
                    srcSyurui = dstSyurui; //駒は「元・種類」を記憶していませんので、「現・種類」を指定します。
                    srcOkiba  = Okiba.ShogiBan;
                    srcMasu   = Util_Masu.OkibaSujiDanToMasu(srcOkiba, srcSuji, srcDan);
                }


                //------------------------------
                // 5
                //------------------------------
                if ("+" == strNari)
                {
                    // 成りました
                    dstSyurui = KomaSyurui14Array.NariCaseHandle[(int)dstSyurui];
                }


                //------------------------------
                // 結果
                //------------------------------
                // 棋譜
                move = new RO_ShootingStarlight(
                    //koma,//TODO:

                    new RO_Star_Koma(
                        kifu.CountPside(kifu.CurNode),
                        srcMasu,//FIXME:升ハンドルにしたい
                        srcSyurui
                        ),

                    new RO_Star_Koma(
                        kifu.CountPside(kifu.CurNode),
                        Util_Masu.OkibaSujiDanToMasu(Okiba.ShogiBan, suji, dan),//符号は将棋盤の升目です。 FIXME:升ハンドルにしたい
                        dstSyurui
                        ),

                    PieceType.None//符号からは、取った駒は分からない
                    );
            }
            catch (Exception ex)
            {
                //>>>>> エラーが起こりました。

                // どうにもできないので 経路と情報を付け足して 更に外側に投げます。
                throw new Exception($"{ex.GetType().Name}:{ex.Message} in TuginoItte_Sfen.GetData_FromTextSub(A) str1=「{str1}」 str2=「{str2}」 str3=「{str3}」 str4=「{str4}」 strNari=「{strNari}」 ");
            }
        }
Exemplo n.º 3
0
        /// <summary>
        /// 棋譜[再生]時用(マウス操作のときは関係ない)
        ///
        ///         一手進む、一手[巻戻し]に対応。
        ///
        /// </summary>
        /// <param name="move">棋譜に記録するために「指す前/指した後」を含めた手。</param>
        /// <param name="kifu"></param>
        /// <param name="isMakimodosi"></param>
        private static void Kifusasi52_WhenKifuRead(
            Starlight dst,
            PieceType syurui2,
            ref Finger figMovedKoma,
            out Finger out_figFoodKoma,
            ShootingStarlightable move,
            KifuTree kifu,
            bool isMakimodosi,
            out Node <ShootingStarlightable, KyokumenWrapper> out_newNode_OrNull
            )
        {
            out_figFoodKoma = Fingers.Error_1;

            // Sky 局面データは、この関数の途中で何回か変更されます。ローカル変数に退避しておくと、同期が取れなくなります。

            //------------------------------------------------------------
            // 駒を取る
            //------------------------------------------------------------
            if (!isMakimodosi)
            {
                RO_Star_Koma dstKoma = Util_Koma.AsKoma(dst.Now);


                PieceType foodKomaSyurui;//取られた駒の種類

                //----------
                // 将棋盤上のその場所に駒はあるか
                //----------
                foodKomaSyurui  = PieceType.None;                                                                         //ひとまずクリアー
                out_figFoodKoma = Util_Sky.Fingers_AtMasuNow(kifu.CurNode.Value.ToKyokumenConst, dstKoma.Masu).ToFirst(); //盤上

                if (Fingers.Error_1 != out_figFoodKoma)
                {
                    //>>>>> 指した先に駒があったなら

                    //
                    // 取られる駒
                    //
                    foodKomaSyurui = Util_Koma.AsKoma(kifu.CurNode.Value.ToKyokumenConst.StarlightIndexOf(out_figFoodKoma).Now).Syurui;

                    //
                    // 取られる駒は、駒置き場の空きマスに移動させます。
                    //
                    Okiba      okiba;
                    Playerside pside;
                    switch (dstKoma.Pside)
                    {
                    case Playerside.P1:
                    {
                        okiba = Okiba.Sente_Komadai;
                        pside = Playerside.P1;
                    }
                    break;

                    case Playerside.P2:
                    {
                        okiba = Okiba.Gote_Komadai;
                        pside = Playerside.P2;
                    }
                    break;

                    default:
                    {
                        //>>>>> エラー: 先後がおかしいです。

                        throw new Exception($@"エラー: 先後がおかしいです。
dst.Pside={dstKoma.Pside}");
                    }
                    }

                    // 駒台の空きスペース
                    SyElement akiMasu = akiMasu = KifuIO.GetKomadaiKomabukuroSpace(okiba, kifu.CurNode.Value.ToKyokumenConst);

                    if (Masu_Honshogi.Error == akiMasu)
                    {
                        //>>>>> エラー: 駒台に空きスペースがありませんでした。
                        throw new Exception($@"エラー: 駒台に空きスペースがありませんでした。
駒台={Okiba.Gote_Komadai}");
                    }

                    //>>>>> 駒台に空きスペースがありました。

                    //
                    // 取られる動き
                    //
                    {
                        SkyBuffer buffer_Sky = new SkyBuffer(kifu.CurNode.Value.ToKyokumenConst);
                        buffer_Sky.AddOverwriteStarlight(
                            out_figFoodKoma,
                            new RO_MotionlessStarlight(
                                //out_figFoodKoma,
                                new RO_Star_Koma(
                                    pside,
                                    akiMasu,                                                                                          //駒台の空きマスへ
                                    Util_Koma.AsKoma(kifu.CurNode.Value.ToKyokumenConst.StarlightIndexOf(out_figFoodKoma).Now).Syurui //駒の種類
                                    )
                                )
                            );
                        kifu.CurNode.Value.SetKyokumen(new SkyConst(buffer_Sky));
                        // ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
                        // この時点で局面データに変更あり
                        // ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
                    }



                    //------------------------------
                    // 成っていれば、「成り」は解除。
                    //------------------------------
                    RO_Star_Koma koma3 = Util_Koma.AsKoma(kifu.CurNode.Value.ToKyokumenConst.StarlightIndexOf(out_figFoodKoma).Now);


                    switch (Util_Masu.GetOkiba(koma3.Masu))
                    {
                    case Okiba.Sente_Komadai:    //thru
                    case Okiba.Gote_Komadai:
                        // 駒台へ移動しました
                        //>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

                        SkyBuffer buffer_Sky = new SkyBuffer(kifu.CurNode.Value.ToKyokumenConst);
                        buffer_Sky.AddOverwriteStarlight(out_figFoodKoma, new RO_MotionlessStarlight(
                                                             //out_figFoodKoma,
                                                             new RO_Star_Koma(koma3.Pside,
                                                                              koma3.Masu,
                                                                              koma3.ToNarazuCase())
                                                             )
                                                         );
                        kifu.CurNode.Value.SetKyokumen(new SkyConst(buffer_Sky));
                        // ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
                        // この時点で局面データに変更あり
                        // ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

                        break;
                    }


                    //------------------------------
                    // 取った駒を棋譜に覚えさせます。(差替え)
                    //------------------------------
                    kifu.AppendChildB_Swap(
                        foodKomaSyurui,
                        kifu.CurNode.Value.ToKyokumenConst,
                        "KifuIO_Kifusasi52"
                        );
                    //}
                }
            }

            //------------------------------------------------------------
            // 駒の移動
            //------------------------------------------------------------
            {
                SkyBuffer buffer_Sky = new SkyBuffer(kifu.CurNode.Value.ToKyokumenConst);
                buffer_Sky.AddOverwriteStarlight(figMovedKoma, dst);
                kifu.CurNode.Value.SetKyokumen(new SkyConst(buffer_Sky));
            }
            // ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
            // この時点で局面データに変更あり
            // ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■


            //------------------------------------------------------------
            // 取った駒を戻す
            //------------------------------------------------------------
            if (isMakimodosi)
            {
                RO_Star_Koma koma = Util_Koma.AsKoma(move.Now);


                if (PieceType.None != (PieceType)move.FoodKomaSyurui)
                {
                    // 駒台から、駒を検索します。
                    Okiba okiba;
                    if (Playerside.P2 == koma.Pside)
                    {
                        okiba = Okiba.Gote_Komadai;
                    }
                    else
                    {
                        okiba = Okiba.Sente_Komadai;
                    }


                    // 取った駒は、種類が同じなら、駒台のどの駒でも同じです。
                    Finger temp_figFoodKoma = Util_Sky.FingerNow_BySyuruiIgnoreCase(kifu.CurNode.Value.ToKyokumenConst, okiba, (PieceType)move.FoodKomaSyurui);
                    if (Fingers.Error_1 != temp_figFoodKoma)
                    {
                        // 取った駒のデータをセットし直します。
                        SkyBuffer buffer_Sky = new SkyBuffer(kifu.CurNode.Value.ToKyokumenConst);

                        buffer_Sky.AddOverwriteStarlight(
                            temp_figFoodKoma,
                            new RO_MotionlessStarlight(
                                //temp_figFoodKoma,
                                new RO_Star_Koma(
                                    Converter04.AlternatePside(koma.Pside), //先後を逆にして駒台に置きます。
                                    koma.Masu,                              // マス
                                    (PieceType)move.FoodKomaSyurui
                                    )
                                )
                            );

                        kifu.CurNode.Value.SetKyokumen(new SkyConst(buffer_Sky));
                        // ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
                        // この時点で局面データに変更あり
                        // ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

                        out_figFoodKoma = temp_figFoodKoma;
                    }
                }
            }


            //
            // ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
            // 局面データに変更があったものとして進めます。
            // ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
            //
            out_newNode_OrNull = kifu.CurNode;// この変数を返すのがポイント。
            {
                out_newNode_OrNull.Value.SetKyokumen(kifu.CurNode.Value.ToKyokumenConst);

                kifu.CurNode.Value.SetKyokumen(kifu.CurNode.Value.ToKyokumenConst);
            }
        }