Subversion Repositories Games.Chess Giants

// window_main.cpp

#include "../common.h"

// global variables used in this module only

static wchar_t folder_path[MAX_PATH];

// prototypes of local functions

static bool Button_IsHovered (guibutton_t *button, int gui_x, int gui_y);

static bool Button_UpdateHoverState (guibutton_t *button, int gui_x, int gui_y);

LRESULT CALLBACK WindowProc_Main (HWND hWnd, unsigned int message, WPARAM wParam, LPARAM lParam)

{

   // this is the main message handler for the program

   static wchar_t fen_string[128];

   static char selectable_parts[14] = "PRNBQK kqbnrp";

   static int prevgui_x = 0;

   static int prevgui_y = 0;

   static bool ctrl_pressed = false;

   static bool rbutton_pushed = false;

   unsigned short wParam_hiword;

   unsigned short wParam_loword;

   int prev_hovered_position[2];

   player_t *current_player;

   player_t *opposite_player;

   player_t *local_player;

   player_t *remote_player;

   ccreply_t *entered_ccreply;

   boardmove_t *current_move;

   float board_x;

   float board_y;

   int gui_x;

   int gui_y;

   int line;

   int column;

   int index_line;

   int index_column;

   int part_index;

   int part_color;

   int part_count;

   int viewer_index;

   RECT rect;

   POINT point;

   // filter out the commonly used message values

   wParam_hiword = HIWORD (wParam);

   wParam_loword = LOWORD (wParam);

   // get current and opposite players and see if we're online

   current_player = Player_GetCurrent ();

   opposite_player = Player_GetOpposite ();

   remote_player = Player_FindByType (PLAYER_INTERNET);

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

   // has the window just been fired up ?

   if (message == WM_CREATE)

   {

      the_scene.gui.is_entering_text = false; // we are NOT entering text yet

      // call the default window message processing function to keep things going

      return (DefWindowProc (hWnd, message, wParam, lParam));

   }

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

   // else is the window being resized ?

   else if ((message == WM_SIZE) || (message == WM_WINDOWPOSCHANGED))

   {

      GetWindowRect (hMainWnd, &rect); // grab the current window size and update the options accordingly

      options.want_maximized = (rect.right - rect.left > GetSystemMetrics (SM_CXMAXIMIZED) * 90 / 100) && (rect.bottom - rect.top > GetSystemMetrics (SM_CYMAXIMIZED) * 80 / 100);

      if (!options.want_maximized)

      {

         options.window_width = max (rect.right - rect.left, 640); // min window width

         options.window_height = max (rect.bottom - rect.top, 480); // min window height (only save them when the window is not maximized)

      }

      return (0); // don't let Windows do the default processing on this message

   }

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

   // else have we clicked on the close button ?

   else if (message == WM_CLOSE)

   {

      if ((the_board.game_state == STATE_PLAYING) && ((the_board.move_count > 1) || (remote_player != NULL)))

         DialogBox_Quit (); // if a game has started OR if we are online against somebody, ask for confirmation

      else

         is_dialogbox_quit_validated = true; // if game hasn't started yet, quit without question

      return (0); // don't let Windows do the default processing on this message

   }

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

   // else is the user closing its session OR the window is being destroyed ?

   else if ((message == WM_QUERYENDSESSION) || (message == WM_ENDSESSION) || (message == WM_DESTROY))

      terminate_everything = true; // suicide (for some reason, PostQuitMessage() is unreliable !?)

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

   // MENU EVENTS //

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

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

   // menu command

   else if (message == WM_COMMAND)

   {

      // ANY menu choice makes the "new game" / "open game" front GUI button disappear

      GUIBUTTON_DISABLE (the_scene.gui.newgamebutton);

      GUIBUTTON_DISABLE (the_scene.gui.opengamebutton);

      // game menu, new game

      if (wParam_loword == MENUID_GAME_NEWGAME)

      {

         if ((the_board.game_state == STATE_PLAYING) && (the_board.move_count > 1))

            DialogBox_Resign (RESIGNTYPE_NEWGAME); // if a game is playing, ask to resign first

         else

            DialogBox_NewGame (); // game not started yet, show the new game dialog box

      }

      // game menu, setup start position

      else if (wParam_loword == MENUID_GAME_SETUPPOSITION)

         Board_EnterSetupPosition (&the_board); // enter setup position mode

      // game menu, load game

      else if (wParam_loword == MENUID_GAME_LOAD)

      {

         if ((the_board.game_state == STATE_PLAYING) && (the_board.move_count > 1))

            DialogBox_Resign (RESIGNTYPE_LOADGAME); // if a game is playing, ask to resign first

         else

            DialogBox_Load (); // fire up the load dialog box

      }

      // game menu, save game

      else if (wParam_loword == MENUID_GAME_SAVE)

      {

         if (save_pathname[0] != 0)

            is_dialogbox_save_validated = true; // if the filename is known, save it directly

         else

            DialogBox_Save (false); // else fire up the save dialog box

      }

      // game menu, save as

      else if (wParam_loword == MENUID_GAME_SAVEAS)

         DialogBox_Save (false); // fire up the save dialog box

      // game menu, save position as

      else if (wParam_loword == MENUID_GAME_SAVEPOSITIONAS)

         DialogBox_SavePosition (); // fire up the save position dialog box

      // game menu, pause

      else if (wParam_loword == MENUID_GAME_PAUSE)

      {

         is_paused ^= true; // toggle game pause state on/off

         CheckMenuItem (GetMenu (hWnd), MENUID_GAME_PAUSE, (is_paused ? MF_CHECKED : MF_UNCHECKED)); // highlight the menu entry as necessary

         the_board.reevaluate = true; // evaluate board again

      }

      // game menu, resign

      else if (wParam_loword == MENUID_GAME_RESIGN)

         DialogBox_Resign (RESIGNTYPE_UNDEFINED); // if a game has started, ask for confirmation

      // game menu, statistics (stats are only available in online mode)

      else if (wParam_loword == MENUID_GAME_STATISTICS)

      {

         local_player = Player_FindByType (PLAYER_HUMAN);

         if (local_player != NULL)

            PlayerCard_FindOrCreate (local_player->name); // display player's own player card

      }

      // game menu, options

      else if (wParam_loword == MENUID_GAME_OPTIONS)

         DialogBox_Options (); // fire up the options dialog box

      // game menu, quit

      else if (wParam_loword == MENUID_GAME_QUIT)

      {

         if ((the_board.game_state == STATE_PLAYING) && ((the_board.move_count > 1) || (remote_player != NULL)))

            DialogBox_Quit (); // if a game has started OR if we are online against somebody, ask for confirmation

         else

            is_dialogbox_quit_validated = true; // if game hasn't started yet, quit without question

      }

      // move menu, cancel last move

      else if (wParam_loword == MENUID_MOVE_CANCELLASTMOVE)

         the_board.players[current_viewer].wants_cancel = true; // remember this player wants to cancel his last move

      // move menu, suggest move

      else if (wParam_loword == MENUID_MOVE_SUGGESTMOVE)

         the_board.players[current_viewer].wants_hint = true; // remember this player wants a hint

      // move menu, comment move

      else if (wParam_loword == MENUID_MOVE_COMMENTMOVE)

         DialogBox_Comment (); // fire up the comment dialog box

      // move menu, go to move

      else if (wParam_loword == MENUID_MOVE_GOTOMOVE)

         DialogBox_GoToMove (); // fire up the go to move dialog box

      // chessboard menu, swap sides

      else if (wParam_loword == MENUID_CHESSBOARD_SWAPSIDES)

         the_board.want_playerswap = true; // remember board sides are to be swapped

      // chessboard menu, rename players

      else if (wParam_loword == MENUID_CHESSBOARD_RENAMESIDES)

         DialogBox_RenameSides(); // fire up the rename sides dialog box

      // chessboard menu, beginning of game

      else if (wParam_loword == MENUID_CHESSBOARD_BEGINNINGOFGAME)

      {

         the_board.viewed_move = 0; // enter view mode and go to the beginning of the game

         Audio_PlaySoundAtCenter (SOUNDTYPE_CLICK); // make a click sound at the center of the board

         the_board.reevaluate = true; // evaluate board again

      }

      // chessboard menu, previous move (only if arrow is enabled)

      else if ((wParam_loword == MENUID_CHESSBOARD_PREVIOUSMOVE) && (the_scene.gui.larrow.state != 0))

      {

         the_board.viewed_move--; // enter view mode and go back one move

         Audio_PlaySoundAtCenter (SOUNDTYPE_CLICK); // make a click sound at the center of the board

         the_board.reevaluate = true; // evaluate board again

      }

      // chessboard menu, next move (only if arrow is enabled)

      else if ((wParam_loword == MENUID_CHESSBOARD_NEXTMOVE) && (the_scene.gui.rarrow.state != 0))

      {

         the_board.viewed_move++; // enter view mode and go forward one move

         Audio_PlaySoundAtCenter (SOUNDTYPE_CLICK); // make a click sound at the center of the board

         the_board.reevaluate = true; // evaluate board again

      }

      // chessboard menu, current state of game

      else if (wParam_loword == MENUID_CHESSBOARD_CURRENTSTATEOFGAME)

      {

         the_board.viewed_move = the_board.move_count - 1; // enter view mode and go to the current state of the game

         Audio_PlaySoundAtCenter (SOUNDTYPE_CLICK); // make a click sound at the center of the board

         the_board.reevaluate = true; // evaluate board again

      }

      // chessboard menu, top view

      else if (wParam_loword == MENUID_CHESSBOARD_TOPVIEW)

      {

         // cycle through both players and change their view angles EXCEPT the opponent if he's human

         for (viewer_index = 0; viewer_index < 2; viewer_index++)

            if ((the_board.players[viewer_index].type == PLAYER_COMPUTER)

                || (the_board.players[viewer_index].type == PLAYER_INTERNET)

                || (viewer_index == current_viewer))

            {

               the_board.players[viewer_index].view_pitch = 89.99f;

               the_board.players[viewer_index].view_yaw = (current_viewer == COLOR_BLACK ? 90.0f : -90.0f);

               the_board.players[viewer_index].view_distance = 58.0f;

            }

      }

      // chessboard menu, default view

      else if (wParam_loword == MENUID_CHESSBOARD_DEFAULTVIEW)

      {

         // cycle through both players and change their view angles EXCEPT the opponent if he's human

         for (viewer_index = 0; viewer_index < 2; viewer_index++)

            if ((the_board.players[viewer_index].type == PLAYER_COMPUTER)

                || (the_board.players[viewer_index].type == PLAYER_INTERNET)

                || (viewer_index == current_viewer))

            {

               the_board.players[viewer_index].view_pitch = 55.0f;

               the_board.players[viewer_index].view_yaw = (current_viewer == COLOR_BLACK ? 90.0f : -90.0f);

               the_board.players[viewer_index].view_distance = 70.0f;

            }

      }

      // chessboard menu, reset view

      else if (wParam_loword == MENUID_CHESSBOARD_RESETVIEW)

      {

         // cycle through both players and change their view angles EXCEPT the opponent if he's human

         for (viewer_index = 0; viewer_index < 2; viewer_index++)

            if ((the_board.players[viewer_index].type == PLAYER_COMPUTER)

                || (the_board.players[viewer_index].type == PLAYER_INTERNET)

                || (viewer_index == current_viewer))

            {

               the_board.players[viewer_index].view_pitch = the_board.players[current_viewer].custom_pitch;

               the_board.players[viewer_index].view_yaw = the_board.players[current_viewer].custom_yaw;

               the_board.players[viewer_index].view_distance = the_board.players[current_viewer].custom_distance;

            }

      }

      // chessboard menu, zoom in

      else if (wParam_loword == MENUID_CHESSBOARD_ZOOMIN)

      {

         // scroll up & save this as the new custom distance

         the_board.players[current_viewer].view_distance = max (48.0f, the_board.players[current_viewer].view_distance - 2.0f);

         the_board.players[current_viewer].custom_distance = the_board.players[current_viewer].view_distance;

         the_scene.update = true; // update the 3D scene

      }

      // chessboard menu, zoom out

      else if (wParam_loword == MENUID_CHESSBOARD_ZOOMOUT)

      {

         // scroll down & save this as the new custom distance

         the_board.players[current_viewer].view_distance = min (100.0f, the_board.players[current_viewer].view_distance + 2.0f);

         the_board.players[current_viewer].custom_distance = the_board.players[current_viewer].view_distance;

         the_scene.update = true; // update the 3D scene

      }

      // chessboard menu, change appearance

      else if (wParam_loword == MENUID_CHESSBOARD_CHANGEAPPEARANCE)

         DialogBox_ChangeAppearance ();

      // chessboard menu, display windows desktop

      else if (wParam_loword == MENUID_CHESSBOARD_DISPLAYWINDOWSDESKTOP)

         ShowWindow (hWnd, SW_MINIMIZE);

      // internet menu, show online players

      else if (wParam_loword == MENUID_INTERNET_SHOWONLINEPLAYERS)

         Window_Opponents ();

      // internet menu, show sought games

      else if (wParam_loword == MENUID_INTERNET_SHOWSOUGHTGAMES)

         Window_Sought ();

      // internet menu, seek game

      else if (wParam_loword == MENUID_INTERNET_SEEKGAME)

         DialogBox_SendSeek ();

      // internet menu, chatter channels

      else if (wParam_loword == MENUID_INTERNET_CHATTERCHANNELS)

         Window_ChatterChannels ();

      // internet menu, enter chat text

      else if (wParam_loword == MENUID_INTERNET_ENTERCHATTEXT)

         PostMessage (hWnd, WM_CHAR, L' ', 0); // emulate a space bar hit

      // internet menu, display player card

      else if (wParam_loword == MENUID_INTERNET_DISPLAYPLAYERCARD)

         DialogBox_PlayerInfoName ();

      // internet menu, display your card

      else if (wParam_loword == MENUID_INTERNET_DISPLAYYOURCARD)

      {

         local_player = Player_FindByType (PLAYER_HUMAN);

         if (local_player != NULL)

            PlayerCard_FindOrCreate (local_player->name); // display player's own player card

      }

      // internet menu, MOTD

      else if (wParam_loword == MENUID_INTERNET_MOTD)

         Window_MOTD ();

      // help menu, help

      else if (wParam_loword == MENUID_HELP_HELP)

      {

         swprintf_s (folder_path, WCHAR_SIZEOF (folder_path), L"%s\\Chess Giants (%s).html", app_path, languages[language_id].name);

         if (_waccess (folder_path, 0) != 0)

            swprintf_s (folder_path, WCHAR_SIZEOF (folder_path), L"%s\\Chess Giants (English).html", app_path);

         ShellExecute (NULL, L"open", folder_path, NULL, NULL, SW_MAXIMIZE); // fire up the help file

      }

      // help menu, get chess games

      else if (wParam_loword == MENUID_HELP_GETCHESSGAMES)

         ShellExecute (NULL, L"open", L"http://www.chessgames.com", NULL, NULL, SW_MAXIMIZE); // fire up the browser

      // help menu, add/modify visual themes

      else if (wParam_loword == MENUID_HELP_ADDMODIFYVISUALTHEMES)

      {

         swprintf_s (folder_path, WCHAR_SIZEOF (folder_path), L"%s\\themes", app_path);

         ShellExecute (NULL, L"open", folder_path, NULL, NULL, SW_SHOWNORMAL); // fire up Windows Explorer

      }

      // help menu, add/modify engines

      else if (wParam_loword == MENUID_HELP_ADDMODIFYENGINES)

      {

         swprintf_s (folder_path, WCHAR_SIZEOF (folder_path), L"%s\\engines", app_path);

         ShellExecute (NULL, L"open", folder_path, NULL, NULL, SW_SHOWNORMAL); // fire up Windows Explorer

      }

      // help menu, add/modify translations

      else if (wParam_loword == MENUID_HELP_ADDMODIFYTRANSLATIONS)

      {

         swprintf_s (folder_path, WCHAR_SIZEOF (folder_path), L"%s\\data\\languages", app_path);

         ShellExecute (NULL, L"open", folder_path, NULL, NULL, SW_SHOWNORMAL); // fire up Windows Explorer

      }

      // help menu, report a problem to the author

      else if (wParam_loword == MENUID_HELP_REPORTAPROBLEM)

      {

         // send the game engine history to the author and display an error message if failed

         if (MessageBox (hMainWnd, LOCALIZE (L"ReportAProblem"), LOCALIZE (L"ImportantMessage"), MB_ICONQUESTION | MB_YESNOCANCEL | MB_DEFBUTTON3) == IDYES)

            if (Debug_SendLogToAuthor ("user request", true)) // with user description

               MessageBox (hMainWnd, LOCALIZE (L"MessageSent"), PROGRAM_NAME, MB_ICONINFORMATION | MB_OK);

            else

               MessageBox (hMainWnd, LOCALIZE (L"NoInternetConnection"), LOCALIZE (L"FatalError"), MB_ICONWARNING | MB_OK);

      }

      // help menu, about

      else if (wParam_loword == MENUID_HELP_ABOUT)

         DialogBox_About (); // show the About dialog box

      // call the default window message processing function to keep things going

      return (DefWindowProc (hWnd, message, wParam, lParam));

   }

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

   // ctrl key press or release (while not in animation)

   else if ((message == WM_KEYDOWN) && (wParam == VK_CONTROL) && (animation_endtime + 1.0f < current_time))

   {

      ctrl_pressed = true; // remember the ctrl key is pressed

      // call the default window message processing function to keep things going

      return (DefWindowProc (hWnd, message, wParam, lParam));

   }

   else if ((message == WM_KEYUP) && (wParam == VK_CONTROL) && (animation_endtime + 1.0f < current_time))

   {

      ctrl_pressed = false; // remember the ctrl key is released

      rbutton_pushed = false; // remember button is released

      the_scene.update = true; // update the 3D scene

      // call the default window message processing function to keep things going

      return (DefWindowProc (hWnd, message, wParam, lParam));

   }

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

   // MOUSE EVENTS //

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

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

   // left mouse button push

   else if (message == WM_LBUTTONDOWN)

   {

      // are we in animation OR are mouse commands NOT allowed ?

      if ((animation_endtime + 1.0f >= current_time) || (command_ignoretime >= current_time))

         return (DefWindowProc (hWnd, message, wParam, lParam)); // if so, call the default message proc to keep things going

      // are we in board closeup mode OR are we online AND do we NOT have the right to select anything ?

      if (((current_distance == CLOSEUP_VIEW_DISTANCE) && (current_pitch == CLOSEUP_VIEW_PITCH))

          || ((remote_player != NULL) && !remote_player->is_in_game))

         return (DefWindowProc (hWnd, message, wParam, lParam)); // if so, call the default window message processing function to keep things going

      // is the ctrl key pressed (emulates a right click) ?

      if (ctrl_pressed)

      {

         prevgui_x = GET_X_LPARAM (lParam); // remember mouse coordinates

         prevgui_y = GET_Y_LPARAM (lParam);

         // if we click something, stop moving the table immediately

         // cycle through both players and change their view angles EXCEPT the opponent if he's human

         for (viewer_index = 0; viewer_index < 2; viewer_index++)

            if ((the_board.players[viewer_index].type == PLAYER_COMPUTER)

                || (the_board.players[viewer_index].type == PLAYER_INTERNET)

                || (viewer_index == current_viewer))

            {

               the_board.players[viewer_index].view_pitch = current_pitch;

               the_board.players[viewer_index].view_yaw = current_yaw;

            }

         rbutton_pushed = true; // remember button is clicked

      }

      // call the default window message processing function to keep things going

      return (DefWindowProc (hWnd, message, wParam, lParam));

   }

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

   // left mouse button release

   else if (message == WM_LBUTTONUP)

   {

      // are we in animation OR are mouse commands NOT allowed ?

      if ((animation_endtime + 1.0f >= current_time) || (command_ignoretime >= current_time))

         return (DefWindowProc (hWnd, message, wParam, lParam)); // if so, call the default message proc to keep things going

      // is the ctrl key pressed (emulates a right click) ?

      if (ctrl_pressed)

      {

         rbutton_pushed = false; // remember button is released

         the_scene.update = true; // update the 3D scene

         // call the default window message processing function to keep things going

         return (DefWindowProc (hWnd, message, wParam, lParam));

      }

      prevgui_x = GET_X_LPARAM (lParam); // remember mouse coordinates

      prevgui_y = GET_Y_LPARAM (lParam);

      // get mouse coordinates

      gui_x = GET_X_LPARAM (lParam);

      gui_y = GET_Y_LPARAM (lParam);

      // is the "new game" button displayed AND is the mouse hovering it ?

      if ((the_scene.gui.newgamebutton.state != 0) && Button_IsHovered (&the_scene.gui.newgamebutton, gui_x, gui_y))

      {

         GUIBUTTON_DISABLE (the_scene.gui.newgamebutton); // hide the "new game" button

         GUIBUTTON_DISABLE (the_scene.gui.opengamebutton); // hide the "open game" button

         DialogBox_NewGame (); // fire up the "new game" dialog box

      }

      // is the "open game" button displayed AND is the mouse hovering it ?

      if ((the_scene.gui.opengamebutton.state != 0) && Button_IsHovered (&the_scene.gui.opengamebutton, gui_x, gui_y))

      {

         GUIBUTTON_DISABLE (the_scene.gui.newgamebutton); // hide the "new game" button

         GUIBUTTON_DISABLE (the_scene.gui.opengamebutton); // hide the "open game" button

         DialogBox_Load (); // fire up the "open game" dialog box

      }

      // is the chat button displayed AND is the mouse hovering it ?

      if ((the_scene.gui.chatbutton.state != 0) && Button_IsHovered (&the_scene.gui.chatbutton, gui_x, gui_y))

      {

         // find or create the corresponding interlocutor structure and fire it up

         if (remote_player != NULL)

            Interlocutor_FindOrCreate (remote_player->name);

      }

      // is the games button displayed AND is the mouse hovering it ?

      if ((the_scene.gui.gamesbutton.state != 0) && Button_IsHovered (&the_scene.gui.gamesbutton, gui_x, gui_y))

         Window_Sought (); // if so, display the sought games window

      // is the people button displayed AND is the mouse hovering it ?

      if ((the_scene.gui.peoplebutton.state != 0) && Button_IsHovered (&the_scene.gui.peoplebutton, gui_x, gui_y))

         Window_Opponents (); // if so, display the opponents window

      // are we in board closeup mode OR are we online AND do we NOT have the right to select anything ?

      if (((current_distance == CLOSEUP_VIEW_DISTANCE) && (current_pitch == CLOSEUP_VIEW_PITCH))

          || ((remote_player != NULL) && !remote_player->is_in_game))

         return (DefWindowProc (hWnd, message, wParam, lParam)); // if so, call the default window message processing function to keep things going

      // handle game history navigation

      if ((the_scene.gui.llarrow.state != 0) && Button_IsHovered (&the_scene.gui.llarrow, gui_x, gui_y))

         SendMessage (hWnd, WM_COMMAND, MENUID_CHESSBOARD_BEGINNINGOFGAME, NULL); // send a "jump to beginning" event

      else if ((the_scene.gui.larrow.state != 0) && Button_IsHovered (&the_scene.gui.larrow, gui_x, gui_y))

         SendMessage (hWnd, WM_COMMAND, MENUID_CHESSBOARD_PREVIOUSMOVE, NULL); // send a "previous move" event

      else if ((the_scene.gui.rarrow.state != 0) && Button_IsHovered (&the_scene.gui.rarrow, gui_x, gui_y))

         SendMessage (hWnd, WM_COMMAND, MENUID_CHESSBOARD_NEXTMOVE, NULL); // send a "next move" event

      else if ((the_scene.gui.rrarrow.state != 0) && Button_IsHovered (&the_scene.gui.rrarrow, gui_x, gui_y))

         SendMessage (hWnd, WM_COMMAND, MENUID_CHESSBOARD_CURRENTSTATEOFGAME, NULL); // send a "jump to end" event

      // is the parts selection line displayed AND is the mouse anywhere near it ?

      if (the_scene.gui.is_partspick_displayed && Render_IsMouseInBox (gui_x, gui_y, 0.0f, 0.0f, 100.0f, 11.0f))

      {

         // for each selectable part, if the mouse is on it, mark it as selected

         for (part_index = 0; part_index < 13; part_index++)

            if (Render_IsMouseInBox (gui_x, gui_y, part_index * (100.0f / 13.0f), 0, 100.0f / 13.0f, 11.0f))

            {

               the_scene.gui.partspick_selectedpart = selectable_parts[part_index]; // mark it as selected

               Audio_PlaySoundAtCenter (SOUNDTYPE_CLICK); // make a click sound at the center of the board

               break; // no need to search further if one selection was found

            }

      }

      // if we are not allowed to select anything, don't even try

      if (is_paused || (current_player->type != PLAYER_HUMAN) || (the_board.viewed_move != the_board.move_count - 1)

          || ((the_board.game_state != STATE_SETUPPOSITION) && (the_board.game_state != STATE_PLAYING))

          || ((remote_player != NULL) && !remote_player->is_in_game))

      {

         the_scene.update = true; // update the 3D scene

         // call the default window message processing function to keep things going

         return (DefWindowProc (hWnd, message, wParam, lParam));

      }

      // it's a single click. The user clicked on a square.

      // figure out the coordinates on table

      Render_MouseToFloor (gui_x, gui_y, &board_x, &board_y);

      // translate them to board coordinates

      the_board.hovered_position[0] = (int) floor ((20.0f - board_y) / 5.0f);

      the_board.hovered_position[1] = 7 - (int) floor ((20.0f - board_x) / 5.0f);

      highlight_endtime = 0; // stop highlighting anything

      // if it's outside the table, end the job

      if (!IS_VALID_POSITION (the_board.hovered_position))

      {

         the_scene.update = true; // update the 3D scene

         // call the default window message processing function to keep things going

         return (DefWindowProc (hWnd, message, wParam, lParam));

      }

      // we clicked a valid slot on the table

      current_move = &the_board.moves[the_board.viewed_move]; // quick access to current move

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

      // are we in parts placement mode ?

      if (the_board.game_state == STATE_SETUPPOSITION)

      {

         // quick access to line and column

         line = the_board.hovered_position[0];

         column = the_board.hovered_position[1];

         // figure out the color of the part we are placing

         if (the_scene.gui.partspick_selectedpart == tolower (the_scene.gui.partspick_selectedpart))

            part_color = COLOR_BLACK; // black color

         else

            part_color = COLOR_WHITE; // white color

         // in parts placement mode, we must not allow for the creation of a deliring chessboard. A few rules have to be respected.

         // for each color:

         // - no more than 16 parts per color, i.e. the equivalent of 2 rows

         // - no more than 8 pawns

         // - no more than 10 knights, i.e. 2 genuine + 8 promoted

         // - no more than 10 bishops, i.e. 2 genuine + 8 promoted

         // - no more than 10 rooks,   i.e. 2 genuine + 8 promoted

         // - no more than 9 queens,   i.e. 1 genuine + 8 promoted

         // - no more than 1 king

         // - no pawns on the 1st (back) or the 8th (promotion) row

         // and also:

         // - the side not on move must not be in check (TODO)

         // count limits

         part_count = 0; // count the number of pieces of the color we want to place

         for (index_line = 0; index_line < 8; index_line++)

            for (index_column = 0; index_column < 8; index_column++)

               if ((current_move->slots[index_line][index_column].part != PART_NONE) && (current_move->slots[index_line][index_column].color == part_color))

                  part_count++;

         if (part_count >= 16) // if we already have 16 parts of this color...

         {

            Audio_PlaySoundAtSlot (SOUNDTYPE_ILLEGALMOVE, line, column); // play the "illegal move" sound

            Scene_AddCCAnnouncement (&the_scene, NULL, LOCALIZE (L"NoMoreThan16PiecesInTotal"));

            return (DefWindowProc (hWnd, message, wParam, lParam)); // call the default window message proc

         }

         // are we erasing the king ? if so, replace it at his default location

         if ((current_move->slots[line][column].part == PART_KING)

             && (   ((current_move->slots[line][column].color == COLOR_BLACK) && (the_scene.gui.partspick_selectedpart != 'k'))

                 || ((current_move->slots[line][column].color == COLOR_WHITE) && (the_scene.gui.partspick_selectedpart != 'K'))))

         {

            // is it ALREADY the king's default location ? if so, silently prevent the user from doing that

            if ((line == (current_move->slots[line][column].color == COLOR_BLACK ? 7 : 0)) && (column == 4))

               return (DefWindowProc (hWnd, message, wParam, lParam)); // call the default window message proc

            // replace the king at his default location

            Move_SetSlot (current_move, (current_move->slots[line][column].color == COLOR_BLACK ? 7 : 0), 4, current_move->slots[line][column].color, PART_KING);

         }

         // place the selected part on the board

         #define COUNT_PARTS(part_type) part_count = 0; for (index_line = 0; index_line < 8; index_line++) for (index_column = 0; index_column < 8; index_column++) if ((current_move->slots[index_line][index_column].color == part_color) && (current_move->slots[index_line][index_column].part == (part_type))) part_count++;

         if (tolower (the_scene.gui.partspick_selectedpart) == 'p')

         {

            COUNT_PARTS (PART_PAWN); // count the number of pawns of the color we want to place

            if ((part_count >= 8) || (line == 0) || (line == 7)) // if we already have 8 pawns of this color OR if we are attempting to place a pawn on the 1st or 8th line...

            {

               Audio_PlaySoundAtSlot (SOUNDTYPE_ILLEGALMOVE, line, column); // play the "illegal move" sound

               Scene_AddCCAnnouncement (&the_scene, NULL, LOCALIZE (L"NoMoreThan8Pawns"));

               return (DefWindowProc (hWnd, message, wParam, lParam)); // call the default window message proc

            }

            Move_SetSlot (current_move, line, column, part_color, PART_PAWN); // pawn

         }

         else if (tolower (the_scene.gui.partspick_selectedpart) == 'r')

         {

            COUNT_PARTS (PART_ROOK); // count the number of rooks of the color we want to place

            if (part_count >= 10) // if we already have 10 rooks of this color (2 genuine + 8 promoted)...

            {

               Audio_PlaySoundAtSlot (SOUNDTYPE_ILLEGALMOVE, line, column); // play the "illegal move" sound

               Scene_AddCCAnnouncement (&the_scene, NULL, LOCALIZE (L"NoMoreThan10Rooks"));

               return (DefWindowProc (hWnd, message, wParam, lParam)); // call the default window message proc

            }

            Move_SetSlot (current_move, line, column, part_color, PART_ROOK); // rook

         }

         else if (tolower (the_scene.gui.partspick_selectedpart) == 'n')

         {

            COUNT_PARTS (PART_KNIGHT); // count the number of bishops of the color we want to place

            if (part_count >= 10) // if we already have 10 knights of this color (2 genuine + 8 promoted)...

            {

               Audio_PlaySoundAtSlot (SOUNDTYPE_ILLEGALMOVE, line, column); // play the "illegal move" sound

               Scene_AddCCAnnouncement (&the_scene, NULL, LOCALIZE (L"NoMoreThan10Knights"));

               return (DefWindowProc (hWnd, message, wParam, lParam)); // call the default window message proc

            }

            Move_SetSlot (current_move, line, column, part_color, PART_KNIGHT); // knight

         }

         else if (tolower (the_scene.gui.partspick_selectedpart) == 'b')

         {

            COUNT_PARTS (PART_BISHOP); // count the number of bishops of the color we want to place

            if (part_count >= 10) // if we already have 10 bishops of this color (2 genuine + 8 promoted)...

            {

               Audio_PlaySoundAtSlot (SOUNDTYPE_ILLEGALMOVE, line, column); // play the "illegal move" sound

               Scene_AddCCAnnouncement (&the_scene, NULL, LOCALIZE (L"NoMoreThan10Bishops"));

               return (DefWindowProc (hWnd, message, wParam, lParam)); // call the default window message proc

            }

            Move_SetSlot (current_move, line, column, part_color, PART_BISHOP); // bishop

         }

         else if (tolower (the_scene.gui.partspick_selectedpart) == 'q')

         {

            COUNT_PARTS (PART_QUEEN); // count the number of queens of the color we want to place

            if (part_count >= 9) // if we already have 9 queens of this color (1 genuine + 8 promoted)...

            {

               Audio_PlaySoundAtSlot (SOUNDTYPE_ILLEGALMOVE, line, column); // play the "illegal move" sound

               Scene_AddCCAnnouncement (&the_scene, NULL, LOCALIZE (L"NoMoreThan9Queens"));

               return (DefWindowProc (hWnd, message, wParam, lParam)); // call the default window message proc

            }

            Move_SetSlot (current_move, line, column, part_color, PART_QUEEN); // queen

         }

         else if (tolower (the_scene.gui.partspick_selectedpart) == 'k')

         {

            // parse the board for other kings of the same color and erase them

            for (index_line = 0; index_line < 8; index_line++)

               for (index_column = 0; index_column < 8; index_column++)

                  if ((current_move->slots[index_line][index_column].color == part_color)

                      && (current_move->slots[index_line][index_column].part == PART_KING))

                     memset (&current_move->slots[index_line][index_column], 0, sizeof (boardslot_t)); // erase this slot

            Move_SetSlot (current_move, line, column, part_color, PART_KING); // king

         }

         else

            Move_SetSlot (current_move, line, column, 0, PART_NONE); // no part

         // figure out which sound to play

         if (the_scene.gui.partspick_selectedpart != ' ')

            Audio_PlaySoundAtSlot (SOUNDTYPE_MOVE, line, column); // play a move sound when placing a part

         the_scene.update = true; // update the 3D scene

         // call the default window message processing function to keep things going

         return (DefWindowProc (hWnd, message, wParam, lParam));

      }

      // end of parts placement mode

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

      // does a selection NOT exist yet ?

      if (!IS_VALID_POSITION (the_board.selected_position))

      {

         // is there a selectable part at this location ?

         if ((current_move->slots[the_board.hovered_position[0]][the_board.hovered_position[1]].part != PART_NONE)