示例#1
0
        static void Main()
        {
            var engineConf = new EngineConf();

            EntitiesLayer.Implement(engineConf);

            /*
             * Application.EnableVisualStyles();
             * Application.SetCompatibleTextRenderingDefault(false);
             * Application.Run(new Form1());
             */

            KifuNarabeVsImpl kifuNarabeVs = new KifuNarabeVsImpl(engineConf);

            //↓ [STAThread]指定のあるメソッドで フォームを作成してください。
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            kifuNarabeVs.OwnerForm = new Ui_ShogiForm1(kifuNarabeVs);
            //↑ [STAThread]指定のあるメソッドで フォームを作成してください。

            kifuNarabeVs.Load_AsStart();

            kifuNarabeVs.WidgetLoaders.Add(new WidgetsLoader_KifuNarabe(engineConf.GetResourceFullPath("NarabeGuiWidgets")));
            kifuNarabeVs.WidgetLoaders.Add(new WidgetsLoader_KifuNarabeVs(engineConf.GetResourceFullPath("VsGuiWidgets")));

            kifuNarabeVs.LaunchForm_AsBody();
        }
示例#2
0
        static void Main()
        {
            var engineConf = new EngineConf();

            EntitiesLayer.Implement(engineConf);

            // ヌル防止のための初期値
            Dictionary <string, string> argsDic = new Dictionary <string, string>();

            argsDic.Add("position", "position startpos moves");
            argsDic.Add("outFile", "1.png"); //出力ファイル
            argsDic.Add("kmFile", "2.png");  //駒画像へのパス。
            argsDic.Add("kmW", "1");         //駒の横幅。koma width
            argsDic.Add("kmH", "1");
            argsDic.Add("sjFile", "3.png");  //数字・小
            argsDic.Add("sjW", "1");         //数字の横幅。suji width
            argsDic.Add("sjH", "1");
            Program.AppendCommandline(argsDic);

            //foreach (KeyValuePair<string, string> entry in argsDic)
            //{
            //    MessageBox.Show("["+entry.Key + "]=[" + entry.Value+"]", "デバッグ");
            //}
            //MessageBox.Show("出力先=[" + Path.Combine(Application.StartupPath, argsDic["outPath"]) + "]", "デバッグ");



            //
            // SFEN
            //
            string sfen;
            {
                // SFEN を分解したい。
                //string sfen = "lnsgkgsn1/1r5b1/ppppppppp/9/9/9/PPPPPPPPP/1B5R1/LNSGKGSNL w - 1";
                //string sfen = "position sfen lnsgkgsnl/9/ppppppppp/9/9/9/PPPPPPPPP/1B5R1/LNSGKGSNL w - 1 moves 5a6b 7g7f 3a3b";
                //string sfen = "position sfen lnsgkgsnl/9/p1ppppppp/9/9/9/P1PPPPPPP/1B5R1/LNSGKGSNL w Pp 1 moves 5a6b 7g7f 3a3b";
                //string sfen = "position sfen 1nsgkgsnl/9/p2pppppp/9/9/9/P2PPPPPP/1B5R1/1NSGKGSNL w L2Pl2p 1 moves 5a6b 7g7f 3a3b";
                sfen = argsDic["position"];
            }

            ReportEnvironment reportEnvironment = new ReportEnvironmentImpl(
                argsDic["kmFile"],
                argsDic["sjFile"],
                argsDic["kmW"],
                argsDic["kmH"],
                argsDic["sjW"],
                argsDic["sjH"]
                );

            //SFEN文字列と、出力ファイル名を指定することで、局面の画像ログを出力します。
            KyokumenPngWriterImpl.Write2(
                engineConf,
                sfen,
                Path.Combine(engineConf.GetResourceFullPath("PositionPngLogDirectory"), argsDic["outFile"]),
                reportEnvironment
                );
        }
示例#3
0
        static void Main()
        {
            var engineConf = new EngineConf();

            EntitiesLayer.Implement(engineConf);

            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new Form1());
        }
示例#4
0
        private void Init()
        {
            var generator = GetNode <LevelGenerator>("LevelGenerator");

            generator.Generate();
            if (EntitiesLayer.GetChildCount() > 0)
            {
                EntitiesLayer.GetNode <Player>("Player").GlobalPosition = generator.PlayerSpawnPosition;
            }
            Pathfinder = new Pathfinder(TileMap);
        }
示例#5
0
        public ArtisteViewer(EntitiesLayer.Artiste source) 
        {
            InitializeComponent();

            if (source == null)
            {
                // récupération d'un artiste
                BusinessLayer.BusinessManager bm = new BusinessLayer.BusinessManager();
                _source = bm.GetArtistes()[0];
            }
            else _source = source;
        }
示例#6
0
        public static int Main(string[] args)
        {
            var engineConf = new EngineConf();

            EntitiesLayer.Implement(engineConf);

            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new Ui_SyugoronTestForm());


            return(0);
        }
示例#7
0
        static void Main()
        {
            var engineConf = new EngineConf();

            EntitiesLayer.Implement(engineConf);

            MainGui_CsharpVsImpl mainGuiVs = new MainGui_CsharpVsImpl(engineConf);

            //↓ [STAThread]指定のあるメソッドで フォームを作成してください。
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            mainGuiVs.OwnerForm = new Form1_Shogi(mainGuiVs);
            //↑ [STAThread]指定のあるメソッドで フォームを作成してください。

            mainGuiVs.Load_AsStart();
            mainGuiVs.LaunchForm_AsBody();
        }
示例#8
0
        public void ModificarDatosEmpresa(EntitiesLayer.Empresa empresa)
        {
            try
            {
                SqlCommand cmd = new SqlCommand();

                cmd.Parameters.Add(new SqlParameter("@nombre", empresa.NombreEmpresa));
                cmd.Parameters.Add(new SqlParameter("@logo", empresa.Logo));

                DBAccess.ExecuteSPNonQuery(cmd, "USP_Empresa_Update");

            }
            catch (Exception ex)
            {

            }
        }
示例#9
0
        static void Main(string[] args)
        {
            MessageBox.Show("AIMSサーバー");

            var engineConf = new EngineConf();

            EntitiesLayer.Implement(engineConf);

            string filepath = engineConf.GetResourceFullPath("AimsDataSetteiXml");

            MessageBox.Show($"設定ファイルパス=[{filepath}]");

            //
            // 設定XMLファイル
            //
            SetteiXmlFile setteiXmlFile;

            {
                setteiXmlFile = new SetteiXmlFile(filepath);
                //if (!setteiXmlFile.Exists())
                //{
                //    // ファイルが存在しませんでした。

                //    // 作ります。
                //    setteiXmlFile.Write();
                //}

                setteiXmlFile.Read();

                // デバッグ
                //setteiXmlFile.DebugWrite();
            }


            MessageBox.Show($"AIMSサーバー\n将棋エンジン・ファイルパス=[{setteiXmlFile.ShogiEngineFilePath}]");

            SkyConst src_Sky = Util_SkyWriter.New_Hirate(Playerside.P1);

            AimsServerImpl aimsServer = new AimsServerImpl(src_Sky, 0);

            aimsServer.ShogiEngineFilePath = setteiXmlFile.ShogiEngineFilePath;

            aimsServer.AtBegin();
            aimsServer.AtBody();
        }
示例#10
0
        public void registrarTransaccion(EntitiesLayer.Bitacora bitacora)
        {
            try
            {
                SqlCommand cmd = new SqlCommand();

                cmd.Parameters.Add(new SqlParameter("@id_usuario", bitacora.IdUsuario));
                cmd.Parameters.Add(new SqlParameter("@accion", bitacora.Accion));
                cmd.Parameters.Add(new SqlParameter("@fecha_hora", bitacora.Fecha));

                DBAccess.ExecuteSPNonQuery(cmd, "USP_Bitacora_Insert");

            }
            catch (Exception ex)
            {

            }
        }
示例#11
0
        static void Main()
        {
            var engineConf = new EngineConf();

            EntitiesLayer.Implement(engineConf);

            KifuNarabeImpl kifuNarabe = new KifuNarabeImpl(engineConf);

            //↓ [STAThread]指定のあるメソッドで フォームを作成してください。
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            kifuNarabe.OwnerForm = new Ui_ShogiForm1(kifuNarabe);
            //↑ [STAThread]指定のあるメソッドで フォームを作成してください。

            kifuNarabe.Load_AsStart();
            kifuNarabe.WidgetLoaders.Add(new WidgetsLoader_KifuNarabe("../../Data/data_widgets_KifuNarabe.csv"));
            kifuNarabe.LaunchForm_AsBody();
        }
示例#12
0
        static void Main()
        {
            var engineConf = new EngineConf();

            EntitiesLayer.Implement(engineConf);

            MainGui_CsharpImpl mainGui = new MainGui_CsharpImpl(engineConf);//new ShogiEngineVsClientImpl(this)

            //↓ [STAThread]指定のあるメソッドで フォームを作成してください。
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            mainGui.OwnerForm = new Form1_Shogi(mainGui);
            //↑ [STAThread]指定のあるメソッドで フォームを作成してください。

            mainGui.Load_AsStart();
            mainGui.WidgetLoaders.Add(new WidgetsLoader_CsharpImpl(engineConf.GetResourceFullPath("Shogiban01Widgets"), mainGui));
            mainGui.WidgetLoaders.Add(new WidgetsLoader_CsharpImpl(engineConf.GetResourceFullPath("Console02Widgets"), mainGui));
            mainGui.LaunchForm_AsBody();
        }
示例#13
0
        public void registrarExcepcion(EntitiesLayer.BitacoraExcepciones bitacora)
        {
            try
            {
                SqlCommand cmd = new SqlCommand();

                cmd.Parameters.Add(new SqlParameter("@mensaje", bitacora.Mensaje));
                cmd.Parameters.Add(new SqlParameter("@inner_exception", bitacora.InnerException));
                cmd.Parameters.Add(new SqlParameter("@call_trace", bitacora.CallTrace));
                cmd.Parameters.Add(new SqlParameter("@id_usuario", bitacora.IdUsuario));
                cmd.Parameters.Add(new SqlParameter("@fecha_hora", bitacora.Fecha));

                DBAccess.ExecuteSPNonQuery(cmd, "USP_BitacoraExcepciones_Insert");

            }
            catch (Exception ex)
            {

            }
        }
示例#14
0
        static void Main()
        {
            var engineConf = new EngineConf();

            EntitiesLayer.Implement(engineConf);

            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

            Ui_SyugoronTestForm form1 = new Ui_SyugoronTestForm();

            form1.Text = "集合論ライブラリー テスター 将棋版";
            Ui_SyugoronTestPanel panel = form1.Ui_SyugoronTestPanel;

            // サンプルで少し入れておく。
            panel.SyFuncDictionary.Add("右上一直線升たち", Sample_Func.func右上一直線升たち);
            panel.SyFuncDictionary.Add("右下一直線升たち", Sample_Func.func右下一直線升たち);
            panel.SyFuncDictionary.Add("左下一直線升たち", Sample_Func.func左下一直線升たち);
            panel.SyFuncDictionary.Add("左上一直線升たち", Sample_Func.func左上一直線升たち);



            Application.Run(form1);
        }
示例#15
0
 public static void setCurrentPlayer(EntitiesLayer.Joueur j,int num_j)
 {
     if(num_j == 1)
         game.J1 = j;
     if(num_j == 2)
         game.J2 = j;
 }
示例#16
0
        public static void setCurrentGameTournament(EntitiesLayer.Tournoi t)
        {
            game.Tournament = t;
            int i = (int)EntitiesLayer.EPhaseTournoi.HuitiemeFinale1;
            foreach(EntitiesLayer.Match ma in game.Tournament.Matchs.Where(m => (int)m.PhaseTournoi >= (int)EntitiesLayer.EPhaseTournoi.HuitiemeFinale8).ToList())
            {
                ma.PhaseTournoi = (EntitiesLayer.EPhaseTournoi) i;
                i--;
            }

            game.Current_match = t.Matchs.First();
        }
示例#17
0
 public static void setCurrentGameMode(EntitiesLayer.Mode m)
 {
     game.Mode = m;
 }
示例#18
0
 public StadeViewModel(EntitiesLayer.Stade stade)
 {
     m_stade = stade;
 }
示例#19
0
 public PartieViewModel(EntitiesLayer.Partie partie)
 {
     m_partie = partie;
 }
示例#20
0
 public TournamentViewModel (EntitiesLayer.Tournoi tournament)
 {
     m_tournament = tournament;
 }
示例#21
0
        /// <summary>
        /// C#のプログラムは、
        /// この Main 関数から始まり、 Main 関数を抜けて終わります。
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            var engineConf = new EngineConf();

            EntitiesLayer.Implement(engineConf);

            //
            var playing = new Playing();

            // 思考エンジンの、記憶を読み取ります。
            playing.shogisasi = new ShogisasiImpl(playing);
            playing.shogisasi.Kokoro.ReadTenonagare();

            try
            {
                //
                // 図.
                //
                //     プログラムの開始:  ここの先頭行から始まります。
                //     プログラムの実行:  この中で、ずっと無限ループし続けています。
                //     プログラムの終了:  この中の最終行を終えたとき、
                //                         または途中で Environment.Exit(0); が呼ばれたときに終わります。
                //                         また、コンソールウィンドウの[×]ボタンを押して強制終了されたときも  ぶつ切り  で突然終わります。

                //------+-----------------------------------------------------------------------------------------------------------------
                // 準備 |
                //------+-----------------------------------------------------------------------------------------------------------------
                // データの読取「道」
                Michi187Array.Load(engineConf.GetResourceFullPath("Michi187"));

                // データの読取「配役」
                Util_Haiyaku184Array.Load(engineConf.GetResourceFullPath("Haiyaku185"), Encoding.UTF8);

                // データの読取「強制転成表」 ※駒配役を生成した後で。
                ForcePromotionArray.Load(engineConf.GetResourceFullPath("InputForcePromotion"), Encoding.UTF8);
                File.WriteAllText(engineConf.GetResourceFullPath("OutputForcePromotion"), ForcePromotionArray.LogHtml());

                // データの読取「配役転換表」
                Data_HaiyakuTransition.Load(engineConf.GetResourceFullPath("InputSyuruiToHaiyaku"), Encoding.UTF8);
                File.WriteAllText(engineConf.GetResourceFullPath("OutputSyuruiToHaiyaku"), Data_HaiyakuTransition.LogHtml());



                //-------------------+----------------------------------------------------------------------------------------------------
                // ログファイル削除  |
                //-------------------+----------------------------------------------------------------------------------------------------
                //
                // 図.
                //
                //      フォルダー
                //          ├─ Engine.KifuWarabe.exe
                //          └─ log.txt               ←これを削除
                //
                Logger.RemoveAllLogFile();

                {
                    //-------------+----------------------------------------------------------------------------------------------------------
                    // ログ書込み  |  <この将棋エンジン>  製品名、バージョン番号
                    //-------------+----------------------------------------------------------------------------------------------------------
                    //
                    // 図.
                    //
                    //      log.txt
                    //      ┌────────────────────────────────────────
                    //      │2014/08/02 1:04:59> v(^▽^)v イェーイ☆ ... fugafuga 1.00.0
                    //      │
                    //      │
                    //
                    //
                    // 製品名とバージョン番号は、次のファイルに書かれているものを使っています。
                    // 場所:  [ソリューション エクスプローラー]-[ソリューション名]-[プロジェクト名]-[Properties]-[AssemblyInfo.cs] の中の、[AssemblyProduct]と[AssemblyVersion] を参照。
                    //
                    // バージョン番号を「1.00.0」形式(メジャー番号.マイナー番号.ビルド番号)で書くのは作者の趣味です。
                    //
                    string versionStr;
                    {
                        // バージョン番号
                        Version version = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
                        versionStr = String.Format("{0}.{1}.{2}", version.Major, version.Minor.ToString("00"), version.Build);

                        //seihinName += " " + versionStr;
                    }

                    var engineName = engineConf.GetEngine("Name");
                    Logger.Trace($"v(^▽^)v イェーイ☆ ... {engineName} {versionStr}");
                }


                //-----------+------------------------------------------------------------------------------------------------------------
                // 通信開始  |
                //-----------+------------------------------------------------------------------------------------------------------------
                //
                // 図.
                //
                //      無限ループ(全体)
                //          │
                //          ├─無限ループ(1)
                //          │                      将棋エンジンであることが認知されるまで、目で訴え続けます(^▽^)
                //          │                      認知されると、無限ループ(2)に進みます。
                //          │
                //          └─無限ループ(2)
                //                                  対局中、ずっとです。
                //                                  対局が終わると、無限ループ(1)に戻ります。
                //
                // 無限ループの中に、2つの無限ループが入っています。
                //



                // ループ(全体)
                while (true)
                {
#if DEBUG_STOPPABLE
                    MessageBox.Show("きふわらべのMainの無限ループでブレイク☆!", "デバッグ");
                    System.Diagnostics.Debugger.Break();
#endif
                    // ループ(1つ目)
                    while (true)
                    {
                        // 将棋サーバーから何かメッセージが届いていないか、見てみます。
                        string line = Util_Message.Download_BlockingIO();
                        Logger.WriteLineR(line);

                        if ("usi" == line)
                        {
                            Version version      = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
                            var     engineName   = $"{engineConf.GetEngine("Name")} { version.Major}.{ version.Minor}.{ version.Build}";
                            var     engineAuthor = engineConf.GetEngine("Author");
                            playing.UsiOk(engineName, engineAuthor);
                        }
                        else if (line.StartsWith("setoption"))
                        {
                            Regex regex = new Regex(@"setoption name ([^ ]+)(?: value (.*))?", RegexOptions.Singleline);
                            Match m     = regex.Match(line);

                            if (m.Success)
                            {
                                string name  = (string)m.Groups[1].Value;
                                string value = "";

                                if (3 <= m.Groups.Count)
                                {
                                    // 「value ★」も省略されずにありました。
                                    //>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
                                    value = (string)m.Groups[2].Value;
                                }

                                playing.SetOption(name, value);
                            }
                        }
                        else if ("isready" == line)
                        {
                            playing.ReadyOk();
                        }
                        else if ("usinewgame" == line)
                        {
                            playing.UsiNewGame();

                            // 無限ループ(1つ目)を抜けます。無限ループ(2つ目)に進みます。
                            break;
                        }
                        else if ("quit" == line)
                        {
                            playing.Quit();

                            // このプログラムを終了します。
                            goto end_usi;
                        }
                        else
                        {
                            //------------------------------------------------------------
                            // ○△□×!?
                            //------------------------------------------------------------
                            //
                            // /(^×^)\
                            //

                            // 通信が届いていますが、このプログラムでは  聞かなかったことにします。
                            // USIプロトコルの独習を進め、対応/未対応を選んでください。
                        }
                    }

                    // ループ(2つ目)
                    playing.AjimiEngine = new AjimiEngine(playing);

                    //
                    // 図.
                    //
                    //      この将棋エンジンが後手とします。
                    //
                    //      ┌──┬─────────────┬──────┬──────┬────────────────────────────────────┐
                    //      │順番│                          │計算        │tesumiCount │解説                                                                    │
                    //      ┝━━┿━━━━━━━━━━━━━┿━━━━━━┿━━━━━━┿━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┥
                    //      │   1│初回                      │            │            │相手が先手、この将棋エンジンが後手とします。                            │
                    //      │    │                          │            │0           │もし、この将棋エンジンが先手なら、初回は tesumiCount = -1 とします。    │
                    //      ├──┼─────────────┼──────┼──────┼────────────────────────────────────┤
                    //      │   2│position                  │+-0         │            │                                                                        │
                    //      │    │    (相手が指しても、     │            │            │                                                                        │
                    //      │    │     指していないときでも │            │            │                                                                        │
                    //      │    │     送られてきます)      │            │0           │                                                                        │
                    //      ├──┼─────────────┼──────┼──────┼────────────────────────────────────┤
                    //      │   3│go                        │+2          │            │+2 します                                                               │
                    //      │    │    (相手が指した)        │            │2           │    ※「go」は、「go ponder」「go mate」「go infinite」とは区別します。 │
                    //      ├──┼─────────────┼──────┼──────┼────────────────────────────────────┤
                    //      │   4│go ponder                 │+-0         │            │                                                                        │
                    //      │    │    (相手はまだ指してない)│            │2           │                                                                        │
                    //      ├──┼─────────────┼──────┼──────┼────────────────────────────────────┤
                    //      │   5│自分が指した              │+-0         │            │相手が指してから +2 すると決めたので、                                  │
                    //      │    │                          │            │2           │自分が指したときにはカウントを変えません。                              │
                    //      └──┴─────────────┴──────┴──────┴────────────────────────────────────┘
                    //


                    //PerformanceMetrics performanceMetrics = new PerformanceMetrics();//使ってない?

                    while (true)
                    {
                        // 将棋サーバーから何かメッセージが届いていないか、見てみます。
                        string line = Util_Message.Download_BlockingIO();
                        Logger.WriteLineR(line);

                        if (line.StartsWith("position"))
                        {
                            // 手番になったときに、“まず”、将棋所から送られてくる文字が position です。
                            // このメッセージを読むと、駒の配置が分かります。
                            //
                            // “が”、まだ指してはいけません。
                            Logger.Trace("(^△^)positionきたコレ!");

                            // 入力行を解析します。
                            KifuParserA_Result result = new KifuParserA_ResultImpl();
                            var roomViewModel         = new DefaultRoomViewModel(playing.Game.Kifu);
                            var genjo  = new KifuParserA_GenjoImpl(line);
                            var parser = new KifuParserA_Impl();
                            Logger.Trace($@"┏━━━━━━━━━━┓
わたしは {parser.State.GetType().Name} の Execute_All だぜ☆");

                            KifuParserA_State nextState = parser.State;

                            while (!genjo.ToBreak)
                            {
                                genjo.InputLine = parser.State.Execute(
                                    ref result,
                                    roomViewModel,
                                    out nextState, parser,
                                    genjo);
                                parser.State = nextState;
                            }


                            KifuNode kifuNode = (KifuNode)result.Out_newNode_OrNull;
                            int      tesumi_yomiGenTeban_forLog = 0;//ログ用。読み進めている現在の手目済

                            Logger.Trace(
                                Util_Sky.Json_1Sky(playing.Game.Kifu.CurNode.Value.ToKyokumenConst, "現局面になっているのかなんだぜ☆? line=[" + line + "] 棋譜=" + KirokuGakari.ToJapaneseKifuText(playing.Game.Kifu),
                                                   "PgCS",
                                                   tesumi_yomiGenTeban_forLog//読み進めている現在の手目
                                                   ));

                            //
                            // 局面画像ログ
                            //
                            if (kifuNode != null) // (2020-12-20 sun) なんでヌルになるのか分からないが、避けるぜ☆(^~^)
                            {
                                //SFEN文字列と、出力ファイル名を指定することで、局面の画像ログを出力します。
                                var ky       = kifuNode.ToRO_Kyokumen1();
                                var fullname = SpecifyFiles.LatestPositionLogPng.Name;
                                var env      = ShogisasiImpl.ReportEnvironment;
                                KyokumenPngWriterImpl.Write1(engineConf, ky, fullname, env);
                            }


                            //------------------------------------------------------------
                            // じっとがまん
                            //------------------------------------------------------------
                            //
                            // 応答は無用です。
                            // 多分、将棋所もまだ準備ができていないのではないでしょうか(?)
                            //
                            playing.Position();
                        }
                        else if (line.StartsWith("go ponder"))
                        {
                            playing.GoPonder();
                        }
                        // 「go ponder」「go mate」「go infinite」とは区別します。
                        else if (line.StartsWith("go"))
                        {
                            //------------------------------------------------------------
                            // あなたの手番です
                            //------------------------------------------------------------
                            //
                            // 図.
                            //
                            //      log.txt
                            //      ┌────────────────────────────────────────
                            //      ~
                            //      │2014/08/02 2:36:19> go btime 599000 wtime 600000 byoyomi 60000
                            //      │
                            //
                            // もう指していいときに、将棋所から送られてくる文字が go です。
                            //

                            // n手目を 2 増やします。
                            // 相手の手番と、自分の手番の 2つが増えた、という数え方です。
                            playing.Game.TesumiCount += 2;

                            //------------------------------------------------------------
                            // 先手 3:00  後手 0:00  記録係「50秒ぉ~」
                            //------------------------------------------------------------
                            //
                            // 上図のメッセージのままだと使いにくいので、
                            // あとで使いやすいように Key と Value の表に分けて持ち直します。
                            //
                            // 図.
                            //
                            //      goDictionary
                            //      ┌──────┬──────┐
                            //      │Key         │Value       │
                            //      ┝━━━━━━┿━━━━━━┥
                            //      │btime       │599000      │
                            //      ├──────┼──────┤
                            //      │wtime       │600000      │
                            //      ├──────┼──────┤
                            //      │byoyomi     │60000       │
                            //      └──────┴──────┘
                            //      単位はミリ秒ですので、599000 は 59.9秒 です。
                            //
                            Regex regex = new Regex(@"go btime (\d+) wtime (\d+) byoyomi (\d+)", RegexOptions.Singleline);
                            Match m     = regex.Match(line);

                            if (m.Success)
                            {
                                playing.Go((string)m.Groups[1].Value, (string)m.Groups[2].Value, (string)m.Groups[3].Value, "", "");
                            }
                            else
                            {
                                // (2020-12-16 wed) フィッシャー・クロック・ルールに対応☆(^~^)
                                regex = new Regex(@"go btime (\d+) wtime (\d+) binc (\d+) winc (\d+)", RegexOptions.Singleline);
                                m     = regex.Match(line);

                                playing.Go((string)m.Groups[1].Value, (string)m.Groups[2].Value, "", (string)m.Groups[3].Value, (string)m.Groups[4].Value);
                            }
                            //System.C onsole.WriteLine();

                            //throw new Exception("デバッグだぜ☆! エラーはキャッチできたかな~☆?(^▽^)");
                        }
                        else if (line.StartsWith("stop"))
                        {
                            playing.Stop();
                        }
                        else if (line.StartsWith("gameover"))
                        {
                            Regex regex = new Regex(@"gameover (.)", RegexOptions.Singleline);
                            Match m     = regex.Match(line);

                            if (m.Success)
                            {
                                playing.GameOver((string)m.Groups[1].Value);
                            }

                            // 無限ループ(2つ目)を抜けます。無限ループ(1つ目)に戻ります。
                            break;
                        }
                        // 独自コマンド「ログ出せ」
                        else if ("logdase" == line)
                        {
                            StringBuilder sb = new StringBuilder();
                            sb.Append("ログだせ~(^▽^)");

                            playing.Game.Kifu.ForeachZenpuku(
                                playing.Game.Kifu.GetRoot(), (int tesumi, KyokumenWrapper sky, Node <ShootingStarlightable, KyokumenWrapper> node, ref bool toBreak) =>
                            {
                                //sb.AppendLine("(^-^)");

                                if (null != node)
                                {
                                    if (null != node.Key)
                                    {
                                        string sfenText = Util_Sky.ToSfenMoveText(node.Key);
                                        sb.Append(sfenText);
                                        sb.AppendLine();
                                    }
                                }
                            });

                            File.WriteAllText("../../Logs/_log_ログ出せ命令.txt", sb.ToString());
                        }
                        else
                        {
                            //------------------------------------------------------------
                            // ○△□×!?
                            //------------------------------------------------------------
                            //
                            // /(^×^)\
                            //

                            // 通信が届いていますが、このプログラムでは  聞かなかったことにします。
                            // USIプロトコルの独習を進め、対応/未対応を選んでください。
                        }
                    }

                    //-------------------+----------------------------------------------------------------------------------------------------
                    // スナップショット  |
                    //-------------------+----------------------------------------------------------------------------------------------------
                    // 対局後のタイミングで、データの中身を確認しておきます。
                    // Key と Value の表の形をしています。(順不同)
                    //
                    // 図.
                    //      ※内容はサンプルです。実際と異なる場合があります。
                    //
                    //      setoptionDictionary
                    //      ┌──────┬──────┐
                    //      │Key         │Value       │
                    //      ┝━━━━━━┿━━━━━━┥
                    //      │USI_Ponder  │true        │
                    //      ├──────┼──────┤
                    //      │USI_Hash    │256         │
                    //      └──────┴──────┘
                    //
                    //      goDictionary
                    //      ┌──────┬──────┐
                    //      │Key         │Value       │
                    //      ┝━━━━━━┿━━━━━━┥
                    //      │btime       │599000      │
                    //      ├──────┼──────┤
                    //      │wtime       │600000      │
                    //      ├──────┼──────┤
                    //      │byoyomi     │60000       │
                    //      └──────┴──────┘
                    //
                    //      goMateDictionary
                    //      ┌──────┬──────┐
                    //      │Key         │Value       │
                    //      ┝━━━━━━┿━━━━━━┥
                    //      │mate        │599000      │
                    //      └──────┴──────┘
                    //
                    //      gameoverDictionary
                    //      ┌──────┬──────┐
                    //      │Key         │Value       │
                    //      ┝━━━━━━┿━━━━━━┥
                    //      │gameover    │lose        │
                    //      └──────┴──────┘
                    //
                    Logger.Trace("KifuParserA_Impl.LOGGING_BY_ENGINE, ┏━確認━━━━setoptionDictionary ━┓");
                    foreach (KeyValuePair <string, string> pair in playing.SetoptionDictionary)
                    {
                        Logger.Trace(pair.Key + "=" + pair.Value);
                    }
                    Logger.Trace("┗━━━━━━━━━━━━━━━━━━┛");

                    //Dictionary<string, string> goMateProperties = new Dictionary<string, string>();
                    //goMateProperties["mate"] = "";
                    //LarabeLoggerList_Warabe.ENGINE.WriteLine_AddMemo("┏━確認━━━━goMateDictionary━━━┓");
                    //foreach (KeyValuePair<string, string> pair in this.goMateProperties)
                    //{
                    //    LarabeLoggerList_Warabe.ENGINE.WriteLine_AddMemo(pair.Key + "=" + pair.Value);
                    //}

                    Logger.Trace("┗━━━━━━━━━━━━━━━━━━┛");
                }
            }
            catch (Exception ex)
            {
                // エラーが起こりました。
                //>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

                // どうにもできないので  ログだけ取って無視します。
                Logger.Fatal($"(^ー^)「大外枠でキャッチ」{ex}");
                Playing.Send("bestmove resign");
            }

end_usi:
            // 終了時に、妄想履歴のログを残します。
            playing.shogisasi.Kokoro.WriteTenonagare(playing.shogisasi);
        }
 // CONSTRUCTEURS
 public CaracteristiqueViewModel(EntitiesLayer.Caracteristique caract) {
     Carac = caract;
 }
示例#23
0
 /// <see cref="IDal.Cs"/>
 public void AddPlanning(EntitiesLayer.PlanningElement element)
 {
     _dal.AddPlanning(element);
 }
示例#24
0
 /// <see cref="IDal.Cs"/>
 public void RemovePlanning(EntitiesLayer.PlanningElement element)
 {
     _dal.RemovePlanning(element);
 }
示例#25
0
 public static ReservationWS Convert(EntitiesLayer.Reservation res)
 {
     return new ReservationWS(
         PlanningElementWS.Convert(res.Planning),
         res.NbPlaces,
         res.Guid);
 }
示例#26
0
 public MatchViewModel(EntitiesLayer.Match match)
 {
     m_match = match;
 }
示例#27
0
 public JediViewModel(EntitiesLayer.Jedi jedi)
 {
     m_jedi = jedi;
 }
示例#28
0
        private void UpdateNavigationMesh()
        {
            var worldTileMap = GetNode <TileMap>("WorldTileMap");
            var worldTileSet = worldTileMap.TileSet;
            var blockedSet   = new HashSet <Vector2>();

            foreach (var node in EntitiesLayer.GetChildren())
            {
                if (node is StaticBody2D staticBody)
                {
                    var collisionShapeNode = staticBody.GetFirstNodeOfType <CollisionShape2D>();
                    if (collisionShapeNode == null)
                    {
                        continue;
                    }

                    var collisionShape = collisionShapeNode.Shape as RectangleShape2D;
                    if (collisionShape == null)
                    {
                        continue;
                    }

                    List <Vector2> subdividedPoints = new List <Vector2>();
                    var            shapeSize        = collisionShape.Extents * 2f;
                    var            xOffset          = -collisionShape.Extents.x;
                    while (xOffset < collisionShape.Extents.x)
                    {
                        var yOffset = -collisionShape.Extents.y;
                        while (yOffset < collisionShape.Extents.y)
                        {
                            subdividedPoints.Add(new Vector2(xOffset, yOffset));
                            yOffset += TILE_SIZE;
                        }
                        xOffset += TILE_SIZE;
                    }

                    // add the right corners
                    subdividedPoints.Add(new Vector2(collisionShape.Extents.x, -collisionShape.Extents.y));
                    subdividedPoints.Add(new Vector2(collisionShape.Extents.x, collisionShape.Extents.y));

                    foreach (var point in subdividedPoints)
                    {
                        var blockedCellV = worldTileMap.WorldToMap(collisionShapeNode.GlobalPosition + point * .99f);
                        blockedSet.Add(blockedCellV);
                    }
                }
            }

            foreach (var cellvObj in worldTileMap.GetUsedCells())
            {
                var cellv  = (Vector2)cellvObj;
                var cellId = worldTileMap.GetCellv(cellv);

                if (blockedSet.Contains(cellv))
                {
                    continue;
                }

                var cellCoord = worldTileMap.GetCellAutotileCoord((int)cellv.x, (int)cellv.y);
                var poly      = worldTileSet.AutotileGetNavigationPolygon(cellId, cellCoord);
                if (poly == null)
                {
                    poly = worldTileSet.TileGetNavigationPolygon(cellId);
                    if (poly == null)
                    {
                        continue;
                    }
                }

                var transform = Transform2D.Identity;
                transform.origin = worldTileMap.MapToWorld(cellv);

                if (OS.IsDebugBuild() && _drawNavigation)
                {
                    var polygonNode = new Polygon2D();
                    polygonNode.Polygon   = poly.GetVertices();
                    polygonNode.Transform = transform;
                    polygonNode.Modulate  = new Color(0f, .5f, .5f, .5f);
                    _navigation.AddChild(polygonNode);
                }
                _navigation.NavpolyAdd(poly, transform);
            }
        }
示例#29
0
        /// <summary>
        /// ここからコンソール・アプリケーションが始まるぜ☆(^▽^)
        ///
        /// PCのコンソール画面のプログラムなんだぜ☆(^▽^)
        /// Unityでは中身は要らないぜ☆(^~^)
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            try
            {
                var engineConf = new EngineConf();
                EntitiesLayer.Implement(engineConf);

                var playing = new Playing(engineConf);

                /*
                 #if DEBUG
                 * // いろいろテスト☆
                 * System.Console.WriteLine("# デバッグ");
                 * System.Console.WriteLine($"# (1L<<31)=[{(1L << 31)}]");
                 * System.Console.WriteLine($"# (1L<<32)=[{(1L << 32)}]");
                 * System.Console.WriteLine($"# (1L<<33)=[{(1L << 33)}]");
                 * System.Console.WriteLine($"# (1L<<62)=[{(1L << 62)}]");
                 * System.Console.WriteLine($"# (1L<<63)=[{(1L << 63)}]");
                 * System.Console.WriteLine($"# (1L<<64)=[{(1L << 64)}]");
                 * System.Console.WriteLine($"# (1L<<65)=[{(1L << 65)}]");
                 * System.Console.WriteLine($"# (long.MinValue << 1)=[{(long.MinValue << 1)}]");
                 * System.Console.WriteLine($"# (~0UL)=[{(~0UL)}]");
                 * System.Console.WriteLine($"# (~0UL << 1)=[{(~0UL << 1)}]");
                 #endif
                 */


                //────────────────────────────────────────
                // (手順1)アプリケーション開始前に設定しろだぜ☆(^▽^)!
                //────────────────────────────────────────
                {
                    // アプリケーション開始後は Face_Kifuwarabe.Execute("set 名前 値") を使って設定してくれだぜ☆(^▽^)
                    // ↓コメントアウトしているところは、デフォルト値を使っている☆(^~^)

                    //Option_Application.Optionlist.AspirationFukasa = 7;
                    //Option_Application.Optionlist.AspirationWindow = Hyokati.Hyokati_SeiNoSu_Hiyoko;
                    //Option_Application.Optionlist.BetaCutPer = 100;
                    //Option_Application.Optionlist.HanpukuSinkaTansakuTukau = true;
                    //Option_Application.Optionlist.JohoJikan = 3000;

                    //──────────
                    // 定跡
                    //──────────
                    Option_Application.Optionlist.JosekiPer = 0;     // 定跡を利用する確率。0~100。
                    Option_Application.Optionlist.JosekiRec = false; // 定跡は記録しない
                                                                     //Option_Application.Optionlist.JosekiRec = true;// 定跡を記録する☆

                    //Option_Application.Optionlist.Learn = false;
                    //Option_Application.Optionlist.NikomaHyokaKeisu = 1.0d;
                    //Option_Application.Optionlist.NikomaGakusyuKeisu = 0.001d;// HYOKA_SCALEが 1.0d のとき、GAKUSYU_SCALE 0.00001d なら、小数点部を広く使って じっくりしている☆(^~^)
                    //Option_Application.Optionlist.P1Com = false;
                    Option_Application.Optionlist.P2Com = true;           //対局者2はコンピューター☆
                                                                          //Option_Application.Optionlist.PNChar = new SasiteCharacter[] { SasiteCharacter.HyokatiYusen, SasiteCharacter.HyokatiYusen };
                                                                          //Option_Application.Optionlist.PNName = new string[] { "対局者1", "対局者2" };
                                                                          //Option_Application.Optionlist.RandomCharacter = false;
                                                                          //Option_Application.Optionlist.RandomNikoma = false;
                                                                          //Option_Application.Optionlist.RandomStart = false;
                                                                          //Option_Application.Optionlist.RenzokuTaikyoku = false;
                    Option_Application.Optionlist.SagareruHiyoko = false; // さがれるひよこモード☆ アプリケーション開始後は Face_Kifuwarabe.Execute("set SagareruHiyoko true") コマンドを使って設定すること☆ #仲ルール
                    Option_Application.Optionlist.SaidaiFukasa   = 13;    // コンピューターの読みの最大深さ

                    //──────────
                    // 成績
                    //──────────
                    Option_Application.Optionlist.SeisekiRec = false; // 成績は記録しない
                                                                      //Option_Application.Optionlist.SeisekiRec = true;// 成績を記録する☆

                    //Option_Application.Optionlist.SennititeKaihi = false;

                    //──────────
                    // 思考時間
                    //──────────
                    Option_Application.Optionlist.SikoJikan       = 5000; // 500; // 最低でも用意されているコンピューターが思考する時間(ミリ秒)
                    Option_Application.Optionlist.SikoJikanRandom = 5000; // 1501;// 追加で増えるランダム時間の最大(この値未満)。 期待値を考えて設定しろだぜ☆(^~^)例: ( 500 + 1500 ) / 2 = 1000
                                                                          //Option_Application.Optionlist.TranspositionTableTukau = true;
                                                                          //Option_Application.Optionlist.UseTimeOver = true;
                }

                StringBuilder syuturyoku = Util_Machine.Syuturyoku;

                // (手順3)アプリケーション開始時設定 を終えた後に これを呼び出すこと☆(^~^)!
                Option_Application.TimeManager.Stopwatch_Savefile.Start();// 定跡ファイルの保存間隔の計測
                Option_Application.TimeManager.Stopwatch_RenzokuRandomRule.Start();

                // 平手初期局面を作るぜ☆(*^~^*)
                Option_Application.Kyokumen.DoHirate(Option_Application.Optionlist.USI, syuturyoku);

                Util_Machine.Assert_Sabun_Kiki("アプリケーション始30", Option_Application.Kyokumen.Sindan);

                /*
                 * Util_Application.LoadJoseki(syuturyoku);// 定跡ファイルの読込み
                 * Util_Application.LoadSeiseki(syuturyoku);// 成績ファイルの読込み
                 * Util_Application.LoadNikoma(syuturyoku);// 二駒関係ファイルの読込み
                 */

                // ゲームモード設定☆
                Util_Application.GameMode = GameMode.Karappo;

                // まず最初に「USI\n」が届くかどうかを判定☆(^~^)
                Util_ConsoleGame.ReadCommandline(syuturyoku);
                //string firstInput = Util_Machine.ReadLine();
                if (Util_Commandline.Commandline == "usi")
                {
                    Option_Application.Optionlist.USI = true;

                    var     engineName   = engineConf.GetEngine("Name");
                    Version version      = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
                    var     engineAuthor = engineConf.GetEngine("Author");

                    playing.UsiOk($"{engineName} {version.Major}.{version.Minor}.{version.Build}", engineAuthor, syuturyoku);
                }
                else
                {
                    Util_ConsoleGame.WriteMessage_TitleGamen(syuturyoku);// とりあえず、タイトル画面表示☆(^~^)
                }

                // 空打ちで、ゲームモードに入るぜ☆(^▽^)
                var ky = Option_Application.Kyokumen;
                // このプログラムでは(A)コマンド・モード、(B)ゲーム・モード の2種類があるぜ☆
                // 最初は コマンド・モードになっている☆(^~^)
                //
                // ゲームモード
                //      (1)手番
                //              人間、コンピューターの設定が有効になり、
                //              人間の手番のときにしかコマンドが打てなくなるぜ☆
                //      (2)合法手
                //              指し手の合法手チェックを行うぜ☆
                //      (3)自動着手
                //              コンピューターは自分の手番で 指すぜ☆
                //      (4)決着
                //              決着すると ゲームモード を抜けるぜ☆ 連続対局設定の場合は抜けない☆(^▽^)
                //
                // コマンドモード
                //      (1)手番
                //              MAN vs MAN扱い
                //      (2)合法手
                //              チェックしない☆ ひよこをナナメに進めるのも、ワープするのも可能☆
                //      (3)自動着手
                //              しない☆
                //      (4)決着
                //              しない☆ [Enter]キーを空打ちすると、ゲームモードに変わるぜ☆(^▽^)

                for (; ;) //メインループ(無限ループ)
                {
                    //────────────────────────────────────────
                    // (手順2)ユーザー入力
                    //────────────────────────────────────────
                    Util_Commandline.InitCommandline();             // コマンド・ライン初期化☆
                    Util_Commandline.ReadCommandBuffer(syuturyoku); // コマンド・バッファー読取り☆

                    if (Util_Commandline.Commandline != null)
                    {
                        // コマンド・バッファーにコマンドラインが残っていたようなら、そのまま使うぜ☆(^▽^)
                    }
                    else if (
                        GameMode.Game == Util_Application.GameMode // ゲームモードの場合☆
                        &&
                        Util_Application.IsComputerNoBan(ky)       // コンピューターの番の場合☆
                        )
                    {
                        Util_Commandline.ClearCommandline(); // コマンドラインは消しておくぜ☆(^▽^)
                    }
                    else
                    {
                        Util_ConsoleGame.ReadCommandline(syuturyoku);// コンソールからのキー入力を受け取るぜ☆(^▽^)(コンソール・ゲーム用)
                    }

                    if (GameMode.Game == Util_Application.GameMode)
                    {
                        // 指す前の局面☆(定跡 登録用)
                        Util_ConsoleGame.Init_JosekiToroku(ky);

                        //────────────────────────────────────────
                        // (手順3)人間の手番
                        //────────────────────────────────────────
                        if (Util_Application.IsNingenNoBan(ky)) // 人間の手番
                        {
                            // ゲームモードでの人間の手番では、さらにコマンド解析

                            // ここで do コマンド(do b3b2 等)を先行して解析するぜ☆(^▽^)
                            if (Util_Commandline.Caret != Util_Commandline.Commandline.IndexOf("do ", Util_Commandline.Caret))
                            {
                                // do以外のコマンドであれば、コマンドラインを保持したまま、そのまま続行
                            }
                            // 以下、do コマンドの場合☆
                            else if (!Util_Application.ParseDoMove(ky, out Move inputSasite))
                            {
                                // do コマンドのパースエラー表示(コンソール・ゲーム用)☆(^~^)
                                syuturyoku.AppendLine(ConvMove.Setumei(MoveMatigaiRiyu.ParameterSyosikiMatigai));
                                var msg = syuturyoku.ToString();
                                syuturyoku.Clear();
                                Logger.Flush(msg);
                                Util_Commandline.CommentCommandline();                       // コマンドの誤発動防止
                            }
                            else if (!ky.CanDoMove(inputSasite, out MoveMatigaiRiyu reason)) // 指し手の合否チェック
                            {
                                // イリーガル・ムーブなどの、エラー理由表示☆(^~^)
                                syuturyoku.AppendLine(ConvMove.Setumei(reason));
                                var msg = syuturyoku.ToString();
                                syuturyoku.Clear();
                                Logger.Flush(msg);
                            }
                            else
                            {
                                // do コマンドを実行するぜ☆(^▽^)
                                // 1手指す☆!(^▽^)
                                Nanteme konoTeme = new Nanteme();// 使いまわさないだろう☆(^~^)ここで作ってしまおう☆
                                ky.DoMove(Option_Application.Optionlist.USI, inputSasite, MoveType.N00_Karappo, ref konoTeme, ky.CurrentOptionalPhase, syuturyoku);


                                Util_Application.JudgeKettyaku(inputSasite, ky);// 勝敗判定☆(^▽^)

                                // 局面出力
                                Util_Information.Setumei_NingenGameYo(ky, syuturyoku);
                                Util_ConsoleGame.Update1_JosekiToroku(inputSasite, ky, syuturyoku);// やるなら、定跡更新☆(^▽^)
                            }
                        }// 人間おわり☆(^▽^)

                        //────────────────────────────────────────
                        // (手順4)コンピューターの手番
                        //────────────────────────────────────────
                        else if (Util_Application.IsComputerNoBan(ky))                                                                                                        //コンピューターの番☆
                        {
                            Util_ConsoleGame.AppendMessage_ComputerSikochu(ky, syuturyoku);                                                                                   // 表示(コンピューター思考中☆)

                            Move bestSasite = Util_Application.Go(playing, ky, out HyokatiUtiwake best_hyokatiUTiwake, Face_YomisujiJoho.Dlgt_WriteYomisujiJoho, syuturyoku); // コンピューターに1手指させるぜ☆
                            Util_Application.JudgeKettyaku(bestSasite, ky);                                                                                                   // 勝敗判定☆(^▽^)

                            Util_ConsoleGame.Update2_JosekiToroku(bestSasite, best_hyokatiUTiwake.EdaBest, ky, syuturyoku);                                                   // やるなら、定跡更新☆(^▽^)
                            Util_ConsoleGame.ShowMessage_KettyakuJi(ky, syuturyoku);                                                                                          // 決着していた場合はメッセージ表示☆(^~^)
                        }// コンピューターの手番おわり☆(^~^)

                        //────────────────────────────────────────
                        // (手順5)決着時
                        //────────────────────────────────────────
                        if (Util_Application.IsKettyaku(ky))                                    // 決着が付いているなら☆
                        {
                            Util_Application.DoTejun5_SyuryoTaikyoku1(playing, ky, syuturyoku); // 対局終了時
                        }
                    }

                    //────────────────────────────────────────
                    // (手順6)ゲーム用の指し手以外のコマンドライン実行
                    //────────────────────────────────────────
                    string commandline = Util_Commandline.Commandline;
                    int    caret       = Util_Commandline.Caret;
                    Util_Commandline.IsQuit         = false;
                    Util_Commandline.IsKyokumenEcho = true; // ゲーム・モードの場合、特に指示がなければ コマンド終了後、局面表示を返すぜ☆
                    if (null == commandline)
                    {
                        // 未設定
                    }
                    else if (commandline == "")
                    {
                        // 空打ちは無視するか、からっぽモードでは、ゲームモードに切り替えるぜ☆(^▽^)
                        if (GameMode.Karappo == Util_Application.GameMode)// 感想戦での発動防止☆
                        {
                            // ゲームモード(対局開始)
                            Util_Application.GameMode = GameMode.Game;
                        }
                    }
                    // なるべく、アルファベット順☆(^▽^)同じつづりで始まる単語の場合、語句の長い単語を優先にしないと if 文が通らないぜ☆www
                    else if (caret == commandline.IndexOf("@", caret))
                    {
                        playing.Atmark(commandline);
                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("#", caret))
                    {
                        // 受け付けるが、何もしないぜ☆(^▽^)www
                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("bitboard", caret))
                    {
                        // テスト用だぜ☆(^~^)
                        if (commandline == "bitboard")
                        {
                            // ビットボード表示☆

                            // 筋
                            {
                                for (int iSuji = 0; iSuji < Option_Application.Optionlist.BanYokoHaba; iSuji++)
                                {
                                    Util_Information.Setumei_1Bitboard($"筋{iSuji}", ky.BB_SujiArray[iSuji], syuturyoku);
                                }
                                syuturyoku.AppendLine();
                            }
                            // 段
                            {
                                for (int iDan = 0; iDan < Option_Application.Optionlist.BanTateHaba; iDan++)
                                {
                                    Util_Information.Setumei_1Bitboard($"段{iDan}", ky.BB_DanArray[iDan], syuturyoku);
                                }
                                syuturyoku.AppendLine();
                            }
                            // トライ
                            {
                                Util_Information.Setumei_Bitboards(new string[] { "対局者1", "対局者2(トライ)" },
                                                                   new Bitboard[] { ky.BB_Try[(int)Phase.Black], ky.BB_Try[(int)Phase.White] }, syuturyoku);
                                syuturyoku.AppendLine();
                            }

                            Util_Information.HyojiKomanoIbasho(ky.Shogiban, syuturyoku);                       // 駒の居場所☆
                            Util_Information.HyojiKomanoKikiSu(ky.Shogiban, syuturyoku);                       // 駒の重ね利き数☆
                            Util_Information.HyojiKomanoKiki(ky.Shogiban, syuturyoku);                         // 駒の利き☆
                            Util_Information.HyojiKomanoUgoki(ky.Shogiban, ky.Sindan.MASU_YOSOSU, syuturyoku); // 駒の動き☆
                            return;
                        }

                        // うしろに続く文字は☆(^▽^)
                        int caret2 = 0;
                        Util_String.TobasuTangoToMatubiKuhaku(commandline, ref caret2, "bitboard ");

                        if (caret2 == commandline.IndexOf("kiki", caret2))
                        {
                            // 重ね利きビットボード表示☆

                            // 駒別
                            {
                                // 再計算
                                Shogiban saikeisan = new Shogiban(ky.Sindan);
                                saikeisan.Tukurinaosi_1_Clear_KikiKomabetu();
                                saikeisan.Tukurinaosi_2_Input_KikiKomabetu(ky.Sindan);
                                saikeisan.TukurinaosiBBKikiZenbu();

                                syuturyoku.AppendLine("利き:(再計算)全部、駒別");
                                Util_Information.HyojiKomanoKiki(saikeisan, syuturyoku);

                                // 現行
                                syuturyoku.AppendLine("利き:(現行)全部、駒別");
                                Util_Information.HyojiKomanoKiki(ky.Shogiban, syuturyoku);
                            }

                            // 全部
                            {
                                // 再計算
                                Shogiban saikeisan = new Shogiban(ky.Sindan);
                                saikeisan.TukurinaosiKikisuZenbu(ky.Shogiban, ky.Sindan);
                                saikeisan.TukurinaosiKikisuKomabetu(ky.Shogiban, ky.Sindan);

                                syuturyoku.AppendLine("利き数:(再計算)全部、駒別");
                                Util_Information.HyojiKomanoKikiSu(saikeisan, syuturyoku);

                                // 現行
                                syuturyoku.AppendLine("利き数:全部(現行)全部、駒別");
                                Util_Information.HyojiKomanoKikiSu(ky.Shogiban, syuturyoku);
                            }

                            return;
                        }
                        else if (caret2 == commandline.IndexOf("remake", caret2))
                        {
                            // 駒の動き方を作り直し
                            ky.Shogiban.Tukurinaosi_1_Clear_KomanoUgokikata(ky.Sindan.MASU_YOSOSU);
                            ky.Shogiban.Tukurinaosi_2_Input_KomanoUgokikata(ky.Sindan);
                        }

                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("cando", caret))
                    {
                        // GameMode.Game == Util_Application.GameMode ? CommandMode.NingenYoConsoleGame : CommandMode.NigenYoConsoleKaihatu,
                        // うしろに続く文字は☆(^▽^)
                        int caret2 = 0;
                        Util_String.TobasuTangoToMatubiKuhaku(commandline, ref caret2, "cando ");

                        if (!Med_Parser.TryFenMove(Option_Application.Optionlist.USI, commandline, ref caret2, ky.Sindan, out Move ss))
                        {
                            throw new Exception($"パースエラー [{commandline}]");
                        }

                        if (ky.CanDoMove(ss, out MoveMatigaiRiyu riyu))
                        {
                            syuturyoku.AppendLine("cando, true");
                        }
                        else
                        {
                            syuturyoku.Append("cando, false, ");
                            syuturyoku.AppendLine(riyu.ToString());
                        }
                    }
                    else if (caret == commandline.IndexOf("clear", caret))
                    {
                        Util_Machine.Clear();
                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("do", caret))
                    {
                        playing.Do(
                            Option_Application.Optionlist.USI,
                            commandline,
                            ky,
                            GameMode.Game == Util_Application.GameMode ? CommandMode.NingenYoConsoleGame : CommandMode.NigenYoConsoleKaihatu,
                            syuturyoku);
                    }
                    else if (caret == commandline.IndexOf("gameover", caret))
                    {
                        playing.Gameover(commandline, ky, syuturyoku);
                    }
                    else if (caret == commandline.IndexOf("go", caret))
                    {
                        var isSfen = Option_Application.Optionlist.USI;
                        var mode   = CommandMode.NigenYoConsoleKaihatu;
                        playing.Go(isSfen, mode, ky, syuturyoku);
                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("hash", caret))
                    {
                        playing.Hash(ky, syuturyoku);
                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("hirate", caret))
                    {
                        playing.Hirate(Option_Application.Optionlist.USI, ky, syuturyoku);
                    }
                    else if (caret == commandline.IndexOf("honyaku", caret))
                    {
                        playing.Honyaku(commandline, ky, syuturyoku);
                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("hyoka", caret))
                    {
                        playing.Hyoka(commandline, ky, syuturyoku);
                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("isready", caret))
                    {
                        playing.ReadyOk(syuturyoku);
                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("jam", caret))
                    {
                        playing.Jam(Option_Application.Optionlist.USI, ky, syuturyoku);
                    }
                    else if (caret == commandline.IndexOf("jokyo", caret))
                    {
                        playing.Jokyo(commandline, ky, syuturyoku);
                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("joseki", caret))
                    {
                        playing.Joseki(Option_Application.Optionlist.USI, commandline, syuturyoku);
                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("kansosen", caret))
                    {
                        // 駒の場所を表示するぜ☆(^▽^)
                        playing.Kansosen(Option_Application.Optionlist.USI, commandline, ky, syuturyoku);
                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("kifu", caret))
                    {
                        // 駒の場所を表示するぜ☆(^▽^)
                        playing.Kifu(Option_Application.Optionlist.USI, commandline, ky, syuturyoku);
                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("kikikazu", caret))
                    {
                        // 利きの数を調べるぜ☆(^▽^)
                        playing.KikiKazu(commandline, ky, syuturyoku);
                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("kiki", caret))
                    {
                        // 利きを調べるぜ☆(^▽^)
                        playing.Kiki(Option_Application.Optionlist.USI, commandline, ky, syuturyoku);
                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("koma", caret))
                    {
                        // 駒の場所を表示するぜ☆(^▽^)
                        playing.Koma_cmd(Option_Application.Optionlist.USI, commandline, ky, syuturyoku);
                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("ky", caret))
                    {
                        // 局面を表示するぜ☆(^▽^)
                        Util_Machine.Assert_Sabun_Kiki("飛び利き増やす1", ky.Sindan);
                        playing.Ky(Option_Application.Optionlist.USI, commandline, ky, syuturyoku);
                        Util_Machine.Assert_Sabun_Kiki("飛び利き増やす2", ky.Sindan);

                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("manual", caret))
                    {
                        // "man" と同じ☆(^▽^)
                        playing.Man(syuturyoku);
                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("man", caret))
                    {
                        // "manual" と同じ☆(^▽^)
                        playing.Man(syuturyoku);
                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("masu", caret))
                    {
                        playing.Masu_cmd(commandline, syuturyoku);
                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("nikoma", caret))
                    {
                        playing.Nikoma(Option_Application.Optionlist.USI, commandline, ky, syuturyoku);
                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("position", caret))
                    {
                        playing.Position();

                        // うしろに続く文字は☆(^▽^)
                        int caret2 = 0;
                        Util_String.YomuTangoTobasuMatubiKuhaku(commandline, ref caret2, out string token);

                        if ("position" == token)
                        {
                            // パース☆!(^▽^)
                            if (!ky.ParsePositionvalue(Option_Application.Optionlist.USI, commandline, ref caret2, true, false, out string moves, syuturyoku))
                            {
                                string msg = "パースに失敗だぜ☆(^~^)! #黒牛";
                                syuturyoku.AppendLine(msg);
                                var msg2 = syuturyoku.ToString();
                                syuturyoku.Clear();
                                Logger.Flush(msg2);
                                throw new Exception(msg);
                            }

                            // 棋譜を作成するぜ☆(^▽^)
                            Kifu kifu = new Kifu();

                            // 初期局面
                            {
                                StringBuilder mojiretu = new StringBuilder();
                                ky.AppendFenTo(Option_Application.Optionlist.USI, mojiretu);
                                kifu.SyokiKyokumenFen = mojiretu.ToString();
                            }

                            // うしろに続く文字は☆(^▽^)
                            Util_String.YomuTangoTobasuMatubiKuhaku(commandline, ref caret2, out token);
                            if ("" != moves)
                            {
                                // moves が続いていたら☆(^~^)

                                // 頭の moves を取り除くぜ☆(*^~^*)
                                moves = moves.Substring("moves ".Length);

                                kifu.AddMoves(Option_Application.Optionlist.USI, moves, ky.Sindan);

                                // positionで渡された最終局面まで進めようぜ☆(^▽^)www
                                kifu.GoToFinish(Option_Application.Optionlist.USI, ky, syuturyoku);
                            }

                            // 初回は「position startpos」しか送られてこない☆(^~^)
                        }
                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("quit", caret))
                    {
                        playing.Quit();
                        Util_Commandline.IsQuit = true;
                    }
                    else if (caret == commandline.IndexOf("result", caret))
                    {
                        playing.Result(ky, syuturyoku, CommandMode.NigenYoConsoleKaihatu);
                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("rnd", caret))
                    {
                        playing.Rnd(ky, syuturyoku);
                    }
                    else if (caret == commandline.IndexOf("move", caret))
                    {
                        playing.MoveCmd(Option_Application.Optionlist.USI, commandline, ky, syuturyoku);
                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("see", caret))
                    {
                        playing.See(Option_Application.Optionlist.USI, commandline, ky, syuturyoku);
                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("seiseki", caret))
                    {
                        playing.Seiseki(Option_Application.Optionlist.USI, commandline, syuturyoku);
                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("setoption", caret))
                    {
                        // // とりあえず無視☆(*^~^*)

                        // 「setoption name 名前 value 値」といった書式なので、
                        // 「set 名前 値」に変えたい。

                        // うしろに続く文字は☆(^▽^)
                        int caret2 = 0;
                        Util_String.TobasuTangoToMatubiKuhaku(commandline, ref caret2, "setoption ");
                        Util_String.TobasuTangoToMatubiKuhaku(commandline, ref caret2, "name ");
                        int end = commandline.IndexOf("value ", caret2);
                        if (-1 != end)
                        {
                            StringBuilder sb = new StringBuilder();
                            sb.Append("set ");
                            sb.Append(commandline.Substring(caret2, end - caret2)); //名前
                            caret2 = end + "value ".Length;
                            sb.Append(commandline.Substring(caret2));               //値

                            playing.Set(sb.ToString(), ky, syuturyoku);
                        }

                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("set", caret))
                    {
                        playing.Set(commandline, ky, syuturyoku);
                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("taikyokusya", caret))
                    {
                        playing.Taikyokusya_cmd(commandline, ky, syuturyoku);
                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("test", caret))
                    {
                        playing.Test(Option_Application.Optionlist.USI, commandline, ky, syuturyoku);
                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("tantaitest", caret))
                    {
                        playing.TantaiTest(playing, Option_Application.Optionlist.USI, ky, syuturyoku);
                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("tumeshogi", caret))
                    {
                        // "tu" と同じ☆(^▽^)
                        playing.TumeShogi(Option_Application.Optionlist.USI, commandline, ky, syuturyoku);
                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("tu", caret))
                    {
                        // "tumeshogi" と同じ☆(^▽^)
                        playing.TumeShogi(Option_Application.Optionlist.USI, commandline, ky, syuturyoku);
                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("undo", caret))
                    {
                        playing.Undo(commandline, ky, syuturyoku);
                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("usinewgame", caret))
                    {
                        playing.UsiNewGame();
                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else if (caret == commandline.IndexOf("usi", caret))
                    {
                        //ここは普通、来ない☆(^~^)
                        var     engineName   = engineConf.GetEngine("Name");
                        Version version      = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
                        var     engineAuthor = engineConf.GetEngine("Author");

                        playing.UsiOk($"{engineName} {version.Major}.{version.Minor}.{version.Build}", engineAuthor, syuturyoku);
                        Util_Commandline.IsKyokumenEcho = false;
                    }
                    else
                    {
                        // 表示(コンソール・ゲーム用)
                        syuturyoku.Append("「");
                        syuturyoku.Append(commandline);
                        syuturyoku.AppendLine("」☆?(^▽^)");

                        syuturyoku.AppendLine("そんなコマンドは無いぜ☆(>_<) man で調べろだぜ☆(^▽^)");
                        var msg = syuturyoku.ToString();
                        syuturyoku.Clear();
                        Logger.Flush(msg);
                    }

                    if (Util_Commandline.IsQuit)
                    {
                        break;//goto gt_EndLoop1;
                    }

                    // 次の入力を促す表示をしてるだけだぜ☆(^~^)
                    Util_Commandline.ShowPrompt(playing, Option_Application.Optionlist.USI, ky, syuturyoku);
                }//無限ループ
                 //gt_EndLoop1:
                 //;

                // 開発モードでは、ユーザー入力を待機するぜ☆(^▽^)

                // (手順5)アプリケーション終了時に呼び出せだぜ☆(^▽^)!
                Face_Kifuwarabe.OnApplicationFinished(syuturyoku);
            }
            catch (Exception ex)
            {
                // エラーが起こりました。
                //>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

                // どうにもできないので  ログだけ取って無視します。
                Logger.Fatal($"(^ー^)「大外枠でキャッチ」:{ex}");
                Console.Out.WriteLine("bestmove resign");
                //throw;//追加
            }
        }
示例#30
0
        static void Main(string[] args)
        {
            var engineConf = new EngineConf();

            EntitiesLayer.Implement(engineConf);

            /*
             * Logger.Trace("targetって何だぜ☆?");
             * Logger.Trace("func(-256.0) → [{func(-256.0)}]");
             * Logger.Trace("func(-192.0) → [{func(-192.0)}]");
             * Logger.Trace("func(-128.0) → [{func(-128.0)}]");
             * Logger.Trace("func(-  1.0) → [{func(-1.0)}]");
             * Logger.Trace("func(   0.0) → [{func(   0.0)}]");
             * Logger.Trace("func(   1.0) → [{func(   1.0)}]");
             * Logger.Trace("func( 128.0) → [{func(128.0)}]");
             * Logger.Trace("func( 192.0) → [{func(192.0)}]");
             * Logger.Trace("func( 256.0) → [{func(256.0)}]");
             * Logger.Trace();
             */

            /*
             * Logger.Trace("評価値の修正点?");
             * Logger.Trace("dfunc(-256.0) → [{dfunc(-256.0)}]。 ÷32 → [{(dfunc(-256.0) / FV_SCALE)}]");
             * Logger.Trace("dfunc(-255.0) → [{dfunc(-255.0)}]。 ÷32 → [{(dfunc(-255.0) / FV_SCALE)}]");
             * Logger.Trace("dfunc(-244.0) → [{dfunc(-224.0)}]。 ÷32 → [{(dfunc(-224.0) / FV_SCALE)}]");
             * Logger.Trace("dfunc(-192.0) → [{dfunc(-192.0)}]。 ÷32 → [{(dfunc(-192.0) / FV_SCALE)}]");
             * Logger.Trace("dfunc(-128.0) → [{dfunc(-128.0)}]。 ÷32 → [{(dfunc(-128.0) / FV_SCALE)}]");
             * Logger.Trace("dfunc(- 96.0) → [{dfunc(-96.0)}]。 ÷32 → [{(dfunc(-96.0) / FV_SCALE)}]");
             * Logger.Trace("dfunc(- 64.0) → [{dfunc(-64.0)}]。 ÷32 → [{(dfunc(-64.0) / FV_SCALE)}]");
             * Logger.Trace("dfunc(- 32.0) → [{dfunc(-32.0)}]。 ÷32 → [{(dfunc(-32.0) / FV_SCALE)}]");
             * Logger.Trace("dfunc(- 16.0) → [{dfunc(-16.0)}]。 ÷32 → [{(dfunc(-16.0) / FV_SCALE)}]");
             * Logger.Trace("dfunc(-  1.0) → [{dfunc(-1.0)}]。 ÷32 → [{(dfunc(-1.0) / FV_SCALE)}]");
             * Logger.Trace("dfunc(   0.0) → [{dfunc(   0.0)}]。 ÷32 → [{(dfunc(0.0) / FV_SCALE)}]");
             * Logger.Trace("dfunc(   1.0) → [{dfunc(   1.0)}]。 ÷32 → [{(dfunc(1.0) / FV_SCALE)}]");
             * Logger.Trace("dfunc(  16.0) → [{dfunc(16.0)}]。 ÷32 → [{(dfunc(16.0) / FV_SCALE)}]");
             * Logger.Trace("dfunc(  32.0) → [{dfunc(32.0)}]。 ÷32 → [{(dfunc(32.0) / FV_SCALE)}]");
             * Logger.Trace("dfunc(  64.0) → [{dfunc(64.0)}]。 ÷32 → [{(dfunc(64.0) / FV_SCALE)}]");
             * Logger.Trace("dfunc(  96.0) → [{dfunc(96.0)}]。 ÷32 → [{(dfunc(96.0) / FV_SCALE)}]");
             * Logger.Trace("dfunc( 128.0) → [{dfunc(128.0)}]。 ÷32 → [{(dfunc(128.0) / FV_SCALE)}]");
             * Logger.Trace("dfunc( 192.0) → [{dfunc( 192.0)}]。 ÷32 → [{(dfunc(192.0) / FV_SCALE)}]");
             * Logger.Trace("dfunc( 244.0) → [{dfunc(224.0)}]。 ÷32 → [{(dfunc(224.0) / FV_SCALE)}]");
             * Logger.Trace("dfunc( 255.0) → [{dfunc(255.0)}]。 ÷32 → [{(dfunc(255.0) / FV_SCALE)}]");
             * Logger.Trace("dfunc( 256.0) → [{dfunc( 256.0)}]。 ÷32 → [{(dfunc(256.0) / FV_SCALE)}]");
             */

            Logger.Trace("Derivedシグモイド関数を眺めてみるんだぜ☆ +も-も結果は同じ☆");

            /*
             * Logger.Trace("       小数点第4位以下を四捨五入してみるぜ☆!");
             * Logger.Trace("dfunc(-256.0) → 約[{string.Format("{0:0.0}", dfunc(-256.0)*1000)}] [{dfunc(-256.0)}]");
             * Logger.Trace("dfunc(-255.0) → 約[{string.Format("{0:0.0}", dfunc(-255.0) * 1000)}] [{dfunc(-255.0)}]");
             * Logger.Trace("dfunc(-128.0) → 約[{string.Format("{0:0.0}", dfunc(-128.0) * 1000)}] [{dfunc(-128.0)}]");
             * Logger.Trace("dfunc(-120.0) → 約[{string.Format("{0:0.0}", dfunc(-120.0) * 1000)}] [{dfunc(-120.0)}]");
             * Logger.Trace("dfunc(-112.0) → 約[{string.Format("{0:0.0}", dfunc(-112.0) * 1000)}] [{dfunc(-112.0)}]");
             * Logger.Trace("dfunc(-104.0) → 約[{string.Format("{0:0.0}", dfunc(-104.0) * 1000)}] [{dfunc(-104.0)}]");
             * Logger.Trace("dfunc(- 96.0) → 約[{string.Format("{0:0.0}", dfunc(-96.0) * 1000)}] [{dfunc(-96.0)}]");
             * Logger.Trace("dfunc(- 88.0) → 約[{string.Format("{0:0.0}", dfunc(-88.0) * 1000)}] [{dfunc(-88.0)}]");
             * Logger.Trace("dfunc(- 80.0) → 約[{string.Format("{0:0.0}", dfunc(-80.0) * 1000)}] [{dfunc(-80.0)}]");
             * Logger.Trace("dfunc(- 72.0) → 約[{string.Format("{0:0.0}", dfunc(-72.0) * 1000)}] [{dfunc(-72.0)}]");
             * Logger.Trace("dfunc(- 64.0) → 約[{string.Format("{0:0.0}", dfunc(-64.0) * 1000)}] [{dfunc(-64.0)}]");
             * Logger.Trace("dfunc(- 56.0) → 約[{string.Format("{0:0.0}", dfunc(-56.0) * 1000)}] [{dfunc(-56.0)}]");
             * Logger.Trace("dfunc(- 48.0) → 約[{string.Format("{0:0.0}", dfunc(-48.0) * 1000)}] [{dfunc(-48.0)}]");
             * Logger.Trace("dfunc(- 40.0) → 約[{string.Format("{0:0.0}", dfunc(-40.0) * 1000)}] [{dfunc(-40.0)}]");
             * Logger.Trace("dfunc(- 32.0) → 約[{string.Format("{0:0.0}", dfunc(-32.0) * 1000)}] [{dfunc(-32.0)}]");
             * Logger.Trace("dfunc(- 24.0) → 約[{string.Format("{0:0.0}", dfunc(-24.0) * 1000)}] [{dfunc(-24.0)}]");
             * Logger.Trace("dfunc(- 16.0) → 約[{string.Format("{0:0.0}", dfunc(-16.0) * 1000)}] [{dfunc(-16.0)}]");
             * Logger.Trace("dfunc(-  8.0) → 約[{string.Format("{0:0.0}", dfunc(-8.0) * 1000)}] [{dfunc(-8.0)}]");
             * Logger.Trace("dfunc(   0.0) → 約[{string.Format("{0:0.0}", dfunc(-0.0) * 1000)}] [{dfunc(0.0)}]");
             */
            Logger.Trace(" ※A……Derivedシグモイドする ※B……変化手に下方修正する特徴量1000倍表示");
            Program.Display(256.0f);
            Program.Display(255.0f);
            Logger.Trace(" ~中略~");
            Program.Display(144.0f);
            Program.Display(136.0f);
            Program.Display(128.0f);
            Program.Display(120.0f);
            Program.Display(112.0f);
            Program.Display(104.0f);
            Program.Display(96.0f);
            Program.Display(88.0f);
            Program.Display(80.0f);
            Program.Display(72.0f);
            Program.Display(64.0f);
            Program.Display(56.0f);
            Program.Display(48.0f);
            Program.Display(40.0f);
            Program.Display(32.0f);
            Program.Display(24.0f);
            Program.Display(16.0f);
            Program.Display(8.0f);
            Program.Display(0.0f);

            Console.ReadKey();
        }
示例#31
0
        static void Main()
        {
            var engineConf = new EngineConf();

            EntitiesLayer.Implement(engineConf);

            //
            // コマンドライン引数の例
            //
            // --position="position sfen 1nsgkgsnl/9/p2pppppp/9/9/9/P2PPPPPP/1B5R1/1NSGKGSNL w L2Pl2p 1 moves 5a6b 7g7f 3a3b" \
            // --outFolder="../../Logs/"
            // --outFile="_log_局面1.png"
            // --imgFolder="../../Data/img/gkLog/" \
            // --kmFile="koma1.png" \
            // --sjFile="suji1.png" \
            // --kmW=20 \
            // --kmH=20 \
            // --sjW=8 \
            // --sjH=12 \
            // --end
            //

            // ヌル防止のための初期値
            Dictionary <string, string> argsDic = new Dictionary <string, string>();

            argsDic.Add("position", "position startpos moves");
            argsDic.Add("outFolder", "./");                                          //出力フォルダー "../../Logs/"
            argsDic.Add("outFile", engineConf.GetResourceFullPath("N1PngBasename")); //出力ファイル
            argsDic.Add("imgFolder", ".");                                           //画像フォルダーへのパス image path
            argsDic.Add("kmFile", engineConf.GetResourceFullPath("N2PngBasename"));  //駒画像へのパス。
            argsDic.Add("kmW", "1");                                                 //駒の横幅。koma width
            argsDic.Add("kmH", "1");
            argsDic.Add("sjFile", engineConf.GetResourceFullPath("N3PngBasename"));  //数字・小
            argsDic.Add("sjW", "1");                                                 //数字の横幅。suji width
            argsDic.Add("sjH", "1");
            Program.AppendCommandline(argsDic);

            //foreach (KeyValuePair<string, string> entry in argsDic)
            //{
            //    MessageBox.Show($"[{entry.Key}]=[{entry.Value}]", "デバッグ");
            //}
            //MessageBox.Show($"出力先=[{Path.Combine(Application.StartupPath, argsDic["outPath"])}]", "デバッグ");



            //
            // SFEN
            //
            string sfen;
            {
                // SFEN を分解したい。
                //string sfen = "lnsgkgsn1/1r5b1/ppppppppp/9/9/9/PPPPPPPPP/1B5R1/LNSGKGSNL w - 1";
                //string sfen = "position sfen lnsgkgsnl/9/ppppppppp/9/9/9/PPPPPPPPP/1B5R1/LNSGKGSNL w - 1 moves 5a6b 7g7f 3a3b";
                //string sfen = "position sfen lnsgkgsnl/9/p1ppppppp/9/9/9/P1PPPPPPP/1B5R1/LNSGKGSNL w Pp 1 moves 5a6b 7g7f 3a3b";
                //string sfen = "position sfen 1nsgkgsnl/9/p2pppppp/9/9/9/P2PPPPPP/1B5R1/1NSGKGSNL w L2Pl2p 1 moves 5a6b 7g7f 3a3b";
                sfen = argsDic["position"];
            }

            KyokumenPngEnvironment reportEnvironment = new KyokumenPngEnvironmentImpl(
                argsDic["outFolder"],
                argsDic["imgFolder"],
                argsDic["kmFile"],
                argsDic["sjFile"],
                argsDic["kmW"],
                argsDic["kmH"],
                argsDic["sjW"],
                argsDic["sjH"]
                );

            // テスト・プログラム
            Util_KyokumenPng_Writer.Write_ForTest(
                sfen,
                "",
                argsDic["outFile"],
                reportEnvironment
                );
        }
示例#32
0
        /// <summary>
        /// C#のプログラムは、
        /// この Main 関数から始まり、 Main 関数を抜けて終わります。
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            var engineConf = new EngineConf();

            EntitiesLayer.Implement(engineConf);

            // 将棋エンジン きふわらべ
            var playing = new Playing();

            //-------------------+----------------------------------------------------------------------------------------------------
            // ログファイル削除  |
            //-------------------+----------------------------------------------------------------------------------------------------
            {
                //
                // 図.
                //
                //      フォルダー
                //          ├─ Engine.KifuWarabe.exe
                //          └─ log.txt               ←これを削除
                //
                Logger.RemoveAllLogFiles();
            }

            //------------------------------------------------------------------------------------------------------------------------
            // 思考エンジンの、記憶を読み取ります。
            //------------------------------------------------------------------------------------------------------------------------
            Util_FvLoad.OpenFv(engineConf, playing.FeatureVector, engineConf.GetResourceFullPath("Fv00Komawari"));

            //------------------------------------------------------------------------------------------------------------------------
            // ファイル読込み
            //------------------------------------------------------------------------------------------------------------------------
            {
                // データの読取「道」
                if (Michi187Array.Load(engineConf.GetResourceFullPath("Michi187")))
                {
                }

                // データの読取「配役」
                Util_Array_KomahaiyakuEx184.Load(engineConf.GetResourceFullPath("Haiyaku185"), Encoding.UTF8);

                // データの読取「強制転成表」 ※駒配役を生成した後で。
                Array_ForcePromotion.Load(engineConf.GetResourceFullPath("InputForcePromotion"), Encoding.UTF8);

#if DEBUG
                {
                    File.WriteAllText(engineConf.GetResourceFullPath("OutputForcePromotion"), Array_ForcePromotion.LogHtml());
                }
#endif

                // データの読取「配役転換表」
                Data_KomahaiyakuTransition.Load(engineConf.GetResourceFullPath("InputSyuruiToHaiyaku"), Encoding.UTF8);

#if DEBUG
                {
                    File.WriteAllText(engineConf.GetResourceFullPath("OutputSyuruiToHaiyaku"), Data_KomahaiyakuTransition.Format_LogHtml());
                }
#endif
            }

            //-------------+----------------------------------------------------------------------------------------------------------
            // ログ書込み  |  <この将棋エンジン>  製品名、バージョン番号
            //-------------+----------------------------------------------------------------------------------------------------------
            //
            // 図.
            //
            //      log.txt
            //      ┌────────────────────────────────────────
            //      │2014/08/02 1:04:59> v(^▽^)v イェーイ☆ ... fugafuga 1.00.0
            //      │
            //      │
            //
            //
            // 製品名とバージョン番号は、次のファイルに書かれているものを使っています。
            // 場所:  [ソリューション エクスプローラー]-[ソリューション名]-[プロジェクト名]-[Properties]-[AssemblyInfo.cs] の中の、[AssemblyProduct]と[AssemblyVersion] を参照。
            //
            // バージョン番号を「1.00.0」形式(メジャー番号.マイナー番号.ビルド番号)で書くのは作者の趣味です。
            //
            {
                string versionStr;

                // バージョン番号
                Version version = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
                versionStr = String.Format("{0}.{1}.{2}", version.Major, version.Minor.ToString("00"), version.Build);

                //seihinName += $" {versionStr}";
#if DEBUG
                var engineName = engineConf.GetEngine("Name");
                Logger.Trace($"v(^▽^)v イェーイ☆ ... {engineName} {versionStr}");
#endif
            }

            bool isTimeoutShutdown = false;

            try
            {
                //
                // 図.
                //
                //     プログラムの開始:  ここの先頭行から始まります。
                //     プログラムの実行:  この中で、ずっと無限ループし続けています。
                //     プログラムの終了:  この中の最終行を終えたとき、
                //                         または途中で Environment.Exit(0); が呼ばれたときに終わります。
                //                         また、コンソールウィンドウの[×]ボタンを押して強制終了されたときも  ぶつ切り  で突然終わります。


                // ループ(全体)
                //
                // 図.
                //
                //      無限ループ(全体)
                //          │
                //          ├─無限ループ(1)
                //          │                      将棋エンジンであることが認知されるまで、目で訴え続けます(^▽^)
                //          │                      認知されると、無限ループ(2)に進みます。
                //          │
                //          └─無限ループ(2)
                //                                  対局中、ずっとです。
                //                                  対局が終わると、無限ループ(1)に戻ります。
                //
                // 無限ループの中に、2つの無限ループが入っています。
                //

                while (true)
                {
#if DEBUG_STOPPABLE
                    MessageBox.Show("きふわらべのMainの無限ループでブレイク☆!", "デバッグ");
                    System.Diagnostics.Debugger.Break();
#endif
                    isTimeoutShutdown = false;

                    //
                    // サーバーに noop を送ってもよいかどうかは setoption コマンドがくるまで分からないので、
                    // 作ってしまっておきます。
                    // 1回も役に立たずに Loop2 に行くようなら、正常です。
#if NOOPABLE
                    NoopTimerImpl noopTimer = new NoopTimerImpl();
                    noopTimer._01_BeforeLoop();
#endif

                    // USIループ(1つ目)
                    while (true)
                    {
                        // 将棋サーバーから何かメッセージが届いていないか、見てみます。
                        string line = Util_Message.Download_Nonstop();

                        // (2020-12-13 sun) ノン・ブロッキングなら このコードが意味あったんだが☆(^~^)
                        if (null == line)//次の行が無ければヌル。
                        {
                            // メッセージは届いていませんでした。
                            //>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#if NOOPABLE
                            bool isTimeoutShutdown_temp;
                            noopTimer._03_AtEmptyMessage(this.Owner, out isTimeoutShutdown_temp);
                            if (isTimeoutShutdown_temp)
                            {
                                //MessageBox.Show("ループ1でタイムアウトだぜ☆!");
                                out_isTimeoutShutdown = isTimeoutShutdown_temp;
                                result_UsiLoop1       = PhaseResult_UsiLoop1.TimeoutShutdown;
                                goto end_loop1;
                            }
#endif

                            goto gt_NextTime1;
                        }

                        // 通信ログは必ず取ります。
                        Logger.WriteLineC(line);

#if NOOPABLE
                        noopTimer._04_AtResponsed(this.Owner, line);
#endif



                        if ("usi" == line)
                        {
                            var     engineName   = engineConf.GetEngine("Name");
                            Version version      = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
                            var     engineAuthor = engineConf.GetEngine("Author");
                            playing.UsiOk($"{engineName} {version.Major}.{version.Minor}.{version.Build}", engineAuthor);
                        }
                        else if (line.StartsWith("setoption"))
                        {
                            Match m = regexOfSetoption.Match(line);

                            if (m.Success)
                            {
                                string name  = (string)m.Groups[1].Value;
                                string value = "";

                                if (3 <= m.Groups.Count)
                                {
                                    // 「value ★」も省略されずにありました。
                                    //>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
                                    value = (string)m.Groups[2].Value;
                                }

                                playing.SetOption(name, value);
                            }
                        }
                        else if ("isready" == line)
                        {
                            playing.ReadyOk();
                        }
                        else if ("usinewgame" == line)
                        {
                            playing.UsiNewGame();

                            // 無限ループ(1つ目)を抜けます。無限ループ(2つ目)に進みます。
                            goto end_loop1;
                        }
                        else if ("quit" == line)
                        {
                            playing.Quit();

                            // このプログラムを終了します。
                            goto gt_EndMethod;//全体ループを抜けます。
                        }
                        else
                        {
                            //------------------------------------------------------------
                            // ○△□×!?
                            //------------------------------------------------------------
                            //
                            // /(^×^)\
                            //

                            // 通信が届いていますが、このプログラムでは  聞かなかったことにします。
                            // USIプロトコルの独習を進め、対応/未対応を選んでください。
                            //
                            // ログだけ取って、スルーします。
                        }

gt_NextTime1:
                        ;
                    }
end_loop1:

                    if (isTimeoutShutdown)
                    {
                        //MessageBox.Show("ループ1で矯正終了するんだぜ☆!");
                        goto gt_EndMethod;
                    }

                    //
                    // USIループ(2つ目)
                    //

                    //
                    // 図.
                    //
                    //      この将棋エンジンが後手とします。
                    //
                    //      ┌──┬─────────────┬──────┬──────┬────────────────────────────────────┐
                    //      │順番│                          │計算        │temezumiCount │解説                                                                    │
                    //      ┝━━┿━━━━━━━━━━━━━┿━━━━━━┿━━━━━━┿━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┥
                    //      │   1│初回                      │            │            │相手が先手、この将棋エンジンが後手とします。                            │
                    //      │    │                          │            │0           │もし、この将棋エンジンが先手なら、初回は temezumiCount = -1 とします。    │
                    //      ├──┼─────────────┼──────┼──────┼────────────────────────────────────┤
                    //      │   2│position                  │+-0         │            │                                                                        │
                    //      │    │    (相手が指しても、     │            │            │                                                                        │
                    //      │    │     指していないときでも │            │            │                                                                        │
                    //      │    │     送られてきます)      │            │0           │                                                                        │
                    //      ├──┼─────────────┼──────┼──────┼────────────────────────────────────┤
                    //      │   3│go                        │+2          │            │+2 します                                                               │
                    //      │    │    (相手が指した)        │            │2           │    ※「go」は、「go ponder」「go mate」「go infinite」とは区別します。 │
                    //      ├──┼─────────────┼──────┼──────┼────────────────────────────────────┤
                    //      │   4│go ponder                 │+-0         │            │                                                                        │
                    //      │    │    (相手はまだ指してない)│            │2           │                                                                        │
                    //      ├──┼─────────────┼──────┼──────┼────────────────────────────────────┤
                    //      │   5│自分が指した              │+-0         │            │相手が指してから +2 すると決めたので、                                  │
                    //      │    │                          │            │2           │自分が指したときにはカウントを変えません。                              │
                    //      └──┴─────────────┴──────┴──────┴────────────────────────────────────┘
                    //

                    // 棋譜
                    {
                        Debug.Assert(!Conv_MasuHandle.OnKomabukuro(
                                         Conv_SyElement.ToMasuNumber(((RO_Star)playing.Game.Kifu.CurNode.Value.KyokumenConst.StarlightIndexOf((Finger)0).Now).Masu)
                                         ), "駒が駒袋にあった。");
                    }

                    // go ponderの属性一覧
                    {
                        playing.Game.GoPonderNow = false;   // go ponderを将棋所に伝えたなら真
                    }

                    isTimeoutShutdown = false;
                    //PerformanceMetrics performanceMetrics = new PerformanceMetrics();//使ってない?

#if NOOPABLE
                    // サーバーに noop を送ってもよい場合だけ有効にします。
                    NoopTimerImpl noopTimer = null;
                    if (this.owner.Option_enable_serverNoopable)
                    {
                        noopTimer = new NoopTimerImpl();
                        noopTimer._01_BeforeLoop();
                    }
#endif

                    while (true)
                    {
                        PhaseResult_UsiLoop2 result_UsiLoop2 = PhaseResult_UsiLoop2.None;

                        //ノンストップ版
                        //string line = TimeoutReader.ReadLine(1000);//指定ミリ秒だけブロック。  (2020-12-13 sun) そのあと抜ける。頼んで作ってもらった関数、入力を取りこぼす不具合がある☆(^~^)?

                        // ブロッキングIO。
                        string line = Console.In.ReadLine();

                        // 通信ログは必ず取ります。
                        Logger.WriteLineC(line);

#if NOOPABLE
                        if (this.owner.Option_enable_serverNoopable)
                        {
                            noopTimer._03_AtResponsed(this.owner, line);
                        }
#endif


                        if (line.StartsWith("position"))
                        {
#if DEBUG
                            Logger.Trace("(^△^)positionきたコレ!");
#endif
                            // 入力行を解析します。
                            KifuParserA_Result result         = new KifuParserA_ResultImpl();
                            KifuParserA_Impl   kifuParserA    = new KifuParserA_Impl();
                            Model_Taikyoku     model_Taikyoku = new Model_TaikyokuImpl(playing.Game.Kifu);//FIXME:  この棋譜を委譲メソッドで修正するはず。 ShogiGui_Warabeは?
                            KifuParserA_Genjo  genjo          = new KifuParserA_GenjoImpl(line);
                            kifuParserA.Execute_All(
                                ref result,
                                model_Taikyoku,
                                genjo
                                );
                            if (null != genjo.StartposImporter_OrNull)
                            {
                                // SFENの解析結果を渡すので、
                                // その解析結果をどう使うかは、委譲します。
                                Util_InClient.OnChangeSky_Im_Client(
                                    model_Taikyoku,
                                    genjo
                                    );
                            }


#if DEBUG
                            Playing.Log2_Png_Tyokkin(line, (KifuNode)result.Out_newNode_OrNull);
#endif

                            //------------------------------------------------------------
                            // じっとがまん
                            //------------------------------------------------------------
                            //
                            // 応答は無用です。
                            // 多分、将棋所もまだ準備ができていないのではないでしょうか(?)
                            //
                            playing.Position();
                        }
                        else if (line.StartsWith("go ponder"))
                        {
                            playing.GoPonder();
                        }
                        // 「go ponder」「go mate」「go infinite」とは区別します。
                        else if (line.StartsWith("go"))
                        {
                            Match m = regexOfGo.Match(line);
                            if (m.Success)
                            {
                                playing.Go((string)m.Groups[1].Value, (string)m.Groups[2].Value, (string)m.Groups[3].Value, "", "");
                            }
                            else
                            {
                                // (2020-12-16 wed) フィッシャー・クロック・ルールに対応☆(^~^)
                                m = regexOfGoFisherClock.Match(line);

                                playing.Go((string)m.Groups[1].Value, (string)m.Groups[2].Value, "", (string)m.Groups[3].Value, (string)m.Groups[4].Value);
                            }
                        }
                        else if (line.StartsWith("stop"))
                        {
                            playing.Stop();
                        }
                        else if (line.StartsWith("gameover"))
                        {
                            Match m = regexOfGameover.Match(line);
                            if (m.Success)
                            {
                                playing.GameOver((string)m.Groups[1].Value);
                            }

                            // 無限ループ(2つ目)を抜けます。無限ループ(1つ目)に戻ります。
                            result_UsiLoop2 = PhaseResult_UsiLoop2.Break;
                        }
                        else if ("logdase" == line)
                        {
                            StringBuilder sb = new StringBuilder();
                            sb.Append("ログだせ~(^▽^)");

                            playing.Game.Kifu.ForeachZenpuku(
                                playing.Game.Kifu.GetRoot(), (int temezumi, KyokumenWrapper sky, Node <IMove, KyokumenWrapper> node, ref bool toBreak) =>
                            {
                                //sb.AppendLine("(^-^)");

                                if (null != node)
                                {
                                    if (null != node.Key)
                                    {
                                        string sfenText = ConvMoveStrSfen.ToMoveStrSfen(node.Key);
                                        sb.Append(sfenText);
                                        sb.AppendLine();
                                    }
                                }
                            });

                            File.WriteAllText(engineConf.GetResourceFullPath("LogDaseMeirei"), sb.ToString());
                        }
                        else
                        {
                            //------------------------------------------------------------
                            // ○△□×!?
                            //------------------------------------------------------------
                            //
                            // /(^×^)\
                            //

                            // 通信が届いていますが、このプログラムでは  聞かなかったことにします。
                            // USIプロトコルの独習を進め、対応/未対応を選んでください。
                            //
                            // ログだけ取って、スルーします。
                        }

                        switch (result_UsiLoop2)
                        {
                        case PhaseResult_UsiLoop2.Break:
                            goto end_loop2;

                        default:
                            break;
                        }

#pragma warning disable CS0164 // このラベルは参照されていません
gt_NextLine_loop2:
#pragma warning restore CS0164 // このラベルは参照されていません
                        ;
                    }

end_loop2:
                    ;

                    //-------------------+----------------------------------------------------------------------------------------------------
                    // スナップショット  |
                    //-------------------+----------------------------------------------------------------------------------------------------
                    // 対局後のタイミングで、データの中身を確認しておきます。
                    // Key と Value の表の形をしています。(順不同)
                    //
                    // 図.
                    //      ※内容はサンプルです。実際と異なる場合があります。
                    //
                    //      setoptionDictionary
                    //      ┌──────┬──────┐
                    //      │Key         │Value       │
                    //      ┝━━━━━━┿━━━━━━┥
                    //      │USI_Ponder  │true        │
                    //      ├──────┼──────┤
                    //      │USI_Hash    │256         │
                    //      └──────┴──────┘
                    //
                    //      goDictionary
                    //      ┌──────┬──────┐
                    //      │Key         │Value       │
                    //      ┝━━━━━━┿━━━━━━┥
                    //      │btime       │599000      │
                    //      ├──────┼──────┤
                    //      │wtime       │600000      │
                    //      ├──────┼──────┤
                    //      │byoyomi     │60000       │
                    //      └──────┴──────┘
                    //
                    //      goMateDictionary
                    //      ┌──────┬──────┐
                    //      │Key         │Value       │
                    //      ┝━━━━━━┿━━━━━━┥
                    //      │mate        │599000      │
                    //      └──────┴──────┘
                    //
                    //      gameoverDictionary
                    //      ┌──────┬──────┐
                    //      │Key         │Value       │
                    //      ┝━━━━━━┿━━━━━━┥
                    //      │gameover    │lose        │
                    //      └──────┴──────┘
                    //
#if DEBUG
                    Logger.Trace("KifuParserA_Impl.LOGGING_BY_ENGINE, ┏━確認━━━━setoptionDictionary ━┓");
                    foreach (KeyValuePair <string, string> pair in playing.SetoptionDictionary)
                    {
                        Logger.Trace($"{pair.Key}={pair.Value}");
                    }
                    Logger.Trace("┗━━━━━━━━━━━━━━━━━━┛");

                    //Dictionary<string, string> goMateProperties = new Dictionary<string, string>();
                    //goMateProperties["mate"] = "";
                    //LarabeLoggerList_Warabe.ENGINE.WriteLineAddMemo("┗━━━━━━━━━━━━━━━━━━┛");
                    //LarabeLoggerList_Warabe.ENGINE.WriteLineAddMemo("┏━確認━━━━goMateDictionary━━━┓");
                    //foreach (KeyValuePair<string, string> pair in this.goMateProperties)
                    //{
                    //    LarabeLoggerList_Warabe.ENGINE.WriteLineAddMemo($"{pair.Key}={pair.Value}");
                    //}
#endif

                    if (isTimeoutShutdown)
                    {
                        //MessageBox.Show("ループ2で矯正終了するんだぜ☆!");
                        goto gt_EndMethod;//全体ループを抜けます。
                    }
                }
            }
            catch (Exception ex)
            {
                // エラーが起こりました。
                //>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

                // どうにもできないので  ログだけ取って無視します。
                Logger.Fatal($"(^ー^)「大外枠でキャッチ」{ex}");
                Playing.Send("bestmove resign");
            }

gt_EndMethod:
            ;
        }
示例#33
0
 internal static ArtisteWS castFromArtiste(EntitiesLayer.Artiste inArtiste)
 {
     return new ArtisteWS(inArtiste.Name, inArtiste.BirthDate, inArtiste.Guid);
 }
示例#34
0
        public static EvenementWS castFromEntitiesEvenements(EntitiesLayer.Evenement e)
        {
            EvenementWS ev;
            if (e is EntitiesLayer.Concert)
            {
                EntitiesLayer.Concert c = (EntitiesLayer.Concert)e;
                ev = new EvenementWS(c.Artistes, c.Description, c.Guid, c.Tarif, c.Titre, c.DispositionParticuliere, c.DureeEnMinutes, c.NombreLoges);
            }
            else
            {
                EntitiesLayer.Exposition ex = (EntitiesLayer.Exposition)e;
                ev = new EvenementWS(ex.NombreOeuvresExposees, ArtisteWS.castFromArtiste(ex.Artistes), ex.Description, ex.Guid, ex.Tarif, ex.Titre);
            }

            return ev;
        }