Subversion Repositories Games.Chess Giants

Rev

Rev 171 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. // pgnfile.cpp
  2.  
  3. #include "common.h"
  4.  
  5.  
  6. // handy definitions
  7. #define COPY_TIL_LAST_QUOTEMARK(dest,source) \
  8. { \
  9.    mbstowcs_s (&converted_count, (dest), WCHAR_SIZEOF (dest), (source), WCHAR_SIZEOF (dest)); \
  10.    for (char_index = wcslen (dest) - 1; char_index >= 0; char_index--) \
  11.       if ((dest)[char_index] == L'"') \
  12.       { \
  13.          (dest)[char_index] = 0; \
  14.          break; \
  15.       } \
  16. }
  17.  
  18.  
  19. // global variables used in this module only
  20. static char *pgnfile_data = NULL; // mallocated
  21. static size_t pgnfile_size = 0;
  22.  
  23.  
  24. // prototypes of local functions
  25. static void PGNFile_GameList_Init (int entry_count);
  26. static void PGNFile_GameList_Shutdown (void);
  27. static wchar_t *PGNFile_NAGTextFromCode (int nag_code);
  28. static char *sgets (char *destination_line, int max_length, char *source_buffer);
  29.  
  30.  
  31. bool PGNFile_Load (const wchar_t *pgnfile_pathname)
  32. {
  33.    // this function loads a PGN file and builds the game databases of the games described in this file
  34.  
  35.    char line_buffer[256]; // PGN files have 256 chars max per line by design
  36.    char *buffer;
  37.    char *ptr;
  38.    int file_index;
  39.    int char_index;
  40.    int entry_count;
  41.    FILE *fp;
  42.    size_t converted_count; // used by the STRING_TO_CHAR macro
  43.  
  44.    // try to open file for reading in BINARY mode so as NOT to convert end of lines
  45.    _wfopen_s (&fp, pgnfile_pathname, L"rb");
  46.    if (fp == NULL)
  47.       return (false); // on error, cancel
  48.  
  49.    // get file length
  50.    fseek (fp, 0, SEEK_END);
  51.    pgnfile_size = ftell (fp);
  52.    fseek (fp, 0, SEEK_SET);
  53.  
  54.    // mallocate space for it and read it all at once
  55.    pgnfile_data = (char *) SAFE_realloc (pgnfile_data, 0, pgnfile_size, sizeof (char), false);
  56.    fread (pgnfile_data, pgnfile_size, 1, fp);
  57.    fclose (fp); // we no longer need the file, so close it
  58.  
  59.    // now the file is fully loaded in memory
  60.  
  61.    // read line per line and count the number of games
  62.    buffer = pgnfile_data;
  63.    entry_count = 0;
  64.    while ((buffer = sgets (line_buffer, sizeof (line_buffer), buffer)) != NULL)
  65.       if (strncmp (line_buffer, "[Event \"", 8) == 0)
  66.          entry_count++; // we know now one game more
  67.  
  68.    // now prepare the games database for "entry_count" games
  69.    PGNFile_GameList_Init (entry_count);
  70.  
  71.    // read line per line
  72.    buffer = pgnfile_data;
  73.    entry_count = 0;
  74.    file_index = 0;
  75.    while ((buffer = sgets (line_buffer, sizeof (line_buffer), buffer)) != NULL)
  76.    {
  77.       // is it a new game ?
  78.       if (strncmp (line_buffer, "[Event \"", 8) == 0)
  79.       {
  80.          memset (&games[entry_count], 0, sizeof (games[entry_count]));
  81.          COPY_TIL_LAST_QUOTEMARK (games[entry_count].event_str, &line_buffer[8]); // copy event
  82.  
  83.          // assume a default "standard chess" start position unless told otherwise later
  84.          wcscpy_s (games[entry_count].fen_str, WCHAR_SIZEOF (games[entry_count].fen_str), FENSTARTUP_STANDARDCHESS);
  85.  
  86.          games[entry_count].gamedata_start = 0; // reset gamedata so far
  87.          entry_count++; // we know now one game more
  88.       }
  89.  
  90.       // else have we found a game already ?
  91.       else if (entry_count > 0)
  92.       {
  93.          // is it a tag ? (i.e: line BEGINS with a opening bracket and the first closing bracket ENDS it)
  94.          if ((line_buffer[0] == '[') && (ptr = strchr (line_buffer, ']')) && ((ptr[1] == '\r') || (ptr[1] == 0)))
  95.          {
  96.             if (strncmp (&line_buffer[1], "Site \"", 6) == 0)
  97.                COPY_TIL_LAST_QUOTEMARK (games[entry_count - 1].site_str, &line_buffer[7]) // copy site
  98.             else if (strncmp (&line_buffer[1], "Date \"", 6) == 0)
  99.                COPY_TIL_LAST_QUOTEMARK (games[entry_count - 1].date_str, &line_buffer[7]) // copy date
  100.             else if (strncmp (&line_buffer[1], "Round \"", 7) == 0)
  101.                COPY_TIL_LAST_QUOTEMARK (games[entry_count - 1].round_str, &line_buffer[8]) // copy round
  102.             else if (strncmp (&line_buffer[1], "White \"", 7) == 0)
  103.                COPY_TIL_LAST_QUOTEMARK (games[entry_count - 1].white_str, &line_buffer[8]) // copy white
  104.             else if (strncmp (&line_buffer[1], "Black \"", 7) == 0)
  105.                COPY_TIL_LAST_QUOTEMARK (games[entry_count - 1].black_str, &line_buffer[8]) // copy black
  106.             else if (strncmp (&line_buffer[1], "Result \"", 8) == 0)
  107.                COPY_TIL_LAST_QUOTEMARK (games[entry_count - 1].result_str, &line_buffer[9]) // copy results
  108.             else if (strncmp (&line_buffer[1], "ECO \"", 5) == 0)
  109.                COPY_TIL_LAST_QUOTEMARK (games[entry_count - 1].eco_str, &line_buffer[6]) // copy ECO code
  110.             else if (strncmp (&line_buffer[1], "FEN \"", 5) == 0)
  111.                COPY_TIL_LAST_QUOTEMARK (games[entry_count - 1].fen_str, &line_buffer[6]) // copy FEN string
  112.          }
  113.  
  114.          // else is it the beginning of a game ?
  115.          else if (strncmp (line_buffer, "1.", 2) == 0)
  116.             games[entry_count - 1].gamedata_start = file_index; // remember where this game starts
  117.          else if ((ptr = strstr (line_buffer, "} 1.")) != NULL)
  118.             games[entry_count - 1].gamedata_start = (ptr + 2 - pgnfile_data); // remember where this game starts
  119.       }
  120.  
  121.       file_index = buffer - pgnfile_data; // save current file pointer index
  122.    }
  123.  
  124.    return (true); // finished, return TRUE
  125. }
  126.  
  127.  
  128. bool PGNFile_LoadGame (board_t *board, const wchar_t *pgnfile_pathname, pgngame_t *game)
  129. {
  130.    // this function loads and parses a game data in a PGN file. If the selected game is NULL, it means that
  131.    // the user didn't want to chose any game at all, so just free the games list and return a success value.
  132.  
  133.    static wchar_t pgn_comment[65536]; // declared static so as not to reallocate it
  134.  
  135.    boardmove_t new_move;
  136.    int nag_code;
  137.    int length;
  138.    int char_index;
  139.    int fieldstart;
  140.    int fieldstop;
  141.    int program_index;
  142.    int variation_depth;
  143.    int new_gamestate;
  144.    char movenumber_string[8];
  145.  
  146.    // did we chose NO game ?
  147.    if (game == NULL)
  148.    {
  149.       PGNFile_GameList_Shutdown (); // free the games list
  150.       SAFE_free ((void **) &pgnfile_data); // free the file data space
  151.       return (true); // return success as there's nothing to load
  152.    }
  153.  
  154.    // if either of the players is a chess engine, start it
  155.    for (program_index = 0; program_index < options.engine.program_count; program_index++)
  156.    {
  157.       if (wcscmp (game->black_str, options.engine.programs[program_index].friendly_name) == 0)
  158.       {
  159.          options.engine.selected_program = program_index; // update the preferred chess engine (FIXME: we should not)
  160.          Player_Shutdown (&board->players[COLOR_BLACK]);
  161.          Player_Init (&board->players[COLOR_BLACK], COLOR_BLACK, PLAYER_COMPUTER);
  162.       }
  163.       if (wcscmp (game->white_str, options.engine.programs[program_index].friendly_name) == 0)
  164.       {
  165.          options.engine.selected_program = program_index; // update the preferred chess engine (FIXME: we should not)
  166.          Player_Shutdown (&board->players[COLOR_WHITE]);
  167.          Player_Init (&board->players[COLOR_WHITE], COLOR_WHITE, PLAYER_COMPUTER);
  168.       }
  169.    }
  170.  
  171.    // reset the board (but NOT the players, just their view angles)
  172.    Board_Reset (board, game->fen_str);
  173.    animation_endtime = current_time + 2.0f; // HACK: this sorta prevents the "load file" dialog box trailing clicks to be misinterpreted
  174.  
  175.    // while we've not parsed til the end of game...
  176.    char_index = game->gamedata_start;
  177.    new_move.source[0] = -1;
  178.    new_move.source[1] = -1;
  179.    new_move.target[0] = -1;
  180.    new_move.target[1] = -1;
  181.    new_move.promotion_type = 0;
  182.    pgn_comment[0] = 0;
  183.    new_gamestate = STATE_PLAYING; // assume this is an unfinished game until told otherwise
  184.    for (;;)
  185.    {
  186.       // build the move number string
  187.       sprintf_s (movenumber_string, sizeof (movenumber_string), "%d.", 1 + board->move_count / 2);
  188.  
  189.       // is it a space ?
  190.       if (isspace (pgnfile_data[char_index]))
  191.       {
  192.          char_index++; // if so, skip it
  193.          continue; // and proceed to the next data
  194.       }
  195.  
  196.       // else is what we're reading a move number ?
  197.       else if (strncmp (&pgnfile_data[char_index], movenumber_string, strlen (movenumber_string)) == 0)
  198.       {
  199.          char_index += strlen (movenumber_string); // if so, skip it
  200.          continue; // and proceed to the next data
  201.       }
  202.  
  203.       // else is it a dot ?
  204.       else if (pgnfile_data[char_index] == '.')
  205.       {
  206.          char_index++; // if so, skip it
  207.          continue; // and proceed to the next data
  208.       }
  209.  
  210.       // else is it an en passant notification ?
  211.       else if (strncmp (&pgnfile_data[char_index], "e.p.", 4) == 0)
  212.       {
  213.          char_index += 4; // this notification is superfluous, skip it
  214.          continue; // and proceed to the next data
  215.       }
  216.  
  217.       // else is it a comment ?
  218.       else if (pgnfile_data[char_index] == '{')
  219.       {
  220.          fieldstart = char_index + 1; // skip the leading brace
  221.  
  222.          while ((fieldstart < (int) pgnfile_size) && isspace (pgnfile_data[fieldstart]))
  223.             fieldstart++; // skip any leading spaces
  224.  
  225.          // move through all the other characters...
  226.          for (fieldstop = fieldstart; fieldstop < (int) pgnfile_size; fieldstop++)
  227.             if (pgnfile_data[fieldstop] == '}')
  228.                break; // and stop at the first closing brace we find
  229.  
  230.          char_index = fieldstop + 1; // remember where to continue reading (that is, after the closing brace)
  231.  
  232.          while ((fieldstop > 0) && isspace (pgnfile_data[fieldstop]))
  233.             fieldstop--; // chop off any trailing spaces
  234.  
  235.          pgnfile_data[fieldstop] = 0; // break the string at this location
  236.  
  237.          // now copy out the commentary by appending it to the one we know already
  238.          if (pgn_comment[0] != 0)
  239.             wcscat_s (pgn_comment, WCHAR_SIZEOF (pgn_comment), L" ");
  240.          length = wcslen (pgn_comment);
  241.          ConvertToWideChar (&pgn_comment[length], WCHAR_SIZEOF (pgn_comment) - length, &pgnfile_data[fieldstart]);
  242.          ConvertCRLFsToSingleSpaces (pgn_comment); // linearize string
  243.  
  244.          continue; // and proceed to the next data
  245.       }
  246.  
  247.       // else is it a numeric annotation glyph ?
  248.       else if (pgnfile_data[char_index] == '$')
  249.       {
  250.          nag_code = atoi (&pgnfile_data[char_index + 1]); // read it
  251.  
  252.          // now copy out as a comment
  253.          if (pgn_comment[0] != 0)
  254.             wcscat_s (pgn_comment, WCHAR_SIZEOF (pgn_comment), L" ");
  255.          length = wcslen (pgn_comment);
  256.          swprintf_s (&pgn_comment[length], WCHAR_SIZEOF (pgn_comment) - length, L"[NAG: %s]", PGNFile_NAGTextFromCode (nag_code));
  257.  
  258.          while ((char_index < (int) pgnfile_size) && !isspace (pgnfile_data[char_index]))
  259.             char_index++; // figure out where it stops
  260.          while ((char_index < (int) pgnfile_size) && isspace (pgnfile_data[char_index]))
  261.             char_index++; // figure out where the next word starts
  262.  
  263.          continue; // and proceed to the next data
  264.       }
  265.  
  266.       // else is it a variation ? if so, just ignore it (FIXME: better support this)
  267.       else if (pgnfile_data[char_index] == '(')
  268.       {
  269.          variation_depth = 1;
  270.          while ((char_index < (int) pgnfile_size) && (variation_depth != 0))
  271.          {
  272.             char_index++; // move through file data and cope with nested variations
  273.             if      (pgnfile_data[char_index] == '(') variation_depth++;
  274.             else if (pgnfile_data[char_index] == ')') variation_depth--;
  275.          }
  276.          char_index++; // skip the closing parenthese
  277.          while ((char_index < (int) pgnfile_size) && isspace (pgnfile_data[char_index]))
  278.             char_index++; // figure out where the next word starts
  279.  
  280.          continue; // and proceed to the next data
  281.       }
  282.  
  283.       // else is it a game end marker ?
  284.       else if ((strncmp (&pgnfile_data[char_index], "1/2-1/2", 7) == 0)
  285.                || (strncmp (&pgnfile_data[char_index], "1-0", 3) == 0)
  286.                || (strncmp (&pgnfile_data[char_index], "0-1", 3) == 0)
  287.                || (pgnfile_data[char_index] == '*'))
  288.       {
  289.          // if there's a move pending, validate it
  290.          if ((new_move.source[0] != -1) && (new_move.source[1] != -1) && (new_move.target[0] != -1) && (new_move.target[1] != -1))
  291.          {
  292.             Board_AppendMove (board, new_move.source[0], new_move.source[1], new_move.target[0], new_move.target[1], new_move.promotion_type, pgn_comment); // save move
  293.             new_move.part = PART_NONE;
  294.             new_move.source[0] = -1;
  295.             new_move.source[1] = -1;
  296.             new_move.target[0] = -1;
  297.             new_move.target[1] = -1;
  298.             new_move.promotion_type = 0;
  299.             pgn_comment[0] = 0; // reset comment
  300.          }
  301.  
  302.          // has the game been closed ?
  303.          if (strncmp (&pgnfile_data[char_index], "1/2-1/2", 7) == 0)
  304.             new_gamestate = STATE_DRAW_OTHER; // game closed on a draw (FIXME: identify variants)
  305.          else if (strncmp (&pgnfile_data[char_index], "1-0", 7) == 0)
  306.          {
  307.             // see if it's a checkmate
  308.             if (board->moves[board->move_count - 1].is_check && board->moves[board->move_count - 1].is_stalemate)
  309.                new_gamestate = STATE_WHITEWIN_CHECKMATE; // game was won by white on a checkmate (checkmate = check + stalemate)
  310.             else
  311.                new_gamestate = STATE_WHITEWIN_RESIGNORFORFEIT; // game was won by white for another reason
  312.          }
  313.          else if (strncmp (&pgnfile_data[char_index], "0-1", 7) == 0)
  314.          {
  315.             // see if it's a checkmate
  316.             if (board->moves[board->move_count - 1].is_check && board->moves[board->move_count - 1].is_stalemate)
  317.                new_gamestate = STATE_BLACKWIN_CHECKMATE; // game was won by black on a checkmate (checkmate = check + stalemate)
  318.             else
  319.                new_gamestate = STATE_BLACKWIN_RESIGNORFORFEIT; // game was won by black for another reason
  320.          }
  321.  
  322.          board->players[1 - board->moves[board->move_count - 1].color].should_wakeup = true; // wake the player whose turn it is
  323.          break; // we've finished reading the game
  324.       }
  325.  
  326.       // else it must be a move data
  327.       else
  328.       {
  329.          // if there's a move pending, validate it
  330.          if ((new_move.source[0] != -1) && (new_move.source[1] != -1) && (new_move.target[0] != -1) && (new_move.target[1] != -1))
  331.          {
  332.             Board_AppendMove (board, new_move.source[0], new_move.source[1], new_move.target[0], new_move.target[1], new_move.promotion_type, pgn_comment); // save move
  333.             new_move.part = PART_NONE;
  334.             new_move.source[0] = -1;
  335.             new_move.source[1] = -1;
  336.             new_move.target[0] = -1;
  337.             new_move.target[1] = -1;
  338.             new_move.promotion_type = 0;
  339.             pgn_comment[0] = 0; // reset comment
  340.          }
  341.  
  342.          // convert the move string data to wide char
  343.          ConvertToWideChar (new_move.pgntext, WCHAR_SIZEOF (new_move.pgntext), &pgnfile_data[char_index]);
  344.  
  345.          // evaluate the string in Standard Algebraic Notation and find the source, destination, part type and promotion
  346.          if (!Move_SetupFromSAN (&board->moves[board->move_count - 1], &new_move, Board_ColorToMove (board)))
  347.          {
  348.             PGNFile_GameList_Shutdown (); // free the games list
  349.             SAFE_free ((void **) &pgnfile_data); // free the file data space
  350.             return (false); // on error, cancel
  351.          }
  352.  
  353.          // find where it stops
  354.          while ((char_index < (int) pgnfile_size) && !isspace (pgnfile_data[char_index]))
  355.             char_index++; // reach the next space
  356.  
  357.          char_index++; // remember where to continue reading (that is, after the next space)
  358.          continue; // and proceed to the next data
  359.       }
  360.    }
  361.  
  362.    // save the players' names
  363.    wcscpy_s (board->players[COLOR_WHITE].name, WCHAR_SIZEOF (board->players[COLOR_WHITE].name), game->white_str);
  364.    wcscpy_s (board->players[COLOR_BLACK].name, WCHAR_SIZEOF (board->players[COLOR_BLACK].name), game->black_str);
  365.  
  366.    // we loaded the game we want, we no longer need the games array
  367.    PGNFile_GameList_Shutdown ();
  368.  
  369.    // we no longer need the file data space, so free it
  370.    SAFE_free ((void **) &pgnfile_data);
  371.  
  372.    board->game_state = new_gamestate; // save the new game state
  373.    return (true); // game loaded successfully, return TRUE
  374. }
  375.  
  376.  
  377. bool PGNFile_Save (board_t *board, const wchar_t *pgnfile_pathname)
  378. {
  379.    // this function writes a PGN file in the standard, international Chess format
  380.  
  381.    FILE *fp;
  382.    wchar_t machine_name[256];
  383.    unsigned long buffer_size;
  384.    wchar_t result_string[16];
  385.    time_t rawtime;
  386.    struct tm timeinfo;
  387.    boardmove_t *move;
  388.    int move_index;
  389.    int char_index;
  390.    int length;
  391.    int count;
  392.    int consecutive_count;
  393.    bool needs_newline;
  394.  
  395.    // try to open file for writing
  396.    _wfopen_s (&fp, pgnfile_pathname, L"w");
  397.    if (fp == NULL)
  398.       return (false); // on error, cancel
  399.  
  400.    // get the machine name as an ASCII string
  401.    buffer_size = WCHAR_SIZEOF (machine_name);
  402.    GetComputerName (machine_name, &buffer_size);
  403.  
  404.    // get the current date and time
  405.    time (&rawtime);
  406.    localtime_s (&timeinfo, &rawtime);
  407.  
  408.    // build the result string
  409.    if ((board->game_state == STATE_WHITEWIN_CHECKMATE) || (board->game_state == STATE_WHITEWIN_RESIGNORFORFEIT))
  410.       wcscpy_s (result_string, WCHAR_SIZEOF (result_string), L"1-0"); // white won
  411.    else if ((board->game_state == STATE_BLACKWIN_CHECKMATE) || (board->game_state == STATE_BLACKWIN_RESIGNORFORFEIT))
  412.       wcscpy_s (result_string, WCHAR_SIZEOF (result_string), L"0-1"); // black won
  413.    else if ((board->game_state == STATE_DRAW_STALEMATE) || (board->game_state == STATE_DRAW_AGREEMENT) || (board->game_state == STATE_DRAW_OTHER))
  414.       wcscpy_s (result_string, WCHAR_SIZEOF (result_string), L"1/2-1/2"); // game is a draw
  415.    else
  416.       wcscpy_s (result_string, WCHAR_SIZEOF (result_string), L"*"); // game still in progress
  417.  
  418.    // write the mandatory header parts
  419.    fwprintf (fp, L"[Event \"Chess Giants game\"]\n");
  420.    fwprintf (fp, L"[Site \"%s\"]\n", machine_name);
  421.    fwprintf (fp, L"[Date \"%d.%02d.%02d\"]\n", 1900 + timeinfo.tm_year, 1 + timeinfo.tm_mon, timeinfo.tm_mday);
  422.    fwprintf (fp, L"[Round \"1\"]\n");
  423.    fwprintf (fp, L"[White \"%s\"]\n", board->players[COLOR_WHITE].name);
  424.    fwprintf (fp, L"[Black \"%s\"]\n", board->players[COLOR_BLACK].name);
  425.    fwprintf (fp, L"[Result \"%s\"]\n", result_string);
  426.    fwprintf (fp, L"[FEN \"%s\"]\n", board->moves[0].fen_string);
  427.    fwprintf (fp, L"\n");
  428.  
  429.    // now write the game
  430.    consecutive_count = 0;
  431.    for (move_index = 1; move_index < board->move_count; move_index++)
  432.    {
  433.       // every seven move pairs, drop a carriage return
  434.       if (consecutive_count == 14)
  435.       {
  436.          fwprintf (fp, L"\n"); // one blank line
  437.          consecutive_count = 0;
  438.       }
  439.  
  440.       move = &board->moves[move_index]; // quick access to move
  441.  
  442.       // white to move ?
  443.       if (move->color == COLOR_WHITE)
  444.          fwprintf (fp, L"%d.", (move_index + 1) / 2); // if so, display double-move number
  445.  
  446.       // dump move data
  447.       fwprintf (fp, L"%s ", move->pgntext);
  448.       consecutive_count++;
  449.  
  450.       // is there a comment for this move ?
  451.       if ((move->comment != NULL) && (move->comment[0] != 0))
  452.       {
  453.          fwprintf (fp, L"\n{\n"); // dump an open brace
  454.          length = wcslen (move->comment); // get comment length
  455.  
  456.          // for each character in comment text...
  457.          needs_newline = false;
  458.          count = 0;
  459.          for (char_index = 0; char_index < length; char_index++)
  460.          {
  461.             // is it a space and do we need a newline ?
  462.             if (iswspace (move->comment[char_index]) && needs_newline)
  463.             {
  464.                fputwc (L'\n', fp); // dump a newline
  465.                needs_newline = false; // we no longer need a newline
  466.                count = 0; // reset the number of characters written
  467.             }
  468.  
  469.             // else it's a character
  470.             else
  471.             {
  472.                fputwc (move->comment[char_index], fp); // dump it
  473.                count++; // we dumped one character more on this line
  474.                if (count > 80)
  475.                   needs_newline = true; // if we need a newline, remember it
  476.             }
  477.          }
  478.  
  479.          fwprintf (fp, L"\n}\n"); // dump an open brace
  480.          consecutive_count = 0;
  481.       }
  482.  
  483.       // if it's the last move, dump the game results
  484.       if (move_index == board->move_count - 1)
  485.          fwprintf (fp, result_string);
  486.    }
  487.  
  488.    fclose (fp); // finished, close the file
  489.  
  490.    return (true); // file saved successfully, return TRUE
  491. }
  492.  
  493.  
  494. static void PGNFile_GameList_Init (int entry_count)
  495. {
  496.    // helper function to initialize the game lists array pointer and the games count
  497.  
  498.    // allocate space for all the games in a row (it's faster than reallocating)
  499.    games = (pgngame_t *) SAFE_malloc (entry_count, sizeof (pgngame_t), true);
  500.    game_count = entry_count;
  501.  
  502.    return; // finished
  503. }
  504.  
  505.  
  506. static void PGNFile_GameList_Shutdown (void)
  507. {
  508.    // helper function to free the game lists array and reset the games count
  509.  
  510.    SAFE_free ((void **) &games); // free the PGN games array
  511.    game_count = 0;
  512.  
  513.    return; // finished
  514. }
  515.  
  516.  
  517. static wchar_t *PGNFile_NAGTextFromCode (int nag_code)
  518. {
  519.    // helper function that returns the NAG (numeric annotation glyph) text that corresponds to a particular code
  520.  
  521.    typedef struct nag_s
  522.    {
  523.       int code;
  524.       wchar_t *text;
  525.    } nag_t;
  526.    nag_t nag_codes[] =
  527.    {
  528.       { 1, L"good move" },
  529.       { 2, L"poor move or mistake" },
  530.       { 3, L"very good or brilliant move" },
  531.       { 4, L"very poor move or blunder" },
  532.       { 5, L"speculative or interesting move" },
  533.       { 6, L"questionable or dubious move" },
  534.       { 7, L"forced move (all others lose quickly) or only move" },
  535.       { 8, L"singular move (no reasonable alternatives)" },
  536.       { 9, L"worst move" },
  537.       { 10, L"drawish position or even" },
  538.       { 11, L"equal chances, quiet position" },
  539.       { 12, L"equal chances, active position" },
  540.       { 13, L"unclear position" },
  541.       { 14, L"White has a slight advantage" },
  542.       { 15, L"Black has a slight advantage" },
  543.       { 16, L"White has a moderate advantage" },
  544.       { 17, L"Black has a moderate advantage" },
  545.       { 18, L"White has a decisive advantage" },
  546.       { 19, L"Black has a decisive advantage" },
  547.       { 20, L"White has a crushing advantage (Black should resign)" },
  548.       { 21, L"Black has a crushing advantage (White should resign)" },
  549.       { 22, L"White is in zugzwang" },
  550.       { 23, L"Black is in zugzwang" },
  551.       { 24, L"White has a slight space advantage" },
  552.       { 25, L"Black has a slight space advantage" },
  553.       { 26, L"White has a moderate space advantage" },
  554.       { 27, L"Black has a moderate space advantage" },
  555.       { 28, L"White has a decisive space advantage" },
  556.       { 29, L"Black has a decisive space advantage" },
  557.       { 30, L"White has a slight time (development) advantage" },
  558.       { 31, L"Black has a slight time (development) advantage" },
  559.       { 32, L"White has a moderate time (development) advantage" },
  560.       { 33, L"Black has a moderate time (development) advantage" },
  561.       { 34, L"White has a decisive time (development) advantage" },
  562.       { 35, L"Black has a decisive time (development) advantage" },
  563.       { 36, L"White has the initiative" },
  564.       { 37, L"Black has the initiative" },
  565.       { 38, L"White has a lasting initiative" },
  566.       { 39, L"Black has a lasting initiative" },
  567.       { 40, L"White has the attack" },
  568.       { 41, L"Black has the attack" },
  569.       { 42, L"White has insufficient compensation for material deficit" },
  570.       { 43, L"Black has insufficient compensation for material deficit" },
  571.       { 44, L"White has sufficient compensation for material deficit" },
  572.       { 45, L"Black has sufficient compensation for material deficit" },
  573.       { 46, L"White has more than adequate compensation for material deficit" },
  574.       { 47, L"Black has more than adequate compensation for material deficit" },
  575.       { 48, L"White has a slight center control advantage" },
  576.       { 49, L"Black has a slight center control advantage" },
  577.       { 50, L"White has a moderate center control advantage" },
  578.       { 51, L"Black has a moderate center control advantage" },
  579.       { 52, L"White has a decisive center control advantage" },
  580.       { 53, L"Black has a decisive center control advantage" },
  581.       { 54, L"White has a slight kingside control advantage" },
  582.       { 55, L"Black has a slight kingside control advantage" },
  583.       { 56, L"White has a moderate kingside control advantage" },
  584.       { 57, L"Black has a moderate kingside control advantage" },
  585.       { 58, L"White has a decisive kingside control advantage" },
  586.       { 59, L"Black has a decisive kingside control advantage" },
  587.       { 60, L"White has a slight queenside control advantage" },
  588.       { 61, L"Black has a slight queenside control advantage" },
  589.       { 62, L"White has a moderate queenside control advantage" },
  590.       { 63, L"Black has a moderate queenside control advantage" },
  591.       { 64, L"White has a decisive queenside control advantage" },
  592.       { 65, L"Black has a decisive queenside control advantage" },
  593.       { 66, L"White has a vulnerable first rank" },
  594.       { 67, L"Black has a vulnerable first rank" },
  595.       { 68, L"White has a well protected first rank" },
  596.       { 69, L"Black has a well protected first rank" },
  597.       { 70, L"White has a poorly protected king" },
  598.       { 71, L"Black has a poorly protected king" },
  599.       { 72, L"White has a well protected king" },
  600.       { 73, L"Black has a well protected king" },
  601.       { 74, L"White has a poorly placed king" },
  602.       { 75, L"Black has a poorly placed king" },
  603.       { 76, L"White has a well placed king" },
  604.       { 77, L"Black has a well placed king" },
  605.       { 78, L"White has a very weak pawn structure" },
  606.       { 79, L"Black has a very weak pawn structure" },
  607.       { 80, L"White has a moderately weak pawn structure" },
  608.       { 81, L"Black has a moderately weak pawn structure" },
  609.       { 82, L"White has a moderately strong pawn structure" },
  610.       { 83, L"Black has a moderately strong pawn structure" },
  611.       { 84, L"White has a very strong pawn structure" },
  612.       { 85, L"Black has a very strong pawn structure" },
  613.       { 86, L"White has poor knight placement" },
  614.       { 87, L"Black has poor knight placement" },
  615.       { 88, L"White has good knight placement" },
  616.       { 89, L"Black has good knight placement" },
  617.       { 90, L"White has poor bishop placement" },
  618.       { 91, L"Black has poor bishop placement" },
  619.       { 92, L"White has good bishop placement" },
  620.       { 93, L"Black has good bishop placement" },
  621.       { 94, L"White has poor rook placement" },
  622.       { 95, L"Black has poor rook placement" },
  623.       { 96, L"White has good rook placement" },
  624.       { 97, L"Black has good rook placement" },
  625.       { 98, L"White has poor queen placement" },
  626.       { 99, L"Black has poor queen placement" },
  627.       { 100, L"White has good queen placement" },
  628.       { 101, L"Black has good queen placement" },
  629.       { 102, L"White has poor piece coordination" },
  630.       { 103, L"Black has poor piece coordination" },
  631.       { 104, L"White has good piece coordination" },
  632.       { 105, L"Black has good piece coordination" },
  633.       { 106, L"White has played the opening very poorly" },
  634.       { 107, L"Black has played the opening very poorly" },
  635.       { 108, L"White has played the opening poorly" },
  636.       { 109, L"Black has played the opening poorly" },
  637.       { 110, L"White has played the opening well" },
  638.       { 111, L"Black has played the opening well" },
  639.       { 112, L"White has played the opening very well" },
  640.       { 113, L"Black has played the opening very well" },
  641.       { 114, L"White has played the middlegame very poorly" },
  642.       { 115, L"Black has played the middlegame very poorly" },
  643.       { 116, L"White has played the middlegame poorly" },
  644.       { 117, L"Black has played the middlegame poorly" },
  645.       { 118, L"White has played the middlegame well" },
  646.       { 119, L"Black has played the middlegame well" },
  647.       { 120, L"White has played the middlegame very well" },
  648.       { 121, L"Black has played the middlegame very well" },
  649.       { 122, L"White has played the ending very poorly" },
  650.       { 123, L"Black has played the ending very poorly" },
  651.       { 124, L"White has played the ending poorly" },
  652.       { 125, L"Black has played the ending poorly" },
  653.       { 126, L"White has played the ending well" },
  654.       { 127, L"Black has played the ending well" },
  655.       { 128, L"White has played the ending very well" },
  656.       { 129, L"Black has played the ending very well" },
  657.       { 130, L"White has slight counterplay" },
  658.       { 131, L"Black has slight counterplay" },
  659.       { 132, L"White has moderate counterplay" },
  660.       { 133, L"Black has moderate counterplay" },
  661.       { 134, L"White has decisive counterplay" },
  662.       { 135, L"Black has decisive counterplay" },
  663.       { 136, L"White has moderate time control pressure" },
  664.       { 137, L"Black has moderate time control pressure" },
  665.       { 138, L"White has severe time control pressure" },
  666.       { 139, L"Black has severe time control pressure" }
  667.    };
  668.    int nag_index;
  669.  
  670.    // cycle through all known NAGs and return the text that corresponds to the requested code
  671.    for (nag_index = 0; nag_index < sizeof (nag_codes) / sizeof (nag_t); nag_index++)
  672.       if (nag_codes[nag_index].code == nag_code)
  673.          return (nag_codes[nag_index].text); // return the text as soon as we find it
  674.  
  675.    return (L"undocumented code"); // not found, return a placeholder string
  676. }
  677.  
  678.  
  679. static char *sgets (char *destination_line, int max_length, char *source_buffer)
  680. {
  681.    // copy a line from a given string. Kinda like fgets() when you're reading from a string.
  682.    // use it like:
  683.    // while (blah = sgets (dest, sizeof (dest), blah)) != NULL)
  684.  
  685.    char *pointer;
  686.    int char_index;
  687.  
  688.    if (source_buffer[0] == 0)
  689.    {
  690.       destination_line[0] = 0;
  691.       return (NULL); // if EOS return a NULL pointer
  692.    }
  693.  
  694.    pointer = strchr (source_buffer, '\n'); // get to the first carriage return we can find
  695.  
  696.    // found none ?
  697.    if (pointer == NULL)
  698.    {
  699.       // if so, copy the line we found
  700.       for (char_index = 0; char_index < max_length; char_index++)
  701.       {
  702.          destination_line[char_index] = source_buffer[char_index]; // copy the line we found
  703.          if (source_buffer[char_index] == 0)
  704.             break; // don't copy beyond the end of source
  705.       }
  706.  
  707.       if (char_index == max_length)
  708.          destination_line[max_length - 1] = 0; // ensure string is terminated
  709.  
  710.       return (&source_buffer[strlen (source_buffer)]); // and return a pointer to the end of the string
  711.    }
  712.  
  713.    *pointer = 0; // temporarily turn the carriage return to an end of string
  714.  
  715.    for (char_index = 0; char_index < max_length; char_index++)
  716.    {
  717.       destination_line[char_index] = source_buffer[char_index]; // copy the line we found
  718.       if (source_buffer[char_index] == 0)
  719.          break; // don't copy beyond the end of source
  720.    }
  721.  
  722.    destination_line[max_length - 1] = 0; // terminate string
  723.    *pointer = '\n'; // put the carriage return back
  724.  
  725.    return (&pointer[1]); // and return next line's source buffer pointer
  726. }
  727.