Subversion Repositories Games.Chess Giants

// network.cpp

#include "common.h"

// handy definitions

#define REACH_NEXT_FIELD_ELSE(field,action) \

{ \

   while (*(field) && !iswspace (*(field))) (field)++; if (*(field) == 0) action; \

   while (*(field) && iswspace (*(field))) (field)++; if (*(field) == 0) action; \

}

#define LOCATE_REPLY_END_FROM_START(end,start) \

{ \

   (end) = wcschr ((start), L'\n'); \

   while (((end) != NULL) && ((end)[1] == L'\\')) (end) = wcschr (&(end)[1], L'\n'); /* find the first line feed that is NOT followed by a backslash */ \

   if ((end) != NULL) (end)++; /* skip it */ \

   else (end) = (start) + wcslen (start); \

}

#define ERASE_FROM_TO(beginning,end) \

{ \

   while ((((end) != NULL) && ((beginning) < (end))) || (*(beginning) != 0)) \

      *(beginning) = L' ', (beginning)++; /* replace all the area with spaces */ \

}

#define IS_FIELD_PRESENT(field_var,string) \

   (((field_var) = wcsstr (player->recvbuffer, (string))) != NULL) /* this text is present */

#define IS_FIELD_PRESENT_AT_BEGINNING_OF_LINE(field_var,string) \

   ((((field_var) = wcsstr (player->recvbuffer, (string))) != NULL) /* this text is present... */ \

    && (ReachBeginningOfCurrentLine (player->recvbuffer, (field_var)) == (field_var))) /* ... at the beginning of a line */

// prototypes of local functions

static void ReadNickname (wchar_t *nickname, size_t nickname_size, wchar_t *from_string);

static void ReadGamename (wchar_t *gamename, size_t gamename_size, wchar_t *from_string);

static void ReadSpannedLine (wchar_t *outstring, size_t outstring_size, wchar_t *multiline_string);

void EvaluateServerReply_MOTD (player_t *player)

{

   // this function parses a network reply and evaluates it, deciding what to do

   // is the MOTD already filled ?

   if (server_motd[0] != 0)

      return; // if so, this reply can't be a MOTD so just return

   // read all received text as part of the MOTD

   wcscpy_s (server_motd, WCHAR_SIZEOF (server_motd), player->recvbuffer);

   // do we want the MOTD to be displayed ?

   if (options.network.want_servermessages && options.network.want_motdonconnect)

      Window_MOTD (); // display MOTD window if required

   Player_SendBuffer_Add (player, 1000, L"style 12\n"); // set the style 12 (computer-friendly board display)

   Player_SendBuffer_Add (player, 1000, L"who\n"); // send the players update request

   Player_SendBuffer_Add (player, 1000, L"sought all\n"); // send the sought games update request

   if (options.network.want_publicchat)

      Player_SendBuffer_Add (player, 1000, L"inchannel\n"); // send the chatter channels update request

   return; // finished evaluating the MOTD

}

void EvaluateServerReply_Announcement (player_t *player)

{

   // this function parses a network reply and evaluates it, deciding what to do

   // Announcement format:

   //RECEIVED:[

   //

   //    **ANNOUNCEMENT** from relay: FICS is relaying the 11th Delhi International

   //\   Open Category A 2013 - Round 3, the 24th Villa de Roquetas International 

   //\   Open 2013 - Round 8 and the 18th Bosnjaci International Open 2013 - Round 

   //\   5. To find more about Relay type "tell relay help"

   //]

   static wchar_t announcement_text[1024];

   wchar_t *announcement_start;

   wchar_t *announcement_end;

   wchar_t *field_start;

   // are both of the possible announcement headers NOT present ?

   if (!IS_FIELD_PRESENT (announcement_start, L"\n\n    **ANNOUNCEMENT** from ")

       && !IS_FIELD_PRESENT (announcement_start, L"\n\n    **UNREG ANNOUNCEMENT** from "))

      return; // if so, this reply can't be an announcement notification so just return

   // this reply is indeed an announcement ; find where it ends

   LOCATE_REPLY_END_FROM_START (announcement_end, announcement_start + 2);

   // are we concerned about server messages ?

   if (options.network.want_servermessages)

   {

      field_start = wcsstr (announcement_start, L": "); // reach the first colon+space, that's where the announcement starts

      if (field_start != NULL)

      {

         field_start += 2; // skip colon and space

         ReadSpannedLine (announcement_text, WCHAR_SIZEOF (announcement_text), field_start); // now format the announcement text well

         Scene_AddAnnouncement (&the_scene, announcement_text); // and put it in place

      }

   }

   // now erase the announcement from the recvbuffer, so that it cannot be misinterpreted by further parsing

   ERASE_FROM_TO (announcement_start, announcement_end);

   return; // finished evaluating this announcement

}

void EvaluateServerReply_ChannelMessage (player_t *player)

{

   // this function parses a network reply and evaluates it, deciding what to do

   static wchar_t channelmessage_text[1024];

   wchar_t nickname[32];

   wchar_t channelname[64];

   unsigned long rgbx_color;

   wchar_t *channelmessage_start;

   wchar_t *channelmessage_end;

   wchar_t *field_start;

   wchar_t *field_stop;

   int channel_index;

   int channel_number;

   // is the discriminatives bit for a channel message NOT present ?

   if (!IS_FIELD_PRESENT (field_stop, L"): "))

      return; // if so, this reply can't be a channel message so just return

   // reach beginning of current line

   channelmessage_start = ReachBeginningOfCurrentLine (player->recvbuffer, field_stop);

   // locate the first space in line (i.e. where the message text is supposed to start)

   field_start = wcschr (channelmessage_start, L' ');

   if (field_start != NULL)

      field_start++; // skip it

   // is the first space BEFORE the discirminative bit ?

   if (field_start < field_stop)

      return; // if so, this reply can't be a channel message so just return

   while ((field_stop > player->recvbuffer) && (*field_stop != L'('))

      field_stop--; // parse the string backwards to find the channel index

   if (*field_stop != L'(')

      return; // drop bogus replies

   channel_number = _wtoi (&field_stop[1]); // read channel number

   if (channel_number == 0)

      return; // if what's between the parentheses is not a number, this reply can't be a channel message so just return

   // this reply is indeed a channel message ; find where it ends

   LOCATE_REPLY_END_FROM_START (channelmessage_end, channelmessage_start);

   // are we concerned about channel messages ?

   if (options.network.want_publicchat)

   {

      ReadNickname (nickname, WCHAR_SIZEOF (nickname), channelmessage_start); // get the nickname

      ReadSpannedLine (channelmessage_text, WCHAR_SIZEOF (channelmessage_text), field_start); // get the message

      channel_number = _wtoi (&field_stop[1]); // and read channel number

      for (channel_index = 0; channel_index < chatterchannel_count; channel_index++)

         if (chatterchannels[channel_index].id == channel_number)

         {

            if (chatterchannels[channel_index].theme[0] != 0)

            {

               wcscpy_s (channelname, WCHAR_SIZEOF (channelname), chatterchannels[channel_index].theme);

               rgbx_color = chatterchannels[channel_index].color;

            }

            break; // break as soon as we find the channel's name and copy it if it exists

         }

      if (channelname[0] == 0)

      {

         swprintf_s (channelname, WCHAR_SIZEOF (channelname), L"%s %d", LOCALIZE (L"ChatterChannels_ColumnChannelNumber"), channel_number); // if it hasn't been filled, use the number

         rgbx_color = RGBA_TO_RGBACOLOR (17, 181, 205, 0); // default channel color

      }

      // add CC reply

      Scene_AddCCReply (&the_scene, nickname, channelname, rgbx_color, channelmessage_text);

   }

   // now erase the channel message from the recvbuffer, so that it cannot be misinterpreted by further parsing

   ERASE_FROM_TO (channelmessage_start, channelmessage_end);

   return; // finished evaluating this channel message

}

void EvaluateServerReply_PrivateMessage (player_t *player)

{

   // this function parses a network reply and evaluates it, deciding what to do

   static wchar_t privatemessage_text[16384];

   wchar_t nickname[32];

   wchar_t *privatemessage_start;

   wchar_t *privatemessage_end;

   wchar_t *field_start;

   wchar_t *first_space;

   int player_index;

   // is the private message discriminative bit NOT present ?

   // private messages have " tells you: " just after the first space

   if (!IS_FIELD_PRESENT (field_start, L" tells you: "))

      return; // if so, this reply can't be a private message so just return

   // look up for the last line feed and the first space of the line

   privatemessage_start = ReachBeginningOfCurrentLine (player->recvbuffer, field_start);

   first_space = wcschr (privatemessage_start, L' ');

   // is the first space BEFORE the discirminative bit ?

   if ((first_space != NULL) && (first_space < field_start))

      return; // if so, this reply can't be a channel message so just return

   // this reply is indeed a private message ; find where it ends

   LOCATE_REPLY_END_FROM_START (privatemessage_end, privatemessage_start + 2);

   ReadNickname (nickname, WCHAR_SIZEOF (nickname), privatemessage_start); // get username

   // is it NOT RoboAdmin OR do we care about server messages ?

   if ((_wcsicmp (L"ROBOadmin", nickname) != 0) || options.network.want_servermessages)

   {

      // see if this nickname exists in the list of connected players ; if not, refresh list

      for (player_index = 0; player_index < onlineplayer_count; player_index++)

         if (wcscmp (nickname, onlineplayers[player_index].nickname) == 0)

            break; // break as soon as we find it

      // have we NOT found it ?

      if (player_index == onlineplayer_count)

         Player_SendBuffer_Add (player, 1000, L"who\n"); // if so, request a players list refresh

      field_start += 12; // skip string break and reach the next colon, that's where the PM starts

      ReadSpannedLine (privatemessage_text, WCHAR_SIZEOF (privatemessage_text), field_start); // now format the PM text well

      // find or create our interlocutor structure and append the chat text in it

      Interlocutor_Chat (Interlocutor_FindOrCreate (nickname), nickname, false, privatemessage_text);

   }

   // now erase the private message from the recvbuffer, so that it cannot be misinterpreted by further parsing

   ERASE_FROM_TO (privatemessage_start, privatemessage_end);

   return; // finished evaluating this private message

}

void EvaluateServerReply_Finger (player_t *player)

{

   // this function parses a network reply and evaluates it, deciding what to do

   wchar_t line_buffer[256];

   wchar_t month_str[5];

   wchar_t dayhrminsec[8];

   wchar_t nickname[32];

   gamestylerating_t gs;

   playercard_t *playercard;

   player_t *local_player;

   wchar_t *finger_start;

   wchar_t *finger_end;

   wchar_t *field_start;

   wchar_t *fingerdata_start;

   wchar_t *string_pointer;

   int onlineplayer_index;

   int days;

   int hours;

   int minutes;

   int number;

   // is it a NEGATIVE finger reply ? "'gue$tpm' is not a valid handle."

   if (IS_FIELD_PRESENT (field_start, L"' is not a valid handle."))

   {

      field_start = ReachBeginningOfCurrentLine (player->recvbuffer, field_start); // look up for the last line feed

      if (field_start[0] == L'\'') // first character must be an apostrophe

      {

         ReadNickname (nickname, WCHAR_SIZEOF (nickname), &field_start[1]); // read username

         // test again with the complete finger reply header. Are we SURE it is a finger reply ?

         if (wcscmp (&field_start[1 + wcslen (nickname)], L"' is not a valid handle.") == 0)

         {

            // find or create our player card structure

            playercard = PlayerCard_FindOrCreate (nickname);

            playercard->doesnt_exist = true; // mark it as non-existing

            playercard->update_dialog = true; // and tell the dialog to update itself

            return; // finished evaluating this finger reply

         }

      }

   }

   // is it a NEGATIVE finger reply ? "Ambiguous name guestp:"

   if (IS_FIELD_PRESENT_AT_BEGINNING_OF_LINE (field_start, L"Ambiguous name "))

   {

      ReadNickname (nickname, WCHAR_SIZEOF (nickname), &field_start[15]); // read username

      // find or create our player card structure

      playercard = PlayerCard_FindOrCreate (nickname);

      playercard->doesnt_exist = true; // mark it as non-existing

      playercard->update_dialog = true; // and tell the dialog to update itself

      return; // finished evaluating this finger reply

   }

   // is it a NEGATIVE finger reply ? "There is no player matching the name guestpm."

   if (IS_FIELD_PRESENT_AT_BEGINNING_OF_LINE (field_start, L"There is no player matching the name "))

   {

      ReadNickname (nickname, WCHAR_SIZEOF (nickname), &field_start[37]); // read username

      // find or create our player card structure

      playercard = PlayerCard_FindOrCreate (nickname);

      playercard->doesnt_exist = true; // mark it as non-existing

      playercard->update_dialog = true; // and tell the dialog to update itself

      return; // finished evaluating this finger reply

   }

   // is it a POSITIVE finger reply ? "Finger of guestpm:"

   if (IS_FIELD_PRESENT_AT_BEGINNING_OF_LINE (field_start, L"Finger of "))

   {

      ReadNickname (nickname, WCHAR_SIZEOF (nickname), &field_start[10]); // get username

      // find or create our player card structure

      playercard = PlayerCard_FindOrCreate (nickname);

      playercard->got_reply = true; // remember it has actual data

      // when we have it, update username

      wcscpy_s (playercard->nickname, WCHAR_SIZEOF (playercard->nickname), nickname);

      // find local player and see whether this player card is ours

      local_player = Player_FindByType (PLAYER_HUMAN);

      if ((local_player != NULL) && (_wcsicmp (nickname, local_player->name) == 0))

         playercard->is_own = true; // remember this player card is ours

      ///////////////////////////////////////////////////////////////////////

      // Finger: parse the connection data (On for: n days n hours n minutes)

      // reach the next double line-break, that's where connection data starts

      fingerdata_start = wcsstr (field_start, L"\n\n");

      if (fingerdata_start == NULL)

         return; // nothing in finger reply ; reply evaluated

      fingerdata_start += 2; // skip them

      wcsgets (line_buffer, WCHAR_SIZEOF (line_buffer), fingerdata_start); // copy that line into a buffer for easy parsing

      // is the player currently online ?

      if (wcsncmp (line_buffer, L"On for: ", 8) == 0)

      {

         field_start = &line_buffer[8]; // skip the "On for: " text

         // according to the data presentation, read and convert in the right form

         if (swscanf_s (field_start, L"%d %*s %d %*s %d %*s Idle: %d %s", &days, &hours, &minutes, &number, dayhrminsec, WCHAR_SIZEOF (dayhrminsec)) == 5)

         {

            playercard->minutes_online = (days * 60 * 24) + (hours * 60) + minutes; // days, hours, minutes

            playercard->seconds_idle = number * (dayhrminsec[0] == L'd' ? 60 * 60 * 24 : (dayhrminsec[0] == L'h' ? 60 * 60 : (dayhrminsec[0] == L'm' ? 60 : 1)));

         }

         else if (swscanf_s (field_start, L"%d %*s %d %*s Idle: %d %s", &hours, &minutes, &number, dayhrminsec, WCHAR_SIZEOF (dayhrminsec)) == 4)

         {

            playercard->minutes_online = (hours * 60) + minutes; // hours, minutes

            playercard->seconds_idle = number * (dayhrminsec[0] == L'd' ? 60 * 60 * 24 : (dayhrminsec[0] == L'h' ? 60 * 60 : (dayhrminsec[0] == L'm' ? 60 : 1)));

         }

         else if (swscanf_s (field_start, L"%*d secs Idle: %d %s", &number, dayhrminsec, WCHAR_SIZEOF (dayhrminsec)) == 2)

         {

            playercard->minutes_online = 1; // less than one minute, round to 1

            playercard->seconds_idle = number * (dayhrminsec[0] == L'd' ? 60 * 60 * 24 : (dayhrminsec[0] == L'h' ? 60 * 60 : (dayhrminsec[0] == L'm' ? 60 : 1)));

         }

         else if (swscanf_s (field_start, L"%d %*s Idle: %d %s", &minutes, &number, dayhrminsec, WCHAR_SIZEOF (dayhrminsec)) == 3)

         {

            playercard->minutes_online = minutes; // just minutes

            playercard->seconds_idle = number * (dayhrminsec[0] == L'd' ? 60 * 60 * 24 : (dayhrminsec[0] == L'h' ? 60 * 60 : (dayhrminsec[0] == L'm' ? 60 : 1)));

         }

         playercard->update_dialog = true; // remember to update dialog

      }

      // else has player already disconnected ?

      else if (wcsncmp (line_buffer, L"Last disconnected: ", 19) == 0)

      {

         field_start = &line_buffer[19]; // skip the "Last disconnected: " text

         // read and convert the data in the right form

         if (swscanf_s (field_start, L"%*s %s %d, %*d:%*d %*s %d", month_str, WCHAR_SIZEOF (month_str), &playercard->disconnection_day, &playercard->disconnection_year) == 3)

            playercard->disconnection_month = MonthStringToNumber (month_str); // convert month from string to number

         playercard->update_dialog = true; // remember to update dialog

      }

      // else player has never connected

      else

      {

         playercard->disconnection_day = 0; // 0 everywhere means the player has never connected

         playercard->disconnection_month = 0;

         playercard->disconnection_year = 0;

         playercard->update_dialog = true; // remember to update dialog

      }

      ////////////////////////////////////////////////////////////

      // Finger: parse the status data (playing game N:aaa vs bbb)

      // see if this player is currently playing a game

      field_start = wcsstr (fingerdata_start, L"\n(playing game ");

      if (field_start != NULL)

      {

         field_start += 15; // skip the "\n(playing game " substring

         // update player activity in opponents list

         for (onlineplayer_index = 0; onlineplayer_index < onlineplayer_count; onlineplayer_index++)

            if (wcscmp (onlineplayers[onlineplayer_index].nickname, playercard->nickname) == 0)

            {

               // if this player is NOT involved in a tournament...

               if (onlineplayers[onlineplayer_index].handlestatus != HANDLESTATUS_INTOURNAMENT)

               {

                  if (playercard->seconds_idle < 5 * 60)

                     onlineplayers[onlineplayer_index].handlestatus = HANDLESTATUS_INGAME; // update status (playing)

                  else

                     onlineplayers[onlineplayer_index].handlestatus = HANDLESTATUS_INACTIVEORBUSY; // update status (idle)

               }

               break; // stop searching as soon as player is found

            }

         // scan the game number and name

         swscanf_s (field_start, L"%d: %[^)]", &playercard->game_played, playercard->game_name, WCHAR_SIZEOF (playercard->game_name));

         playercard->update_dialog = true; // remember to update dialog

      }

      // see if this player is currently playing a game

      field_start = wcsstr (fingerdata_start, L"\n(examining game ");

      if (field_start != NULL)

      {

         field_start += 17; // skip the "\n(examining game " substring

         // update player activity in opponents list

         for (onlineplayer_index = 0; onlineplayer_index < onlineplayer_count; onlineplayer_index++)

            if (wcscmp (onlineplayers[onlineplayer_index].nickname, playercard->nickname) == 0)

            {

               // if this player is NOT involved in a tournament...

               if (onlineplayers[onlineplayer_index].handlestatus != HANDLESTATUS_INTOURNAMENT)

               {

                  if (playercards->seconds_idle < 5 * 60)

                     onlineplayers[onlineplayer_index].handlestatus = HANDLESTATUS_EXAMININGAGAME; // update status (studying)

                  else

                     onlineplayers[onlineplayer_index].handlestatus = HANDLESTATUS_INACTIVEORBUSY; // update status (idle)

               }

               break; // stop searching as soon as player is found

            }

         // scan the game number and name

         swscanf_s (field_start, L"%d: %[^)]", &playercard->game_played, playercard->game_name, WCHAR_SIZEOF (playercard->game_name));

         playercard->update_dialog = true; // remember to update dialog

      }

      //////////////////////////////////////////

      // Finger: parse the game statistics array

      // see if this player has game statistics, find it and jump to the first line

      field_start = wcsstr (fingerdata_start, L"          rating     RD      win    loss    draw   total   best\n");

      if (field_start != NULL)

      {

         field_start += 64; // skip the rating table headers and its carriage return

         // game statistics start here. Read line per line...

         string_pointer = field_start; // start at the beginning of the line

         while ((string_pointer = wcsgets (line_buffer, WCHAR_SIZEOF (line_buffer), string_pointer)) != NULL)

         {

            if (line_buffer[0] == 0)

               continue; // skip empty lines

            memset (&gs, 0, sizeof (gs)); // reset all statistics we're about to read

            // does it look like a valid game statistics line ?

            if ((swscanf_s (line_buffer, L"%s %d %f %d %d %d %d", gs.name, WCHAR_SIZEOF (gs.name), &gs.rating, &gs.rd, &gs.win_count, &gs.loss_count, &gs.draw_count, &gs.total_matches) == 7)

                || (swscanf_s (line_buffer, L"%s ---- %f %d %d %d %d", gs.name, WCHAR_SIZEOF (gs.name), &gs.rd, &gs.win_count, &gs.loss_count, &gs.draw_count, &gs.total_matches) == 6))

            {

               // reallocate space to hold one game style rating more in this player card

               playercard->gamestyleratings = (gamestylerating_t *) SAFE_realloc (playercard->gamestyleratings, playercard->gamestylerating_count, playercard->gamestylerating_count + 1, sizeof (gamestylerating_t), false);

               memcpy (&playercard->gamestyleratings[playercard->gamestylerating_count], &gs, sizeof (gamestylerating_t)); // copy data

               playercard->gamestylerating_count++; // we know now one game style rating more for this player card

            }

         }

         playercard->update_dialog = true; // remember to update dialog

      }

      //////////////////////////////////////

      // Finger: parse the personal messages

      // see if this player has personal data, find it and jump to the first line

      field_start = wcsstr (fingerdata_start, L"\n\n 1:");

      if (field_start != NULL)

      {

         field_start += 2; // skip the two carriage returns

         finger_start = field_start;

         // personal data starts here. Read line per line...

         string_pointer = field_start; // start at the beginning of the line

         while ((string_pointer = wcsgets (line_buffer, WCHAR_SIZEOF (line_buffer), string_pointer)) != NULL)

         {

            if (line_buffer[0] == 0)

               continue; // skip empty lines

            // does it look like a valid personal finger data line ?

            if ((wcslen (line_buffer) > 4) && (wcsncmp (&line_buffer[2], L": ", 2) == 0))

               PlayerCard_AppendPersonalData (playercard, &line_buffer[4]); // if so, append it to player's personal data

            else if (wcsncmp (line_buffer, L"\\   ", 3) == 0)

            {

               if (playercard->fingertext_length > 1)

               {

                  playercard->fingertext[playercard->fingertext_length - 1] = 0; // chop off the last carriage return in finger text

                  playercard->fingertext_length--; // UGLY: now size no longer reflects allocated space

               }

               PlayerCard_AppendPersonalData (playercard, &line_buffer[3]); // ...and append it to player's personal data

            }

         }

         // now erase that text from the recvbuffer, so that it cannot be misinterpreted by further parsing

         LOCATE_REPLY_END_FROM_START (finger_end, finger_start);

         ERASE_FROM_TO (finger_start, finger_end);

         playercard->update_dialog = true; // remember to update dialog

      }

      return; // finished evaluating this finger reply

   }

   return; // this was not a reply we could be concerned about

}

void EvaluateServerReply_Seek (player_t *player)

{

   // this function parses a network reply and evaluates it, deciding what to do

   wchar_t *field_start;

   // are the two bits of the seek notification sentence not present ?

   if (!IS_FIELD_PRESENT (field_start, L") seeking ") || !IS_FIELD_PRESENT (field_start, L"\" to respond)"))

      return; // if so, this reply can't be a seek notification so just return

   // only refresh the sought games list if we're displaying it

   if (IsWindow (hSoughtWnd) && (lastsought_time + 5.0f < current_time))

      Player_SendBuffer_Add (player, 1000, L"sought all\n"); // send the sought games update request

   return; // finished evaluating this seek notification

}

void EvaluateServerReply_Challenge (player_t *player)

{

   // this function parses a network reply and evaluates it, deciding what to do

   challenge_t chal;

   wchar_t *field_start;

   // is the challenge line header NOT present ?

   if (!IS_FIELD_PRESENT_AT_BEGINNING_OF_LINE (field_start, L"Challenge: "))

      return; // if so, this reply can't be a challenge notification so just return

   // challenges can appear as

   // Challenge: IOEO (1370) pmbaty (----) unrated blitz 2 12.

   // Challenge: IOEO (1370) [black] pmbaty (----) unrated blitz 2 12.

   field_start += 11; // skip the "Challenge: " substring

   ReadNickname (chal.challenger, WCHAR_SIZEOF (chal.challenger), field_start); // read challenger nickname

   REACH_NEXT_FIELD_ELSE (field_start, return);

   if (*field_start == L'(')

      field_start++; // skip the leading parenthesis

   if ((*field_start != L'-') && (*field_start != L'+'))

      chal.challenger_level = _wtoi (field_start); // read player rating

   else

      chal.challenger_level = 0;

   REACH_NEXT_FIELD_ELSE (field_start, return);

   if (_wcsnicmp (field_start, L"[black]", 7) == 0)

   {

      chal.color = COLOR_BLACK; // opponent wants to play black

      REACH_NEXT_FIELD_ELSE (field_start, return);

   }

   else if (_wcsnicmp (field_start, L"[white]", 7) == 0)

   {

      chal.color = COLOR_WHITE; // opponent wants to play white

      REACH_NEXT_FIELD_ELSE (field_start, return);

   }

   else

      chal.color = COLOR_UNSPECIFIED; // opponent has no preference over which color he wants to play

   REACH_NEXT_FIELD_ELSE (field_start, return); // skip our name

   REACH_NEXT_FIELD_ELSE (field_start, return); // skip our rating   

   chal.is_rated = (*field_start == L'r' ? true : false); // read whether it is rated or not

   REACH_NEXT_FIELD_ELSE (field_start, return);

   ReadGamename (chal.game_type, WCHAR_SIZEOF (chal.game_type), field_start); // read game type

   REACH_NEXT_FIELD_ELSE (field_start, return);

   chal.initial_time = (float) _wtoi (field_start); // read initial time

   REACH_NEXT_FIELD_ELSE (field_start, return);

   chal.increment = (float) _wtoi (field_start); // read increment

   // is this variant unsupported ?

   if ((_wcsicmp (chal.game_type, L"Untimed") != 0) && (_wcsicmp (chal.game_type, L"Standard") != 0)

       && (_wcsicmp (chal.game_type, L"Blitz") != 0) && (_wcsicmp (chal.game_type, L"Lightning") != 0))

      Player_SendBuffer_Add (player, 1000, L"decline %s\n", chal.challenger); // automatically decline all unsupported games

   else

   {

      // supported variant. Display a message box for the user to choose whether to accept or decline.

      // request a player list update before displaying the dialog box

      if (lastonlineplayers_time + 5.0f < current_time)

         Player_SendBuffer_Add (player, 1000, L"who\n");

      // print a notification in this player's chat window

      Interlocutor_Notify (Interlocutor_FindOrCreate (chal.challenger), LOCALIZE (L"Chat_InvitationReceived"), chal.challenger);

      // find or create our challenge structure and update its data

      Challenge_UpdateData (Challenge_FindOrCreate (chal.challenger), &chal);

   }

   return; // finished evaluating this challenge notification

}

void EvaluateServerReply_ChallengeAccepted (player_t *player)

{

   // this function parses a network reply and evaluates it, deciding what to do

   wchar_t nickname[32];

   wchar_t *line_start;

   wchar_t *field_start;

   interlocutor_t *interlocutor;

   int player_index;

   // is the challenge accepted notification discriminative bit NOT present ?

   if (!IS_FIELD_PRESENT (field_start, L" accepts the match offer."))

      return; // if so, this reply can't be a challenge reply notification so just return

   line_start = ReachBeginningOfCurrentLine (player->recvbuffer, field_start); // look up for the last line feed

   ReadNickname (nickname, WCHAR_SIZEOF (nickname), line_start); // get username

   // see if this nickname exists in the list of connected players ; if not, refresh list

   for (player_index = 0; player_index < onlineplayer_count; player_index++)

      if (wcscmp (nickname, onlineplayers[player_index].nickname) == 0)

         break; // break as soon as we find it

   // have we NOT found it ?

   if (player_index == onlineplayer_count)

      Player_SendBuffer_Add (player, 1000, L"who\n"); // if so, request a players list refresh

   // send a notification to this player's chat window

   interlocutor = Interlocutor_FindOrCreate (nickname);

   Interlocutor_Notify (interlocutor, LOCALIZE (L"Chat_InvitationAcceptedByOther"), nickname);

   if (IsWindow (interlocutor->hWnd))

      ShowWindow (interlocutor->hWnd, SW_MINIMIZE); // minimize chat window immediately

   return; // finished evaluating this challenge reply notification

}

void EvaluateServerReply_ChallengeDeclined (player_t *player)

{

   // this function parses a network reply and evaluates it, deciding what to do

   wchar_t nickname[32];

   wchar_t *line_start;

   wchar_t *field_start;

   int player_index;

   // is the challenge declined notification discriminative bit NOT present ?

   if (!IS_FIELD_PRESENT (field_start, L" declines the match offer."))

      return; // if so, this reply can't be a challenge reply notification so just return

   line_start = ReachBeginningOfCurrentLine (player->recvbuffer, field_start); // look up for the last line feed

   ReadNickname (nickname, WCHAR_SIZEOF (nickname), line_start); // get username

   // see if this nickname exists in the list of connected players ; if not, refresh list

   for (player_index = 0; player_index < onlineplayer_count; player_index++)

      if (wcscmp (nickname, onlineplayers[player_index].nickname) == 0)

         break; // break as soon as we find it

   // have we NOT found it ?

   if (player_index == onlineplayer_count)

      Player_SendBuffer_Add (player, 1000, L"who\n"); // if so, request a players list refresh

   // send a notification to this player's chat window

   Interlocutor_Notify (Interlocutor_FindOrCreate (nickname), LOCALIZE (L"Chat_InvitationDeclinedByOther"), nickname);

   return; // finished evaluating this challenge reply notification

}

void EvaluateServerReply_Takeback (player_t *player)

{

   // this function parses a network reply and evaluates it, deciding what to do

   wchar_t *field_start;

   wchar_t *field_stop;

   int howmany_halfmoves;

   // is the challenge declined notification discriminative bit NOT present ?

   if (!IS_FIELD_PRESENT (field_start, L" would like to take back ") || !IS_FIELD_PRESENT (field_stop, L" half move(s)"))

      return; // if so, this reply can't be a challenge reply notification so just return

   // read the numbre of half moves the opponent reclaims

   swscanf_s (field_start, L" would like to take back %d ", &howmany_halfmoves);

   // send a notification to the local player's chat window

   Interlocutor_Notify (Interlocutor_FindOrCreate (player->name), LOCALIZE (L"Chat_TakebackRequestReceived"), player->name, howmany_halfmoves);

   DialogBox_Takeback (howmany_halfmoves); // and fire up a modal dialog box to ask confirmation to the local player

   return; // finished evaluating this challenge reply notification

}

void EvaluateServerReply_TakebackDeclinedByOther (player_t *player)

{

   // this function parses a network reply and evaluates it, deciding what to do

   wchar_t *field_start;

   // is the takeback declined notification discriminative bit NOT present ?

   if (!IS_FIELD_PRESENT (field_start, L" declines the takeback request."))

      return; // if so, this reply can't be a takeback reply notification so just return

   // send a notification to the local player's chat window

   Interlocutor_Notify (Interlocutor_FindOrCreate (player->name), LOCALIZE (L"Chat_TakebackRefused"), player->name);

   return; // finished evaluating this challenge reply notification

}

void EvaluateServerReply_TakebackDeclinedByYou (player_t *player)

{

   // this function parses a network reply and evaluates it, deciding what to do

   wchar_t *field_start;

   // is the takeback declined notification discriminative bit NOT present ?

   if (!IS_FIELD_PRESENT_AT_BEGINNING_OF_LINE (field_start, L"You decline the takeback request from "))

      return; // if so, this reply can't be a takeback reply notification so just return

   // send a notification to the local player's chat window

   Interlocutor_Notify (Interlocutor_FindOrCreate (player->name), LOCALIZE (L"Chat_TakebackRefused"), player->name);

   return; // finished evaluating this challenge reply notification

}

void EvaluateServerReply_PlayNotAllowed (player_t *player)

{

   // this function parses a network reply and evaluates it, deciding what to do

   wchar_t *field_start;

   // is the play reply notification discriminative bit NOT present ?

   if (!IS_FIELD_PRESENT_AT_BEGINNING_OF_LINE (field_start, L"Only registered players can play rated games."))

      return; // if so, this reply can't be a play reply notification so just return

   // display a message box for the player to know that his opponent refuses to play

   messagebox.hWndParent = (IsWindow (hSoughtWnd) ? hSoughtWnd : hMainWnd);

   wcscpy_s (messagebox.title, WCHAR_SIZEOF (messagebox.title), LOCALIZE (L"PlayReply_ServerReply"));

   swprintf_s (messagebox.text, WCHAR_SIZEOF (messagebox.text), LOCALIZE (L"PlayReply_OnlyRegisteredCanPlayRated"));

   messagebox.flags = MB_ICONINFORMATION | MB_OK;

   DialogBox_Message (&messagebox); // display a modeless error message box

   return; // finished evaluating this play reply notification

}