Esempio n. 1
0
        /// <summary>
        /// 動かす駒を移動先へ。
        /// </summary>
        /// <param name="figMovedKoma"></param>
        /// <param name="move">棋譜に記録するために「指す前/指した後」を含めた手。</param>
        /// <param name="obsoluted_kifu_mutable"></param>
        /// <param name="isMakimodosi"></param>
        private static void Do25_UgokasuKoma_IdoSakiHe(
            out Finger figMovedKoma,
            IMove move,
            Playerside kaisi_tebanside,
            SkyConst kaisi_Sky
            ,
            [CallerMemberName] string memberName    = "",
            [CallerFilePath] string sourceFilePath  = "",
            [CallerLineNumber] int sourceLineNumber = 0
            )
        {
            figMovedKoma = Fingers.Error_1;

            //------------------------------------------------------------
            // 選択  :  動かす駒
            //------------------------------------------------------------
            // [巻戻し]のとき
            //>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

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

            RO_Star koma = Util_Starlightable.AsKoma(move.Now);

            // 動かす駒
            figMovedKoma = Util_Sky_FingerQuery.InShogibanMasuNow(
                kaisi_Sky,
                koma.Pside,
                koma.Masu//[巻戻し]のときは、先位置が 駒の居場所。
                );
            Debug.Assert(figMovedKoma != Fingers.Error_1, "駒を動かせなかった?5");
        }
Esempio n. 2
0
        /// <summary>
        /// 持駒を取得。
        /// </summary>
        /// <param name="fingers_banjoSeme"></param>
        /// <param name="fingers_banjoKurau"></param>
        /// <param name="fingers_motiSeme"></param>
        /// <param name="fingers_motiKurau"></param>
        /// <param name="src_Sky"></param>
        /// <param name="tebanSeme"></param>
        /// <param name="tebanKurau"></param>
        public static void Split_Moti1p_Moti2p(
            out Fingers fingers_moti1p, // 持駒 1P
            out Fingers fingers_moti2p, // 持駒 2=
            SkyConst src_Sky
            )
        {
            Fingers fingers_moti1p_temp = new Fingers(); // (3)持ち駒_攻め手
            Fingers fingers_moti2p_temp = new Fingers(); // (4)持ち駒_食らう側

            src_Sky.Foreach_Starlights((Finger finger, IMoveHalf dd, ref bool toBreak) =>
            {
                RO_Star koma = Util_Starlightable.AsKoma(dd.Now);

                if (Conv_SyElement.ToOkiba(koma.Masu) == Okiba.Sente_Komadai)
                {
                    //
                    // 1P 駒台
                    //
                    fingers_moti1p_temp.Add(finger);
                }
                else if (Conv_SyElement.ToOkiba(koma.Masu) == Okiba.Gote_Komadai)
                {
                    //
                    // 2P 駒台
                    //
                    fingers_moti2p_temp.Add(finger);
                }
            });
            fingers_moti1p = fingers_moti1p_temp;
            fingers_moti2p = fingers_moti2p_temp;
        }
Esempio n. 3
0
        /// <summary>
        /// 用途例:持ち駒を確認するために使います。
        /// </summary>
        /// <param name="hkomas_gen_MOTI"></param>
        /// <returns></returns>
        public static string JsonElements_KomaHandles(bool enableLog, SkyConst src_Sky, List <int> hKomas, string comment)
        {
            StringBuilder sb = new StringBuilder();

            if (!enableLog)
            {
                goto gt_EndMethod;
            }

            //sb.AppendLine("            [");
            sb.AppendLine("                { act:\"colorMasu\", style:\"rgba(100,240,100,0.5)\" },");


            foreach (int hKoma in hKomas)
            {
                RO_Star koma = Util_Starlightable.AsKoma(src_Sky.StarlightIndexOf(hKoma).Now);


                string komaImg = Util_Converter_LogGraphicEx.Finger_ToString(src_Sky, hKoma, "");
                sb.AppendLine($"                {{ act:\"drawImg\", img:\"{komaImg}\", masu: {Conv_SyElement.ToMasuNumber(koma.Masu)} }},");//FIXME:おかしい?
            }



            sb.AppendLine($"                {{ act:\"drawText\", text:\"{comment}\"  , x:0, y:20 }},");

            //sb.AppendLine("            ],");

gt_EndMethod:
            return(sb.ToString());
        }
Esempio n. 4
0
        /// <summary>
        /// 指定した駒全てについて、基本的な駒の動きを返します。(金は「前、ななめ前、横、下に進める」のような)
        /// </summary>
        /// <param name="srcSky"></param>
        /// <param name="fingers"></param>
        /// <returns></returns>
        public static Maps_OneAndOne <Finger, SySet <SyElement> > GetPotentialMoves(
            SkyConst srcSky,
            Fingers fingers
            )
        {
            if (fingers is null)
            {
                throw new ArgumentNullException(nameof(fingers));
            }

            Maps_OneAndOne <Finger, SySet <SyElement> > kiki_fMs = new Maps_OneAndOne <Finger, SySet <SyElement> >();// 「どの駒を、どこに進める」の一覧

            foreach (Finger finger in fingers.Items)
            {
                // ポテンシャル・ムーブを調べます。
                SySet <SyElement> move = Util_Sky_SyugoQuery.KomaKidou_Potential(finger, srcSky);//←ポテンシャル・ムーブ取得関数を選択。歩とか。

                if (!move.IsEmptySet())
                {
                    // 移動可能升があるなら
                    Util_Sky258A.AddOverwrite(kiki_fMs, finger, move);
                }
            }

            return(kiki_fMs);
        }
Esempio n. 5
0
        /// <summary>
        /// 特殊な用途。
        /// </summary>
        /// <param name="collection"></param>
        /// <returns></returns>
        public static string Dump(List_OneAndMulti <T1, T2> collection, SkyConst skyConst)
        {
            int count = 0;

            StringBuilder sb = new StringBuilder();

            {
                foreach (Couple <T1, T2> item in collection.Items)
                {
                    if (item.A is Finger && item.B is SySet <SyElement> )
                    {
                        foreach (SyElement syElement in ((SySet <SyElement>)item.B).Elements)
                        {
                            sb.AppendLine($"({count}) a=[{Util_Komasyurui14.Ichimoji[(int)Util_Starlightable.AsKoma(skyConst.StarlightIndexOf(item.A as Finger).Now).Komasyurui]}] b=[{Util_Masu10.ToSujiKanji(syElement)}]");
                            count++;
                        }
                    }
                    else
                    {
                        sb.AppendLine($"({count}) a=[{item.A.ToString()}] b=[{item.B.ToString()}]");
                        count++;
                    }
                }
            }

            return(sb.ToString());
        }
Esempio n. 6
0
        /// <summary>
        /// 指定の場所にある駒を返します。
        ///
        ///         先後は見ますが、将棋盤限定です。
        ///
        /// </summary>
        /// <param name="okiba">置き場</param>
        /// <param name="masu">筋、段</param>
        /// <param name="uc_Main">メインパネル</param>
        /// <returns>駒。無ければヌル。</returns>
        public static Finger InShogibanMasuNow(SkyConst src_Sky, Playerside pside, SyElement masu)
        {
            Finger foundKoma = Fingers.Error_1;

            foreach (Finger finger in Finger_Honshogi.Items_KomaOnly)
            {
                IMoveHalf sl = src_Sky.StarlightIndexOf(finger);

                RO_Star koma = Util_Starlightable.AsKoma(sl.Now);

                int suji1;
                int suji2;
                int dan1;
                int dan2;
                Util_MasuNum.TryMasuToSuji(koma.Masu, out suji1);
                Util_MasuNum.TryMasuToSuji(masu, out suji2);
                Util_MasuNum.TryMasuToDan(koma.Masu, out dan1);
                Util_MasuNum.TryMasuToDan(masu, out dan2);

                // 先後は見ますが、将棋盤限定です。
                if (
                    koma.Pside == pside &&
                    Conv_SyElement.ToOkiba(koma.Masu) == Okiba.ShogiBan &&
                    suji1 == suji2 &&
                    dan1 == dan2
                    )
                {
                    foundKoma = finger;
                    break;
                }
            }

            return(foundKoma);
        }
Esempio n. 7
0
        /// <summary>
        /// a - b = c
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="sbGohosyu"></param>
        public static Maps_OneAndOne <Finger, SySet <SyElement> > MinusMasus(
            SkyConst src_Sky_forLog,
            Maps_OneAndOne <Finger, SySet <SyElement> > a1,
            SySet <SyElement> b
            )
        {
            //GraphicalLogUtil.Log(enableLog, "Thought_KomaAndMove#MinusMasus",
            //    "["+
            //    GraphicalLogUtil.JsonKyokumens_MultiKomabetuMasus(enableLog, siteiSky_forLog, a1, "a1") +
            //    "]"
            //    );


            Maps_OneAndOne <Finger, SySet <SyElement> > c = new Maps_OneAndOne <Finger, SySet <SyElement> >(a1);

            List <Finger> list_koma = c.ToKeyList();//調べたい側の全駒


            foreach (Finger selfKoma in list_koma)
            {
                SySet <SyElement> srcMasus = c.ElementAt(selfKoma);

                SySet <SyElement> minusedMasus = srcMasus.Minus_Closed(b, Util_SyElement_BinaryOperator.Dlgt_Equals_MasuNumber);

                // 差替え
                c.AddReplace(selfKoma, minusedMasus, false);//差分に差替えます。もともと無い駒なら何もしません。
            }

            return(c);
        }
Esempio n. 8
0
        /// <summary>
        /// 1P玉と、2P玉を取得します。
        /// </summary>
        /// <param name="koma_1PGyoku_orNull"></param>
        /// <param name="koma_2PGyoku_orNull"></param>
        /// <param name="src_Sky"></param>
        public static void Split_1PGyoku_2PGyoku(
            out RO_Star koma_1PGyoku_orNull,
            out RO_Star koma_2PGyoku_orNull,
            SkyConst src_Sky
            )
        {
            RO_Star koma_1PGyoku_temp = null;
            RO_Star koma_2PGyoku_temp = null;

            src_Sky.Foreach_Starlights((Finger finger, IMoveHalf ds, ref bool toBreak) =>
            {
                RO_Star koma = Util_Starlightable.AsKoma(ds.Now);

                if (
                    Okiba.ShogiBan == Conv_SyElement.ToOkiba(koma.Masu) &&
                    PieceType.K == koma.Komasyurui
                    )
                {
                    if (Playerside.P1 == koma.Pside)
                    {
                        koma_1PGyoku_temp = koma;// 1P玉の位置
                    }
                    else if (Playerside.P2 == koma.Pside)
                    {
                        koma_2PGyoku_temp = koma;// 2P玉の位置
                    }
                }
            });
            koma_1PGyoku_orNull = koma_1PGyoku_temp;
            koma_2PGyoku_orNull = koma_2PGyoku_temp;
        }
Esempio n. 9
0
        /// <summary>
        /// 不一致判定: 先後、駒種類  が、自分と同じものが <ひとつもない>
        /// </summary>
        /// <returns></returns>
        public static bool NeverOnaji(IMoveHalf ms, SkyConst src_Sky, params Fingers[] komaGroupArgs)
        {
            bool unmatched = true;

            foreach (Fingers komaGroup in komaGroupArgs)
            {
                foreach (Finger figKoma in komaGroup.Items)
                {
                    RO_Star koma1 = Util_Starlightable.AsKoma(ms.Now);
                    RO_Star koma2 = Util_Starlightable.AsKoma(src_Sky.StarlightIndexOf(figKoma).Now);



                    if (
                        koma1.Pside == koma2.Pside &&  // 誰のものか
                        Util_Komahaiyaku184.Syurui(koma1.Haiyaku) == Util_Komahaiyaku184.Syurui(koma2.Haiyaku)    // 駒の種類は
                        )
                    {
                        // 1つでも一致するものがあれば、終了します。
                        unmatched = false;
                        goto gt_EndLoop;
                    }
                }
            }
gt_EndLoop:

            return(unmatched);
        }
Esempio n. 10
0
        public static SfenStringImpl ExportSfen(SkyConst src_Sky)
        {
            Debug.Assert(src_Sky.Count == 40, $"sky.Starlights.Count=[{src_Sky.Count}]");//将棋の駒の数

            StartposExporterImpl se = new StartposExporterImpl(src_Sky);

            return(new SfenStringImpl($"sfen {Util_StartposExporter.ToSfenstring(se, false)}"));
        }
Esempio n. 11
0
        public StartposExporterImpl(SkyConst src_Sky)
        {
            Debug.Assert(src_Sky.Count == 40, $"sourceSky.Starlights.Count=[{src_Sky.Count}]"); //将棋の駒の数

            this.BanObject201 = new Dictionary <int, RO_Star>();                                //Masu

            this.ToBanObject201(src_Sky);
        }
Esempio n. 12
0
        /// <summary>
        /// 動かす駒を移動先へ。
        /// </summary>
        /// <param name="figMovedKoma"></param>
        /// <param name="move">棋譜に記録するために「指す前/指した後」を含めた手。</param>
        /// <param name="obsoluted_kifu_mutable"></param>
        /// <param name="isMakimodosi"></param>
        private static void Do24_UgokasuKoma_IdoSakiHe(
            out Finger figMovedKoma,
            IMove move,
            Playerside kaisi_tebanside,
            SkyConst kaisi_Sky,
            string hint
            ,
            [CallerMemberName] string memberName    = "",
            [CallerFilePath] string sourceFilePath  = "",
            [CallerLineNumber] int sourceLineNumber = 0
            )
        {
            figMovedKoma = Fingers.Error_1;

            //------------------------------------------------------------
            // 選択  :  動かす駒
            //------------------------------------------------------------
            // 進むとき
            //>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

            //Debug.Assert(null != move, "Sasu24_UgokasuKoma_IdoSakiHe: 指し手がヌルでした。");
            if (Util_Sky_BoolQuery.IsDaAction(move))// 多分、ここで move がヌルになるエラーがある☆
            {
                //----------
                // 駒台から “打”
                //----------
                RO_Star srcKoma = Util_Starlightable.AsKoma(move.LongTimeAgo);
                RO_Star dstKoma = Util_Starlightable.AsKoma(move.Now);

                // FIXME: 駒台の、どの駒を拾うか?
                figMovedKoma = Util_Sky_FingerQuery.InOkibaSyuruiNowIgnoreCase(
                    kaisi_Sky,
                    Conv_SyElement.ToOkiba(srcKoma.Masu),
                    Util_Komahaiyaku184.Syurui(dstKoma.Haiyaku)
                    );
                Debug.Assert(figMovedKoma != Fingers.Error_1, "駒を動かせなかった?14");
            }
            else
            {
                //----------
                // 将棋盤から
                //----------

                RO_Star srcKoma = Util_Starlightable.AsKoma(move.LongTimeAgo);
                Debug.Assert(!Masu_Honshogi.IsErrorBasho(srcKoma.Masu), "srcKoma.Masuエラー。15");
                RO_Star dstKoma = Util_Starlightable.AsKoma(move.Now);

                figMovedKoma = Util_Sky_FingerQuery.InShogibanMasuNow(
                    kaisi_Sky,
                    dstKoma.Pside,
                    Util_Masu10.OkibaSujiDanToMasu(
                        Conv_SyElement.ToOkiba(Masu_Honshogi.Masus_All[Conv_SyElement.ToMasuNumber(dstKoma.Masu)]),
                        Conv_SyElement.ToMasuNumber(srcKoma.Masu)
                        )
                    );
                Debug.Assert(figMovedKoma != Fingers.Error_1, "駒を動かせなかった?13");
            }
        }
Esempio n. 13
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="src"></param>
        /// <param name="finger1">指した駒、指されていた駒</param>
        /// <param name="light1"></param>
        /// <param name="finger2">取った駒、取っていた駒</param>
        /// <param name="light2"></param>
        /// <returns></returns>
        public static SkyConst NewInstance_OverwriteOrAdd_Light(Sky src, int temezumi_orMinus1, Finger finger1, IMoveHalf light1, Finger finger2, IMoveHalf light2)
        {
            SkyConst result = new SkyConst(src, false, temezumi_orMinus1, new Finger[] { finger1, finger2 }, new IMoveHalf[] { light1, light2 },
                                           // 手得計算
                                           PieceType.None, 0, Masu_Honshogi.Query_Basho(Masu_Honshogi.nError)
                                           );

            return(result);
        }
Esempio n. 14
0
        /// <summary>
        /// 指したあとの、次の局面を作るだけ☆
        /// </summary>
        /// <param name="src_Sky"></param>
        /// <param name="finger"></param>
        /// <param name="masu"></param>
        /// <param name="pside_genTeban"></param>
        /// <param name="logTag"></param>
        /// <returns></returns>
        public static SkyConst Sasu(
            SkyConst src_Sky, //指定局面
            Finger finger,    //動かす駒
            SyElement masu,   //移動先マス
            bool toNaru       //成るなら真
            )
        {
            SkyBuffer sky_buf = new SkyBuffer(src_Sky);                         // 現局面を元に、新規局面を書き換えます。

            sky_buf.SetKaisiPside(Conv_Playerside.Reverse(src_Sky.KaisiPside)); // 開始先後を逆転させます。
            sky_buf.SetTemezumi(sky_buf.Temezumi + 1);                          // 1手進めます。
            SkyConst src_Sky2 = SkyConst.NewInstance(sky_buf,
                                                     -1                         //sky_bufでもう変えてあるので、そのまま。
                                                     );

            // 移動先に相手の駒がないか、確認します。
            Finger tottaKoma = Util_Sky_FingersQuery.InMasuNow(src_Sky2, masu).ToFirst();

            if (tottaKoma != Fingers.Error_1)
            {
                // なにか駒を取ったら
                SyElement akiMasu;

                if (src_Sky.KaisiPside == Playerside.P1)
                {
                    akiMasu = Util_IttesasuRoutine.GetKomadaiKomabukuroSpace(Okiba.Sente_Komadai, src_Sky2);
                }
                else
                {
                    akiMasu = Util_IttesasuRoutine.GetKomadaiKomabukuroSpace(Okiba.Gote_Komadai, src_Sky2);
                }


                RO_Star koma = Util_Starlightable.AsKoma(sky_buf.StarlightIndexOf(tottaKoma).Now);

                // FIXME:配役あってるか?
                sky_buf.PutOverwriteOrAdd_Starlight(tottaKoma, new RO_Starlight(new RO_Star(src_Sky.KaisiPside, akiMasu, koma.Komasyurui)));//tottaKoma,
            }

            // 駒を1個動かします。
            // FIXME: 取った駒はどうなっている?
            {
                RO_Star   koma       = Util_Starlightable.AsKoma(sky_buf.StarlightIndexOf(finger).Now);
                PieceType komaSyurui = koma.Komasyurui;

                if (toNaru)
                {
                    komaSyurui = Util_Komasyurui14.ToNariCase(komaSyurui);
                }

                sky_buf.PutOverwriteOrAdd_Starlight(finger, new RO_Starlight(new RO_Star(src_Sky.KaisiPside, masu, komaSyurui)));
            }

            return(SkyConst.NewInstance(sky_buf,
                                        -1//sky_bufでもう進めてあるので、そのまま。
                                        ));
        }
Esempio n. 15
0
        public static SkyConst NewInstance_ReversePside(Sky src, int temezumi_orMinus1)
        {
            SkyConst result = new SkyConst(src, true, temezumi_orMinus1, new Finger[] { Fingers.Error_1 }, new IMoveHalf[] { null },
                                           // 手得計算
                                           PieceType.None, 0, Masu_Honshogi.Query_Basho(Masu_Honshogi.nError)
                                           );

            return(result);
        }
Esempio n. 16
0
        public void Log3(
            SkyConst src_Sky,
            Playerside tebanKurau,       //手番(喰らう側)
            Playerside tebanSeme,        //手番(利きを調べる側)
            Fingers fingers_kurau_IKUSA, //戦駒(喰らう側)
            Fingers fingers_kurau_MOTI,  // 持駒(喰らう側)
            Fingers fingers_seme_IKUSA,  //戦駒(利きを調べる側)
            Fingers fingers_seme_MOTI    // 持駒(利きを調べる側)
            )
        {
            // 攻め手の駒の位置
            KaisetuBoard boardLog_clone = new KaisetuBoard(this.BrdMove);

            foreach (Finger finger in fingers_seme_IKUSA.Items)
            {
                RO_Star koma = Util_Starlightable.AsKoma(src_Sky.StarlightIndexOf(finger).Now);

                Gkl_KomaMasu km = new Gkl_KomaMasu(
                    Util_Converter_LogGraphicEx.PsideKs14_ToString(tebanSeme, Util_Komahaiyaku184.Syurui(koma.Haiyaku), ""),
                    Conv_SyElement.ToMasuNumber(koma.Masu)
                    );
                boardLog_clone.KomaMasu1.Add(km);
            }

            foreach (Finger finger in fingers_kurau_IKUSA.Items)
            {
                RO_Star koma = Util_Starlightable.AsKoma(src_Sky.StarlightIndexOf(finger).Now);

                this.BrdMove.KomaMasu2.Add(new Gkl_KomaMasu(
                                               Util_Converter_LogGraphicEx.PsideKs14_ToString(tebanKurau, Util_Komahaiyaku184.Syurui(koma.Haiyaku), ""),
                                               Conv_SyElement.ToMasuNumber(koma.Masu)
                                               ));
            }

            foreach (Finger finger in fingers_seme_MOTI.Items)
            {
                RO_Star koma = Util_Starlightable.AsKoma(src_Sky.StarlightIndexOf(finger).Now);

                Gkl_KomaMasu km = new Gkl_KomaMasu(
                    Util_Converter_LogGraphicEx.PsideKs14_ToString(tebanSeme, Util_Komahaiyaku184.Syurui(koma.Haiyaku), ""),
                    Conv_SyElement.ToMasuNumber(koma.Masu)
                    );
                this.BrdMove.KomaMasu3.Add(km);
            }

            foreach (Finger finger in fingers_kurau_MOTI.Items)
            {
                RO_Star koma = Util_Starlightable.AsKoma(src_Sky.StarlightIndexOf(finger).Now);

                this.BrdMove.KomaMasu4.Add(new Gkl_KomaMasu(
                                               Util_Converter_LogGraphicEx.PsideKs14_ToString(tebanKurau, Util_Komahaiyaku184.Syurui(koma.Haiyaku), ""),
                                               Conv_SyElement.ToMasuNumber(koma.Masu)
                                               ));
            }
            this.BrdMove = boardLog_clone;
        }
Esempio n. 17
0
 /// <summary>
 /// 盤上の駒を、攻め側と、食らう側に グループ分けします。
 /// </summary>
 /// <param name="out_masus_seme"></param>
 /// <param name="out_masus_kurau"></param>
 /// <param name="src_Sky"></param>
 /// <param name="fs_kurau">fingers</param>
 /// <param name="fs_seme"></param>
 public static void SplitGroup_Banjo(
     out SySet <SyElement> out_masus_seme,
     out SySet <SyElement> out_masus_kurau,
     SkyConst src_Sky,
     Fingers fs_kurau, //盤上の駒(喰らう側)
     Fingers fs_seme   //盤上の駒(利きを調べる側)
     )
 {
     out_masus_seme  = Conv_Fingers.ToMasus(fs_seme, src_Sky);  // 盤上のマス(利きを調べる側の駒)
     out_masus_kurau = Conv_Fingers.ToMasus(fs_kurau, src_Sky); // 盤上のマス(喰らう側の駒)
 }
Esempio n. 18
0
        /// <summary>
        /// 駒を1個 更新します。
        ///
        /// (1)指したとき。戻したとき。
        /// (2)駒の向き変更にも使われる。
        /// </summary>
        /// <param name="src"></param>
        /// <param name="finger1"></param>
        /// <param name="light1"></param>
        /// <returns></returns>
        public static SkyConst NewInstance_OverwriteOrAdd_Light(Sky src, int temezumi_orMinus1, Finger finger1, IMoveHalf light1,
                                                                // 手得計算
                                                                PieceType tedokuKeisan_komasyurui, int tedokukeisan_index, SyElement tedokukeisan_sasitamasu
                                                                )
        {
            SkyConst result = new SkyConst(src, false, temezumi_orMinus1, new Finger[] { finger1 }, new IMoveHalf[] { light1 },
                                           // 手得計算
                                           tedokuKeisan_komasyurui, tedokukeisan_index, tedokukeisan_sasitamasu
                                           );

            return(result);
        }
Esempio n. 19
0
        //Dictionary<Starbeamable, KyokumenWrapper>
        public static Dictionary <string, SasuEntry> KomabetuMasusToMoveBetuSky(
            List_OneAndMulti <Finger, SySet <SyElement> > sMs, SkyConst src_Sky)
        {
            Dictionary <string, SasuEntry> moveBetuEntry = new Dictionary <string, SasuEntry>();


            sMs.Foreach_Entry((Finger key, SySet <SyElement> value, ref bool toBreak) =>
            {
                RO_Star koma = Util_Starlightable.AsKoma(src_Sky.StarlightIndexOf(key).Now);


                foreach (SyElement dstMasu in value.Elements)
                {
                    IMove move = Util_Sky258A.BuildMove(
                        new RO_Star(src_Sky.KaisiPside, koma.Masu, koma.Haiyaku),
                        new RO_Star(src_Sky.KaisiPside, dstMasu, koma.Haiyaku),//FIXME:配役は適当。
                        PieceType.None
                        );

                    string moveStr      = ConvMoveStrSfen.ToMoveStrSfen(move);//重複防止用のキー
                    SasuEntry sasuEntry = new SasuEntry(
                        move,
                        key,     //動かす駒
                        dstMasu, //移動先升
                        false    //成りません。
                        );
                    if (!moveBetuEntry.ContainsKey(moveStr))
                    {
                        moveBetuEntry.Add(moveStr, sasuEntry);
                    }
                }
            });

            return(moveBetuEntry);

            /*
             * Dictionary<Starbeamable, KyokumenWrapper> result = new Dictionary<Starbeamable, KyokumenWrapper>();
             * foreach (KeyValuePair<string, SasuEntry> entry in movebetuEntry)
             * {
             *  result.Add(
             *      entry.Value.NewMove,
             *      new KyokumenWrapper(Util_Sasu341.Sasu(
             *      src_Sky,//指定局面
             *      entry.Value.Finger,//動かす駒
             *      entry.Value.Masu,//移動先升
             *      entry.Value.Naru,//成りません。
             *      logTag
             *  )));
             * }
             *
             * return result;
             */
        }
Esempio n. 20
0
        /// <summary>
        /// フィンガー番号→駒→駒のある升の集合
        /// </summary>
        /// <param name="fingers"></param>
        /// <param name="src_Sky"></param>
        /// <returns></returns>
        public static SySet <SyElement> ToMasus(Fingers fingers, SkyConst src_Sky)
        {
            SySet <SyElement> masus = new SySet_Default <SyElement>("何かの升");

            foreach (Finger finger in fingers.Items)
            {
                RO_Star koma = Util_Starlightable.AsKoma(src_Sky.StarlightIndexOf(finger).Now);


                masus.AddElement(koma.Masu);
            }

            return(masus);
        }
Esempio n. 21
0
 public IttemodosuResultImpl(
     Finger figMovedKoma,
     Finger figFoodKoma,
     Node <IMove, KyokumenWrapper> out_newNode_OrNull,
     PieceType foodKomaSyurui,
     SkyConst susunda_Sky_orNull
     )
 {
     this.FigMovedKoma       = figMovedKoma;
     this.FigFoodKoma        = figFoodKoma;
     this.SyuryoNode_OrNull  = out_newNode_OrNull;
     this.FoodKomaSyurui     = foodKomaSyurui;
     this.Susunda_Sky_orNull = susunda_Sky_orNull;
 }
Esempio n. 22
0
        /// <summary>
        /// ************************************************************************************************************************
        /// 駒の移動可能升
        /// ************************************************************************************************************************
        ///
        /// ポテンシャルなので、貫通している。
        ///
        /// </summary>
        /// <param name="light"></param>
        /// <returns></returns>
        public static SySet <SyElement> KomaKidou_Potential(Finger finger, SkyConst src_Sky)
        {
            SySet <SyElement> result;

            RO_Star koma = Util_Starlightable.AsKoma(src_Sky.StarlightIndexOf(finger).Now);

            //
            // ポテンシャルなので、貫通しているのは仕様通り。
            //
            // FIXME: 成香が横に進めることが分かっているか?
            //
            result = Array_Rule01_PotentialMove15.ItemMethods[(int)koma.Komasyurui](koma.Pside, koma.Masu);

            return(result);
        }
Esempio n. 23
0
        public string Execute(
            ref KifuParserA_Result result,
            Model_Taikyoku model_Taikyoku,
            out KifuParserA_State nextState,
            KifuParserA owner,
            KifuParserA_Genjo genjo
            )
        {
            nextState = this;

            if (genjo.InputLine.StartsWith("startpos"))
            {
                // 平手の初期配置です。
                //>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

#if DEBUG
                Logger.Trace($"(^△^)「{genjo.InputLine}」vs【{this.GetType().Name}】 : 平手のようなんだぜ☆");
#endif

                genjo.InputLine = genjo.InputLine.Substring("startpos".Length);
                genjo.InputLine = genjo.InputLine.Trim();

                //----------------------------------------
                // 棋譜を空っぽにし、平手初期局面を与えます。
                //----------------------------------------
                {
                    model_Taikyoku.Kifu.Clear();// 棋譜を空っぽにします。

                    model_Taikyoku.Kifu.GetRoot().Value.SetKyokumen(
                        SkyConst.NewInstance(Util_SkyWriter.New_Hirate(Playerside.P1),
                                             0                                                    //初期配置は 0手目済み。)
                                             ));                                                  //SFENのstartpos解析時
                    model_Taikyoku.Kifu.SetProperty(Word_KifuTree.PropName_Startpos, "startpos"); //平手の初期局面
                }

                nextState = KifuParserA_StateA1a_SfenStartpos.GetInstance();
            }
            else
            {
                //#if DEBUG
                // : 局面の指定のようなんだぜ☆ 対応していない☆?
                Logger.Error($"(^△^)ここはスルーして次に状態遷移するんだぜ☆\n「{genjo.InputLine}」vs【{this.GetType().Name}】");
                //#endif
                nextState = KifuParserA_StateA1b_SfenLnsgkgsnl.GetInstance();
            }

            return(genjo.InputLine);
        }
Esempio n. 24
0
        /// <summary>
        /// ************************************************************************************************************************
        /// 指定のマスにあるスプライトを返します。(本将棋用)
        /// ************************************************************************************************************************
        /// </summary>
        /// <param name="masu">マス番号</param>
        /// <param name="logTag">ログ名</param>
        /// <returns>スプライト番号。なければエラー番号。</returns>
        public static Fingers InMasuNow(SkyConst src_Sky, SyElement masu)
        {
            Fingers found = new Fingers();

            foreach (Finger finger in Finger_Honshogi.Items_KomaOnly)
            {
                RO_Star koma = Util_Koma.FromFinger(src_Sky, finger);

                if (Masu_Honshogi.Basho_Equals(koma.Masu, masu))
                {
                    found.Add(finger);
                }
            }

            return(found);
        }
Esempio n. 25
0
        // */

        /*
         #region SfenstringImpl型
         * public SkyConst ToKyokumenConst {
         *  get {
         *      SkyConst result = Util_Sky.ImportSfen(this.sfenstringImpl);
         *
         *      StartposImporter.Assert_HirateHonsyogi(new SkyBuffer(result), "this.startposString=[{this.sfenstringImpl}]");
         *
         *      return result;
         *  }
         * }
         * public void SetKyokumen(SkyConst sky) { this.sfenstringImpl = Util_Sky.ExportSfen(sky); }
         * private SfenstringImpl sfenstringImpl;
         #endregion
         * // */

        public KyokumenWrapper(SkyConst sky)
        {
            Debug.Assert(sky.Count == 40, "sky.Starlights.Count=[{sky.Count}]");//将棋の駒の数

            //*
            #region sky型
            this.kyokumen = sky;
            #endregion
            // */

            /*
             #region SfenstringImpl型
             * this.sfenstringImpl = Util_Sky.ExportSfen(sky);
             #endregion
             * // */
        }
Esempio n. 26
0
        /// <summary>
        /// 駒のハンドルを返します。
        /// </summary>
        /// <param name="pside"></param>
        /// <param name="hKomas"></param>
        /// <returns></returns>
        public static Fingers InPsideNow(SkyConst srcSky, Playerside pside)
        {
            Fingers fingers = new Fingers();

            srcSky.Foreach_Starlights((Finger finger, IMoveHalf ds, ref bool toBreak) =>
            {
                RO_Star koma = Util_Starlightable.AsKoma(ds.Now);

                if (pside == koma.Pside)
                {
                    fingers.Add(finger);
                }
            });

            return(fingers);
        }
Esempio n. 27
0
        /// <summary>
        /// ************************************************************************************************************************
        /// 指定のマスにある駒を返します。(本将棋用)
        /// ************************************************************************************************************************
        /// </summary>
        /// <param name="masu">マス番号</param>
        /// <returns>スプライト番号。なければエラー番号。</returns>
        public static RO_Star InMasuNow(SkyConst src_Sky, SyElement masu)
        {
            RO_Star koma = null;

            Finger fig = Util_Sky_FingersQuery.InMasuNow(src_Sky, masu).ToFirst();

            if (Fingers.Error_1 == fig)
            {
                // 指定の升には駒がない。
                goto gt_EndMethod;
            }

            koma = Util_Koma.FromFinger(src_Sky, fig);

gt_EndMethod:
            return(koma);
        }
Esempio n. 28
0
        /// <summary>
        /// 駒のハンドル(*1)を返します。
        ///
        ///         *1…将棋の駒1つ1つに付けられた番号です。
        ///
        /// </summary>
        /// <param name="syurui"></param>
        /// <param name="hKomas"></param>
        /// <returns></returns>
        public static Fingers InKomasyuruiNow(SkyConst src_Sky, PieceType syurui)
        {
            Fingers figKomas = new Fingers();

            foreach (Finger figKoma in Finger_Honshogi.Items_KomaOnly)
            {
                RO_Star koma = Util_Starlightable.AsKoma(src_Sky.StarlightIndexOf(figKoma).Now);


                if (Util_Komasyurui14.Matches(syurui, Util_Komahaiyaku184.Syurui(koma.Haiyaku)))
                {
                    figKomas.Add(figKoma);
                }
            }

            return(figKomas);
        }
Esempio n. 29
0
        /// <summary>
        /// 升コレクション。
        /// </summary>
        /// <param name="src_Sky"></param>
        /// <param name="pside"></param>
        /// <returns></returns>
        public static SySet <SyElement> Masus_Now(SkyConst src_Sky, Playerside pside)
        {
            SySet_Default <SyElement> masus = new SySet_Default <SyElement>("今の升");

            src_Sky.Foreach_Starlights((Finger finger, IMoveHalf mlLight, ref bool toBreak) =>
            {
                RO_Star koma = Util_Starlightable.AsKoma(mlLight.Now);


                if (koma.Pside == pside && Conv_SyElement.ToOkiba(koma.Masu) == Okiba.ShogiBan)
                {
                    masus.AddElement(koma.Masu);
                }
            });

            return(masus);
        }
Esempio n. 30
0
        public static RO_Star FromFinger(SkyConst src_Sky, Finger finger)
        {
            RO_Star koma;

            IMoveSource lightable = src_Sky.StarlightIndexOf(finger).Now;

            if (lightable is RO_Star)
            {
                koma = (RO_Star)lightable;
            }
            else
            {
                throw new Exception("未対応の星の光クラス");
            }

            return(koma);
        }