예제 #1
0
        /// <summary>
        /// 将棋盤、駒台に筋があります。
        /// </summary>
        /// <param name="masu"></param>
        /// <returns>該当なければ-1</returns>
        public static bool TryMasuToDan(int masuNumber, out int result)
        {
            bool successful = true;

            Okiba okiba = Conv_SyElement.ToOkiba(masuNumber);

            switch (okiba)
            {
            case Okiba.ShogiBan:
                result = (masuNumber - Conv_SyElement.ToMasuNumber(Conv_Okiba.GetFirstMasuFromOkiba(okiba))) % 9 + 1;
                break;

            case Okiba.Sente_Komadai:
            case Okiba.Gote_Komadai:
                result = (masuNumber - Conv_SyElement.ToMasuNumber(Conv_Okiba.GetFirstMasuFromOkiba(okiba))) % 10 + 1;
                break;

            case Okiba.KomaBukuro:
                result = (masuNumber - Conv_SyElement.ToMasuNumber(Conv_Okiba.GetFirstMasuFromOkiba(okiba))) % 10 + 1;
                break;

            default:
                // エラー
                result     = -1;
                successful = false;
                goto gt_EndMethod;
            }

gt_EndMethod:
            return(successful);
        }
예제 #2
0
        /// <summary>
        /// 合法手レベル1
        /// </summary>
        /// <returns></returns>
        public static SySet <SyElement> Create_01Fu(Playerside pside, SyElement masu_ji)
        {
            //----------------------------------------
            // 歩
            //----------------------------------------
            SySet_Default <SyElement> dst = new SySet_Default <SyElement>("歩の移動先");

            if (Okiba.ShogiBan == Conv_SyElement.ToOkiba(masu_ji))
            {
                //----------------------------------------
                // 将棋盤上の歩の移動先
                //----------------------------------------
                dst.AddSupersets(KomanoKidou.DstIppo_上(pside, masu_ji));
            }
            else if ((Okiba.Sente_Komadai | Okiba.Gote_Komadai).HasFlag(
                         Conv_SyElement.ToOkiba(masu_ji)))
            {
                //----------------------------------------
                // 駒台上の歩の移動先
                //----------------------------------------
                dst.AddSupersets(KomanoKidou.Dst_歩打面(pside));
            }

            return(dst);
        }
예제 #3
0
        /// <summary>
        /// ************************************************************************************************************************
        /// 局面に合わせて、駒ボタンのx,y位置を変更します
        /// ************************************************************************************************************************
        /// </summary>
        /// <param name="btnKoma">駒</param>
        public static void Redraw_KomaLocation(
            Finger figKoma,
            MainGui_Csharp mainGui
            )
        {
            RO_Star koma = Util_Starlightable.AsKoma(mainGui.Model_Manual.GuiSkyConst.StarlightIndexOf(figKoma).Now);

            Shape_BtnKoma btnKoma = Conv_Koma_InGui.FingerToKomaBtn(figKoma, mainGui);

            // マスと駒の隙間(パディング)
            int padX = 2;
            int padY = 2;

            int suji;
            int dan;

            Util_MasuNum.TryMasuToSuji(koma.Masu, out suji);
            Util_MasuNum.TryMasuToDan(koma.Masu, out dan);

            switch (Conv_SyElement.ToOkiba(koma.Masu))
            {
            case Okiba.ShogiBan:
                btnKoma.SetBounds(new Rectangle(
                                      mainGui.Shape_PnlTaikyoku.Shogiban.SujiToX(suji) + padX,
                                      mainGui.Shape_PnlTaikyoku.Shogiban.DanToY(dan) + padY,
                                      btnKoma.Bounds.Width,
                                      btnKoma.Bounds.Height
                                      ));
                break;

            case Okiba.Sente_Komadai:
                btnKoma.SetBounds(new Rectangle(
                                      mainGui.Shape_PnlTaikyoku.KomadaiArr[0].SujiToX(suji) + padX,
                                      mainGui.Shape_PnlTaikyoku.KomadaiArr[0].DanToY(dan) + padY,
                                      btnKoma.Bounds.Width,
                                      btnKoma.Bounds.Height
                                      ));
                break;

            case Okiba.Gote_Komadai:
                btnKoma.SetBounds(new Rectangle(
                                      mainGui.Shape_PnlTaikyoku.KomadaiArr[1].SujiToX(suji) + padX,
                                      mainGui.Shape_PnlTaikyoku.KomadaiArr[1].DanToY(dan) + padY,
                                      btnKoma.Bounds.Width,
                                      btnKoma.Bounds.Height
                                      ));
                break;

            case Okiba.KomaBukuro:
                btnKoma.SetBounds(new Rectangle(
                                      mainGui.Shape_PnlTaikyoku.KomadaiArr[2].SujiToX(suji) + padX,
                                      mainGui.Shape_PnlTaikyoku.KomadaiArr[2].DanToY(dan) + padY,
                                      btnKoma.Bounds.Width,
                                      btnKoma.Bounds.Height
                                      ));
                break;
            }
        }
예제 #4
0
        private static void Panic1(RO_Star koma)
        {
            StringBuilder sb = new StringBuilder();

            sb.AppendLine("Util_54List#Error1:2駒関係FVの配列添え字がわからないぜ☆!処理は続けられない。");
            sb.AppendLine($"koma1.Pside=[{koma.Pside}]");
            sb.AppendLine($"koma1.Komasyurui=[{koma.Komasyurui}]");
            sb.AppendLine($"koma1.Masu=[{koma.Masu}]");
            sb.AppendLine($"Conv_SyElement.ToOkiba(koma1.Masu)=[{Conv_SyElement.ToOkiba(koma.Masu)}]");
            throw new Exception(sb.ToString());
        }
예제 #5
0
        /// <summary>
        /// 2駒関係[PP]用。
        /// フィーチャーベクターの調査項目インデックス。該当なければ-1。
        /// </summary>
        /// <param name="pside">プレイヤーサイド</param>
        /// <param name="komasyurui">盤上の種類</param>
        /// <param name="masu">盤上の駒の升</param>
        /// <returns></returns>
        public static int ToPIndex_FromBanjo_PsideKomasyuruiMasu(Playerside pside, PieceType komasyurui, SyElement masu, out int p_index)
        {
            p_index = 0;//ここに累計していく。

            if (Okiba.ShogiBan != Conv_SyElement.ToOkiba(masu))
            {
                // 盤上でなければ。
                p_index = -1;
                goto gt_EndMethod;
            }

            switch (pside)
            {
            case Playerside.P1: break;

            case Playerside.P2: p_index += FeatureVectorImpl.CHOSA_KOMOKU_2P; break;

            default: break;
            }

            switch (komasyurui)
            {
            case PieceType.PP:     //thru
            case PieceType.P: p_index += FeatureVectorImpl.CHOSA_KOMOKU_____FU_____; break;

            case PieceType.PL:     //thru
            case PieceType.L: p_index += FeatureVectorImpl.CHOSA_KOMOKU_____KYO____; break;

            case PieceType.PN:     //thru
            case PieceType.N: p_index += FeatureVectorImpl.CHOSA_KOMOKU_____KEI____; break;

            case PieceType.PS:     //thru
            case PieceType.S: p_index += FeatureVectorImpl.CHOSA_KOMOKU_____GIN____; break;

            case PieceType.G: p_index += FeatureVectorImpl.CHOSA_KOMOKU_____KIN____; break;

            case PieceType.K: p_index += FeatureVectorImpl.CHOSA_KOMOKU_____OH_____; break;

            case PieceType.PR:     //thru
            case PieceType.R: p_index += FeatureVectorImpl.CHOSA_KOMOKU_____HISYA__; break;

            case PieceType.PB:     //thru
            case PieceType.B: p_index += FeatureVectorImpl.CHOSA_KOMOKU_____KAKU___; break;

            default: p_index = -1; goto gt_EndMethod;
            }

            p_index += Conv_SyElement.ToMasuNumber(masu);

gt_EndMethod:
            ;
            return(p_index);
        }
예제 #6
0
        public static SySet <SyElement> CreateKin_static(Playerside pside, SyElement masu_ji)
        {
            SySet_Default <SyElement> dst = new SySet_Default <SyElement>("カナゴマの移動先");

            if (Okiba.ShogiBan == Conv_SyElement.ToOkiba(masu_ji))
            {
                dst.AddSupersets(KomanoKidou.DstIppo_上(pside, masu_ji));
                dst.AddSupersets(KomanoKidou.DstIppo_昇(pside, masu_ji));
                dst.AddSupersets(KomanoKidou.DstIppo_射(pside, masu_ji));
                dst.AddSupersets(KomanoKidou.DstIppo_引(pside, masu_ji));
                dst.AddSupersets(KomanoKidou.DstIppo_滑(pside, masu_ji));
                dst.AddSupersets(KomanoKidou.DstIppo_浮(pside, masu_ji));
            }

            return(dst);
        }
예제 #7
0
        /// <summary>
        /// 合法手レベル1
        /// </summary>
        /// <returns></returns>
        public static SySet <SyElement> Create_05Kin(Playerside pside, SyElement masu_ji)
        {
            SySet <SyElement> dst = new SySet_Default <SyElement>("金の移動先");

            if (Okiba.ShogiBan == Conv_SyElement.ToOkiba(masu_ji))
            {
                dst = Array_Rule01_PotentialMove15.CreateKin_static(pside, masu_ji);
            }
            else if ((Okiba.Sente_Komadai | Okiba.Gote_Komadai).HasFlag(
                         Conv_SyElement.ToOkiba(masu_ji)))
            {
                dst.AddSupersets(KomanoKidou.Dst_全打面(pside));
            }

            return(dst);
        }
예제 #8
0
        /// <summary>
        /// 合法手レベル1
        /// </summary>
        /// <returns></returns>
        public static SySet <SyElement> Create_02Kyo(Playerside pside, SyElement masu_ji)
        {
            SySet_Default <SyElement> dst = new SySet_Default <SyElement>("香の移動先");

            if (Okiba.ShogiBan == Conv_SyElement.ToOkiba(masu_ji))
            {
                dst.AddSupersets(KomanoKidou.DstKantu_上(pside, masu_ji));
            }
            else if ((Okiba.Sente_Komadai | Okiba.Gote_Komadai).HasFlag(
                         Conv_SyElement.ToOkiba(masu_ji)))
            {
                dst.AddSupersets(KomanoKidou.Dst_歩打面(pside));//香も同じ
            }

            return(dst);
        }
예제 #9
0
        /// <summary>
        /// 合法手レベル1
        /// </summary>
        /// <returns></returns>
        public static SySet <SyElement> Create_03Kei(Playerside pside, SyElement masu_ji)
        {
            SySet_Default <SyElement> dst = new SySet_Default <SyElement>("桂の移動先");

            if (Okiba.ShogiBan == Conv_SyElement.ToOkiba(masu_ji))
            {
                dst.AddSupersets(KomanoKidou.DstKeimatobi_駆(pside, masu_ji));
                dst.AddSupersets(KomanoKidou.DstKeimatobi_跳(pside, masu_ji));
            }
            else if ((Okiba.Sente_Komadai | Okiba.Gote_Komadai).HasFlag(
                         Conv_SyElement.ToOkiba(masu_ji)))
            {
                dst.AddSupersets(KomanoKidou.Dst_桂打面(pside));
            }

            return(dst);
        }
예제 #10
0
        /// <summary>
        /// v(^▽^)v超能力『メナス』だぜ☆ 未来の脅威を予測し、可視化するぜ☆www
        /// </summary>
        public static void Menace(MainGui_Csharp mainGui)
        {
            if (0 < mainGui.Model_Manual.GuiTemezumi)
            {
                // 処理の順序が悪く、初回はうまく判定できない。
                SkyConst src_Sky = mainGui.Model_Manual.GuiSkyConst;


                //----------
                // 将棋盤上の駒
                //----------
                mainGui.RepaintRequest.SetFlag_RefreshRequest();

                // [クリアー]
                mainGui.Shape_PnlTaikyoku.Shogiban.ClearHMasu_KikiKomaList();

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


                    if (
                        Okiba.ShogiBan == Conv_SyElement.ToOkiba(koma.Masu)
                        &&
                        mainGui.Model_Manual.GuiPside != koma.Pside
                        )
                    {
                        // 駒の利き
                        SySet <SyElement> kikiZukei = Util_Sky_SyugoQuery.KomaKidou_Potential(figKoma, src_Sky);

                        IEnumerable <SyElement> kikiMasuList = kikiZukei.Elements;
                        foreach (SyElement masu in kikiMasuList)
                        {
                            // その枡に利いている駒のハンドルを追加
                            if (!Masu_Honshogi.IsErrorBasho(masu))
                            {
                                mainGui.Shape_PnlTaikyoku.Shogiban.HMasu_KikiKomaList[Conv_SyElement.ToMasuNumber(masu)].Add((int)figKoma);
                            }
                        }
                    }
                }
            }
        }
예제 #11
0
        /// <summary>
        /// 合法手レベル1
        /// </summary>
        /// <returns></returns>
        public static SySet <SyElement> Create_04Gin(Playerside pside, SyElement masu_ji)
        {
            SySet_Default <SyElement> dst = new SySet_Default <SyElement>("銀の移動先");

            if (Okiba.ShogiBan == Conv_SyElement.ToOkiba(masu_ji))
            {
                dst.AddSupersets(KomanoKidou.DstIppo_上(pside, masu_ji));
                dst.AddSupersets(KomanoKidou.DstIppo_昇(pside, masu_ji));
                dst.AddSupersets(KomanoKidou.DstIppo_沈(pside, masu_ji));
                dst.AddSupersets(KomanoKidou.DstIppo_降(pside, masu_ji));
                dst.AddSupersets(KomanoKidou.DstIppo_浮(pside, masu_ji));
            }
            else if ((Okiba.Sente_Komadai | Okiba.Gote_Komadai).HasFlag(
                         Conv_SyElement.ToOkiba(masu_ji)))
            {
                dst.AddSupersets(KomanoKidou.Dst_全打面(pside));
            }

            return(dst);
        }
예제 #12
0
        /// <summary>
        /// 2駒関係[KK]用。
        /// フィーチャーベクターの調査項目インデックス。該当なければ-1。
        /// </summary>
        /// <param name="pside">プレイヤーサイド</param>
        /// <param name="komasyurui">盤上の種類</param>
        /// <param name="masu">盤上の駒の升</param>
        /// <returns></returns>
        public static int ToKIndex_From_PsideBanjoKomasyuruiMasu(SkyConst src_Sky, Playerside pside)
        {
            // 調査項目番号(K1、K2等)
            int result;

            SyElement masu;

            {
                Finger  figK1  = Util_Sky_FingersQuery.InOkibaPsideKomasyuruiNow(src_Sky, Okiba.ShogiBan, pside, PieceType.K).ToFirst();
                RO_Star komaK1 = Util_Starlightable.AsKoma(src_Sky.StarlightIndexOf(figK1).Now);
                masu = komaK1.Masu;
            }

            if (Okiba.ShogiBan != Conv_SyElement.ToOkiba(masu))
            {
                // 盤上でなければ。
                result = -1;
                goto gt_EndMethod;
            }

            int kSuji;

            Util_MasuNum.TryMasuToSuji(masu, out kSuji);
            int kDan;

            Util_MasuNum.TryMasuToDan(masu, out kDan);


            int p1;

            Conv_FvKoumoku522.Converter_K1_to_P(Playerside.P1, kDan, kSuji, out p1);


            result = p1;

gt_EndMethod:
            ;
            return(result);
        }
예제 #13
0
        /// <summary>
        /// 評価値を返します。先手が有利ならプラス、後手が有利ならマイナス、互角は 0.0 です。
        /// </summary>
        /// <param name="args"></param>
        /// <returns></returns>
        public override void Evaluate(
            out float out_score,
#if DEBUG || LEARN
            out KyHyokaMeisai_Koumoku out_meisaiKoumoku_orNull,
#endif
            SkyConst srcSky,
            FeatureVector fv
            )
        {
            float score_p1 = 0.0f;
            float score_p2 = 0.0f;//2Pは、負の数なほどグッドということに注意。



            srcSky.Foreach_Starlights((Finger finger, IMoveHalf light, ref bool toBreak) =>
            {
                RO_Starlight ms = (RO_Starlight)light;

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

                // 駒の種類による点数
                float komaScore_temp = fv.Komawari[(int)koma.Komasyurui];

                // 持ち駒は、価値を高めます。(ボーナス)序盤に駒をぽんぽん打つのを防ぐため。
                if (
                    (Okiba.Sente_Komadai | Okiba.Gote_Komadai).HasFlag(Conv_SyElement.ToOkiba(koma.Masu))
                    )
                {
                    //komaScore_temp *= 1.05f;// 1.05倍だと、相手の桂馬の利きに、桂馬をタダ捨てした。足りてないか。
                    komaScore_temp *= 1.13f;
                    //komaScore_temp *= 1.25f;// 1.25倍だと、金、金、角を打たずに王手されて終わってしまった。ボーナスを付けすぎたか☆
                }


                if (koma.Pside == Playerside.P1)
                {
                    score_p1 += komaScore_temp;
                }
                else
                {
                    // 駒割は、他の評価値と違って、
                    // 1プレイヤーも、2プレイヤーも正の数になっている。
                    // 2プレイヤーは 符号を反転させること。
                    score_p2 += -komaScore_temp;
                }
            });

            //
            // 2プレイヤーは 負の数になっている(負の数が多いほど有利)ので、
            // 足すだけでいい。
            //
            out_score = score_p1 + score_p2;

            //----------------------------------------
            // 明細項目
            //----------------------------------------
#if DEBUG || LEARN
            string utiwake = "";
            // 明細
            {
                StringBuilder sb = new StringBuilder();
                sb.Append("駒割");
                utiwake = sb.ToString();
            }

            // 明細項目
            out_meisaiKoumoku_orNull = new KyHyokaMeisai_KoumokuImpl(utiwake, out_score);
#endif
        }
예제 #14
0
        /// <summary>
        /// ************************************************************************************************************************
        /// HTML出力。(これは作者のホームページ用に書かれています)
        /// ************************************************************************************************************************
        /// </summary>
        public static string CreateHtml(MainGui_Csharp mainGui)
        {
            StringBuilder sb = new StringBuilder();

            sb.AppendLine("<div style=\"position:relative; left:0px; top:0px; border:solid 1px black; width:250px; height:180px;\">");

            // 後手の持ち駒
            sb.AppendLine("    <div style=\"position:absolute; left:0px; top:2px; width:30px;\">");
            sb.AppendLine("        △後手");
            sb.AppendLine("        <div style=\"margin-top:10px; width:30px;\">");
            sb.Append("            ");

            SkyConst siteiSky = mainGui.Model_Manual.GuiSkyConst;

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


                if (Conv_SyElement.ToOkiba(koma.Masu) == Okiba.Gote_Komadai)
                {
                    sb.Append(Util_Komasyurui14.Fugo[(int)Util_Komahaiyaku184.Syurui(koma.Haiyaku)]);
                }
            });

            sb.AppendLine("        </div>");
            sb.AppendLine("    </div>");

            // 将棋盤
            sb.AppendLine("    <div style=\"position:absolute; left:30px; top:2px; width:182px;\">");
            sb.AppendLine("        <table>");
            for (int dan = 1; dan <= 9; dan++)
            {
                sb.Append("        <tr>");
                for (int suji = 9; 1 <= suji; suji--)
                {
                    bool isSpace = true;

                    siteiSky.Foreach_Starlights((Finger finger, IMoveHalf ml, ref bool toBreak) =>
                    {
                        RO_Star koma2 = Util_Starlightable.AsKoma(ml.Now);


                        int suji2;
                        Util_MasuNum.TryMasuToSuji(koma2.Masu, out suji2);

                        int dan2;
                        Util_MasuNum.TryMasuToDan(koma2.Masu, out dan2);

                        if (
                            Conv_SyElement.ToOkiba(koma2.Masu) == Okiba.ShogiBan && //盤上
                            suji2 == suji &&
                            dan2 == dan
                            )
                        {
                            if (Playerside.P2 == koma2.Pside)
                            {
                                sb.Append("<td><span class=\"koma2x\">");
                                sb.Append(Util_Komasyurui14.Fugo[(int)Util_Komahaiyaku184.Syurui(koma2.Haiyaku)]);
                                sb.Append("</span></td>");
                                isSpace = false;
                            }
                            else
                            {
                                sb.Append("<td><span class=\"koma1x\">");
                                sb.Append(Util_Komasyurui14.Fugo[(int)Util_Komahaiyaku184.Syurui(koma2.Haiyaku)]);
                                sb.Append("</span></td>");
                                isSpace = false;
                            }
                        }
                    });

                    if (isSpace)
                    {
                        sb.Append("<td> </td>");
                    }
                }

                sb.AppendLine("</tr>");
            }
            sb.AppendLine("        </table>");
            sb.AppendLine("    </div>");

            // 先手の持ち駒
            sb.AppendLine("    <div style=\"position:absolute; left:215px; top:2px; width:30px;\">");
            sb.AppendLine("        ▲先手");
            sb.AppendLine("        <div style=\"margin-top:10px; width:30px;\">");
            sb.Append("            ");

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

                if (Conv_SyElement.ToOkiba(koma.Masu) == Okiba.Sente_Komadai)
                {
                    sb.Append(Util_Komasyurui14.Fugo[(int)Util_Komahaiyaku184.Syurui(koma.Haiyaku)]);
                }
            });

            sb.AppendLine("        </div>");
            sb.AppendLine("    </div>");

            //
            sb.AppendLine("</div>");

            return(sb.ToString());
        }
예제 #15
0
        /// <summary>
        /// 評価値を返します。先手が有利ならプラス、後手が有利ならマイナス、互角は 0.0 です。
        /// </summary>
        /// <param name="input_node"></param>
        /// <returns></returns>
        public override void Evaluate(
            out float out_score,
#if DEBUG || LEARN
            out KyHyokaMeisai_Koumoku out_meisaiKoumoku_orNull,
#endif
            SkyConst src_Sky,
            FeatureVector fv
            )
        {
            out_score = 0.0f;            // -999~999(*bairitu) が 40×40個ほど足し合わせた数になるはず。


#if DEBUG
            float[] komabetuMeisai = new float[Finger_Honshogi.Items_KomaOnly.Length];
#endif
            //
            // 盤上にある駒だけ、項目番号を調べます。
            //

            //----------------------------------------
            // 項目番号リスト
            //----------------------------------------
            //
            // 40個の駒と、14種類の持ち駒があるだけなので、
            // 54個サイズの長さがあれば足りるんだぜ☆ 固定長にしておこう☆
            //
            int   nextIndex            = 0;
            int[] komokuArray_unsorted = new int[54];                       //昇順でなくても構わないアルゴリズムにすること。

            for (int i = 0; i < Finger_Honshogi.Items_KomaOnly.Length; i++) // 全駒
            {
                RO_Star koma = Util_Starlightable.AsKoma(src_Sky.StarlightIndexOf(Finger_Honshogi.Items_KomaOnly[i]).Now);

                if (Okiba.ShogiBan == Conv_SyElement.ToOkiba(koma.Masu))
                {
                    // 盤上
                    komokuArray_unsorted[nextIndex] = Util_FvParamIndex.ParamIndex_Banjo(koma);
                    nextIndex++;
                }
                else
                {
                    // 持ち駒は、ここでは無視します。
                }
            }
            // 持ち駒:先後×7種類
            for (int iPside = 0; iPside < Array_Playerside.Items_PlayerOnly.Length; iPside++)
            {
                for (int iKomasyurui = 0; iKomasyurui < Array_Komasyurui.MotiKoma7Syurui.Length; iKomasyurui++)
                {
                    komokuArray_unsorted[nextIndex] = Util_FvParamIndex.ParamIndex_Moti(src_Sky, Array_Playerside.Items_PlayerOnly[iPside], Array_Komasyurui.MotiKoma7Syurui[iKomasyurui]);
                    nextIndex++;
                }
            }
            //Array.Sort(komokuArray_unsorted);

            //
            //
            // 例えば、[1P1三歩、2P2一桂]という組み合わせと、[2P2一桂、1P1三歩]という組み合わせは、同じだが欄が2つある。
            // そこで、表の半分を省きたい。
            // しかし、表を三角形にするためには、要素は昇順にソートされている必要がある。
            // 合法手1つごとにソートしていては、本末転倒。
            // そこで、表は正方形に読み、内容は三角形の部分にだけ入っているということにする。
            //
            //
            // 例えば、[1P1三歩、1P1三歩]という組み合わせもある。これは、自分自身の絶対位置の評価として試しに、残しておいてみる☆
            //
            //
            for (int iA = 0; iA < nextIndex; iA++)
            {
                int p1 = komokuArray_unsorted[iA];

                for (int iB = 0; iB < nextIndex; iB++)
                {
                    int p2 = komokuArray_unsorted[iB];

                    if (p1 <= p2) // 「p2 < p1」という組み合わせは同じ意味なので省く。「p1==p2」は省かない。
                    {
                        //----------------------------------------
                        // よし、組み合わせだぜ☆!
                        //----------------------------------------
                        out_score += fv.NikomaKankeiPp_ForMemory[p1, p2];
                    }
                    else
                    {
                        //----------------------------------------
                        // 使っていない方の三角形だぜ☆!
                        //----------------------------------------

                        // スルー。
                    }
                }
            }

            //----------------------------------------
            // 明細項目
            //----------------------------------------
#if DEBUG || LEARN
            string utiwake = "";
            // 内訳
            {
                StringBuilder sb = new StringBuilder();

                sb.Append(" PP ");
                sb.Append(out_score);
                sb.Append("点");

                utiwake = sb.ToString();
            }
            out_meisaiKoumoku_orNull = new KyHyokaMeisai_KoumokuImpl(utiwake, out_score);
#endif
        }
예제 #16
0
        /// <summary>
        /// 54駒のリスト。
        ///
        /// 盤上の40駒リスト。
        /// 駒台の14駒リスト。
        /// </summary>
        public static N54List Calc_54List(SkyConst src_Sky)
        {
            N54List result_n54List = new N54ListImpl();


            //----------------------------------------
            // インナー・メソッド用 集計変数
            //----------------------------------------
            int p54Next = 0;

            int[] p54List = new int[54];

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

                //----------------------------------------
                // まず、p を調べます。
                //----------------------------------------
                if (Conv_SyElement.ToOkiba(koma.Masu) == Okiba.ShogiBan)
                {
                    int pIndex = FeatureVectorImpl.CHOSA_KOMOKU_ERROR;// 調査項目P1
                    //----------------------------------------
                    // 盤上の駒
                    //----------------------------------------
                    Conv_FvKoumoku525.ToPIndex_FromBanjo_PsideKomasyuruiMasu(koma.Pside, koma.Komasyurui, koma.Masu, out pIndex);

                    if (FeatureVectorImpl.CHOSA_KOMOKU_ERROR == pIndex)
                    {
                        // p1 がエラーでは、処理は続けられない。
                        Util_54List.Panic1(koma);
                        goto gt_NextLoop_player1;
                    }

                    //----------------------------------------
                    // 盤上の駒だぜ☆!
                    //----------------------------------------
                    p54List[p54Next] = pIndex;
                    p54Next++;
                }
                else if (
                    Conv_SyElement.ToOkiba(koma.Masu) == Okiba.Sente_Komadai ||
                    Conv_SyElement.ToOkiba(koma.Masu) == Okiba.Gote_Komadai)
                {
                    int pIndex = FeatureVectorImpl.CHOSA_KOMOKU_ERROR;// 調査項目P1
                    //----------------------------------------
                    // 持ち駒
                    //----------------------------------------
                    PieceType motiKomasyurui = koma.ToNarazuCase();//例:駒台に馬はない。角の数を数える。
                    // 駒の枚数
                    int maisu = Util_Sky_FingersQuery.InOkibaKomasyuruiNow(src_Sky, Conv_Playerside.ToKomadai(koma.Pside), motiKomasyurui).Items.Count;
                    Conv_FvKoumoku525.ToPIndex_FromMoti_PsideKomasyuruiMaisu(koma.Pside, motiKomasyurui, maisu, out pIndex);

                    if (FeatureVectorImpl.CHOSA_KOMOKU_ERROR == pIndex)
                    {
                        // p1 がエラーでは、処理は続けられない。
                        Util_54List.Panic1(koma);
                        goto gt_NextLoop_player1;
                    }

                    //----------------------------------------
                    // 駒台の駒だぜ☆!
                    //----------------------------------------
                    p54List[p54Next] = pIndex;
                    p54Next++;
                }

                gt_NextLoop_player1:
                ;
            });


            result_n54List.SetP54List_Unsorted(p54List);
            result_n54List.SetP54Next(p54Next);

            return(result_n54List);
        }
예제 #17
0
        public static Okiba ToOkiba(SyElement masu)
        {
            int masuNumber = Conv_SyElement.ToMasuNumber(masu);

            return(Conv_SyElement.ToOkiba(masuNumber));
        }
예제 #18
0
        public void Go(string btime, string wtime, string byoyomi, string binc, string winc)
        {
            //------------------------------------------------------------
            // あなたの手番です
            //------------------------------------------------------------
            //
            // 図.
            //
            //      log.txt
            //      ┌────────────────────────────────────────
            //      ~
            //      │2014/08/02 2:36:19> go btime 599000 wtime 600000 byoyomi 60000
            //      │
            //
            // もう指していいときに、将棋所から送られてくる文字が go です。
            //


            //------------------------------------------------------------
            // 先手 3:00  後手 0:00  記録係「50秒ぉ~」
            //------------------------------------------------------------
            //
            // 上図のメッセージのままだと使いにくいので、
            // あとで使いやすいように Key と Value の表に分けて持ち直します。
            //
            // 図.
            //
            //      goDictionary
            //      ┌──────┬──────┐
            //      │Key         │Value       │
            //      ┝━━━━━━┿━━━━━━┥
            //      │btime       │599000      │
            //      ├──────┼──────┤
            //      │wtime       │600000      │
            //      ├──────┼──────┤
            //      │byoyomi     │60000       │
            //      └──────┴──────┘
            //      単位はミリ秒ですので、599000 は 59.9秒 です。
            //
            //----------------------------------------
            // 棋譜ツリー、局面データは、position コマンドで先に与えられているものとします。
            //----------------------------------------

            // ┏━━━━プログラム━━━━┓

            int latestTemezumi = this.Game.Kifu.CurNode.Value.KyokumenConst.Temezumi;     //現・手目済

            SkyConst src_Sky = this.Game.Kifu.NodeAt(latestTemezumi).Value.KyokumenConst; //現局面

            //Logger.Trace($"将棋サーバー「{latestTemezumi}手目、きふわらべ さんの手番ですよ!」 {line}");


            //----------------------------------------
            // 王の状態を調べます。
            //----------------------------------------
            Result_KingState result_kingState;

            {
                result_kingState = Result_KingState.Empty;

                RO_Star king1p = Util_Starlightable.AsKoma(src_Sky.StarlightIndexOf(Finger_Honshogi.SenteOh).Now);
                RO_Star king2p = Util_Starlightable.AsKoma(src_Sky.StarlightIndexOf(Finger_Honshogi.GoteOh).Now);
                //Logger.Trace("将棋サーバー「ではここで、王さまがどこにいるか確認してみましょう」");
                //Logger.Trace($"▲王の置き場={Conv_SyElement.Masu_ToOkiba(koma1.Masu)}");
                //Logger.Trace($"△王の置き場={Conv_SyElement.Masu_ToOkiba(koma2.Masu)}");

                if (Conv_SyElement.ToOkiba(king1p.Masu) != Okiba.ShogiBan)
                {
                    // 先手の王さまが将棋盤上にいないとき☆
                    result_kingState = Result_KingState.Lost_SenteOh;
                }
                else if (Conv_SyElement.ToOkiba(king2p.Masu) != Okiba.ShogiBan)
                {
                    // または、後手の王さまが将棋盤上にいないとき☆
                    result_kingState = Result_KingState.Lost_GoteOh;
                }
                else
                {
                    result_kingState = Result_KingState.Empty;
                }
            }

            //------------------------------------------------------------
            // わたしの手番のとき、王様が 将棋盤上からいなくなっていれば、投了します。
            //------------------------------------------------------------
            //
            //      将棋GUI『きふならべ』用☆ 将棋盤上に王さまがいないときに、本将棋で go コマンドが送られてくることは無いのでは☆?
            //
            switch (result_kingState)
            {
            case Result_KingState.Lost_SenteOh:   // 先手の王さまが将棋盤上にいないとき☆
            case Result_KingState.Lost_GoteOh:    // または、後手の王さまが将棋盤上にいないとき☆
            {
                //------------------------------------------------------------
                // 投了
                //------------------------------------------------------------
                //
                // 図.
                //
                //      log.txt
                //      ┌────────────────────────────────────────
                //      ~
                //      │2014/08/02 2:36:21< bestmove resign
                //      │
                //

                // この将棋エンジンは、後手とします。
                // 20手目、投了  を決め打ちで返します。
                Playing.Send("bestmove resign");        //投了
            }
            break;

            default:    // どちらの王さまも、まだまだ健在だぜ☆!
            {
                List <KifuNode> bestKifuNodeList = new List <KifuNode>();

                //------------------------------------------------------------
                // 指し手のチョイス
                //------------------------------------------------------------
                bool isHonshogi = true;



                //------------------------------------------------------------
                // MultiPV のテスト中☆
                //------------------------------------------------------------
                //
                // 指し手を決めます。
                // TODO: その指し手の評価値がいくらだったのか調べたい。
                //
                // FIXME: ログがMultiPV別になっていないので、混ざって、同じ手を2度指しているみたいに見えてしまう☆
                //
                int multiPV_Count = 1;        // 2;
                {
                    // 最善手、次善手、三次善手、四次善手、五次善手
                    for (int iMultiPV = 0; iMultiPV < multiPV_Count; iMultiPV++)
                    {
                        bestKifuNodeList.Add(this.WA_Bestmove(
                                                 isHonshogi,
                                                 this.Game.Kifu)
                                             );
                    }


#if DEBUG
                    //// 内容をログ出力
                    //// 最善手、次善手、三次善手、四次善手、五次善手
                    //StringBuilder sb = new StringBuilder();
                    //for (int iMultiPV = 0; iMultiPV < 5; iMultiPV++)
                    //{
                    //    string sfenText = Util_Sky.ToSfenMoveText(bestMoveList[iMultiPV]);
                    //    sb.AppendLine($"[{iMultiPV}]{sfenText}");
                    //}
                    //System.Windows.Forms.MessageBox.Show(sb.ToString());
#endif
                }

                KifuNode bestKifuNode = null;
                // 最善手、次善手、三次善手、四次善手、五次善手
                float bestScore = float.MinValue;
                for (int iMultiPV = 0; iMultiPV < bestKifuNodeList.Count; iMultiPV++)
                {
                    KifuNode node = bestKifuNodeList[iMultiPV];

                    if (null != node && null != node.KyHyokaSheet_Mutable && bestScore <= node.Score)
                    {
                        bestScore    = node.Score;
                        bestKifuNode = node;
                    }
                }

                IMove bestMove2;
                if (null == bestKifuNode)
                {
                    // 投了
                    bestMove2 = Util_Sky258A.NullObjectMove;
                }
                else
                {
                    bestMove2 = bestKifuNode.Key;
                }

                if (Util_Sky_BoolQuery.isEnableSfen(bestMove2))
                {
                    string sfenText = ConvMoveStrSfen.ToMoveStrSfen(bestMove2);

                    // ログが重過ぎる☆!
                    //Logger.Trace($"(Warabe)指し手のチョイス: bestmove=[{sfenText}] 棋譜={KirokuGakari.ToJsaKifuText(this.Kifu)}");

                    //----------------------------------------
                    // スコア 試し
                    //----------------------------------------
                    {
                        //int hyojiScore = (int)(bestScore / 100.0d);//FIXME:適当に調整した。
                        int hyojiScore = (int)bestScore;
                        if (this.Game.Kifu.CurNode.Value.KyokumenConst.KaisiPside == Playerside.P2)
                        {
                            // 符号を逆転
                            hyojiScore = -hyojiScore;
                        }
                        Playing.Send($"info time 1 depth 1 nodes 1 score cp {hyojiScore.ToString()} pv ");        //FIXME:
                        //+ " pv 3a3b L*4h 4c4d"
                    }


                    //----------------------------------------
                    // 指し手を送ります。
                    //----------------------------------------
                    Playing.Send($"bestmove {sfenText}");
                }
                else         // 指し手がないときは、SFENが書けない☆ 投了だぜ☆
                {
                    // ログが重過ぎる☆!
                    //Logger.Trace($"(Warabe)指し手のチョイス: 指し手がないときは、SFENが書けない☆ 投了だぜ☆ww(>_<) 棋譜={KirokuGakari.ToJsaKifuText(this.Kifu)}");

                    //----------------------------------------
                    // 投了w!
                    //----------------------------------------
                    Playing.Send("bestmove resign");
                }

                //------------------------------------------------------------
                // 以前の手カッター
                //------------------------------------------------------------
                UtilKifuTree282.IzennoHenkaCutter(this.Game.Kifu);
            }
            break;
            }
            // ┗━━━━プログラム━━━━┛

            // Logger.Trace();

            //throw new Exception("デバッグだぜ☆! エラーはキャッチできたかな~☆?(^▽^)");
        }