WebSVN – Games.Chess Giants – Diff – /chessengine.cpp



bool PlayerEngine_Init (player_t *player)
{
   // this function starts a chess engine as a child process. This process's stdin and
   // stdout are redirected to the handles we give it, so that we may read/write to it.
 
   engineprogram_t *program;
   wchar_t widechar_buffer[256];
   SYSTEM_INFO sysinfo;
   SECURITY_ATTRIBUTES saAttr;
   STARTUPINFO si;
   int try_index;

   hChessEngineStdinWr = NULL;
   hChessEngineStdoutRd = NULL;
   hChessEngineStdoutWr = NULL;
   player->wants_hint = false;
 
   // quick access to engine program
   program = &options.engine.programs[options.engine.selected_program];
 
   // build the chess engine module path and pathname
   swprintf_s (chessenginemodule_path, WCHAR_SIZEOF (chessenginemodule_path), L"%s/engines/%s", app_path, program->folder);
   swprintf_s (chessenginemodule_pathname, WCHAR_SIZEOF (chessenginemodule_pathname), L"%s/engines/%s/%s", app_path, program->folder, program->cmdline);
 
   // prepare the pipes' security attributes
   memset (&saAttr, 0, sizeof (saAttr));
   saAttr.nLength = sizeof (SECURITY_ATTRIBUTES);
   saAttr.bInheritHandle = true; // set the bInheritHandle flag so pipe handles are inherited

   si.dwFlags = STARTF_USESTDHANDLES;
   si.hStdInput = hChessEngineStdinRd;
   si.hStdOutput = hChessEngineStdoutWr;
   si.hStdError = hChessEngineStdoutWr;
   if (!CreateProcess (chessenginemodule_pathname, // module pathname
                       program->cmdline, // command line
                       NULL, NULL,
                       true, // handles are inherited
                       CREATE_NO_WINDOW | DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP,
                       NULL,
                       chessenginemodule_path, // process path

   // has the engine process not spoken yet ?
   if (player->recvbuffer[0] == 0)
   {
      messagebox.hWndParent = hMainWnd;
      wcscpy_s (messagebox.title, WCHAR_SIZEOF (messagebox.title), LOCALIZE (L"ImportantMessage"));
      swprintf_s (messagebox.text, WCHAR_SIZEOF (messagebox.text), LOCALIZE (L"Error_ChessEngineInitializationFailed"), program->folder);
      messagebox.flags = MB_ICONWARNING | MB_OK;
      DialogBox_Message (&messagebox); // display a modeless error message box
 
      PlayerEngine_Shutdown (player); // on error, shutdown the engine
      return (false);

 
   // eventually initialize the debug log file
   Debug_Init (L"Chess engine output.txt");
 
   // build the init file full qualified path name and try to open it
   swprintf_s (chessengineinitfile_pathname, WCHAR_SIZEOF (chessengineinitfile_pathname), L"%s/engines/%s/init.txt", app_path, program->folder);
   _wfopen_s (&fp, chessengineinitfile_pathname, L"r");
 
   // could the init file be opened ?
   if (fp != NULL)
   {

 
      fclose (fp); // finished, close the file
   }
 
   // everything's okay, set engine name as the player's name
   wcscpy_s (player->name, WCHAR_SIZEOF (player->name), program->name);
 
   return (true); // finished
}
 
 

   unsigned long exit_code;
   unsigned long handle_flags;
   int attempt_index;
 
   // send the engine a quit command
   Player_SendBuffer_Add (player, 1000, options.engine.programs[options.engine.selected_program].command_quit);
   Player_SendBuffer_Add (player, 1000, L"\n"); // since the format string was read from the options, don't forget to end it with a carriage return
   PlayerEngine_Send (player);
 
   // close the pipe handles
   if (hChessEngineStdinRd)

 
bool PlayerEngine_Think (player_t *player)
{
   // this function reads and writes any necessary data from and to the chess engine. Returns TRUE if scene needs to be updated.
 
   engineprogram_t *program;
   wchar_t line_buffer[256];
   wchar_t *line_pointer;
   wchar_t *move_string;
   int char_index;
   int length;
   boardmove_t move;
   player_t *current_player;
   player_t *opposite_player;
   bool do_update;
 
   // quick access to chess engine program
   program = &options.engine.programs[options.engine.selected_program];
 
   // don't update the scene until told otherwise
   do_update = false;
 
   // get current and opposite players

      // has the game ended already ?
      if (the_board.game_state > STATE_PLAYING)
         continue; // ignore all that the engine tells us. Game is over already.
 
      // else is it a normal move ?
      else if ((move_string = wcsstr (line_buffer, program->replystring_move)) != NULL)
         move_string += wcslen (program->replystring_move); // go to the parsable data
 
      // else it's any other sort of line
      else
         continue; // skip lines that don't contain any valid move data
 

 
      // is it NOT a hint, are blunders allowed, should we do one now AND can we do one now ?
      if (!is_hint_pending && (options.engine.blunder_chances > 0) && (rand () % 100 < options.engine.blunder_chances)
          && Move_FindRandomMove (&the_board.moves[the_board.move_count - 1], player->color, &move))
      {
         Player_SendBuffer_Add (player, 1000, program->command_force, Move_BuildString (&move)); // send the blunderous move to the engine
         Player_SendBuffer_Add (player, 1000, L"\n"); // since the format string was read from the options, don't forget to end it with a carriage return
         if (_wcsnicmp (program->name, L"Crafty", 6) == 0)
            Player_SendBuffer_Add (player, 1000, L"disp\n");
         Debug_Log (L"===Discarding engine move, forcing a blunderous move (%s) instead===\n", Move_BuildString (&move)); // blunder
      }
 
      // mark the engine's selected and hovered squares

         Debug_Log (L"===Hint received, rebuilding board and telling engine to backup 1 move===\n");
         Debug_Log (L"===setting up board using FEN string===\n");
 
         // instruct it about its allowed search depth BEFORE each table set (this ensures engine will be "ready" to handle the command)
         // then get the current game state in FEN format and feed it to the engine
         Player_SendBuffer_Add (player, 1000, program->command_sd, options.engine.depth);
         Player_SendBuffer_Add (player, 1000, L"\n"); // since the format string was read from the options, don't forget to end it with a carriage return
         Player_SendBuffer_Add (player, 1000, program->command_setboard, the_board.moves[the_board.move_count - 1].fen_string);
         Player_SendBuffer_Add (player, 1000, L"\n"); // since the format string was read from the options, don't forget to end it with a carriage return
 
         if (_wcsnicmp (program->name, L"Crafty", 6) == 0)
            Player_SendBuffer_Add (player, 1000, L"disp\n");
      }
 
      do_update = true; // remember to update the 3D scene
   }

   if (the_board.was_setup)
   {
      Debug_Log (L"===Got board setup notification from interface===\n");
 
      // send a new game command to the chess engine
      Player_SendBuffer_Add (player, 1000, program->command_new);
      Player_SendBuffer_Add (player, 1000, L"\n"); // since the format string was read from the options, don't forget to end it with a carriage return
 
      // just set up the board from its Forsyth-Edwards notation
      Debug_Log (L"===setting up board using FEN string===\n");
 
      // instruct it about its allowed search depth BEFORE each table set (this ensures engine will be "ready" to handle the command)
      // then get the current game state in FEN format and feed it to the engine
      Player_SendBuffer_Add (player, 1000, program->command_sd, options.engine.depth);
      Player_SendBuffer_Add (player, 1000, L"\n"); // since the format string was read from the options, don't forget to end it with a carriage return
      Player_SendBuffer_Add (player, 1000, program->command_setboard, the_board.moves[the_board.move_count - 1].fen_string);
      Player_SendBuffer_Add (player, 1000, L"\n"); // since the format string was read from the options, don't forget to end it with a carriage return
 
      current_obstinacy = 0; // reset current obstinacy
      is_hint_pending = false; // no hint was requested so far
 
      if (_wcsnicmp (program->name, L"Crafty", 6) == 0)
         Player_SendBuffer_Add (player, 1000, L"disp\n");
   }
 
   // have we been notified that players are swapping colors ? (N.B. when this happens in human vs. computer mode, it's always that the human player is *GIVING* his turn)
   if (the_board.want_playerswap)
   {
      Debug_Log (L"===Got player SWAP notification from interface===\n");
      Player_SendBuffer_Add (player, 1000, program->command_go); // tell engine it's now the current player
      Player_SendBuffer_Add (player, 1000, L"\n"); // since the format string was read from the options, don't forget to end it with a carriage return
   }
 
   // have we been notified that the current player just changed ?
   if (the_board.has_playerchanged)

      {
         // is it NOT a board setup AND has at least one move been played (meaning it was just the other's turn before) ?
         if (!the_board.was_setup && (the_board.move_count > 1))
         {
            Debug_Log (L"===Player just played, sending the chosen move to engine===\n");
            if (_wcsnicmp (program->name, L"Crafty", 6) == 0)
               Player_SendBuffer_Add (player, 1000, L"disp\n");
 
            // instruct it about its allowed search depth BEFORE each move (this ensures engine will be "ready" to handle the command)
            // then build the move string, and send the move string to the engine
            Player_SendBuffer_Add (player, 1000, program->command_sd, options.engine.depth);
            Player_SendBuffer_Add (player, 1000, L"\n"); // since the format string was read from the options, don't forget to end it with a carriage return
            Player_SendBuffer_Add (player, 1000, program->command_move, Move_BuildString (&the_board.moves[the_board.move_count - 1]));
            Player_SendBuffer_Add (player, 1000, L"\n"); // end the send buffer with a carriage return
         }
 
         // else game has not started yet, but it's our turn
         else
         {
            Player_SendBuffer_Add (player, 1000, program->command_go); // so let's start the game
            Player_SendBuffer_Add (player, 1000, L"\n"); // since the format string was read from the options, don't forget to end it with a carriage return
         }
      }
   }
 

      // does our opponent want a hint ?
      if (current_player->wants_hint)
      {
         current_player->wants_hint = false; // don't ask twice
         Debug_Log (L"===Hint requested, asking engine for it===\n");
         Player_SendBuffer_Add (player, 1000, program->command_go); // tell the computer to analyze this position
         Player_SendBuffer_Add (player, 1000, L"\n"); // since the format string was read from the options, don't forget to end it with a carriage return
         is_hint_pending = true; // remember a hint is pending
 
         // FIXME: move to scene.cpp
         Scene_SetText (&the_scene.gui.central_text, 50.0f, 40.0f, -1, ALIGN_CENTER, ALIGN_CENTER, ALIGN_CENTER, centermsg_fontindex, RGBA_TO_RGBACOLOR (255, 255, 255, 191),

         // just set up the board from its Forsyth-Edwards notation
         Debug_Log (L"===setting up board using FEN string===\n");
 
         // instruct it about its allowed search depth BEFORE each table set (this ensures engine will be "ready" to handle the command)
         // then get the current game state in FEN format and feed it to the engine
         Player_SendBuffer_Add (player, 1000, program->command_sd, options.engine.depth);
         Player_SendBuffer_Add (player, 1000, L"\n"); // since the format string was read from the options, don't forget to end it with a carriage return
         Player_SendBuffer_Add (player, 1000, program->command_setboard, the_board.moves[the_board.move_count - 1].fen_string);
         Player_SendBuffer_Add (player, 1000, L"\n"); // since the format string was read from the options, don't forget to end it with a carriage return
 
         if (_wcsnicmp (program->name, L"Crafty", 6) == 0)
            Player_SendBuffer_Add (player, 1000, L"disp\n");
 
         do_update = true; // remember to update the 3D scene
      }
   }
Subversion Repositories Games.Chess Giants

Games.Chess Giants/chessengine.cpp – Rev 116 → 119
