예제 #1
0
            public void Tukurinaosi_Remake()
            {
                valueKmMs = new int[Conv_Koma.itiran.Length][];

                Bitboard bb_ibashoCopy    = new Bitboard();
                Bitboard bb_ugokikataCopy = new Bitboard();

                // 盤上
                foreach (Piece km_all in Conv_Koma.itiran)
                {
                    Taikyokusya tai = Med_Koma.KomaToTaikyokusya(km_all);
                    Komasyurui  ks  = Med_Koma.KomaToKomasyurui(km_all);
                    valueKmMs[(int)km_all] = new int[PureSettei.banHeimen];

                    PureMemory.gky_ky.yomiKy.yomiShogiban.yomiIbashoBan.ToSet_Koma(km_all, bb_ibashoCopy);
                    Masu ms_ibasho;
                    while (bb_ibashoCopy.Ref_PopNTZ(out ms_ibasho))
                    {
                        BitboardsOmatome.KomanoUgokikataYk00.ToSet_Merge(
                            km_all,
                            ms_ibasho,
                            bb_ugokikataCopy);

                        Masu ms_kiki;
                        while (bb_ugokikataCopy.Ref_PopNTZ(out ms_kiki))
                        {
                            valueKmMs[(int)km_all][(int)ms_kiki]++;
                        }
                    }
                }
            }
예제 #2
0
        /// <summary>
        /// 局面ハッシュを再計算するぜ☆(^▽^)
        /// </summary>
        /// <returns></returns>
        public void Tukurinaosi(Kyokumen ky)
        {
            ulong hash = 0;

            // 盤上
            Bitboard komaBB = new Bitboard();

            for (int iTai = 0; iTai < Conv_Taikyokusya.AllOptionalPhaseList.Length; iTai++)
            {
                var optionalPhase = Conv_Taikyokusya.AllOptionalPhaseList[iTai];
                for (int iKs = 0; iKs < Conv_Komasyurui.Itiran.Length; iKs++)
                {
                    Komasyurui ks = Conv_Komasyurui.Itiran[iKs];
                    Koma       km = Med_Koma.KomasyuruiAndTaikyokusyaToKoma(ks, optionalPhase);

                    ky.Shogiban.ToSet_BBKoma(km, komaBB);
                    while (komaBB.Ref_PopNTZ(out Masu ms))
                    {
                        hash ^= Util_ZobristHashing.GetBanjoKey(ms, km, ky.Sindan);
                    }
                }
            }

            // 持ち駒
            foreach (MotiKoma mk in Conv_MotiKoma.Itiran)
            {
                hash ^= Util_ZobristHashing.GetMotiKey(ky.Sindan, mk);
            }


            // 手番
            hash ^= Util_ZobristHashing.GetTaikyokusyaKey(ky.CurrentOptionalPhase, ky.Sindan);

            Value = hash;
        }
예제 #3
0
 /// <summary>
 /// 改造Fen用の文字列を返すぜ☆(^▽^)
 /// </summary>
 /// <param name="ks"></param>
 /// <returns></returns>
 public static void AppendFenTo(bool isSfen, Komasyurui ks, StringBuilder syuturyoku)
 {
     if (isSfen)
     {
         syuturyoku.Append(Conv_Komasyurui.m_sfen_[(int)ks]);
     }
     else
     {
         syuturyoku.Append(Conv_Komasyurui.m_dfen_[(int)ks]);
     }
 }
예제 #4
0
        /// <summary>
        /// カーソル位置に挿入。
        /// カーソルは1進み、エンドは進んだカーソル位置に合わせるぜ☆(^~^)
        /// </summary>
        /// <param name="ss"></param>
        /// <param name="ssType"></param>
        public static void AddKifu(Move ss, MoveType ssType, Komasyurui toraretaKs)
        {
            PureMemory.kifu_moveArray[PureMemory.kifu_endTeme]     = ss;
            PureMemory.kifu_moveTypeArray[PureMemory.kifu_endTeme] = ssType;

            // 取った駒の種類を覚えておくぜ☆(^▽^)
            PureMemory.kifu_toraretaKsAr[PureMemory.kifu_endTeme] = toraretaKs;

            // 棋譜を進めるぜ☆(^~^)
            PureMemory.AddTeme();
        }
예제 #5
0
 public static bool SetSsssMotMks_AndHasMotigoma(MotigomaSyurui val)
 {
     ssss_mot_mks_ = val;
     ssss_mot_mg_  = Med_Koma.MotiKomasyuruiAndTaikyokusyaToMotiKoma(val, kifu_teban);
     if (gky_ky.motigomaItiran.yomiMotigomaItiran.HasMotigoma(ssss_mot_mg_))
     {
         // 持ち駒を持っているときだけセットするぜ☆(^~^)
         ssss_mot_km_ = Med_Koma.MotiKomasyuruiAndTaikyokusyaToKoma(ssss_mot_mks_, kifu_teban);
         ssss_mot_ks_ = Med_Koma.MotiKomasyuruiToKomasyrui(ssss_mot_mks_);
         return(true);
     }
     return(false);
 }
예제 #6
0
 public bool Exists(Taikyokusya tai, Masu ms, out Komasyurui out_ks)
 {
     for (int iKm = 0; iKm < Conv_Koma.itiranTai[(int)tai].Length; iKm++)
     {
         Piece km = Conv_Koma.itiranTai[(int)tai][iKm];
         if (valueKm[(int)km].IsOn(ms))
         {
             out_ks = Med_Koma.KomaToKomasyurui(km);
             return(true);
         }
     }
     out_ks = Komasyurui.Yososu;
     return(false);
 }
예제 #7
0
        /// <summary>
        /// 取った駒を、駒台に置くぜ☆(^▽^)
        /// </summary>
        /// <returns></returns>
        public static bool TryFail_DaiOn(
            Piece km_c,// あれば、移動先の相手の駒(取られる駒; capture)
            Komasyurui ks_c,
            Motigoma mk_c

#if DEBUG
            , FenSyurui f
            , IDebugMojiretu dbg_reigai
#endif
            )
        {
            //────────────────────────────────────────
            // 状況:
            //          移動先に駒があれば……。
            //────────────────────────────────────────
            #region 駒を取る
            if (km_c != Piece.Kuhaku)
            {
                // 駒取るぜ☆(^▽^)!

                // ただし、らいおんを除く
                if (ks_c != Komasyurui.R) // らいおん を取っても、持駒は増えないぜ☆
                {
                    //────────────────────────────────────────
                    // C    [1]     取る前の 持ち駒が増える前の 駒台が在る
                    //────────────────────────────────────────

                    //────────────────────────────────────────
                    //  C    [遷移]    取った持ち駒を増やす
                    //────────────────────────────────────────
                    // 取る前の持ち駒をリカウントする
                    // 増やす
                    PureMemory.gky_ky.motigomaItiran.Fuyasu(mk_c);

                    // TODO: 駒割りを増やすならここだぜ☆(^~^)


                    //────────────────────────────────────────
                    // C   [3]  取った後の 持駒が1つ増えた 駒台が在る
                    //────────────────────────────────────────
                }
            }
            #endregion

            return(Pure.SUCCESSFUL_FALSE);
        }
예제 #8
0
        /// <summary>
        /// 改造Fen用の文字列を返すぜ☆(^▽^)
        /// </summary>
        /// <param name="ks"></param>
        /// <returns></returns>
        public static string ToFen(FenSyurui f, Komasyurui ks)
        {
            switch (f)
            {
            case FenSyurui.sfe_n:
            {
                return(Conv_Komasyurui.m_sfen_[(int)ks]);
            }

            case FenSyurui.dfe_n:
            {
                return(Conv_Komasyurui.m_dfen_[(int)ks]);
            }

            default:
                throw new Exception(string.Format("未定義 {0}", f));
            }
        }
예제 #9
0
        /// <summary>
        /// 局面に点数を付けるぜ☆(^▽^)
        ///
        /// どちらの対局者でも、自分に有利と思っていれば正の数の方向に点数が付くぜ☆(^▽^)
        /// </summary>
        /// <param name="ky_base"></param>
        /// <returns></returns>
        public void Tukurinaosi(Kyokumen.Sindanyo kys)
        {
            Hyokati[] hyokati = new Hyokati[] { Hyokati.Hyokati_Rei, Hyokati.Hyokati_Rei
                                                , Hyokati.Hyokati_Rei // 空白は手番なしで ここに入れるぜ☆(^~^)
            };

            // 盤上
            Bitboard komaBB = new Bitboard();

            for (int iTai = 0; iTai < Conv_Taikyokusya.AllOptionalPhaseList.Length; iTai++)
            {
                var optionalPhase = Conv_Taikyokusya.AllOptionalPhaseList[iTai];
                for (int iKs = 0; iKs < Conv_Komasyurui.Itiran.Length; iKs++)
                {
                    Komasyurui ks = Conv_Komasyurui.Itiran[iKs];

                    kys.ToSetIbasho(Med_Koma.KomasyuruiAndTaikyokusyaToKoma(ks, optionalPhase), komaBB);
                    while (komaBB.Ref_PopNTZ(out Masu ms_jissai))
                    {
                        hyokati[iTai] += Conv_Koma.BanjoKomaHyokatiNumber[(int)Med_Koma.KomasyuruiAndTaikyokusyaToKoma(ks, optionalPhase)];
                    }
                }
            }

            // 持ち駒
            foreach (MotiKoma mk in Conv_MotiKoma.Itiran)
            {
                var            optionalPhase = Med_Koma.MotiKomaToPhase(mk);
                var            phaseIndex    = OptionalPhase.IndexOf(optionalPhase);
                MotiKomasyurui mks           = Med_Koma.MotiKomaToMotiKomasyrui(mk);
                Hyokati        komaHyokati   = Conv_Hyokati.KomaHyokati[(int)Med_Koma.MotiKomasyuruiAndPhaseToKoma(mks, optionalPhase)];

                hyokati[phaseIndex] += (int)komaHyokati * kys.CountMotikoma(mk);
            }

            // 手番 - 相手番
            Hyokati hyokatiP1 = hyokati[(int)Phase.Black];

            hyokati[(int)Phase.Black] -= hyokati[(int)Phase.White];
            hyokati[(int)Phase.White] -= hyokatiP1;
            KomawariHyokati_Sabun      = hyokati;
        }
예제 #10
0
        public static bool MatchKomasyurui(string line, ref int caret, out Komasyurui out_ks)
        {
            Match m = GetKomaPattern(PureSettei.fenSyurui).Match(line, caret);

            if (m.Success)
            {
                // キャレットを進めます
                Util_String.SkipMatch(line, ref caret, m);

                // 駒種類(FIXME: 後手の表記だと誤動作になるか?)
                string ks_moji = m.Groups[1].Value;
                out_ks = Med_Parser.MojiToKomasyurui(PureSettei.fenSyurui, ks_moji);
                return(true);
            }
            else
            {
                out_ks = Komasyurui.Yososu;
                return(false);
            }
        }
예제 #11
0
        /// <summary>
        /// 将棋盤を180度ひっくり返すぜ☆(^▽^)
        /// 主にテスト用だぜ☆(^▽^)
        ///
        /// 参考:「ビットの並びを反転する」http://blog.livedoor.jp/techblog1/archives/5365383.html
        /// </summary>
        public static void Hanten()
        {
            // 盤上
            {
                // 左右反転して、先後も入替
                Bitboard tmp_T1 = PureMemory.gky_ky.shogiban.ibashoBan_yk00.CloneBB_KomaZenbu(Taikyokusya.T1);
                Bitboard tmp_T2 = PureMemory.gky_ky.shogiban.ibashoBan_yk00.CloneBB_KomaZenbu(Taikyokusya.T2);
                tmp_T1.Bitflip128();
                tmp_T2.Bitflip128();
                PureMemory.gky_ky.shogiban.ibashoBan_yk00.Set_KomaZenbu(Taikyokusya.T1, tmp_T1);
                PureMemory.gky_ky.shogiban.ibashoBan_yk00.Set_KomaZenbu(Taikyokusya.T2, tmp_T2);

                for (int iKs = 0; iKs < Conv_Komasyurui.itiran.Length; iKs++)
                {
                    Komasyurui ks = Conv_Komasyurui.itiran[iKs];

                    Piece km1 = Med_Koma.KomasyuruiAndTaikyokusyaToKoma(ks, Taikyokusya.T1);
                    tmp_T1 = PureMemory.gky_ky.shogiban.ibashoBan_yk00.CloneBb_Koma(km1);
                    tmp_T1.Bitflip128();
                    PureMemory.gky_ky.shogiban.ibashoBan_yk00.Set_Koma(km1, tmp_T1);

                    Piece km2 = Med_Koma.KomasyuruiAndTaikyokusyaToKoma(ks, Taikyokusya.T2);
                    tmp_T2 = PureMemory.gky_ky.shogiban.ibashoBan_yk00.CloneBb_Koma(km2);
                    tmp_T2.Bitflip128();
                    PureMemory.gky_ky.shogiban.ibashoBan_yk00.Set_Koma(km2, tmp_T2);
                }
                // 盤面反転、駒の先後も反転だぜ☆(^▽^)
            }
            // 持ち駒
            {
                MotigomaItiran tmp = new MotigomaItiran();
                foreach (Motigoma mk in Conv_Motigoma.itiran)
                {
                    MotigomaSyurui mks            = Med_Koma.MotiKomaToMotiKomasyrui(mk);
                    Taikyokusya    tai            = Med_Koma.MotiKomaToTaikyokusya(mk);
                    Motigoma       hantenMotikoma = Med_Koma.MotiKomasyuruiAndTaikyokusyaToMotiKoma(mks, Conv_Taikyokusya.Hanten(tai));
                    tmp.Set(mk, PureMemory.gky_ky.motigomaItiran.yomiMotigomaItiran.Count(hantenMotikoma));
                }
                PureMemory.gky_ky.motigomaItiran.Set(tmp);
            }
        }
예제 #12
0
        /// <summary>
        /// 移動先の相手番の駒を取るぜ☆(^▽^)
        /// </summary>
        /// <returns></returns>
        public static bool TryFail_DstOff(
            Masu ms_t1,     // 移動先升
            Piece km_c,     // あれば、移動先の相手の駒(取られる駒; capture)
            Komasyurui ks_c // 取られた駒の種類
#if DEBUG
            , FenSyurui f
            , IDebugMojiretu dbg_reigai
#endif
            )
        {
            // 移動先に駒があるかどうかのチェックは先に終わらせておくこと☆(^~^)
            //────────────────────────────────────────
            // T2C  [1] 移動先に 相手の駒 が在る
            //────────────────────────────────────────

            //────────────────────────────────────────
            // T2C  [遷移]    移動先の 相手の駒 を除外する
            //────────────────────────────────────────
            Debug.Assert(Conv_Koma.IsOk(km_c), "km_c can not remove");

            if (PureMemory.gky_ky.shogiban.TryFail_TorinozokuKoma(
                    ms_t1,
                    km_c,
                    Conv_Masu.masu_error,
                    true
#if DEBUG
                    , dbg_reigai
#endif
                    ))
            {
                return(Pure.FailTrue("TryFail_Torinozoku(1)"));
            }

            //────────────────────────────────────────
            // T2C  [2]     移動先に 相手の駒 が無い
            //────────────────────────────────────────

            // ビットボードの駒の数は合っていないからチェックしないぜ☆
            return(Pure.SUCCESSFUL_FALSE);
        }
예제 #13
0
        /// <summary>
        /// 手番らいおん の逃げ道を開ける相手番の手かどうか調べるぜ☆(^▽^)
        /// </summary>
        /// <returns></returns>
        public bool IsNigemitiWoAkeru(Kyokumen ky, Komasyurui ks_aite, Masu ms_t0, Masu ms_t1)
        {
            if (NigemitiWoFusaideiruAiteNoKomaBB.IsOff(ms_t0))
            {
                // 逃げ道を塞いでいる駒ではないのなら、スルーするぜ☆(^▽^)
                return(false);
            }

            // 手番らいおん の8近傍 のどこかに、重ね利きの数 0 が出来ていれば、
            // 逃げ道を開けると判定するぜ☆(^▽^)
            bool akeru = false;
            Koma km_t0 = Med_Koma.KomasyuruiAndTaikyokusyaToKoma(ks_aite, CurrentOptionalPhase);
            Koma km_t1 = km_t0;// FIXME: 成りを考慮していない

            // 重ね利きの数を差分更新するぜ☆(^▽^)
            ky.Shogiban.N100_HerasuKiki(km_t0, ky.Sindan.CloneKomanoUgoki(km_t0, ms_t0), ky.Sindan);
            ky.Shogiban.N100_FuyasuKiki(km_t1, ky.Sindan.CloneKomanoUgoki(km_t1, ms_t1), ky.Sindan);

            Bitboard nigemitiBB = new Bitboard();

            nigemitiBB.Set(FriendRaion8KinboBB);
            nigemitiBB.Sitdown(FriendKomaBB);
            while (nigemitiBB.Ref_PopNTZ(out Masu ms_nigemiti))
            {
                if (0 == ky.Shogiban.CountKikisuZenbu(Conv_Taikyokusya.Reverse(CurrentOptionalPhase), ms_nigemiti)) // 相手番の利きが無くなったか☆(^▽^)
                {
                    akeru = true;                                                                                   // (^▽^)逃げ道が開いたぜ☆!
                    goto gt_EndLoop;
                }
            }
gt_EndLoop:
            ;

            // 重ね利きの数の差分更新を、元に戻すぜ☆(^▽^)
            ky.Shogiban.N100_HerasuKiki(km_t1, ky.Sindan.CloneKomanoUgoki(km_t1, ms_t1), ky.Sindan);
            ky.Shogiban.N100_FuyasuKiki(km_t0, ky.Sindan.CloneKomanoUgoki(km_t0, ms_t0), ky.Sindan);

            return(akeru);
        }
예제 #14
0
        /// <summary>
        /// 局面(駒の配置)の一致判定だぜ☆(^▽^)
        ///
        /// 重い処理がある☆ 探索で使うような内容じゃないぜ☆(^~^)開発中用だぜ☆(^▽^)
        /// </summary>
        /// <param name="motiKomas1"></param>
        /// <returns></returns>
        public static bool Equals_ForDevelop(Shogiban shogiban_hikaku, int[] motiKomas1)
        {
            Debug.Assert(PureMemory.gky_ky.yomiKy.yomiMotigomaItiran.GetArrayLength() == motiKomas1.Length, "局面の一致判定");

            // 盤上の一致判定
            for (int iTai = 0; iTai < Conv_Taikyokusya.itiran.Length; iTai++)
            {
                Taikyokusya tai = (Taikyokusya)iTai;

                if (!PureMemory.gky_ky.shogiban.ibashoBan_yk00.yomiIbashoBan.Equals_KomaZenbu_ForDevelop(tai, shogiban_hikaku.ibashoBan_yk00.yomiIbashoBan))
                {
                    return(false);
                }

                for (int iKs = 0; iKs < Conv_Komasyurui.itiran.Length; iKs++)
                {
                    Komasyurui ks = Conv_Komasyurui.itiran[iKs];
                    Piece      km = Med_Koma.KomasyuruiAndTaikyokusyaToKoma(ks, tai);

                    if (!PureMemory.gky_ky.shogiban.ibashoBan_yk00.yomiIbashoBan.Equals_Koma_ForDevelop(km, shogiban_hikaku.ibashoBan_yk00.yomiIbashoBan))
                    {
                        return(false);
                    }
                }
            }

            // 持ち駒の一致判定
            for (int iMk = 0; iMk < Conv_Motigoma.itiran.Length; iMk++)
            {
                if (PureMemory.gky_ky.yomiKy.yomiMotigomaItiran.Count((Motigoma)iMk) != motiKomas1[iMk])
                {
                    return(false);
                }
            }

            return(true);
        }
예제 #15
0
 /// <summary>
 /// 改造Fen用の文字列を返すぜ☆(^▽^)
 /// </summary>
 /// <param name="ks"></param>
 /// <returns></returns>
 public static void AppendFenTo(FenSyurui f, Komasyurui ks, StringBuilder syuturyoku)
 {
     syuturyoku.Append(ToFen(f, ks));
 }
예제 #16
0
 /// <summary>
 /// 目視確認用の文字列を返すぜ☆(^▽^)
 /// </summary>
 /// <param name="ks"></param>
 /// <returns></returns>
 public static void GetNingenyoMijikaiFugo(Komasyurui ks, StringBuilder syuturyoku)
 {
     syuturyoku.Append(Conv_Komasyurui.m_ningenyoMijikaiFugo_[(int)ks]);
 }
예제 #17
0
 public static Komasyurui ToNarazuCase(Komasyurui ks)
 {
     return(ItiranToNarazu[(int)ks]);
 }
예제 #18
0
 public static Komasyurui ToNariCase(Komasyurui ks)
 {
     return(itiranToNari[(int)ks]);
 }
예제 #19
0
        static PureMemory()
        {
            int taiLn = Conv_Taikyokusya.itiran.Length;

            #region 被王手判定
            // ビットボード
            hot_bb_checkerAr     = new Bitboard[taiLn];
            hot_bb_raion8KinboAr = new Bitboard[taiLn];
            hot_bb_nigemitiWoFusaideiruAiteNoKomaAr = new Bitboard[taiLn];
            hot_bb_nigereruAr = new Bitboard[taiLn];
            hot_bb_nigeroAr   = new Bitboard[taiLn];
            for (int iTai = 0; iTai < taiLn; iTai++)
            {
                hot_bb_checkerAr[iTai]     = new Bitboard();
                hot_bb_raion8KinboAr[iTai] = new Bitboard();
                hot_bb_nigemitiWoFusaideiruAiteNoKomaAr[iTai] = new Bitboard();
                hot_bb_nigereruAr[iTai] = new Bitboard();
                hot_bb_nigeroAr[iTai]   = new Bitboard();
            }

            hot_ms_raionAr             = new Masu[taiLn];
            hot_outeKomasCountAr       = new int[taiLn];
            hot_isNigerarenaiCheckerAr = new bool[taiLn];
            hot_raionCatchChosaAr      = new bool[taiLn];
            #endregion

            #region 指し手生成(シングルスレッドを想定)
            ssss_moveList             = new MoveList[PureMemory.MaxMoveDepth];
            ssss_moveListBad          = new MoveList[PureMemory.MaxMoveDepth];
            ssss_bbVar_idosaki_narazu = new Bitboard();
            ssss_bbVar_idosaki_nari   = new Bitboard();
            ssssTmp_bbVar_ibasho      = new Bitboard();

            ssss_bbBase_idosaki01_checker            = new Bitboard();
            ssss_bbBase_idosaki02_raionCatch         = new Bitboard();
            ssss_bbBase_idosaki03_nigeroTe           = new Bitboard();
            ssss_bbBase_idosaki04_try                = new Bitboard();
            ssss_bbBase_idosaki05_komaWoToruTe       = new Bitboard();
            ssss_bbBase_idosaki06_himodukiOteZasi    = new Bitboard();
            ssss_bbBase_idosaki07_suteOteZasi        = new Bitboard();
            ssss_bbBase_idosaki08_suteOteDa          = new Bitboard();
            ssss_bbBase_idosaki09_himodukiOteDa      = new Bitboard();
            ssss_bbBase_idosaki10_himodukiKanmanDa   = new Bitboard();
            ssss_bbBase_idosaki11_himodukiKanmanZasi = new Bitboard();
            ssss_bbBase_idosaki12_bottiKanmanZasi    = new Bitboard();
            ssss_bbBase_idosaki13_bottiKanmanDa      = new Bitboard();
            ssss_bbBase_idosaki14_suteKanmanZasi     = new Bitboard();
            ssss_bbBase_idosaki15_suteKanmanDa       = new Bitboard();

            ssss_movePickerWoNuketaBasho1 = "";

            for (int iFukasa = 0; iFukasa < PureMemory.MaxMoveDepth; iFukasa++)
            {
                ssss_moveList[iFukasa]    = new MoveList();
                ssss_moveListBad[iFukasa] = new MoveList();
            }
            #endregion

            #region ムーブス
            mvs_ssAr = new Move[KIFU_SIZE];
            #endregion
            #region 棋譜(コンピューター・プレイヤー同時に1つまで)
            kifu_syokiKyokumenFen = "";
            kifu_toraretaKsAr     = new Komasyurui[KIFU_SIZE];
            kifu_moveArray        = new Move[KIFU_SIZE];
            kifu_moveTypeArray    = new MoveType[KIFU_SIZE];
            // 手番☆(^~^)
            kifu_tebanAr_    = new Taikyokusya[KIFU_SIZE];
            kifu_aitebanAr_  = new Taikyokusya[KIFU_SIZE];
            kifu_nTebanAr_   = new int[KIFU_SIZE];
            kifu_nAitebanAr_ = new int[KIFU_SIZE];

            // 初期局面手番を未設定にしておいて、ResetTebanArray( ) すれば、手番配列の初期値が入るぜ☆(^~^)
            kifu_syokikyokumenTeban = Taikyokusya.Yososu;
            ResetTebanArray(Taikyokusya.T1);

            // 配列等の初期化が終わったあとで、手目をリセット
            ClearTeme(
                //kifu_syokikyokumenTeban
                );
            #endregion

            #region 現局面(棋譜カーソルが指している局面)(コンピューター・プレイヤー同時に1つまで)
            gky_kekka   = TaikyokuKekka.Karappo;
            gky_ky      = new Kyokumen();
            gky_hyokati = new Hyokati();
            Util_Control.UpdateRule(
#if DEBUG
                "static PureMemory"
#endif
                );
            #endregion

            #region 探索(tnsk)
            tnsk_kohoMove = Move.Toryo;
            #endregion
        }
예제 #20
0
 /// <summary>
 /// 目視確認用の文字列を返すぜ☆(^▽^)
 /// </summary>
 /// <param name="ks"></param>
 /// <returns></returns>
 public static void GetNingenyoMijikaiFugo(Komasyurui ks, StringBuilder hyoji)
 {
     hyoji.Append(Conv_Komasyurui.m_ningenyoMijikaiFugo_[(int)ks]);
 }
예제 #21
0
 public static Piece KomasyuruiAndTaikyokusyaToKoma(Komasyurui ks, Taikyokusya tb)
 {
     return(m_KomasyuruiAndTaikyokusyaToKoma_[(int)ks, (int)tb]);
 }
예제 #22
0
 public static bool MatchKomasyurui(string line, ref int caret, out Komasyurui out_ks)
 {
     return(Itiran_FenParser.MatchKomasyurui(line, ref caret, out out_ks));
 }
예제 #23
0
 public bool ExistsKoma(Taikyokusya tai, Masu ms, out Komasyurui ks)
 {
     return(hontai_.BBItiran_Komabetu.Exists(tai, ms, out ks));
 }
예제 #24
0
        /// <summary>
        /// 盤上の駒を置くぜ☆(^▽^)
        /// </summary>
        /// <param name="ms_t1"></param>
        /// <param name="km_t1"></param>
        /// <param name="updateKiki">利きを先に作るか、駒を先に並べるか、という循環が発生するのを防ぐために</param>
        public bool TryFail_OkuKoma(
            Masu ms_t1,
            Piece km_t1,
            bool updateKiki
#if DEBUG
            , IDebugMojiretu reigai1
#endif
            )
        {
            Debug.Assert(Conv_Koma.IsOk(km_t1), string.Format("置けない駒 km_t1 を置こうとしました。 km_t1={0}", km_t1));
            Debug.Assert(Conv_Masu.IsBanjo(ms_t1), string.Format("ms={0}", ms_t1));

            // 取り除いた駒は、どちらの対局者の物か☆(^~^)
            Taikyokusya tai_put = Med_Koma.KomaToTaikyokusya(km_t1);


            //──────────
            // とりあえず、盤に駒を置くんだぜ☆(^~^)
            //──────────
            OkuKoma(ms_t1, km_t1);

            //──────────
            // TODO: 駒が増えた現状に更新する
            //──────────
            if (updateKiki)
            {
                // 駒の利き割りの評価値を増やすならここで☆(^~^)

                //──────────
                // 駒が増えた後の、関連する飛び利きを消す
                //──────────
                // 置いた駒がある 縦列きりん、横列きりん、縦列いのしし、左上がりぞう、左下がりぞう を探す
                foreach (Taikyokusya tai in Conv_Taikyokusya.itiran)
                {
                    Komasyurui[] ksAr = new Komasyurui[]
                    {
                        Komasyurui.K,
                        Komasyurui.Z,
                        Komasyurui.S,
                    };

                    foreach (Komasyurui ks in ksAr)
                    {
                        Piece km_reverse = Med_Koma.KomasyuruiAndTaikyokusyaToKoma(ks, tai);

                        //bbTmp_kiki_forOku.Clear();
                        BitboardsOmatome.KomanoUgokikataYk00.ToSet_Merge(
                            km_reverse,       // 相手番の駒にして、利きを飛ばしてきている位置を調べるのに使う
                            ms_t1,            // 升
                            bbTmp_kiki_forOku // リーガルムーブの盤面を、ここに入れるぜ☆(^~^)
                            );

                        Masu ms_atk;
                        while (bbTmp_kiki_forOku.Ref_PopNTZ(out ms_atk))// 立っているビットを降ろすぜ☆
                        {
                            kikiBan.TorinozokuKiki(km_reverse, ms_atk);
                        }
                    }
                }

                //*
                // 利きを増やすぜ☆(^~^)
                kikiBan.OkuKiki(
                    km_t1, // 駒
                    ms_t1  // 升
                    );
                //*/
            }

            // TODO: 駒割り評価値を増やすならここだぜ☆(^~^)

            return(Pure.SUCCESSFUL_FALSE);
        }
예제 #25
0
        /// <summary>
        /// 盤上の駒を取り除く。
        ///
        /// よくある問題
        /// ──────
        ///
        /// (1)きりんA の右上に きりんB を打つ。
        /// (2)きりんB を取り除く。
        /// (3)このとき、きりんB の利きも取り除くが、きりんA と被っている利きもある。
        /// これを消してしまうと、利きが欠けた きりんA ができてしまい、整合性が取れない。
        ///
        /// </summary>
        /// <param name="ms_ibasho">取り除く駒がある升</param>
        /// <param name="km_remove">取り除く駒</param>
        /// <param name="ms_mirainihaKomagaAru">(飛び利き更新用)</param>
        /// <param name="updateKiki">偽にすると、利きを更新しません</param>
        /// <param name="yomiGky"></param>
        /// <param name="reigai1"></param>
        /// <returns></returns>
        public bool TryFail_TorinozokuKoma(
            Masu ms_ibasho,
            Piece km_remove,
            Masu ms_mirainihaKomagaAru,
            bool updateKiki

#if DEBUG
            , IDebugMojiretu reigai1
#endif
            )
        {
            Debug.Assert(Conv_Koma.IsOk(km_remove), "km_remove not ok");
            Debug.Assert(Conv_Masu.IsBanjo(ms_ibasho), "");

            // 取り除いた駒は、どちらの対局者の物か☆(^~^)
            Taikyokusya tai_removed = Med_Koma.KomaToTaikyokusya(km_remove);

            //────────────────────────────────────────
            // (1)利き表をいじる前☆(^▽^)
            //────────────────────────────────────────

            //──────────
            // とりあえず、駒を取り除いた状態にするぜ☆(^~^)
            //──────────
            TorinozokuKoma(ms_ibasho, km_remove);

            //──────────
            // 駒が取り除かれた現状に更新する
            //──────────
            if (updateKiki)
            {
                // 駒の利き割りの評価値を減らすならここで☆(^~^)

                kikiBan.TorinozokuKiki(km_remove, ms_ibasho);

                //──────────
                // 駒が減った後の、関連する飛び利きを増やす
                //──────────
                // 置いた駒がある 縦列きりん、横列きりん、縦列いのしし、左上がりぞう、左下がりぞう を探す
                foreach (Taikyokusya tai in Conv_Taikyokusya.itiran)
                {
                    Komasyurui[] ksAr = new Komasyurui[]
                    {
                        Komasyurui.K,
                        Komasyurui.Z,
                        Komasyurui.S,
                    };

                    foreach (Komasyurui ks in ksAr)
                    {
                        Piece km_forReverse = Med_Koma.KomasyuruiAndTaikyokusyaToKoma(ks, tai);

                        BitboardsOmatome.KomanoUgokikataYk00.ToSet_Merge(
                            km_forReverse,    // 相手番の駒にして、利きを飛ばしてきている位置を調べるのに使う
                            ms_ibasho,        // 升
                            bbTmp_kiki_forOku // リーガルムーブの盤面を、ここに入れるぜ☆(^~^)
                            );

                        Masu ms_atk;
                        while (bbTmp_kiki_forOku.Ref_PopNTZ(out ms_atk))// 立っているビットを降ろすぜ☆
                        {
                            kikiBan.OkuKiki(km_forReverse, ms_atk);
                        }
                    }
                }
            }

            return(Pure.SUCCESSFUL_FALSE);
        }
예제 #26
0
 public static MotigomaSyurui KomasyuruiToMotiKomasyrui(Komasyurui ks)
 {
     return(Med_Koma.m_KomasyuruiToMotiKomasyurui_[(int)ks]);
 }
예제 #27
0
 public static string GetKomasyuruiNamae(Taikyokusya tai, Komasyurui ks)
 {
     return(komasyuruiNamaeItiran[(int)tai][(int)ks]);
 }
예제 #28
0
 public static void SetSsssUgokiKm(Piece km)
 {
     ssss_ugoki_km_       = km;
     ssss_ugoki_ks_       = Med_Koma.KomaToKomasyurui(km);
     ssss_ugoki_sakasaKm_ = Med_Koma.KomasyuruiAndTaikyokusyaToKoma(ssss_ugoki_ks_, kifu_aiteban);
 }
예제 #29
0
 public static Motigoma KomasyuruiAndTaikyokusyaToMotiKoma(Komasyurui ks, Taikyokusya tai)
 {
     return(Med_Koma.m_KomasyuruiAndTaikyokusyaToMotiKoma_[(int)ks, (int)tai]);
 }
예제 #30
0
 public static string GetKomasyuruiNamae(Option <Phase> optionalPhase, Komasyurui ks)
 {
     return(komasyuruiNamaeItiran[OptionalPhase.IndexOf(optionalPhase)][(int)ks]);
 }